From 643d6c66c19493f19da32630356ec896983e2abe Mon Sep 17 00:00:00 2001 From: Yiyi Shen Date: Fri, 7 Jun 2024 18:26:47 +0800 Subject: [PATCH] [Audiosharing] Increase test coverage for audio sharing Bug: 345686602 Test: atest Change-Id: Ib75a0127921d7ac6e7e0bbc82258ac0a21be90a2 --- ...ringCompatibilityPreferenceController.java | 5 +- .../AudioSharingDashboardFragment.java | 23 +++- .../AudioSharingPreferenceController.java | 4 +- ...CompatibilityPreferenceControllerTest.java | 113 ++++++++++++++---- .../AudioSharingDashboardFragmentTest.java | 62 +++++++++- .../AudioSharingDeviceItemTest.java | 15 +++ .../AudioSharingPreferenceControllerTest.java | 87 ++++++++++++-- 7 files changed, 263 insertions(+), 46 deletions(-) diff --git a/src/com/android/settings/connecteddevice/audiosharing/AudioSharingCompatibilityPreferenceController.java b/src/com/android/settings/connecteddevice/audiosharing/AudioSharingCompatibilityPreferenceController.java index d2f23edfe8a..581ad62bb31 100644 --- a/src/com/android/settings/connecteddevice/audiosharing/AudioSharingCompatibilityPreferenceController.java +++ b/src/com/android/settings/connecteddevice/audiosharing/AudioSharingCompatibilityPreferenceController.java @@ -57,9 +57,10 @@ public class AudioSharingCompatibilityPreferenceController extends TogglePrefere @Nullable private TwoStatePreference mPreference; private final Executor mExecutor; private final MetricsFeatureProvider mMetricsFeatureProvider; - private AtomicBoolean mCallbacksRegistered = new AtomicBoolean(false); + private final AtomicBoolean mCallbacksRegistered = new AtomicBoolean(false); - private final BluetoothLeBroadcast.Callback mBroadcastCallback = + @VisibleForTesting + protected final BluetoothLeBroadcast.Callback mBroadcastCallback = new BluetoothLeBroadcast.Callback() { @Override public void onBroadcastStarted(int reason, int broadcastId) { diff --git a/src/com/android/settings/connecteddevice/audiosharing/AudioSharingDashboardFragment.java b/src/com/android/settings/connecteddevice/audiosharing/AudioSharingDashboardFragment.java index c3248c7e573..c7d740740e7 100644 --- a/src/com/android/settings/connecteddevice/audiosharing/AudioSharingDashboardFragment.java +++ b/src/com/android/settings/connecteddevice/audiosharing/AudioSharingDashboardFragment.java @@ -20,6 +20,8 @@ import android.app.settings.SettingsEnums; import android.content.Context; import android.os.Bundle; +import androidx.annotation.VisibleForTesting; + import com.android.settings.R; import com.android.settings.SettingsActivity; import com.android.settings.connecteddevice.audiosharing.audiostreams.AudioStreamsCategoryController; @@ -31,7 +33,6 @@ public class AudioSharingDashboardFragment extends DashboardFragment private static final String TAG = "AudioSharingDashboardFrag"; SettingsMainSwitchBar mMainSwitchBar; - private AudioSharingSwitchBarController mSwitchBarController; private AudioSharingDeviceVolumeGroupController mAudioSharingDeviceVolumeGroupController; private AudioSharingCallAudioPreferenceController mAudioSharingCallAudioPreferenceController; private AudioSharingPlaySoundPreferenceController mAudioSharingPlaySoundPreferenceController; @@ -83,9 +84,10 @@ public class AudioSharingDashboardFragment extends DashboardFragment final SettingsActivity activity = (SettingsActivity) getActivity(); mMainSwitchBar = activity.getSwitchBar(); mMainSwitchBar.setTitle(getText(R.string.audio_sharing_switch_title)); - mSwitchBarController = new AudioSharingSwitchBarController(activity, mMainSwitchBar, this); - mSwitchBarController.init(this); - getSettingsLifecycle().addObserver(mSwitchBarController); + AudioSharingSwitchBarController switchBarController = + new AudioSharingSwitchBarController(activity, mMainSwitchBar, this); + switchBarController.init(this); + getSettingsLifecycle().addObserver(switchBarController); mMainSwitchBar.show(); } @@ -99,6 +101,19 @@ public class AudioSharingDashboardFragment extends DashboardFragment onProfilesConnectedForAttachedPreferences(); } + /** Test only: set mock controllers for the {@link AudioSharingDashboardFragment} */ + @VisibleForTesting + protected void setControllers( + AudioSharingDeviceVolumeGroupController volumeGroupController, + AudioSharingCallAudioPreferenceController callAudioController, + AudioSharingPlaySoundPreferenceController playSoundController, + AudioStreamsCategoryController streamsCategoryController) { + mAudioSharingDeviceVolumeGroupController = volumeGroupController; + mAudioSharingCallAudioPreferenceController = callAudioController; + mAudioSharingPlaySoundPreferenceController = playSoundController; + mAudioStreamsCategoryController = streamsCategoryController; + } + private void updateVisibilityForAttachedPreferences() { mAudioSharingDeviceVolumeGroupController.updateVisibility(); mAudioSharingCallAudioPreferenceController.updateVisibility(); diff --git a/src/com/android/settings/connecteddevice/audiosharing/AudioSharingPreferenceController.java b/src/com/android/settings/connecteddevice/audiosharing/AudioSharingPreferenceController.java index 54eb722ba50..d27d3a20d72 100644 --- a/src/com/android/settings/connecteddevice/audiosharing/AudioSharingPreferenceController.java +++ b/src/com/android/settings/connecteddevice/audiosharing/AudioSharingPreferenceController.java @@ -23,6 +23,7 @@ import android.util.Log; import androidx.annotation.NonNull; import androidx.annotation.Nullable; +import androidx.annotation.VisibleForTesting; import androidx.lifecycle.DefaultLifecycleObserver; import androidx.lifecycle.LifecycleOwner; import androidx.preference.Preference; @@ -50,7 +51,8 @@ public class AudioSharingPreferenceController extends BasePreferenceController @Nullable private Preference mPreference; private final Executor mExecutor; - private final BluetoothLeBroadcast.Callback mBroadcastCallback = + @VisibleForTesting + protected final BluetoothLeBroadcast.Callback mBroadcastCallback = new BluetoothLeBroadcast.Callback() { @Override public void onBroadcastStarted(int reason, int broadcastId) { diff --git a/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/AudioSharingCompatibilityPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/AudioSharingCompatibilityPreferenceControllerTest.java index 1a9d09e4148..19221a65abe 100644 --- a/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/AudioSharingCompatibilityPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/AudioSharingCompatibilityPreferenceControllerTest.java @@ -25,6 +25,7 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyBoolean; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.never; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoInteractions; @@ -34,6 +35,7 @@ import static org.robolectric.Shadows.shadowOf; import android.app.settings.SettingsEnums; import android.bluetooth.BluetoothAdapter; import android.bluetooth.BluetoothLeBroadcast; +import android.bluetooth.BluetoothLeBroadcastMetadata; import android.bluetooth.BluetoothStatusCodes; import android.content.Context; import android.os.Looper; @@ -94,28 +96,28 @@ public class AudioSharingCompatibilityPreferenceControllerTest { @Mock private LocalBluetoothLeBroadcastAssistant mAssistant; @Mock private VolumeControlProfile mVolumeControl; @Mock private TwoStatePreference mPreference; + @Mock private BluetoothLeBroadcastMetadata mMetadata; private AudioSharingCompatibilityPreferenceController mController; - private ShadowBluetoothAdapter mShadowBluetoothAdapter; - private LocalBluetoothManager mLocalBluetoothManager; private FakeFeatureFactory mFeatureFactory; private Lifecycle mLifecycle; private LifecycleOwner mLifecycleOwner; @Before public void setUp() { - mShadowBluetoothAdapter = Shadow.extract(BluetoothAdapter.getDefaultAdapter()); - mShadowBluetoothAdapter.setEnabled(true); - mShadowBluetoothAdapter.setIsLeAudioBroadcastSourceSupported( + ShadowBluetoothAdapter shadowBluetoothAdapter = + Shadow.extract(BluetoothAdapter.getDefaultAdapter()); + shadowBluetoothAdapter.setEnabled(true); + shadowBluetoothAdapter.setIsLeAudioBroadcastSourceSupported( BluetoothStatusCodes.FEATURE_SUPPORTED); - mShadowBluetoothAdapter.setIsLeAudioBroadcastAssistantSupported( + shadowBluetoothAdapter.setIsLeAudioBroadcastAssistantSupported( BluetoothStatusCodes.FEATURE_SUPPORTED); mLifecycleOwner = () -> mLifecycle; mLifecycle = new Lifecycle(mLifecycleOwner); ShadowBluetoothUtils.sLocalBluetoothManager = mLocalBtManager; - mLocalBluetoothManager = Utils.getLocalBtManager(mContext); + LocalBluetoothManager localBluetoothManager = Utils.getLocalBtManager(mContext); mFeatureFactory = FakeFeatureFactory.setupForTest(); - when(mLocalBluetoothManager.getEventManager()).thenReturn(mBtEventManager); - when(mLocalBluetoothManager.getProfileManager()).thenReturn(mBtProfileManager); + when(localBluetoothManager.getEventManager()).thenReturn(mBtEventManager); + when(localBluetoothManager.getProfileManager()).thenReturn(mBtProfileManager); when(mBtProfileManager.getLeAudioBroadcastProfile()).thenReturn(mBroadcast); when(mBtProfileManager.getLeAudioBroadcastAssistantProfile()).thenReturn(mAssistant); when(mBtProfileManager.getVolumeControlProfile()).thenReturn(mVolumeControl); @@ -133,7 +135,7 @@ public class AudioSharingCompatibilityPreferenceControllerTest { verify(mBroadcast) .registerServiceCallBack( any(Executor.class), any(BluetoothLeBroadcast.Callback.class)); - verify(mBtProfileManager, times(0)).addServiceListener(mController); + verify(mBtProfileManager, never()).addServiceListener(mController); } @Test @@ -141,7 +143,7 @@ public class AudioSharingCompatibilityPreferenceControllerTest { mSetFlagsRule.enableFlags(Flags.FLAG_ENABLE_LE_AUDIO_SHARING); when(mBroadcast.isProfileReady()).thenReturn(false); mController.onStart(mLifecycleOwner); - verify(mBroadcast, times(0)) + verify(mBroadcast, never()) .registerServiceCallBack( any(Executor.class), any(BluetoothLeBroadcast.Callback.class)); verify(mBtProfileManager).addServiceListener(mController); @@ -151,7 +153,7 @@ public class AudioSharingCompatibilityPreferenceControllerTest { public void onStart_flagOff_doNothing() { mSetFlagsRule.disableFlags(Flags.FLAG_ENABLE_LE_AUDIO_SHARING); mController.onStart(mLifecycleOwner); - verify(mBroadcast, times(0)) + verify(mBroadcast, never()) .registerServiceCallBack( any(Executor.class), any(BluetoothLeBroadcast.Callback.class)); } @@ -170,9 +172,9 @@ public class AudioSharingCompatibilityPreferenceControllerTest { mSetFlagsRule.disableFlags(Flags.FLAG_ENABLE_LE_AUDIO_SHARING); mController.setCallbacksRegistered(true); mController.onStop(mLifecycleOwner); - verify(mBroadcast, times(0)) + verify(mBroadcast, never()) .unregisterServiceCallBack(any(BluetoothLeBroadcast.Callback.class)); - verify(mBtProfileManager, times(0)).removeServiceListener(mController); + verify(mBtProfileManager, never()).removeServiceListener(mController); } @Test @@ -224,11 +226,10 @@ public class AudioSharingCompatibilityPreferenceControllerTest { mController.displayPreference(mScreen); shadowOf(Looper.getMainLooper()).idle(); verify(mPreference).setEnabled(false); - verify(mPreference) - .setSummary( - eq(mContext.getString( - R.string - .audio_sharing_stream_compatibility_disabled_description))); + String expected = + mContext.getString( + R.string.audio_sharing_stream_compatibility_disabled_description); + verify(mPreference).setSummary(eq(expected)); } @Test @@ -237,10 +238,9 @@ public class AudioSharingCompatibilityPreferenceControllerTest { mController.displayPreference(mScreen); shadowOf(Looper.getMainLooper()).idle(); verify(mPreference).setEnabled(true); - verify(mPreference) - .setSummary( - eq(mContext.getString( - R.string.audio_sharing_stream_compatibility_description))); + String expected = + mContext.getString(R.string.audio_sharing_stream_compatibility_description); + verify(mPreference).setSummary(eq(expected)); } @Test @@ -272,8 +272,73 @@ public class AudioSharingCompatibilityPreferenceControllerTest { public void setCheckedToCurrentValue_returnsFalse() { when(mBroadcast.getImproveCompatibility()).thenReturn(true); boolean setChecked = mController.setChecked(true); - verify(mBroadcast, times(0)).setImproveCompatibility(anyBoolean()); + verify(mBroadcast, never()).setImproveCompatibility(anyBoolean()); verifyNoInteractions(mFeatureFactory.metricsFeatureProvider); assertThat(setChecked).isFalse(); } + + @Test + public void testBluetoothLeBroadcastCallbacks_refreshPreference() { + when(mBroadcast.isEnabled(any())).thenReturn(false); + mController.displayPreference(mScreen); + shadowOf(Looper.getMainLooper()).idle(); + verify(mPreference).setEnabled(true); + String expected = + mContext.getString(R.string.audio_sharing_stream_compatibility_description); + verify(mPreference).setSummary(eq(expected)); + + when(mBroadcast.isEnabled(any())).thenReturn(true); + mController.mBroadcastCallback.onBroadcastStarted(/* reason= */ 1, /* broadcastId= */ 1); + shadowOf(Looper.getMainLooper()).idle(); + verify(mPreference).setEnabled(false); + expected = + mContext.getString( + R.string.audio_sharing_stream_compatibility_disabled_description); + verify(mPreference).setSummary(eq(expected)); + + when(mBroadcast.isEnabled(any())).thenReturn(false); + mController.mBroadcastCallback.onBroadcastStopped(/* reason= */ 1, /* broadcastId= */ 1); + shadowOf(Looper.getMainLooper()).idle(); + + // Verify one extra setEnabled/setSummary is called other than the first call in + // displayPreference. + verify(mPreference, times(2)).setEnabled(true); + expected = mContext.getString(R.string.audio_sharing_stream_compatibility_description); + verify(mPreference, times(2)).setSummary(eq(expected)); + } + + @Test + public void testBluetoothLeBroadcastCallbacks_doNothing() { + when(mBroadcast.isEnabled(any())).thenReturn(false); + mController.displayPreference(mScreen); + shadowOf(Looper.getMainLooper()).idle(); + verify(mPreference).setEnabled(true); + String expected = + mContext.getString(R.string.audio_sharing_stream_compatibility_description); + verify(mPreference).setSummary(eq(expected)); + + // Verify no extra setEnabled/setSummary is called other than call in displayPreference. + mController.mBroadcastCallback.onBroadcastMetadataChanged(/* reason= */ 1, mMetadata); + verify(mPreference).setEnabled(anyBoolean()); + verify(mPreference).setSummary(any()); + mController.mBroadcastCallback.onBroadcastUpdated(/* reason= */ 1, /* broadcastId= */ 1); + verify(mPreference).setEnabled(anyBoolean()); + verify(mPreference).setSummary(any()); + mController.mBroadcastCallback.onPlaybackStarted(/* reason= */ 1, /* broadcastId= */ 1); + verify(mPreference).setEnabled(anyBoolean()); + verify(mPreference).setSummary(any()); + mController.mBroadcastCallback.onPlaybackStopped(/* reason= */ 1, /* broadcastId= */ 1); + verify(mPreference).setEnabled(anyBoolean()); + verify(mPreference).setSummary(any()); + mController.mBroadcastCallback.onBroadcastStartFailed(/* reason= */ 1); + verify(mPreference).setEnabled(anyBoolean()); + verify(mPreference).setSummary(any()); + mController.mBroadcastCallback.onBroadcastStopFailed(/* reason= */ 1); + verify(mPreference).setEnabled(anyBoolean()); + verify(mPreference).setSummary(any()); + mController.mBroadcastCallback.onBroadcastUpdateFailed( + /* reason= */ 1, /* broadcastId= */ 1); + verify(mPreference).setEnabled(anyBoolean()); + verify(mPreference).setSummary(any()); + } } diff --git a/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/AudioSharingDashboardFragmentTest.java b/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/AudioSharingDashboardFragmentTest.java index c1afeaa7806..8e4915cc8ff 100644 --- a/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/AudioSharingDashboardFragmentTest.java +++ b/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/AudioSharingDashboardFragmentTest.java @@ -18,22 +18,45 @@ package com.android.settings.connecteddevice.audiosharing; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; + import android.app.settings.SettingsEnums; +import android.content.Context; +import android.os.Bundle; + +import androidx.test.core.app.ApplicationProvider; import com.android.settings.R; +import com.android.settings.SettingsActivity; +import com.android.settings.connecteddevice.audiosharing.audiostreams.AudioStreamsCategoryController; +import com.android.settings.testutils.shadow.ShadowFragment; +import com.android.settings.widget.SettingsMainSwitchBar; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; import org.robolectric.RobolectricTestRunner; +import org.robolectric.annotation.Config; @RunWith(RobolectricTestRunner.class) +@Config(shadows = {ShadowFragment.class}) public class AudioSharingDashboardFragmentTest { @Rule public final MockitoRule mMockitoRule = MockitoJUnit.rule(); + + @Mock private SettingsActivity mActivity; + @Mock private SettingsMainSwitchBar mSwitchBar; + @Mock private AudioSharingDeviceVolumeGroupController mVolumeGroupController; + @Mock private AudioSharingCallAudioPreferenceController mCallAudioController; + @Mock private AudioSharingPlaySoundPreferenceController mPlaySoundController; + @Mock private AudioStreamsCategoryController mStreamsCategoryController; + private final Context mContext = ApplicationProvider.getApplicationContext(); private AudioSharingDashboardFragment mFragment; @Before @@ -59,7 +82,42 @@ public class AudioSharingDashboardFragmentTest { @Test public void getHelpResource_returnsCorrectResource() { - assertThat(mFragment.getHelpResource()) - .isEqualTo(R.string.help_url_audio_sharing); + assertThat(mFragment.getHelpResource()).isEqualTo(R.string.help_url_audio_sharing); + } + + @Test + public void onActivityCreated_showSwitchBar() { + doReturn(mSwitchBar).when(mActivity).getSwitchBar(); + mFragment = spy(new AudioSharingDashboardFragment()); + doReturn(mActivity).when(mFragment).getActivity(); + doReturn(mContext).when(mFragment).getContext(); + mFragment.onAttach(mContext); + mFragment.onActivityCreated(new Bundle()); + verify(mSwitchBar).show(); + } + + @Test + public void onAudioSharingStateChanged_updateVisibilityForControllers() { + mFragment.setControllers( + mVolumeGroupController, + mCallAudioController, + mPlaySoundController, + mStreamsCategoryController); + mFragment.onAudioSharingStateChanged(); + verify(mVolumeGroupController).updateVisibility(); + verify(mCallAudioController).updateVisibility(); + verify(mPlaySoundController).updateVisibility(); + verify(mStreamsCategoryController).updateVisibility(); + } + + @Test + public void onAudioSharingProfilesConnected_registerCallbacksForVolumeGroupController() { + mFragment.setControllers( + mVolumeGroupController, + mCallAudioController, + mPlaySoundController, + mStreamsCategoryController); + mFragment.onAudioSharingProfilesConnected(); + verify(mVolumeGroupController).onAudioSharingProfilesConnected(); } } diff --git a/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/AudioSharingDeviceItemTest.java b/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/AudioSharingDeviceItemTest.java index 1bae3d170f8..b23882d3953 100644 --- a/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/AudioSharingDeviceItemTest.java +++ b/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/AudioSharingDeviceItemTest.java @@ -63,4 +63,19 @@ public class AudioSharingDeviceItemTest { public void creator_newArray() { assertThat(AudioSharingDeviceItem.CREATOR.newArray(2)).hasLength(2); } + + @Test + public void creator_createFromParcel() { + AudioSharingDeviceItem item = + new AudioSharingDeviceItem(TEST_NAME, TEST_GROUP_ID, TEST_IS_ACTIVE); + Parcel parcel = Parcel.obtain(); + item.writeToParcel(parcel, 0); + parcel.setDataPosition(0); + AudioSharingDeviceItem itemFromParcel = + AudioSharingDeviceItem.CREATOR.createFromParcel(parcel); + parcel.recycle(); + assertThat(itemFromParcel.getName()).isEqualTo(TEST_NAME); + assertThat(itemFromParcel.getGroupId()).isEqualTo(TEST_GROUP_ID); + assertThat(itemFromParcel.isActive()).isEqualTo(TEST_IS_ACTIVE); + } } diff --git a/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/AudioSharingPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/AudioSharingPreferenceControllerTest.java index b8bee1a65c8..046a4ce8f67 100644 --- a/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/AudioSharingPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/connecteddevice/audiosharing/AudioSharingPreferenceControllerTest.java @@ -25,12 +25,15 @@ import static com.android.settings.core.BasePreferenceController.UNSUPPORTED_ON_ import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static org.robolectric.Shadows.shadowOf; import android.bluetooth.BluetoothAdapter; import android.bluetooth.BluetoothLeBroadcast; +import android.bluetooth.BluetoothLeBroadcastMetadata; import android.bluetooth.BluetoothStatusCodes; import android.content.Context; import android.os.Looper; @@ -84,47 +87,67 @@ public class AudioSharingPreferenceControllerTest { @Mock private BluetoothEventManager mBtEventManager; @Mock private LocalBluetoothProfileManager mLocalBtProfileManager; @Mock private LocalBluetoothLeBroadcast mBroadcast; + @Mock private BluetoothLeBroadcastMetadata mMetadata; private AudioSharingPreferenceController mController; - private ShadowBluetoothAdapter mShadowBluetoothAdapter; - private LocalBluetoothManager mLocalBluetoothManager; private Lifecycle mLifecycle; private LifecycleOwner mLifecycleOwner; - private Preference mPreference; + @Spy private Preference mPreference; @Before public void setUp() { - mShadowBluetoothAdapter = Shadow.extract(BluetoothAdapter.getDefaultAdapter()); - mShadowBluetoothAdapter.setEnabled(true); - mShadowBluetoothAdapter.setIsLeAudioBroadcastSourceSupported( + ShadowBluetoothAdapter shadowBluetoothAdapter = + Shadow.extract(BluetoothAdapter.getDefaultAdapter()); + shadowBluetoothAdapter.setEnabled(true); + shadowBluetoothAdapter.setIsLeAudioBroadcastSourceSupported( BluetoothStatusCodes.FEATURE_SUPPORTED); - mShadowBluetoothAdapter.setIsLeAudioBroadcastAssistantSupported( + shadowBluetoothAdapter.setIsLeAudioBroadcastAssistantSupported( BluetoothStatusCodes.FEATURE_SUPPORTED); mLifecycleOwner = () -> mLifecycle; mLifecycle = new Lifecycle(mLifecycleOwner); ShadowBluetoothUtils.sLocalBluetoothManager = mLocalBtManager; - mLocalBluetoothManager = Utils.getLocalBtManager(mContext); - when(mLocalBluetoothManager.getEventManager()).thenReturn(mBtEventManager); - when(mLocalBluetoothManager.getProfileManager()).thenReturn(mLocalBtProfileManager); + LocalBluetoothManager localBluetoothManager = Utils.getLocalBtManager(mContext); + when(localBluetoothManager.getEventManager()).thenReturn(mBtEventManager); + when(localBluetoothManager.getProfileManager()).thenReturn(mLocalBtProfileManager); when(mLocalBtProfileManager.getLeAudioBroadcastProfile()).thenReturn(mBroadcast); mController = new AudioSharingPreferenceController(mContext, PREF_KEY); - mPreference = new Preference(mContext); + mPreference = spy(new Preference(mContext)); when(mScreen.findPreference(PREF_KEY)).thenReturn(mPreference); } @Test - public void onStart_registerCallback() { + public void onStart_flagOn_registerCallback() { + mSetFlagsRule.enableFlags(Flags.FLAG_ENABLE_LE_AUDIO_SHARING); mController.onStart(mLifecycleOwner); verify(mBtEventManager).registerCallback(mController); verify(mBroadcast).registerServiceCallBack(any(), any(BluetoothLeBroadcast.Callback.class)); } @Test - public void onStop_unregisterCallback() { + public void onStart_flagOff_skipRegisterCallback() { + mSetFlagsRule.disableFlags(Flags.FLAG_ENABLE_LE_AUDIO_SHARING); + mController.onStart(mLifecycleOwner); + verify(mBtEventManager, never()).registerCallback(mController); + verify(mBroadcast, never()) + .registerServiceCallBack(any(), any(BluetoothLeBroadcast.Callback.class)); + } + + @Test + public void onStop_flagOn_unregisterCallback() { + mSetFlagsRule.enableFlags(Flags.FLAG_ENABLE_LE_AUDIO_SHARING); mController.onStop(mLifecycleOwner); verify(mBtEventManager).unregisterCallback(mController); verify(mBroadcast).unregisterServiceCallBack(any(BluetoothLeBroadcast.Callback.class)); } + @Test + public void onStop_flagOff_skipUnregisterCallback() { + mSetFlagsRule.disableFlags(Flags.FLAG_ENABLE_LE_AUDIO_SHARING); + mController.onStop(mLifecycleOwner); + verify(mBtEventManager, never()).unregisterCallback(mController); + verify(mBroadcast, never()) + .unregisterServiceCallBack(any(BluetoothLeBroadcast.Callback.class)); + } + @Test public void getAvailabilityStatus_flagOn() { mSetFlagsRule.enableFlags(Flags.FLAG_ENABLE_LE_AUDIO_SHARING); @@ -166,4 +189,42 @@ public class AudioSharingPreferenceControllerTest { assertThat(mPreference.getSummary().toString()) .isEqualTo(mContext.getString(R.string.audio_sharing_summary_off)); } + + @Test + public void testBluetoothLeBroadcastCallbacks_refreshSummary() { + mController.displayPreference(mScreen); + + when(mBroadcast.isEnabled(any())).thenReturn(true); + mController.mBroadcastCallback.onBroadcastStarted(/* reason= */ 1, /* broadcastId= */ 1); + shadowOf(Looper.getMainLooper()).idle(); + assertThat(mPreference.getSummary().toString()) + .isEqualTo(mContext.getString(R.string.audio_sharing_summary_on)); + + when(mBroadcast.isEnabled(any())).thenReturn(false); + mController.mBroadcastCallback.onBroadcastStopped(/* reason= */ 1, /* broadcastId= */ 1); + shadowOf(Looper.getMainLooper()).idle(); + assertThat(mPreference.getSummary().toString()) + .isEqualTo(mContext.getString(R.string.audio_sharing_summary_off)); + } + + @Test + public void testBluetoothLeBroadcastCallbacks_doNothing() { + mController.displayPreference(mScreen); + + mController.mBroadcastCallback.onBroadcastMetadataChanged(/* reason= */ 1, mMetadata); + verify(mPreference, never()).setSummary(any()); + mController.mBroadcastCallback.onBroadcastUpdated(/* reason= */ 1, /* broadcastId= */ 1); + verify(mPreference, never()).setSummary(any()); + mController.mBroadcastCallback.onPlaybackStarted(/* reason= */ 1, /* broadcastId= */ 1); + verify(mPreference, never()).setSummary(any()); + mController.mBroadcastCallback.onPlaybackStopped(/* reason= */ 1, /* broadcastId= */ 1); + verify(mPreference, never()).setSummary(any()); + mController.mBroadcastCallback.onBroadcastStartFailed(/* reason= */ 1); + verify(mPreference, never()).setSummary(any()); + mController.mBroadcastCallback.onBroadcastStopFailed(/* reason= */ 1); + verify(mPreference, never()).setSummary(any()); + mController.mBroadcastCallback.onBroadcastUpdateFailed( + /* reason= */ 1, /* broadcastId= */ 1); + verify(mPreference, never()).setSummary(any()); + } }