blob: 1953af4adee5d1ae73d123cfee95d8d0c682156f [file] [log] [blame]
Yorke Leeb4ce1432014-06-09 13:53:23 -07001/*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
Santos Cordon9eb45932014-06-27 12:28:43 -07004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
5 * in compliance with the License. You may obtain a copy of the License at
Yorke Leeb4ce1432014-06-09 13:53:23 -07006 *
Santos Cordon9eb45932014-06-27 12:28:43 -07007 * http://www.apache.org/licenses/LICENSE-2.0
Yorke Leeb4ce1432014-06-09 13:53:23 -07008 *
Santos Cordon9eb45932014-06-27 12:28:43 -07009 * Unless required by applicable law or agreed to in writing, software distributed under the License
10 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
11 * or implied. See the License for the specific language governing permissions and limitations under
12 * the License.
Yorke Leeb4ce1432014-06-09 13:53:23 -070013 */
14
Tyler Gunnef9f6f92014-09-12 22:16:17 -070015package android.telecom;
Yorke Leeb4ce1432014-06-09 13:53:23 -070016
Tyler Gunn00d737b2019-10-31 13:04:37 -070017import static android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE;
18
Hall Liu0464b9b2016-01-12 15:32:58 -080019import android.Manifest;
Tyler Gunn6e3ecc42018-11-12 11:30:56 -080020import android.annotation.IntDef;
Fan Zhang5431ef52019-10-14 13:43:46 -070021import android.annotation.NonNull;
Slava Shklyaeve65e4012019-03-04 16:02:34 +000022import android.annotation.Nullable;
Yorke Leec61d13662015-09-21 17:25:25 -070023import android.annotation.RequiresPermission;
Jeff Sharkey910e0812017-04-21 16:29:27 -060024import android.annotation.SuppressAutoDoc;
Jeff Sharkeybfc4fcd2017-06-05 17:38:17 -060025import android.annotation.SuppressLint;
Santos Cordon6c7a3882014-06-25 15:30:08 -070026import android.annotation.SystemApi;
Jeff Sharkeyd86b8fe2017-06-02 17:36:26 -060027import android.annotation.SystemService;
Brad Ebingera8366ae2021-03-23 21:01:51 +000028import android.compat.annotation.ChangeId;
29import android.compat.annotation.EnabledSince;
Artur Satayev2ebb31c2020-01-08 12:24:36 +000030import android.compat.annotation.UnsupportedAppUsage;
Santos Cordon6c7a3882014-06-25 15:30:08 -070031import android.content.ComponentName;
Yorke Leeb4ce1432014-06-09 13:53:23 -070032import android.content.Context;
Yorke Lee3e56ba12015-04-23 12:32:36 -070033import android.content.Intent;
Nancy Chenb2299c12014-10-29 18:22:11 -070034import android.net.Uri;
Sanket Padawef6a9e5b2018-01-05 14:26:16 -080035import android.os.Build;
Santos Cordon96efb482014-07-19 14:57:05 -070036import android.os.Bundle;
Kevin Jeon767cda32020-11-17 01:40:16 +000037import android.os.IBinder;
Shuo Qian4d065262020-10-20 11:04:28 -070038import android.os.Process;
Santos Cordon6c7a3882014-06-25 15:30:08 -070039import android.os.RemoteException;
40import android.os.ServiceManager;
Tyler Gunn7e45b722018-12-04 12:56:45 -080041import android.os.UserHandle;
Chen Xuc9d4ee12019-09-26 16:11:59 -070042import android.telephony.Annotation.CallState;
Brad Ebingere7833312019-05-07 10:55:55 -070043import android.telephony.SubscriptionManager;
Yorke Lee2ae312e2014-09-12 17:58:48 -070044import android.telephony.TelephonyManager;
Anthony Lee67279262014-10-27 11:28:40 -070045import android.text.TextUtils;
Santos Cordon6c7a3882014-06-25 15:30:08 -070046import android.util.Log;
Yorke Leeb4ce1432014-06-09 13:53:23 -070047
Kevin Jeon767cda32020-11-17 01:40:16 +000048import com.android.internal.annotations.GuardedBy;
Tyler Gunnef9f6f92014-09-12 22:16:17 -070049import com.android.internal.telecom.ITelecomService;
Yorke Leeb4ce1432014-06-09 13:53:23 -070050
Tyler Gunn6e3ecc42018-11-12 11:30:56 -080051import java.lang.annotation.Retention;
52import java.lang.annotation.RetentionPolicy;
Jay Shrauner7746a942014-08-26 12:15:15 -070053import java.util.ArrayList;
Tyler Gunna1ed7d12014-09-08 09:52:22 -070054import java.util.Collections;
Ihab Awad807fe0a2014-07-09 12:30:52 -070055import java.util.List;
Philip P. Moltmann00cf9fb2020-01-06 16:41:38 -080056import java.util.Objects;
Tyler Gunn7e45b722018-12-04 12:56:45 -080057import java.util.concurrent.Executor;
Ihab Awad807fe0a2014-07-09 12:30:52 -070058
Yorke Leeb4ce1432014-06-09 13:53:23 -070059/**
Santos Cordond9e614f2014-10-28 13:10:36 -070060 * Provides access to information about active calls and registration/call-management functionality.
Evan Charlton0e094d92014-11-08 15:49:16 -080061 * Apps can use methods in this class to determine the current call state.
Santos Cordond9e614f2014-10-28 13:10:36 -070062 * <p>
63 * Apps do not instantiate this class directly; instead, they retrieve a reference to an instance
64 * through {@link Context#getSystemService Context.getSystemService(Context.TELECOM_SERVICE)}.
65 * <p>
66 * Note that access to some telecom information is permission-protected. Your app cannot access the
67 * protected information or gain access to protected functionality unless it has the appropriate
68 * permissions declared in its manifest file. Where permissions apply, they are noted in the method
69 * descriptions.
Yorke Leeb4ce1432014-06-09 13:53:23 -070070 */
Jeff Sharkey910e0812017-04-21 16:29:27 -060071@SuppressAutoDoc
Jeff Sharkeyd86b8fe2017-06-02 17:36:26 -060072@SystemService(Context.TELECOM_SERVICE)
Tyler Gunnef9f6f92014-09-12 22:16:17 -070073public class TelecomManager {
Ihab Awad807fe0a2014-07-09 12:30:52 -070074
Evan Charlton10197192014-07-19 15:00:29 -070075 /**
Santos Cordon96efb482014-07-19 14:57:05 -070076 * Activity action: Starts the UI for handing an incoming call. This intent starts the in-call
Tyler Gunnef9f6f92014-09-12 22:16:17 -070077 * UI by notifying the Telecom system that an incoming call exists for a specific call service
78 * (see {@link android.telecom.ConnectionService}). Telecom reads the Intent extras to find
79 * and bind to the appropriate {@link android.telecom.ConnectionService} which Telecom will
Santos Cordon96efb482014-07-19 14:57:05 -070080 * ultimately use to control and get information about the call.
81 * <p>
82 * Input: get*Extra field {@link #EXTRA_PHONE_ACCOUNT_HANDLE} contains the component name of the
Tyler Gunnef9f6f92014-09-12 22:16:17 -070083 * {@link android.telecom.ConnectionService} that Telecom should bind to. Telecom will then
Evan Charlton10197192014-07-19 15:00:29 -070084 * ask the connection service for more information about the call prior to showing any UI.
Brad Ebinger23b1c6d2017-01-12 13:10:40 -080085 *
86 * @deprecated Use {@link #addNewIncomingCall} instead.
Evan Charlton10197192014-07-19 15:00:29 -070087 */
Tyler Gunnef9f6f92014-09-12 22:16:17 -070088 public static final String ACTION_INCOMING_CALL = "android.telecom.action.INCOMING_CALL";
Evan Charlton10197192014-07-19 15:00:29 -070089
90 /**
Yorke Leec3cf9822014-10-02 09:38:39 -070091 * Similar to {@link #ACTION_INCOMING_CALL}, but is used only by Telephony to add a new
92 * sim-initiated MO call for carrier testing.
Brad Ebinger23b1c6d2017-01-12 13:10:40 -080093 * @deprecated Use {@link #addNewUnknownCall} instead.
Yorke Leec3cf9822014-10-02 09:38:39 -070094 * @hide
95 */
96 public static final String ACTION_NEW_UNKNOWN_CALL = "android.telecom.action.NEW_UNKNOWN_CALL";
97
98 /**
Santos Cordon895d4b82015-06-25 16:41:48 -070099 * An {@link android.content.Intent} action sent by the telecom framework to start a
100 * configuration dialog for a registered {@link PhoneAccount}. There is no default dialog
101 * and each app that registers a {@link PhoneAccount} should provide one if desired.
102 * <p>
103 * A user can access the list of enabled {@link android.telecom.PhoneAccount}s through the Phone
104 * app's settings menu. For each entry, the settings app will add a click action. When
105 * triggered, the click-action will start this intent along with the extra
106 * {@link #EXTRA_PHONE_ACCOUNT_HANDLE} to indicate the {@link PhoneAccount} to configure. If the
107 * {@link PhoneAccount} package does not register an {@link android.app.Activity} for this
108 * intent, then it will not be sent.
Evan Charlton10197192014-07-19 15:00:29 -0700109 */
Santos Cordon895d4b82015-06-25 16:41:48 -0700110 public static final String ACTION_CONFIGURE_PHONE_ACCOUNT =
111 "android.telecom.action.CONFIGURE_PHONE_ACCOUNT";
Evan Charlton10197192014-07-19 15:00:29 -0700112
113 /**
Andrew Lee873cfbf2015-02-26 15:22:00 -0800114 * The {@link android.content.Intent} action used to show the call accessibility settings page.
115 */
116 public static final String ACTION_SHOW_CALL_ACCESSIBILITY_SETTINGS =
117 "android.telecom.action.SHOW_CALL_ACCESSIBILITY_SETTINGS";
118
119 /**
Yorke Lee3818a8922014-07-21 15:57:17 -0700120 * The {@link android.content.Intent} action used to show the call settings page.
121 */
122 public static final String ACTION_SHOW_CALL_SETTINGS =
Tyler Gunnef9f6f92014-09-12 22:16:17 -0700123 "android.telecom.action.SHOW_CALL_SETTINGS";
Yorke Lee3818a8922014-07-21 15:57:17 -0700124
125 /**
Andrew Lee866080f2015-02-19 12:05:33 -0800126 * The {@link android.content.Intent} action used to show the respond via SMS settings page.
127 */
128 public static final String ACTION_SHOW_RESPOND_VIA_SMS_SETTINGS =
129 "android.telecom.action.SHOW_RESPOND_VIA_SMS_SETTINGS";
130
131 /**
Evan Charlton6d8604f2014-09-04 12:38:17 -0700132 * The {@link android.content.Intent} action used to show the settings page used to configure
133 * {@link PhoneAccount} preferences.
134 */
135 public static final String ACTION_CHANGE_PHONE_ACCOUNTS =
Tyler Gunnef9f6f92014-09-12 22:16:17 -0700136 "android.telecom.action.CHANGE_PHONE_ACCOUNTS";
Evan Charlton6d8604f2014-09-04 12:38:17 -0700137
138 /**
Tyler Gunnd9da6ce2017-04-14 13:43:30 -0700139 * {@link android.content.Intent} action used indicate that a new phone account was just
140 * registered.
141 * <p>
142 * The Intent {@link Intent#getExtras() extras} will contain {@link #EXTRA_PHONE_ACCOUNT_HANDLE}
143 * to indicate which {@link PhoneAccount} was registered.
144 * <p>
145 * Will only be sent to the default dialer app (see {@link #getDefaultDialerPackage()}).
Santos Cordonc66f3ba2015-02-27 15:22:07 -0800146 */
Santos Cordonc66f3ba2015-02-27 15:22:07 -0800147 public static final String ACTION_PHONE_ACCOUNT_REGISTERED =
148 "android.telecom.action.PHONE_ACCOUNT_REGISTERED";
149
150 /**
Tyler Gunnd9da6ce2017-04-14 13:43:30 -0700151 * {@link android.content.Intent} action used indicate that a phone account was just
152 * unregistered.
153 * <p>
154 * The Intent {@link Intent#getExtras() extras} will contain {@link #EXTRA_PHONE_ACCOUNT_HANDLE}
155 * to indicate which {@link PhoneAccount} was unregistered.
156 * <p>
157 * Will only be sent to the default dialer app (see {@link #getDefaultDialerPackage()}).
Bryce Lee30b0aa02015-09-23 21:53:53 -0700158 */
Bryce Lee30b0aa02015-09-23 21:53:53 -0700159 public static final String ACTION_PHONE_ACCOUNT_UNREGISTERED =
160 "android.telecom.action.PHONE_ACCOUNT_UNREGISTERED";
161
162 /**
Yorke Lee1011f482015-04-23 15:58:27 -0700163 * Activity action: Shows a dialog asking the user whether or not they want to replace the
164 * current default Dialer with the one specified in
165 * {@link #EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME}.
166 *
167 * Usage example:
168 * <pre>
169 * Intent intent = new Intent(TelecomManager.ACTION_CHANGE_DEFAULT_DIALER);
170 * intent.putExtra(TelecomManager.EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME,
171 * getActivity().getPackageName());
172 * startActivity(intent);
173 * </pre>
Hai Zhang929085f2019-05-03 15:31:43 +0800174 * <p>
175 * This is no longer supported since Q, please use
176 * {@link android.app.role.RoleManager#createRequestRoleIntent(String)} with
177 * {@link android.app.role.RoleManager#ROLE_DIALER} instead.
Yorke Lee1011f482015-04-23 15:58:27 -0700178 */
179 public static final String ACTION_CHANGE_DEFAULT_DIALER =
180 "android.telecom.action.CHANGE_DEFAULT_DIALER";
181
182 /**
Yorke Lee107c4ce2015-06-15 12:08:24 -0700183 * Broadcast intent action indicating that the current default dialer has changed.
184 * The string extra {@link #EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME} will contain the
185 * name of the package that the default dialer was changed to.
186 *
187 * @see #EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME
188 */
189 public static final String ACTION_DEFAULT_DIALER_CHANGED =
190 "android.telecom.action.DEFAULT_DIALER_CHANGED";
191
192 /**
Yorke Lee1011f482015-04-23 15:58:27 -0700193 * Extra value used to provide the package name for {@link #ACTION_CHANGE_DEFAULT_DIALER}.
194 */
195 public static final String EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME =
196 "android.telecom.extra.CHANGE_DEFAULT_DIALER_PACKAGE_NAME";
197
198 /**
tonyzhuff60f5e2018-10-01 19:14:59 +0800199 * Broadcast intent action indicating that the current default call screening app has changed.
Tyler Gunn78f77f62020-03-27 12:51:26 -0700200 * <p>
201 * Note: This intent is NEVER actually broadcast and will be deprecated in the future.
202 * <p>
203 * An app that want to know if it holds the
204 * {@link android.app.role.RoleManager#ROLE_CALL_SCREENING} role can use
205 * {@link android.app.role.RoleManager#isRoleHeld(String)} to confirm if it holds the role or
206 * not.
tonyzhuff60f5e2018-10-01 19:14:59 +0800207 */
208 public static final String ACTION_DEFAULT_CALL_SCREENING_APP_CHANGED =
209 "android.telecom.action.DEFAULT_CALL_SCREENING_APP_CHANGED";
210
211 /**
212 * Extra value used with {@link #ACTION_DEFAULT_CALL_SCREENING_APP_CHANGED} broadcast to
213 * indicate the ComponentName of the call screening app which has changed.
Tyler Gunn78f77f62020-03-27 12:51:26 -0700214 * <p>
215 * Note: This extra is NOT used and will be deprecated in the future.
tonyzhuff60f5e2018-10-01 19:14:59 +0800216 */
217 public static final String EXTRA_DEFAULT_CALL_SCREENING_APP_COMPONENT_NAME =
218 "android.telecom.extra.DEFAULT_CALL_SCREENING_APP_COMPONENT_NAME";
219
220 /**
221 * Extra value used with {@link #ACTION_DEFAULT_CALL_SCREENING_APP_CHANGED} broadcast to
222 * indicate whether an app is the default call screening app.
Tyler Gunn78f77f62020-03-27 12:51:26 -0700223 * <p>
224 * Note: This extra is NOT used and will be deprecated in the future.
tonyzhuff60f5e2018-10-01 19:14:59 +0800225 */
226 public static final String EXTRA_IS_DEFAULT_CALL_SCREENING_APP =
227 "android.telecom.extra.IS_DEFAULT_CALL_SCREENING_APP";
228
229 /**
Evan Charlton6eb262c2014-07-19 18:18:19 -0700230 * Optional extra for {@link android.content.Intent#ACTION_CALL} containing a boolean that
231 * determines whether the speakerphone should be automatically turned on for an outgoing call.
Evan Charlton10197192014-07-19 15:00:29 -0700232 */
233 public static final String EXTRA_START_CALL_WITH_SPEAKERPHONE =
Tyler Gunnef9f6f92014-09-12 22:16:17 -0700234 "android.telecom.extra.START_CALL_WITH_SPEAKERPHONE";
Evan Charlton10197192014-07-19 15:00:29 -0700235
236 /**
Evan Charlton6eb262c2014-07-19 18:18:19 -0700237 * Optional extra for {@link android.content.Intent#ACTION_CALL} containing an integer that
238 * determines the desired video state for an outgoing call.
Santos Cordon96efb482014-07-19 14:57:05 -0700239 * Valid options:
Yorke Lee32f24732015-05-12 16:18:03 -0700240 * {@link VideoProfile#STATE_AUDIO_ONLY},
241 * {@link VideoProfile#STATE_BIDIRECTIONAL},
242 * {@link VideoProfile#STATE_RX_ENABLED},
243 * {@link VideoProfile#STATE_TX_ENABLED}.
Evan Charlton10197192014-07-19 15:00:29 -0700244 */
245 public static final String EXTRA_START_CALL_WITH_VIDEO_STATE =
Tyler Gunnef9f6f92014-09-12 22:16:17 -0700246 "android.telecom.extra.START_CALL_WITH_VIDEO_STATE";
Evan Charlton10197192014-07-19 15:00:29 -0700247
248 /**
Tyler Gunn37653562017-03-13 18:15:15 -0700249 * Optional extra for {@link #addNewIncomingCall(PhoneAccountHandle, Bundle)} containing an
250 * integer that determines the requested video state for an incoming call.
251 * Valid options:
252 * {@link VideoProfile#STATE_AUDIO_ONLY},
253 * {@link VideoProfile#STATE_BIDIRECTIONAL},
254 * {@link VideoProfile#STATE_RX_ENABLED},
255 * {@link VideoProfile#STATE_TX_ENABLED}.
256 */
257 public static final String EXTRA_INCOMING_VIDEO_STATE =
258 "android.telecom.extra.INCOMING_VIDEO_STATE";
259
260 /**
Santos Cordon96efb482014-07-19 14:57:05 -0700261 * The extra used with an {@link android.content.Intent#ACTION_CALL} and
262 * {@link android.content.Intent#ACTION_DIAL} {@code Intent} to specify a
263 * {@link PhoneAccountHandle} to use when making the call.
Evan Charlton10197192014-07-19 15:00:29 -0700264 * <p class="note">
Santos Cordon96efb482014-07-19 14:57:05 -0700265 * Retrieve with {@link android.content.Intent#getParcelableExtra(String)}.
Evan Charlton10197192014-07-19 15:00:29 -0700266 */
Evan Charlton6eb262c2014-07-19 18:18:19 -0700267 public static final String EXTRA_PHONE_ACCOUNT_HANDLE =
Tyler Gunnef9f6f92014-09-12 22:16:17 -0700268 "android.telecom.extra.PHONE_ACCOUNT_HANDLE";
Evan Charlton10197192014-07-19 15:00:29 -0700269
270 /**
Tyler Gunn335ff2e2015-07-30 14:18:33 -0700271 * Optional extra for {@link android.content.Intent#ACTION_CALL} containing a string call
272 * subject which will be associated with an outgoing call. Should only be specified if the
Shuo Qian3ed38832020-11-30 21:54:36 -0800273 * {@link PhoneAccount} supports the capability {@link PhoneAccount#CAPABILITY_CALL_SUBJECT}
274 * or {@link PhoneAccount#CAPABILITY_CALL_COMPOSER}.
Tyler Gunn335ff2e2015-07-30 14:18:33 -0700275 */
276 public static final String EXTRA_CALL_SUBJECT = "android.telecom.extra.CALL_SUBJECT";
277
Shuo Qian3ed38832020-11-30 21:54:36 -0800278 // Values for EXTRA_PRIORITY
279 /**
280 * Indicates the call composer call priority is normal.
281 *
282 * Reference: RCC.20 Section 2.4.4.2
283 */
284 public static final int PRIORITY_NORMAL = 0;
285
286 /**
287 * Indicates the call composer call priority is urgent.
288 *
289 * Reference: RCC.20 Section 2.4.4.2
290 */
291 public static final int PRIORITY_URGENT = 1;
292
293 /**
294 * Extra for the call composer call priority, either {@link #PRIORITY_NORMAL} or
295 * {@link #PRIORITY_URGENT}.
296 *
297 * Reference: RCC.20 Section 2.4.4.2
298 */
299 public static final String EXTRA_PRIORITY = "android.telecom.extra.PRIORITY";
300
301 /**
302 * Extra for the call composer call location, an {@link android.location.Location} parcelable
303 * class to represent the geolocation as a latitude and longitude pair.
304 *
305 * Reference: RCC.20 Section 2.4.3.2
306 */
307 public static final String EXTRA_LOCATION = "android.telecom.extra.LOCATION";
308
309 /**
310 * A boolean extra set on incoming calls to indicate that the call has a picture specified.
311 * Given that image download could take a (short) time, the EXTRA is set immediately upon
312 * adding the call to the Dialer app, this allows the Dialer app to reserve space for an image
313 * if one is expected. The EXTRA may be unset if the image download ends up failing for some
314 * reason.
315 */
316 public static final String EXTRA_HAS_PICTURE = "android.telecom.extra.HAS_PICTURE";
317
318 /**
Hall Liu48c3c142021-03-11 16:14:22 -0800319 * A {@link Uri} representing the picture that was downloaded when a call is received or
320 * uploaded when a call is placed.
Hall Liu8fee7ea2021-01-21 16:37:51 -0800321 *
Shuo Qian3ed38832020-11-30 21:54:36 -0800322 * This is a content URI within the call log provider which can be used to open a file
323 * descriptor. This could be set a short time after a call is added to the Dialer app if the
Hall Liu8fee7ea2021-01-21 16:37:51 -0800324 * download/upload is delayed for some reason. The Dialer app will receive a callback via
Shuo Qian3ed38832020-11-30 21:54:36 -0800325 * {@link Call.Callback#onDetailsChanged} when this value has changed.
326 *
327 * Reference: RCC.20 Section 2.4.3.2
328 */
Hall Liu8fee7ea2021-01-21 16:37:51 -0800329 public static final String EXTRA_PICTURE_URI = "android.telecom.extra.PICTURE_URI";
Shuo Qian3ed38832020-11-30 21:54:36 -0800330
Shuo Qian3ed38832020-11-30 21:54:36 -0800331 /**
332 * A ParcelUuid used as a token to represent a picture that was uploaded prior to the call
Hall Liua749abc2021-01-21 10:05:43 -0800333 * being placed. The value of this extra should be set using the {@link android.os.ParcelUuid}
334 * obtained from the callback in {@link TelephonyManager#uploadCallComposerPicture}.
Shuo Qian3ed38832020-11-30 21:54:36 -0800335 */
336 public static final String EXTRA_OUTGOING_PICTURE = "android.telecom.extra.OUTGOING_PICTURE";
337
Tyler Gunn335ff2e2015-07-30 14:18:33 -0700338 /**
Yorke Lee04ea7d32015-06-05 15:59:18 -0700339 * The extra used by a {@link ConnectionService} to provide the handle of the caller that
340 * has initiated a new incoming call.
341 */
Yorke Lee02fb5bc2015-06-09 12:27:36 -0700342 public static final String EXTRA_INCOMING_CALL_ADDRESS =
343 "android.telecom.extra.INCOMING_CALL_ADDRESS";
Yorke Lee04ea7d32015-06-05 15:59:18 -0700344
345 /**
Santos Cordon96efb482014-07-19 14:57:05 -0700346 * Optional extra for {@link #ACTION_INCOMING_CALL} containing a {@link Bundle} which contains
347 * metadata about the call. This {@link Bundle} will be returned to the
348 * {@link ConnectionService}.
Evan Charlton10197192014-07-19 15:00:29 -0700349 */
350 public static final String EXTRA_INCOMING_CALL_EXTRAS =
Tyler Gunnef9f6f92014-09-12 22:16:17 -0700351 "android.telecom.extra.INCOMING_CALL_EXTRAS";
Evan Charlton10197192014-07-19 15:00:29 -0700352
353 /**
Joseph Pirozzo40ea5ee2018-01-02 16:15:23 -0800354 * Optional extra for {@link #ACTION_INCOMING_CALL} containing a boolean to indicate that the
355 * call has an externally generated ringer. Used by the HfpClientConnectionService when In Band
356 * Ringtone is enabled to prevent two ringers from being generated.
357 * @hide
358 */
359 public static final String EXTRA_CALL_EXTERNAL_RINGER =
360 "android.telecom.extra.CALL_EXTERNAL_RINGER";
361
362 /**
Nancy Chen10798dc2014-08-08 14:00:25 -0700363 * Optional extra for {@link android.content.Intent#ACTION_CALL} and
364 * {@link android.content.Intent#ACTION_DIAL} {@code Intent} containing a {@link Bundle}
365 * which contains metadata about the call. This {@link Bundle} will be saved into
Santos Cordon7a060d52015-06-19 14:52:04 -0700366 * {@code Call.Details} and passed to the {@link ConnectionService} when placing the call.
Nancy Chen10798dc2014-08-08 14:00:25 -0700367 */
368 public static final String EXTRA_OUTGOING_CALL_EXTRAS =
Tyler Gunnef9f6f92014-09-12 22:16:17 -0700369 "android.telecom.extra.OUTGOING_CALL_EXTRAS";
Nancy Chen10798dc2014-08-08 14:00:25 -0700370
371 /**
sqian6d9e7452019-02-08 21:42:15 -0800372 * An optional boolean extra on {@link android.content.Intent#ACTION_CALL_EMERGENCY} to tell
373 * whether the user's dial intent is emergency; this is required to specify when the dialed
374 * number is ambiguous, identified as both emergency number and any other non-emergency number;
375 * e.g. in some situation, 611 could be both an emergency number in a country and a
376 * non-emergency number of a carrier's customer service hotline.
377 *
378 * @hide
379 */
380 @SystemApi
381 public static final String EXTRA_IS_USER_INTENT_EMERGENCY_CALL =
382 "android.telecom.extra.IS_USER_INTENT_EMERGENCY_CALL";
383
384 /**
Hall Liuba820bd2020-01-22 17:17:13 -0800385 * A mandatory extra containing a {@link Uri} to be passed in when calling
386 * {@link #addNewUnknownCall(PhoneAccountHandle, Bundle)}. The {@link Uri} value indicates
387 * the remote handle of the new call.
Yorke Leec3cf9822014-10-02 09:38:39 -0700388 * @hide
389 */
Hall Liu2ef04112020-09-14 18:34:10 -0700390 @SystemApi
Yorke Leec3cf9822014-10-02 09:38:39 -0700391 public static final String EXTRA_UNKNOWN_CALL_HANDLE =
392 "android.telecom.extra.UNKNOWN_CALL_HANDLE";
393
394 /**
Sailesh Nepalda6bb382016-04-14 19:51:46 -0700395 * Optional extra for incoming and outgoing calls containing a long which specifies the time the
396 * call was created. This value is in milliseconds since boot.
Hall Liudbb17f12020-03-10 18:28:58 -0700397 * @hide
Sailesh Nepalda6bb382016-04-14 19:51:46 -0700398 */
399 public static final String EXTRA_CALL_CREATED_TIME_MILLIS =
400 "android.telecom.extra.CALL_CREATED_TIME_MILLIS";
401
402 /**
Jack Yu1e1ff942019-12-23 15:19:56 -0800403 * Optional extra for incoming and outgoing calls containing a long which specifies the Epoch
404 * time the call was created.
405 * @hide
406 */
407 public static final String EXTRA_CALL_CREATED_EPOCH_TIME_MILLIS =
408 "android.telecom.extra.CALL_CREATED_EPOCH_TIME_MILLIS";
409
410 /**
Sailesh Nepalda6bb382016-04-14 19:51:46 -0700411 * Optional extra for incoming and outgoing calls containing a long which specifies the time
412 * telecom began routing the call. This value is in milliseconds since boot.
413 * @hide
414 */
415 public static final String EXTRA_CALL_TELECOM_ROUTING_START_TIME_MILLIS =
416 "android.telecom.extra.CALL_TELECOM_ROUTING_START_TIME_MILLIS";
417
418 /**
419 * Optional extra for incoming and outgoing calls containing a long which specifies the time
420 * telecom finished routing the call. This value is in milliseconds since boot.
421 * @hide
422 */
423 public static final String EXTRA_CALL_TELECOM_ROUTING_END_TIME_MILLIS =
424 "android.telecom.extra.CALL_TELECOM_ROUTING_END_TIME_MILLIS";
425
426 /**
Evan Charlton6eb262c2014-07-19 18:18:19 -0700427 * Optional extra for {@link android.telephony.TelephonyManager#ACTION_PHONE_STATE_CHANGED}
428 * containing the disconnect code.
Evan Charlton10197192014-07-19 15:00:29 -0700429 */
430 public static final String EXTRA_CALL_DISCONNECT_CAUSE =
Tyler Gunnef9f6f92014-09-12 22:16:17 -0700431 "android.telecom.extra.CALL_DISCONNECT_CAUSE";
Evan Charlton10197192014-07-19 15:00:29 -0700432
433 /**
Evan Charlton6eb262c2014-07-19 18:18:19 -0700434 * Optional extra for {@link android.telephony.TelephonyManager#ACTION_PHONE_STATE_CHANGED}
435 * containing the disconnect message.
Evan Charlton10197192014-07-19 15:00:29 -0700436 */
437 public static final String EXTRA_CALL_DISCONNECT_MESSAGE =
Tyler Gunnef9f6f92014-09-12 22:16:17 -0700438 "android.telecom.extra.CALL_DISCONNECT_MESSAGE";
Evan Charlton10197192014-07-19 15:00:29 -0700439
440 /**
radhika0dd90652020-11-04 11:12:51 -0800441 * A string value for {@link #EXTRA_CALL_DISCONNECT_MESSAGE}, indicates the call was dropped by
442 * lower layers
443 * @hide
444 */
445 public static final String CALL_AUTO_DISCONNECT_MESSAGE_STRING =
446 "Call dropped by lower layers";
447
448 /**
Evan Charlton6eb262c2014-07-19 18:18:19 -0700449 * Optional extra for {@link android.telephony.TelephonyManager#ACTION_PHONE_STATE_CHANGED}
450 * containing the component name of the associated connection service.
Evan Charlton0e094d92014-11-08 15:49:16 -0800451 * @hide
Evan Charlton10197192014-07-19 15:00:29 -0700452 */
Evan Charlton0e094d92014-11-08 15:49:16 -0800453 @SystemApi
Evan Charlton10197192014-07-19 15:00:29 -0700454 public static final String EXTRA_CONNECTION_SERVICE =
Tyler Gunnef9f6f92014-09-12 22:16:17 -0700455 "android.telecom.extra.CONNECTION_SERVICE";
Evan Charlton10197192014-07-19 15:00:29 -0700456
457 /**
Hall Liuba820bd2020-01-22 17:17:13 -0800458 * Optional extra for communicating the call technology used by a {@link ConnectionService}
459 * to Telecom. Valid values are:
460 * <ul>
461 * <li>{@link TelephonyManager#PHONE_TYPE_CDMA}</li>
462 * <li>{@link TelephonyManager#PHONE_TYPE_GSM}</li>
463 * <li>{@link TelephonyManager#PHONE_TYPE_IMS}</li>
464 * <li>{@link TelephonyManager#PHONE_TYPE_THIRD_PARTY}</li>
465 * <li>{@link TelephonyManager#PHONE_TYPE_SIP}</li>
466 * </ul>
Hall Liu90f62902015-11-19 16:19:24 -0800467 * @hide
468 */
Hall Liu2ef04112020-09-14 18:34:10 -0700469 @SystemApi
Hall Liu90f62902015-11-19 16:19:24 -0800470 public static final String EXTRA_CALL_TECHNOLOGY_TYPE =
471 "android.telecom.extra.CALL_TECHNOLOGY_TYPE";
472
473 /**
Wei Huang7f7f72e2018-05-30 19:21:36 +0800474 * Optional extra for communicating the call network technology used by a
475 * {@link android.telecom.Connection} to Telecom and InCallUI.
476 *
Andrew Sapperstein8fe35e52020-04-28 12:29:20 -0700477 * {@code NETWORK_TYPE_*} in {@link android.telephony.TelephonyManager}.
Wei Huang7f7f72e2018-05-30 19:21:36 +0800478 */
479 public static final String EXTRA_CALL_NETWORK_TYPE =
480 "android.telecom.extra.CALL_NETWORK_TYPE";
481
482 /**
Nancy Chen7ab1dc42014-09-09 18:18:26 -0700483 * An optional {@link android.content.Intent#ACTION_CALL} intent extra denoting the
484 * package name of the app specifying an alternative gateway for the call.
485 * The value is a string.
486 *
487 * (The following comment corresponds to the all GATEWAY_* extras)
488 * An app which sends the {@link android.content.Intent#ACTION_CALL} intent can specify an
489 * alternative address to dial which is different from the one specified and displayed to
490 * the user. This alternative address is referred to as the gateway address.
491 */
492 public static final String GATEWAY_PROVIDER_PACKAGE =
Tyler Gunnef9f6f92014-09-12 22:16:17 -0700493 "android.telecom.extra.GATEWAY_PROVIDER_PACKAGE";
Nancy Chen7ab1dc42014-09-09 18:18:26 -0700494
495 /**
496 * An optional {@link android.content.Intent#ACTION_CALL} intent extra corresponding to the
497 * original address to dial for the call. This is used when an alternative gateway address is
498 * provided to recall the original address.
499 * The value is a {@link android.net.Uri}.
500 *
501 * (See {@link #GATEWAY_PROVIDER_PACKAGE} for details)
502 */
503 public static final String GATEWAY_ORIGINAL_ADDRESS =
Tyler Gunnef9f6f92014-09-12 22:16:17 -0700504 "android.telecom.extra.GATEWAY_ORIGINAL_ADDRESS";
Nancy Chen7ab1dc42014-09-09 18:18:26 -0700505
506 /**
Evan Charlton10197192014-07-19 15:00:29 -0700507 * The number which the party on the other side of the line will see (and use to return the
508 * call).
509 * <p>
Santos Cordon96efb482014-07-19 14:57:05 -0700510 * {@link ConnectionService}s which interact with {@link RemoteConnection}s should only populate
511 * this if the {@link android.telephony.TelephonyManager#getLine1Number()} value, as that is the
512 * user's expected caller ID.
Evan Charlton10197192014-07-19 15:00:29 -0700513 */
Tyler Gunnef9f6f92014-09-12 22:16:17 -0700514 public static final String EXTRA_CALL_BACK_NUMBER = "android.telecom.extra.CALL_BACK_NUMBER";
Evan Charlton10197192014-07-19 15:00:29 -0700515
516 /**
Hall Liu8f613fb2017-02-14 18:11:11 -0800517 * The number of milliseconds that Telecom should wait after disconnecting a call via the
518 * ACTION_NEW_OUTGOING_CALL broadcast, in order to wait for the app which cancelled the call
519 * to make a new one.
520 * @hide
521 */
522 public static final String EXTRA_NEW_OUTGOING_CALL_CANCEL_TIMEOUT =
523 "android.telecom.extra.NEW_OUTGOING_CALL_CANCEL_TIMEOUT";
524
525 /**
Tyler Gunn9f6f0472017-04-17 18:25:22 -0700526 * Boolean extra specified to indicate that the intention of adding a call is to handover an
Tyler Gunn8bf76572017-04-06 15:30:08 -0700527 * existing call from the user's device to a different {@link PhoneAccount}.
528 * <p>
Tyler Gunn9f6f0472017-04-17 18:25:22 -0700529 * Used when calling {@link #addNewIncomingCall(PhoneAccountHandle, Bundle)}
530 * to indicate to Telecom that the purpose of adding a new incoming call is to handover an
531 * existing call from the user's device to a different {@link PhoneAccount}. This occurs on
532 * the receiving side of a handover.
533 * <p>
534 * Used when Telecom calls
535 * {@link ConnectionService#onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}
536 * to indicate that the purpose of Telecom requesting a new outgoing connection it to request
537 * a handover to this {@link ConnectionService} from an ongoing call on the user's device. This
538 * occurs on the initiating side of a handover.
539 * <p>
Tyler Gunn727c6bd2017-04-11 09:51:40 -0700540 * The phone number of the call used by Telecom to determine which call should be handed over.
Tyler Gunn8bf76572017-04-06 15:30:08 -0700541 * @hide
Tyler Gunn6e3ecc42018-11-12 11:30:56 -0800542 * @deprecated Use the public handover APIs. See
543 * {@link Call#handoverTo(PhoneAccountHandle, int, Bundle)} for more information.
Tyler Gunn8bf76572017-04-06 15:30:08 -0700544 */
Tyler Gunn6e3ecc42018-11-12 11:30:56 -0800545 @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 119305590)
Tyler Gunn8bf76572017-04-06 15:30:08 -0700546 public static final String EXTRA_IS_HANDOVER = "android.telecom.extra.IS_HANDOVER";
547
548 /**
Tyler Gunn79bc1ec2018-01-22 15:17:54 -0800549 * When {@code true} indicates that a request to create a new connection is for the purpose of
550 * a handover. Note: This is used with the
551 * {@link android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle)} API as part of the
552 * internal communication mechanism with the {@link android.telecom.ConnectionService}. It is
553 * not the same as the legacy {@link #EXTRA_IS_HANDOVER} extra.
554 * @hide
555 */
556 public static final String EXTRA_IS_HANDOVER_CONNECTION =
557 "android.telecom.extra.IS_HANDOVER_CONNECTION";
558
559 /**
Tyler Gunn3af38692017-05-26 13:30:09 -0700560 * Parcelable extra used with {@link #EXTRA_IS_HANDOVER} to indicate the source
561 * {@link PhoneAccountHandle} when initiating a handover which {@link ConnectionService}
562 * the handover is from.
563 * @hide
564 */
565 public static final String EXTRA_HANDOVER_FROM_PHONE_ACCOUNT =
566 "android.telecom.extra.HANDOVER_FROM_PHONE_ACCOUNT";
567
568 /**
Tyler Gunn9f6f0472017-04-17 18:25:22 -0700569 * Extra key specified in the {@link ConnectionRequest#getExtras()} when Telecom calls
570 * {@link ConnectionService#onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)}
571 * to inform the {@link ConnectionService} what the initial {@link CallAudioState} of the
572 * {@link Connection} will be.
573 * @hide
574 */
575 public static final String EXTRA_CALL_AUDIO_STATE = "android.telecom.extra.CALL_AUDIO_STATE";
576
577 /**
Hall Liu95d55872017-01-25 17:12:49 -0800578 * A boolean extra, which when set on the {@link Intent#ACTION_CALL} intent or on the bundle
579 * passed into {@link #placeCall(Uri, Bundle)}, indicates that the call should be initiated with
580 * an RTT session open. See {@link android.telecom.Call.RttCall} for more information on RTT.
581 */
582 public static final String EXTRA_START_CALL_WITH_RTT =
583 "android.telecom.extra.START_CALL_WITH_RTT";
584
585 /**
Grace Jia91cec6e2019-12-16 14:23:05 -0800586 * Start an activity indicating that the completion of an outgoing call or an incoming call
587 * which was not blocked by the {@link CallScreeningService}, and which was NOT terminated
588 * while the call was in {@link Call#STATE_AUDIO_PROCESSING}.
589 *
590 * The {@link Uri} extra {@link #EXTRA_HANDLE} will contain the uri handle(phone number) for the
591 * call which completed.
592 *
593 * The integer extra {@link #EXTRA_DISCONNECT_CAUSE} will indicate the reason for the call
594 * disconnection. See {@link #EXTRA_DISCONNECT_CAUSE} for more information.
595 *
596 * The integer extra {@link #EXTRA_CALL_DURATION} will indicate the duration of the call. See
597 * {@link #EXTRA_CALL_DURATION} for more information.
598 */
599 public static final String ACTION_POST_CALL = "android.telecom.action.POST_CALL";
600
601 /**
602 * A {@link Uri} extra, which when set on the {@link #ACTION_POST_CALL} intent, indicates the
603 * uri handle(phone number) of the completed call.
604 */
605 public static final String EXTRA_HANDLE = "android.telecom.extra.HANDLE";
606
607 /**
608 * A integer value provided for completed calls to indicate the reason for the call
609 * disconnection.
610 * <p>
611 * Allowed values:
612 * <ul>
613 * <li>{@link DisconnectCause#UNKNOWN}</li>
614 * <li>{@link DisconnectCause#LOCAL}</li>
615 * <li>{@link DisconnectCause#REMOTE}</li>
616 * <li>{@link DisconnectCause#REJECTED}</li>
617 * <li>{@link DisconnectCause#MISSED}</li>
618 * </ul>
619 * </p>
620 */
621 public static final String EXTRA_DISCONNECT_CAUSE = "android.telecom.extra.DISCONNECT_CAUSE";
622
623 /**
624 * A integer value provided for completed calls to indicate the duration of the call.
625 * <p>
626 * Allowed values:
627 * <ul>
628 * <li>{@link #DURATION_VERY_SHORT}</li>
629 * <li>{@link #DURATION_SHORT}</li>
630 * <li>{@link #DURATION_MEDIUM}</li>
631 * <li>{@link #DURATION_LONG}</li>
632 * </ul>
633 * </p>
634 */
635 public static final String EXTRA_CALL_DURATION = "android.telecom.extra.CALL_DURATION";
636
637 /**
638 * A integer value for {@link #EXTRA_CALL_DURATION}, indicates the duration of the completed
639 * call was < 3 seconds.
640 */
641 public static final int DURATION_VERY_SHORT = 0;
642
643 /**
644 * A integer value for {@link #EXTRA_CALL_DURATION}, indicates the duration of the completed
645 * call was >= 3 seconds and < 60 seconds.
646 */
647 public static final int DURATION_SHORT = 1;
648
649 /**
650 * A integer value for {@link #EXTRA_CALL_DURATION}, indicates the duration of the completed
651 * call was >= 60 seconds and < 120 seconds.
652 */
653 public static final int DURATION_MEDIUM = 2;
654
655 /**
656 * A integer value for {@link #EXTRA_CALL_DURATION}, indicates the duration of the completed
657 * call was >= 120 seconds.
658 */
659 public static final int DURATION_LONG = 3;
660
661 /**
662 * The threshold between {@link #DURATION_VERY_SHORT} calls and {@link #DURATION_SHORT} calls in
663 * milliseconds.
664 * @hide
665 */
666 public static final long VERY_SHORT_CALL_TIME_MS = 3000;
667
668 /**
669 * The threshold between {@link #DURATION_SHORT} calls and {@link #DURATION_MEDIUM} calls in
670 * milliseconds.
671 * @hide
672 */
673 public static final long SHORT_CALL_TIME_MS = 60000;
674
675 /**
676 * The threshold between {@link #DURATION_MEDIUM} calls and {@link #DURATION_LONG} calls in
677 * milliseconds.
678 * @hide
679 */
680 public static final long MEDIUM_CALL_TIME_MS = 120000;
681
682 /**
Santos Cordonf2600eb2015-06-22 15:02:20 -0700683 * A boolean meta-data value indicating whether an {@link InCallService} implements an
684 * in-call user interface. Dialer implementations (see {@link #getDefaultDialerPackage()}) which
685 * would also like to replace the in-call interface should set this meta-data to {@code true} in
686 * the manifest registration of their {@link InCallService}.
687 */
688 public static final String METADATA_IN_CALL_SERVICE_UI = "android.telecom.IN_CALL_SERVICE_UI";
689
690 /**
Santos Cordon88881552015-12-10 17:29:54 -0800691 * A boolean meta-data value indicating whether an {@link InCallService} implements an
692 * in-call user interface to be used while the device is in car-mode (see
Hector Dearman923382c2018-12-13 16:42:33 +0000693 * {@link android.content.res.Configuration#UI_MODE_TYPE_CAR}).
Santos Cordon88881552015-12-10 17:29:54 -0800694 */
695 public static final String METADATA_IN_CALL_SERVICE_CAR_MODE_UI =
696 "android.telecom.IN_CALL_SERVICE_CAR_MODE_UI";
697
698 /**
Sailesh Nepal9c2618b2016-01-23 16:28:22 -0800699 * A boolean meta-data value indicating whether an {@link InCallService} implements ringing.
700 * Dialer implementations (see {@link #getDefaultDialerPackage()}) which would also like to
701 * override the system provided ringing should set this meta-data to {@code true} in the
702 * manifest registration of their {@link InCallService}.
Tyler Gunn556d2402019-04-10 08:59:43 -0700703 * <p>
704 * When {@code true}, it is the {@link InCallService}'s responsibility to play a ringtone for
705 * all incoming calls.
Sailesh Nepal9c2618b2016-01-23 16:28:22 -0800706 */
707 public static final String METADATA_IN_CALL_SERVICE_RINGING =
708 "android.telecom.IN_CALL_SERVICE_RINGING";
709
710 /**
Tyler Gunn876dbfb2016-03-14 15:18:07 -0700711 * A boolean meta-data value indicating whether an {@link InCallService} wants to be informed of
712 * calls which have the {@link Call.Details#PROPERTY_IS_EXTERNAL_CALL} property. An external
713 * call is one which a {@link ConnectionService} knows about, but is not connected to directly.
714 * Dialer implementations (see {@link #getDefaultDialerPackage()}) which would like to be
715 * informed of external calls should set this meta-data to {@code true} in the manifest
716 * registration of their {@link InCallService}. By default, the {@link InCallService} will NOT
717 * be informed of external calls.
718 */
719 public static final String METADATA_INCLUDE_EXTERNAL_CALLS =
720 "android.telecom.INCLUDE_EXTERNAL_CALLS";
721
722 /**
Tyler Gunn24e18332017-02-10 09:42:49 -0800723 * A boolean meta-data value indicating whether an {@link InCallService} wants to be informed of
724 * calls which have the {@link Call.Details#PROPERTY_SELF_MANAGED} property. A self-managed
725 * call is one which originates from a self-managed {@link ConnectionService} which has chosen
726 * to implement its own call user interface. An {@link InCallService} implementation which
727 * would like to be informed of external calls should set this meta-data to {@code true} in the
728 * manifest registration of their {@link InCallService}. By default, the {@link InCallService}
729 * will NOT be informed about self-managed calls.
730 * <p>
731 * An {@link InCallService} which receives self-managed calls is free to view and control the
732 * state of calls in the self-managed {@link ConnectionService}. An example use-case is
Tyler Gunn37653562017-03-13 18:15:15 -0700733 * exposing these calls to an automotive device via its companion app.
734 * <p>
735 * This meta-data can only be set for an {@link InCallService} which also sets
736 * {@link #METADATA_IN_CALL_SERVICE_UI}. Only the default phone/dialer app, or a car-mode
737 * {@link InCallService} can see self-managed calls.
Tyler Gunn24e18332017-02-10 09:42:49 -0800738 * <p>
739 * See also {@link Connection#PROPERTY_SELF_MANAGED}.
740 */
741 public static final String METADATA_INCLUDE_SELF_MANAGED_CALLS =
742 "android.telecom.INCLUDE_SELF_MANAGED_CALLS";
743
744 /**
Evan Charlton10197192014-07-19 15:00:29 -0700745 * The dual tone multi-frequency signaling character sent to indicate the dialing system should
746 * pause for a predefined period.
747 */
748 public static final char DTMF_CHARACTER_PAUSE = ',';
749
750 /**
751 * The dual-tone multi-frequency signaling character sent to indicate the dialing system should
752 * wait for user confirmation before proceeding.
753 */
754 public static final char DTMF_CHARACTER_WAIT = ';';
755
756 /**
Tyler Gunn6e3ecc42018-11-12 11:30:56 -0800757 * @hide
758 */
759 @IntDef(prefix = { "TTY_MODE_" },
760 value = {TTY_MODE_OFF, TTY_MODE_FULL, TTY_MODE_HCO, TTY_MODE_VCO})
761 @Retention(RetentionPolicy.SOURCE)
762 public @interface TtyMode {}
763
764 /**
Evan Charlton10197192014-07-19 15:00:29 -0700765 * TTY (teletypewriter) mode is off.
766 *
767 * @hide
768 */
Tyler Gunn6e3ecc42018-11-12 11:30:56 -0800769 @SystemApi
Evan Charlton10197192014-07-19 15:00:29 -0700770 public static final int TTY_MODE_OFF = 0;
771
772 /**
773 * TTY (teletypewriter) mode is on. The speaker is off and the microphone is muted. The user
774 * will communicate with the remote party by sending and receiving text messages.
775 *
776 * @hide
777 */
Tyler Gunn6e3ecc42018-11-12 11:30:56 -0800778 @SystemApi
Evan Charlton10197192014-07-19 15:00:29 -0700779 public static final int TTY_MODE_FULL = 1;
780
781 /**
782 * TTY (teletypewriter) mode is in hearing carryover mode (HCO). The microphone is muted but the
783 * speaker is on. The user will communicate with the remote party by sending text messages and
784 * hearing an audible reply.
785 *
786 * @hide
787 */
Tyler Gunn6e3ecc42018-11-12 11:30:56 -0800788 @SystemApi
Evan Charlton10197192014-07-19 15:00:29 -0700789 public static final int TTY_MODE_HCO = 2;
790
791 /**
792 * TTY (teletypewriter) mode is in voice carryover mode (VCO). The speaker is off but the
793 * microphone is still on. User will communicate with the remote party by speaking and receiving
794 * text message replies.
795 *
796 * @hide
797 */
Tyler Gunn6e3ecc42018-11-12 11:30:56 -0800798 @SystemApi
Evan Charlton10197192014-07-19 15:00:29 -0700799 public static final int TTY_MODE_VCO = 3;
800
801 /**
Hall Liu2ef04112020-09-14 18:34:10 -0700802 * Broadcast intent action indicating that the current TTY mode has changed.
Evan Charlton10197192014-07-19 15:00:29 -0700803 *
Hall Liu2ef04112020-09-14 18:34:10 -0700804 * This intent will contain {@link #EXTRA_CURRENT_TTY_MODE} as an intent extra, giving the new
805 * TTY mode.
Evan Charlton10197192014-07-19 15:00:29 -0700806 * @hide
807 */
Hall Liu2ef04112020-09-14 18:34:10 -0700808 @SystemApi
Evan Charlton10197192014-07-19 15:00:29 -0700809 public static final String ACTION_CURRENT_TTY_MODE_CHANGED =
Tyler Gunnef9f6f92014-09-12 22:16:17 -0700810 "android.telecom.action.CURRENT_TTY_MODE_CHANGED";
Evan Charlton10197192014-07-19 15:00:29 -0700811
812 /**
Hall Liu2ef04112020-09-14 18:34:10 -0700813 * Integer extra key that indicates the current TTY mode.
814 *
815 * Used with {@link #ACTION_CURRENT_TTY_MODE_CHANGED}.
816 *
817 * Valid modes are:
818 * <ul>
819 * <li>{@link #TTY_MODE_OFF}</li>
820 * <li>{@link #TTY_MODE_FULL}</li>
821 * <li>{@link #TTY_MODE_HCO}</li>
822 * <li>{@link #TTY_MODE_VCO}</li>
823 * </ul>
824 *
825 * This TTY mode is distinct from the one sent via {@link #ACTION_TTY_PREFERRED_MODE_CHANGED},
826 * since the current TTY mode will always be {@link #TTY_MODE_OFF}unless a TTY terminal is
827 * plugged into the device.
828 * @hide
829 */
Hall Liu2ef04112020-09-14 18:34:10 -0700830 @SystemApi
831 public static final String EXTRA_CURRENT_TTY_MODE =
832 "android.telecom.extra.CURRENT_TTY_MODE";
833
834 /**
835 * Broadcast intent action indicating that the TTY preferred operating mode has changed.
836 *
837 * This intent will contain {@link #EXTRA_TTY_PREFERRED_MODE} as an intent extra, giving the new
838 * preferred TTY mode.
839 * @hide
840 */
Hall Liu2ef04112020-09-14 18:34:10 -0700841 @SystemApi
842 public static final String ACTION_TTY_PREFERRED_MODE_CHANGED =
843 "android.telecom.action.TTY_PREFERRED_MODE_CHANGED";
844
845 /**
846 * Integer extra key that indicates the preferred TTY mode.
847 *
848 * Used with {@link #ACTION_TTY_PREFERRED_MODE_CHANGED}.
849 *
Evan Charlton10197192014-07-19 15:00:29 -0700850 * Valid modes are:
Hall Liuba820bd2020-01-22 17:17:13 -0800851 * <ul>
852 * <li>{@link #TTY_MODE_OFF}</li>
853 * <li>{@link #TTY_MODE_FULL}</li>
854 * <li>{@link #TTY_MODE_HCO}</li>
855 * <li>{@link #TTY_MODE_VCO}</li>
856 * </ul>
Evan Charlton10197192014-07-19 15:00:29 -0700857 * @hide
858 */
Hall Liu2ef04112020-09-14 18:34:10 -0700859 @SystemApi
Evan Charlton10197192014-07-19 15:00:29 -0700860 public static final String EXTRA_TTY_PREFERRED_MODE =
Hall Liuba820bd2020-01-22 17:17:13 -0800861 "android.telecom.extra.TTY_PREFERRED_MODE";
Evan Charlton10197192014-07-19 15:00:29 -0700862
Nancy Chen9d568c02014-09-08 14:17:59 -0700863 /**
Bryce Lee5e4dd3e2015-08-03 16:59:10 -0700864 * Broadcast intent action for letting custom component know to show the missed call
Sailesh Nepalbe15ad92016-01-21 19:26:20 -0800865 * notification. If no custom component exists then this is sent to the default dialer which
866 * should post a missed-call notification.
Bryce Lee5e4dd3e2015-08-03 16:59:10 -0700867 */
Bryce Lee5e4dd3e2015-08-03 16:59:10 -0700868 public static final String ACTION_SHOW_MISSED_CALLS_NOTIFICATION =
869 "android.telecom.action.SHOW_MISSED_CALLS_NOTIFICATION";
870
871 /**
Sailesh Nepalbe15ad92016-01-21 19:26:20 -0800872 * The number of calls associated with the notification. If the number is zero then the missed
873 * call notification should be dismissed.
Bryce Lee5e4dd3e2015-08-03 16:59:10 -0700874 */
Bryce Lee5e4dd3e2015-08-03 16:59:10 -0700875 public static final String EXTRA_NOTIFICATION_COUNT =
876 "android.telecom.extra.NOTIFICATION_COUNT";
877
878 /**
879 * The number associated with the missed calls. This number is only relevant
880 * when EXTRA_NOTIFICATION_COUNT is 1.
Bryce Lee5e4dd3e2015-08-03 16:59:10 -0700881 */
Bryce Lee5e4dd3e2015-08-03 16:59:10 -0700882 public static final String EXTRA_NOTIFICATION_PHONE_NUMBER =
883 "android.telecom.extra.NOTIFICATION_PHONE_NUMBER";
884
885 /**
Bryce Lee8d41d1d2015-08-10 07:40:42 -0700886 * The intent to clear missed calls.
887 * @hide
888 */
889 @SystemApi
890 public static final String EXTRA_CLEAR_MISSED_CALLS_INTENT =
891 "android.telecom.extra.CLEAR_MISSED_CALLS_INTENT";
892
893 /**
894 * The intent to call back a missed call.
895 * @hide
896 */
897 @SystemApi
898 public static final String EXTRA_CALL_BACK_INTENT =
899 "android.telecom.extra.CALL_BACK_INTENT";
900
901 /**
Charles He858f1322017-11-27 17:11:04 -0800902 * The dialer activity responsible for placing emergency calls from, for example, a locked
903 * keyguard.
904 * @hide
905 */
906 public static final ComponentName EMERGENCY_DIALER_COMPONENT =
907 ComponentName.createRelative("com.android.phone", ".EmergencyDialer");
908
909 /**
Eric Erfanian62706c52017-12-06 16:27:53 -0800910 * The boolean indicated by this extra controls whether or not a call is eligible to undergo
911 * assisted dialing. This extra is stored under {@link #EXTRA_OUTGOING_CALL_EXTRAS}.
Tyler Gunn00d737b2019-10-31 13:04:37 -0700912 * <p>
913 * The call initiator can use this extra to indicate that a call used assisted dialing to help
914 * place the call. This is most commonly used by a Dialer app which provides the ability to
915 * automatically add dialing prefixes when placing international calls.
916 * <p>
917 * Setting this extra on the outgoing call extras will cause the
Tyler Gunn754493b2020-01-27 10:30:51 -0800918 * {@link Connection#PROPERTY_ASSISTED_DIALING} property and
919 * {@link Call.Details#PROPERTY_ASSISTED_DIALING} property to be set on the
Tyler Gunn00d737b2019-10-31 13:04:37 -0700920 * {@link Connection}/{@link Call} in question. When the call is logged to the call log, the
921 * {@link android.provider.CallLog.Calls#FEATURES_ASSISTED_DIALING_USED} call feature is set to
922 * indicate that assisted dialing was used for the call.
Eric Erfanian62706c52017-12-06 16:27:53 -0800923 */
924 public static final String EXTRA_USE_ASSISTED_DIALING =
925 "android.telecom.extra.USE_ASSISTED_DIALING";
926
927 /**
Shaotang Li8cec25c2018-07-19 17:29:39 +0800928 * Optional extra for {@link #placeCall(Uri, Bundle)} containing an integer that specifies
929 * the source where user initiated this call. This data is used in metrics.
Hall Liuba820bd2020-01-22 17:17:13 -0800930 * Valid sources are:
931 * {@link TelecomManager#CALL_SOURCE_UNSPECIFIED},
932 * {@link TelecomManager#CALL_SOURCE_EMERGENCY_DIALPAD},
933 * {@link TelecomManager#CALL_SOURCE_EMERGENCY_SHORTCUT}.
Shaotang Li8cec25c2018-07-19 17:29:39 +0800934 *
Hall Liu2ef04112020-09-14 18:34:10 -0700935 * Intended for use with the platform emergency dialer only.
Shaotang Li8cec25c2018-07-19 17:29:39 +0800936 * @hide
937 */
Hall Liu2ef04112020-09-14 18:34:10 -0700938 @SystemApi
Shaotang Li8cec25c2018-07-19 17:29:39 +0800939 public static final String EXTRA_CALL_SOURCE = "android.telecom.extra.CALL_SOURCE";
940
941 /**
Hall Liuba820bd2020-01-22 17:17:13 -0800942 * Indicating the call is initiated via emergency dialer's shortcut button.
943 *
944 * @hide
945 */
Hall Liu2ef04112020-09-14 18:34:10 -0700946 @SystemApi
Hall Liuba820bd2020-01-22 17:17:13 -0800947 public static final int CALL_SOURCE_EMERGENCY_SHORTCUT = 2;
948
949 /**
950 * Indicating the call is initiated via emergency dialer's dialpad.
951 *
952 * @hide
953 */
Hall Liu2ef04112020-09-14 18:34:10 -0700954 @SystemApi
Hall Liuba820bd2020-01-22 17:17:13 -0800955 public static final int CALL_SOURCE_EMERGENCY_DIALPAD = 1;
956
957 /**
958 * Indicating the call source is not specified.
959 *
960 * @hide
961 */
Hall Liu2ef04112020-09-14 18:34:10 -0700962 @SystemApi
Hall Liuba820bd2020-01-22 17:17:13 -0800963 public static final int CALL_SOURCE_UNSPECIFIED = 0;
964
965 /**
Nancy Chen9d568c02014-09-08 14:17:59 -0700966 * The following 4 constants define how properties such as phone numbers and names are
967 * displayed to the user.
968 */
969
Santos Cordoned769ae2015-05-13 18:47:38 -0700970 /**
971 * Indicates that the address or number of a call is allowed to be displayed for caller ID.
Charles He858f1322017-11-27 17:11:04 -0800972 */
Nancy Chen9d568c02014-09-08 14:17:59 -0700973 public static final int PRESENTATION_ALLOWED = 1;
974
Santos Cordoned769ae2015-05-13 18:47:38 -0700975 /**
976 * Indicates that the address or number of a call is blocked by the other party.
977 */
Nancy Chen9d568c02014-09-08 14:17:59 -0700978 public static final int PRESENTATION_RESTRICTED = 2;
979
Santos Cordoned769ae2015-05-13 18:47:38 -0700980 /**
981 * Indicates that the address or number of a call is not specified or known by the carrier.
982 */
Nancy Chen9d568c02014-09-08 14:17:59 -0700983 public static final int PRESENTATION_UNKNOWN = 3;
984
Santos Cordoned769ae2015-05-13 18:47:38 -0700985 /**
986 * Indicates that the address or number of a call belongs to a pay phone.
987 */
Nancy Chen9d568c02014-09-08 14:17:59 -0700988 public static final int PRESENTATION_PAYPHONE = 4;
989
Hall Liu4a9fde12020-01-16 17:38:46 -0800990
991 /*
992 * Values for the adb property "persist.radio.videocall.audio.output"
993 */
994 /** @hide */
995 public static final int AUDIO_OUTPUT_ENABLE_SPEAKER = 0;
996 /** @hide */
997 public static final int AUDIO_OUTPUT_DISABLE_SPEAKER = 1;
998 /** @hide */
999 public static final int AUDIO_OUTPUT_DEFAULT = AUDIO_OUTPUT_ENABLE_SPEAKER;
1000
Tyler Gunn00d737b2019-10-31 13:04:37 -07001001 /** @hide */
1002 @Retention(RetentionPolicy.SOURCE)
1003 @IntDef(
1004 prefix = { "PRESENTATION_" },
1005 value = {PRESENTATION_ALLOWED, PRESENTATION_RESTRICTED, PRESENTATION_UNKNOWN,
1006 PRESENTATION_PAYPHONE})
1007 public @interface Presentation {}
1008
Brad Ebingera8366ae2021-03-23 21:01:51 +00001009
1010 /**
1011 * Enable READ_PHONE_STATE protection on APIs querying and notifying call state, such as
1012 * {@code TelecomManager#getCallState}, {@link TelephonyManager#getCallStateForSubscription()},
1013 * and {@link android.telephony.TelephonyCallback.CallStateListener}.
Brad Ebingerd0812632021-04-17 16:11:42 -07001014 * @hide
Brad Ebingera8366ae2021-03-23 21:01:51 +00001015 */
1016 @ChangeId
1017 @EnabledSince(targetSdkVersion = Build.VERSION_CODES.S)
1018 // this magic number is a bug ID
1019 public static final long ENABLE_GET_CALL_STATE_PERMISSION_PROTECTION = 157233955L;
1020
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001021 private static final String TAG = "TelecomManager";
Yorke Leeb4ce1432014-06-09 13:53:23 -07001022
Kevin Jeon767cda32020-11-17 01:40:16 +00001023
1024 /** Cached service handles, cleared by resetServiceCache() at death */
1025 private static final Object CACHE_LOCK = new Object();
1026
1027 @GuardedBy("CACHE_LOCK")
1028 private static ITelecomService sTelecomService;
1029 @GuardedBy("CACHE_LOCK")
1030 private static final DeathRecipient SERVICE_DEATH = new DeathRecipient();
1031
Yorke Leeb4ce1432014-06-09 13:53:23 -07001032 private final Context mContext;
Yorke Leeb4ce1432014-06-09 13:53:23 -07001033
Hall Liue1bc2ec2015-10-09 15:58:37 -07001034 private final ITelecomService mTelecomServiceOverride;
1035
Santos Cordon6c7a3882014-06-25 15:30:08 -07001036 /**
1037 * @hide
1038 */
Chen Xu4c0b06d2018-10-22 16:54:39 +00001039 @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001040 public static TelecomManager from(Context context) {
1041 return (TelecomManager) context.getSystemService(Context.TELECOM_SERVICE);
Yorke Leeb4ce1432014-06-09 13:53:23 -07001042 }
Santos Cordon6c7a3882014-06-25 15:30:08 -07001043
1044 /**
1045 * @hide
1046 */
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001047 public TelecomManager(Context context) {
Hall Liue1bc2ec2015-10-09 15:58:37 -07001048 this(context, null);
1049 }
1050
1051 /**
1052 * @hide
1053 */
1054 public TelecomManager(Context context, ITelecomService telecomServiceImpl) {
Ihab Awad807fe0a2014-07-09 12:30:52 -07001055 Context appContext = context.getApplicationContext();
Philip P. Moltmann12ac3f42020-03-05 15:01:29 -08001056 if (appContext != null && Objects.equals(context.getAttributionTag(),
1057 appContext.getAttributionTag())) {
Ihab Awad807fe0a2014-07-09 12:30:52 -07001058 mContext = appContext;
1059 } else {
1060 mContext = context;
1061 }
Hall Liue1bc2ec2015-10-09 15:58:37 -07001062 mTelecomServiceOverride = telecomServiceImpl;
Ihab Awad807fe0a2014-07-09 12:30:52 -07001063 }
1064
1065 /**
Santos Cordon91371dc02015-05-08 13:52:09 -07001066 * Return the {@link PhoneAccount} which will be used to place outgoing calls to addresses with
1067 * the specified {@code uriScheme}. This {@link PhoneAccount} will always be a member of the
1068 * list which is returned from invoking {@link #getCallCapablePhoneAccounts()}. The specific
1069 * account returned depends on the following priorities:
1070 * <ul>
1071 * <li> If the user-selected default {@link PhoneAccount} supports the specified scheme, it will
1072 * be returned.
1073 * </li>
1074 * <li> If there exists only one {@link PhoneAccount} that supports the specified scheme, it
1075 * will be returned.
1076 * </li>
1077 * </ul>
Ihab Awad94cf4bf2014-07-17 11:21:19 -07001078 * <p>
Santos Cordon91371dc02015-05-08 13:52:09 -07001079 * If no {@link PhoneAccount} fits the criteria above, this method will return {@code null}.
1080 *
Tyler Gunnf5b29dc2014-09-03 09:09:12 -07001081 * @param uriScheme The URI scheme.
Santos Cordon91371dc02015-05-08 13:52:09 -07001082 * @return The {@link PhoneAccountHandle} corresponding to the account to be used.
Ihab Awad94cf4bf2014-07-17 11:21:19 -07001083 */
Yorke Leec61d13662015-09-21 17:25:25 -07001084 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE)
Tyler Gunnf5b29dc2014-09-03 09:09:12 -07001085 public PhoneAccountHandle getDefaultOutgoingPhoneAccount(String uriScheme) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001086 ITelecomService service = getTelecomService();
1087 if (service != null) {
1088 try {
1089 return service.getDefaultOutgoingPhoneAccount(uriScheme,
Philip P. Moltmann12ac3f42020-03-05 15:01:29 -08001090 mContext.getOpPackageName(), mContext.getAttributionTag());
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001091 } catch (RemoteException e) {
1092 Log.e(TAG, "Error calling ITelecomService#getDefaultOutgoingPhoneAccount", e);
Ihab Awad94cf4bf2014-07-17 11:21:19 -07001093 }
Ihab Awad94cf4bf2014-07-17 11:21:19 -07001094 }
1095 return null;
1096 }
1097
1098 /**
Andrew Leed4abbfb2014-09-03 14:58:27 -07001099 * Return the {@link PhoneAccount} which is the user-chosen default for making outgoing phone
1100 * calls. This {@code PhoneAccount} will always be a member of the list which is returned from
Nancy Chen210ef032014-09-15 17:58:42 -07001101 * calling {@link #getCallCapablePhoneAccounts()}
Santos Cordon91371dc02015-05-08 13:52:09 -07001102 * <p>
Andrew Leed4abbfb2014-09-03 14:58:27 -07001103 * Apps must be prepared for this method to return {@code null}, indicating that there currently
1104 * exists no user-chosen default {@code PhoneAccount}.
Tyler Gunn36c50ed2018-11-15 07:29:49 -08001105 * <p>
1106 * The default dialer has access to use this method.
Andrew Leed4abbfb2014-09-03 14:58:27 -07001107 *
Slava Shklyaeve65e4012019-03-04 16:02:34 +00001108 * @return The user outgoing phone account selected by the user, or {@code null} if there is no
1109 * user selected outgoing {@link PhoneAccountHandle}.
Andrew Leed4abbfb2014-09-03 14:58:27 -07001110 */
Tyler Gunn36c50ed2018-11-15 07:29:49 -08001111 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE)
Slava Shklyaeve65e4012019-03-04 16:02:34 +00001112 public @Nullable PhoneAccountHandle getUserSelectedOutgoingPhoneAccount() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001113 ITelecomService service = getTelecomService();
1114 if (service != null) {
1115 try {
1116 return service.getUserSelectedOutgoingPhoneAccount(
Tyler Gunn36c50ed2018-11-15 07:29:49 -08001117 mContext.getOpPackageName());
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001118 } catch (RemoteException e) {
1119 Log.e(TAG, "Error calling ITelecomService#getUserSelectedOutgoingPhoneAccount", e);
Andrew Leed4abbfb2014-09-03 14:58:27 -07001120 }
Andrew Leed4abbfb2014-09-03 14:58:27 -07001121 }
1122 return null;
1123 }
1124
1125 /**
Tyler Gunn36c50ed2018-11-15 07:29:49 -08001126 * Sets the user-chosen default {@link PhoneAccountHandle} for making outgoing phone calls.
1127 *
1128 * @param accountHandle The {@link PhoneAccountHandle} which will be used by default for making
Slava Shklyaeve65e4012019-03-04 16:02:34 +00001129 * outgoing voice calls, or {@code null} if no default is specified (the
1130 * user will be asked each time a call is placed in this case).
Andrew Lee59cac3a2014-08-28 16:50:10 -07001131 * @hide
1132 */
Tyler Gunn36c50ed2018-11-15 07:29:49 -08001133 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE)
1134 @SystemApi
Slava Shklyaeve65e4012019-03-04 16:02:34 +00001135 public void setUserSelectedOutgoingPhoneAccount(@Nullable PhoneAccountHandle accountHandle) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001136 ITelecomService service = getTelecomService();
1137 if (service != null) {
1138 try {
1139 service.setUserSelectedOutgoingPhoneAccount(accountHandle);
1140 } catch (RemoteException e) {
1141 Log.e(TAG, "Error calling ITelecomService#setUserSelectedOutgoingPhoneAccount");
Andrew Lee59cac3a2014-08-28 16:50:10 -07001142 }
Andrew Lee59cac3a2014-08-28 16:50:10 -07001143 }
1144 }
1145
1146 /**
Andrew Lee59cac3a2014-08-28 16:50:10 -07001147 * Returns the current SIM call manager. Apps must be prepared for this method to return
Brad Ebingere7833312019-05-07 10:55:55 -07001148 * {@code null}, indicating that there currently exists no SIM call manager {@link PhoneAccount}
1149 * for the default voice subscription.
Santos Cordon91371dc02015-05-08 13:52:09 -07001150 *
Brad Ebingere7833312019-05-07 10:55:55 -07001151 * @return The phone account handle of the current sim call manager for the default voice
1152 * subscription.
1153 * @see SubscriptionManager#getDefaultVoiceSubscriptionId()
Andrew Lee59cac3a2014-08-28 16:50:10 -07001154 */
1155 public PhoneAccountHandle getSimCallManager() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001156 ITelecomService service = getTelecomService();
1157 if (service != null) {
1158 try {
1159 return service.getSimCallManager(
Brad Ebingere7833312019-05-07 10:55:55 -07001160 SubscriptionManager.getDefaultSubscriptionId());
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001161 } catch (RemoteException e) {
1162 Log.e(TAG, "Error calling ITelecomService#getSimCallManager");
Andrew Lee59cac3a2014-08-28 16:50:10 -07001163 }
Andrew Lee59cac3a2014-08-28 16:50:10 -07001164 }
1165 return null;
1166 }
1167
1168 /**
Brad Ebingere7833312019-05-07 10:55:55 -07001169 * Returns current SIM call manager for the Telephony Subscription ID specified. Apps must be
1170 * prepared for this method to return {@code null}, indicating that there currently exists no
1171 * SIM call manager {@link PhoneAccount} for the subscription specified.
1172 *
1173 * @param subscriptionId The Telephony Subscription ID that the SIM call manager should be
1174 * queried for.
1175 * @return The phone account handle of the current sim call manager.
1176 * @see SubscriptionManager#getActiveSubscriptionInfoList()
Brad Ebingere7833312019-05-07 10:55:55 -07001177 */
Tyler Gunn00d737b2019-10-31 13:04:37 -07001178 public @Nullable PhoneAccountHandle getSimCallManagerForSubscription(int subscriptionId) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001179 ITelecomService service = getTelecomService();
1180 if (service != null) {
1181 try {
1182 return service.getSimCallManager(subscriptionId);
1183 } catch (RemoteException e) {
1184 Log.e(TAG, "Error calling ITelecomService#getSimCallManager");
Brad Ebingere7833312019-05-07 10:55:55 -07001185 }
Brad Ebingere7833312019-05-07 10:55:55 -07001186 }
1187 return null;
1188 }
1189
1190 /**
1191 * Returns the current SIM call manager for the user-chosen default Telephony Subscription ID
1192 * (see {@link SubscriptionManager#getDefaultSubscriptionId()}) and the specified user. Apps
1193 * must be prepared for this method to return {@code null}, indicating that there currently
1194 * exists no SIM call manager {@link PhoneAccount} for the default voice subscription.
Sailesh Nepalcf855622015-07-28 19:22:14 -07001195 *
1196 * @return The phone account handle of the current sim call manager.
1197 *
1198 * @hide
Tyler Gunn6e3ecc42018-11-12 11:30:56 -08001199 * @deprecated Use {@link #getSimCallManager()}.
Sailesh Nepalcf855622015-07-28 19:22:14 -07001200 */
Tyler Gunn6e3ecc42018-11-12 11:30:56 -08001201 @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 119305590)
Sailesh Nepalcf855622015-07-28 19:22:14 -07001202 public PhoneAccountHandle getSimCallManager(int userId) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001203 ITelecomService service = getTelecomService();
1204 if (service != null) {
1205 try {
1206 return service.getSimCallManagerForUser(userId);
1207 } catch (RemoteException e) {
1208 Log.e(TAG, "Error calling ITelecomService#getSimCallManagerForUser");
Sailesh Nepalcf855622015-07-28 19:22:14 -07001209 }
Sailesh Nepalcf855622015-07-28 19:22:14 -07001210 }
1211 return null;
1212 }
1213
1214 /**
Evan Charltoneb0a8d562014-09-04 12:03:34 -07001215 * Returns the current connection manager. Apps must be prepared for this method to return
Brad Ebingere7833312019-05-07 10:55:55 -07001216 * {@code null}, indicating that there currently exists no Connection Manager
1217 * {@link PhoneAccount} for the default voice subscription.
Evan Charltoneb0a8d562014-09-04 12:03:34 -07001218 *
1219 * @return The phone account handle of the current connection manager.
Evan Charlton0e094d92014-11-08 15:49:16 -08001220 * @hide
Evan Charltoneb0a8d562014-09-04 12:03:34 -07001221 */
Evan Charlton0e094d92014-11-08 15:49:16 -08001222 @SystemApi
Evan Charltoneb0a8d562014-09-04 12:03:34 -07001223 public PhoneAccountHandle getConnectionManager() {
1224 return getSimCallManager();
1225 }
1226
1227 /**
Nancy Chen210ef032014-09-15 17:58:42 -07001228 * Returns a list of the {@link PhoneAccountHandle}s which can be used to make and receive phone
1229 * calls which support the specified URI scheme.
Tyler Gunnf5b29dc2014-09-03 09:09:12 -07001230 * <P>
1231 * For example, invoking with {@code "tel"} will find all {@link PhoneAccountHandle}s which
1232 * support telephone calls (e.g. URIs such as {@code tel:555-555-1212}). Invoking with
1233 * {@code "sip"} will find all {@link PhoneAccountHandle}s which support SIP calls (e.g. URIs
1234 * such as {@code sip:example@sipexample.com}).
1235 *
1236 * @param uriScheme The URI scheme.
1237 * @return A list of {@code PhoneAccountHandle} objects supporting the URI scheme.
Evan Charlton0e094d92014-11-08 15:49:16 -08001238 * @hide
Tyler Gunnf5b29dc2014-09-03 09:09:12 -07001239 */
Evan Charlton0e094d92014-11-08 15:49:16 -08001240 @SystemApi
Jeff Sharkeybfc4fcd2017-06-05 17:38:17 -06001241 @RequiresPermission(anyOf = {
Tyler Gunn00d737b2019-10-31 13:04:37 -07001242 READ_PRIVILEGED_PHONE_STATE,
Jeff Sharkeybfc4fcd2017-06-05 17:38:17 -06001243 android.Manifest.permission.READ_PHONE_STATE
1244 })
Tyler Gunnf5b29dc2014-09-03 09:09:12 -07001245 public List<PhoneAccountHandle> getPhoneAccountsSupportingScheme(String uriScheme) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001246 ITelecomService service = getTelecomService();
1247 if (service != null) {
1248 try {
1249 return service.getPhoneAccountsSupportingScheme(uriScheme,
Svet Ganov16a16892015-04-16 10:32:04 -07001250 mContext.getOpPackageName());
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001251 } catch (RemoteException e) {
1252 Log.e(TAG, "Error calling ITelecomService#getPhoneAccountsSupportingScheme", e);
Tyler Gunnf5b29dc2014-09-03 09:09:12 -07001253 }
Tyler Gunnf5b29dc2014-09-03 09:09:12 -07001254 }
1255 return new ArrayList<>();
1256 }
1257
Nancy Chen513c8922014-09-17 14:47:20 -07001258
1259 /**
Santos Cordon91371dc02015-05-08 13:52:09 -07001260 * Returns a list of {@link PhoneAccountHandle}s which can be used to make and receive phone
1261 * calls. The returned list includes only those accounts which have been explicitly enabled
1262 * by the user.
Nancy Chen513c8922014-09-17 14:47:20 -07001263 *
1264 * @see #EXTRA_PHONE_ACCOUNT_HANDLE
1265 * @return A list of {@code PhoneAccountHandle} objects.
Nancy Chen513c8922014-09-17 14:47:20 -07001266 */
Yorke Leec61d13662015-09-21 17:25:25 -07001267 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE)
Nancy Chen513c8922014-09-17 14:47:20 -07001268 public List<PhoneAccountHandle> getCallCapablePhoneAccounts() {
Santos Cordon91371dc02015-05-08 13:52:09 -07001269 return getCallCapablePhoneAccounts(false);
1270 }
1271
1272 /**
Tyler Gunn89317072017-04-07 14:57:37 -07001273 * Returns a list of {@link PhoneAccountHandle}s for self-managed {@link ConnectionService}s.
1274 * <p>
1275 * Self-Managed {@link ConnectionService}s have a {@link PhoneAccount} with
1276 * {@link PhoneAccount#CAPABILITY_SELF_MANAGED}.
1277 * <p>
1278 * Requires permission {@link android.Manifest.permission#READ_PHONE_STATE}, or that the caller
1279 * is the default dialer app.
1280 * <p>
1281 * A {@link SecurityException} will be thrown if a called is not the default dialer, or lacks
1282 * the {@link android.Manifest.permission#READ_PHONE_STATE} permission.
1283 *
1284 * @return A list of {@code PhoneAccountHandle} objects.
1285 */
1286 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE)
1287 public List<PhoneAccountHandle> getSelfManagedPhoneAccounts() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001288 ITelecomService service = getTelecomService();
1289 if (service != null) {
1290 try {
1291 return service.getSelfManagedPhoneAccounts(mContext.getOpPackageName(),
Philip P. Moltmann12ac3f42020-03-05 15:01:29 -08001292 mContext.getAttributionTag());
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001293 } catch (RemoteException e) {
1294 Log.e(TAG, "Error calling ITelecomService#getSelfManagedPhoneAccounts()", e);
Tyler Gunn89317072017-04-07 14:57:37 -07001295 }
Tyler Gunn89317072017-04-07 14:57:37 -07001296 }
1297 return new ArrayList<>();
1298 }
1299
1300 /**
Santos Cordon91371dc02015-05-08 13:52:09 -07001301 * Returns a list of {@link PhoneAccountHandle}s including those which have not been enabled
1302 * by the user.
1303 *
Tyler Gunn6e3ecc42018-11-12 11:30:56 -08001304 * @param includeDisabledAccounts When {@code true}, disabled phone accounts will be included,
Hall Liub2306242019-11-15 17:13:05 -08001305 * when {@code false}, only enabled phone accounts will be
1306 * included.
Santos Cordon91371dc02015-05-08 13:52:09 -07001307 * @return A list of {@code PhoneAccountHandle} objects.
1308 * @hide
1309 */
Hall Liub2306242019-11-15 17:13:05 -08001310 @SystemApi
Hall Liub2306242019-11-15 17:13:05 -08001311 @RequiresPermission(READ_PRIVILEGED_PHONE_STATE)
1312 public @NonNull List<PhoneAccountHandle> getCallCapablePhoneAccounts(
1313 boolean includeDisabledAccounts) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001314 ITelecomService service = getTelecomService();
1315 if (service != null) {
1316 try {
1317 return service.getCallCapablePhoneAccounts(includeDisabledAccounts,
Philip P. Moltmann12ac3f42020-03-05 15:01:29 -08001318 mContext.getOpPackageName(), mContext.getAttributionTag());
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001319 } catch (RemoteException e) {
1320 Log.e(TAG, "Error calling ITelecomService#getCallCapablePhoneAccounts("
1321 + includeDisabledAccounts + ")", e);
Nancy Chen513c8922014-09-17 14:47:20 -07001322 }
Nancy Chen513c8922014-09-17 14:47:20 -07001323 }
1324 return new ArrayList<>();
1325 }
1326
Tyler Gunnf5b29dc2014-09-03 09:09:12 -07001327 /**
Nancy Chen513c8922014-09-17 14:47:20 -07001328 * Returns a list of all {@link PhoneAccount}s registered for the calling package.
1329 *
Grace Jia0128b3c2020-06-23 12:53:17 -07001330 * @deprecated Use {@link #getSelfManagedPhoneAccounts()} instead to get only self-managed
1331 * {@link PhoneAccountHandle} for the calling package.
Nancy Chen513c8922014-09-17 14:47:20 -07001332 * @return A list of {@code PhoneAccountHandle} objects.
Evan Charlton0e094d92014-11-08 15:49:16 -08001333 * @hide
Nancy Chen513c8922014-09-17 14:47:20 -07001334 */
Evan Charlton0e094d92014-11-08 15:49:16 -08001335 @SystemApi
Aurimas Liutikas1394a012020-11-12 18:26:09 -08001336 @SuppressLint("RequiresPermission")
Grace Jia0128b3c2020-06-23 12:53:17 -07001337 @Deprecated
Nancy Chen513c8922014-09-17 14:47:20 -07001338 public List<PhoneAccountHandle> getPhoneAccountsForPackage() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001339 ITelecomService service = getTelecomService();
1340 if (service != null) {
1341 try {
1342 return service.getPhoneAccountsForPackage(mContext.getPackageName());
1343 } catch (RemoteException e) {
1344 Log.e(TAG, "Error calling ITelecomService#getPhoneAccountsForPackage", e);
Nancy Chen513c8922014-09-17 14:47:20 -07001345 }
Nancy Chen513c8922014-09-17 14:47:20 -07001346 }
1347 return null;
1348 }
1349
1350 /**
Evan Charlton8c8a0622014-07-20 12:31:00 -07001351 * Return the {@link PhoneAccount} for a specified {@link PhoneAccountHandle}. Object includes
1352 * resources which can be used in a user interface.
Ihab Awad807fe0a2014-07-09 12:30:52 -07001353 *
Evan Charlton6eb262c2014-07-19 18:18:19 -07001354 * @param account The {@link PhoneAccountHandle}.
Evan Charlton8c8a0622014-07-20 12:31:00 -07001355 * @return The {@link PhoneAccount} object.
Ihab Awad807fe0a2014-07-09 12:30:52 -07001356 */
Evan Charlton8c8a0622014-07-20 12:31:00 -07001357 public PhoneAccount getPhoneAccount(PhoneAccountHandle account) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001358 ITelecomService service = getTelecomService();
1359 if (service != null) {
1360 try {
1361 return service.getPhoneAccount(account);
1362 } catch (RemoteException e) {
1363 Log.e(TAG, "Error calling ITelecomService#getPhoneAccount", e);
Ihab Awad807fe0a2014-07-09 12:30:52 -07001364 }
Ihab Awad807fe0a2014-07-09 12:30:52 -07001365 }
1366 return null;
1367 }
1368
1369 /**
Nancy Chen210ef032014-09-15 17:58:42 -07001370 * Returns a count of all {@link PhoneAccount}s.
Tyler Gunna1ed7d12014-09-08 09:52:22 -07001371 *
Nancy Chen210ef032014-09-15 17:58:42 -07001372 * @return The count of {@link PhoneAccount}s.
Tyler Gunna1ed7d12014-09-08 09:52:22 -07001373 * @hide
1374 */
1375 @SystemApi
1376 public int getAllPhoneAccountsCount() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001377 ITelecomService service = getTelecomService();
1378 if (service != null) {
1379 try {
1380 return service.getAllPhoneAccountsCount();
1381 } catch (RemoteException e) {
1382 Log.e(TAG, "Error calling ITelecomService#getAllPhoneAccountsCount", e);
Tyler Gunna1ed7d12014-09-08 09:52:22 -07001383 }
Tyler Gunna1ed7d12014-09-08 09:52:22 -07001384 }
1385 return 0;
1386 }
1387
1388 /**
1389 * Returns a list of all {@link PhoneAccount}s.
1390 *
1391 * @return All {@link PhoneAccount}s.
1392 * @hide
1393 */
1394 @SystemApi
1395 public List<PhoneAccount> getAllPhoneAccounts() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001396 ITelecomService service = getTelecomService();
1397 if (service != null) {
1398 try {
1399 return service.getAllPhoneAccounts();
1400 } catch (RemoteException e) {
1401 Log.e(TAG, "Error calling ITelecomService#getAllPhoneAccounts", e);
Tyler Gunna1ed7d12014-09-08 09:52:22 -07001402 }
Tyler Gunna1ed7d12014-09-08 09:52:22 -07001403 }
1404 return Collections.EMPTY_LIST;
1405 }
1406
1407 /**
1408 * Returns a list of all {@link PhoneAccountHandle}s.
1409 *
1410 * @return All {@link PhoneAccountHandle}s.
1411 * @hide
1412 */
1413 @SystemApi
1414 public List<PhoneAccountHandle> getAllPhoneAccountHandles() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001415 ITelecomService service = getTelecomService();
1416 if (service != null) {
1417 try {
1418 return service.getAllPhoneAccountHandles();
1419 } catch (RemoteException e) {
1420 Log.e(TAG, "Error calling ITelecomService#getAllPhoneAccountHandles", e);
Tyler Gunna1ed7d12014-09-08 09:52:22 -07001421 }
Tyler Gunna1ed7d12014-09-08 09:52:22 -07001422 }
1423 return Collections.EMPTY_LIST;
1424 }
1425
1426 /**
Brad Ebingerec0d3342016-01-29 15:40:43 -08001427 * Register a {@link PhoneAccount} for use by the system that will be stored in Device Encrypted
1428 * storage. When registering {@link PhoneAccount}s, existing registrations will be overwritten
1429 * if the {@link PhoneAccountHandle} matches that of a {@link PhoneAccount} which is already
Santos Cordond9e614f2014-10-28 13:10:36 -07001430 * registered. Once registered, the {@link PhoneAccount} is listed to the user as an option
1431 * when placing calls. The user may still need to enable the {@link PhoneAccount} within
1432 * the phone app settings before the account is usable.
1433 * <p>
1434 * A {@link SecurityException} will be thrown if an app tries to register a
1435 * {@link PhoneAccountHandle} where the package name specified within
1436 * {@link PhoneAccountHandle#getComponentName()} does not match the package name of the app.
Ihab Awad807fe0a2014-07-09 12:30:52 -07001437 *
Evan Charlton8c8a0622014-07-20 12:31:00 -07001438 * @param account The complete {@link PhoneAccount}.
Ihab Awad807fe0a2014-07-09 12:30:52 -07001439 */
Evan Charlton8c8a0622014-07-20 12:31:00 -07001440 public void registerPhoneAccount(PhoneAccount account) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001441 ITelecomService service = getTelecomService();
1442 if (service != null) {
1443 try {
1444 service.registerPhoneAccount(account);
1445 } catch (RemoteException e) {
1446 Log.e(TAG, "Error calling ITelecomService#registerPhoneAccount", e);
Ihab Awad807fe0a2014-07-09 12:30:52 -07001447 }
Ihab Awad807fe0a2014-07-09 12:30:52 -07001448 }
1449 }
1450
1451 /**
Evan Charlton8c8a0622014-07-20 12:31:00 -07001452 * Remove a {@link PhoneAccount} registration from the system.
Ihab Awad807fe0a2014-07-09 12:30:52 -07001453 *
Evan Charlton8c8a0622014-07-20 12:31:00 -07001454 * @param accountHandle A {@link PhoneAccountHandle} for the {@link PhoneAccount} to unregister.
Ihab Awad807fe0a2014-07-09 12:30:52 -07001455 */
Evan Charlton8c8a0622014-07-20 12:31:00 -07001456 public void unregisterPhoneAccount(PhoneAccountHandle accountHandle) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001457 ITelecomService service = getTelecomService();
1458 if (service != null) {
1459 try {
1460 service.unregisterPhoneAccount(accountHandle);
1461 } catch (RemoteException e) {
1462 Log.e(TAG, "Error calling ITelecomService#unregisterPhoneAccount", e);
Ihab Awad807fe0a2014-07-09 12:30:52 -07001463 }
Ihab Awad807fe0a2014-07-09 12:30:52 -07001464 }
1465 }
1466
1467 /**
Nancy Chen7ab1dc42014-09-09 18:18:26 -07001468 * Remove all Accounts that belong to the calling package from the system.
Evan Charlton0e094d92014-11-08 15:49:16 -08001469 * @hide
Ihab Awad807fe0a2014-07-09 12:30:52 -07001470 */
Evan Charlton0e094d92014-11-08 15:49:16 -08001471 @SystemApi
Aurimas Liutikas1394a012020-11-12 18:26:09 -08001472 @SuppressLint("RequiresPermission")
Yorke Lee06044272015-04-14 15:16:59 -07001473 public void clearPhoneAccounts() {
1474 clearAccounts();
1475 }
1476 /**
1477 * Remove all Accounts that belong to the calling package from the system.
1478 * @deprecated Use {@link #clearPhoneAccounts()} instead.
1479 * @hide
1480 */
1481 @SystemApi
Aurimas Liutikas1394a012020-11-12 18:26:09 -08001482 @SuppressLint("RequiresPermission")
Nancy Chen7ab1dc42014-09-09 18:18:26 -07001483 public void clearAccounts() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001484 ITelecomService service = getTelecomService();
1485 if (service != null) {
1486 try {
1487 service.clearAccounts(mContext.getPackageName());
1488 } catch (RemoteException e) {
1489 Log.e(TAG, "Error calling ITelecomService#clearAccounts", e);
Ihab Awad807fe0a2014-07-09 12:30:52 -07001490 }
Ihab Awad807fe0a2014-07-09 12:30:52 -07001491 }
1492 }
1493
1494 /**
Anthony Lee67279262014-10-27 11:28:40 -07001495 * Remove all Accounts that belong to the specified package from the system.
1496 * @hide
1497 */
1498 public void clearAccountsForPackage(String packageName) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001499 ITelecomService service = getTelecomService();
1500 if (service != null) {
1501 try {
1502 if (!TextUtils.isEmpty(packageName)) {
1503 service.clearAccounts(packageName);
1504 }
1505 } catch (RemoteException e) {
1506 Log.e(TAG, "Error calling ITelecomService#clearAccountsForPackage", e);
Anthony Lee67279262014-10-27 11:28:40 -07001507 }
Anthony Lee67279262014-10-27 11:28:40 -07001508 }
1509 }
1510
Yorke Lee1011f482015-04-23 15:58:27 -07001511
Anthony Lee67279262014-10-27 11:28:40 -07001512 /**
Yorke Lee1011f482015-04-23 15:58:27 -07001513 * @deprecated - Use {@link TelecomManager#getDefaultDialerPackage} to directly access
1514 * the default dialer's package name instead.
Ihab Awad807fe0a2014-07-09 12:30:52 -07001515 * @hide
1516 */
Santos Cordon6c7a3882014-06-25 15:30:08 -07001517 @SystemApi
Aurimas Liutikas1394a012020-11-12 18:26:09 -08001518 @SuppressLint("RequiresPermission")
Santos Cordon6c7a3882014-06-25 15:30:08 -07001519 public ComponentName getDefaultPhoneApp() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001520 ITelecomService service = getTelecomService();
1521 if (service != null) {
1522 try {
1523 return service.getDefaultPhoneApp();
1524 } catch (RemoteException e) {
1525 Log.e(TAG, "RemoteException attempting to get the default phone app.", e);
Santos Cordon9eb45932014-06-27 12:28:43 -07001526 }
Santos Cordon6c7a3882014-06-25 15:30:08 -07001527 }
1528 return null;
1529 }
1530
Santos Cordon9eb45932014-06-27 12:28:43 -07001531 /**
Yorke Lee1011f482015-04-23 15:58:27 -07001532 * Used to determine the currently selected default dialer package.
1533 *
1534 * @return package name for the default dialer package or null if no package has been
1535 * selected as the default dialer.
1536 */
1537 public String getDefaultDialerPackage() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001538 ITelecomService service = getTelecomService();
1539 if (service != null) {
1540 try {
1541 return service.getDefaultDialerPackage();
1542 } catch (RemoteException e) {
1543 Log.e(TAG, "RemoteException attempting to get the default dialer package name.", e);
Yorke Lee1011f482015-04-23 15:58:27 -07001544 }
Yorke Lee1011f482015-04-23 15:58:27 -07001545 }
1546 return null;
1547 }
1548
1549 /**
Tyler Gunn00d737b2019-10-31 13:04:37 -07001550 * Used to determine the currently selected default dialer package for a specific user.
1551 *
Tyler Gunn754493b2020-01-27 10:30:51 -08001552 * @param userHandle the user id to query the default dialer package for.
Tyler Gunn00d737b2019-10-31 13:04:37 -07001553 * @return package name for the default dialer package or null if no package has been
1554 * selected as the default dialer.
1555 * @hide
1556 */
1557 @SystemApi
Tyler Gunn00d737b2019-10-31 13:04:37 -07001558 @RequiresPermission(READ_PRIVILEGED_PHONE_STATE)
Tyler Gunn754493b2020-01-27 10:30:51 -08001559 public @Nullable String getDefaultDialerPackage(@NonNull UserHandle userHandle) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001560 ITelecomService service = getTelecomService();
1561 if (service != null) {
1562 try {
1563 return service.getDefaultDialerPackageForUser(
Tyler Gunn754493b2020-01-27 10:30:51 -08001564 userHandle.getIdentifier());
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001565 } catch (RemoteException e) {
1566 Log.e(TAG, "RemoteException attempting to get the default dialer package name.", e);
Tyler Gunn00d737b2019-10-31 13:04:37 -07001567 }
Tyler Gunn00d737b2019-10-31 13:04:37 -07001568 }
1569 return null;
1570 }
1571
1572 /**
Yorke Lee107c4ce2015-06-15 12:08:24 -07001573 * Used to set the default dialer package.
1574 *
Slava Shklyaeve65e4012019-03-04 16:02:34 +00001575 * @param packageName to set the default dialer to, or {@code null} if the system provided
1576 * dialer should be used instead.
Yorke Lee107c4ce2015-06-15 12:08:24 -07001577 *
1578 * @result {@code true} if the default dialer was successfully changed, {@code false} if
1579 * the specified package does not correspond to an installed dialer, or is already
1580 * the default dialer.
1581 *
Yorke Lee107c4ce2015-06-15 12:08:24 -07001582 * @hide
Tyler Gunn7e45b722018-12-04 12:56:45 -08001583 * @deprecated Use
Hai Zhangf5e8ccd2019-03-06 20:12:24 -08001584 * {@link android.app.role.RoleManager#addRoleHolderAsUser(String, String, int, UserHandle,
1585 * Executor, java.util.function.Consumer)} instead.
Suprabh Shukla169bed72019-05-13 13:54:58 -07001586 * @removed
Yorke Lee107c4ce2015-06-15 12:08:24 -07001587 */
Tyler Gunn6e3ecc42018-11-12 11:30:56 -08001588 @SystemApi
Tyler Gunn7e45b722018-12-04 12:56:45 -08001589 @Deprecated
Tyler Gunn6e3ecc42018-11-12 11:30:56 -08001590 @RequiresPermission(allOf = {
1591 android.Manifest.permission.MODIFY_PHONE_STATE,
1592 android.Manifest.permission.WRITE_SECURE_SETTINGS})
Slava Shklyaeve65e4012019-03-04 16:02:34 +00001593 public boolean setDefaultDialer(@Nullable String packageName) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001594 ITelecomService service = getTelecomService();
1595 if (service != null) {
1596 try {
1597 return service.setDefaultDialer(packageName);
1598 } catch (RemoteException e) {
1599 Log.e(TAG, "RemoteException attempting to set the default dialer.", e);
Yorke Lee107c4ce2015-06-15 12:08:24 -07001600 }
Yorke Lee107c4ce2015-06-15 12:08:24 -07001601 }
1602 return false;
1603 }
1604
1605 /**
Tyler Gunn6e3ecc42018-11-12 11:30:56 -08001606 * Determines the package name of the system-provided default phone app.
Yorke Lee1011f482015-04-23 15:58:27 -07001607 *
Slava Shklyaeve65e4012019-03-04 16:02:34 +00001608 * @return package name for the system dialer package or {@code null} if no system dialer is
1609 * preloaded.
Yorke Lee1011f482015-04-23 15:58:27 -07001610 */
Slava Shklyaeve65e4012019-03-04 16:02:34 +00001611 public @Nullable String getSystemDialerPackage() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001612 ITelecomService service = getTelecomService();
1613 if (service != null) {
1614 try {
1615 return service.getSystemDialerPackage();
1616 } catch (RemoteException e) {
1617 Log.e(TAG, "RemoteException attempting to get the system dialer package name.", e);
Yorke Lee1011f482015-04-23 15:58:27 -07001618 }
Yorke Lee1011f482015-04-23 15:58:27 -07001619 }
1620 return null;
1621 }
1622
1623 /**
Nancy Chen443e5012014-10-15 15:48:21 -07001624 * Return whether a given phone number is the configured voicemail number for a
1625 * particular phone account.
1626 *
1627 * @param accountHandle The handle for the account to check the voicemail number against
1628 * @param number The number to look up.
Nancy Chen443e5012014-10-15 15:48:21 -07001629 */
Yorke Leec61d13662015-09-21 17:25:25 -07001630 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE)
Nancy Chen443e5012014-10-15 15:48:21 -07001631 public boolean isVoiceMailNumber(PhoneAccountHandle accountHandle, String number) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001632 ITelecomService service = getTelecomService();
1633 if (service != null) {
1634 try {
1635 return service.isVoiceMailNumber(accountHandle, number,
Philip P. Moltmann12ac3f42020-03-05 15:01:29 -08001636 mContext.getOpPackageName(), mContext.getAttributionTag());
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001637 } catch (RemoteException e) {
1638 Log.e(TAG, "RemoteException calling ITelecomService#isVoiceMailNumber.", e);
Nancy Chen443e5012014-10-15 15:48:21 -07001639 }
Nancy Chen443e5012014-10-15 15:48:21 -07001640 }
1641 return false;
1642 }
1643
1644 /**
Yorke Lee49e2d462015-04-15 16:14:22 -07001645 * Return the voicemail number for a given phone account.
Nancy Chen8c066f7c2014-12-03 15:18:08 -08001646 *
Yorke Lee49e2d462015-04-15 16:14:22 -07001647 * @param accountHandle The handle for the phone account.
1648 * @return The voicemail number for the phone account, and {@code null} if one has not been
1649 * configured.
Nancy Chen8c066f7c2014-12-03 15:18:08 -08001650 */
Yorke Leec61d13662015-09-21 17:25:25 -07001651 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE)
Yorke Lee49e2d462015-04-15 16:14:22 -07001652 public String getVoiceMailNumber(PhoneAccountHandle accountHandle) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001653 ITelecomService service = getTelecomService();
1654 if (service != null) {
1655 try {
1656 return service.getVoiceMailNumber(accountHandle,
Philip P. Moltmann12ac3f42020-03-05 15:01:29 -08001657 mContext.getOpPackageName(), mContext.getAttributionTag());
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001658 } catch (RemoteException e) {
1659 Log.e(TAG, "RemoteException calling ITelecomService#hasVoiceMailNumber.", e);
Nancy Chen8c066f7c2014-12-03 15:18:08 -08001660 }
Nancy Chen8c066f7c2014-12-03 15:18:08 -08001661 }
Yorke Lee49e2d462015-04-15 16:14:22 -07001662 return null;
Nancy Chen8c066f7c2014-12-03 15:18:08 -08001663 }
1664
1665 /**
Nancy Chen5cf27842015-01-24 23:30:27 -08001666 * Return the line 1 phone number for given phone account.
1667 *
Michael Groover08490f12020-03-24 14:08:14 -07001668 * <p>Requires Permission:
1669 * {@link android.Manifest.permission#READ_SMS READ_SMS},
1670 * {@link android.Manifest.permission#READ_PHONE_NUMBERS READ_PHONE_NUMBERS},
1671 * or that the caller is the default SMS app for any API level.
1672 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}
1673 * for apps targeting SDK API level 29 and below.
Yorke Leec61d13662015-09-21 17:25:25 -07001674 *
Nancy Chen5cf27842015-01-24 23:30:27 -08001675 * @param accountHandle The handle for the account retrieve a number for.
1676 * @return A string representation of the line 1 phone number.
Nancy Chen5cf27842015-01-24 23:30:27 -08001677 */
Michael Groover08490f12020-03-24 14:08:14 -07001678 @SuppressAutoDoc // Blocked by b/72967236 - no support for carrier privileges or default SMS app
1679 @RequiresPermission(anyOf = {
1680 android.Manifest.permission.READ_PHONE_STATE,
1681 android.Manifest.permission.READ_SMS,
1682 android.Manifest.permission.READ_PHONE_NUMBERS
1683 }, conditional = true)
Nancy Chen5cf27842015-01-24 23:30:27 -08001684 public String getLine1Number(PhoneAccountHandle accountHandle) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001685 ITelecomService service = getTelecomService();
1686 if (service != null) {
1687 try {
1688 return service.getLine1Number(accountHandle,
Philip P. Moltmann12ac3f42020-03-05 15:01:29 -08001689 mContext.getOpPackageName(), mContext.getAttributionTag());
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001690 } catch (RemoteException e) {
1691 Log.e(TAG, "RemoteException calling ITelecomService#getLine1Number.", e);
Nancy Chen5cf27842015-01-24 23:30:27 -08001692 }
Nancy Chen5cf27842015-01-24 23:30:27 -08001693 }
1694 return null;
1695 }
1696
1697 /**
Santos Cordon9eb45932014-06-27 12:28:43 -07001698 * Returns whether there is an ongoing phone call (can be in dialing, ringing, active or holding
Tyler Gunn24e18332017-02-10 09:42:49 -08001699 * states) originating from either a manager or self-managed {@link ConnectionService}.
Tyler Gunn24e18332017-02-10 09:42:49 -08001700 *
1701 * @return {@code true} if there is an ongoing call in either a managed or self-managed
1702 * {@link ConnectionService}, {@code false} otherwise.
Santos Cordon9eb45932014-06-27 12:28:43 -07001703 */
Yorke Leec61d13662015-09-21 17:25:25 -07001704 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE)
Nancy Chen0eb1e402014-08-21 22:52:29 -07001705 public boolean isInCall() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001706 ITelecomService service = getTelecomService();
1707 if (service != null) {
1708 try {
1709 return service.isInCall(mContext.getOpPackageName(),
Philip P. Moltmann12ac3f42020-03-05 15:01:29 -08001710 mContext.getAttributionTag());
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001711 } catch (RemoteException e) {
1712 Log.e(TAG, "RemoteException calling isInCall().", e);
Santos Cordon9eb45932014-06-27 12:28:43 -07001713 }
Santos Cordon9eb45932014-06-27 12:28:43 -07001714 }
1715 return false;
1716 }
1717
1718 /**
Shuo Qian93273fd2021-02-10 15:12:09 -08001719 * Returns whether the caller has {@link android.Manifest.permission#MANAGE_ONGOING_CALLS}
1720 * permission. The permission can be obtained by associating with a physical wearable device
1721 * via the {@link android.companion.CompanionDeviceManager} API as a companion app. If the
1722 * caller app has the permission, it has {@link InCallService} access to manage ongoing calls.
Shuo Qian4d065262020-10-20 11:04:28 -07001723 *
1724 * @return {@code true} if the caller has {@link InCallService} access for
1725 * companion app; {@code false} otherwise.
1726 */
Shuo Qian93273fd2021-02-10 15:12:09 -08001727 public boolean hasManageOngoingCallsPermission() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001728 ITelecomService service = getTelecomService();
1729 if (service != null) {
1730 try {
Shuo Qian93273fd2021-02-10 15:12:09 -08001731 return service.hasManageOngoingCallsPermission(
Shuo Qian4d065262020-10-20 11:04:28 -07001732 mContext.getOpPackageName());
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001733 } catch (RemoteException e) {
Shuo Qian93273fd2021-02-10 15:12:09 -08001734 Log.e(TAG, "RemoteException calling hasManageOngoingCallsPermission().", e);
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001735 if (!isSystemProcess()) {
1736 e.rethrowAsRuntimeException();
1737 }
Shuo Qian4d065262020-10-20 11:04:28 -07001738 }
1739 }
1740 return false;
1741 }
1742
1743 /**
Tyler Gunn24e18332017-02-10 09:42:49 -08001744 * Returns whether there is an ongoing call originating from a managed
1745 * {@link ConnectionService}. An ongoing call can be in dialing, ringing, active or holding
1746 * states.
1747 * <p>
1748 * If you also need to know if there are ongoing self-managed calls, use {@link #isInCall()}
1749 * instead.
Tyler Gunn24e18332017-02-10 09:42:49 -08001750 *
1751 * @return {@code true} if there is an ongoing call in a managed {@link ConnectionService},
1752 * {@code false} otherwise.
1753 */
1754 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE)
1755 public boolean isInManagedCall() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001756 ITelecomService service = getTelecomService();
1757 if (service != null) {
1758 try {
1759 return service.isInManagedCall(mContext.getOpPackageName(),
Philip P. Moltmann12ac3f42020-03-05 15:01:29 -08001760 mContext.getAttributionTag());
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001761 } catch (RemoteException e) {
1762 Log.e(TAG, "RemoteException calling isInManagedCall().", e);
Tyler Gunn24e18332017-02-10 09:42:49 -08001763 }
Tyler Gunn24e18332017-02-10 09:42:49 -08001764 }
1765 return false;
1766 }
1767
1768 /**
Yorke Lee2ae312e2014-09-12 17:58:48 -07001769 * Returns one of the following constants that represents the current state of Telecom:
1770 *
1771 * {@link TelephonyManager#CALL_STATE_RINGING}
1772 * {@link TelephonyManager#CALL_STATE_OFFHOOK}
1773 * {@link TelephonyManager#CALL_STATE_IDLE}
Yorke Lee7c72c2d2014-10-28 14:12:02 -07001774 *
Tyler Gunn24e18332017-02-10 09:42:49 -08001775 * Takes into consideration both managed and self-managed calls.
Brad Ebingera8366ae2021-03-23 21:01:51 +00001776 * <p>
1777 * Requires Permission:
1778 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} for applications
1779 * targeting API level 31+.
Tyler Gunn24e18332017-02-10 09:42:49 -08001780 *
Yorke Lee2ae312e2014-09-12 17:58:48 -07001781 * @hide
1782 */
Brad Ebingera8366ae2021-03-23 21:01:51 +00001783 @RequiresPermission(anyOf = {READ_PRIVILEGED_PHONE_STATE,
1784 android.Manifest.permission.READ_PHONE_STATE}, conditional = true)
Yorke Lee2ae312e2014-09-12 17:58:48 -07001785 @SystemApi
Chen Xuc9d4ee12019-09-26 16:11:59 -07001786 public @CallState int getCallState() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001787 ITelecomService service = getTelecomService();
1788 if (service != null) {
1789 try {
Brad Ebingera8366ae2021-03-23 21:01:51 +00001790 return service.getCallStateUsingPackage(mContext.getPackageName(),
1791 mContext.getAttributionTag());
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001792 } catch (RemoteException e) {
1793 Log.d(TAG, "RemoteException calling getCallState().", e);
Yorke Lee2ae312e2014-09-12 17:58:48 -07001794 }
Yorke Lee2ae312e2014-09-12 17:58:48 -07001795 }
1796 return TelephonyManager.CALL_STATE_IDLE;
1797 }
1798
1799 /**
Santos Cordon9eb45932014-06-27 12:28:43 -07001800 * Returns whether there currently exists is a ringing incoming-call.
1801 *
Tyler Gunn24e18332017-02-10 09:42:49 -08001802 * @return {@code true} if there is a managed or self-managed ringing call.
Santos Cordon9eb45932014-06-27 12:28:43 -07001803 * @hide
1804 */
1805 @SystemApi
Jeff Sharkeybfc4fcd2017-06-05 17:38:17 -06001806 @RequiresPermission(anyOf = {
Tyler Gunn00d737b2019-10-31 13:04:37 -07001807 READ_PRIVILEGED_PHONE_STATE,
Jeff Sharkeybfc4fcd2017-06-05 17:38:17 -06001808 android.Manifest.permission.READ_PHONE_STATE
1809 })
Santos Cordon9eb45932014-06-27 12:28:43 -07001810 public boolean isRinging() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001811 ITelecomService service = getTelecomService();
1812 if (service != null) {
1813 try {
1814 return service.isRinging(mContext.getOpPackageName());
1815 } catch (RemoteException e) {
1816 Log.e(TAG, "RemoteException attempting to get ringing state of phone app.", e);
Santos Cordon9eb45932014-06-27 12:28:43 -07001817 }
Santos Cordon9eb45932014-06-27 12:28:43 -07001818 }
1819 return false;
1820 }
1821
1822 /**
Tyler Gunne1aa26c2018-05-02 13:23:48 -07001823 * Ends the foreground call on the device.
1824 * <p>
1825 * If there is a ringing call, calling this method rejects the ringing call. Otherwise the
1826 * foreground call is ended.
1827 * <p>
Tyler Gunnf18ee4c2019-05-14 11:08:06 -07001828 * Note: this method CANNOT be used to end ongoing emergency calls and will return {@code false}
1829 * if an attempt is made to end an emergency call.
Tyler Gunne1aa26c2018-05-02 13:23:48 -07001830 *
1831 * @return {@code true} if there is a call which will be rejected or terminated, {@code false}
1832 * otherwise.
Tyler Gunn9bd8db42019-01-31 10:54:03 -08001833 * @deprecated Companion apps for wearable devices should use the {@link InCallService} API
1834 * instead. Apps performing call screening should use the {@link CallScreeningService} API
1835 * instead.
Santos Cordon9eb45932014-06-27 12:28:43 -07001836 */
Tyler Gunne1aa26c2018-05-02 13:23:48 -07001837 @RequiresPermission(Manifest.permission.ANSWER_PHONE_CALLS)
Tyler Gunn9bd8db42019-01-31 10:54:03 -08001838 @Deprecated
Santos Cordon9eb45932014-06-27 12:28:43 -07001839 public boolean endCall() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001840 ITelecomService service = getTelecomService();
1841 if (service != null) {
1842 try {
1843 return service.endCall(mContext.getPackageName());
1844 } catch (RemoteException e) {
1845 Log.e(TAG, "Error calling ITelecomService#endCall", e);
Santos Cordon9eb45932014-06-27 12:28:43 -07001846 }
Santos Cordon9eb45932014-06-27 12:28:43 -07001847 }
1848 return false;
1849 }
1850
1851 /**
1852 * If there is a ringing incoming call, this method accepts the call on behalf of the user.
Eugene Suslacae3d3e2017-01-31 11:08:11 -08001853 *
Tyler Gunn6676bb52015-10-23 14:39:49 -07001854 * If the incoming call is a video call, the call will be answered with the same video state as
1855 * the incoming call requests. This means, for example, that an incoming call requesting
1856 * {@link VideoProfile#STATE_BIDIRECTIONAL} will be answered, accepting that state.
Eugene Suslacae3d3e2017-01-31 11:08:11 -08001857 *
Tyler Gunn9bd8db42019-01-31 10:54:03 -08001858 * @deprecated Companion apps for wearable devices should use the {@link InCallService} API
1859 * instead.
Santos Cordon9eb45932014-06-27 12:28:43 -07001860 */
Eugene Suslacae3d3e2017-01-31 11:08:11 -08001861 //TODO: L-release - need to convert all invocation of ITelecmmService#answerRingingCall to use
1862 // this method (clockwork & gearhead).
1863 @RequiresPermission(anyOf =
1864 {Manifest.permission.ANSWER_PHONE_CALLS, Manifest.permission.MODIFY_PHONE_STATE})
Tyler Gunn9bd8db42019-01-31 10:54:03 -08001865 @Deprecated
Santos Cordon9eb45932014-06-27 12:28:43 -07001866 public void acceptRingingCall() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001867 ITelecomService service = getTelecomService();
1868 if (service != null) {
1869 try {
1870 service.acceptRingingCall(mContext.getPackageName());
1871 } catch (RemoteException e) {
1872 Log.e(TAG, "Error calling ITelecomService#acceptRingingCall", e);
Santos Cordon9eb45932014-06-27 12:28:43 -07001873 }
Santos Cordon9eb45932014-06-27 12:28:43 -07001874 }
1875 }
1876
1877 /**
Tyler Gunn6676bb52015-10-23 14:39:49 -07001878 * If there is a ringing incoming call, this method accepts the call on behalf of the user,
1879 * with the specified video state.
1880 *
1881 * @param videoState The desired video state to answer the call with.
Tyler Gunn9bd8db42019-01-31 10:54:03 -08001882 * @deprecated Companion apps for wearable devices should use the {@link InCallService} API
1883 * instead.
Tyler Gunn6676bb52015-10-23 14:39:49 -07001884 */
Eugene Suslacae3d3e2017-01-31 11:08:11 -08001885 @RequiresPermission(anyOf =
1886 {Manifest.permission.ANSWER_PHONE_CALLS, Manifest.permission.MODIFY_PHONE_STATE})
Tyler Gunn9bd8db42019-01-31 10:54:03 -08001887 @Deprecated
Tyler Gunn6676bb52015-10-23 14:39:49 -07001888 public void acceptRingingCall(int videoState) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001889 ITelecomService service = getTelecomService();
1890 if (service != null) {
1891 try {
1892 service.acceptRingingCallWithVideoState(
Eugene Suslacae3d3e2017-01-31 11:08:11 -08001893 mContext.getPackageName(), videoState);
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001894 } catch (RemoteException e) {
1895 Log.e(TAG, "Error calling ITelecomService#acceptRingingCallWithVideoState", e);
Tyler Gunn6676bb52015-10-23 14:39:49 -07001896 }
Tyler Gunn6676bb52015-10-23 14:39:49 -07001897 }
1898 }
1899
1900 /**
Santos Cordon9eb45932014-06-27 12:28:43 -07001901 * Silences the ringer if a ringing call exists.
Tyler Gunn556d2402019-04-10 08:59:43 -07001902 * <p>
1903 * This method can only be relied upon to stop the ringtone for a call if the ringtone has
1904 * already started playing. It is intended to handle use-cases such as silencing a ringing call
1905 * when the user presses the volume button during ringing.
1906 * <p>
1907 * If this method is called prior to when the ringtone begins playing, the ringtone will not be
1908 * silenced. As such it is not intended as a means to avoid playing of a ringtone.
1909 * <p>
1910 * A dialer app which wants to have more control over ringtone playing should declare
1911 * {@link TelecomManager#METADATA_IN_CALL_SERVICE_RINGING} in the manifest entry for their
1912 * {@link InCallService} implementation to indicate that the app wants to be responsible for
1913 * playing the ringtone for all incoming calls.
1914 * <p>
1915 * Requires permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE} or that the
1916 * app fills the dialer role (see {@link #getDefaultDialerPackage()}).
Santos Cordon9eb45932014-06-27 12:28:43 -07001917 */
Yorke Leec61d13662015-09-21 17:25:25 -07001918 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE)
Santos Cordon9eb45932014-06-27 12:28:43 -07001919 public void silenceRinger() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001920 ITelecomService service = getTelecomService();
1921 if (service != null) {
1922 try {
1923 service.silenceRinger(mContext.getOpPackageName());
1924 } catch (RemoteException e) {
1925 Log.e(TAG, "Error calling ITelecomService#silenceRinger", e);
Santos Cordon9eb45932014-06-27 12:28:43 -07001926 }
Santos Cordon9eb45932014-06-27 12:28:43 -07001927 }
1928 }
1929
Sailesh Nepal001bbbb2014-07-15 14:40:39 -07001930 /**
1931 * Returns whether TTY is supported on this device.
Sailesh Nepal001bbbb2014-07-15 14:40:39 -07001932 */
Jeff Sharkeybfc4fcd2017-06-05 17:38:17 -06001933 @RequiresPermission(anyOf = {
Tyler Gunn00d737b2019-10-31 13:04:37 -07001934 READ_PRIVILEGED_PHONE_STATE,
Jeff Sharkeybfc4fcd2017-06-05 17:38:17 -06001935 android.Manifest.permission.READ_PHONE_STATE
1936 })
Sailesh Nepal001bbbb2014-07-15 14:40:39 -07001937 public boolean isTtySupported() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001938 ITelecomService service = getTelecomService();
1939 if (service != null) {
1940 try {
1941 return service.isTtySupported(mContext.getOpPackageName(),
Philip P. Moltmann12ac3f42020-03-05 15:01:29 -08001942 mContext.getAttributionTag());
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001943 } catch (RemoteException e) {
1944 Log.e(TAG, "RemoteException attempting to get TTY supported state.", e);
Sailesh Nepal001bbbb2014-07-15 14:40:39 -07001945 }
Sailesh Nepal001bbbb2014-07-15 14:40:39 -07001946 }
1947 return false;
1948 }
1949
1950 /**
1951 * Returns the current TTY mode of the device. For TTY to be on the user must enable it in
Santos Cordon96efb482014-07-19 14:57:05 -07001952 * settings and have a wired headset plugged in.
1953 * Valid modes are:
Tyler Gunnef9f6f92014-09-12 22:16:17 -07001954 * - {@link TelecomManager#TTY_MODE_OFF}
1955 * - {@link TelecomManager#TTY_MODE_FULL}
1956 * - {@link TelecomManager#TTY_MODE_HCO}
1957 * - {@link TelecomManager#TTY_MODE_VCO}
Sailesh Nepal001bbbb2014-07-15 14:40:39 -07001958 * @hide
1959 */
Tyler Gunn6e3ecc42018-11-12 11:30:56 -08001960 @SystemApi
Tyler Gunn00d737b2019-10-31 13:04:37 -07001961 @RequiresPermission(READ_PRIVILEGED_PHONE_STATE)
Tyler Gunn6e3ecc42018-11-12 11:30:56 -08001962 public @TtyMode int getCurrentTtyMode() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001963 ITelecomService service = getTelecomService();
1964 if (service != null) {
1965 try {
1966 return service.getCurrentTtyMode(mContext.getOpPackageName(),
Philip P. Moltmann12ac3f42020-03-05 15:01:29 -08001967 mContext.getAttributionTag());
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00001968 } catch (RemoteException e) {
1969 Log.e(TAG, "RemoteException attempting to get the current TTY mode.", e);
Sailesh Nepal001bbbb2014-07-15 14:40:39 -07001970 }
Sailesh Nepal001bbbb2014-07-15 14:40:39 -07001971 }
Evan Charlton10197192014-07-19 15:00:29 -07001972 return TTY_MODE_OFF;
Sailesh Nepal001bbbb2014-07-15 14:40:39 -07001973 }
1974
Santos Cordon96efb482014-07-19 14:57:05 -07001975 /**
1976 * Registers a new incoming call. A {@link ConnectionService} should invoke this method when it
Tyler Gunnf5035432017-01-09 09:43:12 -08001977 * has an incoming call. For managed {@link ConnectionService}s, the specified
1978 * {@link PhoneAccountHandle} must have been registered with {@link #registerPhoneAccount} and
1979 * the user must have enabled the corresponding {@link PhoneAccount}. This can be checked using
1980 * {@link #getPhoneAccount}. Self-managed {@link ConnectionService}s must have
1981 * {@link android.Manifest.permission#MANAGE_OWN_CALLS} to add a new incoming call.
1982 * <p>
Tyler Gunn37653562017-03-13 18:15:15 -07001983 * The incoming call you are adding is assumed to have a video state of
1984 * {@link VideoProfile#STATE_AUDIO_ONLY}, unless the extra value
1985 * {@link #EXTRA_INCOMING_VIDEO_STATE} is specified.
1986 * <p>
Tyler Gunnf5035432017-01-09 09:43:12 -08001987 * Once invoked, this method will cause the system to bind to the {@link ConnectionService}
1988 * associated with the {@link PhoneAccountHandle} and request additional information about the
1989 * call (See {@link ConnectionService#onCreateIncomingConnection}) before starting the incoming
Brad Ebingerec0d3342016-01-29 15:40:43 -08001990 * call UI.
1991 * <p>
Tyler Gunnf5035432017-01-09 09:43:12 -08001992 * For a managed {@link ConnectionService}, a {@link SecurityException} will be thrown if either
1993 * the {@link PhoneAccountHandle} does not correspond to a registered {@link PhoneAccount} or
1994 * the associated {@link PhoneAccount} is not currently enabled by the user.
1995 * <p>
1996 * For a self-managed {@link ConnectionService}, a {@link SecurityException} will be thrown if
1997 * the {@link PhoneAccount} has {@link PhoneAccount#CAPABILITY_SELF_MANAGED} and the calling app
1998 * does not have {@link android.Manifest.permission#MANAGE_OWN_CALLS}.
1999 *
Santos Cordon96efb482014-07-19 14:57:05 -07002000 * @param phoneAccount A {@link PhoneAccountHandle} registered with
2001 * {@link #registerPhoneAccount}.
2002 * @param extras A bundle that will be passed through to
2003 * {@link ConnectionService#onCreateIncomingConnection}.
2004 */
2005 public void addNewIncomingCall(PhoneAccountHandle phoneAccount, Bundle extras) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00002006 ITelecomService service = getTelecomService();
2007 if (service != null) {
2008 try {
Sanket Padawef6a9e5b2018-01-05 14:26:16 -08002009 if (extras != null && extras.getBoolean(EXTRA_IS_HANDOVER) &&
2010 mContext.getApplicationContext().getApplicationInfo().targetSdkVersion >
2011 Build.VERSION_CODES.O_MR1) {
2012 Log.e("TAG", "addNewIncomingCall failed. Use public api " +
2013 "acceptHandover for API > O-MR1");
Tyler Gunn9ae6db82019-02-13 13:51:18 -08002014 return;
Sanket Padawef6a9e5b2018-01-05 14:26:16 -08002015 }
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00002016 service.addNewIncomingCall(phoneAccount, extras == null ? new Bundle() : extras);
2017 } catch (RemoteException e) {
2018 Log.e(TAG, "RemoteException adding a new incoming call: " + phoneAccount, e);
Santos Cordon96efb482014-07-19 14:57:05 -07002019 }
Santos Cordon96efb482014-07-19 14:57:05 -07002020 }
2021 }
2022
Nancy Chen0eb1e402014-08-21 22:52:29 -07002023 /**
Ravi Paluri80aa2142019-12-02 11:57:37 +05302024 * Registers a new incoming conference. A {@link ConnectionService} should invoke this method
Grace Jia8587ee52020-07-10 15:42:32 -07002025 * when it has an incoming conference. An incoming {@link Conference} is an adhoc conference
2026 * call initiated on another device which the user is being invited to join in. For managed
2027 * {@link ConnectionService}s, the specified {@link PhoneAccountHandle} must have been
2028 * registered with {@link #registerPhoneAccount} and the user must have enabled the
2029 * corresponding {@link PhoneAccount}. This can be checked using
2030 * {@link #getPhoneAccount(PhoneAccountHandle)}. Self-managed {@link ConnectionService}s must
2031 * have {@link android.Manifest.permission#MANAGE_OWN_CALLS} to add a new incoming call.
Ravi Paluri80aa2142019-12-02 11:57:37 +05302032 * <p>
2033 * The incoming conference you are adding is assumed to have a video state of
2034 * {@link VideoProfile#STATE_AUDIO_ONLY}, unless the extra value
2035 * {@link #EXTRA_INCOMING_VIDEO_STATE} is specified.
2036 * <p>
2037 * Once invoked, this method will cause the system to bind to the {@link ConnectionService}
2038 * associated with the {@link PhoneAccountHandle} and request additional information about the
Grace Jia8587ee52020-07-10 15:42:32 -07002039 * call (See
2040 * {@link ConnectionService#onCreateIncomingConference(PhoneAccountHandle, ConnectionRequest)})
2041 * before starting the incoming call UI.
Ravi Paluri80aa2142019-12-02 11:57:37 +05302042 * <p>
2043 * For a managed {@link ConnectionService}, a {@link SecurityException} will be thrown if either
2044 * the {@link PhoneAccountHandle} does not correspond to a registered {@link PhoneAccount} or
2045 * the associated {@link PhoneAccount} is not currently enabled by the user.
2046 *
2047 * @param phoneAccount A {@link PhoneAccountHandle} registered with
2048 * {@link #registerPhoneAccount}.
2049 * @param extras A bundle that will be passed through to
2050 * {@link ConnectionService#onCreateIncomingConference}.
2051 */
Ravi Paluri80aa2142019-12-02 11:57:37 +05302052 public void addNewIncomingConference(@NonNull PhoneAccountHandle phoneAccount,
2053 @NonNull Bundle extras) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00002054 ITelecomService service = getTelecomService();
2055 if (service != null) {
2056 try {
2057 service.addNewIncomingConference(
Ravi Paluri80aa2142019-12-02 11:57:37 +05302058 phoneAccount, extras == null ? new Bundle() : extras);
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00002059 } catch (RemoteException e) {
2060 Log.e(TAG, "RemoteException adding a new incoming conference: " + phoneAccount, e);
Ravi Paluri80aa2142019-12-02 11:57:37 +05302061 }
Ravi Paluri80aa2142019-12-02 11:57:37 +05302062 }
2063 }
2064
2065 /**
Yorke Leec3cf9822014-10-02 09:38:39 -07002066 * Registers a new unknown call with Telecom. This can only be called by the system Telephony
2067 * service. This is invoked when Telephony detects a new unknown connection that was neither
2068 * a new incoming call, nor an user-initiated outgoing call.
2069 *
2070 * @param phoneAccount A {@link PhoneAccountHandle} registered with
2071 * {@link #registerPhoneAccount}.
2072 * @param extras A bundle that will be passed through to
2073 * {@link ConnectionService#onCreateIncomingConnection}.
2074 * @hide
2075 */
2076 @SystemApi
2077 public void addNewUnknownCall(PhoneAccountHandle phoneAccount, Bundle extras) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00002078 ITelecomService service = getTelecomService();
2079 if (service != null) {
2080 try {
2081 service.addNewUnknownCall(
Yorke Leec3cf9822014-10-02 09:38:39 -07002082 phoneAccount, extras == null ? new Bundle() : extras);
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00002083 } catch (RemoteException e) {
2084 Log.e(TAG, "RemoteException adding a new unknown call: " + phoneAccount, e);
Yorke Leec3cf9822014-10-02 09:38:39 -07002085 }
Yorke Leec3cf9822014-10-02 09:38:39 -07002086 }
2087 }
2088
2089 /**
Nancy Chen0eb1e402014-08-21 22:52:29 -07002090 * Processes the specified dial string as an MMI code.
2091 * MMI codes are any sequence of characters entered into the dialpad that contain a "*" or "#".
2092 * Some of these sequences launch special behavior through handled by Telephony.
Nancy Chen95e8a672014-10-16 18:38:21 -07002093 * This method uses the default subscription.
Nancy Chen0eb1e402014-08-21 22:52:29 -07002094 * <p>
2095 * Requires that the method-caller be set as the system dialer app.
2096 * </p>
2097 *
2098 * @param dialString The digits to dial.
2099 * @return True if the digits were processed as an MMI code, false otherwise.
2100 */
Yorke Leec61d13662015-09-21 17:25:25 -07002101 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE)
Nancy Chen0eb1e402014-08-21 22:52:29 -07002102 public boolean handleMmi(String dialString) {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07002103 ITelecomService service = getTelecomService();
Nancy Chen0eb1e402014-08-21 22:52:29 -07002104 if (service != null) {
2105 try {
Yorke Leef1a349b2015-04-29 16:16:50 -07002106 return service.handlePinMmi(dialString, mContext.getOpPackageName());
Nancy Chen0eb1e402014-08-21 22:52:29 -07002107 } catch (RemoteException e) {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07002108 Log.e(TAG, "Error calling ITelecomService#handlePinMmi", e);
Nancy Chen0eb1e402014-08-21 22:52:29 -07002109 }
2110 }
2111 return false;
2112 }
2113
2114 /**
Nancy Chen95e8a672014-10-16 18:38:21 -07002115 * Processes the specified dial string as an MMI code.
2116 * MMI codes are any sequence of characters entered into the dialpad that contain a "*" or "#".
2117 * Some of these sequences launch special behavior through handled by Telephony.
2118 * <p>
2119 * Requires that the method-caller be set as the system dialer app.
2120 * </p>
2121 *
2122 * @param accountHandle The handle for the account the MMI code should apply to.
2123 * @param dialString The digits to dial.
2124 * @return True if the digits were processed as an MMI code, false otherwise.
Nancy Chen95e8a672014-10-16 18:38:21 -07002125 */
Yorke Leec61d13662015-09-21 17:25:25 -07002126 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE)
Yorke Lee06044272015-04-14 15:16:59 -07002127 public boolean handleMmi(String dialString, PhoneAccountHandle accountHandle) {
Nancy Chen95e8a672014-10-16 18:38:21 -07002128 ITelecomService service = getTelecomService();
2129 if (service != null) {
2130 try {
Yorke Leef1a349b2015-04-29 16:16:50 -07002131 return service.handlePinMmiForPhoneAccount(accountHandle, dialString,
2132 mContext.getOpPackageName());
Nancy Chen95e8a672014-10-16 18:38:21 -07002133 } catch (RemoteException e) {
2134 Log.e(TAG, "Error calling ITelecomService#handlePinMmi", e);
2135 }
2136 }
2137 return false;
2138 }
2139
2140 /**
Tyler Gunn1a4f0402020-11-06 09:48:16 -08002141 * Returns a URI (with the content:// scheme) specific to the specified {@link PhoneAccount}
2142 * for ADN content retrieval.
Nancy Chenb2299c12014-10-29 18:22:11 -07002143 * @param accountHandle The handle for the account to derive an adn query URI for or
2144 * {@code null} to return a URI which will use the default account.
2145 * @return The URI (with the content:// scheme) specific to the specified {@link PhoneAccount}
2146 * for the the content retrieve.
2147 */
Yorke Leec61d13662015-09-21 17:25:25 -07002148 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE)
Nancy Chenb2299c12014-10-29 18:22:11 -07002149 public Uri getAdnUriForPhoneAccount(PhoneAccountHandle accountHandle) {
2150 ITelecomService service = getTelecomService();
2151 if (service != null && accountHandle != null) {
2152 try {
Yorke Leef1a349b2015-04-29 16:16:50 -07002153 return service.getAdnUriForPhoneAccount(accountHandle, mContext.getOpPackageName());
Nancy Chenb2299c12014-10-29 18:22:11 -07002154 } catch (RemoteException e) {
2155 Log.e(TAG, "Error calling ITelecomService#getAdnUriForPhoneAccount", e);
2156 }
2157 }
2158 return Uri.parse("content://icc/adn");
2159 }
2160
2161 /**
Nancy Chen0eb1e402014-08-21 22:52:29 -07002162 * Removes the missed-call notification if one is present.
2163 * <p>
2164 * Requires that the method-caller be set as the system dialer app.
2165 * </p>
2166 */
Yorke Leec61d13662015-09-21 17:25:25 -07002167 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE)
Nancy Chen0eb1e402014-08-21 22:52:29 -07002168 public void cancelMissedCallsNotification() {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07002169 ITelecomService service = getTelecomService();
Nancy Chen0eb1e402014-08-21 22:52:29 -07002170 if (service != null) {
2171 try {
Yorke Leef1a349b2015-04-29 16:16:50 -07002172 service.cancelMissedCallsNotification(mContext.getOpPackageName());
Nancy Chen0eb1e402014-08-21 22:52:29 -07002173 } catch (RemoteException e) {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07002174 Log.e(TAG, "Error calling ITelecomService#cancelMissedCallsNotification", e);
Nancy Chen0eb1e402014-08-21 22:52:29 -07002175 }
2176 }
2177 }
2178
2179 /**
2180 * Brings the in-call screen to the foreground if there is an ongoing call. If there is
2181 * currently no ongoing call, then this method does nothing.
2182 * <p>
2183 * Requires that the method-caller be set as the system dialer app or have the
2184 * {@link android.Manifest.permission#READ_PHONE_STATE} permission.
2185 * </p>
2186 *
2187 * @param showDialpad Brings up the in-call dialpad as part of showing the in-call screen.
2188 */
Yorke Leec61d13662015-09-21 17:25:25 -07002189 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE)
Nancy Chen0eb1e402014-08-21 22:52:29 -07002190 public void showInCallScreen(boolean showDialpad) {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07002191 ITelecomService service = getTelecomService();
Nancy Chen0eb1e402014-08-21 22:52:29 -07002192 if (service != null) {
2193 try {
Philip P. Moltmann00cf9fb2020-01-06 16:41:38 -08002194 service.showInCallScreen(showDialpad, mContext.getOpPackageName(),
Philip P. Moltmann12ac3f42020-03-05 15:01:29 -08002195 mContext.getAttributionTag());
Nancy Chen0eb1e402014-08-21 22:52:29 -07002196 } catch (RemoteException e) {
Tyler Gunnef9f6f92014-09-12 22:16:17 -07002197 Log.e(TAG, "Error calling ITelecomService#showCallScreen", e);
Nancy Chen0eb1e402014-08-21 22:52:29 -07002198 }
2199 }
2200 }
2201
Yorke Lee3e56ba12015-04-23 12:32:36 -07002202 /**
2203 * Places a new outgoing call to the provided address using the system telecom service with
2204 * the specified extras.
2205 *
2206 * This method is equivalent to placing an outgoing call using {@link Intent#ACTION_CALL},
2207 * except that the outgoing call will always be sent via the system telecom service. If
2208 * method-caller is either the user selected default dialer app or preloaded system dialer
2209 * app, then emergency calls will also be allowed.
2210 *
Tyler Gunnf5035432017-01-09 09:43:12 -08002211 * Placing a call via a managed {@link ConnectionService} requires permission:
2212 * {@link android.Manifest.permission#CALL_PHONE}
Yorke Lee3e56ba12015-04-23 12:32:36 -07002213 *
2214 * Usage example:
2215 * <pre>
2216 * Uri uri = Uri.fromParts("tel", "12345", null);
2217 * Bundle extras = new Bundle();
2218 * extras.putBoolean(TelecomManager.EXTRA_START_CALL_WITH_SPEAKERPHONE, true);
2219 * telecomManager.placeCall(uri, extras);
2220 * </pre>
2221 *
Santos Cordon7a060d52015-06-19 14:52:04 -07002222 * The following keys are supported in the supplied extras.
2223 * <ul>
2224 * <li>{@link #EXTRA_OUTGOING_CALL_EXTRAS}</li>
2225 * <li>{@link #EXTRA_PHONE_ACCOUNT_HANDLE}</li>
2226 * <li>{@link #EXTRA_START_CALL_WITH_SPEAKERPHONE}</li>
2227 * <li>{@link #EXTRA_START_CALL_WITH_VIDEO_STATE}</li>
2228 * </ul>
Tyler Gunnf5035432017-01-09 09:43:12 -08002229 * <p>
2230 * An app which implements the self-managed {@link ConnectionService} API uses
2231 * {@link #placeCall(Uri, Bundle)} to inform Telecom of a new outgoing call. A self-managed
2232 * {@link ConnectionService} must include {@link #EXTRA_PHONE_ACCOUNT_HANDLE} to specify its
2233 * associated {@link android.telecom.PhoneAccountHandle}.
2234 *
2235 * Self-managed {@link ConnectionService}s require permission
2236 * {@link android.Manifest.permission#MANAGE_OWN_CALLS}.
Santos Cordon7a060d52015-06-19 14:52:04 -07002237 *
Brad Ebinger3636d742019-05-21 15:28:19 -07002238 * <p class="note"><strong>Note:</strong> If this method is used to place an emergency call, it
2239 * is not guaranteed that the call will be placed on the {@link PhoneAccount} provided in
2240 * the {@link #EXTRA_PHONE_ACCOUNT_HANDLE} extra (if specified) and may be placed on another
2241 * {@link PhoneAccount} with the {@link PhoneAccount#CAPABILITY_PLACE_EMERGENCY_CALLS}
2242 * capability, depending on external factors, such as network conditions and Modem/SIM status.
2243 * </p>
2244 *
Yorke Lee3e56ba12015-04-23 12:32:36 -07002245 * @param address The address to make the call to.
2246 * @param extras Bundle of extras to use with the call.
2247 */
Tyler Gunnf5035432017-01-09 09:43:12 -08002248 @RequiresPermission(anyOf = {android.Manifest.permission.CALL_PHONE,
2249 android.Manifest.permission.MANAGE_OWN_CALLS})
Yorke Lee3e56ba12015-04-23 12:32:36 -07002250 public void placeCall(Uri address, Bundle extras) {
2251 ITelecomService service = getTelecomService();
2252 if (service != null) {
Yorke Leea5d5c1d2015-05-05 16:25:55 -07002253 if (address == null) {
2254 Log.w(TAG, "Cannot place call to empty address.");
2255 }
Yorke Lee3e56ba12015-04-23 12:32:36 -07002256 try {
Yorke Leea5d5c1d2015-05-05 16:25:55 -07002257 service.placeCall(address, extras == null ? new Bundle() : extras,
Philip P. Moltmann12ac3f42020-03-05 15:01:29 -08002258 mContext.getOpPackageName(), mContext.getAttributionTag());
Yorke Lee3e56ba12015-04-23 12:32:36 -07002259 } catch (RemoteException e) {
2260 Log.e(TAG, "Error calling ITelecomService#placeCall", e);
2261 }
2262 }
2263 }
2264
Ravi Paluri80aa2142019-12-02 11:57:37 +05302265
2266 /**
Grace Jia8587ee52020-07-10 15:42:32 -07002267 * Place a new adhoc conference call with the provided participants using the system telecom
2268 * service. This method doesn't support placing of emergency calls.
Ravi Paluri80aa2142019-12-02 11:57:37 +05302269 *
2270 * An adhoc conference call is established by providing a list of addresses to
2271 * {@code TelecomManager#startConference(List<Uri>, int videoState)} where the
2272 * {@link ConnectionService} is responsible for connecting all indicated participants
2273 * to a conference simultaneously.
2274 * This is in contrast to conferences formed by merging calls together (e.g. using
2275 * {@link android.telecom.Call#mergeConference()}).
2276 *
2277 * The following keys are supported in the supplied extras.
2278 * <ul>
2279 * <li>{@link #EXTRA_PHONE_ACCOUNT_HANDLE}</li>
2280 * <li>{@link #EXTRA_START_CALL_WITH_SPEAKERPHONE}</li>
2281 * <li>{@link #EXTRA_START_CALL_WITH_VIDEO_STATE}</li>
2282 * </ul>
2283 *
2284 * @param participants List of participants to start conference with
2285 * @param extras Bundle of extras to use with the call
2286 */
2287 @RequiresPermission(android.Manifest.permission.CALL_PHONE)
2288 public void startConference(@NonNull List<Uri> participants,
2289 @NonNull Bundle extras) {
2290 ITelecomService service = getTelecomService();
2291 if (service != null) {
2292 try {
2293 service.startConference(participants, extras,
2294 mContext.getOpPackageName());
2295 } catch (RemoteException e) {
2296 Log.e(TAG, "Error calling ITelecomService#placeCall", e);
2297 }
2298 }
2299 }
2300
Santos Cordon91371dc02015-05-08 13:52:09 -07002301 /**
2302 * Enables and disables specified phone account.
2303 *
2304 * @param handle Handle to the phone account.
2305 * @param isEnabled Enable state of the phone account.
2306 * @hide
2307 */
2308 @SystemApi
Jeff Sharkeybfc4fcd2017-06-05 17:38:17 -06002309 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE)
Santos Cordon91371dc02015-05-08 13:52:09 -07002310 public void enablePhoneAccount(PhoneAccountHandle handle, boolean isEnabled) {
2311 ITelecomService service = getTelecomService();
2312 if (service != null) {
2313 try {
2314 service.enablePhoneAccount(handle, isEnabled);
2315 } catch (RemoteException e) {
2316 Log.e(TAG, "Error enablePhoneAbbount", e);
2317 }
2318 }
2319 }
2320
Hall Liu0464b9b2016-01-12 15:32:58 -08002321 /**
2322 * Dumps telecom analytics for uploading.
2323 *
2324 * @return
2325 * @hide
2326 */
2327 @SystemApi
2328 @RequiresPermission(Manifest.permission.DUMP)
Hall Liu057def52016-05-05 17:17:07 -07002329 public TelecomAnalytics dumpAnalytics() {
Hall Liu0464b9b2016-01-12 15:32:58 -08002330 ITelecomService service = getTelecomService();
Hall Liu057def52016-05-05 17:17:07 -07002331 TelecomAnalytics result = null;
Hall Liu0464b9b2016-01-12 15:32:58 -08002332 if (service != null) {
2333 try {
2334 result = service.dumpCallAnalytics();
2335 } catch (RemoteException e) {
2336 Log.e(TAG, "Error dumping call analytics", e);
2337 }
2338 }
2339 return result;
2340 }
2341
Abhijith Shastry1908cb842016-02-02 11:10:19 -08002342 /**
Abhijith Shastrya26fe992016-02-29 11:40:24 -08002343 * Creates the {@link Intent} which can be used with {@link Context#startActivity(Intent)} to
2344 * launch the activity to manage blocked numbers.
Abhijith Shastryec30d2f2016-03-04 16:46:08 -08002345 * <p> The activity will display the UI to manage blocked numbers only if
Abhijith Shastrya26fe992016-02-29 11:40:24 -08002346 * {@link android.provider.BlockedNumberContract#canCurrentUserBlockNumbers(Context)} returns
2347 * {@code true} for the current user.
2348 */
2349 public Intent createManageBlockedNumbersIntent() {
2350 ITelecomService service = getTelecomService();
2351 Intent result = null;
2352 if (service != null) {
2353 try {
2354 result = service.createManageBlockedNumbersIntent();
2355 } catch (RemoteException e) {
2356 Log.e(TAG, "Error calling ITelecomService#createManageBlockedNumbersIntent", e);
2357 }
2358 }
2359 return result;
2360 }
2361
Fan Zhang5431ef52019-10-14 13:43:46 -07002362
2363 /**
2364 * Creates the {@link Intent} which can be used with {@link Context#startActivity(Intent)} to
2365 * launch the activity for emergency dialer.
2366 *
2367 * @param number Optional number to call in emergency dialer
2368 * @hide
2369 */
2370 @SystemApi
2371 @NonNull
2372 public Intent createLaunchEmergencyDialerIntent(@Nullable String number) {
2373 ITelecomService service = getTelecomService();
Fan Zhang5431ef52019-10-14 13:43:46 -07002374 if (service != null) {
2375 try {
Tyler Gunn753aa102020-04-23 10:16:26 -07002376 return service.createLaunchEmergencyDialerIntent(number);
Fan Zhang5431ef52019-10-14 13:43:46 -07002377 } catch (RemoteException e) {
2378 Log.e(TAG, "Error createLaunchEmergencyDialerIntent", e);
2379 }
Tyler Gunn753aa102020-04-23 10:16:26 -07002380 } else {
2381 Log.w(TAG, "createLaunchEmergencyDialerIntent - Telecom service not available.");
Fan Zhang5431ef52019-10-14 13:43:46 -07002382 }
Tyler Gunn753aa102020-04-23 10:16:26 -07002383
2384 // Telecom service knows the package name of the expected emergency dialer package; if it
2385 // is not available, then fallback to not targeting a specific package.
2386 Intent intent = new Intent(Intent.ACTION_DIAL_EMERGENCY);
2387 if (!TextUtils.isEmpty(number) && TextUtils.isDigitsOnly(number)) {
2388 intent.setData(Uri.fromParts(PhoneAccount.SCHEME_TEL, number, null));
2389 }
2390 return intent;
Fan Zhang5431ef52019-10-14 13:43:46 -07002391 }
2392
Tyler Gunnf5035432017-01-09 09:43:12 -08002393 /**
2394 * Determines whether Telecom would permit an incoming call to be added via the
2395 * {@link #addNewIncomingCall(PhoneAccountHandle, Bundle)} API for the specified
2396 * {@link PhoneAccountHandle}.
2397 * <p>
2398 * A {@link ConnectionService} may not add a call for the specified {@link PhoneAccountHandle}
2399 * in the following situations:
2400 * <ul>
2401 * <li>{@link PhoneAccount} does not have property
2402 * {@link PhoneAccount#CAPABILITY_SELF_MANAGED} set (i.e. it is a managed
2403 * {@link ConnectionService}), and the active or held call limit has
2404 * been reached.</li>
2405 * <li>There is an ongoing emergency call.</li>
2406 * </ul>
2407 *
2408 * @param phoneAccountHandle The {@link PhoneAccountHandle} the call will be added for.
2409 * @return {@code true} if telecom will permit an incoming call to be added, {@code false}
2410 * otherwise.
2411 */
2412 public boolean isIncomingCallPermitted(PhoneAccountHandle phoneAccountHandle) {
Tyler Gunn44e01912017-01-31 10:49:05 -08002413 if (phoneAccountHandle == null) {
2414 return false;
2415 }
2416
Tyler Gunnf5035432017-01-09 09:43:12 -08002417 ITelecomService service = getTelecomService();
2418 if (service != null) {
2419 try {
2420 return service.isIncomingCallPermitted(phoneAccountHandle);
2421 } catch (RemoteException e) {
2422 Log.e(TAG, "Error isIncomingCallPermitted", e);
2423 }
2424 }
2425 return false;
2426 }
2427
2428 /**
2429 * Determines whether Telecom would permit an outgoing call to be placed via the
2430 * {@link #placeCall(Uri, Bundle)} API for the specified {@link PhoneAccountHandle}.
2431 * <p>
2432 * A {@link ConnectionService} may not place a call for the specified {@link PhoneAccountHandle}
2433 * in the following situations:
2434 * <ul>
2435 * <li>{@link PhoneAccount} does not have property
2436 * {@link PhoneAccount#CAPABILITY_SELF_MANAGED} set (i.e. it is a managed
2437 * {@link ConnectionService}), and the active, held or ringing call limit has
2438 * been reached.</li>
2439 * <li>{@link PhoneAccount} has property {@link PhoneAccount#CAPABILITY_SELF_MANAGED} set
2440 * (i.e. it is a self-managed {@link ConnectionService} and there is an ongoing call in
2441 * another {@link ConnectionService}.</li>
2442 * <li>There is an ongoing emergency call.</li>
2443 * </ul>
2444 *
2445 * @param phoneAccountHandle The {@link PhoneAccountHandle} the call will be added for.
2446 * @return {@code true} if telecom will permit an outgoing call to be placed, {@code false}
2447 * otherwise.
2448 */
2449 public boolean isOutgoingCallPermitted(PhoneAccountHandle phoneAccountHandle) {
2450 ITelecomService service = getTelecomService();
2451 if (service != null) {
2452 try {
2453 return service.isOutgoingCallPermitted(phoneAccountHandle);
2454 } catch (RemoteException e) {
2455 Log.e(TAG, "Error isOutgoingCallPermitted", e);
2456 }
2457 }
2458 return false;
2459 }
2460
Sanket Padawea8eddd42017-11-03 11:07:35 -07002461 /**
Tyler Gunn9d127732018-03-02 15:45:51 -08002462 * Called by an app to indicate that it wishes to accept the handover of an ongoing call to a
2463 * {@link PhoneAccountHandle} it defines.
2464 * <p>
2465 * A call handover is the process where an ongoing call is transferred from one app (i.e.
2466 * {@link ConnectionService} to another app. The user could, for example, choose to continue a
2467 * mobile network call in a video calling app. The mobile network call via the Telephony stack
2468 * is referred to as the source of the handover, and the video calling app is referred to as the
2469 * destination.
2470 * <p>
2471 * When considering a handover scenario the <em>initiating</em> device is where a user initiated
2472 * the handover process (e.g. by calling {@link android.telecom.Call#handoverTo(
2473 * PhoneAccountHandle, int, Bundle)}, and the other device is considered the <em>receiving</em>
2474 * device.
2475 * <p>
2476 * For a full discussion of the handover process and the APIs involved, see
2477 * {@link android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle)}.
2478 * <p>
2479 * This method is called from the <em>receiving</em> side of a handover to indicate a desire to
2480 * accept the handover of an ongoing call to another {@link ConnectionService} identified by
Sanket Padawea8eddd42017-11-03 11:07:35 -07002481 * {@link PhoneAccountHandle} destAcct. For managed {@link ConnectionService}s, the specified
2482 * {@link PhoneAccountHandle} must have been registered with {@link #registerPhoneAccount} and
2483 * the user must have enabled the corresponding {@link PhoneAccount}. This can be checked using
2484 * {@link #getPhoneAccount}. Self-managed {@link ConnectionService}s must have
2485 * {@link android.Manifest.permission#MANAGE_OWN_CALLS} to handover a call to it.
2486 * <p>
2487 * Once invoked, this method will cause the system to bind to the {@link ConnectionService}
2488 * associated with the {@link PhoneAccountHandle} destAcct and call
2489 * (See {@link ConnectionService#onCreateIncomingHandoverConnection}).
2490 * <p>
2491 * For a managed {@link ConnectionService}, a {@link SecurityException} will be thrown if either
2492 * the {@link PhoneAccountHandle} destAcct does not correspond to a registered
2493 * {@link PhoneAccount} or the associated {@link PhoneAccount} is not currently enabled by the
2494 * user.
2495 * <p>
2496 * For a self-managed {@link ConnectionService}, a {@link SecurityException} will be thrown if
2497 * the calling app does not have {@link android.Manifest.permission#MANAGE_OWN_CALLS}.
2498 *
2499 * @param srcAddr The {@link android.net.Uri} of the ongoing call to handover to the caller’s
2500 * {@link ConnectionService}.
2501 * @param videoState Video state after the handover.
2502 * @param destAcct The {@link PhoneAccountHandle} registered to the calling package.
2503 */
Tyler Gunn9d127732018-03-02 15:45:51 -08002504 public void acceptHandover(Uri srcAddr, @VideoProfile.VideoState int videoState,
2505 PhoneAccountHandle destAcct) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00002506 ITelecomService service = getTelecomService();
2507 if (service != null) {
2508 try {
2509 service.acceptHandover(srcAddr, videoState, destAcct);
2510 } catch (RemoteException e) {
2511 Log.e(TAG, "RemoteException acceptHandover: " + e);
Sanket Padawea8eddd42017-11-03 11:07:35 -07002512 }
Sanket Padawea8eddd42017-11-03 11:07:35 -07002513 }
2514 }
Tyler Gunnf5035432017-01-09 09:43:12 -08002515
Tyler Gunn5bd90852018-09-21 09:37:07 -07002516 /**
2517 * Determines if there is an ongoing emergency call. This can be either an outgoing emergency
2518 * call, as identified by the dialed number, or because a call was identified by the network
2519 * as an emergency call.
2520 * @return {@code true} if there is an ongoing emergency call, {@code false} otherwise.
2521 * @hide
2522 */
2523 @SystemApi
2524 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE)
2525 public boolean isInEmergencyCall() {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00002526 ITelecomService service = getTelecomService();
2527 if (service != null) {
2528 try {
2529 return service.isInEmergencyCall();
2530 } catch (RemoteException e) {
2531 Log.e(TAG, "RemoteException isInEmergencyCall: " + e);
2532 return false;
Tyler Gunn5bd90852018-09-21 09:37:07 -07002533 }
Tyler Gunn5bd90852018-09-21 09:37:07 -07002534 }
2535 return false;
2536 }
2537
Tyler Gunnc37445c2018-09-28 16:16:20 -07002538 /**
2539 * Handles {@link Intent#ACTION_CALL} intents trampolined from UserCallActivity.
2540 * @param intent The {@link Intent#ACTION_CALL} intent to handle.
Brad Ebingera9a33e12019-09-27 16:55:35 -07002541 * @param callingPackageProxy The original package that called this before it was trampolined.
Tyler Gunnc37445c2018-09-28 16:16:20 -07002542 * @hide
2543 */
Brad Ebingera9a33e12019-09-27 16:55:35 -07002544 public void handleCallIntent(Intent intent, String callingPackageProxy) {
Kevin Jeoneddcb1b2020-11-11 00:07:39 +00002545 ITelecomService service = getTelecomService();
2546 if (service != null) {
2547 try {
2548 service.handleCallIntent(intent, callingPackageProxy);
2549 } catch (RemoteException e) {
2550 Log.e(TAG, "RemoteException handleCallIntent: " + e);
Tyler Gunnc37445c2018-09-28 16:16:20 -07002551 }
Tyler Gunnc37445c2018-09-28 16:16:20 -07002552 }
Tyler Gunnc37445c2018-09-28 16:16:20 -07002553 }
2554
Shuo Qian4d065262020-10-20 11:04:28 -07002555 private boolean isSystemProcess() {
2556 return Process.myUid() == Process.SYSTEM_UID;
2557 }
2558
Tyler Gunnef9f6f92014-09-12 22:16:17 -07002559 private ITelecomService getTelecomService() {
Hall Liue1bc2ec2015-10-09 15:58:37 -07002560 if (mTelecomServiceOverride != null) {
2561 return mTelecomServiceOverride;
2562 }
Kevin Jeon767cda32020-11-17 01:40:16 +00002563 if (sTelecomService == null) {
2564 ITelecomService temp = ITelecomService.Stub.asInterface(
2565 ServiceManager.getService(Context.TELECOM_SERVICE));
2566 synchronized (CACHE_LOCK) {
2567 if (sTelecomService == null && temp != null) {
2568 try {
2569 sTelecomService = temp;
2570 sTelecomService.asBinder().linkToDeath(SERVICE_DEATH, 0);
2571 } catch (Exception e) {
2572 sTelecomService = null;
2573 }
2574 }
2575 }
Santos Cordon9eb45932014-06-27 12:28:43 -07002576 }
Kevin Jeon767cda32020-11-17 01:40:16 +00002577 return sTelecomService;
2578 }
2579
2580 private static class DeathRecipient implements IBinder.DeathRecipient {
2581 @Override
2582 public void binderDied() {
2583 resetServiceCache();
2584 }
2585 }
2586
2587 private static void resetServiceCache() {
2588 synchronized (CACHE_LOCK) {
2589 if (sTelecomService != null) {
2590 sTelecomService.asBinder().unlinkToDeath(SERVICE_DEATH, 0);
2591 sTelecomService = null;
2592 }
2593 }
Santos Cordon9eb45932014-06-27 12:28:43 -07002594 }
Evan Charlton235c1592014-09-05 15:41:23 +00002595}