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

Commit 8946b03a authored by Michael Mikhail's avatar Michael Mikhail
Browse files

[Flexiglass] remove unnecessary code in domain layer of media.controls package 

Flag: com.android.systemui.scene_container
Bug: 436384980
Test: build
Change-Id: I425e742c8ad4e30c7d9b62373ecb67fd4fa5d153
parent de20b87b

packages/SystemUI/multivalentTests/src/com/android/systemui/media/controls/domain/interactor/MediaControlInteractorTest.kt

deleted100644 → 0
+0 −239
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2024 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.controls.domain.interactor



import android.app.PendingIntent

import android.os.Bundle

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.activityIntentHelper

import com.android.systemui.animation.ActivityTransitionAnimator

import com.android.systemui.animation.DialogTransitionAnimator

import com.android.systemui.animation.Expandable

import com.android.systemui.concurrency.fakeExecutor

import com.android.systemui.coroutines.collectLastValue

import com.android.systemui.kosmos.testScope

import com.android.systemui.media.controls.data.repository.mediaDataRepository

import com.android.systemui.media.controls.domain.pipeline.MediaDataFilterImpl

import com.android.systemui.media.controls.domain.pipeline.MediaDataProcessor

import com.android.systemui.media.controls.domain.pipeline.interactor.MediaControlInteractor

import com.android.systemui.media.controls.domain.pipeline.interactor.mediaControlInteractor

import com.android.systemui.media.controls.domain.pipeline.mediaDataFilter

import com.android.systemui.media.controls.domain.pipeline.mediaDataProcessor

import com.android.systemui.media.controls.shared.model.MediaData

import com.android.systemui.media.controls.util.mediaInstanceId

import com.android.systemui.media.mediaOutputDialogManager

import com.android.systemui.mockActivityIntentHelper

import com.android.systemui.plugins.activityStarter

import com.android.systemui.statusbar.notificationLockscreenUserManager

import com.android.systemui.statusbar.policy.keyguardStateController

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

import org.mockito.Mockito.never

import org.mockito.Mockito.verify

import org.mockito.kotlin.any

import org.mockito.kotlin.eq

import org.mockito.kotlin.mock

import org.mockito.kotlin.whenever



@SmallTest

@RunWith(AndroidJUnit4::class)

class MediaControlInteractorTest : SysuiTestCase() {



    private val kosmos = testKosmos()

    private val testScope = kosmos.testScope



    private val mediaDataFilter: MediaDataFilterImpl = with(kosmos) { mediaDataFilter }

    private val activityStarter = kosmos.activityStarter

    private val keyguardStateController = kosmos.keyguardStateController

    private val instanceId: InstanceId = kosmos.mediaInstanceId

    private val notificationLockscreenUserManager = kosmos.notificationLockscreenUserManager



    private val underTest: MediaControlInteractor =

        with(kosmos) {

            activityIntentHelper = mockActivityIntentHelper

            kosmos.mediaControlInteractor

        }



    @Test

    fun onMediaDataUpdated() =

        testScope.runTest {

            whenever(notificationLockscreenUserManager.isCurrentProfile(USER_ID)).thenReturn(true)

            whenever(notificationLockscreenUserManager.isProfileAvailable(USER_ID)).thenReturn(true)

            val controlModel by collectLastValue(underTest.mediaControl)

            var mediaData = MediaData(userId = USER_ID, instanceId = instanceId, artist = ARTIST)



            mediaDataFilter.onMediaDataLoaded(KEY, KEY, mediaData)



            assertThat(controlModel?.instanceId).isEqualTo(instanceId)

            assertThat(controlModel?.artistName).isEqualTo(ARTIST)



            mediaData = MediaData(userId = USER_ID, instanceId = instanceId, artist = ARTIST_2)



            mediaDataFilter.onMediaDataLoaded(KEY, KEY, mediaData)



            assertThat(controlModel?.instanceId).isEqualTo(instanceId)

            assertThat(controlModel?.artistName).isEqualTo(ARTIST_2)



            mediaData =

                MediaData(

                    userId = USER_ID,

                    instanceId = InstanceId.fakeInstanceId(2),

                    artist = ARTIST,

                )



            mediaDataFilter.onMediaDataLoaded(KEY, KEY, mediaData)



            assertThat(controlModel?.instanceId).isNotEqualTo(mediaData.instanceId)

            assertThat(controlModel?.artistName).isEqualTo(ARTIST_2)

        }



