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 android.Manifest; 18 import android.annotation.RequiresPermission; 19 import android.annotation.SuppressAutoDoc; 20 import android.annotation.SuppressLint; 21 import android.annotation.SystemApi; 22 import android.annotation.SystemService; 23 import android.content.ComponentName; 24 import android.content.Context; 25 import android.content.Intent; 26 import android.net.Uri; 27 import android.os.Build; 28 import android.os.Bundle; 29 import android.os.RemoteException; 30 import android.os.ServiceManager; 31 import android.telephony.TelephonyManager; 32 import android.text.TextUtils; 33 import android.util.Log; 34 35 import com.android.internal.telecom.ITelecomService; 36 37 import java.util.ArrayList; 38 import java.util.Collections; 39 import java.util.List; 40 41 /** 42 * Provides access to information about active calls and registration/call-management functionality. 43 * Apps can use methods in this class to determine the current call state. 44 * <p> 45 * Apps do not instantiate this class directly; instead, they retrieve a reference to an instance 46 * through {@link Context#getSystemService Context.getSystemService(Context.TELECOM_SERVICE)}. 47 * <p> 48 * Note that access to some telecom information is permission-protected. Your app cannot access the 49 * protected information or gain access to protected functionality unless it has the appropriate 50 * permissions declared in its manifest file. Where permissions apply, they are noted in the method 51 * descriptions. 52 */ 53 @SuppressAutoDoc 54 @SystemService(Context.TELECOM_SERVICE) 55 public class TelecomManager { 56 57 /** 58 * Activity action: Starts the UI for handing an incoming call. This intent starts the in-call 59 * UI by notifying the Telecom system that an incoming call exists for a specific call service 60 * (see {@link android.telecom.ConnectionService}). Telecom reads the Intent extras to find 61 * and bind to the appropriate {@link android.telecom.ConnectionService} which Telecom will 62 * ultimately use to control and get information about the call. 63 * <p> 64 * Input: get*Extra field {@link #EXTRA_PHONE_ACCOUNT_HANDLE} contains the component name of the 65 * {@link android.telecom.ConnectionService} that Telecom should bind to. Telecom will then 66 * ask the connection service for more information about the call prior to showing any UI. 67 * 68 * @deprecated Use {@link #addNewIncomingCall} instead. 69 */ 70 public static final String ACTION_INCOMING_CALL = "android.telecom.action.INCOMING_CALL"; 71 72 /** 73 * Similar to {@link #ACTION_INCOMING_CALL}, but is used only by Telephony to add a new 74 * sim-initiated MO call for carrier testing. 75 * @deprecated Use {@link #addNewUnknownCall} instead. 76 * @hide 77 */ 78 public static final String ACTION_NEW_UNKNOWN_CALL = "android.telecom.action.NEW_UNKNOWN_CALL"; 79 80 /** 81 * An {@link android.content.Intent} action sent by the telecom framework to start a 82 * configuration dialog for a registered {@link PhoneAccount}. There is no default dialog 83 * and each app that registers a {@link PhoneAccount} should provide one if desired. 84 * <p> 85 * A user can access the list of enabled {@link android.telecom.PhoneAccount}s through the Phone 86 * app's settings menu. For each entry, the settings app will add a click action. When 87 * triggered, the click-action will start this intent along with the extra 88 * {@link #EXTRA_PHONE_ACCOUNT_HANDLE} to indicate the {@link PhoneAccount} to configure. If the 89 * {@link PhoneAccount} package does not register an {@link android.app.Activity} for this 90 * intent, then it will not be sent. 91 */ 92 public static final String ACTION_CONFIGURE_PHONE_ACCOUNT = 93 "android.telecom.action.CONFIGURE_PHONE_ACCOUNT"; 94 95 /** 96 * The {@link android.content.Intent} action used to show the call accessibility settings page. 97 */ 98 public static final String ACTION_SHOW_CALL_ACCESSIBILITY_SETTINGS = 99 "android.telecom.action.SHOW_CALL_ACCESSIBILITY_SETTINGS"; 100 101 /** 102 * The {@link android.content.Intent} action used to show the call settings page. 103 */ 104 public static final String ACTION_SHOW_CALL_SETTINGS = 105 "android.telecom.action.SHOW_CALL_SETTINGS"; 106 107 /** 108 * The {@link android.content.Intent} action used to show the respond via SMS settings page. 109 */ 110 public static final String ACTION_SHOW_RESPOND_VIA_SMS_SETTINGS = 111 "android.telecom.action.SHOW_RESPOND_VIA_SMS_SETTINGS"; 112 113 /** 114 * The {@link android.content.Intent} action used to show the settings page used to configure 115 * {@link PhoneAccount} preferences. 116 */ 117 public static final String ACTION_CHANGE_PHONE_ACCOUNTS = 118 "android.telecom.action.CHANGE_PHONE_ACCOUNTS"; 119 120 /** 121 * {@link android.content.Intent} action used indicate that a new phone account was just 122 * registered. 123 * <p> 124 * The Intent {@link Intent#getExtras() extras} will contain {@link #EXTRA_PHONE_ACCOUNT_HANDLE} 125 * to indicate which {@link PhoneAccount} was registered. 126 * <p> 127 * Will only be sent to the default dialer app (see {@link #getDefaultDialerPackage()}). 128 */ 129 public static final String ACTION_PHONE_ACCOUNT_REGISTERED = 130 "android.telecom.action.PHONE_ACCOUNT_REGISTERED"; 131 132 /** 133 * {@link android.content.Intent} action used indicate that a phone account was just 134 * unregistered. 135 * <p> 136 * The Intent {@link Intent#getExtras() extras} will contain {@link #EXTRA_PHONE_ACCOUNT_HANDLE} 137 * to indicate which {@link PhoneAccount} was unregistered. 138 * <p> 139 * Will only be sent to the default dialer app (see {@link #getDefaultDialerPackage()}). 140 */ 141 public static final String ACTION_PHONE_ACCOUNT_UNREGISTERED = 142 "android.telecom.action.PHONE_ACCOUNT_UNREGISTERED"; 143 144 /** 145 * Activity action: Shows a dialog asking the user whether or not they want to replace the 146 * current default Dialer with the one specified in 147 * {@link #EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME}. 148 * 149 * Usage example: 150 * <pre> 151 * Intent intent = new Intent(TelecomManager.ACTION_CHANGE_DEFAULT_DIALER); 152 * intent.putExtra(TelecomManager.EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME, 153 * getActivity().getPackageName()); 154 * startActivity(intent); 155 * </pre> 156 */ 157 public static final String ACTION_CHANGE_DEFAULT_DIALER = 158 "android.telecom.action.CHANGE_DEFAULT_DIALER"; 159 160 /** 161 * Broadcast intent action indicating that the current default dialer has changed. 162 * The string extra {@link #EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME} will contain the 163 * name of the package that the default dialer was changed to. 164 * 165 * @see #EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME 166 */ 167 public static final String ACTION_DEFAULT_DIALER_CHANGED = 168 "android.telecom.action.DEFAULT_DIALER_CHANGED"; 169 170 /** 171 * Extra value used to provide the package name for {@link #ACTION_CHANGE_DEFAULT_DIALER}. 172 */ 173 public static final String EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME = 174 "android.telecom.extra.CHANGE_DEFAULT_DIALER_PACKAGE_NAME"; 175 176 /** 177 * Optional extra for {@link android.content.Intent#ACTION_CALL} containing a boolean that 178 * determines whether the speakerphone should be automatically turned on for an outgoing call. 179 */ 180 public static final String EXTRA_START_CALL_WITH_SPEAKERPHONE = 181 "android.telecom.extra.START_CALL_WITH_SPEAKERPHONE"; 182 183 /** 184 * Optional extra for {@link android.content.Intent#ACTION_CALL} containing an integer that 185 * determines the desired video state for an outgoing call. 186 * Valid options: 187 * {@link VideoProfile#STATE_AUDIO_ONLY}, 188 * {@link VideoProfile#STATE_BIDIRECTIONAL}, 189 * {@link VideoProfile#STATE_RX_ENABLED}, 190 * {@link VideoProfile#STATE_TX_ENABLED}. 191 */ 192 public static final String EXTRA_START_CALL_WITH_VIDEO_STATE = 193 "android.telecom.extra.START_CALL_WITH_VIDEO_STATE"; 194 195 /** 196 * Optional extra for {@link #addNewIncomingCall(PhoneAccountHandle, Bundle)} containing an 197 * integer that determines the requested video state for an incoming call. 198 * Valid options: 199 * {@link VideoProfile#STATE_AUDIO_ONLY}, 200 * {@link VideoProfile#STATE_BIDIRECTIONAL}, 201 * {@link VideoProfile#STATE_RX_ENABLED}, 202 * {@link VideoProfile#STATE_TX_ENABLED}. 203 */ 204 public static final String EXTRA_INCOMING_VIDEO_STATE = 205 "android.telecom.extra.INCOMING_VIDEO_STATE"; 206 207 /** 208 * The extra used with an {@link android.content.Intent#ACTION_CALL} and 209 * {@link android.content.Intent#ACTION_DIAL} {@code Intent} to specify a 210 * {@link PhoneAccountHandle} to use when making the call. 211 * <p class="note"> 212 * Retrieve with {@link android.content.Intent#getParcelableExtra(String)}. 213 */ 214 public static final String EXTRA_PHONE_ACCOUNT_HANDLE = 215 "android.telecom.extra.PHONE_ACCOUNT_HANDLE"; 216 217 /** 218 * Optional extra for {@link android.content.Intent#ACTION_CALL} containing a string call 219 * subject which will be associated with an outgoing call. Should only be specified if the 220 * {@link PhoneAccount} supports the capability {@link PhoneAccount#CAPABILITY_CALL_SUBJECT}. 221 */ 222 public static final String EXTRA_CALL_SUBJECT = "android.telecom.extra.CALL_SUBJECT"; 223 224 /** 225 * The extra used by a {@link ConnectionService} to provide the handle of the caller that 226 * has initiated a new incoming call. 227 */ 228 public static final String EXTRA_INCOMING_CALL_ADDRESS = 229 "android.telecom.extra.INCOMING_CALL_ADDRESS"; 230 231 /** 232 * Optional extra for {@link #ACTION_INCOMING_CALL} containing a {@link Bundle} which contains 233 * metadata about the call. This {@link Bundle} will be returned to the 234 * {@link ConnectionService}. 235 */ 236 public static final String EXTRA_INCOMING_CALL_EXTRAS = 237 "android.telecom.extra.INCOMING_CALL_EXTRAS"; 238 239 /** 240 * Optional extra for {@link #ACTION_INCOMING_CALL} containing a boolean to indicate that the 241 * call has an externally generated ringer. Used by the HfpClientConnectionService when In Band 242 * Ringtone is enabled to prevent two ringers from being generated. 243 * @hide 244 */ 245 public static final String EXTRA_CALL_EXTERNAL_RINGER = 246 "android.telecom.extra.CALL_EXTERNAL_RINGER"; 247 248 /** 249 * Optional extra for {@link android.content.Intent#ACTION_CALL} and 250 * {@link android.content.Intent#ACTION_DIAL} {@code Intent} containing a {@link Bundle} 251 * which contains metadata about the call. This {@link Bundle} will be saved into 252 * {@code Call.Details} and passed to the {@link ConnectionService} when placing the call. 253 */ 254 public static final String EXTRA_OUTGOING_CALL_EXTRAS = 255 "android.telecom.extra.OUTGOING_CALL_EXTRAS"; 256 257 /** 258 * @hide 259 */ 260 public static final String EXTRA_UNKNOWN_CALL_HANDLE = 261 "android.telecom.extra.UNKNOWN_CALL_HANDLE"; 262 263 /** 264 * Optional extra for incoming and outgoing calls containing a long which specifies the time the 265 * call was created. This value is in milliseconds since boot. 266 * @hide 267 */ 268 public static final String EXTRA_CALL_CREATED_TIME_MILLIS = 269 "android.telecom.extra.CALL_CREATED_TIME_MILLIS"; 270 271 /** 272 * Optional extra for incoming and outgoing calls containing a long which specifies the time 273 * telecom began routing the call. This value is in milliseconds since boot. 274 * @hide 275 */ 276 public static final String EXTRA_CALL_TELECOM_ROUTING_START_TIME_MILLIS = 277 "android.telecom.extra.CALL_TELECOM_ROUTING_START_TIME_MILLIS"; 278 279 /** 280 * Optional extra for incoming and outgoing calls containing a long which specifies the time 281 * telecom finished routing the call. This value is in milliseconds since boot. 282 * @hide 283 */ 284 public static final String EXTRA_CALL_TELECOM_ROUTING_END_TIME_MILLIS = 285 "android.telecom.extra.CALL_TELECOM_ROUTING_END_TIME_MILLIS"; 286 287 /** 288 * Optional extra for {@link android.telephony.TelephonyManager#ACTION_PHONE_STATE_CHANGED} 289 * containing the disconnect code. 290 */ 291 public static final String EXTRA_CALL_DISCONNECT_CAUSE = 292 "android.telecom.extra.CALL_DISCONNECT_CAUSE"; 293 294 /** 295 * Optional extra for {@link android.telephony.TelephonyManager#ACTION_PHONE_STATE_CHANGED} 296 * containing the disconnect message. 297 */ 298 public static final String EXTRA_CALL_DISCONNECT_MESSAGE = 299 "android.telecom.extra.CALL_DISCONNECT_MESSAGE"; 300 301 /** 302 * Optional extra for {@link android.telephony.TelephonyManager#ACTION_PHONE_STATE_CHANGED} 303 * containing the component name of the associated connection service. 304 * @hide 305 */ 306 @SystemApi 307 public static final String EXTRA_CONNECTION_SERVICE = 308 "android.telecom.extra.CONNECTION_SERVICE"; 309 310 /** 311 * Optional extra for communicating the call technology used by a 312 * {@link com.android.internal.telephony.Connection} to Telecom 313 * @hide 314 */ 315 public static final String EXTRA_CALL_TECHNOLOGY_TYPE = 316 "android.telecom.extra.CALL_TECHNOLOGY_TYPE"; 317 318 /** 319 * An optional {@link android.content.Intent#ACTION_CALL} intent extra denoting the 320 * package name of the app specifying an alternative gateway for the call. 321 * The value is a string. 322 * 323 * (The following comment corresponds to the all GATEWAY_* extras) 324 * An app which sends the {@link android.content.Intent#ACTION_CALL} intent can specify an 325 * alternative address to dial which is different from the one specified and displayed to 326 * the user. This alternative address is referred to as the gateway address. 327 */ 328 public static final String GATEWAY_PROVIDER_PACKAGE = 329 "android.telecom.extra.GATEWAY_PROVIDER_PACKAGE"; 330 331 /** 332 * An optional {@link android.content.Intent#ACTION_CALL} intent extra corresponding to the 333 * original address to dial for the call. This is used when an alternative gateway address is 334 * provided to recall the original address. 335 * The value is a {@link android.net.Uri}. 336 * 337 * (See {@link #GATEWAY_PROVIDER_PACKAGE} for details) 338 */ 339 public static final String GATEWAY_ORIGINAL_ADDRESS = 340 "android.telecom.extra.GATEWAY_ORIGINAL_ADDRESS"; 341 342 /** 343 * The number which the party on the other side of the line will see (and use to return the 344 * call). 345 * <p> 346 * {@link ConnectionService}s which interact with {@link RemoteConnection}s should only populate 347 * this if the {@link android.telephony.TelephonyManager#getLine1Number()} value, as that is the 348 * user's expected caller ID. 349 */ 350 public static final String EXTRA_CALL_BACK_NUMBER = "android.telecom.extra.CALL_BACK_NUMBER"; 351 352 /** 353 * The number of milliseconds that Telecom should wait after disconnecting a call via the 354 * ACTION_NEW_OUTGOING_CALL broadcast, in order to wait for the app which cancelled the call 355 * to make a new one. 356 * @hide 357 */ 358 public static final String EXTRA_NEW_OUTGOING_CALL_CANCEL_TIMEOUT = 359 "android.telecom.extra.NEW_OUTGOING_CALL_CANCEL_TIMEOUT"; 360 361 /** 362 * Boolean extra specified to indicate that the intention of adding a call is to handover an 363 * existing call from the user's device to a different {@link PhoneAccount}. 364 * <p> 365 * Used when calling {@link #addNewIncomingCall(PhoneAccountHandle, Bundle)} 366 * to indicate to Telecom that the purpose of adding a new incoming call is to handover an 367 * existing call from the user's device to a different {@link PhoneAccount}. This occurs on 368 * the receiving side of a handover. 369 * <p> 370 * Used when Telecom calls 371 * {@link ConnectionService#onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)} 372 * to indicate that the purpose of Telecom requesting a new outgoing connection it to request 373 * a handover to this {@link ConnectionService} from an ongoing call on the user's device. This 374 * occurs on the initiating side of a handover. 375 * <p> 376 * The phone number of the call used by Telecom to determine which call should be handed over. 377 * @hide 378 */ 379 public static final String EXTRA_IS_HANDOVER = "android.telecom.extra.IS_HANDOVER"; 380 381 /** 382 * When {@code true} indicates that a request to create a new connection is for the purpose of 383 * a handover. Note: This is used with the 384 * {@link android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle)} API as part of the 385 * internal communication mechanism with the {@link android.telecom.ConnectionService}. It is 386 * not the same as the legacy {@link #EXTRA_IS_HANDOVER} extra. 387 * @hide 388 */ 389 public static final String EXTRA_IS_HANDOVER_CONNECTION = 390 "android.telecom.extra.IS_HANDOVER_CONNECTION"; 391 392 /** 393 * Parcelable extra used with {@link #EXTRA_IS_HANDOVER} to indicate the source 394 * {@link PhoneAccountHandle} when initiating a handover which {@link ConnectionService} 395 * the handover is from. 396 * @hide 397 */ 398 public static final String EXTRA_HANDOVER_FROM_PHONE_ACCOUNT = 399 "android.telecom.extra.HANDOVER_FROM_PHONE_ACCOUNT"; 400 401 /** 402 * Extra key specified in the {@link ConnectionRequest#getExtras()} when Telecom calls 403 * {@link ConnectionService#onCreateOutgoingConnection(PhoneAccountHandle, ConnectionRequest)} 404 * to inform the {@link ConnectionService} what the initial {@link CallAudioState} of the 405 * {@link Connection} will be. 406 * @hide 407 */ 408 public static final String EXTRA_CALL_AUDIO_STATE = "android.telecom.extra.CALL_AUDIO_STATE"; 409 410 /** 411 * A boolean extra, which when set on the {@link Intent#ACTION_CALL} intent or on the bundle 412 * passed into {@link #placeCall(Uri, Bundle)}, indicates that the call should be initiated with 413 * an RTT session open. See {@link android.telecom.Call.RttCall} for more information on RTT. 414 */ 415 public static final String EXTRA_START_CALL_WITH_RTT = 416 "android.telecom.extra.START_CALL_WITH_RTT"; 417 418 /** 419 * A boolean meta-data value indicating whether an {@link InCallService} implements an 420 * in-call user interface. Dialer implementations (see {@link #getDefaultDialerPackage()}) which 421 * would also like to replace the in-call interface should set this meta-data to {@code true} in 422 * the manifest registration of their {@link InCallService}. 423 */ 424 public static final String METADATA_IN_CALL_SERVICE_UI = "android.telecom.IN_CALL_SERVICE_UI"; 425 426 /** 427 * A boolean meta-data value indicating whether an {@link InCallService} implements an 428 * in-call user interface to be used while the device is in car-mode (see 429 * {@link android.content.res.Configuration.UI_MODE_TYPE_CAR}). 430 * 431 * @hide 432 */ 433 public static final String METADATA_IN_CALL_SERVICE_CAR_MODE_UI = 434 "android.telecom.IN_CALL_SERVICE_CAR_MODE_UI"; 435 436 /** 437 * A boolean meta-data value indicating whether an {@link InCallService} implements ringing. 438 * Dialer implementations (see {@link #getDefaultDialerPackage()}) which would also like to 439 * override the system provided ringing should set this meta-data to {@code true} in the 440 * manifest registration of their {@link InCallService}. 441 */ 442 public static final String METADATA_IN_CALL_SERVICE_RINGING = 443 "android.telecom.IN_CALL_SERVICE_RINGING"; 444 445 /** 446 * A boolean meta-data value indicating whether an {@link InCallService} wants to be informed of 447 * calls which have the {@link Call.Details#PROPERTY_IS_EXTERNAL_CALL} property. An external 448 * call is one which a {@link ConnectionService} knows about, but is not connected to directly. 449 * Dialer implementations (see {@link #getDefaultDialerPackage()}) which would like to be 450 * informed of external calls should set this meta-data to {@code true} in the manifest 451 * registration of their {@link InCallService}. By default, the {@link InCallService} will NOT 452 * be informed of external calls. 453 */ 454 public static final String METADATA_INCLUDE_EXTERNAL_CALLS = 455 "android.telecom.INCLUDE_EXTERNAL_CALLS"; 456 457 /** 458 * A boolean meta-data value indicating whether an {@link InCallService} wants to be informed of 459 * calls which have the {@link Call.Details#PROPERTY_SELF_MANAGED} property. A self-managed 460 * call is one which originates from a self-managed {@link ConnectionService} which has chosen 461 * to implement its own call user interface. An {@link InCallService} implementation which 462 * would like to be informed of external calls should set this meta-data to {@code true} in the 463 * manifest registration of their {@link InCallService}. By default, the {@link InCallService} 464 * will NOT be informed about self-managed calls. 465 * <p> 466 * An {@link InCallService} which receives self-managed calls is free to view and control the 467 * state of calls in the self-managed {@link ConnectionService}. An example use-case is 468 * exposing these calls to an automotive device via its companion app. 469 * <p> 470 * This meta-data can only be set for an {@link InCallService} which also sets 471 * {@link #METADATA_IN_CALL_SERVICE_UI}. Only the default phone/dialer app, or a car-mode 472 * {@link InCallService} can see self-managed calls. 473 * <p> 474 * See also {@link Connection#PROPERTY_SELF_MANAGED}. 475 */ 476 public static final String METADATA_INCLUDE_SELF_MANAGED_CALLS = 477 "android.telecom.INCLUDE_SELF_MANAGED_CALLS"; 478 479 /** 480 * The dual tone multi-frequency signaling character sent to indicate the dialing system should 481 * pause for a predefined period. 482 */ 483 public static final char DTMF_CHARACTER_PAUSE = ','; 484 485 /** 486 * The dual-tone multi-frequency signaling character sent to indicate the dialing system should 487 * wait for user confirmation before proceeding. 488 */ 489 public static final char DTMF_CHARACTER_WAIT = ';'; 490 491 /** 492 * TTY (teletypewriter) mode is off. 493 * 494 * @hide 495 */ 496 public static final int TTY_MODE_OFF = 0; 497 498 /** 499 * TTY (teletypewriter) mode is on. The speaker is off and the microphone is muted. The user 500 * will communicate with the remote party by sending and receiving text messages. 501 * 502 * @hide 503 */ 504 public static final int TTY_MODE_FULL = 1; 505 506 /** 507 * TTY (teletypewriter) mode is in hearing carryover mode (HCO). The microphone is muted but the 508 * speaker is on. The user will communicate with the remote party by sending text messages and 509 * hearing an audible reply. 510 * 511 * @hide 512 */ 513 public static final int TTY_MODE_HCO = 2; 514 515 /** 516 * TTY (teletypewriter) mode is in voice carryover mode (VCO). The speaker is off but the 517 * microphone is still on. User will communicate with the remote party by speaking and receiving 518 * text message replies. 519 * 520 * @hide 521 */ 522 public static final int TTY_MODE_VCO = 3; 523 524 /** 525 * Broadcast intent action indicating that the current TTY mode has changed. An intent extra 526 * provides this state as an int. 527 * 528 * @see #EXTRA_CURRENT_TTY_MODE 529 * @hide 530 */ 531 public static final String ACTION_CURRENT_TTY_MODE_CHANGED = 532 "android.telecom.action.CURRENT_TTY_MODE_CHANGED"; 533 534 /** 535 * The lookup key for an int that indicates the current TTY mode. 536 * Valid modes are: 537 * - {@link #TTY_MODE_OFF} 538 * - {@link #TTY_MODE_FULL} 539 * - {@link #TTY_MODE_HCO} 540 * - {@link #TTY_MODE_VCO} 541 * 542 * @hide 543 */ 544 public static final String EXTRA_CURRENT_TTY_MODE = 545 "android.telecom.intent.extra.CURRENT_TTY_MODE"; 546 547 /** 548 * Broadcast intent action indicating that the TTY preferred operating mode has changed. An 549 * intent extra provides the new mode as an int. 550 * 551 * @see #EXTRA_TTY_PREFERRED_MODE 552 * @hide 553 */ 554 public static final String ACTION_TTY_PREFERRED_MODE_CHANGED = 555 "android.telecom.action.TTY_PREFERRED_MODE_CHANGED"; 556 557 /** 558 * The lookup key for an int that indicates preferred TTY mode. Valid modes are: - 559 * {@link #TTY_MODE_OFF} - {@link #TTY_MODE_FULL} - {@link #TTY_MODE_HCO} - 560 * {@link #TTY_MODE_VCO} 561 * 562 * @hide 563 */ 564 public static final String EXTRA_TTY_PREFERRED_MODE = 565 "android.telecom.intent.extra.TTY_PREFERRED"; 566 567 /** 568 * Broadcast intent action for letting custom component know to show the missed call 569 * notification. If no custom component exists then this is sent to the default dialer which 570 * should post a missed-call notification. 571 */ 572 public static final String ACTION_SHOW_MISSED_CALLS_NOTIFICATION = 573 "android.telecom.action.SHOW_MISSED_CALLS_NOTIFICATION"; 574 575 /** 576 * The number of calls associated with the notification. If the number is zero then the missed 577 * call notification should be dismissed. 578 */ 579 public static final String EXTRA_NOTIFICATION_COUNT = 580 "android.telecom.extra.NOTIFICATION_COUNT"; 581 582 /** 583 * The number associated with the missed calls. This number is only relevant 584 * when EXTRA_NOTIFICATION_COUNT is 1. 585 */ 586 public static final String EXTRA_NOTIFICATION_PHONE_NUMBER = 587 "android.telecom.extra.NOTIFICATION_PHONE_NUMBER"; 588 589 /** 590 * The intent to clear missed calls. 591 * @hide 592 */ 593 @SystemApi 594 public static final String EXTRA_CLEAR_MISSED_CALLS_INTENT = 595 "android.telecom.extra.CLEAR_MISSED_CALLS_INTENT"; 596 597 /** 598 * The intent to call back a missed call. 599 * @hide 600 */ 601 @SystemApi 602 public static final String EXTRA_CALL_BACK_INTENT = 603 "android.telecom.extra.CALL_BACK_INTENT"; 604 605 /** 606 * The dialer activity responsible for placing emergency calls from, for example, a locked 607 * keyguard. 608 * @hide 609 */ 610 public static final ComponentName EMERGENCY_DIALER_COMPONENT = 611 ComponentName.createRelative("com.android.phone", ".EmergencyDialer"); 612 613 /** 614 * The boolean indicated by this extra controls whether or not a call is eligible to undergo 615 * assisted dialing. This extra is stored under {@link #EXTRA_OUTGOING_CALL_EXTRAS}. 616 * @hide 617 */ 618 public static final String EXTRA_USE_ASSISTED_DIALING = 619 "android.telecom.extra.USE_ASSISTED_DIALING"; 620 621 /** 622 * The following 4 constants define how properties such as phone numbers and names are 623 * displayed to the user. 624 */ 625 626 /** 627 * Indicates that the address or number of a call is allowed to be displayed for caller ID. 628 */ 629 public static final int PRESENTATION_ALLOWED = 1; 630 631 /** 632 * Indicates that the address or number of a call is blocked by the other party. 633 */ 634 public static final int PRESENTATION_RESTRICTED = 2; 635 636 /** 637 * Indicates that the address or number of a call is not specified or known by the carrier. 638 */ 639 public static final int PRESENTATION_UNKNOWN = 3; 640 641 /** 642 * Indicates that the address or number of a call belongs to a pay phone. 643 */ 644 public static final int PRESENTATION_PAYPHONE = 4; 645 646 private static final String TAG = "TelecomManager"; 647 648 private final Context mContext; 649 650 private final ITelecomService mTelecomServiceOverride; 651 652 /** 653 * @hide 654 */ 655 public static TelecomManager from(Context context) { 656 return (TelecomManager) context.getSystemService(Context.TELECOM_SERVICE); 657 } 658 659 /** 660 * @hide 661 */ 662 public TelecomManager(Context context) { 663 this(context, null); 664 } 665 666 /** 667 * @hide 668 */ 669 public TelecomManager(Context context, ITelecomService telecomServiceImpl) { 670 Context appContext = context.getApplicationContext(); 671 if (appContext != null) { 672 mContext = appContext; 673 } else { 674 mContext = context; 675 } 676 mTelecomServiceOverride = telecomServiceImpl; 677 } 678 679 /** 680 * Return the {@link PhoneAccount} which will be used to place outgoing calls to addresses with 681 * the specified {@code uriScheme}. This {@link PhoneAccount} will always be a member of the 682 * list which is returned from invoking {@link #getCallCapablePhoneAccounts()}. The specific 683 * account returned depends on the following priorities: 684 * <ul> 685 * <li> If the user-selected default {@link PhoneAccount} supports the specified scheme, it will 686 * be returned. 687 * </li> 688 * <li> If there exists only one {@link PhoneAccount} that supports the specified scheme, it 689 * will be returned. 690 * </li> 691 * </ul> 692 * <p> 693 * If no {@link PhoneAccount} fits the criteria above, this method will return {@code null}. 694 * 695 * Requires permission: {@link android.Manifest.permission#READ_PHONE_STATE} 696 * 697 * @param uriScheme The URI scheme. 698 * @return The {@link PhoneAccountHandle} corresponding to the account to be used. 699 */ 700 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) 701 public PhoneAccountHandle getDefaultOutgoingPhoneAccount(String uriScheme) { 702 try { 703 if (isServiceConnected()) { 704 return getTelecomService().getDefaultOutgoingPhoneAccount(uriScheme, 705 mContext.getOpPackageName()); 706 } 707 } catch (RemoteException e) { 708 Log.e(TAG, "Error calling ITelecomService#getDefaultOutgoingPhoneAccount", e); 709 } 710 return null; 711 } 712 713 /** 714 * Return the {@link PhoneAccount} which is the user-chosen default for making outgoing phone 715 * calls. This {@code PhoneAccount} will always be a member of the list which is returned from 716 * calling {@link #getCallCapablePhoneAccounts()} 717 * <p> 718 * Apps must be prepared for this method to return {@code null}, indicating that there currently 719 * exists no user-chosen default {@code PhoneAccount}. 720 * 721 * @return The user outgoing phone account selected by the user. 722 * @hide 723 */ 724 public PhoneAccountHandle getUserSelectedOutgoingPhoneAccount() { 725 try { 726 if (isServiceConnected()) { 727 return getTelecomService().getUserSelectedOutgoingPhoneAccount(); 728 } 729 } catch (RemoteException e) { 730 Log.e(TAG, "Error calling ITelecomService#getUserSelectedOutgoingPhoneAccount", e); 731 } 732 return null; 733 } 734 735 /** 736 * Sets the user-chosen default for making outgoing phone calls. 737 * @hide 738 */ 739 public void setUserSelectedOutgoingPhoneAccount(PhoneAccountHandle accountHandle) { 740 try { 741 if (isServiceConnected()) { 742 getTelecomService().setUserSelectedOutgoingPhoneAccount(accountHandle); 743 } 744 } catch (RemoteException e) { 745 Log.e(TAG, "Error calling ITelecomService#setUserSelectedOutgoingPhoneAccount"); 746 } 747 } 748 749 /** 750 * Returns the current SIM call manager. Apps must be prepared for this method to return 751 * {@code null}, indicating that there currently exists no user-chosen default 752 * {@code PhoneAccount}. 753 * 754 * @return The phone account handle of the current sim call manager. 755 */ 756 public PhoneAccountHandle getSimCallManager() { 757 try { 758 if (isServiceConnected()) { 759 return getTelecomService().getSimCallManager(); 760 } 761 } catch (RemoteException e) { 762 Log.e(TAG, "Error calling ITelecomService#getSimCallManager"); 763 } 764 return null; 765 } 766 767 /** 768 * Returns the current SIM call manager for the specified user. Apps must be prepared for this 769 * method to return {@code null}, indicating that there currently exists no user-chosen default 770 * {@code PhoneAccount}. 771 * 772 * @return The phone account handle of the current sim call manager. 773 * 774 * @hide 775 */ 776 public PhoneAccountHandle getSimCallManager(int userId) { 777 try { 778 if (isServiceConnected()) { 779 return getTelecomService().getSimCallManagerForUser(userId); 780 } 781 } catch (RemoteException e) { 782 Log.e(TAG, "Error calling ITelecomService#getSimCallManagerForUser"); 783 } 784 return null; 785 } 786 787 /** 788 * Returns the current connection manager. Apps must be prepared for this method to return 789 * {@code null}, indicating that there currently exists no user-chosen default 790 * {@code PhoneAccount}. 791 * 792 * @return The phone account handle of the current connection manager. 793 * @hide 794 */ 795 @SystemApi 796 public PhoneAccountHandle getConnectionManager() { 797 return getSimCallManager(); 798 } 799 800 /** 801 * Returns a list of the {@link PhoneAccountHandle}s which can be used to make and receive phone 802 * calls which support the specified URI scheme. 803 * <P> 804 * For example, invoking with {@code "tel"} will find all {@link PhoneAccountHandle}s which 805 * support telephone calls (e.g. URIs such as {@code tel:555-555-1212}). Invoking with 806 * {@code "sip"} will find all {@link PhoneAccountHandle}s which support SIP calls (e.g. URIs 807 * such as {@code sip:example (at) sipexample.com}). 808 * 809 * @param uriScheme The URI scheme. 810 * @return A list of {@code PhoneAccountHandle} objects supporting the URI scheme. 811 * @hide 812 */ 813 @SystemApi 814 @RequiresPermission(anyOf = { 815 android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE, 816 android.Manifest.permission.READ_PHONE_STATE 817 }) 818 public List<PhoneAccountHandle> getPhoneAccountsSupportingScheme(String uriScheme) { 819 try { 820 if (isServiceConnected()) { 821 return getTelecomService().getPhoneAccountsSupportingScheme(uriScheme, 822 mContext.getOpPackageName()); 823 } 824 } catch (RemoteException e) { 825 Log.e(TAG, "Error calling ITelecomService#getPhoneAccountsSupportingScheme", e); 826 } 827 return new ArrayList<>(); 828 } 829 830 831 /** 832 * Returns a list of {@link PhoneAccountHandle}s which can be used to make and receive phone 833 * calls. The returned list includes only those accounts which have been explicitly enabled 834 * by the user. 835 * 836 * Requires permission: {@link android.Manifest.permission#READ_PHONE_STATE} 837 * 838 * @see #EXTRA_PHONE_ACCOUNT_HANDLE 839 * @return A list of {@code PhoneAccountHandle} objects. 840 */ 841 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) 842 public List<PhoneAccountHandle> getCallCapablePhoneAccounts() { 843 return getCallCapablePhoneAccounts(false); 844 } 845 846 /** 847 * Returns a list of {@link PhoneAccountHandle}s for self-managed {@link ConnectionService}s. 848 * <p> 849 * Self-Managed {@link ConnectionService}s have a {@link PhoneAccount} with 850 * {@link PhoneAccount#CAPABILITY_SELF_MANAGED}. 851 * <p> 852 * Requires permission {@link android.Manifest.permission#READ_PHONE_STATE}, or that the caller 853 * is the default dialer app. 854 * <p> 855 * A {@link SecurityException} will be thrown if a called is not the default dialer, or lacks 856 * the {@link android.Manifest.permission#READ_PHONE_STATE} permission. 857 * 858 * @return A list of {@code PhoneAccountHandle} objects. 859 */ 860 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) 861 public List<PhoneAccountHandle> getSelfManagedPhoneAccounts() { 862 try { 863 if (isServiceConnected()) { 864 return getTelecomService().getSelfManagedPhoneAccounts(mContext.getOpPackageName()); 865 } 866 } catch (RemoteException e) { 867 Log.e(TAG, "Error calling ITelecomService#getSelfManagedPhoneAccounts()", e); 868 } 869 return new ArrayList<>(); 870 } 871 872 /** 873 * Returns a list of {@link PhoneAccountHandle}s including those which have not been enabled 874 * by the user. 875 * 876 * @return A list of {@code PhoneAccountHandle} objects. 877 * @hide 878 */ 879 public List<PhoneAccountHandle> getCallCapablePhoneAccounts(boolean includeDisabledAccounts) { 880 try { 881 if (isServiceConnected()) { 882 return getTelecomService().getCallCapablePhoneAccounts( 883 includeDisabledAccounts, mContext.getOpPackageName()); 884 } 885 } catch (RemoteException e) { 886 Log.e(TAG, "Error calling ITelecomService#getCallCapablePhoneAccounts(" + 887 includeDisabledAccounts + ")", e); 888 } 889 return new ArrayList<>(); 890 } 891 892 /** 893 * Returns a list of all {@link PhoneAccount}s registered for the calling package. 894 * 895 * @return A list of {@code PhoneAccountHandle} objects. 896 * @hide 897 */ 898 @SystemApi 899 @SuppressLint("Doclava125") 900 public List<PhoneAccountHandle> getPhoneAccountsForPackage() { 901 try { 902 if (isServiceConnected()) { 903 return getTelecomService().getPhoneAccountsForPackage(mContext.getPackageName()); 904 } 905 } catch (RemoteException e) { 906 Log.e(TAG, "Error calling ITelecomService#getPhoneAccountsForPackage", e); 907 } 908 return null; 909 } 910 911 /** 912 * Return the {@link PhoneAccount} for a specified {@link PhoneAccountHandle}. Object includes 913 * resources which can be used in a user interface. 914 * 915 * @param account The {@link PhoneAccountHandle}. 916 * @return The {@link PhoneAccount} object. 917 */ 918 public PhoneAccount getPhoneAccount(PhoneAccountHandle account) { 919 try { 920 if (isServiceConnected()) { 921 return getTelecomService().getPhoneAccount(account); 922 } 923 } catch (RemoteException e) { 924 Log.e(TAG, "Error calling ITelecomService#getPhoneAccount", e); 925 } 926 return null; 927 } 928 929 /** 930 * Returns a count of all {@link PhoneAccount}s. 931 * 932 * @return The count of {@link PhoneAccount}s. 933 * @hide 934 */ 935 @SystemApi 936 public int getAllPhoneAccountsCount() { 937 try { 938 if (isServiceConnected()) { 939 return getTelecomService().getAllPhoneAccountsCount(); 940 } 941 } catch (RemoteException e) { 942 Log.e(TAG, "Error calling ITelecomService#getAllPhoneAccountsCount", e); 943 } 944 return 0; 945 } 946 947 /** 948 * Returns a list of all {@link PhoneAccount}s. 949 * 950 * @return All {@link PhoneAccount}s. 951 * @hide 952 */ 953 @SystemApi 954 public List<PhoneAccount> getAllPhoneAccounts() { 955 try { 956 if (isServiceConnected()) { 957 return getTelecomService().getAllPhoneAccounts(); 958 } 959 } catch (RemoteException e) { 960 Log.e(TAG, "Error calling ITelecomService#getAllPhoneAccounts", e); 961 } 962 return Collections.EMPTY_LIST; 963 } 964 965 /** 966 * Returns a list of all {@link PhoneAccountHandle}s. 967 * 968 * @return All {@link PhoneAccountHandle}s. 969 * @hide 970 */ 971 @SystemApi 972 public List<PhoneAccountHandle> getAllPhoneAccountHandles() { 973 try { 974 if (isServiceConnected()) { 975 return getTelecomService().getAllPhoneAccountHandles(); 976 } 977 } catch (RemoteException e) { 978 Log.e(TAG, "Error calling ITelecomService#getAllPhoneAccountHandles", e); 979 } 980 return Collections.EMPTY_LIST; 981 } 982 983 /** 984 * Register a {@link PhoneAccount} for use by the system that will be stored in Device Encrypted 985 * storage. When registering {@link PhoneAccount}s, existing registrations will be overwritten 986 * if the {@link PhoneAccountHandle} matches that of a {@link PhoneAccount} which is already 987 * registered. Once registered, the {@link PhoneAccount} is listed to the user as an option 988 * when placing calls. The user may still need to enable the {@link PhoneAccount} within 989 * the phone app settings before the account is usable. 990 * <p> 991 * A {@link SecurityException} will be thrown if an app tries to register a 992 * {@link PhoneAccountHandle} where the package name specified within 993 * {@link PhoneAccountHandle#getComponentName()} does not match the package name of the app. 994 * 995 * @param account The complete {@link PhoneAccount}. 996 */ 997 public void registerPhoneAccount(PhoneAccount account) { 998 try { 999 if (isServiceConnected()) { 1000 getTelecomService().registerPhoneAccount(account); 1001 } 1002 } catch (RemoteException e) { 1003 Log.e(TAG, "Error calling ITelecomService#registerPhoneAccount", e); 1004 } 1005 } 1006 1007 /** 1008 * Remove a {@link PhoneAccount} registration from the system. 1009 * 1010 * @param accountHandle A {@link PhoneAccountHandle} for the {@link PhoneAccount} to unregister. 1011 */ 1012 public void unregisterPhoneAccount(PhoneAccountHandle accountHandle) { 1013 try { 1014 if (isServiceConnected()) { 1015 getTelecomService().unregisterPhoneAccount(accountHandle); 1016 } 1017 } catch (RemoteException e) { 1018 Log.e(TAG, "Error calling ITelecomService#unregisterPhoneAccount", e); 1019 } 1020 } 1021 1022 /** 1023 * Remove all Accounts that belong to the calling package from the system. 1024 * @hide 1025 */ 1026 @SystemApi 1027 @SuppressLint("Doclava125") 1028 public void clearPhoneAccounts() { 1029 clearAccounts(); 1030 } 1031 /** 1032 * Remove all Accounts that belong to the calling package from the system. 1033 * @deprecated Use {@link #clearPhoneAccounts()} instead. 1034 * @hide 1035 */ 1036 @SystemApi 1037 @SuppressLint("Doclava125") 1038 public void clearAccounts() { 1039 try { 1040 if (isServiceConnected()) { 1041 getTelecomService().clearAccounts(mContext.getPackageName()); 1042 } 1043 } catch (RemoteException e) { 1044 Log.e(TAG, "Error calling ITelecomService#clearAccounts", e); 1045 } 1046 } 1047 1048 /** 1049 * Remove all Accounts that belong to the specified package from the system. 1050 * @hide 1051 */ 1052 public void clearAccountsForPackage(String packageName) { 1053 try { 1054 if (isServiceConnected() && !TextUtils.isEmpty(packageName)) { 1055 getTelecomService().clearAccounts(packageName); 1056 } 1057 } catch (RemoteException e) { 1058 Log.e(TAG, "Error calling ITelecomService#clearAccountsForPackage", e); 1059 } 1060 } 1061 1062 1063 /** 1064 * @deprecated - Use {@link TelecomManager#getDefaultDialerPackage} to directly access 1065 * the default dialer's package name instead. 1066 * @hide 1067 */ 1068 @SystemApi 1069 @SuppressLint("Doclava125") 1070 public ComponentName getDefaultPhoneApp() { 1071 try { 1072 if (isServiceConnected()) { 1073 return getTelecomService().getDefaultPhoneApp(); 1074 } 1075 } catch (RemoteException e) { 1076 Log.e(TAG, "RemoteException attempting to get the default phone app.", e); 1077 } 1078 return null; 1079 } 1080 1081 /** 1082 * Used to determine the currently selected default dialer package. 1083 * 1084 * @return package name for the default dialer package or null if no package has been 1085 * selected as the default dialer. 1086 */ 1087 public String getDefaultDialerPackage() { 1088 try { 1089 if (isServiceConnected()) { 1090 return getTelecomService().getDefaultDialerPackage(); 1091 } 1092 } catch (RemoteException e) { 1093 Log.e(TAG, "RemoteException attempting to get the default dialer package name.", e); 1094 } 1095 return null; 1096 } 1097 1098 /** 1099 * Used to set the default dialer package. 1100 * 1101 * @param packageName to set the default dialer to.. 1102 * 1103 * @result {@code true} if the default dialer was successfully changed, {@code false} if 1104 * the specified package does not correspond to an installed dialer, or is already 1105 * the default dialer. 1106 * 1107 * Requires permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE} 1108 * Requires permission: {@link android.Manifest.permission#WRITE_SECURE_SETTINGS} 1109 * 1110 * @hide 1111 */ 1112 public boolean setDefaultDialer(String packageName) { 1113 try { 1114 if (isServiceConnected()) { 1115 return getTelecomService().setDefaultDialer(packageName); 1116 } 1117 } catch (RemoteException e) { 1118 Log.e(TAG, "RemoteException attempting to set the default dialer.", e); 1119 } 1120 return false; 1121 } 1122 1123 /** 1124 * Used to determine the dialer package that is preloaded on the system partition. 1125 * 1126 * @return package name for the system dialer package or null if no system dialer is preloaded. 1127 * @hide 1128 */ 1129 public String getSystemDialerPackage() { 1130 try { 1131 if (isServiceConnected()) { 1132 return getTelecomService().getSystemDialerPackage(); 1133 } 1134 } catch (RemoteException e) { 1135 Log.e(TAG, "RemoteException attempting to get the system dialer package name.", e); 1136 } 1137 return null; 1138 } 1139 1140 /** 1141 * Return whether a given phone number is the configured voicemail number for a 1142 * particular phone account. 1143 * 1144 * Requires permission: {@link android.Manifest.permission#READ_PHONE_STATE} 1145 * 1146 * @param accountHandle The handle for the account to check the voicemail number against 1147 * @param number The number to look up. 1148 */ 1149 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) 1150 public boolean isVoiceMailNumber(PhoneAccountHandle accountHandle, String number) { 1151 try { 1152 if (isServiceConnected()) { 1153 return getTelecomService().isVoiceMailNumber(accountHandle, number, 1154 mContext.getOpPackageName()); 1155 } 1156 } catch (RemoteException e) { 1157 Log.e(TAG, "RemoteException calling ITelecomService#isVoiceMailNumber.", e); 1158 } 1159 return false; 1160 } 1161 1162 /** 1163 * Return the voicemail number for a given phone account. 1164 * 1165 * Requires permission: {@link android.Manifest.permission#READ_PHONE_STATE} 1166 * 1167 * @param accountHandle The handle for the phone account. 1168 * @return The voicemail number for the phone account, and {@code null} if one has not been 1169 * configured. 1170 */ 1171 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) 1172 public String getVoiceMailNumber(PhoneAccountHandle accountHandle) { 1173 try { 1174 if (isServiceConnected()) { 1175 return getTelecomService().getVoiceMailNumber(accountHandle, 1176 mContext.getOpPackageName()); 1177 } 1178 } catch (RemoteException e) { 1179 Log.e(TAG, "RemoteException calling ITelecomService#hasVoiceMailNumber.", e); 1180 } 1181 return null; 1182 } 1183 1184 /** 1185 * Return the line 1 phone number for given phone account. 1186 * 1187 * Requires permission: {@link android.Manifest.permission#READ_PHONE_STATE} 1188 * 1189 * @param accountHandle The handle for the account retrieve a number for. 1190 * @return A string representation of the line 1 phone number. 1191 */ 1192 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) 1193 public String getLine1Number(PhoneAccountHandle accountHandle) { 1194 try { 1195 if (isServiceConnected()) { 1196 return getTelecomService().getLine1Number(accountHandle, 1197 mContext.getOpPackageName()); 1198 } 1199 } catch (RemoteException e) { 1200 Log.e(TAG, "RemoteException calling ITelecomService#getLine1Number.", e); 1201 } 1202 return null; 1203 } 1204 1205 /** 1206 * Returns whether there is an ongoing phone call (can be in dialing, ringing, active or holding 1207 * states) originating from either a manager or self-managed {@link ConnectionService}. 1208 * <p> 1209 * Requires permission: {@link android.Manifest.permission#READ_PHONE_STATE} 1210 * 1211 * @return {@code true} if there is an ongoing call in either a managed or self-managed 1212 * {@link ConnectionService}, {@code false} otherwise. 1213 */ 1214 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) 1215 public boolean isInCall() { 1216 try { 1217 if (isServiceConnected()) { 1218 return getTelecomService().isInCall(mContext.getOpPackageName()); 1219 } 1220 } catch (RemoteException e) { 1221 Log.e(TAG, "RemoteException calling isInCall().", e); 1222 } 1223 return false; 1224 } 1225 1226 /** 1227 * Returns whether there is an ongoing call originating from a managed 1228 * {@link ConnectionService}. An ongoing call can be in dialing, ringing, active or holding 1229 * states. 1230 * <p> 1231 * If you also need to know if there are ongoing self-managed calls, use {@link #isInCall()} 1232 * instead. 1233 * <p> 1234 * Requires permission: {@link android.Manifest.permission#READ_PHONE_STATE} 1235 * 1236 * @return {@code true} if there is an ongoing call in a managed {@link ConnectionService}, 1237 * {@code false} otherwise. 1238 */ 1239 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) 1240 public boolean isInManagedCall() { 1241 try { 1242 if (isServiceConnected()) { 1243 return getTelecomService().isInManagedCall(mContext.getOpPackageName()); 1244 } 1245 } catch (RemoteException e) { 1246 Log.e(TAG, "RemoteException calling isInManagedCall().", e); 1247 } 1248 return false; 1249 } 1250 1251 /** 1252 * Returns one of the following constants that represents the current state of Telecom: 1253 * 1254 * {@link TelephonyManager#CALL_STATE_RINGING} 1255 * {@link TelephonyManager#CALL_STATE_OFFHOOK} 1256 * {@link TelephonyManager#CALL_STATE_IDLE} 1257 * 1258 * Note that this API does not require the 1259 * {@link android.Manifest.permission#READ_PHONE_STATE} permission. This is intentional, to 1260 * preserve the behavior of {@link TelephonyManager#getCallState()}, which also did not require 1261 * the permission. 1262 * 1263 * Takes into consideration both managed and self-managed calls. 1264 * 1265 * @hide 1266 */ 1267 @SystemApi 1268 public int getCallState() { 1269 try { 1270 if (isServiceConnected()) { 1271 return getTelecomService().getCallState(); 1272 } 1273 } catch (RemoteException e) { 1274 Log.d(TAG, "RemoteException calling getCallState().", e); 1275 } 1276 return TelephonyManager.CALL_STATE_IDLE; 1277 } 1278 1279 /** 1280 * Returns whether there currently exists is a ringing incoming-call. 1281 * 1282 * @return {@code true} if there is a managed or self-managed ringing call. 1283 * @hide 1284 */ 1285 @SystemApi 1286 @RequiresPermission(anyOf = { 1287 android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE, 1288 android.Manifest.permission.READ_PHONE_STATE 1289 }) 1290 public boolean isRinging() { 1291 try { 1292 if (isServiceConnected()) { 1293 return getTelecomService().isRinging(mContext.getOpPackageName()); 1294 } 1295 } catch (RemoteException e) { 1296 Log.e(TAG, "RemoteException attempting to get ringing state of phone app.", e); 1297 } 1298 return false; 1299 } 1300 1301 /** 1302 * Ends the foreground call on the device. 1303 * <p> 1304 * If there is a ringing call, calling this method rejects the ringing call. Otherwise the 1305 * foreground call is ended. 1306 * <p> 1307 * Requires permission {@link android.Manifest.permission#ANSWER_PHONE_CALLS}. 1308 * 1309 * @return {@code true} if there is a call which will be rejected or terminated, {@code false} 1310 * otherwise. 1311 */ 1312 @RequiresPermission(Manifest.permission.ANSWER_PHONE_CALLS) 1313 @SystemApi 1314 public boolean endCall() { 1315 try { 1316 if (isServiceConnected()) { 1317 return getTelecomService().endCall(mContext.getPackageName()); 1318 } 1319 } catch (RemoteException e) { 1320 Log.e(TAG, "Error calling ITelecomService#endCall", e); 1321 } 1322 return false; 1323 } 1324 1325 /** 1326 * If there is a ringing incoming call, this method accepts the call on behalf of the user. 1327 * 1328 * If the incoming call is a video call, the call will be answered with the same video state as 1329 * the incoming call requests. This means, for example, that an incoming call requesting 1330 * {@link VideoProfile#STATE_BIDIRECTIONAL} will be answered, accepting that state. 1331 * 1332 * Requires permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE} or 1333 * {@link android.Manifest.permission#ANSWER_PHONE_CALLS} 1334 */ 1335 //TODO: L-release - need to convert all invocation of ITelecmmService#answerRingingCall to use 1336 // this method (clockwork & gearhead). 1337 @RequiresPermission(anyOf = 1338 {Manifest.permission.ANSWER_PHONE_CALLS, Manifest.permission.MODIFY_PHONE_STATE}) 1339 public void acceptRingingCall() { 1340 try { 1341 if (isServiceConnected()) { 1342 getTelecomService().acceptRingingCall(mContext.getPackageName()); 1343 } 1344 } catch (RemoteException e) { 1345 Log.e(TAG, "Error calling ITelecomService#acceptRingingCall", e); 1346 } 1347 } 1348 1349 /** 1350 * If there is a ringing incoming call, this method accepts the call on behalf of the user, 1351 * with the specified video state. 1352 * 1353 * Requires permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE} or 1354 * {@link android.Manifest.permission#ANSWER_PHONE_CALLS} 1355 * 1356 * @param videoState The desired video state to answer the call with. 1357 */ 1358 @RequiresPermission(anyOf = 1359 {Manifest.permission.ANSWER_PHONE_CALLS, Manifest.permission.MODIFY_PHONE_STATE}) 1360 public void acceptRingingCall(int videoState) { 1361 try { 1362 if (isServiceConnected()) { 1363 getTelecomService().acceptRingingCallWithVideoState( 1364 mContext.getPackageName(), videoState); 1365 } 1366 } catch (RemoteException e) { 1367 Log.e(TAG, "Error calling ITelecomService#acceptRingingCallWithVideoState", e); 1368 } 1369 } 1370 1371 /** 1372 * Silences the ringer if a ringing call exists. 1373 * 1374 * Requires permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE} 1375 */ 1376 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) 1377 public void silenceRinger() { 1378 try { 1379 if (isServiceConnected()) { 1380 getTelecomService().silenceRinger(mContext.getOpPackageName()); 1381 } 1382 } catch (RemoteException e) { 1383 Log.e(TAG, "Error calling ITelecomService#silenceRinger", e); 1384 } 1385 } 1386 1387 /** 1388 * Returns whether TTY is supported on this device. 1389 */ 1390 @SystemApi 1391 @RequiresPermission(anyOf = { 1392 android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE, 1393 android.Manifest.permission.READ_PHONE_STATE 1394 }) 1395 public boolean isTtySupported() { 1396 try { 1397 if (isServiceConnected()) { 1398 return getTelecomService().isTtySupported(mContext.getOpPackageName()); 1399 } 1400 } catch (RemoteException e) { 1401 Log.e(TAG, "RemoteException attempting to get TTY supported state.", e); 1402 } 1403 return false; 1404 } 1405 1406 /** 1407 * Returns the current TTY mode of the device. For TTY to be on the user must enable it in 1408 * settings and have a wired headset plugged in. 1409 * Valid modes are: 1410 * - {@link TelecomManager#TTY_MODE_OFF} 1411 * - {@link TelecomManager#TTY_MODE_FULL} 1412 * - {@link TelecomManager#TTY_MODE_HCO} 1413 * - {@link TelecomManager#TTY_MODE_VCO} 1414 * @hide 1415 */ 1416 public int getCurrentTtyMode() { 1417 try { 1418 if (isServiceConnected()) { 1419 return getTelecomService().getCurrentTtyMode(mContext.getOpPackageName()); 1420 } 1421 } catch (RemoteException e) { 1422 Log.e(TAG, "RemoteException attempting to get the current TTY mode.", e); 1423 } 1424 return TTY_MODE_OFF; 1425 } 1426 1427 /** 1428 * Registers a new incoming call. A {@link ConnectionService} should invoke this method when it 1429 * has an incoming call. For managed {@link ConnectionService}s, the specified 1430 * {@link PhoneAccountHandle} must have been registered with {@link #registerPhoneAccount} and 1431 * the user must have enabled the corresponding {@link PhoneAccount}. This can be checked using 1432 * {@link #getPhoneAccount}. Self-managed {@link ConnectionService}s must have 1433 * {@link android.Manifest.permission#MANAGE_OWN_CALLS} to add a new incoming call. 1434 * <p> 1435 * The incoming call you are adding is assumed to have a video state of 1436 * {@link VideoProfile#STATE_AUDIO_ONLY}, unless the extra value 1437 * {@link #EXTRA_INCOMING_VIDEO_STATE} is specified. 1438 * <p> 1439 * Once invoked, this method will cause the system to bind to the {@link ConnectionService} 1440 * associated with the {@link PhoneAccountHandle} and request additional information about the 1441 * call (See {@link ConnectionService#onCreateIncomingConnection}) before starting the incoming 1442 * call UI. 1443 * <p> 1444 * For a managed {@link ConnectionService}, a {@link SecurityException} will be thrown if either 1445 * the {@link PhoneAccountHandle} does not correspond to a registered {@link PhoneAccount} or 1446 * the associated {@link PhoneAccount} is not currently enabled by the user. 1447 * <p> 1448 * For a self-managed {@link ConnectionService}, a {@link SecurityException} will be thrown if 1449 * the {@link PhoneAccount} has {@link PhoneAccount#CAPABILITY_SELF_MANAGED} and the calling app 1450 * does not have {@link android.Manifest.permission#MANAGE_OWN_CALLS}. 1451 * 1452 * @param phoneAccount A {@link PhoneAccountHandle} registered with 1453 * {@link #registerPhoneAccount}. 1454 * @param extras A bundle that will be passed through to 1455 * {@link ConnectionService#onCreateIncomingConnection}. 1456 */ 1457 public void addNewIncomingCall(PhoneAccountHandle phoneAccount, Bundle extras) { 1458 try { 1459 if (isServiceConnected()) { 1460 if (extras != null && extras.getBoolean(EXTRA_IS_HANDOVER) && 1461 mContext.getApplicationContext().getApplicationInfo().targetSdkVersion > 1462 Build.VERSION_CODES.O_MR1) { 1463 Log.e("TAG", "addNewIncomingCall failed. Use public api " + 1464 "acceptHandover for API > O-MR1"); 1465 // TODO add "return" after DUO team adds support for new handover API 1466 } 1467 getTelecomService().addNewIncomingCall( 1468 phoneAccount, extras == null ? new Bundle() : extras); 1469 } 1470 } catch (RemoteException e) { 1471 Log.e(TAG, "RemoteException adding a new incoming call: " + phoneAccount, e); 1472 } 1473 } 1474 1475 /** 1476 * Registers a new unknown call with Telecom. This can only be called by the system Telephony 1477 * service. This is invoked when Telephony detects a new unknown connection that was neither 1478 * a new incoming call, nor an user-initiated outgoing call. 1479 * 1480 * @param phoneAccount A {@link PhoneAccountHandle} registered with 1481 * {@link #registerPhoneAccount}. 1482 * @param extras A bundle that will be passed through to 1483 * {@link ConnectionService#onCreateIncomingConnection}. 1484 * @hide 1485 */ 1486 @SystemApi 1487 public void addNewUnknownCall(PhoneAccountHandle phoneAccount, Bundle extras) { 1488 try { 1489 if (isServiceConnected()) { 1490 getTelecomService().addNewUnknownCall( 1491 phoneAccount, extras == null ? new Bundle() : extras); 1492 } 1493 } catch (RemoteException e) { 1494 Log.e(TAG, "RemoteException adding a new unknown call: " + phoneAccount, e); 1495 } 1496 } 1497 1498 /** 1499 * Processes the specified dial string as an MMI code. 1500 * MMI codes are any sequence of characters entered into the dialpad that contain a "*" or "#". 1501 * Some of these sequences launch special behavior through handled by Telephony. 1502 * This method uses the default subscription. 1503 * <p> 1504 * Requires that the method-caller be set as the system dialer app. 1505 * </p> 1506 * 1507 * Requires permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE} 1508 * 1509 * @param dialString The digits to dial. 1510 * @return True if the digits were processed as an MMI code, false otherwise. 1511 */ 1512 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) 1513 public boolean handleMmi(String dialString) { 1514 ITelecomService service = getTelecomService(); 1515 if (service != null) { 1516 try { 1517 return service.handlePinMmi(dialString, mContext.getOpPackageName()); 1518 } catch (RemoteException e) { 1519 Log.e(TAG, "Error calling ITelecomService#handlePinMmi", e); 1520 } 1521 } 1522 return false; 1523 } 1524 1525 /** 1526 * Processes the specified dial string as an MMI code. 1527 * MMI codes are any sequence of characters entered into the dialpad that contain a "*" or "#". 1528 * Some of these sequences launch special behavior through handled by Telephony. 1529 * <p> 1530 * Requires that the method-caller be set as the system dialer app. 1531 * </p> 1532 * 1533 * Requires permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE} 1534 * 1535 * @param accountHandle The handle for the account the MMI code should apply to. 1536 * @param dialString The digits to dial. 1537 * @return True if the digits were processed as an MMI code, false otherwise. 1538 */ 1539 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) 1540 public boolean handleMmi(String dialString, PhoneAccountHandle accountHandle) { 1541 ITelecomService service = getTelecomService(); 1542 if (service != null) { 1543 try { 1544 return service.handlePinMmiForPhoneAccount(accountHandle, dialString, 1545 mContext.getOpPackageName()); 1546 } catch (RemoteException e) { 1547 Log.e(TAG, "Error calling ITelecomService#handlePinMmi", e); 1548 } 1549 } 1550 return false; 1551 } 1552 1553 /** 1554 * Requires permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE} 1555 * 1556 * @param accountHandle The handle for the account to derive an adn query URI for or 1557 * {@code null} to return a URI which will use the default account. 1558 * @return The URI (with the content:// scheme) specific to the specified {@link PhoneAccount} 1559 * for the the content retrieve. 1560 */ 1561 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) 1562 public Uri getAdnUriForPhoneAccount(PhoneAccountHandle accountHandle) { 1563 ITelecomService service = getTelecomService(); 1564 if (service != null && accountHandle != null) { 1565 try { 1566 return service.getAdnUriForPhoneAccount(accountHandle, mContext.getOpPackageName()); 1567 } catch (RemoteException e) { 1568 Log.e(TAG, "Error calling ITelecomService#getAdnUriForPhoneAccount", e); 1569 } 1570 } 1571 return Uri.parse("content://icc/adn"); 1572 } 1573 1574 /** 1575 * Removes the missed-call notification if one is present. 1576 * <p> 1577 * Requires that the method-caller be set as the system dialer app. 1578 * </p> 1579 * 1580 * Requires permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE} 1581 */ 1582 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) 1583 public void cancelMissedCallsNotification() { 1584 ITelecomService service = getTelecomService(); 1585 if (service != null) { 1586 try { 1587 service.cancelMissedCallsNotification(mContext.getOpPackageName()); 1588 } catch (RemoteException e) { 1589 Log.e(TAG, "Error calling ITelecomService#cancelMissedCallsNotification", e); 1590 } 1591 } 1592 } 1593 1594 /** 1595 * Brings the in-call screen to the foreground if there is an ongoing call. If there is 1596 * currently no ongoing call, then this method does nothing. 1597 * <p> 1598 * Requires that the method-caller be set as the system dialer app or have the 1599 * {@link android.Manifest.permission#READ_PHONE_STATE} permission. 1600 * </p> 1601 * 1602 * @param showDialpad Brings up the in-call dialpad as part of showing the in-call screen. 1603 */ 1604 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) 1605 public void showInCallScreen(boolean showDialpad) { 1606 ITelecomService service = getTelecomService(); 1607 if (service != null) { 1608 try { 1609 service.showInCallScreen(showDialpad, mContext.getOpPackageName()); 1610 } catch (RemoteException e) { 1611 Log.e(TAG, "Error calling ITelecomService#showCallScreen", e); 1612 } 1613 } 1614 } 1615 1616 /** 1617 * Places a new outgoing call to the provided address using the system telecom service with 1618 * the specified extras. 1619 * 1620 * This method is equivalent to placing an outgoing call using {@link Intent#ACTION_CALL}, 1621 * except that the outgoing call will always be sent via the system telecom service. If 1622 * method-caller is either the user selected default dialer app or preloaded system dialer 1623 * app, then emergency calls will also be allowed. 1624 * 1625 * Placing a call via a managed {@link ConnectionService} requires permission: 1626 * {@link android.Manifest.permission#CALL_PHONE} 1627 * 1628 * Usage example: 1629 * <pre> 1630 * Uri uri = Uri.fromParts("tel", "12345", null); 1631 * Bundle extras = new Bundle(); 1632 * extras.putBoolean(TelecomManager.EXTRA_START_CALL_WITH_SPEAKERPHONE, true); 1633 * telecomManager.placeCall(uri, extras); 1634 * </pre> 1635 * 1636 * The following keys are supported in the supplied extras. 1637 * <ul> 1638 * <li>{@link #EXTRA_OUTGOING_CALL_EXTRAS}</li> 1639 * <li>{@link #EXTRA_PHONE_ACCOUNT_HANDLE}</li> 1640 * <li>{@link #EXTRA_START_CALL_WITH_SPEAKERPHONE}</li> 1641 * <li>{@link #EXTRA_START_CALL_WITH_VIDEO_STATE}</li> 1642 * </ul> 1643 * <p> 1644 * An app which implements the self-managed {@link ConnectionService} API uses 1645 * {@link #placeCall(Uri, Bundle)} to inform Telecom of a new outgoing call. A self-managed 1646 * {@link ConnectionService} must include {@link #EXTRA_PHONE_ACCOUNT_HANDLE} to specify its 1647 * associated {@link android.telecom.PhoneAccountHandle}. 1648 * 1649 * Self-managed {@link ConnectionService}s require permission 1650 * {@link android.Manifest.permission#MANAGE_OWN_CALLS}. 1651 * 1652 * @param address The address to make the call to. 1653 * @param extras Bundle of extras to use with the call. 1654 */ 1655 @RequiresPermission(anyOf = {android.Manifest.permission.CALL_PHONE, 1656 android.Manifest.permission.MANAGE_OWN_CALLS}) 1657 public void placeCall(Uri address, Bundle extras) { 1658 ITelecomService service = getTelecomService(); 1659 if (service != null) { 1660 if (address == null) { 1661 Log.w(TAG, "Cannot place call to empty address."); 1662 } 1663 try { 1664 service.placeCall(address, extras == null ? new Bundle() : extras, 1665 mContext.getOpPackageName()); 1666 } catch (RemoteException e) { 1667 Log.e(TAG, "Error calling ITelecomService#placeCall", e); 1668 } 1669 } 1670 } 1671 1672 /** 1673 * Enables and disables specified phone account. 1674 * 1675 * @param handle Handle to the phone account. 1676 * @param isEnabled Enable state of the phone account. 1677 * @hide 1678 */ 1679 @SystemApi 1680 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) 1681 public void enablePhoneAccount(PhoneAccountHandle handle, boolean isEnabled) { 1682 ITelecomService service = getTelecomService(); 1683 if (service != null) { 1684 try { 1685 service.enablePhoneAccount(handle, isEnabled); 1686 } catch (RemoteException e) { 1687 Log.e(TAG, "Error enablePhoneAbbount", e); 1688 } 1689 } 1690 } 1691 1692 /** 1693 * Dumps telecom analytics for uploading. 1694 * 1695 * @return 1696 * @hide 1697 */ 1698 @SystemApi 1699 @RequiresPermission(Manifest.permission.DUMP) 1700 public TelecomAnalytics dumpAnalytics() { 1701 ITelecomService service = getTelecomService(); 1702 TelecomAnalytics result = null; 1703 if (service != null) { 1704 try { 1705 result = service.dumpCallAnalytics(); 1706 } catch (RemoteException e) { 1707 Log.e(TAG, "Error dumping call analytics", e); 1708 } 1709 } 1710 return result; 1711 } 1712 1713 /** 1714 * Creates the {@link Intent} which can be used with {@link Context#startActivity(Intent)} to 1715 * launch the activity to manage blocked numbers. 1716 * <p> The activity will display the UI to manage blocked numbers only if 1717 * {@link android.provider.BlockedNumberContract#canCurrentUserBlockNumbers(Context)} returns 1718 * {@code true} for the current user. 1719 */ 1720 public Intent createManageBlockedNumbersIntent() { 1721 ITelecomService service = getTelecomService(); 1722 Intent result = null; 1723 if (service != null) { 1724 try { 1725 result = service.createManageBlockedNumbersIntent(); 1726 } catch (RemoteException e) { 1727 Log.e(TAG, "Error calling ITelecomService#createManageBlockedNumbersIntent", e); 1728 } 1729 } 1730 return result; 1731 } 1732 1733 /** 1734 * Determines whether Telecom would permit an incoming call to be added via the 1735 * {@link #addNewIncomingCall(PhoneAccountHandle, Bundle)} API for the specified 1736 * {@link PhoneAccountHandle}. 1737 * <p> 1738 * A {@link ConnectionService} may not add a call for the specified {@link PhoneAccountHandle} 1739 * in the following situations: 1740 * <ul> 1741 * <li>{@link PhoneAccount} does not have property 1742 * {@link PhoneAccount#CAPABILITY_SELF_MANAGED} set (i.e. it is a managed 1743 * {@link ConnectionService}), and the active or held call limit has 1744 * been reached.</li> 1745 * <li>There is an ongoing emergency call.</li> 1746 * </ul> 1747 * 1748 * @param phoneAccountHandle The {@link PhoneAccountHandle} the call will be added for. 1749 * @return {@code true} if telecom will permit an incoming call to be added, {@code false} 1750 * otherwise. 1751 */ 1752 public boolean isIncomingCallPermitted(PhoneAccountHandle phoneAccountHandle) { 1753 if (phoneAccountHandle == null) { 1754 return false; 1755 } 1756 1757 ITelecomService service = getTelecomService(); 1758 if (service != null) { 1759 try { 1760 return service.isIncomingCallPermitted(phoneAccountHandle); 1761 } catch (RemoteException e) { 1762 Log.e(TAG, "Error isIncomingCallPermitted", e); 1763 } 1764 } 1765 return false; 1766 } 1767 1768 /** 1769 * Determines whether Telecom would permit an outgoing call to be placed via the 1770 * {@link #placeCall(Uri, Bundle)} API for the specified {@link PhoneAccountHandle}. 1771 * <p> 1772 * A {@link ConnectionService} may not place a call for the specified {@link PhoneAccountHandle} 1773 * in the following situations: 1774 * <ul> 1775 * <li>{@link PhoneAccount} does not have property 1776 * {@link PhoneAccount#CAPABILITY_SELF_MANAGED} set (i.e. it is a managed 1777 * {@link ConnectionService}), and the active, held or ringing call limit has 1778 * been reached.</li> 1779 * <li>{@link PhoneAccount} has property {@link PhoneAccount#CAPABILITY_SELF_MANAGED} set 1780 * (i.e. it is a self-managed {@link ConnectionService} and there is an ongoing call in 1781 * another {@link ConnectionService}.</li> 1782 * <li>There is an ongoing emergency call.</li> 1783 * </ul> 1784 * 1785 * @param phoneAccountHandle The {@link PhoneAccountHandle} the call will be added for. 1786 * @return {@code true} if telecom will permit an outgoing call to be placed, {@code false} 1787 * otherwise. 1788 */ 1789 public boolean isOutgoingCallPermitted(PhoneAccountHandle phoneAccountHandle) { 1790 ITelecomService service = getTelecomService(); 1791 if (service != null) { 1792 try { 1793 return service.isOutgoingCallPermitted(phoneAccountHandle); 1794 } catch (RemoteException e) { 1795 Log.e(TAG, "Error isOutgoingCallPermitted", e); 1796 } 1797 } 1798 return false; 1799 } 1800 1801 /** 1802 * Called by an app to indicate that it wishes to accept the handover of an ongoing call to a 1803 * {@link PhoneAccountHandle} it defines. 1804 * <p> 1805 * A call handover is the process where an ongoing call is transferred from one app (i.e. 1806 * {@link ConnectionService} to another app. The user could, for example, choose to continue a 1807 * mobile network call in a video calling app. The mobile network call via the Telephony stack 1808 * is referred to as the source of the handover, and the video calling app is referred to as the 1809 * destination. 1810 * <p> 1811 * When considering a handover scenario the <em>initiating</em> device is where a user initiated 1812 * the handover process (e.g. by calling {@link android.telecom.Call#handoverTo( 1813 * PhoneAccountHandle, int, Bundle)}, and the other device is considered the <em>receiving</em> 1814 * device. 1815 * <p> 1816 * For a full discussion of the handover process and the APIs involved, see 1817 * {@link android.telecom.Call#handoverTo(PhoneAccountHandle, int, Bundle)}. 1818 * <p> 1819 * This method is called from the <em>receiving</em> side of a handover to indicate a desire to 1820 * accept the handover of an ongoing call to another {@link ConnectionService} identified by 1821 * {@link PhoneAccountHandle} destAcct. For managed {@link ConnectionService}s, the specified 1822 * {@link PhoneAccountHandle} must have been registered with {@link #registerPhoneAccount} and 1823 * the user must have enabled the corresponding {@link PhoneAccount}. This can be checked using 1824 * {@link #getPhoneAccount}. Self-managed {@link ConnectionService}s must have 1825 * {@link android.Manifest.permission#MANAGE_OWN_CALLS} to handover a call to it. 1826 * <p> 1827 * Once invoked, this method will cause the system to bind to the {@link ConnectionService} 1828 * associated with the {@link PhoneAccountHandle} destAcct and call 1829 * (See {@link ConnectionService#onCreateIncomingHandoverConnection}). 1830 * <p> 1831 * For a managed {@link ConnectionService}, a {@link SecurityException} will be thrown if either 1832 * the {@link PhoneAccountHandle} destAcct does not correspond to a registered 1833 * {@link PhoneAccount} or the associated {@link PhoneAccount} is not currently enabled by the 1834 * user. 1835 * <p> 1836 * For a self-managed {@link ConnectionService}, a {@link SecurityException} will be thrown if 1837 * the calling app does not have {@link android.Manifest.permission#MANAGE_OWN_CALLS}. 1838 * 1839 * @param srcAddr The {@link android.net.Uri} of the ongoing call to handover to the callers 1840 * {@link ConnectionService}. 1841 * @param videoState Video state after the handover. 1842 * @param destAcct The {@link PhoneAccountHandle} registered to the calling package. 1843 */ 1844 public void acceptHandover(Uri srcAddr, @VideoProfile.VideoState int videoState, 1845 PhoneAccountHandle destAcct) { 1846 try { 1847 if (isServiceConnected()) { 1848 getTelecomService().acceptHandover(srcAddr, videoState, destAcct); 1849 } 1850 } catch (RemoteException e) { 1851 Log.e(TAG, "RemoteException acceptHandover: " + e); 1852 } 1853 } 1854 1855 private ITelecomService getTelecomService() { 1856 if (mTelecomServiceOverride != null) { 1857 return mTelecomServiceOverride; 1858 } 1859 return ITelecomService.Stub.asInterface(ServiceManager.getService(Context.TELECOM_SERVICE)); 1860 } 1861 1862 private boolean isServiceConnected() { 1863 boolean isConnected = getTelecomService() != null; 1864 if (!isConnected) { 1865 Log.w(TAG, "Telecom Service not found."); 1866 } 1867 return isConnected; 1868 } 1869 } 1870
