@javascriptcommon/react-native-track-player 1.2.23 → 1.2.25

package/android/src/main/java/com/guichaguri/trackplayer/HeadlessJsMediaService.java

@@ -111,7 +111,7 @@ public abstract class HeadlessJsMediaService extends MediaBrowserServiceCompat i
      */
     protected void startTask(final HeadlessJsTaskConfig taskConfig) {
         UiThreadUtil.assertOnUiThread();
-        // acquireWakeLockNow(this);
+        acquireWakeLockNow(this);
         ReactContext reactContext = getReactContext();
         if (reactContext == null) {
             createReactContextAndScheduleTask(taskConfig);

package/android/src/main/java/com/guichaguri/trackplayer/module/MusicModule.kt

@@ -40,7 +40,6 @@ import com.guichaguri.trackplayer.model.Track
 import kotlinx.coroutines.MainScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
-import timber.log.Timber
 import java.util.*
 import java.util.concurrent.Callable
 import java.util.concurrent.ExecutorService
@@ -125,30 +124,37 @@ class MusicModule(reactContext: ReactApplicationContext?) :
 
     override fun onServiceConnected(name: ComponentName, service: IBinder) {
         scope.launch {
-            binder = service as MusicBinder
+        try {
+            binder = service as? MusicBinder ?: return@launch
             connecting = false
+            
             if (musicService == null) {
-                val binder: MusicBinder = service
-                musicService = binder.service
-                musicService?.setupPlayer(playerOptions);
+                musicService = binder?.service
+                musicService?.setupPlayer(playerOptions)
             }
 
             isServiceBound = true
 
             // Reapply options that user set before with updateOptions
-            if (options != null) {
+            if (options != null && binder != null) {
                 binder!!.updateOptions(options!!)
             }
 
             // Triggers all callbacks
-            while (!initCallbacks.isEmpty()) {
+            while (!initCallbacks.isEmpty() && binder != null) {
                 binder!!.post(initCallbacks.remove())
             }
+        } catch (ex: Exception) {
+            connecting = false
+            isServiceBound = false
+            binder = null
+        }
         }
     }
 
     override fun onServiceDisconnected(name: ComponentName) {
         binder = null
+        musicService = null
         connecting = false
         isServiceBound = false
     }
@@ -175,7 +181,9 @@ class MusicModule(reactContext: ReactApplicationContext?) :
         } else {
             initCallbacks.add(r)
         }
-        if (connecting) return
+        if (connecting || isServiceBound) return
+        connecting = true
+        
         val context = reactApplicationContext
 
         // Binds the service to get a MediaWrapper instance
@@ -204,8 +212,16 @@ class MusicModule(reactContext: ReactApplicationContext?) :
             }
         }
         intent.action = Utils.CONNECT_INTENT
-        context.bindService(intent, this, 0)
-        connecting = true
+        val bindResult = try {
+            context.bindService(intent, this, Context.BIND_AUTO_CREATE)
+        } catch (ex: Exception) {
+            connecting = false
+            false
+        }
+        
+        if (!bindResult) {
+            connecting = false
+        }
     }
 
     /* ****************************** API ****************************** */
@@ -545,6 +561,14 @@ class MusicModule(reactContext: ReactApplicationContext?) :
                 )
                 return
             }
