1 /* 2 * Copyright (C) 2015 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 17 package com.android.systemui.keyboard; 18 19 import android.bluetooth.BluetoothAdapter; 20 import android.bluetooth.BluetoothDevice; 21 import android.bluetooth.le.BluetoothLeScanner; 22 import android.bluetooth.le.ScanCallback; 23 import android.bluetooth.le.ScanFilter; 24 import android.bluetooth.le.ScanRecord; 25 import android.bluetooth.le.ScanResult; 26 import android.bluetooth.le.ScanSettings; 27 import android.content.ContentResolver; 28 import android.content.Context; 29 import android.content.DialogInterface; 30 import android.content.res.Configuration; 31 import android.hardware.input.InputManager; 32 import android.os.Handler; 33 import android.os.HandlerThread; 34 import android.os.Looper; 35 import android.os.Message; 36 import android.os.Process; 37 import android.os.SystemClock; 38 import android.os.UserHandle; 39 import android.provider.Settings.Secure; 40 import android.text.TextUtils; 41 import android.util.Pair; 42 import android.util.Slog; 43 import android.widget.Toast; 44 45 import com.android.settingslib.bluetooth.BluetoothCallback; 46 import com.android.settingslib.bluetooth.CachedBluetoothDevice; 47 import com.android.settingslib.bluetooth.CachedBluetoothDeviceManager; 48 import com.android.settingslib.bluetooth.LocalBluetoothAdapter; 49 import com.android.settingslib.bluetooth.LocalBluetoothManager; 50 import com.android.settingslib.bluetooth.LocalBluetoothProfileManager; 51 import com.android.settingslib.bluetooth.Utils; 52 import com.android.systemui.R; 53 import com.android.systemui.SystemUI; 54 55 import java.io.FileDescriptor; 56 import java.io.PrintWriter; 57 import java.util.Arrays; 58 import java.util.Collection; 59 import java.util.List; 60 import java.util.Set; 61 62 public class KeyboardUI extends SystemUI implements InputManager.OnTabletModeChangedListener { 63 private static final String TAG = "KeyboardUI"; 64 private static final boolean DEBUG = false; 65 66 // Give BT some time to start after SyUI comes up. This avoids flashing a dialog in the user's 67 // face because BT starts a little bit later in the boot process than SysUI and it takes some 68 // time for us to receive the signal that it's starting. 69 private static final long BLUETOOTH_START_DELAY_MILLIS = 10 * 1000; 70 71 // We will be scanning up to 30 seconds, after which we'll stop. 72 private static final long BLUETOOTH_SCAN_TIMEOUT_MILLIS = 30 * 1000; 73 74 private static final int STATE_NOT_ENABLED = -1; 75 private static final int STATE_UNKNOWN = 0; 76 private static final int STATE_WAITING_FOR_BOOT_COMPLETED = 1; 77 private static final int STATE_WAITING_FOR_TABLET_MODE_EXIT = 2; 78 private static final int STATE_WAITING_FOR_DEVICE_DISCOVERY = 3; 79 private static final int STATE_WAITING_FOR_BLUETOOTH = 4; 80 private static final int STATE_PAIRING = 5; 81 private static final int STATE_PAIRED = 6; 82 private static final int STATE_PAIRING_FAILED = 7; 83 private static final int STATE_USER_CANCELLED = 8; 84 private static final int STATE_DEVICE_NOT_FOUND = 9; 85 86 private static final int MSG_INIT = 0; 87 private static final int MSG_ON_BOOT_COMPLETED = 1; 88 private static final int MSG_PROCESS_KEYBOARD_STATE = 2; 89 private static final int MSG_ENABLE_BLUETOOTH = 3; 90 private static final int MSG_ON_BLUETOOTH_STATE_CHANGED = 4; 91 private static final int MSG_ON_DEVICE_BOND_STATE_CHANGED = 5; 92 private static final int MSG_ON_BLUETOOTH_DEVICE_ADDED = 6; 93 private static final int MSG_ON_BLE_SCAN_FAILED = 7; 94 private static final int MSG_SHOW_BLUETOOTH_DIALOG = 8; 95 private static final int MSG_DISMISS_BLUETOOTH_DIALOG = 9; 96 private static final int MSG_BLE_ABORT_SCAN = 10; 97 private static final int MSG_SHOW_ERROR = 11; 98 99 private volatile KeyboardHandler mHandler; 100 private volatile KeyboardUIHandler mUIHandler; 101 102 protected volatile Context mContext; 103 104 private boolean mEnabled; 105 private String mKeyboardName; 106 private CachedBluetoothDeviceManager mCachedDeviceManager; 107 private LocalBluetoothAdapter mLocalBluetoothAdapter; 108 private LocalBluetoothProfileManager mProfileManager; 109 private boolean mBootCompleted; 110 private long mBootCompletedTime; 111 112 private int mInTabletMode = InputManager.SWITCH_STATE_UNKNOWN; 113 private int mScanAttempt = 0; 114 private ScanCallback mScanCallback; 115 private BluetoothDialog mDialog; 116 117 private int mState; 118 119 @Override 120 public void start() { 121 mContext = super.mContext; 122 HandlerThread thread = new HandlerThread("Keyboard", Process.THREAD_PRIORITY_BACKGROUND); 123 thread.start(); 124 mHandler = new KeyboardHandler(thread.getLooper()); 125 mHandler.sendEmptyMessage(MSG_INIT); 126 } 127 128 @Override 129 protected void onConfigurationChanged(Configuration newConfig) { 130 } 131 132 @Override 133 public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 134 pw.println("KeyboardUI:"); 135 pw.println(" mEnabled=" + mEnabled); 136 pw.println(" mBootCompleted=" + mEnabled); 137 pw.println(" mBootCompletedTime=" + mBootCompletedTime); 138 pw.println(" mKeyboardName=" + mKeyboardName); 139 pw.println(" mInTabletMode=" + mInTabletMode); 140 pw.println(" mState=" + stateToString(mState)); 141 } 142 143 @Override 144 protected void onBootCompleted() { 145 mHandler.sendEmptyMessage(MSG_ON_BOOT_COMPLETED); 146 } 147 148 @Override 149 public void onTabletModeChanged(long whenNanos, boolean inTabletMode) { 150 if (DEBUG) { 151 Slog.d(TAG, "onTabletModeChanged(" + whenNanos + ", " + inTabletMode + ")"); 152 } 153 154 if (inTabletMode && mInTabletMode != InputManager.SWITCH_STATE_ON 155 || !inTabletMode && mInTabletMode != InputManager.SWITCH_STATE_OFF) { 156 mInTabletMode = inTabletMode ? 157 InputManager.SWITCH_STATE_ON : InputManager.SWITCH_STATE_OFF; 158 processKeyboardState(); 159 } 160 } 161 162 // Shoud only be called on the handler thread 163 private void init() { 164 Context context = mContext; 165 mKeyboardName = 166 context.getString(com.android.internal.R.string.config_packagedKeyboardName); 167 if (TextUtils.isEmpty(mKeyboardName)) { 168 if (DEBUG) { 169 Slog.d(TAG, "No packaged keyboard name given."); 170 } 171 return; 172 } 173 174 LocalBluetoothManager bluetoothManager = LocalBluetoothManager.getInstance(context, null); 175 if (bluetoothManager == null) { 176 if (DEBUG) { 177 Slog.e(TAG, "Failed to retrieve LocalBluetoothManager instance"); 178 } 179 return; 180 } 181 mEnabled = true; 182 mCachedDeviceManager = bluetoothManager.getCachedDeviceManager(); 183 mLocalBluetoothAdapter = bluetoothManager.getBluetoothAdapter(); 184 mProfileManager = bluetoothManager.getProfileManager(); 185 bluetoothManager.getEventManager().registerCallback(new BluetoothCallbackHandler()); 186 Utils.setErrorListener(new BluetoothErrorListener()); 187 188 InputManager im = context.getSystemService(InputManager.class); 189 im.registerOnTabletModeChangedListener(this, mHandler); 190 mInTabletMode = im.isInTabletMode(); 191 192 processKeyboardState(); 193 mUIHandler = new KeyboardUIHandler(); 194 } 195 196 // Should only be called on the handler thread 197 private void processKeyboardState() { 198 mHandler.removeMessages(MSG_PROCESS_KEYBOARD_STATE); 199 200 if (!mEnabled) { 201 mState = STATE_NOT_ENABLED; 202 return; 203 } 204 205 if (!mBootCompleted) { 206 mState = STATE_WAITING_FOR_BOOT_COMPLETED; 207 return; 208 } 209 210 if (mInTabletMode != InputManager.SWITCH_STATE_OFF) { 211 if (mState == STATE_WAITING_FOR_DEVICE_DISCOVERY) { 212 stopScanning(); 213 } else if (mState == STATE_WAITING_FOR_BLUETOOTH) { 214 mUIHandler.sendEmptyMessage(MSG_DISMISS_BLUETOOTH_DIALOG); 215 } 216 mState = STATE_WAITING_FOR_TABLET_MODE_EXIT; 217 return; 218 } 219 220 final int btState = mLocalBluetoothAdapter.getState(); 221 if ((btState == BluetoothAdapter.STATE_TURNING_ON || btState == BluetoothAdapter.STATE_ON) 222 && mState == STATE_WAITING_FOR_BLUETOOTH) { 223 // If we're waiting for bluetooth but it has come on in the meantime, or is coming 224 // on, just dismiss the dialog. This frequently happens during device startup. 225 mUIHandler.sendEmptyMessage(MSG_DISMISS_BLUETOOTH_DIALOG); 226 } 227 228 if (btState == BluetoothAdapter.STATE_TURNING_ON) { 229 mState = STATE_WAITING_FOR_BLUETOOTH; 230 // Wait for bluetooth to fully come on. 231 return; 232 } 233 234 if (btState != BluetoothAdapter.STATE_ON) { 235 mState = STATE_WAITING_FOR_BLUETOOTH; 236 showBluetoothDialog(); 237 return; 238 } 239 240 CachedBluetoothDevice device = getPairedKeyboard(); 241 if (mState == STATE_WAITING_FOR_TABLET_MODE_EXIT || mState == STATE_WAITING_FOR_BLUETOOTH) { 242 if (device != null) { 243 // If we're just coming out of tablet mode or BT just turned on, 244 // then we want to go ahead and automatically connect to the 245 // keyboard. We want to avoid this in other cases because we might 246 // be spuriously called after the user has manually disconnected 247 // the keyboard, meaning we shouldn't try to automtically connect 248 // it again. 249 mState = STATE_PAIRED; 250 device.connect(false); 251 return; 252 } 253 mCachedDeviceManager.clearNonBondedDevices(); 254 } 255 256 device = getDiscoveredKeyboard(); 257 if (device != null) { 258 mState = STATE_PAIRING; 259 device.startPairing(); 260 } else { 261 mState = STATE_WAITING_FOR_DEVICE_DISCOVERY; 262 startScanning(); 263 } 264 } 265 266 // Should only be called on the handler thread 267 public void onBootCompletedInternal() { 268 mBootCompleted = true; 269 mBootCompletedTime = SystemClock.uptimeMillis(); 270 if (mState == STATE_WAITING_FOR_BOOT_COMPLETED) { 271 processKeyboardState(); 272 } 273 } 274 275 // Should only be called on the handler thread 276 private void showBluetoothDialog() { 277 if (isUserSetupComplete()) { 278 long now = SystemClock.uptimeMillis(); 279 long earliestDialogTime = mBootCompletedTime + BLUETOOTH_START_DELAY_MILLIS; 280 if (earliestDialogTime < now) { 281 mUIHandler.sendEmptyMessage(MSG_SHOW_BLUETOOTH_DIALOG); 282 } else { 283 mHandler.sendEmptyMessageAtTime(MSG_PROCESS_KEYBOARD_STATE, earliestDialogTime); 284 } 285 } else { 286 // If we're in setup wizard and the keyboard is docked, just automatically enable BT. 287 mLocalBluetoothAdapter.enable(); 288 } 289 } 290 291 private boolean isUserSetupComplete() { 292 ContentResolver resolver = mContext.getContentResolver(); 293 return Secure.getIntForUser( 294 resolver, Secure.USER_SETUP_COMPLETE, 0, UserHandle.USER_CURRENT) != 0; 295 } 296 297 private CachedBluetoothDevice getPairedKeyboard() { 298 Set<BluetoothDevice> devices = mLocalBluetoothAdapter.getBondedDevices(); 299 for (BluetoothDevice d : devices) { 300 if (mKeyboardName.equals(d.getName())) { 301 return getCachedBluetoothDevice(d); 302 } 303 } 304 return null; 305 } 306 307 private CachedBluetoothDevice getDiscoveredKeyboard() { 308 Collection<CachedBluetoothDevice> devices = mCachedDeviceManager.getCachedDevicesCopy(); 309 for (CachedBluetoothDevice d : devices) { 310 if (d.getName().equals(mKeyboardName)) { 311 return d; 312 } 313 } 314 return null; 315 } 316 317 318 private CachedBluetoothDevice getCachedBluetoothDevice(BluetoothDevice d) { 319 CachedBluetoothDevice cachedDevice = mCachedDeviceManager.findDevice(d); 320 if (cachedDevice == null) { 321 cachedDevice = mCachedDeviceManager.addDevice( 322 mLocalBluetoothAdapter, mProfileManager, d); 323 } 324 return cachedDevice; 325 } 326 327 private void startScanning() { 328 BluetoothLeScanner scanner = mLocalBluetoothAdapter.getBluetoothLeScanner(); 329 ScanFilter filter = (new ScanFilter.Builder()).setDeviceName(mKeyboardName).build(); 330 ScanSettings settings = (new ScanSettings.Builder()) 331 .setCallbackType(ScanSettings.CALLBACK_TYPE_ALL_MATCHES) 332 .setNumOfMatches(ScanSettings.MATCH_NUM_ONE_ADVERTISEMENT) 333 .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY) 334 .setReportDelay(0) 335 .build(); 336 mScanCallback = new KeyboardScanCallback(); 337 scanner.startScan(Arrays.asList(filter), settings, mScanCallback); 338 339 Message abortMsg = mHandler.obtainMessage(MSG_BLE_ABORT_SCAN, ++mScanAttempt, 0); 340 mHandler.sendMessageDelayed(abortMsg, BLUETOOTH_SCAN_TIMEOUT_MILLIS); 341 } 342 343 private void stopScanning() { 344 if (mScanCallback != null) { 345 BluetoothLeScanner scanner = mLocalBluetoothAdapter.getBluetoothLeScanner(); 346 if (scanner != null) { 347 scanner.stopScan(mScanCallback); 348 } 349 mScanCallback = null; 350 } 351 } 352 353 // Should only be called on the handler thread 354 private void bleAbortScanInternal(int scanAttempt) { 355 if (mState == STATE_WAITING_FOR_DEVICE_DISCOVERY && scanAttempt == mScanAttempt) { 356 if (DEBUG) { 357 Slog.d(TAG, "Bluetooth scan timed out"); 358 } 359 stopScanning(); 360 // FIXME: should we also try shutting off bluetooth if we enabled 361 // it in the first place? 362 mState = STATE_DEVICE_NOT_FOUND; 363 } 364 } 365 366 // Should only be called on the handler thread 367 private void onDeviceAddedInternal(CachedBluetoothDevice d) { 368 if (mState == STATE_WAITING_FOR_DEVICE_DISCOVERY && d.getName().equals(mKeyboardName)) { 369 stopScanning(); 370 d.startPairing(); 371 mState = STATE_PAIRING; 372 } 373 } 374 375 // Should only be called on the handler thread 376 private void onBluetoothStateChangedInternal(int bluetoothState) { 377 if (bluetoothState == BluetoothAdapter.STATE_ON && mState == STATE_WAITING_FOR_BLUETOOTH) { 378 processKeyboardState(); 379 } 380 } 381 382 // Should only be called on the handler thread 383 private void onDeviceBondStateChangedInternal(CachedBluetoothDevice d, int bondState) { 384 if (mState == STATE_PAIRING && d.getName().equals(mKeyboardName)) { 385 if (bondState == BluetoothDevice.BOND_BONDED) { 386 // We don't need to manually connect to the device here because it will 387 // automatically try to connect after it has been paired. 388 mState = STATE_PAIRED; 389 } else if (bondState == BluetoothDevice.BOND_NONE) { 390 mState = STATE_PAIRING_FAILED; 391 } 392 } 393 } 394 395 // Should only be called on the handler thread 396 private void onBleScanFailedInternal() { 397 mScanCallback = null; 398 if (mState == STATE_WAITING_FOR_DEVICE_DISCOVERY) { 399 mState = STATE_DEVICE_NOT_FOUND; 400 } 401 } 402 403 // Should only be called on the handler thread. We want to be careful not to show errors for 404 // pairings not initiated by this UI, so we only pop up the toast when we're at an appropriate 405 // point in our pairing flow and it's the expected device. 406 private void onShowErrorInternal(Context context, String name, int messageResId) { 407 if ((mState == STATE_PAIRING || mState == STATE_PAIRING_FAILED) 408 && mKeyboardName.equals(name)) { 409 String message = context.getString(messageResId, name); 410 Toast.makeText(context, message, Toast.LENGTH_SHORT).show(); 411 } 412 } 413 414 private final class KeyboardUIHandler extends Handler { 415 public KeyboardUIHandler() { 416 super(Looper.getMainLooper(), null, true /*async*/); 417 } 418 @Override 419 public void handleMessage(Message msg) { 420 switch(msg.what) { 421 case MSG_SHOW_BLUETOOTH_DIALOG: { 422 if (mDialog != null) { 423 // Don't show another dialog if one is already present 424 break; 425 } 426 DialogInterface.OnClickListener clickListener = 427 new BluetoothDialogClickListener(); 428 DialogInterface.OnDismissListener dismissListener = 429 new BluetoothDialogDismissListener(); 430 mDialog = new BluetoothDialog(mContext); 431 mDialog.setTitle(R.string.enable_bluetooth_title); 432 mDialog.setMessage(R.string.enable_bluetooth_message); 433 mDialog.setPositiveButton( 434 R.string.enable_bluetooth_confirmation_ok, clickListener); 435 mDialog.setNegativeButton(android.R.string.cancel, clickListener); 436 mDialog.setOnDismissListener(dismissListener); 437 mDialog.show(); 438 break; 439 } 440 case MSG_DISMISS_BLUETOOTH_DIALOG: { 441 if (mDialog != null) { 442 mDialog.dismiss(); 443 } 444 break; 445 } 446 } 447 } 448 } 449 450 private final class KeyboardHandler extends Handler { 451 public KeyboardHandler(Looper looper) { 452 super(looper, null, true /*async*/); 453 } 454 455 @Override 456 public void handleMessage(Message msg) { 457 switch(msg.what) { 458 case MSG_INIT: { 459 init(); 460 break; 461 } 462 case MSG_ON_BOOT_COMPLETED: { 463 onBootCompletedInternal(); 464 break; 465 } 466 case MSG_PROCESS_KEYBOARD_STATE: { 467 processKeyboardState(); 468 break; 469 } 470 case MSG_ENABLE_BLUETOOTH: { 471 boolean enable = msg.arg1 == 1; 472 if (enable) { 473 mLocalBluetoothAdapter.enable(); 474 } else { 475 mState = STATE_USER_CANCELLED; 476 } 477 break; 478 } 479 case MSG_BLE_ABORT_SCAN: { 480 int scanAttempt = msg.arg1; 481 bleAbortScanInternal(scanAttempt); 482 break; 483 } 484 case MSG_ON_BLUETOOTH_STATE_CHANGED: { 485 int bluetoothState = msg.arg1; 486 onBluetoothStateChangedInternal(bluetoothState); 487 break; 488 } 489 case MSG_ON_DEVICE_BOND_STATE_CHANGED: { 490 CachedBluetoothDevice d = (CachedBluetoothDevice)msg.obj; 491 int bondState = msg.arg1; 492 onDeviceBondStateChangedInternal(d, bondState); 493 break; 494 } 495 case MSG_ON_BLUETOOTH_DEVICE_ADDED: { 496 BluetoothDevice d = (BluetoothDevice)msg.obj; 497 CachedBluetoothDevice cachedDevice = getCachedBluetoothDevice(d); 498 onDeviceAddedInternal(cachedDevice); 499 break; 500 501 } 502 case MSG_ON_BLE_SCAN_FAILED: { 503 onBleScanFailedInternal(); 504 break; 505 } 506 case MSG_SHOW_ERROR: { 507 Pair<Context, String> p = (Pair<Context, String>) msg.obj; 508 onShowErrorInternal(p.first, p.second, msg.arg1); 509 } 510 } 511 } 512 } 513 514 private final class BluetoothDialogClickListener implements DialogInterface.OnClickListener { 515 @Override 516 public void onClick(DialogInterface dialog, int which) { 517 int enable = DialogInterface.BUTTON_POSITIVE == which ? 1 : 0; 518 mHandler.obtainMessage(MSG_ENABLE_BLUETOOTH, enable, 0).sendToTarget(); 519 mDialog = null; 520 } 521 } 522 523 private final class BluetoothDialogDismissListener 524 implements DialogInterface.OnDismissListener { 525 @Override 526 public void onDismiss(DialogInterface dialog) { 527 mDialog = null; 528 } 529 } 530 531 private final class KeyboardScanCallback extends ScanCallback { 532 533 private boolean isDeviceDiscoverable(ScanResult result) { 534 final ScanRecord scanRecord = result.getScanRecord(); 535 final int flags = scanRecord.getAdvertiseFlags(); 536 final int BT_DISCOVERABLE_MASK = 0x03; 537 538 return (flags & BT_DISCOVERABLE_MASK) != 0; 539 } 540 541 @Override 542 public void onBatchScanResults(List<ScanResult> results) { 543 if (DEBUG) { 544 Slog.d(TAG, "onBatchScanResults(" + results.size() + ")"); 545 } 546 547 BluetoothDevice bestDevice = null; 548 int bestRssi = Integer.MIN_VALUE; 549 550 for (ScanResult result : results) { 551 if (DEBUG) { 552 Slog.d(TAG, "onBatchScanResults: considering " + result); 553 } 554 555 if (isDeviceDiscoverable(result) && result.getRssi() > bestRssi) { 556 bestDevice = result.getDevice(); 557 bestRssi = result.getRssi(); 558 } 559 } 560 561 if (bestDevice != null) { 562 mHandler.obtainMessage(MSG_ON_BLUETOOTH_DEVICE_ADDED, bestDevice).sendToTarget(); 563 } 564 } 565 566 @Override 567 public void onScanFailed(int errorCode) { 568 if (DEBUG) { 569 Slog.d(TAG, "onScanFailed(" + errorCode + ")"); 570 } 571 mHandler.obtainMessage(MSG_ON_BLE_SCAN_FAILED).sendToTarget(); 572 } 573 574 @Override 575 public void onScanResult(int callbackType, ScanResult result) { 576 if (DEBUG) { 577 Slog.d(TAG, "onScanResult(" + callbackType + ", " + result + ")"); 578 } 579 580 if (isDeviceDiscoverable(result)) { 581 mHandler.obtainMessage(MSG_ON_BLUETOOTH_DEVICE_ADDED, 582 result.getDevice()).sendToTarget(); 583 } else if (DEBUG) { 584 Slog.d(TAG, "onScanResult: device " + result.getDevice() + 585 " is not discoverable, ignoring"); 586 } 587 } 588 } 589 590 private final class BluetoothCallbackHandler implements BluetoothCallback { 591 @Override 592 public void onBluetoothStateChanged(int bluetoothState) { 593 mHandler.obtainMessage(MSG_ON_BLUETOOTH_STATE_CHANGED, 594 bluetoothState, 0).sendToTarget(); 595 } 596 597 @Override 598 public void onDeviceBondStateChanged(CachedBluetoothDevice cachedDevice, int bondState) { 599 mHandler.obtainMessage(MSG_ON_DEVICE_BOND_STATE_CHANGED, 600 bondState, 0, cachedDevice).sendToTarget(); 601 } 602 603 @Override 604 public void onDeviceAdded(CachedBluetoothDevice cachedDevice) { } 605 @Override 606 public void onDeviceDeleted(CachedBluetoothDevice cachedDevice) { } 607 @Override 608 public void onScanningStateChanged(boolean started) { } 609 @Override 610 public void onConnectionStateChanged(CachedBluetoothDevice cachedDevice, int state) { } 611 } 612 613 private final class BluetoothErrorListener implements Utils.ErrorListener { 614 public void onShowError(Context context, String name, int messageResId) { 615 mHandler.obtainMessage(MSG_SHOW_ERROR, messageResId, 0 /*unused*/, 616 new Pair<>(context, name)).sendToTarget(); 617 } 618 } 619 620 private static String stateToString(int state) { 621 switch (state) { 622 case STATE_NOT_ENABLED: 623 return "STATE_NOT_ENABLED"; 624 case STATE_WAITING_FOR_BOOT_COMPLETED: 625 return "STATE_WAITING_FOR_BOOT_COMPLETED"; 626 case STATE_WAITING_FOR_TABLET_MODE_EXIT: 627 return "STATE_WAITING_FOR_TABLET_MODE_EXIT"; 628 case STATE_WAITING_FOR_DEVICE_DISCOVERY: 629 return "STATE_WAITING_FOR_DEVICE_DISCOVERY"; 630 case STATE_WAITING_FOR_BLUETOOTH: 631 return "STATE_WAITING_FOR_BLUETOOTH"; 632 case STATE_PAIRING: 633 return "STATE_PAIRING"; 634 case STATE_PAIRED: 635 return "STATE_PAIRED"; 636 case STATE_PAIRING_FAILED: 637 return "STATE_PAIRING_FAILED"; 638 case STATE_USER_CANCELLED: 639 return "STATE_USER_CANCELLED"; 640 case STATE_DEVICE_NOT_FOUND: 641 return "STATE_DEVICE_NOT_FOUND"; 642 case STATE_UNKNOWN: 643 default: 644 return "STATE_UNKNOWN (" + state + ")"; 645 } 646 } 647 } 648
