packages/SystemUI/src/com/android/systemui/statusbar/policy/BluetoothControllerImpl.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2008 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.statusbar.policy;

 import static android.bluetooth.BluetoothAdapter.ERROR;
 import static com.android.systemui.statusbar.policy.BluetoothUtil.connectionStateToString;
 import static com.android.systemui.statusbar.policy.BluetoothUtil.deviceToString;
 import static com.android.systemui.statusbar.policy.BluetoothUtil.profileToString;
 import static com.android.systemui.statusbar.policy.BluetoothUtil.uuidToProfile;
 import static com.android.systemui.statusbar.policy.BluetoothUtil.uuidToString;
 import static com.android.systemui.statusbar.policy.BluetoothUtil.uuidsToString;

 import android.bluetooth.BluetoothA2dp;
 import android.bluetooth.BluetoothA2dpSink;
 import android.bluetooth.BluetoothAdapter;
 import android.bluetooth.BluetoothDevice;
 import android.bluetooth.BluetoothHeadset;
 import android.bluetooth.BluetoothHeadsetClient;
 import android.bluetooth.BluetoothInputDevice;
 import android.bluetooth.BluetoothManager;
 import android.bluetooth.BluetoothMap;
 import android.bluetooth.BluetoothPan;
 import android.bluetooth.BluetoothProfile;
 import android.bluetooth.BluetoothProfile.ServiceListener;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.Message;
 import android.os.ParcelUuid;
 import android.util.ArrayMap;
 import android.util.ArraySet;
 import android.util.Log;
 import android.util.SparseArray;

 import com.android.systemui.statusbar.policy.BluetoothUtil.Profile;

 import java.io.FileDescriptor;
 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.Set;

 public class BluetoothControllerImpl implements BluetoothController {
     private static final String TAG = "BluetoothController";
     private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
     // This controls the order in which we check the states.  Since a device can only have
     // one state on screen, but can have multiple profiles, the later states override the
     // value of earlier states.  So if a device has a profile in CONNECTING and one in
     // CONNECTED, it will show as CONNECTED, theoretically this shouldn't really happen often,
     // but seemed worth noting.
     private static final int[] CONNECTION_STATES = {
         BluetoothProfile.STATE_DISCONNECTED,
         BluetoothProfile.STATE_DISCONNECTING,
         BluetoothProfile.STATE_CONNECTING,
         BluetoothProfile.STATE_CONNECTED,
     };
     // Update all the BT device states.
     private static final int MSG_UPDATE_CONNECTION_STATES = 1;
     // Update just one BT device.
     private static final int MSG_UPDATE_SINGLE_CONNECTION_STATE = 2;
     // Update whether devices are bonded or not.
     private static final int MSG_UPDATE_BONDED_DEVICES = 3;

     private static final int MSG_ADD_PROFILE = 4;
     private static final int MSG_REM_PROFILE = 5;

     private final Context mContext;
     private final ArrayList<Callback> mCallbacks = new ArrayList<Callback>();
     private final BluetoothAdapter mAdapter;
     private final Receiver mReceiver = new Receiver();
     private final ArrayMap<BluetoothDevice, DeviceInfo> mDeviceInfo = new ArrayMap<>();
     private final SparseArray<BluetoothProfile> mProfiles = new SparseArray<>();

     private final H mHandler;

     private boolean mEnabled;
     private boolean mConnecting;
     private BluetoothDevice mLastDevice;

     public BluetoothControllerImpl(Context context, Looper bgLooper) {
         mContext = context;
         mHandler = new H(bgLooper);

         final BluetoothManager bluetoothManager =
                 (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
         mAdapter = bluetoothManager.getAdapter();
         if (mAdapter == null) {
             Log.w(TAG, "Default BT adapter not found");
             return;
         }

         mReceiver.register();
         setAdapterState(mAdapter.getState());
         updateBondedDevices();
         bindAllProfiles();
     }

     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
         pw.println("BluetoothController state:");
         pw.print("  mAdapter="); pw.println(mAdapter);
         pw.print("  mEnabled="); pw.println(mEnabled);
         pw.print("  mConnecting="); pw.println(mConnecting);
         pw.print("  mLastDevice="); pw.println(mLastDevice);
         pw.print("  mCallbacks.size="); pw.println(mCallbacks.size());
         pw.print("  mProfiles="); pw.println(profilesToString(mProfiles));
         pw.print("  mDeviceInfo.size="); pw.println(mDeviceInfo.size());
         for (int i = 0; i < mDeviceInfo.size(); i++) {
             final BluetoothDevice device = mDeviceInfo.keyAt(i);
             final DeviceInfo info = mDeviceInfo.valueAt(i);
             pw.print("    "); pw.print(deviceToString(device));
             pw.print('('); pw.print(uuidsToString(device)); pw.print(')');
             pw.print("    "); pw.println(infoToString(info));
         }
     }

     private static String infoToString(DeviceInfo info) {
         return info == null ? null : ("connectionState=" +
                 connectionStateToString(CONNECTION_STATES[info.connectionStateIndex])
                 + ",bonded=" + info.bonded + ",profiles="
                 + profilesToString(info.connectedProfiles));
     }

     private static String profilesToString(SparseArray<?> profiles) {
         final int N = profiles.size();
         final StringBuffer buffer = new StringBuffer();
         buffer.append('[');
         for (int i = 0; i < N; i++) {
             if (i != 0) {
                 buffer.append(',');
             }
             buffer.append(BluetoothUtil.profileToString(profiles.keyAt(i)));
         }
         buffer.append(']');
         return buffer.toString();
     }

     public void addStateChangedCallback(Callback cb) {
         mCallbacks.add(cb);
         fireStateChange(cb);
     }

     @Override
     public void removeStateChangedCallback(Callback cb) {
         mCallbacks.remove(cb);
     }

     @Override
     public boolean isBluetoothEnabled() {
         return mAdapter != null && mAdapter.isEnabled();
     }

     @Override
     public boolean isBluetoothConnected() {
         return mAdapter != null
                 && mAdapter.getConnectionState() == BluetoothAdapter.STATE_CONNECTED;
     }

     @Override
     public boolean isBluetoothConnecting() {
         return mAdapter != null
                 && mAdapter.getConnectionState() == BluetoothAdapter.STATE_CONNECTING;
     }

     @Override
     public void setBluetoothEnabled(boolean enabled) {
         if (mAdapter != null) {
             if (enabled) {
                 mAdapter.enable();
             } else {
                 mAdapter.disable();
             }
         }
     }

     @Override
     public boolean isBluetoothSupported() {
         return mAdapter != null;
     }

     @Override
     public ArraySet<PairedDevice> getPairedDevices() {
         final ArraySet<PairedDevice> rt = new ArraySet<>();
         for (int i = 0; i < mDeviceInfo.size(); i++) {
             final BluetoothDevice device = mDeviceInfo.keyAt(i);
             final DeviceInfo info = mDeviceInfo.valueAt(i);
             if (!info.bonded) continue;
             final PairedDevice paired = new PairedDevice();
             paired.id = device.getAddress();
             paired.tag = device;
             paired.name = device.getAliasName();
             paired.state = connectionStateToPairedDeviceState(info.connectionStateIndex);
             rt.add(paired);
         }
         return rt;
     }

     private static int connectionStateToPairedDeviceState(int index) {
         int state = CONNECTION_STATES[index];
         if (state == BluetoothAdapter.STATE_CONNECTED) return PairedDevice.STATE_CONNECTED;
         if (state == BluetoothAdapter.STATE_CONNECTING) return PairedDevice.STATE_CONNECTING;
         if (state == BluetoothAdapter.STATE_DISCONNECTING) return PairedDevice.STATE_DISCONNECTING;
         return PairedDevice.STATE_DISCONNECTED;
     }

     @Override
     public void connect(final PairedDevice pd) {
         connect(pd, true);
     }

     @Override
     public void disconnect(PairedDevice pd) {
         connect(pd, false);
     }

     private void connect(PairedDevice pd, final boolean connect) {
         if (mAdapter == null || pd == null || pd.tag == null) return;
         final BluetoothDevice device = (BluetoothDevice) pd.tag;
         final DeviceInfo info = mDeviceInfo.get(device);
         final String action = connect ? "connect" : "disconnect";
         if (DEBUG) Log.d(TAG, action + " " + deviceToString(device));
         final ParcelUuid[] uuids = device.getUuids();
         if (uuids == null) {
             Log.w(TAG, "No uuids returned, aborting " + action + " for " + deviceToString(device));
             return;
         }
         SparseArray<Boolean> profiles = new SparseArray<>();
         if (connect) {
             // When connecting add every profile we can recognize by uuid.
             for (ParcelUuid uuid : uuids) {
                 final int profile = uuidToProfile(uuid);
                 if (profile == 0) {
                     Log.w(TAG, "Device " + deviceToString(device) + " has an unsupported uuid: "
                             + uuidToString(uuid));
                     continue;
                 }
                 final boolean connected = info.connectedProfiles.get(profile, false);
                 if (!connected) {
                     profiles.put(profile, true);
                 }
             }
         } else {
             // When disconnecting, just add every profile we know they are connected to.
             profiles = info.connectedProfiles;
         }
         for (int i = 0; i < profiles.size(); i++) {
             final int profile = profiles.keyAt(i);
             if (mProfiles.indexOfKey(profile) >= 0) {
                 final Profile p = BluetoothUtil.getProfile(mProfiles.get(profile));
                 final boolean ok = connect ? p.connect(device) : p.disconnect(device);
                 if (DEBUG) Log.d(TAG, action + " " + profileToString(profile) + " "
                         + (ok ? "succeeded" : "failed"));
             } else {
                 Log.w(TAG, "Unable get get Profile for " + profileToString(profile));
             }
         }
     }

     @Override
     public String getLastDeviceName() {
         return mLastDevice != null ? mLastDevice.getAliasName() : null;
     }

     private void updateBondedDevices() {
         mHandler.removeMessages(MSG_UPDATE_BONDED_DEVICES);
         mHandler.sendEmptyMessage(MSG_UPDATE_BONDED_DEVICES);
     }

     private void updateConnectionStates() {
         mHandler.removeMessages(MSG_UPDATE_CONNECTION_STATES);
         mHandler.removeMessages(MSG_UPDATE_SINGLE_CONNECTION_STATE);
         mHandler.sendEmptyMessage(MSG_UPDATE_CONNECTION_STATES);
     }

     private void updateConnectionState(BluetoothDevice device, int profile, int state) {
         if (mHandler.hasMessages(MSG_UPDATE_CONNECTION_STATES)) {
             // If we are about to update all the devices, then we don't need to update this one.
             return;
         }
         mHandler.obtainMessage(MSG_UPDATE_SINGLE_CONNECTION_STATE, profile, state, device)
                 .sendToTarget();
     }

     private void handleUpdateBondedDevices() {
         if (mAdapter == null) return;
         final Set<BluetoothDevice> bondedDevices = mAdapter.getBondedDevices();
         for (DeviceInfo info : mDeviceInfo.values()) {
             info.bonded = false;
         }
         int bondedCount = 0;
         BluetoothDevice lastBonded = null;
         if (bondedDevices != null) {
             for (BluetoothDevice bondedDevice : bondedDevices) {
                 final boolean bonded = bondedDevice.getBondState() != BluetoothDevice.BOND_NONE;
                 updateInfo(bondedDevice).bonded = bonded;
                 if (bonded) {
                     bondedCount++;
                     lastBonded = bondedDevice;
                 }
             }
         }
         if (mLastDevice == null && bondedCount == 1) {
             mLastDevice = lastBonded;
         }
         updateConnectionStates();
         firePairedDevicesChanged();
     }

     private void handleUpdateConnectionStates() {
         final int N = mDeviceInfo.size();
         for (int i = 0; i < N; i++) {
             BluetoothDevice device = mDeviceInfo.keyAt(i);
             DeviceInfo info = updateInfo(device);
             info.connectionStateIndex = 0;
             info.connectedProfiles.clear();
             for (int j = 0; j < mProfiles.size(); j++) {
                 int state = mProfiles.valueAt(j).getConnectionState(device);
                 handleUpdateConnectionState(device, mProfiles.keyAt(j), state);
             }
         }
         handleConnectionChange();
         firePairedDevicesChanged();
     }

     private void handleUpdateConnectionState(BluetoothDevice device, int profile, int state) {
         if (DEBUG) Log.d(TAG, "updateConnectionState " + BluetoothUtil.deviceToString(device)
                 + " " + BluetoothUtil.profileToString(profile)
                 + " " + BluetoothUtil.connectionStateToString(state));
         DeviceInfo info = updateInfo(device);
         int stateIndex = 0;
         for (int i = 0; i < CONNECTION_STATES.length; i++) {
             if (CONNECTION_STATES[i] == state) {
                 stateIndex = i;
                 break;
             }
         }
         info.profileStates.put(profile, stateIndex);

         info.connectionStateIndex = 0;
         final int N = info.profileStates.size();
         for (int i = 0; i < N; i++) {
             if (info.profileStates.valueAt(i) > info.connectionStateIndex) {
                 info.connectionStateIndex = info.profileStates.valueAt(i);
             }
         }
         if (state == BluetoothProfile.STATE_CONNECTED) {
             info.connectedProfiles.put(profile, true);
         } else {
             info.connectedProfiles.remove(profile);
         }
     }

     private void handleConnectionChange() {
         // If we are no longer connected to the current device, see if we are connected to
         // something else, so we don't display a name we aren't connected to.
         if (mLastDevice != null &&
                 CONNECTION_STATES[mDeviceInfo.get(mLastDevice).connectionStateIndex]
                         != BluetoothProfile.STATE_CONNECTED) {
             // Make sure we don't keep this device while it isn't connected.
             mLastDevice = null;
             // Look for anything else connected.
             final int size = mDeviceInfo.size();
             for (int i = 0; i < size; i++) {
                 BluetoothDevice device = mDeviceInfo.keyAt(i);
                 DeviceInfo info = mDeviceInfo.valueAt(i);
                 if (CONNECTION_STATES[info.connectionStateIndex]
                         == BluetoothProfile.STATE_CONNECTED) {
                     mLastDevice = device;
                     break;
                 }
             }
         }
     }

     private void bindAllProfiles() {
         // Note: This needs to contain all of the types that can be returned by BluetoothUtil
         // otherwise we can't find the profiles we need when we connect/disconnect.
         mAdapter.getProfileProxy(mContext, mProfileListener, BluetoothProfile.A2DP);
         mAdapter.getProfileProxy(mContext, mProfileListener, BluetoothProfile.A2DP_SINK);
         mAdapter.getProfileProxy(mContext, mProfileListener, BluetoothProfile.AVRCP_CONTROLLER);
         mAdapter.getProfileProxy(mContext, mProfileListener, BluetoothProfile.HEADSET);
         mAdapter.getProfileProxy(mContext, mProfileListener, BluetoothProfile.HEADSET_CLIENT);
         mAdapter.getProfileProxy(mContext, mProfileListener, BluetoothProfile.INPUT_DEVICE);
         mAdapter.getProfileProxy(mContext, mProfileListener, BluetoothProfile.MAP);
         mAdapter.getProfileProxy(mContext, mProfileListener, BluetoothProfile.PAN);
         // Note Health is not in this list because health devices aren't 'connected'.
         // If profiles are expanded to use more than just connection state and connect/disconnect
         // then it should be added.
     }

     private void firePairedDevicesChanged() {
         for (Callback cb : mCallbacks) {
             cb.onBluetoothPairedDevicesChanged();
         }
     }

     private void setAdapterState(int adapterState) {
         final boolean enabled = adapterState == BluetoothAdapter.STATE_ON;
         if (mEnabled == enabled) return;
         mEnabled = enabled;
         fireStateChange();
     }

     private void setConnecting(boolean connecting) {
         if (mConnecting == connecting) return;
         mConnecting = connecting;
         fireStateChange();
     }

     private void fireStateChange() {
         for (Callback cb : mCallbacks) {
             fireStateChange(cb);
         }
     }

     private void fireStateChange(Callback cb) {
         cb.onBluetoothStateChange(mEnabled, mConnecting);
     }

     private static int getProfileFromAction(String action) {
         if (BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED.equals(action)) {
             return BluetoothProfile.A2DP;
         } else if (BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED.equals(action)) {
             return BluetoothProfile.HEADSET;
         } else if (BluetoothA2dpSink.ACTION_CONNECTION_STATE_CHANGED.equals(action)) {
             return BluetoothProfile.A2DP_SINK;
         } else if (BluetoothHeadsetClient.ACTION_CONNECTION_STATE_CHANGED.equals(action)) {
             return BluetoothProfile.HEADSET_CLIENT;
         } else if (BluetoothInputDevice.ACTION_CONNECTION_STATE_CHANGED.equals(action)) {
             return BluetoothProfile.INPUT_DEVICE;
         } else if (BluetoothMap.ACTION_CONNECTION_STATE_CHANGED.equals(action)) {
             return BluetoothProfile.MAP;
         } else if (BluetoothPan.ACTION_CONNECTION_STATE_CHANGED.equals(action)) {
             return BluetoothProfile.PAN;
         }
         if (DEBUG) Log.d(TAG, "Unknown action " + action);
         return -1;
     }

     private final ServiceListener mProfileListener = new ServiceListener() {
         @Override
         public void onServiceDisconnected(int profile) {
             if (DEBUG) Log.d(TAG, "Disconnected from " + BluetoothUtil.profileToString(profile));
             // We lost a profile, don't do any updates until it gets removed.
             mHandler.removeMessages(MSG_UPDATE_CONNECTION_STATES);
             mHandler.removeMessages(MSG_UPDATE_SINGLE_CONNECTION_STATE);
             mHandler.obtainMessage(MSG_REM_PROFILE, profile, 0).sendToTarget();
         }

         @Override
         public void onServiceConnected(int profile, BluetoothProfile proxy) {
             if (DEBUG) Log.d(TAG, "Connected to " + BluetoothUtil.profileToString(profile));
             mHandler.obtainMessage(MSG_ADD_PROFILE, profile, 0, proxy).sendToTarget();
         }
     };

     private final class Receiver extends BroadcastReceiver {
         public void register() {
             final IntentFilter filter = new IntentFilter();
             filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
             filter.addAction(BluetoothAdapter.ACTION_CONNECTION_STATE_CHANGED);
             filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
             filter.addAction(BluetoothDevice.ACTION_ALIAS_CHANGED);
             filter.addAction(BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED);
             filter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
             filter.addAction(BluetoothA2dpSink.ACTION_CONNECTION_STATE_CHANGED);
             filter.addAction(BluetoothHeadsetClient.ACTION_CONNECTION_STATE_CHANGED);
             filter.addAction(BluetoothInputDevice.ACTION_CONNECTION_STATE_CHANGED);
             filter.addAction(BluetoothMap.ACTION_CONNECTION_STATE_CHANGED);
             filter.addAction(BluetoothPan.ACTION_CONNECTION_STATE_CHANGED);
             mContext.registerReceiver(this, filter);
         }

         @Override
         public void onReceive(Context context, Intent intent) {
             final String action = intent.getAction();
             final BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);

             if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) {
                 setAdapterState(intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, ERROR));
                 updateBondedDevices();
                 if (DEBUG) Log.d(TAG, "ACTION_STATE_CHANGED " + mEnabled);
             } else if (action.equals(BluetoothAdapter.ACTION_CONNECTION_STATE_CHANGED)) {
                 updateInfo(device);
                 final int state = intent.getIntExtra(BluetoothAdapter.EXTRA_CONNECTION_STATE,
                         ERROR);
                 mLastDevice = device;
                 if (DEBUG) Log.d(TAG, "ACTION_CONNECTION_STATE_CHANGED "
                         + connectionStateToString(state) + " " + deviceToString(device));
                 setConnecting(state == BluetoothAdapter.STATE_CONNECTING);
             } else if (action.equals(BluetoothDevice.ACTION_ALIAS_CHANGED)) {
                 updateInfo(device);
                 mLastDevice = device;
             } else if (action.equals(BluetoothDevice.ACTION_BOND_STATE_CHANGED)) {
                 if (DEBUG) Log.d(TAG, "ACTION_BOND_STATE_CHANGED " + device);
                 updateBondedDevices();
             } else {
                 int profile = getProfileFromAction(intent.getAction());
                 int state = intent.getIntExtra(BluetoothProfile.EXTRA_STATE, -1);
                 if (DEBUG) Log.d(TAG, "ACTION_CONNECTION_STATE_CHANGE "
                         + BluetoothUtil.profileToString(profile)
                         + " " + BluetoothUtil.connectionStateToString(state));
                 if ((profile != -1) && (state != -1)) {
                     updateConnectionState(device, profile, state);
                 }
             }
         }
     }

     private DeviceInfo updateInfo(BluetoothDevice device) {
         DeviceInfo info = mDeviceInfo.get(device);
         info = info != null ? info : new DeviceInfo();
         mDeviceInfo.put(device, info);
         return info;
     }

     private class H extends Handler {
         public H(Looper l) {
             super(l);
         }

         public void handleMessage(Message msg) {
             switch (msg.what) {
                 case MSG_UPDATE_CONNECTION_STATES:
                     handleUpdateConnectionStates();
                     firePairedDevicesChanged();
                     break;
                 case MSG_UPDATE_SINGLE_CONNECTION_STATE:
                     handleUpdateConnectionState((BluetoothDevice) msg.obj, msg.arg1, msg.arg2);
                     handleConnectionChange();
                     firePairedDevicesChanged();
                     break;
                 case MSG_UPDATE_BONDED_DEVICES:
                     handleUpdateBondedDevices();
                     firePairedDevicesChanged();
                     break;
                 case MSG_ADD_PROFILE:
                     mProfiles.put(msg.arg1, (BluetoothProfile) msg.obj);
                     handleUpdateConnectionStates();
                     firePairedDevicesChanged();
                     break;
                 case MSG_REM_PROFILE:
                     mProfiles.remove(msg.arg1);
                     handleUpdateConnectionStates();
                     firePairedDevicesChanged();
                     break;
             }
         };
     };

     private static class DeviceInfo {
         int connectionStateIndex = 0;
         boolean bonded;  // per getBondedDevices
         SparseArray<Boolean> connectedProfiles = new SparseArray<>();
         SparseArray<Integer> profileStates = new SparseArray<>();
     }
 }
	/*
	* Copyright (C) 2008 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.statusbar.policy;

	import static android.bluetooth.BluetoothAdapter.ERROR;
	import static com.android.systemui.statusbar.policy.BluetoothUtil.connectionStateToString;
	import static com.android.systemui.statusbar.policy.BluetoothUtil.deviceToString;
	import static com.android.systemui.statusbar.policy.BluetoothUtil.profileToString;
	import static com.android.systemui.statusbar.policy.BluetoothUtil.uuidToProfile;
	import static com.android.systemui.statusbar.policy.BluetoothUtil.uuidToString;
	import static com.android.systemui.statusbar.policy.BluetoothUtil.uuidsToString;

	import android.bluetooth.BluetoothA2dp;
	import android.bluetooth.BluetoothA2dpSink;
	import android.bluetooth.BluetoothAdapter;
	import android.bluetooth.BluetoothDevice;
	import android.bluetooth.BluetoothHeadset;
	import android.bluetooth.BluetoothHeadsetClient;
	import android.bluetooth.BluetoothInputDevice;
	import android.bluetooth.BluetoothManager;
	import android.bluetooth.BluetoothMap;
	import android.bluetooth.BluetoothPan;
	import android.bluetooth.BluetoothProfile;
	import android.bluetooth.BluetoothProfile.ServiceListener;
	import android.content.BroadcastReceiver;
	import android.content.Context;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.os.Handler;
	import android.os.Looper;
	import android.os.Message;
	import android.os.ParcelUuid;
	import android.util.ArrayMap;
	import android.util.ArraySet;
	import android.util.Log;
	import android.util.SparseArray;

	import com.android.systemui.statusbar.policy.BluetoothUtil.Profile;

	import java.io.FileDescriptor;
	import java.io.PrintWriter;
	import java.util.ArrayList;
	import java.util.Set;

	public class BluetoothControllerImpl implements BluetoothController {
	private static final String TAG = "BluetoothController";
	private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
	// This controls the order in which we check the states. Since a device can only have
	// one state on screen, but can have multiple profiles, the later states override the
	// value of earlier states. So if a device has a profile in CONNECTING and one in
	// CONNECTED, it will show as CONNECTED, theoretically this shouldn't really happen often,
	// but seemed worth noting.
	private static final int[] CONNECTION_STATES = {
	BluetoothProfile.STATE_DISCONNECTED,
	BluetoothProfile.STATE_DISCONNECTING,
	BluetoothProfile.STATE_CONNECTING,
	BluetoothProfile.STATE_CONNECTED,
	};
	// Update all the BT device states.
	private static final int MSG_UPDATE_CONNECTION_STATES = 1;
	// Update just one BT device.
	private static final int MSG_UPDATE_SINGLE_CONNECTION_STATE = 2;
	// Update whether devices are bonded or not.
	private static final int MSG_UPDATE_BONDED_DEVICES = 3;

	private static final int MSG_ADD_PROFILE = 4;
	private static final int MSG_REM_PROFILE = 5;

	private final Context mContext;
	private final ArrayList<Callback> mCallbacks = new ArrayList<Callback>();
	private final BluetoothAdapter mAdapter;
	private final Receiver mReceiver = new Receiver();
	private final ArrayMap<BluetoothDevice, DeviceInfo> mDeviceInfo = new ArrayMap<>();
	private final SparseArray<BluetoothProfile> mProfiles = new SparseArray<>();

	private final H mHandler;

	private boolean mEnabled;
	private boolean mConnecting;
	private BluetoothDevice mLastDevice;

	public BluetoothControllerImpl(Context context, Looper bgLooper) {
	mContext = context;
	mHandler = new H(bgLooper);

	final BluetoothManager bluetoothManager =
	(BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
	mAdapter = bluetoothManager.getAdapter();
	if (mAdapter == null) {
	Log.w(TAG, "Default BT adapter not found");
	return;
	}

	mReceiver.register();
	setAdapterState(mAdapter.getState());
	updateBondedDevices();
	bindAllProfiles();
	}

	public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
	pw.println("BluetoothController state:");
	pw.print(" mAdapter="); pw.println(mAdapter);
	pw.print(" mEnabled="); pw.println(mEnabled);
	pw.print(" mConnecting="); pw.println(mConnecting);
	pw.print(" mLastDevice="); pw.println(mLastDevice);
	pw.print(" mCallbacks.size="); pw.println(mCallbacks.size());
	pw.print(" mProfiles="); pw.println(profilesToString(mProfiles));
	pw.print(" mDeviceInfo.size="); pw.println(mDeviceInfo.size());
	for (int i = 0; i < mDeviceInfo.size(); i++) {
	final BluetoothDevice device = mDeviceInfo.keyAt(i);
	final DeviceInfo info = mDeviceInfo.valueAt(i);
	pw.print(" "); pw.print(deviceToString(device));
	pw.print('('); pw.print(uuidsToString(device)); pw.print(')');
	pw.print(" "); pw.println(infoToString(info));
	}
	}

	private static String infoToString(DeviceInfo info) {
	return info == null ? null : ("connectionState=" +
	connectionStateToString(CONNECTION_STATES[info.connectionStateIndex])
	+ ",bonded=" + info.bonded + ",profiles="
	+ profilesToString(info.connectedProfiles));
	}

	private static String profilesToString(SparseArray<?> profiles) {
	final int N = profiles.size();
	final StringBuffer buffer = new StringBuffer();
	buffer.append('[');
	for (int i = 0; i < N; i++) {
	if (i != 0) {
	buffer.append(',');
	}
	buffer.append(BluetoothUtil.profileToString(profiles.keyAt(i)));
	}
	buffer.append(']');
	return buffer.toString();
	}

	public void addStateChangedCallback(Callback cb) {
	mCallbacks.add(cb);
	fireStateChange(cb);
	}

	@Override
	public void removeStateChangedCallback(Callback cb) {
	mCallbacks.remove(cb);
	}

	@Override
	public boolean isBluetoothEnabled() {
	return mAdapter != null && mAdapter.isEnabled();
	}

	@Override
	public boolean isBluetoothConnected() {
	return mAdapter != null
	&& mAdapter.getConnectionState() == BluetoothAdapter.STATE_CONNECTED;
	}

	@Override
	public boolean isBluetoothConnecting() {
	return mAdapter != null
	&& mAdapter.getConnectionState() == BluetoothAdapter.STATE_CONNECTING;
	}

	@Override
	public void setBluetoothEnabled(boolean enabled) {
	if (mAdapter != null) {
	if (enabled) {
	mAdapter.enable();
	} else {
	mAdapter.disable();
	}
	}
	}

	@Override
	public boolean isBluetoothSupported() {
	return mAdapter != null;
	}

	@Override
	public ArraySet<PairedDevice> getPairedDevices() {
	final ArraySet<PairedDevice> rt = new ArraySet<>();
	for (int i = 0; i < mDeviceInfo.size(); i++) {
	final BluetoothDevice device = mDeviceInfo.keyAt(i);
	final DeviceInfo info = mDeviceInfo.valueAt(i);
	if (!info.bonded) continue;
	final PairedDevice paired = new PairedDevice();
	paired.id = device.getAddress();
	paired.tag = device;
	paired.name = device.getAliasName();
	paired.state = connectionStateToPairedDeviceState(info.connectionStateIndex);
	rt.add(paired);
	}
	return rt;
	}

	private static int connectionStateToPairedDeviceState(int index) {
	int state = CONNECTION_STATES[index];
	if (state == BluetoothAdapter.STATE_CONNECTED) return PairedDevice.STATE_CONNECTED;
	if (state == BluetoothAdapter.STATE_CONNECTING) return PairedDevice.STATE_CONNECTING;
	if (state == BluetoothAdapter.STATE_DISCONNECTING) return PairedDevice.STATE_DISCONNECTING;
	return PairedDevice.STATE_DISCONNECTED;
	}

	@Override
	public void connect(final PairedDevice pd) {
	connect(pd, true);
	}

	@Override
	public void disconnect(PairedDevice pd) {
	connect(pd, false);
	}

	private void connect(PairedDevice pd, final boolean connect) {
	if (mAdapter == null \|\| pd == null \|\| pd.tag == null) return;
	final BluetoothDevice device = (BluetoothDevice) pd.tag;
	final DeviceInfo info = mDeviceInfo.get(device);
	final String action = connect ? "connect" : "disconnect";
	if (DEBUG) Log.d(TAG, action + " " + deviceToString(device));
	final ParcelUuid[] uuids = device.getUuids();
	if (uuids == null) {
	Log.w(TAG, "No uuids returned, aborting " + action + " for " + deviceToString(device));
	return;
	}
	SparseArray<Boolean> profiles = new SparseArray<>();
	if (connect) {
	// When connecting add every profile we can recognize by uuid.
	for (ParcelUuid uuid : uuids) {
	final int profile = uuidToProfile(uuid);
	if (profile == 0) {
	Log.w(TAG, "Device " + deviceToString(device) + " has an unsupported uuid: "
	+ uuidToString(uuid));
	continue;
	}
	final boolean connected = info.connectedProfiles.get(profile, false);
	if (!connected) {
	profiles.put(profile, true);
	}
	}
	} else {
	// When disconnecting, just add every profile we know they are connected to.
	profiles = info.connectedProfiles;
	}
	for (int i = 0; i < profiles.size(); i++) {
	final int profile = profiles.keyAt(i);
	if (mProfiles.indexOfKey(profile) >= 0) {
	final Profile p = BluetoothUtil.getProfile(mProfiles.get(profile));
	final boolean ok = connect ? p.connect(device) : p.disconnect(device);
	if (DEBUG) Log.d(TAG, action + " " + profileToString(profile) + " "
	+ (ok ? "succeeded" : "failed"));
	} else {
	Log.w(TAG, "Unable get get Profile for " + profileToString(profile));
	}
	}
	}

	@Override
	public String getLastDeviceName() {
	return mLastDevice != null ? mLastDevice.getAliasName() : null;
	}

	private void updateBondedDevices() {
	mHandler.removeMessages(MSG_UPDATE_BONDED_DEVICES);
	mHandler.sendEmptyMessage(MSG_UPDATE_BONDED_DEVICES);
	}

	private void updateConnectionStates() {
	mHandler.removeMessages(MSG_UPDATE_CONNECTION_STATES);
	mHandler.removeMessages(MSG_UPDATE_SINGLE_CONNECTION_STATE);
	mHandler.sendEmptyMessage(MSG_UPDATE_CONNECTION_STATES);
	}

	private void updateConnectionState(BluetoothDevice device, int profile, int state) {
	if (mHandler.hasMessages(MSG_UPDATE_CONNECTION_STATES)) {
	// If we are about to update all the devices, then we don't need to update this one.
	return;
	}
	mHandler.obtainMessage(MSG_UPDATE_SINGLE_CONNECTION_STATE, profile, state, device)
	.sendToTarget();
	}

	private void handleUpdateBondedDevices() {
	if (mAdapter == null) return;
	final Set<BluetoothDevice> bondedDevices = mAdapter.getBondedDevices();
	for (DeviceInfo info : mDeviceInfo.values()) {
	info.bonded = false;
	}
	int bondedCount = 0;
	BluetoothDevice lastBonded = null;
	if (bondedDevices != null) {
	for (BluetoothDevice bondedDevice : bondedDevices) {
	final boolean bonded = bondedDevice.getBondState() != BluetoothDevice.BOND_NONE;
	updateInfo(bondedDevice).bonded = bonded;
	if (bonded) {
	bondedCount++;
	lastBonded = bondedDevice;
	}
	}
	}
	if (mLastDevice == null && bondedCount == 1) {
	mLastDevice = lastBonded;
	}
	updateConnectionStates();
	firePairedDevicesChanged();
	}

	private void handleUpdateConnectionStates() {
	final int N = mDeviceInfo.size();
	for (int i = 0; i < N; i++) {
	BluetoothDevice device = mDeviceInfo.keyAt(i);
	DeviceInfo info = updateInfo(device);
	info.connectionStateIndex = 0;
	info.connectedProfiles.clear();
	for (int j = 0; j < mProfiles.size(); j++) {
	int state = mProfiles.valueAt(j).getConnectionState(device);
	handleUpdateConnectionState(device, mProfiles.keyAt(j), state);
	}
	}
	handleConnectionChange();
	firePairedDevicesChanged();
	}

	private void handleUpdateConnectionState(BluetoothDevice device, int profile, int state) {
	if (DEBUG) Log.d(TAG, "updateConnectionState " + BluetoothUtil.deviceToString(device)
	+ " " + BluetoothUtil.profileToString(profile)
	+ " " + BluetoothUtil.connectionStateToString(state));
	DeviceInfo info = updateInfo(device);
	int stateIndex = 0;
	for (int i = 0; i < CONNECTION_STATES.length; i++) {
	if (CONNECTION_STATES[i] == state) {
	stateIndex = i;
	break;
	}
	}
	info.profileStates.put(profile, stateIndex);

	info.connectionStateIndex = 0;
	final int N = info.profileStates.size();
	for (int i = 0; i < N; i++) {
	if (info.profileStates.valueAt(i) > info.connectionStateIndex) {
	info.connectionStateIndex = info.profileStates.valueAt(i);
	}
	}
	if (state == BluetoothProfile.STATE_CONNECTED) {
	info.connectedProfiles.put(profile, true);
	} else {
	info.connectedProfiles.remove(profile);
	}
	}

	private void handleConnectionChange() {
	// If we are no longer connected to the current device, see if we are connected to
	// something else, so we don't display a name we aren't connected to.
	if (mLastDevice != null &&
	CONNECTION_STATES[mDeviceInfo.get(mLastDevice).connectionStateIndex]
	!= BluetoothProfile.STATE_CONNECTED) {
	// Make sure we don't keep this device while it isn't connected.
	mLastDevice = null;
	// Look for anything else connected.
	final int size = mDeviceInfo.size();
	for (int i = 0; i < size; i++) {
	BluetoothDevice device = mDeviceInfo.keyAt(i);
	DeviceInfo info = mDeviceInfo.valueAt(i);
	if (CONNECTION_STATES[info.connectionStateIndex]
	== BluetoothProfile.STATE_CONNECTED) {
	mLastDevice = device;
	break;
	}
	}
	}
	}

	private void bindAllProfiles() {
	// Note: This needs to contain all of the types that can be returned by BluetoothUtil
	// otherwise we can't find the profiles we need when we connect/disconnect.
	mAdapter.getProfileProxy(mContext, mProfileListener, BluetoothProfile.A2DP);
	mAdapter.getProfileProxy(mContext, mProfileListener, BluetoothProfile.A2DP_SINK);
	mAdapter.getProfileProxy(mContext, mProfileListener, BluetoothProfile.AVRCP_CONTROLLER);
	mAdapter.getProfileProxy(mContext, mProfileListener, BluetoothProfile.HEADSET);
	mAdapter.getProfileProxy(mContext, mProfileListener, BluetoothProfile.HEADSET_CLIENT);
	mAdapter.getProfileProxy(mContext, mProfileListener, BluetoothProfile.INPUT_DEVICE);
	mAdapter.getProfileProxy(mContext, mProfileListener, BluetoothProfile.MAP);
	mAdapter.getProfileProxy(mContext, mProfileListener, BluetoothProfile.PAN);
	// Note Health is not in this list because health devices aren't 'connected'.
	// If profiles are expanded to use more than just connection state and connect/disconnect
	// then it should be added.
	}

	private void firePairedDevicesChanged() {
	for (Callback cb : mCallbacks) {
	cb.onBluetoothPairedDevicesChanged();
	}
	}

	private void setAdapterState(int adapterState) {
	final boolean enabled = adapterState == BluetoothAdapter.STATE_ON;
	if (mEnabled == enabled) return;
	mEnabled = enabled;
	fireStateChange();
	}

	private void setConnecting(boolean connecting) {
	if (mConnecting == connecting) return;
	mConnecting = connecting;
	fireStateChange();
	}

	private void fireStateChange() {
	for (Callback cb : mCallbacks) {
	fireStateChange(cb);
	}
	}

	private void fireStateChange(Callback cb) {
	cb.onBluetoothStateChange(mEnabled, mConnecting);
	}

	private static int getProfileFromAction(String action) {
	if (BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED.equals(action)) {
	return BluetoothProfile.A2DP;
	} else if (BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED.equals(action)) {
	return BluetoothProfile.HEADSET;
	} else if (BluetoothA2dpSink.ACTION_CONNECTION_STATE_CHANGED.equals(action)) {
	return BluetoothProfile.A2DP_SINK;
	} else if (BluetoothHeadsetClient.ACTION_CONNECTION_STATE_CHANGED.equals(action)) {
	return BluetoothProfile.HEADSET_CLIENT;
	} else if (BluetoothInputDevice.ACTION_CONNECTION_STATE_CHANGED.equals(action)) {
	return BluetoothProfile.INPUT_DEVICE;
	} else if (BluetoothMap.ACTION_CONNECTION_STATE_CHANGED.equals(action)) {
	return BluetoothProfile.MAP;
	} else if (BluetoothPan.ACTION_CONNECTION_STATE_CHANGED.equals(action)) {
	return BluetoothProfile.PAN;
	}
	if (DEBUG) Log.d(TAG, "Unknown action " + action);
	return -1;
	}

	private final ServiceListener mProfileListener = new ServiceListener() {
	@Override
	public void onServiceDisconnected(int profile) {
	if (DEBUG) Log.d(TAG, "Disconnected from " + BluetoothUtil.profileToString(profile));
	// We lost a profile, don't do any updates until it gets removed.
	mHandler.removeMessages(MSG_UPDATE_CONNECTION_STATES);
	mHandler.removeMessages(MSG_UPDATE_SINGLE_CONNECTION_STATE);
	mHandler.obtainMessage(MSG_REM_PROFILE, profile, 0).sendToTarget();
	}

	@Override
	public void onServiceConnected(int profile, BluetoothProfile proxy) {
	if (DEBUG) Log.d(TAG, "Connected to " + BluetoothUtil.profileToString(profile));
	mHandler.obtainMessage(MSG_ADD_PROFILE, profile, 0, proxy).sendToTarget();
	}
	};

	private final class Receiver extends BroadcastReceiver {
	public void register() {
	final IntentFilter filter = new IntentFilter();
	filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
	filter.addAction(BluetoothAdapter.ACTION_CONNECTION_STATE_CHANGED);
	filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
	filter.addAction(BluetoothDevice.ACTION_ALIAS_CHANGED);
	filter.addAction(BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED);
	filter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
	filter.addAction(BluetoothA2dpSink.ACTION_CONNECTION_STATE_CHANGED);
	filter.addAction(BluetoothHeadsetClient.ACTION_CONNECTION_STATE_CHANGED);
	filter.addAction(BluetoothInputDevice.ACTION_CONNECTION_STATE_CHANGED);
	filter.addAction(BluetoothMap.ACTION_CONNECTION_STATE_CHANGED);
	filter.addAction(BluetoothPan.ACTION_CONNECTION_STATE_CHANGED);
	mContext.registerReceiver(this, filter);
	}

	@Override
	public void onReceive(Context context, Intent intent) {
	final String action = intent.getAction();
	final BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);

	if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) {
	setAdapterState(intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, ERROR));
	updateBondedDevices();
	if (DEBUG) Log.d(TAG, "ACTION_STATE_CHANGED " + mEnabled);
	} else if (action.equals(BluetoothAdapter.ACTION_CONNECTION_STATE_CHANGED)) {
	updateInfo(device);
	final int state = intent.getIntExtra(BluetoothAdapter.EXTRA_CONNECTION_STATE,
	ERROR);
	mLastDevice = device;
	if (DEBUG) Log.d(TAG, "ACTION_CONNECTION_STATE_CHANGED "
	+ connectionStateToString(state) + " " + deviceToString(device));
	setConnecting(state == BluetoothAdapter.STATE_CONNECTING);
	} else if (action.equals(BluetoothDevice.ACTION_ALIAS_CHANGED)) {
	updateInfo(device);
	mLastDevice = device;
	} else if (action.equals(BluetoothDevice.ACTION_BOND_STATE_CHANGED)) {
	if (DEBUG) Log.d(TAG, "ACTION_BOND_STATE_CHANGED " + device);
	updateBondedDevices();
	} else {
	int profile = getProfileFromAction(intent.getAction());
	int state = intent.getIntExtra(BluetoothProfile.EXTRA_STATE, -1);
	if (DEBUG) Log.d(TAG, "ACTION_CONNECTION_STATE_CHANGE "
	+ BluetoothUtil.profileToString(profile)
	+ " " + BluetoothUtil.connectionStateToString(state));
	if ((profile != -1) && (state != -1)) {
	updateConnectionState(device, profile, state);
	}
	}
	}
	}

	private DeviceInfo updateInfo(BluetoothDevice device) {
	DeviceInfo info = mDeviceInfo.get(device);
	info = info != null ? info : new DeviceInfo();
	mDeviceInfo.put(device, info);
	return info;
	}

	private class H extends Handler {
	public H(Looper l) {
	super(l);
	}

	public void handleMessage(Message msg) {
	switch (msg.what) {
	case MSG_UPDATE_CONNECTION_STATES:
	handleUpdateConnectionStates();
	firePairedDevicesChanged();
	break;
	case MSG_UPDATE_SINGLE_CONNECTION_STATE:
	handleUpdateConnectionState((BluetoothDevice) msg.obj, msg.arg1, msg.arg2);
	handleConnectionChange();
	firePairedDevicesChanged();
	break;
	case MSG_UPDATE_BONDED_DEVICES:
	handleUpdateBondedDevices();
	firePairedDevicesChanged();
	break;
	case MSG_ADD_PROFILE:
	mProfiles.put(msg.arg1, (BluetoothProfile) msg.obj);
	handleUpdateConnectionStates();
	firePairedDevicesChanged();
	break;
	case MSG_REM_PROFILE:
	mProfiles.remove(msg.arg1);
	handleUpdateConnectionStates();
	firePairedDevicesChanged();
	break;
	}
	};
	};

	private static class DeviceInfo {
	int connectionStateIndex = 0;
	boolean bonded; // per getBondedDevices
	SparseArray<Boolean> connectedProfiles = new SparseArray<>();
	SparseArray<Integer> profileStates = new SparseArray<>();
	}
	}