+            
+            if (connecting) {
+                promise.reject(
+                    "player_already_connecting",
+                    "The player is already connecting to the service."
+                )
+                return
+            }
 
             // prevent crash Fatal Exception: android.app.RemoteServiceException$ForegroundServiceDidNotStartInTimeException
             /*        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && AppForegroundTracker.backgrounded) {
@@ -611,13 +635,35 @@ class MusicModule(reactContext: ReactApplicationContext?) :
                 IntentFilter(EVENT_INTENT)
             )
 
-            Intent(reactApplicationContext, MusicService::class.java).also { intent ->
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                    reactApplicationContext.startForegroundService(intent)
-                } else {
-                    reactApplicationContext.startService(intent)
+            val musicModule = this
+            connecting = true
+            scope.launch {
+                var retries = 0
+                var bindSuccess = false
+                while (retries <= 10 && !bindSuccess) {
+                    try {
+                        val intent = Intent(reactApplicationContext, MusicService::class.java)
+                        intent.action = Utils.CONNECT_INTENT
+                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                            reactApplicationContext.startForegroundService(intent)
+                        } else {
+                            reactApplicationContext.startService(intent)
+                        }
+                        bindSuccess = reactApplicationContext.bindService(intent, musicModule, Context.BIND_AUTO_CREATE)
+                        if (bindSuccess) {
+                            break
+                        }
+                    } catch (exception: Exception) {
+                        retries += 1
+                        if (retries > 10) {
+                            break
+                        }
+                        delay(500)
+                    }
+                }
+                if (!bindSuccess) {
+                    connecting = false
                 }
-                reactApplicationContext.bindService(intent, this, Context.BIND_AUTO_CREATE)
             }
         } catch (_: Exception) {}
     }
@@ -711,13 +757,13 @@ class MusicModule(reactContext: ReactApplicationContext?) :
     fun destroy() {
         val serviceConnection = this
         scope.launch {
+            if (binder == null && !connecting) return@launch
+            
             musicService = null
             isServiceBound = false
             connecting = false
             firstPlayDone = false
 
-            // Ignore if it was already destroyed
-            if (binder == null && !connecting) return@launch
             try {
                 if (binder != null) {
                     binder!!.manager.metadata.removeNotifications()
@@ -727,10 +773,7 @@ class MusicModule(reactContext: ReactApplicationContext?) :
                 }
                 val context: ReactContext? = reactApplicationContext
                 context?.unbindService(serviceConnection)
-            } catch (ex: Exception) {
-                // This method shouldn't be throwing unhandled errors even if something goes wrong.
-                Timber.tag(Utils.LOG).e(ex, "An error occurred while destroying the service")
-            }
+            } catch (ex: Exception) {}
         }
     }
 

package/android/src/main/java/com/guichaguri/trackplayer/service/MusicService.kt

@@ -18,11 +18,9 @@ import android.support.v4.media.MediaBrowserCompat.MediaItem
 import android.support.v4.media.RatingCompat
 import android.support.v4.media.session.MediaSessionCompat
 import android.support.v4.media.session.PlaybackStateCompat
-import android.view.KeyEvent
-import android.view.KeyEvent.KEYCODE_MEDIA_STOP
 import androidx.annotation.MainThread
 import androidx.core.app.NotificationCompat
-import androidx.media.session.MediaButtonReceiver
+import androidx.media.MediaBrowserServiceCompat
 import androidx.media.utils.MediaConstants
 import com.facebook.react.ReactHost
 import com.facebook.react.ReactInstanceEventListener
@@ -61,7 +59,6 @@ import com.guichaguri.trackplayer.kotlinaudio.models.RepeatMode
 import com.guichaguri.trackplayer.kotlinaudio.players.QueuedAudioPlayer
 import com.guichaguri.trackplayer.model.Track
 import com.guichaguri.trackplayer.model.TrackAudioItem
-import com.guichaguri.trackplayer.module.AutoConnectionDetector
 import com.guichaguri.trackplayer.module.MusicEvents
 import com.guichaguri.trackplayer.module.MusicModule
 import com.guichaguri.trackplayer.module.MusicModule.Companion.autoConnectionDetector
@@ -121,7 +118,7 @@ class MusicService : HeadlessJsMediaService() {
     private var mediaSession: MediaSessionCompat? = null
     private var stateBuilder: PlaybackStateCompat.Builder? = null
 
-    override fun getTaskConfig(intent: Intent): HeadlessJsTaskConfig {
+    override fun getTaskConfig(intent: Intent?): HeadlessJsTaskConfig {
         return HeadlessJsTaskConfig("TrackPlayer", Arguments.createMap(), 0, true)
     }
 
@@ -155,46 +152,22 @@ class MusicService : HeadlessJsMediaService() {
         } catch (_: Exception) {}
     }
 
-    @SuppressLint("VisibleForTests")
-    private fun onStartForeground() {
-        var serviceForeground = false
-        if (manager != null) {
-            // The session is only active when the service is on foreground
-            serviceForeground = manager!!.metadata.session.isActive
+    @MainThread
+    override fun onBind(intent: Intent?): IBinder? {
+        if (intent == null) {
+            return super.onBind(intent)
         }
-
-        if (!serviceForeground) {
-            val currentReactContext = if (bridgelessEnabled) reactHost.currentReactContext else reactNativeHost.reactInstanceManager.currentReactContext
-
-            // Checks whether there is a React activity
-            if (currentReactContext == null || !currentReactContext.hasCurrentActivity()) {
-                val channel = Utils.getNotificationChannel(this as Context)
-
-                // Sets the service to foreground with an empty notification
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-                    startForeground(
-                        1,
-                        NotificationCompat.Builder(this, channel).build(),
-                        ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK
-                    )
-                } else {
-                    startForeground(1, NotificationCompat.Builder(this, channel).build())
-                }
-                // Stops the service right after
-                stopSelf()
-            }
+        
+        val intentAction = intent.action
+        if (intentAction == MediaBrowserServiceCompat.SERVICE_INTERFACE) {
+            return super.onBind(intent)
         }
-    }
 
-    override fun onBind(intent: Intent): IBinder? {
-        /* if(Utils.CONNECT_INTENT.equals(intent.getAction())) {
-            return new MusicBinder(this, manager);
+        if (manager == null) {
+            manager = MusicManager(this)
         }
-        return super.onBind(intent); */
-
-        return if (SERVICE_INTERFACE == intent.action) {
-            super.onBind(intent)
-        } else MusicBinder(this, manager!!)
+        
+        return MusicBinder(this, manager!!)
     }
 
     fun invokeStartTask(reactContext: ReactContext, restart: Boolean = false) {
@@ -646,12 +619,12 @@ class MusicService : HeadlessJsMediaService() {
         try {
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
                 startForeground(
-                    1,
+                    EMPTY_NOTIFICATION_ID,
                     NotificationCompat.Builder(this, channel).build(),
                     ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK
                 )
             } else {
-                startForeground(1, NotificationCompat.Builder(this, channel).build())
+                startForeground(EMPTY_NOTIFICATION_ID, NotificationCompat.Builder(this, channel).build())
             }
         } catch (_: Exception) { }
     }
