feat: Android Auto Support

android/build.gradle

@@ -21,6 +21,7 @@ android {
     compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
     namespace 'com.doublesymmetry.trackplayer'
 
+    def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
     defaultConfig {
         minSdkVersion getExtOrIntegerDefault('minSdkVersion') // RN's minimum version
         targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
@@ -50,7 +51,7 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.github.doublesymmetry:kotlinaudio:v2.1.0'
+    implementation 'com.github.lovegaoshi:KotlinAudio:v2.0.0-aa23'
     // used when building against local maven
 //    implementation "com.github.doublesymmetry:kotlin-audio:2.1.0"
 
@@ -62,4 +63,5 @@ dependencies {
     implementation "androidx.localbroadcastmanager:localbroadcastmanager:1.1.0"
     implementation "androidx.lifecycle:lifecycle-process:2.5.1"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.3"
+    implementation 'androidx.media:media:1.6.0'
 }

android/src/main/AndroidManifest.xml

@@ -4,18 +4,23 @@
 
     <uses-permission android:name="android.permission.WAKE_LOCK" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
-
     <uses-permission
         android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
 
     <application>
 
         <!-- The main service, handles playback, playlists and media buttons -->
-        <service android:name="com.doublesymmetry.trackplayer.service.MusicService" android:enabled="true" android:exported="true" android:foregroundServiceType="mediaPlayback">
+        <service
+            android:name="com.doublesymmetry.trackplayer.service.MusicService"
+            android:enabled="true"
+            android:exported="true"
+            android:foregroundServiceType="mediaPlayback">
             <intent-filter>
                 <action android:name="android.intent.action.MEDIA_BUTTON" />
+                <action android:name="android.media.browse.MediaBrowserService" />
             </intent-filter>
         </service>
+
     </application>
 
 </manifest>

android/src/main/java/com/doublesymmetry/trackplayer/HeadlessJsMediaService.java

@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+ package com.doublesymmetry.trackplayer;
+
+ import android.annotation.SuppressLint;
+ import android.content.BroadcastReceiver;
+ import android.content.Context;
+ import android.content.Intent;
+ import android.os.IBinder;
+ import android.os.PowerManager;
+
+ import androidx.annotation.Nullable;
+ import androidx.media.MediaBrowserServiceCompat;
+ import com.facebook.infer.annotation.Assertions;
+ import com.facebook.react.bridge.ReactContext;
+ import com.facebook.react.bridge.UiThreadUtil;
+ import com.facebook.react.jstasks.HeadlessJsTaskConfig;
+ import com.facebook.react.jstasks.HeadlessJsTaskContext;
+ import com.facebook.react.jstasks.HeadlessJsTaskEventListener;
+ import com.facebook.react.ReactInstanceManager;
+ import com.facebook.react.ReactInstanceEventListener;
+ import com.facebook.react.ReactNativeHost;
+ import com.facebook.react.ReactApplication;
+ import java.util.Set;
+ import java.util.concurrent.CopyOnWriteArraySet;
+
+ import timber.log.Timber;
+
+/**
+  * Base class for running JS without a UI. Generally, you only need to override {@link
+  * #getTaskConfig}, which is called for every {@link #onStartCommand}. The result, if not {@code
+  * null}, is used to run a JS task.
+  *
+  * <p>If you need more fine-grained control over how tasks are run, you can override {@link
+  * #onStartCommand} and call {@link #startTask} depending on your custom logic.
+  *
+  * <p>If you're starting a {@code HeadlessJsTaskService} from a {@code BroadcastReceiver} (e.g.
+  * handling push notifications), make sure to call {@link #acquireWakeLockNow} before returning from
+  * {@link BroadcastReceiver#onReceive}, to make sure the device doesn't go to sleep before the
+  * service is started.
+  */
+ public abstract class HeadlessJsMediaService extends MediaBrowserServiceCompat implements HeadlessJsTaskEventListener {
+
+   private final Set<Integer> mActiveTasks = new CopyOnWriteArraySet<>();
+   private static @Nullable PowerManager.WakeLock sWakeLock;
+
+
+
+   @Override
+   public int onStartCommand(Intent intent, int flags, int startId) {
+     HeadlessJsTaskConfig taskConfig = getTaskConfig(intent);
+     if (taskConfig != null) {
+       startTask(taskConfig);
+       return START_REDELIVER_INTENT;
+     }
+     return START_NOT_STICKY;
+   }
+
+   /**
+    * Called from {@link #onStartCommand} to create a {@link HeadlessJsTaskConfig} for this intent.
+    *
+    * @param intent the {@link Intent} received in {@link #onStartCommand}.
+    * @return a {@link HeadlessJsTaskConfig} to be used with {@link #startTask}, or {@code null} to
+    *     ignore this command.
+    */
+   protected @Nullable HeadlessJsTaskConfig getTaskConfig(Intent intent) {
+     return null;
+   }
+
+   /**
+    * Acquire a wake lock to ensure the device doesn't go to sleep while processing background tasks.
+    */
+   @SuppressLint("WakelockTimeout")
+   public static void acquireWakeLockNow(Context context) {
+     if (sWakeLock == null || !sWakeLock.isHeld()) {
+       PowerManager powerManager =
+           Assertions.assertNotNull((PowerManager) context.getSystemService(POWER_SERVICE));
+       sWakeLock =
+           powerManager.newWakeLock(
+               PowerManager.PARTIAL_WAKE_LOCK, HeadlessJsMediaService.class.getCanonicalName());
+       sWakeLock.setReferenceCounted(false);
+       sWakeLock.acquire();
+     }
+   }
+
+   @Override
+   public @Nullable IBinder onBind(Intent intent) {
+    return super.onBind(intent);
+   }
+
+     @Override
+     public void onCreate() {
+        super.onCreate();
+     }
+
+     /**
+    * Start a task. This method handles starting a new React instance if required.
+    *
+    * <p>Has to be called on the UI thread.
+    *
+    * @param taskConfig describes what task to start and the parameters to pass to it
+    */
+   protected void startTask(final HeadlessJsTaskConfig taskConfig) {
+     UiThreadUtil.assertOnUiThread();
+     acquireWakeLockNow(this);
+     final ReactInstanceManager reactInstanceManager =
+         getReactNativeHost().getReactInstanceManager();
+     ReactContext reactContext = reactInstanceManager.getCurrentReactContext();
+     if (reactContext == null) {
+       reactInstanceManager.addReactInstanceEventListener(
+           new ReactInstanceEventListener() {
+             @Override
+             public void onReactContextInitialized(ReactContext reactContext) {
+               invokeStartTask(reactContext, taskConfig);
+               reactInstanceManager.removeReactInstanceEventListener(this);
+             }
+           });
+       reactInstanceManager.createReactContextInBackground();
+     } else {
+       invokeStartTask(reactContext, taskConfig);
+     }
+   }
+
+   private void invokeStartTask(ReactContext reactContext, final HeadlessJsTaskConfig taskConfig) {
+     final HeadlessJsTaskContext headlessJsTaskContext =
+         HeadlessJsTaskContext.getInstance(reactContext);
+     headlessJsTaskContext.addTaskEventListener(this);
+
+     UiThreadUtil.runOnUiThread(
+         new Runnable() {
+           @Override
+           public void run() {
+             int taskId = headlessJsTaskContext.startTask(taskConfig);
+             mActiveTasks.add(taskId);
+           }
+         });
+   }
+
+   @Override
+   public void onDestroy() {
+     super.onDestroy();
+
+     if (getReactNativeHost().hasInstance()) {
+       ReactInstanceManager reactInstanceManager = getReactNativeHost().getReactInstanceManager();
+       ReactContext reactContext = reactInstanceManager.getCurrentReactContext();
+       if (reactContext != null) {
+         HeadlessJsTaskContext headlessJsTaskContext =
+             HeadlessJsTaskContext.getInstance(reactContext);
+         headlessJsTaskContext.removeTaskEventListener(this);
+       }
+     }
+     if (sWakeLock != null) {
+       sWakeLock.release();
+     }
+   }
+
+   @Override
+   public void onHeadlessJsTaskStart(int taskId) {}
+
+   @Override
+   public void onHeadlessJsTaskFinish(int taskId) {
+     mActiveTasks.remove(taskId);
+     if (mActiveTasks.size() == 0) {
+       stopSelf();
+     }
+   }
+
+   /**
+    * Get the {@link ReactNativeHost} used by this app. By default, assumes {@link #getApplication()}
+    * is an instance of {@link ReactApplication} and calls {@link
+    * ReactApplication#getReactNativeHost()}. Override this method if your application class does not
+    * implement {@code ReactApplication} or you simply have a different mechanism for storing a
+    * {@code ReactNativeHost}, e.g. as a static field somewhere.
+    */
+   protected ReactNativeHost getReactNativeHost() {
+     return ((ReactApplication) getApplication()).getReactNativeHost();
+   }
+ }
+

android/src/main/java/com/doublesymmetry/trackplayer/module/MusicEvents.kt

@@ -35,6 +35,7 @@ class MusicEvents(private val reactContext: ReactContext) : BroadcastReceiver()
         const val BUTTON_JUMP_FORWARD = "remote-jump-forward"
         const val BUTTON_JUMP_BACKWARD = "remote-jump-backward"
         const val BUTTON_DUCK = "remote-duck"
+        const val BUTTON_BROWSE = "remote-browse"
 
         // Playback Events
         const val PLAYBACK_PLAY_WHEN_READY_CHANGED = "playback-play-when-ready-changed"

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

@@ -1,11 +1,16 @@
 package com.doublesymmetry.trackplayer.module
 
 import android.content.*
+import android.media.MediaDescription
 import android.os.Build
 import android.os.Bundle
 import android.os.IBinder
+import android.net.Uri
 import android.support.v4.media.RatingCompat
+import android.support.v4.media.MediaBrowserCompat.MediaItem
+import android.support.v4.media.MediaDescriptionCompat
 import androidx.localbroadcastmanager.content.LocalBroadcastManager
+import androidx.media.utils.MediaConstants
 import com.doublesymmetry.kotlinaudio.models.Capability
 import com.doublesymmetry.kotlinaudio.models.RepeatMode
 import com.doublesymmetry.trackplayer.extensions.NumberExt.Companion.toMilliseconds
@@ -90,6 +95,68 @@ class MusicModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaM
         return Track(context, bundle, musicService.ratingType)
     }
 
+    private fun hashmapToMediaItem(hashmap: HashMap<String, String>): MediaItem {
+
+        val mediaId = hashmap["mediaId"]
+        val title = hashmap["title"]
+        val subtitle = hashmap["subtitle"]
+        val mediaUri = hashmap["mediaUri"]
+        val iconUri = hashmap["iconUri"]
+        val playableFlag = if (hashmap["playable"]?.toInt() == 1) MediaItem.FLAG_BROWSABLE else MediaItem.FLAG_PLAYABLE
+
+        val mediaDescriptionBuilder = MediaDescriptionCompat.Builder()
+        mediaDescriptionBuilder.setMediaId(mediaId)
+        mediaDescriptionBuilder.setTitle(title)
+        mediaDescriptionBuilder.setSubtitle(subtitle)
+        mediaDescriptionBuilder.setMediaUri(if (mediaUri != null) Uri.parse(mediaUri) else null)
+        mediaDescriptionBuilder.setIconUri(if (iconUri != null) Uri.parse(iconUri) else null)
+        val extras = Bundle()
+        hashmap["groupTitle"]?.let {
+            extras.putString(
+                MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_GROUP_TITLE, it)
+        }
+        hashmap["contentStyle"]?.toInt()?.let {
+            extras.putInt(
+                MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_SINGLE_ITEM, it)
+        }
+        hashmap["childrenPlayableContentStyle"]?.toInt()?.let {
+            extras.putInt(
+                MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_PLAYABLE, it)
+        }
+        hashmap["childrenBrowsableContentStyle"]?.toInt()?.let {
+            extras.putInt(
+                MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_BROWSABLE, it)
+        }
+
+        // playbackProgress should contain a string representation of a number between 0 and 1 if present
+        hashmap["playbackProgress"]?.toDouble()?.let {
+            if (it > 0.98) {
+                extras.putInt(
+                    MediaConstants.DESCRIPTION_EXTRAS_KEY_COMPLETION_STATUS,
+                    MediaConstants.DESCRIPTION_EXTRAS_VALUE_COMPLETION_STATUS_FULLY_PLAYED)
+            } else if (it == 0.0) {
+                extras.putInt(
+                    MediaConstants.DESCRIPTION_EXTRAS_KEY_COMPLETION_STATUS,
+                    MediaConstants.DESCRIPTION_EXTRAS_VALUE_COMPLETION_STATUS_NOT_PLAYED)
+            } else {
+                extras.putInt(
+                    MediaConstants.DESCRIPTION_EXTRAS_KEY_COMPLETION_STATUS,
+                    MediaConstants.DESCRIPTION_EXTRAS_VALUE_COMPLETION_STATUS_PARTIALLY_PLAYED)
+                extras.putDouble(
+                    MediaConstants.DESCRIPTION_EXTRAS_KEY_COMPLETION_PERCENTAGE, it)
+            }
+        }
+
+        mediaDescriptionBuilder.setExtras(extras)
+        return MediaItem(mediaDescriptionBuilder.build(), playableFlag)
+    }
+
+    private fun readableArrayToMediaItems(data: ArrayList<HashMap<String, String>>): MutableList<MediaItem> {
+        return data.map {
+            hashmapToMediaItem(it)
+        }.toMutableList()
+    }
+
     private fun rejectWithException(callback: Promise, exception: Exception) {
         when (exception) {
             is RejectionException -> {
@@ -626,4 +693,36 @@ class MusicModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaM
         if (verifyServiceBoundOrReject(callback)) return@launch
         callback.resolve(Arguments.fromBundle(musicService.getPlayerStateBundle(musicService.state)))
     }
+
+    @ReactMethod
+    fun setBrowseTree(mediaItems: ReadableMap, callback: Promise) = scope.launch {
+        if (verifyServiceBoundOrReject(callback)) return@launch
+        val mediaItemsMap = mediaItems.toHashMap()
+        musicService.mediaTree = mediaItemsMap.mapValues { readableArrayToMediaItems(it.value as ArrayList<HashMap<String, String>>) }
+        Timber.d("refreshing browseTree")
+        mediaItemsMap.keys.forEach {
+            musicService.notifyChildrenChanged(it)
+        }
+        callback.resolve(musicService.mediaTree.toString())
+    }
+
+    @ReactMethod
+    // this method doesn't seem to affect style after onGetRoot is called, and won't change if notifyChildrenChanged is emitted.
+    fun setBrowseTreeStyle(browsableStyle: Int, playableStyle: Int, callback: Promise) = scope.launch {
+        fun getStyle(check: Int): Int {
+            return when (check) {
+                2 -> MediaConstants.DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_GRID_ITEM
+                3 -> MediaConstants.DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_CATEGORY_LIST_ITEM
+                4 -> MediaConstants.DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_CATEGORY_GRID_ITEM
+                else -> MediaConstants.DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_LIST_ITEM
+            }
+        }
+        if (verifyServiceBoundOrReject(callback)) return@launch
+        musicService.mediaTreeStyle = listOf(
+            getStyle(browsableStyle),
+            getStyle(playableStyle)
+        )
+        callback.resolve(null)
+    }
+
 }