blob: ffd25c08a8baeb5597bc2a0fc90c8bfd52c19c90 [file] [log] [blame]
Ihab Awad542e0ea2014-05-16 10:22:16 -07001/*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Tyler Gunnef9f6f92014-09-12 22:16:17 -070017package android.telecom;
Ihab Awad542e0ea2014-05-16 10:22:16 -070018
Tyler Gunn5567d742019-10-31 13:04:37 -070019import android.annotation.NonNull;
20import android.annotation.Nullable;
Santos Cordon5c6fa952014-07-20 17:47:12 -070021import android.annotation.SdkConstant;
Tyler Gunn5567d742019-10-31 13:04:37 -070022import android.annotation.SystemApi;
Sailesh Nepal2a46b902014-07-04 17:21:07 -070023import android.app.Service;
Santos Cordon52d8a152014-06-17 19:08:45 -070024import android.content.ComponentName;
Santos Cordon5c6fa952014-07-20 17:47:12 -070025import android.content.Intent;
Ihab Awad542e0ea2014-05-16 10:22:16 -070026import android.net.Uri;
Santos Cordon6b7f9552015-05-27 17:21:45 -070027import android.os.Bundle;
Santos Cordon52d8a152014-06-17 19:08:45 -070028import android.os.Handler;
29import android.os.IBinder;
30import android.os.Looper;
Sailesh Nepal2a46b902014-07-04 17:21:07 -070031import android.os.Message;
Hall Liub64ac4c2017-02-06 10:49:48 -080032import android.os.ParcelFileDescriptor;
33import android.os.RemoteException;
Brad Ebingerb32d4f82016-10-24 16:40:49 -070034import android.telecom.Logging.Session;
Andrew Lee14185762014-07-25 09:41:56 -070035
Brad Ebinger99f17ce2019-09-11 18:06:51 -070036import com.android.internal.annotations.VisibleForTesting;
Sailesh Nepal2a46b902014-07-04 17:21:07 -070037import com.android.internal.os.SomeArgs;
Tyler Gunnef9f6f92014-09-12 22:16:17 -070038import com.android.internal.telecom.IConnectionService;
39import com.android.internal.telecom.IConnectionServiceAdapter;
40import com.android.internal.telecom.RemoteServiceCallback;
Santos Cordon52d8a152014-06-17 19:08:45 -070041
Ihab Awad5d0410f2014-07-30 10:07:40 -070042import java.util.ArrayList;
Santos Cordonb6939982014-06-04 20:20:58 -070043import java.util.Collection;
Santos Cordon7c7bc7f2014-07-28 18:15:48 -070044import java.util.Collections;
Santos Cordon52d8a152014-06-17 19:08:45 -070045import java.util.List;
Ihab Awad542e0ea2014-05-16 10:22:16 -070046import java.util.Map;
Santos Cordon823fd3c2014-08-07 18:35:18 -070047import java.util.UUID;
mike dooley95e80702014-09-18 14:07:52 -070048import java.util.concurrent.ConcurrentHashMap;
Ihab Awad542e0ea2014-05-16 10:22:16 -070049
50/**
Tyler Gunnf5035432017-01-09 09:43:12 -080051 * An abstract service that should be implemented by any apps which either:
52 * <ol>
53 * <li>Can make phone calls (VoIP or otherwise) and want those calls to be integrated into the
54 * built-in phone app. Referred to as a <b>system managed</b> {@link ConnectionService}.</li>
55 * <li>Are a standalone calling app and don't want their calls to be integrated into the
56 * built-in phone app. Referred to as a <b>self managed</b> {@link ConnectionService}.</li>
57 * </ol>
58 * Once implemented, the {@link ConnectionService} needs to take the following steps so that Telecom
59 * will bind to it:
Santos Cordona663f862014-10-29 13:49:58 -070060 * <p>
61 * 1. <i>Registration in AndroidManifest.xml</i>
62 * <br/>
63 * <pre>
64 * &lt;service android:name="com.example.package.MyConnectionService"
65 * android:label="@string/some_label_for_my_connection_service"
Yorke Lee249c12e2015-05-13 15:59:29 -070066 * android:permission="android.permission.BIND_TELECOM_CONNECTION_SERVICE"&gt;
Santos Cordona663f862014-10-29 13:49:58 -070067 * &lt;intent-filter&gt;
68 * &lt;action android:name="android.telecom.ConnectionService" /&gt;
69 * &lt;/intent-filter&gt;
70 * &lt;/service&gt;
71 * </pre>
72 * <p>
73 * 2. <i> Registration of {@link PhoneAccount} with {@link TelecomManager}.</i>
74 * <br/>
75 * See {@link PhoneAccount} and {@link TelecomManager#registerPhoneAccount} for more information.
76 * <p>
Tyler Gunnf5035432017-01-09 09:43:12 -080077 * System managed {@link ConnectionService}s must be enabled by the user in the phone app settings
kopriva82c591b2018-10-08 15:57:00 -070078 * before Telecom will bind to them. Self-managed {@link ConnectionService}s must be granted the
Tyler Gunnf5035432017-01-09 09:43:12 -080079 * appropriate permission before Telecom will bind to them.
80 * <p>
81 * Once registered and enabled by the user in the phone app settings or granted permission, telecom
82 * will bind to a {@link ConnectionService} implementation when it wants that
83 * {@link ConnectionService} to place a call or the service has indicated that is has an incoming
84 * call through {@link TelecomManager#addNewIncomingCall}. The {@link ConnectionService} can then
85 * expect a call to {@link #onCreateIncomingConnection} or {@link #onCreateOutgoingConnection}
86 * wherein it should provide a new instance of a {@link Connection} object. It is through this
87 * {@link Connection} object that telecom receives state updates and the {@link ConnectionService}
Santos Cordona663f862014-10-29 13:49:58 -070088 * receives call-commands such as answer, reject, hold and disconnect.
89 * <p>
Tyler Gunnf5035432017-01-09 09:43:12 -080090 * When there are no more live calls, telecom will unbind from the {@link ConnectionService}.
Ihab Awad542e0ea2014-05-16 10:22:16 -070091 */
Sailesh Nepal2a46b902014-07-04 17:21:07 -070092public abstract class ConnectionService extends Service {
Santos Cordon5c6fa952014-07-20 17:47:12 -070093 /**
94 * The {@link Intent} that must be declared as handled by the service.
95 */
Ihab Awadb19a0bc2014-08-07 19:46:01 -070096 @SdkConstant(SdkConstant.SdkConstantType.SERVICE_ACTION)
Tyler Gunnef9f6f92014-09-12 22:16:17 -070097 public static final String SERVICE_INTERFACE = "android.telecom.ConnectionService";
Santos Cordon5c6fa952014-07-20 17:47:12 -070098
Tyler Gunn8bf76572017-04-06 15:30:08 -070099 /**
100 * Boolean extra used by Telecom to inform a {@link ConnectionService} that the purpose of it
101 * being asked to create a new outgoing {@link Connection} is to perform a handover of an
102 * ongoing call on the device from another {@link PhoneAccount}/{@link ConnectionService}. Will
103 * be specified in the {@link ConnectionRequest#getExtras()} passed by Telecom when
104 * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)} is called.
105 * <p>
Tyler Gunn727c6bd2017-04-11 09:51:40 -0700106 * When your {@link ConnectionService} receives this extra, it should communicate the fact that
107 * this is a handover to the other device's matching {@link ConnectionService}. That
Tyler Gunn8bf76572017-04-06 15:30:08 -0700108 * {@link ConnectionService} will continue the handover using
109 * {@link TelecomManager#addNewIncomingCall(PhoneAccountHandle, Bundle)}, specifying
Tyler Gunn727c6bd2017-04-11 09:51:40 -0700110 * {@link TelecomManager#EXTRA_IS_HANDOVER}. Telecom will match the phone numbers of the
111 * handover call on the other device with ongoing calls for {@link ConnectionService}s which
112 * support {@link PhoneAccount#EXTRA_SUPPORTS_HANDOVER_FROM}.
Tyler Gunn8bf76572017-04-06 15:30:08 -0700113 * @hide
114 */
115 public static final String EXTRA_IS_HANDOVER = TelecomManager.EXTRA_IS_HANDOVER;
116
Ihab Awad542e0ea2014-05-16 10:22:16 -0700117 // Flag controlling whether PII is emitted into the logs
Ihab Awad60ac30b2014-05-20 22:32:12 -0700118 private static final boolean PII_DEBUG = Log.isLoggable(android.util.Log.DEBUG);
Ihab Awad542e0ea2014-05-16 10:22:16 -0700119
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700120 // Session Definitions
121 private static final String SESSION_HANDLER = "H.";
122 private static final String SESSION_ADD_CS_ADAPTER = "CS.aCSA";
123 private static final String SESSION_REMOVE_CS_ADAPTER = "CS.rCSA";
124 private static final String SESSION_CREATE_CONN = "CS.crCo";
Tyler Gunn041a1fe2017-05-12 10:04:49 -0700125 private static final String SESSION_CREATE_CONN_COMPLETE = "CS.crCoC";
Tyler Gunn44e01912017-01-31 10:49:05 -0800126 private static final String SESSION_CREATE_CONN_FAILED = "CS.crCoF";
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700127 private static final String SESSION_ABORT = "CS.ab";
128 private static final String SESSION_ANSWER = "CS.an";
129 private static final String SESSION_ANSWER_VIDEO = "CS.anV";
Pooja Jaind34698d2017-12-28 14:15:31 +0530130 private static final String SESSION_DEFLECT = "CS.def";
Ravi Palurif4b38e72020-02-05 12:35:41 +0530131 private static final String SESSION_TRANSFER = "CS.trans";
132 private static final String SESSION_CONSULTATIVE_TRANSFER = "CS.cTrans";
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700133 private static final String SESSION_REJECT = "CS.r";
134 private static final String SESSION_REJECT_MESSAGE = "CS.rWM";
135 private static final String SESSION_SILENCE = "CS.s";
136 private static final String SESSION_DISCONNECT = "CS.d";
137 private static final String SESSION_HOLD = "CS.h";
138 private static final String SESSION_UNHOLD = "CS.u";
139 private static final String SESSION_CALL_AUDIO_SC = "CS.cASC";
140 private static final String SESSION_PLAY_DTMF = "CS.pDT";
141 private static final String SESSION_STOP_DTMF = "CS.sDT";
142 private static final String SESSION_CONFERENCE = "CS.c";
143 private static final String SESSION_SPLIT_CONFERENCE = "CS.sFC";
144 private static final String SESSION_MERGE_CONFERENCE = "CS.mC";
145 private static final String SESSION_SWAP_CONFERENCE = "CS.sC";
Ravi Paluri404babb2020-01-23 19:02:44 +0530146 private static final String SESSION_ADD_PARTICIPANT = "CS.aP";
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700147 private static final String SESSION_POST_DIAL_CONT = "CS.oPDC";
148 private static final String SESSION_PULL_EXTERNAL_CALL = "CS.pEC";
149 private static final String SESSION_SEND_CALL_EVENT = "CS.sCE";
Tyler Gunn79bc1ec2018-01-22 15:17:54 -0800150 private static final String SESSION_HANDOVER_COMPLETE = "CS.hC";
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700151 private static final String SESSION_EXTRAS_CHANGED = "CS.oEC";
Hall Liub64ac4c2017-02-06 10:49:48 -0800152 private static final String SESSION_START_RTT = "CS.+RTT";
Hall Liua549fed2018-02-09 16:40:03 -0800153 private static final String SESSION_UPDATE_RTT_PIPES = "CS.uRTT";
Hall Liub64ac4c2017-02-06 10:49:48 -0800154 private static final String SESSION_STOP_RTT = "CS.-RTT";
155 private static final String SESSION_RTT_UPGRADE_RESPONSE = "CS.rTRUR";
Pengquan Meng731c1a32017-11-21 18:01:13 -0800156 private static final String SESSION_CONNECTION_SERVICE_FOCUS_LOST = "CS.cSFL";
157 private static final String SESSION_CONNECTION_SERVICE_FOCUS_GAINED = "CS.cSFG";
Sanket Padawe4cc8ed52017-12-04 16:22:20 -0800158 private static final String SESSION_HANDOVER_FAILED = "CS.haF";
Ravi Paluri80aa2142019-12-02 11:57:37 +0530159 private static final String SESSION_CREATE_CONF = "CS.crConf";
160 private static final String SESSION_CREATE_CONF_COMPLETE = "CS.crConfC";
161 private static final String SESSION_CREATE_CONF_FAILED = "CS.crConfF";
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700162
Ihab Awad8aecfed2014-08-08 17:06:11 -0700163 private static final int MSG_ADD_CONNECTION_SERVICE_ADAPTER = 1;
Sailesh Nepalc5b01572014-07-14 16:29:44 -0700164 private static final int MSG_CREATE_CONNECTION = 2;
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700165 private static final int MSG_ABORT = 3;
Sailesh Nepalc5b01572014-07-14 16:29:44 -0700166 private static final int MSG_ANSWER = 4;
167 private static final int MSG_REJECT = 5;
168 private static final int MSG_DISCONNECT = 6;
169 private static final int MSG_HOLD = 7;
170 private static final int MSG_UNHOLD = 8;
Yorke Lee4af59352015-05-13 14:14:54 -0700171 private static final int MSG_ON_CALL_AUDIO_STATE_CHANGED = 9;
Sailesh Nepalc5b01572014-07-14 16:29:44 -0700172 private static final int MSG_PLAY_DTMF_TONE = 10;
173 private static final int MSG_STOP_DTMF_TONE = 11;
174 private static final int MSG_CONFERENCE = 12;
175 private static final int MSG_SPLIT_FROM_CONFERENCE = 13;
Ihab Awadb19a0bc2014-08-07 19:46:01 -0700176 private static final int MSG_ON_POST_DIAL_CONTINUE = 14;
Ihab Awadb19a0bc2014-08-07 19:46:01 -0700177 private static final int MSG_REMOVE_CONNECTION_SERVICE_ADAPTER = 16;
Tyler Gunnbe74de02014-08-29 14:51:48 -0700178 private static final int MSG_ANSWER_VIDEO = 17;
Santos Cordona4868042014-09-04 17:39:22 -0700179 private static final int MSG_MERGE_CONFERENCE = 18;
180 private static final int MSG_SWAP_CONFERENCE = 19;
Bryce Lee81901682015-08-28 16:38:02 -0700181 private static final int MSG_REJECT_WITH_MESSAGE = 20;
Bryce Leecac50772015-11-17 15:13:29 -0800182 private static final int MSG_SILENCE = 21;
Tyler Gunn876dbfb2016-03-14 15:18:07 -0700183 private static final int MSG_PULL_EXTERNAL_CALL = 22;
184 private static final int MSG_SEND_CALL_EVENT = 23;
Tyler Gunndee56a82016-03-23 16:06:34 -0700185 private static final int MSG_ON_EXTRAS_CHANGED = 24;
Tyler Gunn44e01912017-01-31 10:49:05 -0800186 private static final int MSG_CREATE_CONNECTION_FAILED = 25;
Hall Liub64ac4c2017-02-06 10:49:48 -0800187 private static final int MSG_ON_START_RTT = 26;
188 private static final int MSG_ON_STOP_RTT = 27;
189 private static final int MSG_RTT_UPGRADE_RESPONSE = 28;
Tyler Gunn041a1fe2017-05-12 10:04:49 -0700190 private static final int MSG_CREATE_CONNECTION_COMPLETE = 29;
Pengquan Meng731c1a32017-11-21 18:01:13 -0800191 private static final int MSG_CONNECTION_SERVICE_FOCUS_LOST = 30;
192 private static final int MSG_CONNECTION_SERVICE_FOCUS_GAINED = 31;
Sanket Padawe4cc8ed52017-12-04 16:22:20 -0800193 private static final int MSG_HANDOVER_FAILED = 32;
Tyler Gunn79bc1ec2018-01-22 15:17:54 -0800194 private static final int MSG_HANDOVER_COMPLETE = 33;
Pooja Jaind34698d2017-12-28 14:15:31 +0530195 private static final int MSG_DEFLECT = 34;
Ravi Paluri80aa2142019-12-02 11:57:37 +0530196 private static final int MSG_CREATE_CONFERENCE = 35;
197 private static final int MSG_CREATE_CONFERENCE_COMPLETE = 36;
198 private static final int MSG_CREATE_CONFERENCE_FAILED = 37;
Tyler Gunnfacfdee2020-01-23 13:10:37 -0800199 private static final int MSG_REJECT_WITH_REASON = 38;
Ravi Paluri404babb2020-01-23 19:02:44 +0530200 private static final int MSG_ADD_PARTICIPANT = 39;
Ravi Palurif4b38e72020-02-05 12:35:41 +0530201 private static final int MSG_EXPLICIT_CALL_TRANSFER = 40;
202 private static final int MSG_EXPLICIT_CALL_TRANSFER_CONSULTATIVE = 41;
Santos Cordon7c7bc7f2014-07-28 18:15:48 -0700203
Sailesh Nepalcf7020b2014-08-20 10:07:19 -0700204 private static Connection sNullConnection;
205
mike dooley95e80702014-09-18 14:07:52 -0700206 private final Map<String, Connection> mConnectionById = new ConcurrentHashMap<>();
207 private final Map<Connection, String> mIdByConnection = new ConcurrentHashMap<>();
208 private final Map<String, Conference> mConferenceById = new ConcurrentHashMap<>();
209 private final Map<Conference, String> mIdByConference = new ConcurrentHashMap<>();
Ihab Awadb8e85c72014-08-23 20:34:57 -0700210 private final RemoteConnectionManager mRemoteConnectionManager =
211 new RemoteConnectionManager(this);
Ihab Awad5d0410f2014-07-30 10:07:40 -0700212 private final List<Runnable> mPreInitializationConnectionRequests = new ArrayList<>();
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700213 private final ConnectionServiceAdapter mAdapter = new ConnectionServiceAdapter();
Ihab Awad542e0ea2014-05-16 10:22:16 -0700214
Santos Cordon823fd3c2014-08-07 18:35:18 -0700215 private boolean mAreAccountsInitialized = false;
Santos Cordon0159ac02014-08-21 14:28:11 -0700216 private Conference sNullConference;
Tyler Gunnf0500bd2015-09-01 10:59:48 -0700217 private Object mIdSyncRoot = new Object();
218 private int mId = 0;
Santos Cordon823fd3c2014-08-07 18:35:18 -0700219
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700220 private final IBinder mBinder = new IConnectionService.Stub() {
221 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700222 public void addConnectionServiceAdapter(IConnectionServiceAdapter adapter,
223 Session.Info sessionInfo) {
224 Log.startSession(sessionInfo, SESSION_ADD_CS_ADAPTER);
225 try {
226 SomeArgs args = SomeArgs.obtain();
227 args.arg1 = adapter;
228 args.arg2 = Log.createSubsession();
229 mHandler.obtainMessage(MSG_ADD_CONNECTION_SERVICE_ADAPTER, args).sendToTarget();
230 } finally {
231 Log.endSession();
232 }
Ihab Awad8aecfed2014-08-08 17:06:11 -0700233 }
234
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700235 public void removeConnectionServiceAdapter(IConnectionServiceAdapter adapter,
236 Session.Info sessionInfo) {
237 Log.startSession(sessionInfo, SESSION_REMOVE_CS_ADAPTER);
238 try {
239 SomeArgs args = SomeArgs.obtain();
240 args.arg1 = adapter;
241 args.arg2 = Log.createSubsession();
242 mHandler.obtainMessage(MSG_REMOVE_CONNECTION_SERVICE_ADAPTER, args).sendToTarget();
243 } finally {
244 Log.endSession();
245 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700246 }
247
248 @Override
Ihab Awadf8b69882014-07-25 15:14:01 -0700249 public void createConnection(
250 PhoneAccountHandle connectionManagerPhoneAccount,
Ihab Awadb19a0bc2014-08-07 19:46:01 -0700251 String id,
Ihab Awadf8b69882014-07-25 15:14:01 -0700252 ConnectionRequest request,
Yorke Leec3cf9822014-10-02 09:38:39 -0700253 boolean isIncoming,
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700254 boolean isUnknown,
255 Session.Info sessionInfo) {
256 Log.startSession(sessionInfo, SESSION_CREATE_CONN);
257 try {
258 SomeArgs args = SomeArgs.obtain();
259 args.arg1 = connectionManagerPhoneAccount;
260 args.arg2 = id;
261 args.arg3 = request;
262 args.arg4 = Log.createSubsession();
263 args.argi1 = isIncoming ? 1 : 0;
264 args.argi2 = isUnknown ? 1 : 0;
265 mHandler.obtainMessage(MSG_CREATE_CONNECTION, args).sendToTarget();
266 } finally {
267 Log.endSession();
268 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700269 }
270
271 @Override
Tyler Gunn041a1fe2017-05-12 10:04:49 -0700272 public void createConnectionComplete(String id, Session.Info sessionInfo) {
273 Log.startSession(sessionInfo, SESSION_CREATE_CONN_COMPLETE);
274 try {
275 SomeArgs args = SomeArgs.obtain();
276 args.arg1 = id;
277 args.arg2 = Log.createSubsession();
278 mHandler.obtainMessage(MSG_CREATE_CONNECTION_COMPLETE, args).sendToTarget();
279 } finally {
280 Log.endSession();
281 }
282 }
283
284 @Override
Tyler Gunn44e01912017-01-31 10:49:05 -0800285 public void createConnectionFailed(
Tyler Gunn159f35c2017-03-02 09:28:37 -0800286 PhoneAccountHandle connectionManagerPhoneAccount,
Tyler Gunn44e01912017-01-31 10:49:05 -0800287 String callId,
288 ConnectionRequest request,
289 boolean isIncoming,
290 Session.Info sessionInfo) {
291 Log.startSession(sessionInfo, SESSION_CREATE_CONN_FAILED);
292 try {
293 SomeArgs args = SomeArgs.obtain();
294 args.arg1 = callId;
295 args.arg2 = request;
296 args.arg3 = Log.createSubsession();
Tyler Gunn159f35c2017-03-02 09:28:37 -0800297 args.arg4 = connectionManagerPhoneAccount;
Tyler Gunn44e01912017-01-31 10:49:05 -0800298 args.argi1 = isIncoming ? 1 : 0;
299 mHandler.obtainMessage(MSG_CREATE_CONNECTION_FAILED, args).sendToTarget();
300 } finally {
301 Log.endSession();
302 }
303 }
304
305 @Override
Ravi Paluri80aa2142019-12-02 11:57:37 +0530306 public void createConference(
307 PhoneAccountHandle connectionManagerPhoneAccount,
308 String id,
309 ConnectionRequest request,
310 boolean isIncoming,
311 boolean isUnknown,
312 Session.Info sessionInfo) {
313 Log.startSession(sessionInfo, SESSION_CREATE_CONF);
314 try {
315 SomeArgs args = SomeArgs.obtain();
316 args.arg1 = connectionManagerPhoneAccount;
317 args.arg2 = id;
318 args.arg3 = request;
319 args.arg4 = Log.createSubsession();
320 args.argi1 = isIncoming ? 1 : 0;
321 args.argi2 = isUnknown ? 1 : 0;
322 mHandler.obtainMessage(MSG_CREATE_CONFERENCE, args).sendToTarget();
323 } finally {
324 Log.endSession();
325 }
326 }
327
328 @Override
329 public void createConferenceComplete(String id, Session.Info sessionInfo) {
330 Log.startSession(sessionInfo, SESSION_CREATE_CONF_COMPLETE);
331 try {
332 SomeArgs args = SomeArgs.obtain();
333 args.arg1 = id;
334 args.arg2 = Log.createSubsession();
335 mHandler.obtainMessage(MSG_CREATE_CONFERENCE_COMPLETE, args).sendToTarget();
336 } finally {
337 Log.endSession();
338 }
339 }
340
341 @Override
342 public void createConferenceFailed(
343 PhoneAccountHandle connectionManagerPhoneAccount,
344 String callId,
345 ConnectionRequest request,
346 boolean isIncoming,
347 Session.Info sessionInfo) {
348 Log.startSession(sessionInfo, SESSION_CREATE_CONF_FAILED);
349 try {
350 SomeArgs args = SomeArgs.obtain();
351 args.arg1 = callId;
352 args.arg2 = request;
353 args.arg3 = Log.createSubsession();
354 args.arg4 = connectionManagerPhoneAccount;
355 args.argi1 = isIncoming ? 1 : 0;
356 mHandler.obtainMessage(MSG_CREATE_CONFERENCE_FAILED, args).sendToTarget();
357 } finally {
358 Log.endSession();
359 }
360 }
361
362 @Override
Sanket Padawe4cc8ed52017-12-04 16:22:20 -0800363 public void handoverFailed(String callId, ConnectionRequest request, int reason,
364 Session.Info sessionInfo) {
365 Log.startSession(sessionInfo, SESSION_HANDOVER_FAILED);
366 try {
367 SomeArgs args = SomeArgs.obtain();
368 args.arg1 = callId;
369 args.arg2 = request;
370 args.arg3 = Log.createSubsession();
371 args.arg4 = reason;
372 mHandler.obtainMessage(MSG_HANDOVER_FAILED, args).sendToTarget();
373 } finally {
374 Log.endSession();
375 }
376 }
377
378 @Override
Tyler Gunn79bc1ec2018-01-22 15:17:54 -0800379 public void handoverComplete(String callId, Session.Info sessionInfo) {
380 Log.startSession(sessionInfo, SESSION_HANDOVER_COMPLETE);
381 try {
382 SomeArgs args = SomeArgs.obtain();
383 args.arg1 = callId;
384 args.arg2 = Log.createSubsession();
385 mHandler.obtainMessage(MSG_HANDOVER_COMPLETE, args).sendToTarget();
386 } finally {
387 Log.endSession();
388 }
389 }
390
391 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700392 public void abort(String callId, Session.Info sessionInfo) {
393 Log.startSession(sessionInfo, SESSION_ABORT);
394 try {
395 SomeArgs args = SomeArgs.obtain();
396 args.arg1 = callId;
397 args.arg2 = Log.createSubsession();
398 mHandler.obtainMessage(MSG_ABORT, args).sendToTarget();
399 } finally {
400 Log.endSession();
401 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700402 }
403
404 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700405 public void answerVideo(String callId, int videoState, Session.Info sessionInfo) {
406 Log.startSession(sessionInfo, SESSION_ANSWER_VIDEO);
407 try {
408 SomeArgs args = SomeArgs.obtain();
409 args.arg1 = callId;
410 args.arg2 = Log.createSubsession();
411 args.argi1 = videoState;
412 mHandler.obtainMessage(MSG_ANSWER_VIDEO, args).sendToTarget();
413 } finally {
414 Log.endSession();
415 }
Tyler Gunnbe74de02014-08-29 14:51:48 -0700416 }
417
418 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700419 public void answer(String callId, Session.Info sessionInfo) {
420 Log.startSession(sessionInfo, SESSION_ANSWER);
421 try {
422 SomeArgs args = SomeArgs.obtain();
423 args.arg1 = callId;
424 args.arg2 = Log.createSubsession();
425 mHandler.obtainMessage(MSG_ANSWER, args).sendToTarget();
426 } finally {
427 Log.endSession();
428 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700429 }
430
431 @Override
Pooja Jaind34698d2017-12-28 14:15:31 +0530432 public void deflect(String callId, Uri address, Session.Info sessionInfo) {
433 Log.startSession(sessionInfo, SESSION_DEFLECT);
434 try {
435 SomeArgs args = SomeArgs.obtain();
436 args.arg1 = callId;
437 args.arg2 = address;
438 args.arg3 = Log.createSubsession();
439 mHandler.obtainMessage(MSG_DEFLECT, args).sendToTarget();
440 } finally {
441 Log.endSession();
442 }
443 }
444
445 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700446 public void reject(String callId, Session.Info sessionInfo) {
447 Log.startSession(sessionInfo, SESSION_REJECT);
448 try {
449 SomeArgs args = SomeArgs.obtain();
450 args.arg1 = callId;
451 args.arg2 = Log.createSubsession();
452 mHandler.obtainMessage(MSG_REJECT, args).sendToTarget();
453 } finally {
454 Log.endSession();
455 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700456 }
457
458 @Override
Tyler Gunnfacfdee2020-01-23 13:10:37 -0800459 public void rejectWithReason(String callId,
460 @android.telecom.Call.RejectReason int rejectReason, Session.Info sessionInfo) {
461 Log.startSession(sessionInfo, SESSION_REJECT);
462 try {
463 SomeArgs args = SomeArgs.obtain();
464 args.arg1 = callId;
465 args.argi1 = rejectReason;
466 args.arg2 = Log.createSubsession();
467 mHandler.obtainMessage(MSG_REJECT_WITH_REASON, args).sendToTarget();
468 } finally {
469 Log.endSession();
470 }
471 }
472
473 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700474 public void rejectWithMessage(String callId, String message, Session.Info sessionInfo) {
475 Log.startSession(sessionInfo, SESSION_REJECT_MESSAGE);
476 try {
477 SomeArgs args = SomeArgs.obtain();
478 args.arg1 = callId;
479 args.arg2 = message;
480 args.arg3 = Log.createSubsession();
481 mHandler.obtainMessage(MSG_REJECT_WITH_MESSAGE, args).sendToTarget();
482 } finally {
483 Log.endSession();
484 }
Bryce Lee81901682015-08-28 16:38:02 -0700485 }
486
487 @Override
Ravi Palurif4b38e72020-02-05 12:35:41 +0530488 public void transfer(@NonNull String callId, @NonNull Uri number,
489 boolean isConfirmationRequired, Session.Info sessionInfo) {
490 Log.startSession(sessionInfo, SESSION_TRANSFER);
491 try {
492 SomeArgs args = SomeArgs.obtain();
493 args.arg1 = callId;
494 args.arg2 = number;
495 args.argi1 = isConfirmationRequired ? 1 : 0;
496 args.arg3 = Log.createSubsession();
497 mHandler.obtainMessage(MSG_EXPLICIT_CALL_TRANSFER, args).sendToTarget();
498 } finally {
499 Log.endSession();
500 }
501 }
502
503 @Override
504 public void consultativeTransfer(@NonNull String callId, @NonNull String otherCallId,
505 Session.Info sessionInfo) {
506 Log.startSession(sessionInfo, SESSION_CONSULTATIVE_TRANSFER);
507 try {
508 SomeArgs args = SomeArgs.obtain();
509 args.arg1 = callId;
510 args.arg2 = otherCallId;
511 args.arg3 = Log.createSubsession();
512 mHandler.obtainMessage(
513 MSG_EXPLICIT_CALL_TRANSFER_CONSULTATIVE, args).sendToTarget();
514 } finally {
515 Log.endSession();
516 }
517 }
518
519 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700520 public void silence(String callId, Session.Info sessionInfo) {
521 Log.startSession(sessionInfo, SESSION_SILENCE);
522 try {
523 SomeArgs args = SomeArgs.obtain();
524 args.arg1 = callId;
525 args.arg2 = Log.createSubsession();
526 mHandler.obtainMessage(MSG_SILENCE, args).sendToTarget();
527 } finally {
528 Log.endSession();
529 }
Bryce Leecac50772015-11-17 15:13:29 -0800530 }
531
532 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700533 public void disconnect(String callId, Session.Info sessionInfo) {
534 Log.startSession(sessionInfo, SESSION_DISCONNECT);
535 try {
536 SomeArgs args = SomeArgs.obtain();
537 args.arg1 = callId;
538 args.arg2 = Log.createSubsession();
539 mHandler.obtainMessage(MSG_DISCONNECT, args).sendToTarget();
540 } finally {
541 Log.endSession();
542 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700543 }
544
545 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700546 public void hold(String callId, Session.Info sessionInfo) {
547 Log.startSession(sessionInfo, SESSION_HOLD);
548 try {
549 SomeArgs args = SomeArgs.obtain();
550 args.arg1 = callId;
551 args.arg2 = Log.createSubsession();
552 mHandler.obtainMessage(MSG_HOLD, args).sendToTarget();
553 } finally {
554 Log.endSession();
555 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700556 }
557
558 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700559 public void unhold(String callId, Session.Info sessionInfo) {
560 Log.startSession(sessionInfo, SESSION_UNHOLD);
561 try {
562 SomeArgs args = SomeArgs.obtain();
563 args.arg1 = callId;
564 args.arg2 = Log.createSubsession();
565 mHandler.obtainMessage(MSG_UNHOLD, args).sendToTarget();
566 } finally {
567 Log.endSession();
568 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700569 }
570
571 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700572 public void onCallAudioStateChanged(String callId, CallAudioState callAudioState,
573 Session.Info sessionInfo) {
574 Log.startSession(sessionInfo, SESSION_CALL_AUDIO_SC);
575 try {
576 SomeArgs args = SomeArgs.obtain();
577 args.arg1 = callId;
578 args.arg2 = callAudioState;
579 args.arg3 = Log.createSubsession();
580 mHandler.obtainMessage(MSG_ON_CALL_AUDIO_STATE_CHANGED, args).sendToTarget();
581 } finally {
582 Log.endSession();
583 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700584 }
585
586 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700587 public void playDtmfTone(String callId, char digit, Session.Info sessionInfo) {
588 Log.startSession(sessionInfo, SESSION_PLAY_DTMF);
589 try {
590 SomeArgs args = SomeArgs.obtain();
591 args.arg1 = digit;
592 args.arg2 = callId;
593 args.arg3 = Log.createSubsession();
594 mHandler.obtainMessage(MSG_PLAY_DTMF_TONE, args).sendToTarget();
595 } finally {
596 Log.endSession();
597 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700598 }
599
600 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700601 public void stopDtmfTone(String callId, Session.Info sessionInfo) {
602 Log.startSession(sessionInfo, SESSION_STOP_DTMF);
603 try {
604 SomeArgs args = SomeArgs.obtain();
605 args.arg1 = callId;
606 args.arg2 = Log.createSubsession();
607 mHandler.obtainMessage(MSG_STOP_DTMF_TONE, args).sendToTarget();
608 } finally {
609 Log.endSession();
610 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700611 }
612
613 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700614 public void conference(String callId1, String callId2, Session.Info sessionInfo) {
615 Log.startSession(sessionInfo, SESSION_CONFERENCE);
616 try {
617 SomeArgs args = SomeArgs.obtain();
618 args.arg1 = callId1;
619 args.arg2 = callId2;
620 args.arg3 = Log.createSubsession();
621 mHandler.obtainMessage(MSG_CONFERENCE, args).sendToTarget();
622 } finally {
623 Log.endSession();
624 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700625 }
626
627 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700628 public void splitFromConference(String callId, Session.Info sessionInfo) {
629 Log.startSession(sessionInfo, SESSION_SPLIT_CONFERENCE);
630 try {
631 SomeArgs args = SomeArgs.obtain();
632 args.arg1 = callId;
633 args.arg2 = Log.createSubsession();
634 mHandler.obtainMessage(MSG_SPLIT_FROM_CONFERENCE, args).sendToTarget();
635 } finally {
636 Log.endSession();
637 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700638 }
639
640 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700641 public void mergeConference(String callId, Session.Info sessionInfo) {
642 Log.startSession(sessionInfo, SESSION_MERGE_CONFERENCE);
643 try {
644 SomeArgs args = SomeArgs.obtain();
645 args.arg1 = callId;
646 args.arg2 = Log.createSubsession();
647 mHandler.obtainMessage(MSG_MERGE_CONFERENCE, args).sendToTarget();
648 } finally {
649 Log.endSession();
650 }
Santos Cordona4868042014-09-04 17:39:22 -0700651 }
652
653 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700654 public void swapConference(String callId, Session.Info sessionInfo) {
655 Log.startSession(sessionInfo, SESSION_SWAP_CONFERENCE);
656 try {
657 SomeArgs args = SomeArgs.obtain();
658 args.arg1 = callId;
659 args.arg2 = Log.createSubsession();
660 mHandler.obtainMessage(MSG_SWAP_CONFERENCE, args).sendToTarget();
661 } finally {
662 Log.endSession();
663 }
Santos Cordona4868042014-09-04 17:39:22 -0700664 }
665
666 @Override
Ravi Paluri404babb2020-01-23 19:02:44 +0530667 public void addConferenceParticipants(String callId, List<Uri> participants,
668 Session.Info sessionInfo) {
669 Log.startSession(sessionInfo, SESSION_ADD_PARTICIPANT);
670 try {
671 SomeArgs args = SomeArgs.obtain();
672 args.arg1 = callId;
673 args.arg2 = participants;
674 args.arg3 = Log.createSubsession();
675 mHandler.obtainMessage(MSG_ADD_PARTICIPANT, args).sendToTarget();
676 } finally {
677 Log.endSession();
678 }
679 }
680
681 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700682 public void onPostDialContinue(String callId, boolean proceed, Session.Info sessionInfo) {
683 Log.startSession(sessionInfo, SESSION_POST_DIAL_CONT);
684 try {
685 SomeArgs args = SomeArgs.obtain();
686 args.arg1 = callId;
687 args.arg2 = Log.createSubsession();
688 args.argi1 = proceed ? 1 : 0;
689 mHandler.obtainMessage(MSG_ON_POST_DIAL_CONTINUE, args).sendToTarget();
690 } finally {
691 Log.endSession();
692 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700693 }
Tyler Gunn876dbfb2016-03-14 15:18:07 -0700694
695 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700696 public void pullExternalCall(String callId, Session.Info sessionInfo) {
697 Log.startSession(sessionInfo, SESSION_PULL_EXTERNAL_CALL);
698 try {
699 SomeArgs args = SomeArgs.obtain();
700 args.arg1 = callId;
701 args.arg2 = Log.createSubsession();
702 mHandler.obtainMessage(MSG_PULL_EXTERNAL_CALL, args).sendToTarget();
703 } finally {
704 Log.endSession();
705 }
Tyler Gunn876dbfb2016-03-14 15:18:07 -0700706 }
707
708 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700709 public void sendCallEvent(String callId, String event, Bundle extras,
710 Session.Info sessionInfo) {
711 Log.startSession(sessionInfo, SESSION_SEND_CALL_EVENT);
712 try {
713 SomeArgs args = SomeArgs.obtain();
714 args.arg1 = callId;
715 args.arg2 = event;
716 args.arg3 = extras;
717 args.arg4 = Log.createSubsession();
718 mHandler.obtainMessage(MSG_SEND_CALL_EVENT, args).sendToTarget();
719 } finally {
720 Log.endSession();
721 }
Tyler Gunn876dbfb2016-03-14 15:18:07 -0700722 }
Tyler Gunndee56a82016-03-23 16:06:34 -0700723
724 @Override
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700725 public void onExtrasChanged(String callId, Bundle extras, Session.Info sessionInfo) {
726 Log.startSession(sessionInfo, SESSION_EXTRAS_CHANGED);
727 try {
728 SomeArgs args = SomeArgs.obtain();
729 args.arg1 = callId;
730 args.arg2 = extras;
731 args.arg3 = Log.createSubsession();
732 mHandler.obtainMessage(MSG_ON_EXTRAS_CHANGED, args).sendToTarget();
733 } finally {
734 Log.endSession();
735 }
Tyler Gunndee56a82016-03-23 16:06:34 -0700736 }
Hall Liub64ac4c2017-02-06 10:49:48 -0800737
738 @Override
739 public void startRtt(String callId, ParcelFileDescriptor fromInCall,
740 ParcelFileDescriptor toInCall, Session.Info sessionInfo) throws RemoteException {
741 Log.startSession(sessionInfo, SESSION_START_RTT);
742 try {
743 SomeArgs args = SomeArgs.obtain();
744 args.arg1 = callId;
745 args.arg2 = new Connection.RttTextStream(toInCall, fromInCall);
746 args.arg3 = Log.createSubsession();
747 mHandler.obtainMessage(MSG_ON_START_RTT, args).sendToTarget();
748 } finally {
749 Log.endSession();
750 }
751 }
752
753 @Override
754 public void stopRtt(String callId, Session.Info sessionInfo) throws RemoteException {
755 Log.startSession(sessionInfo, SESSION_STOP_RTT);
756 try {
757 SomeArgs args = SomeArgs.obtain();
758 args.arg1 = callId;
759 args.arg2 = Log.createSubsession();
760 mHandler.obtainMessage(MSG_ON_STOP_RTT, args).sendToTarget();
761 } finally {
762 Log.endSession();
763 }
764 }
765
766 @Override
767 public void respondToRttUpgradeRequest(String callId, ParcelFileDescriptor fromInCall,
768 ParcelFileDescriptor toInCall, Session.Info sessionInfo) throws RemoteException {
769 Log.startSession(sessionInfo, SESSION_RTT_UPGRADE_RESPONSE);
770 try {
771 SomeArgs args = SomeArgs.obtain();
772 args.arg1 = callId;
773 if (toInCall == null || fromInCall == null) {
774 args.arg2 = null;
775 } else {
776 args.arg2 = new Connection.RttTextStream(toInCall, fromInCall);
777 }
778 args.arg3 = Log.createSubsession();
779 mHandler.obtainMessage(MSG_RTT_UPGRADE_RESPONSE, args).sendToTarget();
780 } finally {
781 Log.endSession();
782 }
783 }
Pengquan Meng731c1a32017-11-21 18:01:13 -0800784
785 @Override
786 public void connectionServiceFocusLost(Session.Info sessionInfo) throws RemoteException {
787 Log.startSession(sessionInfo, SESSION_CONNECTION_SERVICE_FOCUS_LOST);
788 try {
789 mHandler.obtainMessage(MSG_CONNECTION_SERVICE_FOCUS_LOST).sendToTarget();
790 } finally {
791 Log.endSession();
792 }
793 }
794
795 @Override
796 public void connectionServiceFocusGained(Session.Info sessionInfo) throws RemoteException {
797 Log.startSession(sessionInfo, SESSION_CONNECTION_SERVICE_FOCUS_GAINED);
798 try {
799 mHandler.obtainMessage(MSG_CONNECTION_SERVICE_FOCUS_GAINED).sendToTarget();
800 } finally {
801 Log.endSession();
802 }
803 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700804 };
805
806 private final Handler mHandler = new Handler(Looper.getMainLooper()) {
807 @Override
808 public void handleMessage(Message msg) {
809 switch (msg.what) {
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700810 case MSG_ADD_CONNECTION_SERVICE_ADAPTER: {
811 SomeArgs args = (SomeArgs) msg.obj;
812 try {
813 IConnectionServiceAdapter adapter = (IConnectionServiceAdapter) args.arg1;
814 Log.continueSession((Session) args.arg2,
815 SESSION_HANDLER + SESSION_ADD_CS_ADAPTER);
816 mAdapter.addAdapter(adapter);
817 onAdapterAttached();
818 } finally {
819 args.recycle();
820 Log.endSession();
821 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700822 break;
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700823 }
824 case MSG_REMOVE_CONNECTION_SERVICE_ADAPTER: {
825 SomeArgs args = (SomeArgs) msg.obj;
826 try {
827 Log.continueSession((Session) args.arg2,
828 SESSION_HANDLER + SESSION_REMOVE_CS_ADAPTER);
829 mAdapter.removeAdapter((IConnectionServiceAdapter) args.arg1);
830 } finally {
831 args.recycle();
832 Log.endSession();
833 }
Ihab Awad8aecfed2014-08-08 17:06:11 -0700834 break;
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700835 }
Ihab Awadf8b69882014-07-25 15:14:01 -0700836 case MSG_CREATE_CONNECTION: {
837 SomeArgs args = (SomeArgs) msg.obj;
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700838 Log.continueSession((Session) args.arg4, SESSION_HANDLER + SESSION_CREATE_CONN);
Ihab Awadf8b69882014-07-25 15:14:01 -0700839 try {
Ihab Awad5d0410f2014-07-30 10:07:40 -0700840 final PhoneAccountHandle connectionManagerPhoneAccount =
Ihab Awadf8b69882014-07-25 15:14:01 -0700841 (PhoneAccountHandle) args.arg1;
Ihab Awadb19a0bc2014-08-07 19:46:01 -0700842 final String id = (String) args.arg2;
843 final ConnectionRequest request = (ConnectionRequest) args.arg3;
Ihab Awad5d0410f2014-07-30 10:07:40 -0700844 final boolean isIncoming = args.argi1 == 1;
Yorke Leec3cf9822014-10-02 09:38:39 -0700845 final boolean isUnknown = args.argi2 == 1;
Ihab Awad5d0410f2014-07-30 10:07:40 -0700846 if (!mAreAccountsInitialized) {
Ihab Awadb19a0bc2014-08-07 19:46:01 -0700847 Log.d(this, "Enqueueing pre-init request %s", id);
Brad Ebinger0c3541b2016-11-01 14:11:38 -0700848 mPreInitializationConnectionRequests.add(
849 new android.telecom.Logging.Runnable(
850 SESSION_HANDLER + SESSION_CREATE_CONN + ".pICR",
851 null /*lock*/) {
Ihab Awad5d0410f2014-07-30 10:07:40 -0700852 @Override
Brad Ebinger0c3541b2016-11-01 14:11:38 -0700853 public void loggedRun() {
Ihab Awad5d0410f2014-07-30 10:07:40 -0700854 createConnection(
855 connectionManagerPhoneAccount,
Ihab Awadb19a0bc2014-08-07 19:46:01 -0700856 id,
Ihab Awad5d0410f2014-07-30 10:07:40 -0700857 request,
Yorke Leec3cf9822014-10-02 09:38:39 -0700858 isIncoming,
859 isUnknown);
Ihab Awad5d0410f2014-07-30 10:07:40 -0700860 }
Brad Ebinger0c3541b2016-11-01 14:11:38 -0700861 }.prepare());
Ihab Awad5d0410f2014-07-30 10:07:40 -0700862 } else {
Ihab Awadb19a0bc2014-08-07 19:46:01 -0700863 createConnection(
864 connectionManagerPhoneAccount,
865 id,
866 request,
Yorke Leec3cf9822014-10-02 09:38:39 -0700867 isIncoming,
868 isUnknown);
Ihab Awad5d0410f2014-07-30 10:07:40 -0700869 }
Ihab Awadf8b69882014-07-25 15:14:01 -0700870 } finally {
871 args.recycle();
Brad Ebingerb32d4f82016-10-24 16:40:49 -0700872 Log.endSession();
Ihab Awadf8b69882014-07-25 15:14:01 -0700873 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -0700874 break;
Ihab Awadf8b69882014-07-25 15:14:01 -0700875 }
Tyler Gunn041a1fe2017-05-12 10:04:49 -0700876 case MSG_CREATE_CONNECTION_COMPLETE: {
877 SomeArgs args = (SomeArgs) msg.obj;
878 Log.continueSession((Session) args.arg2,
879 SESSION_HANDLER + SESSION_CREATE_CONN_COMPLETE);
880 try {
881 final String id = (String) args.arg1;
882 if (!mAreAccountsInitialized) {
883 Log.d(this, "Enqueueing pre-init request %s", id);
884 mPreInitializationConnectionRequests.add(
885 new android.telecom.Logging.Runnable(
886 SESSION_HANDLER + SESSION_CREATE_CONN_COMPLETE
887 + ".pICR",
888 null /*lock*/) {
889 @Override
890 public void loggedRun() {
891 notifyCreateConnectionComplete(id);
892 }
893 }.prepare());
894 } else {
895 notifyCreateConnectionComplete(id);
896 }
897 } finally {
898 args.recycle();
899 Log.endSession();
900 }
901 break;
902 }
Tyler Gunn44e01912017-01-31 10:49:05 -0800903 case MSG_CREATE_CONNECTION_FAILED: {
904 SomeArgs args = (SomeArgs) msg.obj;
905 Log.continueSession((Session) args.arg3, SESSION_HANDLER +
906 SESSION_CREATE_CONN_FAILED);
907 try {
908 final String id = (String) args.arg1;
909 final ConnectionRequest request = (ConnectionRequest) args.arg2;
910 final boolean isIncoming = args.argi1 == 1;
Tyler Gunn159f35c2017-03-02 09:28:37 -0800911 final PhoneAccountHandle connectionMgrPhoneAccount =
912 (PhoneAccountHandle) args.arg4;
Tyler Gunn44e01912017-01-31 10:49:05 -0800913 if (!mAreAccountsInitialized) {
914 Log.d(this, "Enqueueing pre-init request %s", id);
915 mPreInitializationConnectionRequests.add(
916 new android.telecom.Logging.Runnable(
917 SESSION_HANDLER + SESSION_CREATE_CONN_FAILED + ".pICR",
918 null /*lock*/) {
919 @Override
920 public void loggedRun() {
Tyler Gunn159f35c2017-03-02 09:28:37 -0800921 createConnectionFailed(connectionMgrPhoneAccount, id,
922 request, isIncoming);
Tyler Gunn44e01912017-01-31 10:49:05 -0800923 }
924 }.prepare());
925 } else {
926 Log.i(this, "createConnectionFailed %s", id);
Tyler Gunn159f35c2017-03-02 09:28:37 -0800927 createConnectionFailed(connectionMgrPhoneAccount, id, request,
928 isIncoming);
Tyler Gunn44e01912017-01-31 10:49:05 -0800929 }
930 } finally {
931 args.recycle();
932 Log.endSession();
933 }
934 break;
935 }
Ravi Paluri80aa2142019-12-02 11:57:37 +0530936 case MSG_CREATE_CONFERENCE: {
937 SomeArgs args = (SomeArgs) msg.obj;
938 Log.continueSession((Session) args.arg4, SESSION_HANDLER + SESSION_CREATE_CONN);
939 try {
940 final PhoneAccountHandle connectionManagerPhoneAccount =
941 (PhoneAccountHandle) args.arg1;
942 final String id = (String) args.arg2;
943 final ConnectionRequest request = (ConnectionRequest) args.arg3;
944 final boolean isIncoming = args.argi1 == 1;
945 final boolean isUnknown = args.argi2 == 1;
946 if (!mAreAccountsInitialized) {
947 Log.d(this, "Enqueueing pre-initconference request %s", id);
948 mPreInitializationConnectionRequests.add(
949 new android.telecom.Logging.Runnable(
950 SESSION_HANDLER + SESSION_CREATE_CONF + ".pIConfR",
951 null /*lock*/) {
952 @Override
953 public void loggedRun() {
954 createConference(connectionManagerPhoneAccount,
955 id,
956 request,
957 isIncoming,
958 isUnknown);
959 }
960 }.prepare());
961 } else {
962 createConference(connectionManagerPhoneAccount,
963 id,
964 request,
965 isIncoming,
966 isUnknown);
967 }
968 } finally {
969 args.recycle();
970 Log.endSession();
971 }
972 break;
973 }
974 case MSG_CREATE_CONFERENCE_COMPLETE: {
975 SomeArgs args = (SomeArgs) msg.obj;
976 Log.continueSession((Session) args.arg2,
977 SESSION_HANDLER + SESSION_CREATE_CONN_COMPLETE);
978 try {
979 final String id = (String) args.arg1;
980 if (!mAreAccountsInitialized) {
981 Log.d(this, "Enqueueing pre-init conference request %s", id);
982 mPreInitializationConnectionRequests.add(
983 new android.telecom.Logging.Runnable(
984 SESSION_HANDLER + SESSION_CREATE_CONF_COMPLETE
985 + ".pIConfR",
986 null /*lock*/) {
987 @Override
988 public void loggedRun() {
989 notifyCreateConferenceComplete(id);
990 }
991 }.prepare());
992 } else {
993 notifyCreateConferenceComplete(id);
994 }
995 } finally {
996 args.recycle();
997 Log.endSession();
998 }
999 break;
1000 }
1001 case MSG_CREATE_CONFERENCE_FAILED: {
1002 SomeArgs args = (SomeArgs) msg.obj;
1003 Log.continueSession((Session) args.arg3, SESSION_HANDLER +
1004 SESSION_CREATE_CONN_FAILED);
1005 try {
1006 final String id = (String) args.arg1;
1007 final ConnectionRequest request = (ConnectionRequest) args.arg2;
1008 final boolean isIncoming = args.argi1 == 1;
1009 final PhoneAccountHandle connectionMgrPhoneAccount =
1010 (PhoneAccountHandle) args.arg4;
1011 if (!mAreAccountsInitialized) {
1012 Log.d(this, "Enqueueing pre-init conference request %s", id);
1013 mPreInitializationConnectionRequests.add(
1014 new android.telecom.Logging.Runnable(
1015 SESSION_HANDLER + SESSION_CREATE_CONF_FAILED
1016 + ".pIConfR",
1017 null /*lock*/) {
1018 @Override
1019 public void loggedRun() {
1020 createConferenceFailed(connectionMgrPhoneAccount, id,
1021 request, isIncoming);
1022 }
1023 }.prepare());
1024 } else {
1025 Log.i(this, "createConferenceFailed %s", id);
1026 createConferenceFailed(connectionMgrPhoneAccount, id, request,
1027 isIncoming);
1028 }
1029 } finally {
1030 args.recycle();
1031 Log.endSession();
1032 }
1033 break;
1034 }
1035
Sanket Padawe4cc8ed52017-12-04 16:22:20 -08001036 case MSG_HANDOVER_FAILED: {
1037 SomeArgs args = (SomeArgs) msg.obj;
1038 Log.continueSession((Session) args.arg3, SESSION_HANDLER +
1039 SESSION_HANDOVER_FAILED);
1040 try {
1041 final String id = (String) args.arg1;
1042 final ConnectionRequest request = (ConnectionRequest) args.arg2;
1043 final int reason = (int) args.arg4;
1044 if (!mAreAccountsInitialized) {
1045 Log.d(this, "Enqueueing pre-init request %s", id);
1046 mPreInitializationConnectionRequests.add(
1047 new android.telecom.Logging.Runnable(
1048 SESSION_HANDLER
1049 + SESSION_HANDOVER_FAILED + ".pICR",
1050 null /*lock*/) {
1051 @Override
1052 public void loggedRun() {
1053 handoverFailed(id, request, reason);
1054 }
1055 }.prepare());
1056 } else {
1057 Log.i(this, "createConnectionFailed %s", id);
1058 handoverFailed(id, request, reason);
1059 }
1060 } finally {
1061 args.recycle();
1062 Log.endSession();
1063 }
1064 break;
1065 }
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001066 case MSG_ABORT: {
1067 SomeArgs args = (SomeArgs) msg.obj;
1068 Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_ABORT);
1069 try {
1070 abort((String) args.arg1);
1071 } finally {
1072 args.recycle();
1073 Log.endSession();
1074 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001075 break;
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001076 }
1077 case MSG_ANSWER: {
1078 SomeArgs args = (SomeArgs) msg.obj;
1079 Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_ANSWER);
1080 try {
1081 answer((String) args.arg1);
1082 } finally {
1083 args.recycle();
1084 Log.endSession();
1085 }
Tyler Gunnbe74de02014-08-29 14:51:48 -07001086 break;
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001087 }
Tyler Gunnbe74de02014-08-29 14:51:48 -07001088 case MSG_ANSWER_VIDEO: {
Andrew Lee8da4c3c2014-07-16 10:11:42 -07001089 SomeArgs args = (SomeArgs) msg.obj;
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001090 Log.continueSession((Session) args.arg2,
1091 SESSION_HANDLER + SESSION_ANSWER_VIDEO);
Andrew Lee8da4c3c2014-07-16 10:11:42 -07001092 try {
1093 String callId = (String) args.arg1;
Evan Charltonbf11f982014-07-20 22:06:28 -07001094 int videoState = args.argi1;
Tyler Gunnbe74de02014-08-29 14:51:48 -07001095 answerVideo(callId, videoState);
Andrew Lee8da4c3c2014-07-16 10:11:42 -07001096 } finally {
1097 args.recycle();
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001098 Log.endSession();
Andrew Lee8da4c3c2014-07-16 10:11:42 -07001099 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001100 break;
Andrew Lee8da4c3c2014-07-16 10:11:42 -07001101 }
Pooja Jaind34698d2017-12-28 14:15:31 +05301102 case MSG_DEFLECT: {
1103 SomeArgs args = (SomeArgs) msg.obj;
1104 Log.continueSession((Session) args.arg3, SESSION_HANDLER + SESSION_DEFLECT);
1105 try {
1106 deflect((String) args.arg1, (Uri) args.arg2);
1107 } finally {
1108 args.recycle();
1109 Log.endSession();
1110 }
1111 break;
1112 }
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001113 case MSG_REJECT: {
1114 SomeArgs args = (SomeArgs) msg.obj;
1115 Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_REJECT);
1116 try {
1117 reject((String) args.arg1);
1118 } finally {
1119 args.recycle();
1120 Log.endSession();
1121 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001122 break;
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001123 }
Tyler Gunnfacfdee2020-01-23 13:10:37 -08001124 case MSG_REJECT_WITH_REASON: {
1125 SomeArgs args = (SomeArgs) msg.obj;
1126 Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_REJECT);
1127 try {
1128 reject((String) args.arg1, args.argi1);
1129 } finally {
1130 args.recycle();
1131 Log.endSession();
1132 }
1133 break;
1134 }
Bryce Lee81901682015-08-28 16:38:02 -07001135 case MSG_REJECT_WITH_MESSAGE: {
1136 SomeArgs args = (SomeArgs) msg.obj;
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001137 Log.continueSession((Session) args.arg3,
1138 SESSION_HANDLER + SESSION_REJECT_MESSAGE);
Bryce Lee81901682015-08-28 16:38:02 -07001139 try {
1140 reject((String) args.arg1, (String) args.arg2);
1141 } finally {
1142 args.recycle();
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001143 Log.endSession();
Bryce Lee81901682015-08-28 16:38:02 -07001144 }
1145 break;
1146 }
Ravi Palurif4b38e72020-02-05 12:35:41 +05301147 case MSG_EXPLICIT_CALL_TRANSFER: {
1148 SomeArgs args = (SomeArgs) msg.obj;
1149 Log.continueSession((Session) args.arg3, SESSION_HANDLER + SESSION_TRANSFER);
1150 try {
1151 final boolean isConfirmationRequired = args.argi1 == 1;
1152 transfer((String) args.arg1, (Uri) args.arg2, isConfirmationRequired);
1153 } finally {
1154 args.recycle();
1155 Log.endSession();
1156 }
1157 break;
1158 }
1159 case MSG_EXPLICIT_CALL_TRANSFER_CONSULTATIVE: {
1160 SomeArgs args = (SomeArgs) msg.obj;
1161 Log.continueSession(
1162 (Session) args.arg3, SESSION_HANDLER + SESSION_CONSULTATIVE_TRANSFER);
1163 try {
1164 consultativeTransfer((String) args.arg1, (String) args.arg2);
1165 } finally {
1166 args.recycle();
1167 Log.endSession();
1168 }
1169 break;
1170 }
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001171 case MSG_DISCONNECT: {
1172 SomeArgs args = (SomeArgs) msg.obj;
1173 Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_DISCONNECT);
1174 try {
1175 disconnect((String) args.arg1);
1176 } finally {
1177 args.recycle();
1178 Log.endSession();
1179 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001180 break;
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001181 }
1182 case MSG_SILENCE: {
1183 SomeArgs args = (SomeArgs) msg.obj;
1184 Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_SILENCE);
1185 try {
1186 silence((String) args.arg1);
1187 } finally {
1188 args.recycle();
1189 Log.endSession();
1190 }
Bryce Leecac50772015-11-17 15:13:29 -08001191 break;
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001192 }
1193 case MSG_HOLD: {
1194 SomeArgs args = (SomeArgs) msg.obj;
1195 Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_REJECT);
1196 try {
1197 hold((String) args.arg1);
1198 } finally {
1199 args.recycle();
1200 Log.endSession();
1201 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001202 break;
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001203 }
1204 case MSG_UNHOLD: {
1205 SomeArgs args = (SomeArgs) msg.obj;
1206 Log.continueSession((Session) args.arg2, SESSION_HANDLER + SESSION_UNHOLD);
1207 try {
1208 unhold((String) args.arg1);
1209 } finally {
1210 args.recycle();
1211 Log.endSession();
1212 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001213 break;
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001214 }
Yorke Lee4af59352015-05-13 14:14:54 -07001215 case MSG_ON_CALL_AUDIO_STATE_CHANGED: {
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001216 SomeArgs args = (SomeArgs) msg.obj;
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001217 Log.continueSession((Session) args.arg3,
1218 SESSION_HANDLER + SESSION_CALL_AUDIO_SC);
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001219 try {
1220 String callId = (String) args.arg1;
Yorke Lee4af59352015-05-13 14:14:54 -07001221 CallAudioState audioState = (CallAudioState) args.arg2;
1222 onCallAudioStateChanged(callId, new CallAudioState(audioState));
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001223 } finally {
1224 args.recycle();
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001225 Log.endSession();
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001226 }
1227 break;
1228 }
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001229 case MSG_PLAY_DTMF_TONE: {
1230 SomeArgs args = (SomeArgs) msg.obj;
1231 try {
1232 Log.continueSession((Session) args.arg3,
1233 SESSION_HANDLER + SESSION_PLAY_DTMF);
1234 playDtmfTone((String) args.arg2, (char) args.arg1);
1235 } finally {
1236 args.recycle();
1237 Log.endSession();
1238 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001239 break;
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001240 }
1241 case MSG_STOP_DTMF_TONE: {
1242 SomeArgs args = (SomeArgs) msg.obj;
1243 try {
1244 Log.continueSession((Session) args.arg2,
1245 SESSION_HANDLER + SESSION_STOP_DTMF);
1246 stopDtmfTone((String) args.arg1);
1247 } finally {
1248 args.recycle();
1249 Log.endSession();
1250 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001251 break;
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001252 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001253 case MSG_CONFERENCE: {
1254 SomeArgs args = (SomeArgs) msg.obj;
1255 try {
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001256 Log.continueSession((Session) args.arg3,
1257 SESSION_HANDLER + SESSION_CONFERENCE);
Santos Cordon823fd3c2014-08-07 18:35:18 -07001258 String callId1 = (String) args.arg1;
1259 String callId2 = (String) args.arg2;
1260 conference(callId1, callId2);
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001261 } finally {
1262 args.recycle();
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001263 Log.endSession();
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001264 }
1265 break;
1266 }
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001267 case MSG_SPLIT_FROM_CONFERENCE: {
1268 SomeArgs args = (SomeArgs) msg.obj;
1269 try {
1270 Log.continueSession((Session) args.arg2,
1271 SESSION_HANDLER + SESSION_SPLIT_CONFERENCE);
1272 splitFromConference((String) args.arg1);
1273 } finally {
1274 args.recycle();
1275 Log.endSession();
1276 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001277 break;
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001278 }
1279 case MSG_MERGE_CONFERENCE: {
1280 SomeArgs args = (SomeArgs) msg.obj;
1281 try {
1282 Log.continueSession((Session) args.arg2,
1283 SESSION_HANDLER + SESSION_MERGE_CONFERENCE);
1284 mergeConference((String) args.arg1);
1285 } finally {
1286 args.recycle();
1287 Log.endSession();
1288 }
Santos Cordona4868042014-09-04 17:39:22 -07001289 break;
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001290 }
1291 case MSG_SWAP_CONFERENCE: {
1292 SomeArgs args = (SomeArgs) msg.obj;
1293 try {
1294 Log.continueSession((Session) args.arg2,
1295 SESSION_HANDLER + SESSION_SWAP_CONFERENCE);
1296 swapConference((String) args.arg1);
1297 } finally {
1298 args.recycle();
1299 Log.endSession();
1300 }
Santos Cordona4868042014-09-04 17:39:22 -07001301 break;
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001302 }
Ravi Paluri404babb2020-01-23 19:02:44 +05301303 case MSG_ADD_PARTICIPANT: {
1304 SomeArgs args = (SomeArgs) msg.obj;
1305 try {
1306 Log.continueSession((Session) args.arg3,
1307 SESSION_HANDLER + SESSION_ADD_PARTICIPANT);
1308 addConferenceParticipants((String) args.arg1, (List<Uri>)args.arg2);
1309 } finally {
1310 args.recycle();
1311 Log.endSession();
1312 }
1313 break;
1314 }
1315
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001316 case MSG_ON_POST_DIAL_CONTINUE: {
1317 SomeArgs args = (SomeArgs) msg.obj;
1318 try {
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001319 Log.continueSession((Session) args.arg2,
1320 SESSION_HANDLER + SESSION_POST_DIAL_CONT);
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001321 String callId = (String) args.arg1;
1322 boolean proceed = (args.argi1 == 1);
1323 onPostDialContinue(callId, proceed);
1324 } finally {
1325 args.recycle();
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001326 Log.endSession();
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001327 }
1328 break;
1329 }
Tyler Gunn876dbfb2016-03-14 15:18:07 -07001330 case MSG_PULL_EXTERNAL_CALL: {
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001331 SomeArgs args = (SomeArgs) msg.obj;
1332 try {
1333 Log.continueSession((Session) args.arg2,
1334 SESSION_HANDLER + SESSION_PULL_EXTERNAL_CALL);
1335 pullExternalCall((String) args.arg1);
1336 } finally {
1337 args.recycle();
1338 Log.endSession();
1339 }
Tyler Gunn876dbfb2016-03-14 15:18:07 -07001340 break;
1341 }
1342 case MSG_SEND_CALL_EVENT: {
1343 SomeArgs args = (SomeArgs) msg.obj;
1344 try {
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001345 Log.continueSession((Session) args.arg4,
1346 SESSION_HANDLER + SESSION_SEND_CALL_EVENT);
Tyler Gunn876dbfb2016-03-14 15:18:07 -07001347 String callId = (String) args.arg1;
1348 String event = (String) args.arg2;
1349 Bundle extras = (Bundle) args.arg3;
1350 sendCallEvent(callId, event, extras);
1351 } finally {
1352 args.recycle();
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001353 Log.endSession();
Tyler Gunn876dbfb2016-03-14 15:18:07 -07001354 }
1355 break;
1356 }
Tyler Gunn79bc1ec2018-01-22 15:17:54 -08001357 case MSG_HANDOVER_COMPLETE: {
1358 SomeArgs args = (SomeArgs) msg.obj;
1359 try {
1360 Log.continueSession((Session) args.arg2,
1361 SESSION_HANDLER + SESSION_HANDOVER_COMPLETE);
1362 String callId = (String) args.arg1;
1363 notifyHandoverComplete(callId);
1364 } finally {
1365 args.recycle();
1366 Log.endSession();
1367 }
1368 break;
1369 }
Tyler Gunndee56a82016-03-23 16:06:34 -07001370 case MSG_ON_EXTRAS_CHANGED: {
1371 SomeArgs args = (SomeArgs) msg.obj;
1372 try {
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001373 Log.continueSession((Session) args.arg3,
1374 SESSION_HANDLER + SESSION_EXTRAS_CHANGED);
Tyler Gunndee56a82016-03-23 16:06:34 -07001375 String callId = (String) args.arg1;
1376 Bundle extras = (Bundle) args.arg2;
1377 handleExtrasChanged(callId, extras);
1378 } finally {
1379 args.recycle();
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001380 Log.endSession();
Tyler Gunndee56a82016-03-23 16:06:34 -07001381 }
1382 break;
1383 }
Hall Liub64ac4c2017-02-06 10:49:48 -08001384 case MSG_ON_START_RTT: {
1385 SomeArgs args = (SomeArgs) msg.obj;
1386 try {
1387 Log.continueSession((Session) args.arg3,
1388 SESSION_HANDLER + SESSION_START_RTT);
1389 String callId = (String) args.arg1;
1390 Connection.RttTextStream rttTextStream =
1391 (Connection.RttTextStream) args.arg2;
1392 startRtt(callId, rttTextStream);
1393 } finally {
1394 args.recycle();
1395 Log.endSession();
1396 }
1397 break;
1398 }
1399 case MSG_ON_STOP_RTT: {
1400 SomeArgs args = (SomeArgs) msg.obj;
1401 try {
1402 Log.continueSession((Session) args.arg2,
1403 SESSION_HANDLER + SESSION_STOP_RTT);
1404 String callId = (String) args.arg1;
1405 stopRtt(callId);
1406 } finally {
1407 args.recycle();
1408 Log.endSession();
1409 }
1410 break;
1411 }
1412 case MSG_RTT_UPGRADE_RESPONSE: {
1413 SomeArgs args = (SomeArgs) msg.obj;
1414 try {
1415 Log.continueSession((Session) args.arg3,
1416 SESSION_HANDLER + SESSION_RTT_UPGRADE_RESPONSE);
1417 String callId = (String) args.arg1;
1418 Connection.RttTextStream rttTextStream =
1419 (Connection.RttTextStream) args.arg2;
1420 handleRttUpgradeResponse(callId, rttTextStream);
1421 } finally {
1422 args.recycle();
1423 Log.endSession();
1424 }
1425 break;
1426 }
Pengquan Meng731c1a32017-11-21 18:01:13 -08001427 case MSG_CONNECTION_SERVICE_FOCUS_GAINED:
1428 onConnectionServiceFocusGained();
1429 break;
1430 case MSG_CONNECTION_SERVICE_FOCUS_LOST:
1431 onConnectionServiceFocusLost();
1432 break;
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001433 default:
1434 break;
1435 }
1436 }
1437 };
1438
Santos Cordon823fd3c2014-08-07 18:35:18 -07001439 private final Conference.Listener mConferenceListener = new Conference.Listener() {
1440 @Override
1441 public void onStateChanged(Conference conference, int oldState, int newState) {
1442 String id = mIdByConference.get(conference);
1443 switch (newState) {
Ravi Paluri80aa2142019-12-02 11:57:37 +05301444 case Connection.STATE_RINGING:
1445 mAdapter.setRinging(id);
1446 break;
1447 case Connection.STATE_DIALING:
1448 mAdapter.setDialing(id);
1449 break;
Santos Cordon823fd3c2014-08-07 18:35:18 -07001450 case Connection.STATE_ACTIVE:
1451 mAdapter.setActive(id);
1452 break;
1453 case Connection.STATE_HOLDING:
1454 mAdapter.setOnHold(id);
1455 break;
1456 case Connection.STATE_DISCONNECTED:
1457 // handled by onDisconnected
1458 break;
1459 }
1460 }
1461
1462 @Override
Andrew Lee7f3d41f2014-09-11 17:33:16 -07001463 public void onDisconnected(Conference conference, DisconnectCause disconnectCause) {
Santos Cordon823fd3c2014-08-07 18:35:18 -07001464 String id = mIdByConference.get(conference);
Andrew Lee7f3d41f2014-09-11 17:33:16 -07001465 mAdapter.setDisconnected(id, disconnectCause);
Santos Cordon823fd3c2014-08-07 18:35:18 -07001466 }
1467
1468 @Override
1469 public void onConnectionAdded(Conference conference, Connection connection) {
1470 }
1471
1472 @Override
1473 public void onConnectionRemoved(Conference conference, Connection connection) {
1474 }
1475
1476 @Override
Ihab Awad50e35062014-09-30 09:17:03 -07001477 public void onConferenceableConnectionsChanged(
1478 Conference conference, List<Connection> conferenceableConnections) {
1479 mAdapter.setConferenceableConnections(
1480 mIdByConference.get(conference),
1481 createConnectionIdList(conferenceableConnections));
1482 }
1483
1484 @Override
Santos Cordon823fd3c2014-08-07 18:35:18 -07001485 public void onDestroyed(Conference conference) {
1486 removeConference(conference);
1487 }
1488
1489 @Override
Ihab Awad5c9c86e2014-11-12 13:41:16 -08001490 public void onConnectionCapabilitiesChanged(
1491 Conference conference,
1492 int connectionCapabilities) {
Santos Cordon823fd3c2014-08-07 18:35:18 -07001493 String id = mIdByConference.get(conference);
1494 Log.d(this, "call capabilities: conference: %s",
Ihab Awad5c9c86e2014-11-12 13:41:16 -08001495 Connection.capabilitiesToString(connectionCapabilities));
1496 mAdapter.setConnectionCapabilities(id, connectionCapabilities);
Santos Cordon823fd3c2014-08-07 18:35:18 -07001497 }
Rekha Kumar07366812015-03-24 16:42:31 -07001498
1499 @Override
Tyler Gunn720c6642016-03-22 09:02:47 -07001500 public void onConnectionPropertiesChanged(
1501 Conference conference,
1502 int connectionProperties) {
1503 String id = mIdByConference.get(conference);
1504 Log.d(this, "call capabilities: conference: %s",
1505 Connection.propertiesToString(connectionProperties));
1506 mAdapter.setConnectionProperties(id, connectionProperties);
1507 }
1508
1509 @Override
Rekha Kumar07366812015-03-24 16:42:31 -07001510 public void onVideoStateChanged(Conference c, int videoState) {
1511 String id = mIdByConference.get(c);
1512 Log.d(this, "onVideoStateChanged set video state %d", videoState);
1513 mAdapter.setVideoState(id, videoState);
1514 }
1515
1516 @Override
1517 public void onVideoProviderChanged(Conference c, Connection.VideoProvider videoProvider) {
1518 String id = mIdByConference.get(c);
1519 Log.d(this, "onVideoProviderChanged: Connection: %s, VideoProvider: %s", c,
1520 videoProvider);
1521 mAdapter.setVideoProvider(id, videoProvider);
1522 }
Andrew Lee0f51da32015-04-16 13:11:55 -07001523
1524 @Override
Andrew Leeedc625f2015-04-14 13:38:12 -07001525 public void onStatusHintsChanged(Conference conference, StatusHints statusHints) {
1526 String id = mIdByConference.get(conference);
Tyler Gunndee56a82016-03-23 16:06:34 -07001527 if (id != null) {
1528 mAdapter.setStatusHints(id, statusHints);
1529 }
Andrew Leeedc625f2015-04-14 13:38:12 -07001530 }
Santos Cordon6b7f9552015-05-27 17:21:45 -07001531
1532 @Override
Tyler Gunndee56a82016-03-23 16:06:34 -07001533 public void onExtrasChanged(Conference c, Bundle extras) {
1534 String id = mIdByConference.get(c);
1535 if (id != null) {
1536 mAdapter.putExtras(id, extras);
1537 }
1538 }
1539
1540 @Override
1541 public void onExtrasRemoved(Conference c, List<String> keys) {
1542 String id = mIdByConference.get(c);
1543 if (id != null) {
1544 mAdapter.removeExtras(id, keys);
1545 }
Santos Cordon6b7f9552015-05-27 17:21:45 -07001546 }
Tyler Gunn68a73a42018-10-03 15:38:57 -07001547
1548 @Override
1549 public void onConferenceStateChanged(Conference c, boolean isConference) {
1550 String id = mIdByConference.get(c);
1551 if (id != null) {
1552 mAdapter.setConferenceState(id, isConference);
1553 }
1554 }
1555
1556 @Override
1557 public void onAddressChanged(Conference c, Uri newAddress, int presentation) {
1558 String id = mIdByConference.get(c);
1559 if (id != null) {
1560 mAdapter.setAddress(id, newAddress, presentation);
1561 }
1562 }
1563
1564 @Override
1565 public void onCallerDisplayNameChanged(Conference c, String callerDisplayName,
1566 int presentation) {
1567 String id = mIdByConference.get(c);
1568 if (id != null) {
1569 mAdapter.setCallerDisplayName(id, callerDisplayName, presentation);
1570 }
1571 }
Hall Liuc9bc1c62019-04-16 14:00:55 -07001572
1573 @Override
1574 public void onConnectionEvent(Conference c, String event, Bundle extras) {
1575 String id = mIdByConference.get(c);
1576 if (id != null) {
1577 mAdapter.onConnectionEvent(id, event, extras);
1578 }
1579 }
Ravi Paluri80aa2142019-12-02 11:57:37 +05301580
1581 @Override
1582 public void onRingbackRequested(Conference c, boolean ringback) {
1583 String id = mIdByConference.get(c);
1584 Log.d(this, "Adapter conference onRingback %b", ringback);
1585 mAdapter.setRingbackRequested(id, ringback);
1586 }
Santos Cordon823fd3c2014-08-07 18:35:18 -07001587 };
1588
Ihab Awad542e0ea2014-05-16 10:22:16 -07001589 private final Connection.Listener mConnectionListener = new Connection.Listener() {
1590 @Override
1591 public void onStateChanged(Connection c, int state) {
1592 String id = mIdByConnection.get(c);
Ihab Awad42b30e12014-05-22 09:49:34 -07001593 Log.d(this, "Adapter set state %s %s", id, Connection.stateToString(state));
Ihab Awad542e0ea2014-05-16 10:22:16 -07001594 switch (state) {
Ihab Awadb19a0bc2014-08-07 19:46:01 -07001595 case Connection.STATE_ACTIVE:
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001596 mAdapter.setActive(id);
Ihab Awad542e0ea2014-05-16 10:22:16 -07001597 break;
Ihab Awadb19a0bc2014-08-07 19:46:01 -07001598 case Connection.STATE_DIALING:
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001599 mAdapter.setDialing(id);
Ihab Awad542e0ea2014-05-16 10:22:16 -07001600 break;
Tyler Gunnc96b5e02016-07-07 22:53:57 -07001601 case Connection.STATE_PULLING_CALL:
1602 mAdapter.setPulling(id);
1603 break;
Ihab Awadb19a0bc2014-08-07 19:46:01 -07001604 case Connection.STATE_DISCONNECTED:
Ihab Awad542e0ea2014-05-16 10:22:16 -07001605 // Handled in onDisconnected()
1606 break;
Ihab Awadb19a0bc2014-08-07 19:46:01 -07001607 case Connection.STATE_HOLDING:
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001608 mAdapter.setOnHold(id);
Ihab Awad542e0ea2014-05-16 10:22:16 -07001609 break;
Ihab Awadb19a0bc2014-08-07 19:46:01 -07001610 case Connection.STATE_NEW:
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001611 // Nothing to tell Telecom
Ihab Awad542e0ea2014-05-16 10:22:16 -07001612 break;
Ihab Awadb19a0bc2014-08-07 19:46:01 -07001613 case Connection.STATE_RINGING:
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001614 mAdapter.setRinging(id);
Ihab Awad542e0ea2014-05-16 10:22:16 -07001615 break;
1616 }
1617 }
1618
1619 @Override
Andrew Lee7f3d41f2014-09-11 17:33:16 -07001620 public void onDisconnected(Connection c, DisconnectCause disconnectCause) {
Ihab Awad542e0ea2014-05-16 10:22:16 -07001621 String id = mIdByConnection.get(c);
Andrew Lee26786392014-09-16 18:14:59 -07001622 Log.d(this, "Adapter set disconnected %s", disconnectCause);
Andrew Lee7f3d41f2014-09-11 17:33:16 -07001623 mAdapter.setDisconnected(id, disconnectCause);
Ihab Awad542e0ea2014-05-16 10:22:16 -07001624 }
1625
1626 @Override
Tyler Gunnaa07df82014-07-17 07:50:22 -07001627 public void onVideoStateChanged(Connection c, int videoState) {
1628 String id = mIdByConnection.get(c);
1629 Log.d(this, "Adapter set video state %d", videoState);
1630 mAdapter.setVideoState(id, videoState);
1631 }
1632
1633 @Override
Andrew Lee100e2932014-09-08 15:34:24 -07001634 public void onAddressChanged(Connection c, Uri address, int presentation) {
Sailesh Nepal61203862014-07-11 14:50:13 -07001635 String id = mIdByConnection.get(c);
Andrew Lee100e2932014-09-08 15:34:24 -07001636 mAdapter.setAddress(id, address, presentation);
Sailesh Nepal61203862014-07-11 14:50:13 -07001637 }
1638
1639 @Override
1640 public void onCallerDisplayNameChanged(
1641 Connection c, String callerDisplayName, int presentation) {
1642 String id = mIdByConnection.get(c);
1643 mAdapter.setCallerDisplayName(id, callerDisplayName, presentation);
Ihab Awad542e0ea2014-05-16 10:22:16 -07001644 }
1645
1646 @Override
Ihab Awad542e0ea2014-05-16 10:22:16 -07001647 public void onDestroyed(Connection c) {
1648 removeConnection(c);
1649 }
Ihab Awadf8358972014-05-28 16:46:42 -07001650
1651 @Override
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001652 public void onPostDialWait(Connection c, String remaining) {
Sailesh Nepal091768c2014-06-30 15:15:23 -07001653 String id = mIdByConnection.get(c);
1654 Log.d(this, "Adapter onPostDialWait %s, %s", c, remaining);
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001655 mAdapter.onPostDialWait(id, remaining);
Sailesh Nepal091768c2014-06-30 15:15:23 -07001656 }
1657
1658 @Override
Nancy Chen27d1c2d2014-12-15 16:12:50 -08001659 public void onPostDialChar(Connection c, char nextChar) {
1660 String id = mIdByConnection.get(c);
1661 Log.d(this, "Adapter onPostDialChar %s, %s", c, nextChar);
1662 mAdapter.onPostDialChar(id, nextChar);
1663 }
1664
1665 @Override
Andrew Lee100e2932014-09-08 15:34:24 -07001666 public void onRingbackRequested(Connection c, boolean ringback) {
Ihab Awadf8358972014-05-28 16:46:42 -07001667 String id = mIdByConnection.get(c);
1668 Log.d(this, "Adapter onRingback %b", ringback);
Andrew Lee100e2932014-09-08 15:34:24 -07001669 mAdapter.setRingbackRequested(id, ringback);
Ihab Awadf8358972014-05-28 16:46:42 -07001670 }
Santos Cordonb6939982014-06-04 20:20:58 -07001671
1672 @Override
Ihab Awad5c9c86e2014-11-12 13:41:16 -08001673 public void onConnectionCapabilitiesChanged(Connection c, int capabilities) {
Santos Cordonb6939982014-06-04 20:20:58 -07001674 String id = mIdByConnection.get(c);
Ihab Awadb19a0bc2014-08-07 19:46:01 -07001675 Log.d(this, "capabilities: parcelableconnection: %s",
Ihab Awad5c9c86e2014-11-12 13:41:16 -08001676 Connection.capabilitiesToString(capabilities));
1677 mAdapter.setConnectionCapabilities(id, capabilities);
Santos Cordonb6939982014-06-04 20:20:58 -07001678 }
1679
Santos Cordonb6939982014-06-04 20:20:58 -07001680 @Override
Tyler Gunn720c6642016-03-22 09:02:47 -07001681 public void onConnectionPropertiesChanged(Connection c, int properties) {
1682 String id = mIdByConnection.get(c);
1683 Log.d(this, "properties: parcelableconnection: %s",
1684 Connection.propertiesToString(properties));
1685 mAdapter.setConnectionProperties(id, properties);
1686 }
1687
1688 @Override
Ihab Awadb19a0bc2014-08-07 19:46:01 -07001689 public void onVideoProviderChanged(Connection c, Connection.VideoProvider videoProvider) {
Andrew Lee5ffbe8b82014-06-20 16:29:33 -07001690 String id = mIdByConnection.get(c);
Rekha Kumar07366812015-03-24 16:42:31 -07001691 Log.d(this, "onVideoProviderChanged: Connection: %s, VideoProvider: %s", c,
1692 videoProvider);
Ihab Awadb19a0bc2014-08-07 19:46:01 -07001693 mAdapter.setVideoProvider(id, videoProvider);
Andrew Lee5ffbe8b82014-06-20 16:29:33 -07001694 }
Sailesh Nepal33aaae42014-07-07 22:49:44 -07001695
1696 @Override
Sailesh Nepal001bbbb2014-07-15 14:40:39 -07001697 public void onAudioModeIsVoipChanged(Connection c, boolean isVoip) {
Sailesh Nepal33aaae42014-07-07 22:49:44 -07001698 String id = mIdByConnection.get(c);
Andrew Lee100e2932014-09-08 15:34:24 -07001699 mAdapter.setIsVoipAudioMode(id, isVoip);
Sailesh Nepal33aaae42014-07-07 22:49:44 -07001700 }
Sailesh Nepale7ef59a2014-07-08 21:48:22 -07001701
1702 @Override
Sailesh Nepal001bbbb2014-07-15 14:40:39 -07001703 public void onStatusHintsChanged(Connection c, StatusHints statusHints) {
Sailesh Nepale7ef59a2014-07-08 21:48:22 -07001704 String id = mIdByConnection.get(c);
1705 mAdapter.setStatusHints(id, statusHints);
1706 }
Sailesh Nepal2ab88cc2014-07-18 14:49:18 -07001707
1708 @Override
Tyler Gunn6d76ca02014-11-17 15:49:51 -08001709 public void onConferenceablesChanged(
Tyler Gunndf2cbc82015-04-20 09:13:01 -07001710 Connection connection, List<Conferenceable> conferenceables) {
Ihab Awadb8e85c72014-08-23 20:34:57 -07001711 mAdapter.setConferenceableConnections(
1712 mIdByConnection.get(connection),
Tyler Gunn6d76ca02014-11-17 15:49:51 -08001713 createIdList(conferenceables));
Santos Cordon7c7bc7f2014-07-28 18:15:48 -07001714 }
Santos Cordon823fd3c2014-08-07 18:35:18 -07001715
1716 @Override
1717 public void onConferenceChanged(Connection connection, Conference conference) {
1718 String id = mIdByConnection.get(connection);
1719 if (id != null) {
1720 String conferenceId = null;
1721 if (conference != null) {
1722 conferenceId = mIdByConference.get(conference);
1723 }
1724 mAdapter.setIsConferenced(id, conferenceId);
1725 }
1726 }
Anthony Lee17455a32015-04-24 15:25:29 -07001727
1728 @Override
1729 public void onConferenceMergeFailed(Connection connection) {
1730 String id = mIdByConnection.get(connection);
1731 if (id != null) {
1732 mAdapter.onConferenceMergeFailed(id);
1733 }
1734 }
Santos Cordon6b7f9552015-05-27 17:21:45 -07001735
1736 @Override
Tyler Gunndee56a82016-03-23 16:06:34 -07001737 public void onExtrasChanged(Connection c, Bundle extras) {
1738 String id = mIdByConnection.get(c);
Santos Cordon6b7f9552015-05-27 17:21:45 -07001739 if (id != null) {
Tyler Gunndee56a82016-03-23 16:06:34 -07001740 mAdapter.putExtras(id, extras);
Santos Cordon6b7f9552015-05-27 17:21:45 -07001741 }
1742 }
Brad Ebingerb32d4f82016-10-24 16:40:49 -07001743
Tyler Gunnf5035432017-01-09 09:43:12 -08001744 @Override
Tyler Gunndee56a82016-03-23 16:06:34 -07001745 public void onExtrasRemoved(Connection c, List<String> keys) {
1746 String id = mIdByConnection.get(c);
1747 if (id != null) {
1748 mAdapter.removeExtras(id, keys);
1749 }
1750 }
1751
Tyler Gunnbd1eb1f2016-02-16 14:36:20 -08001752 @Override
Tyler Gunn876dbfb2016-03-14 15:18:07 -07001753 public void onConnectionEvent(Connection connection, String event, Bundle extras) {
Tyler Gunnbd1eb1f2016-02-16 14:36:20 -08001754 String id = mIdByConnection.get(connection);
1755 if (id != null) {
Tyler Gunn876dbfb2016-03-14 15:18:07 -07001756 mAdapter.onConnectionEvent(id, event, extras);
Tyler Gunnbd1eb1f2016-02-16 14:36:20 -08001757 }
1758 }
Tyler Gunnf5035432017-01-09 09:43:12 -08001759
1760 @Override
Hall Liua98f58b52017-11-07 17:59:28 -08001761 public void onAudioRouteChanged(Connection c, int audioRoute, String bluetoothAddress) {
Tyler Gunnf5035432017-01-09 09:43:12 -08001762 String id = mIdByConnection.get(c);
1763 if (id != null) {
Hall Liua98f58b52017-11-07 17:59:28 -08001764 mAdapter.setAudioRoute(id, audioRoute, bluetoothAddress);
Tyler Gunnf5035432017-01-09 09:43:12 -08001765 }
1766 }
Hall Liub64ac4c2017-02-06 10:49:48 -08001767
1768 @Override
1769 public void onRttInitiationSuccess(Connection c) {
1770 String id = mIdByConnection.get(c);
1771 if (id != null) {
1772 mAdapter.onRttInitiationSuccess(id);
1773 }
1774 }
1775
1776 @Override
1777 public void onRttInitiationFailure(Connection c, int reason) {
1778 String id = mIdByConnection.get(c);
1779 if (id != null) {
1780 mAdapter.onRttInitiationFailure(id, reason);
1781 }
1782 }
1783
1784 @Override
1785 public void onRttSessionRemotelyTerminated(Connection c) {
1786 String id = mIdByConnection.get(c);
1787 if (id != null) {
1788 mAdapter.onRttSessionRemotelyTerminated(id);
1789 }
1790 }
1791
1792 @Override
1793 public void onRemoteRttRequest(Connection c) {
1794 String id = mIdByConnection.get(c);
1795 if (id != null) {
1796 mAdapter.onRemoteRttRequest(id);
1797 }
1798 }
Srikanth Chintalafcb15012017-05-04 20:58:34 +05301799
1800 @Override
1801 public void onPhoneAccountChanged(Connection c, PhoneAccountHandle pHandle) {
1802 String id = mIdByConnection.get(c);
1803 if (id != null) {
1804 mAdapter.onPhoneAccountChanged(id, pHandle);
1805 }
1806 }
Mengjun Leng25707742017-07-04 11:10:37 +08001807
1808 public void onConnectionTimeReset(Connection c) {
1809 String id = mIdByConnection.get(c);
1810 if (id != null) {
1811 mAdapter.resetConnectionTime(id);
1812 }
1813 }
Ihab Awad542e0ea2014-05-16 10:22:16 -07001814 };
1815
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001816 /** {@inheritDoc} */
Ihab Awad542e0ea2014-05-16 10:22:16 -07001817 @Override
Sailesh Nepal2a46b902014-07-04 17:21:07 -07001818 public final IBinder onBind(Intent intent) {
1819 return mBinder;
1820 }
1821
Santos Cordon29f2f2e2014-09-11 19:50:24 -07001822 /** {@inheritDoc} */
1823 @Override
1824 public boolean onUnbind(Intent intent) {
1825 endAllConnections();
1826 return super.onUnbind(intent);
1827 }
1828
Ravi Paluri80aa2142019-12-02 11:57:37 +05301829
1830 /**
1831 * This can be used by telecom to either create a new outgoing conference call or attach
1832 * to an existing incoming conference call. In either case, telecom will cycle through a
1833 * set of services and call createConference until a connection service cancels the process
1834 * or completes it successfully.
1835 */
1836 private void createConference(
1837 final PhoneAccountHandle callManagerAccount,
1838 final String callId,
1839 final ConnectionRequest request,
1840 boolean isIncoming,
1841 boolean isUnknown) {
1842
1843 Conference conference = null;
1844 conference = isIncoming ? onCreateIncomingConference(callManagerAccount, request)
1845 : onCreateOutgoingConference(callManagerAccount, request);
1846
1847 Log.d(this, "createConference, conference: %s", conference);
1848 if (conference == null) {
1849 Log.i(this, "createConference, implementation returned null conference.");
1850 conference = Conference.createFailedConference(
1851 new DisconnectCause(DisconnectCause.ERROR, "IMPL_RETURNED_NULL_CONFERENCE"),
1852 request.getAccountHandle());
1853 }
1854 if (conference.getExtras() != null) {
1855 conference.getExtras().putString(Connection.EXTRA_ORIGINAL_CONNECTION_ID, callId);
1856 }
1857 mConferenceById.put(callId, conference);
1858 mIdByConference.put(conference, callId);
1859 conference.addListener(mConferenceListener);
1860 ParcelableConference parcelableConference = new ParcelableConference(
1861 request.getAccountHandle(),
1862 conference.getState(),
1863 conference.getConnectionCapabilities(),
1864 conference.getConnectionProperties(),
1865 Collections.<String>emptyList(), //connectionIds
1866 conference.getVideoProvider() == null ?
1867 null : conference.getVideoProvider().getInterface(),
1868 conference.getVideoState(),
1869 conference.getConnectTimeMillis(),
Tyler Gunnc9503d62020-01-27 10:30:51 -08001870 conference.getConnectionStartElapsedRealtimeMillis(),
Ravi Paluri80aa2142019-12-02 11:57:37 +05301871 conference.getStatusHints(),
1872 conference.getExtras(),
1873 conference.getAddress(),
1874 conference.getAddressPresentation(),
1875 conference.getCallerDisplayName(),
1876 conference.getCallerDisplayNamePresentation(),
1877 conference.getDisconnectCause(),
1878 conference.isRingbackRequested());
1879 if (conference.getState() != Connection.STATE_DISCONNECTED) {
1880 conference.setTelecomCallId(callId);
1881 mAdapter.setVideoProvider(callId, conference.getVideoProvider());
1882 mAdapter.setVideoState(callId, conference.getVideoState());
1883 onConferenceAdded(conference);
1884 }
1885
1886 Log.d(this, "createConference, calling handleCreateConferenceSuccessful %s", callId);
1887 mAdapter.handleCreateConferenceComplete(
1888 callId,
1889 request,
1890 parcelableConference);
1891 }
1892
Sailesh Nepalc5b01572014-07-14 16:29:44 -07001893 /**
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001894 * This can be used by telecom to either create a new outgoing call or attach to an existing
1895 * incoming call. In either case, telecom will cycle through a set of services and call
Sailesh Nepalc5b01572014-07-14 16:29:44 -07001896 * createConnection util a connection service cancels the process or completes it successfully.
1897 */
Ihab Awadf8b69882014-07-25 15:14:01 -07001898 private void createConnection(
1899 final PhoneAccountHandle callManagerAccount,
Ihab Awadb19a0bc2014-08-07 19:46:01 -07001900 final String callId,
Ihab Awadf8b69882014-07-25 15:14:01 -07001901 final ConnectionRequest request,
Yorke Leec3cf9822014-10-02 09:38:39 -07001902 boolean isIncoming,
1903 boolean isUnknown) {
Tyler Gunn79bc1ec2018-01-22 15:17:54 -08001904 boolean isLegacyHandover = request.getExtras() != null &&
1905 request.getExtras().getBoolean(TelecomManager.EXTRA_IS_HANDOVER, false);
1906 boolean isHandover = request.getExtras() != null && request.getExtras().getBoolean(
1907 TelecomManager.EXTRA_IS_HANDOVER_CONNECTION, false);
Sailesh Nepalcf7020b2014-08-20 10:07:19 -07001908 Log.d(this, "createConnection, callManagerAccount: %s, callId: %s, request: %s, " +
Tyler Gunn79bc1ec2018-01-22 15:17:54 -08001909 "isIncoming: %b, isUnknown: %b, isLegacyHandover: %b, isHandover: %b",
1910 callManagerAccount, callId, request, isIncoming, isUnknown, isLegacyHandover,
1911 isHandover);
Ihab Awad542e0ea2014-05-16 10:22:16 -07001912
Sanket Padawee29a2662017-12-01 13:59:27 -08001913 Connection connection = null;
Tyler Gunn79bc1ec2018-01-22 15:17:54 -08001914 if (isHandover) {
1915 PhoneAccountHandle fromPhoneAccountHandle = request.getExtras() != null
1916 ? (PhoneAccountHandle) request.getExtras().getParcelable(
1917 TelecomManager.EXTRA_HANDOVER_FROM_PHONE_ACCOUNT) : null;
Sanket Padawee29a2662017-12-01 13:59:27 -08001918 if (!isIncoming) {
Tyler Gunn79bc1ec2018-01-22 15:17:54 -08001919 connection = onCreateOutgoingHandoverConnection(fromPhoneAccountHandle, request);
Sanket Padawee29a2662017-12-01 13:59:27 -08001920 } else {
Tyler Gunn79bc1ec2018-01-22 15:17:54 -08001921 connection = onCreateIncomingHandoverConnection(fromPhoneAccountHandle, request);
Sanket Padawee29a2662017-12-01 13:59:27 -08001922 }
1923 } else {
1924 connection = isUnknown ? onCreateUnknownConnection(callManagerAccount, request)
1925 : isIncoming ? onCreateIncomingConnection(callManagerAccount, request)
1926 : onCreateOutgoingConnection(callManagerAccount, request);
1927 }
Sailesh Nepalcf7020b2014-08-20 10:07:19 -07001928 Log.d(this, "createConnection, connection: %s", connection);
1929 if (connection == null) {
Tyler Gunnfba1a8e2017-12-19 15:23:59 -08001930 Log.i(this, "createConnection, implementation returned null connection.");
Andrew Lee7f3d41f2014-09-11 17:33:16 -07001931 connection = Connection.createFailedConnection(
Tyler Gunnfba1a8e2017-12-19 15:23:59 -08001932 new DisconnectCause(DisconnectCause.ERROR, "IMPL_RETURNED_NULL_CONNECTION"));
Sailesh Nepalc5b01572014-07-14 16:29:44 -07001933 }
Ihab Awad542e0ea2014-05-16 10:22:16 -07001934
Tyler Gunnf2e08b42018-05-24 10:44:44 -07001935 boolean isSelfManaged =
1936 (connection.getConnectionProperties() & Connection.PROPERTY_SELF_MANAGED)
1937 == Connection.PROPERTY_SELF_MANAGED;
1938 // Self-managed Connections should always use voip audio mode; we default here so that the
1939 // local state within the ConnectionService matches the default we assume in Telecom.
1940 if (isSelfManaged) {
1941 connection.setAudioModeIsVoip(true);
1942 }
Tyler Gunnf0500bd2015-09-01 10:59:48 -07001943 connection.setTelecomCallId(callId);
Sailesh Nepalcf7020b2014-08-20 10:07:19 -07001944 if (connection.getState() != Connection.STATE_DISCONNECTED) {
Pengquan Meng70c9885332017-10-02 18:09:03 -07001945 addConnection(request.getAccountHandle(), callId, connection);
Ihab Awad6107bab2014-08-18 09:23:25 -07001946 }
1947
Andrew Lee100e2932014-09-08 15:34:24 -07001948 Uri address = connection.getAddress();
1949 String number = address == null ? "null" : address.getSchemeSpecificPart();
Tyler Gunn720c6642016-03-22 09:02:47 -07001950 Log.v(this, "createConnection, number: %s, state: %s, capabilities: %s, properties: %s",
Ihab Awadb19a0bc2014-08-07 19:46:01 -07001951 Connection.toLogSafePhoneNumber(number),
Sailesh Nepalcf7020b2014-08-20 10:07:19 -07001952 Connection.stateToString(connection.getState()),
Tyler Gunn720c6642016-03-22 09:02:47 -07001953 Connection.capabilitiesToString(connection.getConnectionCapabilities()),
1954 Connection.propertiesToString(connection.getConnectionProperties()));
Santos Cordon7c7bc7f2014-07-28 18:15:48 -07001955
Sailesh Nepalcf7020b2014-08-20 10:07:19 -07001956 Log.d(this, "createConnection, calling handleCreateConnectionSuccessful %s", callId);
Ihab Awad6107bab2014-08-18 09:23:25 -07001957 mAdapter.handleCreateConnectionComplete(
Ihab Awadb19a0bc2014-08-07 19:46:01 -07001958 callId,
Evan Charltonbf11f982014-07-20 22:06:28 -07001959 request,
1960 new ParcelableConnection(
1961 request.getAccountHandle(),
1962 connection.getState(),
Ihab Awad5c9c86e2014-11-12 13:41:16 -08001963 connection.getConnectionCapabilities(),
Tyler Gunn720c6642016-03-22 09:02:47 -07001964 connection.getConnectionProperties(),
Christine Hallstrom2830ce92016-11-30 16:06:42 -08001965 connection.getSupportedAudioRoutes(),
Andrew Lee100e2932014-09-08 15:34:24 -07001966 connection.getAddress(),
1967 connection.getAddressPresentation(),
Evan Charltonbf11f982014-07-20 22:06:28 -07001968 connection.getCallerDisplayName(),
1969 connection.getCallerDisplayNamePresentation(),
Ihab Awadb19a0bc2014-08-07 19:46:01 -07001970 connection.getVideoProvider() == null ?
1971 null : connection.getVideoProvider().getInterface(),
Sailesh Nepal8b9d3ca2014-08-14 17:39:34 -07001972 connection.getVideoState(),
Andrew Lee100e2932014-09-08 15:34:24 -07001973 connection.isRingbackRequested(),
Sailesh Nepal8b9d3ca2014-08-14 17:39:34 -07001974 connection.getAudioModeIsVoip(),
Roshan Piuse927ec02015-07-15 15:47:21 -07001975 connection.getConnectTimeMillis(),
Tyler Gunnc9503d62020-01-27 10:30:51 -08001976 connection.getConnectionStartElapsedRealtimeMillis(),
Ihab Awad6107bab2014-08-18 09:23:25 -07001977 connection.getStatusHints(),
Sailesh Nepalcf7020b2014-08-20 10:07:19 -07001978 connection.getDisconnectCause(),
Santos Cordon6b7f9552015-05-27 17:21:45 -07001979 createIdList(connection.getConferenceables()),
Tyler Gunnd57d76c2019-09-24 14:53:23 -07001980 connection.getExtras(),
1981 connection.getCallerNumberVerificationStatus()));
Tyler Gunnf5035432017-01-09 09:43:12 -08001982
Tyler Gunnf2e08b42018-05-24 10:44:44 -07001983 if (isIncoming && request.shouldShowIncomingCallUi() && isSelfManaged) {
Tyler Gunnf5035432017-01-09 09:43:12 -08001984 // Tell ConnectionService to show its incoming call UX.
1985 connection.onShowIncomingCallUi();
1986 }
Shriram Ganesh6bf35ac2014-12-11 17:53:38 -08001987 if (isUnknown) {
1988 triggerConferenceRecalculate();
1989 }
Evan Charltonbf11f982014-07-20 22:06:28 -07001990 }
1991
Tyler Gunn159f35c2017-03-02 09:28:37 -08001992 private void createConnectionFailed(final PhoneAccountHandle callManagerAccount,
1993 final String callId, final ConnectionRequest request,
1994 boolean isIncoming) {
Tyler Gunn44e01912017-01-31 10:49:05 -08001995
1996 Log.i(this, "createConnectionFailed %s", callId);
1997 if (isIncoming) {
Tyler Gunn159f35c2017-03-02 09:28:37 -08001998 onCreateIncomingConnectionFailed(callManagerAccount, request);
Tyler Gunn44e01912017-01-31 10:49:05 -08001999 } else {
Tyler Gunn159f35c2017-03-02 09:28:37 -08002000 onCreateOutgoingConnectionFailed(callManagerAccount, request);
Tyler Gunn44e01912017-01-31 10:49:05 -08002001 }
2002 }
2003
Ravi Paluri80aa2142019-12-02 11:57:37 +05302004 private void createConferenceFailed(final PhoneAccountHandle callManagerAccount,
2005 final String callId, final ConnectionRequest request,
2006 boolean isIncoming) {
2007
2008 Log.i(this, "createConferenceFailed %s", callId);
2009 if (isIncoming) {
2010 onCreateIncomingConferenceFailed(callManagerAccount, request);
2011 } else {
2012 onCreateOutgoingConferenceFailed(callManagerAccount, request);
2013 }
2014 }
2015
Sanket Padawe4cc8ed52017-12-04 16:22:20 -08002016 private void handoverFailed(final String callId, final ConnectionRequest request,
2017 int reason) {
2018
2019 Log.i(this, "handoverFailed %s", callId);
2020 onHandoverFailed(request, reason);
2021 }
2022
Tyler Gunn041a1fe2017-05-12 10:04:49 -07002023 /**
2024 * Called by Telecom when the creation of a new Connection has completed and it is now added
2025 * to Telecom.
2026 * @param callId The ID of the connection.
2027 */
2028 private void notifyCreateConnectionComplete(final String callId) {
2029 Log.i(this, "notifyCreateConnectionComplete %s", callId);
Tyler Gunn0a88f2e2017-06-16 20:20:34 -07002030 if (callId == null) {
2031 // This could happen if the connection fails quickly and is removed from the
2032 // ConnectionService before Telecom sends the create connection complete callback.
2033 Log.w(this, "notifyCreateConnectionComplete: callId is null.");
2034 return;
2035 }
Tyler Gunn041a1fe2017-05-12 10:04:49 -07002036 onCreateConnectionComplete(findConnectionForAction(callId,
2037 "notifyCreateConnectionComplete"));
2038 }
2039
Ravi Paluri80aa2142019-12-02 11:57:37 +05302040 /**
2041 * Called by Telecom when the creation of a new Conference has completed and it is now added
2042 * to Telecom.
2043 * @param callId The ID of the connection.
2044 */
2045 private void notifyCreateConferenceComplete(final String callId) {
2046 Log.i(this, "notifyCreateConferenceComplete %s", callId);
2047 if (callId == null) {
2048 // This could happen if the conference fails quickly and is removed from the
2049 // ConnectionService before Telecom sends the create conference complete callback.
2050 Log.w(this, "notifyCreateConferenceComplete: callId is null.");
2051 return;
2052 }
2053 onCreateConferenceComplete(findConferenceForAction(callId,
2054 "notifyCreateConferenceComplete"));
2055 }
2056
2057
Sailesh Nepal2a46b902014-07-04 17:21:07 -07002058 private void abort(String callId) {
Ihab Awad60ac30b2014-05-20 22:32:12 -07002059 Log.d(this, "abort %s", callId);
Sailesh Nepal2a46b902014-07-04 17:21:07 -07002060 findConnectionForAction(callId, "abort").onAbort();
Ihab Awad542e0ea2014-05-16 10:22:16 -07002061 }
2062
Tyler Gunnbe74de02014-08-29 14:51:48 -07002063 private void answerVideo(String callId, int videoState) {
2064 Log.d(this, "answerVideo %s", callId);
Ravi Paluri80aa2142019-12-02 11:57:37 +05302065 if (mConnectionById.containsKey(callId)) {
2066 findConnectionForAction(callId, "answer").onAnswer(videoState);
2067 } else {
2068 findConferenceForAction(callId, "answer").onAnswer(videoState);
2069 }
Ihab Awad542e0ea2014-05-16 10:22:16 -07002070 }
2071
Tyler Gunnbe74de02014-08-29 14:51:48 -07002072 private void answer(String callId) {
2073 Log.d(this, "answer %s", callId);
Ravi Paluri80aa2142019-12-02 11:57:37 +05302074 if (mConnectionById.containsKey(callId)) {
2075 findConnectionForAction(callId, "answer").onAnswer();
2076 } else {
2077 findConferenceForAction(callId, "answer").onAnswer();
2078 }
Tyler Gunnbe74de02014-08-29 14:51:48 -07002079 }
2080
Pooja Jaind34698d2017-12-28 14:15:31 +05302081 private void deflect(String callId, Uri address) {
2082 Log.d(this, "deflect %s", callId);
2083 findConnectionForAction(callId, "deflect").onDeflect(address);
2084 }
2085
Sailesh Nepal2a46b902014-07-04 17:21:07 -07002086 private void reject(String callId) {
Ihab Awad60ac30b2014-05-20 22:32:12 -07002087 Log.d(this, "reject %s", callId);
Ravi Paluri80aa2142019-12-02 11:57:37 +05302088 if (mConnectionById.containsKey(callId)) {
2089 findConnectionForAction(callId, "reject").onReject();
2090 } else {
2091 findConferenceForAction(callId, "reject").onReject();
2092 }
Ihab Awad542e0ea2014-05-16 10:22:16 -07002093 }
2094
Bryce Lee81901682015-08-28 16:38:02 -07002095 private void reject(String callId, String rejectWithMessage) {
2096 Log.d(this, "reject %s with message", callId);
2097 findConnectionForAction(callId, "reject").onReject(rejectWithMessage);
2098 }
2099
Tyler Gunnfacfdee2020-01-23 13:10:37 -08002100 private void reject(String callId, @android.telecom.Call.RejectReason int rejectReason) {
2101 Log.d(this, "reject %s with reason %d", callId, rejectReason);
2102 findConnectionForAction(callId, "reject").onReject(rejectReason);
2103 }
2104
Ravi Palurif4b38e72020-02-05 12:35:41 +05302105 private void transfer(String callId, Uri number, boolean isConfirmationRequired) {
2106 Log.d(this, "transfer %s", callId);
2107 findConnectionForAction(callId, "transfer").onTransfer(number, isConfirmationRequired);
2108 }
2109
2110 private void consultativeTransfer(String callId, String otherCallId) {
2111 Log.d(this, "consultativeTransfer %s", callId);
2112 Connection connection1 = findConnectionForAction(callId, "consultativeTransfer");
2113 Connection connection2 = findConnectionForAction(otherCallId, " consultativeTransfer");
2114 connection1.onTransfer(connection2);
2115 }
2116
Bryce Leecac50772015-11-17 15:13:29 -08002117 private void silence(String callId) {
2118 Log.d(this, "silence %s", callId);
2119 findConnectionForAction(callId, "silence").onSilence();
2120 }
2121
Sailesh Nepal2a46b902014-07-04 17:21:07 -07002122 private void disconnect(String callId) {
Ihab Awad60ac30b2014-05-20 22:32:12 -07002123 Log.d(this, "disconnect %s", callId);
Santos Cordon0159ac02014-08-21 14:28:11 -07002124 if (mConnectionById.containsKey(callId)) {
2125 findConnectionForAction(callId, "disconnect").onDisconnect();
2126 } else {
2127 findConferenceForAction(callId, "disconnect").onDisconnect();
2128 }
Ihab Awad542e0ea2014-05-16 10:22:16 -07002129 }
2130
Sailesh Nepal2a46b902014-07-04 17:21:07 -07002131 private void hold(String callId) {
Ihab Awad60ac30b2014-05-20 22:32:12 -07002132 Log.d(this, "hold %s", callId);
Santos Cordon0159ac02014-08-21 14:28:11 -07002133 if (mConnectionById.containsKey(callId)) {
2134 findConnectionForAction(callId, "hold").onHold();
2135 } else {
2136 findConferenceForAction(callId, "hold").onHold();
2137 }
Ihab Awad542e0ea2014-05-16 10:22:16 -07002138 }
2139
Sailesh Nepal2a46b902014-07-04 17:21:07 -07002140 private void unhold(String callId) {
Ihab Awad60ac30b2014-05-20 22:32:12 -07002141 Log.d(this, "unhold %s", callId);
Santos Cordon0159ac02014-08-21 14:28:11 -07002142 if (mConnectionById.containsKey(callId)) {
2143 findConnectionForAction(callId, "unhold").onUnhold();
2144 } else {
2145 findConferenceForAction(callId, "unhold").onUnhold();
2146 }
Ihab Awad542e0ea2014-05-16 10:22:16 -07002147 }
2148
Yorke Lee4af59352015-05-13 14:14:54 -07002149 private void onCallAudioStateChanged(String callId, CallAudioState callAudioState) {
2150 Log.d(this, "onAudioStateChanged %s %s", callId, callAudioState);
Yorke Leea0d3ca92014-09-15 19:18:13 -07002151 if (mConnectionById.containsKey(callId)) {
Yorke Lee4af59352015-05-13 14:14:54 -07002152 findConnectionForAction(callId, "onCallAudioStateChanged").setCallAudioState(
2153 callAudioState);
Yorke Leea0d3ca92014-09-15 19:18:13 -07002154 } else {
Yorke Lee4af59352015-05-13 14:14:54 -07002155 findConferenceForAction(callId, "onCallAudioStateChanged").setCallAudioState(
2156 callAudioState);
Yorke Leea0d3ca92014-09-15 19:18:13 -07002157 }
Ihab Awad542e0ea2014-05-16 10:22:16 -07002158 }
2159
Sailesh Nepal2a46b902014-07-04 17:21:07 -07002160 private void playDtmfTone(String callId, char digit) {
2161 Log.d(this, "playDtmfTone %s %c", callId, digit);
Yorke Leea0d3ca92014-09-15 19:18:13 -07002162 if (mConnectionById.containsKey(callId)) {
2163 findConnectionForAction(callId, "playDtmfTone").onPlayDtmfTone(digit);
2164 } else {
2165 findConferenceForAction(callId, "playDtmfTone").onPlayDtmfTone(digit);
2166 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -07002167 }
2168
2169 private void stopDtmfTone(String callId) {
2170 Log.d(this, "stopDtmfTone %s", callId);
Yorke Leea0d3ca92014-09-15 19:18:13 -07002171 if (mConnectionById.containsKey(callId)) {
2172 findConnectionForAction(callId, "stopDtmfTone").onStopDtmfTone();
2173 } else {
2174 findConferenceForAction(callId, "stopDtmfTone").onStopDtmfTone();
2175 }
Sailesh Nepal2a46b902014-07-04 17:21:07 -07002176 }
2177
Santos Cordon823fd3c2014-08-07 18:35:18 -07002178 private void conference(String callId1, String callId2) {
2179 Log.d(this, "conference %s, %s", callId1, callId2);
Santos Cordon980acb92014-05-31 10:31:19 -07002180
Tyler Gunn6d76ca02014-11-17 15:49:51 -08002181 // Attempt to get second connection or conference.
Santos Cordon823fd3c2014-08-07 18:35:18 -07002182 Connection connection2 = findConnectionForAction(callId2, "conference");
Tyler Gunn6d76ca02014-11-17 15:49:51 -08002183 Conference conference2 = getNullConference();
Sailesh Nepalcf7020b2014-08-20 10:07:19 -07002184 if (connection2 == getNullConnection()) {
Tyler Gunn6d76ca02014-11-17 15:49:51 -08002185 conference2 = findConferenceForAction(callId2, "conference");
2186 if (conference2 == getNullConference()) {
2187 Log.w(this, "Connection2 or Conference2 missing in conference request %s.",
2188 callId2);
2189 return;
2190 }
Santos Cordon823fd3c2014-08-07 18:35:18 -07002191 }
Santos Cordonb6939982014-06-04 20:20:58 -07002192
Tyler Gunn6d76ca02014-11-17 15:49:51 -08002193 // Attempt to get first connection or conference and perform merge.
Ihab Awad50e35062014-09-30 09:17:03 -07002194 Connection connection1 = findConnectionForAction(callId1, "conference");
2195 if (connection1 == getNullConnection()) {
2196 Conference conference1 = findConferenceForAction(callId1, "addConnection");
2197 if (conference1 == getNullConference()) {
2198 Log.w(this,
2199 "Connection1 or Conference1 missing in conference request %s.",
2200 callId1);
2201 } else {
Tyler Gunn6d76ca02014-11-17 15:49:51 -08002202 // Call 1 is a conference.
2203 if (connection2 != getNullConnection()) {
2204 // Call 2 is a connection so merge via call 1 (conference).
2205 conference1.onMerge(connection2);
2206 } else {
2207 // Call 2 is ALSO a conference; this should never happen.
2208 Log.wtf(this, "There can only be one conference and an attempt was made to " +
2209 "merge two conferences.");
2210 return;
2211 }
Ihab Awad50e35062014-09-30 09:17:03 -07002212 }
2213 } else {
Tyler Gunn6d76ca02014-11-17 15:49:51 -08002214 // Call 1 is a connection.
2215 if (conference2 != getNullConference()) {
2216 // Call 2 is a conference, so merge via call 2.
2217 conference2.onMerge(connection1);
2218 } else {
2219 // Call 2 is a connection, so merge together.
2220 onConference(connection1, connection2);
2221 }
Ihab Awad50e35062014-09-30 09:17:03 -07002222 }
Santos Cordon980acb92014-05-31 10:31:19 -07002223 }
2224
Sailesh Nepal2a46b902014-07-04 17:21:07 -07002225 private void splitFromConference(String callId) {
Santos Cordonb6939982014-06-04 20:20:58 -07002226 Log.d(this, "splitFromConference(%s)", callId);
Santos Cordon980acb92014-05-31 10:31:19 -07002227
2228 Connection connection = findConnectionForAction(callId, "splitFromConference");
Sailesh Nepalcf7020b2014-08-20 10:07:19 -07002229 if (connection == getNullConnection()) {
Santos Cordon980acb92014-05-31 10:31:19 -07002230 Log.w(this, "Connection missing in conference request %s.", callId);
2231 return;
2232 }
2233
Santos Cordon0159ac02014-08-21 14:28:11 -07002234 Conference conference = connection.getConference();
2235 if (conference != null) {
2236 conference.onSeparate(connection);
2237 }
Santos Cordon980acb92014-05-31 10:31:19 -07002238 }
2239
Santos Cordona4868042014-09-04 17:39:22 -07002240 private void mergeConference(String callId) {
2241 Log.d(this, "mergeConference(%s)", callId);
2242 Conference conference = findConferenceForAction(callId, "mergeConference");
2243 if (conference != null) {
2244 conference.onMerge();
2245 }
2246 }
2247
2248 private void swapConference(String callId) {
2249 Log.d(this, "swapConference(%s)", callId);
2250 Conference conference = findConferenceForAction(callId, "swapConference");
2251 if (conference != null) {
2252 conference.onSwap();
2253 }
2254 }
2255
Ravi Paluri404babb2020-01-23 19:02:44 +05302256 private void addConferenceParticipants(String callId, List<Uri> participants) {
2257 Log.d(this, "addConferenceParticipants(%s)", callId);
2258 if (mConnectionById.containsKey(callId)) {
2259 findConnectionForAction(callId, "addConferenceParticipants")
2260 .onAddConferenceParticipants(participants);
2261 } else {
2262 findConferenceForAction(callId, "addConferenceParticipants")
2263 .onAddConferenceParticipants(participants);
2264 }
2265 }
2266
Tyler Gunn876dbfb2016-03-14 15:18:07 -07002267 /**
2268 * Notifies a {@link Connection} of a request to pull an external call.
2269 *
2270 * See {@link Call#pullExternalCall()}.
2271 *
2272 * @param callId The ID of the call to pull.
2273 */
2274 private void pullExternalCall(String callId) {
2275 Log.d(this, "pullExternalCall(%s)", callId);
2276 Connection connection = findConnectionForAction(callId, "pullExternalCall");
2277 if (connection != null) {
2278 connection.onPullExternalCall();
2279 }
2280 }
2281
2282 /**
2283 * Notifies a {@link Connection} of a call event.
2284 *
2285 * See {@link Call#sendCallEvent(String, Bundle)}.
2286 *
2287 * @param callId The ID of the call receiving the event.
2288 * @param event The event.
2289 * @param extras Extras associated with the event.
2290 */
2291 private void sendCallEvent(String callId, String event, Bundle extras) {
2292 Log.d(this, "sendCallEvent(%s, %s)", callId, event);
2293 Connection connection = findConnectionForAction(callId, "sendCallEvent");
2294 if (connection != null) {
2295 connection.onCallEvent(event, extras);
2296 }
Tyler Gunn876dbfb2016-03-14 15:18:07 -07002297 }
2298
Tyler Gunndee56a82016-03-23 16:06:34 -07002299 /**
Tyler Gunn79bc1ec2018-01-22 15:17:54 -08002300 * Notifies a {@link Connection} that a handover has completed.
2301 *
2302 * @param callId The ID of the call which completed handover.
2303 */
2304 private void notifyHandoverComplete(String callId) {
2305 Log.d(this, "notifyHandoverComplete(%s)", callId);
2306 Connection connection = findConnectionForAction(callId, "notifyHandoverComplete");
2307 if (connection != null) {
2308 connection.onHandoverComplete();
2309 }
2310 }
2311
2312 /**
Tyler Gunndee56a82016-03-23 16:06:34 -07002313 * Notifies a {@link Connection} or {@link Conference} of a change to the extras from Telecom.
2314 * <p>
2315 * These extra changes can originate from Telecom itself, or from an {@link InCallService} via
2316 * the {@link android.telecom.Call#putExtra(String, boolean)},
2317 * {@link android.telecom.Call#putExtra(String, int)},
2318 * {@link android.telecom.Call#putExtra(String, String)},
2319 * {@link Call#removeExtras(List)}.
2320 *
2321 * @param callId The ID of the call receiving the event.
2322 * @param extras The new extras bundle.
2323 */
2324 private void handleExtrasChanged(String callId, Bundle extras) {
2325 Log.d(this, "handleExtrasChanged(%s, %s)", callId, extras);
2326 if (mConnectionById.containsKey(callId)) {
2327 findConnectionForAction(callId, "handleExtrasChanged").handleExtrasChanged(extras);
2328 } else if (mConferenceById.containsKey(callId)) {
2329 findConferenceForAction(callId, "handleExtrasChanged").handleExtrasChanged(extras);
2330 }
2331 }
2332
Hall Liub64ac4c2017-02-06 10:49:48 -08002333 private void startRtt(String callId, Connection.RttTextStream rttTextStream) {
2334 Log.d(this, "startRtt(%s)", callId);
2335 if (mConnectionById.containsKey(callId)) {
2336 findConnectionForAction(callId, "startRtt").onStartRtt(rttTextStream);
2337 } else if (mConferenceById.containsKey(callId)) {
2338 Log.w(this, "startRtt called on a conference.");
2339 }
2340 }
2341
2342 private void stopRtt(String callId) {
2343 Log.d(this, "stopRtt(%s)", callId);
2344 if (mConnectionById.containsKey(callId)) {
2345 findConnectionForAction(callId, "stopRtt").onStopRtt();
2346 } else if (mConferenceById.containsKey(callId)) {
2347 Log.w(this, "stopRtt called on a conference.");
2348 }
2349 }
2350
2351 private void handleRttUpgradeResponse(String callId, Connection.RttTextStream rttTextStream) {
2352 Log.d(this, "handleRttUpgradeResponse(%s, %s)", callId, rttTextStream == null);
2353 if (mConnectionById.containsKey(callId)) {
2354 findConnectionForAction(callId, "handleRttUpgradeResponse")
2355 .handleRttUpgradeResponse(rttTextStream);
2356 } else if (mConferenceById.containsKey(callId)) {
2357 Log.w(this, "handleRttUpgradeResponse called on a conference.");
2358 }
2359 }
2360
Sailesh Nepal2a46b902014-07-04 17:21:07 -07002361 private void onPostDialContinue(String callId, boolean proceed) {
Evan Charlton6dea4ac2014-06-03 14:07:13 -07002362 Log.d(this, "onPostDialContinue(%s)", callId);
Sailesh Nepal2a46b902014-07-04 17:21:07 -07002363 findConnectionForAction(callId, "stopDtmfTone").onPostDialContinue(proceed);
Evan Charlton6dea4ac2014-06-03 14:07:13 -07002364 }
2365
Sailesh Nepal2a46b902014-07-04 17:21:07 -07002366 private void onAdapterAttached() {
Ihab Awad9c3f1882014-06-30 21:17:13 -07002367 if (mAreAccountsInitialized) {
Santos Cordon52d8a152014-06-17 19:08:45 -07002368 // No need to query again if we already did it.
2369 return;
2370 }
2371
Tyler Gunn4c69fb32019-05-17 10:49:16 -07002372 String callingPackage = getOpPackageName();
2373
Sailesh Nepal2a46b902014-07-04 17:21:07 -07002374 mAdapter.queryRemoteConnectionServices(new RemoteServiceCallback.Stub() {
Santos Cordon52d8a152014-06-17 19:08:45 -07002375 @Override
2376 public void onResult(
2377 final List<ComponentName> componentNames,
Sailesh Nepal2a46b902014-07-04 17:21:07 -07002378 final List<IBinder> services) {
Brad Ebinger0c3541b2016-11-01 14:11:38 -07002379 mHandler.post(new android.telecom.Logging.Runnable("oAA.qRCS.oR", null /*lock*/) {
Ihab Awad6107bab2014-08-18 09:23:25 -07002380 @Override
Brad Ebinger0c3541b2016-11-01 14:11:38 -07002381 public void loggedRun() {
Sailesh Nepal2a46b902014-07-04 17:21:07 -07002382 for (int i = 0; i < componentNames.size() && i < services.size(); i++) {
Santos Cordon52d8a152014-06-17 19:08:45 -07002383 mRemoteConnectionManager.addConnectionService(
2384 componentNames.get(i),
Sailesh Nepal2a46b902014-07-04 17:21:07 -07002385 IConnectionService.Stub.asInterface(services.get(i)));
Santos Cordon52d8a152014-06-17 19:08:45 -07002386 }
Ihab Awad5d0410f2014-07-30 10:07:40 -07002387 onAccountsInitialized();
Sailesh Nepalc5b01572014-07-14 16:29:44 -07002388 Log.d(this, "remote connection services found: " + services);
Santos Cordon52d8a152014-06-17 19:08:45 -07002389 }
Brad Ebinger0c3541b2016-11-01 14:11:38 -07002390 }.prepare());
Santos Cordon52d8a152014-06-17 19:08:45 -07002391 }
2392
2393 @Override
2394 public void onError() {
Brad Ebinger0c3541b2016-11-01 14:11:38 -07002395 mHandler.post(new android.telecom.Logging.Runnable("oAA.qRCS.oE", null /*lock*/) {
Ihab Awad6107bab2014-08-18 09:23:25 -07002396 @Override
Brad Ebinger0c3541b2016-11-01 14:11:38 -07002397 public void loggedRun() {
Ihab Awad9c3f1882014-06-30 21:17:13 -07002398 mAreAccountsInitialized = true;
Santos Cordon52d8a152014-06-17 19:08:45 -07002399 }
Brad Ebinger0c3541b2016-11-01 14:11:38 -07002400 }.prepare());
Santos Cordon52d8a152014-06-17 19:08:45 -07002401 }
Tyler Gunn4c69fb32019-05-17 10:49:16 -07002402 }, callingPackage);
Santos Cordon52d8a152014-06-17 19:08:45 -07002403 }
2404
Ihab Awadf8b69882014-07-25 15:14:01 -07002405 /**
2406 * Ask some other {@code ConnectionService} to create a {@code RemoteConnection} given an
Santos Cordona663f862014-10-29 13:49:58 -07002407 * incoming request. This is used by {@code ConnectionService}s that are registered with
2408 * {@link PhoneAccount#CAPABILITY_CONNECTION_MANAGER} and want to be able to manage
2409 * SIM-based incoming calls.
Ihab Awadf8b69882014-07-25 15:14:01 -07002410 *
2411 * @param connectionManagerPhoneAccount See description at
2412 * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}.
2413 * @param request Details about the incoming call.
2414 * @return The {@code Connection} object to satisfy this call, or {@code null} to
2415 * not handle the call.
2416 */
2417 public final RemoteConnection createRemoteIncomingConnection(
2418 PhoneAccountHandle connectionManagerPhoneAccount,
2419 ConnectionRequest request) {
2420 return mRemoteConnectionManager.createRemoteConnection(
2421 connectionManagerPhoneAccount, request, true);
Santos Cordon52d8a152014-06-17 19:08:45 -07002422 }
2423
2424 /**
Ihab Awadf8b69882014-07-25 15:14:01 -07002425 * Ask some other {@code ConnectionService} to create a {@code RemoteConnection} given an
Santos Cordona663f862014-10-29 13:49:58 -07002426 * outgoing request. This is used by {@code ConnectionService}s that are registered with
2427 * {@link PhoneAccount#CAPABILITY_CONNECTION_MANAGER} and want to be able to use the
2428 * SIM-based {@code ConnectionService} to place its outgoing calls.
Ihab Awadf8b69882014-07-25 15:14:01 -07002429 *
2430 * @param connectionManagerPhoneAccount See description at
2431 * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}.
Cuihtlauac ALVARADO0b3b2a52016-09-13 14:49:41 +02002432 * @param request Details about the outgoing call.
Ihab Awadf8b69882014-07-25 15:14:01 -07002433 * @return The {@code Connection} object to satisfy this call, or {@code null} to
2434 * not handle the call.
2435 */
2436 public final RemoteConnection createRemoteOutgoingConnection(
2437 PhoneAccountHandle connectionManagerPhoneAccount,
2438 ConnectionRequest request) {
2439 return mRemoteConnectionManager.createRemoteConnection(
2440 connectionManagerPhoneAccount, request, false);
2441 }
2442
2443 /**
Santos Cordona663f862014-10-29 13:49:58 -07002444 * Indicates to the relevant {@code RemoteConnectionService} that the specified
2445 * {@link RemoteConnection}s should be merged into a conference call.
2446 * <p>
2447 * If the conference request is successful, the method {@link #onRemoteConferenceAdded} will
2448 * be invoked.
2449 *
2450 * @param remoteConnection1 The first of the remote connections to conference.
2451 * @param remoteConnection2 The second of the remote connections to conference.
Ihab Awadb8e85c72014-08-23 20:34:57 -07002452 */
2453 public final void conferenceRemoteConnections(
Santos Cordona663f862014-10-29 13:49:58 -07002454 RemoteConnection remoteConnection1,
2455 RemoteConnection remoteConnection2) {
2456 mRemoteConnectionManager.conferenceRemoteConnections(remoteConnection1, remoteConnection2);
Ihab Awadb8e85c72014-08-23 20:34:57 -07002457 }
2458
2459 /**
Santos Cordon823fd3c2014-08-07 18:35:18 -07002460 * Adds a new conference call. When a conference call is created either as a result of an
2461 * explicit request via {@link #onConference} or otherwise, the connection service should supply
2462 * an instance of {@link Conference} by invoking this method. A conference call provided by this
2463 * method will persist until {@link Conference#destroy} is invoked on the conference instance.
2464 *
2465 * @param conference The new conference object.
2466 */
2467 public final void addConference(Conference conference) {
Rekha Kumar07366812015-03-24 16:42:31 -07002468 Log.d(this, "addConference: conference=%s", conference);
2469
Santos Cordon823fd3c2014-08-07 18:35:18 -07002470 String id = addConferenceInternal(conference);
2471 if (id != null) {
2472 List<String> connectionIds = new ArrayList<>(2);
2473 for (Connection connection : conference.getConnections()) {
2474 if (mIdByConnection.containsKey(connection)) {
2475 connectionIds.add(mIdByConnection.get(connection));
2476 }
2477 }
Tyler Gunnf0500bd2015-09-01 10:59:48 -07002478 conference.setTelecomCallId(id);
Santos Cordon823fd3c2014-08-07 18:35:18 -07002479 ParcelableConference parcelableConference = new ParcelableConference(
Nancy Chenea38cca2014-09-05 16:38:49 -07002480 conference.getPhoneAccountHandle(),
Santos Cordon823fd3c2014-08-07 18:35:18 -07002481 conference.getState(),
Ihab Awad5c9c86e2014-11-12 13:41:16 -08002482 conference.getConnectionCapabilities(),
Tyler Gunn720c6642016-03-22 09:02:47 -07002483 conference.getConnectionProperties(),
Tyler Gunncd5d33c2015-01-12 09:02:01 -08002484 connectionIds,
Rekha Kumar07366812015-03-24 16:42:31 -07002485 conference.getVideoProvider() == null ?
2486 null : conference.getVideoProvider().getInterface(),
2487 conference.getVideoState(),
Andrew Lee3e3e2f22015-04-16 13:48:43 -07002488 conference.getConnectTimeMillis(),
Tyler Gunnc9503d62020-01-27 10:30:51 -08002489 conference.getConnectionStartElapsedRealtimeMillis(),
Santos Cordon6b7f9552015-05-27 17:21:45 -07002490 conference.getStatusHints(),
Tyler Gunnac60f952019-05-31 07:23:16 -07002491 conference.getExtras(),
2492 conference.getAddress(),
2493 conference.getAddressPresentation(),
2494 conference.getCallerDisplayName(),
2495 conference.getCallerDisplayNamePresentation());
Andrew Lee0f51da32015-04-16 13:11:55 -07002496
Santos Cordon823fd3c2014-08-07 18:35:18 -07002497 mAdapter.addConferenceCall(id, parcelableConference);
Rekha Kumar07366812015-03-24 16:42:31 -07002498 mAdapter.setVideoProvider(id, conference.getVideoProvider());
2499 mAdapter.setVideoState(id, conference.getVideoState());
Santos Cordon823fd3c2014-08-07 18:35:18 -07002500
2501 // Go through any child calls and set the parent.
2502 for (Connection connection : conference.getConnections()) {
2503 String connectionId = mIdByConnection.get(connection);
2504 if (connectionId != null) {
2505 mAdapter.setIsConferenced(connectionId, id);
2506 }
2507 }
Pengquan Meng70c9885332017-10-02 18:09:03 -07002508 onConferenceAdded(conference);
Santos Cordon823fd3c2014-08-07 18:35:18 -07002509 }
2510 }
2511
2512 /**
Tyler Gunn4a57b9b2014-10-30 14:27:48 -07002513 * Adds a connection created by the {@link ConnectionService} and informs telecom of the new
2514 * connection.
2515 *
2516 * @param phoneAccountHandle The phone account handle for the connection.
2517 * @param connection The connection to add.
2518 */
2519 public final void addExistingConnection(PhoneAccountHandle phoneAccountHandle,
2520 Connection connection) {
Tyler Gunn78da7812017-05-09 14:34:57 -07002521 addExistingConnection(phoneAccountHandle, connection, null /* conference */);
2522 }
2523
2524 /**
Pengquan Meng731c1a32017-11-21 18:01:13 -08002525 * Call to inform Telecom that your {@link ConnectionService} has released call resources (e.g
2526 * microphone, camera).
2527 *
Pengquan Menge3bf7e22018-02-22 17:30:04 -08002528 * <p>
2529 * The {@link ConnectionService} will be disconnected when it failed to call this method within
2530 * 5 seconds after {@link #onConnectionServiceFocusLost()} is called.
2531 *
Pengquan Meng731c1a32017-11-21 18:01:13 -08002532 * @see ConnectionService#onConnectionServiceFocusLost()
2533 */
2534 public final void connectionServiceFocusReleased() {
2535 mAdapter.onConnectionServiceFocusReleased();
2536 }
2537
2538 /**
Tyler Gunn78da7812017-05-09 14:34:57 -07002539 * Adds a connection created by the {@link ConnectionService} and informs telecom of the new
Tyler Gunn5567d742019-10-31 13:04:37 -07002540 * connection, as well as adding that connection to the specified conference.
2541 * <p>
2542 * Note: This API is intended ONLY for use by the Telephony stack to provide an easy way to add
2543 * IMS conference participants to be added to a conference in a single step; this helps ensure
2544 * UI updates happen atomically, rather than adding the connection and then adding it to
2545 * the conference in another step.
Tyler Gunn78da7812017-05-09 14:34:57 -07002546 *
2547 * @param phoneAccountHandle The phone account handle for the connection.
2548 * @param connection The connection to add.
2549 * @param conference The parent conference of the new connection.
2550 * @hide
2551 */
Tyler Gunn5567d742019-10-31 13:04:37 -07002552 @SystemApi
2553 public final void addExistingConnection(@NonNull PhoneAccountHandle phoneAccountHandle,
2554 @NonNull Connection connection, @NonNull Conference conference) {
Tyler Gunn4a57b9b2014-10-30 14:27:48 -07002555
Tyler Gunnf0500bd2015-09-01 10:59:48 -07002556 String id = addExistingConnectionInternal(phoneAccountHandle, connection);
Tyler Gunn4a57b9b2014-10-30 14:27:48 -07002557 if (id != null) {
2558 List<String> emptyList = new ArrayList<>(0);
Tyler Gunn78da7812017-05-09 14:34:57 -07002559 String conferenceId = null;
2560 if (conference != null) {
2561 conferenceId = mIdByConference.get(conference);
2562 }
Tyler Gunn4a57b9b2014-10-30 14:27:48 -07002563
2564 ParcelableConnection parcelableConnection = new ParcelableConnection(
2565 phoneAccountHandle,
2566 connection.getState(),
Ihab Awad5c9c86e2014-11-12 13:41:16 -08002567 connection.getConnectionCapabilities(),
Tyler Gunn720c6642016-03-22 09:02:47 -07002568 connection.getConnectionProperties(),
Christine Hallstrom2830ce92016-11-30 16:06:42 -08002569 connection.getSupportedAudioRoutes(),
Tyler Gunn4a57b9b2014-10-30 14:27:48 -07002570 connection.getAddress(),
2571 connection.getAddressPresentation(),
2572 connection.getCallerDisplayName(),
2573 connection.getCallerDisplayNamePresentation(),
2574 connection.getVideoProvider() == null ?
2575 null : connection.getVideoProvider().getInterface(),
2576 connection.getVideoState(),
2577 connection.isRingbackRequested(),
2578 connection.getAudioModeIsVoip(),
Roshan Piuse927ec02015-07-15 15:47:21 -07002579 connection.getConnectTimeMillis(),
Tyler Gunnc9503d62020-01-27 10:30:51 -08002580 connection.getConnectionStartElapsedRealtimeMillis(),
Tyler Gunn4a57b9b2014-10-30 14:27:48 -07002581 connection.getStatusHints(),
2582 connection.getDisconnectCause(),
Santos Cordon6b7f9552015-05-27 17:21:45 -07002583 emptyList,
Tyler Gunn78da7812017-05-09 14:34:57 -07002584 connection.getExtras(),
Tyler Gunn6986a632019-06-25 13:45:32 -07002585 conferenceId,
Tyler Gunnd57d76c2019-09-24 14:53:23 -07002586 connection.getCallDirection(),
2587 Connection.VERIFICATION_STATUS_NOT_VERIFIED);
Tyler Gunn4a57b9b2014-10-30 14:27:48 -07002588 mAdapter.addExistingConnection(id, parcelableConnection);
2589 }
2590 }
2591
2592 /**
Ihab Awadf8b69882014-07-25 15:14:01 -07002593 * Returns all the active {@code Connection}s for which this {@code ConnectionService}
2594 * has taken responsibility.
2595 *
2596 * @return A collection of {@code Connection}s created by this {@code ConnectionService}.
Santos Cordonb6939982014-06-04 20:20:58 -07002597 */
Sailesh Nepal091768c2014-06-30 15:15:23 -07002598 public final Collection<Connection> getAllConnections() {
Santos Cordonb6939982014-06-04 20:20:58 -07002599 return mConnectionById.values();
2600 }
2601
2602 /**
Santos Cordona6018b92016-02-16 14:23:12 -08002603 * Returns all the active {@code Conference}s for which this {@code ConnectionService}
2604 * has taken responsibility.
2605 *
2606 * @return A collection of {@code Conference}s created by this {@code ConnectionService}.
2607 */
2608 public final Collection<Conference> getAllConferences() {
2609 return mConferenceById.values();
2610 }
2611
2612 /**
Ihab Awadf8b69882014-07-25 15:14:01 -07002613 * Create a {@code Connection} given an incoming request. This is used to attach to existing
2614 * incoming calls.
Evan Charltonbf11f982014-07-20 22:06:28 -07002615 *
Ihab Awadf8b69882014-07-25 15:14:01 -07002616 * @param connectionManagerPhoneAccount See description at
2617 * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}.
2618 * @param request Details about the incoming call.
2619 * @return The {@code Connection} object to satisfy this call, or {@code null} to
2620 * not handle the call.
Ihab Awad542e0ea2014-05-16 10:22:16 -07002621 */
Ihab Awadf8b69882014-07-25 15:14:01 -07002622 public Connection onCreateIncomingConnection(
2623 PhoneAccountHandle connectionManagerPhoneAccount,
2624 ConnectionRequest request) {
2625 return null;
2626 }
Ravi Paluri80aa2142019-12-02 11:57:37 +05302627 /**
2628 * Create a {@code Connection} given an incoming request. This is used to attach to existing
2629 * incoming conference call.
2630 *
2631 * @param connectionManagerPhoneAccount See description at
2632 * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}.
2633 * @param request Details about the incoming call.
2634 * @return The {@code Connection} object to satisfy this call, or {@code null} to
2635 * not handle the call.
Tyler Gunn2c1bef92020-03-25 08:50:48 -07002636 * @hide
Ravi Paluri80aa2142019-12-02 11:57:37 +05302637 */
2638 public @Nullable Conference onCreateIncomingConference(
2639 @Nullable PhoneAccountHandle connectionManagerPhoneAccount,
2640 @Nullable ConnectionRequest request) {
2641 return null;
2642 }
Sailesh Nepalc5b01572014-07-14 16:29:44 -07002643
2644 /**
Tyler Gunn041a1fe2017-05-12 10:04:49 -07002645 * Called after the {@link Connection} returned by
2646 * {@link #onCreateIncomingConnection(PhoneAccountHandle, ConnectionRequest)}
2647 * or {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)} has been
2648 * added to the {@link ConnectionService} and sent to Telecom.
2649 *
2650 * @param connection the {@link Connection}.
2651 * @hide
2652 */
2653 public void onCreateConnectionComplete(Connection connection) {
2654 }
2655
2656 /**
Ravi Paluri80aa2142019-12-02 11:57:37 +05302657 * Called after the {@link Conference} returned by
2658 * {@link #onCreateIncomingConference(PhoneAccountHandle, ConnectionRequest)}
2659 * or {@link #onCreateOutgoingConference(PhoneAccountHandle, ConnectionRequest)} has been
2660 * added to the {@link ConnectionService} and sent to Telecom.
2661 *
2662 * @param conference the {@link Conference}.
2663 * @hide
2664 */
2665 public void onCreateConferenceComplete(Conference conference) {
2666 }
2667
2668
2669 /**
Tyler Gunnf5035432017-01-09 09:43:12 -08002670 * Called by Telecom to inform the {@link ConnectionService} that its request to create a new
2671 * incoming {@link Connection} was denied.
2672 * <p>
2673 * Used when a self-managed {@link ConnectionService} attempts to create a new incoming
2674 * {@link Connection}, but Telecom has determined that the call cannot be allowed at this time.
2675 * The {@link ConnectionService} is responsible for silently rejecting the new incoming
2676 * {@link Connection}.
2677 * <p>
2678 * See {@link TelecomManager#isIncomingCallPermitted(PhoneAccountHandle)} for more information.
2679 *
Tyler Gunn159f35c2017-03-02 09:28:37 -08002680 * @param connectionManagerPhoneAccount See description at
2681 * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}.
Tyler Gunnf5035432017-01-09 09:43:12 -08002682 * @param request The incoming connection request.
2683 */
Tyler Gunn159f35c2017-03-02 09:28:37 -08002684 public void onCreateIncomingConnectionFailed(PhoneAccountHandle connectionManagerPhoneAccount,
2685 ConnectionRequest request) {
Tyler Gunnf5035432017-01-09 09:43:12 -08002686 }
2687
2688 /**
2689 * Called by Telecom to inform the {@link ConnectionService} that its request to create a new
2690 * outgoing {@link Connection} was denied.
2691 * <p>
2692 * Used when a self-managed {@link ConnectionService} attempts to create a new outgoing
2693 * {@link Connection}, but Telecom has determined that the call cannot be placed at this time.
2694 * The {@link ConnectionService} is responisible for informing the user that the
2695 * {@link Connection} cannot be made at this time.
2696 * <p>
2697 * See {@link TelecomManager#isOutgoingCallPermitted(PhoneAccountHandle)} for more information.
2698 *
Tyler Gunn159f35c2017-03-02 09:28:37 -08002699 * @param connectionManagerPhoneAccount See description at
2700 * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}.
Tyler Gunnf5035432017-01-09 09:43:12 -08002701 * @param request The outgoing connection request.
2702 */
Tyler Gunn159f35c2017-03-02 09:28:37 -08002703 public void onCreateOutgoingConnectionFailed(PhoneAccountHandle connectionManagerPhoneAccount,
2704 ConnectionRequest request) {
Tyler Gunnf5035432017-01-09 09:43:12 -08002705 }
2706
2707 /**
Ravi Paluri80aa2142019-12-02 11:57:37 +05302708 * Called by Telecom to inform the {@link ConnectionService} that its request to create a new
2709 * incoming {@link Conference} was denied.
2710 * <p>
2711 * Used when a self-managed {@link ConnectionService} attempts to create a new incoming
2712 * {@link Conference}, but Telecom has determined that the call cannot be allowed at this time.
2713 * The {@link ConnectionService} is responsible for silently rejecting the new incoming
2714 * {@link Conference}.
2715 * <p>
2716 * See {@link TelecomManager#isIncomingCallPermitted(PhoneAccountHandle)} for more information.
2717 *
2718 * @param connectionManagerPhoneAccount See description at
2719 * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}.
2720 * @param request The incoming connection request.
Tyler Gunn2c1bef92020-03-25 08:50:48 -07002721 * @hide
Ravi Paluri80aa2142019-12-02 11:57:37 +05302722 */
2723 public void onCreateIncomingConferenceFailed(
2724 @Nullable PhoneAccountHandle connectionManagerPhoneAccount,
2725 @Nullable ConnectionRequest request) {
2726 }
2727
2728 /**
2729 * Called by Telecom to inform the {@link ConnectionService} that its request to create a new
2730 * outgoing {@link Conference} was denied.
2731 * <p>
2732 * Used when a self-managed {@link ConnectionService} attempts to create a new outgoing
2733 * {@link Conference}, but Telecom has determined that the call cannot be placed at this time.
2734 * The {@link ConnectionService} is responisible for informing the user that the
2735 * {@link Conference} cannot be made at this time.
2736 * <p>
2737 * See {@link TelecomManager#isOutgoingCallPermitted(PhoneAccountHandle)} for more information.
2738 *
2739 * @param connectionManagerPhoneAccount See description at
2740 * {@link #onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}.
2741 * @param request The outgoing connection request.
Tyler Gunn2c1bef92020-03-25 08:50:48 -07002742 * @hide
Ravi Paluri80aa2142019-12-02 11:57:37 +05302743 */
2744 public void onCreateOutgoingConferenceFailed(
2745 @Nullable PhoneAccountHandle connectionManagerPhoneAccount,
2746 @Nullable ConnectionRequest request) {
2747 }
2748
2749
2750 /**
Shriram Ganesh6bf35ac2014-12-11 17:53:38 -08002751 * Trigger recalculate functinality for conference calls. This is used when a Telephony
2752 * Connection is part of a conference controller but is not yet added to Connection
2753 * Service and hence cannot be added to the conference call.
2754 *
2755 * @hide
2756 */
2757 public void triggerConferenceRecalculate() {
2758 }
2759
2760 /**
Ihab Awadf8b69882014-07-25 15:14:01 -07002761 * Create a {@code Connection} given an outgoing request. This is used to initiate new
2762 * outgoing calls.
Sailesh Nepalc5b01572014-07-14 16:29:44 -07002763 *
Ihab Awadf8b69882014-07-25 15:14:01 -07002764 * @param connectionManagerPhoneAccount The connection manager account to use for managing
2765 * this call.
2766 * <p>
2767 * If this parameter is not {@code null}, it means that this {@code ConnectionService}
2768 * has registered one or more {@code PhoneAccount}s having
2769 * {@link PhoneAccount#CAPABILITY_CONNECTION_MANAGER}. This parameter will contain
2770 * one of these {@code PhoneAccount}s, while the {@code request} will contain another
2771 * (usually but not always distinct) {@code PhoneAccount} to be used for actually
2772 * making the connection.
2773 * <p>
2774 * If this parameter is {@code null}, it means that this {@code ConnectionService} is
2775 * being asked to make a direct connection. The
2776 * {@link ConnectionRequest#getAccountHandle()} of parameter {@code request} will be
2777 * a {@code PhoneAccount} registered by this {@code ConnectionService} to use for
2778 * making the connection.
2779 * @param request Details about the outgoing call.
2780 * @return The {@code Connection} object to satisfy this call, or the result of an invocation
Andrew Lee7f3d41f2014-09-11 17:33:16 -07002781 * of {@link Connection#createFailedConnection(DisconnectCause)} to not handle the call.
Sailesh Nepalc5b01572014-07-14 16:29:44 -07002782 */
Ihab Awadf8b69882014-07-25 15:14:01 -07002783 public Connection onCreateOutgoingConnection(
2784 PhoneAccountHandle connectionManagerPhoneAccount,
2785 ConnectionRequest request) {
2786 return null;
2787 }
Ihab Awad542e0ea2014-05-16 10:22:16 -07002788
2789 /**
Ravi Paluri80aa2142019-12-02 11:57:37 +05302790 * Create a {@code Conference} given an outgoing request. This is used to initiate new
2791 * outgoing conference call.
2792 *
2793 * @param connectionManagerPhoneAccount The connection manager account to use for managing
2794 * this call.
2795 * <p>
2796 * If this parameter is not {@code null}, it means that this {@code ConnectionService}
2797 * has registered one or more {@code PhoneAccount}s having
2798 * {@link PhoneAccount#CAPABILITY_CONNECTION_MANAGER}. This parameter will contain
2799 * one of these {@code PhoneAccount}s, while the {@code request} will contain another
2800 * (usually but not always distinct) {@code PhoneAccount} to be used for actually
2801 * making the connection.
2802 * <p>
2803 * If this parameter is {@code null}, it means that this {@code ConnectionService} is
2804 * being asked to make a direct connection. The
2805 * {@link ConnectionRequest#getAccountHandle()} of parameter {@code request} will be
2806 * a {@code PhoneAccount} registered by this {@code ConnectionService} to use for
2807 * making the connection.
2808 * @param request Details about the outgoing call.
2809 * @return The {@code Conference} object to satisfy this call, or the result of an invocation
2810 * of {@link Connection#createFailedConnection(DisconnectCause)} to not handle the call.
Tyler Gunn2c1bef92020-03-25 08:50:48 -07002811 * @hide
Ravi Paluri80aa2142019-12-02 11:57:37 +05302812 */
2813 public @Nullable Conference onCreateOutgoingConference(
2814 @Nullable PhoneAccountHandle connectionManagerPhoneAccount,
2815 @Nullable ConnectionRequest request) {
2816 return null;
2817 }
2818
2819
2820 /**
Tyler Gunn9d127732018-03-02 15:45:51 -08002821 * Called by Telecom to request that a {@link ConnectionService} creates an instance of an
2822 * outgoing handover {@link Connection}.
2823 * <p>
2824 * A call handover is the process where an ongoing call is transferred from one app (i.e.
2825 * {@link ConnectionService} to another app. The user could, for example, choose to continue a
2826 * mobile network call in a video calling app. The mobile network call via the Telephony stack
2827 * is referred to as the source of the handover, and the video calling app is referred to as the
2828 * destination.
2829 * <p>
2830 * When considering a handover scenario the <em>initiating</em> device is where a user initiated
2831 * the handover process (e.g. by calling {@link android.telecom.Call#handoverTo(
2832 * PhoneAccountHandle, int, Bundle)}, and the other device is considered the <em>receiving</em>
2833 * device.
2834 * <p>
2835 * This method is called on the destination {@link ConnectionService} on <em>initiating</em>
2836 * device when the user initiates a handover request from one app to another. The user request
2837 * originates in the {@link InCallService} via
2838 * {@link android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle)}.
2839 * <p>
2840 * For a full discussion of the handover process and the APIs involved, see
2841 * {@link android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle)}.
2842 * <p>
2843 * Implementations of this method should return an instance of {@link Connection} which
2844 * represents the handover. If your app does not wish to accept a handover to it at this time,
2845 * you can return {@code null}. The code below shows an example of how this is done.
2846 * <pre>
2847 * {@code
2848 * public Connection onCreateIncomingHandoverConnection(PhoneAccountHandle
2849 * fromPhoneAccountHandle, ConnectionRequest request) {
2850 * if (!isHandoverAvailable()) {
2851 * return null;
2852 * }
2853 * MyConnection connection = new MyConnection();
2854 * connection.setAddress(request.getAddress(), TelecomManager.PRESENTATION_ALLOWED);
2855 * connection.setVideoState(request.getVideoState());
2856 * return connection;
2857 * }
2858 * }
2859 * </pre>
2860 *
Sanket Padawea8eddd42017-11-03 11:07:35 -07002861 * @param fromPhoneAccountHandle {@link PhoneAccountHandle} associated with the
2862 * ConnectionService which needs to handover the call.
Tyler Gunn9d127732018-03-02 15:45:51 -08002863 * @param request Details about the call to handover.
2864 * @return {@link Connection} instance corresponding to the handover call.
Sanket Padawea8eddd42017-11-03 11:07:35 -07002865 */
2866 public Connection onCreateOutgoingHandoverConnection(PhoneAccountHandle fromPhoneAccountHandle,
2867 ConnectionRequest request) {
2868 return null;
2869 }
2870
2871 /**
Tyler Gunn9d127732018-03-02 15:45:51 -08002872 * Called by Telecom to request that a {@link ConnectionService} creates an instance of an
2873 * incoming handover {@link Connection}.
2874 * <p>
2875 * A call handover is the process where an ongoing call is transferred from one app (i.e.
2876 * {@link ConnectionService} to another app. The user could, for example, choose to continue a
2877 * mobile network call in a video calling app. The mobile network call via the Telephony stack
2878 * is referred to as the source of the handover, and the video calling app is referred to as the
2879 * destination.
2880 * <p>
2881 * When considering a handover scenario the <em>initiating</em> device is where a user initiated
2882 * the handover process (e.g. by calling {@link android.telecom.Call#handoverTo(
2883 * PhoneAccountHandle, int, Bundle)}, and the other device is considered the <em>receiving</em>
2884 * device.
2885 * <p>
2886 * This method is called on the destination app on the <em>receiving</em> device when the
2887 * destination app calls {@link TelecomManager#acceptHandover(Uri, int, PhoneAccountHandle)} to
2888 * accept an incoming handover from the <em>initiating</em> device.
2889 * <p>
2890 * For a full discussion of the handover process and the APIs involved, see
2891 * {@link android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle)}.
2892 * <p>
2893 * Implementations of this method should return an instance of {@link Connection} which
2894 * represents the handover. The code below shows an example of how this is done.
2895 * <pre>
2896 * {@code
2897 * public Connection onCreateIncomingHandoverConnection(PhoneAccountHandle
2898 * fromPhoneAccountHandle, ConnectionRequest request) {
2899 * // Given that your app requested to accept the handover, you should not return null here.
2900 * MyConnection connection = new MyConnection();
2901 * connection.setAddress(request.getAddress(), TelecomManager.PRESENTATION_ALLOWED);
2902 * connection.setVideoState(request.getVideoState());
2903 * return connection;
2904 * }
2905 * }
2906 * </pre>
2907 *
Sanket Padawea8eddd42017-11-03 11:07:35 -07002908 * @param fromPhoneAccountHandle {@link PhoneAccountHandle} associated with the
2909 * ConnectionService which needs to handover the call.
2910 * @param request Details about the call which needs to be handover.
Tyler Gunn9d127732018-03-02 15:45:51 -08002911 * @return {@link Connection} instance corresponding to the handover call.
Sanket Padawea8eddd42017-11-03 11:07:35 -07002912 */
2913 public Connection onCreateIncomingHandoverConnection(PhoneAccountHandle fromPhoneAccountHandle,
2914 ConnectionRequest request) {
2915 return null;
2916 }
2917
2918 /**
2919 * Called by Telecom in response to a {@code TelecomManager#acceptHandover()}
2920 * invocation which failed.
Tyler Gunn9d127732018-03-02 15:45:51 -08002921 * <p>
2922 * For a full discussion of the handover process and the APIs involved, see
2923 * {@link android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle)}
2924 *
2925 * @param request Details about the call which failed to handover.
2926 * @param error Reason for handover failure. Will be one of the
Sanket Padawea8eddd42017-11-03 11:07:35 -07002927 */
Tyler Gunn9d127732018-03-02 15:45:51 -08002928 public void onHandoverFailed(ConnectionRequest request,
2929 @Call.Callback.HandoverFailureErrors int error) {
Sanket Padawea8eddd42017-11-03 11:07:35 -07002930 return;
2931 }
2932
2933 /**
Yorke Leec3cf9822014-10-02 09:38:39 -07002934 * Create a {@code Connection} for a new unknown call. An unknown call is a call originating
2935 * from the ConnectionService that was neither a user-initiated outgoing call, nor an incoming
2936 * call created using
2937 * {@code TelecomManager#addNewIncomingCall(PhoneAccountHandle, android.os.Bundle)}.
2938 *
Yorke Lee770ed6e2014-10-06 18:58:52 -07002939 * @hide
Yorke Leec3cf9822014-10-02 09:38:39 -07002940 */
2941 public Connection onCreateUnknownConnection(PhoneAccountHandle connectionManagerPhoneAccount,
2942 ConnectionRequest request) {
Brad Ebingerb32d4f82016-10-24 16:40:49 -07002943 return null;
Yorke Leec3cf9822014-10-02 09:38:39 -07002944 }
2945
2946 /**
Santos Cordon823fd3c2014-08-07 18:35:18 -07002947 * Conference two specified connections. Invoked when the user has made a request to merge the
2948 * specified connections into a conference call. In response, the connection service should
2949 * create an instance of {@link Conference} and pass it into {@link #addConference}.
Santos Cordonb6939982014-06-04 20:20:58 -07002950 *
Santos Cordon823fd3c2014-08-07 18:35:18 -07002951 * @param connection1 A connection to merge into a conference call.
2952 * @param connection2 A connection to merge into a conference call.
Santos Cordonb6939982014-06-04 20:20:58 -07002953 */
Santos Cordon823fd3c2014-08-07 18:35:18 -07002954 public void onConference(Connection connection1, Connection connection2) {}
Santos Cordonb6939982014-06-04 20:20:58 -07002955
Santos Cordona663f862014-10-29 13:49:58 -07002956 /**
Pengquan Meng70c9885332017-10-02 18:09:03 -07002957 * Called when a connection is added.
2958 * @hide
2959 */
2960 public void onConnectionAdded(Connection connection) {}
2961
2962 /**
2963 * Called when a connection is removed.
2964 * @hide
2965 */
2966 public void onConnectionRemoved(Connection connection) {}
2967
2968 /**
2969 * Called when a conference is added.
2970 * @hide
2971 */
2972 public void onConferenceAdded(Conference conference) {}
2973
2974 /**
2975 * Called when a conference is removed.
2976 * @hide
2977 */
2978 public void onConferenceRemoved(Conference conference) {}
2979
2980 /**
Santos Cordona663f862014-10-29 13:49:58 -07002981 * Indicates that a remote conference has been created for existing {@link RemoteConnection}s.
2982 * When this method is invoked, this {@link ConnectionService} should create its own
2983 * representation of the conference call and send it to telecom using {@link #addConference}.
2984 * <p>
2985 * This is only relevant to {@link ConnectionService}s which are registered with
2986 * {@link PhoneAccount#CAPABILITY_CONNECTION_MANAGER}.
2987 *
2988 * @param conference The remote conference call.
2989 */
Ihab Awadb8e85c72014-08-23 20:34:57 -07002990 public void onRemoteConferenceAdded(RemoteConference conference) {}
2991
Santos Cordon823fd3c2014-08-07 18:35:18 -07002992 /**
Tyler Gunn4a57b9b2014-10-30 14:27:48 -07002993 * Called when an existing connection is added remotely.
2994 * @param connection The existing connection which was added.
2995 */
2996 public void onRemoteExistingConnectionAdded(RemoteConnection connection) {}
2997
2998 /**
Pengquan Meng731c1a32017-11-21 18:01:13 -08002999 * Called when the {@link ConnectionService} has lost the call focus.
3000 * The {@link ConnectionService} should release the call resources and invokes
3001 * {@link ConnectionService#connectionServiceFocusReleased()} to inform telecom that it has
3002 * released the call resources.
3003 */
3004 public void onConnectionServiceFocusLost() {}
3005
3006 /**
3007 * Called when the {@link ConnectionService} has gained the call focus. The
3008 * {@link ConnectionService} can acquire the call resources at this time.
3009 */
3010 public void onConnectionServiceFocusGained() {}
3011
3012 /**
Santos Cordon823fd3c2014-08-07 18:35:18 -07003013 * @hide
3014 */
3015 public boolean containsConference(Conference conference) {
3016 return mIdByConference.containsKey(conference);
3017 }
3018
Ihab Awadb8e85c72014-08-23 20:34:57 -07003019 /** {@hide} */
3020 void addRemoteConference(RemoteConference remoteConference) {
3021 onRemoteConferenceAdded(remoteConference);
3022 }
3023
Tyler Gunn4a57b9b2014-10-30 14:27:48 -07003024 /** {@hide} */
3025 void addRemoteExistingConnection(RemoteConnection remoteConnection) {
3026 onRemoteExistingConnectionAdded(remoteConnection);
3027 }
3028
Ihab Awad5d0410f2014-07-30 10:07:40 -07003029 private void onAccountsInitialized() {
3030 mAreAccountsInitialized = true;
3031 for (Runnable r : mPreInitializationConnectionRequests) {
3032 r.run();
3033 }
3034 mPreInitializationConnectionRequests.clear();
3035 }
3036
Tyler Gunn4a57b9b2014-10-30 14:27:48 -07003037 /**
Tyler Gunnf0500bd2015-09-01 10:59:48 -07003038 * Adds an existing connection to the list of connections, identified by a new call ID unique
3039 * to this connection service.
Tyler Gunn4a57b9b2014-10-30 14:27:48 -07003040 *
3041 * @param connection The connection.
Tyler Gunnf0500bd2015-09-01 10:59:48 -07003042 * @return The ID of the connection (e.g. the call-id).
Tyler Gunn4a57b9b2014-10-30 14:27:48 -07003043 */
Tyler Gunnf0500bd2015-09-01 10:59:48 -07003044 private String addExistingConnectionInternal(PhoneAccountHandle handle, Connection connection) {
3045 String id;
Tyler Gunncd6ccfd2016-10-17 15:48:19 -07003046
3047 if (connection.getExtras() != null && connection.getExtras()
3048 .containsKey(Connection.EXTRA_ORIGINAL_CONNECTION_ID)) {
3049 id = connection.getExtras().getString(Connection.EXTRA_ORIGINAL_CONNECTION_ID);
3050 Log.d(this, "addExistingConnectionInternal - conn %s reusing original id %s",
3051 connection.getTelecomCallId(), id);
3052 } else if (handle == null) {
Tyler Gunnf0500bd2015-09-01 10:59:48 -07003053 // If no phone account handle was provided, we cannot be sure the call ID is unique,
3054 // so just use a random UUID.
3055 id = UUID.randomUUID().toString();
3056 } else {
3057 // Phone account handle was provided, so use the ConnectionService class name as a
3058 // prefix for a unique incremental call ID.
3059 id = handle.getComponentName().getClassName() + "@" + getNextCallId();
3060 }
Pengquan Meng70c9885332017-10-02 18:09:03 -07003061 addConnection(handle, id, connection);
Tyler Gunn4a57b9b2014-10-30 14:27:48 -07003062 return id;
3063 }
3064
Pengquan Meng70c9885332017-10-02 18:09:03 -07003065 private void addConnection(PhoneAccountHandle handle, String callId, Connection connection) {
Tyler Gunnf0500bd2015-09-01 10:59:48 -07003066 connection.setTelecomCallId(callId);
Ihab Awad542e0ea2014-05-16 10:22:16 -07003067 mConnectionById.put(callId, connection);
3068 mIdByConnection.put(connection, callId);
3069 connection.addConnectionListener(mConnectionListener);
Santos Cordon823fd3c2014-08-07 18:35:18 -07003070 connection.setConnectionService(this);
Pengquan Meng70c9885332017-10-02 18:09:03 -07003071 connection.setPhoneAccountHandle(handle);
3072 onConnectionAdded(connection);
Ihab Awad542e0ea2014-05-16 10:22:16 -07003073 }
3074
Anthony Lee30e65842014-11-06 16:30:53 -08003075 /** {@hide} */
3076 protected void removeConnection(Connection connection) {
Santos Cordon823fd3c2014-08-07 18:35:18 -07003077 connection.unsetConnectionService(this);
Ihab Awad542e0ea2014-05-16 10:22:16 -07003078 connection.removeConnectionListener(mConnectionListener);
Chenjie Luoe370b532016-05-12 16:59:43 -07003079 String id = mIdByConnection.get(connection);
3080 if (id != null) {
3081 mConnectionById.remove(id);
3082 mIdByConnection.remove(connection);
3083 mAdapter.removeCall(id);
Pengquan Meng70c9885332017-10-02 18:09:03 -07003084 onConnectionRemoved(connection);
Chenjie Luoe370b532016-05-12 16:59:43 -07003085 }
Ihab Awad542e0ea2014-05-16 10:22:16 -07003086 }
3087
Santos Cordon823fd3c2014-08-07 18:35:18 -07003088 private String addConferenceInternal(Conference conference) {
Tyler Gunncd6ccfd2016-10-17 15:48:19 -07003089 String originalId = null;
3090 if (conference.getExtras() != null && conference.getExtras()
3091 .containsKey(Connection.EXTRA_ORIGINAL_CONNECTION_ID)) {
3092 originalId = conference.getExtras().getString(Connection.EXTRA_ORIGINAL_CONNECTION_ID);
3093 Log.d(this, "addConferenceInternal: conf %s reusing original id %s",
3094 conference.getTelecomCallId(),
3095 originalId);
3096 }
Santos Cordon823fd3c2014-08-07 18:35:18 -07003097 if (mIdByConference.containsKey(conference)) {
3098 Log.w(this, "Re-adding an existing conference: %s.", conference);
3099 } else if (conference != null) {
Tyler Gunnf0500bd2015-09-01 10:59:48 -07003100 // Conferences do not (yet) have a PhoneAccountHandle associated with them, so we
3101 // cannot determine a ConnectionService class name to associate with the ID, so use
3102 // a unique UUID (for now).
Tyler Gunncd6ccfd2016-10-17 15:48:19 -07003103 String id = originalId == null ? UUID.randomUUID().toString() : originalId;
Santos Cordon823fd3c2014-08-07 18:35:18 -07003104 mConferenceById.put(id, conference);
3105 mIdByConference.put(conference, id);
3106 conference.addListener(mConferenceListener);
3107 return id;
3108 }
3109
3110 return null;
3111 }
3112
3113 private void removeConference(Conference conference) {
3114 if (mIdByConference.containsKey(conference)) {
3115 conference.removeListener(mConferenceListener);
3116
3117 String id = mIdByConference.get(conference);
3118 mConferenceById.remove(id);
3119 mIdByConference.remove(conference);
3120 mAdapter.removeCall(id);
Pengquan Meng70c9885332017-10-02 18:09:03 -07003121
3122 onConferenceRemoved(conference);
Santos Cordon823fd3c2014-08-07 18:35:18 -07003123 }
3124 }
3125
Ihab Awad542e0ea2014-05-16 10:22:16 -07003126 private Connection findConnectionForAction(String callId, String action) {
Tyler Gunn0a88f2e2017-06-16 20:20:34 -07003127 if (callId != null && mConnectionById.containsKey(callId)) {
Ihab Awad542e0ea2014-05-16 10:22:16 -07003128 return mConnectionById.get(callId);
3129 }
Ihab Awad60ac30b2014-05-20 22:32:12 -07003130 Log.w(this, "%s - Cannot find Connection %s", action, callId);
Sailesh Nepalcf7020b2014-08-20 10:07:19 -07003131 return getNullConnection();
3132 }
3133
3134 static synchronized Connection getNullConnection() {
3135 if (sNullConnection == null) {
3136 sNullConnection = new Connection() {};
3137 }
3138 return sNullConnection;
Santos Cordon7c7bc7f2014-07-28 18:15:48 -07003139 }
Santos Cordon0159ac02014-08-21 14:28:11 -07003140
3141 private Conference findConferenceForAction(String conferenceId, String action) {
3142 if (mConferenceById.containsKey(conferenceId)) {
3143 return mConferenceById.get(conferenceId);
3144 }
3145 Log.w(this, "%s - Cannot find conference %s", action, conferenceId);
3146 return getNullConference();
3147 }
3148
Ihab Awadb8e85c72014-08-23 20:34:57 -07003149 private List<String> createConnectionIdList(List<Connection> connections) {
3150 List<String> ids = new ArrayList<>();
3151 for (Connection c : connections) {
3152 if (mIdByConnection.containsKey(c)) {
3153 ids.add(mIdByConnection.get(c));
3154 }
3155 }
3156 Collections.sort(ids);
3157 return ids;
3158 }
3159
Tyler Gunn6d76ca02014-11-17 15:49:51 -08003160 /**
3161 * Builds a list of {@link Connection} and {@link Conference} IDs based on the list of
Tyler Gunndf2cbc82015-04-20 09:13:01 -07003162 * {@link Conferenceable}s passed in.
Tyler Gunn6d76ca02014-11-17 15:49:51 -08003163 *
Tyler Gunndf2cbc82015-04-20 09:13:01 -07003164 * @param conferenceables The {@link Conferenceable} connections and conferences.
Tyler Gunn6d76ca02014-11-17 15:49:51 -08003165 * @return List of string conference and call Ids.
3166 */
Tyler Gunndf2cbc82015-04-20 09:13:01 -07003167 private List<String> createIdList(List<Conferenceable> conferenceables) {
Tyler Gunn6d76ca02014-11-17 15:49:51 -08003168 List<String> ids = new ArrayList<>();
Tyler Gunndf2cbc82015-04-20 09:13:01 -07003169 for (Conferenceable c : conferenceables) {
Tyler Gunn6d76ca02014-11-17 15:49:51 -08003170 // Only allow Connection and Conference conferenceables.
3171 if (c instanceof Connection) {
3172 Connection connection = (Connection) c;
3173 if (mIdByConnection.containsKey(connection)) {
3174 ids.add(mIdByConnection.get(connection));
3175 }
3176 } else if (c instanceof Conference) {
3177 Conference conference = (Conference) c;
3178 if (mIdByConference.containsKey(conference)) {
3179 ids.add(mIdByConference.get(conference));
3180 }
3181 }
3182 }
3183 Collections.sort(ids);
3184 return ids;
3185 }
3186
Santos Cordon0159ac02014-08-21 14:28:11 -07003187 private Conference getNullConference() {
3188 if (sNullConference == null) {
3189 sNullConference = new Conference(null) {};
3190 }
3191 return sNullConference;
3192 }
Santos Cordon29f2f2e2014-09-11 19:50:24 -07003193
3194 private void endAllConnections() {
3195 // Unbound from telecomm. We should end all connections and conferences.
3196 for (Connection connection : mIdByConnection.keySet()) {
3197 // only operate on top-level calls. Conference calls will be removed on their own.
3198 if (connection.getConference() == null) {
3199 connection.onDisconnect();
3200 }
3201 }
3202 for (Conference conference : mIdByConference.keySet()) {
3203 conference.onDisconnect();
3204 }
3205 }
Tyler Gunnf0500bd2015-09-01 10:59:48 -07003206
3207 /**
3208 * Retrieves the next call ID as maintainted by the connection service.
3209 *
3210 * @return The call ID.
3211 */
3212 private int getNextCallId() {
Brad Ebingerb32d4f82016-10-24 16:40:49 -07003213 synchronized (mIdSyncRoot) {
Tyler Gunnf0500bd2015-09-01 10:59:48 -07003214 return ++mId;
3215 }
3216 }
Brad Ebinger99f17ce2019-09-11 18:06:51 -07003217
3218 /**
3219 * Returns this handler, ONLY FOR TESTING.
3220 * @hide
3221 */
3222 @VisibleForTesting
3223 public Handler getHandler() {
3224 return mHandler;
3225 }
Santos Cordon980acb92014-05-31 10:31:19 -07003226}