Implement APIs for Bluetooth Health profile.
This first patch implements all the APIs.
The APIs wil be made public soon. The data specification
API will be submited in another patchset.
Change-Id: I2462683b7e07380e2c42474b0036b34d03b4bed1
diff --git a/Android.mk b/Android.mk
index d4d9a33..f87aaff 100644
--- a/Android.mk
+++ b/Android.mk
@@ -90,6 +90,7 @@
core/java/android/bluetooth/IBluetoothA2dp.aidl \
core/java/android/bluetooth/IBluetoothCallback.aidl \
core/java/android/bluetooth/IBluetoothHeadset.aidl \
+ core/java/android/bluetooth/IBluetoothHealthCallback.aidl \
core/java/android/bluetooth/IBluetoothPbap.aidl \
core/java/android/content/IClipboard.aidl \
core/java/android/content/IContentService.aidl \
@@ -244,6 +245,7 @@
frameworks/base/core/java/android/app/Notification.aidl \
frameworks/base/core/java/android/app/PendingIntent.aidl \
frameworks/base/core/java/android/bluetooth/BluetoothDevice.aidl \
+ frameworks/base/core/java/android/bluetooth/BluetoothHealthAppConfiguration.aidl \
frameworks/base/core/java/android/content/ComponentName.aidl \
frameworks/base/core/java/android/content/Intent.aidl \
frameworks/base/core/java/android/content/IntentSender.aidl \
diff --git a/core/java/android/bluetooth/BluetoothAdapter.java b/core/java/android/bluetooth/BluetoothAdapter.java
index a8c31f9..b993bd8 100644
--- a/core/java/android/bluetooth/BluetoothAdapter.java
+++ b/core/java/android/bluetooth/BluetoothAdapter.java
@@ -1115,6 +1115,9 @@
} else if (profile == BluetoothProfile.PAN) {
BluetoothPan pan = new BluetoothPan(context, listener);
return true;
+ } else if (profile == BluetoothProfile.HEALTH) {
+ BluetoothHealth health = new BluetoothHealth(context, listener);
+ return true;
} else {
return false;
}
diff --git a/core/java/android/bluetooth/BluetoothHealth.java b/core/java/android/bluetooth/BluetoothHealth.java
new file mode 100644
index 0000000..52efc07
--- /dev/null
+++ b/core/java/android/bluetooth/BluetoothHealth.java
@@ -0,0 +1,444 @@
+/*
+ * 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.content.Context;
+import android.os.IBinder;
+import android.os.ParcelFileDescriptor;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Public API for Bluetooth Health Profile.
+ *
+ * <p>BluetoothHealth is a proxy object for controlling the Bluetooth
+ * Service via IPC.
+ *
+ * <p> Use {@link BluetoothAdapter#getProfileProxy} to get
+ * the BluetoothHealth proxy object. Use
+ * {@link BluetoothAdapter#closeProfileProxy} to close the service connection.
+ * @hide
+ */
+public final class BluetoothHealth implements BluetoothProfile {
+ private static final String TAG = "BluetoothHealth";
+ private static final boolean DBG = false;
+
+ /**
+ * Health Profile Source Role - the health device.
+ */
+ public static final int SOURCE_ROLE = 1 << 0;
+
+ /**
+ * Health Profile Sink Role the device talking to the health device.
+ */
+ public static final int SINK_ROLE = 1 << 1;
+
+ /**
+ * Health Profile - Channel Type used - Reliable
+ */
+ public static final int CHANNEL_TYPE_RELIABLE = 10;
+
+ /**
+ * Health Profile - Channel Type used - Streaming
+ */
+ public static final int CHANNEL_TYPE_STREAMING = 11;
+
+ /**
+ * @hide
+ */
+ public static final int CHANNEL_TYPE_ANY = 12;
+
+ private final ArrayList<BluetoothHealthAppConfiguration> mAppConfigs =
+ new ArrayList<BluetoothHealthAppConfiguration>();
+
+ /**
+ * Register an application configuration that acts as a Health SINK.
+ * This is the configuration that will be used to communicate with health devices
+ * which will act as the {@link #SOURCE_ROLE}. This is an asynchronous call and so
+ * the callback is used to notify success or failure if the function returns true.
+ *
+ * <p>Requires {@link android.Manifest.permission#BLUETOOTH} permission.
+ *
+ * @param name The friendly name associated with the application or configuration.
+ * @param dataType The dataType of the Source role of Health Profile to which
+ * the sink wants to connect to.
+ * @param callback A callback to indicate success or failure of the registration and
+ * all operations done on this application configuration.
+ * @return If true, callback will be called.
+ */
+ public boolean registerSinkAppConfiguration(String name, int dataType,
+ IBluetoothHealthCallback callback) {
+ if (!isEnabled() || name == null) return false;
+
+ if (DBG) log("registerSinkApplication(" + name + ":" + dataType + ")");
+ return registerAppConfiguration(name, dataType, SINK_ROLE,
+ CHANNEL_TYPE_ANY, callback);
+ }
+
+ /**
+ * Register an application configuration that acts as a Health SINK or in a Health
+ * SOURCE role.This is an asynchronous call and so
+ * the callback is used to notify success or failure if the function returns true.
+ *
+ * <p>Requires {@link android.Manifest.permission#BLUETOOTH} permission.
+ *
+ * @param name The friendly name associated with the application or configuration.
+ * @param dataType The dataType of the Source role of Health Profile.
+ * @param channelType The channel type. Will be one of
+ * {@link #CHANNEL_TYPE_RELIABLE} or
+ * {@link #CHANNEL_TYPE_STREAMING}
+ * @param callback - A callback to indicate success or failure.
+ * @return If true, callback will be called.
+ * @hide
+ */
+ public boolean registerAppConfiguration(String name, int dataType, int role,
+ int channelType, IBluetoothHealthCallback callback) {
+ boolean result = false;
+ if (!isEnabled() || !checkAppParam(name, role, channelType, callback)) return result;
+
+ if (DBG) log("registerApplication(" + name + ":" + dataType + ")");
+ BluetoothHealthAppConfiguration config =
+ new BluetoothHealthAppConfiguration(name, dataType, role, channelType,
+ callback);
+
+ if (mService != null) {
+ try {
+ result = mService.registerAppConfiguration(config);
+ } catch (RemoteException e) {
+ Log.e(TAG, e.toString());
+ }
+ } else {
+ Log.w(TAG, "Proxy not attached to service");
+ if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable()));
+ }
+
+ if (result) mAppConfigs.add(config);
+ return result;
+ }
+
+ /**
+ * Unregister an application configuration that has been registered using
+ * {@link #registerSinkAppConfiguration}
+ *
+ * <p>Requires {@link android.Manifest.permission#BLUETOOTH} permission.
+ *
+ * @param config The health app configuration
+ * @return Success or failure.
+ * @hide
+ */
+ public boolean unregisterAppConfiguration(BluetoothHealthAppConfiguration config) {
+ boolean result = false;
+ if (mService != null && isEnabled() && isValidAppConfig(config)) {
+ try {
+ result = mService.unregisterAppConfiguration(config);
+ } catch (RemoteException e) {
+ Log.e(TAG, e.toString());
+ }
+ } else {
+ Log.w(TAG, "Proxy not attached to service");
+ if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable()));
+ }
+ if (result) mAppConfigs.remove(config);
+ return result;
+ }
+
+ /**
+ * Connect to a health device which has the {@link #SOURCE_ROLE}.
+ * This is an asynchrnous call. If this function returns true, the callback
+ * associated with the application configuration will be called.
+ *
+ * <p>Requires {@link android.Manifest.permission#BLUETOOTH} permission.
+ *
+ * @param device The remote Bluetooth device.
+ * @param config The application configuration which has been registed using
+ * {@link #registerSinkAppConfiguration(String, int, IBluetoothHealthCallback) }
+ * @return If true, the callback associated with the application config will be called.
+ */
+ public boolean connectChannelToSource(BluetoothDevice device,
+ BluetoothHealthAppConfiguration config) {
+ if (mService != null && isEnabled() && isValidDevice(device) &&
+ isValidAppConfig(config)) {
+ try {
+ return mService.connectChannelToSource(device, config);
+ } catch (RemoteException e) {
+ Log.e(TAG, e.toString());
+ }
+ } else {
+ Log.w(TAG, "Proxy not attached to service");
+ if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable()));
+ }
+ return false;
+ }
+
+ /**
+ * Connect to a health device which has the {@link #SINK_ROLE}.
+ * This is an asynchronous call. If this function returns true, the callback
+ * associated with the application configuration will be called.
+ *
+ *<p>Requires {@link android.Manifest.permission#BLUETOOTH} permission.
+ *
+ * @param device The remote Bluetooth device.
+ * @param config The application configuration which has been registed using
+ * {@link #registerSinkAppConfiguration(String, int, IBluetoothHealthCallback) }
+ * @return If true, the callback associated with the application config will be called.
+ * @hide
+ */
+ public boolean connectChannelToSink(BluetoothDevice device,
+ BluetoothHealthAppConfiguration config, int channelType) {
+ if (mService != null && isEnabled() && isValidDevice(device) &&
+ isValidAppConfig(config)) {
+ try {
+ return mService.connectChannelToSink(device, config, channelType);
+ } catch (RemoteException e) {
+ Log.e(TAG, e.toString());
+ }
+ } else {
+ Log.w(TAG, "Proxy not attached to service");
+ if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable()));
+ }
+ return false;
+ }
+
+ /**
+ * Disconnect a connected health channel.
+ * This is an asynchronous call. If this function returns true, the callback
+ * associated with the application configuration will be called.
+ *
+ *<p>Requires {@link android.Manifest.permission#BLUETOOTH} permission.
+ *
+ * @param device The remote Bluetooth device.
+ * @param config The application configuration which has been registed using
+ * {@link #registerSinkAppConfiguration(String, int, IBluetoothHealthCallback) }
+ * @param fd The file descriptor that was associated with the channel.
+ * @return If true, the callback associated with the application config will be called.
+ * @hide
+ */
+ public boolean disconnectChannel(BluetoothDevice device,
+ BluetoothHealthAppConfiguration config, ParcelFileDescriptor fd) {
+ if (mService != null && isEnabled() && isValidDevice(device) &&
+ isValidAppConfig(config)) {
+ try {
+ return mService.disconnectChannel(device, config, fd);
+ } catch (RemoteException e) {
+ Log.e(TAG, e.toString());
+ }
+ } else {
+ Log.w(TAG, "Proxy not attached to service");
+ if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable()));
+ }
+ return false;
+ }
+
+ /**
+ * Get the file descriptor of the main channel associated with the remote device
+ * and application configuration.
+ *
+ * <p>Requires {@link android.Manifest.permission#BLUETOOTH} permission.
+ *
+ * @param device The remote Bluetooth health device
+ * @param config The application configuration
+ * @return null on failure, ParcelFileDescriptor on success.
+ */
+
+ public ParcelFileDescriptor getMainChannelFd(BluetoothDevice device,
+ BluetoothHealthAppConfiguration config) {
+ if (mService != null && isEnabled() && isValidDevice(device) &&
+ isValidAppConfig(config)) {
+ try {
+ return mService.getMainChannelFd(device, config);
+ } catch (RemoteException e) {
+ Log.e(TAG, e.toString());
+ }
+ } else {
+ Log.w(TAG, "Proxy not attached to service");
+ if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable()));
+ }
+ return null;
+ }
+
+ /**
+ * Get the current connection state of the profile.
+ *
+ * <p>Requires {@link android.Manifest.permission#BLUETOOTH} permission.
+ *
+ * This is not specific to any application configuration but represents the connection
+ * state of the local Bluetooth adapter with the remote device. This can be used
+ * by applications like status bar which would just like to know the state of the
+ * local adapter.
+ *
+ * @param device Remote bluetooth device.
+ * @return State of the profile connection. One of
+ * {@link #STATE_CONNECTED}, {@link #STATE_CONNECTING},
+ * {@link #STATE_DISCONNECTED}, {@link #STATE_DISCONNECTING}
+ */
+ public int getConnectionState(BluetoothDevice device) {
+ if (mService != null && isEnabled() && isValidDevice(device)) {
+ try {
+ return mService.getHealthDeviceConnectionState(device);
+ } catch (RemoteException e) {
+ Log.e(TAG, e.toString());
+ }
+ } else {
+ Log.w(TAG, "Proxy not attached to service");
+ if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable()));
+ }
+ return STATE_DISCONNECTED;
+ }
+
+ /**
+ * Get connected devices for this specific profile.
+ *
+ * <p> Return the set of devices which are in state {@link #STATE_CONNECTED}
+ *
+ * <p>Requires {@link android.Manifest.permission#BLUETOOTH} permission.
+ *
+ * This is not specific to any application configuration but represents the connection
+ * state of the local Bluetooth adapter for this profile. This can be used
+ * by applications like status bar which would just like to know the state of the
+ * local adapter.
+ * @return List of devices. The list will be empty on error.
+ */
+ public List<BluetoothDevice> getConnectedDevices() {
+ if (mService != null && isEnabled()) {
+ try {
+ return mService.getConnectedHealthDevices();
+ } 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>();
+ }
+
+ /**
+ * Get a list of devices that match any of the given connection
+ * states.
+ *
+ * <p> If none of the devices match any of the given states,
+ * an empty list will be returned.
+ *
+ * <p>Requires {@link android.Manifest.permission#BLUETOOTH} permission.
+ * This is not specific to any application configuration but represents the connection
+ * state of the local Bluetooth adapter for this profile. This can be used
+ * by applications like status bar which would just like to know the state of the
+ * local adapter.
+ *
+ * @param states Array of states. States can be one of
+ * {@link #STATE_CONNECTED}, {@link #STATE_CONNECTING},
+ * {@link #STATE_DISCONNECTED}, {@link #STATE_DISCONNECTING},
+ * @return List of devices. The list will be empty on error.
+ */
+ public List<BluetoothDevice> getDevicesMatchingConnectionStates(int[] states) {
+ if (mService != null && isEnabled()) {
+ try {
+ return mService.getHealthDevicesMatchingConnectionStates(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>();
+ }
+
+ /** Health Channel Connection State - Disconnected */
+ public static final int STATE_CHANNEL_DISCONNECTED = 0;
+ /** Health Channel Connection State - Connecting */
+ public static final int STATE_CHANNEL_CONNECTING = 1;
+ /** Health Channel Connection State - Connected */
+ public static final int STATE_CHANNEL_CONNECTED = 2;
+ /** Health Channel Connection State - Disconnecting */
+ public static final int STATE_CHANNEL_DISCONNECTING = 3;
+
+ /** Health App Configuration registration success */
+ public static final int APPLICATION_REGISTRATION_SUCCESS = 0;
+ /** Health App Configuration registration failure */
+ public static final int APPLICATION_REGISTRATION_FAILURE = 1;
+ /** Health App Configuration un-registration success */
+ public static final int APPLICATION_UNREGISTRATION_SUCCESS = 2;
+ /** Health App Configuration un-registration failure */
+ public static final int APPLICATION_UNREGISTRATION_FAILURE = 3;
+
+ private Context mContext;
+ private ServiceListener mServiceListener;
+ private IBluetooth mService;
+ BluetoothAdapter mAdapter;
+
+ /**
+ * Create a BluetoothHealth proxy object.
+ */
+ /*package*/ BluetoothHealth(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.HEALTH, this);
+ }
+ } else {
+ Log.w(TAG, "Bluetooth Service not available!");
+
+ // Instead of throwing an exception which prevents people from going
+ // into Wireless settings in the emulator. Let it crash later when it is actually used.
+ mService = null;
+ }
+ }
+
+ private boolean isEnabled() {
+ BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
+
+ if (adapter != null && adapter.getState() == BluetoothAdapter.STATE_ON) return true;
+ log("Bluetooth is Not enabled");
+ return false;
+ }
+
+ private boolean isValidDevice(BluetoothDevice device) {
+ if (device == null) return false;
+
+ if (BluetoothAdapter.checkBluetoothAddress(device.getAddress())) return true;
+ return false;
+ }
+
+ private boolean isValidAppConfig(BluetoothHealthAppConfiguration config) {
+ if (!mAppConfigs.isEmpty() && mAppConfigs.contains(config)) return true;
+ log("Not a valid config: " + config);
+ return false;
+ }
+
+ private boolean checkAppParam(String name, int role, int channelType,
+ IBluetoothHealthCallback callback) {
+ if (name == null || (role != SOURCE_ROLE && role != SINK_ROLE) ||
+ (channelType != CHANNEL_TYPE_RELIABLE &&
+ channelType != CHANNEL_TYPE_STREAMING &&
+ channelType != CHANNEL_TYPE_ANY) || callback == null) {
+ return false;
+ }
+ if (role == SOURCE_ROLE && channelType == CHANNEL_TYPE_ANY) return false;
+ return true;
+ }
+
+ private static void log(String msg) {
+ Log.d(TAG, msg);
+ }
+}
diff --git a/core/java/android/bluetooth/BluetoothHealthAppConfiguration.aidl b/core/java/android/bluetooth/BluetoothHealthAppConfiguration.aidl
new file mode 100644
index 0000000..bc9e54f
--- /dev/null
+++ b/core/java/android/bluetooth/BluetoothHealthAppConfiguration.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/BluetoothHealthAppConfiguration.java b/core/java/android/bluetooth/BluetoothHealthAppConfiguration.java
new file mode 100644
index 0000000..b87aea5
--- /dev/null
+++ b/core/java/android/bluetooth/BluetoothHealthAppConfiguration.java
@@ -0,0 +1,180 @@
+/*
+ * 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.IBinder;
+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.
+ *
+ * @hide
+ */
+public final class BluetoothHealthAppConfiguration implements Parcelable {
+ private final String mName;
+ private final int mDataType;
+ private final int mRole;
+ private final int mChannelType;
+ private final IBluetoothHealthCallback mCallback;
+
+ /**
+ * 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
+ * @param callback Callback associated with the application configuration.
+ */
+ BluetoothHealthAppConfiguration(String name, int dataType, IBluetoothHealthCallback callback) {
+ mName = name;
+ mDataType = dataType;
+ mRole = BluetoothHealth.SINK_ROLE;
+ mChannelType = BluetoothHealth.CHANNEL_TYPE_ANY;
+ mCallback = callback;
+ }
+
+ /**
+ * 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}
+ * @param callback Callback associated with the application configuration.
+ */
+ BluetoothHealthAppConfiguration(String name, int dataType, int role, int channelType,
+ IBluetoothHealthCallback callback) {
+ mName = name;
+ mDataType = dataType;
+ mRole = role;
+ mChannelType = channelType;
+ mCallback = callback;
+ }
+
+ @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() &&
+ mCallback.equals(config.getCallback());
+ }
+ 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;
+ result = 31 * result + (mCallback != null ? mCallback.hashCode() : 0);
+ return result;
+ }
+
+ @Override
+ public String toString() {
+ return "BluetoothHealthAppConfiguration [mName = " + mName +
+ ",mDataType = " + mDataType + ", mRole = " + mRole + ",mChannelType = " +
+ mChannelType + ",callback=" + mCallback +"]";
+ }
+
+ 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}.
+ */
+ public int getChannelType() {
+ return mChannelType;
+ }
+
+ /**
+ * Return the callback associated with this application configuration.
+ *
+ * @return IBluetoothHealthCallback
+ */
+ public IBluetoothHealthCallback getCallback() {
+ return mCallback;
+ }
+
+ public static final Parcelable.Creator<BluetoothHealthAppConfiguration> CREATOR =
+ new Parcelable.Creator<BluetoothHealthAppConfiguration>() {
+ public BluetoothHealthAppConfiguration createFromParcel(Parcel in) {
+ String name = in.readString();
+ int type = in.readInt();
+ int role = in.readInt();
+ int channelType = in.readInt();
+ IBluetoothHealthCallback callback =
+ IBluetoothHealthCallback.Stub.asInterface(in.readStrongBinder());
+ return new BluetoothHealthAppConfiguration(name, type, role, channelType,
+ callback);
+ }
+ 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);
+ out.writeStrongInterface(mCallback);
+ }
+}
diff --git a/core/java/android/bluetooth/BluetoothProfile.java b/core/java/android/bluetooth/BluetoothProfile.java
index 22555f0..6cd81fd 100644
--- a/core/java/android/bluetooth/BluetoothProfile.java
+++ b/core/java/android/bluetooth/BluetoothProfile.java
@@ -65,16 +65,22 @@
public static final int A2DP = 2;
/**
+ * Health Profile
+ * @hide
+ */
+ public static final int HEALTH = 3;
+
+ /**
* Input Device Profile
* @hide
*/
- public static final int INPUT_DEVICE = 3;
+ public static final int INPUT_DEVICE = 4;
/**
* PAN Profile
* @hide
*/
- public static final int PAN = 4;
+ public static final int PAN = 5;
/**
* Default priority for devices that we try to auto-connect to and
diff --git a/core/java/android/bluetooth/IBluetooth.aidl b/core/java/android/bluetooth/IBluetooth.aidl
index d25f5d0..28b09b6 100644
--- a/core/java/android/bluetooth/IBluetooth.aidl
+++ b/core/java/android/bluetooth/IBluetooth.aidl
@@ -18,7 +18,9 @@
import android.bluetooth.IBluetoothCallback;
import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothHealthAppConfiguration;
import android.os.ParcelUuid;
+import android.os.ParcelFileDescriptor;
/**
* System private API for talking with the Bluetooth service.
@@ -98,5 +100,17 @@
boolean connectPanDevice(in BluetoothDevice device);
boolean disconnectPanDevice(in BluetoothDevice device);
+ // HDP profile APIs
+ boolean registerAppConfiguration(in BluetoothHealthAppConfiguration config);
+ boolean unregisterAppConfiguration(in BluetoothHealthAppConfiguration config);
+ boolean connectChannelToSource(in BluetoothDevice device, in BluetoothHealthAppConfiguration config);
+ boolean connectChannelToSink(in BluetoothDevice device, in BluetoothHealthAppConfiguration config,
+ int channelType);
+ boolean disconnectChannel(in BluetoothDevice device, in BluetoothHealthAppConfiguration config, in ParcelFileDescriptor fd);
+ ParcelFileDescriptor getMainChannelFd(in BluetoothDevice device, in BluetoothHealthAppConfiguration config);
+ List<BluetoothDevice> getConnectedHealthDevices();
+ List<BluetoothDevice> getHealthDevicesMatchingConnectionStates(in int[] states);
+ int getHealthDeviceConnectionState(in BluetoothDevice device);
+
void sendConnectionStateChange(in BluetoothDevice device, int state, int prevState);
}
diff --git a/core/java/android/bluetooth/IBluetoothHealthCallback.aidl b/core/java/android/bluetooth/IBluetoothHealthCallback.aidl
new file mode 100644
index 0000000..9fe5335
--- /dev/null
+++ b/core/java/android/bluetooth/IBluetoothHealthCallback.aidl
@@ -0,0 +1,31 @@
+/*
+ * 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);
+}
diff --git a/core/java/android/server/BluetoothEventLoop.java b/core/java/android/server/BluetoothEventLoop.java
index e72aaa7..a220007 100644
--- a/core/java/android/server/BluetoothEventLoop.java
+++ b/core/java/android/server/BluetoothEventLoop.java
@@ -989,6 +989,33 @@
BluetoothPan.LOCAL_NAP_ROLE);
}
+ /**
+ * Called by native code on a PropertyChanged signal from
+ * org.bluez.HealthDevice.
+ *
+ * @param devicePath the object path of the remote device
+ * @param propValues Properties (Name-Value) of the Health Device.
+ */
+ private void onHealthDevicePropertyChanged(String devicePath, String[] propValues) {
+ log("Health Device : Name of Property is: " + propValues[0] + " Value:" + propValues[1]);
+ mBluetoothService.onHealthDevicePropertyChanged(devicePath, propValues[1]);
+ }
+
+ /**
+ * Called by native code on a ChannelCreated/Deleted signal from
+ * org.bluez.HealthDevice.
+ *
+ * @param devicePath the object path of the remote device
+ * @param channelPath the path of the health channel.
+ * @param exists Boolean to indicate if the channel was created or deleted.
+ */
+ private void onHealthDeviceChannelChanged(String devicePath, String channelPath,
+ boolean exists) {
+ log("Health Device : devicePath: " + devicePath + ":channelPath:" + channelPath +
+ ":exists" + exists);
+ mBluetoothService.onHealthDeviceChannelChanged(devicePath, channelPath, exists);
+ }
+
private void onRestartRequired() {
if (mBluetoothService.isEnabled()) {
Log.e(TAG, "*** A serious error occurred (did bluetoothd crash?) - " +
diff --git a/core/java/android/server/BluetoothHealthProfileHandler.java b/core/java/android/server/BluetoothHealthProfileHandler.java
new file mode 100644
index 0000000..7f862e0
--- /dev/null
+++ b/core/java/android/server/BluetoothHealthProfileHandler.java
@@ -0,0 +1,600 @@
+/*
+ * 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.server;
+
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothHealth;
+import android.bluetooth.BluetoothHealthAppConfiguration;
+import android.bluetooth.BluetoothHealth;
+import android.bluetooth.BluetoothInputDevice;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Handler;
+import android.os.Message;
+import android.os.ParcelFileDescriptor;
+import android.os.RemoteException;
+import android.provider.Settings;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map.Entry;
+
+import java.io.FileDescriptor;
+import java.io.FileInputStream;
+import java.io.IOException;
+
+/**
+ * This handles all the operations on the Bluetooth Health profile.
+ * All functions are called by BluetoothService, as Bluetooth Service
+ * is the Service handler for the HDP profile.
+ *
+ * @hide
+ */
+final class BluetoothHealthProfileHandler {
+ private static final String TAG = "BluetoothHealthProfileHandler";
+ /*STOPSHIP*/
+ private static final boolean DBG = true;
+
+ private static BluetoothHealthProfileHandler sInstance;
+ private Context mContext;
+ private BluetoothService mBluetoothService;
+ private ArrayList<HealthChannel> mHealthChannels;
+ private HashMap <BluetoothHealthAppConfiguration, String> mHealthAppConfigs;
+ private HashMap <BluetoothDevice, Integer> mHealthDevices;
+
+ private static final int MESSAGE_REGISTER_APPLICATION = 0;
+ private static final int MESSAGE_UNREGISTER_APPLICATION = 1;
+ private static final int MESSAGE_CONNECT_CHANNEL = 2;
+
+ class HealthChannel {
+ private ParcelFileDescriptor mChannelFd;
+ private boolean mMainChannel;
+ private String mChannelPath;
+ private BluetoothDevice mDevice;
+ private BluetoothHealthAppConfiguration mConfig;
+ private int mState;
+ private int mChannelType;
+
+ HealthChannel(BluetoothDevice device, BluetoothHealthAppConfiguration config,
+ ParcelFileDescriptor fd, boolean mainChannel, String channelPath) {
+ mChannelFd = fd;
+ mMainChannel = mainChannel;
+ mChannelPath = channelPath;
+ mDevice = device;
+ mConfig = config;
+ mState = BluetoothHealth.STATE_CHANNEL_DISCONNECTED;
+ }
+ }
+
+ private final Handler mHandler = new Handler() {
+ @Override
+ public void handleMessage(Message msg) {
+ switch (msg.what) {
+ case MESSAGE_REGISTER_APPLICATION:
+ BluetoothHealthAppConfiguration registerApp =
+ (BluetoothHealthAppConfiguration) msg.obj;
+ int role = registerApp.getRole();
+ String path = null;
+
+ if (role == BluetoothHealth.SINK_ROLE) {
+ path = mBluetoothService.registerHealthApplicationNative(
+ registerApp.getDataType(), getStringRole(role), registerApp.getName());
+ } else {
+ path = mBluetoothService.registerHealthApplicationNative(
+ registerApp.getDataType(), getStringRole(role), registerApp.getName(),
+ getStringChannelType(registerApp.getChannelType()));
+ }
+
+ if (path == null) {
+ callHealthApplicationStatusCallback(registerApp,
+ BluetoothHealth.APPLICATION_REGISTRATION_FAILURE);
+ } else {
+ mHealthAppConfigs.put(registerApp, path);
+ callHealthApplicationStatusCallback(registerApp,
+ BluetoothHealth.APPLICATION_REGISTRATION_SUCCESS);
+ }
+
+ break;
+ case MESSAGE_UNREGISTER_APPLICATION:
+ BluetoothHealthAppConfiguration unregisterApp =
+ (BluetoothHealthAppConfiguration) msg.obj;
+ boolean result = mBluetoothService.unregisterHealthApplicationNative(
+ mHealthAppConfigs.get(unregisterApp));
+ if (result) {
+ callHealthApplicationStatusCallback(unregisterApp,
+ BluetoothHealth.APPLICATION_UNREGISTRATION_SUCCESS);
+ } else {
+ callHealthApplicationStatusCallback(unregisterApp,
+ BluetoothHealth.APPLICATION_UNREGISTRATION_FAILURE);
+ }
+ break;
+ case MESSAGE_CONNECT_CHANNEL:
+ HealthChannel chan = (HealthChannel)msg.obj;
+ String deviceObjectPath =
+ mBluetoothService.getObjectPathFromAddress(chan.mDevice.getAddress());
+ String configPath = mHealthAppConfigs.get(chan.mConfig);
+ String channelType = getStringChannelType(chan.mChannelType);
+
+ if (!mBluetoothService.createChannelNative(deviceObjectPath, configPath,
+ channelType)) {
+ int prevState = chan.mState;
+ int state = BluetoothHealth.STATE_CHANNEL_DISCONNECTED;
+ callHealthChannelCallback(chan.mConfig, chan.mDevice, prevState, state, null);
+ mHealthChannels.remove(chan);
+ }
+ }
+ }
+ };
+
+ private BluetoothHealthProfileHandler(Context context, BluetoothService service) {
+ mContext = context;
+ mBluetoothService = service;
+ mHealthAppConfigs = new HashMap<BluetoothHealthAppConfiguration, String>();
+ mHealthChannels = new ArrayList<HealthChannel>();
+ mHealthDevices = new HashMap<BluetoothDevice, Integer>();
+ }
+
+ static synchronized BluetoothHealthProfileHandler getInstance(Context context,
+ BluetoothService service) {
+ if (sInstance == null) sInstance = new BluetoothHealthProfileHandler(context, service);
+ return sInstance;
+ }
+
+ boolean registerAppConfiguration(BluetoothHealthAppConfiguration config) {
+ Message msg = mHandler.obtainMessage(MESSAGE_REGISTER_APPLICATION);
+ msg.obj = config;
+ mHandler.sendMessage(msg);
+ return true;
+ }
+
+ boolean unregisterAppConfiguration(BluetoothHealthAppConfiguration config) {
+ String path = mHealthAppConfigs.get(config);
+ if (path == null) return false;
+
+ Message msg = mHandler.obtainMessage(MESSAGE_UNREGISTER_APPLICATION);
+ msg.obj = config;
+ mHandler.sendMessage(msg);
+ return true;
+ }
+
+ boolean connectChannelToSource(BluetoothDevice device,
+ BluetoothHealthAppConfiguration config) {
+ return connectChannel(device, config, BluetoothHealth.CHANNEL_TYPE_ANY);
+ }
+
+ private HealthChannel getMainChannel(BluetoothDevice device,
+ BluetoothHealthAppConfiguration config) {
+ for (HealthChannel chan: mHealthChannels) {
+ if (chan.mDevice.equals(device) && chan.mConfig.equals(config)) {
+ if (chan.mMainChannel) return chan;
+ }
+ }
+ return null;
+ }
+
+ boolean connectChannel(BluetoothDevice device,
+ BluetoothHealthAppConfiguration config, int channelType) {
+ String deviceObjectPath =
+ mBluetoothService.getObjectPathFromAddress(device.getAddress());
+ if (deviceObjectPath == null) return false;
+
+ String configPath = mHealthAppConfigs.get(config);
+ if (configPath == null) return false;
+
+ HealthChannel chan = new HealthChannel(device, config, null, false, null);
+ chan.mState = BluetoothHealth.STATE_CHANNEL_CONNECTING;
+ chan.mChannelType = channelType;
+ mHealthChannels.add(chan);
+
+ int prevState = BluetoothHealth.STATE_CHANNEL_DISCONNECTED;
+ int state = BluetoothHealth.STATE_CHANNEL_CONNECTING;
+ callHealthChannelCallback(config, device, prevState, state, null);
+
+ Message msg = mHandler.obtainMessage(MESSAGE_CONNECT_CHANNEL);
+ msg.obj = chan;
+ mHandler.sendMessage(msg);
+
+ return true;
+ }
+
+ private String getStringChannelType(int type) {
+ if (type == BluetoothHealth.CHANNEL_TYPE_RELIABLE) {
+ return "Reliable";
+ } else if (type == BluetoothHealth.CHANNEL_TYPE_STREAMING) {
+ return "Streaming";
+ } else {
+ return "Any";
+ }
+ }
+
+ private String getStringRole(int role) {
+ if (role == BluetoothHealth.SINK_ROLE) {
+ return "Sink";
+ } else if (role == BluetoothHealth.SOURCE_ROLE) {
+ return "Streaming";
+ } else {
+ return null;
+ }
+ }
+
+ boolean disconnectChannel(BluetoothDevice device,
+ BluetoothHealthAppConfiguration config, ParcelFileDescriptor fd) {
+ HealthChannel chan = findChannelByFd(device, config, fd);
+ if (chan == null) return false;
+
+ String deviceObjectPath =
+ mBluetoothService.getObjectPathFromAddress(device.getAddress());
+ if (mBluetoothService.destroyChannelNative(deviceObjectPath, chan.mChannelPath)) {
+ int prevState = chan.mState;
+ chan.mState = BluetoothHealth.STATE_CHANNEL_DISCONNECTING;
+ callHealthChannelCallback(config, device, prevState, chan.mState,
+ chan.mChannelFd);
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ private HealthChannel findChannelByFd(BluetoothDevice device,
+ BluetoothHealthAppConfiguration config, ParcelFileDescriptor fd) {
+ for (HealthChannel chan : mHealthChannels) {
+ if (chan.mChannelFd.equals(fd) && chan.mDevice.equals(device) &&
+ chan.mConfig.equals(config)) return chan;
+ }
+ return null;
+ }
+
+ private HealthChannel findChannelByPath(BluetoothDevice device,
+ BluetoothHealthAppConfiguration config, String path) {
+ for (HealthChannel chan : mHealthChannels) {
+ if (chan.mChannelPath.equals(path) && chan.mDevice.equals(device) &&
+ chan.mConfig.equals(config)) return chan;
+ }
+ return null;
+ }
+
+ private List<HealthChannel> findChannelByStates(BluetoothDevice device, int[] states) {
+ List<HealthChannel> channels = new ArrayList<HealthChannel>();
+ for (HealthChannel chan: mHealthChannels) {
+ if (chan.mDevice.equals(device)) {
+ for (int state : states) {
+ if (chan.mState == state) {
+ channels.add(chan);
+ }
+ }
+ }
+ }
+ return channels;
+ }
+
+ private HealthChannel findConnectingChannel(BluetoothDevice device,
+ BluetoothHealthAppConfiguration config) {
+ for (HealthChannel chan : mHealthChannels) {
+ if (chan.mDevice.equals(device) && chan.mConfig.equals(config) &&
+ chan.mState == BluetoothHealth.STATE_CHANNEL_CONNECTING) return chan;
+ }
+ return null;
+ }
+
+ ParcelFileDescriptor getMainChannelFd(BluetoothDevice device,
+ BluetoothHealthAppConfiguration config) {
+ HealthChannel chan = getMainChannel(device, config);
+ if (chan != null) return chan.mChannelFd;
+
+ String objectPath =
+ mBluetoothService.getObjectPathFromAddress(device.getAddress());
+ if (objectPath == null) return null;
+
+ String mainChannelPath = mBluetoothService.getMainChannelNative(objectPath);
+ if (mainChannelPath == null) return null;
+
+ // We had no record of the main channel but querying Bluez we got a
+ // main channel. We might not have received the PropertyChanged yet for
+ // the main channel creation so update our data structure here.
+ chan = findChannelByPath(device, config, mainChannelPath);
+ if (chan == null) {
+ errorLog("Main Channel present but we don't have any account of it:" +
+ device +":" + config);
+ return null;
+ }
+ chan.mMainChannel = true;
+ return chan.mChannelFd;
+ }
+
+ /*package*/ void onHealthDevicePropertyChanged(String devicePath,
+ String channelPath) {
+ BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
+ String address = mBluetoothService.getAddressFromObjectPath(devicePath);
+ if (address == null) return;
+
+ //TODO: Fix this in Bluez
+ if (channelPath.equals("/")) {
+ // This means that the main channel is being destroyed.
+ return;
+ }
+
+ BluetoothDevice device = adapter.getRemoteDevice(address);
+ BluetoothHealthAppConfiguration config = findHealthApplication(device,
+ channelPath);
+ if (config != null) {
+ HealthChannel chan = findChannelByPath(device, config, channelPath);
+ if (chan == null) {
+ errorLog("Health Channel is not present:" + channelPath);
+ } else {
+ chan.mMainChannel = true;
+ }
+ }
+ }
+
+ private BluetoothHealthAppConfiguration findHealthApplication(
+ BluetoothDevice device, String channelPath) {
+ BluetoothHealthAppConfiguration config = null;
+ String configPath = mBluetoothService.getChannelApplicationNative(channelPath);
+
+ if (configPath == null) {
+ errorLog("No associated application for Health Channel:" + channelPath);
+ return null;
+ } else {
+ for (Entry<BluetoothHealthAppConfiguration, String> e :
+ mHealthAppConfigs.entrySet()) {
+ if (e.getValue().equals(configPath)) {
+ config = e.getKey();
+ }
+ }
+ if (config == null) {
+ errorLog("No associated application for application path:" + configPath);
+ return null;
+ }
+ }
+ return config;
+ }
+
+ /*package*/ void onHealthDeviceChannelChanged(String devicePath,
+ String channelPath, boolean exists) {
+ debugLog("onHealthDeviceChannelChanged: devicePath: " + devicePath +
+ "ChannelPath: " + channelPath + "Exists: " + exists);
+ BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
+ String address = mBluetoothService.getAddressFromObjectPath(devicePath);
+ if (address == null) return;
+
+ BluetoothDevice device = adapter.getRemoteDevice(address);
+
+ BluetoothHealthAppConfiguration config = findHealthApplication(device,
+ channelPath);
+ int state, prevState = BluetoothHealth.STATE_CHANNEL_DISCONNECTED;
+ ParcelFileDescriptor fd;
+ HealthChannel channel;
+
+ if (config != null) {
+ if (exists) {
+ fd = mBluetoothService.getChannelFdNative(channelPath);
+
+ if (fd == null) {
+ errorLog("Error obtaining fd for channel:" + channelPath);
+ return;
+ }
+
+ boolean mainChannel =
+ getMainChannel(device, config) == null ? false : true;
+ if (!mainChannel) {
+ String mainChannelPath =
+ mBluetoothService.getMainChannelNative(devicePath);
+ if (mainChannelPath == null) {
+ errorLog("Main Channel Path is null for devicePath:" + devicePath);
+ return;
+ }
+ if (mainChannelPath.equals(channelPath)) mainChannel = true;
+ }
+
+ channel = findConnectingChannel(device, config);
+ if (channel != null) {
+ channel.mChannelFd = fd;
+ channel.mMainChannel = mainChannel;
+ channel.mChannelPath = channelPath;
+ prevState = channel.mState;
+ } else {
+ channel = new HealthChannel(device, config, fd, mainChannel,
+ channelPath);
+ mHealthChannels.add(channel);
+ prevState = BluetoothHealth.STATE_CHANNEL_DISCONNECTED;
+ }
+ state = BluetoothHealth.STATE_CHANNEL_CONNECTED;
+ } else {
+ channel = findChannelByPath(device, config, channelPath);
+ if (channel == null) {
+ errorLog("Channel not found:" + config + ":" + channelPath);
+ return;
+ }
+
+ fd = channel.mChannelFd;
+ // CLOSE FD
+ mBluetoothService.releaseChannelFdNative(channel.mChannelPath);
+ mHealthChannels.remove(channel);
+
+ prevState = channel.mState;
+ state = BluetoothHealth.STATE_CHANNEL_DISCONNECTED;
+ }
+ channel.mState = state;
+ callHealthChannelCallback(config, device, prevState, state, fd);
+ }
+ }
+
+ private void callHealthChannelCallback(BluetoothHealthAppConfiguration config,
+ BluetoothDevice device, int prevState, int state, ParcelFileDescriptor fd) {
+ broadcastHealthDeviceStateChange(device, prevState, state);
+
+ debugLog("Health Device Callback: " + device + " State Change: "
+ + prevState + "->" + state);
+ try {
+ config.getCallback().onHealthChannelStateChange(config, device, prevState,
+ state, fd);
+ } catch (RemoteException e) {
+ errorLog("Error while making health channel state change callback: " + e);
+ }
+ }
+
+ private void callHealthApplicationStatusCallback(
+ BluetoothHealthAppConfiguration config, int status) {
+ debugLog("Health Device Application: " + config + " State Change: status:"
+ + status);
+ try {
+ config.getCallback().onHealthAppConfigurationStatusChange(config, status);
+ } catch (RemoteException e) {
+ errorLog("Error while making health app registration state change callback: " + e);
+ }
+ }
+
+ int getHealthDeviceConnectionState(BluetoothDevice device) {
+ if (mHealthDevices.get(device) == null) {
+ return BluetoothHealth.STATE_DISCONNECTED;
+ }
+ return mHealthDevices.get(device);
+ }
+
+ List<BluetoothDevice> getConnectedHealthDevices() {
+ List<BluetoothDevice> devices = lookupHealthDevicesMatchingStates(
+ new int[] {BluetoothHealth.STATE_CONNECTED});
+ return devices;
+ }
+
+ List<BluetoothDevice> getHealthDevicesMatchingConnectionStates(int[] states) {
+ List<BluetoothDevice> devices = lookupHealthDevicesMatchingStates(states);
+ return devices;
+ }
+
+ List<BluetoothDevice> lookupHealthDevicesMatchingStates(int[] states) {
+ List<BluetoothDevice> healthDevices = new ArrayList<BluetoothDevice>();
+
+ for (BluetoothDevice device: mHealthDevices.keySet()) {
+ int healthDeviceState = getHealthDeviceConnectionState(device);
+ for (int state : states) {
+ if (state == healthDeviceState) {
+ healthDevices.add(device);
+ break;
+ }
+ }
+ }
+ return healthDevices;
+ }
+
+ /**
+ * This function sends the intent for the updates on the connection status to the remote device.
+ * Note that multiple channels can be connected to the remote device by multiple applications.
+ * This sends an intent for the update to the device connection status and not the channel
+ * connection status. Only the following state transitions are possible:
+ *
+ * {@link BluetoothHealth#STATE_DISCONNECTED} to {@link BluetoothHealth#STATE_CONNECTING}
+ * {@link BluetoothHealth#STATE_CONNECTING} to {@link BluetoothHealth#STATE_CONNECTED}
+ * {@link BluetoothHealth#STATE_CONNECTED} to {@link BluetoothHealth#STATE_DISCONNECTING}
+ * {@link BluetoothHealth#STATE_DISCONNECTING} to {@link BluetoothHealth#STATE_DISCONNECTED}
+ * {@link BluetoothHealth#STATE_DISCONNECTED} to {@link BluetoothHealth#STATE_CONNECTED}
+ * {@link BluetoothHealth#STATE_CONNECTED} to {@link BluetoothHealth#STATE_DISCONNECTED}
+ * {@link BluetoothHealth#STATE_CONNECTING} to {{@link BluetoothHealth#STATE_DISCONNECTED}
+ *
+ * @param device
+ * @param prevChannelState
+ * @param newChannelState
+ * @hide
+ */
+ private void broadcastHealthDeviceStateChange(BluetoothDevice device, int prevChannelState,
+ int newChannelState) {
+ if (mHealthDevices.get(device) == null) {
+ mHealthDevices.put(device, BluetoothHealth.STATE_DISCONNECTED);
+ }
+
+ int currDeviceState = mHealthDevices.get(device);
+ int newDeviceState = convertState(newChannelState);
+
+ if (currDeviceState != newDeviceState) {
+ List<HealthChannel> chan;
+ switch (currDeviceState) {
+ case BluetoothHealth.STATE_DISCONNECTED:
+ updateAndsendIntent(device, currDeviceState, newDeviceState);
+ break;
+ case BluetoothHealth.STATE_CONNECTING:
+ // Channel got connected.
+ if (newDeviceState == BluetoothHealth.STATE_CONNECTED) {
+ updateAndsendIntent(device, currDeviceState, newDeviceState);
+ } else {
+ // Channel got disconnected
+ chan = findChannelByStates(device, new int [] {
+ BluetoothHealth.STATE_CHANNEL_CONNECTING,
+ BluetoothHealth.STATE_CHANNEL_DISCONNECTING});
+ if (chan.isEmpty()) {
+ updateAndsendIntent(device, currDeviceState, newDeviceState);
+ }
+ }
+ break;
+ case BluetoothHealth.STATE_CONNECTED:
+ // Channel got disconnected or is in disconnecting state.
+ chan = findChannelByStates(device, new int [] {
+ BluetoothHealth.STATE_CHANNEL_CONNECTING,
+ BluetoothHealth.STATE_CHANNEL_CONNECTED});
+ if (chan.isEmpty()) {
+ updateAndsendIntent(device, currDeviceState, newDeviceState);
+ }
+ case BluetoothHealth.STATE_DISCONNECTING:
+ // Channel got disconnected.
+ chan = findChannelByStates(device, new int [] {
+ BluetoothHealth.STATE_CHANNEL_CONNECTING,
+ BluetoothHealth.STATE_CHANNEL_DISCONNECTING});
+ if (chan.isEmpty()) {
+ updateAndsendIntent(device, currDeviceState, newDeviceState);
+ }
+ break;
+ }
+ }
+ }
+
+ private void updateAndsendIntent(BluetoothDevice device, int prevDeviceState,
+ int newDeviceState) {
+ mHealthDevices.put(device, newDeviceState);
+ mBluetoothService.sendConnectionStateChange(device, prevDeviceState, newDeviceState);
+ }
+
+ /**
+ * This function converts the channel connection state to device connection state.
+ *
+ * @param state
+ * @return
+ */
+ private int convertState(int state) {
+ switch (state) {
+ case BluetoothHealth.STATE_CHANNEL_CONNECTED:
+ return BluetoothHealth.STATE_CONNECTED;
+ case BluetoothHealth.STATE_CHANNEL_CONNECTING:
+ return BluetoothHealth.STATE_CONNECTING;
+ case BluetoothHealth.STATE_CHANNEL_DISCONNECTING:
+ return BluetoothHealth.STATE_DISCONNECTING;
+ case BluetoothHealth.STATE_CHANNEL_DISCONNECTED:
+ return BluetoothHealth.STATE_DISCONNECTED;
+ }
+ errorLog("Mismatch in Channel and Health Device State");
+ return -1;
+ }
+
+ private static void debugLog(String msg) {
+ if (DBG) Log.d(TAG, msg);
+ }
+
+ private static void errorLog(String msg) {
+ Log.e(TAG, msg);
+ }
+}
diff --git a/core/java/android/server/BluetoothService.java b/core/java/android/server/BluetoothService.java
index a4588ae..7f47ebc 100755
--- a/core/java/android/server/BluetoothService.java
+++ b/core/java/android/server/BluetoothService.java
@@ -31,6 +31,7 @@
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothDeviceProfileState;
import android.bluetooth.BluetoothHeadset;
+import android.bluetooth.BluetoothHealthAppConfiguration;
import android.bluetooth.BluetoothInputDevice;
import android.bluetooth.BluetoothPan;
import android.bluetooth.BluetoothProfile;
@@ -49,6 +50,7 @@
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
+import android.os.ParcelFileDescriptor;
import android.os.ParcelUuid;
import android.os.RemoteException;
import android.os.ServiceManager;
@@ -148,6 +150,7 @@
private int mAdapterConnectionState = BluetoothAdapter.STATE_DISCONNECTED;
private BluetoothPanProfileHandler mBluetoothPanProfileHandler;
private BluetoothInputProfileHandler mBluetoothInputProfileHandler;
+ private BluetoothHealthProfileHandler mBluetoothHealthProfileHandler;
private static class RemoteService {
public String address;
@@ -220,6 +223,7 @@
mContext.registerReceiver(mReceiver, filter);
mBluetoothInputProfileHandler = BluetoothInputProfileHandler.getInstance(mContext, this);
mBluetoothPanProfileHandler = BluetoothPanProfileHandler.getInstance(mContext, this);
+ mBluetoothHealthProfileHandler = BluetoothHealthProfileHandler.getInstance(mContext, this);
}
public static synchronized String readDockBluetoothAddress() {
@@ -2077,6 +2081,106 @@
}
}
+ /**** Handlers for Health Device Profile ****/
+ // TODO: All these need to be converted to a state machine.
+
+ public boolean registerAppConfiguration(BluetoothHealthAppConfiguration config) {
+ mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM,
+ "Need BLUETOOTH permission");
+ synchronized (mBluetoothHealthProfileHandler) {
+ return mBluetoothHealthProfileHandler.registerAppConfiguration(config);
+ }
+ }
+
+ public boolean unregisterAppConfiguration(BluetoothHealthAppConfiguration config) {
+ mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM,
+ "Need BLUETOOTH permission");
+ synchronized (mBluetoothHealthProfileHandler) {
+ return mBluetoothHealthProfileHandler.unregisterAppConfiguration(config);
+ }
+ }
+
+
+ public boolean connectChannelToSource(BluetoothDevice device,
+ BluetoothHealthAppConfiguration config) {
+ mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM,
+ "Need BLUETOOTH permission");
+ synchronized (mBluetoothHealthProfileHandler) {
+ return mBluetoothHealthProfileHandler.connectChannelToSource(device,
+ config);
+ }
+ }
+
+ public boolean connectChannelToSink(BluetoothDevice device,
+ BluetoothHealthAppConfiguration config, int channelType) {
+ mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM,
+ "Need BLUETOOTH permission");
+ synchronized (mBluetoothHealthProfileHandler) {
+ return mBluetoothHealthProfileHandler.connectChannel(device, config,
+ channelType);
+ }
+ }
+
+ public boolean disconnectChannel(BluetoothDevice device,
+ BluetoothHealthAppConfiguration config, ParcelFileDescriptor fd) {
+ mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM,
+ "Need BLUETOOTH permission");
+ synchronized (mBluetoothHealthProfileHandler) {
+ return mBluetoothHealthProfileHandler.disconnectChannel(device, config, fd);
+ }
+ }
+
+ public ParcelFileDescriptor getMainChannelFd(BluetoothDevice device,
+ BluetoothHealthAppConfiguration config) {
+ mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM,
+ "Need BLUETOOTH permission");
+ synchronized (mBluetoothHealthProfileHandler) {
+ return mBluetoothHealthProfileHandler.getMainChannelFd(device, config);
+ }
+ }
+
+ /*package*/ void onHealthDevicePropertyChanged(String devicePath,
+ String channelPath) {
+ synchronized (mBluetoothHealthProfileHandler) {
+ mBluetoothHealthProfileHandler.onHealthDevicePropertyChanged(devicePath,
+ channelPath);
+ }
+ }
+
+ /*package*/ void onHealthDeviceChannelChanged(String devicePath,
+ String channelPath, boolean exists) {
+ synchronized(mBluetoothHealthProfileHandler) {
+ mBluetoothHealthProfileHandler.onHealthDeviceChannelChanged(devicePath,
+ channelPath, exists);
+ }
+ }
+
+ public int getHealthDeviceConnectionState(BluetoothDevice device) {
+ mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM,
+ "Need BLUETOOTH permission");
+ synchronized (mBluetoothHealthProfileHandler) {
+ return mBluetoothHealthProfileHandler.getHealthDeviceConnectionState(device);
+ }
+ }
+
+ public List<BluetoothDevice> getConnectedHealthDevices() {
+ mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM,
+ "Need BLUETOOTH permission");
+ synchronized (mBluetoothHealthProfileHandler) {
+ return mBluetoothHealthProfileHandler.getConnectedHealthDevices();
+ }
+ }
+
+ public List<BluetoothDevice> getHealthDevicesMatchingConnectionStates(
+ int[] states) {
+ mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM,
+ "Need BLUETOOTH permission");
+ synchronized (mBluetoothHealthProfileHandler) {
+ return mBluetoothHealthProfileHandler.
+ getHealthDevicesMatchingConnectionStates(states);
+ }
+ }
+
public boolean connectHeadset(String address) {
if (getBondState(address) != BluetoothDevice.BOND_BONDED) return false;
@@ -2375,4 +2479,16 @@
private native int[] addReservedServiceRecordsNative(int[] uuuids);
private native boolean removeReservedServiceRecordsNative(int[] handles);
+
+ // Health API
+ native String registerHealthApplicationNative(int dataType, String role, String name,
+ String channelType);
+ native String registerHealthApplicationNative(int dataType, String role, String name);
+ native boolean unregisterHealthApplicationNative(String path);
+ native boolean createChannelNative(String devicePath, String appPath, String channelType);
+ native boolean destroyChannelNative(String devicePath, String channelpath);
+ native String getMainChannelNative(String path);
+ native String getChannelApplicationNative(String channelPath);
+ native ParcelFileDescriptor getChannelFdNative(String channelPath);
+ native boolean releaseChannelFdNative(String channelPath);
}
diff --git a/core/jni/android_bluetooth_common.cpp b/core/jni/android_bluetooth_common.cpp
index 6ae3e35..5c6f5e8 100644
--- a/core/jni/android_bluetooth_common.cpp
+++ b/core/jni/android_bluetooth_common.cpp
@@ -81,6 +81,16 @@
{"UUID", DBUS_TYPE_STRING},
};
+static Properties health_device_properties[] = {
+ {"MainChannel", DBUS_TYPE_OBJECT_PATH},
+};
+
+static Properties health_channel_properties[] = {
+ {"Type", DBUS_TYPE_STRING},
+ {"Device", DBUS_TYPE_OBJECT_PATH},
+ {"Application", DBUS_TYPE_OBJECT_PATH},
+};
+
typedef union {
char *str_val;
int int_val;
@@ -315,6 +325,22 @@
return ret;
}
+jint dbus_returns_unixfd(JNIEnv *env, DBusMessage *reply) {
+
+ DBusError err;
+ jint ret = -1;
+
+ dbus_error_init(&err);
+ if (!dbus_message_get_args(reply, &err,
+ DBUS_TYPE_UNIX_FD, &ret,
+ DBUS_TYPE_INVALID)) {
+ LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, reply);
+ }
+ dbus_message_unref(reply);
+ return ret;
+}
+
+
jint dbus_returns_int32(JNIEnv *env, DBusMessage *reply) {
DBusError err;
@@ -486,6 +512,55 @@
dbus_message_iter_close_container(iter, &value_iter);
}
+static void dict_append_entry(DBusMessageIter *dict,
+ const char *key, int type, void *val)
+{
+ DBusMessageIter dict_entry;
+ dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
+ NULL, &dict_entry);
+
+ dbus_message_iter_append_basic(&dict_entry, DBUS_TYPE_STRING, &key);
+ append_variant(&dict_entry, type, val);
+ dbus_message_iter_close_container(dict, &dict_entry);
+}
+
+static void append_dict_valist(DBusMessageIter *iterator, const char *first_key,
+ va_list var_args)
+{
+ DBusMessageIter dict;
+ int val_type;
+ const char *val_key;
+ void *val;
+
+ dbus_message_iter_open_container(iterator, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
+
+ val_key = first_key;
+ while (val_key) {
+ val_type = va_arg(var_args, int);
+ val = va_arg(var_args, void *);
+ dict_append_entry(&dict, val_key, val_type, val);
+ val_key = va_arg(var_args, char *);
+ }
+
+ dbus_message_iter_close_container(iterator, &dict);
+}
+
+void append_dict_args(DBusMessage *reply, const char *first_key, ...)
+{
+ DBusMessageIter iter;
+ va_list var_args;
+
+ dbus_message_iter_init_append(reply, &iter);
+
+ va_start(var_args, first_key);
+ append_dict_valist(&iter, first_key, var_args);
+ va_end(var_args);
+}
+
+
int get_property(DBusMessageIter iter, Properties *properties,
int max_num_properties, int *prop_index, property_value *value, int *len) {
DBusMessageIter prop_val, array_val_iter;
@@ -737,6 +812,21 @@
sizeof(input_properties) / sizeof(Properties));
}
+jobjectArray parse_health_device_properties(JNIEnv *env, DBusMessageIter *iter) {
+ return parse_properties(env, iter, (Properties *) &health_device_properties,
+ sizeof(health_device_properties) / sizeof(Properties));
+}
+
+jobjectArray parse_health_device_property_change(JNIEnv *env, DBusMessage *msg) {
+ return parse_property_change(env, msg, (Properties *) &health_device_properties,
+ sizeof(health_device_properties) / sizeof(Properties));
+}
+
+jobjectArray parse_health_channel_properties(JNIEnv *env, DBusMessageIter *iter) {
+ return parse_properties(env, iter, (Properties *) &health_channel_properties,
+ sizeof(health_channel_properties) / sizeof(Properties));
+}
+
int get_bdaddr(const char *str, bdaddr_t *ba) {
char *d = ((char *)ba) + 5, *endp;
int i;
diff --git a/core/jni/android_bluetooth_common.h b/core/jni/android_bluetooth_common.h
index 3364703..2f5fd5a 100644
--- a/core/jni/android_bluetooth_common.h
+++ b/core/jni/android_bluetooth_common.h
@@ -149,6 +149,7 @@
jint dbus_returns_int32(JNIEnv *env, DBusMessage *reply);
jint dbus_returns_uint32(JNIEnv *env, DBusMessage *reply);
+jint dbus_returns_unixfd(JNIEnv *env, DBusMessage *reply);
jstring dbus_returns_string(JNIEnv *env, DBusMessage *reply);
jboolean dbus_returns_boolean(JNIEnv *env, DBusMessage *reply);
jobjectArray dbus_returns_array_of_strings(JNIEnv *env, DBusMessage *reply);
@@ -164,8 +165,13 @@
jobjectArray parse_remote_device_property_change(JNIEnv *env, DBusMessage *msg);
jobjectArray parse_adapter_property_change(JNIEnv *env, DBusMessage *msg);
jobjectArray parse_input_properties(JNIEnv *env, DBusMessageIter *iter);
+jobjectArray parse_health_device_properties(JNIEnv *env, DBusMessageIter *iter);
+jobjectArray parse_health_channel_properties(JNIEnv *env, DBusMessageIter *iter);
jobjectArray parse_input_property_change(JNIEnv *env, DBusMessage *msg);
jobjectArray parse_pan_property_change(JNIEnv *env, DBusMessage *msg);
+jobjectArray parse_health_device_property_change(JNIEnv *env, DBusMessage *msg);
+
+void append_dict_args(DBusMessage *reply, const char *first_key, ...);
void append_variant(DBusMessageIter *iter, int type, void *val);
int get_bdaddr(const char *str, bdaddr_t *ba);
void get_bdaddr_as_string(const bdaddr_t *ba, char *str);
diff --git a/core/jni/android_server_BluetoothEventLoop.cpp b/core/jni/android_server_BluetoothEventLoop.cpp
index 59b97c2..fb25486 100644
--- a/core/jni/android_server_BluetoothEventLoop.cpp
+++ b/core/jni/android_server_BluetoothEventLoop.cpp
@@ -72,6 +72,8 @@
static jmethodID method_onInputDeviceConnectionResult;
static jmethodID method_onPanDevicePropertyChanged;
static jmethodID method_onPanDeviceConnectionResult;
+static jmethodID method_onHealthDevicePropertyChanged;
+static jmethodID method_onHealthDeviceChannelChanged;
typedef event_loop_native_data_t native_data_t;
@@ -139,6 +141,10 @@
"(Ljava/lang/String;[Ljava/lang/String;)V");
method_onPanDeviceConnectionResult = env->GetMethodID(clazz, "onPanDeviceConnectionResult",
"(Ljava/lang/String;I)V");
+ method_onHealthDevicePropertyChanged = env->GetMethodID(clazz, "onHealthDevicePropertyChanged",
+ "(Ljava/lang/String;[Ljava/lang/String;)V");
+ method_onHealthDeviceChannelChanged = env->GetMethodID(clazz, "onHealthDeviceChannelChanged",
+ "(Ljava/lang/String;Ljava/lang/String;Z)V");
method_onRequestOobData = env->GetMethodID(clazz, "onRequestOobData",
"(Ljava/lang/String;I)V");
@@ -271,6 +277,15 @@
LOG_AND_FREE_DBUS_ERROR(&err);
return JNI_FALSE;
}
+
+ dbus_bus_add_match(nat->conn,
+ "type='signal',interface='"BLUEZ_DBUS_BASE_IFC".HealthDevice'",
+ &err);
+ if (dbus_error_is_set(&err)) {
+ LOG_AND_FREE_DBUS_ERROR(&err);
+ return JNI_FALSE;
+ }
+
dbus_bus_add_match(nat->conn,
"type='signal',interface='org.bluez.AudioSink'",
&err);
@@ -459,6 +474,12 @@
LOG_AND_FREE_DBUS_ERROR(&err);
}
dbus_bus_remove_match(nat->conn,
+ "type='signal',interface='"BLUEZ_DBUS_BASE_IFC".HealthDevice'",
+ &err);
+ if (dbus_error_is_set(&err)) {
+ LOG_AND_FREE_DBUS_ERROR(&err);
+ }
+ dbus_bus_remove_match(nat->conn,
"type='signal',interface='org.bluez.audio.Manager'",
&err);
if (dbus_error_is_set(&err)) {
@@ -985,6 +1006,58 @@
LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
}
goto success;
+ } else if (dbus_message_is_signal(msg,
+ "org.bluez.HealthDevice",
+ "ChannelConnected")) {
+ const char *c_path = dbus_message_get_path(msg);
+ const char *c_channel_path;
+ jboolean exists = JNI_TRUE;
+ if (dbus_message_get_args(msg, &err,
+ DBUS_TYPE_OBJECT_PATH, &c_channel_path,
+ DBUS_TYPE_INVALID)) {
+ env->CallVoidMethod(nat->me,
+ method_onHealthDeviceChannelChanged,
+ env->NewStringUTF(c_path),
+ env->NewStringUTF(c_channel_path),
+ exists);
+ } else {
+ LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
+ }
+ goto success;
+ } else if (dbus_message_is_signal(msg,
+ "org.bluez.NetworkServer",
+ "ChannelDeleted")) {
+
+ const char *c_path = dbus_message_get_path(msg);
+ const char *c_channel_path;
+ jboolean exists = JNI_FALSE;
+ if (dbus_message_get_args(msg, &err,
+ DBUS_TYPE_OBJECT_PATH, &c_channel_path,
+ DBUS_TYPE_INVALID)) {
+ env->CallVoidMethod(nat->me,
+ method_onHealthDeviceChannelChanged,
+ env->NewStringUTF(c_path),
+ env->NewStringUTF(c_channel_path),
+ exists);
+ } else {
+ LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
+ }
+ goto success;
+ } else if (dbus_message_is_signal(msg,
+ "org.bluez.HealthDevice",
+ "PropertyChanged")) {
+ jobjectArray str_array =
+ parse_health_device_property_change(env, msg);
+ if (str_array != NULL) {
+ const char *c_path = dbus_message_get_path(msg);
+ env->CallVoidMethod(nat->me,
+ method_onHealthDevicePropertyChanged,
+ env->NewStringUTF(c_path),
+ str_array);
+ } else {
+ LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
+ }
+ goto success;
}
ret = a2dp_event_filter(msg, env);
diff --git a/core/jni/android_server_BluetoothService.cpp b/core/jni/android_server_BluetoothService.cpp
index ac75634..036c34c 100644
--- a/core/jni/android_server_BluetoothService.cpp
+++ b/core/jni/android_server_BluetoothService.cpp
@@ -19,12 +19,16 @@
#define DBUS_INPUT_IFACE BLUEZ_DBUS_BASE_IFC ".Input"
#define DBUS_NETWORK_IFACE BLUEZ_DBUS_BASE_IFC ".Network"
#define DBUS_NETWORKSERVER_IFACE BLUEZ_DBUS_BASE_IFC ".NetworkServer"
-
+#define DBUS_HEALTH_MANAGER_PATH "/org/bluez"
+#define DBUS_HEALTH_MANAGER_IFACE BLUEZ_DBUS_BASE_IFC ".HealthManager"
+#define DBUS_HEALTH_DEVICE_IFACE BLUEZ_DBUS_BASE_IFC ".HealthDevice"
+#define DBUS_HEALTH_CHANNEL_IFACE BLUEZ_DBUS_BASE_IFC ".HealthChannel"
#define LOG_TAG "BluetoothService.cpp"
#include "android_bluetooth_common.h"
#include "android_runtime/AndroidRuntime.h"
+#include "android_util_Binder.h"
#include "JNIHelp.h"
#include "jni.h"
#include "utils/Log.h"
@@ -1255,6 +1259,400 @@
return JNI_FALSE;
}
+static jstring registerHealthApplicationNative(JNIEnv *env, jobject object,
+ jint dataType, jstring role,
+ jstring name, jstring channelType) {
+ LOGV("%s", __FUNCTION__);
+ jstring path = NULL;
+#ifdef HAVE_BLUETOOTH
+ native_data_t *nat = get_native_data(env, object);
+ if (nat) {
+ const char *c_role = env->GetStringUTFChars(role, NULL);
+ const char *c_name = env->GetStringUTFChars(name, NULL);
+ const char *c_channel_type = env->GetStringUTFChars(channelType, NULL);
+ char *c_path;
+ DBusMessage *msg, *reply;
+ DBusError err;
+ dbus_error_init(&err);
+
+ msg = dbus_message_new_method_call(BLUEZ_DBUS_BASE_IFC,
+ DBUS_HEALTH_MANAGER_PATH,
+ DBUS_HEALTH_MANAGER_IFACE,
+ "CreateApplication");
+
+ if (msg == NULL) {
+ LOGE("Could not allocate D-Bus message object!");
+ return NULL;
+ }
+
+ /* append arguments */
+ append_dict_args(msg,
+ "DataType", DBUS_TYPE_UINT16, &dataType,
+ "Role", DBUS_TYPE_STRING, &c_role,
+ "Description", DBUS_TYPE_STRING, &c_name,
+ "ChannelType", DBUS_TYPE_STRING, &c_channel_type,
+ DBUS_TYPE_INVALID);
+
+
+ /* Make the call. */
+ reply = dbus_connection_send_with_reply_and_block(nat->conn, msg, -1, &err);
+
+ env->ReleaseStringUTFChars(role, c_role);
+ env->ReleaseStringUTFChars(name, c_name);
+ env->ReleaseStringUTFChars(channelType, c_channel_type);
+
+ if (!reply) {
+ if (dbus_error_is_set(&err)) {
+ LOG_AND_FREE_DBUS_ERROR(&err);
+ }
+ } else {
+ if (!dbus_message_get_args(reply, &err,
+ DBUS_TYPE_OBJECT_PATH, &c_path,
+ DBUS_TYPE_INVALID)) {
+ if (dbus_error_is_set(&err)) {
+ LOG_AND_FREE_DBUS_ERROR(&err);
+ }
+ } else {
+ path = env->NewStringUTF(c_path);
+ }
+ dbus_message_unref(reply);
+ }
+ }
+#endif
+ return path;
+}
+
+static jstring registerSinkHealthApplicationNative(JNIEnv *env, jobject object,
+ jint dataType, jstring role,
+ jstring name) {
+ LOGV("%s", __FUNCTION__);
+ jstring path = NULL;
+#ifdef HAVE_BLUETOOTH
+ native_data_t *nat = get_native_data(env, object);
+ if (nat) {
+ const char *c_role = env->GetStringUTFChars(role, NULL);
+ const char *c_name = env->GetStringUTFChars(name, NULL);
+ char *c_path;
+
+ DBusMessage *msg, *reply;
+ DBusError err;
+ dbus_error_init(&err);
+
+ msg = dbus_message_new_method_call(BLUEZ_DBUS_BASE_IFC,
+ DBUS_HEALTH_MANAGER_PATH,
+ DBUS_HEALTH_MANAGER_IFACE,
+ "CreateApplication");
+
+ if (msg == NULL) {
+ LOGE("Could not allocate D-Bus message object!");
+ return NULL;
+ }
+
+ /* append arguments */
+ append_dict_args(msg,
+ "DataType", DBUS_TYPE_UINT16, &dataType,
+ "Role", DBUS_TYPE_STRING, &c_role,
+ "Description", DBUS_TYPE_STRING, &c_name,
+ DBUS_TYPE_INVALID);
+
+
+ /* Make the call. */
+ reply = dbus_connection_send_with_reply_and_block(nat->conn, msg, -1, &err);
+
+ env->ReleaseStringUTFChars(role, c_role);
+ env->ReleaseStringUTFChars(name, c_name);
+
+ if (!reply) {
+ if (dbus_error_is_set(&err)) {
+ LOG_AND_FREE_DBUS_ERROR(&err);
+ }
+ } else {
+ LOGE("--_Call made getting the patch...");
+ if (!dbus_message_get_args(reply, &err,
+ DBUS_TYPE_OBJECT_PATH, &c_path,
+ DBUS_TYPE_INVALID)) {
+ if (dbus_error_is_set(&err)) {
+ LOG_AND_FREE_DBUS_ERROR(&err);
+ }
+ } else {
+ path = env->NewStringUTF(c_path);
+ LOGE("----Path is %s", c_path);
+ }
+ dbus_message_unref(reply);
+ }
+ }
+#endif
+ return path;
+}
+
+static jboolean unregisterHealthApplicationNative(JNIEnv *env, jobject object,
+ jstring path) {
+ LOGV("%s", __FUNCTION__);
+ jboolean result = JNI_FALSE;
+#ifdef HAVE_BLUETOOTH
+ native_data_t *nat = get_native_data(env, object);
+ if (nat) {
+ const char *c_path = env->GetStringUTFChars(path, NULL);
+ DBusError err;
+ dbus_error_init(&err);
+ DBusMessage *reply =
+ dbus_func_args_timeout(env, nat->conn, -1,
+ DBUS_HEALTH_MANAGER_PATH,
+ DBUS_HEALTH_MANAGER_IFACE, "DestroyApplication",
+ DBUS_TYPE_OBJECT_PATH, &c_path,
+ DBUS_TYPE_INVALID);
+
+ env->ReleaseStringUTFChars(path, c_path);
+
+ if (!reply) {
+ if (dbus_error_is_set(&err)) {
+ LOG_AND_FREE_DBUS_ERROR(&err);
+ }
+ } else {
+ result = JNI_TRUE;
+ }
+ }
+#endif
+ return result;
+}
+
+static jboolean createChannelNative(JNIEnv *env, jobject object,
+ jstring devicePath, jstring appPath, jstring config) {
+ LOGV("%s", __FUNCTION__);
+ jboolean result = JNI_FALSE;
+#ifdef HAVE_BLUETOOTH
+ native_data_t *nat = get_native_data(env, object);
+
+ if (nat) {
+ DBusError err;
+ dbus_error_init(&err);
+
+ const char *c_device_path = env->GetStringUTFChars(devicePath, NULL);
+ const char *c_app_path = env->GetStringUTFChars(appPath, NULL);
+ const char *c_config = env->GetStringUTFChars(config, NULL);
+ LOGE("Params...%s, %s, %s \n", c_device_path, c_app_path, c_config);
+
+ DBusMessage *reply = dbus_func_args(env, nat->conn,
+ c_device_path,
+ DBUS_HEALTH_DEVICE_IFACE,
+ "CreateChannel",
+ DBUS_TYPE_OBJECT_PATH, &c_app_path,
+ DBUS_TYPE_STRING, &c_config,
+ DBUS_TYPE_INVALID);
+
+
+ env->ReleaseStringUTFChars(devicePath, c_device_path);
+ env->ReleaseStringUTFChars(appPath, c_app_path);
+ env->ReleaseStringUTFChars(config, c_config);
+
+ if (!reply) {
+ if (dbus_error_is_set(&err)) {
+ LOG_AND_FREE_DBUS_ERROR(&err);
+ }
+ } else {
+ result = JNI_TRUE;
+ }
+ }
+#endif
+ return result;
+}
+
+static jboolean destroyChannelNative(JNIEnv *env, jobject object, jstring devicePath,
+ jstring channelPath) {
+ LOGE("%s", __FUNCTION__);
+ jboolean result = JNI_FALSE;
+#ifdef HAVE_BLUETOOTH
+ native_data_t *nat = get_native_data(env, object);
+
+ if (nat) {
+ DBusError err;
+ dbus_error_init(&err);
+
+ const char *c_device_path = env->GetStringUTFChars(devicePath, NULL);
+ const char *c_channel_path = env->GetStringUTFChars(channelPath, NULL);
+
+ DBusMessage *reply = dbus_func_args(env, nat->conn,
+ c_device_path,
+ DBUS_HEALTH_DEVICE_IFACE,
+ "DestroyChannel",
+ DBUS_TYPE_OBJECT_PATH, &c_channel_path,
+ DBUS_TYPE_INVALID);
+
+ env->ReleaseStringUTFChars(devicePath, c_device_path);
+ env->ReleaseStringUTFChars(channelPath, c_channel_path);
+
+ if (!reply) {
+ if (dbus_error_is_set(&err)) {
+ LOG_AND_FREE_DBUS_ERROR(&err);
+ }
+ } else {
+ result = JNI_TRUE;
+ }
+ }
+#endif
+ return result;
+}
+
+static jstring getMainChannelNative(JNIEnv *env, jobject object, jstring devicePath) {
+ LOGE("%s", __FUNCTION__);
+#ifdef HAVE_BLUETOOTH
+ native_data_t *nat = get_native_data(env, object);
+ if (nat) {
+ const char *c_device_path = env->GetStringUTFChars(devicePath, NULL);
+ DBusError err;
+ dbus_error_init(&err);
+
+ LOGE("---Args %s", c_device_path);
+ DBusMessage *reply = dbus_func_args(env, nat->conn,
+ c_device_path,
+ DBUS_HEALTH_DEVICE_IFACE, "GetProperties",
+ DBUS_TYPE_INVALID);
+ env->ReleaseStringUTFChars(devicePath, c_device_path);
+
+ if (!reply) {
+ if (dbus_error_is_set(&err)) {
+ LOG_AND_FREE_DBUS_ERROR(&err);
+ }
+ } else {
+ DBusMessageIter iter;
+ jobjectArray str_array = NULL;
+ if (dbus_message_iter_init(reply, &iter))
+ str_array = parse_health_device_properties(env, &iter);
+ dbus_message_unref(reply);
+ jstring path = (jstring) env->GetObjectArrayElement(str_array, 1);
+
+ return path;
+ }
+ }
+#endif
+ return NULL;
+}
+
+static jstring getChannelApplicationNative(JNIEnv *env, jobject object, jstring channelPath) {
+ LOGE("%s", __FUNCTION__);
+#ifdef HAVE_BLUETOOTH
+ native_data_t *nat = get_native_data(env, object);
+ if (nat) {
+ const char *c_channel_path = env->GetStringUTFChars(channelPath, NULL);
+ DBusError err;
+ dbus_error_init(&err);
+
+ LOGE("---Args %s", c_channel_path);
+
+ DBusMessage *reply = dbus_func_args(env, nat->conn,
+ c_channel_path,
+ DBUS_HEALTH_CHANNEL_IFACE, "GetProperties",
+ DBUS_TYPE_INVALID);
+ env->ReleaseStringUTFChars(channelPath, c_channel_path);
+
+ if (!reply) {
+ if (dbus_error_is_set(&err)) {
+ LOG_AND_FREE_DBUS_ERROR(&err);
+ }
+ } else {
+ DBusMessageIter iter;
+ jobjectArray str_array = NULL;
+ if (dbus_message_iter_init(reply, &iter))
+ str_array = parse_health_channel_properties(env, &iter);
+ dbus_message_unref(reply);
+
+ jint len = env->GetArrayLength(str_array);
+
+ jstring name, path;
+ const char *c_name;
+
+ for (int i = 0; i < len; i+=2) {
+ name = (jstring) env->GetObjectArrayElement(str_array, i);
+ c_name = env->GetStringUTFChars(name, NULL);
+
+ if (!strcmp(c_name, "Application")) {
+ path = (jstring) env->GetObjectArrayElement(str_array, i+1);
+ LOGE("----Path is %s", env->GetStringUTFChars(path, NULL));
+ env->ReleaseStringUTFChars(name, c_name);
+ return path;
+ }
+ env->ReleaseStringUTFChars(name, c_name);
+ }
+ }
+ }
+#endif
+ return NULL;
+}
+
+static jboolean releaseChannelFdNative(JNIEnv *env, jobject object, jstring channelPath) {
+ LOGV("%s", __FUNCTION__);
+#ifdef HAVE_BLUETOOTH
+ native_data_t *nat = get_native_data(env, object);
+ if (nat) {
+ const char *c_channel_path = env->GetStringUTFChars(channelPath, NULL);
+ DBusError err;
+ dbus_error_init(&err);
+
+ DBusMessage *reply = dbus_func_args(env, nat->conn,
+ c_channel_path,
+ DBUS_HEALTH_CHANNEL_IFACE, "Release",
+ DBUS_TYPE_INVALID);
+ env->ReleaseStringUTFChars(channelPath, c_channel_path);
+
+ return reply ? JNI_TRUE : JNI_FALSE;
+ }
+#endif
+ return JNI_FALSE;
+}
+
+static jobject getChannelFdNative(JNIEnv *env, jobject object, jstring channelPath) {
+ LOGV("%s", __FUNCTION__);
+#ifdef HAVE_BLUETOOTH
+ native_data_t *nat = get_native_data(env, object);
+ if (nat) {
+ const char *c_channel_path = env->GetStringUTFChars(channelPath, NULL);
+ int32_t fd;
+ DBusError err;
+ dbus_error_init(&err);
+
+ DBusMessage *reply = dbus_func_args(env, nat->conn,
+ c_channel_path,
+ DBUS_HEALTH_CHANNEL_IFACE, "Acquire",
+ DBUS_TYPE_INVALID);
+ env->ReleaseStringUTFChars(channelPath, c_channel_path);
+
+ if (!reply) {
+ if (dbus_error_is_set(&err)) {
+ LOG_AND_FREE_DBUS_ERROR(&err);
+ }
+ return NULL;
+ }
+
+ fd = dbus_returns_unixfd(env, reply);
+ if (fd == -1) return NULL;
+
+ LOGE("---got fd %d\n", fd);
+ // Create FileDescriptor object
+ jobject fileDesc = jniCreateFileDescriptor(env, fd);
+ if (fileDesc == NULL) {
+ // FileDescriptor constructor has thrown an exception
+ releaseChannelFdNative(env, object, channelPath);
+ LOGE("---File Desc is null");
+ return NULL;
+ }
+
+ // Wrap it in a ParcelFileDescriptor
+ jobject parcelFileDesc = newParcelFileDescriptor(env, fileDesc);
+ if (parcelFileDesc == NULL) {
+ // ParcelFileDescriptor constructor has thrown an exception
+ releaseChannelFdNative(env, object, channelPath);
+ LOGE("---Parcel File Desc is null");
+ return NULL;
+ }
+
+ return parcelFileDesc;
+ }
+#endif
+ return NULL;
+}
+
+
+
static JNINativeMethod sMethods[] = {
/* name, signature, funcPtr */
{"classInitNative", "()V", (void*)classInitNative},
@@ -1317,6 +1715,24 @@
{"disconnectPanDeviceNative", "(Ljava/lang/String;)Z", (void *)disconnectPanDeviceNative},
{"disconnectPanServerDeviceNative", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Z",
(void *)disconnectPanServerDeviceNative},
+ // Health function
+ {"registerHealthApplicationNative",
+ "(ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
+ (void *)registerHealthApplicationNative},
+ {"registerHealthApplicationNative",
+ "(ILjava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
+ (void *)registerSinkHealthApplicationNative},
+
+ {"unregisterHealthApplicationNative", "(Ljava/lang/String;)Z",
+ (void *)unregisterHealthApplicationNative},
+ {"createChannelNative", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Z",
+ (void *)createChannelNative},
+ {"destroyChannelNative", "(Ljava/lang/String;Ljava/lang/String;)Z", (void *)destroyChannelNative},
+ {"getMainChannelNative", "(Ljava/lang/String;)Ljava/lang/String;", (void *)getMainChannelNative},
+ {"getChannelApplicationNative", "(Ljava/lang/String;)Ljava/lang/String;",
+ (void *)getChannelApplicationNative},
+ {"getChannelFdNative", "(Ljava/lang/String;)Landroid/os/ParcelFileDescriptor;", (void *)getChannelFdNative},
+ {"releaseChannelFdNative", "(Ljava/lang/String;)Z", (void *)releaseChannelFdNative},
};