@@ -664,7 +637,7 @@ class MusicService : HeadlessJsMediaService() {
      * information see https://github.com/doublesymmetry/react-native-track-player/issues/1666
      */
     private fun startAndStopEmptyNotificationToAvoidANR() {
-        val notificationManager = this.getSystemService(NOTIFICATION_SERVICE) as NotificationManager
+        val notificationManager = this.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             notificationManager.createNotificationChannel(
                 NotificationChannel("Playback", "Playback", NotificationManager.IMPORTANCE_LOW)
@@ -673,59 +646,31 @@ class MusicService : HeadlessJsMediaService() {
 
         val resId = applicationContext.resources.getIdentifier("track_player_logo", "drawable", applicationContext.packageName)
         val logo = if (resId != 0) resId else R.drawable.ic_play
-        val notificationBuilder: NotificationCompat.Builder = NotificationCompat.Builder(
-            this, "Playback"
-        )
+        val notificationBuilder = NotificationCompat.Builder(this, "Playback")
             .setPriority(NotificationCompat.PRIORITY_LOW)
-            .setCategory(NotificationCompat.CATEGORY_SERVICE)
+            .setCategory(Notification.CATEGORY_SERVICE)
             .setSmallIcon(logo)
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            notificationBuilder.setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE)
+            notificationBuilder.foregroundServiceBehavior = NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE
         }
         val notification = notificationBuilder.build()
-        startForeground(1, notification)
-        @Suppress("DEPRECATION")
-        stopForeground(true)
-    }
-
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-
-        if (intent == null) {
-            return START_NOT_STICKY
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            startForeground(EMPTY_NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK)
+        } else {
+            startForeground(EMPTY_NOTIFICATION_ID, notification)
         }
-
-        if (Intent.ACTION_MEDIA_BUTTON == intent.action) {
-            onStartForeground()
-
-            if (Build.VERSION.SDK_INT >= 33) {
-                try {
-                    startAndStopEmptyNotificationToAvoidANR()
-                } catch (_: java.lang.Exception) {}
-            }
-
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            stopForeground(STOP_FOREGROUND_REMOVE)
+        } else {
             @Suppress("DEPRECATION")
-            val intentExtra: KeyEvent? = intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT)
-            if (intentExtra!!.keyCode == KEYCODE_MEDIA_STOP) {
-                intentToStop = true
-                startServiceOreoAndAbove()
-                stopSelf()
-            } else {
-                intentToStop = false
-            }
-
-            if (manager != null) {
-                MediaButtonReceiver.handleIntent(manager!!.metadata.session, intent)
-                return START_NOT_STICKY
-            }
+            stopForeground(true)
         }
+    }
 
-        if (manager == null) manager = MusicManager(this)
-
-        @Suppress("DEPRECATION")
-        if (handler == null) handler = Handler()
-
-        super.onStartCommand(intent, flags, startId)
-        return START_NOT_STICKY
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        startTask(getTaskConfig(intent))
+        if (intent != null) startAndStopEmptyNotificationToAvoidANR()
+        return START_STICKY
     }
 
     private fun startServiceOreoAndAbove() {
@@ -750,9 +695,9 @@ class MusicService : HeadlessJsMediaService() {
                     NotificationCompat.PRIORITY_MIN
                 ).build()
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-                startForeground(1, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK)
+                startForeground(EMPTY_NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK)
             } else {
-                startForeground(1, notification)
+                startForeground(EMPTY_NOTIFICATION_ID, notification)
             }
         }
     }
@@ -1185,6 +1130,9 @@ class MusicService : HeadlessJsMediaService() {
                         notification = it.notification;
                         if (it.ongoing) {
                             if (player?.playWhenReady == true) {
+                                if (sWakeLock?.isHeld != true) {
+                                    sWakeLock?.acquire()
+                                }
                                 startForegroundIfNecessary()
                             }
                         } else if (shouldStopForeground()) {
@@ -1194,7 +1142,10 @@ class MusicService : HeadlessJsMediaService() {
                             // user's queue is complete. This prevents the service from potentially
                             // being immediately destroyed once the player finishes playing media.
                             scope.launch {
-                                delay(stopForegroundGracePeriod.toLong() * 1000)
+                                if (sWakeLock?.isHeld == true) {
+                                    sWakeLock?.release()
+                                }
+                                // delay(stopForegroundGracePeriod.toLong() * 1000)
                                 // if (shouldStopForeground()) {
                                 // @Suppress("DEPRECATION")
                                 // stopForeground(removeNotificationWhenNotOngoing)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@javascriptcommon/react-native-track-player",
-  "version": "1.2.23",
+  "version": "1.2.25",
   "description": "A fully fledged audio module created for music apps",
   "contributors": [
     {