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