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