diff --git a/src/com/android/settings/connecteddevice/audiosharing/AudioSharingCompatibilityPreferenceController.java b/src/com/android/settings/connecteddevice/audiosharing/AudioSharingCompatibilityPreferenceController.java
index d2f23ed..581ad62 100644
--- a/src/com/android/settings/connecteddevice/audiosharing/AudioSharingCompatibilityPreferenceController.java
+++ b/src/com/android/settings/connecteddevice/audiosharing/AudioSharingCompatibilityPreferenceController.java
@@ -57,9 +57,10 @@
     @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 c3248c7..c7d7407 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.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 @@
     private static final String TAG = "AudioSharingDashboardFrag";
 
     SettingsMainSwitchBar mMainSwitchBar;
-    private AudioSharingSwitchBarController mSwitchBarController;
     private AudioSharingDeviceVolumeGroupController mAudioSharingDeviceVolumeGroupController;
     private AudioSharingCallAudioPreferenceController mAudioSharingCallAudioPreferenceController;
     private AudioSharingPlaySoundPreferenceController mAudioSharingPlaySoundPreferenceController;
@@ -83,9 +84,10 @@
         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 @@
         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 54eb722..d27d3a2 100644
--- a/src/com/android/settings/connecteddevice/audiosharing/AudioSharingPreferenceController.java
+++ b/src/com/android/settings/connecteddevice/audiosharing/AudioSharingPreferenceController.java
@@ -23,6 +23,7 @@
 
 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 @@
     @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 1a9d09e..19221a6 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.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 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 @@
     @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 @@
         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 @@
         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 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 @@
         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 @@
         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 @@
         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 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 c1afeaa..8e4915c 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 @@
 
 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 @@
 
     @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 1bae3d1..b23882d 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 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 b8bee1a..046a4ce 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.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,48 +87,68 @@
     @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);
         assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
@@ -166,4 +189,42 @@
         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());
+    }
 }