@javascriptcommon/react-native-track-player 4.1.7 → 4.1.8

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

@@ -15,6 +15,7 @@ import com.doublesymmetry.trackplayer.model.Track
 import com.doublesymmetry.trackplayer.module.MusicEvents.Companion.EVENT_INTENT
 import com.doublesymmetry.trackplayer.service.MusicService
 import com.doublesymmetry.trackplayer.utils.AppForegroundTracker
+import com.doublesymmetry.trackplayer.utils.AutoConnectionDetector
 import com.doublesymmetry.trackplayer.utils.RejectionException
 import com.doublesymmetry.trackplayer.NativeTrackPlayerSpec
 import com.facebook.react.bridge.*
@@ -64,6 +65,7 @@ class MusicModule(reactContext: ReactApplicationContext) : NativeTrackPlayerSpec
 
     override fun initialize() {
         AppForegroundTracker.start()
+        AutoConnectionDetector(context).registerCarConnectionReceiver()
     }
 
     override fun onServiceConnected(name: ComponentName, service: IBinder) {

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

@@ -951,30 +951,33 @@ class MusicService : HeadlessJsMediaService() {
 
     @SuppressLint("VisibleForTests")
     private fun selfWake(clientPackageName: String): Boolean {
-        val reactActivity = reactContext?.currentActivity
-        if (
-        // HACK: validate reactActivity is present; if not, send wake intent
-            (reactActivity == null || reactActivity.isDestroyed)
-            && Settings.canDrawOverlays(this)
-        ) {
-            val currentTime = System.currentTimeMillis()
-            if (currentTime - lastWake < 100000) {
-                return false
-            }
-            lastWake = currentTime
-            val activityIntent = packageManager.getLaunchIntentForPackage(packageName)
-            activityIntent!!.data = "trackplayer://service-bound".toUri()
-            activityIntent.action = Intent.ACTION_VIEW
-            activityIntent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
-            var activityOptions = ActivityOptions.makeBasic()
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-                activityOptions = activityOptions.setPendingIntentBackgroundActivityStartMode(
-                    ActivityOptions.MODE_BACKGROUND_ACTIVITY_START_ALLOWED)
-            }
-            this.startActivity(activityIntent, activityOptions.toBundle())
-            return true
-        }
+        // FORK PATCH: AVOID STARTING APP IN FOREGROUND, PREFER STARTING HEADLESS
         return false
+
+//        val reactActivity = reactContext?.currentActivity
+//        if (
+//        // HACK: validate reactActivity is present; if not, send wake intent
+//            (reactActivity == null || reactActivity.isDestroyed)
+//            && Settings.canDrawOverlays(this)
+//        ) {
+//            val currentTime = System.currentTimeMillis()
+//            if (currentTime - lastWake < 100000) {
+//                return false
+//            }
+//            lastWake = currentTime
+//            val activityIntent = packageManager.getLaunchIntentForPackage(packageName)
+//            activityIntent!!.data = "trackplayer://service-bound".toUri()
+//            activityIntent.action = Intent.ACTION_VIEW
+//            activityIntent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
+//            var activityOptions = ActivityOptions.makeBasic()
+//            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+//                activityOptions = activityOptions.setPendingIntentBackgroundActivityStartMode(
+//                    ActivityOptions.MODE_BACKGROUND_ACTIVITY_START_ALLOWED)
+//            }
+//            this.startActivity(activityIntent, activityOptions.toBundle())
+//            return true
+//        }
+//        return false
     }
 
     override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaLibrarySession {
@@ -1006,6 +1009,7 @@ class MusicService : HeadlessJsMediaService() {
             player.destroy()
         }
 
+        // FORK PATCH
         // -> Attempt to fix https://github.com/doublesymmetry/react-native-track-player/issues/2485
         mediaSession.release()
         
@@ -1086,15 +1090,17 @@ class MusicService : HeadlessJsMediaService() {
         private val rootItem = buildMediaItem(title = "root", mediaId = AA_ROOT_KEY, isPlayable = false)
         private val forYouItem = buildMediaItem(title = "For You", mediaId = AA_FOR_YOU_KEY, isPlayable = false)
 
-        override fun onDisconnected(
-            session: MediaSession,
-            controller: MediaSession.ControllerInfo
-        ) {
-            emit(MusicEvents.CONNECTOR_DISCONNECTED, Bundle().apply {
-                putString("package", controller.packageName)
-            })
-            super.onDisconnected(session, controller)
-        }
+        // FORK PATCH: onDisconnected it's called only a long time after Android Auto disconnection, replaced with AutoConnectionDetector
+//        override fun onDisconnected(
+//            session: MediaSession,
+//            controller: MediaSession.ControllerInfo
+//        ) {
+//
+//            emit(MusicEvents.CONNECTOR_DISCONNECTED, Bundle().apply {
+//                putString("package", controller.packageName)
+//            })
+//            super.onDisconnected(session, controller)
+//        }
         // Configure commands available to the controller in onConnect()
         @OptIn(UnstableApi::class)
         override fun onConnect(

package/android/src/main/java/com/doublesymmetry/trackplayer/utils/AutoConnectionDetector.kt

@@ -0,0 +1,97 @@
+package com.doublesymmetry.trackplayer.utils
+
+import android.os.Handler
+import android.os.Looper
+import androidx.car.app.connection.CarConnection
+import androidx.lifecycle.LifecycleOwner
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.doublesymmetry.trackplayer.module.MusicEvents
+
+class AutoConnectionDetector(
+    val context: ReactContext,
+    onConnectionChange: ((Boolean) -> Unit)? = null
+) {
+
+    companion object {
+        const val TAG = "AutoConnectionDetector"
+    }
+
+    var isCarConnected = false
+    private var carConnection: CarConnection? = null
+    private val onConnectionChangeCallback = onConnectionChange
+    private var isObserving = false
+
+    fun registerCarConnectionReceiver() {
+        if (carConnection == null) {
+            carConnection = CarConnection(context)
+        }
+
+        val mainHandler = Handler(Looper.getMainLooper())
+        mainHandler.post {
+            val lifecycleOwner = context.currentActivity as? LifecycleOwner
+            if (lifecycleOwner != null && !isObserving) {
+                try {
+                    carConnection?.type?.observe(lifecycleOwner, ::onConnectionStateUpdated)
+                    isObserving = true
+                } catch (_: Throwable) {}
+            }
+        }
+    }
+
+    private fun onConnectionStateUpdated(connectionState: Int) {
+        when (connectionState) {
+            CarConnection.CONNECTION_TYPE_NOT_CONNECTED -> {
+                if (isCarConnected) {
+                    notifyCarDisconnected()
+                }
+            }
+            CarConnection.CONNECTION_TYPE_NATIVE -> {
+                notifyCarConnected(connectionState)
+            }
+            CarConnection.CONNECTION_TYPE_PROJECTION -> {
+                notifyCarConnected(connectionState)
+            }
+        }
+    }
+
+    private fun emitConnectorEvent(eventName: String, connectionState: Int?) {
+        val params = Arguments.createMap()
+        params.putString("package", "com.google.android.projection.gearhead") // Android Auto package name
+        params.putBoolean(
+            "isAutomotiveController",
+            connectionState == CarConnection.CONNECTION_TYPE_NATIVE // Android Automotive
+        )
+        params.putBoolean(
+            "isAutoCompanionController",
+            connectionState == CarConnection.CONNECTION_TYPE_PROJECTION // Android Auto
+        )
+        params.putBoolean("isMediaNotificationController", false)
+
+        context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            ?.emit(eventName, params)
+    }
+
+    private fun notifyCarConnected(connectionState: Int) {
+        if (isCarConnected) return
+        isCarConnected = true
+
+        // emitConnectionUpdate(params) // old
+        // emitConnectorEvent(MusicEvents.CONNECTOR_CONNECTED, connectionState) // new but not necessary (MusicService event works)
+
+        onConnectionChangeCallback?.invoke(true)
+    }
+
+    private fun notifyCarDisconnected() {
+        if (!isCarConnected) return
+        isCarConnected = false
+
+        // emitConnectionUpdate(params) // old
+
+        // MusicService event doesn't work -> emit manually
+        emitConnectorEvent(MusicEvents.CONNECTOR_DISCONNECTED, CarConnection.CONNECTION_TYPE_NOT_CONNECTED)
+
+        onConnectionChangeCallback?.invoke(false)
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@javascriptcommon/react-native-track-player",
-  "version": "4.1.7",
+  "version": "4.1.8",
   "description": "A fully fledged audio module created for music apps",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",