Merge "Pop up pairing another ear dialog when detecting hearing aid is a set" into tm-dev am: 13438e6084

Original change: https://googleplex-android-review.googlesource.com/c/platform/packages/apps/Settings/+/17291804

Change-Id: Ie8e5fb7f0811b546ecbc1025ed80565fd1bbb608
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

tests/robotests/src/com/android/settings/accessibility/AccessibilityHearingAidPreferenceControllerTest.java

@@ -19,6 +19,7 @@ package com.android.settings.accessibility;
 import static com.google.common.truth.Truth.assertThat;
 
 import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -32,12 +33,16 @@ import android.bluetooth.BluetoothProfile;
 import android.content.BroadcastReceiver;
 import android.content.Intent;
 
+import androidx.appcompat.app.AlertDialog;
+import androidx.fragment.app.FragmentActivity;
 import androidx.preference.Preference;
 
 import com.android.settings.R;
 import com.android.settings.bluetooth.Utils;
+import com.android.settings.testutils.shadow.ShadowAlertDialogCompat;
 import com.android.settings.testutils.shadow.ShadowBluetoothAdapter;
 import com.android.settings.testutils.shadow.ShadowBluetoothUtils;
+import com.android.settingslib.bluetooth.BluetoothEventManager;
 import com.android.settingslib.bluetooth.CachedBluetoothDevice;
 import com.android.settingslib.bluetooth.CachedBluetoothDeviceManager;
 import com.android.settingslib.bluetooth.HearingAidProfile;
@@ -59,6 +64,7 @@ import org.robolectric.shadows.ShadowApplication;
 import java.util.ArrayList;
 import java.util.List;
 
