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

Commit 9afd28fc authored by timhypeng's avatar timhypeng Committed by tim peng
Browse files

[Fix] Unable to show output device indicator after reboot 

- To fix the NPE in MediaOutputIndicatorWorker
- To get Bluetooth device status in Slice, not in Worker
- To purify Worker to be an event receiver

Bug: 128945026
Test: make -j42 RunSettingsRoboTests
Change-Id: I9360202870c7a43a79641c5b84210c1bfad4b9a6
parent dedeb2bd

src/com/android/settings/media/MediaOutputIndicatorSlice.java

+83 −13
Original line number Diff line number Diff line
@@ -20,35 +20,51 @@ import static com.android.settings.slices.CustomSliceRegistry.MEDIA_OUTPUT_INDIC 


import android.annotation.ColorInt;

import android.app.PendingIntent;

import android.bluetooth.BluetoothDevice;

import android.content.Context;

import android.content.Intent;

import android.net.Uri;

import android.util.Log;



import androidx.annotation.VisibleForTesting;

import androidx.core.graphics.drawable.IconCompat;

import androidx.slice.Slice;

import androidx.slice.builders.ListBuilder;

import androidx.slice.builders.SliceAction;



import com.android.internal.util.CollectionUtils;

import com.android.settings.R;

import com.android.settings.Utils;

import com.android.settings.slices.CustomSliceable;

import com.android.settings.slices.SliceBackgroundWorker;

import com.android.settingslib.bluetooth.A2dpProfile;

import com.android.settingslib.bluetooth.HearingAidProfile;

import com.android.settingslib.bluetooth.LocalBluetoothManager;

import com.android.settingslib.bluetooth.LocalBluetoothProfileManager;

import com.android.settingslib.media.MediaOutputSliceConstants;



import java.util.ArrayList;

import java.util.List;



public class MediaOutputIndicatorSlice implements CustomSliceable {



    private static final String TAG = "MediaOutputIndicatorSlice";



    private Context mContext;

    @VisibleForTesting

    MediaOutputIndicatorWorker mWorker;

    private LocalBluetoothManager mLocalBluetoothManager;

    private LocalBluetoothProfileManager mProfileManager;



    public MediaOutputIndicatorSlice(Context context) {

        mContext = context;

        mLocalBluetoothManager = com.android.settings.bluetooth.Utils.getLocalBtManager(context);

        if (mLocalBluetoothManager == null) {

            Log.e(TAG, "Bluetooth is not supported on this device");

            return;

        }

        mProfileManager = mLocalBluetoothManager.getProfileManager();

    }



    @Override

