1 /* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * 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 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * 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. 13 */ 14 15 package android.telecom; 16 17 import static android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE; 18 import static android.content.Intent.LOCAL_FLAG_FROM_SYSTEM; 19 20 import android.Manifest; 21 import android.annotation.CallbackExecutor; 22 import android.annotation.IntDef; 23 import android.annotation.NonNull; 24 import android.annotation.Nullable; 25 import android.annotation.RequiresFeature; 26 import android.annotation.RequiresPermission; 27 import android.annotation.SuppressAutoDoc; 28 import android.annotation.SuppressLint; 29 import android.annotation.SystemApi; 30 import android.annotation.SystemService; 31 import android.compat.annotation.ChangeId; 32 import android.compat.annotation.EnabledSince; 33 import android.compat.annotation.UnsupportedAppUsage; 34 import android.content.ComponentName; 35 import android.content.Context; 36 import android.content.Intent; 37 import android.content.pm.PackageManager; 38 import android.net.Uri; 39 import android.os.Build; 40 import android.os.Bundle; 41 import android.os.IBinder; 42 import android.os.OutcomeReceiver; 43 import android.os.Process; 44 import android.os.RemoteException; 45 import android.os.ServiceManager; 46 import android.os.UserHandle; 47 import android.telephony.Annotation.CallState; 48 import android.telephony.SubscriptionManager; 49 import android.telephony.TelephonyManager; 50 import android.text.TextUtils; 51 import android.util.Log; 52 53 import com.android.internal.annotations.GuardedBy; 54 import com.android.internal.telecom.ClientTransactionalServiceRepository; 55 import com.android.internal.telecom.ClientTransactionalServiceWrapper; 56 import com.android.internal.telecom.ITelecomService; 57 58 import java.lang.annotation.Retention; 59 import java.lang.annotation.RetentionPolicy; 60 import java.util.ArrayList; 61 import java.util.Collections; 62 import java.util.List; 63 import java.util.Objects; 64 import java.util.concurrent.Executor; 65 66 /** 67 * Provides access to information about active calls and registration/call-management functionality. 68 * Apps can use methods in this class to determine the current call state. 69 * <p> 70 * Apps do not instantiate this class directly; instead, they retrieve a reference to an instance 71 * through {@link Context#getSystemService Context.getSystemService(Context.TELECOM_SERVICE)}. 72 * <p> 73 * Note that access to some telecom information is permission-protected. Your app cannot access the 74 * protected information or gain access to protected functionality unless it has the appropriate 75 * permissions declared in its manifest file. Where permissions apply, they are noted in the method 76 * descriptions. 77 */ 78 @SuppressAutoDoc 79 @SystemService(Context.TELECOM_SERVICE) 80 @RequiresFeature(PackageManager.FEATURE_TELECOM) 81 public class TelecomManager { 82 83 /** 84 * Activity action: Starts the UI for handing an incoming call. This intent starts the in-call 85 * UI by notifying the Telecom system that an incoming call exists for a specific call service 86 * (see {@link android.telecom.ConnectionService}). Telecom reads the Intent extras to find 87 * and bind to the appropriate {@link android.telecom.ConnectionService} which Telecom will 88 * ultimately use to control and get information about the call. 89 * <p> 90 * Input: get*Extra field {@link #EXTRA_PHONE_ACCOUNT_HANDLE} contains the component name of the 91 * {@link android.telecom.ConnectionService} that Telecom should bind to. Telecom will then 92 * ask the connection service for more information about the call prior to showing any UI. 93 * 94 * @deprecated Use {@link #addNewIncomingCall} instead. 95 */ 96 public static final String ACTION_INCOMING_CALL = "android.telecom.action.INCOMING_CALL"; 97 98 /** 99 * Similar to {@link #ACTION_INCOMING_CALL}, but is used only by Telephony to add a new 100 * sim-initiated MO call for carrier testing. 101 * @deprecated Use {@link #addNewUnknownCall} instead. 102 * @hide 103 */ 104 public static final String ACTION_NEW_UNKNOWN_CALL = "android.telecom.action.NEW_UNKNOWN_CALL"; 105 106 /** 107 * An {@link android.content.Intent} action sent by the telecom framework to start a 108 * configuration dialog for a registered {@link PhoneAccount}. There is no default dialog 109 * and each app that registers a {@link PhoneAccount} should provide one if desired. 110 * <p> 111 * A user can access the list of enabled {@link android.telecom.PhoneAccount}s through the Phone 112 * app's settings menu. For each entry, the settings app will add a click action. When 113 * triggered, the click-action will start this intent along with the extra 114 * {@link #EXTRA_PHONE_ACCOUNT_HANDLE} to indicate the {@link PhoneAccount} to configure. If the 115 * {@link PhoneAccount} package does not register an {@link android.app.Activity} for this 116 * intent, then it will not be sent. 117 */ 118 public static final String ACTION_CONFIGURE_PHONE_ACCOUNT = 119 "android.telecom.action.CONFIGURE_PHONE_ACCOUNT"; 120 121 /** 122 * The {@link android.content.Intent} action used to show the call accessibility settings page. 123 */ 124 public static final String ACTION_SHOW_CALL_ACCESSIBILITY_SETTINGS = 125 "android.telecom.action.SHOW_CALL_ACCESSIBILITY_SETTINGS"; 126 127 /** 128 * The {@link android.content.Intent} action used to show the call settings page. 129 */ 130 public static final String ACTION_SHOW_CALL_SETTINGS = 131 "android.telecom.action.SHOW_CALL_SETTINGS"; 132 133 /** 134 * The {@link android.content.Intent} action used to show the respond via SMS settings page. 135 */ 136 public static final String ACTION_SHOW_RESPOND_VIA_SMS_SETTINGS = 137 "android.telecom.action.SHOW_RESPOND_VIA_SMS_SETTINGS"; 138 139 /** 140 * The {@link android.content.Intent} action used to show the settings page used to configure 141 * {@link PhoneAccount} preferences. 142 */ 143 public static final String ACTION_CHANGE_PHONE_ACCOUNTS = 144 "android.telecom.action.CHANGE_PHONE_ACCOUNTS"; 145 146 /** 147 * {@link android.content.Intent} action used indicate that a new phone account was just 148 * registered. 149 * <p> 150 * The Intent {@link Intent#getExtras() extras} will contain {@link #EXTRA_PHONE_ACCOUNT_HANDLE} 151 * to indicate which {@link PhoneAccount} was registered. 152 * <p> 153 * Will only be sent to the default dialer app (see {@link #getDefaultDialerPackage()}). 154 */ 155 public static final String ACTION_PHONE_ACCOUNT_REGISTERED = 156 "android.telecom.action.PHONE_ACCOUNT_REGISTERED"; 157 158 /** 159 * {@link android.content.Intent} action used indicate that a phone account was just 160 * unregistered. 161 * <p> 162 * The Intent {@link Intent#getExtras() extras} will contain {@link #EXTRA_PHONE_ACCOUNT_HANDLE} 163 * to indicate which {@link PhoneAccount} was unregistered. 164 * <p> 165 * Will only be sent to the default dialer app (see {@link #getDefaultDialerPackage()}). 166 */ 167 public static final String ACTION_PHONE_ACCOUNT_UNREGISTERED = 168 "android.telecom.action.PHONE_ACCOUNT_UNREGISTERED"; 169 170 /** 171 * Activity action: Shows a dialog asking the user whether or not they want to replace the 172 * current default Dialer with the one specified in 173 * {@link #EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME}. 174 * 175 * Usage example: 176 * <pre> 177 * Intent intent = new Intent(TelecomManager.ACTION_CHANGE_DEFAULT_DIALER); 178 * intent.putExtra(TelecomManager.EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME, 179 * getActivity().getPackageName()); 180 * startActivity(intent); 181 * </pre> 182 * <p> 183 * This is no longer supported since Q, please use 184 * {@link android.app.role.RoleManager#createRequestRoleIntent(String)} with 185 * {@link android.app.role.RoleManager#ROLE_DIALER} instead. 186 */ 187 public static final String ACTION_CHANGE_DEFAULT_DIALER = 188 "android.telecom.action.CHANGE_DEFAULT_DIALER"; 189 190 /** 191 * Broadcast intent action indicating that the current default dialer has changed. 192 * The string extra {@link #EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME} will contain the 193 * name of the package that the default dialer was changed to. 194 * 195 * @see #EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME 196 */ 197 public static final String ACTION_DEFAULT_DIALER_CHANGED = 198 "android.telecom.action.DEFAULT_DIALER_CHANGED"; 199 200 /** 201 * Extra value used to provide the package name for {@link #ACTION_CHANGE_DEFAULT_DIALER}. 202 */ 203 public static final String EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME = 204 "android.telecom.extra.CHANGE_DEFAULT_DIALER_PACKAGE_NAME"; 205 206 /** 207 * Broadcast intent action indicating that the current default call screening app has changed. 208 * <p> 209 * Note: This intent is NEVER actually broadcast and will be deprecated in the future. 210 * <p> 211 * An app that want to know if it holds the 212 * {@link android.app.role.RoleManager#ROLE_CALL_SCREENING} role can use 213 * {@link android.app.role.RoleManager#isRoleHeld(String)} to confirm if it holds the role or 214 * not. 215 */ 216 public static final String ACTION_DEFAULT_CALL_SCREENING_APP_CHANGED = 217 "android.telecom.action.DEFAULT_CALL_SCREENING_APP_CHANGED"; 218 219 /** 220 * Extra value used with {@link #ACTION_DEFAULT_CALL_SCREENING_APP_CHANGED} broadcast to 221 * indicate the ComponentName of the call screening app which has changed. 222 * <p> 223 * Note: This extra is NOT used and will be deprecated in the future. 224 */ 225 public static final String EXTRA_DEFAULT_CALL_SCREENING_APP_COMPONENT_NAME = 226 "android.telecom.extra.DEFAULT_CALL_SCREENING_APP_COMPONENT_NAME"; 227 228 /** 229 * Extra value used with {@link #ACTION_DEFAULT_CALL_SCREENING_APP_CHANGED} broadcast to 230 * indicate whether an app is the default call screening app. 231 * <p> 232 * Note: This extra is NOT used and will be deprecated in the future. 233 */ 234 public static final String EXTRA_IS_DEFAULT_CALL_SCREENING_APP = 235 "android.telecom.extra.IS_DEFAULT_CALL_SCREENING_APP"; 236 237 /** 238 * Optional extra for {@link android.content.Intent#ACTION_CALL} containing a boolean that 239 * determines whether the speakerphone should be automatically turned on for an outgoing call. 240 */ 241 public static final String EXTRA_START_CALL_WITH_SPEAKERPHONE = 242 "android.telecom.extra.START_CALL_WITH_SPEAKERPHONE"; 243 244 /** 245 * Optional extra for {@link android.content.Intent#ACTION_CALL} containing an integer that 246 * determines the desired video state for an outgoing call. 247 * Valid options: 248 * {@link VideoProfile#STATE_AUDIO_ONLY}, 249 * {@link VideoProfile#STATE_BIDIRECTIONAL}, 250 * {@link VideoProfile#STATE_RX_ENABLED}, 251 * {@link VideoProfile#STATE_TX_ENABLED}. 252 */ 253 public static final String EXTRA_START_CALL_WITH_VIDEO_STATE = 254 "android.telecom.extra.START_CALL_WITH_VIDEO_STATE"; 255 256 /** 257 * Optional extra for {@link #addNewIncomingCall(PhoneAccountHandle, Bundle)} containing an 258 * integer that determines the requested video state for an incoming call. 259 * Valid options: 260 * {@link VideoProfile#STATE_AUDIO_ONLY}, 261 * {@link VideoProfile#STATE_BIDIRECTIONAL}, 262 * {@link VideoProfile#STATE_RX_ENABLED}, 263 * {@link VideoProfile#STATE_TX_ENABLED}. 264 */ 265 public static final String EXTRA_INCOMING_VIDEO_STATE = 266 "android.telecom.extra.INCOMING_VIDEO_STATE"; 267 268 /** 269 * The extra used with an {@link android.content.Intent#ACTION_CALL} and 270 * {@link android.content.Intent#ACTION_DIAL} {@code Intent} to specify a 271 * {@link PhoneAccountHandle} to use when making the call. 272 * <p class="note"> 273 * Retrieve with {@link android.content.Intent#getParcelableExtra(String)}. 274 */ 275 public static final String EXTRA_PHONE_ACCOUNT_HANDLE = 276 "android.telecom.extra.PHONE_ACCOUNT_HANDLE"; 277 278 /** 279 * Optional extra for {@link android.content.Intent#ACTION_CALL} containing a string call 280 * subject which will be associated with an outgoing call. Should only be specified if the 281 * {@link PhoneAccount} supports the capability {@link PhoneAccount#CAPABILITY_CALL_SUBJECT} 282 * or {@link PhoneAccount#CAPABILITY_CALL_COMPOSER}. 283 */ 284 public static final String EXTRA_CALL_SUBJECT = "android.telecom.extra.CALL_SUBJECT"; 285 286 // Values for EXTRA_PRIORITY 287 /** 288 * Indicates the call composer call priority is normal. 289 * 290 * Reference: RCC.20 Section 2.4.4.2 291 */ 292 public static final int PRIORITY_NORMAL = 0; 293 294 /** 295 * Indicates the call composer call priority is urgent. 296 * 297 * Reference: RCC.20 Section 2.4.4.2 298 */ 299 public static final int PRIORITY_URGENT = 1; 300 301 /** 302 * Extra for the call composer call priority, either {@link #PRIORITY_NORMAL} or 303 * {@link #PRIORITY_URGENT}. 304 * 305 * Reference: RCC.20 Section 2.4.4.2 306 */ 307 public static final String EXTRA_PRIORITY = "android.telecom.extra.PRIORITY"; 308 309 /** 310 * Extra for the call composer call location, an {@link android.location.Location} parcelable 311 * class to represent the geolocation as a latitude and longitude pair. 312 * 313 * Reference: RCC.20 Section 2.4.3.2 314 */ 315 public static final String EXTRA_LOCATION = "android.telecom.extra.LOCATION"; 316 317 /** 318 * A boolean extra set on incoming calls to indicate that the call has a picture specified. 319 * Given that image download could take a (short) time, the EXTRA is set immediately upon 320 * adding the call to the Dialer app, this allows the Dialer app to reserve space for an image 321 * if one is expected. The EXTRA may be unset if the image download ends up failing for some 322 * reason. 323 */ 324 public static final String EXTRA_HAS_PICTURE = "android.telecom.extra.HAS_PICTURE"; 325 326 /** 327 * A {@link Uri} representing the picture that was downloaded when a call is received or 328 * uploaded when a call is placed. 329 * 330 * This is a content URI within the call log provider which can be used to open a file 331 * descriptor. This could be set a short time after a call is added to the Dialer app if the 332 * download/upload is delayed for some reason. The Dialer app will receive a callback via 333 * {@link Call.Callback#onDetailsChanged} when this value has changed. 334 * 335 * Reference: RCC.20 Section 2.4.3.2 336 */ 337 public static final String EXTRA_PICTURE_URI = "android.telecom.extra.PICTURE_URI"; 338 339 /** 340 * A ParcelUuid used as a token to represent a picture that was uploaded prior to the call 341 * being placed. The value of this extra should be set using the {@link android.os.ParcelUuid} 342 * obtained from the callback in {@link TelephonyManager#uploadCallComposerPicture}. 343 */ 344 public static final String EXTRA_OUTGOING_PICTURE = "android.telecom.extra.OUTGOING_PICTURE"; 345 346 /** 347 * The extra used by a {@link ConnectionService} to provide the handle of the caller that 348 * has initiated a new incoming call. 349 */ 350 public static final String EXTRA_INCOMING_CALL_ADDRESS = 351 "android.telecom.extra.INCOMING_CALL_ADDRESS"; 352 353 /** 354 * Optional extra for {@link #ACTION_INCOMING_CALL} containing a {@link Bundle} which contains 355 * metadata about the call. This {@link Bundle} will be returned to the 356 * {@link ConnectionService}. 357 */ 358 public static final String EXTRA_INCOMING_CALL_EXTRAS = 359 "android.telecom.extra.INCOMING_CALL_EXTRAS"; 360 361 /** 362 * Optional extra for {@link #addNewIncomingCall(PhoneAccountHandle, Bundle)} used to indicate 363 * that a call has an in-band ringtone associated with it. This is used when the device is 364 * acting as an HFP headset and the Bluetooth stack has received an in-band ringtone from the 365 * the HFP host which must be played instead of any local ringtone the device would otherwise 366 * have generated. 367 * 368 * @hide 369 */ 370 @SystemApi 371 public static final String EXTRA_CALL_HAS_IN_BAND_RINGTONE = 372 "android.telecom.extra.CALL_HAS_IN_BAND_RINGTONE"; 373 374 /** 375 * Optional extra for {@link android.content.Intent#ACTION_CALL} and 376 * {@link android.content.Intent#ACTION_DIAL} {@code Intent} containing a {@link Bundle} 377 * which contains metadata about the call. This {@link Bundle} will be saved into 378 * {@code Call.Details} and passed to the {@link ConnectionService} when placing the call. 379 */ 380 public static final String EXTRA_OUTGOING_CALL_EXTRAS = 381 "android.telecom.extra.OUTGOING_CALL_EXTRAS"; 382 383 /** 384 * An optional boolean extra on {@link android.content.Intent#ACTION_CALL_EMERGENCY} to tell 385 * whether the user's dial intent is emergency; this is required to specify when the dialed 386 * number is ambiguous, identified as both emergency number and any other non-emergency number; 387 * e.g. in some situation, 611 could be both an emergency number in a country and a 388 * non-emergency number of a carrier's customer service hotline. 389 * 390 * @hide 391 */ 392 @SystemApi 393 public static final String EXTRA_IS_USER_INTENT_EMERGENCY_CALL = 394 "android.telecom.extra.IS_USER_INTENT_EMERGENCY_CALL"; 395 396 /** 397 * A mandatory extra containing a {@link Uri} to be passed in when calling 398 * {@link #addNewUnknownCall(PhoneAccountHandle, Bundle)}. The {@link Uri} value indicates 399 * the remote handle of the new call. 400 * @hide 401 */ 402 @SystemApi 403 public static final String EXTRA_UNKNOWN_CALL_HANDLE = 404 "android.telecom.extra.UNKNOWN_CALL_HANDLE"; 405 406 /** 407 * Optional extra for incoming and outgoing calls containing a long which specifies the time the 408 * call was created. This value is in milliseconds since boot. 409 * @hide 410 */ 411 public static final String EXTRA_CALL_CREATED_TIME_MILLIS = 412 "android.telecom.extra.CALL_CREATED_TIME_MILLIS"; 413 414 /** 415 * Optional extra for incoming and outgoing calls containing a long which specifies the Epoch 416 * time the call was created. 417 * @hide 418 */ 419 public static final String EXTRA_CALL_CREATED_EPOCH_TIME_MILLIS = 420 "android.telecom.extra.CALL_CREATED_EPOCH_TIME_MILLIS"; 421 422 /** 423 * Optional extra for incoming and outgoing calls containing a long which specifies the time 424 * telecom began routing the call. This value is in milliseconds since boot. 425 * @hide 426 */ 427 public static final String EXTRA_CALL_TELECOM_ROUTING_START_TIME_MILLIS = 428 "android.telecom.extra.CALL_TELECOM_ROUTING_START_TIME_MILLIS"; 429 430 /** 431 * Optional extra for incoming and outgoing calls containing a long which specifies the time 432 * telecom finished routing the call. This value is in milliseconds since boot. 433 * @hide 434 */ 435 public static final String EXTRA_CALL_TELECOM_ROUTING_END_TIME_MILLIS = 436 "android.telecom.extra.CALL_TELECOM_ROUTING_END_TIME_MILLIS"; 437 438 /** 439 * Optional extra for {@link android.telephony.TelephonyManager#ACTION_PHONE_STATE_CHANGED} 440 * containing the disconnect code. 441 */ 442 public static final String EXTRA_CALL_DISCONNECT_CAUSE = 443 "android.telecom.extra.CALL_DISCONNECT_CAUSE"; 444 445 /** 446 * Optional extra for {@link android.telephony.TelephonyManager#ACTION_PHONE_STATE_CHANGED} 447 * containing the disconnect message. 448 */ 449 public static final String EXTRA_CALL_DISCONNECT_MESSAGE = 450 "android.telecom.extra.CALL_DISCONNECT_MESSAGE"; 451 452 /** 453 * A string value for {@link #EXTRA_CALL_DISCONNECT_MESSAGE}, indicates the call was dropped by 454 * lower layers 455 * @hide 456 */ 457 public static final String CALL_AUTO_DISCONNECT_MESSAGE_STRING = 458 "Call dropped by lower layers"; 459 460 /** 461 * Optional extra for {@link android.telephony.TelephonyManager#ACTION_PHONE_STATE_CHANGED} 462 * containing the component name of the associated connection service. 463 * @hide 464 */ 465 @SystemApi 466 public static final String EXTRA_CONNECTION_SERVICE = 467 "android.telecom.extra.CONNECTION_SERVICE"; 468 469 /** 470 * Optional extra for communicating the call technology used by a {@link ConnectionService} 471 * to Telecom. Valid values are: 472 * <ul> 473 * <li>{@link TelephonyManager#PHONE_TYPE_CDMA}</li> 474 * <li>{@link TelephonyManager#PHONE_TYPE_GSM}</li> 475 * <li>{@link TelephonyManager#PHONE_TYPE_IMS}</li> 476 * <li>{@link TelephonyManager#PHONE_TYPE_THIRD_PARTY}</li> 477 * <li>{@link TelephonyManager#PHONE_TYPE_SIP}</li> 478 * </ul> 479 * @hide 480 */ 481 @SystemApi 482 public static final String EXTRA_CALL_TECHNOLOGY_TYPE = 483 "android.telecom.extra.CALL_TECHNOLOGY_TYPE"; 484 485 /** 486 * Optional extra for communicating the call network technology used by a 487 * {@link android.telecom.Connection} to Telecom and InCallUI. 488 * 489 * {@code NETWORK_TYPE_*} in {@link android.telephony.TelephonyManager}. 490 */ 491 public static final String EXTRA_CALL_NETWORK_TYPE = 492 "android.telecom.extra.CALL_NETWORK_TYPE"; 493 494 /** 495 * An optional {@link android.content.Intent#ACTION_CALL} intent extra denoting the 496 * package name of the app specifying an alternative gateway for the call. 497 * The value is a string. 498 * 499 * (The following comment corresponds to the all GATEWAY_* extras) 500 * An app which sends the {@link android.content.Intent#ACTION_CALL} intent can specify an 501 * alternative address to dial which is different from the one specified and displayed to 502 * the user. This alternative address is referred to as the gateway address. 503 */ 504 public static final String GATEWAY_PROVIDER_PACKAGE = 505 "android.telecom.extra.GATEWAY_PROVIDER_PACKAGE"; 506 507 /** 508 * An optional {@link android.content.Intent#ACTION_CALL} intent extra corresponding to the 509 * original address to dial for the call. This is used when an alternative gateway address is 510 * provided to recall the original address. 511 * The value is a {@link android.net.Uri}. 512 * 513 * (See {@link #GATEWAY_PROVIDER_PACKAGE} for details) 514 */ 515 public static final String GATEWAY_ORIGINAL_ADDRESS = 516 "android.telecom.extra.GATEWAY_ORIGINAL_ADDRESS"; 517 518 /** 519 * The number which the party on the other side of the line will see (and use to return the 520 * call). 521 * <p> 522 * {@link ConnectionService}s which interact with {@link RemoteConnection}s should only populate 523 * this if the {@link android.telephony.TelephonyManager#getLine1Number()} value, as that is the 524 * user's expected caller ID. 525 */ 526 public static final String EXTRA_CALL_BACK_NUMBER = "android.telecom.extra.CALL_BACK_NUMBER"; 527 528 /** 529 * The number of milliseconds that Telecom should wait after disconnecting a call via the 530 * ACTION_NEW_OUTGOING_CALL broadcast, in order to wait for the app which cancelled the call 531 * to make a new one. 532 * @hide 533 */ 534 public static final String EXTRA_NEW_OUTGOING_CALL_CANCEL_TIMEOUT = 535 "android.telecom.extra.NEW_OUTGOING_CALL_CANCEL_TIMEOUT"; 536 537 /** 538 * Boolean extra specified to indicate that the intention of adding a call is to handover an 539 * existing call from the user's device to a different {@link PhoneAccount}. 540 * <p> 541 * Used when calling {@link #addNewIncomingCall(PhoneAccountHandle, Bundle)} 542 * to indicate to Telecom that the purpose of adding a new incoming call is to handover an 543 * existing call from the user's device to a different {@link PhoneAccount}. This occurs on 544 * the receiving side of a handover. 545 * <p> 546 * Used when Telecom calls 547 * {@link ConnectionService#onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)} 548 * to indicate that the purpose of Telecom requesting a new outgoing connection it to request 549 * a handover to this {@link ConnectionService} from an ongoing call on the user's device. This 550 * occurs on the initiating side of a handover. 551 * <p> 552 * The phone number of the call used by Telecom to determine which call should be handed over. 553 * @hide 554 * @deprecated Use the public handover APIs. See 555 * {@link Call#handoverTo(PhoneAccountHandle, int, Bundle)} for more information. 556 */ 557 @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 119305590) 558 public static final String EXTRA_IS_HANDOVER = "android.telecom.extra.IS_HANDOVER"; 559 560 /** 561 * When {@code true} indicates that a request to create a new connection is for the purpose of 562 * a handover. Note: This is used with the 563 * {@link android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle)} API as part of the 564 * internal communication mechanism with the {@link android.telecom.ConnectionService}. It is 565 * not the same as the legacy {@link #EXTRA_IS_HANDOVER} extra. 566 * @hide 567 */ 568 public static final String EXTRA_IS_HANDOVER_CONNECTION = 569 "android.telecom.extra.IS_HANDOVER_CONNECTION"; 570 571 /** 572 * Parcelable extra used with {@link #EXTRA_IS_HANDOVER} to indicate the source 573 * {@link PhoneAccountHandle} when initiating a handover which {@link ConnectionService} 574 * the handover is from. 575 * @hide 576 */ 577 public static final String EXTRA_HANDOVER_FROM_PHONE_ACCOUNT = 578 "android.telecom.extra.HANDOVER_FROM_PHONE_ACCOUNT"; 579 580 /** 581 * Extra key specified in the {@link ConnectionRequest#getExtras()} when Telecom calls 582 * {@link ConnectionService#onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)} 583 * to inform the {@link ConnectionService} what the initial {@link CallAudioState} of the 584 * {@link Connection} will be. 585 * @hide 586 */ 587 public static final String EXTRA_CALL_AUDIO_STATE = "android.telecom.extra.CALL_AUDIO_STATE"; 588 589 /** 590 * A boolean extra, which when set on the {@link Intent#ACTION_CALL} intent or on the bundle 591 * passed into {@link #placeCall(Uri, Bundle)}, indicates that the call should be initiated with 592 * an RTT session open. See {@link android.telecom.Call.RttCall} for more information on RTT. 593 */ 594 public static final String EXTRA_START_CALL_WITH_RTT = 595 "android.telecom.extra.START_CALL_WITH_RTT"; 596 597 /** 598 * Start an activity indicating that the completion of an outgoing call or an incoming call 599 * which was not blocked by the {@link CallScreeningService}, and which was NOT terminated 600 * while the call was in {@link Call#STATE_AUDIO_PROCESSING}. 601 * 602 * The {@link Uri} extra {@link #EXTRA_HANDLE} will contain the uri handle(phone number) for the 603 * call which completed. 604 * 605 * The integer extra {@link #EXTRA_DISCONNECT_CAUSE} will indicate the reason for the call 606 * disconnection. See {@link #EXTRA_DISCONNECT_CAUSE} for more information. 607 * 608 * The integer extra {@link #EXTRA_CALL_DURATION} will indicate the duration of the call. See 609 * {@link #EXTRA_CALL_DURATION} for more information. 610 */ 611 public static final String ACTION_POST_CALL = "android.telecom.action.POST_CALL"; 612 613 /** 614 * A {@link Uri} extra, which when set on the {@link #ACTION_POST_CALL} intent, indicates the 615 * uri handle(phone number) of the completed call. 616 */ 617 public static final String EXTRA_HANDLE = "android.telecom.extra.HANDLE"; 618 619 /** 620 * A integer value provided for completed calls to indicate the reason for the call 621 * disconnection. 622 * <p> 623 * Allowed values: 624 * <ul> 625 * <li>{@link DisconnectCause#UNKNOWN}</li> 626 * <li>{@link DisconnectCause#LOCAL}</li> 627 * <li>{@link DisconnectCause#REMOTE}</li> 628 * <li>{@link DisconnectCause#REJECTED}</li> 629 * <li>{@link DisconnectCause#MISSED}</li> 630 * </ul> 631 * </p> 632 */ 633 public static final String EXTRA_DISCONNECT_CAUSE = "android.telecom.extra.DISCONNECT_CAUSE"; 634 635 /** 636 * A integer value provided for completed calls to indicate the duration of the call. 637 * <p> 638 * Allowed values: 639 * <ul> 640 * <li>{@link #DURATION_VERY_SHORT}</li> 641 * <li>{@link #DURATION_SHORT}</li> 642 * <li>{@link #DURATION_MEDIUM}</li> 643 * <li>{@link #DURATION_LONG}</li> 644 * </ul> 645 * </p> 646 */ 647 public static final String EXTRA_CALL_DURATION = "android.telecom.extra.CALL_DURATION"; 648 649 /** 650 * A integer value for {@link #EXTRA_CALL_DURATION}, indicates the duration of the completed 651 * call was < 3 seconds. 652 */ 653 public static final int DURATION_VERY_SHORT = 0; 654 655 /** 656 * A integer value for {@link #EXTRA_CALL_DURATION}, indicates the duration of the completed 657 * call was >= 3 seconds and < 60 seconds. 658 */ 659 public static final int DURATION_SHORT = 1; 660 661 /** 662 * A integer value for {@link #EXTRA_CALL_DURATION}, indicates the duration of the completed 663 * call was >= 60 seconds and < 120 seconds. 664 */ 665 public static final int DURATION_MEDIUM = 2; 666 667 /** 668 * A integer value for {@link #EXTRA_CALL_DURATION}, indicates the duration of the completed 669 * call was >= 120 seconds. 670 */ 671 public static final int DURATION_LONG = 3; 672 673 /** 674 * The threshold between {@link #DURATION_VERY_SHORT} calls and {@link #DURATION_SHORT} calls in 675 * milliseconds. 676 * @hide 677 */ 678 public static final long VERY_SHORT_CALL_TIME_MS = 3000; 679 680 /** 681 * The threshold between {@link #DURATION_SHORT} calls and {@link #DURATION_MEDIUM} calls in 682 * milliseconds. 683 * @hide 684 */ 685 public static final long SHORT_CALL_TIME_MS = 60000; 686 687 /** 688 * The threshold between {@link #DURATION_MEDIUM} calls and {@link #DURATION_LONG} calls in 689 * milliseconds. 690 * @hide 691 */ 692 public static final long MEDIUM_CALL_TIME_MS = 120000; 693 694 /** 695 * A boolean meta-data value indicating whether an {@link InCallService} implements an 696 * in-call user interface. Dialer implementations (see {@link #getDefaultDialerPackage()}) which 697 * would also like to replace the in-call interface should set this meta-data to {@code true} in 698 * the manifest registration of their {@link InCallService}. 699 */ 700 public static final String METADATA_IN_CALL_SERVICE_UI = "android.telecom.IN_CALL_SERVICE_UI"; 701 702 /** 703 * A boolean meta-data value indicating whether an {@link InCallService} implements an 704 * in-call user interface to be used while the device is in car-mode (see 705 * {@link android.content.res.Configuration#UI_MODE_TYPE_CAR}). 706 */ 707 public static final String METADATA_IN_CALL_SERVICE_CAR_MODE_UI = 708 "android.telecom.IN_CALL_SERVICE_CAR_MODE_UI"; 709 710 /** 711 * A boolean meta-data value indicating whether an {@link InCallService} implements ringing. 712 * Dialer implementations (see {@link #getDefaultDialerPackage()}) which would also like to 713 * override the system provided ringing should set this meta-data to {@code true} in the 714 * manifest registration of their {@link InCallService}. 715 * <p> 716 * When {@code true}, it is the {@link InCallService}'s responsibility to play a ringtone for 717 * all incoming calls. 718 */ 719 public static final String METADATA_IN_CALL_SERVICE_RINGING = 720 "android.telecom.IN_CALL_SERVICE_RINGING"; 721 722 /** 723 * A boolean meta-data value indicating whether an {@link InCallService} wants to be informed of 724 * calls which have the {@link Call.Details#PROPERTY_IS_EXTERNAL_CALL} property. An external 725 * call is one which a {@link ConnectionService} knows about, but is not connected to directly. 726 * Dialer implementations (see {@link #getDefaultDialerPackage()}) which would like to be 727 * informed of external calls should set this meta-data to {@code true} in the manifest 728 * registration of their {@link InCallService}. By default, the {@link InCallService} will NOT 729 * be informed of external calls. 730 */ 731 public static final String METADATA_INCLUDE_EXTERNAL_CALLS = 732 "android.telecom.INCLUDE_EXTERNAL_CALLS"; 733 734 /** 735 * A boolean meta-data value indicating whether an {@link InCallService} wants to be informed of 736 * calls which have the {@link Call.Details#PROPERTY_SELF_MANAGED} property. A self-managed 737 * call is one which originates from a self-managed {@link ConnectionService} which has chosen 738 * to implement its own call user interface. An {@link InCallService} implementation which 739 * would like to be informed of external calls should set this meta-data to {@code true} in the 740 * manifest registration of their {@link InCallService}. By default, the {@link InCallService} 741 * will NOT be informed about self-managed calls. 742 * <p> 743 * An {@link InCallService} which receives self-managed calls is free to view and control the 744 * state of calls in the self-managed {@link ConnectionService}. An example use-case is 745 * exposing these calls to an automotive device via its companion app. 746 * <p> 747 * See also {@link Connection#PROPERTY_SELF_MANAGED}. 748 */ 749 public static final String METADATA_INCLUDE_SELF_MANAGED_CALLS = 750 "android.telecom.INCLUDE_SELF_MANAGED_CALLS"; 751 752 /** 753 * The dual tone multi-frequency signaling character sent to indicate the dialing system should 754 * pause for a predefined period. 755 */ 756 public static final char DTMF_CHARACTER_PAUSE = ','; 757 758 /** 759 * The dual-tone multi-frequency signaling character sent to indicate the dialing system should 760 * wait for user confirmation before proceeding. 761 */ 762 public static final char DTMF_CHARACTER_WAIT = ';'; 763 764 /** 765 * @hide 766 */ 767 @IntDef(prefix = { "TTY_MODE_" }, 768 value = {TTY_MODE_OFF, TTY_MODE_FULL, TTY_MODE_HCO, TTY_MODE_VCO}) 769 @Retention(RetentionPolicy.SOURCE) 770 public @interface TtyMode {} 771 772 /** 773 * TTY (teletypewriter) mode is off. 774 * 775 * @hide 776 */ 777 @SystemApi 778 public static final int TTY_MODE_OFF = 0; 779 780 /** 781 * TTY (teletypewriter) mode is on. The speaker is off and the microphone is muted. The user 782 * will communicate with the remote party by sending and receiving text messages. 783 * 784 * @hide 785 */ 786 @SystemApi 787 public static final int TTY_MODE_FULL = 1; 788 789 /** 790 * TTY (teletypewriter) mode is in hearing carryover mode (HCO). The microphone is muted but the 791 * speaker is on. The user will communicate with the remote party by sending text messages and 792 * hearing an audible reply. 793 * 794 * @hide 795 */ 796 @SystemApi 797 public static final int TTY_MODE_HCO = 2; 798 799 /** 800 * TTY (teletypewriter) mode is in voice carryover mode (VCO). The speaker is off but the 801 * microphone is still on. User will communicate with the remote party by speaking and receiving 802 * text message replies. 803 * 804 * @hide 805 */ 806 @SystemApi 807 public static final int TTY_MODE_VCO = 3; 808 809 /** 810 * Broadcast intent action indicating that the current TTY mode has changed. 811 * 812 * This intent will contain {@link #EXTRA_CURRENT_TTY_MODE} as an intent extra, giving the new 813 * TTY mode. 814 * @hide 815 */ 816 @SystemApi 817 public static final String ACTION_CURRENT_TTY_MODE_CHANGED = 818 "android.telecom.action.CURRENT_TTY_MODE_CHANGED"; 819 820 /** 821 * Integer extra key that indicates the current TTY mode. 822 * 823 * Used with {@link #ACTION_CURRENT_TTY_MODE_CHANGED}. 824 * 825 * Valid modes are: 826 * <ul> 827 * <li>{@link #TTY_MODE_OFF}</li> 828 * <li>{@link #TTY_MODE_FULL}</li> 829 * <li>{@link #TTY_MODE_HCO}</li> 830 * <li>{@link #TTY_MODE_VCO}</li> 831 * </ul> 832 * 833 * This TTY mode is distinct from the one sent via {@link #ACTION_TTY_PREFERRED_MODE_CHANGED}, 834 * since the current TTY mode will always be {@link #TTY_MODE_OFF}unless a TTY terminal is 835 * plugged into the device. 836 * @hide 837 */ 838 @SystemApi 839 public static final String EXTRA_CURRENT_TTY_MODE = 840 "android.telecom.extra.CURRENT_TTY_MODE"; 841 842 /** 843 * Broadcast intent action indicating that the TTY preferred operating mode has changed. 844 * 845 * This intent will contain {@link #EXTRA_TTY_PREFERRED_MODE} as an intent extra, giving the new 846 * preferred TTY mode. 847 * @hide 848 */ 849 @SystemApi 850 public static final String ACTION_TTY_PREFERRED_MODE_CHANGED = 851 "android.telecom.action.TTY_PREFERRED_MODE_CHANGED"; 852 853 /** 854 * Integer extra key that indicates the preferred TTY mode. 855 * 856 * Used with {@link #ACTION_TTY_PREFERRED_MODE_CHANGED}. 857 * 858 * Valid modes are: 859 * <ul> 860 * <li>{@link #TTY_MODE_OFF}</li> 861 * <li>{@link #TTY_MODE_FULL}</li> 862 * <li>{@link #TTY_MODE_HCO}</li> 863 * <li>{@link #TTY_MODE_VCO}</li> 864 * </ul> 865 * @hide 866 */ 867 @SystemApi 868 public static final String EXTRA_TTY_PREFERRED_MODE = 869 "android.telecom.extra.TTY_PREFERRED_MODE"; 870 871 /** 872 * Broadcast intent action for letting custom component know to show the missed call 873 * notification. If no custom component exists then this is sent to the default dialer which 874 * should post a missed-call notification. 875 */ 876 public static final String ACTION_SHOW_MISSED_CALLS_NOTIFICATION = 877 "android.telecom.action.SHOW_MISSED_CALLS_NOTIFICATION"; 878 879 /** 880 * The number of calls associated with the notification. If the number is zero then the missed 881 * call notification should be dismissed. 882 */ 883 public static final String EXTRA_NOTIFICATION_COUNT = 884 "android.telecom.extra.NOTIFICATION_COUNT"; 885 886 /** 887 * The number associated with the missed calls. This number is only relevant 888 * when EXTRA_NOTIFICATION_COUNT is 1. 889 */ 890 public static final String EXTRA_NOTIFICATION_PHONE_NUMBER = 891 "android.telecom.extra.NOTIFICATION_PHONE_NUMBER"; 892 893 /** 894 * Included in the extras of the {@link #ACTION_SHOW_MISSED_CALLS_NOTIFICATION}, provides a 895 * pending intent which can be used to clear the missed calls notification and mark unread 896 * missed call log entries as read. 897 * @hide 898 * @deprecated Use {@link #cancelMissedCallsNotification()} instead. 899 */ 900 @Deprecated 901 @SystemApi 902 public static final String EXTRA_CLEAR_MISSED_CALLS_INTENT = 903 "android.telecom.extra.CLEAR_MISSED_CALLS_INTENT"; 904 905 /** 906 * The intent to call back a missed call. 907 * @hide 908 */ 909 @SystemApi 910 public static final String EXTRA_CALL_BACK_INTENT = 911 "android.telecom.extra.CALL_BACK_INTENT"; 912 913 /** 914 * The dialer activity responsible for placing emergency calls from, for example, a locked 915 * keyguard. 916 * @hide 917 */ 918 public static final ComponentName EMERGENCY_DIALER_COMPONENT = 919 ComponentName.createRelative("com.android.phone", ".EmergencyDialer"); 920 921 /** 922 * The boolean indicated by this extra controls whether or not a call is eligible to undergo 923 * assisted dialing. This extra is stored under {@link #EXTRA_OUTGOING_CALL_EXTRAS}. 924 * <p> 925 * The call initiator can use this extra to indicate that a call used assisted dialing to help 926 * place the call. This is most commonly used by a Dialer app which provides the ability to 927 * automatically add dialing prefixes when placing international calls. 928 * <p> 929 * Setting this extra on the outgoing call extras will cause the 930 * {@link Connection#PROPERTY_ASSISTED_DIALING} property and 931 * {@link Call.Details#PROPERTY_ASSISTED_DIALING} property to be set on the 932 * {@link Connection}/{@link Call} in question. When the call is logged to the call log, the 933 * {@link android.provider.CallLog.Calls#FEATURES_ASSISTED_DIALING_USED} call feature is set to 934 * indicate that assisted dialing was used for the call. 935 */ 936 public static final String EXTRA_USE_ASSISTED_DIALING = 937 "android.telecom.extra.USE_ASSISTED_DIALING"; 938 939 /** 940 * Optional extra for {@link #placeCall(Uri, Bundle)} containing an integer that specifies 941 * the source where user initiated this call. This data is used in metrics. 942 * Valid sources are: 943 * {@link TelecomManager#CALL_SOURCE_UNSPECIFIED}, 944 * {@link TelecomManager#CALL_SOURCE_EMERGENCY_DIALPAD}, 945 * {@link TelecomManager#CALL_SOURCE_EMERGENCY_SHORTCUT}. 946 * 947 * Intended for use with the platform emergency dialer only. 948 * @hide 949 */ 950 @SystemApi 951 public static final String EXTRA_CALL_SOURCE = "android.telecom.extra.CALL_SOURCE"; 952 953 /** 954 * Intent action to trigger "switch to managed profile" dialog for call in SystemUI 955 * 956 * @hide 957 */ 958 public static final String ACTION_SHOW_SWITCH_TO_WORK_PROFILE_FOR_CALL_DIALOG = 959 "android.telecom.action.SHOW_SWITCH_TO_WORK_PROFILE_FOR_CALL_DIALOG"; 960 961 /** 962 * Extra specifying the managed profile user id. 963 * This is used with {@link TelecomManager#ACTION_SHOW_SWITCH_TO_WORK_PROFILE_FOR_CALL_DIALOG} 964 * 965 * @hide 966 */ 967 public static final String EXTRA_MANAGED_PROFILE_USER_ID = 968 "android.telecom.extra.MANAGED_PROFILE_USER_ID"; 969 970 /** 971 * Indicating the call is initiated via emergency dialer's shortcut button. 972 * 973 * @hide 974 */ 975 @SystemApi 976 public static final int CALL_SOURCE_EMERGENCY_SHORTCUT = 2; 977 978 /** 979 * Indicating the call is initiated via emergency dialer's dialpad. 980 * 981 * @hide 982 */ 983 @SystemApi 984 public static final int CALL_SOURCE_EMERGENCY_DIALPAD = 1; 985 986 /** 987 * Indicating the call source is not specified. 988 * 989 * @hide 990 */ 991 @SystemApi 992 public static final int CALL_SOURCE_UNSPECIFIED = 0; 993 994 /** 995 * The following 4 constants define how properties such as phone numbers and names are 996 * displayed to the user. 997 */ 998 999 /** 1000 * Indicates that the address or number of a call is allowed to be displayed for caller ID. 1001 */ 1002 public static final int PRESENTATION_ALLOWED = 1; 1003 1004 /** 1005 * Indicates that the address or number of a call is blocked by the other party. 1006 */ 1007 public static final int PRESENTATION_RESTRICTED = 2; 1008 1009 /** 1010 * Indicates that the address or number of a call is not specified or known by the carrier. 1011 */ 1012 public static final int PRESENTATION_UNKNOWN = 3; 1013 1014 /** 1015 * Indicates that the address or number of a call belongs to a pay phone. 1016 */ 1017 public static final int PRESENTATION_PAYPHONE = 4; 1018 1019 /** 1020 * Indicates that the address or number of a call is unavailable. 1021 */ 1022 public static final int PRESENTATION_UNAVAILABLE = 5; 1023 1024 1025 /* 1026 * Values for the adb property "persist.radio.videocall.audio.output" 1027 */ 1028 /** @hide */ 1029 public static final int AUDIO_OUTPUT_ENABLE_SPEAKER = 0; 1030 /** @hide */ 1031 public static final int AUDIO_OUTPUT_DISABLE_SPEAKER = 1; 1032 /** @hide */ 1033 public static final int AUDIO_OUTPUT_DEFAULT = AUDIO_OUTPUT_ENABLE_SPEAKER; 1034 1035 /** @hide */ 1036 @Retention(RetentionPolicy.SOURCE) 1037 @IntDef( 1038 prefix = { "PRESENTATION_" }, 1039 value = {PRESENTATION_ALLOWED, PRESENTATION_RESTRICTED, PRESENTATION_UNKNOWN, 1040 PRESENTATION_PAYPHONE, PRESENTATION_UNAVAILABLE}) 1041 public @interface Presentation {} 1042 1043 1044 /** 1045 * Enable READ_PHONE_STATE protection on APIs querying and notifying call state, such as 1046 * {@code TelecomManager#getCallState}, {@link TelephonyManager#getCallStateForSubscription()}, 1047 * and {@link android.telephony.TelephonyCallback.CallStateListener}. 1048 * @hide 1049 */ 1050 @ChangeId 1051 @EnabledSince(targetSdkVersion = Build.VERSION_CODES.S) 1052 // this magic number is a bug ID 1053 public static final long ENABLE_GET_CALL_STATE_PERMISSION_PROTECTION = 157233955L; 1054 1055 /** 1056 * Enable READ_PHONE_NUMBERS or READ_PRIVILEGED_PHONE_STATE protections on 1057 * {@link TelecomManager#getPhoneAccount(PhoneAccountHandle)}. 1058 * @hide 1059 */ 1060 @ChangeId 1061 @EnabledSince(targetSdkVersion = Build.VERSION_CODES.S) 1062 // bug ID 1063 public static final long ENABLE_GET_PHONE_ACCOUNT_PERMISSION_PROTECTION = 183407956L; 1064 1065 private static final String TAG = "TelecomManager"; 1066 1067 1068 /** Cached service handles, cleared by resetServiceCache() at death */ 1069 private static final Object CACHE_LOCK = new Object(); 1070 1071 @GuardedBy("CACHE_LOCK") 1072 private static ITelecomService sTelecomService; 1073 @GuardedBy("CACHE_LOCK") 1074 private static final DeathRecipient SERVICE_DEATH = new DeathRecipient(); 1075 1076 private final Context mContext; 1077 1078 private final ITelecomService mTelecomServiceOverride; 1079 1080 /** @hide **/ 1081 private final ClientTransactionalServiceRepository mTransactionalServiceRepository = 1082 new ClientTransactionalServiceRepository(); 1083 /** @hide **/ 1084 public static final int TELECOM_TRANSACTION_SUCCESS = 0; 1085 /** @hide **/ 1086 public static final String TRANSACTION_CALL_ID_KEY = "TelecomCallId"; 1087 1088 /** 1089 * @hide 1090 */ 1091 @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P) from(Context context)1092 public static TelecomManager from(Context context) { 1093 return (TelecomManager) context.getSystemService(Context.TELECOM_SERVICE); 1094 } 1095 1096 /** 1097 * @hide 1098 */ TelecomManager(Context context)1099 public TelecomManager(Context context) { 1100 this(context, null); 1101 } 1102 1103 /** 1104 * @hide 1105 */ TelecomManager(Context context, ITelecomService telecomServiceImpl)1106 public TelecomManager(Context context, ITelecomService telecomServiceImpl) { 1107 Context appContext = context.getApplicationContext(); 1108 if (appContext != null && Objects.equals(context.getAttributionTag(), 1109 appContext.getAttributionTag())) { 1110 mContext = appContext; 1111 } else { 1112 mContext = context; 1113 } 1114 mTelecomServiceOverride = telecomServiceImpl; 1115 } 1116 1117 /** 1118 * Return the {@link PhoneAccount} which will be used to place outgoing calls to addresses with 1119 * the specified {@code uriScheme}. This {@link PhoneAccount} will always be a member of the 1120 * list which is returned from invoking {@link #getCallCapablePhoneAccounts()}. The specific 1121 * account returned depends on the following priorities: 1122 * <ul> 1123 * <li> If the user-selected default {@link PhoneAccount} supports the specified scheme, it will 1124 * be returned. 1125 * </li> 1126 * <li> If there exists only one {@link PhoneAccount} that supports the specified scheme, it 1127 * will be returned. 1128 * </li> 1129 * </ul> 1130 * <p> 1131 * If no {@link PhoneAccount} fits the criteria above, this method will return {@code null}. 1132 * 1133 * @param uriScheme The URI scheme. 1134 * @return The {@link PhoneAccountHandle} corresponding to the account to be used. 1135 */ 1136 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getDefaultOutgoingPhoneAccount(String uriScheme)1137 public PhoneAccountHandle getDefaultOutgoingPhoneAccount(String uriScheme) { 1138 ITelecomService service = getTelecomService(); 1139 if (service != null) { 1140 try { 1141 return service.getDefaultOutgoingPhoneAccount(uriScheme, 1142 mContext.getOpPackageName(), mContext.getAttributionTag()); 1143 } catch (RemoteException e) { 1144 Log.e(TAG, "Error calling ITelecomService#getDefaultOutgoingPhoneAccount", e); 1145 } 1146 } 1147 return null; 1148 } 1149 1150 /** 1151 * Return the {@link PhoneAccount} which is the user-chosen default for making outgoing phone 1152 * calls. This {@code PhoneAccount} will always be a member of the list which is returned from 1153 * calling {@link #getCallCapablePhoneAccounts()} 1154 * <p> 1155 * Apps must be prepared for this method to return {@code null}, indicating that there currently 1156 * exists no user-chosen default {@code PhoneAccount}. 1157 * <p> 1158 * The default dialer has access to use this method. 1159 * 1160 * @return The user outgoing phone account selected by the user, or {@code null} if there is no 1161 * user selected outgoing {@link PhoneAccountHandle}. 1162 */ 1163 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getUserSelectedOutgoingPhoneAccount()1164 public @Nullable PhoneAccountHandle getUserSelectedOutgoingPhoneAccount() { 1165 ITelecomService service = getTelecomService(); 1166 if (service != null) { 1167 try { 1168 return service.getUserSelectedOutgoingPhoneAccount( 1169 mContext.getOpPackageName()); 1170 } catch (RemoteException e) { 1171 Log.e(TAG, "Error calling ITelecomService#getUserSelectedOutgoingPhoneAccount", e); 1172 } 1173 } 1174 return null; 1175 } 1176 1177 /** 1178 * Sets the user-chosen default {@link PhoneAccountHandle} for making outgoing phone calls. 1179 * 1180 * @param accountHandle The {@link PhoneAccountHandle} which will be used by default for making 1181 * outgoing voice calls, or {@code null} if no default is specified (the 1182 * user will be asked each time a call is placed in this case). 1183 * @hide 1184 */ 1185 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) 1186 @SystemApi setUserSelectedOutgoingPhoneAccount(@ullable PhoneAccountHandle accountHandle)1187 public void setUserSelectedOutgoingPhoneAccount(@Nullable PhoneAccountHandle accountHandle) { 1188 ITelecomService service = getTelecomService(); 1189 if (service != null) { 1190 try { 1191 service.setUserSelectedOutgoingPhoneAccount(accountHandle); 1192 } catch (RemoteException e) { 1193 Log.e(TAG, "Error calling ITelecomService#setUserSelectedOutgoingPhoneAccount"); 1194 } 1195 } 1196 } 1197 1198 /** 1199 * Returns the current SIM call manager. Apps must be prepared for this method to return 1200 * {@code null}, indicating that there currently exists no SIM call manager {@link PhoneAccount} 1201 * for the default voice subscription. 1202 * 1203 * @return The phone account handle of the current sim call manager for the default voice 1204 * subscription. 1205 * @see SubscriptionManager#getDefaultVoiceSubscriptionId() 1206 */ getSimCallManager()1207 public PhoneAccountHandle getSimCallManager() { 1208 ITelecomService service = getTelecomService(); 1209 if (service != null) { 1210 try { 1211 return service.getSimCallManager( 1212 SubscriptionManager.getDefaultSubscriptionId(), mContext.getPackageName()); 1213 } catch (RemoteException e) { 1214 Log.e(TAG, "Error calling ITelecomService#getSimCallManager"); 1215 } 1216 } 1217 return null; 1218 } 1219 1220 /** 1221 * Returns current SIM call manager for the Telephony Subscription ID specified. Apps must be 1222 * prepared for this method to return {@code null}, indicating that there currently exists no 1223 * SIM call manager {@link PhoneAccount} for the subscription specified. 1224 * 1225 * @param subscriptionId The Telephony Subscription ID that the SIM call manager should be 1226 * queried for. 1227 * @return The phone account handle of the current sim call manager. 1228 * @see SubscriptionManager#getActiveSubscriptionInfoList() 1229 */ getSimCallManagerForSubscription(int subscriptionId)1230 public @Nullable PhoneAccountHandle getSimCallManagerForSubscription(int subscriptionId) { 1231 ITelecomService service = getTelecomService(); 1232 if (service != null) { 1233 try { 1234 return service.getSimCallManager(subscriptionId, mContext.getPackageName()); 1235 } catch (RemoteException e) { 1236 Log.e(TAG, "Error calling ITelecomService#getSimCallManager"); 1237 } 1238 } 1239 return null; 1240 } 1241 1242 /** 1243 * Returns the current SIM call manager for the user-chosen default Telephony Subscription ID 1244 * (see {@link SubscriptionManager#getDefaultSubscriptionId()}) and the specified user. Apps 1245 * must be prepared for this method to return {@code null}, indicating that there currently 1246 * exists no SIM call manager {@link PhoneAccount} for the default voice subscription. 1247 * 1248 * @return The phone account handle of the current sim call manager. 1249 * 1250 * @hide 1251 * @deprecated Use {@link #getSimCallManager()}. 1252 */ 1253 @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 119305590) getSimCallManager(int userId)1254 public PhoneAccountHandle getSimCallManager(int userId) { 1255 ITelecomService service = getTelecomService(); 1256 if (service != null) { 1257 try { 1258 return service.getSimCallManagerForUser(userId, mContext.getPackageName()); 1259 } catch (RemoteException e) { 1260 Log.e(TAG, "Error calling ITelecomService#getSimCallManagerForUser"); 1261 } 1262 } 1263 return null; 1264 } 1265 1266 /** 1267 * Returns the current connection manager. Apps must be prepared for this method to return 1268 * {@code null}, indicating that there currently exists no Connection Manager 1269 * {@link PhoneAccount} for the default voice subscription. 1270 * 1271 * @return The phone account handle of the current connection manager. 1272 * @hide 1273 */ 1274 @SystemApi getConnectionManager()1275 public PhoneAccountHandle getConnectionManager() { 1276 return getSimCallManager(); 1277 } 1278 1279 /** 1280 * Returns a list of the {@link PhoneAccountHandle}s which can be used to make and receive phone 1281 * calls which support the specified URI scheme. 1282 * <P> 1283 * For example, invoking with {@code "tel"} will find all {@link PhoneAccountHandle}s which 1284 * support telephone calls (e.g. URIs such as {@code tel:555-555-1212}). Invoking with 1285 * {@code "sip"} will find all {@link PhoneAccountHandle}s which support SIP calls (e.g. URIs 1286 * such as {@code sip:example@sipexample.com}). 1287 * 1288 * @param uriScheme The URI scheme. 1289 * @return A list of {@code PhoneAccountHandle} objects supporting the URI scheme. 1290 * @hide 1291 */ 1292 @SystemApi 1293 @RequiresPermission(anyOf = { 1294 READ_PRIVILEGED_PHONE_STATE, 1295 android.Manifest.permission.READ_PHONE_STATE 1296 }) getPhoneAccountsSupportingScheme(String uriScheme)1297 public List<PhoneAccountHandle> getPhoneAccountsSupportingScheme(String uriScheme) { 1298 ITelecomService service = getTelecomService(); 1299 if (service != null) { 1300 try { 1301 return service.getPhoneAccountsSupportingScheme(uriScheme, 1302 mContext.getOpPackageName()).getList(); 1303 } catch (RemoteException e) { 1304 Log.e(TAG, "Error calling ITelecomService#getPhoneAccountsSupportingScheme", e); 1305 } 1306 } 1307 return new ArrayList<>(); 1308 } 1309 1310 1311 /** 1312 * Returns a list of {@link PhoneAccountHandle}s which can be used to make and receive phone 1313 * calls. The returned list includes only those accounts which have been explicitly enabled 1314 * by the user. 1315 * 1316 * @see #EXTRA_PHONE_ACCOUNT_HANDLE 1317 * @return A list of {@code PhoneAccountHandle} objects. 1318 */ 1319 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getCallCapablePhoneAccounts()1320 public List<PhoneAccountHandle> getCallCapablePhoneAccounts() { 1321 return getCallCapablePhoneAccounts(false); 1322 } 1323 1324 /** 1325 * Returns a list of {@link PhoneAccountHandle}s for all self-managed 1326 * {@link ConnectionService}s owned by the calling {@link UserHandle}. 1327 * <p> 1328 * Self-Managed {@link ConnectionService}s have a {@link PhoneAccount} with 1329 * {@link PhoneAccount#CAPABILITY_SELF_MANAGED}. 1330 * <p> 1331 * Requires permission {@link android.Manifest.permission#READ_PHONE_STATE}, or that the caller 1332 * is the default dialer app. 1333 * <p> 1334 * A {@link SecurityException} will be thrown if a called is not the default dialer, or lacks 1335 * the {@link android.Manifest.permission#READ_PHONE_STATE} permission. 1336 * 1337 * @return A list of {@code PhoneAccountHandle} objects. 1338 */ 1339 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getSelfManagedPhoneAccounts()1340 public @NonNull List<PhoneAccountHandle> getSelfManagedPhoneAccounts() { 1341 ITelecomService service = getTelecomService(); 1342 if (service != null) { 1343 try { 1344 return service.getSelfManagedPhoneAccounts(mContext.getOpPackageName(), 1345 mContext.getAttributionTag()).getList(); 1346 } catch (RemoteException e) { 1347 Log.e(TAG, "Error calling ITelecomService#getSelfManagedPhoneAccounts()", e); 1348 } 1349 } 1350 return new ArrayList<>(); 1351 } 1352 1353 /** 1354 * Returns a list of {@link PhoneAccountHandle}s owned by the calling self-managed 1355 * {@link ConnectionService}. 1356 * <p> 1357 * Self-Managed {@link ConnectionService}s have a {@link PhoneAccount} with 1358 * {@link PhoneAccount#CAPABILITY_SELF_MANAGED}. 1359 * <p> 1360 * Requires permission {@link android.Manifest.permission#MANAGE_OWN_CALLS} 1361 * <p> 1362 * A {@link SecurityException} will be thrown if a caller lacks the 1363 * {@link android.Manifest.permission#MANAGE_OWN_CALLS} permission. 1364 * 1365 * @return A list of {@code PhoneAccountHandle} objects. 1366 */ 1367 @RequiresPermission(Manifest.permission.MANAGE_OWN_CALLS) getOwnSelfManagedPhoneAccounts()1368 public @NonNull List<PhoneAccountHandle> getOwnSelfManagedPhoneAccounts() { 1369 ITelecomService service = getTelecomService(); 1370 if (service != null) { 1371 try { 1372 return service.getOwnSelfManagedPhoneAccounts(mContext.getOpPackageName(), 1373 mContext.getAttributionTag()).getList(); 1374 } catch (RemoteException e) { 1375 throw e.rethrowFromSystemServer(); 1376 } 1377 } 1378 throw new IllegalStateException("Telecom is not available"); 1379 } 1380 1381 /** 1382 * Returns a list of {@link PhoneAccountHandle}s including those which have not been enabled 1383 * by the user. 1384 * 1385 * @param includeDisabledAccounts When {@code true}, disabled phone accounts will be included, 1386 * when {@code false}, only enabled phone accounts will be 1387 * included. 1388 * @return A list of {@code PhoneAccountHandle} objects. 1389 * @hide 1390 */ 1391 @SystemApi 1392 @RequiresPermission(READ_PRIVILEGED_PHONE_STATE) getCallCapablePhoneAccounts( boolean includeDisabledAccounts)1393 public @NonNull List<PhoneAccountHandle> getCallCapablePhoneAccounts( 1394 boolean includeDisabledAccounts) { 1395 ITelecomService service = getTelecomService(); 1396 if (service != null) { 1397 try { 1398 return service.getCallCapablePhoneAccounts(includeDisabledAccounts, 1399 mContext.getOpPackageName(), mContext.getAttributionTag()).getList(); 1400 } catch (RemoteException e) { 1401 Log.e(TAG, "Error calling ITelecomService#getCallCapablePhoneAccounts(" 1402 + includeDisabledAccounts + ")", e); 1403 } 1404 } 1405 return new ArrayList<>(); 1406 } 1407 1408 /** 1409 * Returns a list of all {@link PhoneAccount}s registered for the calling package. 1410 * 1411 * @deprecated Use {@link #getSelfManagedPhoneAccounts()} instead to get only self-managed 1412 * {@link PhoneAccountHandle} for the calling package. 1413 * @return A list of {@code PhoneAccountHandle} objects. 1414 * @hide 1415 */ 1416 @SystemApi 1417 @SuppressLint("RequiresPermission") 1418 @Deprecated getPhoneAccountsForPackage()1419 public List<PhoneAccountHandle> getPhoneAccountsForPackage() { 1420 ITelecomService service = getTelecomService(); 1421 if (service != null) { 1422 try { 1423 return service.getPhoneAccountsForPackage(mContext.getPackageName()).getList(); 1424 } catch (RemoteException e) { 1425 Log.e(TAG, "Error calling ITelecomService#getPhoneAccountsForPackage", e); 1426 } 1427 } 1428 return null; 1429 } 1430 1431 /** 1432 * Return the {@link PhoneAccount} for a specified {@link PhoneAccountHandle}. Object includes 1433 * resources which can be used in a user interface. 1434 * 1435 * Requires Permission: 1436 * {@link android.Manifest.permission#READ_PHONE_NUMBERS} for applications targeting API 1437 * level 31+. 1438 * @param account The {@link PhoneAccountHandle}. 1439 * @return The {@link PhoneAccount} object. 1440 */ getPhoneAccount(PhoneAccountHandle account)1441 public PhoneAccount getPhoneAccount(PhoneAccountHandle account) { 1442 ITelecomService service = getTelecomService(); 1443 if (service != null) { 1444 try { 1445 return service.getPhoneAccount(account, mContext.getPackageName()); 1446 } catch (RemoteException e) { 1447 Log.e(TAG, "Error calling ITelecomService#getPhoneAccount", e); 1448 } 1449 } 1450 return null; 1451 } 1452 1453 /** 1454 * Returns a count of all {@link PhoneAccount}s. 1455 * 1456 * @return The count of {@link PhoneAccount}s. 1457 * @hide 1458 */ 1459 @SystemApi getAllPhoneAccountsCount()1460 public int getAllPhoneAccountsCount() { 1461 ITelecomService service = getTelecomService(); 1462 if (service != null) { 1463 try { 1464 return service.getAllPhoneAccountsCount(); 1465 } catch (RemoteException e) { 1466 Log.e(TAG, "Error calling ITelecomService#getAllPhoneAccountsCount", e); 1467 } 1468 } 1469 return 0; 1470 } 1471 1472 /** 1473 * Returns a list of all {@link PhoneAccount}s. 1474 * 1475 * @return All {@link PhoneAccount}s. 1476 * @hide 1477 */ 1478 @SystemApi getAllPhoneAccounts()1479 public List<PhoneAccount> getAllPhoneAccounts() { 1480 ITelecomService service = getTelecomService(); 1481 if (service != null) { 1482 try { 1483 return service.getAllPhoneAccounts().getList(); 1484 } catch (RemoteException e) { 1485 Log.e(TAG, "Error calling ITelecomService#getAllPhoneAccounts", e); 1486 } 1487 } 1488 return Collections.EMPTY_LIST; 1489 } 1490 1491 /** 1492 * Returns a list of all {@link PhoneAccountHandle}s. 1493 * 1494 * @return All {@link PhoneAccountHandle}s. 1495 * @hide 1496 */ 1497 @SystemApi getAllPhoneAccountHandles()1498 public List<PhoneAccountHandle> getAllPhoneAccountHandles() { 1499 ITelecomService service = getTelecomService(); 1500 if (service != null) { 1501 try { 1502 return service.getAllPhoneAccountHandles().getList(); 1503 } catch (RemoteException e) { 1504 Log.e(TAG, "Error calling ITelecomService#getAllPhoneAccountHandles", e); 1505 } 1506 } 1507 return Collections.EMPTY_LIST; 1508 } 1509 1510 /** 1511 * Register a {@link PhoneAccount} for use by the system that will be stored in Device Encrypted 1512 * storage. When registering {@link PhoneAccount}s, existing registrations will be overwritten 1513 * if the {@link PhoneAccountHandle} matches that of a {@link PhoneAccount} which is already 1514 * registered. Once registered, the {@link PhoneAccount} is listed to the user as an option 1515 * when placing calls. The user may still need to enable the {@link PhoneAccount} within 1516 * the phone app settings before the account is usable. 1517 * <p> 1518 * Note: Each package is limited to 10 {@link PhoneAccount} registrations. 1519 * <p> 1520 * A {@link SecurityException} will be thrown if an app tries to register a 1521 * {@link PhoneAccountHandle} where the package name specified within 1522 * {@link PhoneAccountHandle#getComponentName()} does not match the package name of the app. 1523 * <p> 1524 * A {@link IllegalArgumentException} will be thrown if an app tries to register a 1525 * {@link PhoneAccount} when the upper bound limit, 10, has already been reached. 1526 * 1527 * @param account The complete {@link PhoneAccount}. 1528 */ registerPhoneAccount(PhoneAccount account)1529 public void registerPhoneAccount(PhoneAccount account) { 1530 ITelecomService service = getTelecomService(); 1531 if (service != null) { 1532 try { 1533 service.registerPhoneAccount(account, mContext.getPackageName()); 1534 } catch (RemoteException e) { 1535 Log.e(TAG, "Error calling ITelecomService#registerPhoneAccount", e); 1536 } 1537 } 1538 } 1539 1540 /** 1541 * Remove a {@link PhoneAccount} registration from the system. 1542 * 1543 * @param accountHandle A {@link PhoneAccountHandle} for the {@link PhoneAccount} to unregister. 1544 */ unregisterPhoneAccount(PhoneAccountHandle accountHandle)1545 public void unregisterPhoneAccount(PhoneAccountHandle accountHandle) { 1546 ITelecomService service = getTelecomService(); 1547 if (service != null) { 1548 try { 1549 service.unregisterPhoneAccount(accountHandle, mContext.getPackageName()); 1550 } catch (RemoteException e) { 1551 Log.e(TAG, "Error calling ITelecomService#unregisterPhoneAccount", e); 1552 } 1553 } 1554 } 1555 1556 /** 1557 * Remove all Accounts that belong to the calling package from the system. 1558 * @hide 1559 */ 1560 @SystemApi 1561 @SuppressLint("RequiresPermission") clearPhoneAccounts()1562 public void clearPhoneAccounts() { 1563 clearAccounts(); 1564 } 1565 /** 1566 * Remove all Accounts that belong to the calling package from the system. 1567 * @deprecated Use {@link #clearPhoneAccounts()} instead. 1568 * @hide 1569 */ 1570 @SystemApi 1571 @SuppressLint("RequiresPermission") clearAccounts()1572 public void clearAccounts() { 1573 ITelecomService service = getTelecomService(); 1574 if (service != null) { 1575 try { 1576 service.clearAccounts(mContext.getPackageName()); 1577 } catch (RemoteException e) { 1578 Log.e(TAG, "Error calling ITelecomService#clearAccounts", e); 1579 } 1580 } 1581 } 1582 1583 /** 1584 * Remove all Accounts that belong to the specified package from the system. 1585 * @hide 1586 */ clearAccountsForPackage(String packageName)1587 public void clearAccountsForPackage(String packageName) { 1588 ITelecomService service = getTelecomService(); 1589 if (service != null) { 1590 try { 1591 if (!TextUtils.isEmpty(packageName)) { 1592 service.clearAccounts(packageName); 1593 } 1594 } catch (RemoteException e) { 1595 Log.e(TAG, "Error calling ITelecomService#clearAccountsForPackage", e); 1596 } 1597 } 1598 } 1599 1600 1601 /** 1602 * @deprecated - Use {@link TelecomManager#getDefaultDialerPackage} to directly access 1603 * the default dialer's package name instead. 1604 * @hide 1605 */ 1606 @SystemApi 1607 @SuppressLint("RequiresPermission") getDefaultPhoneApp()1608 public ComponentName getDefaultPhoneApp() { 1609 ITelecomService service = getTelecomService(); 1610 if (service != null) { 1611 try { 1612 return service.getDefaultPhoneApp(); 1613 } catch (RemoteException e) { 1614 Log.e(TAG, "RemoteException attempting to get the default phone app.", e); 1615 } 1616 } 1617 return null; 1618 } 1619 1620 /** 1621 * Used to determine the currently selected default dialer package. 1622 * 1623 * @return package name for the default dialer package or null if no package has been 1624 * selected as the default dialer. 1625 */ getDefaultDialerPackage()1626 public String getDefaultDialerPackage() { 1627 ITelecomService service = getTelecomService(); 1628 if (service != null) { 1629 try { 1630 return service.getDefaultDialerPackage(mContext.getPackageName()); 1631 } catch (RemoteException e) { 1632 Log.e(TAG, "RemoteException attempting to get the default dialer package name.", e); 1633 } 1634 } 1635 return null; 1636 } 1637 1638 /** 1639 * Used to determine the currently selected default dialer package for a specific user. 1640 * 1641 * @param userHandle the user id to query the default dialer package for. 1642 * @return package name for the default dialer package or null if no package has been 1643 * selected as the default dialer. 1644 * @hide 1645 */ 1646 @SystemApi 1647 @RequiresPermission(READ_PRIVILEGED_PHONE_STATE) getDefaultDialerPackage(@onNull UserHandle userHandle)1648 public @Nullable String getDefaultDialerPackage(@NonNull UserHandle userHandle) { 1649 ITelecomService service = getTelecomService(); 1650 if (service != null) { 1651 try { 1652 return service.getDefaultDialerPackageForUser( 1653 userHandle.getIdentifier()); 1654 } catch (RemoteException e) { 1655 Log.e(TAG, "RemoteException attempting to get the default dialer package name.", e); 1656 } 1657 } 1658 return null; 1659 } 1660 1661 /** 1662 * Used to set the default dialer package. 1663 * 1664 * @param packageName to set the default dialer to, or {@code null} if the system provided 1665 * dialer should be used instead. 1666 * 1667 * @result {@code true} if the default dialer was successfully changed, {@code false} if 1668 * the specified package does not correspond to an installed dialer, or is already 1669 * the default dialer. 1670 * 1671 * @hide 1672 * @deprecated Use 1673 * {@link android.app.role.RoleManager#addRoleHolderAsUser(String, String, int, UserHandle, 1674 * Executor, java.util.function.Consumer)} instead. 1675 * @removed 1676 */ 1677 @SystemApi 1678 @Deprecated 1679 @RequiresPermission(allOf = { 1680 android.Manifest.permission.MODIFY_PHONE_STATE, 1681 android.Manifest.permission.WRITE_SECURE_SETTINGS}) setDefaultDialer(@ullable String packageName)1682 public boolean setDefaultDialer(@Nullable String packageName) { 1683 ITelecomService service = getTelecomService(); 1684 if (service != null) { 1685 try { 1686 return service.setDefaultDialer(packageName); 1687 } catch (RemoteException e) { 1688 Log.e(TAG, "RemoteException attempting to set the default dialer.", e); 1689 } 1690 } 1691 return false; 1692 } 1693 1694 /** 1695 * Determines the package name of the system-provided default phone app. 1696 * 1697 * @return package name for the system dialer package or {@code null} if no system dialer is 1698 * preloaded. 1699 */ getSystemDialerPackage()1700 public @Nullable String getSystemDialerPackage() { 1701 ITelecomService service = getTelecomService(); 1702 if (service != null) { 1703 try { 1704 return service.getSystemDialerPackage(mContext.getPackageName()); 1705 } catch (RemoteException e) { 1706 Log.e(TAG, "RemoteException attempting to get the system dialer package name.", e); 1707 } 1708 } 1709 return null; 1710 } 1711 1712 /** 1713 * Return whether a given phone number is the configured voicemail number for a 1714 * particular phone account. 1715 * 1716 * @param accountHandle The handle for the account to check the voicemail number against 1717 * @param number The number to look up. 1718 */ 1719 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) isVoiceMailNumber(PhoneAccountHandle accountHandle, String number)1720 public boolean isVoiceMailNumber(PhoneAccountHandle accountHandle, String number) { 1721 ITelecomService service = getTelecomService(); 1722 if (service != null) { 1723 try { 1724 return service.isVoiceMailNumber(accountHandle, number, 1725 mContext.getOpPackageName(), mContext.getAttributionTag()); 1726 } catch (RemoteException e) { 1727 Log.e(TAG, "RemoteException calling ITelecomService#isVoiceMailNumber.", e); 1728 } 1729 } 1730 return false; 1731 } 1732 1733 /** 1734 * Return the voicemail number for a given phone account. 1735 * 1736 * @param accountHandle The handle for the phone account. 1737 * @return The voicemail number for the phone account, and {@code null} if one has not been 1738 * configured. 1739 */ 1740 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) getVoiceMailNumber(PhoneAccountHandle accountHandle)1741 public String getVoiceMailNumber(PhoneAccountHandle accountHandle) { 1742 ITelecomService service = getTelecomService(); 1743 if (service != null) { 1744 try { 1745 return service.getVoiceMailNumber(accountHandle, 1746 mContext.getOpPackageName(), mContext.getAttributionTag()); 1747 } catch (RemoteException e) { 1748 Log.e(TAG, "RemoteException calling ITelecomService#hasVoiceMailNumber.", e); 1749 } 1750 } 1751 return null; 1752 } 1753 1754 /** 1755 * Return the line 1 phone number for given phone account. 1756 * 1757 * <p>Requires Permission: 1758 * {@link android.Manifest.permission#READ_SMS READ_SMS}, 1759 * {@link android.Manifest.permission#READ_PHONE_NUMBERS READ_PHONE_NUMBERS}, 1760 * or that the caller is the default SMS app for any API level. 1761 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} 1762 * for apps targeting SDK API level 29 and below. 1763 * 1764 * @param accountHandle The handle for the account retrieve a number for. 1765 * @return A string representation of the line 1 phone number. 1766 * @deprecated use {@link SubscriptionManager#getPhoneNumber(int)} instead, which takes a 1767 * Telephony Subscription ID that can be retrieved with the {@code accountHandle} 1768 * from {@link TelephonyManager#getSubscriptionId(PhoneAccountHandle)}. 1769 */ 1770 @Deprecated 1771 @SuppressAutoDoc // Blocked by b/72967236 - no support for carrier privileges or default SMS app 1772 @RequiresPermission(anyOf = { 1773 android.Manifest.permission.READ_PHONE_STATE, 1774 android.Manifest.permission.READ_SMS, 1775 android.Manifest.permission.READ_PHONE_NUMBERS 1776 }, conditional = true) getLine1Number(PhoneAccountHandle accountHandle)1777 public String getLine1Number(PhoneAccountHandle accountHandle) { 1778 ITelecomService service = getTelecomService(); 1779 if (service != null) { 1780 try { 1781 return service.getLine1Number(accountHandle, 1782 mContext.getOpPackageName(), mContext.getAttributionTag()); 1783 } catch (RemoteException e) { 1784 Log.e(TAG, "RemoteException calling ITelecomService#getLine1Number.", e); 1785 } 1786 } 1787 return null; 1788 } 1789 1790 /** 1791 * Returns whether there is an ongoing phone call (can be in dialing, ringing, active or holding 1792 * states) originating from either a manager or self-managed {@link ConnectionService}. 1793 * 1794 * @return {@code true} if there is an ongoing call in either a managed or self-managed 1795 * {@link ConnectionService}, {@code false} otherwise. 1796 */ 1797 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) isInCall()1798 public boolean isInCall() { 1799 ITelecomService service = getTelecomService(); 1800 if (service != null) { 1801 try { 1802 return service.isInCall(mContext.getOpPackageName(), 1803 mContext.getAttributionTag()); 1804 } catch (RemoteException e) { 1805 Log.e(TAG, "RemoteException calling isInCall().", e); 1806 } 1807 } 1808 return false; 1809 } 1810 1811 /** 1812 * Returns whether the caller has {@link android.Manifest.permission#MANAGE_ONGOING_CALLS} 1813 * permission. The permission can be obtained by associating with a physical wearable device 1814 * via the {@link android.companion.CompanionDeviceManager} API as a companion app. If the 1815 * caller app has the permission, it has {@link InCallService} access to manage ongoing calls. 1816 * 1817 * @return {@code true} if the caller has {@link InCallService} access for 1818 * companion app; {@code false} otherwise. 1819 */ hasManageOngoingCallsPermission()1820 public boolean hasManageOngoingCallsPermission() { 1821 ITelecomService service = getTelecomService(); 1822 if (service != null) { 1823 try { 1824 return service.hasManageOngoingCallsPermission( 1825 mContext.getOpPackageName()); 1826 } catch (RemoteException e) { 1827 Log.e(TAG, "RemoteException calling hasManageOngoingCallsPermission().", e); 1828 if (!isSystemProcess()) { 1829 e.rethrowAsRuntimeException(); 1830 } 1831 } 1832 } 1833 return false; 1834 } 1835 1836 /** 1837 * Returns whether there is an ongoing call originating from a managed 1838 * {@link ConnectionService}. An ongoing call can be in dialing, ringing, active or holding 1839 * states. 1840 * <p> 1841 * If you also need to know if there are ongoing self-managed calls, use {@link #isInCall()} 1842 * instead. 1843 * 1844 * @return {@code true} if there is an ongoing call in a managed {@link ConnectionService}, 1845 * {@code false} otherwise. 1846 */ 1847 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) isInManagedCall()1848 public boolean isInManagedCall() { 1849 ITelecomService service = getTelecomService(); 1850 if (service != null) { 1851 try { 1852 return service.isInManagedCall(mContext.getOpPackageName(), 1853 mContext.getAttributionTag()); 1854 } catch (RemoteException e) { 1855 Log.e(TAG, "RemoteException calling isInManagedCall().", e); 1856 } 1857 } 1858 return false; 1859 } 1860 1861 /** 1862 * Returns one of the following constants that represents the current state of Telecom: 1863 * 1864 * {@link TelephonyManager#CALL_STATE_RINGING} 1865 * {@link TelephonyManager#CALL_STATE_OFFHOOK} 1866 * {@link TelephonyManager#CALL_STATE_IDLE} 1867 * 1868 * Takes into consideration both managed and self-managed calls. 1869 * <p> 1870 * Requires Permission: 1871 * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} for applications 1872 * targeting API level 31+. 1873 * 1874 * @hide 1875 */ 1876 @RequiresPermission(anyOf = {READ_PRIVILEGED_PHONE_STATE, 1877 android.Manifest.permission.READ_PHONE_STATE}, conditional = true) 1878 @SystemApi getCallState()1879 public @CallState int getCallState() { 1880 ITelecomService service = getTelecomService(); 1881 if (service != null) { 1882 try { 1883 return service.getCallStateUsingPackage(mContext.getOpPackageName(), 1884 mContext.getAttributionTag()); 1885 } catch (RemoteException e) { 1886 Log.d(TAG, "RemoteException calling getCallState().", e); 1887 } 1888 } 1889 return TelephonyManager.CALL_STATE_IDLE; 1890 } 1891 1892 /** 1893 * Returns whether there currently exists is a ringing incoming-call. 1894 * 1895 * @return {@code true} if there is a managed or self-managed ringing call. 1896 * @hide 1897 */ 1898 @SystemApi 1899 @RequiresPermission(anyOf = { 1900 READ_PRIVILEGED_PHONE_STATE, 1901 android.Manifest.permission.READ_PHONE_STATE 1902 }) isRinging()1903 public boolean isRinging() { 1904 ITelecomService service = getTelecomService(); 1905 if (service != null) { 1906 try { 1907 return service.isRinging(mContext.getOpPackageName()); 1908 } catch (RemoteException e) { 1909 Log.e(TAG, "RemoteException attempting to get ringing state of phone app.", e); 1910 } 1911 } 1912 return false; 1913 } 1914 1915 /** 1916 * Ends the foreground call on the device. 1917 * <p> 1918 * If there is a ringing call, calling this method rejects the ringing call. Otherwise the 1919 * foreground call is ended. 1920 * <p> 1921 * Note: this method CANNOT be used to end ongoing emergency calls and will return {@code false} 1922 * if an attempt is made to end an emergency call. 1923 * 1924 * @return {@code true} if there is a call which will be rejected or terminated, {@code false} 1925 * otherwise. 1926 * @deprecated Companion apps for wearable devices should use the {@link InCallService} API 1927 * instead. Apps performing call screening should use the {@link CallScreeningService} API 1928 * instead. 1929 */ 1930 @RequiresPermission(Manifest.permission.ANSWER_PHONE_CALLS) 1931 @Deprecated endCall()1932 public boolean endCall() { 1933 ITelecomService service = getTelecomService(); 1934 if (service != null) { 1935 try { 1936 return service.endCall(mContext.getPackageName()); 1937 } catch (RemoteException e) { 1938 Log.e(TAG, "Error calling ITelecomService#endCall", e); 1939 } 1940 } 1941 return false; 1942 } 1943 1944 /** 1945 * If there is a ringing incoming call, this method accepts the call on behalf of the user. 1946 * 1947 * If the incoming call is a video call, the call will be answered with the same video state as 1948 * the incoming call requests. This means, for example, that an incoming call requesting 1949 * {@link VideoProfile#STATE_BIDIRECTIONAL} will be answered, accepting that state. 1950 * 1951 * @deprecated Companion apps for wearable devices should use the {@link InCallService} API 1952 * instead. 1953 */ 1954 //TODO: L-release - need to convert all invocation of ITelecmmService#answerRingingCall to use 1955 // this method (clockwork & gearhead). 1956 @RequiresPermission(anyOf = 1957 {Manifest.permission.ANSWER_PHONE_CALLS, Manifest.permission.MODIFY_PHONE_STATE}) 1958 @Deprecated acceptRingingCall()1959 public void acceptRingingCall() { 1960 ITelecomService service = getTelecomService(); 1961 if (service != null) { 1962 try { 1963 service.acceptRingingCall(mContext.getPackageName()); 1964 } catch (RemoteException e) { 1965 Log.e(TAG, "Error calling ITelecomService#acceptRingingCall", e); 1966 } 1967 } 1968 } 1969 1970 /** 1971 * If there is a ringing incoming call, this method accepts the call on behalf of the user, 1972 * with the specified video state. 1973 * 1974 * @param videoState The desired video state to answer the call with. 1975 * @deprecated Companion apps for wearable devices should use the {@link InCallService} API 1976 * instead. 1977 */ 1978 @RequiresPermission(anyOf = 1979 {Manifest.permission.ANSWER_PHONE_CALLS, Manifest.permission.MODIFY_PHONE_STATE}) 1980 @Deprecated acceptRingingCall(int videoState)1981 public void acceptRingingCall(int videoState) { 1982 ITelecomService service = getTelecomService(); 1983 if (service != null) { 1984 try { 1985 service.acceptRingingCallWithVideoState( 1986 mContext.getPackageName(), videoState); 1987 } catch (RemoteException e) { 1988 Log.e(TAG, "Error calling ITelecomService#acceptRingingCallWithVideoState", e); 1989 } 1990 } 1991 } 1992 1993 /** 1994 * Silences the ringer if a ringing call exists. 1995 * <p> 1996 * This method can only be relied upon to stop the ringtone for a call if the ringtone has 1997 * already started playing. It is intended to handle use-cases such as silencing a ringing call 1998 * when the user presses the volume button during ringing. 1999 * <p> 2000 * If this method is called prior to when the ringtone begins playing, the ringtone will not be 2001 * silenced. As such it is not intended as a means to avoid playing of a ringtone. 2002 * <p> 2003 * A dialer app which wants to have more control over ringtone playing should declare 2004 * {@link TelecomManager#METADATA_IN_CALL_SERVICE_RINGING} in the manifest entry for their 2005 * {@link InCallService} implementation to indicate that the app wants to be responsible for 2006 * playing the ringtone for all incoming calls. 2007 * <p> 2008 * Requires permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE} or that the 2009 * app fills the dialer role (see {@link #getDefaultDialerPackage()}). 2010 */ 2011 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) silenceRinger()2012 public void silenceRinger() { 2013 ITelecomService service = getTelecomService(); 2014 if (service != null) { 2015 try { 2016 service.silenceRinger(mContext.getOpPackageName()); 2017 } catch (RemoteException e) { 2018 Log.e(TAG, "Error calling ITelecomService#silenceRinger", e); 2019 } 2020 } 2021 } 2022 2023 /** 2024 * Returns whether TTY is supported on this device. 2025 */ 2026 @RequiresPermission(anyOf = { 2027 READ_PRIVILEGED_PHONE_STATE, 2028 android.Manifest.permission.READ_PHONE_STATE 2029 }) isTtySupported()2030 public boolean isTtySupported() { 2031 ITelecomService service = getTelecomService(); 2032 if (service != null) { 2033 try { 2034 return service.isTtySupported(mContext.getOpPackageName(), 2035 mContext.getAttributionTag()); 2036 } catch (RemoteException e) { 2037 Log.e(TAG, "RemoteException attempting to get TTY supported state.", e); 2038 } 2039 } 2040 return false; 2041 } 2042 2043 /** 2044 * Returns the current TTY mode of the device. For TTY to be on the user must enable it in 2045 * settings and have a wired headset plugged in. 2046 * Valid modes are: 2047 * - {@link TelecomManager#TTY_MODE_OFF} 2048 * - {@link TelecomManager#TTY_MODE_FULL} 2049 * - {@link TelecomManager#TTY_MODE_HCO} 2050 * - {@link TelecomManager#TTY_MODE_VCO} 2051 * @hide 2052 */ 2053 @SystemApi 2054 @RequiresPermission(READ_PRIVILEGED_PHONE_STATE) getCurrentTtyMode()2055 public @TtyMode int getCurrentTtyMode() { 2056 ITelecomService service = getTelecomService(); 2057 if (service != null) { 2058 try { 2059 return service.getCurrentTtyMode(mContext.getOpPackageName(), 2060 mContext.getAttributionTag()); 2061 } catch (RemoteException e) { 2062 Log.e(TAG, "RemoteException attempting to get the current TTY mode.", e); 2063 } 2064 } 2065 return TTY_MODE_OFF; 2066 } 2067 2068 /** 2069 * Registers a new incoming call. A {@link ConnectionService} should invoke this method when it 2070 * has an incoming call. For managed {@link ConnectionService}s, the specified 2071 * {@link PhoneAccountHandle} must have been registered with {@link #registerPhoneAccount} and 2072 * the user must have enabled the corresponding {@link PhoneAccount}. This can be checked using 2073 * {@link #getPhoneAccount}. Self-managed {@link ConnectionService}s must have 2074 * {@link android.Manifest.permission#MANAGE_OWN_CALLS} to add a new incoming call. 2075 * <p> 2076 * Specify the address associated with the incoming call using 2077 * {@link #EXTRA_INCOMING_CALL_ADDRESS}. If an incoming call is from an anonymous source, omit 2078 * this extra and ensure you specify a valid number presentation via 2079 * {@link Connection#setAddress(Uri, int)} on the {@link Connection} instance you return in 2080 * your 2081 * {@link ConnectionService#onCreateIncomingConnection(PhoneAccountHandle, ConnectionRequest)} 2082 * implementation. 2083 * <p> 2084 * The incoming call you are adding is assumed to have a video state of 2085 * {@link VideoProfile#STATE_AUDIO_ONLY}, unless the extra value 2086 * {@link #EXTRA_INCOMING_VIDEO_STATE} is specified. 2087 * <p> 2088 * Once invoked, this method will cause the system to bind to the {@link ConnectionService} 2089 * associated with the {@link PhoneAccountHandle} and request additional information about the 2090 * call (See {@link ConnectionService#onCreateIncomingConnection}) before starting the incoming 2091 * call UI. 2092 * <p> 2093 * For a managed {@link ConnectionService}, a {@link SecurityException} will be thrown if either 2094 * the {@link PhoneAccountHandle} does not correspond to a registered {@link PhoneAccount} or 2095 * the associated {@link PhoneAccount} is not currently enabled by the user. 2096 * <p> 2097 * For a self-managed {@link ConnectionService}, a {@link SecurityException} will be thrown if 2098 * the {@link PhoneAccount} has {@link PhoneAccount#CAPABILITY_SELF_MANAGED} and the calling app 2099 * does not have {@link android.Manifest.permission#MANAGE_OWN_CALLS}. 2100 * <p> 2101 * <p> 2102 * <b>Note</b>: {@link android.app.Notification.CallStyle} notifications should be posted after 2103 * the call is added to Telecom in order for the notification to be non-dismissible. 2104 * @param phoneAccount A {@link PhoneAccountHandle} registered with 2105 * {@link #registerPhoneAccount}. 2106 * @param extras A bundle that will be passed through to 2107 * {@link ConnectionService#onCreateIncomingConnection}. 2108 */ addNewIncomingCall(PhoneAccountHandle phoneAccount, Bundle extras)2109 public void addNewIncomingCall(PhoneAccountHandle phoneAccount, Bundle extras) { 2110 ITelecomService service = getTelecomService(); 2111 if (service != null) { 2112 try { 2113 if (extras != null && extras.getBoolean(EXTRA_IS_HANDOVER) && 2114 mContext.getApplicationContext().getApplicationInfo().targetSdkVersion > 2115 Build.VERSION_CODES.O_MR1) { 2116 Log.e("TAG", "addNewIncomingCall failed. Use public api " + 2117 "acceptHandover for API > O-MR1"); 2118 return; 2119 } 2120 service.addNewIncomingCall(phoneAccount, extras == null ? new Bundle() : extras, 2121 mContext.getPackageName()); 2122 } catch (RemoteException e) { 2123 Log.e(TAG, "RemoteException adding a new incoming call: " + phoneAccount, e); 2124 } 2125 } 2126 } 2127 2128 /** 2129 * Registers a new incoming conference. A {@link ConnectionService} should invoke this method 2130 * when it has an incoming conference. An incoming {@link Conference} is an adhoc conference 2131 * call initiated on another device which the user is being invited to join in. For managed 2132 * {@link ConnectionService}s, the specified {@link PhoneAccountHandle} must have been 2133 * registered with {@link #registerPhoneAccount} and the user must have enabled the 2134 * corresponding {@link PhoneAccount}. This can be checked using 2135 * {@link #getPhoneAccount(PhoneAccountHandle)}. Self-managed {@link ConnectionService}s must 2136 * have {@link android.Manifest.permission#MANAGE_OWN_CALLS} to add a new incoming call. 2137 * <p> 2138 * The incoming conference you are adding is assumed to have a video state of 2139 * {@link VideoProfile#STATE_AUDIO_ONLY}, unless the extra value 2140 * {@link #EXTRA_INCOMING_VIDEO_STATE} is specified. 2141 * <p> 2142 * Once invoked, this method will cause the system to bind to the {@link ConnectionService} 2143 * associated with the {@link PhoneAccountHandle} and request additional information about the 2144 * call (See 2145 * {@link ConnectionService#onCreateIncomingConference(PhoneAccountHandle, ConnectionRequest)}) 2146 * before starting the incoming call UI. 2147 * <p> 2148 * For a managed {@link ConnectionService}, a {@link SecurityException} will be thrown if either 2149 * the {@link PhoneAccountHandle} does not correspond to a registered {@link PhoneAccount} or 2150 * the associated {@link PhoneAccount} is not currently enabled by the user. 2151 * 2152 * @param phoneAccount A {@link PhoneAccountHandle} registered with 2153 * {@link #registerPhoneAccount}. 2154 * @param extras A bundle that will be passed through to 2155 * {@link ConnectionService#onCreateIncomingConference}. 2156 */ addNewIncomingConference(@onNull PhoneAccountHandle phoneAccount, @NonNull Bundle extras)2157 public void addNewIncomingConference(@NonNull PhoneAccountHandle phoneAccount, 2158 @NonNull Bundle extras) { 2159 ITelecomService service = getTelecomService(); 2160 if (service != null) { 2161 try { 2162 service.addNewIncomingConference( 2163 phoneAccount, extras == null ? new Bundle() : extras, 2164 mContext.getPackageName()); 2165 } catch (RemoteException e) { 2166 Log.e(TAG, "RemoteException adding a new incoming conference: " + phoneAccount, e); 2167 } 2168 } 2169 } 2170 2171 /** 2172 * Registers a new unknown call with Telecom. This can only be called by the system Telephony 2173 * service. This is invoked when Telephony detects a new unknown connection that was neither 2174 * a new incoming call, nor an user-initiated outgoing call. 2175 * 2176 * @param phoneAccount A {@link PhoneAccountHandle} registered with 2177 * {@link #registerPhoneAccount}. 2178 * @param extras A bundle that will be passed through to 2179 * {@link ConnectionService#onCreateIncomingConnection}. 2180 * @hide 2181 */ 2182 @SystemApi addNewUnknownCall(PhoneAccountHandle phoneAccount, Bundle extras)2183 public void addNewUnknownCall(PhoneAccountHandle phoneAccount, Bundle extras) { 2184 ITelecomService service = getTelecomService(); 2185 if (service != null) { 2186 try { 2187 service.addNewUnknownCall( 2188 phoneAccount, extras == null ? new Bundle() : extras); 2189 } catch (RemoteException e) { 2190 Log.e(TAG, "RemoteException adding a new unknown call: " + phoneAccount, e); 2191 } 2192 } 2193 } 2194 2195 /** 2196 * Processes the specified dial string as an MMI code. 2197 * MMI codes are any sequence of characters entered into the dialpad that contain a "*" or "#". 2198 * Some of these sequences launch special behavior through handled by Telephony. 2199 * This method uses the default subscription. 2200 * <p> 2201 * Requires that the method-caller be set as the system dialer app. 2202 * </p> 2203 * 2204 * @param dialString The digits to dial. 2205 * @return True if the digits were processed as an MMI code, false otherwise. 2206 */ 2207 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) handleMmi(String dialString)2208 public boolean handleMmi(String dialString) { 2209 ITelecomService service = getTelecomService(); 2210 if (service != null) { 2211 try { 2212 return service.handlePinMmi(dialString, mContext.getOpPackageName()); 2213 } catch (RemoteException e) { 2214 Log.e(TAG, "Error calling ITelecomService#handlePinMmi", e); 2215 } 2216 } 2217 return false; 2218 } 2219 2220 /** 2221 * Processes the specified dial string as an MMI code. 2222 * MMI codes are any sequence of characters entered into the dialpad that contain a "*" or "#". 2223 * Some of these sequences launch special behavior through handled by Telephony. 2224 * <p> 2225 * Requires that the method-caller be set as the system dialer app. 2226 * </p> 2227 * 2228 * @param accountHandle The handle for the account the MMI code should apply to. 2229 * @param dialString The digits to dial. 2230 * @return True if the digits were processed as an MMI code, false otherwise. 2231 */ 2232 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) handleMmi(String dialString, PhoneAccountHandle accountHandle)2233 public boolean handleMmi(String dialString, PhoneAccountHandle accountHandle) { 2234 ITelecomService service = getTelecomService(); 2235 if (service != null) { 2236 try { 2237 return service.handlePinMmiForPhoneAccount(accountHandle, dialString, 2238 mContext.getOpPackageName()); 2239 } catch (RemoteException e) { 2240 Log.e(TAG, "Error calling ITelecomService#handlePinMmi", e); 2241 } 2242 } 2243 return false; 2244 } 2245 2246 /** 2247 * Returns a URI (with the content:// scheme) specific to the specified {@link PhoneAccount} 2248 * for ADN content retrieval. 2249 * @param accountHandle The handle for the account to derive an adn query URI for or 2250 * {@code null} to return a URI which will use the default account. 2251 * @return The URI (with the content:// scheme) specific to the specified {@link PhoneAccount} 2252 * for the the content retrieve. 2253 */ 2254 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) getAdnUriForPhoneAccount(PhoneAccountHandle accountHandle)2255 public Uri getAdnUriForPhoneAccount(PhoneAccountHandle accountHandle) { 2256 ITelecomService service = getTelecomService(); 2257 if (service != null && accountHandle != null) { 2258 try { 2259 return service.getAdnUriForPhoneAccount(accountHandle, mContext.getOpPackageName()); 2260 } catch (RemoteException e) { 2261 Log.e(TAG, "Error calling ITelecomService#getAdnUriForPhoneAccount", e); 2262 } 2263 } 2264 return Uri.parse("content://icc/adn"); 2265 } 2266 2267 /** 2268 * Removes the missed-call notification if one is present and marks missed calls in the call 2269 * log as read. 2270 * <p> 2271 * Requires that the method-caller be set as the default dialer app. 2272 * </p> 2273 */ 2274 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) cancelMissedCallsNotification()2275 public void cancelMissedCallsNotification() { 2276 ITelecomService service = getTelecomService(); 2277 if (service != null) { 2278 try { 2279 service.cancelMissedCallsNotification(mContext.getOpPackageName()); 2280 } catch (RemoteException e) { 2281 Log.e(TAG, "Error calling ITelecomService#cancelMissedCallsNotification", e); 2282 } 2283 } 2284 } 2285 2286 /** 2287 * Brings the in-call screen to the foreground if there is an ongoing call. If there is 2288 * currently no ongoing call, then this method does nothing. 2289 * <p> 2290 * Requires that the method-caller be set as the system dialer app or have the 2291 * {@link android.Manifest.permission#READ_PHONE_STATE} permission. 2292 * </p> 2293 * 2294 * @param showDialpad Brings up the in-call dialpad as part of showing the in-call screen. 2295 */ 2296 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) showInCallScreen(boolean showDialpad)2297 public void showInCallScreen(boolean showDialpad) { 2298 ITelecomService service = getTelecomService(); 2299 if (service != null) { 2300 try { 2301 service.showInCallScreen(showDialpad, mContext.getOpPackageName(), 2302 mContext.getAttributionTag()); 2303 } catch (RemoteException e) { 2304 Log.e(TAG, "Error calling ITelecomService#showCallScreen", e); 2305 } 2306 } 2307 } 2308 2309 /** 2310 * Places a new outgoing call to the provided address using the system telecom service with 2311 * the specified extras. 2312 * 2313 * This method is equivalent to placing an outgoing call using {@link Intent#ACTION_CALL}, 2314 * except that the outgoing call will always be sent via the system telecom service. If 2315 * method-caller is either the user selected default dialer app or preloaded system dialer 2316 * app, then emergency calls will also be allowed. 2317 * 2318 * Placing a call via a managed {@link ConnectionService} requires permission: 2319 * {@link android.Manifest.permission#CALL_PHONE} 2320 * 2321 * Usage example: 2322 * <pre> 2323 * Uri uri = Uri.fromParts("tel", "12345", null); 2324 * Bundle extras = new Bundle(); 2325 * extras.putBoolean(TelecomManager.EXTRA_START_CALL_WITH_SPEAKERPHONE, true); 2326 * telecomManager.placeCall(uri, extras); 2327 * </pre> 2328 * 2329 * The following keys are supported in the supplied extras. 2330 * <ul> 2331 * <li>{@link #EXTRA_OUTGOING_CALL_EXTRAS}</li> 2332 * <li>{@link #EXTRA_PHONE_ACCOUNT_HANDLE}</li> 2333 * <li>{@link #EXTRA_START_CALL_WITH_SPEAKERPHONE}</li> 2334 * <li>{@link #EXTRA_START_CALL_WITH_VIDEO_STATE}</li> 2335 * </ul> 2336 * <p> 2337 * An app which implements the self-managed {@link ConnectionService} API uses 2338 * {@link #placeCall(Uri, Bundle)} to inform Telecom of a new outgoing call. A self-managed 2339 * {@link ConnectionService} must include {@link #EXTRA_PHONE_ACCOUNT_HANDLE} to specify its 2340 * associated {@link android.telecom.PhoneAccountHandle}. 2341 * 2342 * Self-managed {@link ConnectionService}s require permission 2343 * {@link android.Manifest.permission#MANAGE_OWN_CALLS}. 2344 * 2345 * <p class="note"><strong>Note:</strong> If this method is used to place an emergency call, it 2346 * is not guaranteed that the call will be placed on the {@link PhoneAccount} provided in 2347 * the {@link #EXTRA_PHONE_ACCOUNT_HANDLE} extra (if specified) and may be placed on another 2348 * {@link PhoneAccount} with the {@link PhoneAccount#CAPABILITY_PLACE_EMERGENCY_CALLS} 2349 * capability, depending on external factors, such as network conditions and Modem/SIM status. 2350 * </p> 2351 * <p> 2352 * <p> 2353 * <b>Note</b>: {@link android.app.Notification.CallStyle} notifications should be posted after 2354 * the call is placed in order for the notification to be non-dismissible. 2355 * @param address The address to make the call to. 2356 * @param extras Bundle of extras to use with the call. 2357 */ 2358 @RequiresPermission(anyOf = {android.Manifest.permission.CALL_PHONE, 2359 android.Manifest.permission.MANAGE_OWN_CALLS}) placeCall(Uri address, Bundle extras)2360 public void placeCall(Uri address, Bundle extras) { 2361 ITelecomService service = getTelecomService(); 2362 if (service != null) { 2363 if (address == null) { 2364 Log.w(TAG, "Cannot place call to empty address."); 2365 } 2366 try { 2367 service.placeCall(address, extras == null ? new Bundle() : extras, 2368 mContext.getOpPackageName(), mContext.getAttributionTag()); 2369 } catch (RemoteException e) { 2370 Log.e(TAG, "Error calling ITelecomService#placeCall", e); 2371 } 2372 } 2373 } 2374 2375 2376 /** 2377 * Place a new adhoc conference call with the provided participants using the system telecom 2378 * service. This method doesn't support placing of emergency calls. 2379 * 2380 * An adhoc conference call is established by providing a list of addresses to 2381 * {@code TelecomManager#startConference(List<Uri>, int videoState)} where the 2382 * {@link ConnectionService} is responsible for connecting all indicated participants 2383 * to a conference simultaneously. 2384 * This is in contrast to conferences formed by merging calls together (e.g. using 2385 * {@link android.telecom.Call#mergeConference()}). 2386 * 2387 * The following keys are supported in the supplied extras. 2388 * <ul> 2389 * <li>{@link #EXTRA_PHONE_ACCOUNT_HANDLE}</li> 2390 * <li>{@link #EXTRA_START_CALL_WITH_SPEAKERPHONE}</li> 2391 * <li>{@link #EXTRA_START_CALL_WITH_VIDEO_STATE}</li> 2392 * </ul> 2393 * 2394 * @param participants List of participants to start conference with 2395 * @param extras Bundle of extras to use with the call 2396 */ 2397 @RequiresPermission(android.Manifest.permission.CALL_PHONE) startConference(@onNull List<Uri> participants, @NonNull Bundle extras)2398 public void startConference(@NonNull List<Uri> participants, 2399 @NonNull Bundle extras) { 2400 ITelecomService service = getTelecomService(); 2401 if (service != null) { 2402 try { 2403 service.startConference(participants, extras, 2404 mContext.getOpPackageName()); 2405 } catch (RemoteException e) { 2406 Log.e(TAG, "Error calling ITelecomService#placeCall", e); 2407 } 2408 } 2409 } 2410 2411 /** 2412 * Enables and disables specified phone account. 2413 * 2414 * @param handle Handle to the phone account. 2415 * @param isEnabled Enable state of the phone account. 2416 * @hide 2417 */ 2418 @SystemApi 2419 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) enablePhoneAccount(PhoneAccountHandle handle, boolean isEnabled)2420 public void enablePhoneAccount(PhoneAccountHandle handle, boolean isEnabled) { 2421 ITelecomService service = getTelecomService(); 2422 if (service != null) { 2423 try { 2424 service.enablePhoneAccount(handle, isEnabled); 2425 } catch (RemoteException e) { 2426 Log.e(TAG, "Error enablePhoneAbbount", e); 2427 } 2428 } 2429 } 2430 2431 /** 2432 * Dumps telecom analytics for uploading. 2433 * 2434 * @return 2435 * @hide 2436 */ 2437 @SystemApi 2438 @RequiresPermission(Manifest.permission.DUMP) dumpAnalytics()2439 public TelecomAnalytics dumpAnalytics() { 2440 ITelecomService service = getTelecomService(); 2441 TelecomAnalytics result = null; 2442 if (service != null) { 2443 try { 2444 result = service.dumpCallAnalytics(); 2445 } catch (RemoteException e) { 2446 Log.e(TAG, "Error dumping call analytics", e); 2447 } 2448 } 2449 return result; 2450 } 2451 2452 /** 2453 * Creates the {@link Intent} which can be used with {@link Context#startActivity(Intent)} to 2454 * launch the activity to manage blocked numbers. 2455 * <p> The activity will display the UI to manage blocked numbers only if 2456 * {@link android.provider.BlockedNumberContract#canCurrentUserBlockNumbers(Context)} returns 2457 * {@code true} for the current user. 2458 */ createManageBlockedNumbersIntent()2459 public Intent createManageBlockedNumbersIntent() { 2460 ITelecomService service = getTelecomService(); 2461 Intent result = null; 2462 if (service != null) { 2463 try { 2464 result = service.createManageBlockedNumbersIntent(mContext.getPackageName()); 2465 if (result != null) { 2466 result.prepareToEnterProcess(LOCAL_FLAG_FROM_SYSTEM, 2467 mContext.getAttributionSource()); 2468 } 2469 } catch (RemoteException e) { 2470 Log.e(TAG, "Error calling ITelecomService#createManageBlockedNumbersIntent", e); 2471 } 2472 } 2473 return result; 2474 } 2475 2476 2477 /** 2478 * Creates the {@link Intent} which can be used with {@link Context#startActivity(Intent)} to 2479 * launch the activity for emergency dialer. 2480 * 2481 * @param number Optional number to call in emergency dialer 2482 * @hide 2483 */ 2484 @SystemApi 2485 @NonNull createLaunchEmergencyDialerIntent(@ullable String number)2486 public Intent createLaunchEmergencyDialerIntent(@Nullable String number) { 2487 ITelecomService service = getTelecomService(); 2488 if (service != null) { 2489 try { 2490 Intent result = service.createLaunchEmergencyDialerIntent(number); 2491 if (result != null) { 2492 result.prepareToEnterProcess(LOCAL_FLAG_FROM_SYSTEM, 2493 mContext.getAttributionSource()); 2494 } 2495 return result; 2496 } catch (RemoteException e) { 2497 Log.e(TAG, "Error createLaunchEmergencyDialerIntent", e); 2498 } 2499 } else { 2500 Log.w(TAG, "createLaunchEmergencyDialerIntent - Telecom service not available."); 2501 } 2502 2503 // Telecom service knows the package name of the expected emergency dialer package; if it 2504 // is not available, then fallback to not targeting a specific package. 2505 Intent intent = new Intent(Intent.ACTION_DIAL_EMERGENCY); 2506 if (!TextUtils.isEmpty(number) && TextUtils.isDigitsOnly(number)) { 2507 intent.setData(Uri.fromParts(PhoneAccount.SCHEME_TEL, number, null)); 2508 } 2509 return intent; 2510 } 2511 2512 /** 2513 * Determines whether Telecom would permit an incoming call to be added via the 2514 * {@link #addNewIncomingCall(PhoneAccountHandle, Bundle)} API for the specified 2515 * {@link PhoneAccountHandle}. 2516 * <p> 2517 * A {@link ConnectionService} may not add a call for the specified {@link PhoneAccountHandle} 2518 * in the following situations: 2519 * <ul> 2520 * <li>{@link PhoneAccount} does not have property 2521 * {@link PhoneAccount#CAPABILITY_SELF_MANAGED} set (i.e. it is a managed 2522 * {@link ConnectionService}), and the active or held call limit has 2523 * been reached.</li> 2524 * <li>There is an ongoing emergency call.</li> 2525 * </ul> 2526 * 2527 * @param phoneAccountHandle The {@link PhoneAccountHandle} the call will be added for. 2528 * @return {@code true} if telecom will permit an incoming call to be added, {@code false} 2529 * otherwise. 2530 */ isIncomingCallPermitted(PhoneAccountHandle phoneAccountHandle)2531 public boolean isIncomingCallPermitted(PhoneAccountHandle phoneAccountHandle) { 2532 if (phoneAccountHandle == null) { 2533 return false; 2534 } 2535 2536 ITelecomService service = getTelecomService(); 2537 if (service != null) { 2538 try { 2539 return service.isIncomingCallPermitted(phoneAccountHandle, 2540 mContext.getOpPackageName()); 2541 } catch (RemoteException e) { 2542 Log.e(TAG, "Error isIncomingCallPermitted", e); 2543 } 2544 } 2545 return false; 2546 } 2547 2548 /** 2549 * Determines whether Telecom would permit an outgoing call to be placed via the 2550 * {@link #placeCall(Uri, Bundle)} API for the specified {@link PhoneAccountHandle}. 2551 * <p> 2552 * A {@link ConnectionService} may not place a call for the specified {@link PhoneAccountHandle} 2553 * in the following situations: 2554 * <ul> 2555 * <li>{@link PhoneAccount} does not have property 2556 * {@link PhoneAccount#CAPABILITY_SELF_MANAGED} set (i.e. it is a managed 2557 * {@link ConnectionService}), and the active, held or ringing call limit has 2558 * been reached.</li> 2559 * <li>{@link PhoneAccount} has property {@link PhoneAccount#CAPABILITY_SELF_MANAGED} set 2560 * (i.e. it is a self-managed {@link ConnectionService} and there is an ongoing call in 2561 * another {@link ConnectionService}.</li> 2562 * <li>There is an ongoing emergency call.</li> 2563 * </ul> 2564 * 2565 * @param phoneAccountHandle The {@link PhoneAccountHandle} the call will be added for. 2566 * @return {@code true} if telecom will permit an outgoing call to be placed, {@code false} 2567 * otherwise. 2568 */ isOutgoingCallPermitted(PhoneAccountHandle phoneAccountHandle)2569 public boolean isOutgoingCallPermitted(PhoneAccountHandle phoneAccountHandle) { 2570 ITelecomService service = getTelecomService(); 2571 if (service != null) { 2572 try { 2573 return service.isOutgoingCallPermitted(phoneAccountHandle, 2574 mContext.getOpPackageName()); 2575 } catch (RemoteException e) { 2576 Log.e(TAG, "Error isOutgoingCallPermitted", e); 2577 } 2578 } 2579 return false; 2580 } 2581 2582 /** 2583 * Called by an app to indicate that it wishes to accept the handover of an ongoing call to a 2584 * {@link PhoneAccountHandle} it defines. 2585 * <p> 2586 * A call handover is the process where an ongoing call is transferred from one app (i.e. 2587 * {@link ConnectionService} to another app. The user could, for example, choose to continue a 2588 * mobile network call in a video calling app. The mobile network call via the Telephony stack 2589 * is referred to as the source of the handover, and the video calling app is referred to as the 2590 * destination. 2591 * <p> 2592 * When considering a handover scenario the <em>initiating</em> device is where a user initiated 2593 * the handover process (e.g. by calling {@link android.telecom.Call#handoverTo( 2594 * PhoneAccountHandle, int, Bundle)}, and the other device is considered the <em>receiving</em> 2595 * device. 2596 * <p> 2597 * For a full discussion of the handover process and the APIs involved, see 2598 * {@link android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle)}. 2599 * <p> 2600 * This method is called from the <em>receiving</em> side of a handover to indicate a desire to 2601 * accept the handover of an ongoing call to another {@link ConnectionService} identified by 2602 * {@link PhoneAccountHandle} destAcct. For managed {@link ConnectionService}s, the specified 2603 * {@link PhoneAccountHandle} must have been registered with {@link #registerPhoneAccount} and 2604 * the user must have enabled the corresponding {@link PhoneAccount}. This can be checked using 2605 * {@link #getPhoneAccount}. Self-managed {@link ConnectionService}s must have 2606 * {@link android.Manifest.permission#MANAGE_OWN_CALLS} to handover a call to it. 2607 * <p> 2608 * Once invoked, this method will cause the system to bind to the {@link ConnectionService} 2609 * associated with the {@link PhoneAccountHandle} destAcct and call 2610 * (See {@link ConnectionService#onCreateIncomingHandoverConnection}). 2611 * <p> 2612 * For a managed {@link ConnectionService}, a {@link SecurityException} will be thrown if either 2613 * the {@link PhoneAccountHandle} destAcct does not correspond to a registered 2614 * {@link PhoneAccount} or the associated {@link PhoneAccount} is not currently enabled by the 2615 * user. 2616 * <p> 2617 * For a self-managed {@link ConnectionService}, a {@link SecurityException} will be thrown if 2618 * the calling app does not have {@link android.Manifest.permission#MANAGE_OWN_CALLS}. 2619 * 2620 * @param srcAddr The {@link android.net.Uri} of the ongoing call to handover to the caller’s 2621 * {@link ConnectionService}. 2622 * @param videoState Video state after the handover. 2623 * @param destAcct The {@link PhoneAccountHandle} registered to the calling package. 2624 */ acceptHandover(Uri srcAddr, @VideoProfile.VideoState int videoState, PhoneAccountHandle destAcct)2625 public void acceptHandover(Uri srcAddr, @VideoProfile.VideoState int videoState, 2626 PhoneAccountHandle destAcct) { 2627 ITelecomService service = getTelecomService(); 2628 if (service != null) { 2629 try { 2630 service.acceptHandover(srcAddr, videoState, destAcct, mContext.getPackageName()); 2631 } catch (RemoteException e) { 2632 Log.e(TAG, "RemoteException acceptHandover: " + e); 2633 } 2634 } 2635 } 2636 2637 /** 2638 * Determines if there is an ongoing emergency call. This can be either an outgoing emergency 2639 * call, as identified by the dialed number, or because a call was identified by the network 2640 * as an emergency call. 2641 * @return {@code true} if there is an ongoing emergency call, {@code false} otherwise. 2642 * @hide 2643 */ 2644 @SystemApi 2645 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) isInEmergencyCall()2646 public boolean isInEmergencyCall() { 2647 ITelecomService service = getTelecomService(); 2648 if (service != null) { 2649 try { 2650 return service.isInEmergencyCall(); 2651 } catch (RemoteException e) { 2652 Log.e(TAG, "RemoteException isInEmergencyCall: " + e); 2653 return false; 2654 } 2655 } 2656 return false; 2657 } 2658 2659 /** 2660 * Determines whether there are any ongoing {@link PhoneAccount#CAPABILITY_SELF_MANAGED} 2661 * calls for a given {@code packageName} and {@code userHandle}. 2662 * 2663 * @param packageName the package name of the app to check calls for. 2664 * @param userHandle the user handle on which to check for calls. 2665 * @return {@code true} if there are ongoing calls, {@code false} otherwise. 2666 * @hide 2667 */ 2668 @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) isInSelfManagedCall(@onNull String packageName, @NonNull UserHandle userHandle)2669 public boolean isInSelfManagedCall(@NonNull String packageName, 2670 @NonNull UserHandle userHandle) { 2671 ITelecomService service = getTelecomService(); 2672 if (service != null) { 2673 try { 2674 return service.isInSelfManagedCall(packageName, userHandle, 2675 mContext.getOpPackageName()); 2676 } catch (RemoteException e) { 2677 Log.e(TAG, "RemoteException isInSelfManagedCall: " + e); 2678 e.rethrowFromSystemServer(); 2679 return false; 2680 } 2681 } else { 2682 throw new IllegalStateException("Telecom service is not present"); 2683 } 2684 } 2685 2686 /** 2687 * Add a call to the Android system service Telecom. This allows the system to start tracking an 2688 * incoming or outgoing call with the specified {@link CallAttributes}. Once a call is added, 2689 * a {@link android.app.Notification.CallStyle} notification should be posted and when the 2690 * call is ready to be disconnected, use {@link CallControl#disconnect(DisconnectCause, 2691 * Executor, OutcomeReceiver)} which is provided by the 2692 * {@code pendingControl#onResult(CallControl)}. 2693 * <p> 2694 * <p> 2695 * <p> 2696 * <b>Call Lifecycle</b>: Your app is given foreground execution priority as long as you have a 2697 * valid call and are posting a {@link android.app.Notification.CallStyle} notification. 2698 * When your application is given foreground execution priority, your app is treated as a 2699 * foreground service. Foreground execution priority will prevent the 2700 * {@link android.app.ActivityManager} from killing your application when it is placed the 2701 * background. Foreground execution priority is removed from your app when all of your app's 2702 * calls terminate or your app no longer posts a valid notification. 2703 * <p> 2704 * <p> 2705 * <p> 2706 * <b>Note</b>: Only packages that register with 2707 * {@link PhoneAccount#CAPABILITY_SUPPORTS_TRANSACTIONAL_OPERATIONS} 2708 * can utilize this API. {@link PhoneAccount}s that set the capabilities 2709 * {@link PhoneAccount#CAPABILITY_SIM_SUBSCRIPTION}, 2710 * {@link PhoneAccount#CAPABILITY_CALL_PROVIDER}, 2711 * {@link PhoneAccount#CAPABILITY_CONNECTION_MANAGER} 2712 * are not supported and will cause an exception to be thrown. 2713 * <p> 2714 * <p> 2715 * <p> 2716 * <b>Usage example:</b> 2717 * <pre> 2718 * // Its up to your app on how you want to wrap the objects. One such implementation can be: 2719 * class MyVoipCall { 2720 * ... 2721 * public CallControlCallEventCallback handshakes = new CallControlCallback() { 2722 * ... 2723 * } 2724 * 2725 * public CallEventCallback events = new CallEventCallback() { 2726 * ... 2727 * } 2728 * 2729 * public MyVoipCall(String id){ 2730 * ... 2731 * } 2732 * } 2733 * 2734 * MyVoipCall myFirstOutgoingCall = new MyVoipCall("1"); 2735 * 2736 * telecomManager.addCall(callAttributes, 2737 * Runnable::run, 2738 * new OutcomeReceiver() { 2739 * public void onResult(CallControl callControl) { 2740 * // The call has been added successfully. For demonstration 2741 * // purposes, the call is disconnected immediately ... 2742 * callControl.disconnect( 2743 * new DisconnectCause(DisconnectCause.LOCAL) ) 2744 * } 2745 * }, 2746 * myFirstOutgoingCall.handshakes, 2747 * myFirstOutgoingCall.events); 2748 * </pre> 2749 * 2750 * @param callAttributes attributes of the new call (incoming or outgoing, address, etc.) 2751 * @param executor execution context to run {@link CallControlCallback} updates on 2752 * @param pendingControl Receives the result of addCall transaction. Upon success, a 2753 * CallControl object is provided which can be used to do things like 2754 * disconnect the call that was added. 2755 * @param handshakes callback that receives <b>actionable</b> updates that originate from 2756 * Telecom. 2757 * @param events callback that receives <b>non</b>-actionable updates that originate 2758 * from Telecom. 2759 */ 2760 @RequiresPermission(android.Manifest.permission.MANAGE_OWN_CALLS) 2761 @SuppressLint("SamShouldBeLast") addCall(@onNull CallAttributes callAttributes, @NonNull @CallbackExecutor Executor executor, @NonNull OutcomeReceiver<CallControl, CallException> pendingControl, @NonNull CallControlCallback handshakes, @NonNull CallEventCallback events)2762 public void addCall(@NonNull CallAttributes callAttributes, 2763 @NonNull @CallbackExecutor Executor executor, 2764 @NonNull OutcomeReceiver<CallControl, CallException> pendingControl, 2765 @NonNull CallControlCallback handshakes, 2766 @NonNull CallEventCallback events) { 2767 Objects.requireNonNull(callAttributes); 2768 Objects.requireNonNull(executor); 2769 Objects.requireNonNull(pendingControl); 2770 Objects.requireNonNull(handshakes); 2771 Objects.requireNonNull(events); 2772 2773 ITelecomService service = getTelecomService(); 2774 if (service != null) { 2775 try { 2776 // create or add the new call to a service wrapper w/ the same phoneAccountHandle 2777 ClientTransactionalServiceWrapper transactionalServiceWrapper = 2778 mTransactionalServiceRepository.addNewCallForTransactionalServiceWrapper( 2779 callAttributes.getPhoneAccountHandle()); 2780 2781 // couple all the args passed by the client 2782 String newCallId = transactionalServiceWrapper.trackCall(callAttributes, executor, 2783 pendingControl, handshakes, events); 2784 2785 // send args to server to process new call 2786 service.addCall(callAttributes, transactionalServiceWrapper.getCallEventCallback(), 2787 newCallId, mContext.getOpPackageName()); 2788 } catch (RemoteException e) { 2789 Log.e(TAG, "RemoteException addCall: " + e); 2790 e.rethrowFromSystemServer(); 2791 } 2792 } else { 2793 throw new IllegalStateException("Telecom service is not present"); 2794 } 2795 } 2796 2797 /** 2798 * Handles {@link Intent#ACTION_CALL} intents trampolined from UserCallActivity. 2799 * @param intent The {@link Intent#ACTION_CALL} intent to handle. 2800 * @param callingPackageProxy The original package that called this before it was trampolined. 2801 * @hide 2802 */ handleCallIntent(Intent intent, String callingPackageProxy)2803 public void handleCallIntent(Intent intent, String callingPackageProxy) { 2804 ITelecomService service = getTelecomService(); 2805 if (service != null) { 2806 try { 2807 service.handleCallIntent(intent, callingPackageProxy); 2808 } catch (RemoteException e) { 2809 Log.e(TAG, "RemoteException handleCallIntent: " + e); 2810 } 2811 } 2812 } 2813 isSystemProcess()2814 private boolean isSystemProcess() { 2815 return Process.myUid() == Process.SYSTEM_UID; 2816 } 2817 getTelecomService()2818 private ITelecomService getTelecomService() { 2819 if (mTelecomServiceOverride != null) { 2820 return mTelecomServiceOverride; 2821 } 2822 if (sTelecomService == null) { 2823 ITelecomService temp = ITelecomService.Stub.asInterface( 2824 ServiceManager.getService(Context.TELECOM_SERVICE)); 2825 synchronized (CACHE_LOCK) { 2826 if (sTelecomService == null && temp != null) { 2827 try { 2828 sTelecomService = temp; 2829 sTelecomService.asBinder().linkToDeath(SERVICE_DEATH, 0); 2830 } catch (Exception e) { 2831 sTelecomService = null; 2832 } 2833 } 2834 } 2835 } 2836 return sTelecomService; 2837 } 2838 2839 private static class DeathRecipient implements IBinder.DeathRecipient { 2840 @Override binderDied()2841 public void binderDied() { 2842 resetServiceCache(); 2843 } 2844 } 2845 resetServiceCache()2846 private static void resetServiceCache() { 2847 synchronized (CACHE_LOCK) { 2848 if (sTelecomService != null) { 2849 sTelecomService.asBinder().unlinkToDeath(SERVICE_DEATH, 0); 2850 sTelecomService = null; 2851 } 2852 } 2853 } 2854 } 2855