Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ae7783a2 authored by Michael Mikhail's avatar Michael Mikhail
Browse files

[remedia] add new media repository for remedia code.

This CL forks implementation of media repository. It also adds an abstract class that has common implementation. It adds an interface that should be consumed by MediaInteractor.

Flag: com.android.systemui.media_controls_in_compose
Bug: 397989775
Test: build.
Change-Id: I718aa1e63f1cfa51ad0d545d99cbce34af81ce64
parent a3faf951
Loading
Loading
Loading
Loading
+4 −4
Original line number Diff line number Diff line
@@ -120,7 +120,7 @@ class KeyguardClockInteractorTest : SysuiTestCase() {
            val value by collectLastValue(underTest.clockSize)
            kosmos.shadeRepository.setShadeLayoutWide(false)
            val userMedia = MediaData().copy(active = true)
            kosmos.mediaFilterRepository.addSelectedUserMediaEntry(userMedia)
            kosmos.mediaFilterRepository.addCurrentUserMediaEntry(userMedia)

            assertThat(value).isEqualTo(ClockSize.SMALL)
        }
@@ -132,7 +132,7 @@ class KeyguardClockInteractorTest : SysuiTestCase() {
            val value by collectLastValue(underTest.clockSize)
            val userMedia = MediaData().copy(active = true)
            kosmos.shadeRepository.setShadeLayoutWide(true)
            kosmos.mediaFilterRepository.addSelectedUserMediaEntry(userMedia)
            kosmos.mediaFilterRepository.addCurrentUserMediaEntry(userMedia)
            kosmos.keyguardRepository.setIsDozing(false)

            assertThat(value).isEqualTo(ClockSize.SMALL)
@@ -156,7 +156,7 @@ class KeyguardClockInteractorTest : SysuiTestCase() {
            val value by collectLastValue(underTest.clockSize)
            val userMedia = MediaData().copy(active = true)
            kosmos.shadeRepository.setShadeLayoutWide(true)
            kosmos.mediaFilterRepository.addSelectedUserMediaEntry(userMedia)
            kosmos.mediaFilterRepository.addCurrentUserMediaEntry(userMedia)
            kosmos.keyguardRepository.setIsDozing(true)

            assertThat(value).isEqualTo(ClockSize.LARGE)
@@ -170,7 +170,7 @@ class KeyguardClockInteractorTest : SysuiTestCase() {
            val userMedia = MediaData().copy(active = true)
            kosmos.fakeKeyguardClockRepository.setSelectedClockSize(ClockSizeSetting.SMALL)
            kosmos.shadeRepository.setShadeLayoutWide(true)
            kosmos.mediaFilterRepository.addSelectedUserMediaEntry(userMedia)
            kosmos.mediaFilterRepository.addCurrentUserMediaEntry(userMedia)
            kosmos.keyguardRepository.setIsDozing(true)

            assertThat(value).isEqualTo(ClockSize.SMALL)
+2 −2
Original line number Diff line number Diff line
@@ -58,7 +58,7 @@ class KeyguardMediaViewModelTest : SysuiTestCase() {
        kosmos.runTest {
            val userMedia = MediaData(active = true)

            mediaFilterRepository.addSelectedUserMediaEntry(userMedia)
            mediaFilterRepository.addCurrentUserMediaEntry(userMedia)
            keyguardRepository.setIsDozing(true)

            assertThat(underTest.isMediaVisible).isFalse()
@@ -69,7 +69,7 @@ class KeyguardMediaViewModelTest : SysuiTestCase() {
        kosmos.runTest {
            val userMedia = MediaData(active = true)

            mediaFilterRepository.addSelectedUserMediaEntry(userMedia)
            mediaFilterRepository.addCurrentUserMediaEntry(userMedia)
            keyguardRepository.setIsDozing(false)

            assertThat(underTest.isMediaVisible).isTrue()
+36 −53
Original line number Diff line number Diff line
@@ -41,88 +41,88 @@ class MediaFilterRepositoryTest : SysuiTestCase() {
    private val underTest: MediaFilterRepository = with(kosmos) { mediaFilterRepository }

    @Test
    fun addSelectedUserMediaEntry_activeThenInactivate() =
    fun addCurrentUserMediaEntry_activeThenInactivate() =
        testScope.runTest {
            val selectedUserEntries by collectLastValue(underTest.selectedUserEntries)
            val currentUserEntries by collectLastValue(underTest.currentUserEntries)

            val instanceId = InstanceId.fakeInstanceId(123)
            val userMedia = MediaData().copy(active = true, instanceId = instanceId)

            underTest.addSelectedUserMediaEntry(userMedia)
            underTest.addCurrentUserMediaEntry(userMedia)

            assertThat(selectedUserEntries?.get(instanceId)).isEqualTo(userMedia)
            assertThat(currentUserEntries?.get(instanceId)).isEqualTo(userMedia)
            assertThat(underTest.hasActiveMedia()).isTrue()
            assertThat(underTest.hasAnyMedia()).isTrue()

            underTest.addSelectedUserMediaEntry(userMedia.copy(active = false))
            underTest.addCurrentUserMediaEntry(userMedia.copy(active = false))

            assertThat(selectedUserEntries?.get(instanceId)).isNotEqualTo(userMedia)
            assertThat(selectedUserEntries?.get(instanceId)?.active).isFalse()
            assertThat(currentUserEntries?.get(instanceId)).isNotEqualTo(userMedia)
            assertThat(currentUserEntries?.get(instanceId)?.active).isFalse()
            assertThat(underTest.hasActiveMedia()).isFalse()
            assertThat(underTest.hasAnyMedia()).isTrue()
        }

    @Test
    fun addSelectedUserMediaEntry_thenRemove_returnsBoolean() =
    fun addCurrentUserMediaEntry_thenRemove_returnsBoolean() =
        testScope.runTest {
            val selectedUserEntries by collectLastValue(underTest.selectedUserEntries)
            val currentUserEntries by collectLastValue(underTest.currentUserEntries)

            val instanceId = InstanceId.fakeInstanceId(123)
            val userMedia = MediaData().copy(instanceId = instanceId)

            underTest.addSelectedUserMediaEntry(userMedia)
            underTest.addCurrentUserMediaEntry(userMedia)

            assertThat(selectedUserEntries?.get(instanceId)).isEqualTo(userMedia)
            assertThat(currentUserEntries?.get(instanceId)).isEqualTo(userMedia)
            assertThat(underTest.hasActiveMedia()).isTrue()
            assertThat(underTest.hasAnyMedia()).isTrue()

            assertThat(underTest.removeSelectedUserMediaEntry(instanceId, userMedia)).isTrue()
            assertThat(underTest.removeCurrentUserMediaEntry(instanceId, userMedia)).isTrue()
            assertThat(underTest.hasActiveMedia()).isFalse()
            assertThat(underTest.hasAnyMedia()).isFalse()
        }

    @Test
    fun addSelectedUserMediaEntry_thenRemove_returnsValue() =
    fun addCurrentUserMediaEntry_thenRemove_returnsValue() =
        testScope.runTest {
            val selectedUserEntries by collectLastValue(underTest.selectedUserEntries)
            val currentUserEntries by collectLastValue(underTest.currentUserEntries)

            val instanceId = InstanceId.fakeInstanceId(123)
            val userMedia = MediaData().copy(instanceId = instanceId)

            underTest.addSelectedUserMediaEntry(userMedia)
            underTest.addCurrentUserMediaEntry(userMedia)

            assertThat(selectedUserEntries?.get(instanceId)).isEqualTo(userMedia)
            assertThat(currentUserEntries?.get(instanceId)).isEqualTo(userMedia)

            assertThat(underTest.removeSelectedUserMediaEntry(instanceId)).isEqualTo(userMedia)
            assertThat(underTest.removeCurrentUserMediaEntry(instanceId)).isEqualTo(userMedia)
        }

    @Test
    fun addAllUserMediaEntry_activeThenInactivate() =
    fun addMediaEntry_activeThenInactivate() =
        testScope.runTest {
            val allUserEntries by collectLastValue(underTest.allUserEntries)
            val allMediaEntries by collectLastValue(underTest.allMediaEntries)

            val userMedia = MediaData().copy(active = true)

            underTest.addMediaEntry(KEY, userMedia)

            assertThat(allUserEntries?.get(KEY)).isEqualTo(userMedia)
            assertThat(allMediaEntries?.get(KEY)).isEqualTo(userMedia)

            underTest.addMediaEntry(KEY, userMedia.copy(active = false))

            assertThat(allUserEntries?.get(KEY)).isNotEqualTo(userMedia)
            assertThat(allUserEntries?.get(KEY)?.active).isFalse()
            assertThat(allMediaEntries?.get(KEY)).isNotEqualTo(userMedia)
            assertThat(allMediaEntries?.get(KEY)?.active).isFalse()
        }

    @Test
    fun addAllUserMediaEntry_thenRemove_returnsValue() =
    fun addMediaEntry_thenRemove_returnsValue() =
        testScope.runTest {
            val allUserEntries by collectLastValue(underTest.allUserEntries)
            val allMediaEntries by collectLastValue(underTest.allMediaEntries)

            val userMedia = MediaData()

            underTest.addMediaEntry(KEY, userMedia)

            assertThat(allUserEntries?.get(KEY)).isEqualTo(userMedia)
            assertThat(allMediaEntries?.get(KEY)).isEqualTo(userMedia)

            assertThat(underTest.removeMediaEntry(KEY)).isEqualTo(userMedia)
        }
@@ -136,17 +136,9 @@ class MediaFilterRepositoryTest : SysuiTestCase() {
            val playingData = createMediaData("app1", true, LOCAL, false, playingInstanceId)
            val remoteData = createMediaData("app2", true, REMOTE, false, remoteInstanceId)

            underTest.addSelectedUserMediaEntry(playingData)
            underTest.addMediaDataLoadingState(
                MediaDataLoadingModel.Loaded(playingInstanceId),
                false,
            )
            underTest.addCurrentUserMediaEntry(playingData)

            underTest.addSelectedUserMediaEntry(remoteData)
            underTest.addMediaDataLoadingState(
                MediaDataLoadingModel.Loaded(remoteInstanceId),
                false,
            )
            underTest.addCurrentUserMediaEntry(remoteData)

            assertThat(currentMedia?.size).isEqualTo(2)
            assertThat(currentMedia)
@@ -166,10 +158,8 @@ class MediaFilterRepositoryTest : SysuiTestCase() {
            var playingData1 = createMediaData("app1", true, LOCAL, false, playingInstanceId1)
            var playingData2 = createMediaData("app2", false, LOCAL, false, playingInstanceId2)

            underTest.addSelectedUserMediaEntry(playingData1)
            underTest.addMediaDataLoadingState(MediaDataLoadingModel.Loaded(playingInstanceId1))
            underTest.addSelectedUserMediaEntry(playingData2)
            underTest.addMediaDataLoadingState(MediaDataLoadingModel.Loaded(playingInstanceId2))
            underTest.addCurrentUserMediaEntry(playingData1)
            underTest.addCurrentUserMediaEntry(playingData2)

            assertThat(currentMedia?.size).isEqualTo(2)
            assertThat(currentMedia)
@@ -182,10 +172,8 @@ class MediaFilterRepositoryTest : SysuiTestCase() {
            playingData1 = createMediaData("app1", false, LOCAL, false, playingInstanceId1)
            playingData2 = createMediaData("app2", true, LOCAL, false, playingInstanceId2)

            underTest.addSelectedUserMediaEntry(playingData1)
            underTest.addMediaDataLoadingState(MediaDataLoadingModel.Loaded(playingInstanceId1))
            underTest.addSelectedUserMediaEntry(playingData2)
            underTest.addMediaDataLoadingState(MediaDataLoadingModel.Loaded(playingInstanceId2))
            underTest.addCurrentUserMediaEntry(playingData1)
            underTest.addCurrentUserMediaEntry(playingData2)

            assertThat(currentMedia?.size).isEqualTo(2)
            assertThat(currentMedia)
@@ -221,20 +209,15 @@ class MediaFilterRepositoryTest : SysuiTestCase() {
            val stoppedAndRemoteData = createMediaData("app4", false, REMOTE, false, instanceId4)
            val canResumeData = createMediaData("app5", false, LOCAL, true, instanceId5)

            underTest.addSelectedUserMediaEntry(stoppedAndLocalData)
            underTest.addMediaDataLoadingState(MediaDataLoadingModel.Loaded(instanceId3))
            underTest.addCurrentUserMediaEntry(stoppedAndLocalData)

            underTest.addSelectedUserMediaEntry(stoppedAndRemoteData)
            underTest.addMediaDataLoadingState(MediaDataLoadingModel.Loaded(instanceId4))
            underTest.addCurrentUserMediaEntry(stoppedAndRemoteData)

            underTest.addSelectedUserMediaEntry(canResumeData)
            underTest.addMediaDataLoadingState(MediaDataLoadingModel.Loaded(instanceId5))
            underTest.addCurrentUserMediaEntry(canResumeData)

            underTest.addSelectedUserMediaEntry(playingAndLocalData)
            underTest.addMediaDataLoadingState(MediaDataLoadingModel.Loaded(instanceId1))
            underTest.addCurrentUserMediaEntry(playingAndLocalData)

            underTest.addSelectedUserMediaEntry(playingAndRemoteData)
            underTest.addMediaDataLoadingState(MediaDataLoadingModel.Loaded(instanceId2))
            underTest.addCurrentUserMediaEntry(playingAndRemoteData)

            underTest.setOrderedMedia()

+4 −9
Original line number Diff line number Diff line
@@ -26,7 +26,6 @@ import com.android.systemui.media.controls.data.repository.mediaFilterRepository
import com.android.systemui.media.controls.domain.pipeline.interactor.MediaCarouselInteractor
import com.android.systemui.media.controls.domain.pipeline.interactor.mediaCarouselInteractor
import com.android.systemui.media.controls.shared.model.MediaData
import com.android.systemui.media.controls.shared.model.MediaDataLoadingModel
import com.android.systemui.testKosmos
import com.google.common.truth.Truth.assertThat
import kotlinx.coroutines.test.runTest
@@ -58,13 +57,13 @@ class MediaCarouselInteractorTest : SysuiTestCase() {

            val userMedia = MediaData(active = true)

            mediaFilterRepository.addSelectedUserMediaEntry(userMedia)
            mediaFilterRepository.addCurrentUserMediaEntry(userMedia)

            assertThat(hasActiveMedia).isTrue()
            assertThat(underTest.hasActiveMedia()).isTrue()
            assertThat(underTest.hasAnyMedia()).isTrue()

            mediaFilterRepository.addSelectedUserMediaEntry(userMedia.copy(active = false))
            mediaFilterRepository.addCurrentUserMediaEntry(userMedia.copy(active = false))

            assertThat(hasActiveMedia).isFalse()
            assertThat(underTest.hasActiveMedia()).isFalse()
@@ -79,18 +78,14 @@ class MediaCarouselInteractorTest : SysuiTestCase() {
            val userMedia = MediaData(active = false)
            val instanceId = userMedia.instanceId

            mediaFilterRepository.addSelectedUserMediaEntry(userMedia)
            mediaFilterRepository.addMediaDataLoadingState(MediaDataLoadingModel.Loaded(instanceId))
            mediaFilterRepository.addCurrentUserMediaEntry(userMedia)

            assertThat(hasActiveMedia).isFalse()
            assertThat(underTest.hasActiveMedia()).isFalse()
            assertThat(underTest.hasAnyMedia()).isTrue()

            assertThat(mediaFilterRepository.removeSelectedUserMediaEntry(instanceId, userMedia))
            assertThat(mediaFilterRepository.removeCurrentUserMediaEntry(instanceId, userMedia))
                .isTrue()
            mediaFilterRepository.addMediaDataLoadingState(
                MediaDataLoadingModel.Removed(instanceId)
            )

            assertThat(hasActiveMedia).isFalse()
            assertThat(underTest.hasActiveMedia()).isFalse()
+276 −0
Original line number Diff line number Diff line
/*
 * Copyright (C) 2025 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.systemui.media.remedia.data.repository

import android.media.session.MediaController
import android.media.session.MediaSession
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.filters.SmallTest
import com.android.internal.logging.InstanceId
import com.android.systemui.SysuiTestCase
import com.android.systemui.coroutines.collectLastValue
import com.android.systemui.kosmos.testScope
import com.android.systemui.media.controls.shared.model.MediaData
import com.android.systemui.media.remedia.data.model.MediaDataModel
import com.android.systemui.testKosmos
import com.google.common.truth.Truth.assertThat
import kotlinx.coroutines.test.runTest
import org.junit.Test
import org.junit.runner.RunWith

@SmallTest
@RunWith(AndroidJUnit4::class)
class MediaRepositoryTest : SysuiTestCase() {

    private val kosmos = testKosmos()
    private val testScope = kosmos.testScope
    private val session = MediaSession(context, "MediaRepositoryTestSession")

    private val underTest: MediaRepositoryImpl = kosmos.mediaRepository

    @Test
    fun addCurrentUserMediaEntry_activeThenInactivate() =
        testScope.runTest {
            val currentUserEntries by collectLastValue(underTest.currentUserEntries)

            val instanceId = InstanceId.fakeInstanceId(123)
            val userMedia =
                MediaData()
                    .copy(token = session.sessionToken, active = true, instanceId = instanceId)

            underTest.addCurrentUserMediaEntry(userMedia)

            assertThat(currentUserEntries?.get(instanceId)).isEqualTo(userMedia)

            underTest.addCurrentUserMediaEntry(userMedia.copy(active = false))

            assertThat(currentUserEntries?.get(instanceId)).isNotEqualTo(userMedia)
            assertThat(currentUserEntries?.get(instanceId)?.active).isFalse()
        }

    @Test
    fun addCurrentUserMediaEntry_thenRemove_returnsBoolean() =
        testScope.runTest {
            val currentUserEntries by collectLastValue(underTest.currentUserEntries)

            val instanceId = InstanceId.fakeInstanceId(123)
            val userMedia = MediaData().copy(token = session.sessionToken, instanceId = instanceId)

            underTest.addCurrentUserMediaEntry(userMedia)

            assertThat(currentUserEntries?.get(instanceId)).isEqualTo(userMedia)
            assertThat(underTest.removeCurrentUserMediaEntry(instanceId, userMedia)).isTrue()
        }

    @Test
    fun addCurrentUserMediaEntry_thenRemove_returnsValue() =
        testScope.runTest {
            val currentUserEntries by collectLastValue(underTest.currentUserEntries)

            val instanceId = InstanceId.fakeInstanceId(123)
            val userMedia = MediaData().copy(token = session.sessionToken, instanceId = instanceId)

            underTest.addCurrentUserMediaEntry(userMedia)

            assertThat(currentUserEntries?.get(instanceId)).isEqualTo(userMedia)

            assertThat(underTest.removeCurrentUserMediaEntry(instanceId)).isEqualTo(userMedia)
        }

    @Test
    fun addMediaEntry_activeThenInactivate() =
        testScope.runTest {
            val allMediaEntries by collectLastValue(underTest.allMediaEntries)

            val userMedia = MediaData().copy(active = true)

            underTest.addMediaEntry(KEY, userMedia)

            assertThat(allMediaEntries?.get(KEY)).isEqualTo(userMedia)

            underTest.addMediaEntry(KEY, userMedia.copy(active = false))

            assertThat(allMediaEntries?.get(KEY)).isNotEqualTo(userMedia)
            assertThat(allMediaEntries?.get(KEY)?.active).isFalse()
        }

    @Test
    fun addMediaEntry_thenRemove_returnsValue() =
        testScope.runTest {
            val allMediaEntries by collectLastValue(underTest.allMediaEntries)

            val userMedia = MediaData()

            underTest.addMediaEntry(KEY, userMedia)

            assertThat(allMediaEntries?.get(KEY)).isEqualTo(userMedia)

            assertThat(underTest.removeMediaEntry(KEY)).isEqualTo(userMedia)
        }

    @Test
    fun addMediaControlPlayingThenRemote() =
        testScope.runTest {
            val currentMedia by collectLastValue(underTest.currentMedia)
            val playingInstanceId = InstanceId.fakeInstanceId(123)
            val remoteInstanceId = InstanceId.fakeInstanceId(321)
            val playingData = createMediaData("app1", true, LOCAL, false, playingInstanceId)
            val remoteData = createMediaData("app2", true, REMOTE, false, remoteInstanceId)

            underTest.addCurrentUserMediaEntry(playingData)

            underTest.addCurrentUserMediaEntry(remoteData)

            assertThat(currentMedia?.size).isEqualTo(2)
            assertThat(currentMedia)
                .containsExactly(
                    playingData.toDataModel(currentMedia!![0].controller),
                    remoteData.toDataModel(currentMedia!![1].controller),
                )
                .inOrder()
        }

    @Test
    fun switchMediaControlsPlaying() =
        testScope.runTest {
            val currentMedia by collectLastValue(underTest.currentMedia)
            val playingInstanceId1 = InstanceId.fakeInstanceId(123)
            val playingInstanceId2 = InstanceId.fakeInstanceId(321)
            var playingData1 = createMediaData("app1", true, LOCAL, false, playingInstanceId1)
            var playingData2 = createMediaData("app2", false, LOCAL, false, playingInstanceId2)

            underTest.addCurrentUserMediaEntry(playingData1)
            underTest.addCurrentUserMediaEntry(playingData2)

            assertThat(currentMedia?.size).isEqualTo(2)
            assertThat(currentMedia)
                .containsExactly(
                    playingData1.toDataModel(currentMedia!![0].controller),
                    playingData2.toDataModel(currentMedia!![1].controller),
                )
                .inOrder()

            playingData1 = createMediaData("app1", false, LOCAL, false, playingInstanceId1)
            playingData2 = createMediaData("app2", true, LOCAL, false, playingInstanceId2)

            underTest.addCurrentUserMediaEntry(playingData1)
            underTest.addCurrentUserMediaEntry(playingData2)

            assertThat(currentMedia?.size).isEqualTo(2)
            assertThat(currentMedia)
                .containsExactly(
                    playingData1.toDataModel(currentMedia!![0].controller),
                    playingData2.toDataModel(currentMedia!![1].controller),
                )
                .inOrder()

            underTest.reorderMedia()

            assertThat(currentMedia?.size).isEqualTo(2)
            assertThat(currentMedia)
                .containsExactly(
                    playingData2.toDataModel(currentMedia!![0].controller),
                    playingData1.toDataModel(currentMedia!![1].controller),
                )
                .inOrder()
        }

    @Test
    fun fullOrderTest() =
        testScope.runTest {
            val currentMedia by collectLastValue(underTest.currentMedia)
            val instanceId1 = InstanceId.fakeInstanceId(123)
            val instanceId2 = InstanceId.fakeInstanceId(456)
            val instanceId3 = InstanceId.fakeInstanceId(321)
            val instanceId4 = InstanceId.fakeInstanceId(654)
            val instanceId5 = InstanceId.fakeInstanceId(124)
            val playingAndLocalData = createMediaData("app1", true, LOCAL, false, instanceId1)
            val playingAndRemoteData = createMediaData("app2", true, REMOTE, false, instanceId2)
            val stoppedAndLocalData = createMediaData("app3", false, LOCAL, false, instanceId3)
            val stoppedAndRemoteData = createMediaData("app4", false, REMOTE, false, instanceId4)
            val canResumeData = createMediaData("app5", false, LOCAL, true, instanceId5)

            underTest.addCurrentUserMediaEntry(stoppedAndLocalData)

            underTest.addCurrentUserMediaEntry(stoppedAndRemoteData)

            underTest.addCurrentUserMediaEntry(canResumeData)

            underTest.addCurrentUserMediaEntry(playingAndLocalData)

            underTest.addCurrentUserMediaEntry(playingAndRemoteData)

            underTest.reorderMedia()

            assertThat(currentMedia?.size).isEqualTo(5)
            assertThat(currentMedia)
                .containsExactly(
                    playingAndLocalData.toDataModel(currentMedia!![0].controller),
                    playingAndRemoteData.toDataModel(currentMedia!![1].controller),
                    stoppedAndRemoteData.toDataModel(currentMedia!![2].controller),
                    stoppedAndLocalData.toDataModel(currentMedia!![3].controller),
                    canResumeData.toDataModel(currentMedia!![4].controller),
                )
                .inOrder()
        }

    private fun createMediaData(
        app: String,
        playing: Boolean,
        playbackLocation: Int,
        isResume: Boolean,
        instanceId: InstanceId,
    ): MediaData {
        return MediaData(
            token = session.sessionToken,
            playbackLocation = playbackLocation,
            resumption = isResume,
            notificationKey = "key: $app",
            isPlaying = playing,
            instanceId = instanceId,
        )
    }

    private fun MediaData.toDataModel(mediaController: MediaController): MediaDataModel {
        return MediaDataModel(
            instanceId = instanceId,
            appUid = appUid,
            packageName = packageName,
            appName = app.toString(),
            appIcon = null,
            background = null,
            title = song.toString(),
            subtitle = artist.toString(),
            notificationActions = actions,
            playbackStateActions = semanticActions,
            outputDevice = device,
            clickIntent = clickIntent,
            controller = mediaController,
            canBeDismissed = isClearable,
            isActive = active,
            isResume = resumption,
            resumeAction = resumeAction,
            isExplicit = isExplicit,
        )
    }

    companion object {
        private const val LOCAL = MediaData.PLAYBACK_LOCAL
        private const val REMOTE = MediaData.PLAYBACK_CAST_LOCAL
        private const val KEY = "KEY"
    }
}
Loading