    @Test

    fun startSettings() {

        underTest.startSettings()



        verify(activityStarter).startActivity(any(), eq(true))

    }



    @Test

    fun startClickIntent_showOverLockscreen() {

        whenever(keyguardStateController.isShowing).thenReturn(true)

        whenever(kosmos.activityIntentHelper.wouldPendingShowOverLockscreen(any(), any()))

            .thenReturn(true)



        val clickIntent = mock<PendingIntent> { whenever(it.isActivity).thenReturn(true) }

        val expandable = mock<Expandable>()

        val activityController = mock<ActivityTransitionAnimator.Controller>()

        whenever(expandable.activityTransitionController(any())).thenReturn(activityController)



        underTest.startClickIntent(expandable, clickIntent)



        verify(activityStarter)

            .startPendingIntentMaybeDismissingKeyguard(

                eq(clickIntent),

                eq(null),

                eq(activityController),

            )

    }



    @Test

    fun startClickIntent_hideOverLockscreen() {

        whenever(notificationLockscreenUserManager.isCurrentProfile(USER_ID)).thenReturn(true)

        whenever(notificationLockscreenUserManager.isProfileAvailable(USER_ID)).thenReturn(true)

        whenever(keyguardStateController.isShowing).thenReturn(false)



        val clickIntent = mock<PendingIntent> { whenever(it.isActivity).thenReturn(true) }

        val expandable = mock<Expandable>()

        val activityController = mock<ActivityTransitionAnimator.Controller>()

        whenever(expandable.activityTransitionController(any())).thenReturn(activityController)



        val mediaData = MediaData(userId = USER_ID, instanceId = instanceId, artist = ARTIST)

        mediaDataFilter.onMediaDataLoaded(KEY, null, mediaData)

        underTest.startClickIntent(expandable, clickIntent)



        verify(activityStarter)

            .postStartActivityDismissingKeyguard(eq(clickIntent), eq(activityController))

    }



    @Test

    fun startDeviceIntent_showOverLockscreen() {

        whenever(keyguardStateController.isShowing).thenReturn(true)

        whenever(kosmos.activityIntentHelper.wouldPendingShowOverLockscreen(any(), any()))

            .thenReturn(true)



        val deviceIntent = mock<PendingIntent> { whenever(it.isActivity).thenReturn(true) }



        underTest.startDeviceIntent(deviceIntent)



        verify(deviceIntent).send(any<Bundle>())

    }



    @Test

    fun startDeviceIntent_intentNotActivity() {

        whenever(keyguardStateController.isShowing).thenReturn(true)

        whenever(kosmos.activityIntentHelper.wouldPendingShowOverLockscreen(any(), any()))

            .thenReturn(true)



        val deviceIntent = mock<PendingIntent> { whenever(it.isActivity).thenReturn(false) }



        underTest.startDeviceIntent(deviceIntent)



        verify(deviceIntent, never()).send(any<Bundle>())

    }



    @Test

    fun startDeviceIntent_hideOverLockscreen() {

        whenever(keyguardStateController.isShowing).thenReturn(false)



        val deviceIntent = mock<PendingIntent> { whenever(it.isActivity).thenReturn(true) }



        underTest.startDeviceIntent(deviceIntent)



        verify(activityStarter).postStartActivityDismissingKeyguard(eq(deviceIntent))

    }



    @Test

    fun startMediaOutputDialog() {

        val expandable = mock<Expandable>()

        val dialogTransitionController = mock<DialogTransitionAnimator.Controller>()

        whenever(expandable.dialogTransitionController(any()))

            .thenReturn(dialogTransitionController)



        underTest.startMediaOutputDialog(expandable, PACKAGE_NAME)



        verify(kosmos.mediaOutputDialogManager)

            .createAndShowWithController(

                eq(PACKAGE_NAME),

                eq(true),

                eq(dialogTransitionController),

                eq(null),

                eq(null),

            )

    }



    @Test

