389 lines
14 KiB
Java
389 lines
14 KiB
Java
/*
|
|
* 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 com.android.settings.ProgressCategory;
|
|
import com.android.settings.R;
|
|
|
|
import android.bluetooth.BluetoothAdapter;
|
|
import android.bluetooth.BluetoothClass;
|
|
import android.bluetooth.BluetoothDevice;
|
|
import android.bluetooth.BluetoothDevicePicker;
|
|
import android.bluetooth.BluetoothUuid;
|
|
import android.content.BroadcastReceiver;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.IntentFilter;
|
|
import android.os.Bundle;
|
|
import android.os.ParcelUuid;
|
|
import android.preference.CheckBoxPreference;
|
|
import android.preference.Preference;
|
|
import android.preference.PreferenceActivity;
|
|
import android.preference.PreferenceScreen;
|
|
import android.view.ContextMenu;
|
|
import android.view.Menu;
|
|
import android.view.MenuItem;
|
|
import android.view.View;
|
|
import android.view.ContextMenu.ContextMenuInfo;
|
|
import android.widget.AdapterView.AdapterContextMenuInfo;
|
|
|
|
import java.util.List;
|
|
import java.util.WeakHashMap;
|
|
|
|
/**
|
|
* BluetoothSettings is the Settings screen for Bluetooth configuration and
|
|
* connection management.
|
|
*/
|
|
public class BluetoothSettings extends PreferenceActivity
|
|
implements LocalBluetoothManager.Callback {
|
|
|
|
private static final String TAG = "BluetoothSettings";
|
|
|
|
private static final int MENU_SCAN = Menu.FIRST;
|
|
|
|
private static final String KEY_BT_CHECKBOX = "bt_checkbox";
|
|
private static final String KEY_BT_DISCOVERABLE = "bt_discoverable";
|
|
private static final String KEY_BT_DEVICE_LIST = "bt_device_list";
|
|
private static final String KEY_BT_NAME = "bt_name";
|
|
private static final String KEY_BT_SCAN = "bt_scan";
|
|
|
|
private static final int SCREEN_TYPE_SETTINGS = 0;
|
|
private static final int SCREEN_TYPE_DEVICEPICKER = 1;
|
|
|
|
private int mScreenType;
|
|
private int mFilterType;
|
|
private boolean mNeedAuth;
|
|
private String mLaunchPackage;
|
|
private String mLaunchClass;
|
|
|
|
private BluetoothDevice mSelectedDevice= null;
|
|
|
|
private LocalBluetoothManager mLocalManager;
|
|
|
|
private BluetoothEnabler mEnabler;
|
|
private BluetoothDiscoverableEnabler mDiscoverableEnabler;
|
|
|
|
private BluetoothNamePreference mNamePreference;
|
|
|
|
private ProgressCategory mDeviceList;
|
|
|
|
private WeakHashMap<CachedBluetoothDevice, BluetoothDevicePreference> mDevicePreferenceMap =
|
|
new WeakHashMap<CachedBluetoothDevice, BluetoothDevicePreference>();
|
|
|
|
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
|
|
@Override
|
|
public void onReceive(Context context, Intent intent) {
|
|
// TODO: put this in callback instead of receiving
|
|
|
|
if (intent.getAction().equals(BluetoothAdapter.ACTION_STATE_CHANGED)) {
|
|
onBluetoothStateChanged(mLocalManager.getBluetoothState());
|
|
} else if (intent.getAction().equals(BluetoothDevice.ACTION_BOND_STATE_CHANGED)
|
|
&& mScreenType == SCREEN_TYPE_DEVICEPICKER) {
|
|
int bondState = intent
|
|
.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, BluetoothDevice.ERROR);
|
|
if (bondState == BluetoothDevice.BOND_BONDED) {
|
|
BluetoothDevice device = intent
|
|
.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
|
|
if (device.equals(mSelectedDevice)) {
|
|
sendDevicePickedIntent(device);
|
|
finish();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
@Override
|
|
protected void onCreate(Bundle savedInstanceState) {
|
|
super.onCreate(savedInstanceState);
|
|
|
|
mLocalManager = LocalBluetoothManager.getInstance(this);
|
|
if (mLocalManager == null) finish();
|
|
|
|
// Note:
|
|
// If an application wish to show the BT device list, it can send an
|
|
// intent to Settings application with below extra data:
|
|
// -DEVICE_PICKER_FILTER_TYPE: the type of BT devices that want to show.
|
|
// -DEVICE_PICKER_LAUNCH_PACKAGE: the package which the application belongs to.
|
|
// -DEVICE_PICKER_LAUNCH_CLASS: the class which will receive user's selected
|
|
// result from the BT list.
|
|
// -DEVICE_PICKER_NEED_AUTH: to show if bonding procedure needed.
|
|
|
|
mFilterType = BluetoothDevicePicker.FILTER_TYPE_ALL;
|
|
Intent intent = getIntent();
|
|
String action = intent.getAction();
|
|
|
|
if (action.equals(BluetoothDevicePicker.ACTION_LAUNCH)) {
|
|
mScreenType = SCREEN_TYPE_DEVICEPICKER;
|
|
mNeedAuth = intent.getBooleanExtra(BluetoothDevicePicker.EXTRA_NEED_AUTH, false);
|
|
mFilterType = intent.getIntExtra(BluetoothDevicePicker.EXTRA_FILTER_TYPE,
|
|
BluetoothDevicePicker.FILTER_TYPE_ALL);
|
|
mLaunchPackage = intent.getStringExtra(BluetoothDevicePicker.EXTRA_LAUNCH_PACKAGE);
|
|
mLaunchClass = intent.getStringExtra(BluetoothDevicePicker.EXTRA_LAUNCH_CLASS);
|
|
|
|
setTitle(getString(R.string.device_picker));
|
|
addPreferencesFromResource(R.xml.device_picker);
|
|
} else {
|
|
addPreferencesFromResource(R.xml.bluetooth_settings);
|
|
|
|
mEnabler = new BluetoothEnabler(
|
|
this,
|
|
(CheckBoxPreference) findPreference(KEY_BT_CHECKBOX));
|
|
|
|
mDiscoverableEnabler = new BluetoothDiscoverableEnabler(
|
|
this,
|
|
(CheckBoxPreference) findPreference(KEY_BT_DISCOVERABLE));
|
|
|
|
mNamePreference = (BluetoothNamePreference) findPreference(KEY_BT_NAME);
|
|
|
|
mDeviceList = (ProgressCategory) findPreference(KEY_BT_DEVICE_LIST);
|
|
}
|
|
|
|
mDeviceList = (ProgressCategory) findPreference(KEY_BT_DEVICE_LIST);
|
|
|
|
registerForContextMenu(getListView());
|
|
}
|
|
|
|
@Override
|
|
protected void onResume() {
|
|
super.onResume();
|
|
|
|
// Repopulate (which isn't too bad since it's cached in the settings
|
|
// bluetooth manager
|
|
mDevicePreferenceMap.clear();
|
|
mDeviceList.removeAll();
|
|
addDevices();
|
|
|
|
if (mScreenType == SCREEN_TYPE_SETTINGS) {
|
|
mEnabler.resume();
|
|
mDiscoverableEnabler.resume();
|
|
mNamePreference.resume();
|
|
}
|
|
|
|
mLocalManager.registerCallback(this);
|
|
|
|
mDeviceList.setProgress(mLocalManager.getBluetoothAdapter().isDiscovering());
|
|
mLocalManager.startScanning(false);
|
|
|
|
IntentFilter intentFilter = new IntentFilter();
|
|
intentFilter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
|
|
intentFilter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
|
|
registerReceiver(mReceiver, intentFilter);
|
|
mLocalManager.setForegroundActivity(this);
|
|
}
|
|
|
|
@Override
|
|
protected void onPause() {
|
|
super.onPause();
|
|
|
|
mLocalManager.setForegroundActivity(null);
|
|
|
|
unregisterReceiver(mReceiver);
|
|
|
|
mLocalManager.unregisterCallback(this);
|
|
if (mScreenType == SCREEN_TYPE_SETTINGS) {
|
|
mNamePreference.pause();
|
|
mDiscoverableEnabler.pause();
|
|
mEnabler.pause();
|
|
}
|
|
}
|
|
|
|
private void addDevices() {
|
|
List<CachedBluetoothDevice> cachedDevices =
|
|
mLocalManager.getCachedDeviceManager().getCachedDevicesCopy();
|
|
for (CachedBluetoothDevice cachedDevice : cachedDevices) {
|
|
onDeviceAdded(cachedDevice);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean onCreateOptionsMenu(Menu menu) {
|
|
menu.add(0, MENU_SCAN, 0, R.string.bluetooth_scan_for_devices)
|
|
.setIcon(com.android.internal.R.drawable.ic_menu_refresh)
|
|
.setAlphabeticShortcut('r');
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean onPrepareOptionsMenu(Menu menu) {
|
|
menu.findItem(MENU_SCAN).setEnabled(mLocalManager.getBluetoothAdapter().isEnabled());
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean onOptionsItemSelected(MenuItem item) {
|
|
switch (item.getItemId()) {
|
|
|
|
case MENU_SCAN:
|
|
mLocalManager.startScanning(true);
|
|
return true;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen,
|
|
Preference preference) {
|
|
|
|
if (KEY_BT_SCAN.equals(preference.getKey())) {
|
|
mLocalManager.startScanning(true);
|
|
return true;
|
|
}
|
|
|
|
if (preference instanceof BluetoothDevicePreference) {
|
|
BluetoothDevicePreference btPreference = (BluetoothDevicePreference)preference;
|
|
if (mScreenType == SCREEN_TYPE_SETTINGS) {
|
|
btPreference.getCachedDevice().onClicked();
|
|
} else if (mScreenType == SCREEN_TYPE_DEVICEPICKER) {
|
|
CachedBluetoothDevice device = btPreference.getCachedDevice();
|
|
|
|
mSelectedDevice = device.getDevice();
|
|
mLocalManager.persistSelectedDeviceInPicker(mSelectedDevice.getAddress());
|
|
if ((device.getBondState() == BluetoothDevice.BOND_BONDED) ||
|
|
(mNeedAuth == false)) {
|
|
sendDevicePickedIntent(mSelectedDevice);
|
|
finish();
|
|
} else {
|
|
btPreference.getCachedDevice().onClicked();
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return super.onPreferenceTreeClick(preferenceScreen, preference);
|
|
}
|
|
|
|
@Override
|
|
public void onCreateContextMenu(ContextMenu menu, View v,
|
|
ContextMenuInfo menuInfo) {
|
|
//For device picker, disable Context Menu
|
|
if (mScreenType != SCREEN_TYPE_SETTINGS) {
|
|
return;
|
|
}
|
|
CachedBluetoothDevice cachedDevice = getDeviceFromMenuInfo(menuInfo);
|
|
if (cachedDevice == null) return;
|
|
|
|
cachedDevice.onCreateContextMenu(menu);
|
|
}
|
|
|
|
@Override
|
|
public boolean onContextItemSelected(MenuItem item) {
|
|
CachedBluetoothDevice cachedDevice = getDeviceFromMenuInfo(item.getMenuInfo());
|
|
if (cachedDevice == null) return false;
|
|
|
|
cachedDevice.onContextItemSelected(item);
|
|
return true;
|
|
}
|
|
|
|
private CachedBluetoothDevice getDeviceFromMenuInfo(ContextMenuInfo menuInfo) {
|
|
if ((menuInfo == null) || !(menuInfo instanceof AdapterContextMenuInfo)) {
|
|
return null;
|
|
}
|
|
|
|
AdapterContextMenuInfo adapterMenuInfo = (AdapterContextMenuInfo) menuInfo;
|
|
Preference pref = (Preference) getPreferenceScreen().getRootAdapter().getItem(
|
|
adapterMenuInfo.position);
|
|
if (pref == null || !(pref instanceof BluetoothDevicePreference)) {
|
|
return null;
|
|
}
|
|
|
|
return ((BluetoothDevicePreference) pref).getCachedDevice();
|
|
}
|
|
|
|
public void onDeviceAdded(CachedBluetoothDevice cachedDevice) {
|
|
|
|
if (mDevicePreferenceMap.get(cachedDevice) != null) {
|
|
throw new IllegalStateException("Got onDeviceAdded, but cachedDevice already exists");
|
|
}
|
|
|
|
if (addDevicePreference(cachedDevice)) {
|
|
createDevicePreference(cachedDevice);
|
|
}
|
|
}
|
|
|
|
private boolean addDevicePreference(CachedBluetoothDevice cachedDevice) {
|
|
ParcelUuid[] uuids = cachedDevice.getDevice().getUuids();
|
|
BluetoothClass bluetoothClass = cachedDevice.getDevice().getBluetoothClass();
|
|
|
|
switch(mFilterType) {
|
|
case BluetoothDevicePicker.FILTER_TYPE_TRANSFER:
|
|
if (uuids != null)
|
|
if (BluetoothUuid.containsAnyUuid(uuids,
|
|
LocalBluetoothProfileManager.OPP_PROFILE_UUIDS)) return true;
|
|
if (bluetoothClass != null
|
|
&& bluetoothClass.doesClassMatch(BluetoothClass.PROFILE_OPP)) {
|
|
return true;
|
|
}
|
|
break;
|
|
case BluetoothDevicePicker.FILTER_TYPE_AUDIO:
|
|
if (uuids != null) {
|
|
if (BluetoothUuid.containsAnyUuid(uuids,
|
|
LocalBluetoothProfileManager.A2DP_PROFILE_UUIDS)) return true;
|
|
|
|
if (BluetoothUuid.containsAnyUuid(uuids,
|
|
LocalBluetoothProfileManager.HEADSET_PROFILE_UUIDS)) return true;
|
|
} else if (bluetoothClass != null) {
|
|
if (bluetoothClass.doesClassMatch(BluetoothClass.PROFILE_A2DP)) return true;
|
|
|
|
if (bluetoothClass.doesClassMatch(BluetoothClass.PROFILE_HEADSET)) return true;
|
|
}
|
|
break;
|
|
default:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void createDevicePreference(CachedBluetoothDevice cachedDevice) {
|
|
BluetoothDevicePreference preference = new BluetoothDevicePreference(this, cachedDevice);
|
|
mDeviceList.addPreference(preference);
|
|
mDevicePreferenceMap.put(cachedDevice, preference);
|
|
}
|
|
|
|
public void onDeviceDeleted(CachedBluetoothDevice cachedDevice) {
|
|
BluetoothDevicePreference preference = mDevicePreferenceMap.remove(cachedDevice);
|
|
if (preference != null) {
|
|
mDeviceList.removePreference(preference);
|
|
}
|
|
}
|
|
|
|
public void onScanningStateChanged(boolean started) {
|
|
mDeviceList.setProgress(started);
|
|
}
|
|
|
|
private void onBluetoothStateChanged(int bluetoothState) {
|
|
// When bluetooth is enabled (and we are in the activity, which we are),
|
|
// we should start a scan
|
|
if (bluetoothState == BluetoothAdapter.STATE_ON) {
|
|
mLocalManager.startScanning(false);
|
|
} else if (bluetoothState == BluetoothAdapter.STATE_OFF) {
|
|
mDeviceList.setProgress(false);
|
|
}
|
|
}
|
|
|
|
private void sendDevicePickedIntent(BluetoothDevice device) {
|
|
Intent intent = new Intent(BluetoothDevicePicker.ACTION_DEVICE_SELECTED);
|
|
if (mLaunchPackage != null && mLaunchClass != null) {
|
|
intent.setClassName(mLaunchPackage, mLaunchClass);
|
|
}
|
|
intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);
|
|
sendBroadcast(intent);
|
|
}
|
|
}
|