From 61aa866570b02e2965bf58633524372282f2be8a Mon Sep 17 00:00:00 2001 From: Caitlin Cassidy Date: Fri, 15 Apr 2022 20:07:49 +0000 Subject: [PATCH 1/2] [Media] Add logging to MediaMuteAwaitConnectionManager. Fixes: 219768211 Test: MediaMuteAwaitConnectionManagerTest Test: manually dumped log Change-Id: I42f5d4b1005f9b81d309b1fe03ee9c568b389c21 --- .../systemui/log/dagger/LogModule.java | 12 +++++ .../log/dagger/MediaMuteAwaitLog.java | 36 +++++++++++++ .../MediaMuteAwaitConnectionManager.kt | 16 ++++-- .../MediaMuteAwaitConnectionManagerFactory.kt | 3 +- .../media/muteawait/MediaMuteAwaitLogger.kt | 51 +++++++++++++++++++ .../MediaMuteAwaitConnectionManagerTest.kt | 38 +++++++++++++- 6 files changed, 149 insertions(+), 7 deletions(-) create mode 100644 packages/SystemUI/src/com/android/systemui/log/dagger/MediaMuteAwaitLog.java create mode 100644 packages/SystemUI/src/com/android/systemui/media/muteawait/MediaMuteAwaitLogger.kt diff --git a/packages/SystemUI/src/com/android/systemui/log/dagger/LogModule.java b/packages/SystemUI/src/com/android/systemui/log/dagger/LogModule.java index ae7a671f3d54c..96862af59817d 100644 --- a/packages/SystemUI/src/com/android/systemui/log/dagger/LogModule.java +++ b/packages/SystemUI/src/com/android/systemui/log/dagger/LogModule.java @@ -176,6 +176,18 @@ public class LogModule { return factory.create("MediaTttReceiver", 20); } + + /** + * Provides a logging buffer for logs related to the media mute-await connections. See + * {@link com.android.systemui.media.muteawait.MediaMuteAwaitConnectionManager}. + */ + @Provides + @SysUISingleton + @MediaMuteAwaitLog + public static LogBuffer provideMediaMuteAwaitLogBuffer(LogBufferFactory factory) { + return factory.create("MediaMuteAwaitLog", 20); + } + /** Allows logging buffers to be tweaked via adb on debug builds but not on prod builds. */ @Provides @SysUISingleton diff --git a/packages/SystemUI/src/com/android/systemui/log/dagger/MediaMuteAwaitLog.java b/packages/SystemUI/src/com/android/systemui/log/dagger/MediaMuteAwaitLog.java new file mode 100644 index 0000000000000..c67d8bebe313a --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/log/dagger/MediaMuteAwaitLog.java @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2022 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.log.dagger; + +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import com.android.systemui.log.LogBuffer; + +import java.lang.annotation.Documented; +import java.lang.annotation.Retention; + +import javax.inject.Qualifier; + +/** + * A {@link LogBuffer} for + * {@link com.android.systemui.media.muteawait.MediaMuteAwaitConnectionManager}. + */ +@Qualifier +@Documented +@Retention(RUNTIME) +public @interface MediaMuteAwaitLog { +} diff --git a/packages/SystemUI/src/com/android/systemui/media/muteawait/MediaMuteAwaitConnectionManager.kt b/packages/SystemUI/src/com/android/systemui/media/muteawait/MediaMuteAwaitConnectionManager.kt index 2783532aff970..f47954a238900 100644 --- a/packages/SystemUI/src/com/android/systemui/media/muteawait/MediaMuteAwaitConnectionManager.kt +++ b/packages/SystemUI/src/com/android/systemui/media/muteawait/MediaMuteAwaitConnectionManager.kt @@ -33,14 +33,13 @@ import java.util.concurrent.Executor * will be notified. * * See [AudioManager.muteAwaitConnection] and b/206614671 for more details. - * - * TODO(b/206614671): Add logging. */ class MediaMuteAwaitConnectionManager constructor( @Main private val mainExecutor: Executor, private val localMediaManager: LocalMediaManager, private val context: Context, - private val deviceIconUtil: DeviceIconUtil + private val deviceIconUtil: DeviceIconUtil, + private val logger: MediaMuteAwaitLogger ) { var currentMutedDevice: AudioDeviceAttributes? = null @@ -48,7 +47,8 @@ class MediaMuteAwaitConnectionManager constructor( val muteAwaitConnectionChangeListener = object : AudioManager.MuteAwaitConnectionCallback() { override fun onMutedUntilConnection(device: AudioDeviceAttributes, mutedUsages: IntArray) { - if (USAGE_MEDIA in mutedUsages) { + logger.logMutedDeviceAdded(device.address, device.name, mutedUsages.hasMedia()) + if (mutedUsages.hasMedia()) { // There should only be one device that's mutedUntilConnection at a time, so we can // safely override any previous value. currentMutedDevice = device @@ -63,7 +63,11 @@ class MediaMuteAwaitConnectionManager constructor( device: AudioDeviceAttributes, mutedUsages: IntArray ) { - if (currentMutedDevice == device && USAGE_MEDIA in mutedUsages) { + val isMostRecentDevice = currentMutedDevice == device + logger.logMutedDeviceRemoved( + device.address, device.name, mutedUsages.hasMedia(), isMostRecentDevice + ) + if (isMostRecentDevice && mutedUsages.hasMedia()) { currentMutedDevice = null localMediaManager.dispatchAboutToConnectDeviceRemoved() } @@ -92,4 +96,6 @@ class MediaMuteAwaitConnectionManager constructor( private fun AudioDeviceAttributes.getIcon(): Drawable { return deviceIconUtil.getIconFromAudioDeviceType(this.type, context) } + + private fun IntArray.hasMedia() = USAGE_MEDIA in this } diff --git a/packages/SystemUI/src/com/android/systemui/media/muteawait/MediaMuteAwaitConnectionManagerFactory.kt b/packages/SystemUI/src/com/android/systemui/media/muteawait/MediaMuteAwaitConnectionManagerFactory.kt index 118b2dd4dc90d..ffcc1f75f0777 100644 --- a/packages/SystemUI/src/com/android/systemui/media/muteawait/MediaMuteAwaitConnectionManagerFactory.kt +++ b/packages/SystemUI/src/com/android/systemui/media/muteawait/MediaMuteAwaitConnectionManagerFactory.kt @@ -30,6 +30,7 @@ import javax.inject.Inject class MediaMuteAwaitConnectionManagerFactory @Inject constructor( private val mediaFlags: MediaFlags, private val context: Context, + private val logger: MediaMuteAwaitLogger, @Main private val mainExecutor: Executor ) { private val deviceIconUtil = DeviceIconUtil() @@ -40,7 +41,7 @@ class MediaMuteAwaitConnectionManagerFactory @Inject constructor( return null } return MediaMuteAwaitConnectionManager( - mainExecutor, localMediaManager, context, deviceIconUtil + mainExecutor, localMediaManager, context, deviceIconUtil, logger ) } } diff --git a/packages/SystemUI/src/com/android/systemui/media/muteawait/MediaMuteAwaitLogger.kt b/packages/SystemUI/src/com/android/systemui/media/muteawait/MediaMuteAwaitLogger.kt new file mode 100644 index 0000000000000..78f4e012da036 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/media/muteawait/MediaMuteAwaitLogger.kt @@ -0,0 +1,51 @@ +package com.android.systemui.media.muteawait + +import com.android.systemui.dagger.SysUISingleton +import com.android.systemui.log.LogBuffer +import com.android.systemui.log.LogLevel +import com.android.systemui.log.dagger.MediaMuteAwaitLog +import javax.inject.Inject + +/** Log messages for [MediaMuteAwaitConnectionManager]. */ +@SysUISingleton +class MediaMuteAwaitLogger @Inject constructor( + @MediaMuteAwaitLog private val buffer: LogBuffer +) { + /** Logs that a muted device has been newly added. */ + fun logMutedDeviceAdded(deviceAddress: String, deviceName: String, hasMediaUsage: Boolean) = + buffer.log( + TAG, + LogLevel.DEBUG, + { + str1 = deviceAddress + str2 = deviceName + bool1 = hasMediaUsage + }, + { + "Muted device added: address=$str1 name=$str2 hasMediaUsage=$bool1" + } + ) + + /** Logs that a muted device has been removed. */ + fun logMutedDeviceRemoved( + deviceAddress: String, + deviceName: String, + hasMediaUsage: Boolean, + isMostRecentDevice: Boolean + ) = buffer.log( + TAG, + LogLevel.DEBUG, + { + str1 = deviceAddress + str2 = deviceName + bool1 = hasMediaUsage + bool2 = isMostRecentDevice + }, + { + "Muted device removed: " + + "address=$str1 name=$str2 hasMediaUsage=$bool1 isMostRecentDevice=$bool2" + } + ) +} + +private const val TAG = "MediaMuteAwait" diff --git a/packages/SystemUI/tests/src/com/android/systemui/media/muteawait/MediaMuteAwaitConnectionManagerTest.kt b/packages/SystemUI/tests/src/com/android/systemui/media/muteawait/MediaMuteAwaitConnectionManagerTest.kt index 27c039dcf29ca..b09fc558d0501 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/media/muteawait/MediaMuteAwaitConnectionManagerTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/media/muteawait/MediaMuteAwaitConnectionManagerTest.kt @@ -53,6 +53,8 @@ class MediaMuteAwaitConnectionManagerTest : SysuiTestCase() { private lateinit var deviceIconUtil: DeviceIconUtil @Mock private lateinit var localMediaManager: LocalMediaManager + @Mock + private lateinit var logger: MediaMuteAwaitLogger private lateinit var icon: Drawable @Before @@ -66,7 +68,8 @@ class MediaMuteAwaitConnectionManagerTest : SysuiTestCase() { FakeExecutor(FakeSystemClock()), localMediaManager, context, - deviceIconUtil + deviceIconUtil, + logger ) } @@ -186,6 +189,39 @@ class MediaMuteAwaitConnectionManagerTest : SysuiTestCase() { verify(localMediaManager).dispatchAboutToConnectDeviceRemoved() } + @Test + fun onMutedUntilConnection_isLogged() { + muteAwaitConnectionManager.startListening() + + getMuteAwaitListener().onMutedUntilConnection(DEVICE, intArrayOf(USAGE_MEDIA)) + + verify(logger).logMutedDeviceAdded(DEVICE_ADDRESS, DEVICE_NAME, hasMediaUsage = true) + } + + @Test + fun onUnmutedEvent_notMostRecentDevice_isLogged() { + muteAwaitConnectionManager.startListening() + + getMuteAwaitListener().onUnmutedEvent(EVENT_CONNECTION, DEVICE, intArrayOf(USAGE_MEDIA)) + + verify(logger).logMutedDeviceRemoved( + DEVICE_ADDRESS, DEVICE_NAME, hasMediaUsage = true, isMostRecentDevice = false + ) + } + + @Test + fun onUnmutedEvent_isMostRecentDevice_isLogged() { + muteAwaitConnectionManager.startListening() + val muteAwaitListener = getMuteAwaitListener() + + muteAwaitListener.onMutedUntilConnection(DEVICE, intArrayOf(USAGE_MEDIA)) + muteAwaitListener.onUnmutedEvent(EVENT_CONNECTION, DEVICE, intArrayOf(USAGE_MEDIA)) + + verify(logger).logMutedDeviceRemoved( + DEVICE_ADDRESS, DEVICE_NAME, hasMediaUsage = true, isMostRecentDevice = true + ) + } + private fun getMuteAwaitListener(): AudioManager.MuteAwaitConnectionCallback { val listenerCaptor = ArgumentCaptor.forClass( AudioManager.MuteAwaitConnectionCallback::class.java From 1f94d22ad894fc0879dbf5d77453af843f10531a Mon Sep 17 00:00:00 2001 From: Caitlin Cassidy Date: Mon, 18 Apr 2022 15:23:49 +0000 Subject: [PATCH 2/2] [Media] Add logging for NearbyMediaDevicesManager. Fixes: 219767651 Test: atest NearbyMediaDevicesManagerTest Change-Id: I3d1952ae30e5d4c3fa0f234f00883dc4b9bc233a --- .../systemui/log/dagger/LogModule.java | 11 ++ .../log/dagger/NearbyMediaDevicesLog.java | 33 ++++++ .../media/nearby/NearbyMediaDevicesLogger.kt | 51 +++++++++ .../media/nearby/NearbyMediaDevicesManager.kt | 12 +- .../nearby/NearbyMediaDevicesManagerTest.kt | 104 +++++++++++++++++- 5 files changed, 204 insertions(+), 7 deletions(-) create mode 100644 packages/SystemUI/src/com/android/systemui/log/dagger/NearbyMediaDevicesLog.java create mode 100644 packages/SystemUI/src/com/android/systemui/media/nearby/NearbyMediaDevicesLogger.kt diff --git a/packages/SystemUI/src/com/android/systemui/log/dagger/LogModule.java b/packages/SystemUI/src/com/android/systemui/log/dagger/LogModule.java index 96862af59817d..79ac9e8b09867 100644 --- a/packages/SystemUI/src/com/android/systemui/log/dagger/LogModule.java +++ b/packages/SystemUI/src/com/android/systemui/log/dagger/LogModule.java @@ -188,6 +188,17 @@ public class LogModule { return factory.create("MediaMuteAwaitLog", 20); } + /** + * Provides a logging buffer for logs related to the media mute-await connections. See + * {@link com.android.systemui.media.nearby.NearbyMediaDevicesManager}. + */ + @Provides + @SysUISingleton + @NearbyMediaDevicesLog + public static LogBuffer provideNearbyMediaDevicesLogBuffer(LogBufferFactory factory) { + return factory.create("NearbyMediaDevicesLog", 20); + } + /** Allows logging buffers to be tweaked via adb on debug builds but not on prod builds. */ @Provides @SysUISingleton diff --git a/packages/SystemUI/src/com/android/systemui/log/dagger/NearbyMediaDevicesLog.java b/packages/SystemUI/src/com/android/systemui/log/dagger/NearbyMediaDevicesLog.java new file mode 100644 index 0000000000000..b1c6dcfcb13bb --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/log/dagger/NearbyMediaDevicesLog.java @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2022 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.log.dagger; + +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import com.android.systemui.log.LogBuffer; + +import java.lang.annotation.Documented; +import java.lang.annotation.Retention; + +import javax.inject.Qualifier; + +/** A {@link LogBuffer} for {@link com.android.systemui.media.nearby.NearbyMediaDevicesManager}. */ +@Qualifier +@Documented +@Retention(RUNTIME) +public @interface NearbyMediaDevicesLog { +} diff --git a/packages/SystemUI/src/com/android/systemui/media/nearby/NearbyMediaDevicesLogger.kt b/packages/SystemUI/src/com/android/systemui/media/nearby/NearbyMediaDevicesLogger.kt new file mode 100644 index 0000000000000..46b2cc141b3c8 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/media/nearby/NearbyMediaDevicesLogger.kt @@ -0,0 +1,51 @@ +package com.android.systemui.media.nearby + +import com.android.systemui.dagger.SysUISingleton +import com.android.systemui.log.LogBuffer +import com.android.systemui.log.LogLevel +import com.android.systemui.log.dagger.NearbyMediaDevicesLog +import javax.inject.Inject + +/** Log messages for [NearbyMediaDevicesManager]. */ +@SysUISingleton +class NearbyMediaDevicesLogger @Inject constructor( + @NearbyMediaDevicesLog private val buffer: LogBuffer +) { + /** + * Log that a new provider was registered. + * + * @param numProviders the total number of providers that are currently registered. + */ + fun logProviderRegistered(numProviders: Int) = buffer.log( + TAG, + LogLevel.DEBUG, + { int1 = numProviders }, + { "Provider registered; total providers = $int1" } + ) + + /** + * Log that a new provider was unregistered. + * + * @param numProviders the total number of providers that are currently registered. + */ + fun logProviderUnregistered(numProviders: Int) = buffer.log( + TAG, + LogLevel.DEBUG, + { int1 = numProviders }, + { "Provider unregistered; total providers = $int1" } + ) + + /** + * Log that a provider's binder has died. + * + * @param numProviders the total number of providers that are currently registered. + */ + fun logProviderBinderDied(numProviders: Int) = buffer.log( + TAG, + LogLevel.DEBUG, + { int1 = numProviders }, + { "Provider binder died; total providers = $int1" } + ) +} + +private const val TAG = "NearbyMediaDevices" diff --git a/packages/SystemUI/src/com/android/systemui/media/nearby/NearbyMediaDevicesManager.kt b/packages/SystemUI/src/com/android/systemui/media/nearby/NearbyMediaDevicesManager.kt index 9875ffbaf668e..64b772b6a02cf 100644 --- a/packages/SystemUI/src/com/android/systemui/media/nearby/NearbyMediaDevicesManager.kt +++ b/packages/SystemUI/src/com/android/systemui/media/nearby/NearbyMediaDevicesManager.kt @@ -27,12 +27,11 @@ import javax.inject.Inject * A service that acts as a bridge between (1) external clients that have data on nearby devices * that are able to play media and (2) internal clients (like media Output Switcher) that need data * on these nearby devices. - * - * TODO(b/216313420): Add logging to this class. */ @SysUISingleton class NearbyMediaDevicesManager @Inject constructor( - commandQueue: CommandQueue + commandQueue: CommandQueue, + private val logger: NearbyMediaDevicesLogger ) { private var providers: MutableList = mutableListOf() private var activeCallbacks: MutableList = mutableListOf() @@ -46,13 +45,17 @@ class NearbyMediaDevicesManager @Inject constructor( newProvider.registerNearbyDevicesCallback(it) } providers.add(newProvider) + logger.logProviderRegistered(providers.size) newProvider.asBinder().linkToDeath(deathRecipient, /* flags= */ 0) } override fun unregisterNearbyMediaDevicesProvider( newProvider: INearbyMediaDevicesProvider ) { - providers.remove(newProvider) + val isRemoved = providers.remove(newProvider) + if (isRemoved) { + logger.logProviderUnregistered(providers.size) + } } } @@ -99,6 +102,7 @@ class NearbyMediaDevicesManager @Inject constructor( for (i in providers.size - 1 downTo 0) { if (providers[i].asBinder() == who) { providers.removeAt(i) + logger.logProviderBinderDied(providers.size) break } } diff --git a/packages/SystemUI/tests/src/com/android/systemui/media/nearby/NearbyMediaDevicesManagerTest.kt b/packages/SystemUI/tests/src/com/android/systemui/media/nearby/NearbyMediaDevicesManagerTest.kt index f87a67310ff02..301d887b74741 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/media/nearby/NearbyMediaDevicesManagerTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/media/nearby/NearbyMediaDevicesManagerTest.kt @@ -5,13 +5,18 @@ import android.media.INearbyMediaDevicesUpdateCallback import androidx.test.filters.SmallTest import com.android.systemui.SysuiTestCase import android.media.NearbyDevice +import android.os.IBinder import com.android.systemui.statusbar.CommandQueue import com.google.common.truth.Truth.assertThat import org.junit.Before import org.junit.Test import org.mockito.ArgumentCaptor import org.mockito.Mock -import org.mockito.Mockito +import org.mockito.Mockito.anyInt +import org.mockito.Mockito.never +import org.mockito.Mockito.reset +import org.mockito.Mockito.times +import org.mockito.Mockito.verify import org.mockito.MockitoAnnotations @SmallTest @@ -19,16 +24,18 @@ class NearbyMediaDevicesManagerTest : SysuiTestCase() { private lateinit var manager: NearbyMediaDevicesManager @Mock + private lateinit var logger: NearbyMediaDevicesLogger + @Mock private lateinit var commandQueue: CommandQueue private lateinit var commandQueueCallbacks: CommandQueue.Callbacks @Before fun setUp() { MockitoAnnotations.initMocks(this) - manager = NearbyMediaDevicesManager(commandQueue) + manager = NearbyMediaDevicesManager(commandQueue, logger) val callbackCaptor = ArgumentCaptor.forClass(CommandQueue.Callbacks::class.java) - Mockito.verify(commandQueue).addCallback(callbackCaptor.capture()) + verify(commandQueue).addCallback(callbackCaptor.capture()) commandQueueCallbacks = callbackCaptor.value!! } @@ -128,9 +135,92 @@ class NearbyMediaDevicesManagerTest : SysuiTestCase() { assertThat(provider2.lastRegisteredCallback).isEqualTo(callback) } + @Test + fun providerUnregistered_doesNotReceiveNewCallback() { + val provider = TestProvider() + commandQueueCallbacks.registerNearbyMediaDevicesProvider(provider) + commandQueueCallbacks.unregisterNearbyMediaDevicesProvider(provider) + + val callback = object : INearbyMediaDevicesUpdateCallback.Stub() { + override fun onDevicesUpdated(nearbyDevices: List) {} + } + manager.registerNearbyDevicesCallback(callback) + + assertThat(provider.lastRegisteredCallback).isEqualTo(null) + } + + @Test + fun providerRegistered_isLogged() { + commandQueueCallbacks.registerNearbyMediaDevicesProvider(TestProvider()) + + verify(logger).logProviderRegistered(numProviders = 1) + } + + @Test + fun providerRegisteredTwice_onlyLoggedOnce() { + val provider = TestProvider() + + commandQueueCallbacks.registerNearbyMediaDevicesProvider(provider) + commandQueueCallbacks.registerNearbyMediaDevicesProvider(provider) + + verify(logger, times(1)).logProviderRegistered(numProviders = 1) + } + + @Test + fun multipleProvidersRegistered_isLogged() { + commandQueueCallbacks.registerNearbyMediaDevicesProvider(TestProvider()) + commandQueueCallbacks.registerNearbyMediaDevicesProvider(TestProvider()) + reset(logger) + + commandQueueCallbacks.registerNearbyMediaDevicesProvider(TestProvider()) + + verify(logger).logProviderRegistered(numProviders = 3) + } + + @Test + fun providerUnregistered_isLogged() { + val provider = TestProvider() + commandQueueCallbacks.registerNearbyMediaDevicesProvider(provider) + + commandQueueCallbacks.unregisterNearbyMediaDevicesProvider(provider) + + verify(logger).logProviderUnregistered(numProviders = 0) + } + + @Test + fun multipleProvidersRegisteredThenUnregistered_isLogged() { + val provider = TestProvider() + commandQueueCallbacks.registerNearbyMediaDevicesProvider(provider) + commandQueueCallbacks.registerNearbyMediaDevicesProvider(TestProvider()) + commandQueueCallbacks.registerNearbyMediaDevicesProvider(TestProvider()) + + commandQueueCallbacks.unregisterNearbyMediaDevicesProvider(provider) + + verify(logger).logProviderUnregistered(numProviders = 2) + } + + @Test + fun providerUnregisteredButNeverRegistered_notLogged() { + commandQueueCallbacks.unregisterNearbyMediaDevicesProvider(TestProvider()) + + verify(logger, never()).logProviderRegistered(anyInt()) + } + + @Test + fun providerBinderDied_isLogged() { + val provider = TestProvider() + commandQueueCallbacks.registerNearbyMediaDevicesProvider(provider) + + provider.deathRecipient!!.binderDied(provider) + + verify(logger).logProviderBinderDied(numProviders = 0) + } + private class TestProvider : INearbyMediaDevicesProvider.Stub() { var lastRegisteredCallback: INearbyMediaDevicesUpdateCallback? = null var lastUnregisteredCallback: INearbyMediaDevicesUpdateCallback? = null + var deathRecipient: IBinder.DeathRecipient? = null + override fun registerNearbyDevicesCallback( callback: INearbyMediaDevicesUpdateCallback ) { @@ -142,5 +232,13 @@ class NearbyMediaDevicesManagerTest : SysuiTestCase() { ) { lastUnregisteredCallback = callback } + + override fun asBinder(): IBinder { + return this + } + + override fun linkToDeath(recipient: IBinder.DeathRecipient, flags: Int) { + deathRecipient = recipient + } } }