samples/BluetoothHDP/src/com/example/bluetooth/health/BluetoothHDPService.java - platform/development - Git at Google

 /*
  * 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 com.example.bluetooth.health;

 import android.app.Service;
 import android.bluetooth.BluetoothAdapter;
 import android.bluetooth.BluetoothDevice;
 import android.bluetooth.BluetoothHealth;
 import android.bluetooth.BluetoothHealthAppConfiguration;
 import android.bluetooth.BluetoothHealthCallback;
 import android.bluetooth.BluetoothProfile;
 import android.content.Intent;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.Message;
 import android.os.Messenger;
 import android.os.ParcelFileDescriptor;
 import android.os.RemoteException;
 import android.util.Log;
 import android.widget.Toast;

 import java.io.FileInputStream;
 import java.io.IOException;

 /**
  * This Service encapsulates Bluetooth Health API to establish, manage, and disconnect
  * communication between the Android device and a Bluetooth HDP-enabled device.  Possible HDP
  * device type includes blood pressure monitor, glucose meter, thermometer, etc.
  *
  * As outlined in the
  * <a href="http://developer.android.com/reference/android/bluetooth/BluetoothHealth.html">BluetoothHealth</a>
  * documentation, the steps involve:
  * 1. Get a reference to the BluetoothHealth proxy object.
  * 2. Create a BluetoothHealth callback and register an application configuration that acts as a
  *    Health SINK.
  * 3. Establish connection to a health device.  Some devices will initiate the connection.  It is
  *    unnecessary to carry out this step for those devices.
  * 4. When connected successfully, read / write to the health device using the file descriptor.
  *    The received data needs to be interpreted using a health manager which implements the
  *    IEEE 11073-xxxxx specifications.
  * 5. When done, close the health channel and unregister the application.  The channel will
  *    also close when there is extended inactivity.
  */
 public class BluetoothHDPService extends Service {
     private static final String TAG = "BluetoothHDPService";

     public static final int RESULT_OK = 0;
     public static final int RESULT_FAIL = -1;

     // Status codes sent back to the UI client.
     // Application registration complete.
     public static final int STATUS_HEALTH_APP_REG = 100;
     // Application unregistration complete.
     public static final int STATUS_HEALTH_APP_UNREG = 101;
     // Channel creation complete.
     public static final int STATUS_CREATE_CHANNEL = 102;
     // Channel destroy complete.
     public static final int STATUS_DESTROY_CHANNEL = 103;
     // Reading data from Bluetooth HDP device.
     public static final int STATUS_READ_DATA = 104;
     // Done with reading data.
     public static final int STATUS_READ_DATA_DONE = 105;

     // Message codes received from the UI client.
     // Register client with this service.
     public static final int MSG_REG_CLIENT = 200;
     // Unregister client from this service.
     public static final int MSG_UNREG_CLIENT = 201;
     // Register health application.
     public static final int MSG_REG_HEALTH_APP = 300;
     // Unregister health application.
     public static final int MSG_UNREG_HEALTH_APP = 301;
     // Connect channel.
     public static final int MSG_CONNECT_CHANNEL = 400;
     // Disconnect channel.
     public static final int MSG_DISCONNECT_CHANNEL = 401;

     private BluetoothHealthAppConfiguration mHealthAppConfig;
     private BluetoothAdapter mBluetoothAdapter;
     private BluetoothHealth mBluetoothHealth;
     private BluetoothDevice mDevice;
     private int mChannelId;

     private Messenger mClient;

     // Handles events sent by {@link HealthHDPActivity}.
     private class IncomingHandler extends Handler {
         @Override
         public void handleMessage(Message msg) {
             switch (msg.what) {
                 // Register UI client to this service so the client can receive messages.
                 case MSG_REG_CLIENT:
                     Log.d(TAG, "Activity client registered");
                     mClient = msg.replyTo;
                     break;
                 // Unregister UI client from this service.
                 case MSG_UNREG_CLIENT:
                     mClient = null;
                     break;
                 // Register health application.
                 case MSG_REG_HEALTH_APP:
                     registerApp(msg.arg1);
                     break;
                 // Unregister health application.
                 case MSG_UNREG_HEALTH_APP:
                     unregisterApp();
                     break;
                 // Connect channel.
                 case MSG_CONNECT_CHANNEL:
                     mDevice = (BluetoothDevice) msg.obj;
                     connectChannel();
                     break;
                 // Disconnect channel.
                 case MSG_DISCONNECT_CHANNEL:
                     mDevice = (BluetoothDevice) msg.obj;
                     disconnectChannel();
                     break;
                 default:
                     super.handleMessage(msg);
             }
         }
     }

     final Messenger mMessenger = new Messenger(new IncomingHandler());

     /**
      * Make sure Bluetooth and health profile are available on the Android device.  Stop service
      * if they are not available.
      */
     @Override
     public void onCreate() {
         super.onCreate();
         mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
         if (mBluetoothAdapter == null || !mBluetoothAdapter.isEnabled()) {
             // Bluetooth adapter isn't available.  The client of the service is supposed to
             // verify that it is available and activate before invoking this service.
             stopSelf();
             return;
         }
         if (!mBluetoothAdapter.getProfileProxy(this, mBluetoothServiceListener,
                 BluetoothProfile.HEALTH)) {
             Toast.makeText(this, R.string.bluetooth_health_profile_not_available,
                     Toast.LENGTH_LONG);
             stopSelf();
             return;
         }
     }

     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
         Log.d(TAG, "BluetoothHDPService is running.");
         return START_STICKY;
     }

     @Override
     public IBinder onBind(Intent intent) {
         return mMessenger.getBinder();
     };

     // Register health application through the Bluetooth Health API.
     private void registerApp(int dataType) {
         mBluetoothHealth.registerSinkAppConfiguration(TAG, dataType, mHealthCallback);
     }

     // Unregister health application through the Bluetooth Health API.
     private void unregisterApp() {
         mBluetoothHealth.unregisterAppConfiguration(mHealthAppConfig);
     }

     // Connect channel through the Bluetooth Health API.
     private void connectChannel() {
         Log.i(TAG, "connectChannel()");
         mBluetoothHealth.connectChannelToSource(mDevice, mHealthAppConfig);
     }

     // Disconnect channel through the Bluetooth Health API.
     private void disconnectChannel() {
         Log.i(TAG, "disconnectChannel()");
         mBluetoothHealth.disconnectChannel(mDevice, mHealthAppConfig, mChannelId);
     }

     // Callbacks to handle connection set up and disconnection clean up.
     private final BluetoothProfile.ServiceListener mBluetoothServiceListener =
             new BluetoothProfile.ServiceListener() {
         public void onServiceConnected(int profile, BluetoothProfile proxy) {
             if (profile == BluetoothProfile.HEALTH) {
                 mBluetoothHealth = (BluetoothHealth) proxy;
                 if (Log.isLoggable(TAG, Log.DEBUG))
                     Log.d(TAG, "onServiceConnected to profile: " + profile);
             }
         }

         public void onServiceDisconnected(int profile) {
             if (profile == BluetoothProfile.HEALTH) {
                 mBluetoothHealth = null;
             }
         }
     };

     private final BluetoothHealthCallback mHealthCallback = new BluetoothHealthCallback() {
         // Callback to handle application registration and unregistration events.  The service
         // passes the status back to the UI client.
         public void onHealthAppConfigurationStatusChange(BluetoothHealthAppConfiguration config,
                 int status) {
             if (status == BluetoothHealth.APP_CONFIG_REGISTRATION_FAILURE) {
                 mHealthAppConfig = null;
                 sendMessage(STATUS_HEALTH_APP_REG, RESULT_FAIL);
             } else if (status == BluetoothHealth.APP_CONFIG_REGISTRATION_SUCCESS) {
                 mHealthAppConfig = config;
                 sendMessage(STATUS_HEALTH_APP_REG, RESULT_OK);
             } else if (status == BluetoothHealth.APP_CONFIG_UNREGISTRATION_FAILURE ||
                     status == BluetoothHealth.APP_CONFIG_UNREGISTRATION_SUCCESS) {
                 sendMessage(STATUS_HEALTH_APP_UNREG,
                         status == BluetoothHealth.APP_CONFIG_UNREGISTRATION_SUCCESS ?
                         RESULT_OK : RESULT_FAIL);
             }
         }

         // Callback to handle channel connection state changes.
         // Note that the logic of the state machine may need to be modified based on the HDP device.
         // When the HDP device is connected, the received file descriptor is passed to the
         // ReadThread to read the content.
         public void onHealthChannelStateChange(BluetoothHealthAppConfiguration config,
                 BluetoothDevice device, int prevState, int newState, ParcelFileDescriptor fd,
                 int channelId) {
             if (Log.isLoggable(TAG, Log.DEBUG))
                 Log.d(TAG, String.format("prevState\t%d ----------> newState\t%d",
                         prevState, newState));
             if (prevState == BluetoothHealth.STATE_CHANNEL_DISCONNECTED &&
                     newState == BluetoothHealth.STATE_CHANNEL_CONNECTED) {
                 if (config.equals(mHealthAppConfig)) {
                     mChannelId = channelId;
                     sendMessage(STATUS_CREATE_CHANNEL, RESULT_OK);
                     (new ReadThread(fd)).start();
                 } else {
                     sendMessage(STATUS_CREATE_CHANNEL, RESULT_FAIL);
                 }
             } else if (prevState == BluetoothHealth.STATE_CHANNEL_CONNECTING &&
                        newState == BluetoothHealth.STATE_CHANNEL_DISCONNECTED) {
                 sendMessage(STATUS_CREATE_CHANNEL, RESULT_FAIL);
             } else if (newState == BluetoothHealth.STATE_CHANNEL_DISCONNECTED) {
                 if (config.equals(mHealthAppConfig)) {
                     sendMessage(STATUS_DESTROY_CHANNEL, RESULT_OK);
                 } else {
                     sendMessage(STATUS_DESTROY_CHANNEL, RESULT_FAIL);
                 }
             }
         }
     };

     // Sends an update message to registered UI client.
     private void sendMessage(int what, int value) {
         if (mClient == null) {
             Log.d(TAG, "No clients registered.");
             return;
         }

         try {
             mClient.send(Message.obtain(null, what, value, 0));
         } catch (RemoteException e) {
             // Unable to reach client.
             e.printStackTrace();
         }
     }

     // Thread to read incoming data received from the HDP device.  This sample application merely
     // reads the raw byte from the incoming file descriptor.  The data should be interpreted using
     // a health manager which implements the IEEE 11073-xxxxx specifications.
     private class ReadThread extends Thread {
         private ParcelFileDescriptor mFd;

         public ReadThread(ParcelFileDescriptor fd) {
             super();
             mFd = fd;
         }

         @Override
         public void run() {
             FileInputStream fis = new FileInputStream(mFd.getFileDescriptor());
             final byte data[] = new byte[8192];
             try {
                 while(fis.read(data) > -1) {
                     // At this point, the application can pass the raw data to a parser that
                     // has implemented the IEEE 11073-xxxxx specifications.  Instead, this sample
                     // simply indicates that some data has been received.
                     sendMessage(STATUS_READ_DATA, 0);
                 }
             } catch(IOException ioe) {}
             if (mFd != null) {
                 try {
                     mFd.close();
                 } catch (IOException e) { /* Do nothing. */ }
             }
             sendMessage(STATUS_READ_DATA_DONE, 0);
         }
     }
 }
	/*
	* 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 com.example.bluetooth.health;

	import android.app.Service;
	import android.bluetooth.BluetoothAdapter;
	import android.bluetooth.BluetoothDevice;
	import android.bluetooth.BluetoothHealth;
	import android.bluetooth.BluetoothHealthAppConfiguration;
	import android.bluetooth.BluetoothHealthCallback;
	import android.bluetooth.BluetoothProfile;
	import android.content.Intent;
	import android.os.Handler;
	import android.os.IBinder;
	import android.os.Message;
	import android.os.Messenger;
	import android.os.ParcelFileDescriptor;
	import android.os.RemoteException;
	import android.util.Log;
	import android.widget.Toast;

	import java.io.FileInputStream;
	import java.io.IOException;

	/**
	* This Service encapsulates Bluetooth Health API to establish, manage, and disconnect
	* communication between the Android device and a Bluetooth HDP-enabled device. Possible HDP
	* device type includes blood pressure monitor, glucose meter, thermometer, etc.
	*
	* As outlined in the
	* <a href="http://developer.android.com/reference/android/bluetooth/BluetoothHealth.html">BluetoothHealth</a>
	* documentation, the steps involve:
	* 1. Get a reference to the BluetoothHealth proxy object.
	* 2. Create a BluetoothHealth callback and register an application configuration that acts as a
	* Health SINK.
	* 3. Establish connection to a health device. Some devices will initiate the connection. It is
	* unnecessary to carry out this step for those devices.
	* 4. When connected successfully, read / write to the health device using the file descriptor.
	* The received data needs to be interpreted using a health manager which implements the
	* IEEE 11073-xxxxx specifications.
	* 5. When done, close the health channel and unregister the application. The channel will
	* also close when there is extended inactivity.
	*/
	public class BluetoothHDPService extends Service {
	private static final String TAG = "BluetoothHDPService";

	public static final int RESULT_OK = 0;
	public static final int RESULT_FAIL = -1;

	// Status codes sent back to the UI client.
	// Application registration complete.
	public static final int STATUS_HEALTH_APP_REG = 100;
	// Application unregistration complete.
	public static final int STATUS_HEALTH_APP_UNREG = 101;
	// Channel creation complete.
	public static final int STATUS_CREATE_CHANNEL = 102;
	// Channel destroy complete.
	public static final int STATUS_DESTROY_CHANNEL = 103;
	// Reading data from Bluetooth HDP device.
	public static final int STATUS_READ_DATA = 104;
	// Done with reading data.
	public static final int STATUS_READ_DATA_DONE = 105;

	// Message codes received from the UI client.
	// Register client with this service.
	public static final int MSG_REG_CLIENT = 200;
	// Unregister client from this service.
	public static final int MSG_UNREG_CLIENT = 201;
	// Register health application.
	public static final int MSG_REG_HEALTH_APP = 300;
	// Unregister health application.
	public static final int MSG_UNREG_HEALTH_APP = 301;
	// Connect channel.
	public static final int MSG_CONNECT_CHANNEL = 400;
	// Disconnect channel.
	public static final int MSG_DISCONNECT_CHANNEL = 401;

	private BluetoothHealthAppConfiguration mHealthAppConfig;
	private BluetoothAdapter mBluetoothAdapter;
	private BluetoothHealth mBluetoothHealth;
	private BluetoothDevice mDevice;
	private int mChannelId;

	private Messenger mClient;

	// Handles events sent by {@link HealthHDPActivity}.
	private class IncomingHandler extends Handler {
	@Override
	public void handleMessage(Message msg) {
	switch (msg.what) {
	// Register UI client to this service so the client can receive messages.
	case MSG_REG_CLIENT:
	Log.d(TAG, "Activity client registered");
	mClient = msg.replyTo;
	break;
	// Unregister UI client from this service.
	case MSG_UNREG_CLIENT:
	mClient = null;
	break;
	// Register health application.
	case MSG_REG_HEALTH_APP:
	registerApp(msg.arg1);
	break;
	// Unregister health application.
	case MSG_UNREG_HEALTH_APP:
	unregisterApp();
	break;
	// Connect channel.
	case MSG_CONNECT_CHANNEL:
	mDevice = (BluetoothDevice) msg.obj;
	connectChannel();
	break;
	// Disconnect channel.
	case MSG_DISCONNECT_CHANNEL:
	mDevice = (BluetoothDevice) msg.obj;
	disconnectChannel();
	break;
	default:
	super.handleMessage(msg);
	}
	}
	}

	final Messenger mMessenger = new Messenger(new IncomingHandler());

	/**
	* Make sure Bluetooth and health profile are available on the Android device. Stop service
	* if they are not available.
	*/
	@Override
	public void onCreate() {
	super.onCreate();
	mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
	if (mBluetoothAdapter == null \|\| !mBluetoothAdapter.isEnabled()) {
	// Bluetooth adapter isn't available. The client of the service is supposed to
	// verify that it is available and activate before invoking this service.
	stopSelf();
	return;
	}
	if (!mBluetoothAdapter.getProfileProxy(this, mBluetoothServiceListener,
	BluetoothProfile.HEALTH)) {
	Toast.makeText(this, R.string.bluetooth_health_profile_not_available,
	Toast.LENGTH_LONG);
	stopSelf();
	return;
	}
	}

	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
	Log.d(TAG, "BluetoothHDPService is running.");
	return START_STICKY;
	}

	@Override
	public IBinder onBind(Intent intent) {
	return mMessenger.getBinder();
	};

	// Register health application through the Bluetooth Health API.
	private void registerApp(int dataType) {
	mBluetoothHealth.registerSinkAppConfiguration(TAG, dataType, mHealthCallback);
	}

	// Unregister health application through the Bluetooth Health API.
	private void unregisterApp() {
	mBluetoothHealth.unregisterAppConfiguration(mHealthAppConfig);
	}

	// Connect channel through the Bluetooth Health API.
	private void connectChannel() {
	Log.i(TAG, "connectChannel()");
	mBluetoothHealth.connectChannelToSource(mDevice, mHealthAppConfig);
	}

	// Disconnect channel through the Bluetooth Health API.
	private void disconnectChannel() {
	Log.i(TAG, "disconnectChannel()");
	mBluetoothHealth.disconnectChannel(mDevice, mHealthAppConfig, mChannelId);
	}

	// Callbacks to handle connection set up and disconnection clean up.
	private final BluetoothProfile.ServiceListener mBluetoothServiceListener =
	new BluetoothProfile.ServiceListener() {
	public void onServiceConnected(int profile, BluetoothProfile proxy) {
	if (profile == BluetoothProfile.HEALTH) {
	mBluetoothHealth = (BluetoothHealth) proxy;
	if (Log.isLoggable(TAG, Log.DEBUG))
	Log.d(TAG, "onServiceConnected to profile: " + profile);
	}
	}

	public void onServiceDisconnected(int profile) {
	if (profile == BluetoothProfile.HEALTH) {
	mBluetoothHealth = null;
	}
	}
	};

	private final BluetoothHealthCallback mHealthCallback = new BluetoothHealthCallback() {
	// Callback to handle application registration and unregistration events. The service
	// passes the status back to the UI client.
	public void onHealthAppConfigurationStatusChange(BluetoothHealthAppConfiguration config,
	int status) {
	if (status == BluetoothHealth.APP_CONFIG_REGISTRATION_FAILURE) {
	mHealthAppConfig = null;
	sendMessage(STATUS_HEALTH_APP_REG, RESULT_FAIL);
	} else if (status == BluetoothHealth.APP_CONFIG_REGISTRATION_SUCCESS) {
	mHealthAppConfig = config;
	sendMessage(STATUS_HEALTH_APP_REG, RESULT_OK);
	} else if (status == BluetoothHealth.APP_CONFIG_UNREGISTRATION_FAILURE \|\|
	status == BluetoothHealth.APP_CONFIG_UNREGISTRATION_SUCCESS) {
	sendMessage(STATUS_HEALTH_APP_UNREG,
	status == BluetoothHealth.APP_CONFIG_UNREGISTRATION_SUCCESS ?
	RESULT_OK : RESULT_FAIL);
	}
	}

	// Callback to handle channel connection state changes.
	// Note that the logic of the state machine may need to be modified based on the HDP device.
	// When the HDP device is connected, the received file descriptor is passed to the
	// ReadThread to read the content.
	public void onHealthChannelStateChange(BluetoothHealthAppConfiguration config,
	BluetoothDevice device, int prevState, int newState, ParcelFileDescriptor fd,
	int channelId) {
	if (Log.isLoggable(TAG, Log.DEBUG))
	Log.d(TAG, String.format("prevState\t%d ----------> newState\t%d",
	prevState, newState));
	if (prevState == BluetoothHealth.STATE_CHANNEL_DISCONNECTED &&
	newState == BluetoothHealth.STATE_CHANNEL_CONNECTED) {
	if (config.equals(mHealthAppConfig)) {
	mChannelId = channelId;
	sendMessage(STATUS_CREATE_CHANNEL, RESULT_OK);
	(new ReadThread(fd)).start();
	} else {
	sendMessage(STATUS_CREATE_CHANNEL, RESULT_FAIL);
	}
	} else if (prevState == BluetoothHealth.STATE_CHANNEL_CONNECTING &&
	newState == BluetoothHealth.STATE_CHANNEL_DISCONNECTED) {
	sendMessage(STATUS_CREATE_CHANNEL, RESULT_FAIL);
	} else if (newState == BluetoothHealth.STATE_CHANNEL_DISCONNECTED) {
	if (config.equals(mHealthAppConfig)) {
	sendMessage(STATUS_DESTROY_CHANNEL, RESULT_OK);
	} else {
	sendMessage(STATUS_DESTROY_CHANNEL, RESULT_FAIL);
	}
	}
	}
	};

	// Sends an update message to registered UI client.
	private void sendMessage(int what, int value) {
	if (mClient == null) {
	Log.d(TAG, "No clients registered.");
	return;
	}

	try {
	mClient.send(Message.obtain(null, what, value, 0));
	} catch (RemoteException e) {
	// Unable to reach client.
	e.printStackTrace();
	}
	}

	// Thread to read incoming data received from the HDP device. This sample application merely
	// reads the raw byte from the incoming file descriptor. The data should be interpreted using
	// a health manager which implements the IEEE 11073-xxxxx specifications.
	private class ReadThread extends Thread {
	private ParcelFileDescriptor mFd;

	public ReadThread(ParcelFileDescriptor fd) {
	super();
	mFd = fd;
	}

	@Override
	public void run() {
	FileInputStream fis = new FileInputStream(mFd.getFileDescriptor());
	final byte data[] = new byte[8192];
	try {
	while(fis.read(data) > -1) {
	// At this point, the application can pass the raw data to a parser that
	// has implemented the IEEE 11073-xxxxx specifications. Instead, this sample
	// simply indicates that some data has been received.
	sendMessage(STATUS_READ_DATA, 0);
	}
	} catch(IOException ioe) {}
	if (mFd != null) {
	try {
	mFd.close();
	} catch (IOException e) { /* Do nothing. */ }
	}
	sendMessage(STATUS_READ_DATA_DONE, 0);
	}
	}
	}