com/android/systemui/statusbar/policy/BluetoothControllerImpl.java - platform/prebuilts/fullsdk/sources/android-29 - 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 com.android.systemui.Dependency.BG_LOOPER_NAME;

 import android.annotation.Nullable;
 import android.app.ActivityManager;
 import android.bluetooth.BluetoothAdapter;
 import android.bluetooth.BluetoothDevice;
 import android.bluetooth.BluetoothProfile;
 import android.content.Context;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.Message;
 import android.os.UserHandle;
 import android.os.UserManager;
 import android.util.Log;

 import com.android.settingslib.bluetooth.BluetoothCallback;
 import com.android.settingslib.bluetooth.CachedBluetoothDevice;
 import com.android.settingslib.bluetooth.LocalBluetoothManager;
 import com.android.settingslib.bluetooth.LocalBluetoothProfileManager;

 import java.io.FileDescriptor;
 import java.io.PrintWriter;
 import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.WeakHashMap;

 import javax.inject.Inject;
 import javax.inject.Named;
 import javax.inject.Singleton;

 /**
  */
 @Singleton
 public class BluetoothControllerImpl implements BluetoothController, BluetoothCallback,
         CachedBluetoothDevice.Callback, LocalBluetoothProfileManager.ServiceListener {
     private static final String TAG = "BluetoothController";
     private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);

     private final LocalBluetoothManager mLocalBluetoothManager;
     private final UserManager mUserManager;
     private final int mCurrentUser;
     private final WeakHashMap<CachedBluetoothDevice, ActuallyCachedState> mCachedState =
             new WeakHashMap<>();
     private final Handler mBgHandler;
     private final List<CachedBluetoothDevice> mConnectedDevices = new ArrayList<>();

     private boolean mEnabled;
     private int mConnectionState = BluetoothAdapter.STATE_DISCONNECTED;

     private final H mHandler = new H(Looper.getMainLooper());
     private int mState;

     /**
      */
     @Inject
     public BluetoothControllerImpl(Context context, @Named(BG_LOOPER_NAME) Looper bgLooper,
             @Nullable LocalBluetoothManager localBluetoothManager) {
         mLocalBluetoothManager = localBluetoothManager;
         mBgHandler = new Handler(bgLooper);
         if (mLocalBluetoothManager != null) {
             mLocalBluetoothManager.getEventManager().registerCallback(this);
             mLocalBluetoothManager.getProfileManager().addServiceListener(this);
             onBluetoothStateChanged(
                     mLocalBluetoothManager.getBluetoothAdapter().getBluetoothState());
         }
         mUserManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
         mCurrentUser = ActivityManager.getCurrentUser();
     }

     @Override
     public boolean canConfigBluetooth() {
         return !mUserManager.hasUserRestriction(UserManager.DISALLOW_CONFIG_BLUETOOTH,
                 UserHandle.of(mCurrentUser))
             && !mUserManager.hasUserRestriction(UserManager.DISALLOW_BLUETOOTH,
                 UserHandle.of(mCurrentUser));
     }

     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
         pw.println("BluetoothController state:");
         pw.print("  mLocalBluetoothManager="); pw.println(mLocalBluetoothManager);
         if (mLocalBluetoothManager == null) {
             return;
         }
         pw.print("  mEnabled="); pw.println(mEnabled);
         pw.print("  mConnectionState="); pw.println(stateToString(mConnectionState));
         pw.print("  mConnectedDevices="); pw.println(mConnectedDevices);
         pw.print("  mCallbacks.size="); pw.println(mHandler.mCallbacks.size());
         pw.println("  Bluetooth Devices:");
         for (CachedBluetoothDevice device : getDevices()) {
             pw.println("    " + getDeviceString(device));
         }
     }

     private static String stateToString(int state) {
         switch (state) {
             case BluetoothAdapter.STATE_CONNECTED:
                 return "CONNECTED";
             case BluetoothAdapter.STATE_CONNECTING:
                 return "CONNECTING";
             case BluetoothAdapter.STATE_DISCONNECTED:
                 return "DISCONNECTED";
             case BluetoothAdapter.STATE_DISCONNECTING:
                 return "DISCONNECTING";
         }
         return "UNKNOWN(" + state + ")";
     }

     private String getDeviceString(CachedBluetoothDevice device) {
         return device.getName() + " " + device.getBondState() + " " + device.isConnected();
     }

     @Override
     public int getBondState(CachedBluetoothDevice device) {
         return getCachedState(device).mBondState;
     }

     @Override
     public List<CachedBluetoothDevice> getConnectedDevices() {
         return mConnectedDevices;
     }

     @Override
     public int getMaxConnectionState(CachedBluetoothDevice device) {
         return getCachedState(device).mMaxConnectionState;
     }

     @Override
     public void addCallback(Callback cb) {
         mHandler.obtainMessage(H.MSG_ADD_CALLBACK, cb).sendToTarget();
         mHandler.sendEmptyMessage(H.MSG_STATE_CHANGED);
     }

     @Override
     public void removeCallback(Callback cb) {
         mHandler.obtainMessage(H.MSG_REMOVE_CALLBACK, cb).sendToTarget();
     }

     @Override
     public boolean isBluetoothEnabled() {
         return mEnabled;
     }

     @Override
     public int getBluetoothState() {
         return mState;
     }

     @Override
     public boolean isBluetoothConnected() {
         return mConnectionState == BluetoothAdapter.STATE_CONNECTED;
     }

     @Override
     public boolean isBluetoothConnecting() {
         return mConnectionState == BluetoothAdapter.STATE_CONNECTING;
     }

     @Override
     public void setBluetoothEnabled(boolean enabled) {
         if (mLocalBluetoothManager != null) {
             mLocalBluetoothManager.getBluetoothAdapter().setBluetoothEnabled(enabled);
         }
     }

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

     @Override
     public void connect(final CachedBluetoothDevice device) {
         if (mLocalBluetoothManager == null || device == null) return;
         device.connect(true);
     }

     @Override
     public void disconnect(CachedBluetoothDevice device) {
         if (mLocalBluetoothManager == null || device == null) return;
         device.disconnect();
     }

     @Override
     public String getConnectedDeviceName() {
         if (mConnectedDevices.size() == 1) {
             return mConnectedDevices.get(0).getName();
         }
         return null;
     }

     @Override
     public Collection<CachedBluetoothDevice> getDevices() {
         return mLocalBluetoothManager != null
                 ? mLocalBluetoothManager.getCachedDeviceManager().getCachedDevicesCopy()
                 : null;
     }

     private void updateConnected() {
         // Make sure our connection state is up to date.
         int state = mLocalBluetoothManager.getBluetoothAdapter().getConnectionState();
         mConnectedDevices.clear();
         // If any of the devices are in a higher state than the adapter, move the adapter into
         // that state.
         for (CachedBluetoothDevice device : getDevices()) {
             int maxDeviceState = device.getMaxConnectionState();
             if (maxDeviceState > state) {
                 state = maxDeviceState;
             }
             if (device.isConnected()) {
                 mConnectedDevices.add(device);
             }
         }

         if (mConnectedDevices.isEmpty() && state == BluetoothAdapter.STATE_CONNECTED) {
             // If somehow we think we are connected, but have no connected devices, we aren't
             // connected.
             state = BluetoothAdapter.STATE_DISCONNECTED;
         }
         if (state != mConnectionState) {
             mConnectionState = state;
             mHandler.sendEmptyMessage(H.MSG_STATE_CHANGED);
         }
     }

     @Override
     public void onBluetoothStateChanged(int bluetoothState) {
         if (DEBUG) Log.d(TAG, "BluetoothStateChanged=" + stateToString(bluetoothState));
         mEnabled = bluetoothState == BluetoothAdapter.STATE_ON
                 || bluetoothState == BluetoothAdapter.STATE_TURNING_ON;
         mState = bluetoothState;
         updateConnected();
         mHandler.sendEmptyMessage(H.MSG_STATE_CHANGED);
     }

     @Override
     public void onDeviceAdded(CachedBluetoothDevice cachedDevice) {
         if (DEBUG) Log.d(TAG, "DeviceAdded=" + cachedDevice.getAddress());
         cachedDevice.registerCallback(this);
         updateConnected();
         mHandler.sendEmptyMessage(H.MSG_PAIRED_DEVICES_CHANGED);
     }

     @Override
     public void onDeviceDeleted(CachedBluetoothDevice cachedDevice) {
         if (DEBUG) Log.d(TAG, "DeviceDeleted=" + cachedDevice.getAddress());
         mCachedState.remove(cachedDevice);
         updateConnected();
         mHandler.sendEmptyMessage(H.MSG_PAIRED_DEVICES_CHANGED);
     }

     @Override
     public void onDeviceBondStateChanged(CachedBluetoothDevice cachedDevice, int bondState) {
         if (DEBUG) Log.d(TAG, "DeviceBondStateChanged=" + cachedDevice.getAddress());
         mCachedState.remove(cachedDevice);
         updateConnected();
         mHandler.sendEmptyMessage(H.MSG_PAIRED_DEVICES_CHANGED);
     }

     @Override
     public void onDeviceAttributesChanged() {
         if (DEBUG) Log.d(TAG, "DeviceAttributesChanged");
         updateConnected();
         mHandler.sendEmptyMessage(H.MSG_PAIRED_DEVICES_CHANGED);
     }

     @Override
     public void onConnectionStateChanged(CachedBluetoothDevice cachedDevice, int state) {
         if (DEBUG) {
             Log.d(TAG, "ConnectionStateChanged=" + cachedDevice.getAddress() + " "
                     + stateToString(state));
         }
         mCachedState.remove(cachedDevice);
         updateConnected();
         mHandler.sendEmptyMessage(H.MSG_STATE_CHANGED);
     }

     @Override
     public void onAclConnectionStateChanged(CachedBluetoothDevice cachedDevice, int state) {
         if (DEBUG) {
             Log.d(TAG, "ACLConnectionStateChanged=" + cachedDevice.getAddress() + " "
                     + stateToString(state));
         }
         mCachedState.remove(cachedDevice);
         updateConnected();
         mHandler.sendEmptyMessage(H.MSG_STATE_CHANGED);
     }

     private ActuallyCachedState getCachedState(CachedBluetoothDevice device) {
         ActuallyCachedState state = mCachedState.get(device);
         if (state == null) {
             state = new ActuallyCachedState(device, mHandler);
             mBgHandler.post(state);
             mCachedState.put(device, state);
             return state;
         }
         return state;
     }

     @Override
     public void onServiceConnected() {
         updateConnected();
         mHandler.sendEmptyMessage(H.MSG_PAIRED_DEVICES_CHANGED);
     }

     @Override
     public void onServiceDisconnected() {}

     private static class ActuallyCachedState implements Runnable {

         private final WeakReference<CachedBluetoothDevice> mDevice;
         private final Handler mUiHandler;
         private int mBondState = BluetoothDevice.BOND_NONE;
         private int mMaxConnectionState = BluetoothProfile.STATE_DISCONNECTED;

         private ActuallyCachedState(CachedBluetoothDevice device, Handler uiHandler) {
             mDevice = new WeakReference<>(device);
             mUiHandler = uiHandler;
         }

         @Override
         public void run() {
             CachedBluetoothDevice device = mDevice.get();
             if (device != null) {
                 mBondState = device.getBondState();
                 mMaxConnectionState = device.getMaxConnectionState();
                 mUiHandler.removeMessages(H.MSG_PAIRED_DEVICES_CHANGED);
                 mUiHandler.sendEmptyMessage(H.MSG_PAIRED_DEVICES_CHANGED);
             }
         }
     }

     private final class H extends Handler {
         private final ArrayList<BluetoothController.Callback> mCallbacks = new ArrayList<>();

         private static final int MSG_PAIRED_DEVICES_CHANGED = 1;
         private static final int MSG_STATE_CHANGED = 2;
         private static final int MSG_ADD_CALLBACK = 3;
         private static final int MSG_REMOVE_CALLBACK = 4;

         public H(Looper looper) {
             super(looper);
         }

         @Override
         public void handleMessage(Message msg) {
             switch (msg.what) {
                 case MSG_PAIRED_DEVICES_CHANGED:
                     firePairedDevicesChanged();
                     break;
                 case MSG_STATE_CHANGED:
                     fireStateChange();
                     break;
                 case MSG_ADD_CALLBACK:
                     mCallbacks.add((BluetoothController.Callback) msg.obj);
                     break;
                 case MSG_REMOVE_CALLBACK:
                     mCallbacks.remove((BluetoothController.Callback) msg.obj);
                     break;
             }
         }

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

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

         private void fireStateChange(BluetoothController.Callback cb) {
             cb.onBluetoothStateChange(mEnabled);
         }
     }
 }
	/*
	* 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 com.android.systemui.Dependency.BG_LOOPER_NAME;

	import android.annotation.Nullable;
	import android.app.ActivityManager;
	import android.bluetooth.BluetoothAdapter;
	import android.bluetooth.BluetoothDevice;
	import android.bluetooth.BluetoothProfile;
	import android.content.Context;
	import android.os.Handler;
	import android.os.Looper;
	import android.os.Message;
	import android.os.UserHandle;
	import android.os.UserManager;
	import android.util.Log;

	import com.android.settingslib.bluetooth.BluetoothCallback;
	import com.android.settingslib.bluetooth.CachedBluetoothDevice;
	import com.android.settingslib.bluetooth.LocalBluetoothManager;
	import com.android.settingslib.bluetooth.LocalBluetoothProfileManager;

	import java.io.FileDescriptor;
	import java.io.PrintWriter;
	import java.lang.ref.WeakReference;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.List;
	import java.util.WeakHashMap;

	import javax.inject.Inject;
	import javax.inject.Named;
	import javax.inject.Singleton;

	/**
	*/
	@Singleton
	public class BluetoothControllerImpl implements BluetoothController, BluetoothCallback,
	CachedBluetoothDevice.Callback, LocalBluetoothProfileManager.ServiceListener {
	private static final String TAG = "BluetoothController";
	private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);

	private final LocalBluetoothManager mLocalBluetoothManager;
	private final UserManager mUserManager;
	private final int mCurrentUser;
	private final WeakHashMap<CachedBluetoothDevice, ActuallyCachedState> mCachedState =
	new WeakHashMap<>();
	private final Handler mBgHandler;
	private final List<CachedBluetoothDevice> mConnectedDevices = new ArrayList<>();

	private boolean mEnabled;
	private int mConnectionState = BluetoothAdapter.STATE_DISCONNECTED;

	private final H mHandler = new H(Looper.getMainLooper());
	private int mState;

	/**
	*/
	@Inject
	public BluetoothControllerImpl(Context context, @Named(BG_LOOPER_NAME) Looper bgLooper,
	@Nullable LocalBluetoothManager localBluetoothManager) {
	mLocalBluetoothManager = localBluetoothManager;
	mBgHandler = new Handler(bgLooper);
	if (mLocalBluetoothManager != null) {
	mLocalBluetoothManager.getEventManager().registerCallback(this);
	mLocalBluetoothManager.getProfileManager().addServiceListener(this);
	onBluetoothStateChanged(
	mLocalBluetoothManager.getBluetoothAdapter().getBluetoothState());
	}
	mUserManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
	mCurrentUser = ActivityManager.getCurrentUser();
	}

	@Override
	public boolean canConfigBluetooth() {
	return !mUserManager.hasUserRestriction(UserManager.DISALLOW_CONFIG_BLUETOOTH,
	UserHandle.of(mCurrentUser))
	&& !mUserManager.hasUserRestriction(UserManager.DISALLOW_BLUETOOTH,
	UserHandle.of(mCurrentUser));
	}

	public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
	pw.println("BluetoothController state:");
	pw.print(" mLocalBluetoothManager="); pw.println(mLocalBluetoothManager);
	if (mLocalBluetoothManager == null) {
	return;
	}
	pw.print(" mEnabled="); pw.println(mEnabled);
	pw.print(" mConnectionState="); pw.println(stateToString(mConnectionState));
	pw.print(" mConnectedDevices="); pw.println(mConnectedDevices);
	pw.print(" mCallbacks.size="); pw.println(mHandler.mCallbacks.size());
	pw.println(" Bluetooth Devices:");
	for (CachedBluetoothDevice device : getDevices()) {
	pw.println(" " + getDeviceString(device));
	}
	}

	private static String stateToString(int state) {
	switch (state) {
	case BluetoothAdapter.STATE_CONNECTED:
	return "CONNECTED";
	case BluetoothAdapter.STATE_CONNECTING:
	return "CONNECTING";
	case BluetoothAdapter.STATE_DISCONNECTED:
	return "DISCONNECTED";
	case BluetoothAdapter.STATE_DISCONNECTING:
	return "DISCONNECTING";
	}
	return "UNKNOWN(" + state + ")";
	}

	private String getDeviceString(CachedBluetoothDevice device) {
	return device.getName() + " " + device.getBondState() + " " + device.isConnected();
	}

	@Override
	public int getBondState(CachedBluetoothDevice device) {
	return getCachedState(device).mBondState;
	}

	@Override
	public List<CachedBluetoothDevice> getConnectedDevices() {
	return mConnectedDevices;
	}

	@Override
	public int getMaxConnectionState(CachedBluetoothDevice device) {
	return getCachedState(device).mMaxConnectionState;
	}

	@Override
	public void addCallback(Callback cb) {
	mHandler.obtainMessage(H.MSG_ADD_CALLBACK, cb).sendToTarget();
	mHandler.sendEmptyMessage(H.MSG_STATE_CHANGED);
	}

	@Override
	public void removeCallback(Callback cb) {
	mHandler.obtainMessage(H.MSG_REMOVE_CALLBACK, cb).sendToTarget();
	}

	@Override
	public boolean isBluetoothEnabled() {
	return mEnabled;
	}

	@Override
	public int getBluetoothState() {
	return mState;
	}

	@Override
	public boolean isBluetoothConnected() {
	return mConnectionState == BluetoothAdapter.STATE_CONNECTED;
	}

	@Override
	public boolean isBluetoothConnecting() {
	return mConnectionState == BluetoothAdapter.STATE_CONNECTING;
	}

	@Override
	public void setBluetoothEnabled(boolean enabled) {
	if (mLocalBluetoothManager != null) {
	mLocalBluetoothManager.getBluetoothAdapter().setBluetoothEnabled(enabled);
	}
	}

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

	@Override
	public void connect(final CachedBluetoothDevice device) {
	if (mLocalBluetoothManager == null \|\| device == null) return;
	device.connect(true);
	}

	@Override
	public void disconnect(CachedBluetoothDevice device) {
	if (mLocalBluetoothManager == null \|\| device == null) return;
	device.disconnect();
	}

	@Override
	public String getConnectedDeviceName() {
	if (mConnectedDevices.size() == 1) {
	return mConnectedDevices.get(0).getName();
	}
	return null;
	}

	@Override
	public Collection<CachedBluetoothDevice> getDevices() {
	return mLocalBluetoothManager != null
	? mLocalBluetoothManager.getCachedDeviceManager().getCachedDevicesCopy()
	: null;
	}

	private void updateConnected() {
	// Make sure our connection state is up to date.
	int state = mLocalBluetoothManager.getBluetoothAdapter().getConnectionState();
	mConnectedDevices.clear();
	// If any of the devices are in a higher state than the adapter, move the adapter into
	// that state.
	for (CachedBluetoothDevice device : getDevices()) {
	int maxDeviceState = device.getMaxConnectionState();
	if (maxDeviceState > state) {
	state = maxDeviceState;
	}
	if (device.isConnected()) {
	mConnectedDevices.add(device);
	}
	}

	if (mConnectedDevices.isEmpty() && state == BluetoothAdapter.STATE_CONNECTED) {
	// If somehow we think we are connected, but have no connected devices, we aren't
	// connected.
	state = BluetoothAdapter.STATE_DISCONNECTED;
	}
	if (state != mConnectionState) {
	mConnectionState = state;
	mHandler.sendEmptyMessage(H.MSG_STATE_CHANGED);
	}
	}

	@Override
	public void onBluetoothStateChanged(int bluetoothState) {
	if (DEBUG) Log.d(TAG, "BluetoothStateChanged=" + stateToString(bluetoothState));
	mEnabled = bluetoothState == BluetoothAdapter.STATE_ON
	\|\| bluetoothState == BluetoothAdapter.STATE_TURNING_ON;
	mState = bluetoothState;
	updateConnected();
	mHandler.sendEmptyMessage(H.MSG_STATE_CHANGED);
	}

	@Override
	public void onDeviceAdded(CachedBluetoothDevice cachedDevice) {
	if (DEBUG) Log.d(TAG, "DeviceAdded=" + cachedDevice.getAddress());
	cachedDevice.registerCallback(this);
	updateConnected();
	mHandler.sendEmptyMessage(H.MSG_PAIRED_DEVICES_CHANGED);
	}

	@Override
	public void onDeviceDeleted(CachedBluetoothDevice cachedDevice) {
	if (DEBUG) Log.d(TAG, "DeviceDeleted=" + cachedDevice.getAddress());
	mCachedState.remove(cachedDevice);
	updateConnected();
	mHandler.sendEmptyMessage(H.MSG_PAIRED_DEVICES_CHANGED);
	}

	@Override
	public void onDeviceBondStateChanged(CachedBluetoothDevice cachedDevice, int bondState) {
	if (DEBUG) Log.d(TAG, "DeviceBondStateChanged=" + cachedDevice.getAddress());
	mCachedState.remove(cachedDevice);
	updateConnected();
	mHandler.sendEmptyMessage(H.MSG_PAIRED_DEVICES_CHANGED);
	}

	@Override
	public void onDeviceAttributesChanged() {
	if (DEBUG) Log.d(TAG, "DeviceAttributesChanged");
	updateConnected();
	mHandler.sendEmptyMessage(H.MSG_PAIRED_DEVICES_CHANGED);
	}

	@Override
	public void onConnectionStateChanged(CachedBluetoothDevice cachedDevice, int state) {
	if (DEBUG) {
	Log.d(TAG, "ConnectionStateChanged=" + cachedDevice.getAddress() + " "
	+ stateToString(state));
	}
	mCachedState.remove(cachedDevice);
	updateConnected();
	mHandler.sendEmptyMessage(H.MSG_STATE_CHANGED);
	}

	@Override
	public void onAclConnectionStateChanged(CachedBluetoothDevice cachedDevice, int state) {
	if (DEBUG) {
	Log.d(TAG, "ACLConnectionStateChanged=" + cachedDevice.getAddress() + " "
	+ stateToString(state));
	}
	mCachedState.remove(cachedDevice);
	updateConnected();
	mHandler.sendEmptyMessage(H.MSG_STATE_CHANGED);
	}

	private ActuallyCachedState getCachedState(CachedBluetoothDevice device) {
	ActuallyCachedState state = mCachedState.get(device);
	if (state == null) {
	state = new ActuallyCachedState(device, mHandler);
	mBgHandler.post(state);
	mCachedState.put(device, state);
	return state;
	}
	return state;
	}

	@Override
	public void onServiceConnected() {
	updateConnected();
	mHandler.sendEmptyMessage(H.MSG_PAIRED_DEVICES_CHANGED);
	}

	@Override
	public void onServiceDisconnected() {}

	private static class ActuallyCachedState implements Runnable {

	private final WeakReference<CachedBluetoothDevice> mDevice;
	private final Handler mUiHandler;
	private int mBondState = BluetoothDevice.BOND_NONE;
	private int mMaxConnectionState = BluetoothProfile.STATE_DISCONNECTED;

	private ActuallyCachedState(CachedBluetoothDevice device, Handler uiHandler) {
	mDevice = new WeakReference<>(device);
	mUiHandler = uiHandler;
	}

	@Override
	public void run() {
	CachedBluetoothDevice device = mDevice.get();
	if (device != null) {
	mBondState = device.getBondState();
	mMaxConnectionState = device.getMaxConnectionState();
	mUiHandler.removeMessages(H.MSG_PAIRED_DEVICES_CHANGED);
	mUiHandler.sendEmptyMessage(H.MSG_PAIRED_DEVICES_CHANGED);
	}
	}
	}

	private final class H extends Handler {
	private final ArrayList<BluetoothController.Callback> mCallbacks = new ArrayList<>();

	private static final int MSG_PAIRED_DEVICES_CHANGED = 1;
	private static final int MSG_STATE_CHANGED = 2;
	private static final int MSG_ADD_CALLBACK = 3;
	private static final int MSG_REMOVE_CALLBACK = 4;

	public H(Looper looper) {
	super(looper);
	}

	@Override
	public void handleMessage(Message msg) {
	switch (msg.what) {
	case MSG_PAIRED_DEVICES_CHANGED:
	firePairedDevicesChanged();
	break;
	case MSG_STATE_CHANGED:
	fireStateChange();
	break;
	case MSG_ADD_CALLBACK:
	mCallbacks.add((BluetoothController.Callback) msg.obj);
	break;
	case MSG_REMOVE_CALLBACK:
	mCallbacks.remove((BluetoothController.Callback) msg.obj);
	break;
	}
	}

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

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

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