    public Slice getSlice() {

        if (!getWorker().isVisible()) {

        if (!isVisible()) {

            return null;

        }

        final IconCompat icon = IconCompat.createWithResource(mContext,
@@ -66,18 +82,11 @@ public class MediaOutputIndicatorSlice implements CustomSliceable { 
                .setAccentColor(color)

                .addRow(new ListBuilder.RowBuilder()

                        .setTitle(title)

                        .setSubtitle(getWorker().findActiveDeviceName())

                        .setSubtitle(findActiveDeviceName())

                        .setPrimaryAction(primarySliceAction));

        return listBuilder.build();

    }



    private MediaOutputIndicatorWorker getWorker() {

        if (mWorker == null) {

            mWorker = (MediaOutputIndicatorWorker) SliceBackgroundWorker.getInstance(getUri());

        }

        return mWorker;

    }



    private Intent getMediaOutputSliceIntent() {

        final Intent intent = new Intent()

                .setAction(MediaOutputSliceConstants.ACTION_MEDIA_OUTPUT)
@@ -101,4 +110,65 @@ public class MediaOutputIndicatorSlice implements CustomSliceable { 
    public Class getBackgroundWorkerClass() {

        return MediaOutputIndicatorWorker.class;

    }



    private boolean isVisible() {

        // To decide Slice's visibility.

        // return true if device is connected or previously connected, false for other cases.

        return !CollectionUtils.isEmpty(getConnectableA2dpDevices())

                || !CollectionUtils.isEmpty(getConnectableHearingAidDevices());

    }



    private List<BluetoothDevice> getConnectableA2dpDevices() {

        // Get A2dp devices on all states

        // (STATE_DISCONNECTED, STATE_CONNECTING, STATE_CONNECTED,  STATE_DISCONNECTING)

        final A2dpProfile a2dpProfile = mProfileManager.getA2dpProfile();

        if (a2dpProfile == null) {

            return new ArrayList<>();

        }

        return a2dpProfile.getConnectableDevices();

    }



    private List<BluetoothDevice> getConnectableHearingAidDevices() {

        // Get hearing aid profile devices on all states

        // (STATE_DISCONNECTED, STATE_CONNECTING, STATE_CONNECTED,  STATE_DISCONNECTING)

        final HearingAidProfile hapProfile = mProfileManager.getHearingAidProfile();

        if (hapProfile == null) {

            return new ArrayList<>();

        }



        return hapProfile.getConnectableDevices();

    }



    private CharSequence findActiveDeviceName() {

        // Return Hearing Aid device name if it is active

        BluetoothDevice activeDevice = findActiveHearingAidDevice();

        if (activeDevice != null) {

            return activeDevice.getAliasName();

        }

        // Return A2DP device name if it is active

        final A2dpProfile a2dpProfile = mProfileManager.getA2dpProfile();

        if (a2dpProfile != null) {

            activeDevice = a2dpProfile.getActiveDevice();

            if (activeDevice != null) {

                return activeDevice.getAliasName();

            }

        }

        // No active device, return default summary

        return mContext.getText(R.string.media_output_default_summary);

    }



    private BluetoothDevice findActiveHearingAidDevice() {

        final HearingAidProfile hearingAidProfile = mProfileManager.getHearingAidProfile();

        if (hearingAidProfile == null) {

            return null;

        }



        final List<BluetoothDevice> activeDevices = hearingAidProfile.getActiveDevices();

        for (BluetoothDevice btDevice : activeDevices) {

            if (btDevice != null) {

                return btDevice;

            }

        }

        return null;

    }

}

src/com/android/settings/media/MediaOutputIndicatorWorker.java

+1 −81
Original line number Diff line number Diff line
@@ -16,26 +16,18 @@ 


package com.android.settings.media;



import android.bluetooth.BluetoothDevice;

import android.bluetooth.BluetoothProfile;

import android.content.Context;

import android.net.Uri;

import android.util.Log;



import com.android.internal.util.CollectionUtils;

import com.android.settings.R;

import com.android.settings.bluetooth.Utils;

import com.android.settings.slices.SliceBackgroundWorker;

import com.android.settingslib.bluetooth.A2dpProfile;

import com.android.settingslib.bluetooth.BluetoothCallback;

import com.android.settingslib.bluetooth.CachedBluetoothDevice;

import com.android.settingslib.bluetooth.HearingAidProfile;

import com.android.settingslib.bluetooth.LocalBluetoothManager;

import com.android.settingslib.bluetooth.LocalBluetoothProfileManager;



import java.io.IOException;

import java.util.ArrayList;

import java.util.List;



/**

 * Listener for background change from {@code BluetoothCallback} to update media output indicator.
@@ -45,7 +37,6 @@ public class MediaOutputIndicatorWorker extends SliceBackgroundWorker implements 
    private static final String TAG = "MediaOutputIndicatorWorker";



    private LocalBluetoothManager mLocalBluetoothManager;

    private LocalBluetoothProfileManager mProfileManager;



    public MediaOutputIndicatorWorker(Context context, Uri uri) {

        super(context, uri);
@@ -53,12 +44,11 @@ public class MediaOutputIndicatorWorker extends SliceBackgroundWorker implements 


    @Override

    protected void onSlicePinned() {

        LocalBluetoothManager mLocalBluetoothManager = Utils.getLocalBtManager(getContext());

        mLocalBluetoothManager = Utils.getLocalBtManager(getContext());

        if (mLocalBluetoothManager == null) {

            Log.e(TAG, "Bluetooth is not supported on this device");

            return;

        }

        mProfileManager = mLocalBluetoothManager.getProfileManager();

        mLocalBluetoothManager.getEventManager().registerCallback(this);

    }
@@ -74,7 +64,6 @@ public class MediaOutputIndicatorWorker extends SliceBackgroundWorker implements 
    @Override

    public void close() throws IOException {

        mLocalBluetoothManager = null;

        mProfileManager = null;

    }



    @Override
@@ -89,73 +78,4 @@ public class MediaOutputIndicatorWorker extends SliceBackgroundWorker implements 
            notifySliceChange();

        }

    }



    /**

     * To decide Slice's visibility.

     *

     * @return true if device is connected or previously connected, false for other cases.

     */

    public boolean isVisible() {

        return !CollectionUtils.isEmpty(getConnectableA2dpDevices())

                || !CollectionUtils.isEmpty(getConnectableHearingAidDevices());

    }



    private List<BluetoothDevice> getConnectableA2dpDevices() {

        // get A2dp devices on all states

        // (STATE_DISCONNECTED, STATE_CONNECTING, STATE_CONNECTED,  STATE_DISCONNECTING)

        final A2dpProfile a2dpProfile = mProfileManager.getA2dpProfile();

        if (a2dpProfile == null) {

            return new ArrayList<>();

        }

        return a2dpProfile.getConnectableDevices();

    }



    private List<BluetoothDevice> getConnectableHearingAidDevices() {

        // get hearing aid profile devices on all states

        // (STATE_DISCONNECTED, STATE_CONNECTING, STATE_CONNECTED,  STATE_DISCONNECTING)

        final HearingAidProfile hapProfile = mProfileManager.getHearingAidProfile();

        if (hapProfile == null) {

            return new ArrayList<>();

        }



        return hapProfile.getConnectableDevices();

    }



    /**

     * Get active devices name.

     *

     * @return active Bluetooth device alias, or default summary if no active device.

     */

    public CharSequence findActiveDeviceName() {

        // Return Hearing Aid device name if it is active

        BluetoothDevice activeDevice = findActiveHearingAidDevice();

        if (activeDevice != null) {

            return activeDevice.getAliasName();

        }

        // Return A2DP device name if it is active

        final A2dpProfile a2dpProfile = mProfileManager.getA2dpProfile();

        if (a2dpProfile != null) {

            activeDevice = a2dpProfile.getActiveDevice();

            if (activeDevice != null) {

                return activeDevice.getAliasName();

            }

        }

        // No active device, return default summary

        return getContext().getText(R.string.media_output_default_summary);

    }



    private BluetoothDevice findActiveHearingAidDevice() {

        final HearingAidProfile hearingAidProfile = mProfileManager.getHearingAidProfile();

        if (hearingAidProfile == null) {

            return null;

        }



        final List<BluetoothDevice> activeDevices = hearingAidProfile.getActiveDevices();

        for (BluetoothDevice btDevice : activeDevices) {

            if (btDevice != null) {

                return btDevice;

            }

        }

        return null;

    }

}

tests/robotests/src/com/android/settings/media/MediaOutputIndicatorSliceTest.java

+77 −34
Original line number Diff line number Diff line
@@ -17,35 +17,29 @@ 


package com.android.settings.media;



import static com.android.settings.slices.CustomSliceRegistry.MEDIA_OUTPUT_INDICATOR_SLICE_URI;



import static com.google.common.truth.Truth.assertThat;



import static org.mockito.Mockito.mock;

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 android.bluetooth.BluetoothAdapter;

import android.bluetooth.BluetoothDevice;

import android.bluetooth.BluetoothManager;

import android.content.Context;

import android.content.Intent;



import androidx.slice.Slice;

import androidx.slice.SliceItem;

import androidx.slice.SliceMetadata;

import androidx.slice.SliceProvider;

import androidx.slice.core.SliceAction;

import androidx.slice.widget.SliceLiveData;



import com.android.settings.R;

import com.android.settings.testutils.shadow.ShadowBluetoothAdapter;

import com.android.settingslib.media.LocalMediaManager;

import com.android.settingslib.media.MediaDevice;

import com.android.settingslib.media.MediaOutputSliceConstants;

import com.android.settings.testutils.shadow.ShadowBluetoothUtils;

import com.android.settingslib.bluetooth.A2dpProfile;

import com.android.settingslib.bluetooth.HearingAidProfile;

import com.android.settingslib.bluetooth.LocalBluetoothManager;

import com.android.settingslib.bluetooth.LocalBluetoothProfileManager;



import org.junit.Before;

import org.junit.Ignore;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.Mock;
@@ -53,59 +47,108 @@ import org.mockito.MockitoAnnotations; 
import org.robolectric.RobolectricTestRunner;

import org.robolectric.RuntimeEnvironment;

import org.robolectric.annotation.Config;

import org.robolectric.shadow.api.Shadow;



import java.util.ArrayList;

import java.util.List;



@RunWith(RobolectricTestRunner.class)

@Config(shadows = {ShadowBluetoothAdapter.class})

@Ignore("b/129292771")

@Config(shadows = {ShadowBluetoothUtils.class})

public class MediaOutputIndicatorSliceTest {



    private static final String TEST_DEVICE_NAME = "test_device_name";

    private static final int TEST_DEVICE_1_ICON =

            com.android.internal.R.drawable.ic_bt_headphones_a2dp;

    private static final String TEST_A2DP_DEVICE_NAME = "Test_A2DP_BT_Device_NAME";

    private static final String TEST_HAP_DEVICE_NAME = "Test_HAP_BT_Device_NAME";

    private static final String TEST_A2DP_DEVICE_ADDRESS = "00:A1:A1:A1:A1:A1";

    private static final String TEST_HAP_DEVICE_ADDRESS = "00:B2:B2:B2:B2:B2";



    @Mock

    private LocalMediaManager mLocalMediaManager;



    private final List<MediaDevice> mDevices = new ArrayList<>();

    private A2dpProfile mA2dpProfile;

    @Mock

    private HearingAidProfile mHearingAidProfile;

    @Mock

    private LocalBluetoothManager mLocalBluetoothManager;

    @Mock

    private LocalBluetoothProfileManager mLocalBluetoothProfileManager;



    private BluetoothAdapter mBluetoothAdapter;

    private BluetoothDevice mA2dpDevice;

    private BluetoothDevice mHapDevice;

    private BluetoothManager mBluetoothManager;

    private Context mContext;

    private List<BluetoothDevice> mDevicesList;

    private MediaOutputIndicatorSlice mMediaOutputIndicatorSlice;

    private MediaOutputIndicatorWorker mMediaOutputIndicatorWorker;

    private ShadowBluetoothAdapter mShadowBluetoothAdapter;



    @Before

    public void setUp() throws Exception {

        MockitoAnnotations.initMocks(this);

        mContext = spy(RuntimeEnvironment.application);



        // Set-up specs for SliceMetadata.

        SliceProvider.setSpecs(SliceLiveData.SUPPORTED_SPECS);



        // Setup Bluetooth environment

        ShadowBluetoothUtils.sLocalBluetoothManager = mLocalBluetoothManager;

        mBluetoothManager = new BluetoothManager(mContext);

        mBluetoothAdapter = mBluetoothManager.getAdapter();

        when(mLocalBluetoothManager.getProfileManager()).thenReturn(mLocalBluetoothProfileManager);

        when(mLocalBluetoothProfileManager.getA2dpProfile()).thenReturn(mA2dpProfile);

        when(mLocalBluetoothProfileManager.getHearingAidProfile()).thenReturn(mHearingAidProfile);



        // Setup A2dp device

        mA2dpDevice = spy(mBluetoothAdapter.getRemoteDevice(TEST_A2DP_DEVICE_ADDRESS));

        when(mA2dpDevice.getName()).thenReturn(TEST_A2DP_DEVICE_NAME);

        when(mA2dpDevice.isConnected()).thenReturn(true);

        // Setup HearingAid device

        mHapDevice = spy(mBluetoothAdapter.getRemoteDevice(TEST_HAP_DEVICE_ADDRESS));

        when(mHapDevice.getName()).thenReturn(TEST_HAP_DEVICE_NAME);

        when(mHapDevice.isConnected()).thenReturn(true);



        mMediaOutputIndicatorSlice = new MediaOutputIndicatorSlice(mContext);

        mMediaOutputIndicatorWorker = spy(new MediaOutputIndicatorWorker(

                mContext, MEDIA_OUTPUT_INDICATOR_SLICE_URI));

        mMediaOutputIndicatorSlice.mWorker = mMediaOutputIndicatorWorker;

        mDevicesList = new ArrayList<>();

    }



    @Test

    public void getSlice_invisible_returnNull() {

        when(mMediaOutputIndicatorWorker.isVisible()).thenReturn(false);

    public void getSlice_noConnectableDevice_returnNull() {

        mDevicesList.clear();

        when(mA2dpProfile.getConnectableDevices()).thenReturn(mDevicesList);



        assertThat(mMediaOutputIndicatorSlice.getSlice()).isNull();

    }



    @Test

    public void getSlice_withActiveDevice_checkContent() {

        when(mMediaOutputIndicatorWorker.isVisible()).thenReturn(true);

        when(mMediaOutputIndicatorWorker.findActiveDeviceName()).thenReturn(TEST_DEVICE_NAME);

    public void getSlice_noActiveDevice_verifyDefaultName() {

        mDevicesList.add(mA2dpDevice);

        when(mA2dpProfile.getConnectableDevices()).thenReturn(mDevicesList);

        when(mA2dpProfile.getActiveDevice()).thenReturn(null);



        // Verify slice title and subtitle

        final Slice mediaSlice = mMediaOutputIndicatorSlice.getSlice();

        final SliceMetadata metadata = SliceMetadata.from(mContext, mediaSlice);

        assertThat(metadata.getTitle()).isEqualTo(mContext.getText(R.string.media_output_title));

        assertThat(metadata.getSubtitle()).isEqualTo(mContext.getText(

                R.string.media_output_default_summary));

    }



    @Test

    public void getSlice_A2dpDeviceActive_verifyName() {

        mDevicesList.add(mA2dpDevice);

        when(mA2dpProfile.getConnectableDevices()).thenReturn(mDevicesList);

        when(mA2dpProfile.getActiveDevice()).thenReturn(mA2dpDevice);



        final Slice mediaSlice = mMediaOutputIndicatorSlice.getSlice();

        final SliceMetadata metadata = SliceMetadata.from(mContext, mediaSlice);

        assertThat(metadata.getTitle()).isEqualTo(mContext.getText(R.string.media_output_title));

        assertThat(metadata.getSubtitle()).isEqualTo(TEST_A2DP_DEVICE_NAME);

    }



    @Test

    public void getSlice_HADeviceActive_verifyName() {

        mDevicesList.add(mHapDevice);

        when(mHearingAidProfile.getConnectableDevices()).thenReturn(mDevicesList);

        when(mHearingAidProfile.getActiveDevices()).thenReturn(mDevicesList);



        // Verify slice title and subtitle

        final Slice mediaSlice = mMediaOutputIndicatorSlice.getSlice();

        final SliceMetadata metadata = SliceMetadata.from(mContext, mediaSlice);

        assertThat(metadata.getTitle()).isEqualTo(mContext.getText(R.string.media_output_title));

        assertThat(metadata.getSubtitle()).isEqualTo(TEST_DEVICE_NAME);

        assertThat(metadata.getSubtitle()).isEqualTo(TEST_HAP_DEVICE_NAME);

    }

}

tests/robotests/src/com/android/settings/media/MediaOutputIndicatorWorkerTest.java

+11 −102
Original line number Diff line number Diff line
@@ -16,28 +16,18 @@ 


package com.android.settings.media;



import static com.google.common.truth.Truth.assertThat;



import static org.mockito.Mockito.spy;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;



import android.bluetooth.BluetoothAdapter;

import android.bluetooth.BluetoothDevice;

import android.bluetooth.BluetoothManager;

import android.content.Context;

import android.net.Uri;



import com.android.settings.R;

import com.android.settings.bluetooth.Utils;

import com.android.settings.testutils.shadow.ShadowBluetoothUtils;

import com.android.settingslib.bluetooth.A2dpProfile;

import com.android.settingslib.bluetooth.BluetoothEventManager;

import com.android.settingslib.bluetooth.HearingAidProfile;

import com.android.settingslib.bluetooth.LocalBluetoothManager;

import com.android.settingslib.bluetooth.LocalBluetoothProfileManager;



import org.junit.Before;

import org.junit.Ignore;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.Mock;
@@ -45,119 +35,38 @@ import org.mockito.MockitoAnnotations; 
import org.robolectric.RobolectricTestRunner;

import org.robolectric.RuntimeEnvironment;

import org.robolectric.annotation.Config;

import org.robolectric.shadows.ShadowBluetoothDevice;



import java.util.ArrayList;

import java.util.List;



@RunWith(RobolectricTestRunner.class)

@Config(shadows = {ShadowBluetoothUtils.class,

        ShadowBluetoothDevice.class})

@Ignore("b/129292771")

@Config(shadows = {ShadowBluetoothUtils.class})

public class MediaOutputIndicatorWorkerTest {



    private static final String TEST_A2DP_DEVICE_NAME = "Test_A2DP_BT_Device_NAME";

    private static final String TEST_HAP_DEVICE_NAME = "Test_HAP_BT_Device_NAME";

    private static final String TEST_A2DP_DEVICE_ADDRESS = "00:A1:A1:A1:A1:A1";

    private static final String TEST_HAP_DEVICE_ADDRESS = "00:B2:B2:B2:B2:B2";

    private static final Uri URI = Uri.parse("content://com.android.settings.slices/test");



    @Mock

    private A2dpProfile mA2dpProfile;

    @Mock

    private HearingAidProfile mHearingAidProfile;

    @Mock

    private LocalBluetoothManager mLocalManager;

    @Mock

    private BluetoothEventManager mBluetoothEventManager;

    @Mock

    private LocalBluetoothProfileManager mLocalBluetoothProfileManager;



    private BluetoothAdapter mBluetoothAdapter;

    private BluetoothDevice mA2dpDevice;

    private BluetoothDevice mHapDevice;

    private BluetoothManager mBluetoothManager;

    private Context mContext;

    private List<BluetoothDevice> mDevicesList;

    private LocalBluetoothManager mLocalBluetoothManager;

    private Context mContext;

    private MediaOutputIndicatorWorker mMediaDeviceUpdateWorker;



    @Before

    public void setUp() {

        MockitoAnnotations.initMocks(this);

        mContext = spy(RuntimeEnvironment.application);

        ShadowBluetoothUtils.sLocalBluetoothManager = mLocalManager;

        mLocalBluetoothManager = Utils.getLocalBtManager(mContext);

        ShadowBluetoothUtils.sLocalBluetoothManager = mLocalBluetoothManager;

        when(mLocalBluetoothManager.getEventManager()).thenReturn(mBluetoothEventManager);

        when(mLocalBluetoothManager.getProfileManager()).thenReturn(mLocalBluetoothProfileManager);

        when(mLocalBluetoothProfileManager.getA2dpProfile()).thenReturn(mA2dpProfile);

        when(mLocalBluetoothProfileManager.getHearingAidProfile()).thenReturn(mHearingAidProfile);

        mBluetoothManager = new BluetoothManager(mContext);

        mBluetoothAdapter = mBluetoothManager.getAdapter();



        // Setup A2dp device

        mA2dpDevice = spy(mBluetoothAdapter.getRemoteDevice(TEST_A2DP_DEVICE_ADDRESS));

        when(mA2dpDevice.getName()).thenReturn(TEST_A2DP_DEVICE_NAME);

        when(mA2dpDevice.isConnected()).thenReturn(true);

        // Setup HearingAid device

        mHapDevice = spy(mBluetoothAdapter.getRemoteDevice(TEST_HAP_DEVICE_ADDRESS));

        when(mHapDevice.getName()).thenReturn(TEST_HAP_DEVICE_NAME);

        when(mHapDevice.isConnected()).thenReturn(true);



        mMediaDeviceUpdateWorker = new MediaOutputIndicatorWorker(mContext, URI);

        mDevicesList = new ArrayList<>();

    }



    @Test

    public void isVisible_noConnectableDevice_returnFalse() {

        mDevicesList.clear();

        when(mA2dpProfile.getConnectableDevices()).thenReturn(mDevicesList);



        assertThat(mMediaDeviceUpdateWorker.isVisible()).isFalse();

    public void onSlicePinned_registerCallback() {

        mMediaDeviceUpdateWorker.onSlicePinned();

        verify(mBluetoothEventManager).registerCallback(mMediaDeviceUpdateWorker);

    }



    @Test

    public void isVisible_withConnectableA2dpDevice_returnTrue() {

        mDevicesList.clear();

        mDevicesList.add(mA2dpDevice);

        when(mHearingAidProfile.getConnectableDevices()).thenReturn(mDevicesList);



        assertThat(mMediaDeviceUpdateWorker.isVisible()).isTrue();

    }



    @Test

    public void isVisible_withConnectableHADevice_returnTrue() {

        mDevicesList.clear();

        mDevicesList.add(mHapDevice);

        when(mA2dpProfile.getConnectableDevices()).thenReturn(mDevicesList);



        assertThat(mMediaDeviceUpdateWorker.isVisible()).isTrue();

    }



    @Test

    public void findActiveDeviceName_A2dpDeviceActive_verifyName() {

        when(mA2dpProfile.getActiveDevice()).thenReturn(mA2dpDevice);



        assertThat(mMediaDeviceUpdateWorker.findActiveDeviceName())

                .isEqualTo(mA2dpDevice.getAliasName());

    }



    @Test

    public void findActiveDeviceName_HADeviceActive_verifyName() {

        mDevicesList.add(mHapDevice);

        when(mHearingAidProfile.getActiveDevices()).thenReturn(mDevicesList);



        assertThat(mMediaDeviceUpdateWorker.findActiveDeviceName())

                .isEqualTo(mHapDevice.getAliasName());

    }



    @Test

    public void findActiveDeviceName_noActiveDevice_verifyDefaultName() {

        when(mA2dpProfile.getActiveDevice()).thenReturn(null);

        mDevicesList.clear();

        when(mHearingAidProfile.getActiveDevices()).thenReturn(mDevicesList);



        assertThat(mMediaDeviceUpdateWorker.findActiveDeviceName())

                .isEqualTo(mContext.getText(R.string.media_output_default_summary));

    public void onSliceUnpinned_unRegisterCallback() {

        mMediaDeviceUpdateWorker.onSlicePinned();

        mMediaDeviceUpdateWorker.onSliceUnpinned();

        verify(mBluetoothEventManager).unregisterCallback(mMediaDeviceUpdateWorker);

    }

}