Search functionality not available on Android auto despite passing the necessary extras

[yuroyami]

In my MediaLibraryService, here's my implementation of onGetLibraryRoot :

        override fun onGetLibraryRoot(session: MediaLibrarySession, browser: MediaSession.ControllerInfo, params: LibraryParams?): ListenableFuture<LibraryResult<MediaItem>> {
            val rootExtras = Bundle()
            rootExtras.putBoolean(MediaConstants.BROWSER_SERVICE_EXTRAS_KEY_SEARCH_SUPPORTED, true)
            val libraryParams = LibraryParams.Builder().setExtras(rootExtras).build()
            return Futures.immediateFuture(LibraryResult.ofItem(rootItem, libraryParams))
        }

The code above should make the search functionality available on Android Auto, but the search button doesn't even show up. I tried to replace MediaConstants.BROWSER_SERVICE_EXTRAS_KEY_SEARCH_SUPPORTED with "android.media.browse.SEARCH_SUPPORTED" to make sure I am passing the correct key, but no avail.

The same result is met on both the virtual desktop head unit and a real car head unit. Am I doing something wrong ?

[marcbaechinger]

There are a few things that come to mind:

First, I think this is supported out of the box without you having to manually insert the extra. You only have to make sure that the browser has the command COMMAND_CODE_LIBRARY_SEARCH available. If this is the case, Media3 will insert that extra property automatically. This is done here in MediaLibraryServiceLegacyStub.onGetRoot. Vice versa, I would expect if you don't have this command available, Media3 would override your value with false.

So you would have to make sure that the COMMAND_CODE_LIBRARY_SEARCH is available. If you do not override Callback.onConnect() this is included by default. If you do override and give back a different set of commands then please make sure to include this command.

Second, of course, there may be a bug in Media3 that somehow doesn't correctly propagate these extras to the legacy browser client. For this I created a unit test case in MediaBrowserCompatWithMediaLibraryServiceTest to verify whether this works as expected:

  @Test
  public void getRoot_commandSearchAvailable_expectedBrowserRootExtraIsTrue() throws Exception {
    connectAndWait(/* connectionHints= */ Bundle.EMPTY);

    assertThat(
        browserCompat
            .getExtras()
            .getBoolean(BROWSER_SERVICE_EXTRAS_KEY_SEARCH_SUPPORTED, /* defaultValue= */ false))
        .isTrue();
  }

This test runs green without me manipulating the available commands in onConnect(), which is the expected result.

I also tested this by using the media controller test app, that uses the MediaBrowserCompat of the legacy media1 library that Automotive is using as well. When I connect with this app to the session demo, I can see the extras in the root keys that I see with browserCompat.getExtras(). This seems to have the expected key in the extras by default without me changing something in the demo app.

So from what I see and tested this should work given the COMMAND_CODE_LIBRARY_SEARCH is available which is the case by default.

Can you review your code and let me know whether you provide the required command?

[yuroyami]

@marcbaechinger Note that I've done my testing using an emulator but I also confirm the issue exists on a real car headunit.

Now on to details: I made sure that the required command does indeed exist in the available session commands. Here's my onConnect implementation:

override fun onConnect(session: MediaSession, controller: MediaSession.ControllerInfo): MediaSession.ConnectionResult {
            val superCall = super.onConnect(session, controller)

            val sessionComs = superCall.availableSessionCommands
                .buildUpon()
                .add(CUSTOM_COM_CUSTOM1)
                .add(CUSTOM_COM_CUSTOM2)
                .build()

            //search command code is 50005
            for (comm in sessionComs.commands) {
                Log.e("SessionCommand", "${comm.commandCode} - ${comm.customAction}")
            }
            return MediaSession.ConnectionResult.accept(sessionComs, superCall.availablePlayerCommands)
        }

As expected, all library commands (including the search command) appear in the logcat as well as the two custom commands. But no sign of any search button throughout the lifecycle of the Android Auto interface.

It gets weirder: when I loaded the media3 branch of UAMP (which is using media3-1.0.0 while I am using media3-1.2.0-alpha01) apparently the search functionality did not appear on the car screen either. I assume that the UAMP is supposed to provide the search functionality as well.

