Merge "Remove all associaitons when forget a device in Settings" into main

aconfig/settings_bluetooth_declarations.aconfig

@@ -54,3 +54,11 @@ flag {
       purpose: PURPOSE_BUGFIX
   }
 }
+
+flag {
+  name: "enable_remove_association_bt_unpair"
+  is_exported: true
+  namespace: "companion_device_manager"
+  description: "Allow to disassociate when to forget a BT pair device"
+  bug: "365613753"
+ }

res-product/values/strings.xml

@@ -419,6 +419,12 @@
     <string name="bluetooth_unpair_dialog_body" product="tablet">Your tablet will no longer be paired with <xliff:g id="device_name">%1$s</xliff:g></string>
     <!--  Bluetooth device details. The body of a confirmation dialog for unpairing a paired device. -->
     <string name="bluetooth_unpair_dialog_body" product="device">Your device will no longer be paired with <xliff:g id="device_name">%1$s</xliff:g></string>
+    <!-- Bluetooth device details. The body of a confirmation dialog for unpairing a paired device if there's any associations associated with this device [CHAR_LIMIT=NONE] -->
+    <string name="bluetooth_unpair_dialog_with_associations_body" product="default">Your phone will no longer be paired with <xliff:g id="device_name">%1$s</xliff:g>.\u0020<xliff:g id="app_name">%2$s</xliff:g> will no longer manage the device</string>
+    <!-- Bluetooth device details. The body of a confirmation dialog for unpairing a paired device if there's any associations associated with this device [CHAR_LIMIT=NONE] -->
+    <string name="bluetooth_unpair_dialog_with_associations_body" product="tablet">Your tablet will no longer be paired with <xliff:g id="device_name">%1$s</xliff:g>.\u0020<xliff:g id="app_name">%2$s</xliff:g> will no longer manage the device</string>
+    <!-- Bluetooth device details. The body of a confirmation dialog for unpairing a paired device if there's any associations associated with this device [CHAR_LIMIT=NONE] -->
+    <string name="bluetooth_unpair_dialog_with_associations_body" product="device">Your device will no longer be paired with <xliff:g id="device_name">%1$s</xliff:g>.\u0020<xliff:g id="app_name">%2$s</xliff:g> will no longer manage the device</string>
     <!--  Virtual device details. The body of a confirmation dialog for unpairing a paired device. [CHAR LIMIT=none] -->
     <string name="virtual_device_forget_dialog_body" product="default"><xliff:g id="device_name">%1$s</xliff:g> will no longer be connected to this phone. If you continue, some apps and app streaming may stop working.</string>
     <!--  Virtual device details. The body of a confirmation dialog for unpairing a paired device. [CHAR LIMIT=none] -->

src/com/android/settings/bluetooth/ForgetDeviceDialogFragment.java

@@ -16,31 +16,52 @@
 
 package com.android.settings.bluetooth;
 
+import static com.android.internal.util.CollectionUtils.filter;
+
 import android.app.Activity;
 import android.app.Dialog;
 import android.app.settings.SettingsEnums;
 import android.bluetooth.BluetoothDevice;
+import android.companion.AssociationInfo;
+import android.companion.CompanionDeviceManager;
 import android.content.Context;
 import android.content.DialogInterface;
+import android.content.pm.PackageManager;
+import android.icu.text.ListFormatter;
 import android.os.Bundle;
+import android.text.TextUtils;
 import android.util.Log;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;
 import androidx.appcompat.app.AlertDialog;
 
 import com.android.settings.R;
 import com.android.settings.core.instrumentation.InstrumentedDialogFragment;
+import com.android.settings.flags.Flags;
 import com.android.settingslib.bluetooth.CachedBluetoothDevice;
 import com.android.settingslib.bluetooth.LocalBluetoothManager;
 
