Make BluetoothInputDevice inherit from BluetoothProfile. (4ab0e774) · Commits · e / os / android_frameworks_base

core/java/android/bluetooth/BluetoothAdapter.java

+3 −0

Original line number	Diff line number	Diff line
		@@ -1049,6 +1049,9 @@ public final class BluetoothAdapter {
		} else if (profile == BluetoothProfile.A2DP) {
		BluetoothA2dp a2dp = new BluetoothA2dp(context, listener);
		return true;
		} else if (profile == BluetoothProfile.INPUT_DEVICE) {
		BluetoothInputDevice iDev = new BluetoothInputDevice(context, listener);
		return true;
		} else {
		return false;
		}

core/java/android/bluetooth/BluetoothDeviceProfileState.java

+9 −9

Original line number	Diff line number	Diff line
		@@ -136,17 +136,17 @@ public final class BluetoothDeviceProfileState extends HierarchicalStateMachine
		newState == BluetoothProfile.STATE_DISCONNECTED) {
		sendMessage(TRANSITION_TO_STABLE);
		}
		} else if (action.equals(BluetoothInputDevice.ACTION_INPUT_DEVICE_STATE_CHANGED)) {
		int newState = intent.getIntExtra(BluetoothInputDevice.EXTRA_INPUT_DEVICE_STATE, 0);
		} else if (action.equals(BluetoothInputDevice.ACTION_CONNECTION_STATE_CHANGED)) {
		int newState = intent.getIntExtra(BluetoothProfile.EXTRA_STATE, 0);
		int oldState =
		intent.getIntExtra(BluetoothInputDevice.EXTRA_PREVIOUS_INPUT_DEVICE_STATE, 0);
		intent.getIntExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE, 0);

		if (oldState == BluetoothInputDevice.STATE_CONNECTED &&
		newState == BluetoothInputDevice.STATE_DISCONNECTED) {
		if (oldState == BluetoothProfile.STATE_CONNECTED &&
		newState == BluetoothProfile.STATE_DISCONNECTED) {
		sendMessage(DISCONNECT_HID_INCOMING);
		}
		if (newState == BluetoothInputDevice.STATE_CONNECTED \|\|
		newState == BluetoothInputDevice.STATE_DISCONNECTED) {
		if (newState == BluetoothProfile.STATE_CONNECTED \|\|
		newState == BluetoothProfile.STATE_DISCONNECTED) {
		sendMessage(TRANSITION_TO_STABLE);
		}
		} else if (action.equals(BluetoothDevice.ACTION_ACL_DISCONNECTED)) {
		@@ -194,7 +194,7 @@ public final class BluetoothDeviceProfileState extends HierarchicalStateMachine
		filter.addAction(BluetoothDevice.ACTION_ACL_CONNECTED);
		filter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
		filter.addAction(BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED);
		filter.addAction(BluetoothInputDevice.ACTION_INPUT_DEVICE_STATE_CHANGED);
		filter.addAction(BluetoothInputDevice.ACTION_CONNECTION_STATE_CHANGED);
		filter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED);

		mContext.registerReceiver(mBroadcastReceiver, filter);
		@@ -286,7 +286,7 @@ public final class BluetoothDeviceProfileState extends HierarchicalStateMachine
		sendMessage(DISCONNECT_A2DP_OUTGOING);
		deferMessage(message);
		break;
		} else if (mService.getInputDeviceState(mDevice) !=
		} else if (mService.getInputDeviceConnectionState(mDevice) !=
		BluetoothInputDevice.STATE_DISCONNECTED) {
		sendMessage(DISCONNECT_HID_OUTGOING);
		deferMessage(message);

core/java/android/bluetooth/BluetoothInputDevice.java

+169 −151

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 The Android Open Source Project
		* Copyright (C) 2011 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.
		@@ -27,91 +27,88 @@ import android.util.Log;
		import java.util.ArrayList;
		import java.util.List;


		/**
		* Public API for controlling the Bluetooth HID (Input Device) Profile
		*
		* BluetoothInputDevice is a proxy object used to make calls to Bluetooth Service
		* which handles the HID profile.
		*
		* Creating a BluetoothInputDevice object will initiate a binding with the
		* Bluetooth service. Users of this object should call close() when they
		* are finished, so that this proxy object can unbind from the service.
		* This class provides the public APIs to control the Bluetooth Input
		* Device Profile.
		*
		* Currently the Bluetooth service runs in the system server and this
		* proxy object will be immediately bound to the service on construction.
		*<p>BluetoothInputDevice is a proxy object for controlling the Bluetooth
		* Service via IPC. Use {@link BluetoothAdapter#getProfileProxy} to get
		* the BluetoothInputDevice proxy object.
		*
		*<p>Each method is protected with its appropriate permission.
		*@hide
		*/
		public final class BluetoothInputDevice {
		public final class BluetoothInputDevice implements BluetoothProfile {
		private static final String TAG = "BluetoothInputDevice";
		private static final boolean DBG = false;

		/** int extra for ACTION_INPUT_DEVICE_STATE_CHANGED */
		public static final String EXTRA_INPUT_DEVICE_STATE =
		"android.bluetooth.inputdevice.extra.INPUT_DEVICE_STATE";
		/** int extra for ACTION_INPUT_DEVICE_STATE_CHANGED */
		public static final String EXTRA_PREVIOUS_INPUT_DEVICE_STATE =
		"android.bluetooth.inputdevice.extra.PREVIOUS_INPUT_DEVICE_STATE";

		/** Indicates the state of an input device has changed.
		* This intent will always contain EXTRA_INPUT_DEVICE_STATE,
		* EXTRA_PREVIOUS_INPUT_DEVICE_STATE and BluetoothDevice.EXTRA_DEVICE
		* extras.
		*/
		@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
		public static final String ACTION_INPUT_DEVICE_STATE_CHANGED =
		"android.bluetooth.inputdevice.action.INPUT_DEVICE_STATE_CHANGED";

		public static final int STATE_DISCONNECTED = 0;
		public static final int STATE_CONNECTING = 1;
		public static final int STATE_CONNECTED = 2;
		public static final int STATE_DISCONNECTING = 3;

		/**
		* Auto connection, incoming and outgoing connection are allowed at this
		* priority level.
		*/
		public static final int PRIORITY_AUTO_CONNECT = 1000;
		/**
		* Incoming and outgoing connection are allowed at this priority level
		*/
		public static final int PRIORITY_ON = 100;
		/**
		* Connections to the device are not allowed at this priority level.
		*/
		public static final int PRIORITY_OFF = 0;
		/**
		* Default priority level when the device is unpaired.
		* Intent used to broadcast the change in connection state of the Input
		* Device profile.
		*
		* <p>This intent will have 3 extras:
		* <ul>
		* <li> {@link #EXTRA_STATE} - The current state of the profile. </li>
		* <li> {@link #EXTRA_PREVIOUS_STATE}- The previous state of the profile.</li>
		* <li> {@link BluetoothDevice#EXTRA_DEVICE} - The remote device. </li>
		* </ul>
		*
		* <p>{@link #EXTRA_STATE} or {@link #EXTRA_PREVIOUS_STATE} can be any of
		* {@link #STATE_DISCONNECTED}, {@link #STATE_CONNECTING},
		* {@link #STATE_CONNECTED}, {@link #STATE_DISCONNECTING}.
		*
		* <p>Requires {@link android.Manifest.permission#BLUETOOTH} permission to
		* receive.
		*/
		public static final int PRIORITY_UNDEFINED = -1;
		@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
		public static final String ACTION_CONNECTION_STATE_CHANGED =
		"android.bluetooth.input.profile.action.CONNECTION_STATE_CHANGED";

		/**
		* Return codes for the connect and disconnect Bluez / Dbus calls.
		* @hide
		*/
		public static final int INPUT_DISCONNECT_FAILED_NOT_CONNECTED = 5000;

		/**
		* @hide
		*/
		public static final int INPUT_CONNECT_FAILED_ALREADY_CONNECTED = 5001;

		/**
		* @hide
		*/
		public static final int INPUT_CONNECT_FAILED_ATTEMPT_FAILED = 5002;

		/**
		* @hide
		*/
		public static final int INPUT_OPERATION_GENERIC_FAILURE = 5003;

		/**
		* @hide
		*/
		public static final int INPUT_OPERATION_SUCCESS = 5004;

		private final IBluetooth mService;
		private final Context mContext;
		private ServiceListener mServiceListener;
		private BluetoothAdapter mAdapter;
		private IBluetooth mService;

		/**
		* Create a BluetoothInputDevice proxy object for interacting with the local
		* Bluetooth Service which handle the HID profile.
		* @param c Context
		* Bluetooth Service which handles the InputDevice profile
		*
		*/
		public BluetoothInputDevice(Context c) {
		mContext = c;

		/package/ BluetoothInputDevice(Context mContext, ServiceListener l) {
		IBinder b = ServiceManager.getService(BluetoothAdapter.BLUETOOTH_SERVICE);
		mServiceListener = l;
		mAdapter = BluetoothAdapter.getDefaultAdapter();
		if (b != null) {
		mService = IBluetooth.Stub.asInterface(b);
		if (mServiceListener != null) {
		mServiceListener.onServiceConnected(BluetoothProfile.INPUT_DEVICE, this);
		}
		} else {
		Log.w(TAG, "Bluetooth Service not available!");

		@@ -121,127 +118,148 @@ public final class BluetoothInputDevice {
		}
		}

		/** Initiate a connection to an Input device.
		*
		* This function returns false on error and true if the connection
		* attempt is being made.
		*
		* Listen for INPUT_DEVICE_STATE_CHANGED_ACTION to find out when the
		* connection is completed.
		* @param device Remote BT device.
		* @return false on immediate error, true otherwise
		/**
		* {@inheritDoc}
		* @hide
		*/
		public boolean connectInputDevice(BluetoothDevice device) {
		if (DBG) log("connectInputDevice(" + device + ")");
		public boolean connect(BluetoothDevice device) {
		if (DBG) log("connect(" + device + ")");
		if (mService != null && isEnabled() &&
		isValidDevice(device)) {
		try {
		return mService.connectInputDevice(device);
		} catch (RemoteException e) {
		Log.e(TAG, "", e);
		Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
		return false;
		}
		}
		if (mService == null) Log.w(TAG, "Proxy not attached to service");
		return false;
		}

		/** Initiate disconnect from an Input Device.
		* This function return false on error and true if the disconnection
		* attempt is being made.
		*
		* Listen for INPUT_DEVICE_STATE_CHANGED_ACTION to find out when
		* disconnect is completed.
		*
		* @param device Remote BT device.
		* @return false on immediate error, true otherwise
		/**
		* {@inheritDoc}
		* @hide
		*/
		public boolean disconnectInputDevice(BluetoothDevice device) {
		if (DBG) log("disconnectInputDevice(" + device + ")");
		public boolean disconnect(BluetoothDevice device) {
		if (DBG) log("disconnect(" + device + ")");
		if (mService != null && isEnabled() &&
		isValidDevice(device)) {
		try {
		return mService.disconnectInputDevice(device);
		} catch (RemoteException e) {
		Log.e(TAG, "", e);
		Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
		return false;
		}
		}

		/** Check if a specified InputDevice is connected.
		*
		* @param device Remote BT device.
		* @return True if connected , false otherwise and on error.
		* @hide
		*/
		public boolean isInputDeviceConnected(BluetoothDevice device) {
		if (DBG) log("isInputDeviceConnected(" + device + ")");
		int state = getInputDeviceState(device);
		if (state == STATE_CONNECTED) return true;
		if (mService == null) Log.w(TAG, "Proxy not attached to service");
		return false;
		}

		/** Check if any Input Device is connected.
		*
		* @return List of devices, empty List on error.
		* @hide
		/**
		* {@inheritDoc}
		*/
		public List<BluetoothDevice> getConnectedInputDevices() {
		if (DBG) log("getConnectedInputDevices()");
		public List<BluetoothDevice> getConnectedDevices() {
		if (DBG) log("getConnectedDevices()");
		if (mService != null && isEnabled()) {
		try {
		return mService.getConnectedInputDevices();
		} catch (RemoteException e) {
		Log.e(TAG, "", e);
		Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
		return new ArrayList<BluetoothDevice>();
		}
		}
		if (mService == null) Log.w(TAG, "Proxy not attached to service");
		return new ArrayList<BluetoothDevice>();
		}

		/** Get the state of an Input Device.
		*
		* @param device Remote BT device.
		* @return The current state of the Input Device
		* @hide
		/**
		* {@inheritDoc}
		*/
		public int getInputDeviceState(BluetoothDevice device) {
		if (DBG) log("getInputDeviceState(" + device + ")");
		public List<BluetoothDevice> getDevicesMatchingConnectionStates(int[] states) {
		if (DBG) log("getDevicesMatchingStates()");
		if (mService != null && isEnabled()) {
		try {
		return mService.getInputDeviceState(device);
		return mService.getInputDevicesMatchingConnectionStates(states);
		} catch (RemoteException e) {
		Log.e(TAG, "", e);
		return STATE_DISCONNECTED;
		Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
		return new ArrayList<BluetoothDevice>();
		}
		}
		if (mService == null) Log.w(TAG, "Proxy not attached to service");
		return new ArrayList<BluetoothDevice>();
		}

		/**
		* Set priority of an input device.
		*
		* Priority is a non-negative integer. Priority can take the following
		* values:
		* {@link PRIORITY_ON}, {@link PRIORITY_OFF}, {@link PRIORITY_AUTO_CONNECT}
		*
		* @param device Paired device.
		* @param priority Integer priority
		* @return true if priority is set, false on error
		* {@inheritDoc}
		*/
		public boolean setInputDevicePriority(BluetoothDevice device, int priority) {
		if (DBG) log("setInputDevicePriority(" + device + ", " + priority + ")");
		public int getConnectionState(BluetoothDevice device) {
		if (DBG) log("getState(" + device + ")");
		if (mService != null && isEnabled()
		&& isValidDevice(device)) {
		try {
		return mService.getInputDeviceConnectionState(device);
		} catch (RemoteException e) {
		Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
		return BluetoothProfile.STATE_DISCONNECTED;
		}
		}
		if (mService == null) Log.w(TAG, "Proxy not attached to service");
		return BluetoothProfile.STATE_DISCONNECTED;
		}

		/**
		* {@inheritDoc}
		* @hide
		*/
		public boolean setPriority(BluetoothDevice device, int priority) {
		if (DBG) log("setPriority(" + device + ", " + priority + ")");
		if (mService != null && isEnabled()
		&& isValidDevice(device)) {
		if (priority != BluetoothProfile.PRIORITY_OFF &&
		priority != BluetoothProfile.PRIORITY_ON) {
		return false;
		}
		try {
		return mService.setInputDevicePriority(device, priority);
		} catch (RemoteException e) {
		Log.e(TAG, "", e);
		Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
		return false;
		}
		}
		if (mService == null) Log.w(TAG, "Proxy not attached to service");
		return false;
		}

		/**
		* Get the priority associated with an Input Device.
		*
		* @param device Input Device
		* @return non-negative priority, or negative error code on error.
		* {@inheritDoc}
		* @hide
		*/
		public int getInputDevicePriority(BluetoothDevice device) {
		if (DBG) log("getInputDevicePriority(" + device + ")");
		public int getPriority(BluetoothDevice device) {
		if (DBG) log("getPriority(" + device + ")");
		if (mService != null && isEnabled()
		&& isValidDevice(device)) {
		try {
		return mService.getInputDevicePriority(device);
		} catch (RemoteException e) {
		Log.e(TAG, "", e);
		return PRIORITY_OFF;
		Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
		return BluetoothProfile.PRIORITY_OFF;
		}
		}
		if (mService == null) Log.w(TAG, "Proxy not attached to service");
		return BluetoothProfile.PRIORITY_OFF;
		}

		private boolean isEnabled() {
		if (mAdapter.getState() == BluetoothAdapter.STATE_ON) return true;
		return false;
		}

		private boolean isValidDevice(BluetoothDevice device) {
		if (device == null) return false;

		if (BluetoothAdapter.checkBluetoothAddress(device.getAddress())) return true;
		return false;
		}

		private static void log(String msg) {

core/java/android/bluetooth/BluetoothProfile.java

+5 −0

Original line number	Diff line number	Diff line
		@@ -62,6 +62,11 @@ public interface BluetoothProfile {
		* A2DP profile.
		*/
		public static final int A2DP = 2;
		/**
		* Input Device Profile
		* @hide
		*/
		public static final int INPUT_DEVICE = 3;

		/**
		* Default priority for devices that we try to auto-connect to and

core/java/android/bluetooth/BluetoothProfileState.java

+5 −5

Original line number	Diff line number	Diff line
		@@ -72,10 +72,10 @@ public class BluetoothProfileState extends HierarchicalStateMachine {
		newState == BluetoothProfile.STATE_DISCONNECTED)) {
		sendMessage(TRANSITION_TO_STABLE);
		}
		} else if (action.equals(BluetoothInputDevice.ACTION_INPUT_DEVICE_STATE_CHANGED)) {
		int newState = intent.getIntExtra(BluetoothInputDevice.EXTRA_INPUT_DEVICE_STATE, 0);
		if (mProfile == HID && (newState == BluetoothInputDevice.STATE_CONNECTED \|\|
		newState == BluetoothInputDevice.STATE_DISCONNECTED)) {
		} else if (action.equals(BluetoothInputDevice.ACTION_CONNECTION_STATE_CHANGED)) {
		int newState = intent.getIntExtra(BluetoothProfile.EXTRA_STATE, 0);
		if (mProfile == HID && (newState == BluetoothProfile.STATE_CONNECTED \|\|
		newState == BluetoothProfile.STATE_DISCONNECTED)) {
		sendMessage(TRANSITION_TO_STABLE);
		}
		} else if (action.equals(BluetoothDevice.ACTION_ACL_DISCONNECTED)) {
		@@ -96,7 +96,7 @@ public class BluetoothProfileState extends HierarchicalStateMachine {
		IntentFilter filter = new IntentFilter();
		filter.addAction(BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED);
		filter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
		filter.addAction(BluetoothInputDevice.ACTION_INPUT_DEVICE_STATE_CHANGED);
		filter.addAction(BluetoothInputDevice.ACTION_CONNECTION_STATE_CHANGED);
		filter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED);
		context.registerReceiver(mBroadcastReceiver, filter);
		}