/* * Copyright (C) 2020 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.bluetooth.telephony; import static java.util.Objects.requireNonNull; import static java.util.Objects.requireNonNullElseGet; import android.annotation.NonNull; import android.bluetooth.BluetoothAdapter; import android.bluetooth.BluetoothLeCall; import android.bluetooth.BluetoothLeCallControl; import android.bluetooth.BluetoothManager; import android.bluetooth.BluetoothProfile; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.net.Uri; import android.os.Binder; import android.os.Bundle; import android.os.IBinder; import android.telecom.BluetoothCallQualityReport; import android.telecom.Call; import android.telecom.CallAudioState; import android.telecom.Connection; import android.telecom.DisconnectCause; import android.telecom.InCallService; import android.telecom.PhoneAccount; import android.telecom.PhoneAccountHandle; import android.telecom.TelecomManager; import android.telecom.VideoProfile; import android.telephony.PhoneNumberUtils; import android.telephony.TelephonyManager; import android.text.TextUtils; import android.util.Log; import androidx.annotation.VisibleForTesting; import com.android.bluetooth.Utils; import com.android.bluetooth.flags.Flags; import com.android.bluetooth.hfp.HeadsetService; import com.android.bluetooth.tbs.BluetoothLeCallControlProxy; import java.util.ArrayDeque; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.Objects; import java.util.Queue; import java.util.Set; import java.util.SortedMap; import java.util.SortedSet; import java.util.TreeMap; import java.util.TreeSet; import java.util.UUID; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * Used to receive updates about calls from the Telecom component. This service is bound to Telecom * while there exist calls which potentially require UI. This includes ringing (incoming), dialing * (outgoing), and active calls. When the last BluetoothCall is disconnected, Telecom will unbind to * the service triggering InCallActivity (via CallList) to finish soon after. */ public class BluetoothInCallService extends InCallService { private static final String TAG = BluetoothInCallService.class.getSimpleName(); // match up with bthf_call_state_t of bt_hf.h private static class CallState { private CallState() {} static final int ACTIVE = 0; static final int HELD = 1; static final int DIALING = 2; static final int ALERTING = 3; static final int INCOMING = 4; static final int WAITING = 5; static final int IDLE = 6; static final int DISCONNECTED = 7; } @VisibleForTesting static class TerminationReason { private TerminationReason() {} static final int INVALID_URI = 0x00; static final int FAIL = 0x01; static final int REMOTE_HANGUP = 0x02; static final int SERVER_HANGUP = 0x03; static final int LINE_BUSY = 0x04; static final int NETWORK_CONGESTION = 0x05; static final int CLIENT_HANGUP = 0x06; static final int NO_SERVICE = 0x07; static final int NO_ANSWER = 0x08; } public static class Result { private Result() {} public static final int SUCCESS = 0; public static final int ERROR_UNKNOWN_CALL_ID = 1; public static final int ERROR_INVALID_URI = 2; public static final int ERROR_APPLICATION = 3; } public static class Capability { private Capability() {} public static final int HOLD_CALL = 0x00000001; public static final int JOIN_CALLS = 0x00000002; } // match up with bthf_call_state_t of bt_hf.h // Terminate all held or set UDUB("busy") to a waiting call private static final int CHLD_TYPE_RELEASEHELD = 0; // Terminate all active calls and accepts a waiting/held call private static final int CHLD_TYPE_RELEASEACTIVE_ACCEPTHELD = 1; // Hold all active calls and accepts a waiting/held call private static final int CHLD_TYPE_HOLDACTIVE_ACCEPTHELD = 2; // Add all held calls to a conference private static final int CHLD_TYPE_ADDHELDTOCONF = 3; // Indicates that no BluetoothCall is ringing private static final int DEFAULT_RINGING_ADDRESS_TYPE = 128; private int mNumActiveCalls = 0; private int mNumHeldCalls = 0; private int mNumChildrenOfActiveCall = 0; private int mBluetoothCallState = CallState.IDLE; private String mRingingAddress = ""; private int mRingingAddressType = DEFAULT_RINGING_ADDRESS_TYPE; private BluetoothCall mOldHeldCall = null; private boolean mHeadsetUpdatedRecently = false; @VisibleForTesting boolean mIsTerminatedByClient = false; private static final Object LOCK = new Object(); @VisibleForTesting BluetoothLeCallControlProxy mBluetoothLeCallControl; private final ExecutorService mExecutor; private TelephonyManager mTelephonyManager; private TelecomManager mTelecomManager; @VisibleForTesting public final HashMap mCallbacks = new HashMap<>(); @VisibleForTesting public final HashMap mBluetoothCallHashMap = new HashMap<>(); private final HashMap mBluetoothConferenceCallInference = new HashMap<>(); private final HashMap mConferenceCallClccIndexMap = new HashMap<>(); // A queue record the removal order of bluetooth calls private final Queue mBluetoothCallQueue = new ArrayDeque<>(); private static BluetoothInCallService sInstance = null; private final CallInfo mCallInfo; private int mMaxNumberOfCalls = 0; private BluetoothAdapter mAdapter = null; private final BluetoothProfile.ServiceListener mProfileListener = new BluetoothProfile.ServiceListener() { @Override public void onServiceConnected(int profile, BluetoothProfile proxy) { Log.d(TAG, "onServiceConnected for profile: " + profile); synchronized (LOCK) { mBluetoothLeCallControl = new BluetoothLeCallControlProxy((BluetoothLeCallControl) proxy); boolean isBearerRegistered = mBluetoothLeCallControl.registerBearer( TAG, List.of("tel"), Capability.HOLD_CALL, getNetworkOperator(), getBearerTechnology(), mExecutor, mBluetoothLeCallControlCallback); Log.d(TAG, "isBearerRegistered: " + isBearerRegistered); sendTbsCurrentCallsList(); } Log.d(TAG, "Calls updated for profile: " + profile); } @Override public void onServiceDisconnected(int profile) { synchronized (LOCK) { mBluetoothLeCallControl = null; } } }; public class BluetoothAdapterReceiver extends BroadcastReceiver { @Override public void onReceive(Context context, Intent intent) { synchronized (LOCK) { int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR); Log.d(TAG, "Bluetooth Adapter state: " + state); if (state == BluetoothAdapter.STATE_ON) { queryPhoneState(HeadsetService.getHeadsetService()); } else if (state == BluetoothAdapter.STATE_TURNING_OFF) { clear(); } } } } /** Receives events for global state changes of the bluetooth adapter. */ // TODO: The code is moved from Telecom stack. Since we're running in the BT process itself, // we may be able to simplify this in a future patch. @VisibleForTesting public BluetoothAdapterReceiver mBluetoothAdapterReceiver; @VisibleForTesting public class CallStateCallback extends Call.Callback { public int mLastState; public CallStateCallback(int initialState) { mLastState = initialState; } public int getLastState() { return mLastState; } void onStateChanged(BluetoothCall call, int state) { if (mCallInfo.isNullCall(call)) { return; } if (call.isExternalCall()) { return; } if (state == Call.STATE_DISCONNECTING) { mLastState = state; return; } Integer tbsCallState = getTbsCallState(call); if (mBluetoothLeCallControl != null && tbsCallState != null) { mBluetoothLeCallControl.onCallStateChanged(call.getTbsCallId(), tbsCallState); } // If a BluetoothCall is being put on hold because of a new connecting call, ignore the // CONNECTING since the BT state update needs to send out the numHeld = 1 + dialing // state atomically. // When the BluetoothCall later transitions to DIALING/DISCONNECTED we will then // send out the aggregated update. if (getLastState() == Call.STATE_ACTIVE && state == Call.STATE_HOLDING) { for (BluetoothCall otherCall : mCallInfo.getBluetoothCalls()) { if (otherCall.getState() == Call.STATE_CONNECTING) { mLastState = state; return; } } } // To have an active BluetoothCall and another dialing at the same time is an invalid BT // state. We can assume that the active BluetoothCall will be automatically held // which will send another update at which point we will be in the right state. BluetoothCall activeCall = mCallInfo.getActiveCall(); if (!mCallInfo.isNullCall(activeCall) && getLastState() == Call.STATE_CONNECTING && (state == Call.STATE_DIALING || state == Call.STATE_PULLING_CALL)) { mLastState = state; return; } mLastState = state; updateHeadsetWithCallState(HeadsetService.getHeadsetService(), false /* force */); } @Override public void onStateChanged(Call call, int state) { super.onStateChanged(call, state); onStateChanged(getBluetoothCallById(System.identityHashCode(call)), state); } @VisibleForTesting void onDetailsChanged( HeadsetService headsetService, BluetoothCall call, Call.Details details) { if (mCallInfo.isNullCall(call)) { return; } if (call.isExternalCall()) { onCallRemoved(headsetService, call, false /* forceRemoveCallback */); } else { onCallAdded(headsetService, call); } } @Override public void onDetailsChanged(Call call, Call.Details details) { super.onDetailsChanged(call, details); onDetailsChanged( HeadsetService.getHeadsetService(), getBluetoothCallById(System.identityHashCode(call)), details); } @VisibleForTesting void onParentChanged(HeadsetService headsetService, BluetoothCall call) { if (mCallInfo.isNullCall(call) || call.isExternalCall()) { Log.w(TAG, "null call or external call"); return; } if (call.getParentId() != null) { // If this BluetoothCall is newly conferenced, ignore the callback. // We only care about the one sent for the parent conference call. Log.d( TAG, "Ignoring onIsConferenceChanged from child BluetoothCall with new parent"); return; } updateHeadsetWithCallState(headsetService, false /* force */); } @Override public void onParentChanged(Call call, Call parent) { super.onParentChanged(call, parent); onParentChanged( HeadsetService.getHeadsetService(), getBluetoothCallById(System.identityHashCode(call))); } @VisibleForTesting void onChildrenChanged( HeadsetService headsetService, BluetoothCall call, List children) { if (mCallInfo.isNullCall(call) || call.isExternalCall()) { Log.w(TAG, "null call or external call"); return; } if (call.getChildrenIds().size() == 1) { // If this is a parent BluetoothCall with only one child, // ignore the callback as well since the minimum number of child calls to // start a conference BluetoothCall is 2. We expect this to be called again // when the parent BluetoothCall has another child BluetoothCall added. Log.d(TAG, "Ignoring onIsConferenceChanged from parent with only one child call"); return; } updateHeadsetWithCallState(headsetService, false /* force */); } @Override public void onChildrenChanged(Call call, List children) { super.onChildrenChanged(call, children); onChildrenChanged( HeadsetService.getHeadsetService(), getBluetoothCallById(System.identityHashCode(call)), getBluetoothCallsByIds(BluetoothCall.getIds(children))); } } @Override public IBinder onBind(Intent intent) { Log.i(TAG, "onBind. Intent: " + intent); return super.onBind(intent); } @Override public boolean onUnbind(Intent intent) { Log.i(TAG, "onUnbind. Intent: " + intent); return super.onUnbind(intent); } private BluetoothInCallService(CallInfo callInfo) { Log.i(TAG, "BluetoothInCallService is created"); mCallInfo = requireNonNullElseGet(callInfo, () -> new CallInfo()); mExecutor = Executors.newSingleThreadExecutor(); } public BluetoothInCallService() { this(null); } @VisibleForTesting BluetoothInCallService( Context context, CallInfo callInfo, BluetoothLeCallControlProxy leCallControl) { this(callInfo); mBluetoothLeCallControl = leCallControl; attachBaseContext(context); } public static BluetoothInCallService getInstance() { return sInstance; } public boolean answerCall() { synchronized (LOCK) { Log.i(TAG, "BT - answering call"); BluetoothCall call = mCallInfo.getRingingOrSimulatedRingingCall(); if (mCallInfo.isNullCall(call)) { return false; } call.answer(VideoProfile.STATE_AUDIO_ONLY); return true; } } public boolean hangupCall() { synchronized (LOCK) { Log.i(TAG, "BT - hanging up call"); BluetoothCall call = mCallInfo.getForegroundCall(); if (mCallInfo.isNullCall(call)) { return false; } // release the parent if there is a conference call BluetoothCall conferenceCall = getBluetoothCallById(call.getParentId()); if (!mCallInfo.isNullCall(conferenceCall) && conferenceCall.getState() == Call.STATE_ACTIVE) { Log.i(TAG, "BT - hanging up conference call"); call = conferenceCall; } else if (Flags.nonConferenceCallHangup() && !mCallInfo.isNullCall(conferenceCall) && conferenceCall.getState() == Call.STATE_HOLDING) { Log.i(TAG, "BT - hanging up active call other than conference call"); /* Find active call other than conference */ for (BluetoothCall btCall : mCallInfo.getBluetoothCalls()) { if (!btCall.isConference() && btCall.getState() == Call.STATE_ACTIVE && btCall.getParentId() == null) { call = btCall; break; } } } if (call.getState() == Call.STATE_RINGING) { call.reject(false, ""); } else { call.disconnect(); } return true; } } public boolean sendDtmf(int dtmf) { synchronized (LOCK) { Log.i(TAG, "BT - sendDtmf " + dtmf); BluetoothCall call = mCallInfo.getForegroundCall(); if (mCallInfo.isNullCall(call)) { return false; } // TODO: Consider making this a queue instead of starting/stopping in quick succession. call.playDtmfTone((char) dtmf); call.stopDtmfTone(); return true; } } public String getNetworkOperator() { synchronized (LOCK) { Log.i(TAG, "getNetworkOperator"); PhoneAccount account = mCallInfo.getBestPhoneAccount(); if (account != null && account.getLabel() != null) { return account.getLabel().toString(); } // Finally, just get the network name from telephony. return mTelephonyManager.getNetworkOperatorName(); } } /** * Gets the bearer technology. * * @return bearer technology as defined in Bluetooth Assigned Numbers */ @VisibleForTesting int getBearerTechnology() { synchronized (LOCK) { Log.i(TAG, "getBearerTechnology"); // Get the network name from telephony. int dataNetworkType = mTelephonyManager.getDataNetworkType(); switch (dataNetworkType) { case TelephonyManager.NETWORK_TYPE_UNKNOWN: case TelephonyManager.NETWORK_TYPE_GSM: return BluetoothLeCallControlProxy.BEARER_TECHNOLOGY_GSM; case TelephonyManager.NETWORK_TYPE_GPRS: return BluetoothLeCallControlProxy.BEARER_TECHNOLOGY_2G; case TelephonyManager.NETWORK_TYPE_EDGE: case TelephonyManager.NETWORK_TYPE_EVDO_0: case TelephonyManager.NETWORK_TYPE_EVDO_A: case TelephonyManager.NETWORK_TYPE_HSDPA: case TelephonyManager.NETWORK_TYPE_HSUPA: case TelephonyManager.NETWORK_TYPE_HSPA: case TelephonyManager.NETWORK_TYPE_IDEN: case TelephonyManager.NETWORK_TYPE_EVDO_B: return BluetoothLeCallControlProxy.BEARER_TECHNOLOGY_3G; case TelephonyManager.NETWORK_TYPE_UMTS: case TelephonyManager.NETWORK_TYPE_TD_SCDMA: return BluetoothLeCallControlProxy.BEARER_TECHNOLOGY_WCDMA; case TelephonyManager.NETWORK_TYPE_LTE: return BluetoothLeCallControlProxy.BEARER_TECHNOLOGY_LTE; case TelephonyManager.NETWORK_TYPE_EHRPD: case TelephonyManager.NETWORK_TYPE_CDMA: case TelephonyManager.NETWORK_TYPE_1xRTT: return BluetoothLeCallControlProxy.BEARER_TECHNOLOGY_CDMA; case TelephonyManager.NETWORK_TYPE_HSPAP: return BluetoothLeCallControlProxy.BEARER_TECHNOLOGY_4G; case TelephonyManager.NETWORK_TYPE_IWLAN: return BluetoothLeCallControlProxy.BEARER_TECHNOLOGY_WIFI; case TelephonyManager.NETWORK_TYPE_NR: return BluetoothLeCallControlProxy.BEARER_TECHNOLOGY_5G; } return BluetoothLeCallControlProxy.BEARER_TECHNOLOGY_GSM; } } public String getSubscriberNumber() { synchronized (LOCK) { Log.i(TAG, "getSubscriberNumber"); String address = null; PhoneAccount account = mCallInfo.getBestPhoneAccount(); if (account != null) { Uri addressUri = account.getAddress(); if (addressUri != null) { address = addressUri.getSchemeSpecificPart(); } } if (TextUtils.isEmpty(address)) { address = mTelephonyManager.getLine1Number(); if (address == null) address = ""; } return address; } } public boolean listCurrentCalls(HeadsetService headsetService) { synchronized (LOCK) { // only log if it is after we recently updated the headset state or else it can // clog the android log since this can be queried every second. boolean logQuery = mHeadsetUpdatedRecently; mHeadsetUpdatedRecently = false; if (logQuery) { Log.i(TAG, "listCurrentCalls"); } sendListOfCalls(headsetService, logQuery); return true; } } public boolean queryPhoneState(HeadsetService headsetService) { synchronized (LOCK) { Log.i(TAG, "queryPhoneState"); updateHeadsetWithCallState(headsetService, true); return true; } } /** Check for HD codec for voice call */ public boolean isHighDefCallInProgress() { boolean isHighDef = false; /* TODO: Add as an API in TelephonyManager aosp/2679237 */ int phoneTypeIms = 5; int phoneTypeCdmaLte = 6; BluetoothCall ringingCall = mCallInfo.getRingingOrSimulatedRingingCall(); BluetoothCall dialingCall = mCallInfo.getOutgoingCall(); BluetoothCall activeCall = mCallInfo.getActiveCall(); /* If it's an incoming call we will have codec info in dialing state */ if (ringingCall != null) { isHighDef = ringingCall.isHighDefAudio(); } else if (dialingCall != null) { /* CS dialing call has codec info in dialing state */ Bundle extras = dialingCall.getDetails().getExtras(); if (extras != null) { int phoneType = extras.getInt(TelecomManager.EXTRA_CALL_TECHNOLOGY_TYPE); if (phoneType == TelephonyManager.PHONE_TYPE_GSM || phoneType == TelephonyManager.PHONE_TYPE_CDMA) { isHighDef = dialingCall.isHighDefAudio(); /* For IMS calls codec info is not present in dialing state */ } else if (phoneType == phoneTypeIms || phoneType == phoneTypeCdmaLte) { isHighDef = true; } } } else if (activeCall != null) { isHighDef = activeCall.isHighDefAudio(); } Log.i(TAG, "isHighDefCallInProgress: Call is High Def " + isHighDef); return isHighDef; } public boolean processChld(HeadsetService headsetService, int chld) { synchronized (LOCK) { final long token = Binder.clearCallingIdentity(); try { Log.i(TAG, "processChld " + chld); return processChldLocked(headsetService, chld); } finally { Binder.restoreCallingIdentity(token); } } } @VisibleForTesting void onCallAdded(HeadsetService headsetService, BluetoothCall call) { synchronized (LOCK) { if (call.isExternalCall()) { Log.d(TAG, "onCallAdded: external call"); return; } if (!mBluetoothCallHashMap.containsKey(call.getId())) { Log.i(TAG, "onCallAdded"); CallStateCallback callback = new CallStateCallback(call.getState()); mCallbacks.put(call.getId(), callback); call.registerCallback(callback); mBluetoothCallHashMap.put(call.getId(), call); if (!call.isConference()) { mMaxNumberOfCalls = Integer.max(mMaxNumberOfCalls, mBluetoothCallHashMap.size()); } updateHeadsetWithCallState(headsetService, false /* force */); BluetoothLeCall tbsCall = createTbsCall(call); if (mBluetoothLeCallControl != null && tbsCall != null) { mBluetoothLeCallControl.onCallAdded(tbsCall); } } else { Log.i(TAG, "onCallAdded: call already exists"); } } } public void sendBluetoothCallQualityReport( long timestamp, int rssi, int snr, int retransmissionCount, int packetsNotReceiveCount, int negativeAcknowledgementCount) { BluetoothCall call = mCallInfo.getForegroundCall(); if (mCallInfo.isNullCall(call)) { Log.w(TAG, "No foreground call while trying to send BQR"); return; } Bundle b = new Bundle(); b.putParcelable( BluetoothCallQualityReport.EXTRA_BLUETOOTH_CALL_QUALITY_REPORT, new BluetoothCallQualityReport.Builder() .setSentTimestampMillis(timestamp) .setChoppyVoice(true) .setRssiDbm(rssi) .setSnrDb(snr) .setRetransmittedPacketsCount(retransmissionCount) .setPacketsNotReceivedCount(packetsNotReceiveCount) .setNegativeAcknowledgementCount(negativeAcknowledgementCount) .build()); call.sendCallEvent(BluetoothCallQualityReport.EVENT_BLUETOOTH_CALL_QUALITY_REPORT, b); } @Override public void onCallAdded(Call call) { super.onCallAdded(call); onCallAdded(HeadsetService.getHeadsetService(), new BluetoothCall(call)); } /** * Called when a {@code BluetoothCall} has been removed from this in-call session. * * @param call the {@code BluetoothCall} to remove * @param forceRemoveCallback if true, this will always unregister this {@code InCallService} as * a callback for the given {@code BluetoothCall}, when false, this will not remove the * callback when the {@code BluetoothCall} is external so that the call can be added back if * no longer external. */ public void onCallRemoved( HeadsetService headsetService, BluetoothCall call, boolean forceRemoveCallback) { synchronized (LOCK) { Log.i(TAG, "onCallRemoved, forceRemoveCallback=" + forceRemoveCallback); CallStateCallback callback = getCallback(call); if (callback != null && (forceRemoveCallback || !call.isExternalCall())) { call.unregisterCallback(callback); } if (mBluetoothCallHashMap.containsKey(call.getId())) { mBluetoothCallHashMap.remove(call.getId()); DisconnectCause cause = call.getDisconnectCause(); if (cause != null && cause.getCode() == DisconnectCause.OTHER) { Log.d(TAG, "add inference call with reason: " + cause.getReason()); mBluetoothCallQueue.add(call.getId()); mBluetoothConferenceCallInference.put(call.getId(), call); if (Flags.maintainCallIndexAfterConference()) { // If the disconnect is due to call merge, store the index for future use. if (cause.getReason() != null && cause.getReason().equals("IMS_MERGED_SUCCESSFULLY")) { if (!mConferenceCallClccIndexMap.containsKey(getClccMapKey(call))) { if (call.mClccIndex > -1) { mConferenceCallClccIndexMap.put( getClccMapKey(call), call.mClccIndex); } } } } // queue size limited to 2 because merge operation only happens on 2 calls // we are only interested in last 2 calls merged if (mBluetoothCallQueue.size() > 2) { Integer callId = mBluetoothCallQueue.peek(); mBluetoothCallQueue.remove(); mBluetoothConferenceCallInference.remove(callId); } } // As there is at most 1 conference call, so clear inference when parent call ends if (call.isConference()) { Log.d(TAG, "conference call ends, clear inference"); mBluetoothConferenceCallInference.clear(); mBluetoothCallQueue.clear(); } } updateHeadsetWithCallState(headsetService, false /* force */); if (Flags.maintainCallIndexAfterConference() && mConferenceCallClccIndexMap.size() > 0) { int anyActiveCalls = mCallInfo.isNullCall(mCallInfo.getActiveCall()) ? 0 : 1; int numHeldCalls = mCallInfo.getNumHeldCalls(); // If no call is active or held clear the hashmap. if (anyActiveCalls == 0 && numHeldCalls == 0) { mConferenceCallClccIndexMap.clear(); } } if (mBluetoothLeCallControl != null) { mBluetoothLeCallControl.onCallRemoved( call.getTbsCallId(), getTbsTerminationReason(call)); } } } @Override public void onCallRemoved(Call call) { super.onCallRemoved(call); BluetoothCall bluetoothCall = getBluetoothCallById(System.identityHashCode(call)); if (bluetoothCall == null) { Log.w(TAG, "onCallRemoved, BluetoothCall is removed before registered"); return; } onCallRemoved( HeadsetService.getHeadsetService(), bluetoothCall, true /* forceRemoveCallback */); } @Override public void onCallAudioStateChanged(CallAudioState audioState) { super.onCallAudioStateChanged(audioState); Log.d(TAG, "onCallAudioStateChanged, audioState == " + audioState); } @Override public void onCreate() { super.onCreate(); synchronized (LOCK) { Log.d(TAG, "onCreate"); mAdapter = requireNonNull(getSystemService(BluetoothManager.class)).getAdapter(); mTelephonyManager = requireNonNull(getSystemService(TelephonyManager.class)); mTelecomManager = requireNonNull(getSystemService(TelecomManager.class)); mAdapter.getProfileProxy(this, mProfileListener, BluetoothProfile.LE_CALL_CONTROL); mBluetoothAdapterReceiver = new BluetoothAdapterReceiver(); IntentFilter intentFilter = new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED); intentFilter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY); registerReceiver(mBluetoothAdapterReceiver, intentFilter); sInstance = this; } } @Override public void onDestroy() { synchronized (LOCK) { Log.d(TAG, "onDestroy"); clear(); } super.onDestroy(); } @Override @VisibleForTesting public void attachBaseContext(Context base) { super.attachBaseContext(base); } @VisibleForTesting void clear() { Log.d(TAG, "clear"); if (mBluetoothAdapterReceiver != null) { unregisterReceiver(mBluetoothAdapterReceiver); mBluetoothAdapterReceiver = null; } if (mBluetoothLeCallControl != null) { mBluetoothLeCallControl.unregisterBearer(); mBluetoothLeCallControl.closeBluetoothLeCallControlProxy(mAdapter); mBluetoothLeCallControl = null; } sInstance = null; mCallbacks.clear(); mBluetoothCallHashMap.clear(); mBluetoothConferenceCallInference.clear(); mBluetoothCallQueue.clear(); mMaxNumberOfCalls = 0; } private static boolean isConferenceWithNoChildren(BluetoothCall call) { return call.isConference() && (call.can(Connection.CAPABILITY_CONFERENCE_HAS_NO_CHILDREN) || call.getChildrenIds().isEmpty()); } private void sendListOfCalls(HeadsetService headsetService, boolean shouldLog) { Collection calls = mCallInfo.getBluetoothCalls(); // either do conference call CLCC index inference or normal conference call BluetoothCall conferenceCallChildrenNotReady = null; for (BluetoothCall call : calls) { // find the conference call parent among calls if (call.isConference() && !mBluetoothConferenceCallInference.isEmpty()) { Log.d( TAG, "conference call inferred size: " + mBluetoothConferenceCallInference.size() + " current size: " + mBluetoothCallHashMap.size()); // Do conference call inference until at least 2 children arrive // If carrier sends children info, then inference will end when info arrives. // If carrier doesn't send children info, then inference won't impact actual value. if (call.getChildrenIds().size() >= 2) { mBluetoothConferenceCallInference.clear(); break; } conferenceCallChildrenNotReady = call; } } if (conferenceCallChildrenNotReady != null) { SortedMap clccResponseMap = new TreeMap<>(); for (BluetoothCall inferredCall : mBluetoothConferenceCallInference.values()) { if (inferredCall.isCallNull() || inferredCall.getHandle() == null) { Log.w(TAG, "inferredCall does not have handle"); continue; } // save the index so later on when real children arrive, index is the same int index = inferredCall.mClccIndex; if (index == -1) { Log.w(TAG, "inferred index is not valid"); continue; } // associate existing bluetoothCall with inferredCall based on call handle for (BluetoothCall bluetoothCall : mBluetoothCallHashMap.values()) { if (bluetoothCall.getHandle() == null) { Log.w(TAG, "call id: " + bluetoothCall.getId() + " handle is null"); continue; } boolean isSame = PhoneNumberUtils.areSamePhoneNumber( bluetoothCall.getHandle().toString(), inferredCall.getHandle().toString(), mTelephonyManager.getNetworkCountryIso()); if (isSame) { Log.d( TAG, "found conference call children that has same call handle, " + "call id: " + bluetoothCall.getId()); bluetoothCall.mClccIndex = inferredCall.mClccIndex; break; } } int direction = inferredCall.isIncoming() ? 1 : 0; int state = CallState.ACTIVE; boolean isPartOfConference = true; final Uri addressUri; if (inferredCall.getGatewayInfo() != null) { addressUri = inferredCall.getGatewayInfo().getOriginalAddress(); } else { addressUri = inferredCall.getHandle(); } String address = addressUri == null ? null : addressUri.getSchemeSpecificPart(); if (address != null) { address = PhoneNumberUtils.stripSeparators(address); } int addressType = address == null ? -1 : PhoneNumberUtils.toaFromString(address); clccResponseMap.put( index, new Object[] { index, direction, state, 0, isPartOfConference, address, addressType }); } // sort CLCC response based on index for (Object[] response : clccResponseMap.values()) { if (response.length < 7) { Log.e(TAG, "clccResponseMap entry too short"); continue; } Log.i( TAG, Utils.formatSimple( "sending inferred clcc for BluetoothCall: index %d, direction" + " %d, state %d, isPartOfConference %b, addressType %d", (int) response[0], (int) response[1], (int) response[2], (boolean) response[4], (int) response[6])); headsetService.clccResponse( (int) response[0], (int) response[1], (int) response[2], (int) response[3], (boolean) response[4], (String) response[5], (int) response[6]); } headsetService.clccResponse(0 /* index */, 0, 0, 0, false, null, 0); // End marker return; } for (BluetoothCall call : calls) { // We don't send the parent conference BluetoothCall to the bluetooth device. // We do, however want to send conferences that have no children to the bluetooth // device (e.g. IMS Conference). boolean isConferenceWithNoChildren = isConferenceWithNoChildren(call); Log.i( TAG, "sendListOfCalls isConferenceWithNoChildren " + isConferenceWithNoChildren + ", call.getChildrenIds() size " + call.getChildrenIds().size()); if (!call.isConference() || isConferenceWithNoChildren) { sendClccForCall(headsetService, call, shouldLog); } } headsetService.clccResponse(0 /* index */, 0, 0, 0, false, null, 0); // End marker } /** Sends a single clcc (C* List Current Calls) event for the specified call. */ private void sendClccForCall( HeadsetService headsetService, BluetoothCall call, boolean shouldLog) { boolean isForeground = call.equals(mCallInfo.getForegroundCall()); int state = getBtCallState(call, isForeground); boolean isPartOfConference = false; boolean isConferenceWithNoChildren = isConferenceWithNoChildren(call); if (state == CallState.IDLE) { return; } BluetoothCall conferenceCall = getBluetoothCallById(call.getParentId()); if (!mCallInfo.isNullCall(conferenceCall)) { isPartOfConference = true; if (conferenceCall.hasProperty(Call.Details.PROPERTY_GENERIC_CONFERENCE)) { // Run some alternative states for CDMA Conference-level merge/swap support. // Basically, if BluetoothCall supports swapping or merging at the conference-level, // then we need to expose the calls as having distinct states // (ACTIVE vs CAPABILITY_HOLD) or // the functionality won't show up on the bluetooth device. // Before doing any special logic, ensure that we are dealing with an // ACTIVE BluetoothCall and that the conference itself has a notion of // the current "active" child call. BluetoothCall activeChild = getBluetoothCallById( conferenceCall.getGenericConferenceActiveChildCallId()); if (state == CallState.ACTIVE && !mCallInfo.isNullCall(activeChild)) { // Reevaluate state if we can MERGE or if we can SWAP without previously having // MERGED. boolean shouldReevaluateState = conferenceCall.can(Connection.CAPABILITY_MERGE_CONFERENCE) || (conferenceCall.can(Connection.CAPABILITY_SWAP_CONFERENCE) && !conferenceCall.wasConferencePreviouslyMerged()); if (shouldReevaluateState) { isPartOfConference = false; if (call.equals(activeChild)) { state = CallState.ACTIVE; } else { // At this point we know there is an "active" child and we know that it // is not this call, so set it to HELD instead. state = CallState.HELD; } } } } if (conferenceCall.getState() == Call.STATE_HOLDING && conferenceCall.can(Connection.CAPABILITY_MANAGE_CONFERENCE)) { // If the parent IMS CEP conference BluetoothCall is on hold, we should mark // this BluetoothCall as being on hold regardless of what the other // children are doing. state = CallState.HELD; } } else if (isConferenceWithNoChildren) { // Handle the special case of an IMS conference BluetoothCall without conference // event package support. // The BluetoothCall will be marked as a conference, but the conference will not have // child calls where conference event packages are not used by the carrier. isPartOfConference = true; } int index = getIndexForCall(call); int direction = call.isIncoming() ? 1 : 0; final Uri addressUri; if (call.getGatewayInfo() != null) { addressUri = call.getGatewayInfo().getOriginalAddress(); } else { addressUri = call.getHandle(); } String address = addressUri == null ? null : addressUri.getSchemeSpecificPart(); if (address != null) { address = PhoneNumberUtils.stripSeparators(address); } int addressType = address == null ? -1 : PhoneNumberUtils.toaFromString(address); if (shouldLog) { Log.i( TAG, "sending clcc for BluetoothCall " + index + ", " + direction + ", " + state + ", " + isPartOfConference + ", " + addressType); } headsetService.clccResponse( index, direction, state, 0, isPartOfConference, address, addressType); } int getNextAvailableClccIndex(int index) { // find the next available smallest index SortedSet availableIndex = new TreeSet<>(); for (int i = index; i <= mMaxNumberOfCalls + 1; i++) { availableIndex.add(i); } for (BluetoothCall bluetoothCall : mBluetoothCallHashMap.values()) { int callCLCCIndex = bluetoothCall.mClccIndex; if (availableIndex.contains(callCLCCIndex)) { availableIndex.remove(callCLCCIndex); } } Log.d(TAG, "availableIndex first: " + availableIndex.first()); return availableIndex.first(); } @VisibleForTesting /* Function to extract and return call handle. */ private String getClccMapKey(BluetoothCall call) { if (mCallInfo.isNullCall(call) || call.getHandle() == null) { return ""; } Uri handle = call.getHandle(); String key; if (call.hasProperty(Call.Details.PROPERTY_SELF_MANAGED)) { key = handle.toString() + " self managed " + call.getId(); } else { key = handle.toString(); } Log.d(TAG, "getClccMapKey Key: " + key); return key; } /** * Returns the caches index for the specified call. If no such index exists, then an index is * given (the smallest number starting from 1 that isn't already taken). */ private int getIndexForCall(BluetoothCall call) { if (mCallInfo.isNullCall(call)) { Log.w(TAG, "empty or null call"); return -1; } // Check if the call handle is already stored. Return the previously stored index. if (Flags.maintainCallIndexAfterConference() && mConferenceCallClccIndexMap.containsKey(getClccMapKey(call))) { call.mClccIndex = mConferenceCallClccIndexMap.get(getClccMapKey(call)); } if (call.mClccIndex >= 1) { return call.mClccIndex; } int index = 1; // Indexes for bluetooth clcc are 1-based. if (call.isConference()) { index = mMaxNumberOfCalls + 1; // The conference call should have a higher index Log.i(TAG, "getIndexForCall for conference call starting from " + mMaxNumberOfCalls); } // NOTE: Indexes are removed in {@link #onCallRemoved}. call.mClccIndex = getNextAvailableClccIndex(index); if (Flags.maintainCallIndexAfterConference()) { // Remove the index from conference hashmap, this can be later added if call merges in // conference mConferenceCallClccIndexMap .entrySet() .removeIf(entry -> entry.getValue() == call.mClccIndex); } Log.d(TAG, "call " + call.getId() + " CLCC index is " + call.mClccIndex); return call.mClccIndex; } private boolean processChldLocked(HeadsetService headsetService, int chld) { BluetoothCall activeCall = mCallInfo.getActiveCall(); BluetoothCall ringingCall = mCallInfo.getRingingOrSimulatedRingingCall(); if (ringingCall == null) { Log.i(TAG, "ringingCall null at processChld"); } else { Log.i(TAG, "ringingCall hashcode: " + ringingCall.hashCode()); } BluetoothCall heldCall = mCallInfo.getHeldCall(); Log.i( TAG, "Active: " + activeCall + " Ringing: " + ringingCall + " Held: " + heldCall + " chld: " + chld); if (chld == CHLD_TYPE_RELEASEHELD) { Log.i(TAG, "chld is CHLD_TYPE_RELEASEHELD"); if (!mCallInfo.isNullCall(ringingCall)) { Log.i(TAG, "reject ringing call " + ringingCall.hashCode()); ringingCall.reject(false, null); return true; } else if (!mCallInfo.isNullCall(heldCall)) { heldCall.disconnect(); return true; } } else if (chld == CHLD_TYPE_RELEASEACTIVE_ACCEPTHELD) { if (mCallInfo.isNullCall(activeCall) && mCallInfo.isNullCall(ringingCall) && mCallInfo.isNullCall(heldCall)) { return false; } if (!mCallInfo.isNullCall(activeCall)) { BluetoothCall conferenceCall = getBluetoothCallById(activeCall.getParentId()); if (!mCallInfo.isNullCall(conferenceCall) && conferenceCall.getState() == Call.STATE_ACTIVE) { Log.i(TAG, "CHLD: disconnect conference call"); conferenceCall.disconnect(); } else { activeCall.disconnect(); } } if (!mCallInfo.isNullCall(ringingCall)) { ringingCall.answer(ringingCall.getVideoState()); } else if (!mCallInfo.isNullCall(heldCall)) { heldCall.unhold(); } return true; } else if (chld == CHLD_TYPE_HOLDACTIVE_ACCEPTHELD) { if (!mCallInfo.isNullCall(activeCall) && activeCall.can(Connection.CAPABILITY_SWAP_CONFERENCE)) { activeCall.swapConference(); Log.i(TAG, "CDMA calls in conference swapped, updating headset"); updateHeadsetWithCallState(headsetService, true /* force */); return true; } else if (!mCallInfo.isNullCall(ringingCall)) { ringingCall.answer(VideoProfile.STATE_AUDIO_ONLY); return true; } else if (!mCallInfo.isNullCall(heldCall)) { // CallsManager will hold any active calls when unhold() is called on a // currently-held call. heldCall.unhold(); return true; } else if (!mCallInfo.isNullCall(activeCall) && activeCall.can(Connection.CAPABILITY_HOLD)) { activeCall.hold(); return true; } } else if (chld == CHLD_TYPE_ADDHELDTOCONF) { if (!mCallInfo.isNullCall(activeCall)) { if (activeCall.can(Connection.CAPABILITY_MERGE_CONFERENCE)) { activeCall.mergeConference(); return true; } else { List conferenceable = getBluetoothCallsByIds(activeCall.getConferenceableCalls()); if (!conferenceable.isEmpty()) { activeCall.conference(conferenceable.get(0)); return true; } } } } return false; } /** * Sends an update of the current BluetoothCall state to the current Headset. * * @param force {@code true} if the headset state should be sent regardless if no changes to the * state have occurred, {@code false} if the state should only be sent if the state has * changed. */ private void updateHeadsetWithCallState(HeadsetService headsetService, boolean force) { if (headsetService == null) { Log.i(TAG, "updateHeadsetWithCallState skipped: No headset service"); return; } BluetoothCall activeCall = mCallInfo.getActiveCall(); BluetoothCall ringingCall = mCallInfo.getRingingOrSimulatedRingingCall(); BluetoothCall heldCall = mCallInfo.getHeldCall(); int bluetoothCallState = getBluetoothCallStateForUpdate(); String ringingAddress = null; int ringingAddressType = DEFAULT_RINGING_ADDRESS_TYPE; String ringingName = null; if (!mCallInfo.isNullCall(ringingCall) && ringingCall.getHandle() != null && !ringingCall.isSilentRingingRequested()) { ringingAddress = ringingCall.getHandle().getSchemeSpecificPart(); if (ringingAddress != null) { ringingAddressType = PhoneNumberUtils.toaFromString(ringingAddress); } ringingName = ringingCall.getCallerDisplayName(); if (TextUtils.isEmpty(ringingName)) { ringingName = ringingCall.getContactDisplayName(); } } if (ringingAddress == null) { ringingAddress = ""; } int numActiveCalls = mCallInfo.isNullCall(activeCall) ? 0 : 1; int numHeldCalls = mCallInfo.getNumHeldCalls(); int numChildrenOfActiveCall = mCallInfo.isNullCall(activeCall) ? 0 : activeCall.getChildrenIds().size(); // Intermediate state for GSM calls which are in the process of being swapped. // TODO: Should we be hardcoding this value to 2 or should we check if all top level calls // are held? boolean callsPendingSwitch = (numHeldCalls == 2); // For conference calls which support swapping the active BluetoothCall within the // conference (namely CDMA calls) we need to expose that as a held BluetoothCall // in order for the BT device to show "swap" and "merge" functionality. boolean ignoreHeldCallChange = false; if (!mCallInfo.isNullCall(activeCall) && activeCall.isConference() && !activeCall.can(Connection.CAPABILITY_CONFERENCE_HAS_NO_CHILDREN)) { if (activeCall.can(Connection.CAPABILITY_SWAP_CONFERENCE)) { // Indicate that BT device should show SWAP command by indicating that there is a // BluetoothCall on hold, but only if the conference wasn't previously merged. numHeldCalls = activeCall.wasConferencePreviouslyMerged() ? 0 : 1; } else if (activeCall.can(Connection.CAPABILITY_MERGE_CONFERENCE)) { numHeldCalls = 1; // Merge is available, so expose via numHeldCalls. } for (Integer id : activeCall.getChildrenIds()) { // Held BluetoothCall has changed due to it being combined into a CDMA conference. // Keep track of this and ignore any future update since it doesn't really count // as a BluetoothCall change. if (mOldHeldCall != null && Objects.equals(mOldHeldCall.getId(), id)) { ignoreHeldCallChange = true; break; } } } boolean callsDetailsChanged = numActiveCalls != mNumActiveCalls || numChildrenOfActiveCall != mNumChildrenOfActiveCall || numHeldCalls != mNumHeldCalls || bluetoothCallState != mBluetoothCallState || !TextUtils.equals(ringingAddress, mRingingAddress) || ringingAddressType != mRingingAddressType || (!Objects.equals(heldCall, mOldHeldCall) && !ignoreHeldCallChange); if (!(force || (!callsPendingSwitch && callsDetailsChanged))) { Log.i(TAG, "updateHeadsetWithCallState skipped"); return; } mOldHeldCall = heldCall; mNumActiveCalls = numActiveCalls; mNumChildrenOfActiveCall = numChildrenOfActiveCall; mNumHeldCalls = numHeldCalls; mRingingAddress = ringingAddress; mRingingAddressType = ringingAddressType; // If the BluetoothCall is transitioning into the alerting state, send DIALING first. // Some devices expect to see a DIALING state prior to seeing an ALERTING state // so we need to send it first. if (mBluetoothCallState != bluetoothCallState && bluetoothCallState == CallState.ALERTING) { phoneStateChanged(headsetService, CallState.DIALING, ringingName); } phoneStateChanged(headsetService, bluetoothCallState, ringingName); mBluetoothCallState = bluetoothCallState; mHeadsetUpdatedRecently = true; } private void phoneStateChanged( HeadsetService headsetService, int callState, String ringingName) { Log.i( TAG, "updateHeadsetWithCallState " + (" numActive=" + mNumActiveCalls) + (" numHeld=" + mNumHeldCalls) + (" callState=" + callState) + (" ringingType=" + mRingingAddressType)); headsetService.phoneStateChanged( mNumActiveCalls, mNumHeldCalls, callState, mRingingAddress, mRingingAddressType, ringingName, false); // isVirtualCall } private int getBluetoothCallStateForUpdate() { BluetoothCall ringingCall = mCallInfo.getRingingOrSimulatedRingingCall(); BluetoothCall dialingCall = mCallInfo.getOutgoingCall(); boolean hasOnlyDisconnectedCalls = mCallInfo.hasOnlyDisconnectedCalls(); // // !! WARNING !! // You will note that WAITING, HELD, and ACTIVE are not used in this version of the // BluetoothCall state mappings. // This is on purpose. // phone_state_change() in btif_hf.c is not written to handle these states. // Only with the listCalls*() method are WAITING and ACTIVE used. // Using the unsupported states here caused problems with inconsistent state in some // bluetooth devices (like not getting out of ringing state after answering a call). // int bluetoothCallState = CallState.IDLE; if (!mCallInfo.isNullCall(ringingCall) && !ringingCall.isSilentRingingRequested()) { bluetoothCallState = CallState.INCOMING; } else if (!mCallInfo.isNullCall(dialingCall)) { bluetoothCallState = CallState.ALERTING; } else if (hasOnlyDisconnectedCalls) { // Keep the DISCONNECTED state until the disconnect tone's playback is done bluetoothCallState = CallState.DISCONNECTED; } return bluetoothCallState; } private static int getBtCallState(BluetoothCall call, boolean isForeground) { return switch (call.getState()) { case Call.STATE_ACTIVE -> CallState.ACTIVE; case Call.STATE_HOLDING -> CallState.HELD; case Call.STATE_NEW, Call.STATE_DISCONNECTED, Call.STATE_AUDIO_PROCESSING -> CallState.IDLE; case Call.STATE_CONNECTING, Call.STATE_SELECT_PHONE_ACCOUNT, Call.STATE_DIALING, Call.STATE_PULLING_CALL -> // Yes, this is correctly returning ALERTING. // "Dialing" for BT means that we have sent information to the service provider // to place the BluetoothCall but there is no confirmation that the // BluetoothCall // is going through. When there finally is confirmation, the ringback is // played which is referred to as an "alert" tone, thus, ALERTING. // TODO: We should consider using the ALERTING terms in Telecom because that // seems to be more industry-standard. CallState.ALERTING; case Call.STATE_RINGING, Call.STATE_SIMULATED_RINGING -> { if (call.isSilentRingingRequested()) { yield CallState.IDLE; } else if (isForeground) { yield CallState.INCOMING; } else { yield CallState.WAITING; } } default -> CallState.IDLE; }; } @VisibleForTesting public CallStateCallback getCallback(BluetoothCall call) { return mCallbacks.get(call.getId()); } @VisibleForTesting public BluetoothCall getBluetoothCallById(Integer id) { if (mBluetoothCallHashMap.containsKey(id)) { return mBluetoothCallHashMap.get(id); } return null; } @VisibleForTesting public List getBluetoothCallsByIds(List ids) { List calls = new ArrayList<>(); for (Integer id : ids) { BluetoothCall call = getBluetoothCallById(id); if (!mCallInfo.isNullCall(call)) { calls.add(call); } } return calls; } // extract call information functions out into this part, so we can mock it in testing @VisibleForTesting public class CallInfo { public BluetoothCall getForegroundCall() { LinkedHashSet states = new LinkedHashSet(); BluetoothCall foregroundCall; states.add(Call.STATE_CONNECTING); foregroundCall = getCallByStates(states); if (!mCallInfo.isNullCall(foregroundCall)) { return foregroundCall; } states.clear(); states.add(Call.STATE_ACTIVE); states.add(Call.STATE_DIALING); states.add(Call.STATE_PULLING_CALL); foregroundCall = getCallByStates(states); if (!mCallInfo.isNullCall(foregroundCall)) { return foregroundCall; } states.clear(); states.add(Call.STATE_RINGING); foregroundCall = getCallByStates(states); if (!mCallInfo.isNullCall(foregroundCall)) { return foregroundCall; } return null; } public BluetoothCall getCallByStates(Set states) { List calls = getBluetoothCalls(); for (BluetoothCall call : calls) { if (states.contains(call.getState())) { return call; } } return null; } public BluetoothCall getCallByState(int state) { List calls = getBluetoothCalls(); for (BluetoothCall call : calls) { if (state == call.getState()) { return call; } } return null; } public int getNumHeldCalls() { int number = 0; List calls = getBluetoothCalls(); for (BluetoothCall call : calls) { if (call.getState() == Call.STATE_HOLDING) { number++; } } return number; } public boolean hasOnlyDisconnectedCalls() { List calls = getBluetoothCalls(); if (calls.size() == 0) { return false; } for (BluetoothCall call : calls) { if (call.getState() != Call.STATE_DISCONNECTED && call.getState() != Call.STATE_DISCONNECTING) { return false; } } return true; } public List getBluetoothCalls() { return getBluetoothCallsByIds(BluetoothCall.getIds(getCalls())); } public BluetoothCall getOutgoingCall() { LinkedHashSet states = new LinkedHashSet(); states.add(Call.STATE_CONNECTING); states.add(Call.STATE_DIALING); states.add(Call.STATE_PULLING_CALL); return getCallByStates(states); } public BluetoothCall getRingingOrSimulatedRingingCall() { LinkedHashSet states = new LinkedHashSet(); states.add(Call.STATE_RINGING); states.add(Call.STATE_SIMULATED_RINGING); return getCallByStates(states); } public BluetoothCall getActiveCall() { return getCallByState(Call.STATE_ACTIVE); } public BluetoothCall getHeldCall() { return getCallByState(Call.STATE_HOLDING); } /** * Returns the best phone account to use for the given state of all calls. First, tries to * return the phone account for the foreground call, second the default phone account for * PhoneAccount.SCHEME_TEL. */ public PhoneAccount getBestPhoneAccount() { BluetoothCall call = getForegroundCall(); PhoneAccount account = null; if (!mCallInfo.isNullCall(call)) { PhoneAccountHandle handle = call.getAccountHandle(); if (handle != null) { // First try to get the network name of the foreground call. account = mTelecomManager.getPhoneAccount(handle); } } if (account == null) { // Second, Try to get the label for the default Phone Account. List handles = mTelecomManager.getPhoneAccountsSupportingScheme(PhoneAccount.SCHEME_TEL); while (handles.iterator().hasNext()) { account = mTelecomManager.getPhoneAccount(handles.iterator().next()); if (account != null) { return account; } } } return null; } public boolean isNullCall(BluetoothCall call) { return call == null || call.isCallNull(); } public BluetoothCall getCallByCallId(UUID callId) { List calls = getBluetoothCalls(); for (BluetoothCall call : calls) { Log.i(TAG, "getCallByCallId lookingFor=" + callId + " has=" + call.getTbsCallId()); if (callId.equals(call.getTbsCallId())) { return call; } } return null; } } private static Integer getTbsCallState(BluetoothCall call) { return switch (call.getState()) { case Call.STATE_ACTIVE -> BluetoothLeCall.STATE_ACTIVE; case Call.STATE_HOLDING -> BluetoothLeCall.STATE_LOCALLY_HELD; case Call.STATE_DIALING, Call.STATE_PULLING_CALL -> BluetoothLeCall.STATE_ALERTING; case Call.STATE_CONNECTING, Call.STATE_SELECT_PHONE_ACCOUNT -> BluetoothLeCall.STATE_DIALING; case Call.STATE_RINGING, Call.STATE_SIMULATED_RINGING -> { if (call.isSilentRingingRequested()) { yield null; } else { yield BluetoothLeCall.STATE_INCOMING; } } default -> null; }; } @VisibleForTesting int getTbsTerminationReason(BluetoothCall call) { DisconnectCause cause = call.getDisconnectCause(); if (cause == null) { Log.w(TAG, " termination cause is null"); return TerminationReason.FAIL; } return switch (cause.getCode()) { case DisconnectCause.BUSY -> TerminationReason.LINE_BUSY; case DisconnectCause.ERROR -> TerminationReason.NETWORK_CONGESTION; case DisconnectCause.CONNECTION_MANAGER_NOT_SUPPORTED -> TerminationReason.INVALID_URI; case DisconnectCause.REMOTE, DisconnectCause.REJECTED -> TerminationReason.REMOTE_HANGUP; case DisconnectCause.LOCAL -> { if (mIsTerminatedByClient) { mIsTerminatedByClient = false; yield TerminationReason.CLIENT_HANGUP; } yield TerminationReason.SERVER_HANGUP; } default -> TerminationReason.FAIL; }; } private BluetoothLeCall createTbsCall(BluetoothCall call) { Integer state = getTbsCallState(call); boolean isConferenceWithNoChildren = isConferenceWithNoChildren(call); if (state == null) { return null; } BluetoothCall conferenceCall = getBluetoothCallById(call.getParentId()); if (!mCallInfo.isNullCall(conferenceCall)) { // Run some alternative states for Conference-level merge/swap support. // Basically, if BluetoothCall supports swapping or merging at the // conference-level, // then we need to expose the calls as having distinct states // (ACTIVE vs CAPABILITY_HOLD) or // the functionality won't show up on the bluetooth device. // Before doing any special logic, ensure that we are dealing with an // ACTIVE BluetoothCall and that the conference itself has a notion of // the current "active" child call. BluetoothCall activeChild = getBluetoothCallById(conferenceCall.getGenericConferenceActiveChildCallId()); if (state == BluetoothLeCall.STATE_ACTIVE && !mCallInfo.isNullCall(activeChild)) { // Reevaluate state if we can MERGE or if we can SWAP without previously having // MERGED. boolean shouldReevaluateState = conferenceCall.can(Connection.CAPABILITY_MERGE_CONFERENCE) || (conferenceCall.can(Connection.CAPABILITY_SWAP_CONFERENCE) && !conferenceCall.wasConferencePreviouslyMerged()); if (shouldReevaluateState) { if (call.equals(activeChild)) { state = BluetoothLeCall.STATE_ACTIVE; } else { // At this point we know there is an "active" child and we know that it is // not this call, so set it to HELD instead. state = BluetoothLeCall.STATE_LOCALLY_HELD; } } } if (conferenceCall.getState() == Call.STATE_HOLDING && conferenceCall.can(Connection.CAPABILITY_MANAGE_CONFERENCE)) { // If the parent IMS CEP conference BluetoothCall is on hold, we should mark // this BluetoothCall as being on hold regardless of what the other // children are doing. state = BluetoothLeCall.STATE_LOCALLY_HELD; } } else if (isConferenceWithNoChildren) { // Handle the special case of an IMS conference BluetoothCall without conference // event package support. // The BluetoothCall will be marked as a conference, but the conference will not // have // child calls where conference event packages are not used by the carrier. } final Uri addressUri; if (call.getGatewayInfo() != null) { addressUri = call.getGatewayInfo().getOriginalAddress(); } else { addressUri = call.getHandle(); } String uri = addressUri == null ? null : addressUri.toString(); int callFlags = call.isIncoming() ? 0 : BluetoothLeCall.FLAG_OUTGOING_CALL; String friendlyName = call.getCallerDisplayName(); if (TextUtils.isEmpty(friendlyName)) { friendlyName = call.getContactDisplayName(); } return new BluetoothLeCall(call.getTbsCallId(), uri, friendlyName, state, callFlags); } private void sendTbsCurrentCallsList() { List tbsCalls = new ArrayList<>(); for (BluetoothCall call : mBluetoothCallHashMap.values()) { BluetoothLeCall tbsCall = createTbsCall(call); if (tbsCall != null) { tbsCalls.add(tbsCall); } } mBluetoothLeCallControl.currentCallsList(tbsCalls); } @VisibleForTesting final BluetoothLeCallControl.Callback mBluetoothLeCallControlCallback = new BluetoothLeCallControl.Callback() { @Override public void onAcceptCall(int requestId, UUID callId) { synchronized (LOCK) { Log.i(TAG, "TBS - accept call=" + callId); int result = Result.SUCCESS; BluetoothCall call = mCallInfo.getCallByCallId(callId); if (mCallInfo.isNullCall(call)) { result = Result.ERROR_UNKNOWN_CALL_ID; } else { call.answer(VideoProfile.STATE_AUDIO_ONLY); } mBluetoothLeCallControl.requestResult(requestId, result); } } @Override public void onTerminateCall(int requestId, UUID callId) { synchronized (LOCK) { Log.i(TAG, "TBS - terminate call=" + callId); int result = Result.SUCCESS; BluetoothCall call = mCallInfo.getCallByCallId(callId); if (mCallInfo.isNullCall(call)) { result = Result.ERROR_UNKNOWN_CALL_ID; } else { mIsTerminatedByClient = true; call.disconnect(); } mBluetoothLeCallControl.requestResult(requestId, result); } } @Override public void onHoldCall(int requestId, UUID callId) { synchronized (LOCK) { Log.i(TAG, "TBS - hold call=" + callId); int result = Result.SUCCESS; BluetoothCall call = mCallInfo.getCallByCallId(callId); if (mCallInfo.isNullCall(call)) { result = Result.ERROR_UNKNOWN_CALL_ID; } else { call.hold(); } mBluetoothLeCallControl.requestResult(requestId, result); } } @Override public void onUnholdCall(int requestId, UUID callId) { synchronized (LOCK) { Log.i(TAG, "TBS - unhold call=" + callId); int result = Result.SUCCESS; BluetoothCall call = mCallInfo.getCallByCallId(callId); if (mCallInfo.isNullCall(call)) { result = Result.ERROR_UNKNOWN_CALL_ID; } else { call.unhold(); } mBluetoothLeCallControl.requestResult(requestId, result); } } @Override public void onPlaceCall(int requestId, UUID callId, String uri) { mBluetoothLeCallControl.requestResult(requestId, Result.ERROR_APPLICATION); } @Override public void onJoinCalls(int requestId, @NonNull List callIds) { synchronized (LOCK) { Log.i(TAG, "TBS - onJoinCalls"); List alreadyJoinedCalls = new ArrayList<>(); BluetoothCall baseCallInstance = null; if (callIds.size() < 2) { Log.e( TAG, "TBS - onJoinCalls, join call number is invalid: " + callIds.size()); mBluetoothLeCallControl.requestResult( requestId, Result.ERROR_UNKNOWN_CALL_ID); return; } for (UUID callToJoinUuid : callIds) { BluetoothCall callToJoinInstance = mCallInfo.getCallByCallId(callToJoinUuid); /* Skip invalid and already add device */ if ((callToJoinInstance == null) || (alreadyJoinedCalls.contains(callToJoinUuid))) { continue; } /* Lets make first valid call the base call */ if (baseCallInstance == null) { baseCallInstance = callToJoinInstance; alreadyJoinedCalls.add(callToJoinUuid); continue; } baseCallInstance.conference(callToJoinInstance); alreadyJoinedCalls.add(callToJoinUuid); } int result = Result.SUCCESS; if ((baseCallInstance == null) || (alreadyJoinedCalls.size() < 2)) { result = Result.ERROR_UNKNOWN_CALL_ID; } mBluetoothLeCallControl.requestResult(requestId, result); } } }; }