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

   1 /*
   2  * Copyright (C) 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.android.settings.bluetooth;
  17
  18 import android.bluetooth.BluetoothClass;
  19 import android.bluetooth.BluetoothDevice;
  20 import android.content.Context;
  21 import android.content.Intent;
  22 import android.text.Editable;
  23 import android.util.Log;
  24 import android.widget.CompoundButton;
  25 import android.widget.CompoundButton.OnCheckedChangeListener;
  26 import com.android.settings.R;
  27 import com.android.settings.bluetooth.BluetoothPairingDialogFragment.BluetoothPairingDialogListener;
  28 import com.android.settingslib.bluetooth.LocalBluetoothManager;
  29 import com.android.settingslib.bluetooth.LocalBluetoothProfile;
  30 import java.util.Locale;
  31
  32 /**
  33  * A controller used by {@link BluetoothPairingDialog} to manage connection state while we try to
  34  * pair with a bluetooth device. It includes methods that allow the
  35  * {@link BluetoothPairingDialogFragment} to interrogate the current state as well.
  36  */
  37 public class BluetoothPairingController implements OnCheckedChangeListener,
  38         BluetoothPairingDialogListener {
  39
  40     private static final String TAG = "BTPairingController";
  41
  42     // Different types of dialogs we can map to
  43     public static final int INVALID_DIALOG_TYPE = -1;
  44     public static final int USER_ENTRY_DIALOG = 0;
  45     public static final int CONFIRMATION_DIALOG = 1;
  46     public static final int DISPLAY_PASSKEY_DIALOG = 2;
  47
  48     private static final int BLUETOOTH_PIN_MAX_LENGTH = 16;
  49     private static final int BLUETOOTH_PASSKEY_MAX_LENGTH = 6;
  50
  51     // Bluetooth dependencies for the connection we are trying to establish
  52     private LocalBluetoothManager mBluetoothManager;
  53     private BluetoothDevice mDevice;
  54     private int mType;
  55     private String mUserInput;
  56     private String mPasskeyFormatted;
  57     private int mPasskey;
  58     private String mDeviceName;
  59     private LocalBluetoothProfile mPbapClientProfile;
  60
  61     /**
  62      * Creates an instance of a BluetoothPairingController.
  63      *
  64      * @param intent - must contain {@link BluetoothDevice#EXTRA_PAIRING_VARIANT}, {@link
  65      * BluetoothDevice#EXTRA_PAIRING_KEY}, and {@link BluetoothDevice#EXTRA_DEVICE}. Missing extra
  66      * will lead to undefined behavior.
  67      */
  68     public BluetoothPairingController(Intent intent, Context context) {
  69         mBluetoothManager = Utils.getLocalBtManager(context);
  70         mDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
  71
  72         String message = "";
  73         if (mBluetoothManager == null) {
  74             throw new IllegalStateException("Could not obtain LocalBluetoothManager");
  75         } else if (mDevice == null) {
  76             throw new IllegalStateException("Could not find BluetoothDevice");
  77         }
  78
  79         mType = intent.getIntExtra(BluetoothDevice.EXTRA_PAIRING_VARIANT, BluetoothDevice.ERROR);
  80         mPasskey = intent.getIntExtra(BluetoothDevice.EXTRA_PAIRING_KEY, BluetoothDevice.ERROR);
  81         mDeviceName = mBluetoothManager.getCachedDeviceManager().getName(mDevice);
  82         mPbapClientProfile = mBluetoothManager.getProfileManager().getPbapClientProfile();
  83         mPasskeyFormatted = formatKey(mPasskey);
  84
  85     }
  86
  87     @Override
  88     public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
  89         if (isChecked) {
  90             mDevice.setPhonebookAccessPermission(BluetoothDevice.ACCESS_ALLOWED);
  91         } else {
  92             mDevice.setPhonebookAccessPermission(BluetoothDevice.ACCESS_REJECTED);
  93         }
  94     }
  95
  96     @Override
  97     public void onDialogPositiveClick(BluetoothPairingDialogFragment dialog) {
  98         if (getDialogType() == USER_ENTRY_DIALOG) {
  99             onPair(mUserInput);
 100         } else {
 101             onPair(null);
 102         }
 103     }
 104
 105     @Override
 106     public void onDialogNegativeClick(BluetoothPairingDialogFragment dialog) {
 107         onCancel();
 108     }
 109
 110     /**
 111      * A method for querying which bluetooth pairing dialog fragment variant this device requires.
 112      *
 113      * @return - The dialog view variant needed for this device.
 114      */
 115     public int getDialogType() {
 116         switch (mType) {
 117             case BluetoothDevice.PAIRING_VARIANT_PIN:
 118             case BluetoothDevice.PAIRING_VARIANT_PIN_16_DIGITS:
 119             case BluetoothDevice.PAIRING_VARIANT_PASSKEY:
 120                 return USER_ENTRY_DIALOG;
 121
 122             case BluetoothDevice.PAIRING_VARIANT_PASSKEY_CONFIRMATION:
 123             case BluetoothDevice.PAIRING_VARIANT_CONSENT:
 124             case BluetoothDevice.PAIRING_VARIANT_OOB_CONSENT:
 125                 return CONFIRMATION_DIALOG;
 126
 127             case BluetoothDevice.PAIRING_VARIANT_DISPLAY_PASSKEY:
 128             case BluetoothDevice.PAIRING_VARIANT_DISPLAY_PIN:
 129                 return DISPLAY_PASSKEY_DIALOG;
 130
 131             default:
 132                 return INVALID_DIALOG_TYPE;
 133         }
 134     }
 135
 136     /**
 137      * @return - A string containing the name provided by the device.
 138      */
 139     public String getDeviceName() {
 140         return mDeviceName;
 141     }
 142
 143     /**
 144      * A method for querying if the bluetooth device has a profile already set up on this device.
 145      *
 146      * @return - A boolean indicating if the device has previous knowledge of a profile for this
 147      * device.
 148      */
 149     public boolean isProfileReady() {
 150         return mPbapClientProfile != null && mPbapClientProfile.isProfileReady();
 151     }
 152
 153     /**
 154      * A method for querying if the bluetooth device has access to contacts on the device.
 155      *
 156      * @return - A boolean indicating if the bluetooth device has permission to access the device
 157      * contacts
 158      */
 159     public boolean getContactSharingState() {
 160         switch (mDevice.getPhonebookAccessPermission()) {
 161             case BluetoothDevice.ACCESS_ALLOWED:
 162                 return true;
 163             case BluetoothDevice.ACCESS_REJECTED:
 164                 return false;
 165             default:
 166                 if (mDevice.getBluetoothClass().getDeviceClass()
 167                         == BluetoothClass.Device.AUDIO_VIDEO_HANDSFREE) {
 168                     return true;
 169                 }
 170                 return false;
 171         }
 172     }
 173
 174     /**
 175      * A method for querying if the provided editable is a valid passkey/pin format for this device.
 176      *
 177      * @param s - The passkey/pin
 178      * @return - A boolean indicating if the passkey/pin is of the correct format.
 179      */
 180     public boolean isPasskeyValid(Editable s) {
 181         boolean requires16Digits = mType == BluetoothDevice.PAIRING_VARIANT_PIN_16_DIGITS;
 182         return s.length() >= 16 && requires16Digits || s.length() > 0 && !requires16Digits;
 183     }
 184
 185     /**
 186      * A method for querying what message should be shown to the user as additional text in the
 187      * dialog for this device. Returns -1 to indicate a device type that does not use this message.
 188      *
 189      * @return - The message ID to show the user.
 190      */
 191     public int getDeviceVariantMessageId() {
 192         switch (mType) {
 193             case BluetoothDevice.PAIRING_VARIANT_PIN_16_DIGITS:
 194             case BluetoothDevice.PAIRING_VARIANT_PIN:
 195                 return R.string.bluetooth_enter_pin_other_device;
 196
 197             case BluetoothDevice.PAIRING_VARIANT_PASSKEY:
 198                 return R.string.bluetooth_enter_passkey_other_device;
 199
 200             default:
 201                 return INVALID_DIALOG_TYPE;
 202         }
 203     }
 204
 205     /**
 206      * A method for querying what message hint should be shown to the user as additional text in the
 207      * dialog for this device. Returns -1 to indicate a device type that does not use this message.
 208      *
 209      * @return - The message ID to show the user.
 210      */
 211     public int getDeviceVariantMessageHintId() {
 212         switch (mType) {
 213             case BluetoothDevice.PAIRING_VARIANT_PIN_16_DIGITS:
 214                 return R.string.bluetooth_pin_values_hint_16_digits;
 215
 216             case BluetoothDevice.PAIRING_VARIANT_PIN:
 217             case BluetoothDevice.PAIRING_VARIANT_PASSKEY:
 218                 return R.string.bluetooth_pin_values_hint;
 219
 220             default:
 221                 return INVALID_DIALOG_TYPE;
 222         }
 223     }
 224
 225     /**
 226      * A method for querying the maximum passkey/pin length for this device.
 227      *
 228      * @return - An int indicating the maximum length
 229      */
 230     public int getDeviceMaxPasskeyLength() {
 231         switch (mType) {
 232             case BluetoothDevice.PAIRING_VARIANT_PIN_16_DIGITS:
 233             case BluetoothDevice.PAIRING_VARIANT_PIN:
 234                 return BLUETOOTH_PIN_MAX_LENGTH;
 235
 236             case BluetoothDevice.PAIRING_VARIANT_PASSKEY:
 237                 return BLUETOOTH_PASSKEY_MAX_LENGTH;
 238
 239             default:
 240                 return 0;
 241         }
 242
 243     }
 244
 245     /**
 246      * A method for querying if the device uses an alphanumeric passkey.
 247      *
 248      * @return - a boolean indicating if the passkey can be alphanumeric.
 249      */
 250     public boolean pairingCodeIsAlphanumeric() {
 251         switch (mType) {
 252             case BluetoothDevice.PAIRING_VARIANT_PASSKEY:
 253                 return false;
 254
 255             default:
 256                 return true;
 257         }
 258     }
 259
 260     /**
 261      * A method used by the dialogfragment to notify the controller that the dialog has been
 262      * displayed for bluetooth device types that just care about it being displayed.
 263      */
 264     protected void notifyDialogDisplayed() {
 265         // send an OK to the framework, indicating that the dialog has been displayed.
 266         if (mType == BluetoothDevice.PAIRING_VARIANT_DISPLAY_PASSKEY) {
 267             mDevice.setPairingConfirmation(true);
 268         } else if (mType == BluetoothDevice.PAIRING_VARIANT_DISPLAY_PIN) {
 269             byte[] pinBytes = BluetoothDevice.convertPinToBytes(mPasskeyFormatted);
 270             mDevice.setPin(pinBytes);
 271         }
 272     }
 273
 274     /**
 275      * A method for querying if this bluetooth device type has a key it would like displayed
 276      * to the user.
 277      *
 278      * @return - A boolean indicating if a key exists which should be displayed to the user.
 279      */
 280     public boolean isDisplayPairingKeyVariant() {
 281         switch (mType) {
 282             case BluetoothDevice.PAIRING_VARIANT_DISPLAY_PASSKEY:
 283             case BluetoothDevice.PAIRING_VARIANT_DISPLAY_PIN:
 284             case BluetoothDevice.PAIRING_VARIANT_OOB_CONSENT:
 285                 return true;
 286             default:
 287                 return false;
 288         }
 289     }
 290
 291     /**
 292      * A method for querying if this bluetooth device type has other content it would like displayed
 293      * to the user.
 294      *
 295      * @return - A boolean indicating if content exists which should be displayed to the user.
 296      */
 297     public boolean hasPairingContent() {
 298         switch (mType) {
 299             case BluetoothDevice.PAIRING_VARIANT_DISPLAY_PASSKEY:
 300             case BluetoothDevice.PAIRING_VARIANT_DISPLAY_PIN:
 301             case BluetoothDevice.PAIRING_VARIANT_PASSKEY_CONFIRMATION:
 302                 return true;
 303
 304             default:
 305                 return false;
 306         }
 307     }
 308
 309     /**
 310      * A method for obtaining any additional content this bluetooth device has for displaying to the
 311      * user.
 312      *
 313      * @return - A string containing the additional content, null if none exists.
 314      * @see {@link BluetoothPairingController#hasPairingContent()}
 315      */
 316     public String getPairingContent() {
 317         if (hasPairingContent()) {
 318             return mPasskeyFormatted;
 319         } else {
 320             return null;
 321         }
 322     }
 323
 324     /**
 325      * A method that exists to allow the fragment to update the controller with input the user has
 326      * provided in the fragment.
 327      *
 328      * @param input - A string containing the user input.
 329      */
 330     protected void updateUserInput(String input) {
 331         mUserInput = input;
 332     }
 333
 334     /**
 335      * Returns the provided passkey in a format that this device expects. Only works for numeric
 336      * passkeys/pins.
 337      *
 338      * @param passkey - An integer containing the passkey to format.
 339      * @return - A string containing the formatted passkey/pin
 340      */
 341     private String formatKey(int passkey) {
 342         switch (mType) {
 343             case BluetoothDevice.PAIRING_VARIANT_PASSKEY_CONFIRMATION:
 344             case BluetoothDevice.PAIRING_VARIANT_DISPLAY_PASSKEY:
 345                 return String.format(Locale.US, "%06d", passkey);
 346
 347             case BluetoothDevice.PAIRING_VARIANT_DISPLAY_PIN:
 348                 return String.format("%04d", passkey);
 349
 350             default:
 351                 return null;
 352         }
 353     }
 354
 355     /**
 356      * handles the necessary communication with the bluetooth device to establish a successful
 357      * pairing
 358      *
 359      * @param passkey - The passkey we will attempt to pair to the device with.
 360      */
 361     private void onPair(String passkey) {
 362         Log.d(TAG, "Pairing dialog accepted");
 363         switch (mType) {
 364             case BluetoothDevice.PAIRING_VARIANT_PIN:
 365             case BluetoothDevice.PAIRING_VARIANT_PIN_16_DIGITS:
 366                 byte[] pinBytes = BluetoothDevice.convertPinToBytes(passkey);
 367                 if (pinBytes == null) {
 368                     return;
 369                 }
 370                 mDevice.setPin(pinBytes);
 371                 break;
 372
 373             case BluetoothDevice.PAIRING_VARIANT_PASSKEY:
 374                 int pass = Integer.parseInt(passkey);
 375                 mDevice.setPasskey(pass);
 376                 break;
 377
 378             case BluetoothDevice.PAIRING_VARIANT_PASSKEY_CONFIRMATION:
 379             case BluetoothDevice.PAIRING_VARIANT_CONSENT:
 380                 mDevice.setPairingConfirmation(true);
 381                 break;
 382
 383             case BluetoothDevice.PAIRING_VARIANT_DISPLAY_PASSKEY:
 384             case BluetoothDevice.PAIRING_VARIANT_DISPLAY_PIN:
 385                 // Do nothing.
 386                 break;
 387
 388             case BluetoothDevice.PAIRING_VARIANT_OOB_CONSENT:
 389                 mDevice.setRemoteOutOfBandData();
 390                 break;
 391
 392             default:
 393                 Log.e(TAG, "Incorrect pairing type received");
 394         }
 395     }
 396
 397     /**
 398      * A method for properly ending communication with the bluetooth device. Will be called by the
 399      * {@link BluetoothPairingDialogFragment} when it is dismissed.
 400      */
 401     public void onCancel() {
 402         Log.d(TAG, "Pairing dialog canceled");
 403         mDevice.cancelPairingUserInput();
 404     }
 405
 406     /**
 407      * A method for checking if this device is equal to another device.
 408      *
 409      * @param device - The other device being compared to this device.
 410      * @return - A boolean indicating if the devices were equal.
 411      */
 412     public boolean deviceEquals(BluetoothDevice device) {
 413         return mDevice == device;
 414     }
 415 }