    fun removeMediaControl() {

        whenever(notificationLockscreenUserManager.isCurrentProfile(USER_ID)).thenReturn(true)

        whenever(notificationLockscreenUserManager.isProfileAvailable(USER_ID)).thenReturn(true)

        val listener = mock<MediaDataProcessor.Listener>()

        kosmos.mediaDataProcessor.addInternalListener(listener)



        val mediaData = MediaData(userId = USER_ID, instanceId = instanceId, artist = ARTIST)

        kosmos.mediaDataRepository.addMediaEntry(KEY, mediaData)

        kosmos.mediaDataFilter.onMediaDataLoaded(KEY, null, mediaData)



        underTest.removeMediaControl(null, instanceId, 0L)

        kosmos.fakeExecutor.advanceClockToNext()

        kosmos.fakeExecutor.runAllReady()



        verify(listener).onMediaDataRemoved(eq(KEY), eq(true))

    }



    companion object {

        private const val USER_ID = 0

        private const val KEY = "key"

        private const val PACKAGE_NAME = "com.example.app"

        private const val APP_NAME = "app"

        private const val ARTIST = "artist"

        private const val ARTIST_2 = "artist2"

    }

}

packages/SystemUI/src/com/android/systemui/media/controls/domain/pipeline/interactor/MediaCarouselInteractor.kt

+0 −22
Original line number Diff line number Diff line
@@ -21,7 +21,6 @@ import android.media.MediaDescription 
import android.media.session.MediaSession

import android.media.session.PlaybackState

import android.service.notification.StatusBarNotification

import com.android.internal.logging.InstanceId

import com.android.systemui.CoreStartable

import com.android.systemui.dagger.SysUISingleton

import com.android.systemui.dagger.qualifiers.Application
@@ -30,7 +29,6 @@ import com.android.systemui.keyguard.domain.interactor.KeyguardTransitionInterac 
import com.android.systemui.keyguard.shared.model.Edge

import com.android.systemui.keyguard.shared.model.KeyguardState.DOZING

import com.android.systemui.keyguard.shared.model.KeyguardState.GONE

import com.android.systemui.media.controls.data.repository.MediaFilterRepository

import com.android.systemui.media.controls.domain.pipeline.MediaDataCombineLatest

import com.android.systemui.media.controls.domain.pipeline.MediaDataFilterImpl

import com.android.systemui.media.controls.domain.pipeline.MediaDataManager
@@ -47,7 +45,6 @@ import java.io.PrintWriter 
import javax.inject.Inject

import kotlinx.coroutines.CoroutineScope

import kotlinx.coroutines.flow.Flow

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.SharingStarted

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.combine
@@ -92,15 +89,6 @@ constructor( 
                initialValue = false,

            )



    /** The current list for user media instances */

    val currentMedia =

        if (!MediaControlsInComposeFlag.isEnabled) {

            (mediaPipelineRepository as MediaFilterRepository).currentMedia

        } else {

            // TODO(b/397989775) remove, not used with media_controls_in_compose

            MutableStateFlow(mutableListOf())

        }



    val allowMediaOnLockscreen: StateFlow<Boolean> =

        mediaPipelineRepository.allowMediaPlayerOnLockscreen
@@ -205,10 +193,6 @@ constructor( 
        return mediaDataProcessor.dismissMediaData(key, delay, userInitiated)

    }



    fun removeMediaControl(instanceId: InstanceId, delay: Long) {

        mediaDataProcessor.dismissMediaData(instanceId, delay, userInitiated = false)

    }



    override fun onNotificationRemoved(key: String) {

        mediaDataProcessor.onNotificationRemoved(key)

    }
