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