It gets even weirder: At some point when I started my media3 development, the search functionality did exist, then at some point it just stopped working. When the search functionality/button used to appear, I had both the onGetSearchResult and onSearch implemented, so it's probably not because of them, but something else. I think there is something else messing with it, probably another MediaLibraryCallback method ? I will keep on testing and see what I can fruit out of it.

Here's my full implementation of the MediaLibraryService just in case:

MediaLibraryService implementation

class MusicPlayerService : MediaLibraryService() {

    lateinit var player: Player
    private var mediaSession: MediaLibrarySession? = null

    //private lateinit var packageValidator: PackageValidator

    private val serviceIOScope = CoroutineScope(Dispatchers.IO)
    private val serviceMainScope = CoroutineScope(Dispatchers.Main)

    /** This is the root item that is parent to our playlist.
     *  It is necessary to have a parent item otherwise there is no "library" */
    val rootItem = MediaItem.Builder()
        .setMediaId(nodeROOT)
        .setMediaMetadata(
            MediaMetadata.Builder()
                .setIsBrowsable(true)
                .setIsPlayable(false)
                .setMediaType(MediaMetadata.MEDIA_TYPE_FOLDER_MIXED)
                .setTitle("Gmix")
                .build()
        )
        .build()

    lateinit var subroot_TracklistItem: MediaItem

    lateinit var subroot_PlaylistItem: MediaItem

    val rootHierarchy = mutableListOf<MediaItem>()

    var tracklist = mutableListOf<MediaItem>()
    var playlist = mutableListOf<MediaItem>()

    var latestSearchResults = mutableListOf<MediaItem>()

    var tracklistFullyPopulated = false

    /** This will fetch music from the source folder (or the entire device if not specified) */
    private fun queryMusic() {
        val sp = PreferenceManager.getDefaultSharedPreferences(applicationContext)
        val src = sp.getString("music_src_folder", "") ?: ""

        serviceIOScope.launch {
            tracklist.clear()
            scanMusic(
                uri = if (src == "") null else src.toUri(),
                onSongDetected = { song ->
                    tracklist.add(song)
                    serviceMainScope.launch {
                        mediaSession?.notifyChildrenChanged(nodeTRACKLIST, tracklist.size, null)
                    }
                }
            ) {
                tracklistFullyPopulated = true
                tracklist.sortWith(NameComparator())
                serviceMainScope.launch {
                    mediaSession?.notifyChildrenChanged(nodeROOT, 2, null)
                    mediaSession?.notifyChildrenChanged(nodeTRACKLIST, tracklist.size, null)
                    mediaSession?.notifyChildrenChanged(nodeROOT, 2, null)
                }
            }
        }
    }

