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 */ 352 public static final String METADATA_INCLUDE_EXTERNAL_CALLS = 353 "android.telecom.INCLUDE_EXTERNAL_CALLS"; 354 355 /** 356 * The dual tone multi-frequency signaling character sent to indicate the dialing system should 357 * pause for a predefined period. 358 */ 359 public static final char DTMF_CHARACTER_PAUSE = ','; 360 361 /** 362 * The dual-tone multi-frequency signaling character sent to indicate the dialing system should 363 * wait for user confirmation before proceeding. 364 */ 365 public static final char DTMF_CHARACTER_WAIT = ';'; 366 367 /** 368 * TTY (teletypewriter) mode is off. 369 * 370 * @hide 371 */ 372 public static final int TTY_MODE_OFF = 0; 373 374 /** 375 * TTY (teletypewriter) mode is on. The speaker is off and the microphone is muted. The user 376 * will communicate with the remote party by sending and receiving text messages. 377 * 378 * @hide 379 */ 380 public static final int TTY_MODE_FULL = 1; 381 382 /** 383 * TTY (teletypewriter) mode is in hearing carryover mode (HCO). The microphone is muted but the 384 * speaker is on. The user will communicate with the remote party by sending text messages and 385 * hearing an audible reply. 386 * 387 * @hide 388 */ 389 public static final int TTY_MODE_HCO = 2; 390 391 /** 392 * TTY (teletypewriter) mode is in voice carryover mode (VCO). The speaker is off but the 393 * microphone is still on. User will communicate with the remote party by speaking and receiving 394 * text message replies. 395 * 396 * @hide 397 */ 398 public static final int TTY_MODE_VCO = 3; 399 400 /** 401 * Broadcast intent action indicating that the current TTY mode has changed. An intent extra 402 * provides this state as an int. 403 * 404 * @see #EXTRA_CURRENT_TTY_MODE 405 * @hide 406 */ 407 public static final String ACTION_CURRENT_TTY_MODE_CHANGED = 408 "android.telecom.action.CURRENT_TTY_MODE_CHANGED"; 409 410 /** 411 * The lookup key for an int that indicates the current TTY mode. 412 * Valid modes are: 413 * - {@link #TTY_MODE_OFF} 414 * - {@link #TTY_MODE_FULL} 415 * - {@link #TTY_MODE_HCO} 416 * - {@link #TTY_MODE_VCO} 417 * 418 * @hide 419 */ 420 public static final String EXTRA_CURRENT_TTY_MODE = 421 "android.telecom.intent.extra.CURRENT_TTY_MODE"; 422 423 /** 424 * Broadcast intent action indicating that the TTY preferred operating mode has changed. An 425 * intent extra provides the new mode as an int. 426 * 427 * @see #EXTRA_TTY_PREFERRED_MODE 428 * @hide 429 */ 430 public static final String ACTION_TTY_PREFERRED_MODE_CHANGED = 431 "android.telecom.action.TTY_PREFERRED_MODE_CHANGED"; 432 433 /** 434 * The lookup key for an int that indicates preferred TTY mode. Valid modes are: - 435 * {@link #TTY_MODE_OFF} - {@link #TTY_MODE_FULL} - {@link #TTY_MODE_HCO} - 436 * {@link #TTY_MODE_VCO} 437 * 438 * @hide 439 */ 440 public static final String EXTRA_TTY_PREFERRED_MODE = 441 "android.telecom.intent.extra.TTY_PREFERRED"; 442 443 /** 444 * Broadcast intent action for letting custom component know to show the missed call 445 * notification. If no custom component exists then this is sent to the default dialer which 446 * should post a missed-call notification. 447 */ 448 public static final String ACTION_SHOW_MISSED_CALLS_NOTIFICATION = 449 "android.telecom.action.SHOW_MISSED_CALLS_NOTIFICATION"; 450 451 /** 452 * The number of calls associated with the notification. If the number is zero then the missed 453 * call notification should be dismissed. 454 */ 455 public static final String EXTRA_NOTIFICATION_COUNT = 456 "android.telecom.extra.NOTIFICATION_COUNT"; 457 458 /** 459 * The number associated with the missed calls. This number is only relevant 460 * when EXTRA_NOTIFICATION_COUNT is 1. 461 */ 462 public static final String EXTRA_NOTIFICATION_PHONE_NUMBER = 463 "android.telecom.extra.NOTIFICATION_PHONE_NUMBER"; 464 465 /** 466 * The intent to clear missed calls. 467 * @hide 468 */ 469 @SystemApi 470 public static final String EXTRA_CLEAR_MISSED_CALLS_INTENT = 471 "android.telecom.extra.CLEAR_MISSED_CALLS_INTENT"; 472 473 /** 474 * The intent to call back a missed call. 475 * @hide 476 */ 477 @SystemApi 478 public static final String EXTRA_CALL_BACK_INTENT = 479 "android.telecom.extra.CALL_BACK_INTENT"; 480 481 /** 482 * The following 4 constants define how properties such as phone numbers and names are 483 * displayed to the user. 484 */ 485 486 /** 487 * Indicates that the address or number of a call is allowed to be displayed for caller ID. 488 */ 489 public static final int PRESENTATION_ALLOWED = 1; 490 491 /** 492 * Indicates that the address or number of a call is blocked by the other party. 493 */ 494 public static final int PRESENTATION_RESTRICTED = 2; 495 496 /** 497 * Indicates that the address or number of a call is not specified or known by the carrier. 498 */ 499 public static final int PRESENTATION_UNKNOWN = 3; 500 501 /** 502 * Indicates that the address or number of a call belongs to a pay phone. 503 */ 504 public static final int PRESENTATION_PAYPHONE = 4; 505 506 private static final String TAG = "TelecomManager"; 507 508 private final Context mContext; 509 510 private final ITelecomService mTelecomServiceOverride; 511 512 /** 513 * @hide 514 */ 515 public static TelecomManager from(Context context) { 516 return (TelecomManager) context.getSystemService(Context.TELECOM_SERVICE); 517 } 518 519 /** 520 * @hide 521 */ 522 public TelecomManager(Context context) { 523 this(context, null); 524 } 525 526 /** 527 * @hide 528 */ 529 public TelecomManager(Context context, ITelecomService telecomServiceImpl) { 530 Context appContext = context.getApplicationContext(); 531 if (appContext != null) { 532 mContext = appContext; 533 } else { 534 mContext = context; 535 } 536 mTelecomServiceOverride = telecomServiceImpl; 537 android.telecom.Log.initMd5Sum(); 538 } 539 540 /** 541 * Return the {@link PhoneAccount} which will be used to place outgoing calls to addresses with 542 * the specified {@code uriScheme}. This {@link PhoneAccount} will always be a member of the 543 * list which is returned from invoking {@link #getCallCapablePhoneAccounts()}. The specific 544 * account returned depends on the following priorities: 545 * <ul> 546 * <li> If the user-selected default {@link PhoneAccount} supports the specified scheme, it will 547 * be returned. 548 * </li> 549 * <li> If there exists only one {@link PhoneAccount} that supports the specified scheme, it 550 * will be returned. 551 * </li> 552 * </ul> 553 * <p> 554 * If no {@link PhoneAccount} fits the criteria above, this method will return {@code null}. 555 * 556 * Requires permission: {@link android.Manifest.permission#READ_PHONE_STATE} 557 * 558 * @param uriScheme The URI scheme. 559 * @return The {@link PhoneAccountHandle} corresponding to the account to be used. 560 */ 561 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) 562 public PhoneAccountHandle getDefaultOutgoingPhoneAccount(String uriScheme) { 563 try { 564 if (isServiceConnected()) { 565 return getTelecomService().getDefaultOutgoingPhoneAccount(uriScheme, 566 mContext.getOpPackageName()); 567 } 568 } catch (RemoteException e) { 569 Log.e(TAG, "Error calling ITelecomService#getDefaultOutgoingPhoneAccount", e); 570 } 571 return null; 572 } 573 574 /** 575 * Return the {@link PhoneAccount} which is the user-chosen default for making outgoing phone 576 * calls. This {@code PhoneAccount} will always be a member of the list which is returned from 577 * calling {@link #getCallCapablePhoneAccounts()} 578 * <p> 579 * Apps must be prepared for this method to return {@code null}, indicating that there currently 580 * exists no user-chosen default {@code PhoneAccount}. 581 * 582 * @return The user outgoing phone account selected by the user. 583 * @hide 584 */ 585 public PhoneAccountHandle getUserSelectedOutgoingPhoneAccount() { 586 try { 587 if (isServiceConnected()) { 588 return getTelecomService().getUserSelectedOutgoingPhoneAccount(); 589 } 590 } catch (RemoteException e) { 591 Log.e(TAG, "Error calling ITelecomService#getUserSelectedOutgoingPhoneAccount", e); 592 } 593 return null; 594 } 595 596 /** 597 * Sets the user-chosen default for making outgoing phone calls. 598 * @hide 599 */ 600 public void setUserSelectedOutgoingPhoneAccount(PhoneAccountHandle accountHandle) { 601 try { 602 if (isServiceConnected()) { 603 getTelecomService().setUserSelectedOutgoingPhoneAccount(accountHandle); 604 } 605 } catch (RemoteException e) { 606 Log.e(TAG, "Error calling ITelecomService#setUserSelectedOutgoingPhoneAccount"); 607 } 608 } 609 610 /** 611 * Returns the current SIM call manager. Apps must be prepared for this method to return 612 * {@code null}, indicating that there currently exists no user-chosen default 613 * {@code PhoneAccount}. 614 * 615 * @return The phone account handle of the current sim call manager. 616 */ 617 public PhoneAccountHandle getSimCallManager() { 618 try { 619 if (isServiceConnected()) { 620 return getTelecomService().getSimCallManager(); 621 } 622 } catch (RemoteException e) { 623 Log.e(TAG, "Error calling ITelecomService#getSimCallManager"); 624 } 625 return null; 626 } 627 628 /** 629 * Returns the current SIM call manager for the specified user. Apps must be prepared for this 630 * method to return {@code null}, indicating that there currently exists no user-chosen default 631 * {@code PhoneAccount}. 632 * 633 * @return The phone account handle of the current sim call manager. 634 * 635 * @hide 636 */ 637 public PhoneAccountHandle getSimCallManager(int userId) { 638 try { 639 if (isServiceConnected()) { 640 return getTelecomService().getSimCallManagerForUser(userId); 641 } 642 } catch (RemoteException e) { 643 Log.e(TAG, "Error calling ITelecomService#getSimCallManagerForUser"); 644 } 645 return null; 646 } 647 648 /** 649 * Returns the current connection manager. Apps must be prepared for this method to return 650 * {@code null}, indicating that there currently exists no user-chosen default 651 * {@code PhoneAccount}. 652 * 653 * @return The phone account handle of the current connection manager. 654 * @hide 655 */ 656 @SystemApi 657 public PhoneAccountHandle getConnectionManager() { 658 return getSimCallManager(); 659 } 660 661 /** 662 * Returns a list of the {@link PhoneAccountHandle}s which can be used to make and receive phone 663 * calls which support the specified URI scheme. 664 * <P> 665 * For example, invoking with {@code "tel"} will find all {@link PhoneAccountHandle}s which 666 * support telephone calls (e.g. URIs such as {@code tel:555-555-1212}). Invoking with 667 * {@code "sip"} will find all {@link PhoneAccountHandle}s which support SIP calls (e.g. URIs 668 * such as {@code sip:example (at) sipexample.com}). 669 * 670 * @param uriScheme The URI scheme. 671 * @return A list of {@code PhoneAccountHandle} objects supporting the URI scheme. 672 * @hide 673 */ 674 @SystemApi 675 public List<PhoneAccountHandle> getPhoneAccountsSupportingScheme(String uriScheme) { 676 try { 677 if (isServiceConnected()) { 678 return getTelecomService().getPhoneAccountsSupportingScheme(uriScheme, 679 mContext.getOpPackageName()); 680 } 681 } catch (RemoteException e) { 682 Log.e(TAG, "Error calling ITelecomService#getPhoneAccountsSupportingScheme", e); 683 } 684 return new ArrayList<>(); 685 } 686 687 688 /** 689 * Returns a list of {@link PhoneAccountHandle}s which can be used to make and receive phone 690 * calls. The returned list includes only those accounts which have been explicitly enabled 691 * by the user. 692 * 693 * Requires permission: {@link android.Manifest.permission#READ_PHONE_STATE} 694 * 695 * @see #EXTRA_PHONE_ACCOUNT_HANDLE 696 * @return A list of {@code PhoneAccountHandle} objects. 697 */ 698 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) 699 public List<PhoneAccountHandle> getCallCapablePhoneAccounts() { 700 return getCallCapablePhoneAccounts(false); 701 } 702 703 /** 704 * Returns a list of {@link PhoneAccountHandle}s including those which have not been enabled 705 * by the user. 706 * 707 * @return A list of {@code PhoneAccountHandle} objects. 708 * @hide 709 */ 710 public List<PhoneAccountHandle> getCallCapablePhoneAccounts(boolean includeDisabledAccounts) { 711 try { 712 if (isServiceConnected()) { 713 return getTelecomService().getCallCapablePhoneAccounts( 714 includeDisabledAccounts, mContext.getOpPackageName()); 715 } 716 } catch (RemoteException e) { 717 Log.e(TAG, "Error calling ITelecomService#getCallCapablePhoneAccounts(" + 718 includeDisabledAccounts + ")", e); 719 } 720 return new ArrayList<>(); 721 } 722 723 /** 724 * Returns a list of all {@link PhoneAccount}s registered for the calling package. 725 * 726 * @return A list of {@code PhoneAccountHandle} objects. 727 * @hide 728 */ 729 @SystemApi 730 public List<PhoneAccountHandle> getPhoneAccountsForPackage() { 731 try { 732 if (isServiceConnected()) { 733 return getTelecomService().getPhoneAccountsForPackage(mContext.getPackageName()); 734 } 735 } catch (RemoteException e) { 736 Log.e(TAG, "Error calling ITelecomService#getPhoneAccountsForPackage", e); 737 } 738 return null; 739 } 740 741 /** 742 * Return the {@link PhoneAccount} for a specified {@link PhoneAccountHandle}. Object includes 743 * resources which can be used in a user interface. 744 * 745 * @param account The {@link PhoneAccountHandle}. 746 * @return The {@link PhoneAccount} object. 747 */ 748 public PhoneAccount getPhoneAccount(PhoneAccountHandle account) { 749 try { 750 if (isServiceConnected()) { 751 return getTelecomService().getPhoneAccount(account); 752 } 753 } catch (RemoteException e) { 754 Log.e(TAG, "Error calling ITelecomService#getPhoneAccount", e); 755 } 756 return null; 757 } 758 759 /** 760 * Returns a count of all {@link PhoneAccount}s. 761 * 762 * @return The count of {@link PhoneAccount}s. 763 * @hide 764 */ 765 @SystemApi 766 public int getAllPhoneAccountsCount() { 767 try { 768 if (isServiceConnected()) { 769 return getTelecomService().getAllPhoneAccountsCount(); 770 } 771 } catch (RemoteException e) { 772 Log.e(TAG, "Error calling ITelecomService#getAllPhoneAccountsCount", e); 773 } 774 return 0; 775 } 776 777 /** 778 * Returns a list of all {@link PhoneAccount}s. 779 * 780 * @return All {@link PhoneAccount}s. 781 * @hide 782 */ 783 @SystemApi 784 public List<PhoneAccount> getAllPhoneAccounts() { 785 try { 786 if (isServiceConnected()) { 787 return getTelecomService().getAllPhoneAccounts(); 788 } 789 } catch (RemoteException e) { 790 Log.e(TAG, "Error calling ITelecomService#getAllPhoneAccounts", e); 791 } 792 return Collections.EMPTY_LIST; 793 } 794 795 /** 796 * Returns a list of all {@link PhoneAccountHandle}s. 797 * 798 * @return All {@link PhoneAccountHandle}s. 799 * @hide 800 */ 801 @SystemApi 802 public List<PhoneAccountHandle> getAllPhoneAccountHandles() { 803 try { 804 if (isServiceConnected()) { 805 return getTelecomService().getAllPhoneAccountHandles(); 806 } 807 } catch (RemoteException e) { 808 Log.e(TAG, "Error calling ITelecomService#getAllPhoneAccountHandles", e); 809 } 810 return Collections.EMPTY_LIST; 811 } 812 813 /** 814 * Register a {@link PhoneAccount} for use by the system that will be stored in Device Encrypted 815 * storage. When registering {@link PhoneAccount}s, existing registrations will be overwritten 816 * if the {@link PhoneAccountHandle} matches that of a {@link PhoneAccount} which is already 817 * registered. Once registered, the {@link PhoneAccount} is listed to the user as an option 818 * when placing calls. The user may still need to enable the {@link PhoneAccount} within 819 * the phone app settings before the account is usable. 820 * <p> 821 * A {@link SecurityException} will be thrown if an app tries to register a 822 * {@link PhoneAccountHandle} where the package name specified within 823 * {@link PhoneAccountHandle#getComponentName()} does not match the package name of the app. 824 * 825 * @param account The complete {@link PhoneAccount}. 826 */ 827 public void registerPhoneAccount(PhoneAccount account) { 828 try { 829 if (isServiceConnected()) { 830 getTelecomService().registerPhoneAccount(account); 831 } 832 } catch (RemoteException e) { 833 Log.e(TAG, "Error calling ITelecomService#registerPhoneAccount", e); 834 } 835 } 836 837 /** 838 * Remove a {@link PhoneAccount} registration from the system. 839 * 840 * @param accountHandle A {@link PhoneAccountHandle} for the {@link PhoneAccount} to unregister. 841 */ 842 public void unregisterPhoneAccount(PhoneAccountHandle accountHandle) { 843 try { 844 if (isServiceConnected()) { 845 getTelecomService().unregisterPhoneAccount(accountHandle); 846 } 847 } catch (RemoteException e) { 848 Log.e(TAG, "Error calling ITelecomService#unregisterPhoneAccount", e); 849 } 850 } 851 852 /** 853 * Remove all Accounts that belong to the calling package from the system. 854 * @hide 855 */ 856 @SystemApi 857 public void clearPhoneAccounts() { 858 clearAccounts(); 859 } 860 /** 861 * Remove all Accounts that belong to the calling package from the system. 862 * @deprecated Use {@link #clearPhoneAccounts()} instead. 863 * @hide 864 */ 865 @SystemApi 866 public void clearAccounts() { 867 try { 868 if (isServiceConnected()) { 869 getTelecomService().clearAccounts(mContext.getPackageName()); 870 } 871 } catch (RemoteException e) { 872 Log.e(TAG, "Error calling ITelecomService#clearAccounts", e); 873 } 874 } 875 876 /** 877 * Remove all Accounts that belong to the specified package from the system. 878 * @hide 879 */ 880 public void clearAccountsForPackage(String packageName) { 881 try { 882 if (isServiceConnected() && !TextUtils.isEmpty(packageName)) { 883 getTelecomService().clearAccounts(packageName); 884 } 885 } catch (RemoteException e) { 886 Log.e(TAG, "Error calling ITelecomService#clearAccountsForPackage", e); 887 } 888 } 889 890 891 /** 892 * @deprecated - Use {@link TelecomManager#getDefaultDialerPackage} to directly access 893 * the default dialer's package name instead. 894 * @hide 895 */ 896 @SystemApi 897 public ComponentName getDefaultPhoneApp() { 898 try { 899 if (isServiceConnected()) { 900 return getTelecomService().getDefaultPhoneApp(); 901 } 902 } catch (RemoteException e) { 903 Log.e(TAG, "RemoteException attempting to get the default phone app.", e); 904 } 905 return null; 906 } 907 908 /** 909 * Used to determine the currently selected default dialer package. 910 * 911 * @return package name for the default dialer package or null if no package has been 912 * selected as the default dialer. 913 */ 914 public String getDefaultDialerPackage() { 915 try { 916 if (isServiceConnected()) { 917 return getTelecomService().getDefaultDialerPackage(); 918 } 919 } catch (RemoteException e) { 920 Log.e(TAG, "RemoteException attempting to get the default dialer package name.", e); 921 } 922 return null; 923 } 924 925 /** 926 * Used to set the default dialer package. 927 * 928 * @param packageName to set the default dialer to.. 929 * 930 * @result {@code true} if the default dialer was successfully changed, {@code false} if 931 * the specified package does not correspond to an installed dialer, or is already 932 * the default dialer. 933 * 934 * Requires permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE} 935 * Requires permission: {@link android.Manifest.permission#WRITE_SECURE_SETTINGS} 936 * 937 * @hide 938 */ 939 public boolean setDefaultDialer(String packageName) { 940 try { 941 if (isServiceConnected()) { 942 return getTelecomService().setDefaultDialer(packageName); 943 } 944 } catch (RemoteException e) { 945 Log.e(TAG, "RemoteException attempting to set the default dialer.", e); 946 } 947 return false; 948 } 949 950 /** 951 * Used to determine the dialer package that is preloaded on the system partition. 952 * 953 * @return package name for the system dialer package or null if no system dialer is preloaded. 954 * @hide 955 */ 956 public String getSystemDialerPackage() { 957 try { 958 if (isServiceConnected()) { 959 return getTelecomService().getSystemDialerPackage(); 960 } 961 } catch (RemoteException e) { 962 Log.e(TAG, "RemoteException attempting to get the system dialer package name.", e); 963 } 964 return null; 965 } 966 967 /** 968 * Return whether a given phone number is the configured voicemail number for a 969 * particular phone account. 970 * 971 * Requires permission: {@link android.Manifest.permission#READ_PHONE_STATE} 972 * 973 * @param accountHandle The handle for the account to check the voicemail number against 974 * @param number The number to look up. 975 */ 976 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) 977 public boolean isVoiceMailNumber(PhoneAccountHandle accountHandle, String number) { 978 try { 979 if (isServiceConnected()) { 980 return getTelecomService().isVoiceMailNumber(accountHandle, number, 981 mContext.getOpPackageName()); 982 } 983 } catch (RemoteException e) { 984 Log.e(TAG, "RemoteException calling ITelecomService#isVoiceMailNumber.", e); 985 } 986 return false; 987 } 988 989 /** 990 * Return the voicemail number for a given phone account. 991 * 992 * Requires permission: {@link android.Manifest.permission#READ_PHONE_STATE} 993 * 994 * @param accountHandle The handle for the phone account. 995 * @return The voicemail number for the phone account, and {@code null} if one has not been 996 * configured. 997 */ 998 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) 999 public String getVoiceMailNumber(PhoneAccountHandle accountHandle) { 1000 try { 1001 if (isServiceConnected()) { 1002 return getTelecomService().getVoiceMailNumber(accountHandle, 1003 mContext.getOpPackageName()); 1004 } 1005 } catch (RemoteException e) { 1006 Log.e(TAG, "RemoteException calling ITelecomService#hasVoiceMailNumber.", e); 1007 } 1008 return null; 1009 } 1010 1011 /** 1012 * Return the line 1 phone number for given phone account. 1013 * 1014 * Requires permission: {@link android.Manifest.permission#READ_PHONE_STATE} 1015 * 1016 * @param accountHandle The handle for the account retrieve a number for. 1017 * @return A string representation of the line 1 phone number. 1018 */ 1019 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) 1020 public String getLine1Number(PhoneAccountHandle accountHandle) { 1021 try { 1022 if (isServiceConnected()) { 1023 return getTelecomService().getLine1Number(accountHandle, 1024 mContext.getOpPackageName()); 1025 } 1026 } catch (RemoteException e) { 1027 Log.e(TAG, "RemoteException calling ITelecomService#getLine1Number.", e); 1028 } 1029 return null; 1030 } 1031 1032 /** 1033 * Returns whether there is an ongoing phone call (can be in dialing, ringing, active or holding 1034 * states). 1035 * <p> 1036 * Requires permission: {@link android.Manifest.permission#READ_PHONE_STATE} 1037 * </p> 1038 */ 1039 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) 1040 public boolean isInCall() { 1041 try { 1042 if (isServiceConnected()) { 1043 return getTelecomService().isInCall(mContext.getOpPackageName()); 1044 } 1045 } catch (RemoteException e) { 1046 Log.e(TAG, "RemoteException calling isInCall().", e); 1047 } 1048 return false; 1049 } 1050 1051 /** 1052 * Returns one of the following constants that represents the current state of Telecom: 1053 * 1054 * {@link TelephonyManager#CALL_STATE_RINGING} 1055 * {@link TelephonyManager#CALL_STATE_OFFHOOK} 1056 * {@link TelephonyManager#CALL_STATE_IDLE} 1057 * 1058 * Note that this API does not require the 1059 * {@link android.Manifest.permission#READ_PHONE_STATE} permission. This is intentional, to 1060 * preserve the behavior of {@link TelephonyManager#getCallState()}, which also did not require 1061 * the permission. 1062 * @hide 1063 */ 1064 @SystemApi 1065 public int getCallState() { 1066 try { 1067 if (isServiceConnected()) { 1068 return getTelecomService().getCallState(); 1069 } 1070 } catch (RemoteException e) { 1071 Log.d(TAG, "RemoteException calling getCallState().", e); 1072 } 1073 return TelephonyManager.CALL_STATE_IDLE; 1074 } 1075 1076 /** 1077 * Returns whether there currently exists is a ringing incoming-call. 1078 * 1079 * @hide 1080 */ 1081 @SystemApi 1082 public boolean isRinging() { 1083 try { 1084 if (isServiceConnected()) { 1085 return getTelecomService().isRinging(mContext.getOpPackageName()); 1086 } 1087 } catch (RemoteException e) { 1088 Log.e(TAG, "RemoteException attempting to get ringing state of phone app.", e); 1089 } 1090 return false; 1091 } 1092 1093 /** 1094 * Ends an ongoing call. 1095 * TODO: L-release - need to convert all invocations of ITelecomService#endCall to use this 1096 * method (clockwork & gearhead). 1097 * @hide 1098 */ 1099 @SystemApi 1100 public boolean endCall() { 1101 try { 1102 if (isServiceConnected()) { 1103 return getTelecomService().endCall(); 1104 } 1105 } catch (RemoteException e) { 1106 Log.e(TAG, "Error calling ITelecomService#endCall", e); 1107 } 1108 return false; 1109 } 1110 1111 /** 1112 * If there is a ringing incoming call, this method accepts the call on behalf of the user. 1113 * TODO: L-release - need to convert all invocation of ITelecmmService#answerRingingCall to use 1114 * this method (clockwork & gearhead). 1115 * If the incoming call is a video call, the call will be answered with the same video state as 1116 * the incoming call requests. This means, for example, that an incoming call requesting 1117 * {@link VideoProfile#STATE_BIDIRECTIONAL} will be answered, accepting that state. 1118 * @hide 1119 */ 1120 @SystemApi 1121 public void acceptRingingCall() { 1122 try { 1123 if (isServiceConnected()) { 1124 getTelecomService().acceptRingingCall(); 1125 } 1126 } catch (RemoteException e) { 1127 Log.e(TAG, "Error calling ITelecomService#acceptRingingCall", e); 1128 } 1129 } 1130 1131 /** 1132 * If there is a ringing incoming call, this method accepts the call on behalf of the user, 1133 * with the specified video state. 1134 * 1135 * @param videoState The desired video state to answer the call with. 1136 * @hide 1137 */ 1138 @SystemApi 1139 public void acceptRingingCall(int videoState) { 1140 try { 1141 if (isServiceConnected()) { 1142 getTelecomService().acceptRingingCallWithVideoState(videoState); 1143 } 1144 } catch (RemoteException e) { 1145 Log.e(TAG, "Error calling ITelecomService#acceptRingingCallWithVideoState", e); 1146 } 1147 } 1148 1149 /** 1150 * Silences the ringer if a ringing call exists. 1151 * 1152 * Requires permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE} 1153 */ 1154 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) 1155 public void silenceRinger() { 1156 try { 1157 if (isServiceConnected()) { 1158 getTelecomService().silenceRinger(mContext.getOpPackageName()); 1159 } 1160 } catch (RemoteException e) { 1161 Log.e(TAG, "Error calling ITelecomService#silenceRinger", e); 1162 } 1163 } 1164 1165 /** 1166 * Returns whether TTY is supported on this device. 1167 * 1168 * @hide 1169 */ 1170 @SystemApi 1171 public boolean isTtySupported() { 1172 try { 1173 if (isServiceConnected()) { 1174 return getTelecomService().isTtySupported(mContext.getOpPackageName()); 1175 } 1176 } catch (RemoteException e) { 1177 Log.e(TAG, "RemoteException attempting to get TTY supported state.", e); 1178 } 1179 return false; 1180 } 1181 1182 /** 1183 * Returns the current TTY mode of the device. For TTY to be on the user must enable it in 1184 * settings and have a wired headset plugged in. 1185 * Valid modes are: 1186 * - {@link TelecomManager#TTY_MODE_OFF} 1187 * - {@link TelecomManager#TTY_MODE_FULL} 1188 * - {@link TelecomManager#TTY_MODE_HCO} 1189 * - {@link TelecomManager#TTY_MODE_VCO} 1190 * @hide 1191 */ 1192 public int getCurrentTtyMode() { 1193 try { 1194 if (isServiceConnected()) { 1195 return getTelecomService().getCurrentTtyMode(mContext.getOpPackageName()); 1196 } 1197 } catch (RemoteException e) { 1198 Log.e(TAG, "RemoteException attempting to get the current TTY mode.", e); 1199 } 1200 return TTY_MODE_OFF; 1201 } 1202 1203 /** 1204 * Registers a new incoming call. A {@link ConnectionService} should invoke this method when it 1205 * has an incoming call. The specified {@link PhoneAccountHandle} must have been registered 1206 * with {@link #registerPhoneAccount} and the user must have enabled the corresponding 1207 * {@link PhoneAccount}. This can be checked using {@link #getPhoneAccount}. Once invoked, this 1208 * method will cause the system to bind to the {@link ConnectionService} associated with the 1209 * {@link PhoneAccountHandle} and request additional information about the call 1210 * (See {@link ConnectionService#onCreateIncomingConnection}) before starting the incoming 1211 * call UI. 1212 * <p> 1213 * A {@link SecurityException} will be thrown if either the {@link PhoneAccountHandle} does not 1214 * correspond to a registered {@link PhoneAccount} or the associated {@link PhoneAccount} is not 1215 * currently enabled by the user. 1216 * @param phoneAccount A {@link PhoneAccountHandle} registered with 1217 * {@link #registerPhoneAccount}. 1218 * @param extras A bundle that will be passed through to 1219 * {@link ConnectionService#onCreateIncomingConnection}. 1220 */ 1221 public void addNewIncomingCall(PhoneAccountHandle phoneAccount, Bundle extras) { 1222 try { 1223 if (isServiceConnected()) { 1224 getTelecomService().addNewIncomingCall( 1225 phoneAccount, extras == null ? new Bundle() : extras); 1226 } 1227 } catch (RemoteException e) { 1228 Log.e(TAG, "RemoteException adding a new incoming call: " + phoneAccount, e); 1229 } 1230 } 1231 1232 /** 1233 * Registers a new unknown call with Telecom. This can only be called by the system Telephony 1234 * service. This is invoked when Telephony detects a new unknown connection that was neither 1235 * a new incoming call, nor an user-initiated outgoing call. 1236 * 1237 * @param phoneAccount A {@link PhoneAccountHandle} registered with 1238 * {@link #registerPhoneAccount}. 1239 * @param extras A bundle that will be passed through to 1240 * {@link ConnectionService#onCreateIncomingConnection}. 1241 * @hide 1242 */ 1243 @SystemApi 1244 public void addNewUnknownCall(PhoneAccountHandle phoneAccount, Bundle extras) { 1245 try { 1246 if (isServiceConnected()) { 1247 getTelecomService().addNewUnknownCall( 1248 phoneAccount, extras == null ? new Bundle() : extras); 1249 } 1250 } catch (RemoteException e) { 1251 Log.e(TAG, "RemoteException adding a new unknown call: " + phoneAccount, e); 1252 } 1253 } 1254 1255 /** 1256 * Processes the specified dial string as an MMI code. 1257 * MMI codes are any sequence of characters entered into the dialpad that contain a "*" or "#". 1258 * Some of these sequences launch special behavior through handled by Telephony. 1259 * This method uses the default subscription. 1260 * <p> 1261 * Requires that the method-caller be set as the system dialer app. 1262 * </p> 1263 * 1264 * Requires permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE} 1265 * 1266 * @param dialString The digits to dial. 1267 * @return True if the digits were processed as an MMI code, false otherwise. 1268 */ 1269 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) 1270 public boolean handleMmi(String dialString) { 1271 ITelecomService service = getTelecomService(); 1272 if (service != null) { 1273 try { 1274 return service.handlePinMmi(dialString, mContext.getOpPackageName()); 1275 } catch (RemoteException e) { 1276 Log.e(TAG, "Error calling ITelecomService#handlePinMmi", e); 1277 } 1278 } 1279 return false; 1280 } 1281 1282 /** 1283 * Processes the specified dial string as an MMI code. 1284 * MMI codes are any sequence of characters entered into the dialpad that contain a "*" or "#". 1285 * Some of these sequences launch special behavior through handled by Telephony. 1286 * <p> 1287 * Requires that the method-caller be set as the system dialer app. 1288 * </p> 1289 * 1290 * Requires permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE} 1291 * 1292 * @param accountHandle The handle for the account the MMI code should apply to. 1293 * @param dialString The digits to dial. 1294 * @return True if the digits were processed as an MMI code, false otherwise. 1295 */ 1296 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) 1297 public boolean handleMmi(String dialString, PhoneAccountHandle accountHandle) { 1298 ITelecomService service = getTelecomService(); 1299 if (service != null) { 1300 try { 1301 return service.handlePinMmiForPhoneAccount(accountHandle, dialString, 1302 mContext.getOpPackageName()); 1303 } catch (RemoteException e) { 1304 Log.e(TAG, "Error calling ITelecomService#handlePinMmi", e); 1305 } 1306 } 1307 return false; 1308 } 1309 1310 /** 1311 * Requires permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE} 1312 * 1313 * @param accountHandle The handle for the account to derive an adn query URI for or 1314 * {@code null} to return a URI which will use the default account. 1315 * @return The URI (with the content:// scheme) specific to the specified {@link PhoneAccount} 1316 * for the the content retrieve. 1317 */ 1318 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) 1319 public Uri getAdnUriForPhoneAccount(PhoneAccountHandle accountHandle) { 1320 ITelecomService service = getTelecomService(); 1321 if (service != null && accountHandle != null) { 1322 try { 1323 return service.getAdnUriForPhoneAccount(accountHandle, mContext.getOpPackageName()); 1324 } catch (RemoteException e) { 1325 Log.e(TAG, "Error calling ITelecomService#getAdnUriForPhoneAccount", e); 1326 } 1327 } 1328 return Uri.parse("content://icc/adn"); 1329 } 1330 1331 /** 1332 * Removes the missed-call notification if one is present. 1333 * <p> 1334 * Requires that the method-caller be set as the system dialer app. 1335 * </p> 1336 * 1337 * Requires permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE} 1338 */ 1339 @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) 1340 public void cancelMissedCallsNotification() { 1341 ITelecomService service = getTelecomService(); 1342 if (service != null) { 1343 try { 1344 service.cancelMissedCallsNotification(mContext.getOpPackageName()); 1345 } catch (RemoteException e) { 1346 Log.e(TAG, "Error calling ITelecomService#cancelMissedCallsNotification", e); 1347 } 1348 } 1349 } 1350 1351 /** 1352 * Brings the in-call screen to the foreground if there is an ongoing call. If there is 1353 * currently no ongoing call, then this method does nothing. 1354 * <p> 1355 * Requires that the method-caller be set as the system dialer app or have the 1356 * {@link android.Manifest.permission#READ_PHONE_STATE} permission. 1357 * </p> 1358 * 1359 * @param showDialpad Brings up the in-call dialpad as part of showing the in-call screen. 1360 */ 1361 @RequiresPermission(android.Manifest.permission.READ_PHONE_STATE) 1362 public void showInCallScreen(boolean showDialpad) { 1363 ITelecomService service = getTelecomService(); 1364 if (service != null) { 1365 try { 1366 service.showInCallScreen(showDialpad, mContext.getOpPackageName()); 1367 } catch (RemoteException e) { 1368 Log.e(TAG, "Error calling ITelecomService#showCallScreen", e); 1369 } 1370 } 1371 } 1372 1373 /** 1374 * Places a new outgoing call to the provided address using the system telecom service with 1375 * the specified extras. 1376 * 1377 * This method is equivalent to placing an outgoing call using {@link Intent#ACTION_CALL}, 1378 * except that the outgoing call will always be sent via the system telecom service. If 1379 * method-caller is either the user selected default dialer app or preloaded system dialer 1380 * app, then emergency calls will also be allowed. 1381 * 1382 * Requires permission: {@link android.Manifest.permission#CALL_PHONE} 1383 * 1384 * Usage example: 1385 * <pre> 1386 * Uri uri = Uri.fromParts("tel", "12345", null); 1387 * Bundle extras = new Bundle(); 1388 * extras.putBoolean(TelecomManager.EXTRA_START_CALL_WITH_SPEAKERPHONE, true); 1389 * telecomManager.placeCall(uri, extras); 1390 * </pre> 1391 * 1392 * The following keys are supported in the supplied extras. 1393 * <ul> 1394 * <li>{@link #EXTRA_OUTGOING_CALL_EXTRAS}</li> 1395 * <li>{@link #EXTRA_PHONE_ACCOUNT_HANDLE}</li> 1396 * <li>{@link #EXTRA_START_CALL_WITH_SPEAKERPHONE}</li> 1397 * <li>{@link #EXTRA_START_CALL_WITH_VIDEO_STATE}</li> 1398 * </ul> 1399 * 1400 * @param address The address to make the call to. 1401 * @param extras Bundle of extras to use with the call. 1402 */ 1403 @RequiresPermission(android.Manifest.permission.CALL_PHONE) 1404 public void placeCall(Uri address, Bundle extras) { 1405 ITelecomService service = getTelecomService(); 1406 if (service != null) { 1407 if (address == null) { 1408 Log.w(TAG, "Cannot place call to empty address."); 1409 } 1410 try { 1411 service.placeCall(address, extras == null ? new Bundle() : extras, 1412 mContext.getOpPackageName()); 1413 } catch (RemoteException e) { 1414 Log.e(TAG, "Error calling ITelecomService#placeCall", e); 1415 } 1416 } 1417 } 1418 1419 /** 1420 * Enables and disables specified phone account. 1421 * 1422 * @param handle Handle to the phone account. 1423 * @param isEnabled Enable state of the phone account. 1424 * @hide 1425 */ 1426 @SystemApi 1427 public void enablePhoneAccount(PhoneAccountHandle handle, boolean isEnabled) { 1428 ITelecomService service = getTelecomService(); 1429 if (service != null) { 1430 try { 1431 service.enablePhoneAccount(handle, isEnabled); 1432 } catch (RemoteException e) { 1433 Log.e(TAG, "Error enablePhoneAbbount", e); 1434 } 1435 } 1436 } 1437 1438 /** 1439 * Dumps telecom analytics for uploading. 1440 * 1441 * @return 1442 * @hide 1443 */ 1444 @SystemApi 1445 @RequiresPermission(Manifest.permission.DUMP) 1446 public TelecomAnalytics dumpAnalytics() { 1447 ITelecomService service = getTelecomService(); 1448 TelecomAnalytics result = null; 1449 if (service != null) { 1450 try { 1451 result = service.dumpCallAnalytics(); 1452 } catch (RemoteException e) { 1453 Log.e(TAG, "Error dumping call analytics", e); 1454 } 1455 } 1456 return result; 1457 } 1458 1459 /** 1460 * Creates the {@link Intent} which can be used with {@link Context#startActivity(Intent)} to 1461 * launch the activity to manage blocked numbers. 1462 * <p> The activity will display the UI to manage blocked numbers only if 1463 * {@link android.provider.BlockedNumberContract#canCurrentUserBlockNumbers(Context)} returns 1464 * {@code true} for the current user. 1465 */ 1466 public Intent createManageBlockedNumbersIntent() { 1467 ITelecomService service = getTelecomService(); 1468 Intent result = null; 1469 if (service != null) { 1470 try { 1471 result = service.createManageBlockedNumbersIntent(); 1472 } catch (RemoteException e) { 1473 Log.e(TAG, "Error calling ITelecomService#createManageBlockedNumbersIntent", e); 1474 } 1475 } 1476 return result; 1477 } 1478 1479 private ITelecomService getTelecomService() { 1480 if (mTelecomServiceOverride != null) { 1481 return mTelecomServiceOverride; 1482 } 1483 return ITelecomService.Stub.asInterface(ServiceManager.getService(Context.TELECOM_SERVICE)); 1484 } 1485 1486 private boolean isServiceConnected() { 1487 boolean isConnected = getTelecomService() != null; 1488 if (!isConnected) { 1489 Log.w(TAG, "Telecom Service not found."); 1490 } 1491 return isConnected; 1492 } 1493 } 1494