diff --git a/src/com/android/settings/bluetooth/BluetoothPairingRequest.java b/src/com/android/settings/bluetooth/BluetoothPairingRequest.java index d7dad887fec..993f584dd36 100644 --- a/src/com/android/settings/bluetooth/BluetoothPairingRequest.java +++ b/src/com/android/settings/bluetooth/BluetoothPairingRequest.java @@ -31,38 +31,39 @@ import android.os.UserHandle; */ public final class BluetoothPairingRequest extends BroadcastReceiver { - @Override - public void onReceive(Context context, Intent intent) { - String action = intent.getAction(); - if (action == null || !action.equals(BluetoothDevice.ACTION_PAIRING_REQUEST)) { - return; - } - PowerManager powerManager = context.getSystemService(PowerManager.class); - BluetoothDevice device = - intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE); - int pairingVariant = intent.getIntExtra(BluetoothDevice.EXTRA_PAIRING_VARIANT, - BluetoothDevice.ERROR); - String deviceAddress = device != null ? device.getAddress() : null; - String deviceName = device != null ? device.getName() : null; - boolean shouldShowDialog = LocalBluetoothPreferences.shouldShowDialogInForeground( - context, deviceAddress, deviceName); + @Override + public void onReceive(Context context, Intent intent) { + String action = intent.getAction(); + if (action == null || !action.equals(BluetoothDevice.ACTION_PAIRING_REQUEST)) { + return; + } - // Skips consent pairing dialog if the device was recently associated with CDM - if (pairingVariant == BluetoothDevice.PAIRING_VARIANT_CONSENT - && device.canBondWithoutDialog()) { - device.setPairingConfirmation(true); - } else if (powerManager.isInteractive() && shouldShowDialog) { - // Since the screen is on and the BT-related activity is in the foreground, - // just open the dialog - // convert broadcast intent into activity intent (same action string) - Intent pairingIntent = BluetoothPairingService.getPairingDialogIntent(context, intent, - BluetoothDevice.EXTRA_PAIRING_INITIATOR_FOREGROUND); + PowerManager powerManager = context.getSystemService(PowerManager.class); + BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE); + int pairingVariant = intent.getIntExtra(BluetoothDevice.EXTRA_PAIRING_VARIANT, + BluetoothDevice.ERROR); + String deviceAddress = device != null ? device.getAddress() : null; + String deviceName = device != null ? device.getName() : null; + boolean shouldShowDialog = LocalBluetoothPreferences.shouldShowDialogInForeground( + context, deviceAddress, deviceName); - context.startActivityAsUser(pairingIntent, UserHandle.CURRENT); - } else { - // Put up a notification that leads to the dialog - intent.setClass(context, BluetoothPairingService.class); - context.startServiceAsUser(intent, UserHandle.CURRENT); + // Skips consent pairing dialog if the device was recently associated with CDM + if (pairingVariant == BluetoothDevice.PAIRING_VARIANT_CONSENT + && device.canBondWithoutDialog()) { + device.setPairingConfirmation(true); + } else if (powerManager.isInteractive() && shouldShowDialog) { + // Since the screen is on and the BT-related activity is in the foreground, + // just open the dialog + // convert broadcast intent into activity intent (same action string) + Intent pairingIntent = BluetoothPairingService.getPairingDialogIntent(context, intent, + BluetoothDevice.EXTRA_PAIRING_INITIATOR_FOREGROUND); + + context.startActivityAsUser(pairingIntent, UserHandle.CURRENT); + } else { + // Put up a notification that leads to the dialog + intent.setClass(context, BluetoothPairingService.class); + intent.setAction(BluetoothDevice.ACTION_PAIRING_REQUEST); + context.startServiceAsUser(intent, UserHandle.CURRENT); + } } - } } diff --git a/src/com/android/settings/bluetooth/BluetoothPairingService.java b/src/com/android/settings/bluetooth/BluetoothPairingService.java index c411b0cd0b4..0bff721b8a9 100644 --- a/src/com/android/settings/bluetooth/BluetoothPairingService.java +++ b/src/com/android/settings/bluetooth/BluetoothPairingService.java @@ -31,6 +31,9 @@ import android.os.IBinder; import android.text.TextUtils; import android.util.Log; +import androidx.annotation.VisibleForTesting; +import androidx.core.app.NotificationCompat; + import com.android.settings.R; /** @@ -39,10 +42,14 @@ import com.android.settings.R; */ public final class BluetoothPairingService extends Service { - private static final int NOTIFICATION_ID = android.R.drawable.stat_sys_data_bluetooth; - - private static final String ACTION_DISMISS_PAIRING = + @VisibleForTesting + static final int NOTIFICATION_ID = android.R.drawable.stat_sys_data_bluetooth; + @VisibleForTesting + static final String ACTION_DISMISS_PAIRING = "com.android.settings.bluetooth.ACTION_DISMISS_PAIRING"; + @VisibleForTesting + static final String ACTION_PAIRING_DIALOG = + "com.android.settings.bluetooth.ACTION_PAIRING_DIALOG"; private static final String BLUETOOTH_NOTIFICATION_CHANNEL = "bluetooth_notification_channel"; @@ -51,6 +58,9 @@ public final class BluetoothPairingService extends Service { private BluetoothDevice mDevice; + @VisibleForTesting + NotificationManager mNm; + public static Intent getPairingDialogIntent(Context context, Intent intent, int initiator) { BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE); int type = intent.getIntExtra(BluetoothDevice.EXTRA_PAIRING_VARIANT, @@ -80,33 +90,35 @@ public final class BluetoothPairingService extends Service { if (action.equals(BluetoothDevice.ACTION_BOND_STATE_CHANGED)) { int bondState = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, BluetoothDevice.ERROR); + Log.d(TAG, "onReceive() Bond state change : " + bondState + ", device name : " + + mDevice.getName()); if ((bondState != BluetoothDevice.BOND_NONE) && (bondState != BluetoothDevice.BOND_BONDED)) { return; } } else if (action.equals(ACTION_DISMISS_PAIRING)) { - Log.d(TAG, "Notification cancel " + mDevice.getAddress() + " (" + + Log.d(TAG, "Notification cancel " + " (" + mDevice.getName() + ")"); mDevice.cancelPairing(); } else { int bondState = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, BluetoothDevice.ERROR); - Log.d(TAG, "Dismiss pairing for " + mDevice.getAddress() + " (" + + Log.d(TAG, "Dismiss pairing for " + " (" + mDevice.getName() + "), BondState: " + bondState); } - stopForeground(true); + + mNm.cancel(NOTIFICATION_ID); stopSelf(); } }; @Override public void onCreate() { - NotificationManager mgr = (NotificationManager)this - .getSystemService(Context.NOTIFICATION_SERVICE); - NotificationChannel notificationChannel = new NotificationChannel( - BLUETOOTH_NOTIFICATION_CHANNEL, - this.getString(R.string.bluetooth), - NotificationManager.IMPORTANCE_HIGH); - mgr.createNotificationChannel(notificationChannel); + mNm = getSystemService(NotificationManager.class); + NotificationChannel notificationChannel = new NotificationChannel( + BLUETOOTH_NOTIFICATION_CHANNEL, + this.getString(R.string.bluetooth), + NotificationManager.IMPORTANCE_HIGH); + mNm.createNotificationChannel(notificationChannel); } @Override @@ -116,23 +128,8 @@ public final class BluetoothPairingService extends Service { stopSelf(); return START_NOT_STICKY; } - - Resources res = getResources(); - Notification.Builder builder = new Notification.Builder(this, - BLUETOOTH_NOTIFICATION_CHANNEL) - .setSmallIcon(android.R.drawable.stat_sys_data_bluetooth) - .setTicker(res.getString(R.string.bluetooth_notif_ticker)) - .setLocalOnly(true); - - PendingIntent pairIntent = PendingIntent.getActivity(this, 0, - getPairingDialogIntent(this, intent, - BluetoothDevice.EXTRA_PAIRING_INITIATOR_BACKGROUND), - PendingIntent.FLAG_ONE_SHOT | PendingIntent.FLAG_UPDATE_CURRENT - | PendingIntent.FLAG_IMMUTABLE); - - PendingIntent dismissIntent = PendingIntent.getBroadcast(this, 0, - new Intent(ACTION_DISMISS_PAIRING), PendingIntent.FLAG_ONE_SHOT - | PendingIntent.FLAG_IMMUTABLE); + String action = intent.getAction(); + Log.d(TAG, "onStartCommand() action : " + action); mDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE); @@ -142,36 +139,76 @@ public final class BluetoothPairingService extends Service { return START_NOT_STICKY; } + if (TextUtils.equals(action, BluetoothDevice.ACTION_PAIRING_REQUEST)) { + createPairingNotification(intent); + } else if (TextUtils.equals(action, ACTION_DISMISS_PAIRING)) { + Log.d(TAG, "Notification cancel " + " (" + mDevice.getName() + ")"); + mDevice.cancelPairing(); + mNm.cancel(NOTIFICATION_ID); + stopSelf(); + } else if (TextUtils.equals(action, ACTION_PAIRING_DIALOG)) { + Intent pairingDialogIntent = getPairingDialogIntent(this, intent, + BluetoothDevice.EXTRA_PAIRING_INITIATOR_BACKGROUND); + + IntentFilter filter = new IntentFilter(); + filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED); + filter.addAction(BluetoothDevice.ACTION_PAIRING_CANCEL); + filter.addAction(ACTION_DISMISS_PAIRING); + registerReceiver(mCancelReceiver, filter); + mRegistered = true; + + startActivity(pairingDialogIntent); + } + + return START_STICKY; + } + + private void createPairingNotification(Intent intent) { + Resources res = getResources(); + NotificationCompat.Builder builder = new NotificationCompat.Builder(this, + BLUETOOTH_NOTIFICATION_CHANNEL) + .setSmallIcon(android.R.drawable.stat_sys_data_bluetooth) + .setTicker(res.getString(R.string.bluetooth_notif_ticker)) + .setLocalOnly(true); + + int type = intent.getIntExtra(BluetoothDevice.EXTRA_PAIRING_VARIANT, + BluetoothDevice.ERROR); + Intent pairingDialogIntent = new Intent(ACTION_PAIRING_DIALOG); + pairingDialogIntent.setClass(this, BluetoothPairingService.class); + pairingDialogIntent.putExtra(BluetoothDevice.EXTRA_DEVICE, mDevice); + pairingDialogIntent.putExtra(BluetoothDevice.EXTRA_PAIRING_VARIANT, type); + PendingIntent pairIntent = PendingIntent.getService(this, 0, pairingDialogIntent, + PendingIntent.FLAG_ONE_SHOT | PendingIntent.FLAG_IMMUTABLE); + + Intent serviceIntent = new Intent(ACTION_DISMISS_PAIRING); + serviceIntent.setClass(this, BluetoothPairingService.class); + serviceIntent.putExtra(BluetoothDevice.EXTRA_DEVICE, mDevice); + PendingIntent dismissIntent = PendingIntent.getService(this, 0, + serviceIntent, PendingIntent.FLAG_ONE_SHOT | PendingIntent.FLAG_IMMUTABLE); + String name = intent.getStringExtra(BluetoothDevice.EXTRA_NAME); if (TextUtils.isEmpty(name)) { BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE); name = device != null ? device.getAlias() : res.getString(android.R.string.unknownName); } - Log.d(TAG, "Show pairing notification for " + mDevice.getAddress() + " (" + name + ")"); + Log.d(TAG, "Show pairing notification for " + " (" + name + ")"); - Notification.Action pairAction = new Notification.Action.Builder(0, + NotificationCompat.Action pairAction = new NotificationCompat.Action.Builder(0, res.getString(R.string.bluetooth_device_context_pair_connect), pairIntent).build(); - Notification.Action dismissAction = new Notification.Action.Builder(0, + NotificationCompat.Action dismissAction = new NotificationCompat.Action.Builder(0, res.getString(android.R.string.cancel), dismissIntent).build(); builder.setContentTitle(res.getString(R.string.bluetooth_notif_title)) .setContentText(res.getString(R.string.bluetooth_notif_message, name)) .setContentIntent(pairIntent) .setDefaults(Notification.DEFAULT_SOUND) + .setOngoing(true) .setColor(getColor(com.android.internal.R.color.system_notification_accent_color)) .addAction(pairAction) .addAction(dismissAction); - IntentFilter filter = new IntentFilter(); - filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED); - filter.addAction(BluetoothDevice.ACTION_PAIRING_CANCEL); - filter.addAction(ACTION_DISMISS_PAIRING); - registerReceiver(mCancelReceiver, filter); - mRegistered = true; - - startForeground(NOTIFICATION_ID, builder.getNotification()); - return START_REDELIVER_INTENT; + mNm.notify(NOTIFICATION_ID, builder.build()); } @Override @@ -180,7 +217,6 @@ public final class BluetoothPairingService extends Service { unregisterReceiver(mCancelReceiver); mRegistered = false; } - stopForeground(true); } @Override diff --git a/tests/robotests/src/com/android/settings/bluetooth/BluetoothPairingServiceTest.java b/tests/robotests/src/com/android/settings/bluetooth/BluetoothPairingServiceTest.java new file mode 100644 index 00000000000..e73b447728e --- /dev/null +++ b/tests/robotests/src/com/android/settings/bluetooth/BluetoothPairingServiceTest.java @@ -0,0 +1,125 @@ +/* + * Copyright (C) 2021 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.bluetooth; + +import static com.android.settings.bluetooth.BluetoothPairingService.ACTION_DISMISS_PAIRING; +import static com.android.settings.bluetooth.BluetoothPairingService.ACTION_PAIRING_DIALOG; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.app.Application; +import android.app.NotificationManager; +import android.bluetooth.BluetoothDevice; +import android.content.Context; +import android.content.Intent; +import android.content.pm.ApplicationInfo; +import android.content.pm.PackageManager; +import android.content.res.Resources; +import android.util.DisplayMetrics; + +import com.android.settings.R; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.RuntimeEnvironment; +import org.robolectric.util.ReflectionHelpers; + +@RunWith(RobolectricTestRunner.class) +public class BluetoothPairingServiceTest { + + private final String mFakeTicker = "fake_ticker"; + + @Mock + private NotificationManager mNm; + @Mock + private BluetoothDevice mDevice; + @Mock + private Context mContext; + @Mock + private Resources mResources; + @Mock + private PackageManager mPackageManager; + @Mock + private DisplayMetrics mDisplayMetrics; + + private BluetoothPairingService mBluetoothPairingService; + private Application mApplication; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + mBluetoothPairingService = new BluetoothPairingService(); + mBluetoothPairingService.mNm = mNm; + mApplication = RuntimeEnvironment.application; + + ReflectionHelpers.setField(mBluetoothPairingService, "mBase", mContext); + when(mContext.getResources()).thenReturn(mResources); + when(mResources.getString(R.string.bluetooth_notif_ticker)).thenReturn(mFakeTicker); + when(mContext.getApplicationInfo()).thenReturn(new ApplicationInfo()); + when(mContext.getPackageManager()).thenReturn(mPackageManager); + when(mResources.getDisplayMetrics()).thenReturn(mDisplayMetrics); + mDisplayMetrics.density = 1.5f; + } + + @Test + public void receivePairingRequestAction_notificationShown() { + Intent intent = new Intent(); + intent.setAction(BluetoothDevice.ACTION_PAIRING_REQUEST); + intent.putExtra(BluetoothDevice.EXTRA_DEVICE, mDevice); + intent.putExtra(BluetoothDevice.EXTRA_NAME, "fake_name"); + when(mDevice.getBondState()).thenReturn(BluetoothDevice.BOND_BONDING); + + mBluetoothPairingService.onStartCommand(intent, /* flags */ 0, /* startId */ 0); + + verify(mNm).notify(eq(mBluetoothPairingService.NOTIFICATION_ID), any()); + } + + @Test + public void receiveDismissPairingAction_cancelPairing() { + Intent intent = new Intent(); + intent.setAction(ACTION_DISMISS_PAIRING); + intent.putExtra(BluetoothDevice.EXTRA_DEVICE, mDevice); + intent.putExtra(BluetoothDevice.EXTRA_NAME, "fake_name"); + when(mDevice.getBondState()).thenReturn(BluetoothDevice.BOND_BONDING); + + mBluetoothPairingService.onStartCommand(intent, /* flags */ 0, /* startId */ 0); + + verify(mDevice).cancelPairing(); + verify(mNm).cancel(mBluetoothPairingService.NOTIFICATION_ID); + } + + @Test + public void receivePairingDialogAction_startActivity() { + Intent intent = new Intent(); + intent.setAction(ACTION_PAIRING_DIALOG); + intent.putExtra(BluetoothDevice.EXTRA_DEVICE, mDevice); + intent.putExtra(BluetoothDevice.EXTRA_NAME, "fake_name"); + when(mDevice.getBondState()).thenReturn(BluetoothDevice.BOND_BONDING); + + mBluetoothPairingService.onStartCommand(intent, /* flags */ 0, /* startId */ 0); + + verify(mContext).startActivity(any()); + } +}