+import com.google.common.base.Objects;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+
 /** Implements an AlertDialog for confirming that a user wishes to unpair or "forget" a paired
  *  device*/
 public class ForgetDeviceDialogFragment extends InstrumentedDialogFragment {
     public static final String TAG = "ForgetBluetoothDevice";
     private static final String KEY_DEVICE_ADDRESS = "device_address";
 
-    private CachedBluetoothDevice mDevice;
+    @VisibleForTesting
-
+    CachedBluetoothDevice mDevice;
+    @VisibleForTesting
+    CompanionDeviceManager mCompanionDeviceManager;
+    @VisibleForTesting
+    PackageManager mPackageManager;
     public static ForgetDeviceDialogFragment newInstance(String deviceAddress) {
         Bundle args = new Bundle(1);
         args.putString(KEY_DEVICE_ADDRESS, deviceAddress);
@@ -63,29 +84,93 @@ public class ForgetDeviceDialogFragment extends InstrumentedDialogFragment {
     }
 
     @Override
-    public Dialog onCreateDialog(Bundle inState) {
+    public void onAttach(@NonNull Context context) {
-        Context context = getContext();
+        super.onAttach(context);
+        mCompanionDeviceManager = context.getSystemService(CompanionDeviceManager.class);
+        mPackageManager = context.getPackageManager();
         mDevice = getDevice(context);
+    }
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(@Nullable Bundle inState) {
         if (mDevice == null) {
-            Log.e(TAG, "onCreateDialog: Device is null.");
+            throw new IllegalStateException("Device must not be null when creating dialog.");
-            return null;
+        }
+        List<AssociationInfo> associationInfos = getAssociations(mDevice.getAddress());
+        Set<String> packageNames = new HashSet<>();
+        if (Flags.enableRemoveAssociationBtUnpair()) {
+            for (AssociationInfo ai : associationInfos) {
+                CharSequence appLabel = getAppLabel(ai.getPackageName());
+                if (!TextUtils.isEmpty(appLabel)) {
+                    packageNames.add(appLabel.toString());
+                }
+            }
         }
 
         DialogInterface.OnClickListener onConfirm = (dialog, which) -> {
+            // 1. Unpair the device.
             mDevice.unpair();
+            // 2. Remove the associations if any.
+            if (Flags.enableRemoveAssociationBtUnpair()) {
+                for (AssociationInfo ai : associationInfos) {
+                    mCompanionDeviceManager.disassociate(ai.getId());
+                }
+            }
+
             Activity activity = getActivity();
             if (activity != null) {
                 activity.finish();
             }
         };
-        AlertDialog dialog = new AlertDialog.Builder(context)
+
+        AlertDialog dialog = new AlertDialog.Builder(getActivity())
                 .setPositiveButton(R.string.bluetooth_unpair_dialog_forget_confirm_button,
                         onConfirm)
                 .setNegativeButton(android.R.string.cancel, null)
                 .create();
+
         dialog.setTitle(R.string.bluetooth_unpair_dialog_title);
-        dialog.setMessage(context.getString(R.string.bluetooth_unpair_dialog_body,
+        String message = buildUnpairMessage(
-                mDevice.getName()));
+                getActivity(), mDevice, associationInfos, packageNames.stream().toList());
+        dialog.setMessage(message);
+
         return dialog;
     }
+
+    private List<AssociationInfo> getAssociations(String address) {
+        return filter(
+                mCompanionDeviceManager.getAllAssociations(),
+                a -> Objects.equal(address, a.getDeviceMacAddressAsString()));
+    }
+
+    private String buildUnpairMessage(Context context, CachedBluetoothDevice device,
+            List<AssociationInfo> associationInfos, List<String> packageNames) {
+        if (Flags.enableRemoveAssociationBtUnpair() && !associationInfos.isEmpty()) {
+            String appNamesString = getAppNamesString(packageNames.stream().toList());
+            return context.getString(R.string.bluetooth_unpair_dialog_with_associations_body,
+                    device.getName(), appNamesString);
+        } else {
+            return context.getString(R.string.bluetooth_unpair_dialog_body, device.getName());
+        }
+    }
+
+    private String getAppNamesString(List<String> appNames) {
+        if (appNames == null || appNames.isEmpty()) {
+            return "";
+        }
+
+        ListFormatter formatter = ListFormatter.getInstance(Locale.getDefault());
+        return formatter.format(appNames);
+    }
+
+    private CharSequence getAppLabel(String packageName) {
+        try {
+            return mPackageManager.getApplicationLabel(
+                    mPackageManager.getApplicationInfo(packageName, 0));
+        } catch (PackageManager.NameNotFoundException e) {
+            Log.e(TAG, "Package Not Found", e);
+            return "";
+        }
+    }
 }

tests/robotests/src/com/android/settings/bluetooth/ForgetDeviceDialogFragmentTest.java

@@ -20,24 +20,36 @@ import static com.google.common.truth.Truth.assertThat;
 
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doReturn;
+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.BluetoothDevice;
+import android.companion.AssociationInfo;
+import android.companion.CompanionDeviceManager;
 import android.content.Context;
+import android.content.DialogInterface;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.net.MacAddress;
+import android.os.Bundle;
+import android.platform.test.annotations.RequiresFlagsEnabled;
+import android.platform.test.flag.junit.CheckFlagsRule;
+import android.platform.test.flag.junit.DeviceFlagsValueProvider;
 
 import androidx.appcompat.app.AlertDialog;
 import androidx.fragment.app.FragmentActivity;
 
 import com.android.settings.R;
-import com.android.settings.testutils.FakeFeatureFactory;
+import com.android.settings.flags.Flags;
 import com.android.settings.testutils.shadow.ShadowAlertDialogCompat;
 import com.android.settingslib.bluetooth.CachedBluetoothDevice;
 
 import org.junit.Before;
 import org.junit.Ignore;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Answers;
@@ -48,41 +60,64 @@ import org.robolectric.RobolectricTestRunner;
 import org.robolectric.RuntimeEnvironment;
 import org.robolectric.annotation.Config;
 import org.robolectric.shadows.ShadowDialog;
+import org.robolectric.shadows.ShadowLooper;
 import org.robolectric.shadows.androidx.fragment.FragmentController;
 
-@Ignore
+import java.util.ArrayList;
+import java.util.List;
+
 @RunWith(RobolectricTestRunner.class)
-@Config(shadows = {ShadowAlertDialogCompat.class})
+@Config(shadows = {
+        com.android.settings.testutils.shadow.ShadowFragment.class,
+        ShadowAlertDialogCompat.class,
+})
 public class ForgetDeviceDialogFragmentTest {
 
     private static final String DEVICE_NAME = "Nightshade";
+    private static final String PACKAGE_NAME = "com.android.test";
+    private static final CharSequence APP_NAME = "test";
 
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private CachedBluetoothDevice mCachedDevice;
     @Mock
     private BluetoothDevice mBluetoothDevice;
+    @Mock
+    private CompanionDeviceManager mCompanionDeviceManager;
+    @Mock
+    private PackageManager mPackageManager;
 
     private ForgetDeviceDialogFragment mFragment;
     private FragmentActivity mActivity;
     private AlertDialog mDialog;
     private Context mContext;
+    private List<AssociationInfo> mAssociations;
+
+    @Rule
+    public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
 
-        mContext = RuntimeEnvironment.application;
-        FakeFeatureFactory.setupForTest();
         String deviceAddress = "55:66:77:88:99:AA";
+        mAssociations = new ArrayList<>();
+        mFragment = spy(ForgetDeviceDialogFragment.newInstance(deviceAddress));
+        mContext = spy(RuntimeEnvironment.application);
+        mFragment.mCompanionDeviceManager = mCompanionDeviceManager;
+        mFragment.mPackageManager = mPackageManager;
+        mFragment.mDevice = mCachedDevice;
+        mActivity = Robolectric.setupActivity(FragmentActivity.class);
+
+        when(mFragment.getActivity()).thenReturn(mActivity);
         when(mCachedDevice.getAddress()).thenReturn(deviceAddress);
         when(mCachedDevice.getIdentityAddress()).thenReturn(deviceAddress);
         when(mCachedDevice.getDevice()).thenReturn(mBluetoothDevice);
         when(mCachedDevice.getName()).thenReturn(DEVICE_NAME);
-        mFragment = spy(ForgetDeviceDialogFragment.newInstance(deviceAddress));
+        when(mCompanionDeviceManager.getAllAssociations()).thenReturn(mAssociations);
         doReturn(mCachedDevice).when(mFragment).getDevice(any());
-        mActivity = Robolectric.setupActivity(FragmentActivity.class);
     }
 
+    @Ignore("b/253386225")
     @Test
     public void cancelDialog() {
         initDialog();
@@ -92,6 +127,7 @@ public class ForgetDeviceDialogFragmentTest {
         assertThat(mActivity.isFinishing()).isFalse();
     }
 
+    @Ignore("b/253386225")
     @Test
     public void confirmDialog() {
         initDialog();
@@ -101,6 +137,7 @@ public class ForgetDeviceDialogFragmentTest {
         assertThat(mActivity.isFinishing()).isTrue();
     }
 
+    @Ignore("b/253386225")
     @Test
     public void createDialog_normalDevice_showNormalMessage() {
         when(mBluetoothDevice.getMetadata(BluetoothDevice.METADATA_IS_UNTETHERED_HEADSET))
@@ -115,8 +152,86 @@ public class ForgetDeviceDialogFragmentTest {
                 mContext.getString(R.string.bluetooth_unpair_dialog_body, DEVICE_NAME));
     }
 
+    @Test
+    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_REMOVE_ASSOCIATION_BT_UNPAIR)
+    public void cancelDialog_with_association() {
+        addAssociation();
+        final AlertDialog dialog = (AlertDialog) mFragment.onCreateDialog(Bundle.EMPTY);
+        dialog.show();
+        dialog.getButton(DialogInterface.BUTTON_NEGATIVE).performClick();
+        ShadowLooper.idleMainLooper();
+
+        verify(mCachedDevice, never()).unpair();
+        verify(mCompanionDeviceManager, never()).disassociate(1);
+        assertThat(mActivity.isFinishing()).isFalse();
+    }
+
+    @Test
+    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_REMOVE_ASSOCIATION_BT_UNPAIR)
+    public void confirmDialog_with_association() {
+        addAssociation();
+        final AlertDialog dialog = (AlertDialog) mFragment.onCreateDialog(Bundle.EMPTY);
+        dialog.show();
+        dialog.getButton(DialogInterface.BUTTON_POSITIVE).performClick();
+        ShadowLooper.idleMainLooper();
+
+        verify(mCachedDevice).unpair();
+        verify(mCompanionDeviceManager).disassociate(1);
+
+        assertThat(mActivity.isFinishing()).isTrue();
+    }
+
+    @Test
+    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_REMOVE_ASSOCIATION_BT_UNPAIR)
+    public void createDialog_showMessage_with_association() {
+        addAssociation();
+        final AlertDialog dialog = (AlertDialog) mFragment.onCreateDialog(Bundle.EMPTY);
+        dialog.show();
+        ShadowLooper.idleMainLooper();
+
+        ShadowAlertDialogCompat shadowDialog = ShadowAlertDialogCompat.shadowOf(dialog);
+        assertThat(shadowDialog.getMessage().toString()).isEqualTo(
+                mContext.getString(
+                        R.string.bluetooth_unpair_dialog_with_associations_body,
+                        DEVICE_NAME, APP_NAME)
+        );
+    }
+
     private void initDialog() {
         mActivity.getSupportFragmentManager().beginTransaction().add(mFragment, null).commit();
         mDialog = (AlertDialog) ShadowDialog.getLatestDialog();
     }
+
+    private void addAssociation() {
+        setupLabelAndInfo(PACKAGE_NAME, APP_NAME);
+        final AssociationInfo association = new AssociationInfo(
+                1,
+                /* userId */ 0,
+                PACKAGE_NAME,
+                MacAddress.fromString(mCachedDevice.getAddress()),
+                /* displayName */ null,
+                /* deviceProfile */ "",
+                /* associatedDevice */ null,
+                /* selfManaged */ false,
+                /* notifyOnDeviceNearby */ true,
+                /* revoked */ false,
+                /* pending */ false,
+                /* timeApprovedMs */ System.currentTimeMillis(),
+                /* lastTimeConnected */ Long.MAX_VALUE,
+                /* systemDataSyncFlags */ -1,
+                /* deviceIcon */ null,
+                /* deviceId */ null);
+
+        mAssociations.add(association);
+    }
+
+    private void setupLabelAndInfo(String packageName, CharSequence appName) {
+        ApplicationInfo appInfo = mock(ApplicationInfo.class);
+        try {
+            when(mPackageManager.getApplicationInfo(packageName, 0)).thenReturn(appInfo);
+            when(mPackageManager.getApplicationLabel(appInfo)).thenReturn(appName);
+        } catch (PackageManager.NameNotFoundException e) {
+            throw new RuntimeException(e);
+        }
+    }
 }