diff options
author | Hemant Gupta <hemantg@codeaurora.org> | 2014-04-18 11:22:45 +0530 |
---|---|---|
committer | Linux Build Service Account <lnxbuild@localhost> | 2015-10-06 03:26:10 -0600 |
commit | 642e963bd74e8ff90c49461a6050847ed8675a88 (patch) | |
tree | ba3d1856e78496329d3188f03a4f01ab287f0aa5 | |
parent | 74e4a37ba2d9bd4908dd1e8c694c746c8da0ee8e (diff) | |
download | frameworks_base-642e963bd74e8ff90c49461a6050847ed8675a88.zip frameworks_base-642e963bd74e8ff90c49461a6050847ed8675a88.tar.gz frameworks_base-642e963bd74e8ff90c49461a6050847ed8675a88.tar.bz2 |
Initial commit for HID Client
Initial commit for HID Client.
Change-Id: Ife1f54acce79892414ad71d5488fdb659efede59
CRs-Fixed: 573086
10 files changed, 1362 insertions, 0 deletions
diff --git a/core/java/android/bluetooth/BluetoothHidDevice.java b/core/java/android/bluetooth/BluetoothHidDevice.java new file mode 100644 index 0000000..b8b8f5f --- /dev/null +++ b/core/java/android/bluetooth/BluetoothHidDevice.java @@ -0,0 +1,651 @@ +/* + * 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. + * 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 android.bluetooth; + +import android.annotation.SdkConstant; +import android.annotation.SdkConstant.SdkConstantType; +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.content.ServiceConnection; +import android.os.IBinder; +import android.os.RemoteException; +import android.util.Log; + +import java.util.ArrayList; +import java.util.List; + + +/** + * This class provides the public APIs to control the Bluetooth Input + * Device Profile. + * + *<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 implements BluetoothProfile { + private static final String TAG = "BluetoothInputDevice"; + private static final boolean DBG = true; + private static final boolean VDBG = false; + + /** + * 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. + */ + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String ACTION_CONNECTION_STATE_CHANGED = + "android.bluetooth.input.profile.action.CONNECTION_STATE_CHANGED"; + + /** + * @hide + */ + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String ACTION_PROTOCOL_MODE_CHANGED = + "android.bluetooth.input.profile.action.PROTOCOL_MODE_CHANGED"; + + /** + * @hide + */ + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String ACTION_REPORT = + "android.bluetooth.input.profile.action.REPORT"; + + /** + * @hide + */ + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String ACTION_VIRTUAL_UNPLUG_STATUS = + "android.bluetooth.input.profile.action.VIRTUAL_UNPLUG_STATUS"; + + + /** + * 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; + + /** + * @hide + */ + public static final int PROTOCOL_REPORT_MODE = 0; + + /** + * @hide + */ + public static final int PROTOCOL_BOOT_MODE = 1; + + /** + * @hide + */ + public static final int PROTOCOL_UNSUPPORTED_MODE = 255; + + /* int reportType, int reportType, int bufferSize */ + /** + * @hide + */ + public static final byte REPORT_TYPE_INPUT = 1; + + /** + * @hide + */ + public static final byte REPORT_TYPE_OUTPUT = 2; + + /** + * @hide + */ + public static final byte REPORT_TYPE_FEATURE = 3; + + /** + * @hide + */ + public static final int VIRTUAL_UNPLUG_STATUS_SUCCESS = 0; + + /** + * @hide + */ + public static final int VIRTUAL_UNPLUG_STATUS_FAIL = 1; + + /** + * @hide + */ + public static final String EXTRA_PROTOCOL_MODE = "android.bluetooth.BluetoothInputDevice.extra.PROTOCOL_MODE"; + + /** + * @hide + */ + public static final String EXTRA_REPORT_TYPE = "android.bluetooth.BluetoothInputDevice.extra.REPORT_TYPE"; + + /** + * @hide + */ + public static final String EXTRA_REPORT_ID = "android.bluetooth.BluetoothInputDevice.extra.REPORT_ID"; + + /** + * @hide + */ + public static final String EXTRA_REPORT_BUFFER_SIZE = "android.bluetooth.BluetoothInputDevice.extra.REPORT_BUFFER_SIZE"; + + /** + * @hide + */ + public static final String EXTRA_REPORT = "android.bluetooth.BluetoothInputDevice.extra.REPORT"; + + /** + * @hide + */ + public static final String EXTRA_VIRTUAL_UNPLUG_STATUS = "android.bluetooth.BluetoothInputDevice.extra.VIRTUAL_UNPLUG_STATUS"; + + private Context mContext; + private ServiceListener mServiceListener; + private BluetoothAdapter mAdapter; + private IBluetoothInputDevice mService; + + final private IBluetoothStateChangeCallback mBluetoothStateChangeCallback = + new IBluetoothStateChangeCallback.Stub() { + public void onBluetoothStateChange(boolean up) { + if (DBG) Log.d(TAG, "onBluetoothStateChange: up=" + up); + if (!up) { + if (VDBG) Log.d(TAG,"Unbinding service..."); + synchronized (mConnection) { + try { + mService = null; + mContext.unbindService(mConnection); + } catch (Exception re) { + Log.e(TAG,"",re); + } + } + } else { + synchronized (mConnection) { + try { + if (mService == null) { + if (VDBG) Log.d(TAG,"Binding service..."); + doBind(); + } + } catch (Exception re) { + Log.e(TAG,"",re); + } + } + } + } + }; + + /** + * Create a BluetoothInputDevice proxy object for interacting with the local + * Bluetooth Service which handles the InputDevice profile + * + */ + /*package*/ BluetoothInputDevice(Context context, ServiceListener l) { + mContext = context; + mServiceListener = l; + mAdapter = BluetoothAdapter.getDefaultAdapter(); + + IBluetoothManager mgr = mAdapter.getBluetoothManager(); + if (mgr != null) { + try { + mgr.registerStateChangeCallback(mBluetoothStateChangeCallback); + } catch (RemoteException e) { + Log.e(TAG,"",e); + } + } + + doBind(); + } + + boolean doBind() { + Intent intent = new Intent(IBluetoothInputDevice.class.getName()); + ComponentName comp = intent.resolveSystemService(mContext.getPackageManager(), 0); + intent.setComponent(comp); + if (comp == null || !mContext.bindService(intent, mConnection, 0)) { + Log.e(TAG, "Could not bind to Bluetooth HID Service with " + intent); + return false; + } + return true; + } + + /*package*/ void close() { + if (VDBG) log("close()"); + IBluetoothManager mgr = mAdapter.getBluetoothManager(); + if (mgr != null) { + try { + mgr.unregisterStateChangeCallback(mBluetoothStateChangeCallback); + } catch (Exception e) { + Log.e(TAG,"",e); + } + } + + synchronized (mConnection) { + if (mService != null) { + try { + mService = null; + mContext.unbindService(mConnection); + } catch (Exception re) { + Log.e(TAG,"",re); + } + } + } + mServiceListener = null; + } + + /** + * Initiate connection to a profile of the remote bluetooth device. + * + * <p> The system supports connection to multiple input devices. + * + * <p> This API returns false in scenarios like the profile on the + * device is already connected or Bluetooth is not turned on. + * When this API returns true, it is guaranteed that + * connection state intent for the profile will be broadcasted with + * the state. Users can get the connection state of the profile + * from this intent. + * + * <p>Requires {@link android.Manifest.permission#BLUETOOTH_ADMIN} + * permission. + * + * @param device Remote Bluetooth Device + * @return false on immediate error, + * true otherwise + * @hide + */ + public boolean connect(BluetoothDevice device) { + if (DBG) log("connect(" + device + ")"); + if (mService != null && isEnabled() && isValidDevice(device)) { + try { + return mService.connect(device); + } catch (RemoteException 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 disconnection from a profile + * + * <p> This API will return false in scenarios like the profile on the + * Bluetooth device is not in connected state etc. When this API returns, + * true, it is guaranteed that the connection state change + * intent will be broadcasted with the state. Users can get the + * disconnection state of the profile from this intent. + * + * <p> If the disconnection is initiated by a remote device, the state + * will transition from {@link #STATE_CONNECTED} to + * {@link #STATE_DISCONNECTED}. If the disconnect is initiated by the + * host (local) device the state will transition from + * {@link #STATE_CONNECTED} to state {@link #STATE_DISCONNECTING} to + * state {@link #STATE_DISCONNECTED}. The transition to + * {@link #STATE_DISCONNECTING} can be used to distinguish between the + * two scenarios. + * + * <p>Requires {@link android.Manifest.permission#BLUETOOTH_ADMIN} + * permission. + * + * @param device Remote Bluetooth Device + * @return false on immediate error, + * true otherwise + * @hide + */ + public boolean disconnect(BluetoothDevice device) { + if (DBG) log("disconnect(" + device + ")"); + if (mService != null && isEnabled() && isValidDevice(device)) { + try { + return mService.disconnect(device); + } catch (RemoteException e) { + Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable())); + return false; + } + } + if (mService == null) Log.w(TAG, "Proxy not attached to service"); + return false; + } + + /** + * {@inheritDoc} + */ + public List<BluetoothDevice> getConnectedDevices() { + if (VDBG) log("getConnectedDevices()"); + if (mService != null && isEnabled()) { + try { + return mService.getConnectedDevices(); + } catch (RemoteException 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>(); + } + + /** + * {@inheritDoc} + */ + public List<BluetoothDevice> getDevicesMatchingConnectionStates(int[] states) { + if (VDBG) log("getDevicesMatchingStates()"); + if (mService != null && isEnabled()) { + try { + return mService.getDevicesMatchingConnectionStates(states); + } catch (RemoteException 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>(); + } + + /** + * {@inheritDoc} + */ + public int getConnectionState(BluetoothDevice device) { + if (VDBG) log("getState(" + device + ")"); + if (mService != null && isEnabled() && isValidDevice(device)) { + try { + return mService.getConnectionState(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; + } + + /** + * Set priority of the profile + * + * <p> The device should already be paired. + * Priority can be one of {@link #PRIORITY_ON} or + * {@link #PRIORITY_OFF}, + * + * <p>Requires {@link android.Manifest.permission#BLUETOOTH_ADMIN} + * permission. + * + * @param device Paired bluetooth device + * @param priority + * @return true if priority is set, false on error + * @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.setPriority(device, priority); + } catch (RemoteException 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 of the profile. + * + * <p> The priority can be any of: + * {@link #PRIORITY_AUTO_CONNECT}, {@link #PRIORITY_OFF}, + * {@link #PRIORITY_ON}, {@link #PRIORITY_UNDEFINED} + * + * <p>Requires {@link android.Manifest.permission#BLUETOOTH} permission. + * + * @param device Bluetooth device + * @return priority of the device + * @hide + */ + public int getPriority(BluetoothDevice device) { + if (VDBG) log("getPriority(" + device + ")"); + if (mService != null && isEnabled() && isValidDevice(device)) { + try { + return mService.getPriority(device); + } catch (RemoteException e) { + 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 final ServiceConnection mConnection = new ServiceConnection() { + public void onServiceConnected(ComponentName className, IBinder service) { + if (DBG) Log.d(TAG, "Proxy object connected"); + mService = IBluetoothInputDevice.Stub.asInterface(service); + + if (mServiceListener != null) { + mServiceListener.onServiceConnected(BluetoothProfile.INPUT_DEVICE, BluetoothInputDevice.this); + } + } + public void onServiceDisconnected(ComponentName className) { + if (DBG) Log.d(TAG, "Proxy object disconnected"); + mService = null; + if (mServiceListener != null) { + mServiceListener.onServiceDisconnected(BluetoothProfile.INPUT_DEVICE); + } + } + }; + + 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; + } + + + /** + * Initiate virtual unplug for a HID input device. + * + * <p>Requires {@link android.Manifest.permission#BLUETOOTH_ADMIN} permission. + * + * @param device Remote Bluetooth Device + * @return false on immediate error, + * true otherwise + * @hide + */ + public boolean virtualUnplug(BluetoothDevice device) { + if (DBG) log("virtualUnplug(" + device + ")"); + if (mService != null && isEnabled() && isValidDevice(device)) { + try { + return mService.virtualUnplug(device); + } catch (RemoteException e) { + Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable())); + return false; + } + } + + if (mService == null) Log.w(TAG, "Proxy not attached to service"); + return false; + + } + + /** + * Send Get_Protocol_Mode command to the connected HID input device. + * + * <p>Requires {@link android.Manifest.permission#BLUETOOTH_ADMIN} permission. + * + * @param device Remote Bluetooth Device + * @return false on immediate error, + *true otherwise + * @hide + */ + public boolean getProtocolMode(BluetoothDevice device) { + if (VDBG) log("getProtocolMode(" + device + ")"); + if (mService != null && isEnabled() && isValidDevice(device)) { + try { + return mService.getProtocolMode(device); + } catch (RemoteException e) { + Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable())); + return false; + } + } + if (mService == null) Log.w(TAG, "Proxy not attached to service"); + return false; + } + + /** + * Send Set_Protocol_Mode command to the connected HID input device. + * + * <p>Requires {@link android.Manifest.permission#BLUETOOTH_ADMIN} permission. + * + * @param device Remote Bluetooth Device + * @return false on immediate error, + * true otherwise + * @hide + */ + public boolean setProtocolMode(BluetoothDevice device, int protocolMode) { + if (DBG) log("setProtocolMode(" + device + ")"); + if (mService != null && isEnabled() && isValidDevice(device)) { + try { + return mService.setProtocolMode(device, protocolMode); + } catch (RemoteException e) { + Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable())); + return false; + } + } + if (mService == null) Log.w(TAG, "Proxy not attached to service"); + return false; + } + + /** + * Send Get_Report command to the connected HID input device. + * + * <p>Requires {@link android.Manifest.permission#BLUETOOTH_ADMIN} permission. + * + * @param device Remote Bluetooth Device + * @param reportType Report type + * @param reportId Report ID + * @param bufferSize Report receiving buffer size + * @return false on immediate error, + * true otherwise + * @hide + */ + public boolean getReport(BluetoothDevice device, byte reportType, byte reportId, int bufferSize) { + if (VDBG) log("getReport(" + device + "), reportType=" + reportType + " reportId=" + reportId + "bufferSize=" + bufferSize); + if (mService != null && isEnabled() && isValidDevice(device)) { + try { + return mService.getReport(device, reportType, reportId, bufferSize); + } catch (RemoteException e) { + Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable())); + return false; + } + } + if (mService == null) Log.w(TAG, "Proxy not attached to service"); + return false; + } + + /** + * Send Set_Report command to the connected HID input device. + * + * <p>Requires {@link android.Manifest.permission#BLUETOOTH_ADMIN} permission. + * + * @param device Remote Bluetooth Device + * @param reportType Report type + * @param report Report receiving buffer size + * @return false on immediate error, + * true otherwise + * @hide + */ + public boolean setReport(BluetoothDevice device, byte reportType, String report) { + if (DBG) log("setReport(" + device + "), reportType=" + reportType + " report=" + report); + if (mService != null && isEnabled() && isValidDevice(device)) { + try { + return mService.setReport(device, reportType, report); + } catch (RemoteException e) { + Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable())); + return false; + } + } + if (mService == null) Log.w(TAG, "Proxy not attached to service"); + return false; + } + + /** + * Send Send_Data command to the connected HID input device. + * + * <p>Requires {@link android.Manifest.permission#BLUETOOTH_ADMIN} permission. + * + * @param device Remote Bluetooth Device + * @param data Data to send + * @return false on immediate error, + * true otherwise + * @hide + */ + public boolean sendData(BluetoothDevice device, String report) { + if (DBG) log("sendData(" + device + "), report=" + report); + if (mService != null && isEnabled() && isValidDevice(device)) { + try { + return mService.sendData(device, report); + } catch (RemoteException e) { + Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable())); + return false; + } + } + if (mService == null) Log.w(TAG, "Proxy not attached to service"); + return false; + } + private static void log(String msg) { + Log.d(TAG, msg); + } +} diff --git a/core/java/android/bluetooth/BluetoothHidDeviceAppConfiguration.aidl b/core/java/android/bluetooth/BluetoothHidDeviceAppConfiguration.aidl new file mode 100644 index 0000000..bc9e54f --- /dev/null +++ b/core/java/android/bluetooth/BluetoothHidDeviceAppConfiguration.aidl @@ -0,0 +1,19 @@ +/* +** Copyright 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. +** 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 android.bluetooth; + +parcelable BluetoothHealthAppConfiguration; diff --git a/core/java/android/bluetooth/BluetoothHidDeviceAppConfiguration.java b/core/java/android/bluetooth/BluetoothHidDeviceAppConfiguration.java new file mode 100644 index 0000000..15a9101 --- /dev/null +++ b/core/java/android/bluetooth/BluetoothHidDeviceAppConfiguration.java @@ -0,0 +1,165 @@ +/* + * 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. + * 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 android.bluetooth; + +import android.os.Parcel; +import android.os.Parcelable; + +/** + * The Bluetooth Health Application Configuration that is used in conjunction with + * the {@link BluetoothHealth} class. This class represents an application configuration + * that the Bluetooth Health third party application will register to communicate with the + * remote Bluetooth health device. + * + */ +public final class BluetoothHealthAppConfiguration implements Parcelable { + private final String mName; + private final int mDataType; + private final int mRole; + private final int mChannelType; + + /** + * Constructor to register the SINK role + * + * @param name Friendly name associated with the application configuration + * @param dataType Data Type of the remote Bluetooth Health device + * @hide + */ + BluetoothHealthAppConfiguration(String name, int dataType) { + mName = name; + mDataType = dataType; + mRole = BluetoothHealth.SINK_ROLE; + mChannelType = BluetoothHealth.CHANNEL_TYPE_ANY; + } + + /** + * Constructor to register the application configuration. + * + * @param name Friendly name associated with the application configuration + * @param dataType Data Type of the remote Bluetooth Health device + * @param role {@link BluetoothHealth#SOURCE_ROLE} or + * {@link BluetoothHealth#SINK_ROLE} + * @hide + */ + BluetoothHealthAppConfiguration(String name, int dataType, int role, int + channelType) { + mName = name; + mDataType = dataType; + mRole = role; + mChannelType = channelType; + } + + @Override + public boolean equals(Object o) { + if (o instanceof BluetoothHealthAppConfiguration) { + BluetoothHealthAppConfiguration config = (BluetoothHealthAppConfiguration) o; + // config.getName() can never be NULL + return mName.equals(config.getName()) && + mDataType == config.getDataType() && + mRole == config.getRole() && + mChannelType == config.getChannelType(); + } + return false; + } + + @Override + public int hashCode() { + int result = 17; + result = 31 * result + (mName != null ? mName.hashCode() : 0); + result = 31 * result + mDataType; + result = 31 * result + mRole; + result = 31 * result + mChannelType; + return result; + } + + @Override + public String toString() { + return "BluetoothHealthAppConfiguration [mName = " + mName + + ",mDataType = " + mDataType + ", mRole = " + mRole + ",mChannelType = " + + mChannelType + "]"; + } + + public int describeContents() { + return 0; + } + + /** + * Return the data type associated with this application configuration. + * + * @return dataType + */ + public int getDataType() { + return mDataType; + } + + /** + * Return the name of the application configuration. + * + * @return String name + */ + public String getName() { + return mName; + } + + /** + * Return the role associated with this application configuration. + * + * @return One of {@link BluetoothHealth#SOURCE_ROLE} or + * {@link BluetoothHealth#SINK_ROLE} + */ + public int getRole() { + return mRole; + } + + /** + * Return the channel type associated with this application configuration. + * + * @return One of {@link BluetoothHealth#CHANNEL_TYPE_RELIABLE} or + * {@link BluetoothHealth#CHANNEL_TYPE_STREAMING} or + * {@link BluetoothHealth#CHANNEL_TYPE_ANY}. + * @hide + */ + public int getChannelType() { + return mChannelType; + } + + public static final Parcelable.Creator<BluetoothHealthAppConfiguration> CREATOR = + new Parcelable.Creator<BluetoothHealthAppConfiguration>() { + @Override + public BluetoothHealthAppConfiguration createFromParcel(Parcel in) { + String name = in.readString(); + int type = in.readInt(); + int role = in.readInt(); + int channelType = in.readInt(); + return new BluetoothHealthAppConfiguration(name, type, role, + channelType); + } + + @Override + public BluetoothHealthAppConfiguration[] newArray(int size) { + return new BluetoothHealthAppConfiguration[size]; + } + }; + + public void writeToParcel(Parcel out, int flags) { + out.writeString(mName); + out.writeInt(mDataType); + out.writeInt(mRole); + out.writeInt(mChannelType); + } +} diff --git a/core/java/android/bluetooth/BluetoothHidDeviceAppQosSettings.aidl b/core/java/android/bluetooth/BluetoothHidDeviceAppQosSettings.aidl new file mode 100644 index 0000000..bc9e54f --- /dev/null +++ b/core/java/android/bluetooth/BluetoothHidDeviceAppQosSettings.aidl @@ -0,0 +1,19 @@ +/* +** Copyright 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. +** 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 android.bluetooth; + +parcelable BluetoothHealthAppConfiguration; diff --git a/core/java/android/bluetooth/BluetoothHidDeviceAppQosSettings.java b/core/java/android/bluetooth/BluetoothHidDeviceAppQosSettings.java new file mode 100644 index 0000000..15a9101 --- /dev/null +++ b/core/java/android/bluetooth/BluetoothHidDeviceAppQosSettings.java @@ -0,0 +1,165 @@ +/* + * 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. + * 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 android.bluetooth; + +import android.os.Parcel; +import android.os.Parcelable; + +/** + * The Bluetooth Health Application Configuration that is used in conjunction with + * the {@link BluetoothHealth} class. This class represents an application configuration + * that the Bluetooth Health third party application will register to communicate with the + * remote Bluetooth health device. + * + */ +public final class BluetoothHealthAppConfiguration implements Parcelable { + private final String mName; + private final int mDataType; + private final int mRole; + private final int mChannelType; + + /** + * Constructor to register the SINK role + * + * @param name Friendly name associated with the application configuration + * @param dataType Data Type of the remote Bluetooth Health device + * @hide + */ + BluetoothHealthAppConfiguration(String name, int dataType) { + mName = name; + mDataType = dataType; + mRole = BluetoothHealth.SINK_ROLE; + mChannelType = BluetoothHealth.CHANNEL_TYPE_ANY; + } + + /** + * Constructor to register the application configuration. + * + * @param name Friendly name associated with the application configuration + * @param dataType Data Type of the remote Bluetooth Health device + * @param role {@link BluetoothHealth#SOURCE_ROLE} or + * {@link BluetoothHealth#SINK_ROLE} + * @hide + */ + BluetoothHealthAppConfiguration(String name, int dataType, int role, int + channelType) { + mName = name; + mDataType = dataType; + mRole = role; + mChannelType = channelType; + } + + @Override + public boolean equals(Object o) { + if (o instanceof BluetoothHealthAppConfiguration) { + BluetoothHealthAppConfiguration config = (BluetoothHealthAppConfiguration) o; + // config.getName() can never be NULL + return mName.equals(config.getName()) && + mDataType == config.getDataType() && + mRole == config.getRole() && + mChannelType == config.getChannelType(); + } + return false; + } + + @Override + public int hashCode() { + int result = 17; + result = 31 * result + (mName != null ? mName.hashCode() : 0); + result = 31 * result + mDataType; + result = 31 * result + mRole; + result = 31 * result + mChannelType; + return result; + } + + @Override + public String toString() { + return "BluetoothHealthAppConfiguration [mName = " + mName + + ",mDataType = " + mDataType + ", mRole = " + mRole + ",mChannelType = " + + mChannelType + "]"; + } + + public int describeContents() { + return 0; + } + + /** + * Return the data type associated with this application configuration. + * + * @return dataType + */ + public int getDataType() { + return mDataType; + } + + /** + * Return the name of the application configuration. + * + * @return String name + */ + public String getName() { + return mName; + } + + /** + * Return the role associated with this application configuration. + * + * @return One of {@link BluetoothHealth#SOURCE_ROLE} or + * {@link BluetoothHealth#SINK_ROLE} + */ + public int getRole() { + return mRole; + } + + /** + * Return the channel type associated with this application configuration. + * + * @return One of {@link BluetoothHealth#CHANNEL_TYPE_RELIABLE} or + * {@link BluetoothHealth#CHANNEL_TYPE_STREAMING} or + * {@link BluetoothHealth#CHANNEL_TYPE_ANY}. + * @hide + */ + public int getChannelType() { + return mChannelType; + } + + public static final Parcelable.Creator<BluetoothHealthAppConfiguration> CREATOR = + new Parcelable.Creator<BluetoothHealthAppConfiguration>() { + @Override + public BluetoothHealthAppConfiguration createFromParcel(Parcel in) { + String name = in.readString(); + int type = in.readInt(); + int role = in.readInt(); + int channelType = in.readInt(); + return new BluetoothHealthAppConfiguration(name, type, role, + channelType); + } + + @Override + public BluetoothHealthAppConfiguration[] newArray(int size) { + return new BluetoothHealthAppConfiguration[size]; + } + }; + + public void writeToParcel(Parcel out, int flags) { + out.writeString(mName); + out.writeInt(mDataType); + out.writeInt(mRole); + out.writeInt(mChannelType); + } +} diff --git a/core/java/android/bluetooth/BluetoothHidDeviceAppSdpSettings.aidl b/core/java/android/bluetooth/BluetoothHidDeviceAppSdpSettings.aidl new file mode 100644 index 0000000..bc9e54f --- /dev/null +++ b/core/java/android/bluetooth/BluetoothHidDeviceAppSdpSettings.aidl @@ -0,0 +1,19 @@ +/* +** Copyright 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. +** 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 android.bluetooth; + +parcelable BluetoothHealthAppConfiguration; diff --git a/core/java/android/bluetooth/BluetoothHidDeviceAppSdpSettings.java b/core/java/android/bluetooth/BluetoothHidDeviceAppSdpSettings.java new file mode 100644 index 0000000..15a9101 --- /dev/null +++ b/core/java/android/bluetooth/BluetoothHidDeviceAppSdpSettings.java @@ -0,0 +1,165 @@ +/* + * 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. + * 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 android.bluetooth; + +import android.os.Parcel; +import android.os.Parcelable; + +/** + * The Bluetooth Health Application Configuration that is used in conjunction with + * the {@link BluetoothHealth} class. This class represents an application configuration + * that the Bluetooth Health third party application will register to communicate with the + * remote Bluetooth health device. + * + */ +public final class BluetoothHealthAppConfiguration implements Parcelable { + private final String mName; + private final int mDataType; + private final int mRole; + private final int mChannelType; + + /** + * Constructor to register the SINK role + * + * @param name Friendly name associated with the application configuration + * @param dataType Data Type of the remote Bluetooth Health device + * @hide + */ + BluetoothHealthAppConfiguration(String name, int dataType) { + mName = name; + mDataType = dataType; + mRole = BluetoothHealth.SINK_ROLE; + mChannelType = BluetoothHealth.CHANNEL_TYPE_ANY; + } + + /** + * Constructor to register the application configuration. + * + * @param name Friendly name associated with the application configuration + * @param dataType Data Type of the remote Bluetooth Health device + * @param role {@link BluetoothHealth#SOURCE_ROLE} or + * {@link BluetoothHealth#SINK_ROLE} + * @hide + */ + BluetoothHealthAppConfiguration(String name, int dataType, int role, int + channelType) { + mName = name; + mDataType = dataType; + mRole = role; + mChannelType = channelType; + } + + @Override + public boolean equals(Object o) { + if (o instanceof BluetoothHealthAppConfiguration) { + BluetoothHealthAppConfiguration config = (BluetoothHealthAppConfiguration) o; + // config.getName() can never be NULL + return mName.equals(config.getName()) && + mDataType == config.getDataType() && + mRole == config.getRole() && + mChannelType == config.getChannelType(); + } + return false; + } + + @Override + public int hashCode() { + int result = 17; + result = 31 * result + (mName != null ? mName.hashCode() : 0); + result = 31 * result + mDataType; + result = 31 * result + mRole; + result = 31 * result + mChannelType; + return result; + } + + @Override + public String toString() { + return "BluetoothHealthAppConfiguration [mName = " + mName + + ",mDataType = " + mDataType + ", mRole = " + mRole + ",mChannelType = " + + mChannelType + "]"; + } + + public int describeContents() { + return 0; + } + + /** + * Return the data type associated with this application configuration. + * + * @return dataType + */ + public int getDataType() { + return mDataType; + } + + /** + * Return the name of the application configuration. + * + * @return String name + */ + public String getName() { + return mName; + } + + /** + * Return the role associated with this application configuration. + * + * @return One of {@link BluetoothHealth#SOURCE_ROLE} or + * {@link BluetoothHealth#SINK_ROLE} + */ + public int getRole() { + return mRole; + } + + /** + * Return the channel type associated with this application configuration. + * + * @return One of {@link BluetoothHealth#CHANNEL_TYPE_RELIABLE} or + * {@link BluetoothHealth#CHANNEL_TYPE_STREAMING} or + * {@link BluetoothHealth#CHANNEL_TYPE_ANY}. + * @hide + */ + public int getChannelType() { + return mChannelType; + } + + public static final Parcelable.Creator<BluetoothHealthAppConfiguration> CREATOR = + new Parcelable.Creator<BluetoothHealthAppConfiguration>() { + @Override + public BluetoothHealthAppConfiguration createFromParcel(Parcel in) { + String name = in.readString(); + int type = in.readInt(); + int role = in.readInt(); + int channelType = in.readInt(); + return new BluetoothHealthAppConfiguration(name, type, role, + channelType); + } + + @Override + public BluetoothHealthAppConfiguration[] newArray(int size) { + return new BluetoothHealthAppConfiguration[size]; + } + }; + + public void writeToParcel(Parcel out, int flags) { + out.writeString(mName); + out.writeInt(mDataType); + out.writeInt(mRole); + out.writeInt(mChannelType); + } +} diff --git a/core/java/android/bluetooth/BluetoothHidDeviceCallback.java b/core/java/android/bluetooth/BluetoothHidDeviceCallback.java new file mode 100644 index 0000000..baf2ade --- /dev/null +++ b/core/java/android/bluetooth/BluetoothHidDeviceCallback.java @@ -0,0 +1,68 @@ +/* + * 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. + * 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 android.bluetooth; + +import android.os.ParcelFileDescriptor; +import android.util.Log; + +/** + * This abstract class is used to implement {@link BluetoothHealth} callbacks. + */ +public abstract class BluetoothHealthCallback { + private static final String TAG = "BluetoothHealthCallback"; + + /** + * Callback to inform change in registration state of the health + * application. + * <p> This callback is called on the binder thread (not on the UI thread) + * + * @param config Bluetooth Health app configuration + * @param status Success or failure of the registration or unregistration + * calls. Can be one of + * {@link BluetoothHealth#APP_CONFIG_REGISTRATION_SUCCESS} or + * {@link BluetoothHealth#APP_CONFIG_REGISTRATION_FAILURE} or + * {@link BluetoothHealth#APP_CONFIG_UNREGISTRATION_SUCCESS} or + * {@link BluetoothHealth#APP_CONFIG_UNREGISTRATION_FAILURE} + */ + public void onHealthAppConfigurationStatusChange(BluetoothHealthAppConfiguration config, + int status) { + Log.d(TAG, "onHealthAppConfigurationStatusChange: " + config + "Status: " + status); + } + + /** + * Callback to inform change in channel state. + * <p> Its the responsibility of the implementor of this callback to close the + * parcel file descriptor when done. This callback is called on the Binder + * thread (not the UI thread) + * + * @param config The Health app configutation + * @param device The Bluetooth Device + * @param prevState The previous state of the channel + * @param newState The new state of the channel. + * @param fd The Parcel File Descriptor when the channel state is connected. + * @param channelId The id associated with the channel. This id will be used + * in future calls like when disconnecting the channel. + */ + public void onHealthChannelStateChange(BluetoothHealthAppConfiguration config, + BluetoothDevice device, int prevState, int newState, ParcelFileDescriptor fd, + int channelId) { + Log.d(TAG, "onHealthChannelStateChange: " + config + "Device: " + device + + "prevState:" + prevState + "newState:" + newState + "ParcelFd:" + fd + + "ChannelId:" + channelId); + } +} diff --git a/core/java/android/bluetooth/IBluetoothHidDevice.aidl b/core/java/android/bluetooth/IBluetoothHidDevice.aidl new file mode 100644 index 0000000..1ebb9ca --- /dev/null +++ b/core/java/android/bluetooth/IBluetoothHidDevice.aidl @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2012 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 android.bluetooth; + +import android.bluetooth.BluetoothDevice; + +/** + * API for Bluetooth HID service + * + * {@hide} + */ +interface IBluetoothInputDevice { + // Public API + boolean connect(in BluetoothDevice device); + boolean disconnect(in BluetoothDevice device); + List<BluetoothDevice> getConnectedDevices(); + List<BluetoothDevice> getDevicesMatchingConnectionStates(in int[] states); + int getConnectionState(in BluetoothDevice device); + boolean setPriority(in BluetoothDevice device, int priority); + int getPriority(in BluetoothDevice device); + /** + * @hide + */ + boolean getProtocolMode(in BluetoothDevice device); + /** + * @hide + */ + boolean virtualUnplug(in BluetoothDevice device); + /** + * @hide + */ + boolean setProtocolMode(in BluetoothDevice device, int protocolMode); + /** + * @hide + */ + boolean getReport(in BluetoothDevice device, byte reportType, byte reportId, int bufferSize); + /** + * @hide + */ + boolean setReport(in BluetoothDevice device, byte reportType, String report); + /** + * @hide + */ + boolean sendData(in BluetoothDevice device, String report); +} diff --git a/core/java/android/bluetooth/IBluetoothHidDeviceCallback.aidl b/core/java/android/bluetooth/IBluetoothHidDeviceCallback.aidl new file mode 100644 index 0000000..0ace9fe --- /dev/null +++ b/core/java/android/bluetooth/IBluetoothHidDeviceCallback.aidl @@ -0,0 +1,32 @@ +/* + * 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. + * 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 android.bluetooth; + +import android.bluetooth.BluetoothDevice; +import android.bluetooth.BluetoothHealthAppConfiguration; +import android.os.ParcelFileDescriptor; + +/** + *@hide + */ +interface IBluetoothHealthCallback +{ + void onHealthAppConfigurationStatusChange(in BluetoothHealthAppConfiguration config, int status); + void onHealthChannelStateChange(in BluetoothHealthAppConfiguration config, + in BluetoothDevice device, int prevState, int newState, in + ParcelFileDescriptor fd, int id); +} |