/*
* 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);
}
}
|
