Java tutorial
/* * 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.telecom; import android.annotation.SdkConstant; import android.app.Service; import android.content.ComponentName; import android.content.Intent; import android.net.Uri; import android.os.Bundle; import android.os.Handler; import android.os.IBinder; import android.os.Looper; import android.os.Message; import android.os.ParcelFileDescriptor; import android.os.RemoteException; import android.telecom.Logging.Session; import com.android.internal.os.SomeArgs; import com.android.internal.telecom.IConnectionService; import com.android.internal.telecom.IConnectionServiceAdapter; import com.android.internal.telecom.RemoteServiceCallback; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.Map; import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; /** * An abstract service that should be implemented by any apps which either: * <ol> * <li>Can make phone calls (VoIP or otherwise) and want those calls to be integrated into the * built-in phone app. Referred to as a <b>system managed</b> {@link ConnectionService}.</li> * <li>Are a standalone calling app and don't want their calls to be integrated into the * built-in phone app. Referred to as a <b>self managed</b> {@link ConnectionService}.</li> * </ol> * Once implemented, the {@link ConnectionService} needs to take the following steps so that Telecom * will bind to it: * <p> * 1. <i>Registration in AndroidManifest.xml</i> * <br/> * <pre> * <service android:name="com.example.package.MyConnectionService" * android:label="@string/some_label_for_my_connection_service" * android:permission="android.permission.BIND_TELECOM_CONNECTION_SERVICE"> * <intent-filter> * <action android:name="android.telecom.ConnectionService" /> * </intent-filter> * </service> * </pre> * <p> * 2. <i> Registration of {@link PhoneAccount} with {@link TelecomManager}.</i> * <br/> * See {@link PhoneAccount} and {@link TelecomManager#registerPhoneAccount} for more information. * <p> * System managed {@link ConnectionService}s must be enabled by the user in the phone app settings * before Telecom will bind to them. Self-managed {@link ConnectionService}s must be granted the * appropriate permission before Telecom will bind to them. * <p> * Once registered and enabled by the user in the phone app settings or granted permission, telecom * will bind to a {@link ConnectionService} implementation when it wants that * {@link ConnectionService} to place a call or the service has indicated that is has an incoming * call through {@link TelecomManager#addNewIncomingCall}. The {@link ConnectionService} can then * expect a call to {@link #onCreateIncomingConnection} or {@link #onCreateOutgoingConnection} * wherein it should provide a new instance of a {@link Connection} object. It is through this * {@link Connection} object that telecom receives state updates and the {@link ConnectionService} * receives call-commands such as answer, reject, hold and disconnect. * <p> * When there are no more live calls, telecom will unbind from the {@link ConnectionService}. */ public abstract class ConnectionService extends Service { /** * The {@link Intent} that must be declared as handled by the service. */ @SdkConstant(SdkConstant.SdkConstantType.SERVICE_ACTION) public static final String SERVICE_INTERFACE = "android.telecom.ConnectionService"; /** * Boolean extra used by Telecom to inform a {@link ConnectionService} that the purpose of it * being asked to create a new outgoing {@link Connection} is to perform a handover of an * ongoing call on the device from another {@link PhoneAccount}/{@link ConnectionService}. Will * be specified in the {@link ConnectionRequest#getExtras()} passed by Telecom when * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)} is called. * <p> * When your {@link ConnectionService} receives this extra, it should communicate the fact that * this is a handover to the other device's matching {@link ConnectionService}. That * {@link ConnectionService} will continue the handover using * {@link TelecomManager#addNewIncomingCall(PhoneAccountHandle, Bundle)}, specifying * {@link TelecomManager#EXTRA_IS_HANDOVER}. Telecom will match the phone numbers of the * handover call on the other device with ongoing calls for {@link ConnectionService}s which * support {@link PhoneAccount#EXTRA_SUPPORTS_HANDOVER_FROM}. * @hide */ public static final String EXTRA_IS_HANDOVER = TelecomManager.EXTRA_IS_HANDOVER; // Flag controlling whether PII is emitted into the logs private static final boolean PII_DEBUG = Log.isLoggable(android.util.Log.DEBUG); // Session Definitions private static final String SESSION_HANDLER = "H."; private static final String SESSION_ADD_CS_ADAPTER = "CS.aCSA"; private static final String SESSION_REMOVE_CS_ADAPTER = "CS.rCSA"; private static final String SESSION_CREATE_CONN = "CS.crCo"; private static final String SESSION_CREATE_CONN_COMPLETE = "CS.crCoC"; private static final String SESSION_CREATE_CONN_FAILED = "CS.crCoF"; private static final String SESSION_ABORT = "CS.ab"; private static final String SESSION_ANSWER = "CS.an"; private static final String SESSION_ANSWER_VIDEO = "CS.anV"; private static final String SESSION_DEFLECT = "CS.def"; private static final String SESSION_REJECT = "CS.r"; private static final String SESSION_REJECT_MESSAGE = "CS.rWM"; private static final String SESSION_SILENCE = "CS.s"; private static final String SESSION_DISCONNECT = "CS.d"; private static final String SESSION_HOLD = "CS.h"; private static final String SESSION_UNHOLD = "CS.u"; private static final String SESSION_CALL_AUDIO_SC = "CS.cASC"; private static final String SESSION_PLAY_DTMF = "CS.pDT"; private static final String SESSION_STOP_DTMF = "CS.sDT"; private static final String SESSION_CONFERENCE = "CS.c"; private static final String SESSION_SPLIT_CONFERENCE = "CS.sFC"; private static final String SESSION_MERGE_CONFERENCE = "CS.mC"; private static final String SESSION_SWAP_CONFERENCE = "CS.sC"; private static final String SESSION_POST_DIAL_CONT = "CS.oPDC"; private static final String SESSION_PULL_EXTERNAL_CALL = "CS.pEC"; private static final String SESSION_SEND_CALL_EVENT = "CS.sCE"; private static final String SESSION_HANDOVER_COMPLETE = "CS.hC"; private static final String SESSION_EXTRAS_CHANGED = "CS.oEC"; private static final String SESSION_START_RTT = "CS.+RTT"; private static final String SESSION_UPDATE_RTT_PIPES = "CS.uRTT"; private static final String SESSION_STOP_RTT = "CS.-RTT"; private static final String SESSION_RTT_UPGRADE_RESPONSE = "CS.rTRUR"; private static final String SESSION_CONNECTION_SERVICE_FOCUS_LOST = "CS.cSFL"; private static final String SESSION_CONNECTION_SERVICE_FOCUS_GAINED = "CS.cSFG"; private static final String SESSION_HANDOVER_FAILED = "CS.haF"; private static final int MSG_ADD_CONNECTION_SERVICE_ADAPTER = 1; private static final int MSG_CREATE_CONNECTION = 2; private static final int MSG_ABORT = 3; private static final int MSG_ANSWER = 4; private static final int MSG_REJECT = 5; private static final int MSG_DISCONNECT = 6; private static final int MSG_HOLD = 7; private static final int MSG_UNHOLD = 8; private static final int MSG_ON_CALL_AUDIO_STATE_CHANGED = 9; private static final int MSG_PLAY_DTMF_TONE = 10; private static final int MSG_STOP_DTMF_TONE = 11; private static final int MSG_CONFERENCE = 12; private static final int MSG_SPLIT_FROM_CONFERENCE = 13; private static final int MSG_ON_POST_DIAL_CONTINUE = 14; private static final int MSG_REMOVE_CONNECTION_SERVICE_ADAPTER = 16; private static final int MSG_ANSWER_VIDEO = 17; private static final int MSG_MERGE_CONFERENCE = 18; private static final int MSG_SWAP_CONFERENCE = 19; private static final int MSG_REJECT_WITH_MESSAGE = 20; private static final int MSG_SILENCE = 21; private static final int MSG_PULL_EXTERNAL_CALL = 22; private static final int MSG_SEND_CALL_EVENT = 23; private static final int MSG_ON_EXTRAS_CHANGED = 24; private static final int MSG_CREATE_CONNECTION_FAILED = 25; private static final int MSG_ON_START_RTT = 26; private static final int MSG_ON_STOP_RTT = 27; private static final int MSG_RTT_UPGRADE_RESPONSE = 28; private static final int MSG_CREATE_CONNECTION_COMPLETE = 29; private static final int MSG_CONNECTION_SERVICE_FOCUS_LOST = 30; private static final int MSG_CONNECTION_SERVICE_FOCUS_GAINED = 31; private static final int MSG_HANDOVER_FAILED = 32; private static final int MSG_HANDOVER_COMPLETE = 33; private static final int MSG_DEFLECT = 34; private static Connection sNullConnection; private final Map<String, Connection> mConnectionById = new ConcurrentHashMap<>(); private final Map<Connection, String> mIdByConnection = new ConcurrentHashMap<>(); private final Map<String, Conference> mConferenceById = new ConcurrentHashMap<>(); private final Map<Conference, String> mIdByConference = new ConcurrentHashMap<>(); private final RemoteConnectionManager mRemoteConnectionManager = new RemoteConnectionManager(this); private final List<Runnable> mPreInitializationConnectionRequests = new ArrayList<>(); private final ConnectionServiceAdapter mAdapter = new ConnectionServiceAdapter(); private boolean mAreAccountsInitialized = false; private Conference sNullConference; private Object mIdSyncRoot = new Object(); private int mId = 0; private final IBinder mBinder = new IConnectionService.Stub() { @Override public void addConnectionServiceAdapter(IConnectionServiceAdapter adapter, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_ADD_CS_ADAPTER); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = adapter; args.arg2 = Log.createSubsession(); mHandler.obtainMessage(MSG_ADD_CONNECTION_SERVICE_ADAPTER, args).sendToTarget(); } finally { Log.endSession(); } } public void removeConnectionServiceAdapter(IConnectionServiceAdapter adapter, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_REMOVE_CS_ADAPTER); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = adapter; args.arg2 = Log.createSubsession(); mHandler.obtainMessage(MSG_REMOVE_CONNECTION_SERVICE_ADAPTER, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void createConnection(PhoneAccountHandle connectionManagerPhoneAccount, String id, ConnectionRequest request, boolean isIncoming, boolean isUnknown, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_CREATE_CONN); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = connectionManagerPhoneAccount; args.arg2 = id; args.arg3 = request; args.arg4 = Log.createSubsession(); args.argi1 = isIncoming ? 1 : 0; args.argi2 = isUnknown ? 1 : 0; mHandler.obtainMessage(MSG_CREATE_CONNECTION, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void createConnectionComplete(String id, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_CREATE_CONN_COMPLETE); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = id; args.arg2 = Log.createSubsession(); mHandler.obtainMessage(MSG_CREATE_CONNECTION_COMPLETE, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void createConnectionFailed(PhoneAccountHandle connectionManagerPhoneAccount, String callId, ConnectionRequest request, boolean isIncoming, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_CREATE_CONN_FAILED); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = request; args.arg3 = Log.createSubsession(); args.arg4 = connectionManagerPhoneAccount; args.argi1 = isIncoming ? 1 : 0; mHandler.obtainMessage(MSG_CREATE_CONNECTION_FAILED, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void handoverFailed(String callId, ConnectionRequest request, int reason, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_HANDOVER_FAILED); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = request; args.arg3 = Log.createSubsession(); args.arg4 = reason; mHandler.obtainMessage(MSG_HANDOVER_FAILED, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void handoverComplete(String callId, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_HANDOVER_COMPLETE); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = Log.createSubsession(); mHandler.obtainMessage(MSG_HANDOVER_COMPLETE, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void abort(String callId, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_ABORT); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = Log.createSubsession(); mHandler.obtainMessage(MSG_ABORT, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void answerVideo(String callId, int videoState, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_ANSWER_VIDEO); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = Log.createSubsession(); args.argi1 = videoState; mHandler.obtainMessage(MSG_ANSWER_VIDEO, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void answer(String callId, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_ANSWER); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = Log.createSubsession(); mHandler.obtainMessage(MSG_ANSWER, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void deflect(String callId, Uri address, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_DEFLECT); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = address; args.arg3 = Log.createSubsession(); mHandler.obtainMessage(MSG_DEFLECT, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void reject(String callId, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_REJECT); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = Log.createSubsession(); mHandler.obtainMessage(MSG_REJECT, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void rejectWithMessage(String callId, String message, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_REJECT_MESSAGE); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = message; args.arg3 = Log.createSubsession(); mHandler.obtainMessage(MSG_REJECT_WITH_MESSAGE, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void silence(String callId, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_SILENCE); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = Log.createSubsession(); mHandler.obtainMessage(MSG_SILENCE, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void disconnect(String callId, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_DISCONNECT); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = Log.createSubsession(); mHandler.obtainMessage(MSG_DISCONNECT, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void hold(String callId, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_HOLD); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = Log.createSubsession(); mHandler.obtainMessage(MSG_HOLD, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void unhold(String callId, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_UNHOLD); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = Log.createSubsession(); mHandler.obtainMessage(MSG_UNHOLD, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void onCallAudioStateChanged(String callId, CallAudioState callAudioState, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_CALL_AUDIO_SC); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = callAudioState; args.arg3 = Log.createSubsession(); mHandler.obtainMessage(MSG_ON_CALL_AUDIO_STATE_CHANGED, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void playDtmfTone(String callId, char digit, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_PLAY_DTMF); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = digit; args.arg2 = callId; args.arg3 = Log.createSubsession(); mHandler.obtainMessage(MSG_PLAY_DTMF_TONE, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void stopDtmfTone(String callId, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_STOP_DTMF); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = Log.createSubsession(); mHandler.obtainMessage(MSG_STOP_DTMF_TONE, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void conference(String callId1, String callId2, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_CONFERENCE); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId1; args.arg2 = callId2; args.arg3 = Log.createSubsession(); mHandler.obtainMessage(MSG_CONFERENCE, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void splitFromConference(String callId, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_SPLIT_CONFERENCE); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = Log.createSubsession(); mHandler.obtainMessage(MSG_SPLIT_FROM_CONFERENCE, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void mergeConference(String callId, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_MERGE_CONFERENCE); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = Log.createSubsession(); mHandler.obtainMessage(MSG_MERGE_CONFERENCE, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void swapConference(String callId, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_SWAP_CONFERENCE); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = Log.createSubsession(); mHandler.obtainMessage(MSG_SWAP_CONFERENCE, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void onPostDialContinue(String callId, boolean proceed, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_POST_DIAL_CONT); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = Log.createSubsession(); args.argi1 = proceed ? 1 : 0; mHandler.obtainMessage(MSG_ON_POST_DIAL_CONTINUE, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void pullExternalCall(String callId, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_PULL_EXTERNAL_CALL); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = Log.createSubsession(); mHandler.obtainMessage(MSG_PULL_EXTERNAL_CALL, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void sendCallEvent(String callId, String event, Bundle extras, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_SEND_CALL_EVENT); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = event; args.arg3 = extras; args.arg4 = Log.createSubsession(); mHandler.obtainMessage(MSG_SEND_CALL_EVENT, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void onExtrasChanged(String callId, Bundle extras, Session.Info sessionInfo) { Log.startSession(sessionInfo, SESSION_EXTRAS_CHANGED); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = extras; args.arg3 = Log.createSubsession(); mHandler.obtainMessage(MSG_ON_EXTRAS_CHANGED, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void startRtt(String callId, ParcelFileDescriptor fromInCall, ParcelFileDescriptor toInCall, Session.Info sessionInfo) throws RemoteException { Log.startSession(sessionInfo, SESSION_START_RTT); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = new Connection.RttTextStream(toInCall, fromInCall); args.arg3 = Log.createSubsession(); mHandler.obtainMessage(MSG_ON_START_RTT, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void stopRtt(String callId, Session.Info sessionInfo) throws RemoteException { Log.startSession(sessionInfo, SESSION_STOP_RTT); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; args.arg2 = Log.createSubsession(); mHandler.obtainMessage(MSG_ON_STOP_RTT, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void respondToRttUpgradeRequest(String callId, ParcelFileDescriptor fromInCall, ParcelFileDescriptor toInCall, Session.Info sessionInfo) throws RemoteException { Log.startSession(sessionInfo, SESSION_RTT_UPGRADE_RESPONSE); try { SomeArgs args = SomeArgs.obtain(); args.arg1 = callId; if (toInCall == null || fromInCall == null) { args.arg2 = null; } else { args.arg2 = new Connection.RttTextStream(toInCall, fromInCall); } args.arg3 = Log.createSubsession(); mHandler.obtainMessage(MSG_RTT_UPGRADE_RESPONSE, args).sendToTarget(); } finally { Log.endSession(); } } @Override public void connectionServiceFocusLost(Session.Info sessionInfo) throws RemoteException { Log.startSession(sessionInfo, SESSION_CONNECTION_SERVICE_FOCUS_LOST); try { mHandler.obtainMessage(MSG_CONNECTION_SERVICE_FOCUS_LOST).sendToTarget(); } finally { Log.endSession(); } } @Override public void connectionServiceFocusGained(Session.Info sessionInfo) throws RemoteException { Log.startSession(sessionInfo, SESSION_CONNECTION_SERVICE_FOCUS_GAINED); try { mHandler.obtainMessage(MSG_CONNECTION_SERVICE_FOCUS_GAINED).sendToTarget(); } finally { Log.endSession(); } } }; private final Handler mHandler = new Handler(Looper.getMainLooper()) { @Override public void handleMessage(Message msg) { switch (msg.what) { case MSG_ADD_CONNECTION_SERVICE_ADAPTER: { SomeArgs args = (SomeArgs) msg.obj; try { IConnectionServiceAdapter adapter = (IConnectionServiceAdapter) args.arg1; Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_ADD_CS_ADAPTER); mAdapter.addAdapter(adapter); onAdapterAttached(); } finally { args.recycle(); Log.endSession(); } break; } case MSG_REMOVE_CONNECTION_SERVICE_ADAPTER: { SomeArgs args = (SomeArgs) msg.obj; try { Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_REMOVE_CS_ADAPTER); mAdapter.removeAdapter((IConnectionServiceAdapter) args.arg1); } finally { args.recycle(); Log.endSession(); } break; } case MSG_CREATE_CONNECTION: { SomeArgs args = (SomeArgs) msg.obj; Log.continueSession((Session) args.arg4, SESSION_HANDLER + SESSION_CREATE_CONN); try { final PhoneAccountHandle connectionManagerPhoneAccount = (PhoneAccountHandle) args.arg1; final String id = (String) args.arg2; final ConnectionRequest request = (ConnectionRequest) args.arg3; final boolean isIncoming = args.argi1 == 1; final boolean isUnknown = args.argi2 == 1; if (!mAreAccountsInitialized) { Log.d(this, "Enqueueing pre-init request %s", id); mPreInitializationConnectionRequests.add(new android.telecom.Logging.Runnable( SESSION_HANDLER + SESSION_CREATE_CONN + ".pICR", null /*lock*/) { @Override public void loggedRun() { createConnection(connectionManagerPhoneAccount, id, request, isIncoming, isUnknown); } }.prepare()); } else { createConnection(connectionManagerPhoneAccount, id, request, isIncoming, isUnknown); } } finally { args.recycle(); Log.endSession(); } break; } case MSG_CREATE_CONNECTION_COMPLETE: { SomeArgs args = (SomeArgs) msg.obj; Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_CREATE_CONN_COMPLETE); try { final String id = (String) args.arg1; if (!mAreAccountsInitialized) { Log.d(this, "Enqueueing pre-init request %s", id); mPreInitializationConnectionRequests.add(new android.telecom.Logging.Runnable( SESSION_HANDLER + SESSION_CREATE_CONN_COMPLETE + ".pICR", null /*lock*/) { @Override public void loggedRun() { notifyCreateConnectionComplete(id); } }.prepare()); } else { notifyCreateConnectionComplete(id); } } finally { args.recycle(); Log.endSession(); } break; } case MSG_CREATE_CONNECTION_FAILED: { SomeArgs args = (SomeArgs) msg.obj; Log.continueSession((Session) args.arg3, SESSION_HANDLER + SESSION_CREATE_CONN_FAILED); try { final String id = (String) args.arg1; final ConnectionRequest request = (ConnectionRequest) args.arg2; final boolean isIncoming = args.argi1 == 1; final PhoneAccountHandle connectionMgrPhoneAccount = (PhoneAccountHandle) args.arg4; if (!mAreAccountsInitialized) { Log.d(this, "Enqueueing pre-init request %s", id); mPreInitializationConnectionRequests.add(new android.telecom.Logging.Runnable( SESSION_HANDLER + SESSION_CREATE_CONN_FAILED + ".pICR", null /*lock*/) { @Override public void loggedRun() { createConnectionFailed(connectionMgrPhoneAccount, id, request, isIncoming); } }.prepare()); } else { Log.i(this, "createConnectionFailed %s", id); createConnectionFailed(connectionMgrPhoneAccount, id, request, isIncoming); } } finally { args.recycle(); Log.endSession(); } break; } case MSG_HANDOVER_FAILED: { SomeArgs args = (SomeArgs) msg.obj; Log.continueSession((Session) args.arg3, SESSION_HANDLER + SESSION_HANDOVER_FAILED); try { final String id = (String) args.arg1; final ConnectionRequest request = (ConnectionRequest) args.arg2; final int reason = (int) args.arg4; if (!mAreAccountsInitialized) { Log.d(this, "Enqueueing pre-init request %s", id); mPreInitializationConnectionRequests.add(new android.telecom.Logging.Runnable( SESSION_HANDLER + SESSION_HANDOVER_FAILED + ".pICR", null /*lock*/) { @Override public void loggedRun() { handoverFailed(id, request, reason); } }.prepare()); } else { Log.i(this, "createConnectionFailed %s", id); handoverFailed(id, request, reason); } } finally { args.recycle(); Log.endSession(); } break; } case MSG_ABORT: { SomeArgs args = (SomeArgs) msg.obj; Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_ABORT); try { abort((String) args.arg1); } finally { args.recycle(); Log.endSession(); } break; } case MSG_ANSWER: { SomeArgs args = (SomeArgs) msg.obj; Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_ANSWER); try { answer((String) args.arg1); } finally { args.recycle(); Log.endSession(); } break; } case MSG_ANSWER_VIDEO: { SomeArgs args = (SomeArgs) msg.obj; Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_ANSWER_VIDEO); try { String callId = (String) args.arg1; int videoState = args.argi1; answerVideo(callId, videoState); } finally { args.recycle(); Log.endSession(); } break; } case MSG_DEFLECT: { SomeArgs args = (SomeArgs) msg.obj; Log.continueSession((Session) args.arg3, SESSION_HANDLER + SESSION_DEFLECT); try { deflect((String) args.arg1, (Uri) args.arg2); } finally { args.recycle(); Log.endSession(); } break; } case MSG_REJECT: { SomeArgs args = (SomeArgs) msg.obj; Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_REJECT); try { reject((String) args.arg1); } finally { args.recycle(); Log.endSession(); } break; } case MSG_REJECT_WITH_MESSAGE: { SomeArgs args = (SomeArgs) msg.obj; Log.continueSession((Session) args.arg3, SESSION_HANDLER + SESSION_REJECT_MESSAGE); try { reject((String) args.arg1, (String) args.arg2); } finally { args.recycle(); Log.endSession(); } break; } case MSG_DISCONNECT: { SomeArgs args = (SomeArgs) msg.obj; Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_DISCONNECT); try { disconnect((String) args.arg1); } finally { args.recycle(); Log.endSession(); } break; } case MSG_SILENCE: { SomeArgs args = (SomeArgs) msg.obj; Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_SILENCE); try { silence((String) args.arg1); } finally { args.recycle(); Log.endSession(); } break; } case MSG_HOLD: { SomeArgs args = (SomeArgs) msg.obj; Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_REJECT); try { hold((String) args.arg1); } finally { args.recycle(); Log.endSession(); } break; } case MSG_UNHOLD: { SomeArgs args = (SomeArgs) msg.obj; Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_UNHOLD); try { unhold((String) args.arg1); } finally { args.recycle(); Log.endSession(); } break; } case MSG_ON_CALL_AUDIO_STATE_CHANGED: { SomeArgs args = (SomeArgs) msg.obj; Log.continueSession((Session) args.arg3, SESSION_HANDLER + SESSION_CALL_AUDIO_SC); try { String callId = (String) args.arg1; CallAudioState audioState = (CallAudioState) args.arg2; onCallAudioStateChanged(callId, new CallAudioState(audioState)); } finally { args.recycle(); Log.endSession(); } break; } case MSG_PLAY_DTMF_TONE: { SomeArgs args = (SomeArgs) msg.obj; try { Log.continueSession((Session) args.arg3, SESSION_HANDLER + SESSION_PLAY_DTMF); playDtmfTone((String) args.arg2, (char) args.arg1); } finally { args.recycle(); Log.endSession(); } break; } case MSG_STOP_DTMF_TONE: { SomeArgs args = (SomeArgs) msg.obj; try { Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_STOP_DTMF); stopDtmfTone((String) args.arg1); } finally { args.recycle(); Log.endSession(); } break; } case MSG_CONFERENCE: { SomeArgs args = (SomeArgs) msg.obj; try { Log.continueSession((Session) args.arg3, SESSION_HANDLER + SESSION_CONFERENCE); String callId1 = (String) args.arg1; String callId2 = (String) args.arg2; conference(callId1, callId2); } finally { args.recycle(); Log.endSession(); } break; } case MSG_SPLIT_FROM_CONFERENCE: { SomeArgs args = (SomeArgs) msg.obj; try { Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_SPLIT_CONFERENCE); splitFromConference((String) args.arg1); } finally { args.recycle(); Log.endSession(); } break; } case MSG_MERGE_CONFERENCE: { SomeArgs args = (SomeArgs) msg.obj; try { Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_MERGE_CONFERENCE); mergeConference((String) args.arg1); } finally { args.recycle(); Log.endSession(); } break; } case MSG_SWAP_CONFERENCE: { SomeArgs args = (SomeArgs) msg.obj; try { Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_SWAP_CONFERENCE); swapConference((String) args.arg1); } finally { args.recycle(); Log.endSession(); } break; } case MSG_ON_POST_DIAL_CONTINUE: { SomeArgs args = (SomeArgs) msg.obj; try { Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_POST_DIAL_CONT); String callId = (String) args.arg1; boolean proceed = (args.argi1 == 1); onPostDialContinue(callId, proceed); } finally { args.recycle(); Log.endSession(); } break; } case MSG_PULL_EXTERNAL_CALL: { SomeArgs args = (SomeArgs) msg.obj; try { Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_PULL_EXTERNAL_CALL); pullExternalCall((String) args.arg1); } finally { args.recycle(); Log.endSession(); } break; } case MSG_SEND_CALL_EVENT: { SomeArgs args = (SomeArgs) msg.obj; try { Log.continueSession((Session) args.arg4, SESSION_HANDLER + SESSION_SEND_CALL_EVENT); String callId = (String) args.arg1; String event = (String) args.arg2; Bundle extras = (Bundle) args.arg3; sendCallEvent(callId, event, extras); } finally { args.recycle(); Log.endSession(); } break; } case MSG_HANDOVER_COMPLETE: { SomeArgs args = (SomeArgs) msg.obj; try { Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_HANDOVER_COMPLETE); String callId = (String) args.arg1; notifyHandoverComplete(callId); } finally { args.recycle(); Log.endSession(); } break; } case MSG_ON_EXTRAS_CHANGED: { SomeArgs args = (SomeArgs) msg.obj; try { Log.continueSession((Session) args.arg3, SESSION_HANDLER + SESSION_EXTRAS_CHANGED); String callId = (String) args.arg1; Bundle extras = (Bundle) args.arg2; handleExtrasChanged(callId, extras); } finally { args.recycle(); Log.endSession(); } break; } case MSG_ON_START_RTT: { SomeArgs args = (SomeArgs) msg.obj; try { Log.continueSession((Session) args.arg3, SESSION_HANDLER + SESSION_START_RTT); String callId = (String) args.arg1; Connection.RttTextStream rttTextStream = (Connection.RttTextStream) args.arg2; startRtt(callId, rttTextStream); } finally { args.recycle(); Log.endSession(); } break; } case MSG_ON_STOP_RTT: { SomeArgs args = (SomeArgs) msg.obj; try { Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_STOP_RTT); String callId = (String) args.arg1; stopRtt(callId); } finally { args.recycle(); Log.endSession(); } break; } case MSG_RTT_UPGRADE_RESPONSE: { SomeArgs args = (SomeArgs) msg.obj; try { Log.continueSession((Session) args.arg3, SESSION_HANDLER + SESSION_RTT_UPGRADE_RESPONSE); String callId = (String) args.arg1; Connection.RttTextStream rttTextStream = (Connection.RttTextStream) args.arg2; handleRttUpgradeResponse(callId, rttTextStream); } finally { args.recycle(); Log.endSession(); } break; } case MSG_CONNECTION_SERVICE_FOCUS_GAINED: onConnectionServiceFocusGained(); break; case MSG_CONNECTION_SERVICE_FOCUS_LOST: onConnectionServiceFocusLost(); break; default: break; } } }; private final Conference.Listener mConferenceListener = new Conference.Listener() { @Override public void onStateChanged(Conference conference, int oldState, int newState) { String id = mIdByConference.get(conference); switch (newState) { case Connection.STATE_ACTIVE: mAdapter.setActive(id); break; case Connection.STATE_HOLDING: mAdapter.setOnHold(id); break; case Connection.STATE_DISCONNECTED: // handled by onDisconnected break; } } @Override public void onDisconnected(Conference conference, DisconnectCause disconnectCause) { String id = mIdByConference.get(conference); mAdapter.setDisconnected(id, disconnectCause); } @Override public void onConnectionAdded(Conference conference, Connection connection) { } @Override public void onConnectionRemoved(Conference conference, Connection connection) { } @Override public void onConferenceableConnectionsChanged(Conference conference, List<Connection> conferenceableConnections) { mAdapter.setConferenceableConnections(mIdByConference.get(conference), createConnectionIdList(conferenceableConnections)); } @Override public void onDestroyed(Conference conference) { removeConference(conference); } @Override public void onConnectionCapabilitiesChanged(Conference conference, int connectionCapabilities) { String id = mIdByConference.get(conference); Log.d(this, "call capabilities: conference: %s", Connection.capabilitiesToString(connectionCapabilities)); mAdapter.setConnectionCapabilities(id, connectionCapabilities); } @Override public void onConnectionPropertiesChanged(Conference conference, int connectionProperties) { String id = mIdByConference.get(conference); Log.d(this, "call capabilities: conference: %s", Connection.propertiesToString(connectionProperties)); mAdapter.setConnectionProperties(id, connectionProperties); } @Override public void onVideoStateChanged(Conference c, int videoState) { String id = mIdByConference.get(c); Log.d(this, "onVideoStateChanged set video state %d", videoState); mAdapter.setVideoState(id, videoState); } @Override public void onVideoProviderChanged(Conference c, Connection.VideoProvider videoProvider) { String id = mIdByConference.get(c); Log.d(this, "onVideoProviderChanged: Connection: %s, VideoProvider: %s", c, videoProvider); mAdapter.setVideoProvider(id, videoProvider); } @Override public void onStatusHintsChanged(Conference conference, StatusHints statusHints) { String id = mIdByConference.get(conference); if (id != null) { mAdapter.setStatusHints(id, statusHints); } } @Override public void onExtrasChanged(Conference c, Bundle extras) { String id = mIdByConference.get(c); if (id != null) { mAdapter.putExtras(id, extras); } } @Override public void onExtrasRemoved(Conference c, List<String> keys) { String id = mIdByConference.get(c); if (id != null) { mAdapter.removeExtras(id, keys); } } @Override public void onConferenceStateChanged(Conference c, boolean isConference) { String id = mIdByConference.get(c); if (id != null) { mAdapter.setConferenceState(id, isConference); } } @Override public void onAddressChanged(Conference c, Uri newAddress, int presentation) { String id = mIdByConference.get(c); if (id != null) { mAdapter.setAddress(id, newAddress, presentation); } } @Override public void onCallerDisplayNameChanged(Conference c, String callerDisplayName, int presentation) { String id = mIdByConference.get(c); if (id != null) { mAdapter.setCallerDisplayName(id, callerDisplayName, presentation); } } @Override public void onConnectionEvent(Conference c, String event, Bundle extras) { String id = mIdByConference.get(c); if (id != null) { mAdapter.onConnectionEvent(id, event, extras); } } }; private final Connection.Listener mConnectionListener = new Connection.Listener() { @Override public void onStateChanged(Connection c, int state) { String id = mIdByConnection.get(c); Log.d(this, "Adapter set state %s %s", id, Connection.stateToString(state)); switch (state) { case Connection.STATE_ACTIVE: mAdapter.setActive(id); break; case Connection.STATE_DIALING: mAdapter.setDialing(id); break; case Connection.STATE_PULLING_CALL: mAdapter.setPulling(id); break; case Connection.STATE_DISCONNECTED: // Handled in onDisconnected() break; case Connection.STATE_HOLDING: mAdapter.setOnHold(id); break; case Connection.STATE_NEW: // Nothing to tell Telecom break; case Connection.STATE_RINGING: mAdapter.setRinging(id); break; } } @Override public void onDisconnected(Connection c, DisconnectCause disconnectCause) { String id = mIdByConnection.get(c); Log.d(this, "Adapter set disconnected %s", disconnectCause); mAdapter.setDisconnected(id, disconnectCause); } @Override public void onVideoStateChanged(Connection c, int videoState) { String id = mIdByConnection.get(c); Log.d(this, "Adapter set video state %d", videoState); mAdapter.setVideoState(id, videoState); } @Override public void onAddressChanged(Connection c, Uri address, int presentation) { String id = mIdByConnection.get(c); mAdapter.setAddress(id, address, presentation); } @Override public void onCallerDisplayNameChanged(Connection c, String callerDisplayName, int presentation) { String id = mIdByConnection.get(c); mAdapter.setCallerDisplayName(id, callerDisplayName, presentation); } @Override public void onDestroyed(Connection c) { removeConnection(c); } @Override public void onPostDialWait(Connection c, String remaining) { String id = mIdByConnection.get(c); Log.d(this, "Adapter onPostDialWait %s, %s", c, remaining); mAdapter.onPostDialWait(id, remaining); } @Override public void onPostDialChar(Connection c, char nextChar) { String id = mIdByConnection.get(c); Log.d(this, "Adapter onPostDialChar %s, %s", c, nextChar); mAdapter.onPostDialChar(id, nextChar); } @Override public void onRingbackRequested(Connection c, boolean ringback) { String id = mIdByConnection.get(c); Log.d(this, "Adapter onRingback %b", ringback); mAdapter.setRingbackRequested(id, ringback); } @Override public void onConnectionCapabilitiesChanged(Connection c, int capabilities) { String id = mIdByConnection.get(c); Log.d(this, "capabilities: parcelableconnection: %s", Connection.capabilitiesToString(capabilities)); mAdapter.setConnectionCapabilities(id, capabilities); } @Override public void onConnectionPropertiesChanged(Connection c, int properties) { String id = mIdByConnection.get(c); Log.d(this, "properties: parcelableconnection: %s", Connection.propertiesToString(properties)); mAdapter.setConnectionProperties(id, properties); } @Override public void onVideoProviderChanged(Connection c, Connection.VideoProvider videoProvider) { String id = mIdByConnection.get(c); Log.d(this, "onVideoProviderChanged: Connection: %s, VideoProvider: %s", c, videoProvider); mAdapter.setVideoProvider(id, videoProvider); } @Override public void onAudioModeIsVoipChanged(Connection c, boolean isVoip) { String id = mIdByConnection.get(c); mAdapter.setIsVoipAudioMode(id, isVoip); } @Override public void onStatusHintsChanged(Connection c, StatusHints statusHints) { String id = mIdByConnection.get(c); mAdapter.setStatusHints(id, statusHints); } @Override public void onConferenceablesChanged(Connection connection, List<Conferenceable> conferenceables) { mAdapter.setConferenceableConnections(mIdByConnection.get(connection), createIdList(conferenceables)); } @Override public void onConferenceChanged(Connection connection, Conference conference) { String id = mIdByConnection.get(connection); if (id != null) { String conferenceId = null; if (conference != null) { conferenceId = mIdByConference.get(conference); } mAdapter.setIsConferenced(id, conferenceId); } } @Override public void onConferenceMergeFailed(Connection connection) { String id = mIdByConnection.get(connection); if (id != null) { mAdapter.onConferenceMergeFailed(id); } } @Override public void onExtrasChanged(Connection c, Bundle extras) { String id = mIdByConnection.get(c); if (id != null) { mAdapter.putExtras(id, extras); } } @Override public void onExtrasRemoved(Connection c, List<String> keys) { String id = mIdByConnection.get(c); if (id != null) { mAdapter.removeExtras(id, keys); } } @Override public void onConnectionEvent(Connection connection, String event, Bundle extras) { String id = mIdByConnection.get(connection); if (id != null) { mAdapter.onConnectionEvent(id, event, extras); } } @Override public void onAudioRouteChanged(Connection c, int audioRoute, String bluetoothAddress) { String id = mIdByConnection.get(c); if (id != null) { mAdapter.setAudioRoute(id, audioRoute, bluetoothAddress); } } @Override public void onRttInitiationSuccess(Connection c) { String id = mIdByConnection.get(c); if (id != null) { mAdapter.onRttInitiationSuccess(id); } } @Override public void onRttInitiationFailure(Connection c, int reason) { String id = mIdByConnection.get(c); if (id != null) { mAdapter.onRttInitiationFailure(id, reason); } } @Override public void onRttSessionRemotelyTerminated(Connection c) { String id = mIdByConnection.get(c); if (id != null) { mAdapter.onRttSessionRemotelyTerminated(id); } } @Override public void onRemoteRttRequest(Connection c) { String id = mIdByConnection.get(c); if (id != null) { mAdapter.onRemoteRttRequest(id); } } @Override public void onPhoneAccountChanged(Connection c, PhoneAccountHandle pHandle) { String id = mIdByConnection.get(c); if (id != null) { mAdapter.onPhoneAccountChanged(id, pHandle); } } public void onConnectionTimeReset(Connection c) { String id = mIdByConnection.get(c); if (id != null) { mAdapter.resetConnectionTime(id); } } }; /** {@inheritDoc} */ @Override public final IBinder onBind(Intent intent) { return mBinder; } /** {@inheritDoc} */ @Override public boolean onUnbind(Intent intent) { endAllConnections(); return super.onUnbind(intent); } /** * This can be used by telecom to either create a new outgoing call or attach to an existing * incoming call. In either case, telecom will cycle through a set of services and call * createConnection util a connection service cancels the process or completes it successfully. */ private void createConnection(final PhoneAccountHandle callManagerAccount, final String callId, final ConnectionRequest request, boolean isIncoming, boolean isUnknown) { boolean isLegacyHandover = request.getExtras() != null && request.getExtras().getBoolean(TelecomManager.EXTRA_IS_HANDOVER, false); boolean isHandover = request.getExtras() != null && request.getExtras().getBoolean(TelecomManager.EXTRA_IS_HANDOVER_CONNECTION, false); Log.d(this, "createConnection, callManagerAccount: %s, callId: %s, request: %s, " + "isIncoming: %b, isUnknown: %b, isLegacyHandover: %b, isHandover: %b", callManagerAccount, callId, request, isIncoming, isUnknown, isLegacyHandover, isHandover); Connection connection = null; if (isHandover) { PhoneAccountHandle fromPhoneAccountHandle = request.getExtras() != null ? (PhoneAccountHandle) request.getExtras() .getParcelable(TelecomManager.EXTRA_HANDOVER_FROM_PHONE_ACCOUNT) : null; if (!isIncoming) { connection = onCreateOutgoingHandoverConnection(fromPhoneAccountHandle, request); } else { connection = onCreateIncomingHandoverConnection(fromPhoneAccountHandle, request); } } else { connection = isUnknown ? onCreateUnknownConnection(callManagerAccount, request) : isIncoming ? onCreateIncomingConnection(callManagerAccount, request) : onCreateOutgoingConnection(callManagerAccount, request); } Log.d(this, "createConnection, connection: %s", connection); if (connection == null) { Log.i(this, "createConnection, implementation returned null connection."); connection = Connection.createFailedConnection( new DisconnectCause(DisconnectCause.ERROR, "IMPL_RETURNED_NULL_CONNECTION")); } boolean isSelfManaged = (connection.getConnectionProperties() & Connection.PROPERTY_SELF_MANAGED) == Connection.PROPERTY_SELF_MANAGED; // Self-managed Connections should always use voip audio mode; we default here so that the // local state within the ConnectionService matches the default we assume in Telecom. if (isSelfManaged) { connection.setAudioModeIsVoip(true); } connection.setTelecomCallId(callId); if (connection.getState() != Connection.STATE_DISCONNECTED) { addConnection(request.getAccountHandle(), callId, connection); } Uri address = connection.getAddress(); String number = address == null ? "null" : address.getSchemeSpecificPart(); Log.v(this, "createConnection, number: %s, state: %s, capabilities: %s, properties: %s", Connection.toLogSafePhoneNumber(number), Connection.stateToString(connection.getState()), Connection.capabilitiesToString(connection.getConnectionCapabilities()), Connection.propertiesToString(connection.getConnectionProperties())); Log.d(this, "createConnection, calling handleCreateConnectionSuccessful %s", callId); mAdapter.handleCreateConnectionComplete(callId, request, new ParcelableConnection( request.getAccountHandle(), connection.getState(), connection.getConnectionCapabilities(), connection.getConnectionProperties(), connection.getSupportedAudioRoutes(), connection.getAddress(), connection.getAddressPresentation(), connection.getCallerDisplayName(), connection.getCallerDisplayNamePresentation(), connection.getVideoProvider() == null ? null : connection.getVideoProvider().getInterface(), connection.getVideoState(), connection.isRingbackRequested(), connection.getAudioModeIsVoip(), connection.getConnectTimeMillis(), connection.getConnectElapsedTimeMillis(), connection.getStatusHints(), connection.getDisconnectCause(), createIdList(connection.getConferenceables()), connection.getExtras())); if (isIncoming && request.shouldShowIncomingCallUi() && isSelfManaged) { // Tell ConnectionService to show its incoming call UX. connection.onShowIncomingCallUi(); } if (isUnknown) { triggerConferenceRecalculate(); } } private void createConnectionFailed(final PhoneAccountHandle callManagerAccount, final String callId, final ConnectionRequest request, boolean isIncoming) { Log.i(this, "createConnectionFailed %s", callId); if (isIncoming) { onCreateIncomingConnectionFailed(callManagerAccount, request); } else { onCreateOutgoingConnectionFailed(callManagerAccount, request); } } private void handoverFailed(final String callId, final ConnectionRequest request, int reason) { Log.i(this, "handoverFailed %s", callId); onHandoverFailed(request, reason); } /** * Called by Telecom when the creation of a new Connection has completed and it is now added * to Telecom. * @param callId The ID of the connection. */ private void notifyCreateConnectionComplete(final String callId) { Log.i(this, "notifyCreateConnectionComplete %s", callId); if (callId == null) { // This could happen if the connection fails quickly and is removed from the // ConnectionService before Telecom sends the create connection complete callback. Log.w(this, "notifyCreateConnectionComplete: callId is null."); return; } onCreateConnectionComplete(findConnectionForAction(callId, "notifyCreateConnectionComplete")); } private void abort(String callId) { Log.d(this, "abort %s", callId); findConnectionForAction(callId, "abort").onAbort(); } private void answerVideo(String callId, int videoState) { Log.d(this, "answerVideo %s", callId); findConnectionForAction(callId, "answer").onAnswer(videoState); } private void answer(String callId) { Log.d(this, "answer %s", callId); findConnectionForAction(callId, "answer").onAnswer(); } private void deflect(String callId, Uri address) { Log.d(this, "deflect %s", callId); findConnectionForAction(callId, "deflect").onDeflect(address); } private void reject(String callId) { Log.d(this, "reject %s", callId); findConnectionForAction(callId, "reject").onReject(); } private void reject(String callId, String rejectWithMessage) { Log.d(this, "reject %s with message", callId); findConnectionForAction(callId, "reject").onReject(rejectWithMessage); } private void silence(String callId) { Log.d(this, "silence %s", callId); findConnectionForAction(callId, "silence").onSilence(); } private void disconnect(String callId) { Log.d(this, "disconnect %s", callId); if (mConnectionById.containsKey(callId)) { findConnectionForAction(callId, "disconnect").onDisconnect(); } else { findConferenceForAction(callId, "disconnect").onDisconnect(); } } private void hold(String callId) { Log.d(this, "hold %s", callId); if (mConnectionById.containsKey(callId)) { findConnectionForAction(callId, "hold").onHold(); } else { findConferenceForAction(callId, "hold").onHold(); } } private void unhold(String callId) { Log.d(this, "unhold %s", callId); if (mConnectionById.containsKey(callId)) { findConnectionForAction(callId, "unhold").onUnhold(); } else { findConferenceForAction(callId, "unhold").onUnhold(); } } private void onCallAudioStateChanged(String callId, CallAudioState callAudioState) { Log.d(this, "onAudioStateChanged %s %s", callId, callAudioState); if (mConnectionById.containsKey(callId)) { findConnectionForAction(callId, "onCallAudioStateChanged").setCallAudioState(callAudioState); } else { findConferenceForAction(callId, "onCallAudioStateChanged").setCallAudioState(callAudioState); } } private void playDtmfTone(String callId, char digit) { Log.d(this, "playDtmfTone %s %c", callId, digit); if (mConnectionById.containsKey(callId)) { findConnectionForAction(callId, "playDtmfTone").onPlayDtmfTone(digit); } else { findConferenceForAction(callId, "playDtmfTone").onPlayDtmfTone(digit); } } private void stopDtmfTone(String callId) { Log.d(this, "stopDtmfTone %s", callId); if (mConnectionById.containsKey(callId)) { findConnectionForAction(callId, "stopDtmfTone").onStopDtmfTone(); } else { findConferenceForAction(callId, "stopDtmfTone").onStopDtmfTone(); } } private void conference(String callId1, String callId2) { Log.d(this, "conference %s, %s", callId1, callId2); // Attempt to get second connection or conference. Connection connection2 = findConnectionForAction(callId2, "conference"); Conference conference2 = getNullConference(); if (connection2 == getNullConnection()) { conference2 = findConferenceForAction(callId2, "conference"); if (conference2 == getNullConference()) { Log.w(this, "Connection2 or Conference2 missing in conference request %s.", callId2); return; } } // Attempt to get first connection or conference and perform merge. Connection connection1 = findConnectionForAction(callId1, "conference"); if (connection1 == getNullConnection()) { Conference conference1 = findConferenceForAction(callId1, "addConnection"); if (conference1 == getNullConference()) { Log.w(this, "Connection1 or Conference1 missing in conference request %s.", callId1); } else { // Call 1 is a conference. if (connection2 != getNullConnection()) { // Call 2 is a connection so merge via call 1 (conference). conference1.onMerge(connection2); } else { // Call 2 is ALSO a conference; this should never happen. Log.wtf(this, "There can only be one conference and an attempt was made to " + "merge two conferences."); return; } } } else { // Call 1 is a connection. if (conference2 != getNullConference()) { // Call 2 is a conference, so merge via call 2. conference2.onMerge(connection1); } else { // Call 2 is a connection, so merge together. onConference(connection1, connection2); } } } private void splitFromConference(String callId) { Log.d(this, "splitFromConference(%s)", callId); Connection connection = findConnectionForAction(callId, "splitFromConference"); if (connection == getNullConnection()) { Log.w(this, "Connection missing in conference request %s.", callId); return; } Conference conference = connection.getConference(); if (conference != null) { conference.onSeparate(connection); } } private void mergeConference(String callId) { Log.d(this, "mergeConference(%s)", callId); Conference conference = findConferenceForAction(callId, "mergeConference"); if (conference != null) { conference.onMerge(); } } private void swapConference(String callId) { Log.d(this, "swapConference(%s)", callId); Conference conference = findConferenceForAction(callId, "swapConference"); if (conference != null) { conference.onSwap(); } } /** * Notifies a {@link Connection} of a request to pull an external call. * * See {@link Call#pullExternalCall()}. * * @param callId The ID of the call to pull. */ private void pullExternalCall(String callId) { Log.d(this, "pullExternalCall(%s)", callId); Connection connection = findConnectionForAction(callId, "pullExternalCall"); if (connection != null) { connection.onPullExternalCall(); } } /** * Notifies a {@link Connection} of a call event. * * See {@link Call#sendCallEvent(String, Bundle)}. * * @param callId The ID of the call receiving the event. * @param event The event. * @param extras Extras associated with the event. */ private void sendCallEvent(String callId, String event, Bundle extras) { Log.d(this, "sendCallEvent(%s, %s)", callId, event); Connection connection = findConnectionForAction(callId, "sendCallEvent"); if (connection != null) { connection.onCallEvent(event, extras); } } /** * Notifies a {@link Connection} that a handover has completed. * * @param callId The ID of the call which completed handover. */ private void notifyHandoverComplete(String callId) { Log.d(this, "notifyHandoverComplete(%s)", callId); Connection connection = findConnectionForAction(callId, "notifyHandoverComplete"); if (connection != null) { connection.onHandoverComplete(); } } /** * Notifies a {@link Connection} or {@link Conference} of a change to the extras from Telecom. * <p> * These extra changes can originate from Telecom itself, or from an {@link InCallService} via * the {@link android.telecom.Call#putExtra(String, boolean)}, * {@link android.telecom.Call#putExtra(String, int)}, * {@link android.telecom.Call#putExtra(String, String)}, * {@link Call#removeExtras(List)}. * * @param callId The ID of the call receiving the event. * @param extras The new extras bundle. */ private void handleExtrasChanged(String callId, Bundle extras) { Log.d(this, "handleExtrasChanged(%s, %s)", callId, extras); if (mConnectionById.containsKey(callId)) { findConnectionForAction(callId, "handleExtrasChanged").handleExtrasChanged(extras); } else if (mConferenceById.containsKey(callId)) { findConferenceForAction(callId, "handleExtrasChanged").handleExtrasChanged(extras); } } private void startRtt(String callId, Connection.RttTextStream rttTextStream) { Log.d(this, "startRtt(%s)", callId); if (mConnectionById.containsKey(callId)) { findConnectionForAction(callId, "startRtt").onStartRtt(rttTextStream); } else if (mConferenceById.containsKey(callId)) { Log.w(this, "startRtt called on a conference."); } } private void stopRtt(String callId) { Log.d(this, "stopRtt(%s)", callId); if (mConnectionById.containsKey(callId)) { findConnectionForAction(callId, "stopRtt").onStopRtt(); } else if (mConferenceById.containsKey(callId)) { Log.w(this, "stopRtt called on a conference."); } } private void handleRttUpgradeResponse(String callId, Connection.RttTextStream rttTextStream) { Log.d(this, "handleRttUpgradeResponse(%s, %s)", callId, rttTextStream == null); if (mConnectionById.containsKey(callId)) { findConnectionForAction(callId, "handleRttUpgradeResponse").handleRttUpgradeResponse(rttTextStream); } else if (mConferenceById.containsKey(callId)) { Log.w(this, "handleRttUpgradeResponse called on a conference."); } } private void onPostDialContinue(String callId, boolean proceed) { Log.d(this, "onPostDialContinue(%s)", callId); findConnectionForAction(callId, "stopDtmfTone").onPostDialContinue(proceed); } private void onAdapterAttached() { if (mAreAccountsInitialized) { // No need to query again if we already did it. return; } mAdapter.queryRemoteConnectionServices(new RemoteServiceCallback.Stub() { @Override public void onResult(final List<ComponentName> componentNames, final List<IBinder> services) { mHandler.post(new android.telecom.Logging.Runnable("oAA.qRCS.oR", null /*lock*/) { @Override public void loggedRun() { for (int i = 0; i < componentNames.size() && i < services.size(); i++) { mRemoteConnectionManager.addConnectionService(componentNames.get(i), IConnectionService.Stub.asInterface(services.get(i))); } onAccountsInitialized(); Log.d(this, "remote connection services found: " + services); } }.prepare()); } @Override public void onError() { mHandler.post(new android.telecom.Logging.Runnable("oAA.qRCS.oE", null /*lock*/) { @Override public void loggedRun() { mAreAccountsInitialized = true; } }.prepare()); } }); } /** * Ask some other {@code ConnectionService} to create a {@code RemoteConnection} given an * incoming request. This is used by {@code ConnectionService}s that are registered with * {@link PhoneAccount#CAPABILITY_CONNECTION_MANAGER} and want to be able to manage * SIM-based incoming calls. * * @param connectionManagerPhoneAccount See description at * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}. * @param request Details about the incoming call. * @return The {@code Connection} object to satisfy this call, or {@code null} to * not handle the call. */ public final RemoteConnection createRemoteIncomingConnection(PhoneAccountHandle connectionManagerPhoneAccount, ConnectionRequest request) { return mRemoteConnectionManager.createRemoteConnection(connectionManagerPhoneAccount, request, true); } /** * Ask some other {@code ConnectionService} to create a {@code RemoteConnection} given an * outgoing request. This is used by {@code ConnectionService}s that are registered with * {@link PhoneAccount#CAPABILITY_CONNECTION_MANAGER} and want to be able to use the * SIM-based {@code ConnectionService} to place its outgoing calls. * * @param connectionManagerPhoneAccount See description at * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}. * @param request Details about the outgoing call. * @return The {@code Connection} object to satisfy this call, or {@code null} to * not handle the call. */ public final RemoteConnection createRemoteOutgoingConnection(PhoneAccountHandle connectionManagerPhoneAccount, ConnectionRequest request) { return mRemoteConnectionManager.createRemoteConnection(connectionManagerPhoneAccount, request, false); } /** * Indicates to the relevant {@code RemoteConnectionService} that the specified * {@link RemoteConnection}s should be merged into a conference call. * <p> * If the conference request is successful, the method {@link #onRemoteConferenceAdded} will * be invoked. * * @param remoteConnection1 The first of the remote connections to conference. * @param remoteConnection2 The second of the remote connections to conference. */ public final void conferenceRemoteConnections(RemoteConnection remoteConnection1, RemoteConnection remoteConnection2) { mRemoteConnectionManager.conferenceRemoteConnections(remoteConnection1, remoteConnection2); } /** * Adds a new conference call. When a conference call is created either as a result of an * explicit request via {@link #onConference} or otherwise, the connection service should supply * an instance of {@link Conference} by invoking this method. A conference call provided by this * method will persist until {@link Conference#destroy} is invoked on the conference instance. * * @param conference The new conference object. */ public final void addConference(Conference conference) { Log.d(this, "addConference: conference=%s", conference); String id = addConferenceInternal(conference); if (id != null) { List<String> connectionIds = new ArrayList<>(2); for (Connection connection : conference.getConnections()) { if (mIdByConnection.containsKey(connection)) { connectionIds.add(mIdByConnection.get(connection)); } } conference.setTelecomCallId(id); ParcelableConference parcelableConference = new ParcelableConference(conference.getPhoneAccountHandle(), conference.getState(), conference.getConnectionCapabilities(), conference.getConnectionProperties(), connectionIds, conference.getVideoProvider() == null ? null : conference.getVideoProvider().getInterface(), conference.getVideoState(), conference.getConnectTimeMillis(), conference.getConnectionStartElapsedRealTime(), conference.getStatusHints(), conference.getExtras()); mAdapter.addConferenceCall(id, parcelableConference); mAdapter.setVideoProvider(id, conference.getVideoProvider()); mAdapter.setVideoState(id, conference.getVideoState()); // Go through any child calls and set the parent. for (Connection connection : conference.getConnections()) { String connectionId = mIdByConnection.get(connection); if (connectionId != null) { mAdapter.setIsConferenced(connectionId, id); } } onConferenceAdded(conference); } } /** * Adds a connection created by the {@link ConnectionService} and informs telecom of the new * connection. * * @param phoneAccountHandle The phone account handle for the connection. * @param connection The connection to add. */ public final void addExistingConnection(PhoneAccountHandle phoneAccountHandle, Connection connection) { addExistingConnection(phoneAccountHandle, connection, null /* conference */); } /** * Call to inform Telecom that your {@link ConnectionService} has released call resources (e.g * microphone, camera). * * @see ConnectionService#onConnectionServiceFocusLost() */ public final void connectionServiceFocusReleased() { mAdapter.onConnectionServiceFocusReleased(); } /** * Adds a connection created by the {@link ConnectionService} and informs telecom of the new * connection. * * @param phoneAccountHandle The phone account handle for the connection. * @param connection The connection to add. * @param conference The parent conference of the new connection. * @hide */ public final void addExistingConnection(PhoneAccountHandle phoneAccountHandle, Connection connection, Conference conference) { String id = addExistingConnectionInternal(phoneAccountHandle, connection); if (id != null) { List<String> emptyList = new ArrayList<>(0); String conferenceId = null; if (conference != null) { conferenceId = mIdByConference.get(conference); } ParcelableConnection parcelableConnection = new ParcelableConnection(phoneAccountHandle, connection.getState(), connection.getConnectionCapabilities(), connection.getConnectionProperties(), connection.getSupportedAudioRoutes(), connection.getAddress(), connection.getAddressPresentation(), connection.getCallerDisplayName(), connection.getCallerDisplayNamePresentation(), connection.getVideoProvider() == null ? null : connection.getVideoProvider().getInterface(), connection.getVideoState(), connection.isRingbackRequested(), connection.getAudioModeIsVoip(), connection.getConnectTimeMillis(), connection.getConnectElapsedTimeMillis(), connection.getStatusHints(), connection.getDisconnectCause(), emptyList, connection.getExtras(), conferenceId); mAdapter.addExistingConnection(id, parcelableConnection); } } /** * Returns all the active {@code Connection}s for which this {@code ConnectionService} * has taken responsibility. * * @return A collection of {@code Connection}s created by this {@code ConnectionService}. */ public final Collection<Connection> getAllConnections() { return mConnectionById.values(); } /** * Returns all the active {@code Conference}s for which this {@code ConnectionService} * has taken responsibility. * * @return A collection of {@code Conference}s created by this {@code ConnectionService}. */ public final Collection<Conference> getAllConferences() { return mConferenceById.values(); } /** * Create a {@code Connection} given an incoming request. This is used to attach to existing * incoming calls. * * @param connectionManagerPhoneAccount See description at * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}. * @param request Details about the incoming call. * @return The {@code Connection} object to satisfy this call, or {@code null} to * not handle the call. */ public Connection onCreateIncomingConnection(PhoneAccountHandle connectionManagerPhoneAccount, ConnectionRequest request) { return null; } /** * Called after the {@link Connection} returned by * {@link #onCreateIncomingConnection(PhoneAccountHandle, ConnectionRequest)} * or {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)} has been * added to the {@link ConnectionService} and sent to Telecom. * * @param connection the {@link Connection}. * @hide */ public void onCreateConnectionComplete(Connection connection) { } /** * Called by Telecom to inform the {@link ConnectionService} that its request to create a new * incoming {@link Connection} was denied. * <p> * Used when a self-managed {@link ConnectionService} attempts to create a new incoming * {@link Connection}, but Telecom has determined that the call cannot be allowed at this time. * The {@link ConnectionService} is responsible for silently rejecting the new incoming * {@link Connection}. * <p> * See {@link TelecomManager#isIncomingCallPermitted(PhoneAccountHandle)} for more information. * * @param connectionManagerPhoneAccount See description at * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}. * @param request The incoming connection request. */ public void onCreateIncomingConnectionFailed(PhoneAccountHandle connectionManagerPhoneAccount, ConnectionRequest request) { } /** * Called by Telecom to inform the {@link ConnectionService} that its request to create a new * outgoing {@link Connection} was denied. * <p> * Used when a self-managed {@link ConnectionService} attempts to create a new outgoing * {@link Connection}, but Telecom has determined that the call cannot be placed at this time. * The {@link ConnectionService} is responisible for informing the user that the * {@link Connection} cannot be made at this time. * <p> * See {@link TelecomManager#isOutgoingCallPermitted(PhoneAccountHandle)} for more information. * * @param connectionManagerPhoneAccount See description at * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}. * @param request The outgoing connection request. */ public void onCreateOutgoingConnectionFailed(PhoneAccountHandle connectionManagerPhoneAccount, ConnectionRequest request) { } /** * Trigger recalculate functinality for conference calls. This is used when a Telephony * Connection is part of a conference controller but is not yet added to Connection * Service and hence cannot be added to the conference call. * * @hide */ public void triggerConferenceRecalculate() { } /** * Create a {@code Connection} given an outgoing request. This is used to initiate new * outgoing calls. * * @param connectionManagerPhoneAccount The connection manager account to use for managing * this call. * <p> * If this parameter is not {@code null}, it means that this {@code ConnectionService} * has registered one or more {@code PhoneAccount}s having * {@link PhoneAccount#CAPABILITY_CONNECTION_MANAGER}. This parameter will contain * one of these {@code PhoneAccount}s, while the {@code request} will contain another * (usually but not always distinct) {@code PhoneAccount} to be used for actually * making the connection. * <p> * If this parameter is {@code null}, it means that this {@code ConnectionService} is * being asked to make a direct connection. The * {@link ConnectionRequest#getAccountHandle()} of parameter {@code request} will be * a {@code PhoneAccount} registered by this {@code ConnectionService} to use for * making the connection. * @param request Details about the outgoing call. * @return The {@code Connection} object to satisfy this call, or the result of an invocation * of {@link Connection#createFailedConnection(DisconnectCause)} to not handle the call. */ public Connection onCreateOutgoingConnection(PhoneAccountHandle connectionManagerPhoneAccount, ConnectionRequest request) { return null; } /** * Called by Telecom to request that a {@link ConnectionService} creates an instance of an * outgoing handover {@link Connection}. * <p> * A call handover is the process where an ongoing call is transferred from one app (i.e. * {@link ConnectionService} to another app. The user could, for example, choose to continue a * mobile network call in a video calling app. The mobile network call via the Telephony stack * is referred to as the source of the handover, and the video calling app is referred to as the * destination. * <p> * When considering a handover scenario the <em>initiating</em> device is where a user initiated * the handover process (e.g. by calling {@link android.telecom.Call#handoverTo( * PhoneAccountHandle, int, Bundle)}, and the other device is considered the <em>receiving</em> * device. * <p> * This method is called on the destination {@link ConnectionService} on <em>initiating</em> * device when the user initiates a handover request from one app to another. The user request * originates in the {@link InCallService} via * {@link android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle)}. * <p> * For a full discussion of the handover process and the APIs involved, see * {@link android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle)}. * <p> * Implementations of this method should return an instance of {@link Connection} which * represents the handover. If your app does not wish to accept a handover to it at this time, * you can return {@code null}. The code below shows an example of how this is done. * <pre> * {@code * public Connection onCreateIncomingHandoverConnection(PhoneAccountHandle * fromPhoneAccountHandle, ConnectionRequest request) { * if (!isHandoverAvailable()) { * return null; * } * MyConnection connection = new MyConnection(); * connection.setAddress(request.getAddress(), TelecomManager.PRESENTATION_ALLOWED); * connection.setVideoState(request.getVideoState()); * return connection; * } * } * </pre> * * @param fromPhoneAccountHandle {@link PhoneAccountHandle} associated with the * ConnectionService which needs to handover the call. * @param request Details about the call to handover. * @return {@link Connection} instance corresponding to the handover call. */ public Connection onCreateOutgoingHandoverConnection(PhoneAccountHandle fromPhoneAccountHandle, ConnectionRequest request) { return null; } /** * Called by Telecom to request that a {@link ConnectionService} creates an instance of an * incoming handover {@link Connection}. * <p> * A call handover is the process where an ongoing call is transferred from one app (i.e. * {@link ConnectionService} to another app. The user could, for example, choose to continue a * mobile network call in a video calling app. The mobile network call via the Telephony stack * is referred to as the source of the handover, and the video calling app is referred to as the * destination. * <p> * When considering a handover scenario the <em>initiating</em> device is where a user initiated * the handover process (e.g. by calling {@link android.telecom.Call#handoverTo( * PhoneAccountHandle, int, Bundle)}, and the other device is considered the <em>receiving</em> * device. * <p> * This method is called on the destination app on the <em>receiving</em> device when the * destination app calls {@link TelecomManager#acceptHandover(Uri, int, PhoneAccountHandle)} to * accept an incoming handover from the <em>initiating</em> device. * <p> * For a full discussion of the handover process and the APIs involved, see * {@link android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle)}. * <p> * Implementations of this method should return an instance of {@link Connection} which * represents the handover. The code below shows an example of how this is done. * <pre> * {@code * public Connection onCreateIncomingHandoverConnection(PhoneAccountHandle * fromPhoneAccountHandle, ConnectionRequest request) { * // Given that your app requested to accept the handover, you should not return null here. * MyConnection connection = new MyConnection(); * connection.setAddress(request.getAddress(), TelecomManager.PRESENTATION_ALLOWED); * connection.setVideoState(request.getVideoState()); * return connection; * } * } * </pre> * * @param fromPhoneAccountHandle {@link PhoneAccountHandle} associated with the * ConnectionService which needs to handover the call. * @param request Details about the call which needs to be handover. * @return {@link Connection} instance corresponding to the handover call. */ public Connection onCreateIncomingHandoverConnection(PhoneAccountHandle fromPhoneAccountHandle, ConnectionRequest request) { return null; } /** * Called by Telecom in response to a {@code TelecomManager#acceptHandover()} * invocation which failed. * <p> * For a full discussion of the handover process and the APIs involved, see * {@link android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle)} * * @param request Details about the call which failed to handover. * @param error Reason for handover failure. Will be one of the */ public void onHandoverFailed(ConnectionRequest request, @Call.Callback.HandoverFailureErrors int error) { return; } /** * Create a {@code Connection} for a new unknown call. An unknown call is a call originating * from the ConnectionService that was neither a user-initiated outgoing call, nor an incoming * call created using * {@code TelecomManager#addNewIncomingCall(PhoneAccountHandle, android.os.Bundle)}. * * @hide */ public Connection onCreateUnknownConnection(PhoneAccountHandle connectionManagerPhoneAccount, ConnectionRequest request) { return null; } /** * Conference two specified connections. Invoked when the user has made a request to merge the * specified connections into a conference call. In response, the connection service should * create an instance of {@link Conference} and pass it into {@link #addConference}. * * @param connection1 A connection to merge into a conference call. * @param connection2 A connection to merge into a conference call. */ public void onConference(Connection connection1, Connection connection2) { } /** * Called when a connection is added. * @hide */ public void onConnectionAdded(Connection connection) { } /** * Called when a connection is removed. * @hide */ public void onConnectionRemoved(Connection connection) { } /** * Called when a conference is added. * @hide */ public void onConferenceAdded(Conference conference) { } /** * Called when a conference is removed. * @hide */ public void onConferenceRemoved(Conference conference) { } /** * Indicates that a remote conference has been created for existing {@link RemoteConnection}s. * When this method is invoked, this {@link ConnectionService} should create its own * representation of the conference call and send it to telecom using {@link #addConference}. * <p> * This is only relevant to {@link ConnectionService}s which are registered with * {@link PhoneAccount#CAPABILITY_CONNECTION_MANAGER}. * * @param conference The remote conference call. */ public void onRemoteConferenceAdded(RemoteConference conference) { } /** * Called when an existing connection is added remotely. * @param connection The existing connection which was added. */ public void onRemoteExistingConnectionAdded(RemoteConnection connection) { } /** * Called when the {@link ConnectionService} has lost the call focus. * The {@link ConnectionService} should release the call resources and invokes * {@link ConnectionService#connectionServiceFocusReleased()} to inform telecom that it has * released the call resources. */ public void onConnectionServiceFocusLost() { } /** * Called when the {@link ConnectionService} has gained the call focus. The * {@link ConnectionService} can acquire the call resources at this time. */ public void onConnectionServiceFocusGained() { } /** * @hide */ public boolean containsConference(Conference conference) { return mIdByConference.containsKey(conference); } /** {@hide} */ void addRemoteConference(RemoteConference remoteConference) { onRemoteConferenceAdded(remoteConference); } /** {@hide} */ void addRemoteExistingConnection(RemoteConnection remoteConnection) { onRemoteExistingConnectionAdded(remoteConnection); } private void onAccountsInitialized() { mAreAccountsInitialized = true; for (Runnable r : mPreInitializationConnectionRequests) { r.run(); } mPreInitializationConnectionRequests.clear(); } /** * Adds an existing connection to the list of connections, identified by a new call ID unique * to this connection service. * * @param connection The connection. * @return The ID of the connection (e.g. the call-id). */ private String addExistingConnectionInternal(PhoneAccountHandle handle, Connection connection) { String id; if (connection.getExtras() != null && connection.getExtras().containsKey(Connection.EXTRA_ORIGINAL_CONNECTION_ID)) { id = connection.getExtras().getString(Connection.EXTRA_ORIGINAL_CONNECTION_ID); Log.d(this, "addExistingConnectionInternal - conn %s reusing original id %s", connection.getTelecomCallId(), id); } else if (handle == null) { // If no phone account handle was provided, we cannot be sure the call ID is unique, // so just use a random UUID. id = UUID.randomUUID().toString(); } else { // Phone account handle was provided, so use the ConnectionService class name as a // prefix for a unique incremental call ID. id = handle.getComponentName().getClassName() + "@" + getNextCallId(); } addConnection(handle, id, connection); return id; } private void addConnection(PhoneAccountHandle handle, String callId, Connection connection) { connection.setTelecomCallId(callId); mConnectionById.put(callId, connection); mIdByConnection.put(connection, callId); connection.addConnectionListener(mConnectionListener); connection.setConnectionService(this); connection.setPhoneAccountHandle(handle); onConnectionAdded(connection); } /** {@hide} */ protected void removeConnection(Connection connection) { connection.unsetConnectionService(this); connection.removeConnectionListener(mConnectionListener); String id = mIdByConnection.get(connection); if (id != null) { mConnectionById.remove(id); mIdByConnection.remove(connection); mAdapter.removeCall(id); onConnectionRemoved(connection); } } private String addConferenceInternal(Conference conference) { String originalId = null; if (conference.getExtras() != null && conference.getExtras().containsKey(Connection.EXTRA_ORIGINAL_CONNECTION_ID)) { originalId = conference.getExtras().getString(Connection.EXTRA_ORIGINAL_CONNECTION_ID); Log.d(this, "addConferenceInternal: conf %s reusing original id %s", conference.getTelecomCallId(), originalId); } if (mIdByConference.containsKey(conference)) { Log.w(this, "Re-adding an existing conference: %s.", conference); } else if (conference != null) { // Conferences do not (yet) have a PhoneAccountHandle associated with them, so we // cannot determine a ConnectionService class name to associate with the ID, so use // a unique UUID (for now). String id = originalId == null ? UUID.randomUUID().toString() : originalId; mConferenceById.put(id, conference); mIdByConference.put(conference, id); conference.addListener(mConferenceListener); return id; } return null; } private void removeConference(Conference conference) { if (mIdByConference.containsKey(conference)) { conference.removeListener(mConferenceListener); String id = mIdByConference.get(conference); mConferenceById.remove(id); mIdByConference.remove(conference); mAdapter.removeCall(id); onConferenceRemoved(conference); } } private Connection findConnectionForAction(String callId, String action) { if (callId != null && mConnectionById.containsKey(callId)) { return mConnectionById.get(callId); } Log.w(this, "%s - Cannot find Connection %s", action, callId); return getNullConnection(); } static synchronized Connection getNullConnection() { if (sNullConnection == null) { sNullConnection = new Connection() { }; } return sNullConnection; } private Conference findConferenceForAction(String conferenceId, String action) { if (mConferenceById.containsKey(conferenceId)) { return mConferenceById.get(conferenceId); } Log.w(this, "%s - Cannot find conference %s", action, conferenceId); return getNullConference(); } private List<String> createConnectionIdList(List<Connection> connections) { List<String> ids = new ArrayList<>(); for (Connection c : connections) { if (mIdByConnection.containsKey(c)) { ids.add(mIdByConnection.get(c)); } } Collections.sort(ids); return ids; } /** * Builds a list of {@link Connection} and {@link Conference} IDs based on the list of * {@link Conferenceable}s passed in. * * @param conferenceables The {@link Conferenceable} connections and conferences. * @return List of string conference and call Ids. */ private List<String> createIdList(List<Conferenceable> conferenceables) { List<String> ids = new ArrayList<>(); for (Conferenceable c : conferenceables) { // Only allow Connection and Conference conferenceables. if (c instanceof Connection) { Connection connection = (Connection) c; if (mIdByConnection.containsKey(connection)) { ids.add(mIdByConnection.get(connection)); } } else if (c instanceof Conference) { Conference conference = (Conference) c; if (mIdByConference.containsKey(conference)) { ids.add(mIdByConference.get(conference)); } } } Collections.sort(ids); return ids; } private Conference getNullConference() { if (sNullConference == null) { sNullConference = new Conference(null) { }; } return sNullConference; } private void endAllConnections() { // Unbound from telecomm. We should end all connections and conferences. for (Connection connection : mIdByConnection.keySet()) { // only operate on top-level calls. Conference calls will be removed on their own. if (connection.getConference() == null) { connection.onDisconnect(); } } for (Conference conference : mIdByConference.keySet()) { conference.onDisconnect(); } } /** * Retrieves the next call ID as maintainted by the connection service. * * @return The call ID. */ private int getNextCallId() { synchronized (mIdSyncRoot) { return ++mId; } } }