    override fun onCreate() {
        super.onCreate()

        val icontracklist = getLocalDrawablePath(applicationContext, R.drawable.ic_tracklist)
        val iconplaylist = getLocalDrawablePath(applicationContext, R.drawable.ic_playlist)

        subroot_TracklistItem = MediaItem.Builder()
            .setMediaId(nodeTRACKLIST)
            .setMediaMetadata(
                MediaMetadata.Builder()
                    .setIsBrowsable(true)
                    .setIsPlayable(false)
                    .setMediaType(MediaMetadata.MEDIA_TYPE_FOLDER_PLAYLISTS)
                    .setTitle("Tracklist")
                    //.setArtworkUri(Uri.parse(icontracklist))
                    /*
                    .setExtras(Bundle().apply {
                        putString("MediaMetadataCompat.METADATA_KEY_DISPLAY_ICON_URI", icontracklist)
                        putString("MediaMetadataCompat.METADATA_KEY_ART_URI", icontracklist)
                        putString("MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI", icontracklist)
                    })

                     */
                    .build()
            )
            .build()

        subroot_PlaylistItem = MediaItem.Builder()
            .setMediaId(nodePLAYLIST)
            .setMediaMetadata(
                MediaMetadata.Builder()
                    .setIsBrowsable(true)
                    .setIsPlayable(false)
                    .setMediaType(MediaMetadata.MEDIA_TYPE_FOLDER_PLAYLISTS)
                    .setTitle("Playlist")
                    //.setArtworkUri(Uri.parse(iconplaylist))
                    /*
                    .setExtras(Bundle().apply {
                        putString("MediaMetadataCompat.METADATA_KEY_DISPLAY_ICON_URI", iconplaylist)
                        putString("MediaMetadataCompat.METADATA_KEY_ART_URI", iconplaylist)
                        putString("MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI", iconplaylist)
                    })

                     */
                    .build()
            )
            .build()

        rootHierarchy.clear()
        rootHierarchy.add(subroot_TracklistItem)
        rootHierarchy.add(subroot_PlaylistItem)

        queryMusic()

        restorePlaylist {
            playlist.clear()
            playlist.addAll(it)

            mediaSession?.notifyChildrenChanged(nodePLAYLIST, playlist.size, null)
            mediaSession?.notifyChildrenChanged(nodeROOT, 2, null)
        }

        /** Building ExoPlayer to use FFmpeg Audio Renderer and also enable fast-seeking */
        player = ExoPlayer.Builder(applicationContext)
            .setSeekParameters(SeekParameters.CLOSEST_SYNC) /* Enabling fast seeking */
            .setRenderersFactory(
                DefaultRenderersFactory(this).setExtensionRendererMode(
                    DefaultRenderersFactory.EXTENSION_RENDERER_MODE_PREFER /* We prefer extensions, such as FFmpeg */
                )
            )
            .setWakeMode(C.WAKE_MODE_LOCAL) /* Prevent the service from being killed during playback */
            .setHandleAudioBecomingNoisy(true) /* Prevent annoying noise when changing devices */
            .setAudioAttributes(
                AudioAttributes.Builder()
                    .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC)
                    .setUsage(C.USAGE_MEDIA)
                    .build(),
                true
            )
            .build()

        player.repeatMode = Player.REPEAT_MODE_ALL

        /** Creating our MediaLibrarySession which is an advanced extension of a MediaSession */
        mediaSession = with(MediaLibrarySession.Builder(this, player, SessionLibCallback())) {
            setId(packageName)
            packageManager?.getLaunchIntentForPackage(packageName)?.let { sessionIntent ->
                setSessionActivity(
                    PendingIntent.getActivity(
                        /* context= */ this@MusicPlayerService,
                        /* requestCode= */ 0,
                        sessionIntent,
                        FLAG_IMMUTABLE
                    )
                )
            }
            build()
        }

        //packageValidator = PackageValidator(this, R.xml.allowed_media_browser_callers)