@@ -225,12 +209,6 @@ constructor( 


    override fun hasAnyMedia() = mediaPipelineRepository.hasAnyMedia()



    fun reorderMedia() {

        if (!MediaControlsInComposeFlag.isEnabled) {

            (mediaPipelineRepository as MediaFilterRepository).setOrderedMedia()

        }

    }



    /** Add a listener for internal events. */

    private fun addInternalListener(listener: MediaDataManager.Listener) =

        mediaDataProcessor.addInternalListener(listener)

packages/SystemUI/src/com/android/systemui/media/controls/domain/pipeline/interactor/MediaControlInteractor.kt

deleted100644 → 0
+0 −196
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2024 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.controls.domain.pipeline.interactor



import android.app.ActivityOptions

import android.app.BroadcastOptions

import android.app.PendingIntent

import android.content.Intent

import android.media.session.MediaSession

import android.provider.Settings

import android.util.Log

import com.android.internal.jank.Cuj

import com.android.internal.logging.InstanceId

import com.android.systemui.ActivityIntentHelper

import com.android.systemui.animation.DialogCuj

import com.android.systemui.animation.DialogTransitionAnimator

import com.android.systemui.animation.Expandable

import com.android.systemui.media.controls.data.repository.MediaFilterRepository

import com.android.systemui.media.controls.domain.pipeline.MediaDataProcessor

import com.android.systemui.media.controls.domain.pipeline.getNotificationActions

import com.android.systemui.media.controls.shared.MediaLogger

import com.android.systemui.media.controls.shared.model.MediaControlModel

import com.android.systemui.media.controls.shared.model.MediaData

import com.android.systemui.media.dialog.MediaOutputDialogManager

import com.android.systemui.plugins.ActivityStarter

import com.android.systemui.statusbar.NotificationLockscreenUserManager

import com.android.systemui.statusbar.policy.KeyguardStateController

import dagger.assisted.Assisted

import dagger.assisted.AssistedInject

import kotlinx.coroutines.flow.Flow

import kotlinx.coroutines.flow.distinctUntilChanged

import kotlinx.coroutines.flow.map



/** Encapsulates business logic for single media control. */

class MediaControlInteractor

@AssistedInject

constructor(

    @Assisted private val instanceId: InstanceId,

    private val repository: MediaFilterRepository,

    private val mediaDataProcessor: MediaDataProcessor,

    private val keyguardStateController: KeyguardStateController,

    private val activityStarter: ActivityStarter,

    private val activityIntentHelper: ActivityIntentHelper,

    private val lockscreenUserManager: NotificationLockscreenUserManager,

    private val mediaOutputDialogManager: MediaOutputDialogManager,

    private val mediaLogger: MediaLogger,

) {



    val mediaControl: Flow<MediaControlModel?> =

        repository.currentUserEntries

            .map { entries -> entries[instanceId]?.let { toMediaControlModel(it) } }

            .distinctUntilChanged()



    fun removeMediaControl(

        token: MediaSession.Token?,

        instanceId: InstanceId,

        delayMs: Long,

    ): Boolean {

        val dismissed =

            mediaDataProcessor.dismissMediaData(instanceId, delayMs, userInitiated = true)

        if (!dismissed) {

            Log.w(

                TAG,

                "Manager failed to dismiss media of instanceId=$instanceId, Token uid=${token?.uid}",

            )

        }

        return dismissed

    }



    private fun toMediaControlModel(data: MediaData): MediaControlModel {

        return with(data) {

            MediaControlModel(

                uid = appUid,

                packageName = packageName,

                instanceId = instanceId,

                token = token,

                appIcon = appIcon,

                clickIntent = clickIntent,

                appName = app,

                songName = song,

                artistName = artist,

                showExplicit = isExplicit,

                artwork = artwork,

                deviceData = device,

                suggestionData = suggestionData,

                semanticActionButtons = semanticActions,

                notificationActionButtons = getNotificationActions(data.actions, activityStarter),

                actionsToShowInCollapsed = actionsToShowInCompact,

                isDismissible = isClearable,

                isResume = resumption,

                resumeProgress = resumeProgress,

            )

        }

    }



    fun startSettings() {

        activityStarter.startActivity(SETTINGS_INTENT, /* dismissShade= */ true)

    }



    fun startClickIntent(expandable: Expandable, clickIntent: PendingIntent) {

        if (!launchOverLockscreen(expandable, clickIntent)) {

            activityStarter.postStartActivityDismissingKeyguard(

                clickIntent,

                expandable.activityTransitionController(Cuj.CUJ_SHADE_APP_LAUNCH_FROM_MEDIA_PLAYER),

            )

        }

    }



    fun startDeviceIntent(deviceIntent: PendingIntent) {

        if (deviceIntent.isActivity) {

            if (!launchOverLockscreen(expandable = null, deviceIntent)) {

                activityStarter.postStartActivityDismissingKeyguard(deviceIntent)

            }

        } else {

            Log.w(TAG, "Device pending intent of instanceId=$instanceId is not an activity.")

        }

    }



    private fun launchOverLockscreen(

        expandable: Expandable?,

        pendingIntent: PendingIntent,

    ): Boolean {

        val showOverLockscreen =

            keyguardStateController.isShowing &&

                activityIntentHelper.wouldPendingShowOverLockscreen(

                    pendingIntent,

                    lockscreenUserManager.currentUserId,

                )

        if (showOverLockscreen) {

            try {

                if (expandable != null) {

                    activityStarter.startPendingIntentMaybeDismissingKeyguard(

                        pendingIntent,

                        /* intentSentUiThreadCallback = */ null,

                        expandable.activityTransitionController(

                            Cuj.CUJ_SHADE_APP_LAUNCH_FROM_MEDIA_PLAYER

                        ),

                    )

                } else {

                    val options = BroadcastOptions.makeBasic()

                    options.isInteractive = true

                    options.pendingIntentBackgroundActivityStartMode =

                        ActivityOptions.MODE_BACKGROUND_ACTIVITY_START_ALLOWED

                    pendingIntent.send(options.toBundle())

                }

            } catch (e: PendingIntent.CanceledException) {

                Log.e(TAG, "pending intent of $instanceId was canceled")

            }

            return true

        }

        return false

    }



    fun startMediaOutputDialog(

        expandable: Expandable,

        packageName: String,

        token: MediaSession.Token? = null,

    ) {

        mediaOutputDialogManager.createAndShowWithController(

            packageName,

            true,

            expandable.dialogController(),

            token = token,

        )

    }



    fun logMediaControlIsBound(artistName: CharSequence, songName: CharSequence) {

        mediaLogger.logMediaControlIsBound(instanceId, artistName, songName)

    }



    private fun Expandable.dialogController(): DialogTransitionAnimator.Controller? {

        return dialogTransitionController(

            cuj =

                DialogCuj(Cuj.CUJ_SHADE_DIALOG_OPEN, MediaOutputDialogManager.INTERACTION_JANK_TAG)

        )

    }



    companion object {

        private const val TAG = "MediaControlInteractor"

        private val SETTINGS_INTENT = Intent(Settings.ACTION_MEDIA_CONTROLS_SETTINGS)

    }

}

packages/SystemUI/src/com/android/systemui/media/controls/domain/pipeline/interactor/factory/MediaControlInteractorFactory.kt

deleted100644 → 0
+0 −30
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2024 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.controls.domain.pipeline.interactor.factory



import com.android.internal.logging.InstanceId

import com.android.systemui.dagger.SysUISingleton

import com.android.systemui.media.controls.domain.pipeline.interactor.MediaControlInteractor

import dagger.assisted.AssistedFactory



/** Factory to create [MediaControlInteractor] for each media control. */

@SysUISingleton

@AssistedFactory

interface MediaControlInteractorFactory {



    fun create(instanceId: InstanceId): MediaControlInteractor

}

packages/SystemUI/src/com/android/systemui/media/controls/shared/model/MediaControlModel.kt

deleted100644 → 0
+0 −53
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2024 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.controls.shared.model



import android.app.Notification

import android.app.PendingIntent

import android.graphics.drawable.Icon

import android.media.session.MediaSession

import android.os.Process

import com.android.internal.logging.InstanceId



data class MediaControlModel(

    val uid: Int = Process.INVALID_UID,

    val packageName: String,

    val instanceId: InstanceId,

    val token: MediaSession.Token?,

    val appIcon: Icon?,

    val clickIntent: PendingIntent?,

    val appName: String?,

    val songName: CharSequence?,

    val artistName: CharSequence?,

    val showExplicit: Boolean,

    val artwork: Icon?,

    val deviceData: MediaDeviceData?,

    val suggestionData: SuggestionData?,

    /** [MediaButton] contains [MediaAction] objects which represent specific buttons in the UI */

    val semanticActionButtons: MediaButton?,

    val notificationActionButtons: List<MediaAction>,

    /**

     * List of [notificationActionButtons] indices shown on smaller version of media player. Check

     * [Notification.MediaStyle.setShowActionsInCompactView].

     */

    val actionsToShowInCollapsed: List<Int>,

    val isDismissible: Boolean,

    /** Whether player is in resumption state. */

    val isResume: Boolean,

    /** Track seek bar progress (0 - 1) when [isResume] is true. */

    val resumeProgress: Double?,

)