Enable testOnSmartspaceMediaDataLoaded

import java.io.IOException

import java.io.PrintWriter

import java.util.concurrent.Executor

import java.util.concurrent.Executors

import javax.inject.Inject

// URI fields to try loading album art from

class MediaDataManager(

    private val context: Context,

    @Background private val backgroundExecutor: Executor,

    @Main private val uiExecutor: Executor,

    @Main private val foregroundExecutor: DelayableExecutor,

    private val mediaControllerFactory: MediaControllerFactory,

    private val broadcastDispatcher: BroadcastDispatcher,

    private val systemClock: SystemClock,

    private val tunerService: TunerService,

    private val mediaFlags: MediaFlags,

    private val logger: MediaUiEventLogger

    private val logger: MediaUiEventLogger,

    private val smartspaceManager: SmartspaceManager,

) : Dumpable, BcSmartspaceDataPlugin.SmartspaceTargetListener {

    companion object {

    constructor(

        context: Context,

        @Background backgroundExecutor: Executor,

        @Main uiExecutor: Executor,

        @Main foregroundExecutor: DelayableExecutor,

        mediaControllerFactory: MediaControllerFactory,

        dumpManager: DumpManager,

        clock: SystemClock,

        tunerService: TunerService,

        mediaFlags: MediaFlags,

        logger: MediaUiEventLogger

        logger: MediaUiEventLogger,

        smartspaceManager: SmartspaceManager,

    ) : this(

        context,

        backgroundExecutor,

        uiExecutor,

        foregroundExecutor,

        mediaControllerFactory,

        broadcastDispatcher,

        clock,

        tunerService,

        mediaFlags,

        logger

        logger,

        smartspaceManager,

    )

    private val appChangeReceiver =

        // Register for Smartspace data updates.

        smartspaceMediaDataProvider.registerListener(this)

        val smartspaceManager: SmartspaceManager =

            context.getSystemService(SmartspaceManager::class.java)

        smartspaceSession =

            smartspaceManager.createSmartspaceSession(

                SmartspaceConfig.Builder(context, SMARTSPACE_UI_SURFACE_LABEL).build()

            )

        smartspaceSession?.let {

            it.addOnTargetsAvailableListener(

                // Use a new thread listening to Smartspace updates instead of using the existing

                // backgroundExecutor. SmartspaceSession has scheduled routine updates which can be

                // unpredictable on test simulators, using the backgroundExecutor makes it's hard to

                // test the threads numbers.

                // Switch to use backgroundExecutor when SmartspaceSession has a good way to be

                // mocked.

                Executors.newCachedThreadPool(),

                // Use a main uiExecutor thread listening to Smartspace updates instead of using

                // the existing background executor.

                // SmartspaceSession has scheduled routine updates which can be unpredictable on

                // test simulators, using the backgroundExecutor makes it's hard to test the threads

                // numbers.

                uiExecutor,

                SmartspaceSession.OnTargetsAvailableListener { targets ->

                    smartspaceMediaDataProvider.onTargetsAvailable(targets)

                }

import android.app.Notification.MediaStyle

import android.app.PendingIntent

import android.app.smartspace.SmartspaceAction

import android.app.smartspace.SmartspaceConfig

import android.app.smartspace.SmartspaceManager

import android.app.smartspace.SmartspaceTarget

import android.content.Intent

import android.graphics.Bitmap

    lateinit var metadataBuilder: MediaMetadata.Builder

    lateinit var backgroundExecutor: FakeExecutor

    lateinit var foregroundExecutor: FakeExecutor

    lateinit var uiExecutor: FakeExecutor

    @Mock lateinit var dumpManager: DumpManager

    @Mock lateinit var broadcastDispatcher: BroadcastDispatcher

    @Mock lateinit var mediaTimeoutListener: MediaTimeoutListener

    @Mock lateinit var listener: MediaDataManager.Listener

    @Mock lateinit var pendingIntent: PendingIntent

    @Mock lateinit var activityStarter: ActivityStarter

    @Mock lateinit var smartspaceManager: SmartspaceManager

    lateinit var smartspaceMediaDataProvider: SmartspaceMediaDataProvider

    @Mock lateinit var mediaSmartspaceTarget: SmartspaceTarget

    @Mock private lateinit var mediaRecommendationItem: SmartspaceAction

    @Mock private lateinit var tunerService: TunerService

    @Captor lateinit var tunableCaptor: ArgumentCaptor<TunerService.Tunable>

    @Captor lateinit var callbackCaptor: ArgumentCaptor<(String, PlaybackState) -> Unit>

    @Captor lateinit var smartSpaceConfigBuilderCaptor: ArgumentCaptor<SmartspaceConfig>

    private val instanceIdSequence = InstanceIdSequenceFake(1 shl 20)

    fun setup() {

        foregroundExecutor = FakeExecutor(clock)

        backgroundExecutor = FakeExecutor(clock)

        uiExecutor = FakeExecutor(clock)

        smartspaceMediaDataProvider = SmartspaceMediaDataProvider()

        Settings.Secure.putInt(

            context.contentResolver,

            MediaDataManager(

                context = context,

                backgroundExecutor = backgroundExecutor,

                uiExecutor = uiExecutor,

                foregroundExecutor = foregroundExecutor,

                mediaControllerFactory = mediaControllerFactory,

                broadcastDispatcher = broadcastDispatcher,

                systemClock = clock,

                tunerService = tunerService,

                mediaFlags = mediaFlags,

                logger = logger

                logger = logger,

                smartspaceManager = smartspaceManager,

            )

        verify(tunerService)

            .addTunable(capture(tunableCaptor), eq(Settings.Secure.MEDIA_CONTROLS_RECOMMENDATION))

                putString(MediaMetadata.METADATA_KEY_ARTIST, SESSION_ARTIST)

                putString(MediaMetadata.METADATA_KEY_TITLE, SESSION_TITLE)

            }

        verify(smartspaceManager).createSmartspaceSession(capture(smartSpaceConfigBuilderCaptor))

        whenever(mediaControllerFactory.create(eq(session.sessionToken))).thenReturn(controller)

        whenever(controller.transportControls).thenReturn(transportControls)

        whenever(controller.playbackInfo).thenReturn(playbackInfo)

            .onSmartspaceMediaDataLoaded(anyObject(), anyObject(), anyBoolean())

    }

    @Ignore("b/233283726")

    @Test

    fun testOnSmartspaceMediaDataLoaded_hasNoneMediaTarget_callsRemoveListener() {

        smartspaceMediaDataProvider.onTargetsAvailable(listOf(mediaSmartspaceTarget))

        verify(logger).getNewInstanceId()

        smartspaceMediaDataProvider.onTargetsAvailable(listOf())

        foregroundExecutor.advanceClockToLast()

        foregroundExecutor.runAllReady()

        uiExecutor.advanceClockToLast()

        uiExecutor.runAllReady()

        verify(listener).onSmartspaceMediaDataRemoved(eq(KEY_MEDIA_SMARTSPACE), eq(false))

        verifyNoMoreInteractions(logger)