        /** Listening to some player events */
        player.addListener(object : Player.Listener {
            override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
                super.onMediaItemTransition(mediaItem, reason)
                Log.e("ed", mediaItem?.mediaId ?: "Empty Media Id")

                if (mediaItem != null && player.mediaItemCount == 1) {
                    val playlistfootprint = mediaItem.requestMetadata.extras?.getBoolean("isplaylist", false) == true

                    if (playlistfootprint && playlist.isNotEmpty()) {
                        val index = playlist.indexOfFirst { it.mediaId == mediaItem.mediaId }
                        player.setMediaItems(playlist, index, 0)
                        setPlaybackMode(PlayBackMode.PBM_PLAYLIST)
                    }

                    if (!playlistfootprint && tracklist.size > 1) {
                        val index = tracklist.indexOfFirst { it.mediaId == mediaItem.mediaId }
                        player.setMediaItems(tracklist, index, 0)
                        setPlaybackMode(PlayBackMode.PBM_TRACKLIST)
                    }
                }

                updateCustomLayout()
            }

            override fun onPlayerError(error: PlaybackException) {
                error.printStackTrace()

                Log.e("PLAYER", error.stackTraceToString())
            }
        })
    }

    fun retrieveItemFromSearch(q: String): MediaItem? {
        val query =
            if (q.startsWith("play ", ignoreCase = true)) {
                q.drop(5)
            } else {
                q
            }

        if (tracklistFullyPopulated) {
            return tracklist.firstOrNull { item ->
                item.mediaMetadata.title?.contains(query, true) == true
                        ||
                        item.mediaMetadata.artist?.contains(query, true) == true
                        ||
                        item.mediaMetadata.albumTitle?.contains(query, true) == true
                        ||
                        item.mediaMetadata.albumArtist?.contains(query, true) == true
            }?.let { newItem ->
                return@let MediaItem.Builder()
                    .setMediaMetadata(newItem.mediaMetadata)
                    .setMediaId(newItem.mediaId)
                    .setUri(newItem.mediaId)
                    .build()
            }
        } else {
            return null //TODO Use MediaStore to blockingly look for the query
        }
    }

    /** The acutal session callback for Media3 (which is backward-compatible with Media2 and Media1 */
    inner class SessionLibCallback: MediaLibrarySession.Callback {
        override fun onAddMediaItems(mediaSession: MediaSession, controller: MediaSession.ControllerInfo, mediaItems: MutableList<MediaItem>): ListenableFuture<MutableList<MediaItem>> {
            val androidAutoCalled = mediaItems.all { it.localConfiguration == null } && (controller.packageName.isAndroidAuto())


            val newItems = mediaItems.map {
                Log.e("eee", "mediaId: ${it.mediaId}")
                val newItem = it.buildUpon().setUri(it.mediaId).build()

                val query = newItem.requestMetadata.searchQuery?.trim()
                if (query != null) {
                    retrieveItemFromSearch(query) ?: newItem
                } else {
                    newItem
                }
            }.toMutableList()

            val finalItems = if (androidAutoCalled) {
                mutableListOf(newItems.first())
            } else newItems


            return Futures.immediateFuture(finalItems)
        }

        override fun onGetLibraryRoot(session: MediaLibrarySession, browser: MediaSession.ControllerInfo, params: LibraryParams?): ListenableFuture<LibraryResult<MediaItem>> {
            //val isKnownCaller = packageValidator.isKnownCaller(browser.packageName, browser.uid)
            return Futures.immediateFuture(LibraryResult.ofItem(rootItem, params))
        }

        override fun onGetChildren(
            session: MediaLibrarySession, browser: MediaSession.ControllerInfo,
            parentId: String, page: Int, pageSize: Int, params: LibraryParams?
        ): ListenableFuture<LibraryResult<ImmutableList<MediaItem>>> {

            return Futures.immediateFuture(
                LibraryResult.ofItemList(
                    when (parentId) {
                        nodeROOT -> rootHierarchy
                        nodeTRACKLIST -> tracklist
                        nodePLAYLIST -> playlist
                        else -> ImmutableList.of()
                    },
                    LibraryParams.Builder().build()
                )
            )
        }


        override fun onSubscribe(session: MediaLibrarySession, browser: MediaSession.ControllerInfo, parentId: String, params: LibraryParams?): ListenableFuture<LibraryResult<Void>> {
            session.notifyChildrenChanged(
                parentId,
                when (parentId) {
                    nodeROOT -> 2
                    nodeTRACKLIST -> tracklist.size
                    nodePLAYLIST -> playlist.size
                    else -> 0
                },
                params
            )
            return Futures.immediateFuture(LibraryResult.ofVoid()) //super.onSubscribe(session, browser, parentId, params)
        }

        /** In order to end the service from our media browser side (UI side), we receive
         * our own custom command (which is [CUSTOM_COM_END_SERVICE]). However, the session
         * is not designed to accept foreign weird commands. So we edit the onConnect callback method
         * to make sure it accepts it.
         */
        override fun onConnect(session: MediaSession, controller: MediaSession.ControllerInfo): MediaSession.ConnectionResult {
            val superCall = super.onConnect(session, controller)

            val sessionComs = superCall.availableSessionCommands
                .buildUpon()
                .add(CUSTOM_COM_PLAY_ITEM) //Command executed when an item is requested to play
                .add(CUSTOM_COM_END_SERVICE) //This one is called to end the service manually from the UI
                .add(CUSTOM_COM_PLAYLIST_ADD) //Command used when adding items to playlist
                .add(CUSTOM_COM_PLAYLIST_REMOVE) //Command used when removing items from playlist
                .add(CUSTOM_COM_PLAYLIST_CLEAR) //Command used when clearing all items from playlist
                .add(CUSTOM_COM_SCAN_MUSIC) //Command use to execute a music scan
                .add(CUSTOM_COM_TRACKLIST_FORGET) //Used when an item is to be forgotten (swipe left)
                .add(CUSTOM_COM_SWITCH_REPEAT_MODE) //Used when switching repeat modes
                .build()

            //search command code is 50005
            for (comm in sessionComs.commands) {
                Log.e("SessionCommand", "${comm.commandCode} - ${comm.customAction}")
            }
            return MediaSession.ConnectionResult.accept(sessionComs, superCall.availablePlayerCommands)
        }

        /** Receiving some custom commands such as the command that ends the service.
         * In order to make the player accept newly customized foreign weird commands, we have
         * to edit the onConnect callback method like we did above */
        override fun onCustomCommand(
            session: MediaSession,
            controller: MediaSession.ControllerInfo,
            customCommand: SessionCommand,
            args: Bundle
        ): ListenableFuture<SessionResult> {

            /** When the controller tries to add an item to the playlist */
            if (customCommand == CUSTOM_COM_PLAY_ITEM) {

                args.getString("id")?.let { mediaid ->
                    if (args.getBoolean("playlist", false)) {
                        val i = playlist.indexOfFirst { it.mediaId == mediaid }
                        setPlaybackMode(PlayBackMode.PBM_PLAYLIST)
                        player.setMediaItems(playlist, i, 0)
                    } else {
                        val i = tracklist.indexOfFirst { it.mediaId == mediaid }
                        setPlaybackMode(PlayBackMode.PBM_TRACKLIST)
                        player.setMediaItems(tracklist, i, 0)
                    }

                    player.prepare()
                    player.play()
                    return Futures.immediateFuture(SessionResult(RESULT_SUCCESS))

                }
            }

            /** When the controller (like the app) closes fully, we need to disconnect */
            if (customCommand == CUSTOM_COM_END_SERVICE) {
                session.release()
                player.release()
                this@MusicPlayerService.stopSelf()

                return Futures.immediateFuture(SessionResult(RESULT_SUCCESS))
            }

            /** When the user changes the source folder */
            if (customCommand == CUSTOM_COM_SCAN_MUSIC) {
                queryMusic()

                return Futures.immediateFuture(SessionResult(RESULT_SUCCESS))
            }

            /** When the controller tries to add an item to the playlist */
            if (customCommand == CUSTOM_COM_PLAYLIST_ADD) {
                (args.getString("id", player.currentMediaItem?.mediaId ?: ""))?.let { mediaid ->
                    tracklist.firstOrNull { it.mediaId == mediaid }?.let { itemToAdd ->

                        itemToAdd.playlistFootprint(true)

                        playlist.add(itemToAdd)

                        serviceIOScope.launch {
                            /** notifying UI-end that the playlist has been modified */
                            //mediaSession?.notifyChildrenChanged(nodePLAYLIST, playlist.size, null)

                            //mediaSession?.notifyChildrenChanged(nodeROOT, 2, null)

                            /** Saving the playlist to memory as it is now */
                            snapshotPlaylist(playlist)
                        }

                        updateCustomLayout()

                        return Futures.immediateFuture(SessionResult(RESULT_SUCCESS))
                    }
                }
            }

            /** When the controller tries to remove an item from the playlist */
            if (customCommand == CUSTOM_COM_PLAYLIST_REMOVE) {
                (args.getString("id", player.currentMediaItem?.mediaId ?: ""))?.let { mediaid ->
                    playlist.firstOrNull { it.mediaId == mediaid }?.let { itemToRemove ->
                        playlist.remove(itemToRemove)

                        serviceIOScope.launch {
                            /** notifying UI-end that the playlist has been modified */
                            //mediaSession?.notifyChildrenChanged(nodePLAYLIST, playlist.size, null)

                            /** Saving the playlist to memory as it is now */
                            snapshotPlaylist(playlist)
                        }

                        updateCustomLayout()

                        return Futures.immediateFuture(SessionResult(RESULT_SUCCESS))
                    }
                }
            }

            /** When the controller tries to clear the playlist */
            if (customCommand == CUSTOM_COM_PLAYLIST_CLEAR) {
                playlist.clear()
                mediaSession?.notifyChildrenChanged(nodePLAYLIST, 0, null)

                /** Saving the playlist to memory as it is now */
                snapshotPlaylist(playlist)

                return Futures.immediateFuture(SessionResult(RESULT_SUCCESS))
            }

            if (customCommand == CUSTOM_COM_SWITCH_REPEAT_MODE) {
                if (player.repeatMode == Player.REPEAT_MODE_ALL) {
                    player.repeatMode = Player.REPEAT_MODE_ONE
                } else {
                    player.repeatMode = Player.REPEAT_MODE_ALL
                }

                updateCustomLayout()

                /* notify UI */
                mediaSession?.notifyChildrenChanged(nodeROOT, 2, null)
            }

                /** When the controller tries to forget an item from the tracklist */
            if (customCommand == CUSTOM_COM_TRACKLIST_FORGET) {
                args.getString("id")?.let { mediaid ->
                    tracklist.firstOrNull { it.mediaId == mediaid }?.let { itemToForget ->
                        tracklist.remove(itemToForget)
                        forgetItem(itemToForget)

                        serviceMainScope.launch {
                            /** notifying UI-end that the playlist has been modified */
                            mediaSession?.notifyChildrenChanged(nodeTRACKLIST, tracklist.size, null)
                        }

                        return Futures.immediateFuture(SessionResult(RESULT_SUCCESS))
                    }
                }
            }

            return super.onCustomCommand(session, controller, customCommand, args)
        }

        override fun onSearch(session: MediaLibrarySession, browser: MediaSession.ControllerInfo, query: String, params: LibraryParams?): ListenableFuture<LibraryResult<Void>> {
            latestSearchResults.clear()

            for (item in tracklist) {
                if (item.mediaMetadata.title?.contains(query, true) == true) {
                    latestSearchResults.add(item)
                }
            }

            session.notifySearchResultChanged(browser, query, latestSearchResults.size, params)

            return Futures.immediateFuture(LibraryResult.ofVoid())
        }

        override fun onGetSearchResult(
            session: MediaLibrarySession,
            browser: MediaSession.ControllerInfo,
            query: String,
            page: Int,
            pageSize: Int,
            params: LibraryParams?
        ): ListenableFuture<LibraryResult<ImmutableList<MediaItem>>> {

            //val fromIndex = max((page - 1) * pageSize, latestSearchResults.size - 1)
            //val toIndex = max(fromIndex + pageSize, latestSearchResults.size - 1)

            return Futures.immediateFuture(
                LibraryResult.ofItemList(
                    if (latestSearchResults.isNotEmpty()) listOf(latestSearchResults.first()) else emptyList(), //.subList(fromIndex, toIndex),
                    LibraryParams.Builder().build()
                )
            )
        }
    }

    override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaLibrarySession? {
        /* return if ("android.media.session.MediaController" == controllerInfo.packageName
            || packageValidator.isKnownCaller(controllerInfo.packageName, controllerInfo.uid)) {
            session
        } else null */
        return mediaSession
    }

    override fun onDestroy() {
        snapshotPlaylist(playlist)
        mediaSession?.run {
            player.release()
            release()
            mediaSession = null
        }
        super.onDestroy()
    }

    /** Forgets the mediaitem forever (until a hard app data reset is done) */
    fun forgetItem(mediaItem: MediaItem) {
        /* The mediaid for the MediaItem is the most unique property (since it's the uri that represents it)
           there are no two items on the device that share the same Uri, so we remember this mediaId */
        val sp = PreferenceManager.getDefaultSharedPreferences(applicationContext)
        val forgottenSet =
            sp.getStringSet("forgotten_items", mutableSetOf())?.toMutableSet() ?: mutableSetOf()

        if (!forgottenSet.contains(mediaItem.mediaId)) {
            forgottenSet.add(mediaItem.mediaId)
        }

        sp.edit().putStringSet("forgotten_items", forgottenSet).apply()
    }


    fun updateCustomLayout() {
        val isFavorite = playlist.contains(player.currentMediaItem)

        val addButton =  CommandButton.Builder()
            .setSessionCommand(CUSTOM_COM_PLAYLIST_ADD)
            .setDisplayName("Add to playlist")
            .setIconResId(R.drawable.ic_star_off)
            .setEnabled(true)
            .build()

        val removeButton = CommandButton.Builder()
            .setSessionCommand(CUSTOM_COM_PLAYLIST_REMOVE)
            .setDisplayName("Remove from playlist")
            .setIconResId(R.drawable.ic_star_on)
            .setEnabled(true)
            .build()

        val shouldEnableRepeat = player.repeatMode == Player.REPEAT_MODE_ALL

        val repeatSwitch = CommandButton.Builder()
            .setSessionCommand(CUSTOM_COM_SWITCH_REPEAT_MODE)
            .setDisplayName("Switch repeat mode")
            .setIconResId(if (shouldEnableRepeat) R.drawable.ic_repeat_off else R.drawable.ic_repeat_on)
            .setEnabled(true)
            .build()

        mediaSession?.setCustomLayout(
            listOf(
                if (isFavorite) removeButton else addButton,
                repeatSwitch
            )
        )
    }

    /** Content styling constants */
    companion object {
        private const val phone_android_auto = "com.google.android.projection.gearhead"
        private const val car_android_auto = "com.android.auto"

        fun String.isAndroidAuto(): Boolean {
            return this == phone_android_auto || this == car_android_auto
        }

        private const val TAG = "MusicService"
    }
}

