Bluetooth: Update Settings.apk to match BT API change.
Split BluetoothDevice into BluetoothDevice and BluetoothAdapter.
BluetoothAdapter: Represents the local BT adapter. Operations on the local
adapter (start a scan, etc).
BluetoothDevice: Represents a remote BT device. Operations on remote devices
(pair, connect, etc).
This commit is contained in:
Nick Pelly
827
src/com/android/settings/bluetooth/CachedBluetoothDevice.java
Normal file
827
src/com/android/settings/bluetooth/CachedBluetoothDevice.java
Normal file
@@ -0,0 +1,827 @@
|
||||
/*
|
||||
* 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.settings.bluetooth;
|
||||
|
||||
import android.app.AlertDialog;
|
||||
import android.bluetooth.BluetoothClass;
|
||||
import android.bluetooth.BluetoothAdapter;
|
||||
import android.bluetooth.BluetoothDevice;
|
||||
import android.content.Context;
|
||||
import android.content.DialogInterface;
|
||||
import android.content.Intent;
|
||||
import android.content.res.Resources;
|
||||
import android.text.TextUtils;
|
||||
import android.util.Log;
|
||||
import android.view.ContextMenu;
|
||||
import android.view.Menu;
|
||||
import android.view.MenuItem;
|
||||
|
||||
import com.android.settings.R;
|
||||
import com.android.settings.bluetooth.LocalBluetoothProfileManager.Profile;
|
||||
|
||||
import java.text.DateFormat;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Date;
|
||||
import java.util.Iterator;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* CachedBluetoothDevice represents a remote Bluetooth device. It contains
|
||||
* attributes of the device (such as the address, name, RSSI, etc.) and
|
||||
* functionality that can be performed on the device (connect, pair, disconnect,
|
||||
* etc.).
|
||||
*/
|
||||
public class CachedBluetoothDevice implements Comparable<CachedBluetoothDevice> {
|
||||
private static final String TAG = "CachedBluetoothDevice";
|
||||
private static final boolean D = LocalBluetoothManager.D;
|
||||
private static final boolean V = LocalBluetoothManager.V;
|
||||
|
||||
private static final int CONTEXT_ITEM_CONNECT = Menu.FIRST + 1;
|
||||
private static final int CONTEXT_ITEM_DISCONNECT = Menu.FIRST + 2;
|
||||
private static final int CONTEXT_ITEM_UNPAIR = Menu.FIRST + 3;
|
||||
private static final int CONTEXT_ITEM_CONNECT_ADVANCED = Menu.FIRST + 4;
|
||||
|
||||
private final BluetoothDevice mDevice;
|
||||
private String mName;
|
||||
private short mRssi;
|
||||
private int mBtClass = BluetoothClass.ERROR;
|
||||
|
||||
private List<Profile> mProfiles = new ArrayList<Profile>();
|
||||
|
||||
private boolean mVisible;
|
||||
|
||||
private final LocalBluetoothManager mLocalManager;
|
||||
|
||||
private List<Callback> mCallbacks = new ArrayList<Callback>();
|
||||
|
||||
/**
|
||||
* When we connect to multiple profiles, we only want to display a single
|
||||
* error even if they all fail. This tracks that state.
|
||||
*/
|
||||
private boolean mIsConnectingErrorPossible;
|
||||
|
||||
// Max time to hold the work queue if we don't get or missed a response
|
||||
// from the bt framework.
|
||||
private static final long MAX_WAIT_TIME_FOR_FRAMEWORK = 25 * 1000;
|
||||
|
||||
private enum BluetoothCommand {
|
||||
CONNECT, DISCONNECT,
|
||||
}
|
||||
|
||||
static class BluetoothJob {
|
||||
final BluetoothCommand command; // CONNECT, DISCONNECT
|
||||
final CachedBluetoothDevice cachedDevice;
|
||||
final Profile profile; // HEADSET, A2DP, etc
|
||||
// 0 means this command was not been sent to the bt framework.
|
||||
long timeSent;
|
||||
|
||||
public BluetoothJob(BluetoothCommand command,
|
||||
CachedBluetoothDevice cachedDevice, Profile profile) {
|
||||
this.command = command;
|
||||
this.cachedDevice = cachedDevice;
|
||||
this.profile = profile;
|
||||
this.timeSent = 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
sb.append(command.name());
|
||||
sb.append(" Address:").append(cachedDevice.mDevice);
|
||||
sb.append(" Profile:").append(profile.name());
|
||||
sb.append(" TimeSent:");
|
||||
if (timeSent == 0) {
|
||||
sb.append("not yet");
|
||||
} else {
|
||||
sb.append(DateFormat.getTimeInstance().format(new Date(timeSent)));
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* We want to serialize connect and disconnect calls. http://b/170538
|
||||
* This are some headsets that may have L2CAP resource limitation. We want
|
||||
* to limit the bt bandwidth usage.
|
||||
*
|
||||
* A queue to keep track of asynchronous calls to the bt framework. The
|
||||
* first item, if exist, should be in progress i.e. went to the bt framework
|
||||
* already, waiting for a notification to come back. The second item and
|
||||
* beyond have not been sent to the bt framework yet.
|
||||
*/
|
||||
private static LinkedList<BluetoothJob> workQueue = new LinkedList<BluetoothJob>();
|
||||
|
||||
private void queueCommand(BluetoothJob job) {
|
||||
if (D) {
|
||||
Log.d(TAG, workQueue.toString());
|
||||
}
|
||||
synchronized (workQueue) {
|
||||
boolean processNow = pruneQueue(job);
|
||||
|
||||
// Add job to queue
|
||||
if (D) {
|
||||
Log.d(TAG, "Adding: " + job.toString());
|
||||
}
|
||||
workQueue.add(job);
|
||||
|
||||
// if there's nothing pending from before, send the command to bt
|
||||
// framework immediately.
|
||||
if (workQueue.size() == 1 || processNow) {
|
||||
// If the failed to process, just drop it from the queue.
|
||||
// There will be no callback to remove this from the queue.
|
||||
processCommands();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private boolean pruneQueue(BluetoothJob job) {
|
||||
boolean removedStaleItems = false;
|
||||
long now = System.currentTimeMillis();
|
||||
Iterator<BluetoothJob> it = workQueue.iterator();
|
||||
while (it.hasNext()) {
|
||||
BluetoothJob existingJob = it.next();
|
||||
|
||||
// Remove any pending CONNECTS when we receive a DISCONNECT
|
||||
if (job != null && job.command == BluetoothCommand.DISCONNECT) {
|
||||
if (existingJob.timeSent == 0
|
||||
&& existingJob.command == BluetoothCommand.CONNECT
|
||||
&& existingJob.cachedDevice.mDevice.equals(job.cachedDevice.mDevice)
|
||||
&& existingJob.profile == job.profile) {
|
||||
if (D) {
|
||||
Log.d(TAG, "Removed because of a pending disconnect. " + existingJob);
|
||||
}
|
||||
it.remove();
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// Defensive Code: Remove any job that older than a preset time.
|
||||
// We never got a call back. It is better to have overlapping
|
||||
// calls than to get stuck.
|
||||
if (existingJob.timeSent != 0
|
||||
&& (now - existingJob.timeSent) >= MAX_WAIT_TIME_FOR_FRAMEWORK) {
|
||||
Log.w(TAG, "Timeout. Removing Job:" + existingJob.toString());
|
||||
it.remove();
|
||||
removedStaleItems = true;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
return removedStaleItems;
|
||||
}
|
||||
|
||||
private boolean processCommand(BluetoothJob job) {
|
||||
boolean successful = false;
|
||||
if (job.timeSent == 0) {
|
||||
job.timeSent = System.currentTimeMillis();
|
||||
switch (job.command) {
|
||||
case CONNECT:
|
||||
successful = connectInt(job.cachedDevice, job.profile);
|
||||
break;
|
||||
case DISCONNECT:
|
||||
successful = disconnectInt(job.cachedDevice, job.profile);
|
||||
break;
|
||||
}
|
||||
|
||||
if (successful) {
|
||||
if (D) {
|
||||
Log.d(TAG, "Command sent successfully:" + job.toString());
|
||||
}
|
||||
} else if (V) {
|
||||
Log.v(TAG, "Framework rejected command immediately:" + job.toString());
|
||||
}
|
||||
} else if (D) {
|
||||
Log.d(TAG, "Job already has a sent time. Skip. " + job.toString());
|
||||
}
|
||||
|
||||
return successful;
|
||||
}
|
||||
|
||||
public void onProfileStateChanged(Profile profile, int newProfileState) {
|
||||
if (D) {
|
||||
Log.d(TAG, "onProfileStateChanged:" + workQueue.toString());
|
||||
}
|
||||
|
||||
int newState = LocalBluetoothProfileManager.getProfileManager(mLocalManager,
|
||||
profile).convertState(newProfileState);
|
||||
|
||||
if (newState == SettingsBtStatus.CONNECTION_STATUS_CONNECTED) {
|
||||
if (!mProfiles.contains(profile)) {
|
||||
mProfiles.add(profile);
|
||||
}
|
||||
}
|
||||
|
||||
/* Ignore the transient states e.g. connecting, disconnecting */
|
||||
if (newState == SettingsBtStatus.CONNECTION_STATUS_CONNECTED ||
|
||||
newState == SettingsBtStatus.CONNECTION_STATUS_DISCONNECTED) {
|
||||
BluetoothJob job = workQueue.peek();
|
||||
if (job == null) {
|
||||
return;
|
||||
} else if (job.cachedDevice.mDevice.equals(mDevice)) {
|
||||
// This can happen in 2 cases: 1) BT device initiated pairing and
|
||||
// 2) disconnects of one headset that's triggered by connects of
|
||||
// another.
|
||||
if (D) {
|
||||
Log.d(TAG, "mDevice:" + mDevice + " != head:" + job.toString());
|
||||
}
|
||||
|
||||
// Check to see if we need to remove the stale items from the queue
|
||||
if (!pruneQueue(null)) {
|
||||
// nothing in the queue was modify. Just ignore the notification and return.
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
// Remove the first item and process the next one
|
||||
workQueue.poll();
|
||||
}
|
||||
|
||||
processCommands();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* This method is called in 2 places:
|
||||
* 1) queryCommand() - when someone or something want to connect or
|
||||
* disconnect
|
||||
* 2) onProfileStateChanged() - when the framework sends an intent
|
||||
* notification when it finishes processing a command
|
||||
*/
|
||||
private void processCommands() {
|
||||
if (D) {
|
||||
Log.d(TAG, "processCommands:" + workQueue.toString());
|
||||
}
|
||||
Iterator<BluetoothJob> it = workQueue.iterator();
|
||||
while (it.hasNext()) {
|
||||
BluetoothJob job = it.next();
|
||||
if (processCommand(job)) {
|
||||
// Sent to bt framework. Done for now. Will remove this job
|
||||
// from queue when we get an event
|
||||
return;
|
||||
} else {
|
||||
/*
|
||||
* If the command failed immediately, there will be no event
|
||||
* callbacks. So delete the job immediately and move on to the
|
||||
* next one
|
||||
*/
|
||||
it.remove();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CachedBluetoothDevice(Context context, BluetoothDevice device) {
|
||||
mLocalManager = LocalBluetoothManager.getInstance(context);
|
||||
if (mLocalManager == null) {
|
||||
throw new IllegalStateException(
|
||||
"Cannot use CachedBluetoothDevice without Bluetooth hardware");
|
||||
}
|
||||
|
||||
mDevice = device;
|
||||
|
||||
fillData();
|
||||
}
|
||||
|
||||
public void onClicked() {
|
||||
int bondState = getBondState();
|
||||
|
||||
if (isConnected()) {
|
||||
askDisconnect();
|
||||
} else if (bondState == BluetoothDevice.BOND_BONDED) {
|
||||
connect();
|
||||
} else if (bondState == BluetoothDevice.BOND_NOT_BONDED) {
|
||||
pair();
|
||||
}
|
||||
}
|
||||
|
||||
public void disconnect() {
|
||||
for (Profile profile : mProfiles) {
|
||||
disconnect(profile);
|
||||
}
|
||||
}
|
||||
|
||||
public void disconnect(Profile profile) {
|
||||
queueCommand(new BluetoothJob(BluetoothCommand.DISCONNECT, this, profile));
|
||||
}
|
||||
|
||||
private boolean disconnectInt(CachedBluetoothDevice cachedDevice, Profile profile) {
|
||||
LocalBluetoothProfileManager profileManager =
|
||||
LocalBluetoothProfileManager.getProfileManager(mLocalManager, profile);
|
||||
int status = profileManager.getConnectionStatus(cachedDevice.mDevice);
|
||||
if (SettingsBtStatus.isConnectionStatusConnected(status)) {
|
||||
if (profileManager.disconnect(cachedDevice.mDevice) ==
|
||||
BluetoothAdapter.RESULT_SUCCESS) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public void askDisconnect() {
|
||||
Context context = mLocalManager.getForegroundActivity();
|
||||
if (context == null) {
|
||||
// Cannot ask, since we need an activity context
|
||||
disconnect();
|
||||
return;
|
||||
}
|
||||
|
||||
Resources res = context.getResources();
|
||||
|
||||
String name = getName();
|
||||
if (TextUtils.isEmpty(name)) {
|
||||
name = res.getString(R.string.bluetooth_device);
|
||||
}
|
||||
String message = res.getString(R.string.bluetooth_disconnect_blank, name);
|
||||
|
||||
DialogInterface.OnClickListener disconnectListener = new DialogInterface.OnClickListener() {
|
||||
public void onClick(DialogInterface dialog, int which) {
|
||||
disconnect();
|
||||
}
|
||||
};
|
||||
|
||||
new AlertDialog.Builder(context)
|
||||
.setTitle(getName())
|
||||
.setMessage(message)
|
||||
.setPositiveButton(android.R.string.ok, disconnectListener)
|
||||
.setNegativeButton(android.R.string.cancel, null)
|
||||
.show();
|
||||
}
|
||||
|
||||
public void connect() {
|
||||
if (!ensurePaired()) return;
|
||||
|
||||
// Reset the only-show-one-error-dialog tracking variable
|
||||
mIsConnectingErrorPossible = true;
|
||||
|
||||
boolean hasAtLeastOnePreferredProfile = false;
|
||||
for (Profile profile : mProfiles) {
|
||||
LocalBluetoothProfileManager profileManager =
|
||||
LocalBluetoothProfileManager.getProfileManager(mLocalManager, profile);
|
||||
if (profileManager.isPreferred(mDevice)) {
|
||||
hasAtLeastOnePreferredProfile = true;
|
||||
queueCommand(new BluetoothJob(BluetoothCommand.CONNECT, this, profile));
|
||||
}
|
||||
}
|
||||
|
||||
if (!hasAtLeastOnePreferredProfile) {
|
||||
connectAndPreferAllProfiles();
|
||||
}
|
||||
}
|
||||
|
||||
private void connectAndPreferAllProfiles() {
|
||||
if (!ensurePaired()) return;
|
||||
|
||||
// Reset the only-show-one-error-dialog tracking variable
|
||||
mIsConnectingErrorPossible = true;
|
||||
|
||||
for (Profile profile : mProfiles) {
|
||||
LocalBluetoothProfileManager profileManager =
|
||||
LocalBluetoothProfileManager.getProfileManager(mLocalManager, profile);
|
||||
profileManager.setPreferred(mDevice, true);
|
||||
queueCommand(new BluetoothJob(BluetoothCommand.CONNECT, this, profile));
|
||||
}
|
||||
}
|
||||
|
||||
public void connect(Profile profile) {
|
||||
// Reset the only-show-one-error-dialog tracking variable
|
||||
mIsConnectingErrorPossible = true;
|
||||
queueCommand(new BluetoothJob(BluetoothCommand.CONNECT, this, profile));
|
||||
}
|
||||
|
||||
private boolean connectInt(CachedBluetoothDevice cachedDevice, Profile profile) {
|
||||
if (!cachedDevice.ensurePaired()) return false;
|
||||
|
||||
LocalBluetoothProfileManager profileManager =
|
||||
LocalBluetoothProfileManager.getProfileManager(mLocalManager, profile);
|
||||
int status = profileManager.getConnectionStatus(cachedDevice.mDevice);
|
||||
if (!SettingsBtStatus.isConnectionStatusConnected(status)) {
|
||||
if (profileManager.connect(cachedDevice.mDevice) == BluetoothAdapter.RESULT_SUCCESS) {
|
||||
return true;
|
||||
}
|
||||
Log.i(TAG, "Failed to connect " + profile.toString() + " to " + cachedDevice.mName);
|
||||
}
|
||||
Log.i(TAG, "Not connected");
|
||||
return false;
|
||||
}
|
||||
|
||||
public void showConnectingError() {
|
||||
if (!mIsConnectingErrorPossible) return;
|
||||
mIsConnectingErrorPossible = false;
|
||||
|
||||
mLocalManager.showError(mDevice, R.string.bluetooth_error_title,
|
||||
R.string.bluetooth_connecting_error_message);
|
||||
}
|
||||
|
||||
private boolean ensurePaired() {
|
||||
if (getBondState() == BluetoothDevice.BOND_NOT_BONDED) {
|
||||
pair();
|
||||
return false;
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public void pair() {
|
||||
BluetoothAdapter adapter = mLocalManager.getBluetoothAdapter();
|
||||
|
||||
// Pairing is unreliable while scanning, so cancel discovery
|
||||
if (adapter.isDiscovering()) {
|
||||
adapter.cancelDiscovery();
|
||||
}
|
||||
|
||||
if (!mDevice.createBond()) {
|
||||
mLocalManager.showError(mDevice, R.string.bluetooth_error_title,
|
||||
R.string.bluetooth_pairing_error_message);
|
||||
}
|
||||
}
|
||||
|
||||
public void unpair() {
|
||||
synchronized (workQueue) {
|
||||
// Remove any pending commands for this device
|
||||
boolean processNow = false;
|
||||
Iterator<BluetoothJob> it = workQueue.iterator();
|
||||
while (it.hasNext()) {
|
||||
BluetoothJob job = it.next();
|
||||
if (job.cachedDevice.mDevice.equals(this.mDevice)) {
|
||||
it.remove();
|
||||
if (job.timeSent != 0) {
|
||||
processNow = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (processNow) {
|
||||
processCommands();
|
||||
}
|
||||
}
|
||||
|
||||
switch (getBondState()) {
|
||||
case BluetoothDevice.BOND_BONDED:
|
||||
mDevice.removeBond();
|
||||
break;
|
||||
|
||||
case BluetoothDevice.BOND_BONDING:
|
||||
mDevice.cancelBondProcess();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private void fillData() {
|
||||
fetchName();
|
||||
fetchBtClass();
|
||||
|
||||
mVisible = false;
|
||||
|
||||
dispatchAttributesChanged();
|
||||
}
|
||||
|
||||
public BluetoothDevice getDevice() {
|
||||
return mDevice;
|
||||
}
|
||||
|
||||
public String getName() {
|
||||
return mName;
|
||||
}
|
||||
|
||||
public void setName(String name) {
|
||||
if (!mName.equals(name)) {
|
||||
if (TextUtils.isEmpty(name)) {
|
||||
mName = mDevice.getAddress();
|
||||
} else {
|
||||
mName = name;
|
||||
}
|
||||
dispatchAttributesChanged();
|
||||
}
|
||||
}
|
||||
|
||||
public void refreshName() {
|
||||
fetchName();
|
||||
dispatchAttributesChanged();
|
||||
}
|
||||
|
||||
private void fetchName() {
|
||||
mName = mDevice.getName();
|
||||
|
||||
if (TextUtils.isEmpty(mName)) {
|
||||
mName = mDevice.getAddress();
|
||||
}
|
||||
}
|
||||
|
||||
public void refresh() {
|
||||
dispatchAttributesChanged();
|
||||
}
|
||||
|
||||
public boolean isVisible() {
|
||||
return mVisible;
|
||||
}
|
||||
|
||||
void setVisible(boolean visible) {
|
||||
if (mVisible != visible) {
|
||||
mVisible = visible;
|
||||
dispatchAttributesChanged();
|
||||
}
|
||||
}
|
||||
|
||||
public int getBondState() {
|
||||
return mDevice.getBondState();
|
||||
}
|
||||
|
||||
void setRssi(short rssi) {
|
||||
if (mRssi != rssi) {
|
||||
mRssi = rssi;
|
||||
dispatchAttributesChanged();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks whether we are connected to this device (any profile counts).
|
||||
*
|
||||
* @return Whether it is connected.
|
||||
*/
|
||||
public boolean isConnected() {
|
||||
for (Profile profile : mProfiles) {
|
||||
int status = LocalBluetoothProfileManager.getProfileManager(mLocalManager, profile)
|
||||
.getConnectionStatus(mDevice);
|
||||
if (SettingsBtStatus.isConnectionStatusConnected(status)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
public boolean isBusy() {
|
||||
for (Profile profile : mProfiles) {
|
||||
int status = LocalBluetoothProfileManager.getProfileManager(mLocalManager, profile)
|
||||
.getConnectionStatus(mDevice);
|
||||
if (SettingsBtStatus.isConnectionStatusBusy(status)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (getBondState() == BluetoothDevice.BOND_BONDING) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
public int getBtClassDrawable() {
|
||||
switch (BluetoothClass.Device.Major.getDeviceMajor(mBtClass)) {
|
||||
case BluetoothClass.Device.Major.COMPUTER:
|
||||
return R.drawable.ic_bt_laptop;
|
||||
|
||||
case BluetoothClass.Device.Major.PHONE:
|
||||
return R.drawable.ic_bt_cellphone;
|
||||
}
|
||||
|
||||
if (mProfiles.contains(Profile.A2DP)) {
|
||||
return R.drawable.ic_bt_headphones_a2dp;
|
||||
} else if (mProfiles.contains(Profile.HEADSET)) {
|
||||
return R.drawable.ic_bt_headset_hfp;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Fetches a new value for the cached BT class.
|
||||
*/
|
||||
private void fetchBtClass() {
|
||||
mBtClass = mDevice.getBluetoothClass();
|
||||
if (mBtClass != BluetoothClass.ERROR) {
|
||||
LocalBluetoothProfileManager.fill(mBtClass, mProfiles);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Refreshes the UI for the BT class, including fetching the latest value
|
||||
* for the class.
|
||||
*/
|
||||
public void refreshBtClass() {
|
||||
fetchBtClass();
|
||||
dispatchAttributesChanged();
|
||||
}
|
||||
|
||||
public void setBtClass(int btClass) {
|
||||
if (mBtClass != btClass && btClass != BluetoothClass.ERROR) {
|
||||
mBtClass = btClass;
|
||||
LocalBluetoothProfileManager.fill(mBtClass, mProfiles);
|
||||
dispatchAttributesChanged();
|
||||
}
|
||||
}
|
||||
|
||||
public int getSummary() {
|
||||
// TODO: clean up
|
||||
int oneOffSummary = getOneOffSummary();
|
||||
if (oneOffSummary != 0) {
|
||||
return oneOffSummary;
|
||||
}
|
||||
|
||||
for (Profile profile : mProfiles) {
|
||||
LocalBluetoothProfileManager profileManager = LocalBluetoothProfileManager
|
||||
.getProfileManager(mLocalManager, profile);
|
||||
int connectionStatus = profileManager.getConnectionStatus(mDevice);
|
||||
|
||||
if (SettingsBtStatus.isConnectionStatusConnected(connectionStatus) ||
|
||||
connectionStatus == SettingsBtStatus.CONNECTION_STATUS_CONNECTING ||
|
||||
connectionStatus == SettingsBtStatus.CONNECTION_STATUS_DISCONNECTING) {
|
||||
return SettingsBtStatus.getConnectionStatusSummary(connectionStatus);
|
||||
}
|
||||
}
|
||||
|
||||
return SettingsBtStatus.getPairingStatusSummary(getBondState());
|
||||
}
|
||||
|
||||
/**
|
||||
* We have special summaries when particular profiles are connected. This
|
||||
* checks for those states and returns an applicable summary.
|
||||
*
|
||||
* @return A one-off summary that is applicable for the current state, or 0.
|
||||
*/
|
||||
private int getOneOffSummary() {
|
||||
boolean isA2dpConnected = false, isHeadsetConnected = false, isConnecting = false;
|
||||
|
||||
if (mProfiles.contains(Profile.A2DP)) {
|
||||
LocalBluetoothProfileManager profileManager = LocalBluetoothProfileManager
|
||||
.getProfileManager(mLocalManager, Profile.A2DP);
|
||||
isConnecting = profileManager.getConnectionStatus(mDevice) ==
|
||||
SettingsBtStatus.CONNECTION_STATUS_CONNECTING;
|
||||
isA2dpConnected = profileManager.isConnected(mDevice);
|
||||
}
|
||||
|
||||
if (mProfiles.contains(Profile.HEADSET)) {
|
||||
LocalBluetoothProfileManager profileManager = LocalBluetoothProfileManager
|
||||
.getProfileManager(mLocalManager, Profile.HEADSET);
|
||||
isConnecting |= profileManager.getConnectionStatus(mDevice) ==
|
||||
SettingsBtStatus.CONNECTION_STATUS_CONNECTING;
|
||||
isHeadsetConnected = profileManager.isConnected(mDevice);
|
||||
}
|
||||
|
||||
if (isConnecting) {
|
||||
// If any of these important profiles is connecting, prefer that
|
||||
return SettingsBtStatus.getConnectionStatusSummary(
|
||||
SettingsBtStatus.CONNECTION_STATUS_CONNECTING);
|
||||
} else if (isA2dpConnected && isHeadsetConnected) {
|
||||
return R.string.bluetooth_summary_connected_to_a2dp_headset;
|
||||
} else if (isA2dpConnected) {
|
||||
return R.string.bluetooth_summary_connected_to_a2dp;
|
||||
} else if (isHeadsetConnected) {
|
||||
return R.string.bluetooth_summary_connected_to_headset;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
public List<Profile> getProfiles() {
|
||||
return new ArrayList<Profile>(mProfiles);
|
||||
}
|
||||
|
||||
public void onCreateContextMenu(ContextMenu menu) {
|
||||
// No context menu if it is busy (none of these items are applicable if busy)
|
||||
if (mLocalManager.getBluetoothState() != BluetoothAdapter.BLUETOOTH_STATE_ON || isBusy()) {
|
||||
return;
|
||||
}
|
||||
|
||||
int bondState = getBondState();
|
||||
boolean isConnected = isConnected();
|
||||
boolean hasProfiles = mProfiles.size() > 0;
|
||||
|
||||
menu.setHeaderTitle(getName());
|
||||
|
||||
if (bondState == BluetoothDevice.BOND_NOT_BONDED) { // Not paired and not connected
|
||||
menu.add(0, CONTEXT_ITEM_CONNECT, 0, R.string.bluetooth_device_context_pair_connect);
|
||||
} else { // Paired
|
||||
if (isConnected) { // Paired and connected
|
||||
menu.add(0, CONTEXT_ITEM_DISCONNECT, 0,
|
||||
R.string.bluetooth_device_context_disconnect);
|
||||
menu.add(0, CONTEXT_ITEM_UNPAIR, 0,
|
||||
R.string.bluetooth_device_context_disconnect_unpair);
|
||||
} else { // Paired but not connected
|
||||
if (hasProfiles) {
|
||||
menu.add(0, CONTEXT_ITEM_CONNECT, 0, R.string.bluetooth_device_context_connect);
|
||||
}
|
||||
menu.add(0, CONTEXT_ITEM_UNPAIR, 0, R.string.bluetooth_device_context_unpair);
|
||||
}
|
||||
|
||||
// Show the connection options item
|
||||
if (hasProfiles) {
|
||||
menu.add(0, CONTEXT_ITEM_CONNECT_ADVANCED, 0,
|
||||
R.string.bluetooth_device_context_connect_advanced);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Called when a context menu item is clicked.
|
||||
*
|
||||
* @param item The item that was clicked.
|
||||
*/
|
||||
public void onContextItemSelected(MenuItem item) {
|
||||
switch (item.getItemId()) {
|
||||
case CONTEXT_ITEM_DISCONNECT:
|
||||
disconnect();
|
||||
break;
|
||||
|
||||
case CONTEXT_ITEM_CONNECT:
|
||||
connect();
|
||||
break;
|
||||
|
||||
case CONTEXT_ITEM_UNPAIR:
|
||||
unpair();
|
||||
break;
|
||||
|
||||
case CONTEXT_ITEM_CONNECT_ADVANCED:
|
||||
Intent intent = new Intent();
|
||||
// Need an activity context to open this in our task
|
||||
Context context = mLocalManager.getForegroundActivity();
|
||||
if (context == null) {
|
||||
// Fallback on application context, and open in a new task
|
||||
context = mLocalManager.getContext();
|
||||
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
|
||||
}
|
||||
intent.setClass(context, ConnectSpecificProfilesActivity.class);
|
||||
intent.putExtra(ConnectSpecificProfilesActivity.EXTRA_DEVICE, mDevice);
|
||||
context.startActivity(intent);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
public void registerCallback(Callback callback) {
|
||||
synchronized (mCallbacks) {
|
||||
mCallbacks.add(callback);
|
||||
}
|
||||
}
|
||||
|
||||
public void unregisterCallback(Callback callback) {
|
||||
synchronized (mCallbacks) {
|
||||
mCallbacks.remove(callback);
|
||||
}
|
||||
}
|
||||
|
||||
private void dispatchAttributesChanged() {
|
||||
synchronized (mCallbacks) {
|
||||
for (Callback callback : mCallbacks) {
|
||||
callback.onDeviceAttributesChanged(this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return mDevice.toString();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object o) {
|
||||
if ((o == null) || !(o instanceof CachedBluetoothDevice)) {
|
||||
throw new ClassCastException();
|
||||
}
|
||||
|
||||
return mDevice.equals(((CachedBluetoothDevice) o).mDevice);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return mDevice.getAddress().hashCode();
|
||||
}
|
||||
|
||||
public int compareTo(CachedBluetoothDevice another) {
|
||||
int comparison;
|
||||
|
||||
// Connected above not connected
|
||||
comparison = (another.isConnected() ? 1 : 0) - (isConnected() ? 1 : 0);
|
||||
if (comparison != 0) return comparison;
|
||||
|
||||
// Paired above not paired
|
||||
comparison = (another.getBondState() == BluetoothDevice.BOND_BONDED ? 1 : 0) -
|
||||
(getBondState() == BluetoothDevice.BOND_BONDED ? 1 : 0);
|
||||
if (comparison != 0) return comparison;
|
||||
|
||||
// Visible above not visible
|
||||
comparison = (another.mVisible ? 1 : 0) - (mVisible ? 1 : 0);
|
||||
if (comparison != 0) return comparison;
|
||||
|
||||
// Stronger signal above weaker signal
|
||||
comparison = another.mRssi - mRssi;
|
||||
if (comparison != 0) return comparison;
|
||||
|
||||
// Fallback on name
|
||||
return getName().compareTo(another.getName());
|
||||
}
|
||||
|
||||
public interface Callback {
|
||||
void onDeviceAttributesChanged(CachedBluetoothDevice cachedDevice);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user