src/com/android/nfc/handover/PeripheralHandoverService.java - platform/packages/apps/Nfc - Git at Google

 /*
  * Copyright (C) 2012 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.nfc.handover;

 import android.app.Service;
 import android.bluetooth.BluetoothAdapter;
 import android.bluetooth.BluetoothClass;
 import android.bluetooth.BluetoothDevice;
 import android.bluetooth.OobData;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.nfc.NfcAdapter;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.Message;
 import android.os.Messenger;
 import android.os.Parcelable;
 import android.os.ParcelUuid;
 import android.os.RemoteException;
 import android.util.Log;

 import java.util.Set;

 public class PeripheralHandoverService extends Service implements BluetoothPeripheralHandover.Callback {
     static final String TAG = "PeripheralHandoverService";
     static final boolean DBG = true;

     static final int MSG_PAUSE_POLLING = 0;

     public static final String BUNDLE_TRANSFER = "transfer";
     public static final String EXTRA_PERIPHERAL_DEVICE = "device";
     public static final String EXTRA_PERIPHERAL_NAME = "headsetname";
     public static final String EXTRA_PERIPHERAL_TRANSPORT = "transporttype";
     public static final String EXTRA_PERIPHERAL_OOB_DATA = "oobdata";
     public static final String EXTRA_PERIPHERAL_UUIDS = "uuids";
     public static final String EXTRA_PERIPHERAL_CLASS = "class";
     public static final String EXTRA_CLIENT = "client";
     public static final String EXTRA_BT_ENABLED = "bt_enabled";

     public static final int MSG_HEADSET_CONNECTED = 0;
     public static final int MSG_HEADSET_NOT_CONNECTED = 1;

     // Amount of time to pause polling when connecting to peripherals
     private static final int PAUSE_POLLING_TIMEOUT_MS = 35000;
     private static final int PAUSE_DELAY_MILLIS = 300;

     private static final Object sLock = new Object();

     // Variables below only accessed on main thread
     final Messenger mMessenger;

     int mStartId;

     BluetoothAdapter mBluetoothAdapter;
     NfcAdapter mNfcAdapter;
     Handler mHandler;
     BluetoothPeripheralHandover mBluetoothPeripheralHandover;
     BluetoothDevice mDevice;
     Messenger mClient;
     boolean mBluetoothHeadsetConnected;
     boolean mBluetoothEnabledByNfc;

     class MessageHandler extends Handler {
         @Override
         public void handleMessage(Message msg) {
             switch (msg.what) {
                 case MSG_PAUSE_POLLING:
                     mNfcAdapter.pausePolling(PAUSE_POLLING_TIMEOUT_MS);
                     break;
             }
         }
     }

     final BroadcastReceiver mBluetoothStatusReceiver = new BroadcastReceiver() {
         @Override
         public void onReceive(Context context, Intent intent) {
             String action = intent.getAction();
             if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) {
                 handleBluetoothStateChanged(intent);
             }
         }
     };

     public PeripheralHandoverService() {
         mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
         mHandler = new MessageHandler();
         mMessenger = new Messenger(mHandler);
         mBluetoothHeadsetConnected = false;
         mBluetoothEnabledByNfc = false;
         mStartId = 0;
     }

     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {

         synchronized (sLock) {
             if (mStartId != 0) {
                 mStartId = startId;
                 // already running
                 return START_STICKY;
             }
             mStartId = startId;
         }

         if (intent == null) {
             if (DBG) Log.e(TAG, "Intent is null, can't do peripheral handover.");
             stopSelf(startId);
             return START_NOT_STICKY;
         }

         if (doPeripheralHandover(intent.getExtras())) {
             return START_STICKY;
         } else {
             stopSelf(startId);
             return START_NOT_STICKY;
         }
     }

     @Override
     public void onCreate() {
         super.onCreate();
         mNfcAdapter = NfcAdapter.getDefaultAdapter(getApplicationContext());

         IntentFilter filter = new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED);
         registerReceiver(mBluetoothStatusReceiver, filter);
     }

     @Override
     public void onDestroy() {
         super.onDestroy();
         unregisterReceiver(mBluetoothStatusReceiver);
     }

     boolean doPeripheralHandover(Bundle msgData) {
         if (mBluetoothPeripheralHandover != null) {
             Log.d(TAG, "Ignoring pairing request, existing handover in progress.");
             return true;
         }

         if (msgData == null) {
             return false;
         }

         mDevice = msgData.getParcelable(EXTRA_PERIPHERAL_DEVICE);
         String name = msgData.getString(EXTRA_PERIPHERAL_NAME);
         int transport = msgData.getInt(EXTRA_PERIPHERAL_TRANSPORT);
         OobData oobData = msgData.getParcelable(EXTRA_PERIPHERAL_OOB_DATA);
         Parcelable[] parcelables = msgData.getParcelableArray(EXTRA_PERIPHERAL_UUIDS);
         BluetoothClass btClass = msgData.getParcelable(EXTRA_PERIPHERAL_CLASS);

         ParcelUuid[] uuids = null;
         if (parcelables != null) {
             uuids = new ParcelUuid[parcelables.length];
             for (int i = 0; i < parcelables.length; i++) {
                 uuids[i] = (ParcelUuid)parcelables[i];
             }
         }

         mClient = msgData.getParcelable(EXTRA_CLIENT);
         mBluetoothEnabledByNfc = msgData.getBoolean(EXTRA_BT_ENABLED);

         mBluetoothPeripheralHandover = new BluetoothPeripheralHandover(
                 this, mDevice, name, transport, oobData, uuids, btClass, this);

         if (transport == BluetoothDevice.TRANSPORT_LE) {
             mHandler.sendMessageDelayed(
                     mHandler.obtainMessage(MSG_PAUSE_POLLING), PAUSE_DELAY_MILLIS);
         }
         if (mBluetoothAdapter.isEnabled()) {
             if (!mBluetoothPeripheralHandover.start()) {
                 mHandler.removeMessages(MSG_PAUSE_POLLING);
                 mNfcAdapter.resumePolling();
             }
         } else {
             // Once BT is enabled, the headset pairing will be started
             if (!enableBluetooth()) {
                 Log.e(TAG, "Error enabling Bluetooth.");
                 mBluetoothPeripheralHandover = null;
                 return false;
             }
         }

         return true;
     }

     private void handleBluetoothStateChanged(Intent intent) {
         int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE,
                 BluetoothAdapter.ERROR);
         if (state == BluetoothAdapter.STATE_ON) {
             // If there is a pending device pairing, start it
             if (mBluetoothPeripheralHandover != null &&
                     !mBluetoothPeripheralHandover.hasStarted()) {
                 if (!mBluetoothPeripheralHandover.start()) {
                     mNfcAdapter.resumePolling();
                 }
             }
         }
     }

     @Override
     public void onBluetoothPeripheralHandoverComplete(boolean connected) {
         // Called on the main thread
         int transport = mBluetoothPeripheralHandover.mTransport;
         mBluetoothPeripheralHandover = null;
         mBluetoothHeadsetConnected = connected;

         // <hack> resume polling immediately if the connection failed,
         // otherwise just wait for polling to come back up after the timeout
         // This ensures we don't disconnect if the user left the volantis
         // on the tag after pairing completed, which results in automatic
         // disconnection </hack>
         if (transport == BluetoothDevice.TRANSPORT_LE && !connected) {
             if (mHandler.hasMessages(MSG_PAUSE_POLLING)) {
                 mHandler.removeMessages(MSG_PAUSE_POLLING);
             }

             // do this unconditionally as the polling could have been paused as we were removing
             // the message in the handler. It's a no-op if polling is already enabled.
             mNfcAdapter.resumePolling();
         }
         disableBluetoothIfNeeded();
         replyToClient(connected);

         synchronized (sLock) {
             stopSelf(mStartId);
             mStartId = 0;
         }
     }


     boolean enableBluetooth() {
         if (!mBluetoothAdapter.isEnabled()) {
             mBluetoothEnabledByNfc = true;
             return mBluetoothAdapter.enableNoAutoConnect();
         }
         return true;
     }

     void disableBluetoothIfNeeded() {
         if (!mBluetoothEnabledByNfc) return;
         if (hasConnectedBluetoothDevices()) return;

         if (!mBluetoothHeadsetConnected) {
             mBluetoothAdapter.disable();
             mBluetoothEnabledByNfc = false;
         }
     }

     boolean hasConnectedBluetoothDevices() {
         Set<BluetoothDevice> bondedDevices = mBluetoothAdapter.getBondedDevices();

         if (bondedDevices != null) {
             for (BluetoothDevice device : bondedDevices) {
                 if (device.equals(mDevice)) {
                     // Not required to check the remote BT "target" device
                     // connection status, because sometimes the connection
                     // state is not yet been updated upon disconnection.
                     // It is enough to check the connection status for
                     // "other" remote BT device/s.
                     continue;
                 }
                 if (device.isConnected()) return true;
             }
         }
         return false;
     }

     void replyToClient(boolean connected) {
         if (mClient == null) {
             return;
         }

         final int msgId = connected ? MSG_HEADSET_CONNECTED : MSG_HEADSET_NOT_CONNECTED;
         final Message msg = Message.obtain(null, msgId);
         msg.arg1 = mBluetoothEnabledByNfc ? 1 : 0;
         try {
             mClient.send(msg);
         } catch (RemoteException e) {
             // Ignore
         }
     }

     @Override
     public IBinder onBind(Intent intent) {
         return null;
     }

     @Override
     public boolean onUnbind(Intent intent) {
         // prevent any future callbacks to the client, no rebind call needed.
         return false;
     }
 }
	/*
	* Copyright (C) 2012 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.nfc.handover;

	import android.app.Service;
	import android.bluetooth.BluetoothAdapter;
	import android.bluetooth.BluetoothClass;
	import android.bluetooth.BluetoothDevice;
	import android.bluetooth.OobData;
	import android.content.BroadcastReceiver;
	import android.content.Context;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.nfc.NfcAdapter;
	import android.os.Bundle;
	import android.os.Handler;
	import android.os.IBinder;
	import android.os.Message;
	import android.os.Messenger;
	import android.os.Parcelable;
	import android.os.ParcelUuid;
	import android.os.RemoteException;
	import android.util.Log;

	import java.util.Set;

	public class PeripheralHandoverService extends Service implements BluetoothPeripheralHandover.Callback {
	static final String TAG = "PeripheralHandoverService";
	static final boolean DBG = true;

	static final int MSG_PAUSE_POLLING = 0;

	public static final String BUNDLE_TRANSFER = "transfer";
	public static final String EXTRA_PERIPHERAL_DEVICE = "device";
	public static final String EXTRA_PERIPHERAL_NAME = "headsetname";
	public static final String EXTRA_PERIPHERAL_TRANSPORT = "transporttype";
	public static final String EXTRA_PERIPHERAL_OOB_DATA = "oobdata";
	public static final String EXTRA_PERIPHERAL_UUIDS = "uuids";
	public static final String EXTRA_PERIPHERAL_CLASS = "class";
	public static final String EXTRA_CLIENT = "client";
	public static final String EXTRA_BT_ENABLED = "bt_enabled";

	public static final int MSG_HEADSET_CONNECTED = 0;
	public static final int MSG_HEADSET_NOT_CONNECTED = 1;

	// Amount of time to pause polling when connecting to peripherals
	private static final int PAUSE_POLLING_TIMEOUT_MS = 35000;
	private static final int PAUSE_DELAY_MILLIS = 300;

	private static final Object sLock = new Object();

	// Variables below only accessed on main thread
	final Messenger mMessenger;

	int mStartId;

	BluetoothAdapter mBluetoothAdapter;
	NfcAdapter mNfcAdapter;
	Handler mHandler;
	BluetoothPeripheralHandover mBluetoothPeripheralHandover;
	BluetoothDevice mDevice;
	Messenger mClient;
	boolean mBluetoothHeadsetConnected;
	boolean mBluetoothEnabledByNfc;

	class MessageHandler extends Handler {
	@Override
	public void handleMessage(Message msg) {
	switch (msg.what) {
	case MSG_PAUSE_POLLING:
	mNfcAdapter.pausePolling(PAUSE_POLLING_TIMEOUT_MS);
	break;
	}
	}
	}

	final BroadcastReceiver mBluetoothStatusReceiver = new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
	String action = intent.getAction();
	if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) {
	handleBluetoothStateChanged(intent);
	}
	}
	};

	public PeripheralHandoverService() {
	mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
	mHandler = new MessageHandler();
	mMessenger = new Messenger(mHandler);
	mBluetoothHeadsetConnected = false;
	mBluetoothEnabledByNfc = false;
	mStartId = 0;
	}

	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {

	synchronized (sLock) {
	if (mStartId != 0) {
	mStartId = startId;
	// already running
	return START_STICKY;
	}
	mStartId = startId;
	}

	if (intent == null) {
	if (DBG) Log.e(TAG, "Intent is null, can't do peripheral handover.");
	stopSelf(startId);
	return START_NOT_STICKY;
	}

	if (doPeripheralHandover(intent.getExtras())) {
	return START_STICKY;
	} else {
	stopSelf(startId);
	return START_NOT_STICKY;
	}
	}

	@Override
	public void onCreate() {
	super.onCreate();
	mNfcAdapter = NfcAdapter.getDefaultAdapter(getApplicationContext());

	IntentFilter filter = new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED);
	registerReceiver(mBluetoothStatusReceiver, filter);
	}

	@Override
	public void onDestroy() {
	super.onDestroy();
	unregisterReceiver(mBluetoothStatusReceiver);
	}

	boolean doPeripheralHandover(Bundle msgData) {
	if (mBluetoothPeripheralHandover != null) {
	Log.d(TAG, "Ignoring pairing request, existing handover in progress.");
	return true;
	}

	if (msgData == null) {
	return false;
	}

	mDevice = msgData.getParcelable(EXTRA_PERIPHERAL_DEVICE);
	String name = msgData.getString(EXTRA_PERIPHERAL_NAME);
	int transport = msgData.getInt(EXTRA_PERIPHERAL_TRANSPORT);
	OobData oobData = msgData.getParcelable(EXTRA_PERIPHERAL_OOB_DATA);
	Parcelable[] parcelables = msgData.getParcelableArray(EXTRA_PERIPHERAL_UUIDS);
	BluetoothClass btClass = msgData.getParcelable(EXTRA_PERIPHERAL_CLASS);

	ParcelUuid[] uuids = null;
	if (parcelables != null) {
	uuids = new ParcelUuid[parcelables.length];
	for (int i = 0; i < parcelables.length; i++) {
	uuids[i] = (ParcelUuid)parcelables[i];
	}
	}

	mClient = msgData.getParcelable(EXTRA_CLIENT);
	mBluetoothEnabledByNfc = msgData.getBoolean(EXTRA_BT_ENABLED);

	mBluetoothPeripheralHandover = new BluetoothPeripheralHandover(
	this, mDevice, name, transport, oobData, uuids, btClass, this);

	if (transport == BluetoothDevice.TRANSPORT_LE) {
	mHandler.sendMessageDelayed(
	mHandler.obtainMessage(MSG_PAUSE_POLLING), PAUSE_DELAY_MILLIS);
	}
	if (mBluetoothAdapter.isEnabled()) {
	if (!mBluetoothPeripheralHandover.start()) {
	mHandler.removeMessages(MSG_PAUSE_POLLING);
	mNfcAdapter.resumePolling();
	}
	} else {
	// Once BT is enabled, the headset pairing will be started
	if (!enableBluetooth()) {
	Log.e(TAG, "Error enabling Bluetooth.");
	mBluetoothPeripheralHandover = null;
	return false;
	}
	}

	return true;
	}

	private void handleBluetoothStateChanged(Intent intent) {
	int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE,
	BluetoothAdapter.ERROR);
	if (state == BluetoothAdapter.STATE_ON) {
	// If there is a pending device pairing, start it
	if (mBluetoothPeripheralHandover != null &&
	!mBluetoothPeripheralHandover.hasStarted()) {
	if (!mBluetoothPeripheralHandover.start()) {
	mNfcAdapter.resumePolling();
	}
	}
	}
	}

	@Override
	public void onBluetoothPeripheralHandoverComplete(boolean connected) {
	// Called on the main thread
	int transport = mBluetoothPeripheralHandover.mTransport;
	mBluetoothPeripheralHandover = null;
	mBluetoothHeadsetConnected = connected;

	// <hack> resume polling immediately if the connection failed,
	// otherwise just wait for polling to come back up after the timeout
	// This ensures we don't disconnect if the user left the volantis
	// on the tag after pairing completed, which results in automatic
	// disconnection </hack>
	if (transport == BluetoothDevice.TRANSPORT_LE && !connected) {
	if (mHandler.hasMessages(MSG_PAUSE_POLLING)) {
	mHandler.removeMessages(MSG_PAUSE_POLLING);
	}

	// do this unconditionally as the polling could have been paused as we were removing
	// the message in the handler. It's a no-op if polling is already enabled.
	mNfcAdapter.resumePolling();
	}
	disableBluetoothIfNeeded();
	replyToClient(connected);

	synchronized (sLock) {
	stopSelf(mStartId);
	mStartId = 0;
	}
	}


	boolean enableBluetooth() {
	if (!mBluetoothAdapter.isEnabled()) {
	mBluetoothEnabledByNfc = true;
	return mBluetoothAdapter.enableNoAutoConnect();
	}
	return true;
	}

	void disableBluetoothIfNeeded() {
	if (!mBluetoothEnabledByNfc) return;
	if (hasConnectedBluetoothDevices()) return;

	if (!mBluetoothHeadsetConnected) {
	mBluetoothAdapter.disable();
	mBluetoothEnabledByNfc = false;
	}
	}

	boolean hasConnectedBluetoothDevices() {
	Set<BluetoothDevice> bondedDevices = mBluetoothAdapter.getBondedDevices();

	if (bondedDevices != null) {
	for (BluetoothDevice device : bondedDevices) {
	if (device.equals(mDevice)) {
	// Not required to check the remote BT "target" device
	// connection status, because sometimes the connection
	// state is not yet been updated upon disconnection.
	// It is enough to check the connection status for
	// "other" remote BT device/s.
	continue;
	}
	if (device.isConnected()) return true;
	}
	}
	return false;
	}

	void replyToClient(boolean connected) {
	if (mClient == null) {
	return;
	}

	final int msgId = connected ? MSG_HEADSET_CONNECTED : MSG_HEADSET_NOT_CONNECTED;
	final Message msg = Message.obtain(null, msgId);
	msg.arg1 = mBluetoothEnabledByNfc ? 1 : 0;
	try {
	mClient.send(msg);
	} catch (RemoteException e) {
	// Ignore
	}
	}

	@Override
	public IBinder onBind(Intent intent) {
	return null;
	}

	@Override
	public boolean onUnbind(Intent intent) {
	// prevent any future callbacks to the client, no rebind call needed.
	return false;
	}
	}