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