packages/SystemUI/src/com/android/systemui/keyboard/KeyboardUI.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2015 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.systemui.keyboard;

 import android.bluetooth.BluetoothAdapter;
 import android.bluetooth.BluetoothDevice;
 import android.bluetooth.le.BluetoothLeScanner;
 import android.bluetooth.le.ScanCallback;
 import android.bluetooth.le.ScanFilter;
 import android.bluetooth.le.ScanRecord;
 import android.bluetooth.le.ScanResult;
 import android.bluetooth.le.ScanSettings;
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.res.Configuration;
 import android.hardware.input.InputManager;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.Looper;
 import android.os.Message;
 import android.os.Process;
 import android.os.SystemClock;
 import android.os.UserHandle;
 import android.provider.Settings.Secure;
 import android.text.TextUtils;
 import android.util.Pair;
 import android.util.Slog;
 import android.widget.Toast;

 import com.android.settingslib.bluetooth.BluetoothCallback;
 import com.android.settingslib.bluetooth.BluetoothUtils;
 import com.android.settingslib.bluetooth.CachedBluetoothDevice;
 import com.android.settingslib.bluetooth.CachedBluetoothDeviceManager;
 import com.android.settingslib.bluetooth.LocalBluetoothAdapter;
 import com.android.settingslib.bluetooth.LocalBluetoothManager;
 import com.android.settingslib.bluetooth.LocalBluetoothProfileManager;
 import com.android.systemui.Dependency;
 import com.android.systemui.R;
 import com.android.systemui.SystemUI;

 import java.io.FileDescriptor;
 import java.io.PrintWriter;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 import java.util.Set;

 public class KeyboardUI extends SystemUI implements InputManager.OnTabletModeChangedListener {
     private static final String TAG = "KeyboardUI";
     private static final boolean DEBUG = false;

     // Give BT some time to start after SyUI comes up. This avoids flashing a dialog in the user's
     // face because BT starts a little bit later in the boot process than SysUI and it takes some
     // time for us to receive the signal that it's starting.
     private static final long BLUETOOTH_START_DELAY_MILLIS = 10 * 1000;

     // We will be scanning up to 30 seconds, after which we'll stop.
     private static final long BLUETOOTH_SCAN_TIMEOUT_MILLIS = 30 * 1000;

     private static final int STATE_NOT_ENABLED = -1;
     private static final int STATE_UNKNOWN = 0;
     private static final int STATE_WAITING_FOR_BOOT_COMPLETED = 1;
     private static final int STATE_WAITING_FOR_TABLET_MODE_EXIT = 2;
     private static final int STATE_WAITING_FOR_DEVICE_DISCOVERY = 3;
     private static final int STATE_WAITING_FOR_BLUETOOTH = 4;
     private static final int STATE_PAIRING = 5;
     private static final int STATE_PAIRED = 6;
     private static final int STATE_PAIRING_FAILED = 7;
     private static final int STATE_USER_CANCELLED = 8;
     private static final int STATE_DEVICE_NOT_FOUND = 9;

     private static final int MSG_INIT = 0;
     private static final int MSG_ON_BOOT_COMPLETED = 1;
     private static final int MSG_PROCESS_KEYBOARD_STATE = 2;
     private static final int MSG_ENABLE_BLUETOOTH = 3;
     private static final int MSG_ON_BLUETOOTH_STATE_CHANGED = 4;
     private static final int MSG_ON_DEVICE_BOND_STATE_CHANGED = 5;
     private static final int MSG_ON_BLUETOOTH_DEVICE_ADDED = 6;
     private static final int MSG_ON_BLE_SCAN_FAILED = 7;
     private static final int MSG_SHOW_BLUETOOTH_DIALOG = 8;
     private static final int MSG_DISMISS_BLUETOOTH_DIALOG = 9;
     private static final int MSG_BLE_ABORT_SCAN = 10;
     private static final int MSG_SHOW_ERROR = 11;

     private volatile KeyboardHandler mHandler;
     private volatile KeyboardUIHandler mUIHandler;

     protected volatile Context mContext;

     private boolean mEnabled;
     private String mKeyboardName;
     private CachedBluetoothDeviceManager mCachedDeviceManager;
     private LocalBluetoothAdapter mLocalBluetoothAdapter;
     private LocalBluetoothProfileManager mProfileManager;
     private boolean mBootCompleted;
     private long mBootCompletedTime;

     private int mInTabletMode = InputManager.SWITCH_STATE_UNKNOWN;
     private int mScanAttempt = 0;
     private ScanCallback mScanCallback;
     private BluetoothDialog mDialog;

     private int mState;

     @Override
     public void start() {
         mContext = super.mContext;
         HandlerThread thread = new HandlerThread("Keyboard", Process.THREAD_PRIORITY_BACKGROUND);
         thread.start();
         mHandler = new KeyboardHandler(thread.getLooper());
         mHandler.sendEmptyMessage(MSG_INIT);
     }

     @Override
     protected void onConfigurationChanged(Configuration newConfig) {
     }

     @Override
     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
         pw.println("KeyboardUI:");
         pw.println("  mEnabled=" + mEnabled);
         pw.println("  mBootCompleted=" + mEnabled);
         pw.println("  mBootCompletedTime=" + mBootCompletedTime);
         pw.println("  mKeyboardName=" + mKeyboardName);
         pw.println("  mInTabletMode=" + mInTabletMode);
         pw.println("  mState=" + stateToString(mState));
     }

     @Override
     protected void onBootCompleted() {
         mHandler.sendEmptyMessage(MSG_ON_BOOT_COMPLETED);
     }

     @Override
     public void onTabletModeChanged(long whenNanos, boolean inTabletMode) {
         if (DEBUG) {
             Slog.d(TAG, "onTabletModeChanged(" + whenNanos + ", " + inTabletMode + ")");
         }

         if (inTabletMode && mInTabletMode != InputManager.SWITCH_STATE_ON
                 || !inTabletMode && mInTabletMode != InputManager.SWITCH_STATE_OFF) {
             mInTabletMode = inTabletMode ?
                     InputManager.SWITCH_STATE_ON : InputManager.SWITCH_STATE_OFF;
             processKeyboardState();
         }
     }

     // Shoud only be called on the handler thread
     private void init() {
         Context context = mContext;
         mKeyboardName =
                 context.getString(com.android.internal.R.string.config_packagedKeyboardName);
         if (TextUtils.isEmpty(mKeyboardName)) {
             if (DEBUG) {
                 Slog.d(TAG, "No packaged keyboard name given.");
             }
             return;
         }

         LocalBluetoothManager bluetoothManager = Dependency.get(LocalBluetoothManager.class);
         if (bluetoothManager == null)  {
             if (DEBUG) {
                 Slog.e(TAG, "Failed to retrieve LocalBluetoothManager instance");
             }
             return;
         }
         mEnabled = true;
         mCachedDeviceManager = bluetoothManager.getCachedDeviceManager();
         mLocalBluetoothAdapter = bluetoothManager.getBluetoothAdapter();
         mProfileManager = bluetoothManager.getProfileManager();
         bluetoothManager.getEventManager().registerCallback(new BluetoothCallbackHandler());
         BluetoothUtils.setErrorListener(new BluetoothErrorListener());

         InputManager im = context.getSystemService(InputManager.class);
         im.registerOnTabletModeChangedListener(this, mHandler);
         mInTabletMode = im.isInTabletMode();

         processKeyboardState();
         mUIHandler = new KeyboardUIHandler();
     }

     // Should only be called on the handler thread
     private void processKeyboardState() {
         mHandler.removeMessages(MSG_PROCESS_KEYBOARD_STATE);

         if (!mEnabled) {
             mState = STATE_NOT_ENABLED;
             return;
         }

         if (!mBootCompleted) {
             mState = STATE_WAITING_FOR_BOOT_COMPLETED;
             return;
         }

         if (mInTabletMode != InputManager.SWITCH_STATE_OFF) {
             if (mState == STATE_WAITING_FOR_DEVICE_DISCOVERY) {
                 stopScanning();
             } else if (mState == STATE_WAITING_FOR_BLUETOOTH) {
                 mUIHandler.sendEmptyMessage(MSG_DISMISS_BLUETOOTH_DIALOG);
             }
             mState = STATE_WAITING_FOR_TABLET_MODE_EXIT;
             return;
         }

         final int btState = mLocalBluetoothAdapter.getState();
         if ((btState == BluetoothAdapter.STATE_TURNING_ON || btState == BluetoothAdapter.STATE_ON)
                 && mState == STATE_WAITING_FOR_BLUETOOTH) {
             // If we're waiting for bluetooth but it has come on in the meantime, or is coming
             // on, just dismiss the dialog. This frequently happens during device startup.
             mUIHandler.sendEmptyMessage(MSG_DISMISS_BLUETOOTH_DIALOG);
         }

         if (btState == BluetoothAdapter.STATE_TURNING_ON) {
             mState = STATE_WAITING_FOR_BLUETOOTH;
             // Wait for bluetooth to fully come on.
             return;
         }

         if (btState != BluetoothAdapter.STATE_ON) {
             mState = STATE_WAITING_FOR_BLUETOOTH;
             showBluetoothDialog();
             return;
         }

         CachedBluetoothDevice device = getPairedKeyboard();
         if (mState == STATE_WAITING_FOR_TABLET_MODE_EXIT || mState == STATE_WAITING_FOR_BLUETOOTH) {
             if (device != null) {
                 // If we're just coming out of tablet mode or BT just turned on,
                 // then we want to go ahead and automatically connect to the
                 // keyboard. We want to avoid this in other cases because we might
                 // be spuriously called after the user has manually disconnected
                 // the keyboard, meaning we shouldn't try to automtically connect
                 // it again.
                 mState = STATE_PAIRED;
                 device.connect(false);
                 return;
             }
             mCachedDeviceManager.clearNonBondedDevices();
         }

         device = getDiscoveredKeyboard();
         if (device != null) {
             mState = STATE_PAIRING;
             device.startPairing();
         } else {
             mState = STATE_WAITING_FOR_DEVICE_DISCOVERY;
             startScanning();
         }
     }

     // Should only be called on the handler thread
     public void onBootCompletedInternal() {
         mBootCompleted = true;
         mBootCompletedTime = SystemClock.uptimeMillis();
         if (mState == STATE_WAITING_FOR_BOOT_COMPLETED) {
             processKeyboardState();
         }
     }

     // Should only be called on the handler thread
     private void showBluetoothDialog() {
         if (isUserSetupComplete()) {
             long now = SystemClock.uptimeMillis();
             long earliestDialogTime = mBootCompletedTime + BLUETOOTH_START_DELAY_MILLIS;
             if (earliestDialogTime < now) {
                 mUIHandler.sendEmptyMessage(MSG_SHOW_BLUETOOTH_DIALOG);
             } else {
                 mHandler.sendEmptyMessageAtTime(MSG_PROCESS_KEYBOARD_STATE, earliestDialogTime);
             }
         } else {
             // If we're in setup wizard and the keyboard is docked, just automatically enable BT.
             mLocalBluetoothAdapter.enable();
         }
     }

     private boolean isUserSetupComplete() {
         ContentResolver resolver = mContext.getContentResolver();
         return Secure.getIntForUser(
                 resolver, Secure.USER_SETUP_COMPLETE, 0, UserHandle.USER_CURRENT) != 0;
     }

     private CachedBluetoothDevice getPairedKeyboard() {
         Set<BluetoothDevice> devices = mLocalBluetoothAdapter.getBondedDevices();
         for (BluetoothDevice d : devices) {
             if (mKeyboardName.equals(d.getName())) {
                 return getCachedBluetoothDevice(d);
             }
         }
         return null;
     }

     private CachedBluetoothDevice getDiscoveredKeyboard() {
         Collection<CachedBluetoothDevice> devices = mCachedDeviceManager.getCachedDevicesCopy();
         for (CachedBluetoothDevice d : devices) {
             if (d.getName().equals(mKeyboardName)) {
                 return d;
             }
         }
         return null;
     }


     private CachedBluetoothDevice getCachedBluetoothDevice(BluetoothDevice d) {
         CachedBluetoothDevice cachedDevice = mCachedDeviceManager.findDevice(d);
         if (cachedDevice == null) {
             cachedDevice = mCachedDeviceManager.addDevice(d);
         }
         return cachedDevice;
     }

     private void startScanning() {
         BluetoothLeScanner scanner = mLocalBluetoothAdapter.getBluetoothLeScanner();
         ScanFilter filter = (new ScanFilter.Builder()).setDeviceName(mKeyboardName).build();
         ScanSettings settings = (new ScanSettings.Builder())
             .setCallbackType(ScanSettings.CALLBACK_TYPE_ALL_MATCHES)
             .setNumOfMatches(ScanSettings.MATCH_NUM_ONE_ADVERTISEMENT)
             .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
             .setReportDelay(0)
             .build();
         mScanCallback = new KeyboardScanCallback();
         scanner.startScan(Arrays.asList(filter), settings, mScanCallback);

         Message abortMsg = mHandler.obtainMessage(MSG_BLE_ABORT_SCAN, ++mScanAttempt, 0);
         mHandler.sendMessageDelayed(abortMsg, BLUETOOTH_SCAN_TIMEOUT_MILLIS);
     }

     private void stopScanning() {
         if (mScanCallback != null) {
             BluetoothLeScanner scanner = mLocalBluetoothAdapter.getBluetoothLeScanner();
             if (scanner != null) {
                 scanner.stopScan(mScanCallback);
             }
             mScanCallback = null;
         }
     }

     // Should only be called on the handler thread
     private void bleAbortScanInternal(int scanAttempt) {
         if (mState == STATE_WAITING_FOR_DEVICE_DISCOVERY && scanAttempt == mScanAttempt) {
             if (DEBUG) {
                 Slog.d(TAG, "Bluetooth scan timed out");
             }
             stopScanning();
             // FIXME: should we also try shutting off bluetooth if we enabled
             // it in the first place?
             mState = STATE_DEVICE_NOT_FOUND;
         }
     }

     // Should only be called on the handler thread
     private void onDeviceAddedInternal(CachedBluetoothDevice d) {
         if (mState == STATE_WAITING_FOR_DEVICE_DISCOVERY && d.getName().equals(mKeyboardName)) {
             stopScanning();
             d.startPairing();
             mState = STATE_PAIRING;
         }
     }

     // Should only be called on the handler thread
     private void onBluetoothStateChangedInternal(int bluetoothState) {
         if (bluetoothState == BluetoothAdapter.STATE_ON && mState == STATE_WAITING_FOR_BLUETOOTH) {
             processKeyboardState();
         }
     }

     // Should only be called on the handler thread
     private void onDeviceBondStateChangedInternal(CachedBluetoothDevice d, int bondState) {
         if (mState == STATE_PAIRING && d.getName().equals(mKeyboardName)) {
             if (bondState == BluetoothDevice.BOND_BONDED) {
                 // We don't need to manually connect to the device here because it will
                 // automatically try to connect after it has been paired.
                 mState = STATE_PAIRED;
             } else if (bondState == BluetoothDevice.BOND_NONE) {
                 mState = STATE_PAIRING_FAILED;
             }
         }
     }

     // Should only be called on the handler thread
     private void onBleScanFailedInternal() {
         mScanCallback = null;
         if (mState == STATE_WAITING_FOR_DEVICE_DISCOVERY) {
             mState = STATE_DEVICE_NOT_FOUND;
         }
     }

     // Should only be called on the handler thread. We want to be careful not to show errors for
     // pairings not initiated by this UI, so we only pop up the toast when we're at an appropriate
     // point in our pairing flow and it's the expected device.
     private void onShowErrorInternal(Context context, String name, int messageResId) {
         if ((mState == STATE_PAIRING || mState == STATE_PAIRING_FAILED)
                 && mKeyboardName.equals(name)) {
             String message = context.getString(messageResId, name);
             Toast.makeText(context, message, Toast.LENGTH_SHORT).show();
         }
     }

     private final class KeyboardUIHandler extends Handler {
         public KeyboardUIHandler() {
             super(Looper.getMainLooper(), null, true /*async*/);
         }
         @Override
         public void handleMessage(Message msg) {
             switch(msg.what) {
                 case MSG_SHOW_BLUETOOTH_DIALOG: {
                     if (mDialog != null) {
                         // Don't show another dialog if one is already present
                         break;
                     }
                     DialogInterface.OnClickListener clickListener =
                             new BluetoothDialogClickListener();
                     DialogInterface.OnDismissListener dismissListener =
                             new BluetoothDialogDismissListener();
                     mDialog = new BluetoothDialog(mContext);
                     mDialog.setTitle(R.string.enable_bluetooth_title);
                     mDialog.setMessage(R.string.enable_bluetooth_message);
                     mDialog.setPositiveButton(
                             R.string.enable_bluetooth_confirmation_ok, clickListener);
                     mDialog.setNegativeButton(android.R.string.cancel, clickListener);
                     mDialog.setOnDismissListener(dismissListener);
                     mDialog.show();
                     break;
                 }
                 case MSG_DISMISS_BLUETOOTH_DIALOG: {
                     if (mDialog != null) {
                         mDialog.dismiss();
                     }
                     break;
                 }
             }
         }
     }

     private final class KeyboardHandler extends Handler {
         public KeyboardHandler(Looper looper) {
             super(looper, null, true /*async*/);
         }

         @Override
         public void handleMessage(Message msg) {
             switch(msg.what) {
                 case MSG_INIT: {
                     init();
                     break;
                 }
                 case MSG_ON_BOOT_COMPLETED: {
                     onBootCompletedInternal();
                     break;
                 }
                 case MSG_PROCESS_KEYBOARD_STATE: {
                     processKeyboardState();
                     break;
                 }
                 case MSG_ENABLE_BLUETOOTH: {
                     boolean enable = msg.arg1 == 1;
                     if (enable) {
                         mLocalBluetoothAdapter.enable();
                     } else {
                         mState = STATE_USER_CANCELLED;
                     }
                     break;
                 }
                 case MSG_BLE_ABORT_SCAN: {
                     int scanAttempt = msg.arg1;
                     bleAbortScanInternal(scanAttempt);
                     break;
                 }
                 case MSG_ON_BLUETOOTH_STATE_CHANGED: {
                     int bluetoothState = msg.arg1;
                     onBluetoothStateChangedInternal(bluetoothState);
                     break;
                 }
                 case MSG_ON_DEVICE_BOND_STATE_CHANGED: {
                     CachedBluetoothDevice d = (CachedBluetoothDevice)msg.obj;
                     int bondState = msg.arg1;
                     onDeviceBondStateChangedInternal(d, bondState);
                     break;
                 }
                 case MSG_ON_BLUETOOTH_DEVICE_ADDED: {
                     BluetoothDevice d = (BluetoothDevice)msg.obj;
                     CachedBluetoothDevice cachedDevice = getCachedBluetoothDevice(d);
                     onDeviceAddedInternal(cachedDevice);
                     break;

                 }
                 case MSG_ON_BLE_SCAN_FAILED: {
                     onBleScanFailedInternal();
                     break;
                 }
                 case MSG_SHOW_ERROR: {
                     Pair<Context, String> p = (Pair<Context, String>) msg.obj;
                     onShowErrorInternal(p.first, p.second, msg.arg1);
                 }
             }
         }
     }

     private final class BluetoothDialogClickListener implements DialogInterface.OnClickListener {
         @Override
         public void onClick(DialogInterface dialog, int which) {
             int enable = DialogInterface.BUTTON_POSITIVE == which ? 1 : 0;
             mHandler.obtainMessage(MSG_ENABLE_BLUETOOTH, enable, 0).sendToTarget();
             mDialog = null;
         }
     }

     private final class BluetoothDialogDismissListener
             implements DialogInterface.OnDismissListener {
         @Override
         public void onDismiss(DialogInterface dialog) {
             mDialog = null;
         }
     }

     private final class KeyboardScanCallback extends ScanCallback {

         private boolean isDeviceDiscoverable(ScanResult result) {
             final ScanRecord scanRecord = result.getScanRecord();
             final int flags = scanRecord.getAdvertiseFlags();
             final int BT_DISCOVERABLE_MASK = 0x03;

             return (flags & BT_DISCOVERABLE_MASK) != 0;
         }

         @Override
         public void onBatchScanResults(List<ScanResult> results) {
             if (DEBUG) {
                 Slog.d(TAG, "onBatchScanResults(" + results.size() + ")");
             }

             BluetoothDevice bestDevice = null;
             int bestRssi = Integer.MIN_VALUE;

             for (ScanResult result : results) {
                 if (DEBUG) {
                     Slog.d(TAG, "onBatchScanResults: considering " + result);
                 }

                 if (isDeviceDiscoverable(result) && result.getRssi() > bestRssi) {
                     bestDevice = result.getDevice();
                     bestRssi = result.getRssi();
                 }
             }

             if (bestDevice != null) {
                 mHandler.obtainMessage(MSG_ON_BLUETOOTH_DEVICE_ADDED, bestDevice).sendToTarget();
             }
         }

         @Override
         public void onScanFailed(int errorCode) {
             if (DEBUG) {
                 Slog.d(TAG, "onScanFailed(" + errorCode + ")");
             }
             mHandler.obtainMessage(MSG_ON_BLE_SCAN_FAILED).sendToTarget();
         }

         @Override
         public void onScanResult(int callbackType, ScanResult result) {
             if (DEBUG) {
                 Slog.d(TAG, "onScanResult(" + callbackType + ", " + result + ")");
             }

             if (isDeviceDiscoverable(result)) {
                 mHandler.obtainMessage(MSG_ON_BLUETOOTH_DEVICE_ADDED,
                         result.getDevice()).sendToTarget();
             } else if (DEBUG) {
                 Slog.d(TAG, "onScanResult: device " + result.getDevice() +
                        " is not discoverable, ignoring");
             }
         }
     }

     private final class BluetoothCallbackHandler implements BluetoothCallback {
         @Override
         public void onBluetoothStateChanged(int bluetoothState) {
             mHandler.obtainMessage(MSG_ON_BLUETOOTH_STATE_CHANGED,
                     bluetoothState, 0).sendToTarget();
         }

         @Override
         public void onDeviceBondStateChanged(CachedBluetoothDevice cachedDevice, int bondState) {
             mHandler.obtainMessage(MSG_ON_DEVICE_BOND_STATE_CHANGED,
                     bondState, 0, cachedDevice).sendToTarget();
         }
     }

     private final class BluetoothErrorListener implements BluetoothUtils.ErrorListener {
         public void onShowError(Context context, String name, int messageResId) {
             mHandler.obtainMessage(MSG_SHOW_ERROR, messageResId, 0 /*unused*/,
                     new Pair<>(context, name)).sendToTarget();
         }
     }

     private static String stateToString(int state) {
         switch (state) {
             case STATE_NOT_ENABLED:
                 return "STATE_NOT_ENABLED";
             case STATE_WAITING_FOR_BOOT_COMPLETED:
                 return "STATE_WAITING_FOR_BOOT_COMPLETED";
             case STATE_WAITING_FOR_TABLET_MODE_EXIT:
                 return "STATE_WAITING_FOR_TABLET_MODE_EXIT";
             case STATE_WAITING_FOR_DEVICE_DISCOVERY:
                 return "STATE_WAITING_FOR_DEVICE_DISCOVERY";
             case STATE_WAITING_FOR_BLUETOOTH:
                 return "STATE_WAITING_FOR_BLUETOOTH";
             case STATE_PAIRING:
                 return "STATE_PAIRING";
             case STATE_PAIRED:
                 return "STATE_PAIRED";
             case STATE_PAIRING_FAILED:
                 return "STATE_PAIRING_FAILED";
             case STATE_USER_CANCELLED:
                 return "STATE_USER_CANCELLED";
             case STATE_DEVICE_NOT_FOUND:
                 return "STATE_DEVICE_NOT_FOUND";
             case STATE_UNKNOWN:
             default:
                 return "STATE_UNKNOWN (" + state + ")";
         }
     }
 }
	/*
	* Copyright (C) 2015 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.systemui.keyboard;

	import android.bluetooth.BluetoothAdapter;
	import android.bluetooth.BluetoothDevice;
	import android.bluetooth.le.BluetoothLeScanner;
	import android.bluetooth.le.ScanCallback;
	import android.bluetooth.le.ScanFilter;
	import android.bluetooth.le.ScanRecord;
	import android.bluetooth.le.ScanResult;
	import android.bluetooth.le.ScanSettings;
	import android.content.ContentResolver;
	import android.content.Context;
	import android.content.DialogInterface;
	import android.content.res.Configuration;
	import android.hardware.input.InputManager;
	import android.os.Handler;
	import android.os.HandlerThread;
	import android.os.Looper;
	import android.os.Message;
	import android.os.Process;
	import android.os.SystemClock;
	import android.os.UserHandle;
	import android.provider.Settings.Secure;
	import android.text.TextUtils;
	import android.util.Pair;
	import android.util.Slog;
	import android.widget.Toast;

	import com.android.settingslib.bluetooth.BluetoothCallback;
	import com.android.settingslib.bluetooth.BluetoothUtils;
	import com.android.settingslib.bluetooth.CachedBluetoothDevice;
	import com.android.settingslib.bluetooth.CachedBluetoothDeviceManager;
	import com.android.settingslib.bluetooth.LocalBluetoothAdapter;
	import com.android.settingslib.bluetooth.LocalBluetoothManager;
	import com.android.settingslib.bluetooth.LocalBluetoothProfileManager;
	import com.android.systemui.Dependency;
	import com.android.systemui.R;
	import com.android.systemui.SystemUI;

	import java.io.FileDescriptor;
	import java.io.PrintWriter;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.List;
	import java.util.Set;

	public class KeyboardUI extends SystemUI implements InputManager.OnTabletModeChangedListener {
	private static final String TAG = "KeyboardUI";
	private static final boolean DEBUG = false;

	// Give BT some time to start after SyUI comes up. This avoids flashing a dialog in the user's
	// face because BT starts a little bit later in the boot process than SysUI and it takes some
	// time for us to receive the signal that it's starting.
	private static final long BLUETOOTH_START_DELAY_MILLIS = 10 * 1000;

	// We will be scanning up to 30 seconds, after which we'll stop.
	private static final long BLUETOOTH_SCAN_TIMEOUT_MILLIS = 30 * 1000;

	private static final int STATE_NOT_ENABLED = -1;
	private static final int STATE_UNKNOWN = 0;
	private static final int STATE_WAITING_FOR_BOOT_COMPLETED = 1;
	private static final int STATE_WAITING_FOR_TABLET_MODE_EXIT = 2;
	private static final int STATE_WAITING_FOR_DEVICE_DISCOVERY = 3;
	private static final int STATE_WAITING_FOR_BLUETOOTH = 4;
	private static final int STATE_PAIRING = 5;
	private static final int STATE_PAIRED = 6;
	private static final int STATE_PAIRING_FAILED = 7;
	private static final int STATE_USER_CANCELLED = 8;
	private static final int STATE_DEVICE_NOT_FOUND = 9;

	private static final int MSG_INIT = 0;
	private static final int MSG_ON_BOOT_COMPLETED = 1;
	private static final int MSG_PROCESS_KEYBOARD_STATE = 2;
	private static final int MSG_ENABLE_BLUETOOTH = 3;
	private static final int MSG_ON_BLUETOOTH_STATE_CHANGED = 4;
	private static final int MSG_ON_DEVICE_BOND_STATE_CHANGED = 5;
	private static final int MSG_ON_BLUETOOTH_DEVICE_ADDED = 6;
	private static final int MSG_ON_BLE_SCAN_FAILED = 7;
	private static final int MSG_SHOW_BLUETOOTH_DIALOG = 8;
	private static final int MSG_DISMISS_BLUETOOTH_DIALOG = 9;
	private static final int MSG_BLE_ABORT_SCAN = 10;
	private static final int MSG_SHOW_ERROR = 11;

	private volatile KeyboardHandler mHandler;
	private volatile KeyboardUIHandler mUIHandler;

	protected volatile Context mContext;

	private boolean mEnabled;
	private String mKeyboardName;
	private CachedBluetoothDeviceManager mCachedDeviceManager;
	private LocalBluetoothAdapter mLocalBluetoothAdapter;
	private LocalBluetoothProfileManager mProfileManager;
	private boolean mBootCompleted;
	private long mBootCompletedTime;

	private int mInTabletMode = InputManager.SWITCH_STATE_UNKNOWN;
	private int mScanAttempt = 0;
	private ScanCallback mScanCallback;
	private BluetoothDialog mDialog;

	private int mState;

	@Override
	public void start() {
	mContext = super.mContext;
	HandlerThread thread = new HandlerThread("Keyboard", Process.THREAD_PRIORITY_BACKGROUND);
	thread.start();
	mHandler = new KeyboardHandler(thread.getLooper());
	mHandler.sendEmptyMessage(MSG_INIT);
	}

	@Override
	protected void onConfigurationChanged(Configuration newConfig) {
	}

	@Override
	public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
	pw.println("KeyboardUI:");
	pw.println(" mEnabled=" + mEnabled);
	pw.println(" mBootCompleted=" + mEnabled);
	pw.println(" mBootCompletedTime=" + mBootCompletedTime);
	pw.println(" mKeyboardName=" + mKeyboardName);
	pw.println(" mInTabletMode=" + mInTabletMode);
	pw.println(" mState=" + stateToString(mState));
	}

	@Override
	protected void onBootCompleted() {
	mHandler.sendEmptyMessage(MSG_ON_BOOT_COMPLETED);
	}

	@Override
	public void onTabletModeChanged(long whenNanos, boolean inTabletMode) {
	if (DEBUG) {
	Slog.d(TAG, "onTabletModeChanged(" + whenNanos + ", " + inTabletMode + ")");
	}

	if (inTabletMode && mInTabletMode != InputManager.SWITCH_STATE_ON
	\|\| !inTabletMode && mInTabletMode != InputManager.SWITCH_STATE_OFF) {
	mInTabletMode = inTabletMode ?
	InputManager.SWITCH_STATE_ON : InputManager.SWITCH_STATE_OFF;
	processKeyboardState();
	}
	}

	// Shoud only be called on the handler thread
	private void init() {
	Context context = mContext;
	mKeyboardName =
	context.getString(com.android.internal.R.string.config_packagedKeyboardName);
	if (TextUtils.isEmpty(mKeyboardName)) {
	if (DEBUG) {
	Slog.d(TAG, "No packaged keyboard name given.");
	}
	return;
	}

	LocalBluetoothManager bluetoothManager = Dependency.get(LocalBluetoothManager.class);
	if (bluetoothManager == null) {
	if (DEBUG) {
	Slog.e(TAG, "Failed to retrieve LocalBluetoothManager instance");
	}
	return;
	}
	mEnabled = true;
	mCachedDeviceManager = bluetoothManager.getCachedDeviceManager();
	mLocalBluetoothAdapter = bluetoothManager.getBluetoothAdapter();
	mProfileManager = bluetoothManager.getProfileManager();
	bluetoothManager.getEventManager().registerCallback(new BluetoothCallbackHandler());
	BluetoothUtils.setErrorListener(new BluetoothErrorListener());

	InputManager im = context.getSystemService(InputManager.class);
	im.registerOnTabletModeChangedListener(this, mHandler);
	mInTabletMode = im.isInTabletMode();

	processKeyboardState();
	mUIHandler = new KeyboardUIHandler();
	}

	// Should only be called on the handler thread
	private void processKeyboardState() {
	mHandler.removeMessages(MSG_PROCESS_KEYBOARD_STATE);

	if (!mEnabled) {
	mState = STATE_NOT_ENABLED;
	return;
	}

	if (!mBootCompleted) {
	mState = STATE_WAITING_FOR_BOOT_COMPLETED;
	return;
	}

	if (mInTabletMode != InputManager.SWITCH_STATE_OFF) {
	if (mState == STATE_WAITING_FOR_DEVICE_DISCOVERY) {
	stopScanning();
	} else if (mState == STATE_WAITING_FOR_BLUETOOTH) {
	mUIHandler.sendEmptyMessage(MSG_DISMISS_BLUETOOTH_DIALOG);
	}
	mState = STATE_WAITING_FOR_TABLET_MODE_EXIT;
	return;
	}

	final int btState = mLocalBluetoothAdapter.getState();
	if ((btState == BluetoothAdapter.STATE_TURNING_ON \|\| btState == BluetoothAdapter.STATE_ON)
	&& mState == STATE_WAITING_FOR_BLUETOOTH) {
	// If we're waiting for bluetooth but it has come on in the meantime, or is coming
	// on, just dismiss the dialog. This frequently happens during device startup.
	mUIHandler.sendEmptyMessage(MSG_DISMISS_BLUETOOTH_DIALOG);
	}

	if (btState == BluetoothAdapter.STATE_TURNING_ON) {
	mState = STATE_WAITING_FOR_BLUETOOTH;
	// Wait for bluetooth to fully come on.
	return;
	}

	if (btState != BluetoothAdapter.STATE_ON) {
	mState = STATE_WAITING_FOR_BLUETOOTH;
	showBluetoothDialog();
	return;
	}

	CachedBluetoothDevice device = getPairedKeyboard();
	if (mState == STATE_WAITING_FOR_TABLET_MODE_EXIT \|\| mState == STATE_WAITING_FOR_BLUETOOTH) {
	if (device != null) {
	// If we're just coming out of tablet mode or BT just turned on,
	// then we want to go ahead and automatically connect to the
	// keyboard. We want to avoid this in other cases because we might
	// be spuriously called after the user has manually disconnected
	// the keyboard, meaning we shouldn't try to automtically connect
	// it again.
	mState = STATE_PAIRED;
	device.connect(false);
	return;
	}
	mCachedDeviceManager.clearNonBondedDevices();
	}

	device = getDiscoveredKeyboard();
	if (device != null) {
	mState = STATE_PAIRING;
	device.startPairing();
	} else {
	mState = STATE_WAITING_FOR_DEVICE_DISCOVERY;
	startScanning();
	}
	}

	// Should only be called on the handler thread
	public void onBootCompletedInternal() {
	mBootCompleted = true;
	mBootCompletedTime = SystemClock.uptimeMillis();
	if (mState == STATE_WAITING_FOR_BOOT_COMPLETED) {
	processKeyboardState();
	}
	}

	// Should only be called on the handler thread
	private void showBluetoothDialog() {
	if (isUserSetupComplete()) {
	long now = SystemClock.uptimeMillis();
	long earliestDialogTime = mBootCompletedTime + BLUETOOTH_START_DELAY_MILLIS;
	if (earliestDialogTime < now) {
	mUIHandler.sendEmptyMessage(MSG_SHOW_BLUETOOTH_DIALOG);
	} else {
	mHandler.sendEmptyMessageAtTime(MSG_PROCESS_KEYBOARD_STATE, earliestDialogTime);
	}
	} else {
	// If we're in setup wizard and the keyboard is docked, just automatically enable BT.
	mLocalBluetoothAdapter.enable();
	}
	}

	private boolean isUserSetupComplete() {
	ContentResolver resolver = mContext.getContentResolver();
	return Secure.getIntForUser(
	resolver, Secure.USER_SETUP_COMPLETE, 0, UserHandle.USER_CURRENT) != 0;
	}

	private CachedBluetoothDevice getPairedKeyboard() {
	Set<BluetoothDevice> devices = mLocalBluetoothAdapter.getBondedDevices();
	for (BluetoothDevice d : devices) {
	if (mKeyboardName.equals(d.getName())) {
	return getCachedBluetoothDevice(d);
	}
	}
	return null;
	}

	private CachedBluetoothDevice getDiscoveredKeyboard() {
	Collection<CachedBluetoothDevice> devices = mCachedDeviceManager.getCachedDevicesCopy();
	for (CachedBluetoothDevice d : devices) {
	if (d.getName().equals(mKeyboardName)) {
	return d;
	}
	}
	return null;
	}


	private CachedBluetoothDevice getCachedBluetoothDevice(BluetoothDevice d) {
	CachedBluetoothDevice cachedDevice = mCachedDeviceManager.findDevice(d);
	if (cachedDevice == null) {
	cachedDevice = mCachedDeviceManager.addDevice(d);
	}
	return cachedDevice;
	}

	private void startScanning() {
	BluetoothLeScanner scanner = mLocalBluetoothAdapter.getBluetoothLeScanner();
	ScanFilter filter = (new ScanFilter.Builder()).setDeviceName(mKeyboardName).build();
	ScanSettings settings = (new ScanSettings.Builder())
	.setCallbackType(ScanSettings.CALLBACK_TYPE_ALL_MATCHES)
	.setNumOfMatches(ScanSettings.MATCH_NUM_ONE_ADVERTISEMENT)
	.setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
	.setReportDelay(0)
	.build();
	mScanCallback = new KeyboardScanCallback();
	scanner.startScan(Arrays.asList(filter), settings, mScanCallback);

	Message abortMsg = mHandler.obtainMessage(MSG_BLE_ABORT_SCAN, ++mScanAttempt, 0);
	mHandler.sendMessageDelayed(abortMsg, BLUETOOTH_SCAN_TIMEOUT_MILLIS);
	}

	private void stopScanning() {
	if (mScanCallback != null) {
	BluetoothLeScanner scanner = mLocalBluetoothAdapter.getBluetoothLeScanner();
	if (scanner != null) {
	scanner.stopScan(mScanCallback);
	}
	mScanCallback = null;
	}
	}

	// Should only be called on the handler thread
	private void bleAbortScanInternal(int scanAttempt) {
	if (mState == STATE_WAITING_FOR_DEVICE_DISCOVERY && scanAttempt == mScanAttempt) {
	if (DEBUG) {
	Slog.d(TAG, "Bluetooth scan timed out");
	}
	stopScanning();
	// FIXME: should we also try shutting off bluetooth if we enabled
	// it in the first place?
	mState = STATE_DEVICE_NOT_FOUND;
	}
	}

	// Should only be called on the handler thread
	private void onDeviceAddedInternal(CachedBluetoothDevice d) {
	if (mState == STATE_WAITING_FOR_DEVICE_DISCOVERY && d.getName().equals(mKeyboardName)) {
	stopScanning();
	d.startPairing();
	mState = STATE_PAIRING;
	}
	}

	// Should only be called on the handler thread
	private void onBluetoothStateChangedInternal(int bluetoothState) {
	if (bluetoothState == BluetoothAdapter.STATE_ON && mState == STATE_WAITING_FOR_BLUETOOTH) {
	processKeyboardState();
	}
	}

	// Should only be called on the handler thread
	private void onDeviceBondStateChangedInternal(CachedBluetoothDevice d, int bondState) {
	if (mState == STATE_PAIRING && d.getName().equals(mKeyboardName)) {
	if (bondState == BluetoothDevice.BOND_BONDED) {
	// We don't need to manually connect to the device here because it will
	// automatically try to connect after it has been paired.
	mState = STATE_PAIRED;
	} else if (bondState == BluetoothDevice.BOND_NONE) {
	mState = STATE_PAIRING_FAILED;
	}
	}
	}

	// Should only be called on the handler thread
	private void onBleScanFailedInternal() {
	mScanCallback = null;
	if (mState == STATE_WAITING_FOR_DEVICE_DISCOVERY) {
	mState = STATE_DEVICE_NOT_FOUND;
	}
	}

	// Should only be called on the handler thread. We want to be careful not to show errors for
	// pairings not initiated by this UI, so we only pop up the toast when we're at an appropriate
	// point in our pairing flow and it's the expected device.
	private void onShowErrorInternal(Context context, String name, int messageResId) {
	if ((mState == STATE_PAIRING \|\| mState == STATE_PAIRING_FAILED)
	&& mKeyboardName.equals(name)) {
	String message = context.getString(messageResId, name);
	Toast.makeText(context, message, Toast.LENGTH_SHORT).show();
	}
	}

	private final class KeyboardUIHandler extends Handler {
	public KeyboardUIHandler() {
	super(Looper.getMainLooper(), null, true /async/);
	}
	@Override
	public void handleMessage(Message msg) {
	switch(msg.what) {
	case MSG_SHOW_BLUETOOTH_DIALOG: {
	if (mDialog != null) {
	// Don't show another dialog if one is already present
	break;
	}
	DialogInterface.OnClickListener clickListener =
	new BluetoothDialogClickListener();
	DialogInterface.OnDismissListener dismissListener =
	new BluetoothDialogDismissListener();
	mDialog = new BluetoothDialog(mContext);
	mDialog.setTitle(R.string.enable_bluetooth_title);
	mDialog.setMessage(R.string.enable_bluetooth_message);
	mDialog.setPositiveButton(
	R.string.enable_bluetooth_confirmation_ok, clickListener);
	mDialog.setNegativeButton(android.R.string.cancel, clickListener);
	mDialog.setOnDismissListener(dismissListener);
	mDialog.show();
	break;
	}
	case MSG_DISMISS_BLUETOOTH_DIALOG: {
	if (mDialog != null) {
	mDialog.dismiss();
	}
	break;
	}
	}
	}
	}

	private final class KeyboardHandler extends Handler {
	public KeyboardHandler(Looper looper) {
	super(looper, null, true /async/);
	}

	@Override
	public void handleMessage(Message msg) {
	switch(msg.what) {
	case MSG_INIT: {
	init();
	break;
	}
	case MSG_ON_BOOT_COMPLETED: {
	onBootCompletedInternal();
	break;
	}
	case MSG_PROCESS_KEYBOARD_STATE: {
	processKeyboardState();
	break;
	}
	case MSG_ENABLE_BLUETOOTH: {
	boolean enable = msg.arg1 == 1;
	if (enable) {
	mLocalBluetoothAdapter.enable();
	} else {
	mState = STATE_USER_CANCELLED;
	}
	break;
	}
	case MSG_BLE_ABORT_SCAN: {
	int scanAttempt = msg.arg1;
	bleAbortScanInternal(scanAttempt);
	break;
	}
	case MSG_ON_BLUETOOTH_STATE_CHANGED: {
	int bluetoothState = msg.arg1;
	onBluetoothStateChangedInternal(bluetoothState);
	break;
	}
	case MSG_ON_DEVICE_BOND_STATE_CHANGED: {
	CachedBluetoothDevice d = (CachedBluetoothDevice)msg.obj;
	int bondState = msg.arg1;
	onDeviceBondStateChangedInternal(d, bondState);
	break;
	}
	case MSG_ON_BLUETOOTH_DEVICE_ADDED: {
	BluetoothDevice d = (BluetoothDevice)msg.obj;
	CachedBluetoothDevice cachedDevice = getCachedBluetoothDevice(d);
	onDeviceAddedInternal(cachedDevice);
	break;

	}
	case MSG_ON_BLE_SCAN_FAILED: {
	onBleScanFailedInternal();
	break;
	}
	case MSG_SHOW_ERROR: {
	Pair<Context, String> p = (Pair<Context, String>) msg.obj;
	onShowErrorInternal(p.first, p.second, msg.arg1);
	}
	}
	}
	}

	private final class BluetoothDialogClickListener implements DialogInterface.OnClickListener {
	@Override
	public void onClick(DialogInterface dialog, int which) {
	int enable = DialogInterface.BUTTON_POSITIVE == which ? 1 : 0;
	mHandler.obtainMessage(MSG_ENABLE_BLUETOOTH, enable, 0).sendToTarget();
	mDialog = null;
	}
	}

	private final class BluetoothDialogDismissListener
	implements DialogInterface.OnDismissListener {
	@Override
	public void onDismiss(DialogInterface dialog) {
	mDialog = null;
	}
	}

	private final class KeyboardScanCallback extends ScanCallback {

	private boolean isDeviceDiscoverable(ScanResult result) {
	final ScanRecord scanRecord = result.getScanRecord();
	final int flags = scanRecord.getAdvertiseFlags();
	final int BT_DISCOVERABLE_MASK = 0x03;

	return (flags & BT_DISCOVERABLE_MASK) != 0;
	}

	@Override
	public void onBatchScanResults(List<ScanResult> results) {
	if (DEBUG) {
	Slog.d(TAG, "onBatchScanResults(" + results.size() + ")");
	}

	BluetoothDevice bestDevice = null;
	int bestRssi = Integer.MIN_VALUE;

	for (ScanResult result : results) {
	if (DEBUG) {
	Slog.d(TAG, "onBatchScanResults: considering " + result);
	}

	if (isDeviceDiscoverable(result) && result.getRssi() > bestRssi) {
	bestDevice = result.getDevice();
	bestRssi = result.getRssi();
	}
	}

	if (bestDevice != null) {
	mHandler.obtainMessage(MSG_ON_BLUETOOTH_DEVICE_ADDED, bestDevice).sendToTarget();
	}
	}

	@Override
	public void onScanFailed(int errorCode) {
	if (DEBUG) {
	Slog.d(TAG, "onScanFailed(" + errorCode + ")");
	}
	mHandler.obtainMessage(MSG_ON_BLE_SCAN_FAILED).sendToTarget();
	}

	@Override
	public void onScanResult(int callbackType, ScanResult result) {
	if (DEBUG) {
	Slog.d(TAG, "onScanResult(" + callbackType + ", " + result + ")");
	}

	if (isDeviceDiscoverable(result)) {
	mHandler.obtainMessage(MSG_ON_BLUETOOTH_DEVICE_ADDED,
	result.getDevice()).sendToTarget();
	} else if (DEBUG) {
	Slog.d(TAG, "onScanResult: device " + result.getDevice() +
	" is not discoverable, ignoring");
	}
	}
	}

	private final class BluetoothCallbackHandler implements BluetoothCallback {
	@Override
	public void onBluetoothStateChanged(int bluetoothState) {
	mHandler.obtainMessage(MSG_ON_BLUETOOTH_STATE_CHANGED,
	bluetoothState, 0).sendToTarget();
	}

	@Override
	public void onDeviceBondStateChanged(CachedBluetoothDevice cachedDevice, int bondState) {
	mHandler.obtainMessage(MSG_ON_DEVICE_BOND_STATE_CHANGED,
	bondState, 0, cachedDevice).sendToTarget();
	}
	}

	private final class BluetoothErrorListener implements BluetoothUtils.ErrorListener {
	public void onShowError(Context context, String name, int messageResId) {
	mHandler.obtainMessage(MSG_SHOW_ERROR, messageResId, 0 /unused/,
	new Pair<>(context, name)).sendToTarget();
	}
	}

	private static String stateToString(int state) {
	switch (state) {
	case STATE_NOT_ENABLED:
	return "STATE_NOT_ENABLED";
	case STATE_WAITING_FOR_BOOT_COMPLETED:
	return "STATE_WAITING_FOR_BOOT_COMPLETED";
	case STATE_WAITING_FOR_TABLET_MODE_EXIT:
	return "STATE_WAITING_FOR_TABLET_MODE_EXIT";
	case STATE_WAITING_FOR_DEVICE_DISCOVERY:
	return "STATE_WAITING_FOR_DEVICE_DISCOVERY";
	case STATE_WAITING_FOR_BLUETOOTH:
	return "STATE_WAITING_FOR_BLUETOOTH";
	case STATE_PAIRING:
	return "STATE_PAIRING";
	case STATE_PAIRED:
	return "STATE_PAIRED";
	case STATE_PAIRING_FAILED:
	return "STATE_PAIRING_FAILED";
	case STATE_USER_CANCELLED:
	return "STATE_USER_CANCELLED";
	case STATE_DEVICE_NOT_FOUND:
	return "STATE_DEVICE_NOT_FOUND";
	case STATE_UNKNOWN:
	default:
	return "STATE_UNKNOWN (" + state + ")";
	}
	}
	}