telecomm/java/android/telecom/TelecomManager.java

   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@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 }