+/** Tests for {@link AccessibilityHearingAidPreferenceController}. */
 @RunWith(RobolectricTestRunner.class)
 @Config(shadows = {ShadowBluetoothAdapter.class, ShadowBluetoothUtils.class})
 public class AccessibilityHearingAidPreferenceControllerTest {
@@ -84,6 +90,8 @@ public class AccessibilityHearingAidPreferenceControllerTest {
     @Mock
     private LocalBluetoothManager mLocalBluetoothManager;
     @Mock
+    private BluetoothEventManager mEventManager;
+    @Mock
     private LocalBluetoothProfileManager mLocalBluetoothProfileManager;
     @Mock
     private HearingAidProfile mHearingAidProfile;
@@ -221,6 +229,24 @@ public class AccessibilityHearingAidPreferenceControllerTest {
         assertThat(mPreferenceController.getConnectedHearingAidDevice()).isNull();
     }
 
+    @Test
+    @Config(shadows = ShadowAlertDialogCompat.class)
+    public void onActiveDeviceChanged_hearingAidProfile_launchHearingAidPairingDialog() {
+        final FragmentActivity mActivity = Robolectric.setupActivity(FragmentActivity.class);
+        when(mCachedBluetoothDevice.isConnectedHearingAidDevice()).thenReturn(true);
+        when(mCachedBluetoothDevice.getDeviceMode()).thenReturn(
+                HearingAidProfile.DeviceMode.MODE_BINAURAL);
+        when(mCachedBluetoothDevice.getDeviceSide()).thenReturn(
+                HearingAidProfile.DeviceSide.SIDE_LEFT);
+        mPreferenceController.setFragmentManager(mActivity.getSupportFragmentManager());
+
+        mPreferenceController.onActiveDeviceChanged(mCachedBluetoothDevice,
+                BluetoothProfile.HEARING_AID);
+
+        final AlertDialog dialog = ShadowAlertDialogCompat.getLatestAlertDialog();
+        assertThat(dialog.isShowing()).isTrue();
+    }
+
     private void setupBluetoothEnvironment() {
         ShadowBluetoothUtils.sLocalBluetoothManager = mLocalBluetoothManager;
         mLocalBluetoothManager = Utils.getLocalBtManager(mContext);
@@ -229,6 +255,7 @@ public class AccessibilityHearingAidPreferenceControllerTest {
         when(mLocalBluetoothManager.getCachedDeviceManager()).thenReturn(mCachedDeviceManager);
         when(mLocalBluetoothManager.getProfileManager()).thenReturn(mLocalBluetoothProfileManager);
         when(mLocalBluetoothProfileManager.getHearingAidProfile()).thenReturn(mHearingAidProfile);
+        doReturn(mEventManager).when(mLocalBluetoothManager).getEventManager();
     }
 
     private void setupHearingAidEnvironment() {
@@ -239,7 +266,6 @@ public class AccessibilityHearingAidPreferenceControllerTest {
         mShadowBluetoothAdapter.addSupportedProfiles(BluetoothProfile.HEARING_AID);
         when(mCachedDeviceManager.findDevice(mBluetoothDevice)).thenReturn(mCachedBluetoothDevice);
         when(mCachedBluetoothDevice.getName()).thenReturn(TEST_DEVICE_NAME);
-        when(mCachedBluetoothDevice.isConnectedHearingAidDevice()).thenReturn(true);
     }
 
     private void sendIntent(Intent intent) {

tests/robotests/src/com/android/settings/accessibility/AccessibilitySettingsTest.java

@@ -58,6 +58,7 @@ import com.android.settings.testutils.XmlTestUtils;
 import com.android.settings.testutils.shadow.ShadowFragment;
 import com.android.settings.testutils.shadow.ShadowUserManager;
 import com.android.settingslib.RestrictedPreference;
+import com.android.settingslib.core.lifecycle.Lifecycle;
 import com.android.settingslib.search.SearchIndexableRaw;
 
 import org.junit.Before;
@@ -93,6 +94,7 @@ public class AccessibilitySettingsTest {
     private static final String DEFAULT_LABEL = "default label";
     private static final Boolean SERVICE_ENABLED = true;
     private static final Boolean SERVICE_DISABLED = false;
+
     @Rule
     public final MockitoRule mocks = MockitoJUnit.rule();
     @Spy
@@ -114,6 +116,8 @@ public class AccessibilitySettingsTest {
     @Mock
     private AppOpsManager mAppOpsManager;
 
+    private Lifecycle mLifecycle;
+
     @Before
     public void setup() {
         mShadowAccessibilityManager = Shadow.extract(AccessibilityManager.getInstance(mContext));
@@ -127,6 +131,8 @@ public class AccessibilitySettingsTest {
         when(mContext.getSystemService(AppOpsManager.class)).thenReturn(mAppOpsManager);
         when(mAppOpsManager.noteOpNoThrow(eq(AppOpsManager.OP_ACCESS_RESTRICTED_SETTINGS),
                 anyInt(), anyString())).thenReturn(AppOpsManager.MODE_ALLOWED);
+        mLifecycle = new Lifecycle(() -> mLifecycle);
+        when(mFragment.getSettingsLifecycle()).thenReturn(mLifecycle);
     }
 
     @Test

tests/robotests/src/com/android/settings/accessibility/HearingAidPairingDialogFragmentTest.java

@@ -0,0 +1,105 @@
+/*
+ * 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.settings.accessibility;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+import static org.robolectric.Shadows.shadowOf;
+
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.Bundle;
+
+import androidx.appcompat.app.AlertDialog;
+import androidx.fragment.app.FragmentActivity;
+
+import com.android.settings.SettingsActivity;
+import com.android.settings.bluetooth.BluetoothPairingDetail;
+import com.android.settings.bluetooth.HearingAidPairingDialogFragment;
+import com.android.settings.testutils.shadow.ShadowAlertDialogCompat;
+import com.android.settingslib.bluetooth.CachedBluetoothDevice;
+import com.android.settingslib.bluetooth.HearingAidProfile;
+
+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.Robolectric;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+/** Tests for {@link HearingAidPairingDialogFragment}. */
+@RunWith(RobolectricTestRunner.class)
+@Config(shadows = ShadowAlertDialogCompat.class)
+public class HearingAidPairingDialogFragmentTest {
+
+    @Rule
+    public final MockitoRule mockito = MockitoJUnit.rule();
+
+    private static final String KEY_CACHED_DEVICE_SIDE = "cached_device_side";
+
+    @Mock
+    private CachedBluetoothDevice mCachedBluetoothDevice;
+    private FragmentActivity mActivity;
+    private HearingAidPairingDialogFragment mFragment;
+
+    @Before
+    public void setUp() {
+        mFragment = spy(HearingAidPairingDialogFragment.newInstance(mCachedBluetoothDevice));
+        mActivity = Robolectric.setupActivity(FragmentActivity.class);
+        when(mFragment.getActivity()).thenReturn(mActivity);
+    }
+
+    @Test
+    public void newInstance_deviceSideRight_argumentSideRight() {
+        when(mCachedBluetoothDevice.getDeviceSide()).thenReturn(
+                HearingAidProfile.DeviceSide.SIDE_RIGHT);
+
+        mFragment = HearingAidPairingDialogFragment.newInstance(mCachedBluetoothDevice);
+
+        final Bundle bundle = mFragment.getArguments();
+        assertThat(bundle.getInt(KEY_CACHED_DEVICE_SIDE)).isEqualTo(
+                HearingAidProfile.DeviceSide.SIDE_RIGHT);
+    }
+
+    @Test
+    public void dialogPositiveButtonClick_intentToExpectedClass() {
+        final AlertDialog dialog = (AlertDialog) mFragment.onCreateDialog(Bundle.EMPTY);
+        dialog.show();
+
+        dialog.getButton(DialogInterface.BUTTON_POSITIVE).performClick();
+
+        final Intent intent = shadowOf(mActivity).getNextStartedActivity();
+        assertThat(intent.getStringExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT))
+                .isEqualTo(BluetoothPairingDetail.class.getName());
+    }
+
+    @Test
+    public void dialogNegativeButtonClick_dismissDialog() {
+        final AlertDialog dialog = (AlertDialog) mFragment.onCreateDialog(Bundle.EMPTY);
+        dialog.show();
+
+        dialog.getButton(DialogInterface.BUTTON_NEGATIVE).performClick();
+
+        assertThat(dialog.isShowing()).isFalse();
+    }
+}

tests/robotests/src/com/android/settings/accessibility/HearingAidUtilsTest.java

@@ -0,0 +1,130 @@
+/*
+ * 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.settings.accessibility;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.when;
+
+import androidx.appcompat.app.AlertDialog;
+import androidx.fragment.app.FragmentActivity;
+import androidx.fragment.app.FragmentManager;
+
+import com.android.settings.testutils.shadow.ShadowAlertDialogCompat;
+import com.android.settingslib.bluetooth.CachedBluetoothDevice;
+import com.android.settingslib.bluetooth.HearingAidProfile;
+
+import org.junit.After;
+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.Robolectric;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+/** Tests for {@link HearingAidUtils}. */
+@RunWith(RobolectricTestRunner.class)
+@Config(shadows = ShadowAlertDialogCompat.class)
+public class HearingAidUtilsTest {
+
+    @Rule
+    public final MockitoRule mockito = MockitoJUnit.rule();
+
+    @Mock
+    private CachedBluetoothDevice mCachedBluetoothDevice;
+    @Mock
+    private CachedBluetoothDevice mSubCachedBluetoothDevice;
+
+    private FragmentManager mFragmentManager;
+
+    @Before
+    public void setUp() {
+        final FragmentActivity mActivity = Robolectric.setupActivity(FragmentActivity.class);
+        mFragmentManager = mActivity.getSupportFragmentManager();
+    }
+
+    @After
+    public void tearDown() {
+        ShadowAlertDialogCompat.reset();
+    }
+    @Test
+    public void launchHearingAidPairingDialog_deviceNotConnectedHearingAid_noDialog() {
+        when(mCachedBluetoothDevice.isConnectedHearingAidDevice()).thenReturn(false);
+
+        HearingAidUtils.launchHearingAidPairingDialog(mFragmentManager, mCachedBluetoothDevice);
+
+        final AlertDialog dialog = ShadowAlertDialogCompat.getLatestAlertDialog();
+        assertThat(dialog).isNull();
+    }
+
+    @Test
+    public void launchHearingAidPairingDialog_deviceIsModeMonaural_noDialog() {
+        when(mCachedBluetoothDevice.isConnectedHearingAidDevice()).thenReturn(true);
+        when(mCachedBluetoothDevice.getDeviceMode()).thenReturn(
+                HearingAidProfile.DeviceMode.MODE_MONAURAL);
+
+        HearingAidUtils.launchHearingAidPairingDialog(mFragmentManager, mCachedBluetoothDevice);
+
+        final AlertDialog dialog = ShadowAlertDialogCompat.getLatestAlertDialog();
+        assertThat(dialog).isNull();
+    }
+
+    @Test
+    public void launchHearingAidPairingDialog_deviceHasSubDevice_noDialog() {
+        when(mCachedBluetoothDevice.isConnectedHearingAidDevice()).thenReturn(true);
+        when(mCachedBluetoothDevice.getDeviceMode()).thenReturn(
+                HearingAidProfile.DeviceMode.MODE_BINAURAL);
+        when(mCachedBluetoothDevice.getSubDevice()).thenReturn(mSubCachedBluetoothDevice);
+
+        HearingAidUtils.launchHearingAidPairingDialog(mFragmentManager, mCachedBluetoothDevice);
+
+        final AlertDialog dialog = ShadowAlertDialogCompat.getLatestAlertDialog();
+        assertThat(dialog).isNull();
+    }
+
+    @Test
+    public void launchHearingAidPairingDialog_deviceIsInvalidSide_noDialog() {
+        when(mCachedBluetoothDevice.isConnectedHearingAidDevice()).thenReturn(true);
+        when(mCachedBluetoothDevice.getDeviceMode()).thenReturn(
+                HearingAidProfile.DeviceMode.MODE_BINAURAL);
+        when(mCachedBluetoothDevice.getDeviceSide()).thenReturn(
+                HearingAidProfile.DeviceSide.SIDE_INVALID);
+
+        HearingAidUtils.launchHearingAidPairingDialog(mFragmentManager, mCachedBluetoothDevice);
+
+        final AlertDialog dialog = ShadowAlertDialogCompat.getLatestAlertDialog();
+        assertThat(dialog).isNull();
+    }
+
+    @Test
+    public void launchHearingAidPairingDialog_dialogShown() {
+        when(mCachedBluetoothDevice.isConnectedHearingAidDevice()).thenReturn(true);
+        when(mCachedBluetoothDevice.getDeviceMode()).thenReturn(
+                HearingAidProfile.DeviceMode.MODE_BINAURAL);
+        when(mCachedBluetoothDevice.getDeviceSide()).thenReturn(
+                HearingAidProfile.DeviceSide.SIDE_LEFT);
+
+        HearingAidUtils.launchHearingAidPairingDialog(mFragmentManager, mCachedBluetoothDevice);
+
+        final AlertDialog dialog = ShadowAlertDialogCompat.getLatestAlertDialog();
+        assertThat(dialog.isShowing()).isTrue();
+    }
+}

tests/robotests/src/com/android/settings/connecteddevice/AvailableMediaDeviceGroupControllerTest.java

@@ -27,10 +27,13 @@ import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import android.bluetooth.BluetoothProfile;
 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.media.AudioManager;
 
+import androidx.appcompat.app.AlertDialog;
+import androidx.fragment.app.FragmentActivity;
 import androidx.preference.Preference;
 import androidx.preference.PreferenceGroup;
 import androidx.preference.PreferenceManager;
@@ -40,25 +43,31 @@ import com.android.settings.R;
 import com.android.settings.bluetooth.AvailableMediaBluetoothDeviceUpdater;
 import com.android.settings.bluetooth.Utils;
 import com.android.settings.dashboard.DashboardFragment;
+import com.android.settings.testutils.shadow.ShadowAlertDialogCompat;
 import com.android.settings.testutils.shadow.ShadowAudioManager;
+import com.android.settings.testutils.shadow.ShadowBluetoothAdapter;
 import com.android.settings.testutils.shadow.ShadowBluetoothUtils;
 import com.android.settingslib.bluetooth.BluetoothCallback;
 import com.android.settingslib.bluetooth.BluetoothEventManager;
+import com.android.settingslib.bluetooth.CachedBluetoothDevice;
+import com.android.settingslib.bluetooth.HearingAidProfile;
 import com.android.settingslib.bluetooth.LocalBluetoothManager;
 
-import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Answers;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
+import org.robolectric.Robolectric;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.RuntimeEnvironment;
 import org.robolectric.annotation.Config;
 
+/** Tests for {@link AvailableMediaDeviceGroupController}. */
 @RunWith(RobolectricTestRunner.class)
-@Config(shadows = {ShadowAudioManager.class, ShadowBluetoothUtils.class})
+@Config(shadows = {ShadowAudioManager.class, ShadowBluetoothAdapter.class,
+        ShadowBluetoothUtils.class})
 public class AvailableMediaDeviceGroupControllerTest {
 
     private static final String PREFERENCE_KEY_1 = "pref_key_1";
@@ -77,6 +86,8 @@ public class AvailableMediaDeviceGroupControllerTest {
     private BluetoothEventManager mEventManager;
     @Mock
     private LocalBluetoothManager mLocalManager;
+    @Mock
+    private CachedBluetoothDevice mCachedBluetoothDevice;
 
     private PreferenceGroup mPreferenceGroup;
     private Context mContext;
@@ -93,27 +104,26 @@ public class AvailableMediaDeviceGroupControllerTest {
         mPreference = new Preference(mContext);
         mPreference.setKey(PREFERENCE_KEY_1);
         mPreferenceGroup = spy(new PreferenceScreen(mContext, null));
+        final FragmentActivity mActivity = Robolectric.setupActivity(FragmentActivity.class);
         when(mPreferenceGroup.getPreferenceManager()).thenReturn(mPreferenceManager);
         doReturn(mContext).when(mDashboardFragment).getContext();
         doReturn(mPackageManager).when(mContext).getPackageManager();
         doReturn(true).when(mPackageManager).hasSystemFeature(PackageManager.FEATURE_BLUETOOTH);
+        when(mDashboardFragment.getParentFragmentManager()).thenReturn(
+                mActivity.getSupportFragmentManager());
 
         ShadowBluetoothUtils.sLocalBluetoothManager = mLocalManager;
         mLocalBluetoothManager = Utils.getLocalBtManager(mContext);
         mAudioManager = mContext.getSystemService(AudioManager.class);
         doReturn(mEventManager).when(mLocalBluetoothManager).getEventManager();
 
-        mAvailableMediaDeviceGroupController = new AvailableMediaDeviceGroupController(mContext);
+        mAvailableMediaDeviceGroupController = spy(
+                new AvailableMediaDeviceGroupController(mContext));
         mAvailableMediaDeviceGroupController.
                 setBluetoothDeviceUpdater(mAvailableMediaBluetoothDeviceUpdater);
         mAvailableMediaDeviceGroupController.mPreferenceGroup = mPreferenceGroup;
     }
 
-    @After
-    public void tearDown() {
-        ShadowBluetoothUtils.reset();
-    }
-
     @Test
     public void onDeviceAdded_firstAdd_becomeVisibleAndPreferenceAdded() {
         mAvailableMediaDeviceGroupController.onDeviceAdded(mPreference);
@@ -222,4 +232,21 @@ public class AvailableMediaDeviceGroupControllerTest {
         // Shouldn't crash
         mAvailableMediaDeviceGroupController.onStop();
     }
+
+    @Test
+    @Config(shadows = ShadowAlertDialogCompat.class)
+    public void onActiveDeviceChanged_hearingAidProfile_launchHearingAidPairingDialog() {
+        when(mCachedBluetoothDevice.isConnectedHearingAidDevice()).thenReturn(true);
+        when(mCachedBluetoothDevice.getDeviceMode()).thenReturn(
+                HearingAidProfile.DeviceMode.MODE_BINAURAL);
+        when(mCachedBluetoothDevice.getDeviceSide()).thenReturn(
+                HearingAidProfile.DeviceSide.SIDE_LEFT);
+        mAvailableMediaDeviceGroupController.init(mDashboardFragment);
+
+        mAvailableMediaDeviceGroupController.onActiveDeviceChanged(mCachedBluetoothDevice,
+                BluetoothProfile.HEARING_AID);
+
+        final AlertDialog dialog = ShadowAlertDialogCompat.getLatestAlertDialog();
+        assertThat(dialog.isShowing()).isTrue();
+    }
 }