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