/* * Copyright (C) 2014 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 android.bluetooth; import android.content.ComponentName; import android.content.Context; import android.content.Intent; import android.content.ServiceConnection; import android.os.Bundle; import android.os.IBinder; import android.os.RemoteException; import android.util.Log; import java.util.ArrayList; import java.util.List; /** * Public API to control Hands Free Profile (HFP role only). * <p> * This class defines methods that shall be used by application to manage profile * connection, calls states and calls actions. * <p> * * @hide * */ public final class BluetoothHeadsetClient implements BluetoothProfile { private static final String TAG = "BluetoothHeadsetClient"; private static final boolean DBG = true; private static final boolean VDBG = false; /** * Intent sent whenever connection to remote changes. * * <p>It includes two extras: * <code>BluetoothProfile.EXTRA_PREVIOUS_STATE</code> * and <code>BluetoothProfile.EXTRA_STATE</code>, which * are mandatory. * <p>There are also non mandatory feature extras: * {@link #EXTRA_AG_FEATURE_3WAY_CALLING}, * {@link #EXTRA_AG_FEATURE_VOICE_RECOGNITION}, * {@link #EXTRA_AG_FEATURE_ATTACH_NUMBER_TO_VT}, * {@link #EXTRA_AG_FEATURE_REJECT_CALL}, * {@link #EXTRA_AG_FEATURE_ECC}, * {@link #EXTRA_AG_FEATURE_RESPONSE_AND_HOLD}, * {@link #EXTRA_AG_FEATURE_ACCEPT_HELD_OR_WAITING_CALL}, * {@link #EXTRA_AG_FEATURE_RELEASE_HELD_OR_WAITING_CALL}, * {@link #EXTRA_AG_FEATURE_RELEASE_AND_ACCEPT}, * {@link #EXTRA_AG_FEATURE_MERGE}, * {@link #EXTRA_AG_FEATURE_MERGE_AND_DETACH}, * sent as boolean values only when <code>EXTRA_STATE</code> * is set to <code>STATE_CONNECTED</code>.</p> * * <p>Note that features supported by AG are being sent as * booleans with value <code>true</code>, * and not supported ones are <strong>not</strong> being sent at all.</p> */ public static final String ACTION_CONNECTION_STATE_CHANGED = "android.bluetooth.headsetclient.profile.action.CONNECTION_STATE_CHANGED"; /** * Intent sent whenever audio state changes. * * <p>It includes two mandatory extras: * {@link BluetoothProfile.EXTRA_STATE}, * {@link BluetoothProfile.EXTRA_PREVIOUS_STATE}, * with possible values: * {@link #STATE_AUDIO_CONNECTING}, * {@link #STATE_AUDIO_CONNECTED}, * {@link #STATE_AUDIO_DISCONNECTED}</p> * <p>When <code>EXTRA_STATE</code> is set * to </code>STATE_AUDIO_CONNECTED</code>, * it also includes {@link #EXTRA_AUDIO_WBS} * indicating wide band speech support.</p> */ public static final String ACTION_AUDIO_STATE_CHANGED = "android.bluetooth.headsetclient.profile.action.AUDIO_STATE_CHANGED"; /** * Intent sending updates of the Audio Gateway state. * Each extra is being sent only when value it * represents has been changed recently on AG. * <p>It can contain one or more of the following extras: * {@link #EXTRA_NETWORK_STATUS}, * {@link #EXTRA_NETWORK_SIGNAL_STRENGTH}, * {@link #EXTRA_NETWORK_ROAMING}, * {@link #EXTRA_BATTERY_LEVEL}, * {@link #EXTRA_OPERATOR_NAME}, * {@link #EXTRA_VOICE_RECOGNITION}, * {@link #EXTRA_IN_BAND_RING}</p> */ public static final String ACTION_AG_EVENT = "android.bluetooth.headsetclient.profile.action.AG_EVENT"; /** * Intent sent whenever state of a call changes. * * <p>It includes: * {@link #EXTRA_CALL}, * with value of {@link BluetoothHeadsetClientCall} instance, * representing actual call state.</p> */ public static final String ACTION_CALL_CHANGED = "android.bluetooth.headsetclient.profile.action.AG_CALL_CHANGED"; /** * Intent that notifies about the result of the last issued action. * Please note that not every action results in explicit action result code being sent. * Instead other notifications about new Audio Gateway state might be sent, * like <code>ACTION_AG_EVENT</code> with <code>EXTRA_VOICE_RECOGNITION</code> value * when for example user started voice recognition from HF unit. */ public static final String ACTION_RESULT = "android.bluetooth.headsetclient.profile.action.RESULT"; /** * Intent that notifies about the number attached to the last voice tag * recorded on AG. * * <p>It contains: * {@link #EXTRA_NUMBER}, * with a <code>String</code> value representing phone number.</p> */ public static final String ACTION_LAST_VTAG = "android.bluetooth.headsetclient.profile.action.LAST_VTAG"; public static final int STATE_AUDIO_DISCONNECTED = 0; public static final int STATE_AUDIO_CONNECTING = 1; public static final int STATE_AUDIO_CONNECTED = 2; /** * Extra with information if connected audio is WBS. * <p>Possible values: <code>true</code>, * <code>false</code>.</p> */ public static final String EXTRA_AUDIO_WBS = "android.bluetooth.headsetclient.extra.AUDIO_WBS"; /** * Extra for AG_EVENT indicates network status. * <p>Value: 0 - network unavailable, * 1 - network available </p> */ public static final String EXTRA_NETWORK_STATUS = "android.bluetooth.headsetclient.extra.NETWORK_STATUS"; /** * Extra for AG_EVENT intent indicates network signal strength. * <p>Value: <code>Integer</code> representing signal strength.</p> */ public static final String EXTRA_NETWORK_SIGNAL_STRENGTH = "android.bluetooth.headsetclient.extra.NETWORK_SIGNAL_STRENGTH"; /** * Extra for AG_EVENT intent indicates roaming state. * <p>Value: 0 - no roaming * 1 - active roaming</p> */ public static final String EXTRA_NETWORK_ROAMING = "android.bluetooth.headsetclient.extra.NETWORK_ROAMING"; /** * Extra for AG_EVENT intent indicates the battery level. * <p>Value: <code>Integer</code> representing signal strength.</p> */ public static final String EXTRA_BATTERY_LEVEL = "android.bluetooth.headsetclient.extra.BATTERY_LEVEL"; /** * Extra for AG_EVENT intent indicates operator name. * <p>Value: <code>String</code> representing operator name.</p> */ public static final String EXTRA_OPERATOR_NAME = "android.bluetooth.headsetclient.extra.OPERATOR_NAME"; /** * Extra for AG_EVENT intent indicates voice recognition state. * <p>Value: * 0 - voice recognition stopped, * 1 - voice recognition started.</p> */ public static final String EXTRA_VOICE_RECOGNITION = "android.bluetooth.headsetclient.extra.VOICE_RECOGNITION"; /** * Extra for AG_EVENT intent indicates in band ring state. * <p>Value: * 0 - in band ring tone not supported, or * 1 - in band ring tone supported.</p> */ public static final String EXTRA_IN_BAND_RING = "android.bluetooth.headsetclient.extra.IN_BAND_RING"; /** * Extra for AG_EVENT intent indicates subscriber info. * <p>Value: <code>String</code> containing subscriber information.</p> */ public static final String EXTRA_SUBSCRIBER_INFO = "android.bluetooth.headsetclient.extra.SUBSCRIBER_INFO"; /** * Extra for AG_CALL_CHANGED intent indicates the * {@link BluetoothHeadsetClientCall} object that has changed. */ public static final String EXTRA_CALL = "android.bluetooth.headsetclient.extra.CALL"; /** * Extra for ACTION_LAST_VTAG intent. * <p>Value: <code>String</code> representing phone number * corresponding to last voice tag recorded on AG</p> */ public static final String EXTRA_NUMBER = "android.bluetooth.headsetclient.extra.NUMBER"; /** * Extra for ACTION_RESULT intent that shows the result code of * last issued action. * <p>Possible results: * {@link #ACTION_RESULT_OK}, * {@link #ACTION_RESULT_ERROR}, * {@link #ACTION_RESULT_ERROR_NO_CARRIER}, * {@link #ACTION_RESULT_ERROR_BUSY}, * {@link #ACTION_RESULT_ERROR_NO_ANSWER}, * {@link #ACTION_RESULT_ERROR_DELAYED}, * {@link #ACTION_RESULT_ERROR_BLACKLISTED}, * {@link #ACTION_RESULT_ERROR_CME}</p> */ public static final String EXTRA_RESULT_CODE = "android.bluetooth.headsetclient.extra.RESULT_CODE"; /** * Extra for ACTION_RESULT intent that shows the extended result code of * last issued action. * <p>Value: <code>Integer</code> - error code.</p> */ public static final String EXTRA_CME_CODE = "android.bluetooth.headsetclient.extra.CME_CODE"; /* Extras for AG_FEATURES, extras type is boolean */ // TODO verify if all of those are actually useful /** * AG feature: three way calling. */ public final static String EXTRA_AG_FEATURE_3WAY_CALLING = "android.bluetooth.headsetclient.extra.EXTRA_AG_FEATURE_3WAY_CALLING"; /** * AG feature: voice recognition. */ public final static String EXTRA_AG_FEATURE_VOICE_RECOGNITION = "android.bluetooth.headsetclient.extra.EXTRA_AG_FEATURE_VOICE_RECOGNITION"; /** * AG feature: fetching phone number for voice tagging procedure. */ public final static String EXTRA_AG_FEATURE_ATTACH_NUMBER_TO_VT = "android.bluetooth.headsetclient.extra.EXTRA_AG_FEATURE_ATTACH_NUMBER_TO_VT"; /** * AG feature: ability to reject incoming call. */ public final static String EXTRA_AG_FEATURE_REJECT_CALL = "android.bluetooth.headsetclient.extra.EXTRA_AG_FEATURE_REJECT_CALL"; /** * AG feature: enhanced call handling (terminate specific call, private consultation). */ public final static String EXTRA_AG_FEATURE_ECC = "android.bluetooth.headsetclient.extra.EXTRA_AG_FEATURE_ECC"; /** * AG feature: response and hold. */ public final static String EXTRA_AG_FEATURE_RESPONSE_AND_HOLD = "android.bluetooth.headsetclient.extra.EXTRA_AG_FEATURE_RESPONSE_AND_HOLD"; /** * AG call handling feature: accept held or waiting call in three way calling scenarios. */ public final static String EXTRA_AG_FEATURE_ACCEPT_HELD_OR_WAITING_CALL = "android.bluetooth.headsetclient.extra.EXTRA_AG_FEATURE_ACCEPT_HELD_OR_WAITING_CALL"; /** * AG call handling feature: release held or waiting call in three way calling scenarios. */ public final static String EXTRA_AG_FEATURE_RELEASE_HELD_OR_WAITING_CALL = "android.bluetooth.headsetclient.extra.EXTRA_AG_FEATURE_RELEASE_HELD_OR_WAITING_CALL"; /** * AG call handling feature: release active call and accept held or waiting call in three way * calling scenarios. */ public final static String EXTRA_AG_FEATURE_RELEASE_AND_ACCEPT = "android.bluetooth.headsetclient.extra.EXTRA_AG_FEATURE_RELEASE_AND_ACCEPT"; /** * AG call handling feature: merge two calls, held and active - multi party conference mode. */ public final static String EXTRA_AG_FEATURE_MERGE = "android.bluetooth.headsetclient.extra.EXTRA_AG_FEATURE_MERGE"; /** * AG call handling feature: merge calls and disconnect from multi party * conversation leaving peers connected to each other. * Note that this feature needs to be supported by mobile network operator * as it requires connection and billing transfer. */ public final static String EXTRA_AG_FEATURE_MERGE_AND_DETACH = "android.bluetooth.headsetclient.extra.EXTRA_AG_FEATURE_MERGE_AND_DETACH"; /* Action result codes */ public final static int ACTION_RESULT_OK = 0; public final static int ACTION_RESULT_ERROR = 1; public final static int ACTION_RESULT_ERROR_NO_CARRIER = 2; public final static int ACTION_RESULT_ERROR_BUSY = 3; public final static int ACTION_RESULT_ERROR_NO_ANSWER = 4; public final static int ACTION_RESULT_ERROR_DELAYED = 5; public final static int ACTION_RESULT_ERROR_BLACKLISTED = 6; public final static int ACTION_RESULT_ERROR_CME = 7; /* Detailed CME error codes */ public final static int CME_PHONE_FAILURE = 0; public final static int CME_NO_CONNECTION_TO_PHONE = 1; public final static int CME_OPERATION_NOT_ALLOWED = 3; public final static int CME_OPERATION_NOT_SUPPORTED = 4; public final static int CME_PHSIM_PIN_REQUIRED = 5; public final static int CME_PHFSIM_PIN_REQUIRED = 6; public final static int CME_PHFSIM_PUK_REQUIRED = 7; public final static int CME_SIM_NOT_INSERTED = 10; public final static int CME_SIM_PIN_REQUIRED = 11; public final static int CME_SIM_PUK_REQUIRED = 12; public final static int CME_SIM_FAILURE = 13; public final static int CME_SIM_BUSY = 14; public final static int CME_SIM_WRONG = 15; public final static int CME_INCORRECT_PASSWORD = 16; public final static int CME_SIM_PIN2_REQUIRED = 17; public final static int CME_SIM_PUK2_REQUIRED = 18; public final static int CME_MEMORY_FULL = 20; public final static int CME_INVALID_INDEX = 21; public final static int CME_NOT_FOUND = 22; public final static int CME_MEMORY_FAILURE = 23; public final static int CME_TEXT_STRING_TOO_LONG = 24; public final static int CME_INVALID_CHARACTER_IN_TEXT_STRING = 25; public final static int CME_DIAL_STRING_TOO_LONG = 26; public final static int CME_INVALID_CHARACTER_IN_DIAL_STRING = 27; public final static int CME_NO_NETWORK_SERVICE = 30; public final static int CME_NETWORK_TIMEOUT = 31; public final static int CME_EMERGENCY_SERVICE_ONLY = 32; public final static int CME_NO_SIMULTANOUS_VOIP_CS_CALLS = 33; public final static int CME_NOT_SUPPORTED_FOR_VOIP = 34; public final static int CME_SIP_RESPONSE_CODE = 35; public final static int CME_NETWORK_PERSONALIZATION_PIN_REQUIRED = 40; public final static int CME_NETWORK_PERSONALIZATION_PUK_REQUIRED = 41; public final static int CME_NETWORK_SUBSET_PERSONALIZATION_PIN_REQUIRED = 42; public final static int CME_NETWORK_SUBSET_PERSONALIZATION_PUK_REQUIRED = 43; public final static int CME_SERVICE_PROVIDER_PERSONALIZATION_PIN_REQUIRED = 44; public final static int CME_SERVICE_PROVIDER_PERSONALIZATION_PUK_REQUIRED = 45; public final static int CME_CORPORATE_PERSONALIZATION_PIN_REQUIRED = 46; public final static int CME_CORPORATE_PERSONALIZATION_PUK_REQUIRED = 47; public final static int CME_HIDDEN_KEY_REQUIRED = 48; public final static int CME_EAP_NOT_SUPPORTED = 49; public final static int CME_INCORRECT_PARAMETERS = 50; /* Action policy for other calls when accepting call */ public static final int CALL_ACCEPT_NONE = 0; public static final int CALL_ACCEPT_HOLD = 1; public static final int CALL_ACCEPT_TERMINATE = 2; private Context mContext; private ServiceListener mServiceListener; private IBluetoothHeadsetClient mService; private BluetoothAdapter mAdapter; final private IBluetoothStateChangeCallback mBluetoothStateChangeCallback = new IBluetoothStateChangeCallback.Stub() { @Override public void onBluetoothStateChange(boolean up) { if (DBG) Log.d(TAG, "onBluetoothStateChange: up=" + up); if (!up) { if (VDBG) Log.d(TAG,"Unbinding service..."); synchronized (mConnection) { try { mService = null; mContext.unbindService(mConnection); } catch (Exception re) { Log.e(TAG,"",re); } } } else { synchronized (mConnection) { try { if (mService == null) { if (VDBG) Log.d(TAG,"Binding service..."); Intent intent = new Intent(IBluetoothHeadsetClient.class.getName()); doBind(); } } catch (Exception re) { Log.e(TAG,"",re); } } } } }; /** * Create a BluetoothHeadsetClient proxy object. */ /*package*/ BluetoothHeadsetClient(Context context, ServiceListener l) { mContext = context; mServiceListener = l; mAdapter = BluetoothAdapter.getDefaultAdapter(); IBluetoothManager mgr = mAdapter.getBluetoothManager(); if (mgr != null) { try { mgr.registerStateChangeCallback(mBluetoothStateChangeCallback); } catch (RemoteException e) { Log.e(TAG,"",e); } } doBind(); } boolean doBind() { Intent intent = new Intent(IBluetoothHeadsetClient.class.getName()); ComponentName comp = intent.resolveSystemService(mContext.getPackageManager(), 0); intent.setComponent(comp); if (comp == null || !mContext.bindServiceAsUser(intent, mConnection, 0, android.os.Process.myUserHandle())) { Log.e(TAG, "Could not bind to Bluetooth Headset Client Service with " + intent); return false; } return true; } /** * Close the connection to the backing service. * Other public functions of BluetoothHeadsetClient will return default error * results once close() has been called. Multiple invocations of close() * are ok. */ /*package*/ void close() { if (VDBG) log("close()"); IBluetoothManager mgr = mAdapter.getBluetoothManager(); if (mgr != null) { try { mgr.unregisterStateChangeCallback(mBluetoothStateChangeCallback); } catch (Exception e) { Log.e(TAG,"",e); } } synchronized (mConnection) { if (mService != null) { try { mService = null; mContext.unbindService(mConnection); } catch (Exception re) { Log.e(TAG,"",re); } } } mServiceListener = null; } /** * Connects to remote device. * * Currently, the system supports only 1 connection. So, in case of the * second connection, this implementation will disconnect already connected * device automatically and will process the new one. * * @param device a remote device we want connect to * @return <code>true</code> if command has been issued successfully; * <code>false</code> otherwise; * upon completion HFP sends {@link #ACTION_CONNECTION_STATE_CHANGED} * intent. */ public boolean connect(BluetoothDevice device) { if (DBG) log("connect(" + device + ")"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.connect(device); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); return false; } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return false; } /** * Disconnects remote device * * @param device a remote device we want disconnect * @return <code>true</code> if command has been issued successfully; * <code>false</code> otherwise; * upon completion HFP sends {@link #ACTION_CONNECTION_STATE_CHANGED} * intent. */ public boolean disconnect(BluetoothDevice device) { if (DBG) log("disconnect(" + device + ")"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.disconnect(device); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); return false; } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return false; } /** * Return the list of connected remote devices * * @return list of connected devices; empty list if nothing is connected. */ @Override public List<BluetoothDevice> getConnectedDevices() { if (VDBG) log("getConnectedDevices()"); if (mService != null && isEnabled()) { try { return mService.getConnectedDevices(); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); return new ArrayList<BluetoothDevice>(); } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return new ArrayList<BluetoothDevice>(); } /** * Returns list of remote devices in a particular state * * @param states collection of states * @return list of devices that state matches the states listed in * <code>states</code>; empty list if nothing matches the * <code>states</code> */ @Override public List<BluetoothDevice> getDevicesMatchingConnectionStates(int[] states) { if (VDBG) log("getDevicesMatchingStates()"); if (mService != null && isEnabled()) { try { return mService.getDevicesMatchingConnectionStates(states); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); return new ArrayList<BluetoothDevice>(); } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return new ArrayList<BluetoothDevice>(); } /** * Returns state of the <code>device</code> * * @param device a remote device * @return the state of connection of the device */ @Override public int getConnectionState(BluetoothDevice device) { if (VDBG) log("getConnectionState(" + device + ")"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.getConnectionState(device); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); return BluetoothProfile.STATE_DISCONNECTED; } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return BluetoothProfile.STATE_DISCONNECTED; } /** * Set priority of the profile * * The device should already be paired. */ public boolean setPriority(BluetoothDevice device, int priority) { if (DBG) log("setPriority(" + device + ", " + priority + ")"); if (mService != null && isEnabled() && isValidDevice(device)) { if (priority != BluetoothProfile.PRIORITY_OFF && priority != BluetoothProfile.PRIORITY_ON) { return false; } try { return mService.setPriority(device, priority); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); return false; } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return false; } /** * Get the priority of the profile. */ public int getPriority(BluetoothDevice device) { if (VDBG) log("getPriority(" + device + ")"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.getPriority(device); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); return PRIORITY_OFF; } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return PRIORITY_OFF; } /** * Starts voice recognition. * * @param device remote device * @return <code>true</code> if command has been issued successfully; * <code>false</code> otherwise; * upon completion HFP sends {@link #ACTION_AG_EVENT} * intent. * * <p>Feature required for successful execution is being reported by: * {@link #EXTRA_AG_FEATURE_VOICE_RECOGNITION}. * This method invocation will fail silently when feature is not supported.</p> */ public boolean startVoiceRecognition(BluetoothDevice device) { if (DBG) log("startVoiceRecognition()"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.startVoiceRecognition(device); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return false; } /** * Stops voice recognition. * * @param device remote device * @return <code>true</code> if command has been issued successfully; * <code>false</code> otherwise; * upon completion HFP sends {@link #ACTION_AG_EVENT} * intent. * * <p>Feature required for successful execution is being reported by: * {@link #EXTRA_AG_FEATURE_VOICE_RECOGNITION}. * This method invocation will fail silently when feature is not supported.</p> */ public boolean stopVoiceRecognition(BluetoothDevice device) { if (DBG) log("stopVoiceRecognition()"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.stopVoiceRecognition(device); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return false; } /** * Returns list of all calls in any state. * * @param device remote device * @return list of calls; empty list if none call exists */ public List<BluetoothHeadsetClientCall> getCurrentCalls(BluetoothDevice device) { if (DBG) log("getCurrentCalls()"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.getCurrentCalls(device); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return null; } /** * Returns list of current values of AG indicators. * * @param device remote device * @return bundle of AG indicators; null if device is not in * CONNECTED state */ public Bundle getCurrentAgEvents(BluetoothDevice device) { if (DBG) log("getCurrentCalls()"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.getCurrentAgEvents(device); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return null; } /** * Accepts a call * * @param device remote device * @param flag action policy while accepting a call. Possible values * {@link #CALL_ACCEPT_NONE}, {@link #CALL_ACCEPT_HOLD}, * {@link #CALL_ACCEPT_TERMINATE} * @return <code>true</code> if command has been issued successfully; * <code>false</code> otherwise; * upon completion HFP sends {@link #ACTION_CALL_CHANGED} * intent. */ public boolean acceptCall(BluetoothDevice device, int flag) { if (DBG) log("acceptCall()"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.acceptCall(device, flag); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return false; } /** * Holds a call. * * @param device remote device * @return <code>true</code> if command has been issued successfully; * <code>false</code> otherwise; * upon completion HFP sends {@link #ACTION_CALL_CHANGED} * intent. */ public boolean holdCall(BluetoothDevice device) { if (DBG) log("holdCall()"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.holdCall(device); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return false; } /** * Rejects a call. * * @param device remote device * @return <code>true</code> if command has been issued successfully; * <code>false</code> otherwise; * upon completion HFP sends {@link #ACTION_CALL_CHANGED} * intent. * * <p>Feature required for successful execution is being reported by: * {@link #EXTRA_AG_FEATURE_REJECT_CALL}. * This method invocation will fail silently when feature is not supported.</p> */ public boolean rejectCall(BluetoothDevice device) { if (DBG) log("rejectCall()"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.rejectCall(device); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return false; } /** * Terminates a specified call. * * Works only when Extended Call Control is supported by Audio Gateway. * * @param device remote device * @param index index of the call to be terminated * @return <code>true</code> if command has been issued successfully; * <code>false</code> otherwise; * upon completion HFP sends {@link #ACTION_CALL_CHANGED} * intent. * * <p>Feature required for successful execution is being reported by: * {@link #EXTRA_AG_FEATURE_ECC}. * This method invocation will fail silently when feature is not supported.</p> */ public boolean terminateCall(BluetoothDevice device, int index) { if (DBG) log("terminateCall()"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.terminateCall(device, index); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return false; } /** * Enters private mode with a specified call. * * Works only when Extended Call Control is supported by Audio Gateway. * * @param device remote device * @param index index of the call to connect in private mode * @return <code>true</code> if command has been issued successfully; * <code>false</code> otherwise; * upon completion HFP sends {@link #ACTION_CALL_CHANGED} * intent. * * <p>Feature required for successful execution is being reported by: * {@link #EXTRA_AG_FEATURE_ECC}. * This method invocation will fail silently when feature is not supported.</p> */ public boolean enterPrivateMode(BluetoothDevice device, int index) { if (DBG) log("enterPrivateMode()"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.enterPrivateMode(device, index); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return false; } /** * Performs explicit call transfer. * * That means connect other calls and disconnect. * * @param device remote device * @return <code>true</code> if command has been issued successfully; * <code>false</code> otherwise; * upon completion HFP sends {@link #ACTION_CALL_CHANGED} * intent. * * <p>Feature required for successful execution is being reported by: * {@link #EXTRA_AG_FEATURE_MERGE_AND_DETACH}. * This method invocation will fail silently when feature is not supported.</p> */ public boolean explicitCallTransfer(BluetoothDevice device) { if (DBG) log("explicitCallTransfer()"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.explicitCallTransfer(device); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return false; } /** * Redials last number from Audio Gateway. * * @param device remote device * @return <code>true</code> if command has been issued successfully; * <code>false</code> otherwise; * upon completion HFP sends {@link #ACTION_CALL_CHANGED} * intent in case of success; {@link #ACTION_RESULT} is sent * otherwise; */ public boolean redial(BluetoothDevice device) { if (DBG) log("redial()"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.redial(device); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return false; } /** * Places a call with specified number. * * @param device remote device * @param number valid phone number * @return <code>true</code> if command has been issued successfully; * <code>false</code> otherwise; * upon completion HFP sends {@link #ACTION_CALL_CHANGED} * intent in case of success; {@link #ACTION_RESULT} is sent * otherwise; */ public boolean dial(BluetoothDevice device, String number) { if (DBG) log("dial()"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.dial(device, number); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return false; } /** * Places a call to the number under specified memory location. * * @param device remote device * @param location valid memory location * @return <code>true</code> if command has been issued successfully; * <code>false</code> otherwise; * upon completion HFP sends {@link #ACTION_CALL_CHANGED} * intent in case of success; {@link #ACTION_RESULT} is sent * otherwise; */ public boolean dialMemory(BluetoothDevice device, int location) { if (DBG) log("dialMemory()"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.dialMemory(device, location); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return false; } /** * Sends DTMF code. * * Possible code values : 0,1,2,3,4,5,6,7,8,9,A,B,C,D,*,# * * @param device remote device * @param code ASCII code * @return <code>true</code> if command has been issued successfully; * <code>false</code> otherwise; * upon completion HFP sends {@link #ACTION_RESULT} intent; */ public boolean sendDTMF(BluetoothDevice device, byte code) { if (DBG) log("sendDTMF()"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.sendDTMF(device, code); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return false; } /** * Get a number corresponding to last voice tag recorded on AG. * * @param device remote device * @return <code>true</code> if command has been issued successfully; * <code>false</code> otherwise; * upon completion HFP sends {@link #ACTION_LAST_VTAG} * or {@link #ACTION_RESULT} intent; * * <p>Feature required for successful execution is being reported by: * {@link #EXTRA_AG_FEATURE_ATTACH_NUMBER_TO_VT}. * This method invocation will fail silently when feature is not supported.</p> */ public boolean getLastVoiceTagNumber(BluetoothDevice device) { if (DBG) log("getLastVoiceTagNumber()"); if (mService != null && isEnabled() && isValidDevice(device)) { try { return mService.getLastVoiceTagNumber(device); } catch (RemoteException e) { Log.e(TAG, Log.getStackTraceString(new Throwable())); } } if (mService == null) Log.w(TAG, "Proxy not attached to service"); return false; } /** * Accept the incoming connection. */ public boolean acceptIncomingConnect(BluetoothDevice device) { if (DBG) log("acceptIncomingConnect"); if (mService != null && isEnabled()) { try { return mService.acceptIncomingConnect(device); } catch (RemoteException e) {Log.e(TAG, e.toString());} } else { Log.w(TAG, "Proxy not attached to service"); if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable())); } return false; } /** * Reject the incoming connection. */ public boolean rejectIncomingConnect(BluetoothDevice device) { if (DBG) log("rejectIncomingConnect"); if (mService != null) { try { return mService.rejectIncomingConnect(device); } catch (RemoteException e) {Log.e(TAG, e.toString());} } else { Log.w(TAG, "Proxy not attached to service"); if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable())); } return false; } /** * Returns current audio state of Audio Gateway. * * Note: This is an internal function and shouldn't be exposed */ public int getAudioState(BluetoothDevice device) { if (VDBG) log("getAudioState"); if (mService != null && isEnabled()) { try { return mService.getAudioState(device); } catch (RemoteException e) {Log.e(TAG, e.toString());} } else { Log.w(TAG, "Proxy not attached to service"); if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable())); } return BluetoothHeadsetClient.STATE_AUDIO_DISCONNECTED; } /** * Initiates a connection of audio channel. * * It setup SCO channel with remote connected Handsfree AG device. * * @return <code>true</code> if command has been issued successfully; * <code>false</code> otherwise; * upon completion HFP sends {@link #ACTION_AUDIO_STATE_CHANGED} * intent; */ public boolean connectAudio() { if (mService != null && isEnabled()) { try { return mService.connectAudio(); } catch (RemoteException e) { Log.e(TAG, e.toString()); } } else { Log.w(TAG, "Proxy not attached to service"); if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable())); } return false; } /** * Disconnects audio channel. * * It tears down the SCO channel from remote AG device. * * @return <code>true</code> if command has been issued successfully; * <code>false</code> otherwise; * upon completion HFP sends {@link #ACTION_AUDIO_STATE_CHANGED} * intent; */ public boolean disconnectAudio() { if (mService != null && isEnabled()) { try { return mService.disconnectAudio(); } catch (RemoteException e) { Log.e(TAG, e.toString()); } } else { Log.w(TAG, "Proxy not attached to service"); if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable())); } return false; } /** * Get Audio Gateway features * * @param device remote device * @return bundle of AG features; null if no service or * AG not connected */ public Bundle getCurrentAgFeatures(BluetoothDevice device) { if (mService != null && isEnabled()) { try { return mService.getCurrentAgFeatures(device); } catch (RemoteException e) { Log.e(TAG, e.toString()); } } else { Log.w(TAG, "Proxy not attached to service"); if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable())); } return null; } private ServiceConnection mConnection = new ServiceConnection() { @Override public void onServiceConnected(ComponentName className, IBinder service) { if (DBG) Log.d(TAG, "Proxy object connected"); mService = IBluetoothHeadsetClient.Stub.asInterface(service); if (mServiceListener != null) { mServiceListener.onServiceConnected(BluetoothProfile.HEADSET_CLIENT, BluetoothHeadsetClient.this); } } @Override public void onServiceDisconnected(ComponentName className) { if (DBG) Log.d(TAG, "Proxy object disconnected"); mService = null; if (mServiceListener != null) { mServiceListener.onServiceDisconnected(BluetoothProfile.HEADSET_CLIENT); } } }; private boolean isEnabled() { if (mAdapter.getState() == BluetoothAdapter.STATE_ON) return true; return false; } private boolean isValidDevice(BluetoothDevice device) { if (device == null) return false; if (BluetoothAdapter.checkBluetoothAddress(device.getAddress())) return true; return false; } private static void log(String msg) { Log.d(TAG, msg); } }