fix: fix all leaking promises

chore: add ignore for vs cod plugin + comment annoying log

fix: continue better promise handling

chore: use err.toString() instead of err.message

fix: more better handling of promises

fix: forget to toString the duration

fix: remove deprecation + clean code of logd

fix: fix bad handling of onError and remove useless resolve/reject

chore: better detection of leaking promise with reject

fix: add wrong path case + fix rebase broken code

fix: unify error code in preparePlayer

chore: code simplification for player & player key usage and more

chore: final code review

Author: dprevost-LMI

.gitignore

@@ -62,3 +62,6 @@ buck-out/
 
 # generated
 lib
+
+# Local history vs code plugin
+.history/

android/src/main/java/com/audiowaveform/AudioPlayer.kt

@@ -2,23 +2,24 @@ package com.audiowaveform
 
 import android.net.Uri
 import android.os.CountDownTimer
+import androidx.media3.common.MediaItem
+import androidx.media3.common.PlaybackException
+import androidx.media3.common.Player
+import androidx.media3.exoplayer.ExoPlayer
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.common.JavascriptException
 import com.facebook.react.modules.core.DeviceEventManagerModule
-import androidx.media3.exoplayer.ExoPlayer
-import androidx.media3.common.MediaItem
-import androidx.media3.common.Player
 
 class AudioPlayer(
     context: ReactApplicationContext,
     playerKey: String,
 ) {
     private val appContext = context
     private lateinit var player: ExoPlayer
-    private var playerListener: Player.Listener? = null
+    private lateinit var playerListener: Player.Listener
     private var isPlayerPrepared: Boolean = false
     private var finishMode = FinishMode.Stop
     private val key = playerKey
@@ -49,8 +50,7 @@ class AudioPlayer(
             player.prepare()
             playerListener = object : Player.Listener {
 
-                @Deprecated("Deprecated in Java")
-                override fun onPlayerStateChanged(isReady: Boolean, state: Int) {
+                override fun onPlaybackStateChanged(state: Int) {
                     if (!isPlayerPrepared) {
                         if (state == Player.STATE_READY) {
                             player.volume = (volume ?: 1).toFloat()
@@ -59,6 +59,10 @@ class AudioPlayer(
                             val duration = player.duration
                             promise.resolve(duration.toString())
                         }
+                        else if (state == Player.STATE_IDLE) {
+                            // Fix leaking promise when path is incorrect
+                            promise.reject("preparePlayer-onPlayerStateChanged-error-idle", "Player stayed in idle state, unable to load $path")
+                        }
                     }
                     if (state == Player.STATE_ENDED) {
                         val args: WritableMap = Arguments.createMap()
@@ -87,30 +91,27 @@ class AudioPlayer(
                         }
                     }
                 }
+                override fun onPlayerError(error: PlaybackException) {
+                    promise.reject("preparePlayer-onPlayerError", error.message)
+                }
             }
-            player.addListener(playerListener!!)
+
+            player.addListener(playerListener)
         } else {
-            promise.reject("preparePlayer Error", "path to audio file or unique key can't be null")
+            promise.reject("preparePlayer-error", "path to audio file or unique key can't be null")
         }
     }
 
-    fun seekToPosition(progress: Long?, promise: Promise) {
+    fun seekToPosition(progress: Long?): Boolean {
         if (progress != null) {
             player.seekTo(progress)
-            promise.resolve(true)
-        } else {
-            promise.resolve(false)
+            return true;
         }
+        return false;
     }
 
-    fun getDuration(durationType: DurationType, promise: Promise) {
-        if (durationType == DurationType.Current) {
-            val duration = player.currentPosition
-            promise.resolve(duration.toString())
-        } else {
-            val duration = player.duration
-            promise.resolve(duration.toString())
-        }
+    fun getDuration(durationType: DurationType): Long {
+        return if (durationType == DurationType.Current) player.currentPosition else player.duration
     }
 
     private fun validateAndSetPlaybackSpeed(player: Player, speed: Float?): Boolean {
@@ -124,75 +125,48 @@ class AudioPlayer(
         return true  // Indicate success
     }
 
-    fun start(finishMode: Int?, speed: Float?, promise: Promise) {
-        try {
-            if (finishMode != null && finishMode == 0) {
-                this.finishMode = FinishMode.Loop
-            } else if (finishMode != null && finishMode == 1) {
-                this.finishMode = FinishMode.Pause
-            } else {
-                this.finishMode = FinishMode.Stop
-            }
+    fun start(finishMode: Int, speed: Float): Boolean {
+        this.finishMode = when (finishMode) {
+            0 -> FinishMode.Loop
+            1 -> FinishMode.Pause
+            else -> FinishMode.Stop
+        }
 
-           validateAndSetPlaybackSpeed(player, speed)
+       validateAndSetPlaybackSpeed(player, speed)
 
-            player.playWhenReady = true
-            player.play()
-            promise.resolve(true)
-            startListening(promise)
-        } catch (e: Exception) {
-            promise.reject("Can not start the player", e.toString())
-        }
+        player.playWhenReady = true
+        player.play()
+        startListening()
+        return true
     }
 
-    fun stop(promise: Promise) {
+    fun stop() {
         stopListening()
-        if (playerListener != null) {
-            player.removeListener(playerListener!!)
-        }
+        player.removeListener(playerListener)
         isPlayerPrepared = false
-        player.stop()
+        if(player.isPlaying) player.stop()
         player.release()
-        promise.resolve(true)
     }
 
-    fun pause(promise: Promise) {
-        try {
-            stopListening()
-            player.pause()
-            promise.resolve(true)
-        } catch (e: Exception) {
-            promise.reject("Failed to pause the player", e.toString())
-        }
-
+    fun pause(): Boolean {
+        stopListening()
+        player.pause()
+        return true
     }
 
-    fun setVolume(volume: Float?, promise: Promise) {
+    fun setVolume(volume: Float): Boolean {
         try {
-            if (volume != null) {
-                player.volume = volume
-                promise.resolve(true)
-            } else {
-                promise.resolve(false)
-            }
-        } catch (e: Exception) {
-            promise.resolve(false)
+            player.volume = volume
+            return true;
+        } catch (_: Exception) {
+            // Noop
         }
+        return false
     }
 
-    fun setPlaybackSpeed(speed: Float?, promise: Promise) {
-        try {
-            // Call the custom function to validate and set the playback speed
-            val success = validateAndSetPlaybackSpeed(player, speed)
-            promise.resolve(success)  // Resolve the promise with success
-
-        } catch (e: Exception) {
-            // Handle any exceptions and reject the promise
-            promise.reject("setPlaybackSpeed Error", e.toString())
-        }
-    }
+    fun setPlaybackSpeed(speed: Float?) = validateAndSetPlaybackSpeed(player, speed)
 
-    private fun startListening(promise: Promise) {
+    private fun startListening() {
         try {
             audioPlaybackListener = object : CountDownTimer(player.duration, UpdateFrequency.Low.value) {
                 override fun onTick(millisUntilFinished: Long) {
@@ -207,7 +181,7 @@ class AudioPlayer(
                 override fun onFinish() {}
             }.start()
         } catch(err: JavascriptException) {
-            promise.reject("startListening Error", err)
+            throw Exception("startListening-error", err)
         }
     }
 

android/src/main/java/com/audiowaveform/AudioRecorder.kt

@@ -22,35 +22,15 @@ class AudioRecorder {
     private var useLegacyNormalization = false
     private var isRecording = false
 
-    private fun isPermissionGranted(activity: Activity?): Int? {
-        return activity?.let { ActivityCompat.checkSelfPermission(it, permissions[0]) }
-    }
+    private fun isPermissionGranted(activity: Activity?): Int? = activity?.let { ActivityCompat.checkSelfPermission(it, permissions[0]) }
 
-    fun checkPermission(activity: Activity?, promise: Promise): String {
-        val permissionResponse = isPermissionGranted(activity)
-        if (permissionResponse === PackageManager.PERMISSION_GRANTED) {
-            promise.resolve("granted")
-            return "granted"
-        } else {
-            promise.resolve("denied")
-            return "denied"
-        }
-    }
+    fun checkPermission(activity: Activity?): String = if (isPermissionGranted(activity) == PackageManager.PERMISSION_GRANTED) "granted" else "denied"
 
-    fun getPermission(activity: Activity?, promise: Promise): String {
-        val permissionResponse = isPermissionGranted(activity)
-        if (permissionResponse === PackageManager.PERMISSION_GRANTED) {
-            promise.resolve("granted");
-            return "granted"
-        } else {
-            activity?.let {
-                ActivityCompat.requestPermissions(
-                    it, permissions,
-                    RECORD_AUDIO_REQUEST_CODE
-                )
-            }
-            return "denied"
-        }
+    fun getPermission(activity: Activity?): String {
+        if (isPermissionGranted(activity) == PackageManager.PERMISSION_GRANTED) return "granted"
+
+        activity?.let { ActivityCompat.requestPermissions(it, permissions, RECORD_AUDIO_REQUEST_CODE) }
+        return "denied"
     }
 
     fun getDecibel(recorder: MediaRecorder?): Double? {
@@ -133,7 +113,7 @@ class AudioRecorder {
                 val tempArrayForCommunication : MutableList<String> = mutableListOf()
                 val duration = getDuration(path)
                 tempArrayForCommunication.add(path)
-                tempArrayForCommunication.add(duration.toString())
+                tempArrayForCommunication.add(duration)
                 promise.resolve(Arguments.fromList(tempArrayForCommunication))
             } else {
                 promise.reject("Error", "Recorder is not recording or has already been stopped")