| /* |
| * 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.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.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.util.Log; |
| import android.view.KeyEvent; |
| import android.widget.Toast; |
| |
| import com.android.nfc.handover.HandoverManager.HandoverPowerManager; |
| import com.android.nfc.R; |
| |
| /** |
| * Connects / Disconnects from a Bluetooth headset (or any device that |
| * might implement BT HSP, HFP or A2DP sink) when touched with NFC. |
| * |
| * This object is created on an NFC interaction, and determines what |
| * sequence of Bluetooth actions to take, and executes them. It is not |
| * designed to be re-used after the sequence has completed or timed out. |
| * Subsequent NFC interactions should use new objects. |
| * |
| * TODO: UI review |
| */ |
| public class BluetoothHeadsetHandover { |
| static final String TAG = HandoverManager.TAG; |
| static final boolean DBG = HandoverManager.DBG; |
| |
| static final String ACTION_ALLOW_CONNECT = "com.android.nfc.handover.action.ALLOW_CONNECT"; |
| static final String ACTION_DENY_CONNECT = "com.android.nfc.handover.action.DENY_CONNECT"; |
| |
| static final int TIMEOUT_MS = 20000; |
| |
| static final int STATE_INIT = 0; |
| static final int STATE_TURNING_ON = 1; |
| static final int STATE_WAITING_FOR_BOND_CONFIRMATION = 2; |
| static final int STATE_BONDING = 3; |
| static final int STATE_CONNECTING = 4; |
| static final int STATE_DISCONNECTING = 5; |
| static final int STATE_COMPLETE = 6; |
| |
| static final int RESULT_PENDING = 0; |
| static final int RESULT_CONNECTED = 1; |
| static final int RESULT_DISCONNECTED = 2; |
| |
| static final int ACTION_DISCONNECT = 1; |
| static final int ACTION_CONNECT = 2; |
| |
| static final int MSG_TIMEOUT = 1; |
| |
| final Context mContext; |
| final BluetoothDevice mDevice; |
| final String mName; |
| final HandoverPowerManager mHandoverPowerManager; |
| final BluetoothA2dp mA2dp; |
| final BluetoothHeadset mHeadset; |
| final Callback mCallback; |
| |
| // only used on main thread |
| int mAction; |
| int mState; |
| int mHfpResult; // used only in STATE_CONNECTING and STATE_DISCONNETING |
| int mA2dpResult; // used only in STATE_CONNECTING and STATE_DISCONNETING |
| |
| public interface Callback { |
| public void onBluetoothHeadsetHandoverComplete(boolean connected); |
| } |
| |
| public BluetoothHeadsetHandover(Context context, BluetoothDevice device, String name, |
| HandoverPowerManager powerManager, BluetoothA2dp a2dp, BluetoothHeadset headset, |
| Callback callback) { |
| checkMainThread(); // mHandler must get get constructed on Main Thread for toasts to work |
| mContext = context; |
| mDevice = device; |
| mName = name; |
| mHandoverPowerManager = powerManager; |
| mA2dp = a2dp; |
| mHeadset = headset; |
| mCallback = callback; |
| mState = STATE_INIT; |
| } |
| |
| /** |
| * Main entry point. This method is usually called after construction, |
| * to begin the BT sequence. Must be called on Main thread. |
| */ |
| public void start() { |
| checkMainThread(); |
| if (mState != STATE_INIT) return; |
| |
| IntentFilter filter = new IntentFilter(); |
| filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED); |
| filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED); |
| filter.addAction(BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED); |
| filter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED); |
| filter.addAction(ACTION_ALLOW_CONNECT); |
| filter.addAction(ACTION_DENY_CONNECT); |
| |
| mContext.registerReceiver(mReceiver, filter); |
| |
| if (mA2dp.getConnectedDevices().contains(mDevice) || |
| mHeadset.getConnectedDevices().contains(mDevice)) { |
| Log.i(TAG, "ACTION_DISCONNECT addr=" + mDevice + " name=" + mName); |
| mAction = ACTION_DISCONNECT; |
| } else { |
| Log.i(TAG, "ACTION_CONNECT addr=" + mDevice + " name=" + mName); |
| mAction = ACTION_CONNECT; |
| } |
| mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_TIMEOUT), TIMEOUT_MS); |
| nextStep(); |
| } |
| |
| /** |
| * Called to execute next step in state machine |
| */ |
| void nextStep() { |
| if (mAction == ACTION_CONNECT) { |
| nextStepConnect(); |
| } else { |
| nextStepDisconnect(); |
| } |
| } |
| |
| void nextStepDisconnect() { |
| switch (mState) { |
| case STATE_INIT: |
| mState = STATE_DISCONNECTING; |
| if (mHeadset.getConnectionState(mDevice) != BluetoothProfile.STATE_DISCONNECTED) { |
| mHfpResult = RESULT_PENDING; |
| mHeadset.disconnect(mDevice); |
| } else { |
| mHfpResult = RESULT_DISCONNECTED; |
| } |
| if (mA2dp.getConnectionState(mDevice) != BluetoothProfile.STATE_DISCONNECTED) { |
| mA2dpResult = RESULT_PENDING; |
| mA2dp.disconnect(mDevice); |
| } else { |
| mA2dpResult = RESULT_DISCONNECTED; |
| } |
| if (mA2dpResult == RESULT_PENDING || mHfpResult == RESULT_PENDING) { |
| toast(mContext.getString(R.string.disconnecting_headset ) + " " + |
| mName + "..."); |
| break; |
| } |
| // fall-through |
| case STATE_DISCONNECTING: |
| if (mA2dpResult == RESULT_PENDING || mHfpResult == RESULT_PENDING) { |
| // still disconnecting |
| break; |
| } |
| if (mA2dpResult == RESULT_DISCONNECTED && mHfpResult == RESULT_DISCONNECTED) { |
| toast(mContext.getString(R.string.disconnected_headset) + " " + mName); |
| } |
| complete(false); |
| break; |
| } |
| } |
| |
| void nextStepConnect() { |
| switch (mState) { |
| case STATE_INIT: |
| if (!mHandoverPowerManager.isBluetoothEnabled()) { |
| if (mHandoverPowerManager.enableBluetooth()) { |
| // Bluetooth is being enabled |
| mState = STATE_TURNING_ON; |
| } else { |
| toast(mContext.getString(R.string.failed_to_enable_bt)); |
| complete(false); |
| } |
| break; |
| } |
| // fall-through |
| case STATE_TURNING_ON: |
| if (mDevice.getBondState() != BluetoothDevice.BOND_BONDED) { |
| requestPairConfirmation(); |
| mState = STATE_WAITING_FOR_BOND_CONFIRMATION; |
| break; |
| } |
| // fall-through |
| case STATE_WAITING_FOR_BOND_CONFIRMATION: |
| if (mDevice.getBondState() != BluetoothDevice.BOND_BONDED) { |
| startBonding(); |
| break; |
| } |
| // fall-through |
| case STATE_BONDING: |
| // Bluetooth Profile service will correctly serialize |
| // HFP then A2DP connect |
| mState = STATE_CONNECTING; |
| if (mHeadset.getConnectionState(mDevice) != BluetoothProfile.STATE_CONNECTED) { |
| mHfpResult = RESULT_PENDING; |
| mHeadset.connect(mDevice); |
| } else { |
| mHfpResult = RESULT_CONNECTED; |
| } |
| if (mA2dp.getConnectionState(mDevice) != BluetoothProfile.STATE_CONNECTED) { |
| mA2dpResult = RESULT_PENDING; |
| mA2dp.connect(mDevice); |
| } else { |
| mA2dpResult = RESULT_CONNECTED; |
| } |
| if (mA2dpResult == RESULT_PENDING || mHfpResult == RESULT_PENDING) { |
| toast(mContext.getString(R.string.connecting_headset) + " " + mName + "..."); |
| break; |
| } |
| // fall-through |
| case STATE_CONNECTING: |
| if (mA2dpResult == RESULT_PENDING || mHfpResult == RESULT_PENDING) { |
| // another connection type still pending |
| break; |
| } |
| if (mA2dpResult == RESULT_CONNECTED || mHfpResult == RESULT_CONNECTED) { |
| // we'll take either as success |
| toast(mContext.getString(R.string.connected_headset) + " " + mName); |
| if (mA2dpResult == RESULT_CONNECTED) startTheMusic(); |
| complete(true); |
| } else { |
| toast (mContext.getString(R.string.connect_headset_failed) + " " + mName); |
| complete(false); |
| } |
| break; |
| } |
| } |
| |
| void startBonding() { |
| mState = STATE_BONDING; |
| toast(mContext.getString(R.string.pairing_headset) + " " + mName + "..."); |
| if (!mDevice.createBond()) { |
| toast(mContext.getString(R.string.pairing_headset_failed) + " " + mName); |
| complete(false); |
| } |
| } |
| |
| void handleIntent(Intent intent) { |
| String action = intent.getAction(); |
| if (BluetoothAdapter.ACTION_STATE_CHANGED.equals(action) && mState == STATE_TURNING_ON) { |
| int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR); |
| if (state == BluetoothAdapter.STATE_ON) { |
| nextStepConnect(); |
| } else if (state == BluetoothAdapter.STATE_OFF) { |
| toast(mContext.getString(R.string.failed_to_enable_bt)); |
| complete(false); |
| } |
| return; |
| } |
| |
| // Everything else requires the device to match... |
| BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE); |
| if (!mDevice.equals(device)) return; |
| |
| if (ACTION_ALLOW_CONNECT.equals(action)) { |
| nextStepConnect(); |
| } else if (ACTION_DENY_CONNECT.equals(action)) { |
| complete(false); |
| } else if (BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(action) && mState == STATE_BONDING) { |
| int bond = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, |
| BluetoothAdapter.ERROR); |
| if (bond == BluetoothDevice.BOND_BONDED) { |
| nextStepConnect(); |
| } else if (bond == BluetoothDevice.BOND_NONE) { |
| toast(mContext.getString(R.string.pairing_headset_failed) + " " + mName); |
| complete(false); |
| } |
| } else if (BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED.equals(action) && |
| (mState == STATE_CONNECTING || mState == STATE_DISCONNECTING)) { |
| int state = intent.getIntExtra(BluetoothProfile.EXTRA_STATE, BluetoothAdapter.ERROR); |
| if (state == BluetoothProfile.STATE_CONNECTED) { |
| mHfpResult = RESULT_CONNECTED; |
| nextStep(); |
| } else if (state == BluetoothProfile.STATE_DISCONNECTED) { |
| mHfpResult = RESULT_DISCONNECTED; |
| nextStep(); |
| } |
| } else if (BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED.equals(action) && |
| (mState == STATE_CONNECTING || mState == STATE_DISCONNECTING)) { |
| int state = intent.getIntExtra(BluetoothProfile.EXTRA_STATE, BluetoothAdapter.ERROR); |
| if (state == BluetoothProfile.STATE_CONNECTED) { |
| mA2dpResult = RESULT_CONNECTED; |
| nextStep(); |
| } else if (state == BluetoothProfile.STATE_DISCONNECTED) { |
| mA2dpResult = RESULT_DISCONNECTED; |
| nextStep(); |
| } |
| } |
| } |
| |
| void complete(boolean connected) { |
| if (DBG) Log.d(TAG, "complete()"); |
| mState = STATE_COMPLETE; |
| mContext.unregisterReceiver(mReceiver); |
| mHandler.removeMessages(MSG_TIMEOUT); |
| mCallback.onBluetoothHeadsetHandoverComplete(connected); |
| } |
| |
| void toast(CharSequence text) { |
| Toast.makeText(mContext, text, Toast.LENGTH_SHORT).show(); |
| } |
| |
| void startTheMusic() { |
| Intent intent = new Intent(Intent.ACTION_MEDIA_BUTTON); |
| intent.putExtra(Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_DOWN, |
| KeyEvent.KEYCODE_MEDIA_PLAY)); |
| mContext.sendOrderedBroadcast(intent, null); |
| intent.putExtra(Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_UP, |
| KeyEvent.KEYCODE_MEDIA_PLAY)); |
| mContext.sendOrderedBroadcast(intent, null); |
| } |
| |
| void requestPairConfirmation() { |
| Intent dialogIntent = new Intent(mContext, ConfirmConnectActivity.class); |
| dialogIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); |
| |
| dialogIntent.putExtra(BluetoothDevice.EXTRA_DEVICE, mDevice); |
| |
| mContext.startActivity(dialogIntent); |
| } |
| |
| final Handler mHandler = new Handler() { |
| @Override |
| public void handleMessage(Message msg) { |
| switch (msg.what) { |
| case MSG_TIMEOUT: |
| if (mState == STATE_COMPLETE) return; |
| Log.i(TAG, "Timeout completing BT handover"); |
| complete(false); |
| break; |
| } |
| } |
| }; |
| |
| final BroadcastReceiver mReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| handleIntent(intent); |
| } |
| }; |
| |
| static void checkMainThread() { |
| if (Looper.myLooper() != Looper.getMainLooper()) { |
| throw new IllegalThreadStateException("must be called on main thread"); |
| } |
| } |
| } |