[marcbaechinger]

When I declare media support for Android Auto in the manifest of the session demo app, then I see the search icon and I can search the media library as expected.

To make this work it needs 3 pieces:

• On connect the Auto controller needs to have COMMAND_CODE_LIBRARY_SEARCH available. This is the case by default.
• Callback.onSearch(...) is implemented and returns RESULT_SUCCESS and calls session.notifySearchResultChanged to notify the browser about the number of matches.
• Callback.onGetSearchresult(...) is implemented and returns the actual media items of the search result.

With this in place search worked for me on Android Auto (DHU) and Automotive OS (Emulator with API 29).

[yuroyami]

It seems that i haven't yet gotten to a workaround or a solution, the source of the problem remains a mystery. I will fiddle around with my MediaLibraryService and update this thread.

[PawelTypiak]

I have the opposite problem - using rootExtras.putBoolean(android.media.browse.SEARCH_SUPPORTED, false) should hide the search button, but unfortunately it doesn't work on the 1.2.0 and 1.2.1 version. It works on UAMP Media3 demo app but it has 1.0.0-beta01 version of Media3. Is there any solution to hide the search button?

[marcbaechinger]

I'm closing this after testing again with tot that will be released with 1.4.1.

The search icon is available on AAOS emulator for API 29 and API 33 if COMMAND_CODE_LIBRARY_SEARCH is included in the available commands in MediaSession.Callback.onConnect(MediaSession, ControllerInfo, ...) when the controller of Automotive identified with MediaSession.isAutomotiveController(controllerInfo) connects:

Disabling the search for Auto and Automotive (removing the search command from the default command set):

override fun onConnect(
    session: MediaSession,
    controller: MediaSession.ControllerInfo): MediaSession.ConnectionResult {
  if (session.isAutomotiveController(controller) ||
      session.isAutoCompanionController(controller)) {
    return MediaSession.ConnectionResult.AcceptedResultBuilder(session)
      .setAvailableSessionCommands(mediaNotificationSessionCommands)
      .build()
  }
 // all other controllers
 return MediaSession.ConnectionResult.AcceptedResultBuilder(session).build()
}