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