blob: 9836cdcf2cc36227c0abccda31ef0603a5bc0438 [file] [log] [blame]
/*
* 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 java.io.File;
import java.nio.BufferUnderflowException;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Notification.Builder;
import android.bluetooth.BluetoothA2dp;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothHeadset;
import android.bluetooth.BluetoothProfile;
import android.content.BroadcastReceiver;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.media.MediaScannerConnection;
import android.net.Uri;
import android.nfc.FormatException;
import android.nfc.NdefMessage;
import android.nfc.NdefRecord;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;
import android.util.Log;
import android.util.Pair;
import com.android.nfc.NfcService;
import com.android.nfc.R;
/**
* Manages handover of NFC to other technologies.
*/
public class HandoverManager implements BluetoothProfile.ServiceListener,
BluetoothHeadsetHandover.Callback {
static final String TAG = "NfcHandover";
static final boolean DBG = true;
static final byte[] TYPE_NOKIA = "nokia.com:bt".getBytes(Charset.forName("US_ASCII"));
static final byte[] TYPE_BT_OOB = "application/vnd.bluetooth.ep.oob".
getBytes(Charset.forName("US_ASCII"));
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";
// permission needed to be able to receive handover status requests
static final String HANDOVER_STATUS_PERMISSION =
"com.android.permission.HANDOVER_STATUS";
static final int MSG_HANDOVER_POWER_CHECK = 0;
// We poll whether we can safely disable BT every POWER_CHECK_MS
static final int POWER_CHECK_MS = 20000;
static final String ACTION_WHITELIST_DEVICE =
"android.btopp.intent.action.WHITELIST_DEVICE";
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 int SOURCE_BLUETOOTH_INCOMING = 0;
static final int SOURCE_BLUETOOTH_OUTGOING = 1;
static final int CARRIER_POWER_STATE_INACTIVE = 0;
static final int CARRIER_POWER_STATE_ACTIVE = 1;
static final int CARRIER_POWER_STATE_ACTIVATING = 2;
static final int CARRIER_POWER_STATE_UNKNOWN = 3;
final Context mContext;
final BluetoothAdapter mBluetoothAdapter;
final NotificationManager mNotificationManager;
final HandoverPowerManager mHandoverPowerManager;
// Variables below synchronized on HandoverManager.this
final HashMap<Pair<String, Boolean>, HandoverTransfer> mTransfers;
BluetoothHeadset mBluetoothHeadset;
BluetoothA2dp mBluetoothA2dp;
BluetoothHeadsetHandover mBluetoothHeadsetHandover;
boolean mBluetoothHeadsetConnected;
String mLocalBluetoothAddress;
int mNotificationId;
static class BluetoothHandoverData {
public boolean valid = false;
public BluetoothDevice device;
public String name;
public boolean carrierActivating = false;
}
class HandoverPowerManager implements Handler.Callback {
final Handler handler;
final Context context;
public HandoverPowerManager(Context context) {
this.handler = new Handler(this);
this.context = context;
}
/**
* Enables Bluetooth and will automatically disable it
* when there is no Bluetooth activity intitiated by NFC
* anymore.
*/
synchronized boolean enableBluetooth() {
// Enable BT
boolean result = mBluetoothAdapter.enableNoAutoConnect();
if (result) {
// Start polling for BT activity to make sure we eventually disable
// it again.
handler.sendEmptyMessageDelayed(MSG_HANDOVER_POWER_CHECK, POWER_CHECK_MS);
}
return result;
}
synchronized boolean isBluetoothEnabled() {
return mBluetoothAdapter.isEnabled();
}
synchronized void resetTimer() {
if (handler.hasMessages(MSG_HANDOVER_POWER_CHECK)) {
handler.removeMessages(MSG_HANDOVER_POWER_CHECK);
handler.sendEmptyMessageDelayed(MSG_HANDOVER_POWER_CHECK, POWER_CHECK_MS);
}
}
void stopMonitoring() {
handler.removeMessages(MSG_HANDOVER_POWER_CHECK);
}
@Override
public boolean handleMessage(Message msg) {
switch (msg.what) {
case MSG_HANDOVER_POWER_CHECK:
// Check for any alive transfers
boolean transferAlive = false;
synchronized (HandoverManager.this) {
for (HandoverTransfer transfer : mTransfers.values()) {
if (transfer.isRunning()) {
transferAlive = true;
}
}
if (!transferAlive && !mBluetoothHeadsetConnected) {
mBluetoothAdapter.disable();
handler.removeMessages(MSG_HANDOVER_POWER_CHECK);
} else {
handler.sendEmptyMessageDelayed(MSG_HANDOVER_POWER_CHECK, POWER_CHECK_MS);
}
}
return true;
}
return false;
}
}
/**
* A HandoverTransfer object represents a set of files
* that were received through NFC connection handover
* from the same source address.
*
* For Bluetooth, files are received through OPP, and
* we have no knowledge how many files will be transferred
* as part of a single transaction.
* Hence, a transfer has a notion of being "alive": if
* the last update to a transfer was within WAIT_FOR_NEXT_TRANSFER_MS
* milliseconds, we consider a new file transfer from the
* same source address as part of the same transfer.
* The corresponding URIs will be grouped in a single folder.
*
*/
class HandoverTransfer implements Handler.Callback,
MediaScannerConnection.OnScanCompletedListener {
// In the states below we still accept new file transfer
static final int STATE_NEW = 0;
static final int STATE_IN_PROGRESS = 1;
static final int STATE_W4_NEXT_TRANSFER = 2;
// In the states below no new files are accepted.
static final int STATE_W4_MEDIA_SCANNER = 3;
static final int STATE_FAILED = 4;
static final int STATE_SUCCESS = 5;
static final int STATE_CANCELLED = 6;
static final int MSG_NEXT_TRANSFER_TIMER = 0;
static final int MSG_TRANSFER_TIMEOUT = 1;
// We need to receive an update within this time period
// to still consider this transfer to be "alive" (ie
// a reason to keep the handover transport enabled).
static final int ALIVE_CHECK_MS = 20000;
// The amount of time to wait for a new transfer
// once the current one completes.
static final int WAIT_FOR_NEXT_TRANSFER_MS = 4000;
static final String BEAM_DIR = "beam";
final BluetoothDevice device;
final String sourceAddress;
final boolean incoming; // whether this is an incoming transfer
final int notificationId; // Unique ID of this transfer used for notifications
final Handler handler;
final PendingIntent cancelIntent;
int state;
Long lastUpdate; // Last time an event occurred for this transfer
float progress; // Progress in range [0..1]
ArrayList<Uri> btUris; // Received uris from Bluetooth OPP
ArrayList<String> btMimeTypes; // Mime-types received from Bluetooth OPP
ArrayList<String> paths; // Raw paths on the filesystem for Beam-stored files
HashMap<String, String> mimeTypes; // Mime-types associated with each path
HashMap<String, Uri> mediaUris; // URIs found by the media scanner for each path
int urisScanned;
public HandoverTransfer(String sourceAddress, boolean incoming) {
synchronized (HandoverManager.this) {
this.notificationId = mNotificationId++;
}
this.lastUpdate = SystemClock.elapsedRealtime();
this.progress = 0.0f;
this.state = STATE_NEW;
this.btUris = new ArrayList<Uri>();
this.btMimeTypes = new ArrayList<String>();
this.paths = new ArrayList<String>();
this.mimeTypes = new HashMap<String, String>();
this.mediaUris = new HashMap<String, Uri>();
this.sourceAddress = sourceAddress;
this.incoming = incoming;
this.handler = new Handler(mContext.getMainLooper(), this);
this.cancelIntent = buildCancelIntent();
this.urisScanned = 0;
this.device = mBluetoothAdapter.getRemoteDevice(sourceAddress);
handler.sendEmptyMessageDelayed(MSG_TRANSFER_TIMEOUT, ALIVE_CHECK_MS);
}
public synchronized void updateFileProgress(float progress) {
if (!isRunning()) return; // Ignore when we're no longer running
handler.removeMessages(MSG_NEXT_TRANSFER_TIMER);
this.progress = progress;
// We're still receiving data from this device - keep it in
// the whitelist for a while longer
if (incoming) whitelistOppDevice(device);
updateStateAndNotification(STATE_IN_PROGRESS);
}
public synchronized void finishTransfer(boolean success, Uri uri, String mimeType) {
if (!isRunning()) return; // Ignore when we're no longer running
if (success && uri != null) {
if (DBG) Log.d(TAG, "Transfer success, uri " + uri + " mimeType " + mimeType);
this.progress = 1.0f;
if (mimeType == null) {
mimeType = BluetoothOppHandover.getMimeTypeForUri(mContext, uri);
}
if (mimeType != null) {
btUris.add(uri);
btMimeTypes.add(mimeType);
} else {
if (DBG) Log.d(TAG, "Could not get mimeType for file.");
}
} else {
Log.e(TAG, "Handover transfer failed");
// Do wait to see if there's another file coming.
}
handler.removeMessages(MSG_NEXT_TRANSFER_TIMER);
handler.sendEmptyMessageDelayed(MSG_NEXT_TRANSFER_TIMER, WAIT_FOR_NEXT_TRANSFER_MS);
updateStateAndNotification(STATE_W4_NEXT_TRANSFER);
}
public synchronized boolean isRunning() {
if (state != STATE_NEW && state != STATE_IN_PROGRESS && state != STATE_W4_NEXT_TRANSFER) {
return false;
} else {
return true;
}
}
synchronized void cancel() {
if (!isRunning()) return;
// Delete all files received so far
for (Uri uri : btUris) {
File file = new File(uri.getPath());
if (file.exists()) file.delete();
}
updateStateAndNotification(STATE_CANCELLED);
}
synchronized void updateNotification() {
if (!incoming) return; // No notifications for outgoing transfers
Builder notBuilder = new Notification.Builder(mContext);
if (state == STATE_NEW || state == STATE_IN_PROGRESS ||
state == STATE_W4_NEXT_TRANSFER || state == STATE_W4_MEDIA_SCANNER) {
notBuilder.setAutoCancel(false);
notBuilder.setSmallIcon(android.R.drawable.stat_sys_download);
notBuilder.setTicker(mContext.getString(R.string.beam_progress));
notBuilder.setContentTitle(mContext.getString(R.string.beam_progress));
notBuilder.addAction(R.drawable.ic_menu_cancel_holo_dark,
mContext.getString(R.string.cancel), cancelIntent);
notBuilder.setDeleteIntent(cancelIntent);
// We do have progress indication on a per-file basis, but in a multi-file
// transfer we don't know the total progress. So for now, just show an
// indeterminate progress bar.
notBuilder.setProgress(100, 0, true);
} else if (state == STATE_SUCCESS) {
notBuilder.setAutoCancel(true);
notBuilder.setSmallIcon(android.R.drawable.stat_sys_download_done);
notBuilder.setTicker(mContext.getString(R.string.beam_complete));
notBuilder.setContentTitle(mContext.getString(R.string.beam_complete));
notBuilder.setContentText(mContext.getString(R.string.beam_touch_to_view));
Intent viewIntent = buildViewIntent();
PendingIntent contentIntent = PendingIntent.getActivity(mContext, 0, viewIntent, 0);
notBuilder.setContentIntent(contentIntent);
// Play Beam success sound
NfcService.getInstance().playSound(NfcService.SOUND_END);
} else if (state == STATE_FAILED) {
notBuilder.setAutoCancel(false);
notBuilder.setSmallIcon(android.R.drawable.stat_sys_download_done);
notBuilder.setTicker(mContext.getString(R.string.beam_failed));
notBuilder.setContentTitle(mContext.getString(R.string.beam_failed));
} else if (state == STATE_CANCELLED) {
notBuilder.setAutoCancel(false);
notBuilder.setSmallIcon(android.R.drawable.stat_sys_download_done);
notBuilder.setTicker(mContext.getString(R.string.beam_canceled));
notBuilder.setContentTitle(mContext.getString(R.string.beam_canceled));
} else {
return;
}
mNotificationManager.notify(mNotificationId, notBuilder.build());
}
synchronized void updateStateAndNotification(int newState) {
this.state = newState;
this.lastUpdate = SystemClock.elapsedRealtime();
if (handler.hasMessages(MSG_TRANSFER_TIMEOUT)) {
// Update timeout timer
handler.removeMessages(MSG_TRANSFER_TIMEOUT);
handler.sendEmptyMessageDelayed(MSG_TRANSFER_TIMEOUT, ALIVE_CHECK_MS);
}
updateNotification();
}
synchronized void processFiles() {
// Check the amount of files we received in this transfer;
// If more than one, create a separate directory for it.
String extRoot = Environment.getExternalStorageDirectory().getPath();
File beamPath = new File(extRoot + "/" + BEAM_DIR);
if (!checkMediaStorage(beamPath) || btUris.size() == 0) {
Log.e(TAG, "Media storage not valid or no uris received.");
updateStateAndNotification(STATE_FAILED);
return;
}
if (btUris.size() > 1) {
beamPath = generateMultiplePath(extRoot + "/" + BEAM_DIR + "/");
if (!beamPath.isDirectory() && !beamPath.mkdir()) {
Log.e(TAG, "Failed to create multiple path " + beamPath.toString());
updateStateAndNotification(STATE_FAILED);
return;
}
}
for (int i = 0; i < btUris.size(); i++) {
Uri uri = btUris.get(i);
String mimeType = btMimeTypes.get(i);
File srcFile = new File(uri.getPath());
File dstFile = generateUniqueDestination(beamPath.getAbsolutePath(),
uri.getLastPathSegment());
if (!srcFile.renameTo(dstFile)) {
if (DBG) Log.d(TAG, "Failed to rename from " + srcFile + " to " + dstFile);
srcFile.delete();
return;
} else {
paths.add(dstFile.getAbsolutePath());
mimeTypes.put(dstFile.getAbsolutePath(), mimeType);
if (DBG) Log.d(TAG, "Did successful rename from " + srcFile + " to " + dstFile);
}
}
// We can either add files to the media provider, or provide an ACTION_VIEW
// intent to the file directly. We base this decision on the mime type
// of the first file; if it's media the platform can deal with,
// use the media provider, if it's something else, just launch an ACTION_VIEW
// on the file.
String mimeType = mimeTypes.get(paths.get(0));
if (mimeType.startsWith("image/") || mimeType.startsWith("video/") ||
mimeType.startsWith("audio/")) {
String[] arrayPaths = new String[paths.size()];
MediaScannerConnection.scanFile(mContext, paths.toArray(arrayPaths), null, this);
updateStateAndNotification(STATE_W4_MEDIA_SCANNER);
} else {
// We're done.
updateStateAndNotification(STATE_SUCCESS);
}
}
public boolean handleMessage(Message msg) {
if (msg.what == MSG_NEXT_TRANSFER_TIMER) {
// We didn't receive a new transfer in time, finalize this one
if (incoming) {
processFiles();
} else {
updateStateAndNotification(STATE_SUCCESS);
}
return true;
} else if (msg.what == MSG_TRANSFER_TIMEOUT) {
// No update on this transfer for a while, check
// to see if it's still running, and fail it if it is.
if (isRunning()) {
updateStateAndNotification(STATE_FAILED);
}
}
return false;
}
public synchronized void onScanCompleted(String path, Uri uri) {
if (DBG) Log.d(TAG, "Scan completed, path " + path + " uri " + uri);
if (uri != null) {
mediaUris.put(path, uri);
}
urisScanned++;
if (urisScanned == paths.size()) {
// We're done
updateStateAndNotification(STATE_SUCCESS);
}
}
boolean checkMediaStorage(File path) {
if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
if (!path.isDirectory() && !path.mkdir()) {
Log.e(TAG, "Not dir or not mkdir " + path.getAbsolutePath());
return false;
}
return true;
} else {
Log.e(TAG, "External storage not mounted, can't store file.");
return false;
}
}
synchronized Intent buildViewIntent() {
if (paths.size() == 0) return null;
Intent viewIntent = new Intent(Intent.ACTION_VIEW);
String filePath = paths.get(0);
Uri mediaUri = mediaUris.get(filePath);
Uri uri = mediaUri != null ? mediaUri :
Uri.parse(ContentResolver.SCHEME_FILE + "://" + filePath);
viewIntent.setDataAndTypeAndNormalize(uri, mimeTypes.get(filePath));
return viewIntent;
}
PendingIntent buildCancelIntent() {
Intent intent = new Intent(ACTION_CANCEL_HANDOVER_TRANSFER);
intent.putExtra(EXTRA_SOURCE_ADDRESS, sourceAddress);
PendingIntent pi = PendingIntent.getBroadcast(mContext, 0, intent, 0);
return pi;
}
synchronized File generateUniqueDestination(String path, String fileName) {
int dotIndex = fileName.lastIndexOf(".");
String extension = null;
String fileNameWithoutExtension = null;
if (dotIndex < 0) {
extension = "";
fileNameWithoutExtension = fileName;
} else {
extension = fileName.substring(dotIndex);
fileNameWithoutExtension = fileName.substring(0, dotIndex);
}
File dstFile = new File(path + File.separator + fileName);
int count = 0;
while (dstFile.exists()) {
dstFile = new File(path + File.separator + fileNameWithoutExtension + "-" +
Integer.toString(count) + extension);
count++;
}
return dstFile;
}
synchronized File generateMultiplePath(String beamRoot) {
// Generate a unique directory with the date
String format = "yyyy-MM-dd";
SimpleDateFormat sdf = new SimpleDateFormat(format);
String newPath = beamRoot + "beam-" + sdf.format(new Date());
File newFile = new File(newPath);
int count = 0;
while (newFile.exists()) {
newPath = beamRoot + "beam-" + sdf.format(new Date()) + "-" +
Integer.toString(count);
newFile = new File(newPath);
count++;
}
return newFile;
}
}
synchronized HandoverTransfer getOrCreateHandoverTransfer(String sourceAddress, boolean incoming,
boolean create) {
Pair<String, Boolean> key = new Pair<String, Boolean>(sourceAddress, incoming);
if (mTransfers.containsKey(key)) {
HandoverTransfer transfer = mTransfers.get(key);
if (transfer.isRunning()) {
return transfer;
} else {
if (create) mTransfers.remove(key); // new one created below
}
}
if (create) {
HandoverTransfer transfer = new HandoverTransfer(sourceAddress, incoming);
mTransfers.put(key, transfer);
return transfer;
} else {
return null;
}
}
public HandoverManager(Context context) {
mContext = context;
mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
if (mBluetoothAdapter != null) {
mBluetoothAdapter.getProfileProxy(mContext, this, BluetoothProfile.HEADSET);
mBluetoothAdapter.getProfileProxy(mContext, this, BluetoothProfile.A2DP);
}
mNotificationManager = (NotificationManager) mContext.getSystemService(
Context.NOTIFICATION_SERVICE);
mTransfers = new HashMap<Pair<String, Boolean>, HandoverTransfer>();
mHandoverPowerManager = new HandoverPowerManager(context);
IntentFilter filter = new IntentFilter(ACTION_BT_OPP_TRANSFER_DONE);
filter.addAction(ACTION_BT_OPP_TRANSFER_PROGRESS);
filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
filter.addAction(ACTION_CANCEL_HANDOVER_TRANSFER);
mContext.registerReceiver(mReceiver, filter, HANDOVER_STATUS_PERMISSION, null);
}
synchronized void cleanupTransfers() {
Iterator<Map.Entry<Pair<String, Boolean>, HandoverTransfer>> it = mTransfers.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<Pair<String, Boolean>, HandoverTransfer> pair = it.next();
HandoverTransfer transfer = pair.getValue();
if (!transfer.isRunning()) {
it.remove();
}
}
}
static NdefRecord createCollisionRecord() {
byte[] random = new byte[2];
new Random().nextBytes(random);
return new NdefRecord(NdefRecord.TNF_WELL_KNOWN, NdefRecord.RTD_HANDOVER_REQUEST, null, random);
}
NdefRecord createBluetoothAlternateCarrierRecord(boolean activating) {
byte[] payload = new byte[4];
payload[0] = (byte) (activating ? CARRIER_POWER_STATE_ACTIVATING :
CARRIER_POWER_STATE_ACTIVE); // Carrier Power State: Activating or active
payload[1] = 1; // length of carrier data reference
payload[2] = 'b'; // carrier data reference: ID for Bluetooth OOB data record
payload[3] = 0; // Auxiliary data reference count
return new NdefRecord(NdefRecord.TNF_WELL_KNOWN, NdefRecord.RTD_ALTERNATIVE_CARRIER, null, payload);
}
NdefRecord createBluetoothOobDataRecord() {
byte[] payload = new byte[8];
payload[0] = 0;
payload[1] = (byte)payload.length;
synchronized (HandoverManager.this) {
if (mLocalBluetoothAddress == null) {
mLocalBluetoothAddress = mBluetoothAdapter.getAddress();
}
byte[] addressBytes = addressToReverseBytes(mLocalBluetoothAddress);
System.arraycopy(addressBytes, 0, payload, 2, 6);
}
return new NdefRecord(NdefRecord.TNF_MIME_MEDIA, TYPE_BT_OOB, new byte[]{'b'}, payload);
}
public boolean isHandoverSupported() {
return (mBluetoothAdapter != null);
}
public NdefMessage createHandoverRequestMessage() {
if (mBluetoothAdapter == null) return null;
return new NdefMessage(createHandoverRequestRecord(), createBluetoothOobDataRecord());
}
NdefMessage createHandoverSelectMessage(boolean activating) {
return new NdefMessage(createHandoverSelectRecord(activating), createBluetoothOobDataRecord());
}
NdefRecord createHandoverSelectRecord(boolean activating) {
NdefMessage nestedMessage = new NdefMessage(createBluetoothAlternateCarrierRecord(activating));
byte[] nestedPayload = nestedMessage.toByteArray();
ByteBuffer payload = ByteBuffer.allocate(nestedPayload.length + 1);
payload.put((byte)0x12); // connection handover v1.2
payload.put(nestedPayload);
byte[] payloadBytes = new byte[payload.position()];
payload.position(0);
payload.get(payloadBytes);
return new NdefRecord(NdefRecord.TNF_WELL_KNOWN, NdefRecord.RTD_HANDOVER_SELECT, null,
payloadBytes);
}
NdefRecord createHandoverRequestRecord() {
NdefMessage nestedMessage = new NdefMessage(createCollisionRecord(),
createBluetoothAlternateCarrierRecord(false));
byte[] nestedPayload = nestedMessage.toByteArray();
ByteBuffer payload = ByteBuffer.allocate(nestedPayload.length + 1);
payload.put((byte)0x12); // connection handover v1.2
payload.put(nestedMessage.toByteArray());
byte[] payloadBytes = new byte[payload.position()];
payload.position(0);
payload.get(payloadBytes);
return new NdefRecord(NdefRecord.TNF_WELL_KNOWN, NdefRecord.RTD_HANDOVER_REQUEST, null,
payloadBytes);
}
/**
* Return null if message is not a Handover Request,
* return the Handover Select response if it is.
*/
public NdefMessage tryHandoverRequest(NdefMessage m) {
if (m == null) return null;
if (mBluetoothAdapter == null) return null;
if (DBG) Log.d(TAG, "tryHandoverRequest():" + m.toString());
NdefRecord r = m.getRecords()[0];
if (r.getTnf() != NdefRecord.TNF_WELL_KNOWN) return null;
if (!Arrays.equals(r.getType(), NdefRecord.RTD_HANDOVER_REQUEST)) return null;
// we have a handover request, look for BT OOB record
BluetoothHandoverData bluetoothData = null;
for (NdefRecord oob : m.getRecords()) {
if (oob.getTnf() == NdefRecord.TNF_MIME_MEDIA &&
Arrays.equals(oob.getType(), TYPE_BT_OOB)) {
bluetoothData = parseBtOob(ByteBuffer.wrap(oob.getPayload()));
break;
}
}
if (bluetoothData == null) return null;
boolean bluetoothActivating = false;
synchronized(HandoverManager.this) {
if (!mHandoverPowerManager.isBluetoothEnabled()) {
if (!mHandoverPowerManager.enableBluetooth()) {
return null;
}
bluetoothActivating = true;
} else {
mHandoverPowerManager.resetTimer();
}
// Create the initial transfer object
HandoverTransfer transfer = getOrCreateHandoverTransfer(
bluetoothData.device.getAddress(), true, true);
transfer.updateNotification();
}
// BT OOB found, whitelist it for incoming OPP data
whitelistOppDevice(bluetoothData.device);
// return BT OOB record so they can perform handover
return (createHandoverSelectMessage(bluetoothActivating));
}
void whitelistOppDevice(BluetoothDevice device) {
if (DBG) Log.d(TAG, "Whitelisting " + device + " for BT OPP");
Intent intent = new Intent(ACTION_WHITELIST_DEVICE);
intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);
mContext.sendBroadcast(intent);
}
public boolean tryHandover(NdefMessage m) {
if (m == null) return false;
if (mBluetoothAdapter == null) return false;
if (DBG) Log.d(TAG, "tryHandover(): " + m.toString());
BluetoothHandoverData handover = parse(m);
if (handover == null) return false;
if (!handover.valid) return true;
synchronized (HandoverManager.this) {
if (mBluetoothAdapter == null ||
mBluetoothA2dp == null ||
mBluetoothHeadset == null) {
if (DBG) Log.d(TAG, "BT handover, but BT not available");
return true;
}
if (mBluetoothHeadsetHandover != null) {
if (DBG) Log.d(TAG, "BT handover already in progress, ignoring");
return true;
}
mBluetoothHeadsetHandover = new BluetoothHeadsetHandover(mContext, handover.device,
handover.name, mHandoverPowerManager, mBluetoothA2dp, mBluetoothHeadset, this);
mBluetoothHeadsetHandover.start();
}
return true;
}
// This starts sending an Uri over BT
public void doHandoverUri(Uri[] uris, NdefMessage m) {
if (mBluetoothAdapter == null) return;
BluetoothHandoverData data = parse(m);
if (data != null && data.valid) {
// Register a new handover transfer object
getOrCreateHandoverTransfer(data.device.getAddress(), false, true);
BluetoothOppHandover handover = new BluetoothOppHandover(mContext, data.device,
uris, mHandoverPowerManager, data.carrierActivating);
handover.start();
}
}
boolean isCarrierActivating(NdefRecord handoverRec, byte[] carrierId) {
byte[] payload = handoverRec.getPayload();
if (payload == null || payload.length <= 1) return false;
// Skip version
byte[] payloadNdef = new byte[payload.length - 1];
System.arraycopy(payload, 1, payloadNdef, 0, payload.length - 1);
NdefMessage msg;
try {
msg = new NdefMessage(payloadNdef);
} catch (FormatException e) {
return false;
}
for (NdefRecord alt : msg.getRecords()) {
byte[] acPayload = alt.getPayload();
if (acPayload != null) {
ByteBuffer buf = ByteBuffer.wrap(acPayload);
int cps = buf.get() & 0x03; // Carrier Power State is in lower 2 bits
int carrierRefLength = buf.get() & 0xFF;
if (carrierRefLength != carrierId.length) return false;
byte[] carrierRefId = new byte[carrierRefLength];
buf.get(carrierRefId);
if (Arrays.equals(carrierRefId, carrierId)) {
// Found match, returning whether power state is activating
return (cps == CARRIER_POWER_STATE_ACTIVATING);
}
}
}
return true;
}
BluetoothHandoverData parseHandoverSelect(NdefMessage m) {
// TODO we could parse this a lot more strictly; right now
// we just search for a BT OOB record, and try to cross-reference
// the carrier state inside the 'hs' payload.
for (NdefRecord oob : m.getRecords()) {
if (oob.getTnf() == NdefRecord.TNF_MIME_MEDIA &&
Arrays.equals(oob.getType(), TYPE_BT_OOB)) {
BluetoothHandoverData data = parseBtOob(ByteBuffer.wrap(oob.getPayload()));
if (data != null && isCarrierActivating(m.getRecords()[0], oob.getId())) {
data.carrierActivating = true;
}
return data;
}
}
return null;
}
BluetoothHandoverData parse(NdefMessage m) {
NdefRecord r = m.getRecords()[0];
short tnf = r.getTnf();
byte[] type = r.getType();
// Check for BT OOB record
if (r.getTnf() == NdefRecord.TNF_MIME_MEDIA && Arrays.equals(r.getType(), TYPE_BT_OOB)) {
return parseBtOob(ByteBuffer.wrap(r.getPayload()));
}
// Check for Handover Select, followed by a BT OOB record
if (tnf == NdefRecord.TNF_WELL_KNOWN &&
Arrays.equals(type, NdefRecord.RTD_HANDOVER_SELECT)) {
return parseHandoverSelect(m);
}
// Check for Nokia BT record, found on some Nokia BH-505 Headsets
if (tnf == NdefRecord.TNF_EXTERNAL_TYPE && Arrays.equals(type, TYPE_NOKIA)) {
return parseNokia(ByteBuffer.wrap(r.getPayload()));
}
return null;
}
BluetoothHandoverData parseNokia(ByteBuffer payload) {
BluetoothHandoverData result = new BluetoothHandoverData();
result.valid = false;
try {
payload.position(1);
byte[] address = new byte[6];
payload.get(address);
result.device = mBluetoothAdapter.getRemoteDevice(address);
result.valid = true;
payload.position(14);
int nameLength = payload.get();
byte[] nameBytes = new byte[nameLength];
payload.get(nameBytes);
result.name = new String(nameBytes, Charset.forName("UTF-8"));
} catch (IllegalArgumentException e) {
Log.i(TAG, "nokia: invalid BT address");
} catch (BufferUnderflowException e) {
Log.i(TAG, "nokia: payload shorter than expected");
}
if (result.valid && result.name == null) result.name = "";
return result;
}
BluetoothHandoverData parseBtOob(ByteBuffer payload) {
BluetoothHandoverData result = new BluetoothHandoverData();
result.valid = false;
try {
payload.position(2);
byte[] address = new byte[6];
payload.get(address);
// ByteBuffer.order(LITTLE_ENDIAN) doesn't work for
// ByteBuffer.get(byte[]), so manually swap order
for (int i = 0; i < 3; i++) {
byte temp = address[i];
address[i] = address[5 - i];
address[5 - i] = temp;
}
result.device = mBluetoothAdapter.getRemoteDevice(address);
result.valid = true;
while (payload.remaining() > 0) {
byte[] nameBytes;
int len = payload.get();
int type = payload.get();
switch (type) {
case 0x08: // short local name
nameBytes = new byte[len - 1];
payload.get(nameBytes);
result.name = new String(nameBytes, Charset.forName("UTF-8"));
break;
case 0x09: // long local name
if (result.name != null) break; // prefer short name
nameBytes = new byte[len - 1];
payload.get(nameBytes);
result.name = new String(nameBytes, Charset.forName("UTF-8"));
break;
default:
payload.position(payload.position() + len - 1);
break;
}
}
} catch (IllegalArgumentException e) {
Log.i(TAG, "BT OOB: invalid BT address");
} catch (BufferUnderflowException e) {
Log.i(TAG, "BT OOB: payload shorter than expected");
}
if (result.valid && result.name == null) result.name = "";
return result;
}
static byte[] addressToReverseBytes(String address) {
String[] split = address.split(":");
byte[] result = new byte[split.length];
for (int i = 0; i < split.length; i++) {
// need to parse as int because parseByte() expects a signed byte
result[split.length - 1 - i] = (byte)Integer.parseInt(split[i], 16);
}
return result;
}
@Override
public void onServiceConnected(int profile, BluetoothProfile proxy) {
synchronized (HandoverManager.this) {
switch (profile) {
case BluetoothProfile.HEADSET:
mBluetoothHeadset = (BluetoothHeadset) proxy;
break;
case BluetoothProfile.A2DP:
mBluetoothA2dp = (BluetoothA2dp) proxy;
break;
}
}
}
@Override
public void onServiceDisconnected(int profile) {
synchronized (HandoverManager.this) {
switch (profile) {
case BluetoothProfile.HEADSET:
mBluetoothHeadset = null;
break;
case BluetoothProfile.A2DP:
mBluetoothA2dp = null;
break;
}
}
}
@Override
public void onBluetoothHeadsetHandoverComplete(boolean connected) {
synchronized (HandoverManager.this) {
mBluetoothHeadsetHandover = null;
mBluetoothHeadsetConnected = connected;
}
}
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_OFF) {
mHandoverPowerManager.stopMonitoring();
}
return;
} else if (action.equals(ACTION_CANCEL_HANDOVER_TRANSFER)) {
String sourceAddress = intent.getStringExtra(EXTRA_SOURCE_ADDRESS);
HandoverTransfer transfer = getOrCreateHandoverTransfer(sourceAddress, true,
false);
if (transfer != null) {
transfer.cancel();
}
} else if (action.equals(ACTION_BT_OPP_TRANSFER_PROGRESS) ||
action.equals(ACTION_BT_OPP_TRANSFER_DONE)) {
// Clean up old transfers no longer in progress
cleanupTransfers();
int direction = intent.getIntExtra(EXTRA_BT_OPP_TRANSFER_DIRECTION, -1);
int id = intent.getIntExtra(EXTRA_BT_OPP_TRANSFER_ID, -1);
String sourceAddress = intent.getStringExtra(EXTRA_BT_OPP_ADDRESS);
if (direction == -1 || id == -1 || sourceAddress == null) return;
boolean incoming = (direction == DIRECTION_BLUETOOTH_INCOMING);
HandoverTransfer transfer = getOrCreateHandoverTransfer(sourceAddress, incoming,
false);
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
// in case this was an incoming transfer
Intent cancelIntent = new Intent("android.btopp.intent.action.STOP_HANDOVER_TRANSFER");
cancelIntent.putExtra(EXTRA_BT_OPP_TRANSFER_ID, id);
mContext.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);
}
}
}
};
}