blob: 1238e7b69a872ae85a7d404be6493b6b33807f9b [file] [log] [blame]
Ihab Awade63fadb2014-07-09 21:52:04 -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 Awade63fadb2014-07-09 21:52:04 -070018
Hall Liu95d55872017-01-25 17:12:49 -080019import android.annotation.IntDef;
Ravi Paluri404babb2020-01-23 19:02:44 +053020import android.annotation.NonNull;
Hall Liu95d55872017-01-25 17:12:49 -080021import android.annotation.Nullable;
Andrew Leeda80c872015-04-15 14:09:50 -070022import android.annotation.SystemApi;
Hall Liu6dfa2492019-10-01 17:20:39 -070023import android.annotation.TestApi;
Artur Satayev53ada2a2019-12-10 17:47:56 +000024import android.compat.annotation.UnsupportedAppUsage;
Tyler Gunn460b7d42020-05-15 10:19:32 -070025import android.content.pm.ServiceInfo;
Ihab Awade63fadb2014-07-09 21:52:04 -070026import android.net.Uri;
Tyler Gunn6e3ecc42018-11-12 11:30:56 -080027import android.os.Build;
Nancy Chen10798dc2014-08-08 14:00:25 -070028import android.os.Bundle;
Andrew Lee011728f2015-04-23 15:47:06 -070029import android.os.Handler;
Hall Liu95d55872017-01-25 17:12:49 -080030import android.os.ParcelFileDescriptor;
Ihab Awade63fadb2014-07-09 21:52:04 -070031
Tyler Gunnd1fdf3a2019-11-05 15:47:58 -080032import com.android.internal.telecom.IVideoProvider;
33
Hall Liu95d55872017-01-25 17:12:49 -080034import java.io.IOException;
35import java.io.InputStreamReader;
36import java.io.OutputStreamWriter;
Hall Liu95d55872017-01-25 17:12:49 -080037import java.lang.annotation.Retention;
38import java.lang.annotation.RetentionPolicy;
39import java.nio.charset.StandardCharsets;
Ihab Awade63fadb2014-07-09 21:52:04 -070040import java.util.ArrayList;
Tyler Gunn071be6f2016-05-10 14:52:33 -070041import java.util.Arrays;
Ihab Awade63fadb2014-07-09 21:52:04 -070042import java.util.Collections;
43import java.util.List;
Santos Cordon7c7bc7f2014-07-28 18:15:48 -070044import java.util.Map;
Ihab Awade63fadb2014-07-09 21:52:04 -070045import java.util.Objects;
Jay Shrauner229e3822014-08-15 09:23:07 -070046import java.util.concurrent.CopyOnWriteArrayList;
Ihab Awade63fadb2014-07-09 21:52:04 -070047
48/**
49 * Represents an ongoing phone call that the in-call app should present to the user.
50 */
51public final class Call {
52 /**
53 * The state of a {@code Call} when newly created.
54 */
55 public static final int STATE_NEW = 0;
56
57 /**
58 * The state of an outgoing {@code Call} when dialing the remote number, but not yet connected.
59 */
60 public static final int STATE_DIALING = 1;
61
62 /**
63 * The state of an incoming {@code Call} when ringing locally, but not yet connected.
64 */
65 public static final int STATE_RINGING = 2;
66
67 /**
68 * The state of a {@code Call} when in a holding state.
69 */
70 public static final int STATE_HOLDING = 3;
71
72 /**
73 * The state of a {@code Call} when actively supporting conversation.
74 */
75 public static final int STATE_ACTIVE = 4;
76
77 /**
78 * The state of a {@code Call} when no further voice or other communication is being
79 * transmitted, the remote side has been or will inevitably be informed that the {@code Call}
80 * is no longer active, and the local data transport has or inevitably will release resources
81 * associated with this {@code Call}.
82 */
83 public static final int STATE_DISCONNECTED = 7;
84
Nancy Chen5da0fd52014-07-08 14:16:17 -070085 /**
Santos Cordone3c507b2015-04-23 14:44:19 -070086 * The state of an outgoing {@code Call} when waiting on user to select a
87 * {@link PhoneAccount} through which to place the call.
Nancy Chen5da0fd52014-07-08 14:16:17 -070088 */
Santos Cordone3c507b2015-04-23 14:44:19 -070089 public static final int STATE_SELECT_PHONE_ACCOUNT = 8;
90
91 /**
92 * @hide
93 * @deprecated use STATE_SELECT_PHONE_ACCOUNT.
94 */
95 @Deprecated
96 @SystemApi
97 public static final int STATE_PRE_DIAL_WAIT = STATE_SELECT_PHONE_ACCOUNT;
Nancy Chen5da0fd52014-07-08 14:16:17 -070098
Nancy Chene20930f2014-08-07 16:17:21 -070099 /**
Nancy Chene9b7a8e2014-08-08 14:26:27 -0700100 * The initial state of an outgoing {@code Call}.
101 * Common transitions are to {@link #STATE_DIALING} state for a successful call or
102 * {@link #STATE_DISCONNECTED} if it failed.
Nancy Chene20930f2014-08-07 16:17:21 -0700103 */
104 public static final int STATE_CONNECTING = 9;
105
Nancy Chen513c8922014-09-17 14:47:20 -0700106 /**
Tyler Gunn4afc6af2014-10-07 10:14:55 -0700107 * The state of a {@code Call} when the user has initiated a disconnection of the call, but the
108 * call has not yet been disconnected by the underlying {@code ConnectionService}. The next
109 * state of the call is (potentially) {@link #STATE_DISCONNECTED}.
110 */
111 public static final int STATE_DISCONNECTING = 10;
112
113 /**
Tyler Gunn876dbfb2016-03-14 15:18:07 -0700114 * The state of an external call which is in the process of being pulled from a remote device to
115 * the local device.
116 * <p>
117 * A call can only be in this state if the {@link Details#PROPERTY_IS_EXTERNAL_CALL} property
118 * and {@link Details#CAPABILITY_CAN_PULL_CALL} capability are set on the call.
119 * <p>
120 * An {@link InCallService} will only see this state if it has the
121 * {@link TelecomManager#METADATA_INCLUDE_EXTERNAL_CALLS} metadata set to {@code true} in its
122 * manifest.
123 */
124 public static final int STATE_PULLING_CALL = 11;
125
126 /**
Hall Liu6dfa2492019-10-01 17:20:39 -0700127 * The state of a call that is active with the network, but the audio from the call is
128 * being intercepted by an app on the local device. Telecom does not hold audio focus in this
129 * state, and the call will be invisible to the user except for a persistent notification.
130 */
131 public static final int STATE_AUDIO_PROCESSING = 12;
132
133 /**
134 * The state of a call that is being presented to the user after being in
135 * {@link #STATE_AUDIO_PROCESSING}. The call is still active with the network in this case, and
136 * Telecom will hold audio focus and play a ringtone if appropriate.
137 */
138 public static final int STATE_SIMULATED_RINGING = 13;
139
140 /**
Nancy Chen513c8922014-09-17 14:47:20 -0700141 * The key to retrieve the optional {@code PhoneAccount}s Telecom can bundle with its Call
142 * extras. Used to pass the phone accounts to display on the front end to the user in order to
143 * select phone accounts to (for example) place a call.
Hall Liu34d9e242018-11-21 17:05:58 -0800144 * @deprecated Use the list from {@link #EXTRA_SUGGESTED_PHONE_ACCOUNTS} instead.
Nancy Chen513c8922014-09-17 14:47:20 -0700145 */
Hall Liu34d9e242018-11-21 17:05:58 -0800146 @Deprecated
Nancy Chen513c8922014-09-17 14:47:20 -0700147 public static final String AVAILABLE_PHONE_ACCOUNTS = "selectPhoneAccountAccounts";
148
mike dooley4af561f2016-12-20 08:55:17 -0800149 /**
Hall Liu34d9e242018-11-21 17:05:58 -0800150 * Key for extra used to pass along a list of {@link PhoneAccountSuggestion}s to the in-call
151 * UI when a call enters the {@link #STATE_SELECT_PHONE_ACCOUNT} state. The list included here
152 * will have the same length and be in the same order as the list passed with
153 * {@link #AVAILABLE_PHONE_ACCOUNTS}.
154 */
155 public static final String EXTRA_SUGGESTED_PHONE_ACCOUNTS =
156 "android.telecom.extra.SUGGESTED_PHONE_ACCOUNTS";
157
158 /**
mike dooley91217422017-03-09 12:58:42 -0800159 * Extra key used to indicate the time (in milliseconds since midnight, January 1, 1970 UTC)
160 * when the last outgoing emergency call was made. This is used to identify potential emergency
161 * callbacks.
mike dooley4af561f2016-12-20 08:55:17 -0800162 */
163 public static final String EXTRA_LAST_EMERGENCY_CALLBACK_TIME_MILLIS =
164 "android.telecom.extra.LAST_EMERGENCY_CALLBACK_TIME_MILLIS";
165
Usman Abdullahb0dc29a2019-03-06 15:54:56 -0800166
167 /**
168 * Extra key used to indicate whether a {@link CallScreeningService} has requested to silence
169 * the ringtone for a call. If the {@link InCallService} declares
170 * {@link TelecomManager#METADATA_IN_CALL_SERVICE_RINGING} in its manifest, it should not
171 * play a ringtone for an incoming call with this extra key set.
172 */
173 public static final String EXTRA_SILENT_RINGING_REQUESTED =
174 "android.telecom.extra.SILENT_RINGING_REQUESTED";
175
Tyler Gunn8bf76572017-04-06 15:30:08 -0700176 /**
177 * Call event sent from a {@link Call} via {@link #sendCallEvent(String, Bundle)} to inform
178 * Telecom that the user has requested that the current {@link Call} should be handed over
179 * to another {@link ConnectionService}.
180 * <p>
181 * The caller must specify the {@link #EXTRA_HANDOVER_PHONE_ACCOUNT_HANDLE} to indicate to
182 * Telecom which {@link PhoneAccountHandle} the {@link Call} should be handed over to.
183 * @hide
Tyler Gunn1a505fa2018-09-14 13:36:38 -0700184 * @deprecated Use {@link Call#handoverTo(PhoneAccountHandle, int, Bundle)} and its associated
185 * APIs instead.
Tyler Gunn8bf76572017-04-06 15:30:08 -0700186 */
187 public static final String EVENT_REQUEST_HANDOVER =
188 "android.telecom.event.REQUEST_HANDOVER";
189
190 /**
191 * Extra key used with the {@link #EVENT_REQUEST_HANDOVER} call event. Specifies the
192 * {@link PhoneAccountHandle} to which a call should be handed over to.
193 * @hide
Tyler Gunn1a505fa2018-09-14 13:36:38 -0700194 * @deprecated Use {@link Call#handoverTo(PhoneAccountHandle, int, Bundle)} and its associated
195 * APIs instead.
Tyler Gunn8bf76572017-04-06 15:30:08 -0700196 */
197 public static final String EXTRA_HANDOVER_PHONE_ACCOUNT_HANDLE =
198 "android.telecom.extra.HANDOVER_PHONE_ACCOUNT_HANDLE";
199
200 /**
201 * Integer extra key used with the {@link #EVENT_REQUEST_HANDOVER} call event. Specifies the
202 * video state of the call when it is handed over to the new {@link PhoneAccount}.
203 * <p>
204 * Valid values: {@link VideoProfile#STATE_AUDIO_ONLY},
205 * {@link VideoProfile#STATE_BIDIRECTIONAL}, {@link VideoProfile#STATE_RX_ENABLED}, and
206 * {@link VideoProfile#STATE_TX_ENABLED}.
207 * @hide
Tyler Gunn1a505fa2018-09-14 13:36:38 -0700208 * @deprecated Use {@link Call#handoverTo(PhoneAccountHandle, int, Bundle)} and its associated
209 * APIs instead.
Tyler Gunn8bf76572017-04-06 15:30:08 -0700210 */
211 public static final String EXTRA_HANDOVER_VIDEO_STATE =
212 "android.telecom.extra.HANDOVER_VIDEO_STATE";
213
214 /**
Tyler Gunn9f6f0472017-04-17 18:25:22 -0700215 * Extra key used with the {@link #EVENT_REQUEST_HANDOVER} call event. Used by the
216 * {@link InCallService} initiating a handover to provide a {@link Bundle} with extra
217 * information to the handover {@link ConnectionService} specified by
218 * {@link #EXTRA_HANDOVER_PHONE_ACCOUNT_HANDLE}.
219 * <p>
220 * This {@link Bundle} is not interpreted by Telecom, but passed as-is to the
221 * {@link ConnectionService} via the request extras when
222 * {@link ConnectionService#onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}
223 * is called to initate the handover.
Tyler Gunn8bf76572017-04-06 15:30:08 -0700224 * @hide
Tyler Gunn1a505fa2018-09-14 13:36:38 -0700225 * @deprecated Use {@link Call#handoverTo(PhoneAccountHandle, int, Bundle)} and its associated
226 * APIs instead.
Tyler Gunn8bf76572017-04-06 15:30:08 -0700227 */
Tyler Gunn9f6f0472017-04-17 18:25:22 -0700228 public static final String EXTRA_HANDOVER_EXTRAS = "android.telecom.extra.HANDOVER_EXTRAS";
Tyler Gunn8bf76572017-04-06 15:30:08 -0700229
230 /**
Tyler Gunn9f6f0472017-04-17 18:25:22 -0700231 * Call event sent from Telecom to the handover {@link ConnectionService} via
232 * {@link Connection#onCallEvent(String, Bundle)} to inform a {@link Connection} that a handover
233 * to the {@link ConnectionService} has completed successfully.
234 * <p>
235 * A handover is initiated with the {@link #EVENT_REQUEST_HANDOVER} call event.
Tyler Gunn8bf76572017-04-06 15:30:08 -0700236 * @hide
Tyler Gunn1a505fa2018-09-14 13:36:38 -0700237 * @deprecated Use {@link Call#handoverTo(PhoneAccountHandle, int, Bundle)} and its associated
238 * APIs instead.
Tyler Gunn8bf76572017-04-06 15:30:08 -0700239 */
Tyler Gunn9f6f0472017-04-17 18:25:22 -0700240 public static final String EVENT_HANDOVER_COMPLETE =
241 "android.telecom.event.HANDOVER_COMPLETE";
Tyler Gunn34a2b312017-06-23 08:32:00 -0700242
243 /**
244 * Call event sent from Telecom to the handover destination {@link ConnectionService} via
245 * {@link Connection#onCallEvent(String, Bundle)} to inform the handover destination that the
246 * source connection has disconnected. The {@link Bundle} parameter for the call event will be
247 * {@code null}.
248 * <p>
249 * A handover is initiated with the {@link #EVENT_REQUEST_HANDOVER} call event.
250 * @hide
Tyler Gunn1a505fa2018-09-14 13:36:38 -0700251 * @deprecated Use {@link Call#handoverTo(PhoneAccountHandle, int, Bundle)} and its associated
252 * APIs instead.
Tyler Gunn34a2b312017-06-23 08:32:00 -0700253 */
254 public static final String EVENT_HANDOVER_SOURCE_DISCONNECTED =
255 "android.telecom.event.HANDOVER_SOURCE_DISCONNECTED";
256
Tyler Gunn9f6f0472017-04-17 18:25:22 -0700257 /**
258 * Call event sent from Telecom to the handover {@link ConnectionService} via
259 * {@link Connection#onCallEvent(String, Bundle)} to inform a {@link Connection} that a handover
260 * to the {@link ConnectionService} has failed.
261 * <p>
262 * A handover is initiated with the {@link #EVENT_REQUEST_HANDOVER} call event.
263 * @hide
Tyler Gunn1a505fa2018-09-14 13:36:38 -0700264 * @deprecated Use {@link Call#handoverTo(PhoneAccountHandle, int, Bundle)} and its associated
265 * APIs instead.
Tyler Gunn9f6f0472017-04-17 18:25:22 -0700266 */
267 public static final String EVENT_HANDOVER_FAILED =
268 "android.telecom.event.HANDOVER_FAILED";
Tyler Gunn8bf76572017-04-06 15:30:08 -0700269
Tyler Gunnfacfdee2020-01-23 13:10:37 -0800270
271 /**
272 * Reject reason used with {@link #reject(int)} to indicate that the user is rejecting this
273 * call because they have declined to answer it. This typically means that they are unable
274 * to answer the call at this time and would prefer it be sent to voicemail.
275 */
276 public static final int REJECT_REASON_DECLINED = 1;
277
278 /**
279 * Reject reason used with {@link #reject(int)} to indicate that the user is rejecting this
280 * call because it is an unwanted call. This allows the user to indicate that they are
281 * rejecting a call because it is likely a nuisance call.
282 */
283 public static final int REJECT_REASON_UNWANTED = 2;
284
285 /**
286 * @hide
287 */
288 @IntDef(prefix = { "REJECT_REASON_" },
289 value = {REJECT_REASON_DECLINED, REJECT_REASON_UNWANTED})
290 @Retention(RetentionPolicy.SOURCE)
291 public @interface RejectReason {};
292
Ihab Awade63fadb2014-07-09 21:52:04 -0700293 public static class Details {
Tyler Gunn94f8f112018-12-17 09:56:11 -0800294 /** @hide */
295 @Retention(RetentionPolicy.SOURCE)
296 @IntDef(
297 prefix = { "DIRECTION_" },
298 value = {DIRECTION_UNKNOWN, DIRECTION_INCOMING, DIRECTION_OUTGOING})
299 public @interface CallDirection {}
300
301 /**
302 * Indicates that the call is neither and incoming nor an outgoing call. This can be the
303 * case for calls reported directly by a {@link ConnectionService} in special cases such as
304 * call handovers.
305 */
306 public static final int DIRECTION_UNKNOWN = -1;
307
308 /**
309 * Indicates that the call is an incoming call.
310 */
311 public static final int DIRECTION_INCOMING = 0;
312
313 /**
314 * Indicates that the call is an outgoing call.
315 */
316 public static final int DIRECTION_OUTGOING = 1;
317
Ihab Awad5c9c86e2014-11-12 13:41:16 -0800318 /** Call can currently be put on hold or unheld. */
319 public static final int CAPABILITY_HOLD = 0x00000001;
320
321 /** Call supports the hold feature. */
322 public static final int CAPABILITY_SUPPORT_HOLD = 0x00000002;
323
324 /**
325 * Calls within a conference can be merged. A {@link ConnectionService} has the option to
326 * add a {@link Conference} call before the child {@link Connection}s are merged. This is how
327 * CDMA-based {@link Connection}s are implemented. For these unmerged {@link Conference}s, this
328 * capability allows a merge button to be shown while the conference call is in the foreground
329 * of the in-call UI.
330 * <p>
331 * This is only intended for use by a {@link Conference}.
332 */
333 public static final int CAPABILITY_MERGE_CONFERENCE = 0x00000004;
334
335 /**
336 * Calls within a conference can be swapped between foreground and background.
337 * See {@link #CAPABILITY_MERGE_CONFERENCE} for additional information.
338 * <p>
339 * This is only intended for use by a {@link Conference}.
340 */
341 public static final int CAPABILITY_SWAP_CONFERENCE = 0x00000008;
342
343 /**
344 * @hide
345 */
Andrew Lee2378ea72015-04-29 14:38:11 -0700346 public static final int CAPABILITY_UNUSED_1 = 0x00000010;
Ihab Awad5c9c86e2014-11-12 13:41:16 -0800347
348 /** Call supports responding via text option. */
349 public static final int CAPABILITY_RESPOND_VIA_TEXT = 0x00000020;
350
351 /** Call can be muted. */
352 public static final int CAPABILITY_MUTE = 0x00000040;
353
354 /**
355 * Call supports conference call management. This capability only applies to {@link Conference}
356 * calls which can have {@link Connection}s as children.
357 */
358 public static final int CAPABILITY_MANAGE_CONFERENCE = 0x00000080;
359
360 /**
Andrew Lee5e9e8bb2015-03-10 13:58:24 -0700361 * Local device supports receiving video.
Ihab Awad5c9c86e2014-11-12 13:41:16 -0800362 */
Andrew Lee5e9e8bb2015-03-10 13:58:24 -0700363 public static final int CAPABILITY_SUPPORTS_VT_LOCAL_RX = 0x00000100;
Ihab Awad5c9c86e2014-11-12 13:41:16 -0800364
365 /**
Andrew Lee5e9e8bb2015-03-10 13:58:24 -0700366 * Local device supports transmitting video.
Ihab Awad5c9c86e2014-11-12 13:41:16 -0800367 */
Andrew Lee5e9e8bb2015-03-10 13:58:24 -0700368 public static final int CAPABILITY_SUPPORTS_VT_LOCAL_TX = 0x00000200;
Ihab Awad5c9c86e2014-11-12 13:41:16 -0800369
370 /**
Andrew Lee5e9e8bb2015-03-10 13:58:24 -0700371 * Local device supports bidirectional video calling.
Ihab Awad5c9c86e2014-11-12 13:41:16 -0800372 */
Andrew Lee9a8f9ce2015-04-10 18:09:46 -0700373 public static final int CAPABILITY_SUPPORTS_VT_LOCAL_BIDIRECTIONAL =
Andrew Lee5e9e8bb2015-03-10 13:58:24 -0700374 CAPABILITY_SUPPORTS_VT_LOCAL_RX | CAPABILITY_SUPPORTS_VT_LOCAL_TX;
Ihab Awad5c9c86e2014-11-12 13:41:16 -0800375
376 /**
Andrew Lee5e9e8bb2015-03-10 13:58:24 -0700377 * Remote device supports receiving video.
Ihab Awad5c9c86e2014-11-12 13:41:16 -0800378 */
Andrew Lee5e9e8bb2015-03-10 13:58:24 -0700379 public static final int CAPABILITY_SUPPORTS_VT_REMOTE_RX = 0x00000400;
380
381 /**
382 * Remote device supports transmitting video.
Andrew Lee5e9e8bb2015-03-10 13:58:24 -0700383 */
384 public static final int CAPABILITY_SUPPORTS_VT_REMOTE_TX = 0x00000800;
385
386 /**
387 * Remote device supports bidirectional video calling.
Andrew Lee5e9e8bb2015-03-10 13:58:24 -0700388 */
Andrew Lee9a8f9ce2015-04-10 18:09:46 -0700389 public static final int CAPABILITY_SUPPORTS_VT_REMOTE_BIDIRECTIONAL =
Andrew Lee5e9e8bb2015-03-10 13:58:24 -0700390 CAPABILITY_SUPPORTS_VT_REMOTE_RX | CAPABILITY_SUPPORTS_VT_REMOTE_TX;
Ihab Awad5c9c86e2014-11-12 13:41:16 -0800391
392 /**
393 * Call is able to be separated from its parent {@code Conference}, if any.
394 */
395 public static final int CAPABILITY_SEPARATE_FROM_CONFERENCE = 0x00001000;
396
397 /**
398 * Call is able to be individually disconnected when in a {@code Conference}.
399 */
400 public static final int CAPABILITY_DISCONNECT_FROM_CONFERENCE = 0x00002000;
401
402 /**
Dong Zhou89f41eb2015-03-15 11:59:49 -0500403 * Speed up audio setup for MT call.
404 * @hide
405 */
Tyler Gunn96d6c402015-03-18 12:39:23 -0700406 public static final int CAPABILITY_SPEED_UP_MT_AUDIO = 0x00040000;
407
Tyler Gunnb5e0cfb2015-04-07 16:10:51 -0700408 /**
409 * Call can be upgraded to a video call.
Rekha Kumar07366812015-03-24 16:42:31 -0700410 * @hide
Tyler Gunn6e3ecc42018-11-12 11:30:56 -0800411 * @deprecated Use {@link #CAPABILITY_SUPPORTS_VT_LOCAL_BIDIRECTIONAL} and
412 * {@link #CAPABILITY_SUPPORTS_VT_REMOTE_BIDIRECTIONAL} to indicate for a call
413 * whether or not video calling is supported.
Rekha Kumar07366812015-03-24 16:42:31 -0700414 */
Tyler Gunn6e3ecc42018-11-12 11:30:56 -0800415 @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 119305590)
Rekha Kumar07366812015-03-24 16:42:31 -0700416 public static final int CAPABILITY_CAN_UPGRADE_TO_VIDEO = 0x00080000;
417
Tyler Gunnb5e0cfb2015-04-07 16:10:51 -0700418 /**
419 * For video calls, indicates whether the outgoing video for the call can be paused using
Yorke Lee32f24732015-05-12 16:18:03 -0700420 * the {@link android.telecom.VideoProfile#STATE_PAUSED} VideoState.
Tyler Gunnb5e0cfb2015-04-07 16:10:51 -0700421 */
422 public static final int CAPABILITY_CAN_PAUSE_VIDEO = 0x00100000;
423
Bryce Lee81901682015-08-28 16:38:02 -0700424 /**
425 * Call sends responses through connection.
426 * @hide
427 */
Tyler Gunnf97a0092016-01-19 15:59:34 -0800428 public static final int CAPABILITY_CAN_SEND_RESPONSE_VIA_CONNECTION = 0x00200000;
429
430 /**
431 * When set, prevents a video {@code Call} from being downgraded to an audio-only call.
432 * <p>
433 * Should be set when the VideoState has the {@link VideoProfile#STATE_TX_ENABLED} or
434 * {@link VideoProfile#STATE_RX_ENABLED} bits set to indicate that the connection cannot be
435 * downgraded from a video call back to a VideoState of
436 * {@link VideoProfile#STATE_AUDIO_ONLY}.
437 * <p>
438 * Intuitively, a call which can be downgraded to audio should also have local and remote
439 * video
440 * capabilities (see {@link #CAPABILITY_SUPPORTS_VT_LOCAL_BIDIRECTIONAL} and
441 * {@link #CAPABILITY_SUPPORTS_VT_REMOTE_BIDIRECTIONAL}).
442 */
443 public static final int CAPABILITY_CANNOT_DOWNGRADE_VIDEO_TO_AUDIO = 0x00400000;
Bryce Lee81901682015-08-28 16:38:02 -0700444
Tyler Gunn876dbfb2016-03-14 15:18:07 -0700445 /**
446 * When set for an external call, indicates that this {@code Call} can be pulled from a
447 * remote device to the current device.
448 * <p>
449 * Should only be set on a {@code Call} where {@link #PROPERTY_IS_EXTERNAL_CALL} is set.
450 * <p>
451 * An {@link InCallService} will only see calls with this capability if it has the
452 * {@link TelecomManager#METADATA_INCLUDE_EXTERNAL_CALLS} metadata set to {@code true}
453 * in its manifest.
454 * <p>
455 * See {@link Connection#CAPABILITY_CAN_PULL_CALL} and
Tyler Gunn720c6642016-03-22 09:02:47 -0700456 * {@link Connection#PROPERTY_IS_EXTERNAL_CALL}.
Tyler Gunn876dbfb2016-03-14 15:18:07 -0700457 */
458 public static final int CAPABILITY_CAN_PULL_CALL = 0x00800000;
459
Pooja Jaind34698d2017-12-28 14:15:31 +0530460 /** Call supports the deflect feature. */
461 public static final int CAPABILITY_SUPPORT_DEFLECT = 0x01000000;
462
Tyler Gunn0c62ef02020-02-11 14:39:43 -0800463 /**
464 * Call supports adding participants to the call via
Grace Jia8587ee52020-07-10 15:42:32 -0700465 * {@link #addConferenceParticipants(List)}. Once participants are added, the call becomes
466 * an adhoc conference call ({@link #PROPERTY_IS_ADHOC_CONFERENCE}).
Tyler Gunn0c62ef02020-02-11 14:39:43 -0800467 */
Ravi Paluri404babb2020-01-23 19:02:44 +0530468 public static final int CAPABILITY_ADD_PARTICIPANT = 0x02000000;
Ravi Palurif4b38e72020-02-05 12:35:41 +0530469
470 /**
471 * When set for a call, indicates that this {@code Call} can be transferred to another
472 * number.
Tyler Gunn460360d2020-07-29 10:21:45 -0700473 * Call supports the confirmed and unconfirmed call transfer feature.
Ravi Palurif4b38e72020-02-05 12:35:41 +0530474 *
475 * @hide
476 */
477 public static final int CAPABILITY_TRANSFER = 0x04000000;
478
479 /**
480 * When set for a call, indicates that this {@code Call} can be transferred to another
481 * ongoing call.
482 * Call supports the consultative call transfer feature.
483 *
484 * @hide
485 */
486 public static final int CAPABILITY_TRANSFER_CONSULTATIVE = 0x08000000;
487
Tyler Gunnd11a3152015-03-18 13:09:14 -0700488 //******************************************************************************************
Ravi Palurif4b38e72020-02-05 12:35:41 +0530489 // Next CAPABILITY value: 0x10000000
Andrew Lee2378ea72015-04-29 14:38:11 -0700490 //******************************************************************************************
491
492 /**
493 * Whether the call is currently a conference.
494 */
495 public static final int PROPERTY_CONFERENCE = 0x00000001;
496
497 /**
498 * Whether the call is a generic conference, where we do not know the precise state of
499 * participants in the conference (eg. on CDMA).
500 */
501 public static final int PROPERTY_GENERIC_CONFERENCE = 0x00000002;
502
503 /**
504 * Whether the call is made while the device is in emergency callback mode.
505 */
506 public static final int PROPERTY_EMERGENCY_CALLBACK_MODE = 0x00000004;
507
508 /**
509 * Connection is using WIFI.
510 */
511 public static final int PROPERTY_WIFI = 0x00000008;
512
513 /**
Tyler Gunn6b6ae552018-10-11 10:42:10 -0700514 * When set, the UI should indicate to the user that a call is using high definition
515 * audio.
516 * <p>
517 * The underlying {@link ConnectionService} is responsible for reporting this
518 * property. It is important to note that this property is not intended to report the
519 * actual audio codec being used for a Call, but whether the call should be indicated
520 * to the user as high definition.
521 * <p>
522 * The Android Telephony stack reports this property for calls based on a number
523 * of factors, including which audio codec is used and whether a call is using an HD
524 * codec end-to-end. Some mobile operators choose to suppress display of an HD indication,
525 * and in these cases this property will not be set for a call even if the underlying audio
526 * codec is in fact "high definition".
Andrew Lee2378ea72015-04-29 14:38:11 -0700527 */
528 public static final int PROPERTY_HIGH_DEF_AUDIO = 0x00000010;
529
Tony Maka68dcce2015-12-17 09:31:18 +0000530 /**
Tony Mak53b5df42016-05-19 13:40:38 +0100531 * Whether the call is associated with the work profile.
532 */
533 public static final int PROPERTY_ENTERPRISE_CALL = 0x00000020;
534
535 /**
Tyler Gunn876dbfb2016-03-14 15:18:07 -0700536 * When set, indicates that this {@code Call} does not actually exist locally for the
537 * {@link ConnectionService}.
538 * <p>
539 * Consider, for example, a scenario where a user has two phones with the same phone number.
540 * When a user places a call on one device, the telephony stack can represent that call on
541 * the other device by adding it to the {@link ConnectionService} with the
Tyler Gunn720c6642016-03-22 09:02:47 -0700542 * {@link Connection#PROPERTY_IS_EXTERNAL_CALL} property set.
Tyler Gunn876dbfb2016-03-14 15:18:07 -0700543 * <p>
544 * An {@link InCallService} will only see calls with this property if it has the
545 * {@link TelecomManager#METADATA_INCLUDE_EXTERNAL_CALLS} metadata set to {@code true}
546 * in its manifest.
547 * <p>
Tyler Gunn720c6642016-03-22 09:02:47 -0700548 * See {@link Connection#PROPERTY_IS_EXTERNAL_CALL}.
Tyler Gunn876dbfb2016-03-14 15:18:07 -0700549 */
550 public static final int PROPERTY_IS_EXTERNAL_CALL = 0x00000040;
551
Brad Ebinger15847072016-05-18 11:08:36 -0700552 /**
553 * Indicates that the call has CDMA Enhanced Voice Privacy enabled.
554 */
555 public static final int PROPERTY_HAS_CDMA_VOICE_PRIVACY = 0x00000080;
556
Tyler Gunn24e18332017-02-10 09:42:49 -0800557 /**
558 * Indicates that the call is from a self-managed {@link ConnectionService}.
559 * <p>
560 * See also {@link Connection#PROPERTY_SELF_MANAGED}
561 */
562 public static final int PROPERTY_SELF_MANAGED = 0x00000100;
563
Eric Erfanianec881872017-12-06 16:27:53 -0800564 /**
565 * Indicates the call used Assisted Dialing.
Tyler Gunn5567d742019-10-31 13:04:37 -0700566 *
567 * @see TelecomManager#EXTRA_USE_ASSISTED_DIALING
Eric Erfanianec881872017-12-06 16:27:53 -0800568 */
Tyler Gunnc9503d62020-01-27 10:30:51 -0800569 public static final int PROPERTY_ASSISTED_DIALING = 0x00000200;
Eric Erfanianec881872017-12-06 16:27:53 -0800570
Hall Liue9041242018-02-09 16:40:03 -0800571 /**
572 * Indicates that the call is an RTT call. Use {@link #getRttCall()} to get the
573 * {@link RttCall} object that is used to send and receive text.
574 */
575 public static final int PROPERTY_RTT = 0x00000400;
576
Tyler Gunn5bd90852018-09-21 09:37:07 -0700577 /**
578 * Indicates that the call has been identified as the network as an emergency call. This
579 * property may be set for both incoming and outgoing calls which the network identifies as
580 * emergency calls.
581 */
582 public static final int PROPERTY_NETWORK_IDENTIFIED_EMERGENCY_CALL = 0x00000800;
583
Tyler Gunn80a5e1e2018-06-22 15:52:27 -0700584 /**
585 * Indicates that the call is using VoIP audio mode.
586 * <p>
587 * When this property is set, the {@link android.media.AudioManager} audio mode for this
588 * call will be {@link android.media.AudioManager#MODE_IN_COMMUNICATION}. When this
589 * property is not set, the audio mode for this call will be
590 * {@link android.media.AudioManager#MODE_IN_CALL}.
591 * <p>
592 * This property reflects changes made using {@link Connection#setAudioModeIsVoip(boolean)}.
593 * <p>
594 * You can use this property to determine whether an un-answered incoming call or a held
595 * call will use VoIP audio mode (if the call does not currently have focus, the system
596 * audio mode may not reflect the mode the call will use).
597 */
598 public static final int PROPERTY_VOIP_AUDIO_MODE = 0x00001000;
599
Ravi Paluri80aa2142019-12-02 11:57:37 +0530600 /**
601 * Indicates that the call is an adhoc conference call. This property can be set for both
Grace Jia8587ee52020-07-10 15:42:32 -0700602 * incoming and outgoing calls. An adhoc conference call is formed using
603 * {@link #addConferenceParticipants(List)},
604 * {@link TelecomManager#addNewIncomingConference(PhoneAccountHandle, Bundle)}, or
605 * {@link TelecomManager#startConference(List, Bundle)}, rather than by merging existing
606 * call using {@link #conference(Call)}.
Ravi Paluri80aa2142019-12-02 11:57:37 +0530607 */
608 public static final int PROPERTY_IS_ADHOC_CONFERENCE = 0x00002000;
609
Andrew Lee2378ea72015-04-29 14:38:11 -0700610 //******************************************************************************************
Ravi Paluri80aa2142019-12-02 11:57:37 +0530611 // Next PROPERTY value: 0x00004000
Tyler Gunnd11a3152015-03-18 13:09:14 -0700612 //******************************************************************************************
Tyler Gunn068085b2015-02-06 13:56:52 -0800613
Sailesh Nepal1bef3392016-01-24 18:21:53 -0800614 private final String mTelecomCallId;
Ihab Awade63fadb2014-07-09 21:52:04 -0700615 private final Uri mHandle;
616 private final int mHandlePresentation;
617 private final String mCallerDisplayName;
618 private final int mCallerDisplayNamePresentation;
Evan Charlton8c8a0622014-07-20 12:31:00 -0700619 private final PhoneAccountHandle mAccountHandle;
Ihab Awad5d0410f2014-07-30 10:07:40 -0700620 private final int mCallCapabilities;
Andrew Lee223ad142014-08-27 16:33:08 -0700621 private final int mCallProperties;
Christine Hallstrom4e22d6d2016-11-30 16:06:42 -0800622 private final int mSupportedAudioRoutes = CallAudioState.ROUTE_ALL;
Andrew Lee7f3d41f2014-09-11 17:33:16 -0700623 private final DisconnectCause mDisconnectCause;
Ihab Awade63fadb2014-07-09 21:52:04 -0700624 private final long mConnectTimeMillis;
625 private final GatewayInfo mGatewayInfo;
Andrew Lee85f5d422014-07-11 17:22:03 -0700626 private final int mVideoState;
Evan Charlton5b49ade2014-07-15 17:03:20 -0700627 private final StatusHints mStatusHints;
Nancy Chen10798dc2014-08-08 14:00:25 -0700628 private final Bundle mExtras;
Santos Cordon6b7f9552015-05-27 17:21:45 -0700629 private final Bundle mIntentExtras;
Tyler Gunnc0bf6de2017-03-17 11:27:09 -0700630 private final long mCreationTimeMillis;
Hall Liuef98bf82020-01-09 15:22:44 -0800631 private final String mContactDisplayName;
Tyler Gunn94f8f112018-12-17 09:56:11 -0800632 private final @CallDirection int mCallDirection;
Tyler Gunnd57d76c2019-09-24 14:53:23 -0700633 private final @Connection.VerificationStatus int mCallerNumberVerificationStatus;
Ihab Awade63fadb2014-07-09 21:52:04 -0700634
635 /**
Ihab Awad5c9c86e2014-11-12 13:41:16 -0800636 * Whether the supplied capabilities supports the specified capability.
637 *
638 * @param capabilities A bit field of capabilities.
639 * @param capability The capability to check capabilities for.
640 * @return Whether the specified capability is supported.
Ihab Awad5c9c86e2014-11-12 13:41:16 -0800641 */
642 public static boolean can(int capabilities, int capability) {
Tyler Gunn014c7112015-12-18 14:33:57 -0800643 return (capabilities & capability) == capability;
Ihab Awad5c9c86e2014-11-12 13:41:16 -0800644 }
645
646 /**
647 * Whether the capabilities of this {@code Details} supports the specified capability.
648 *
649 * @param capability The capability to check capabilities for.
650 * @return Whether the specified capability is supported.
Ihab Awad5c9c86e2014-11-12 13:41:16 -0800651 */
652 public boolean can(int capability) {
653 return can(mCallCapabilities, capability);
654 }
655
656 /**
657 * Render a set of capability bits ({@code CAPABILITY_*}) as a human readable string.
658 *
659 * @param capabilities A capability bit field.
660 * @return A human readable string representation.
661 */
662 public static String capabilitiesToString(int capabilities) {
663 StringBuilder builder = new StringBuilder();
664 builder.append("[Capabilities:");
665 if (can(capabilities, CAPABILITY_HOLD)) {
666 builder.append(" CAPABILITY_HOLD");
667 }
668 if (can(capabilities, CAPABILITY_SUPPORT_HOLD)) {
669 builder.append(" CAPABILITY_SUPPORT_HOLD");
670 }
671 if (can(capabilities, CAPABILITY_MERGE_CONFERENCE)) {
672 builder.append(" CAPABILITY_MERGE_CONFERENCE");
673 }
674 if (can(capabilities, CAPABILITY_SWAP_CONFERENCE)) {
675 builder.append(" CAPABILITY_SWAP_CONFERENCE");
676 }
677 if (can(capabilities, CAPABILITY_RESPOND_VIA_TEXT)) {
678 builder.append(" CAPABILITY_RESPOND_VIA_TEXT");
679 }
680 if (can(capabilities, CAPABILITY_MUTE)) {
681 builder.append(" CAPABILITY_MUTE");
682 }
683 if (can(capabilities, CAPABILITY_MANAGE_CONFERENCE)) {
684 builder.append(" CAPABILITY_MANAGE_CONFERENCE");
685 }
Andrew Lee5e9e8bb2015-03-10 13:58:24 -0700686 if (can(capabilities, CAPABILITY_SUPPORTS_VT_LOCAL_RX)) {
687 builder.append(" CAPABILITY_SUPPORTS_VT_LOCAL_RX");
688 }
689 if (can(capabilities, CAPABILITY_SUPPORTS_VT_LOCAL_TX)) {
690 builder.append(" CAPABILITY_SUPPORTS_VT_LOCAL_TX");
691 }
Andrew Lee9a8f9ce2015-04-10 18:09:46 -0700692 if (can(capabilities, CAPABILITY_SUPPORTS_VT_LOCAL_BIDIRECTIONAL)) {
693 builder.append(" CAPABILITY_SUPPORTS_VT_LOCAL_BIDIRECTIONAL");
Ihab Awad5c9c86e2014-11-12 13:41:16 -0800694 }
Andrew Lee5e9e8bb2015-03-10 13:58:24 -0700695 if (can(capabilities, CAPABILITY_SUPPORTS_VT_REMOTE_RX)) {
696 builder.append(" CAPABILITY_SUPPORTS_VT_REMOTE_RX");
697 }
698 if (can(capabilities, CAPABILITY_SUPPORTS_VT_REMOTE_TX)) {
699 builder.append(" CAPABILITY_SUPPORTS_VT_REMOTE_TX");
700 }
Tyler Gunnf97a0092016-01-19 15:59:34 -0800701 if (can(capabilities, CAPABILITY_CANNOT_DOWNGRADE_VIDEO_TO_AUDIO)) {
702 builder.append(" CAPABILITY_CANNOT_DOWNGRADE_VIDEO_TO_AUDIO");
703 }
Andrew Lee9a8f9ce2015-04-10 18:09:46 -0700704 if (can(capabilities, CAPABILITY_SUPPORTS_VT_REMOTE_BIDIRECTIONAL)) {
705 builder.append(" CAPABILITY_SUPPORTS_VT_REMOTE_BIDIRECTIONAL");
Ihab Awad5c9c86e2014-11-12 13:41:16 -0800706 }
Dong Zhou89f41eb2015-03-15 11:59:49 -0500707 if (can(capabilities, CAPABILITY_SPEED_UP_MT_AUDIO)) {
Tyler Gunnd11a3152015-03-18 13:09:14 -0700708 builder.append(" CAPABILITY_SPEED_UP_MT_AUDIO");
Dong Zhou89f41eb2015-03-15 11:59:49 -0500709 }
Rekha Kumar07366812015-03-24 16:42:31 -0700710 if (can(capabilities, CAPABILITY_CAN_UPGRADE_TO_VIDEO)) {
711 builder.append(" CAPABILITY_CAN_UPGRADE_TO_VIDEO");
712 }
Tyler Gunnb5e0cfb2015-04-07 16:10:51 -0700713 if (can(capabilities, CAPABILITY_CAN_PAUSE_VIDEO)) {
714 builder.append(" CAPABILITY_CAN_PAUSE_VIDEO");
715 }
Tyler Gunn876dbfb2016-03-14 15:18:07 -0700716 if (can(capabilities, CAPABILITY_CAN_PULL_CALL)) {
717 builder.append(" CAPABILITY_CAN_PULL_CALL");
718 }
Pooja Jaind34698d2017-12-28 14:15:31 +0530719 if (can(capabilities, CAPABILITY_SUPPORT_DEFLECT)) {
720 builder.append(" CAPABILITY_SUPPORT_DEFLECT");
721 }
Ravi Paluri404babb2020-01-23 19:02:44 +0530722 if (can(capabilities, CAPABILITY_ADD_PARTICIPANT)) {
723 builder.append(" CAPABILITY_ADD_PARTICIPANT");
724 }
Ravi Palurif4b38e72020-02-05 12:35:41 +0530725 if (can(capabilities, CAPABILITY_TRANSFER)) {
726 builder.append(" CAPABILITY_TRANSFER");
727 }
728 if (can(capabilities, CAPABILITY_TRANSFER_CONSULTATIVE)) {
729 builder.append(" CAPABILITY_TRANSFER_CONSULTATIVE");
730 }
Ihab Awad5c9c86e2014-11-12 13:41:16 -0800731 builder.append("]");
732 return builder.toString();
733 }
734
735 /**
Andrew Lee2378ea72015-04-29 14:38:11 -0700736 * Whether the supplied properties includes the specified property.
737 *
738 * @param properties A bit field of properties.
739 * @param property The property to check properties for.
740 * @return Whether the specified property is supported.
741 */
742 public static boolean hasProperty(int properties, int property) {
Tyler Gunn014c7112015-12-18 14:33:57 -0800743 return (properties & property) == property;
Andrew Lee2378ea72015-04-29 14:38:11 -0700744 }
745
746 /**
747 * Whether the properties of this {@code Details} includes the specified property.
748 *
749 * @param property The property to check properties for.
750 * @return Whether the specified property is supported.
751 */
752 public boolean hasProperty(int property) {
753 return hasProperty(mCallProperties, property);
754 }
755
756 /**
757 * Render a set of property bits ({@code PROPERTY_*}) as a human readable string.
758 *
759 * @param properties A property bit field.
760 * @return A human readable string representation.
761 */
762 public static String propertiesToString(int properties) {
763 StringBuilder builder = new StringBuilder();
764 builder.append("[Properties:");
765 if (hasProperty(properties, PROPERTY_CONFERENCE)) {
766 builder.append(" PROPERTY_CONFERENCE");
767 }
768 if (hasProperty(properties, PROPERTY_GENERIC_CONFERENCE)) {
769 builder.append(" PROPERTY_GENERIC_CONFERENCE");
770 }
771 if (hasProperty(properties, PROPERTY_WIFI)) {
772 builder.append(" PROPERTY_WIFI");
773 }
774 if (hasProperty(properties, PROPERTY_HIGH_DEF_AUDIO)) {
775 builder.append(" PROPERTY_HIGH_DEF_AUDIO");
776 }
777 if (hasProperty(properties, PROPERTY_EMERGENCY_CALLBACK_MODE)) {
Yorke Leebe2a4a22015-06-12 10:10:55 -0700778 builder.append(" PROPERTY_EMERGENCY_CALLBACK_MODE");
Andrew Lee2378ea72015-04-29 14:38:11 -0700779 }
Tyler Gunn876dbfb2016-03-14 15:18:07 -0700780 if (hasProperty(properties, PROPERTY_IS_EXTERNAL_CALL)) {
781 builder.append(" PROPERTY_IS_EXTERNAL_CALL");
782 }
Tyler Gunn80a5e1e2018-06-22 15:52:27 -0700783 if (hasProperty(properties, PROPERTY_HAS_CDMA_VOICE_PRIVACY)) {
Brad Ebinger15847072016-05-18 11:08:36 -0700784 builder.append(" PROPERTY_HAS_CDMA_VOICE_PRIVACY");
785 }
Tyler Gunnc9503d62020-01-27 10:30:51 -0800786 if (hasProperty(properties, PROPERTY_ASSISTED_DIALING)) {
Eric Erfanianec881872017-12-06 16:27:53 -0800787 builder.append(" PROPERTY_ASSISTED_DIALING_USED");
788 }
Tyler Gunn5bd90852018-09-21 09:37:07 -0700789 if (hasProperty(properties, PROPERTY_NETWORK_IDENTIFIED_EMERGENCY_CALL)) {
790 builder.append(" PROPERTY_NETWORK_IDENTIFIED_EMERGENCY_CALL");
791 }
Tyler Gunn80a5e1e2018-06-22 15:52:27 -0700792 if (hasProperty(properties, PROPERTY_RTT)) {
793 builder.append(" PROPERTY_RTT");
794 }
795 if (hasProperty(properties, PROPERTY_VOIP_AUDIO_MODE)) {
796 builder.append(" PROPERTY_VOIP_AUDIO_MODE");
797 }
Ravi Paluri80aa2142019-12-02 11:57:37 +0530798 if (hasProperty(properties, PROPERTY_IS_ADHOC_CONFERENCE)) {
799 builder.append(" PROPERTY_IS_ADHOC_CONFERENCE");
800 }
Andrew Lee2378ea72015-04-29 14:38:11 -0700801 builder.append("]");
802 return builder.toString();
803 }
804
Sailesh Nepal1bef3392016-01-24 18:21:53 -0800805 /** {@hide} */
Hall Liu31de23d2019-10-11 15:38:29 -0700806 @TestApi
Sailesh Nepal1bef3392016-01-24 18:21:53 -0800807 public String getTelecomCallId() {
808 return mTelecomCallId;
809 }
810
Andrew Lee2378ea72015-04-29 14:38:11 -0700811 /**
Ihab Awade63fadb2014-07-09 21:52:04 -0700812 * @return The handle (e.g., phone number) to which the {@code Call} is currently
813 * connected.
814 */
815 public Uri getHandle() {
816 return mHandle;
817 }
818
819 /**
820 * @return The presentation requirements for the handle. See
Tyler Gunnef9f6f92014-09-12 22:16:17 -0700821 * {@link TelecomManager} for valid values.
Ihab Awade63fadb2014-07-09 21:52:04 -0700822 */
823 public int getHandlePresentation() {
824 return mHandlePresentation;
825 }
826
827 /**
Tyler Gunnd081f042018-12-04 12:56:45 -0800828 * The display name for the caller.
829 * <p>
830 * This is the name as reported by the {@link ConnectionService} associated with this call.
Tyler Gunnd081f042018-12-04 12:56:45 -0800831 *
Ihab Awade63fadb2014-07-09 21:52:04 -0700832 * @return The display name for the caller.
833 */
834 public String getCallerDisplayName() {
835 return mCallerDisplayName;
836 }
837
838 /**
839 * @return The presentation requirements for the caller display name. See
Tyler Gunnef9f6f92014-09-12 22:16:17 -0700840 * {@link TelecomManager} for valid values.
Ihab Awade63fadb2014-07-09 21:52:04 -0700841 */
842 public int getCallerDisplayNamePresentation() {
843 return mCallerDisplayNamePresentation;
844 }
845
846 /**
Evan Charlton6eb262c2014-07-19 18:18:19 -0700847 * @return The {@code PhoneAccountHandle} whereby the {@code Call} is currently being
848 * routed.
Ihab Awade63fadb2014-07-09 21:52:04 -0700849 */
Evan Charlton8c8a0622014-07-20 12:31:00 -0700850 public PhoneAccountHandle getAccountHandle() {
851 return mAccountHandle;
Ihab Awade63fadb2014-07-09 21:52:04 -0700852 }
853
854 /**
Ihab Awad5c9c86e2014-11-12 13:41:16 -0800855 * @return A bitmask of the capabilities of the {@code Call}, as defined by the various
856 * {@code CAPABILITY_*} constants in this class.
Ihab Awade63fadb2014-07-09 21:52:04 -0700857 */
Ihab Awad5d0410f2014-07-30 10:07:40 -0700858 public int getCallCapabilities() {
859 return mCallCapabilities;
Ihab Awade63fadb2014-07-09 21:52:04 -0700860 }
861
862 /**
Andrew Lee2378ea72015-04-29 14:38:11 -0700863 * @return A bitmask of the properties of the {@code Call}, as defined by the various
864 * {@code PROPERTY_*} constants in this class.
Andrew Lee223ad142014-08-27 16:33:08 -0700865 */
866 public int getCallProperties() {
867 return mCallProperties;
868 }
869
870 /**
Christine Hallstrom4e22d6d2016-11-30 16:06:42 -0800871 * @return a bitmask of the audio routes available for the call.
872 *
873 * @hide
874 */
875 public int getSupportedAudioRoutes() {
876 return mSupportedAudioRoutes;
877 }
878
879 /**
Ihab Awade63fadb2014-07-09 21:52:04 -0700880 * @return For a {@link #STATE_DISCONNECTED} {@code Call}, the disconnect cause expressed
Nancy Chenf4cf77c2014-09-19 10:53:21 -0700881 * by {@link android.telecom.DisconnectCause}.
Ihab Awade63fadb2014-07-09 21:52:04 -0700882 */
Andrew Lee7f3d41f2014-09-11 17:33:16 -0700883 public DisconnectCause getDisconnectCause() {
884 return mDisconnectCause;
Ihab Awade63fadb2014-07-09 21:52:04 -0700885 }
886
887 /**
Tyler Gunnc0bf6de2017-03-17 11:27:09 -0700888 * Returns the time the {@link Call} connected (i.e. became active). This information is
889 * updated periodically, but user interfaces should not rely on this to display the "call
890 * time clock". For the time when the call was first added to Telecom, see
891 * {@link #getCreationTimeMillis()}.
892 *
893 * @return The time the {@link Call} connected in milliseconds since the epoch.
Ihab Awade63fadb2014-07-09 21:52:04 -0700894 */
Jay Shrauner164a0ac2015-04-14 18:16:10 -0700895 public final long getConnectTimeMillis() {
Ihab Awade63fadb2014-07-09 21:52:04 -0700896 return mConnectTimeMillis;
897 }
898
899 /**
900 * @return Information about any calling gateway the {@code Call} may be using.
901 */
902 public GatewayInfo getGatewayInfo() {
903 return mGatewayInfo;
904 }
905
Andrew Lee7a341382014-07-15 17:05:08 -0700906 /**
Ihab Awad5d0410f2014-07-30 10:07:40 -0700907 * @return The video state of the {@code Call}.
Andrew Lee7a341382014-07-15 17:05:08 -0700908 */
909 public int getVideoState() {
910 return mVideoState;
911 }
912
Ihab Awad5d0410f2014-07-30 10:07:40 -0700913 /**
Tyler Gunnef9f6f92014-09-12 22:16:17 -0700914 * @return The current {@link android.telecom.StatusHints}, or {@code null} if none
Ihab Awad5d0410f2014-07-30 10:07:40 -0700915 * have been set.
Evan Charlton5b49ade2014-07-15 17:03:20 -0700916 */
917 public StatusHints getStatusHints() {
918 return mStatusHints;
919 }
920
Nancy Chen10798dc2014-08-08 14:00:25 -0700921 /**
Santos Cordon6b7f9552015-05-27 17:21:45 -0700922 * @return The extras associated with this call.
Nancy Chen10798dc2014-08-08 14:00:25 -0700923 */
924 public Bundle getExtras() {
925 return mExtras;
926 }
927
Santos Cordon6b7f9552015-05-27 17:21:45 -0700928 /**
929 * @return The extras used with the original intent to place this call.
930 */
931 public Bundle getIntentExtras() {
932 return mIntentExtras;
933 }
934
Tyler Gunnc0bf6de2017-03-17 11:27:09 -0700935 /**
936 * Returns the time when the call was first created and added to Telecom. This is the same
937 * time that is logged as the start time in the Call Log (see
938 * {@link android.provider.CallLog.Calls#DATE}). To determine when the call was connected
939 * (became active), see {@link #getConnectTimeMillis()}.
940 *
941 * @return The creation time of the call, in millis since the epoch.
942 */
943 public long getCreationTimeMillis() {
944 return mCreationTimeMillis;
945 }
946
Tyler Gunnd081f042018-12-04 12:56:45 -0800947 /**
Hall Liuef98bf82020-01-09 15:22:44 -0800948 * Returns the name of the caller on the remote end, as derived from a
949 * {@link android.provider.ContactsContract} lookup of the call's handle.
950 * @return The name of the caller, or {@code null} if the lookup is not yet complete, if
951 * there's no contacts entry for the caller, or if the {@link InCallService} does
952 * not hold the {@link android.Manifest.permission#READ_CONTACTS} permission.
953 */
954 public @Nullable String getContactDisplayName() {
955 return mContactDisplayName;
956 }
957
958 /**
Tyler Gunn94f8f112018-12-17 09:56:11 -0800959 * Indicates whether the call is an incoming or outgoing call.
960 * @return The call's direction.
961 */
962 public @CallDirection int getCallDirection() {
963 return mCallDirection;
964 }
965
Tyler Gunnd57d76c2019-09-24 14:53:23 -0700966 /**
967 * Gets the verification status for the phone number of an incoming call as identified in
968 * ATIS-1000082.
Tyler Gunn9c642492020-10-08 13:37:03 -0700969 * <p>
970 * For incoming calls, the number verification status indicates whether the device was
971 * able to verify the authenticity of the calling number using the STIR process outlined
972 * in ATIS-1000082. {@link Connection#VERIFICATION_STATUS_NOT_VERIFIED} indicates that
973 * the network was not able to use STIR to verify the caller's number (i.e. nothing is
974 * known regarding the authenticity of the number.
975 * {@link Connection#VERIFICATION_STATUS_PASSED} indicates that the network was able to
976 * use STIR to verify the caller's number. This indicates that the network has a high
977 * degree of confidence that the incoming call actually originated from the indicated
978 * number. {@link Connection#VERIFICATION_STATUS_FAILED} indicates that the network's
979 * STIR verification did not pass. This indicates that the incoming call may not
980 * actually be from the indicated number. This could occur if, for example, the caller
981 * is using an impersonated phone number.
982 * <p>
983 * A {@link CallScreeningService} can use this information to help determine if an
984 * incoming call is potentially an unwanted call. A verification status of
985 * {@link Connection#VERIFICATION_STATUS_FAILED} indicates that an incoming call may not
986 * actually be from the number indicated on the call (i.e. impersonated number) and that it
987 * should potentially be blocked. Likewise,
988 * {@link Connection#VERIFICATION_STATUS_PASSED} can be used as a positive signal to
989 * help clarify that the incoming call is originating from the indicated number and it
990 * is less likely to be an undesirable call.
991 * <p>
992 * An {@link InCallService} can use this information to provide a visual indicator to the
993 * user regarding the verification status of a call and to help identify calls from
994 * potentially impersonated numbers.
Tyler Gunnd57d76c2019-09-24 14:53:23 -0700995 * @return the verification status.
996 */
997 public @Connection.VerificationStatus int getCallerNumberVerificationStatus() {
998 return mCallerNumberVerificationStatus;
999 }
1000
Ihab Awade63fadb2014-07-09 21:52:04 -07001001 @Override
1002 public boolean equals(Object o) {
1003 if (o instanceof Details) {
1004 Details d = (Details) o;
1005 return
1006 Objects.equals(mHandle, d.mHandle) &&
1007 Objects.equals(mHandlePresentation, d.mHandlePresentation) &&
1008 Objects.equals(mCallerDisplayName, d.mCallerDisplayName) &&
1009 Objects.equals(mCallerDisplayNamePresentation,
1010 d.mCallerDisplayNamePresentation) &&
Evan Charlton8c8a0622014-07-20 12:31:00 -07001011 Objects.equals(mAccountHandle, d.mAccountHandle) &&
Ihab Awad5d0410f2014-07-30 10:07:40 -07001012 Objects.equals(mCallCapabilities, d.mCallCapabilities) &&
Andrew Lee223ad142014-08-27 16:33:08 -07001013 Objects.equals(mCallProperties, d.mCallProperties) &&
Andrew Lee7f3d41f2014-09-11 17:33:16 -07001014 Objects.equals(mDisconnectCause, d.mDisconnectCause) &&
Ihab Awade63fadb2014-07-09 21:52:04 -07001015 Objects.equals(mConnectTimeMillis, d.mConnectTimeMillis) &&
Andrew Lee85f5d422014-07-11 17:22:03 -07001016 Objects.equals(mGatewayInfo, d.mGatewayInfo) &&
Evan Charlton5b49ade2014-07-15 17:03:20 -07001017 Objects.equals(mVideoState, d.mVideoState) &&
Nancy Chen10798dc2014-08-08 14:00:25 -07001018 Objects.equals(mStatusHints, d.mStatusHints) &&
Tyler Gunn1e9bfc62015-08-19 11:18:58 -07001019 areBundlesEqual(mExtras, d.mExtras) &&
Tyler Gunnc0bf6de2017-03-17 11:27:09 -07001020 areBundlesEqual(mIntentExtras, d.mIntentExtras) &&
Tyler Gunnd081f042018-12-04 12:56:45 -08001021 Objects.equals(mCreationTimeMillis, d.mCreationTimeMillis) &&
Hall Liuef98bf82020-01-09 15:22:44 -08001022 Objects.equals(mContactDisplayName, d.mContactDisplayName) &&
Tyler Gunnd57d76c2019-09-24 14:53:23 -07001023 Objects.equals(mCallDirection, d.mCallDirection) &&
1024 Objects.equals(mCallerNumberVerificationStatus,
1025 d.mCallerNumberVerificationStatus);
Ihab Awade63fadb2014-07-09 21:52:04 -07001026 }
1027 return false;
1028 }
1029
1030 @Override
1031 public int hashCode() {
Tyler Gunnc0bf6de2017-03-17 11:27:09 -07001032 return Objects.hash(mHandle,
1033 mHandlePresentation,
1034 mCallerDisplayName,
1035 mCallerDisplayNamePresentation,
1036 mAccountHandle,
1037 mCallCapabilities,
1038 mCallProperties,
1039 mDisconnectCause,
1040 mConnectTimeMillis,
1041 mGatewayInfo,
1042 mVideoState,
1043 mStatusHints,
1044 mExtras,
1045 mIntentExtras,
Tyler Gunnd081f042018-12-04 12:56:45 -08001046 mCreationTimeMillis,
Hall Liuef98bf82020-01-09 15:22:44 -08001047 mContactDisplayName,
Tyler Gunnd57d76c2019-09-24 14:53:23 -07001048 mCallDirection,
1049 mCallerNumberVerificationStatus);
Ihab Awade63fadb2014-07-09 21:52:04 -07001050 }
1051
1052 /** {@hide} */
1053 public Details(
Sailesh Nepal1bef3392016-01-24 18:21:53 -08001054 String telecomCallId,
Ihab Awade63fadb2014-07-09 21:52:04 -07001055 Uri handle,
1056 int handlePresentation,
1057 String callerDisplayName,
1058 int callerDisplayNamePresentation,
Evan Charlton8c8a0622014-07-20 12:31:00 -07001059 PhoneAccountHandle accountHandle,
Ihab Awade63fadb2014-07-09 21:52:04 -07001060 int capabilities,
Andrew Lee223ad142014-08-27 16:33:08 -07001061 int properties,
Andrew Lee7f3d41f2014-09-11 17:33:16 -07001062 DisconnectCause disconnectCause,
Ihab Awade63fadb2014-07-09 21:52:04 -07001063 long connectTimeMillis,
Andrew Lee85f5d422014-07-11 17:22:03 -07001064 GatewayInfo gatewayInfo,
Evan Charlton5b49ade2014-07-15 17:03:20 -07001065 int videoState,
Nancy Chen10798dc2014-08-08 14:00:25 -07001066 StatusHints statusHints,
Santos Cordon6b7f9552015-05-27 17:21:45 -07001067 Bundle extras,
Tyler Gunnc0bf6de2017-03-17 11:27:09 -07001068 Bundle intentExtras,
Tyler Gunnd081f042018-12-04 12:56:45 -08001069 long creationTimeMillis,
Hall Liuef98bf82020-01-09 15:22:44 -08001070 String contactDisplayName,
Tyler Gunnd57d76c2019-09-24 14:53:23 -07001071 int callDirection,
1072 int callerNumberVerificationStatus) {
Sailesh Nepal1bef3392016-01-24 18:21:53 -08001073 mTelecomCallId = telecomCallId;
Ihab Awade63fadb2014-07-09 21:52:04 -07001074 mHandle = handle;
1075 mHandlePresentation = handlePresentation;
1076 mCallerDisplayName = callerDisplayName;
1077 mCallerDisplayNamePresentation = callerDisplayNamePresentation;
Evan Charlton8c8a0622014-07-20 12:31:00 -07001078 mAccountHandle = accountHandle;
Ihab Awad5d0410f2014-07-30 10:07:40 -07001079 mCallCapabilities = capabilities;
Andrew Lee223ad142014-08-27 16:33:08 -07001080 mCallProperties = properties;
Andrew Lee7f3d41f2014-09-11 17:33:16 -07001081 mDisconnectCause = disconnectCause;
Ihab Awade63fadb2014-07-09 21:52:04 -07001082 mConnectTimeMillis = connectTimeMillis;
1083 mGatewayInfo = gatewayInfo;
Andrew Lee85f5d422014-07-11 17:22:03 -07001084 mVideoState = videoState;
Evan Charlton5b49ade2014-07-15 17:03:20 -07001085 mStatusHints = statusHints;
Nancy Chen10798dc2014-08-08 14:00:25 -07001086 mExtras = extras;
Santos Cordon6b7f9552015-05-27 17:21:45 -07001087 mIntentExtras = intentExtras;
Tyler Gunnc0bf6de2017-03-17 11:27:09 -07001088 mCreationTimeMillis = creationTimeMillis;
Hall Liuef98bf82020-01-09 15:22:44 -08001089 mContactDisplayName = contactDisplayName;
Tyler Gunn94f8f112018-12-17 09:56:11 -08001090 mCallDirection = callDirection;
Tyler Gunnd57d76c2019-09-24 14:53:23 -07001091 mCallerNumberVerificationStatus = callerNumberVerificationStatus;
Ihab Awade63fadb2014-07-09 21:52:04 -07001092 }
Sailesh Nepal1bef3392016-01-24 18:21:53 -08001093
1094 /** {@hide} */
1095 public static Details createFromParcelableCall(ParcelableCall parcelableCall) {
1096 return new Details(
1097 parcelableCall.getId(),
1098 parcelableCall.getHandle(),
1099 parcelableCall.getHandlePresentation(),
1100 parcelableCall.getCallerDisplayName(),
1101 parcelableCall.getCallerDisplayNamePresentation(),
1102 parcelableCall.getAccountHandle(),
1103 parcelableCall.getCapabilities(),
1104 parcelableCall.getProperties(),
1105 parcelableCall.getDisconnectCause(),
1106 parcelableCall.getConnectTimeMillis(),
1107 parcelableCall.getGatewayInfo(),
1108 parcelableCall.getVideoState(),
1109 parcelableCall.getStatusHints(),
1110 parcelableCall.getExtras(),
Tyler Gunnc0bf6de2017-03-17 11:27:09 -07001111 parcelableCall.getIntentExtras(),
Tyler Gunnd081f042018-12-04 12:56:45 -08001112 parcelableCall.getCreationTimeMillis(),
Hall Liuef98bf82020-01-09 15:22:44 -08001113 parcelableCall.getContactDisplayName(),
Tyler Gunnd57d76c2019-09-24 14:53:23 -07001114 parcelableCall.getCallDirection(),
1115 parcelableCall.getCallerNumberVerificationStatus());
Sailesh Nepal1bef3392016-01-24 18:21:53 -08001116 }
Santos Cordon3c20d632016-02-25 16:12:35 -08001117
1118 @Override
1119 public String toString() {
1120 StringBuilder sb = new StringBuilder();
Tyler Gunn3cd820f2018-11-30 14:21:18 -08001121 sb.append("[id: ");
1122 sb.append(mTelecomCallId);
1123 sb.append(", pa: ");
Santos Cordon3c20d632016-02-25 16:12:35 -08001124 sb.append(mAccountHandle);
1125 sb.append(", hdl: ");
Tyler Gunn3cd820f2018-11-30 14:21:18 -08001126 sb.append(Log.piiHandle(mHandle));
1127 sb.append(", hdlPres: ");
1128 sb.append(mHandlePresentation);
1129 sb.append(", videoState: ");
1130 sb.append(VideoProfile.videoStateToString(mVideoState));
Santos Cordon3c20d632016-02-25 16:12:35 -08001131 sb.append(", caps: ");
1132 sb.append(capabilitiesToString(mCallCapabilities));
1133 sb.append(", props: ");
Tyler Gunn720c6642016-03-22 09:02:47 -07001134 sb.append(propertiesToString(mCallProperties));
Santos Cordon3c20d632016-02-25 16:12:35 -08001135 sb.append("]");
1136 return sb.toString();
1137 }
Ihab Awade63fadb2014-07-09 21:52:04 -07001138 }
1139
Tyler Gunn9c0eb0b2016-06-29 11:23:25 -07001140 /**
1141 * Defines callbacks which inform the {@link InCallService} of changes to a {@link Call}.
1142 * These callbacks can originate from the Telecom framework, or a {@link ConnectionService}
1143 * implementation.
1144 * <p>
1145 * You can handle these callbacks by extending the {@link Callback} class and overriding the
1146 * callbacks that your {@link InCallService} is interested in. The callback methods include the
1147 * {@link Call} for which the callback applies, allowing reuse of a single instance of your
1148 * {@link Callback} implementation, if desired.
1149 * <p>
1150 * Use {@link Call#registerCallback(Callback)} to register your callback(s). Ensure
1151 * {@link Call#unregisterCallback(Callback)} is called when you no longer require callbacks
1152 * (typically in {@link InCallService#onCallRemoved(Call)}).
1153 * Note: Callbacks which occur before you call {@link Call#registerCallback(Callback)} will not
1154 * reach your implementation of {@link Callback}, so it is important to register your callback
1155 * as soon as your {@link InCallService} is notified of a new call via
1156 * {@link InCallService#onCallAdded(Call)}.
1157 */
Andrew Leeda80c872015-04-15 14:09:50 -07001158 public static abstract class Callback {
Ihab Awade63fadb2014-07-09 21:52:04 -07001159 /**
Sanket Padawea8eddd42017-11-03 11:07:35 -07001160 * @hide
1161 */
Tyler Gunn9d127732018-03-02 15:45:51 -08001162 @IntDef(prefix = { "HANDOVER_" },
1163 value = {HANDOVER_FAILURE_DEST_APP_REJECTED, HANDOVER_FAILURE_NOT_SUPPORTED,
Tyler Gunn5c60d712018-03-16 09:53:44 -07001164 HANDOVER_FAILURE_USER_REJECTED, HANDOVER_FAILURE_ONGOING_EMERGENCY_CALL,
Tyler Gunn9d127732018-03-02 15:45:51 -08001165 HANDOVER_FAILURE_UNKNOWN})
Sanket Padawea8eddd42017-11-03 11:07:35 -07001166 @Retention(RetentionPolicy.SOURCE)
1167 public @interface HandoverFailureErrors {}
1168
1169 /**
1170 * Handover failure reason returned via {@link #onHandoverFailed(Call, int)} when the app
Tyler Gunn9d127732018-03-02 15:45:51 -08001171 * to handover the call to rejects the handover request.
1172 * <p>
1173 * Will be returned when {@link Call#handoverTo(PhoneAccountHandle, int, Bundle)} is called
1174 * and the destination {@link PhoneAccountHandle}'s {@link ConnectionService} returns a
1175 * {@code null} {@link Connection} from
1176 * {@link ConnectionService#onCreateOutgoingHandoverConnection(PhoneAccountHandle,
1177 * ConnectionRequest)}.
1178 * <p>
1179 * For more information on call handovers, see
1180 * {@link #handoverTo(PhoneAccountHandle, int, Bundle)}.
Sanket Padawea8eddd42017-11-03 11:07:35 -07001181 */
1182 public static final int HANDOVER_FAILURE_DEST_APP_REJECTED = 1;
1183
1184 /**
Tyler Gunn9d127732018-03-02 15:45:51 -08001185 * Handover failure reason returned via {@link #onHandoverFailed(Call, int)} when a handover
1186 * is initiated but the source or destination app does not support handover.
1187 * <p>
1188 * Will be returned when a handover is requested via
1189 * {@link #handoverTo(PhoneAccountHandle, int, Bundle)} and the destination
1190 * {@link PhoneAccountHandle} does not declare
1191 * {@link PhoneAccount#EXTRA_SUPPORTS_HANDOVER_TO}. May also be returned when a handover is
1192 * requested at the {@link PhoneAccountHandle} for the current call (i.e. the source call's
1193 * {@link Details#getAccountHandle()}) does not declare
1194 * {@link PhoneAccount#EXTRA_SUPPORTS_HANDOVER_FROM}.
1195 * <p>
1196 * For more information on call handovers, see
1197 * {@link #handoverTo(PhoneAccountHandle, int, Bundle)}.
Sanket Padawea8eddd42017-11-03 11:07:35 -07001198 */
Tyler Gunn9d127732018-03-02 15:45:51 -08001199 public static final int HANDOVER_FAILURE_NOT_SUPPORTED = 2;
Sanket Padawea8eddd42017-11-03 11:07:35 -07001200
1201 /**
Tyler Gunn9d127732018-03-02 15:45:51 -08001202 * Handover failure reason returned via {@link #onHandoverFailed(Call, int)} when the remote
1203 * user rejects the handover request.
1204 * <p>
1205 * For more information on call handovers, see
1206 * {@link #handoverTo(PhoneAccountHandle, int, Bundle)}.
Sanket Padawea8eddd42017-11-03 11:07:35 -07001207 */
Tyler Gunn9d127732018-03-02 15:45:51 -08001208 public static final int HANDOVER_FAILURE_USER_REJECTED = 3;
Sanket Padawea8eddd42017-11-03 11:07:35 -07001209
Sanket Padawe85291f62017-12-01 13:59:27 -08001210 /**
1211 * Handover failure reason returned via {@link #onHandoverFailed(Call, int)} when there
1212 * is ongoing emergency call.
Tyler Gunn9d127732018-03-02 15:45:51 -08001213 * <p>
1214 * This error code is returned when {@link #handoverTo(PhoneAccountHandle, int, Bundle)} is
1215 * called on an emergency call, or if any other call is an emergency call.
1216 * <p>
1217 * Handovers are not permitted while there are ongoing emergency calls.
1218 * <p>
1219 * For more information on call handovers, see
1220 * {@link #handoverTo(PhoneAccountHandle, int, Bundle)}.
Sanket Padawe85291f62017-12-01 13:59:27 -08001221 */
Tyler Gunn5c60d712018-03-16 09:53:44 -07001222 public static final int HANDOVER_FAILURE_ONGOING_EMERGENCY_CALL = 4;
Sanket Padawe85291f62017-12-01 13:59:27 -08001223
Tyler Gunn9d127732018-03-02 15:45:51 -08001224 /**
1225 * Handover failure reason returned via {@link #onHandoverFailed(Call, int)} when a handover
1226 * fails for an unknown reason.
1227 * <p>
1228 * For more information on call handovers, see
1229 * {@link #handoverTo(PhoneAccountHandle, int, Bundle)}.
1230 */
1231 public static final int HANDOVER_FAILURE_UNKNOWN = 5;
Sanket Padawea8eddd42017-11-03 11:07:35 -07001232
1233 /**
Ihab Awade63fadb2014-07-09 21:52:04 -07001234 * Invoked when the state of this {@code Call} has changed. See {@link #getState()}.
1235 *
Ihab Awade63fadb2014-07-09 21:52:04 -07001236 * @param call The {@code Call} invoking this method.
1237 * @param state The new state of the {@code Call}.
1238 */
1239 public void onStateChanged(Call call, int state) {}
1240
1241 /**
1242 * Invoked when the parent of this {@code Call} has changed. See {@link #getParent()}.
1243 *
1244 * @param call The {@code Call} invoking this method.
1245 * @param parent The new parent of the {@code Call}.
1246 */
1247 public void onParentChanged(Call call, Call parent) {}
1248
1249 /**
1250 * Invoked when the children of this {@code Call} have changed. See {@link #getChildren()}.
1251 *
1252 * @param call The {@code Call} invoking this method.
1253 * @param children The new children of the {@code Call}.
1254 */
1255 public void onChildrenChanged(Call call, List<Call> children) {}
1256
1257 /**
1258 * Invoked when the details of this {@code Call} have changed. See {@link #getDetails()}.
1259 *
1260 * @param call The {@code Call} invoking this method.
1261 * @param details A {@code Details} object describing the {@code Call}.
1262 */
1263 public void onDetailsChanged(Call call, Details details) {}
1264
1265 /**
1266 * Invoked when the text messages that can be used as responses to the incoming
1267 * {@code Call} are loaded from the relevant database.
1268 * See {@link #getCannedTextResponses()}.
1269 *
1270 * @param call The {@code Call} invoking this method.
1271 * @param cannedTextResponses The text messages useable as responses.
1272 */
1273 public void onCannedTextResponsesLoaded(Call call, List<String> cannedTextResponses) {}
1274
1275 /**
Ihab Awade63fadb2014-07-09 21:52:04 -07001276 * Invoked when the post-dial sequence in the outgoing {@code Call} has reached a pause
1277 * character. This causes the post-dial signals to stop pending user confirmation. An
1278 * implementation should present this choice to the user and invoke
1279 * {@link #postDialContinue(boolean)} when the user makes the choice.
1280 *
1281 * @param call The {@code Call} invoking this method.
1282 * @param remainingPostDialSequence The post-dial characters that remain to be sent.
1283 */
1284 public void onPostDialWait(Call call, String remainingPostDialSequence) {}
1285
1286 /**
Andrew Lee50aca232014-07-22 16:41:54 -07001287 * Invoked when the {@code Call.VideoCall} of the {@code Call} has changed.
Ihab Awade63fadb2014-07-09 21:52:04 -07001288 *
1289 * @param call The {@code Call} invoking this method.
Andrew Lee50aca232014-07-22 16:41:54 -07001290 * @param videoCall The {@code Call.VideoCall} associated with the {@code Call}.
Ihab Awade63fadb2014-07-09 21:52:04 -07001291 */
Andrew Lee50aca232014-07-22 16:41:54 -07001292 public void onVideoCallChanged(Call call, InCallService.VideoCall videoCall) {}
Ihab Awade63fadb2014-07-09 21:52:04 -07001293
1294 /**
1295 * Invoked when the {@code Call} is destroyed. Clients should refrain from cleaning
1296 * up their UI for the {@code Call} in response to state transitions. Specifically,
1297 * clients should not assume that a {@link #onStateChanged(Call, int)} with a state of
1298 * {@link #STATE_DISCONNECTED} is the final notification the {@code Call} will send. Rather,
1299 * clients should wait for this method to be invoked.
1300 *
1301 * @param call The {@code Call} being destroyed.
1302 */
1303 public void onCallDestroyed(Call call) {}
Santos Cordon7c7bc7f2014-07-28 18:15:48 -07001304
1305 /**
1306 * Invoked upon changes to the set of {@code Call}s with which this {@code Call} can be
1307 * conferenced.
1308 *
1309 * @param call The {@code Call} being updated.
1310 * @param conferenceableCalls The {@code Call}s with which this {@code Call} can be
1311 * conferenced.
1312 */
1313 public void onConferenceableCallsChanged(Call call, List<Call> conferenceableCalls) {}
Tyler Gunn876dbfb2016-03-14 15:18:07 -07001314
1315 /**
Tyler Gunn5567d742019-10-31 13:04:37 -07001316 * Invoked when a {@link Call} receives an event from its associated {@link Connection} or
1317 * {@link Conference}.
Tyler Gunn9c0eb0b2016-06-29 11:23:25 -07001318 * <p>
1319 * Where possible, the Call should make an attempt to handle {@link Connection} events which
1320 * are part of the {@code android.telecom.*} namespace. The Call should ignore any events
1321 * it does not wish to handle. Unexpected events should be handled gracefully, as it is
1322 * possible that a {@link ConnectionService} has defined its own Connection events which a
1323 * Call is not aware of.
Tyler Gunn876dbfb2016-03-14 15:18:07 -07001324 * <p>
Tyler Gunn5567d742019-10-31 13:04:37 -07001325 * See {@link Connection#sendConnectionEvent(String, Bundle)},
1326 * {@link Conference#sendConferenceEvent(String, Bundle)}.
Tyler Gunn876dbfb2016-03-14 15:18:07 -07001327 *
1328 * @param call The {@code Call} receiving the event.
1329 * @param event The event.
1330 * @param extras Extras associated with the connection event.
1331 */
1332 public void onConnectionEvent(Call call, String event, Bundle extras) {}
Hall Liu95d55872017-01-25 17:12:49 -08001333
1334 /**
1335 * Invoked when the RTT mode changes for this call.
1336 * @param call The call whose RTT mode has changed.
1337 * @param mode the new RTT mode, one of
1338 * {@link RttCall#RTT_MODE_FULL}, {@link RttCall#RTT_MODE_HCO},
1339 * or {@link RttCall#RTT_MODE_VCO}
1340 */
1341 public void onRttModeChanged(Call call, int mode) {}
1342
1343 /**
1344 * Invoked when the call's RTT status changes, either from off to on or from on to off.
1345 * @param call The call whose RTT status has changed.
1346 * @param enabled whether RTT is now enabled or disabled
1347 * @param rttCall the {@link RttCall} object to use for reading and writing if RTT is now
1348 * on, null otherwise.
1349 */
1350 public void onRttStatusChanged(Call call, boolean enabled, RttCall rttCall) {}
1351
1352 /**
1353 * Invoked when the remote end of the connection has requested that an RTT communication
1354 * channel be opened. A response to this should be sent via {@link #respondToRttRequest}
1355 * with the same ID that this method is invoked with.
1356 * @param call The call which the RTT request was placed on
1357 * @param id The ID of the request.
1358 */
1359 public void onRttRequest(Call call, int id) {}
Hall Liu57006aa2017-02-06 10:49:48 -08001360
1361 /**
1362 * Invoked when the RTT session failed to initiate for some reason, including rejection
1363 * by the remote party.
1364 * @param call The call which the RTT initiation failure occurred on.
1365 * @param reason One of the status codes defined in
1366 * {@link android.telecom.Connection.RttModifyStatus}, with the exception of
1367 * {@link android.telecom.Connection.RttModifyStatus#SESSION_MODIFY_REQUEST_SUCCESS}.
1368 */
1369 public void onRttInitiationFailure(Call call, int reason) {}
Sanket Padawea8eddd42017-11-03 11:07:35 -07001370
1371 /**
1372 * Invoked when Call handover from one {@link PhoneAccount} to other {@link PhoneAccount}
1373 * has completed successfully.
Tyler Gunn9d127732018-03-02 15:45:51 -08001374 * <p>
1375 * For a full discussion of the handover process and the APIs involved, see
1376 * {@link android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle)}.
1377 *
Sanket Padawea8eddd42017-11-03 11:07:35 -07001378 * @param call The call which had initiated handover.
1379 */
1380 public void onHandoverComplete(Call call) {}
1381
1382 /**
1383 * Invoked when Call handover from one {@link PhoneAccount} to other {@link PhoneAccount}
1384 * has failed.
Tyler Gunn9d127732018-03-02 15:45:51 -08001385 * <p>
1386 * For a full discussion of the handover process and the APIs involved, see
1387 * {@link android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle)}.
1388 *
Sanket Padawea8eddd42017-11-03 11:07:35 -07001389 * @param call The call which had initiated handover.
Tyler Gunn9d127732018-03-02 15:45:51 -08001390 * @param failureReason Error reason for failure.
Sanket Padawea8eddd42017-11-03 11:07:35 -07001391 */
1392 public void onHandoverFailed(Call call, @HandoverFailureErrors int failureReason) {}
Hall Liu95d55872017-01-25 17:12:49 -08001393 }
1394
1395 /**
1396 * A class that holds the state that describes the state of the RTT channel to the remote
1397 * party, if it is active.
1398 */
1399 public static final class RttCall {
Hall Liu07094df2017-02-28 15:17:44 -08001400 /** @hide */
Hall Liu95d55872017-01-25 17:12:49 -08001401 @Retention(RetentionPolicy.SOURCE)
1402 @IntDef({RTT_MODE_INVALID, RTT_MODE_FULL, RTT_MODE_HCO, RTT_MODE_VCO})
1403 public @interface RttAudioMode {}
1404
1405 /**
1406 * For metrics use. Default value in the proto.
1407 * @hide
1408 */
1409 public static final int RTT_MODE_INVALID = 0;
1410
1411 /**
1412 * Indicates that there should be a bidirectional audio stream between the two parties
1413 * on the call.
1414 */
1415 public static final int RTT_MODE_FULL = 1;
1416
1417 /**
1418 * Indicates that the local user should be able to hear the audio stream from the remote
1419 * user, but not vice versa. Equivalent to muting the microphone.
1420 */
1421 public static final int RTT_MODE_HCO = 2;
1422
1423 /**
1424 * Indicates that the remote user should be able to hear the audio stream from the local
1425 * user, but not vice versa. Equivalent to setting the volume to zero.
1426 */
1427 public static final int RTT_MODE_VCO = 3;
1428
1429 private static final int READ_BUFFER_SIZE = 1000;
1430
1431 private InputStreamReader mReceiveStream;
1432 private OutputStreamWriter mTransmitStream;
1433 private int mRttMode;
1434 private final InCallAdapter mInCallAdapter;
Hall Liu57006aa2017-02-06 10:49:48 -08001435 private final String mTelecomCallId;
Hall Liu95d55872017-01-25 17:12:49 -08001436 private char[] mReadBuffer = new char[READ_BUFFER_SIZE];
1437
1438 /**
1439 * @hide
1440 */
Hall Liu57006aa2017-02-06 10:49:48 -08001441 public RttCall(String telecomCallId, InputStreamReader receiveStream,
1442 OutputStreamWriter transmitStream, int mode, InCallAdapter inCallAdapter) {
1443 mTelecomCallId = telecomCallId;
Hall Liu95d55872017-01-25 17:12:49 -08001444 mReceiveStream = receiveStream;
1445 mTransmitStream = transmitStream;
1446 mRttMode = mode;
1447 mInCallAdapter = inCallAdapter;
1448 }
1449
1450 /**
1451 * Returns the current RTT audio mode.
1452 * @return Current RTT audio mode. One of {@link #RTT_MODE_FULL}, {@link #RTT_MODE_VCO}, or
1453 * {@link #RTT_MODE_HCO}.
1454 */
1455 public int getRttAudioMode() {
1456 return mRttMode;
1457 }
1458
1459 /**
1460 * Sets the RTT audio mode. The requested mode change will be communicated through
1461 * {@link Callback#onRttModeChanged(Call, int)}.
1462 * @param mode The desired RTT audio mode, one of {@link #RTT_MODE_FULL},
1463 * {@link #RTT_MODE_VCO}, or {@link #RTT_MODE_HCO}.
1464 */
1465 public void setRttMode(@RttAudioMode int mode) {
Hall Liu57006aa2017-02-06 10:49:48 -08001466 mInCallAdapter.setRttMode(mTelecomCallId, mode);
Hall Liu95d55872017-01-25 17:12:49 -08001467 }
1468
1469 /**
1470 * Writes the string {@param input} into the outgoing text stream for this RTT call. Since
Hall Liudc46c852020-10-29 16:15:33 -07001471 * RTT transmits text in real-time, this method should be called once for each user action.
1472 * For example, when the user enters text as discrete characters using the keyboard, this
1473 * method should be called once for each character. However, if the user enters text by
1474 * pasting or autocomplete, the entire contents of the pasted or autocompleted text should
1475 * be sent in one call to this method.
Hall Liu95d55872017-01-25 17:12:49 -08001476 *
1477 * This method is not thread-safe -- calling it from multiple threads simultaneously may
1478 * lead to interleaved text.
1479 * @param input The message to send to the remote user.
1480 */
1481 public void write(String input) throws IOException {
1482 mTransmitStream.write(input);
1483 mTransmitStream.flush();
1484 }
1485
1486 /**
1487 * Reads a string from the remote user, blocking if there is no data available. Returns
1488 * {@code null} if the RTT conversation has been terminated and there is no further data
1489 * to read.
1490 *
1491 * This method is not thread-safe -- calling it from multiple threads simultaneously may
1492 * lead to interleaved text.
1493 * @return A string containing text sent by the remote user, or {@code null} if the
1494 * conversation has been terminated or if there was an error while reading.
1495 */
Hall Liub1c8a772017-07-17 17:04:41 -07001496 public String read() {
1497 try {
1498 int numRead = mReceiveStream.read(mReadBuffer, 0, READ_BUFFER_SIZE);
1499 if (numRead < 0) {
1500 return null;
1501 }
1502 return new String(mReadBuffer, 0, numRead);
1503 } catch (IOException e) {
1504 Log.w(this, "Exception encountered when reading from InputStreamReader: %s", e);
Jeff Sharkey90396362017-06-12 16:26:53 -06001505 return null;
Hall Liuffa4a812017-03-02 16:11:00 -08001506 }
Hall Liuffa4a812017-03-02 16:11:00 -08001507 }
1508
1509 /**
1510 * Non-blocking version of {@link #read()}. Returns {@code null} if there is nothing to
1511 * be read.
1512 * @return A string containing text entered by the user, or {@code null} if the user has
1513 * not entered any new text yet.
1514 */
1515 public String readImmediately() throws IOException {
1516 if (mReceiveStream.ready()) {
Hall Liub1c8a772017-07-17 17:04:41 -07001517 int numRead = mReceiveStream.read(mReadBuffer, 0, READ_BUFFER_SIZE);
1518 if (numRead < 0) {
1519 return null;
1520 }
1521 return new String(mReadBuffer, 0, numRead);
Hall Liuffa4a812017-03-02 16:11:00 -08001522 } else {
Hall Liu95d55872017-01-25 17:12:49 -08001523 return null;
1524 }
1525 }
Hall Liue9041242018-02-09 16:40:03 -08001526
1527 /**
1528 * Closes the underlying file descriptors
1529 * @hide
1530 */
1531 public void close() {
1532 try {
1533 mReceiveStream.close();
1534 } catch (IOException e) {
1535 // ignore
1536 }
1537 try {
1538 mTransmitStream.close();
1539 } catch (IOException e) {
1540 // ignore
1541 }
1542 }
Ihab Awade63fadb2014-07-09 21:52:04 -07001543 }
1544
Andrew Leeda80c872015-04-15 14:09:50 -07001545 /**
1546 * @deprecated Use {@code Call.Callback} instead.
1547 * @hide
1548 */
1549 @Deprecated
1550 @SystemApi
1551 public static abstract class Listener extends Callback { }
1552
Ihab Awade63fadb2014-07-09 21:52:04 -07001553 private final Phone mPhone;
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001554 private final String mTelecomCallId;
Ihab Awade63fadb2014-07-09 21:52:04 -07001555 private final InCallAdapter mInCallAdapter;
Santos Cordon823fd3c2014-08-07 18:35:18 -07001556 private final List<String> mChildrenIds = new ArrayList<>();
Ihab Awade63fadb2014-07-09 21:52:04 -07001557 private final List<Call> mChildren = new ArrayList<>();
1558 private final List<Call> mUnmodifiableChildren = Collections.unmodifiableList(mChildren);
Andrew Lee011728f2015-04-23 15:47:06 -07001559 private final List<CallbackRecord<Callback>> mCallbackRecords = new CopyOnWriteArrayList<>();
Santos Cordon7c7bc7f2014-07-28 18:15:48 -07001560 private final List<Call> mConferenceableCalls = new ArrayList<>();
1561 private final List<Call> mUnmodifiableConferenceableCalls =
1562 Collections.unmodifiableList(mConferenceableCalls);
1563
Santos Cordon823fd3c2014-08-07 18:35:18 -07001564 private boolean mChildrenCached;
1565 private String mParentId = null;
Hall Liuef98bf82020-01-09 15:22:44 -08001566 private String mActiveGenericConferenceChild = null;
Santos Cordon7c7bc7f2014-07-28 18:15:48 -07001567 private int mState;
Ihab Awade63fadb2014-07-09 21:52:04 -07001568 private List<String> mCannedTextResponses = null;
Tyler Gunnb88b3112016-11-09 10:19:23 -08001569 private String mCallingPackage;
Tyler Gunn159f35c2017-03-02 09:28:37 -08001570 private int mTargetSdkVersion;
Ihab Awade63fadb2014-07-09 21:52:04 -07001571 private String mRemainingPostDialSequence;
Tyler Gunn584ba6c2015-12-08 10:53:41 -08001572 private VideoCallImpl mVideoCallImpl;
Hall Liu95d55872017-01-25 17:12:49 -08001573 private RttCall mRttCall;
Ihab Awade63fadb2014-07-09 21:52:04 -07001574 private Details mDetails;
Tyler Gunndee56a82016-03-23 16:06:34 -07001575 private Bundle mExtras;
Ihab Awade63fadb2014-07-09 21:52:04 -07001576
1577 /**
1578 * Obtains the post-dial sequence remaining to be emitted by this {@code Call}, if any.
1579 *
1580 * @return The remaining post-dial sequence, or {@code null} if there is no post-dial sequence
1581 * remaining or this {@code Call} is not in a post-dial state.
1582 */
1583 public String getRemainingPostDialSequence() {
1584 return mRemainingPostDialSequence;
1585 }
1586
1587 /**
1588 * Instructs this {@link #STATE_RINGING} {@code Call} to answer.
Andrew Lee8da4c3c2014-07-16 10:11:42 -07001589 * @param videoState The video state in which to answer the call.
Ihab Awade63fadb2014-07-09 21:52:04 -07001590 */
Tyler Gunn9d127732018-03-02 15:45:51 -08001591 public void answer(@VideoProfile.VideoState int videoState) {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001592 mInCallAdapter.answerCall(mTelecomCallId, videoState);
Ihab Awade63fadb2014-07-09 21:52:04 -07001593 }
1594
1595 /**
Pooja Jaind34698d2017-12-28 14:15:31 +05301596 * Instructs this {@link #STATE_RINGING} {@code Call} to deflect.
1597 *
1598 * @param address The address to which the call will be deflected.
1599 */
1600 public void deflect(Uri address) {
1601 mInCallAdapter.deflectCall(mTelecomCallId, address);
1602 }
1603
1604 /**
Ihab Awade63fadb2014-07-09 21:52:04 -07001605 * Instructs this {@link #STATE_RINGING} {@code Call} to reject.
1606 *
1607 * @param rejectWithMessage Whether to reject with a text message.
1608 * @param textMessage An optional text message with which to respond.
1609 */
1610 public void reject(boolean rejectWithMessage, String textMessage) {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001611 mInCallAdapter.rejectCall(mTelecomCallId, rejectWithMessage, textMessage);
Ihab Awade63fadb2014-07-09 21:52:04 -07001612 }
1613
1614 /**
Tyler Gunnfacfdee2020-01-23 13:10:37 -08001615 * Instructs the {@link ConnectionService} providing this {@link #STATE_RINGING} call that the
1616 * user has chosen to reject the call and has indicated a reason why the call is being rejected.
1617 *
1618 * @param rejectReason the reason the call is being rejected.
1619 */
1620 public void reject(@RejectReason int rejectReason) {
1621 mInCallAdapter.rejectCall(mTelecomCallId, rejectReason);
1622 }
1623
1624 /**
Ravi Palurif4b38e72020-02-05 12:35:41 +05301625 * Instructs this {@code Call} to be transferred to another number.
1626 *
1627 * @param targetNumber The address to which the call will be transferred.
Tyler Gunn460360d2020-07-29 10:21:45 -07001628 * @param isConfirmationRequired if {@code true} it will initiate a confirmed transfer,
1629 * if {@code false}, it will initiate an unconfirmed transfer.
Ravi Palurif4b38e72020-02-05 12:35:41 +05301630 *
1631 * @hide
1632 */
1633 public void transfer(@NonNull Uri targetNumber, boolean isConfirmationRequired) {
1634 mInCallAdapter.transferCall(mTelecomCallId, targetNumber, isConfirmationRequired);
1635 }
1636
1637 /**
1638 * Instructs this {@code Call} to be transferred to another ongoing call.
1639 * This will initiate CONSULTATIVE transfer.
1640 * @param toCall The other ongoing {@code Call} to which this call will be transferred.
1641 *
1642 * @hide
1643 */
1644 public void transfer(@NonNull android.telecom.Call toCall) {
1645 mInCallAdapter.transferCall(mTelecomCallId, toCall.mTelecomCallId);
1646 }
1647
1648 /**
Ihab Awade63fadb2014-07-09 21:52:04 -07001649 * Instructs this {@code Call} to disconnect.
1650 */
1651 public void disconnect() {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001652 mInCallAdapter.disconnectCall(mTelecomCallId);
Ihab Awade63fadb2014-07-09 21:52:04 -07001653 }
1654
1655 /**
1656 * Instructs this {@code Call} to go on hold.
1657 */
1658 public void hold() {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001659 mInCallAdapter.holdCall(mTelecomCallId);
Ihab Awade63fadb2014-07-09 21:52:04 -07001660 }
1661
1662 /**
1663 * Instructs this {@link #STATE_HOLDING} call to release from hold.
1664 */
1665 public void unhold() {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001666 mInCallAdapter.unholdCall(mTelecomCallId);
Ihab Awade63fadb2014-07-09 21:52:04 -07001667 }
1668
1669 /**
Hall Liu6dfa2492019-10-01 17:20:39 -07001670 * Instructs Telecom to put the call into the background audio processing state.
Tyler Gunn460b7d42020-05-15 10:19:32 -07001671 * <p>
Hall Liu6dfa2492019-10-01 17:20:39 -07001672 * This method can be called either when the call is in {@link #STATE_RINGING} or
1673 * {@link #STATE_ACTIVE}. After Telecom acknowledges the request by setting the call's state to
1674 * {@link #STATE_AUDIO_PROCESSING}, your app may setup the audio paths with the audio stack in
1675 * order to capture and play audio on the call stream.
Tyler Gunn460b7d42020-05-15 10:19:32 -07001676 * <p>
Hall Liu6dfa2492019-10-01 17:20:39 -07001677 * This method can only be called by the default dialer app.
Tyler Gunn460b7d42020-05-15 10:19:32 -07001678 * <p>
1679 * Apps built with SDK version {@link android.os.Build.VERSION_CODES#R} or later which are using
1680 * the microphone as part of audio processing should specify the foreground service type using
1681 * the attribute {@link android.R.attr#foregroundServiceType} in the {@link InCallService}
1682 * service element of the app's manifest file.
1683 * The {@link ServiceInfo#FOREGROUND_SERVICE_TYPE_MICROPHONE} attribute should be specified.
1684 * @see <a href="https://developer.android.com/preview/privacy/foreground-service-types">
1685 * the Android Developer Site</a> for more information.
Hall Liu6dfa2492019-10-01 17:20:39 -07001686 * @hide
1687 */
1688 @SystemApi
Hall Liu6dfa2492019-10-01 17:20:39 -07001689 public void enterBackgroundAudioProcessing() {
1690 if (mState != STATE_ACTIVE && mState != STATE_RINGING) {
1691 throw new IllegalStateException("Call must be active or ringing");
1692 }
1693 mInCallAdapter.enterBackgroundAudioProcessing(mTelecomCallId);
1694 }
1695
1696 /**
1697 * Instructs Telecom to come out of the background audio processing state requested by
1698 * {@link #enterBackgroundAudioProcessing()} or from the call screening service.
1699 *
1700 * This method can only be called when the call is in {@link #STATE_AUDIO_PROCESSING}.
1701 *
1702 * @param shouldRing If true, Telecom will put the call into the
1703 * {@link #STATE_SIMULATED_RINGING} state and notify other apps that there is
1704 * a ringing call. Otherwise, the call will go into {@link #STATE_ACTIVE}
1705 * immediately.
1706 * @hide
1707 */
1708 @SystemApi
Hall Liu6dfa2492019-10-01 17:20:39 -07001709 public void exitBackgroundAudioProcessing(boolean shouldRing) {
1710 if (mState != STATE_AUDIO_PROCESSING) {
1711 throw new IllegalStateException("Call must in the audio processing state");
1712 }
1713 mInCallAdapter.exitBackgroundAudioProcessing(mTelecomCallId, shouldRing);
1714 }
1715
1716 /**
Ihab Awade63fadb2014-07-09 21:52:04 -07001717 * Instructs this {@code Call} to play a dual-tone multi-frequency signaling (DTMF) tone.
1718 *
1719 * Any other currently playing DTMF tone in the specified call is immediately stopped.
1720 *
1721 * @param digit A character representing the DTMF digit for which to play the tone. This
1722 * value must be one of {@code '0'} through {@code '9'}, {@code '*'} or {@code '#'}.
1723 */
1724 public void playDtmfTone(char digit) {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001725 mInCallAdapter.playDtmfTone(mTelecomCallId, digit);
Ihab Awade63fadb2014-07-09 21:52:04 -07001726 }
1727
1728 /**
1729 * Instructs this {@code Call} to stop any dual-tone multi-frequency signaling (DTMF) tone
1730 * currently playing.
1731 *
1732 * DTMF tones are played by calling {@link #playDtmfTone(char)}. If no DTMF tone is
1733 * currently playing, this method will do nothing.
1734 */
1735 public void stopDtmfTone() {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001736 mInCallAdapter.stopDtmfTone(mTelecomCallId);
Ihab Awade63fadb2014-07-09 21:52:04 -07001737 }
1738
1739 /**
1740 * Instructs this {@code Call} to continue playing a post-dial DTMF string.
1741 *
1742 * A post-dial DTMF string is a string of digits entered after a phone number, when dialed,
1743 * that are immediately sent as DTMF tones to the recipient as soon as the connection is made.
Ihab Awade63fadb2014-07-09 21:52:04 -07001744 *
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001745 * If the DTMF string contains a {@link TelecomManager#DTMF_CHARACTER_PAUSE} symbol, this
Ihab Awade63fadb2014-07-09 21:52:04 -07001746 * {@code Call} will temporarily pause playing the tones for a pre-defined period of time.
1747 *
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001748 * If the DTMF string contains a {@link TelecomManager#DTMF_CHARACTER_WAIT} symbol, this
Andrew Leeda80c872015-04-15 14:09:50 -07001749 * {@code Call} will pause playing the tones and notify callbacks via
1750 * {@link Callback#onPostDialWait(Call, String)}. At this point, the in-call app
Ihab Awade63fadb2014-07-09 21:52:04 -07001751 * should display to the user an indication of this state and an affordance to continue
1752 * the postdial sequence. When the user decides to continue the postdial sequence, the in-call
1753 * app should invoke the {@link #postDialContinue(boolean)} method.
1754 *
1755 * @param proceed Whether or not to continue with the post-dial sequence.
1756 */
1757 public void postDialContinue(boolean proceed) {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001758 mInCallAdapter.postDialContinue(mTelecomCallId, proceed);
Ihab Awade63fadb2014-07-09 21:52:04 -07001759 }
1760
1761 /**
Evan Charlton8c8a0622014-07-20 12:31:00 -07001762 * Notifies this {@code Call} that an account has been selected and to proceed with placing
Nancy Chen36c62f32014-10-21 18:36:39 -07001763 * an outgoing call. Optionally sets this account as the default account.
Nancy Chen5da0fd52014-07-08 14:16:17 -07001764 */
Nancy Chen36c62f32014-10-21 18:36:39 -07001765 public void phoneAccountSelected(PhoneAccountHandle accountHandle, boolean setDefault) {
1766 mInCallAdapter.phoneAccountSelected(mTelecomCallId, accountHandle, setDefault);
Nancy Chen5da0fd52014-07-08 14:16:17 -07001767
1768 }
1769
1770 /**
Ihab Awade63fadb2014-07-09 21:52:04 -07001771 * Instructs this {@code Call} to enter a conference.
Santos Cordon7c7bc7f2014-07-28 18:15:48 -07001772 *
1773 * @param callToConferenceWith The other call with which to conference.
Ihab Awade63fadb2014-07-09 21:52:04 -07001774 */
Santos Cordon7c7bc7f2014-07-28 18:15:48 -07001775 public void conference(Call callToConferenceWith) {
1776 if (callToConferenceWith != null) {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001777 mInCallAdapter.conference(mTelecomCallId, callToConferenceWith.mTelecomCallId);
Santos Cordon7c7bc7f2014-07-28 18:15:48 -07001778 }
Ihab Awade63fadb2014-07-09 21:52:04 -07001779 }
1780
1781 /**
1782 * Instructs this {@code Call} to split from any conference call with which it may be
1783 * connected.
1784 */
1785 public void splitFromConference() {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001786 mInCallAdapter.splitFromConference(mTelecomCallId);
Ihab Awade63fadb2014-07-09 21:52:04 -07001787 }
1788
1789 /**
Ihab Awad5c9c86e2014-11-12 13:41:16 -08001790 * Merges the calls within this conference. See {@link Details#CAPABILITY_MERGE_CONFERENCE}.
Santos Cordona4868042014-09-04 17:39:22 -07001791 */
1792 public void mergeConference() {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001793 mInCallAdapter.mergeConference(mTelecomCallId);
Santos Cordona4868042014-09-04 17:39:22 -07001794 }
1795
1796 /**
Ihab Awad5c9c86e2014-11-12 13:41:16 -08001797 * Swaps the calls within this conference. See {@link Details#CAPABILITY_SWAP_CONFERENCE}.
Santos Cordona4868042014-09-04 17:39:22 -07001798 */
1799 public void swapConference() {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001800 mInCallAdapter.swapConference(mTelecomCallId);
Santos Cordona4868042014-09-04 17:39:22 -07001801 }
1802
1803 /**
Ravi Paluri404babb2020-01-23 19:02:44 +05301804 * Pulls participants to existing call by forming a conference call.
1805 * See {@link Details#CAPABILITY_ADD_PARTICIPANT}.
1806 *
1807 * @param participants participants to be pulled to existing call.
1808 */
1809 public void addConferenceParticipants(@NonNull List<Uri> participants) {
1810 mInCallAdapter.addConferenceParticipants(mTelecomCallId, participants);
1811 }
1812
1813 /**
Tyler Gunn876dbfb2016-03-14 15:18:07 -07001814 * Initiates a request to the {@link ConnectionService} to pull an external call to the local
1815 * device.
1816 * <p>
1817 * Calls to this method are ignored if the call does not have the
1818 * {@link Call.Details#PROPERTY_IS_EXTERNAL_CALL} property set.
1819 * <p>
1820 * An {@link InCallService} will only see calls which support this method if it has the
1821 * {@link TelecomManager#METADATA_INCLUDE_EXTERNAL_CALLS} metadata set to {@code true}
1822 * in its manifest.
1823 */
1824 public void pullExternalCall() {
1825 // If this isn't an external call, ignore the request.
1826 if (!mDetails.hasProperty(Details.PROPERTY_IS_EXTERNAL_CALL)) {
1827 return;
1828 }
1829
1830 mInCallAdapter.pullExternalCall(mTelecomCallId);
1831 }
1832
1833 /**
1834 * Sends a {@code Call} event from this {@code Call} to the associated {@link Connection} in
1835 * the {@link ConnectionService}.
1836 * <p>
Tyler Gunn9c0eb0b2016-06-29 11:23:25 -07001837 * Call events are used to communicate point in time information from an {@link InCallService}
1838 * to a {@link ConnectionService}. A {@link ConnectionService} implementation could define
1839 * events which enable the {@link InCallService}, for example, toggle a unique feature of the
1840 * {@link ConnectionService}.
1841 * <p>
1842 * A {@link ConnectionService} can communicate to the {@link InCallService} using
1843 * {@link Connection#sendConnectionEvent(String, Bundle)}.
1844 * <p>
Tyler Gunn876dbfb2016-03-14 15:18:07 -07001845 * Events are exposed to {@link ConnectionService} implementations via
1846 * {@link android.telecom.Connection#onCallEvent(String, Bundle)}.
1847 * <p>
1848 * No assumptions should be made as to how a {@link ConnectionService} will handle these events.
Tyler Gunn9c0eb0b2016-06-29 11:23:25 -07001849 * The {@link InCallService} must assume that the {@link ConnectionService} could chose to
1850 * ignore some events altogether.
1851 * <p>
1852 * Events should be fully qualified (e.g., {@code com.example.event.MY_EVENT}) to avoid
1853 * conflicts between {@link InCallService} implementations. Further, {@link InCallService}
1854 * implementations shall not re-purpose events in the {@code android.*} namespace, nor shall
1855 * they define their own event types in this namespace. When defining a custom event type,
1856 * ensure the contents of the extras {@link Bundle} is clearly defined. Extra keys for this
1857 * bundle should be named similar to the event type (e.g. {@code com.example.extra.MY_EXTRA}).
1858 * <p>
1859 * When defining events and the associated extras, it is important to keep their behavior
1860 * consistent when the associated {@link InCallService} is updated. Support for deprecated
1861 * events/extras should me maintained to ensure backwards compatibility with older
1862 * {@link ConnectionService} implementations which were built to support the older behavior.
Tyler Gunn876dbfb2016-03-14 15:18:07 -07001863 *
1864 * @param event The connection event.
1865 * @param extras Bundle containing extra information associated with the event.
1866 */
1867 public void sendCallEvent(String event, Bundle extras) {
Sanket Padawef6a9e5b2018-01-05 14:26:16 -08001868 mInCallAdapter.sendCallEvent(mTelecomCallId, event, mTargetSdkVersion, extras);
Tyler Gunn876dbfb2016-03-14 15:18:07 -07001869 }
1870
1871 /**
Hall Liu95d55872017-01-25 17:12:49 -08001872 * Sends an RTT upgrade request to the remote end of the connection. Success is not
1873 * guaranteed, and notification of success will be via the
1874 * {@link Callback#onRttStatusChanged(Call, boolean, RttCall)} callback.
1875 */
1876 public void sendRttRequest() {
Hall Liu57006aa2017-02-06 10:49:48 -08001877 mInCallAdapter.sendRttRequest(mTelecomCallId);
Hall Liu95d55872017-01-25 17:12:49 -08001878 }
1879
1880 /**
1881 * Responds to an RTT request received via the {@link Callback#onRttRequest(Call, int)} )}
1882 * callback.
1883 * The ID used here should be the same as the ID that was received via the callback.
1884 * @param id The request ID received via {@link Callback#onRttRequest(Call, int)}
1885 * @param accept {@code true} if the RTT request should be accepted, {@code false} otherwise.
1886 */
1887 public void respondToRttRequest(int id, boolean accept) {
Hall Liu57006aa2017-02-06 10:49:48 -08001888 mInCallAdapter.respondToRttRequest(mTelecomCallId, id, accept);
Hall Liu95d55872017-01-25 17:12:49 -08001889 }
1890
1891 /**
Sanket Padawea8eddd42017-11-03 11:07:35 -07001892 * Initiates a handover of this {@link Call} to the {@link ConnectionService} identified
1893 * by {@code toHandle}. The videoState specified indicates the desired video state after the
1894 * handover.
1895 * <p>
Tyler Gunn9d127732018-03-02 15:45:51 -08001896 * A call handover is the process where an ongoing call is transferred from one app (i.e.
1897 * {@link ConnectionService} to another app. The user could, for example, choose to continue a
1898 * mobile network call in a video calling app. The mobile network call via the Telephony stack
1899 * is referred to as the source of the handover, and the video calling app is referred to as the
1900 * destination.
1901 * <p>
1902 * When considering a handover scenario the device this method is called on is considered the
1903 * <em>initiating</em> device (since the user initiates the handover from this device), and the
1904 * other device is considered the <em>receiving</em> device.
1905 * <p>
1906 * When this method is called on the <em>initiating</em> device, the Telecom framework will bind
1907 * to the {@link ConnectionService} defined by the {@code toHandle} {@link PhoneAccountHandle}
1908 * and invoke
1909 * {@link ConnectionService#onCreateOutgoingHandoverConnection(PhoneAccountHandle,
1910 * ConnectionRequest)} to inform the destination app that a request has been made to handover a
1911 * call to it. The app returns an instance of {@link Connection} to represent the handover call
1912 * At this point the app should display UI to indicate to the user that a call
1913 * handover is in process.
1914 * <p>
1915 * The destination app is responsible for communicating the handover request from the
1916 * <em>initiating</em> device to the <em>receiving</em> device.
1917 * <p>
1918 * When the app on the <em>receiving</em> device receives the handover request, it calls
1919 * {@link TelecomManager#acceptHandover(Uri, int, PhoneAccountHandle)} to continue the handover
1920 * process from the <em>initiating</em> device to the <em>receiving</em> device. At this point
1921 * the destination app on the <em>receiving</em> device should show UI to allow the user to
1922 * choose whether they want to continue their call in the destination app.
1923 * <p>
1924 * When the destination app on the <em>receiving</em> device calls
1925 * {@link TelecomManager#acceptHandover(Uri, int, PhoneAccountHandle)}, Telecom will bind to its
1926 * {@link ConnectionService} and call
1927 * {@link ConnectionService#onCreateIncomingHandoverConnection(PhoneAccountHandle,
1928 * ConnectionRequest)} to inform it of the handover request. The app returns an instance of
1929 * {@link Connection} to represent the handover call.
1930 * <p>
1931 * If the user of the <em>receiving</em> device accepts the handover, the app calls
1932 * {@link Connection#setActive()} to complete the handover process; Telecom will disconnect the
1933 * original call. If the user rejects the handover, the app calls
1934 * {@link Connection#setDisconnected(DisconnectCause)} and specifies a {@link DisconnectCause}
1935 * of {@link DisconnectCause#CANCELED} to indicate that the handover has been cancelled.
1936 * <p>
1937 * Telecom will only allow handovers from {@link PhoneAccount}s which declare
1938 * {@link PhoneAccount#EXTRA_SUPPORTS_HANDOVER_FROM}. Similarly, the {@link PhoneAccount}
1939 * specified by {@code toHandle} must declare {@link PhoneAccount#EXTRA_SUPPORTS_HANDOVER_TO}.
1940 * <p>
1941 * Errors in the handover process are reported to the {@link InCallService} via
1942 * {@link Callback#onHandoverFailed(Call, int)}. Errors in the handover process are reported to
1943 * the involved {@link ConnectionService}s via
1944 * {@link ConnectionService#onHandoverFailed(ConnectionRequest, int)}.
Sanket Padawea8eddd42017-11-03 11:07:35 -07001945 *
1946 * @param toHandle {@link PhoneAccountHandle} of the {@link ConnectionService} to handover
1947 * this call to.
Tyler Gunn9d127732018-03-02 15:45:51 -08001948 * @param videoState Indicates the video state desired after the handover (see the
1949 * {@code STATE_*} constants defined in {@link VideoProfile}).
Sanket Padawea8eddd42017-11-03 11:07:35 -07001950 * @param extras Bundle containing extra information to be passed to the
1951 * {@link ConnectionService}
1952 */
Tyler Gunn9d127732018-03-02 15:45:51 -08001953 public void handoverTo(PhoneAccountHandle toHandle, @VideoProfile.VideoState int videoState,
1954 Bundle extras) {
Sanket Padawea8eddd42017-11-03 11:07:35 -07001955 mInCallAdapter.handoverTo(mTelecomCallId, toHandle, videoState, extras);
1956 }
1957
1958 /**
Hall Liu95d55872017-01-25 17:12:49 -08001959 * Terminate the RTT session on this call. The resulting state change will be notified via
1960 * the {@link Callback#onRttStatusChanged(Call, boolean, RttCall)} callback.
1961 */
1962 public void stopRtt() {
Hall Liu57006aa2017-02-06 10:49:48 -08001963 mInCallAdapter.stopRtt(mTelecomCallId);
Hall Liu95d55872017-01-25 17:12:49 -08001964 }
1965
1966 /**
Tyler Gunndee56a82016-03-23 16:06:34 -07001967 * Adds some extras to this {@link Call}. Existing keys are replaced and new ones are
1968 * added.
1969 * <p>
1970 * No assumptions should be made as to how an In-Call UI or service will handle these
1971 * extras. Keys should be fully qualified (e.g., com.example.MY_EXTRA) to avoid conflicts.
1972 *
1973 * @param extras The extras to add.
1974 */
1975 public final void putExtras(Bundle extras) {
1976 if (extras == null) {
1977 return;
1978 }
1979
1980 if (mExtras == null) {
1981 mExtras = new Bundle();
1982 }
1983 mExtras.putAll(extras);
1984 mInCallAdapter.putExtras(mTelecomCallId, extras);
1985 }
1986
1987 /**
1988 * Adds a boolean extra to this {@link Call}.
1989 *
1990 * @param key The extra key.
1991 * @param value The value.
1992 * @hide
1993 */
1994 public final void putExtra(String key, boolean value) {
1995 if (mExtras == null) {
1996 mExtras = new Bundle();
1997 }
1998 mExtras.putBoolean(key, value);
1999 mInCallAdapter.putExtra(mTelecomCallId, key, value);
2000 }
2001
2002 /**
Tyler Gunn071be6f2016-05-10 14:52:33 -07002003 * Adds an integer extra to this {@link Call}.
Tyler Gunndee56a82016-03-23 16:06:34 -07002004 *
2005 * @param key The extra key.
2006 * @param value The value.
2007 * @hide
2008 */
2009 public final void putExtra(String key, int value) {
2010 if (mExtras == null) {
2011 mExtras = new Bundle();
2012 }
2013 mExtras.putInt(key, value);
2014 mInCallAdapter.putExtra(mTelecomCallId, key, value);
2015 }
2016
2017 /**
Tyler Gunn071be6f2016-05-10 14:52:33 -07002018 * Adds a string extra to this {@link Call}.
Tyler Gunndee56a82016-03-23 16:06:34 -07002019 *
2020 * @param key The extra key.
2021 * @param value The value.
2022 * @hide
2023 */
2024 public final void putExtra(String key, String value) {
2025 if (mExtras == null) {
2026 mExtras = new Bundle();
2027 }
2028 mExtras.putString(key, value);
2029 mInCallAdapter.putExtra(mTelecomCallId, key, value);
2030 }
2031
2032 /**
Tyler Gunn071be6f2016-05-10 14:52:33 -07002033 * Removes extras from this {@link Call}.
Tyler Gunndee56a82016-03-23 16:06:34 -07002034 *
2035 * @param keys The keys of the extras to remove.
2036 */
2037 public final void removeExtras(List<String> keys) {
2038 if (mExtras != null) {
2039 for (String key : keys) {
2040 mExtras.remove(key);
2041 }
2042 if (mExtras.size() == 0) {
2043 mExtras = null;
2044 }
2045 }
2046 mInCallAdapter.removeExtras(mTelecomCallId, keys);
2047 }
2048
2049 /**
Tyler Gunn071be6f2016-05-10 14:52:33 -07002050 * Removes extras from this {@link Call}.
2051 *
2052 * @param keys The keys of the extras to remove.
2053 */
2054 public final void removeExtras(String ... keys) {
2055 removeExtras(Arrays.asList(keys));
2056 }
2057
2058 /**
Ihab Awade63fadb2014-07-09 21:52:04 -07002059 * Obtains the parent of this {@code Call} in a conference, if any.
2060 *
2061 * @return The parent {@code Call}, or {@code null} if this {@code Call} is not a
2062 * child of any conference {@code Call}s.
2063 */
2064 public Call getParent() {
Santos Cordon823fd3c2014-08-07 18:35:18 -07002065 if (mParentId != null) {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07002066 return mPhone.internalGetCallByTelecomId(mParentId);
Santos Cordon823fd3c2014-08-07 18:35:18 -07002067 }
2068 return null;
Ihab Awade63fadb2014-07-09 21:52:04 -07002069 }
2070
2071 /**
2072 * Obtains the children of this conference {@code Call}, if any.
2073 *
2074 * @return The children of this {@code Call} if this {@code Call} is a conference, or an empty
2075 * {@code List} otherwise.
2076 */
2077 public List<Call> getChildren() {
Santos Cordon823fd3c2014-08-07 18:35:18 -07002078 if (!mChildrenCached) {
2079 mChildrenCached = true;
2080 mChildren.clear();
2081
2082 for(String id : mChildrenIds) {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07002083 Call call = mPhone.internalGetCallByTelecomId(id);
Santos Cordon823fd3c2014-08-07 18:35:18 -07002084 if (call == null) {
2085 // At least one child was still not found, so do not save true for "cached"
2086 mChildrenCached = false;
2087 } else {
2088 mChildren.add(call);
2089 }
2090 }
2091 }
2092
Ihab Awade63fadb2014-07-09 21:52:04 -07002093 return mUnmodifiableChildren;
2094 }
2095
2096 /**
Santos Cordon7c7bc7f2014-07-28 18:15:48 -07002097 * Returns the list of {@code Call}s with which this {@code Call} is allowed to conference.
2098 *
2099 * @return The list of conferenceable {@code Call}s.
2100 */
2101 public List<Call> getConferenceableCalls() {
2102 return mUnmodifiableConferenceableCalls;
2103 }
2104
2105 /**
Ihab Awade63fadb2014-07-09 21:52:04 -07002106 * Obtains the state of this {@code Call}.
2107 *
2108 * @return A state value, chosen from the {@code STATE_*} constants.
2109 */
2110 public int getState() {
2111 return mState;
2112 }
2113
2114 /**
Hall Liuef98bf82020-01-09 15:22:44 -08002115 * Returns the child {@link Call} in a generic conference that is currently active.
Hall Liu135e53aa2020-02-27 18:34:11 -08002116 *
2117 * A "generic conference" is the mechanism used to support two simultaneous calls on a device
2118 * in CDMA networks. It is effectively equivalent to having one call active and one call on hold
2119 * in GSM or IMS calls. This method returns the currently active call.
2120 *
2121 * In a generic conference, the network exposes the conference to us as a single call, and we
2122 * switch between talking to the two participants using a CDMA flash command. Since the network
2123 * exposes no additional information about the call, the only way we know which caller we're
2124 * currently talking to is by keeping track of the flash commands that we've sent to the
2125 * network.
2126 *
Hall Liuef98bf82020-01-09 15:22:44 -08002127 * For calls that are not generic conferences, or when the generic conference has more than
2128 * 2 children, returns {@code null}.
2129 * @see Details#PROPERTY_GENERIC_CONFERENCE
2130 * @return The active child call.
2131 */
2132 public @Nullable Call getGenericConferenceActiveChildCall() {
2133 if (mActiveGenericConferenceChild != null) {
2134 return mPhone.internalGetCallByTelecomId(mActiveGenericConferenceChild);
2135 }
2136 return null;
2137 }
2138
2139 /**
Ihab Awade63fadb2014-07-09 21:52:04 -07002140 * Obtains a list of canned, pre-configured message responses to present to the user as
Tyler Gunn434fc2c2020-10-06 14:23:54 -07002141 * ways of rejecting an incoming {@code Call} using via a text message.
2142 * <p>
2143 * <em>Note:</em> Since canned responses may be loaded from the file system, they are not
2144 * guaranteed to be present when this {@link Call} is first added to the {@link InCallService}
2145 * via {@link InCallService#onCallAdded(Call)}. The callback
2146 * {@link Call.Callback#onCannedTextResponsesLoaded(Call, List)} will be called when/if canned
2147 * responses for the call become available.
Ihab Awade63fadb2014-07-09 21:52:04 -07002148 *
2149 * @see #reject(boolean, String)
2150 *
2151 * @return A list of canned text message responses.
2152 */
2153 public List<String> getCannedTextResponses() {
2154 return mCannedTextResponses;
2155 }
2156
2157 /**
2158 * Obtains an object that can be used to display video from this {@code Call}.
2159 *
Andrew Lee50aca232014-07-22 16:41:54 -07002160 * @return An {@code Call.VideoCall}.
Ihab Awade63fadb2014-07-09 21:52:04 -07002161 */
Andrew Lee50aca232014-07-22 16:41:54 -07002162 public InCallService.VideoCall getVideoCall() {
Tyler Gunn584ba6c2015-12-08 10:53:41 -08002163 return mVideoCallImpl;
Ihab Awade63fadb2014-07-09 21:52:04 -07002164 }
2165
2166 /**
2167 * Obtains an object containing call details.
2168 *
2169 * @return A {@link Details} object. Depending on the state of the {@code Call}, the
2170 * result may be {@code null}.
2171 */
2172 public Details getDetails() {
2173 return mDetails;
2174 }
2175
2176 /**
Hall Liu95d55872017-01-25 17:12:49 -08002177 * Returns this call's RttCall object. The {@link RttCall} instance is used to send and
2178 * receive RTT text data, as well as to change the RTT mode.
2179 * @return A {@link Call.RttCall}. {@code null} if there is no active RTT connection.
2180 */
2181 public @Nullable RttCall getRttCall() {
2182 return mRttCall;
2183 }
2184
2185 /**
2186 * Returns whether this call has an active RTT connection.
2187 * @return true if there is a connection, false otherwise.
2188 */
2189 public boolean isRttActive() {
Hall Liue9041242018-02-09 16:40:03 -08002190 return mRttCall != null && mDetails.hasProperty(Details.PROPERTY_RTT);
Hall Liu95d55872017-01-25 17:12:49 -08002191 }
2192
2193 /**
Andrew Leeda80c872015-04-15 14:09:50 -07002194 * Registers a callback to this {@code Call}.
2195 *
2196 * @param callback A {@code Callback}.
2197 */
2198 public void registerCallback(Callback callback) {
Andrew Lee011728f2015-04-23 15:47:06 -07002199 registerCallback(callback, new Handler());
2200 }
2201
2202 /**
2203 * Registers a callback to this {@code Call}.
2204 *
2205 * @param callback A {@code Callback}.
2206 * @param handler A handler which command and status changes will be delivered to.
2207 */
2208 public void registerCallback(Callback callback, Handler handler) {
2209 unregisterCallback(callback);
Roshan Pius1ca62072015-07-07 17:34:51 -07002210 // Don't allow new callback registration if the call is already being destroyed.
2211 if (callback != null && handler != null && mState != STATE_DISCONNECTED) {
Andrew Lee011728f2015-04-23 15:47:06 -07002212 mCallbackRecords.add(new CallbackRecord<Callback>(callback, handler));
2213 }
Andrew Leeda80c872015-04-15 14:09:50 -07002214 }
2215
2216 /**
2217 * Unregisters a callback from this {@code Call}.
2218 *
2219 * @param callback A {@code Callback}.
2220 */
2221 public void unregisterCallback(Callback callback) {
Roshan Pius1ca62072015-07-07 17:34:51 -07002222 // Don't allow callback deregistration if the call is already being destroyed.
2223 if (callback != null && mState != STATE_DISCONNECTED) {
Andrew Lee011728f2015-04-23 15:47:06 -07002224 for (CallbackRecord<Callback> record : mCallbackRecords) {
2225 if (record.getCallback() == callback) {
2226 mCallbackRecords.remove(record);
2227 break;
2228 }
2229 }
Andrew Leeda80c872015-04-15 14:09:50 -07002230 }
2231 }
2232
Santos Cordon3c20d632016-02-25 16:12:35 -08002233 @Override
2234 public String toString() {
2235 return new StringBuilder().
2236 append("Call [id: ").
2237 append(mTelecomCallId).
2238 append(", state: ").
2239 append(stateToString(mState)).
2240 append(", details: ").
2241 append(mDetails).
2242 append("]").toString();
2243 }
2244
2245 /**
2246 * @param state An integer value of a {@code STATE_*} constant.
2247 * @return A string representation of the value.
2248 */
2249 private static String stateToString(int state) {
2250 switch (state) {
2251 case STATE_NEW:
2252 return "NEW";
2253 case STATE_RINGING:
2254 return "RINGING";
2255 case STATE_DIALING:
2256 return "DIALING";
2257 case STATE_ACTIVE:
2258 return "ACTIVE";
2259 case STATE_HOLDING:
2260 return "HOLDING";
2261 case STATE_DISCONNECTED:
2262 return "DISCONNECTED";
2263 case STATE_CONNECTING:
2264 return "CONNECTING";
2265 case STATE_DISCONNECTING:
2266 return "DISCONNECTING";
2267 case STATE_SELECT_PHONE_ACCOUNT:
2268 return "SELECT_PHONE_ACCOUNT";
Hall Liu4e35b642019-10-14 17:50:45 -07002269 case STATE_SIMULATED_RINGING:
2270 return "SIMULATED_RINGING";
2271 case STATE_AUDIO_PROCESSING:
2272 return "AUDIO_PROCESSING";
Santos Cordon3c20d632016-02-25 16:12:35 -08002273 default:
2274 Log.w(Call.class, "Unknown state %d", state);
2275 return "UNKNOWN";
2276 }
2277 }
2278
Andrew Leeda80c872015-04-15 14:09:50 -07002279 /**
Ihab Awade63fadb2014-07-09 21:52:04 -07002280 * Adds a listener to this {@code Call}.
2281 *
2282 * @param listener A {@code Listener}.
Andrew Leeda80c872015-04-15 14:09:50 -07002283 * @deprecated Use {@link #registerCallback} instead.
2284 * @hide
Ihab Awade63fadb2014-07-09 21:52:04 -07002285 */
Andrew Leeda80c872015-04-15 14:09:50 -07002286 @Deprecated
2287 @SystemApi
Ihab Awade63fadb2014-07-09 21:52:04 -07002288 public void addListener(Listener listener) {
Andrew Leeda80c872015-04-15 14:09:50 -07002289 registerCallback(listener);
Ihab Awade63fadb2014-07-09 21:52:04 -07002290 }
2291
2292 /**
2293 * Removes a listener from this {@code Call}.
2294 *
2295 * @param listener A {@code Listener}.
Andrew Leeda80c872015-04-15 14:09:50 -07002296 * @deprecated Use {@link #unregisterCallback} instead.
2297 * @hide
Ihab Awade63fadb2014-07-09 21:52:04 -07002298 */
Andrew Leeda80c872015-04-15 14:09:50 -07002299 @Deprecated
2300 @SystemApi
Ihab Awade63fadb2014-07-09 21:52:04 -07002301 public void removeListener(Listener listener) {
Andrew Leeda80c872015-04-15 14:09:50 -07002302 unregisterCallback(listener);
Ihab Awade63fadb2014-07-09 21:52:04 -07002303 }
2304
2305 /** {@hide} */
Tyler Gunn159f35c2017-03-02 09:28:37 -08002306 Call(Phone phone, String telecomCallId, InCallAdapter inCallAdapter, String callingPackage,
2307 int targetSdkVersion) {
Ihab Awade63fadb2014-07-09 21:52:04 -07002308 mPhone = phone;
Tyler Gunnef9f6f92014-09-12 22:16:17 -07002309 mTelecomCallId = telecomCallId;
Ihab Awade63fadb2014-07-09 21:52:04 -07002310 mInCallAdapter = inCallAdapter;
2311 mState = STATE_NEW;
Tyler Gunnb88b3112016-11-09 10:19:23 -08002312 mCallingPackage = callingPackage;
Tyler Gunn159f35c2017-03-02 09:28:37 -08002313 mTargetSdkVersion = targetSdkVersion;
Ihab Awade63fadb2014-07-09 21:52:04 -07002314 }
2315
2316 /** {@hide} */
Tyler Gunnb88b3112016-11-09 10:19:23 -08002317 Call(Phone phone, String telecomCallId, InCallAdapter inCallAdapter, int state,
Tyler Gunn159f35c2017-03-02 09:28:37 -08002318 String callingPackage, int targetSdkVersion) {
Shriram Ganeshddf570e2015-05-31 09:18:48 -07002319 mPhone = phone;
2320 mTelecomCallId = telecomCallId;
2321 mInCallAdapter = inCallAdapter;
2322 mState = state;
Tyler Gunnb88b3112016-11-09 10:19:23 -08002323 mCallingPackage = callingPackage;
Tyler Gunn159f35c2017-03-02 09:28:37 -08002324 mTargetSdkVersion = targetSdkVersion;
Shriram Ganeshddf570e2015-05-31 09:18:48 -07002325 }
2326
2327 /** {@hide} */
Ihab Awade63fadb2014-07-09 21:52:04 -07002328 final String internalGetCallId() {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07002329 return mTelecomCallId;
Ihab Awade63fadb2014-07-09 21:52:04 -07002330 }
2331
2332 /** {@hide} */
Santos Cordon7c7bc7f2014-07-28 18:15:48 -07002333 final void internalUpdate(ParcelableCall parcelableCall, Map<String, Call> callIdMap) {
Tyler Gunnb88b3112016-11-09 10:19:23 -08002334
Ihab Awade63fadb2014-07-09 21:52:04 -07002335 // First, we update the internal state as far as possible before firing any updates.
Sailesh Nepal1bef3392016-01-24 18:21:53 -08002336 Details details = Details.createFromParcelableCall(parcelableCall);
Ihab Awade63fadb2014-07-09 21:52:04 -07002337 boolean detailsChanged = !Objects.equals(mDetails, details);
2338 if (detailsChanged) {
2339 mDetails = details;
2340 }
2341
2342 boolean cannedTextResponsesChanged = false;
Santos Cordon88b771d2014-07-19 13:10:40 -07002343 if (mCannedTextResponses == null && parcelableCall.getCannedSmsResponses() != null
2344 && !parcelableCall.getCannedSmsResponses().isEmpty()) {
2345 mCannedTextResponses =
2346 Collections.unmodifiableList(parcelableCall.getCannedSmsResponses());
Yorke Leee886f632015-08-04 13:43:31 -07002347 cannedTextResponsesChanged = true;
Ihab Awade63fadb2014-07-09 21:52:04 -07002348 }
2349
Tyler Gunnd1fdf3a2019-11-05 15:47:58 -08002350 IVideoProvider previousVideoProvider = mVideoCallImpl == null ? null :
2351 mVideoCallImpl.getVideoProvider();
2352 IVideoProvider newVideoProvider = parcelableCall.getVideoProvider();
2353
2354 // parcelableCall.isVideoCallProviderChanged is only true when we have a video provider
2355 // specified; so we should check if the actual IVideoProvider changes as well.
2356 boolean videoCallChanged = parcelableCall.isVideoCallProviderChanged()
2357 && !Objects.equals(previousVideoProvider, newVideoProvider);
Andrew Lee50aca232014-07-22 16:41:54 -07002358 if (videoCallChanged) {
Tyler Gunnd1fdf3a2019-11-05 15:47:58 -08002359 if (mVideoCallImpl != null) {
2360 mVideoCallImpl.destroy();
2361 }
2362 mVideoCallImpl = parcelableCall.isVideoCallProviderChanged() ?
2363 parcelableCall.getVideoCallImpl(mCallingPackage, mTargetSdkVersion) : null;
Tyler Gunn584ba6c2015-12-08 10:53:41 -08002364 }
Tyler Gunnd1fdf3a2019-11-05 15:47:58 -08002365
Tyler Gunn584ba6c2015-12-08 10:53:41 -08002366 if (mVideoCallImpl != null) {
2367 mVideoCallImpl.setVideoState(getDetails().getVideoState());
Ihab Awade63fadb2014-07-09 21:52:04 -07002368 }
2369
Santos Cordone3c507b2015-04-23 14:44:19 -07002370 int state = parcelableCall.getState();
Hall Liu31de23d2019-10-11 15:38:29 -07002371 if (mTargetSdkVersion < Phone.SDK_VERSION_R && state == Call.STATE_SIMULATED_RINGING) {
2372 state = Call.STATE_RINGING;
2373 }
Ihab Awade63fadb2014-07-09 21:52:04 -07002374 boolean stateChanged = mState != state;
2375 if (stateChanged) {
2376 mState = state;
2377 }
2378
Santos Cordon823fd3c2014-08-07 18:35:18 -07002379 String parentId = parcelableCall.getParentCallId();
2380 boolean parentChanged = !Objects.equals(mParentId, parentId);
2381 if (parentChanged) {
2382 mParentId = parentId;
Ihab Awade63fadb2014-07-09 21:52:04 -07002383 }
2384
Santos Cordon823fd3c2014-08-07 18:35:18 -07002385 List<String> childCallIds = parcelableCall.getChildCallIds();
2386 boolean childrenChanged = !Objects.equals(childCallIds, mChildrenIds);
2387 if (childrenChanged) {
2388 mChildrenIds.clear();
2389 mChildrenIds.addAll(parcelableCall.getChildCallIds());
2390 mChildrenCached = false;
Ihab Awade63fadb2014-07-09 21:52:04 -07002391 }
2392
Hall Liuef98bf82020-01-09 15:22:44 -08002393 String activeChildCallId = parcelableCall.getActiveChildCallId();
2394 boolean activeChildChanged = !Objects.equals(activeChildCallId,
2395 mActiveGenericConferenceChild);
2396 if (activeChildChanged) {
2397 mActiveGenericConferenceChild = activeChildCallId;
2398 }
2399
Santos Cordon7c7bc7f2014-07-28 18:15:48 -07002400 List<String> conferenceableCallIds = parcelableCall.getConferenceableCallIds();
2401 List<Call> conferenceableCalls = new ArrayList<Call>(conferenceableCallIds.size());
2402 for (String otherId : conferenceableCallIds) {
2403 if (callIdMap.containsKey(otherId)) {
2404 conferenceableCalls.add(callIdMap.get(otherId));
2405 }
2406 }
2407
2408 if (!Objects.equals(mConferenceableCalls, conferenceableCalls)) {
2409 mConferenceableCalls.clear();
2410 mConferenceableCalls.addAll(conferenceableCalls);
2411 fireConferenceableCallsChanged();
2412 }
2413
Hall Liu95d55872017-01-25 17:12:49 -08002414 boolean isRttChanged = false;
2415 boolean rttModeChanged = false;
Hall Liue9041242018-02-09 16:40:03 -08002416 if (parcelableCall.getIsRttCallChanged()
2417 && mDetails.hasProperty(Details.PROPERTY_RTT)) {
Hall Liu95d55872017-01-25 17:12:49 -08002418 ParcelableRttCall parcelableRttCall = parcelableCall.getParcelableRttCall();
2419 InputStreamReader receiveStream = new InputStreamReader(
2420 new ParcelFileDescriptor.AutoCloseInputStream(
2421 parcelableRttCall.getReceiveStream()),
2422 StandardCharsets.UTF_8);
2423 OutputStreamWriter transmitStream = new OutputStreamWriter(
2424 new ParcelFileDescriptor.AutoCloseOutputStream(
2425 parcelableRttCall.getTransmitStream()),
2426 StandardCharsets.UTF_8);
Hall Liu57006aa2017-02-06 10:49:48 -08002427 RttCall newRttCall = new Call.RttCall(mTelecomCallId,
Hall Liu95d55872017-01-25 17:12:49 -08002428 receiveStream, transmitStream, parcelableRttCall.getRttMode(), mInCallAdapter);
2429 if (mRttCall == null) {
2430 isRttChanged = true;
2431 } else if (mRttCall.getRttAudioMode() != newRttCall.getRttAudioMode()) {
2432 rttModeChanged = true;
2433 }
2434 mRttCall = newRttCall;
2435 } else if (mRttCall != null && parcelableCall.getParcelableRttCall() == null
2436 && parcelableCall.getIsRttCallChanged()) {
2437 isRttChanged = true;
2438 mRttCall = null;
2439 }
2440
Ihab Awade63fadb2014-07-09 21:52:04 -07002441 // Now we fire updates, ensuring that any client who listens to any of these notifications
2442 // gets the most up-to-date state.
2443
2444 if (stateChanged) {
2445 fireStateChanged(mState);
2446 }
2447 if (detailsChanged) {
2448 fireDetailsChanged(mDetails);
2449 }
2450 if (cannedTextResponsesChanged) {
2451 fireCannedTextResponsesLoaded(mCannedTextResponses);
2452 }
Andrew Lee50aca232014-07-22 16:41:54 -07002453 if (videoCallChanged) {
Tyler Gunn584ba6c2015-12-08 10:53:41 -08002454 fireVideoCallChanged(mVideoCallImpl);
Ihab Awade63fadb2014-07-09 21:52:04 -07002455 }
Santos Cordon823fd3c2014-08-07 18:35:18 -07002456 if (parentChanged) {
2457 fireParentChanged(getParent());
2458 }
Hall Liuef98bf82020-01-09 15:22:44 -08002459 if (childrenChanged || activeChildChanged) {
Santos Cordon823fd3c2014-08-07 18:35:18 -07002460 fireChildrenChanged(getChildren());
2461 }
Hall Liu95d55872017-01-25 17:12:49 -08002462 if (isRttChanged) {
2463 fireOnIsRttChanged(mRttCall != null, mRttCall);
2464 }
2465 if (rttModeChanged) {
2466 fireOnRttModeChanged(mRttCall.getRttAudioMode());
2467 }
Ihab Awade63fadb2014-07-09 21:52:04 -07002468
2469 // If we have transitioned to DISCONNECTED, that means we need to notify clients and
2470 // remove ourselves from the Phone. Note that we do this after completing all state updates
2471 // so a client can cleanly transition all their UI to the state appropriate for a
2472 // DISCONNECTED Call while still relying on the existence of that Call in the Phone's list.
2473 if (mState == STATE_DISCONNECTED) {
2474 fireCallDestroyed();
Ihab Awade63fadb2014-07-09 21:52:04 -07002475 }
2476 }
2477
2478 /** {@hide} */
Ihab Awade63fadb2014-07-09 21:52:04 -07002479 final void internalSetPostDialWait(String remaining) {
2480 mRemainingPostDialSequence = remaining;
2481 firePostDialWait(mRemainingPostDialSequence);
2482 }
2483
Sailesh Nepal2ab88cc2014-07-18 14:49:18 -07002484 /** {@hide} */
Santos Cordonf30d7e92014-08-26 09:54:33 -07002485 final void internalSetDisconnected() {
2486 if (mState != Call.STATE_DISCONNECTED) {
2487 mState = Call.STATE_DISCONNECTED;
2488 fireStateChanged(mState);
2489 fireCallDestroyed();
Santos Cordonf30d7e92014-08-26 09:54:33 -07002490 }
2491 }
2492
Tyler Gunn876dbfb2016-03-14 15:18:07 -07002493 /** {@hide} */
2494 final void internalOnConnectionEvent(String event, Bundle extras) {
2495 fireOnConnectionEvent(event, extras);
2496 }
2497
Hall Liu95d55872017-01-25 17:12:49 -08002498 /** {@hide} */
2499 final void internalOnRttUpgradeRequest(final int requestId) {
2500 for (CallbackRecord<Callback> record : mCallbackRecords) {
2501 final Call call = this;
2502 final Callback callback = record.getCallback();
2503 record.getHandler().post(() -> callback.onRttRequest(call, requestId));
2504 }
2505 }
2506
Hall Liu57006aa2017-02-06 10:49:48 -08002507 /** @hide */
2508 final void internalOnRttInitiationFailure(int reason) {
2509 for (CallbackRecord<Callback> record : mCallbackRecords) {
2510 final Call call = this;
2511 final Callback callback = record.getCallback();
2512 record.getHandler().post(() -> callback.onRttInitiationFailure(call, reason));
2513 }
2514 }
2515
Sanket Padawe85291f62017-12-01 13:59:27 -08002516 /** {@hide} */
2517 final void internalOnHandoverFailed(int error) {
2518 for (CallbackRecord<Callback> record : mCallbackRecords) {
2519 final Call call = this;
2520 final Callback callback = record.getCallback();
2521 record.getHandler().post(() -> callback.onHandoverFailed(call, error));
2522 }
2523 }
2524
Tyler Gunn858bfaf2018-01-22 15:17:54 -08002525 /** {@hide} */
2526 final void internalOnHandoverComplete() {
2527 for (CallbackRecord<Callback> record : mCallbackRecords) {
2528 final Call call = this;
2529 final Callback callback = record.getCallback();
2530 record.getHandler().post(() -> callback.onHandoverComplete(call));
2531 }
2532 }
2533
Andrew Lee011728f2015-04-23 15:47:06 -07002534 private void fireStateChanged(final int newState) {
2535 for (CallbackRecord<Callback> record : mCallbackRecords) {
2536 final Call call = this;
2537 final Callback callback = record.getCallback();
2538 record.getHandler().post(new Runnable() {
2539 @Override
2540 public void run() {
2541 callback.onStateChanged(call, newState);
2542 }
2543 });
Ihab Awade63fadb2014-07-09 21:52:04 -07002544 }
2545 }
2546
Andrew Lee011728f2015-04-23 15:47:06 -07002547 private void fireParentChanged(final Call newParent) {
2548 for (CallbackRecord<Callback> record : mCallbackRecords) {
2549 final Call call = this;
2550 final Callback callback = record.getCallback();
2551 record.getHandler().post(new Runnable() {
2552 @Override
2553 public void run() {
2554 callback.onParentChanged(call, newParent);
2555 }
2556 });
Ihab Awade63fadb2014-07-09 21:52:04 -07002557 }
2558 }
2559
Andrew Lee011728f2015-04-23 15:47:06 -07002560 private void fireChildrenChanged(final List<Call> children) {
2561 for (CallbackRecord<Callback> record : mCallbackRecords) {
2562 final Call call = this;
2563 final Callback callback = record.getCallback();
2564 record.getHandler().post(new Runnable() {
2565 @Override
2566 public void run() {
2567 callback.onChildrenChanged(call, children);
2568 }
2569 });
Ihab Awade63fadb2014-07-09 21:52:04 -07002570 }
2571 }
2572
Andrew Lee011728f2015-04-23 15:47:06 -07002573 private void fireDetailsChanged(final Details details) {
2574 for (CallbackRecord<Callback> record : mCallbackRecords) {
2575 final Call call = this;
2576 final Callback callback = record.getCallback();
2577 record.getHandler().post(new Runnable() {
2578 @Override
2579 public void run() {
2580 callback.onDetailsChanged(call, details);
2581 }
2582 });
Ihab Awade63fadb2014-07-09 21:52:04 -07002583 }
2584 }
2585
Andrew Lee011728f2015-04-23 15:47:06 -07002586 private void fireCannedTextResponsesLoaded(final List<String> cannedTextResponses) {
2587 for (CallbackRecord<Callback> record : mCallbackRecords) {
2588 final Call call = this;
2589 final Callback callback = record.getCallback();
2590 record.getHandler().post(new Runnable() {
2591 @Override
2592 public void run() {
2593 callback.onCannedTextResponsesLoaded(call, cannedTextResponses);
2594 }
2595 });
Ihab Awade63fadb2014-07-09 21:52:04 -07002596 }
2597 }
2598
Andrew Lee011728f2015-04-23 15:47:06 -07002599 private void fireVideoCallChanged(final InCallService.VideoCall videoCall) {
2600 for (CallbackRecord<Callback> record : mCallbackRecords) {
2601 final Call call = this;
2602 final Callback callback = record.getCallback();
2603 record.getHandler().post(new Runnable() {
2604 @Override
2605 public void run() {
2606 callback.onVideoCallChanged(call, videoCall);
2607 }
2608 });
Ihab Awade63fadb2014-07-09 21:52:04 -07002609 }
2610 }
2611
Andrew Lee011728f2015-04-23 15:47:06 -07002612 private void firePostDialWait(final String remainingPostDialSequence) {
2613 for (CallbackRecord<Callback> record : mCallbackRecords) {
2614 final Call call = this;
2615 final Callback callback = record.getCallback();
2616 record.getHandler().post(new Runnable() {
2617 @Override
2618 public void run() {
2619 callback.onPostDialWait(call, remainingPostDialSequence);
2620 }
2621 });
Ihab Awade63fadb2014-07-09 21:52:04 -07002622 }
2623 }
2624
2625 private void fireCallDestroyed() {
Roshan Pius1ca62072015-07-07 17:34:51 -07002626 /**
2627 * To preserve the ordering of the Call's onCallDestroyed callback and Phone's
2628 * onCallRemoved callback, we remove this call from the Phone's record
2629 * only once all of the registered onCallDestroyed callbacks are executed.
2630 * All the callbacks get removed from our records as a part of this operation
2631 * since onCallDestroyed is the final callback.
2632 */
2633 final Call call = this;
2634 if (mCallbackRecords.isEmpty()) {
2635 // No callbacks registered, remove the call from Phone's record.
2636 mPhone.internalRemoveCall(call);
2637 }
2638 for (final CallbackRecord<Callback> record : mCallbackRecords) {
Andrew Lee011728f2015-04-23 15:47:06 -07002639 final Callback callback = record.getCallback();
2640 record.getHandler().post(new Runnable() {
2641 @Override
2642 public void run() {
Roshan Pius1ca62072015-07-07 17:34:51 -07002643 boolean isFinalRemoval = false;
2644 RuntimeException toThrow = null;
2645 try {
2646 callback.onCallDestroyed(call);
2647 } catch (RuntimeException e) {
2648 toThrow = e;
2649 }
2650 synchronized(Call.this) {
2651 mCallbackRecords.remove(record);
2652 if (mCallbackRecords.isEmpty()) {
2653 isFinalRemoval = true;
2654 }
2655 }
2656 if (isFinalRemoval) {
2657 mPhone.internalRemoveCall(call);
2658 }
2659 if (toThrow != null) {
2660 throw toThrow;
2661 }
Andrew Lee011728f2015-04-23 15:47:06 -07002662 }
2663 });
Ihab Awade63fadb2014-07-09 21:52:04 -07002664 }
2665 }
2666
Santos Cordon7c7bc7f2014-07-28 18:15:48 -07002667 private void fireConferenceableCallsChanged() {
Andrew Lee011728f2015-04-23 15:47:06 -07002668 for (CallbackRecord<Callback> record : mCallbackRecords) {
2669 final Call call = this;
2670 final Callback callback = record.getCallback();
2671 record.getHandler().post(new Runnable() {
2672 @Override
2673 public void run() {
2674 callback.onConferenceableCallsChanged(call, mUnmodifiableConferenceableCalls);
2675 }
2676 });
Santos Cordon7c7bc7f2014-07-28 18:15:48 -07002677 }
2678 }
Tyler Gunn1e9bfc62015-08-19 11:18:58 -07002679
2680 /**
Tyler Gunn876dbfb2016-03-14 15:18:07 -07002681 * Notifies listeners of an incoming connection event.
2682 * <p>
2683 * Connection events are issued via {@link Connection#sendConnectionEvent(String, Bundle)}.
2684 *
2685 * @param event
2686 * @param extras
2687 */
2688 private void fireOnConnectionEvent(final String event, final Bundle extras) {
2689 for (CallbackRecord<Callback> record : mCallbackRecords) {
2690 final Call call = this;
2691 final Callback callback = record.getCallback();
2692 record.getHandler().post(new Runnable() {
2693 @Override
2694 public void run() {
2695 callback.onConnectionEvent(call, event, extras);
2696 }
2697 });
2698 }
2699 }
2700
2701 /**
Hall Liu95d55872017-01-25 17:12:49 -08002702 * Notifies listeners of an RTT on/off change
2703 *
2704 * @param enabled True if RTT is now enabled, false otherwise
2705 */
2706 private void fireOnIsRttChanged(final boolean enabled, final RttCall rttCall) {
2707 for (CallbackRecord<Callback> record : mCallbackRecords) {
2708 final Call call = this;
2709 final Callback callback = record.getCallback();
2710 record.getHandler().post(() -> callback.onRttStatusChanged(call, enabled, rttCall));
2711 }
2712 }
2713
2714 /**
2715 * Notifies listeners of a RTT mode change
2716 *
2717 * @param mode The new RTT mode
2718 */
2719 private void fireOnRttModeChanged(final int mode) {
2720 for (CallbackRecord<Callback> record : mCallbackRecords) {
2721 final Call call = this;
2722 final Callback callback = record.getCallback();
2723 record.getHandler().post(() -> callback.onRttModeChanged(call, mode));
2724 }
2725 }
2726
2727 /**
Tyler Gunn1e9bfc62015-08-19 11:18:58 -07002728 * Determines if two bundles are equal.
2729 *
2730 * @param bundle The original bundle.
2731 * @param newBundle The bundle to compare with.
2732 * @retrun {@code true} if the bundles are equal, {@code false} otherwise.
2733 */
2734 private static boolean areBundlesEqual(Bundle bundle, Bundle newBundle) {
2735 if (bundle == null || newBundle == null) {
2736 return bundle == newBundle;
2737 }
2738
2739 if (bundle.size() != newBundle.size()) {
2740 return false;
2741 }
2742
2743 for(String key : bundle.keySet()) {
2744 if (key != null) {
2745 final Object value = bundle.get(key);
2746 final Object newValue = newBundle.get(key);
2747 if (!Objects.equals(value, newValue)) {
2748 return false;
2749 }
2750 }
2751 }
2752 return true;
2753 }
Santos Cordon7c7bc7f2014-07-28 18:15:48 -07002754}