| package com.android.nfc.handover; |
| |
| import android.app.Service; |
| import android.bluetooth.BluetoothAdapter; |
| import android.bluetooth.BluetoothDevice; |
| import android.content.BroadcastReceiver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.media.AudioManager; |
| import android.media.SoundPool; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.IBinder; |
| import android.os.Message; |
| import android.os.Messenger; |
| import android.os.RemoteException; |
| import android.util.Log; |
| import android.util.Pair; |
| |
| import com.android.nfc.R; |
| |
| import java.io.File; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.Map; |
| import java.util.Queue; |
| |
| public class HandoverService extends Service implements HandoverTransfer.Callback, |
| BluetoothHeadsetHandover.Callback { |
| |
| static final String TAG = "HandoverService"; |
| static final boolean DBG = true; |
| |
| static final int MSG_REGISTER_CLIENT = 0; |
| static final int MSG_DEREGISTER_CLIENT = 1; |
| static final int MSG_START_INCOMING_TRANSFER = 2; |
| static final int MSG_START_OUTGOING_TRANSFER = 3; |
| static final int MSG_HEADSET_HANDOVER = 4; |
| |
| static final String BUNDLE_TRANSFER = "transfer"; |
| |
| static final String EXTRA_HEADSET_DEVICE = "device"; |
| static final String EXTRA_HEADSET_NAME = "headsetname"; |
| |
| static final String ACTION_CANCEL_HANDOVER_TRANSFER = |
| "com.android.nfc.handover.action.CANCEL_HANDOVER_TRANSFER"; |
| |
| static final String EXTRA_SOURCE_ADDRESS = |
| "com.android.nfc.handover.extra.SOURCE_ADDRESS"; |
| |
| static final String EXTRA_INCOMING = |
| "com.android.nfc.handover.extra.INCOMING"; |
| |
| static final String ACTION_HANDOVER_STARTED = |
| "android.btopp.intent.action.BT_OPP_HANDOVER_STARTED"; |
| |
| static final String ACTION_BT_OPP_TRANSFER_PROGRESS = |
| "android.btopp.intent.action.BT_OPP_TRANSFER_PROGRESS"; |
| |
| static final String ACTION_BT_OPP_TRANSFER_DONE = |
| "android.btopp.intent.action.BT_OPP_TRANSFER_DONE"; |
| |
| static final String EXTRA_BT_OPP_TRANSFER_STATUS = |
| "android.btopp.intent.extra.BT_OPP_TRANSFER_STATUS"; |
| |
| static final String EXTRA_BT_OPP_TRANSFER_MIMETYPE = |
| "android.btopp.intent.extra.BT_OPP_TRANSFER_MIMETYPE"; |
| |
| static final String EXTRA_BT_OPP_ADDRESS = |
| "android.btopp.intent.extra.BT_OPP_ADDRESS"; |
| |
| static final int HANDOVER_TRANSFER_STATUS_SUCCESS = 0; |
| |
| static final int HANDOVER_TRANSFER_STATUS_FAILURE = 1; |
| |
| static final String EXTRA_BT_OPP_TRANSFER_DIRECTION = |
| "android.btopp.intent.extra.BT_OPP_TRANSFER_DIRECTION"; |
| |
| static final int DIRECTION_BLUETOOTH_INCOMING = 0; |
| |
| static final int DIRECTION_BLUETOOTH_OUTGOING = 1; |
| |
| static final String EXTRA_BT_OPP_TRANSFER_ID = |
| "android.btopp.intent.extra.BT_OPP_TRANSFER_ID"; |
| |
| static final String EXTRA_BT_OPP_TRANSFER_PROGRESS = |
| "android.btopp.intent.extra.BT_OPP_TRANSFER_PROGRESS"; |
| |
| static final String EXTRA_BT_OPP_TRANSFER_URI = |
| "android.btopp.intent.extra.BT_OPP_TRANSFER_URI"; |
| |
| public static final String EXTRA_BT_OPP_OBJECT_COUNT = |
| "android.btopp.intent.extra.BT_OPP_OBJECT_COUNT"; |
| |
| // permission needed to be able to receive handover status requests |
| static final String HANDOVER_STATUS_PERMISSION = |
| "com.android.permission.HANDOVER_STATUS"; |
| |
| // Variables below only accessed on main thread |
| final Queue<BluetoothOppHandover> mPendingOutTransfers; |
| final HashMap<Pair<String, Boolean>, HandoverTransfer> mTransfers; |
| final Messenger mMessenger; |
| |
| SoundPool mSoundPool; |
| int mSuccessSound; |
| |
| BluetoothAdapter mBluetoothAdapter; |
| Messenger mClient; |
| Handler mHandler; |
| BluetoothHeadsetHandover mBluetoothHeadsetHandover; |
| boolean mBluetoothHeadsetConnected; |
| boolean mBluetoothEnabledByNfc; |
| |
| public HandoverService() { |
| mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); |
| mPendingOutTransfers = new LinkedList<BluetoothOppHandover>(); |
| mTransfers = new HashMap<Pair<String, Boolean>, HandoverTransfer>(); |
| mHandler = new MessageHandler(); |
| mMessenger = new Messenger(mHandler); |
| mBluetoothHeadsetConnected = false; |
| mBluetoothEnabledByNfc = false; |
| } |
| |
| @Override |
| public void onCreate() { |
| super.onCreate(); |
| |
| mSoundPool = new SoundPool(1, AudioManager.STREAM_NOTIFICATION, 0); |
| mSuccessSound = mSoundPool.load(this, R.raw.end, 1); |
| |
| IntentFilter filter = new IntentFilter(ACTION_BT_OPP_TRANSFER_DONE); |
| filter.addAction(ACTION_BT_OPP_TRANSFER_PROGRESS); |
| filter.addAction(ACTION_CANCEL_HANDOVER_TRANSFER); |
| filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED); |
| filter.addAction(ACTION_HANDOVER_STARTED); |
| registerReceiver(mReceiver, filter, HANDOVER_STATUS_PERMISSION, mHandler); |
| } |
| |
| @Override |
| public void onDestroy() { |
| super.onDestroy(); |
| if (mSoundPool != null) { |
| mSoundPool.release(); |
| } |
| unregisterReceiver(mReceiver); |
| } |
| |
| void doOutgoingTransfer(Message msg) { |
| Bundle msgData = msg.getData(); |
| |
| msgData.setClassLoader(getClassLoader()); |
| PendingHandoverTransfer pendingTransfer = (PendingHandoverTransfer) |
| msgData.getParcelable(BUNDLE_TRANSFER); |
| createHandoverTransfer(pendingTransfer); |
| |
| // Create the actual transfer |
| BluetoothOppHandover handover = new BluetoothOppHandover(HandoverService.this, |
| pendingTransfer.remoteDevice, pendingTransfer.uris, |
| pendingTransfer.remoteActivating); |
| if (mBluetoothAdapter.isEnabled()) { |
| // Start the transfer |
| handover.start(); |
| } else { |
| if (!enableBluetooth()) { |
| Log.e(TAG, "Error enabling Bluetooth."); |
| notifyClientTransferComplete(pendingTransfer.id); |
| return; |
| } |
| if (DBG) Log.d(TAG, "Queueing out transfer " + Integer.toString(pendingTransfer.id)); |
| mPendingOutTransfers.add(handover); |
| // Queue the transfer and enable Bluetooth - when it is enabled |
| // the transfer will be started. |
| } |
| } |
| |
| void doIncomingTransfer(Message msg) { |
| Bundle msgData = msg.getData(); |
| |
| msgData.setClassLoader(getClassLoader()); |
| PendingHandoverTransfer pendingTransfer = (PendingHandoverTransfer) |
| msgData.getParcelable(BUNDLE_TRANSFER); |
| if (!mBluetoothAdapter.isEnabled() && !enableBluetooth()) { |
| Log.e(TAG, "Error enabling Bluetooth."); |
| notifyClientTransferComplete(pendingTransfer.id); |
| return; |
| } |
| createHandoverTransfer(pendingTransfer); |
| // Remote device will connect and finish the transfer |
| } |
| |
| void doHeadsetHandover(Message msg) { |
| Bundle msgData = msg.getData(); |
| BluetoothDevice device = (BluetoothDevice) msgData.getParcelable(EXTRA_HEADSET_DEVICE); |
| String name = (String) msgData.getString(EXTRA_HEADSET_NAME); |
| mBluetoothHeadsetHandover = new BluetoothHeadsetHandover(HandoverService.this, |
| device, name, HandoverService.this); |
| if (mBluetoothAdapter.isEnabled()) { |
| mBluetoothHeadsetHandover.start(); |
| } else { |
| // Once BT is enabled, the headset pairing will be started |
| if (!enableBluetooth()) { |
| Log.e(TAG, "Error enabling Bluetooth."); |
| mBluetoothHeadsetHandover = null; |
| } |
| } |
| } |
| |
| void startPendingTransfers() { |
| while (!mPendingOutTransfers.isEmpty()) { |
| BluetoothOppHandover handover = mPendingOutTransfers.remove(); |
| handover.start(); |
| } |
| } |
| |
| class MessageHandler extends Handler { |
| @Override |
| public void handleMessage(Message msg) { |
| switch (msg.what) { |
| case MSG_REGISTER_CLIENT: |
| mClient = msg.replyTo; |
| break; |
| case MSG_DEREGISTER_CLIENT: |
| mClient = null; |
| break; |
| case MSG_START_INCOMING_TRANSFER: |
| doIncomingTransfer(msg); |
| break; |
| case MSG_START_OUTGOING_TRANSFER: |
| doOutgoingTransfer(msg); |
| break; |
| case MSG_HEADSET_HANDOVER: |
| doHeadsetHandover(msg); |
| break; |
| } |
| } |
| } |
| |
| boolean enableBluetooth() { |
| if (!mBluetoothAdapter.isEnabled()) { |
| mBluetoothEnabledByNfc = true; |
| return mBluetoothAdapter.enableNoAutoConnect(); |
| } |
| return true; |
| } |
| |
| void disableBluetoothIfNeeded() { |
| if (!mBluetoothEnabledByNfc) return; |
| |
| if (mTransfers.size() == 0 && !mBluetoothHeadsetConnected) { |
| mBluetoothAdapter.disable(); |
| mBluetoothEnabledByNfc = false; |
| } |
| } |
| |
| void createHandoverTransfer(PendingHandoverTransfer pendingTransfer) { |
| Pair<String, Boolean> key = new Pair<String, Boolean>( |
| pendingTransfer.remoteDevice.getAddress(), pendingTransfer.incoming); |
| if (mTransfers.containsKey(key)) { |
| HandoverTransfer transfer = mTransfers.get(key); |
| if (!transfer.isRunning()) { |
| mTransfers.remove(key); // new one created below |
| } else { |
| // There is already a transfer running to this |
| // device - it will automatically get combined |
| // with the existing transfer. |
| notifyClientTransferComplete(pendingTransfer.id); |
| return; |
| } |
| } |
| |
| HandoverTransfer transfer = new HandoverTransfer(this, this, pendingTransfer); |
| mTransfers.put(key, transfer); |
| transfer.updateNotification(); |
| } |
| |
| HandoverTransfer findHandoverTransfer(String sourceAddress, boolean incoming) { |
| Pair<String, Boolean> key = new Pair<String, Boolean>(sourceAddress, incoming); |
| if (mTransfers.containsKey(key)) { |
| HandoverTransfer transfer = mTransfers.get(key); |
| if (transfer.isRunning()) { |
| return transfer; |
| } |
| } |
| return null; |
| } |
| |
| @Override |
| public IBinder onBind(Intent intent) { |
| return mMessenger.getBinder(); |
| } |
| |
| final BroadcastReceiver mReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| String action = intent.getAction(); |
| if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) { |
| int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, |
| BluetoothAdapter.ERROR); |
| if (state == BluetoothAdapter.STATE_ON) { |
| // If there is a pending headset pairing, start it |
| if (mBluetoothHeadsetHandover != null && |
| !mBluetoothHeadsetHandover.hasStarted()) { |
| mBluetoothHeadsetHandover.start(); |
| } |
| |
| // Start any pending file transfers |
| startPendingTransfers(); |
| } else if (state == BluetoothAdapter.STATE_OFF) { |
| mBluetoothEnabledByNfc = false; |
| mBluetoothHeadsetConnected = false; |
| } |
| } else if (action.equals(ACTION_CANCEL_HANDOVER_TRANSFER)) { |
| String sourceAddress = intent.getStringExtra(EXTRA_SOURCE_ADDRESS); |
| boolean incoming = (intent.getIntExtra(EXTRA_INCOMING, 1)) == 1; |
| HandoverTransfer transfer = findHandoverTransfer(sourceAddress, incoming); |
| if (transfer != null) { |
| if (DBG) Log.d(TAG, "Cancelling transfer " + |
| Integer.toString(transfer.mTransferId)); |
| transfer.cancel(); |
| } |
| } else if (action.equals(ACTION_BT_OPP_TRANSFER_PROGRESS) || |
| action.equals(ACTION_BT_OPP_TRANSFER_DONE) || |
| action.equals(ACTION_HANDOVER_STARTED)) { |
| int direction = intent.getIntExtra(EXTRA_BT_OPP_TRANSFER_DIRECTION, -1); |
| int id = intent.getIntExtra(EXTRA_BT_OPP_TRANSFER_ID, -1); |
| if (action.equals(ACTION_HANDOVER_STARTED)) { |
| // This is always for incoming transfers |
| direction = DIRECTION_BLUETOOTH_INCOMING; |
| } |
| String sourceAddress = intent.getStringExtra(EXTRA_BT_OPP_ADDRESS); |
| |
| if (direction == -1 || sourceAddress == null) return; |
| boolean incoming = (direction == DIRECTION_BLUETOOTH_INCOMING); |
| |
| HandoverTransfer transfer = findHandoverTransfer(sourceAddress, incoming); |
| if (transfer == null) { |
| // There is no transfer running for this source address; most likely |
| // the transfer was cancelled. We need to tell BT OPP to stop transferring. |
| if (id != -1) { |
| if (DBG) Log.d(TAG, "Didn't find transfer, stopping"); |
| Intent cancelIntent = new Intent( |
| "android.btopp.intent.action.STOP_HANDOVER_TRANSFER"); |
| cancelIntent.putExtra(EXTRA_BT_OPP_TRANSFER_ID, id); |
| sendBroadcast(cancelIntent); |
| } |
| return; |
| } |
| if (action.equals(ACTION_BT_OPP_TRANSFER_DONE)) { |
| int handoverStatus = intent.getIntExtra(EXTRA_BT_OPP_TRANSFER_STATUS, |
| HANDOVER_TRANSFER_STATUS_FAILURE); |
| if (handoverStatus == HANDOVER_TRANSFER_STATUS_SUCCESS) { |
| String uriString = intent.getStringExtra(EXTRA_BT_OPP_TRANSFER_URI); |
| String mimeType = intent.getStringExtra(EXTRA_BT_OPP_TRANSFER_MIMETYPE); |
| Uri uri = Uri.parse(uriString); |
| if (uri.getScheme() == null) { |
| uri = Uri.fromFile(new File(uri.getPath())); |
| } |
| transfer.finishTransfer(true, uri, mimeType); |
| } else { |
| transfer.finishTransfer(false, null, null); |
| } |
| } else if (action.equals(ACTION_BT_OPP_TRANSFER_PROGRESS)) { |
| float progress = intent.getFloatExtra(EXTRA_BT_OPP_TRANSFER_PROGRESS, 0.0f); |
| transfer.updateFileProgress(progress); |
| } else if (action.equals(ACTION_HANDOVER_STARTED)) { |
| int count = intent.getIntExtra(EXTRA_BT_OPP_OBJECT_COUNT, 0); |
| if (count > 0) { |
| transfer.setObjectCount(count); |
| } |
| } |
| } |
| } |
| }; |
| |
| void notifyClientTransferComplete(int transferId) { |
| if (mClient != null) { |
| Message msg = Message.obtain(null, HandoverManager.MSG_HANDOVER_COMPLETE); |
| msg.arg1 = transferId; |
| try { |
| mClient.send(msg); |
| } catch (RemoteException e) { |
| // Ignore |
| } |
| } |
| } |
| |
| @Override |
| public void onTransferComplete(HandoverTransfer transfer, boolean success) { |
| // Called on the main thread |
| |
| // First, remove the transfer from our list |
| Iterator it = mTransfers.entrySet().iterator(); |
| while (it.hasNext()) { |
| Map.Entry hashPair = (Map.Entry)it.next(); |
| HandoverTransfer transferEntry = (HandoverTransfer) hashPair.getValue(); |
| if (transferEntry == transfer) { |
| it.remove(); |
| } |
| } |
| |
| // Notify any clients of the service |
| notifyClientTransferComplete(transfer.getTransferId()); |
| |
| // Play success sound |
| if (success) { |
| mSoundPool.play(mSuccessSound, 1.0f, 1.0f, 0, 0, 1.0f); |
| } else { |
| if (DBG) Log.d(TAG, "Transfer failed, final state: " + |
| Integer.toString(transfer.mState)); |
| } |
| disableBluetoothIfNeeded(); |
| } |
| |
| @Override |
| public void onBluetoothHeadsetHandoverComplete(boolean connected) { |
| // Called on the main thread |
| mBluetoothHeadsetHandover = null; |
| mBluetoothHeadsetConnected = connected; |
| if (mClient != null) { |
| Message msg = Message.obtain(null, |
| connected ? HandoverManager.MSG_HEADSET_CONNECTED |
| : HandoverManager.MSG_HEADSET_NOT_CONNECTED); |
| try { |
| mClient.send(msg); |
| } catch (RemoteException e) { |
| // Ignore |
| } |
| } |
| disableBluetoothIfNeeded(); |
| } |
| } |
