1 /*
2  * Copyright (C) 2007 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.internal.telephony;
18 
19 import android.content.Context;
20 import android.net.LinkProperties;
21 import android.net.NetworkCapabilities;
22 import android.os.Handler;
23 import android.os.Message;
24 import android.telephony.CellInfo;
25 import android.telephony.CellLocation;
26 import android.telephony.PhoneStateListener;
27 import android.telephony.ServiceState;
28 import android.telephony.SignalStrength;
29 
30 import com.android.internal.telephony.imsphone.ImsPhone;
31 import com.android.internal.telephony.RadioCapability;
32 import com.android.internal.telephony.test.SimulatedRadioControl;
33 import com.android.internal.telephony.uicc.IsimRecords;
34 import com.android.internal.telephony.uicc.UiccCard;
35 import com.android.internal.telephony.uicc.UsimServiceTable;
36 
37 import com.android.internal.telephony.PhoneConstants.*; // ????
38 
39 import java.util.List;
40 
41 /**
42  * Internal interface used to control the phone; SDK developers cannot
43  * obtain this interface.
44  *
45  * {@hide}
46  *
47  */
48 public interface Phone {
49 
50     /** used to enable additional debug messages */
51     static final boolean DEBUG_PHONE = true;
52 
53     public enum DataActivityState {
54         /**
55          * The state of a data activity.
56          * <ul>
57          * <li>NONE = No traffic</li>
58          * <li>DATAIN = Receiving IP ppp traffic</li>
59          * <li>DATAOUT = Sending IP ppp traffic</li>
60          * <li>DATAINANDOUT = Both receiving and sending IP ppp traffic</li>
61          * <li>DORMANT = The data connection is still active,
62                                      but physical link is down</li>
63          * </ul>
64          */
65         NONE, DATAIN, DATAOUT, DATAINANDOUT, DORMANT;
66     }
67 
68     enum SuppService {
69       UNKNOWN, SWITCH, SEPARATE, TRANSFER, CONFERENCE, REJECT, HANGUP, RESUME;
70     }
71 
72     // "Features" accessible through the connectivity manager
73     static final String FEATURE_ENABLE_MMS = "enableMMS";
74     static final String FEATURE_ENABLE_SUPL = "enableSUPL";
75     static final String FEATURE_ENABLE_DUN = "enableDUN";
76     static final String FEATURE_ENABLE_HIPRI = "enableHIPRI";
77     static final String FEATURE_ENABLE_DUN_ALWAYS = "enableDUNAlways";
78     static final String FEATURE_ENABLE_FOTA = "enableFOTA";
79     static final String FEATURE_ENABLE_IMS = "enableIMS";
80     static final String FEATURE_ENABLE_CBS = "enableCBS";
81     static final String FEATURE_ENABLE_EMERGENCY = "enableEmergency";
82 
83     /**
84      * Optional reasons for disconnect and connect
85      */
86     static final String REASON_ROAMING_ON = "roamingOn";
87     static final String REASON_ROAMING_OFF = "roamingOff";
88     static final String REASON_DATA_DISABLED = "dataDisabled";
89     static final String REASON_DATA_ENABLED = "dataEnabled";
90     static final String REASON_DATA_ATTACHED = "dataAttached";
91     static final String REASON_DATA_DETACHED = "dataDetached";
92     static final String REASON_CDMA_DATA_ATTACHED = "cdmaDataAttached";
93     static final String REASON_CDMA_DATA_DETACHED = "cdmaDataDetached";
94     static final String REASON_APN_CHANGED = "apnChanged";
95     static final String REASON_APN_SWITCHED = "apnSwitched";
96     static final String REASON_APN_FAILED = "apnFailed";
97     static final String REASON_RESTORE_DEFAULT_APN = "restoreDefaultApn";
98     static final String REASON_RADIO_TURNED_OFF = "radioTurnedOff";
99     static final String REASON_PDP_RESET = "pdpReset";
100     static final String REASON_VOICE_CALL_ENDED = "2GVoiceCallEnded";
101     static final String REASON_VOICE_CALL_STARTED = "2GVoiceCallStarted";
102     static final String REASON_PS_RESTRICT_ENABLED = "psRestrictEnabled";
103     static final String REASON_PS_RESTRICT_DISABLED = "psRestrictDisabled";
104     static final String REASON_SIM_LOADED = "simLoaded";
105     static final String REASON_NW_TYPE_CHANGED = "nwTypeChanged";
106     static final String REASON_DATA_DEPENDENCY_MET = "dependencyMet";
107     static final String REASON_DATA_DEPENDENCY_UNMET = "dependencyUnmet";
108     static final String REASON_LOST_DATA_CONNECTION = "lostDataConnection";
109     static final String REASON_CONNECTED = "connected";
110     static final String REASON_SINGLE_PDN_ARBITRATION = "SinglePdnArbitration";
111     static final String REASON_DATA_SPECIFIC_DISABLED = "specificDisabled";
112 
113     // Used for band mode selection methods
114     static final int BM_UNSPECIFIED = 0; // selected by baseband automatically
115     static final int BM_EURO_BAND   = 1; // GSM-900 / DCS-1800 / WCDMA-IMT-2000
116     static final int BM_US_BAND     = 2; // GSM-850 / PCS-1900 / WCDMA-850 / WCDMA-PCS-1900
117     static final int BM_JPN_BAND    = 3; // WCDMA-800 / WCDMA-IMT-2000
118     static final int BM_AUS_BAND    = 4; // GSM-900 / DCS-1800 / WCDMA-850 / WCDMA-IMT-2000
119     static final int BM_AUS2_BAND   = 5; // GSM-900 / DCS-1800 / WCDMA-850
120     static final int BM_BOUNDARY    = 6; // upper band boundary
121 
122     // Used for preferred network type
123     // Note NT_* substitute RILConstants.NETWORK_MODE_* above the Phone
124     int NT_MODE_WCDMA_PREF   = RILConstants.NETWORK_MODE_WCDMA_PREF;
125     int NT_MODE_GSM_ONLY     = RILConstants.NETWORK_MODE_GSM_ONLY;
126     int NT_MODE_WCDMA_ONLY   = RILConstants.NETWORK_MODE_WCDMA_ONLY;
127     int NT_MODE_GSM_UMTS     = RILConstants.NETWORK_MODE_GSM_UMTS;
128 
129     int NT_MODE_CDMA         = RILConstants.NETWORK_MODE_CDMA;
130 
131     int NT_MODE_CDMA_NO_EVDO = RILConstants.NETWORK_MODE_CDMA_NO_EVDO;
132     int NT_MODE_EVDO_NO_CDMA = RILConstants.NETWORK_MODE_EVDO_NO_CDMA;
133     int NT_MODE_GLOBAL       = RILConstants.NETWORK_MODE_GLOBAL;
134 
135     int NT_MODE_LTE_CDMA_AND_EVDO        = RILConstants.NETWORK_MODE_LTE_CDMA_EVDO;
136     int NT_MODE_LTE_GSM_WCDMA            = RILConstants.NETWORK_MODE_LTE_GSM_WCDMA;
137     int NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA  = RILConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA;
138     int NT_MODE_LTE_ONLY                 = RILConstants.NETWORK_MODE_LTE_ONLY;
139     int NT_MODE_LTE_WCDMA                = RILConstants.NETWORK_MODE_LTE_WCDMA;
140     int PREFERRED_NT_MODE                = RILConstants.PREFERRED_NETWORK_MODE;
141 
142     // Used for CDMA roaming mode
143     static final int CDMA_RM_HOME        = 0;  // Home Networks only, as defined in PRL
144     static final int CDMA_RM_AFFILIATED  = 1;  // Roaming an Affiliated networks, as defined in PRL
145     static final int CDMA_RM_ANY         = 2;  // Roaming on Any Network, as defined in PRL
146 
147     // Used for CDMA subscription mode
148     static final int CDMA_SUBSCRIPTION_UNKNOWN  =-1; // Unknown
149     static final int CDMA_SUBSCRIPTION_RUIM_SIM = 0; // RUIM/SIM (default)
150     static final int CDMA_SUBSCRIPTION_NV       = 1; // NV -> non-volatile memory
151 
152     static final int PREFERRED_CDMA_SUBSCRIPTION = CDMA_SUBSCRIPTION_NV;
153 
154     static final int TTY_MODE_OFF = 0;
155     static final int TTY_MODE_FULL = 1;
156     static final int TTY_MODE_HCO = 2;
157     static final int TTY_MODE_VCO = 3;
158 
159      /**
160      * CDMA OTA PROVISION STATUS, the same as RIL_CDMA_OTA_Status in ril.h
161      */
162 
163     public static final int CDMA_OTA_PROVISION_STATUS_SPL_UNLOCKED = 0;
164     public static final int CDMA_OTA_PROVISION_STATUS_SPC_RETRIES_EXCEEDED = 1;
165     public static final int CDMA_OTA_PROVISION_STATUS_A_KEY_EXCHANGED = 2;
166     public static final int CDMA_OTA_PROVISION_STATUS_SSD_UPDATED = 3;
167     public static final int CDMA_OTA_PROVISION_STATUS_NAM_DOWNLOADED = 4;
168     public static final int CDMA_OTA_PROVISION_STATUS_MDN_DOWNLOADED = 5;
169     public static final int CDMA_OTA_PROVISION_STATUS_IMSI_DOWNLOADED = 6;
170     public static final int CDMA_OTA_PROVISION_STATUS_PRL_DOWNLOADED = 7;
171     public static final int CDMA_OTA_PROVISION_STATUS_COMMITTED = 8;
172     public static final int CDMA_OTA_PROVISION_STATUS_OTAPA_STARTED = 9;
173     public static final int CDMA_OTA_PROVISION_STATUS_OTAPA_STOPPED = 10;
174     public static final int CDMA_OTA_PROVISION_STATUS_OTAPA_ABORTED = 11;
175 
176 
177     /**
178      * Get the current ServiceState. Use
179      * <code>registerForServiceStateChanged</code> to be informed of
180      * updates.
181      */
getServiceState()182     ServiceState getServiceState();
183 
184     /**
185      * Get the current CellLocation.
186      */
getCellLocation()187     CellLocation getCellLocation();
188 
189     /**
190      * @return all available cell information or null if none.
191      */
getAllCellInfo()192     public List<CellInfo> getAllCellInfo();
193 
194     /**
195      * Sets the minimum time in milli-seconds between {@link PhoneStateListener#onCellInfoChanged
196      * PhoneStateListener.onCellInfoChanged} will be invoked.
197      *
198      * The default, 0, means invoke onCellInfoChanged when any of the reported
199      * information changes. Setting the value to INT_MAX(0x7fffffff) means never issue
200      * A onCellInfoChanged.
201      *
202      * @param rateInMillis the rate
203      */
setCellInfoListRate(int rateInMillis)204     public void setCellInfoListRate(int rateInMillis);
205 
206     /**
207      * Get the current for the default apn DataState. No change notification
208      * exists at this interface -- use
209      * {@link android.telephony.PhoneStateListener} instead.
210      */
getDataConnectionState()211     DataState getDataConnectionState();
212 
213     /**
214      * Get the current DataState. No change notification exists at this
215      * interface -- use
216      * {@link android.telephony.PhoneStateListener} instead.
217      * @param apnType specify for which apn to get connection state info.
218      */
getDataConnectionState(String apnType)219     DataState getDataConnectionState(String apnType);
220 
221     /**
222      * Get the current DataActivityState. No change notification exists at this
223      * interface -- use
224      * {@link android.telephony.TelephonyManager} instead.
225      */
getDataActivityState()226     DataActivityState getDataActivityState();
227 
228     /**
229      * Gets the context for the phone, as set at initialization time.
230      */
getContext()231     Context getContext();
232 
233     /**
234      * Disables the DNS check (i.e., allows "0.0.0.0").
235      * Useful for lab testing environment.
236      * @param b true disables the check, false enables.
237      */
disableDnsCheck(boolean b)238     void disableDnsCheck(boolean b);
239 
240     /**
241      * Returns true if the DNS check is currently disabled.
242      */
isDnsCheckDisabled()243     boolean isDnsCheckDisabled();
244 
245     /**
246      * Get current coarse-grained voice call state.
247      * Use {@link #registerForPreciseCallStateChanged(Handler, int, Object)
248      * registerForPreciseCallStateChanged()} for change notification. <p>
249      * If the phone has an active call and call waiting occurs,
250      * then the phone state is RINGING not OFFHOOK
251      * <strong>Note:</strong>
252      * This registration point provides notification of finer-grained
253      * changes.<p>
254      *
255      */
getState()256     State getState();
257 
258     /**
259      * Returns a string identifier for this phone interface for parties
260      *  outside the phone app process.
261      *  @return The string name.
262      */
getPhoneName()263     String getPhoneName();
264 
265     /**
266      * Return a numerical identifier for the phone radio interface.
267      * @return PHONE_TYPE_XXX as defined above.
268      */
getPhoneType()269     int getPhoneType();
270 
271     /**
272      * Returns an array of string identifiers for the APN types serviced by the
273      * currently active.
274      *  @return The string array will always return at least one entry, Phone.APN_TYPE_DEFAULT.
275      * TODO: Revisit if we always should return at least one entry.
276      */
getActiveApnTypes()277     String[] getActiveApnTypes();
278 
279     /**
280      * Check if TETHER_DUN_APN setting or config_tether_apndata includes APN that matches
281      * current operator.
282      * @return true if there is a matching DUN APN.
283      */
hasMatchedTetherApnSetting()284     boolean hasMatchedTetherApnSetting();
285 
286     /**
287      * Returns string for the active APN host.
288      *  @return type as a string or null if none.
289      */
getActiveApnHost(String apnType)290     String getActiveApnHost(String apnType);
291 
292     /**
293      * Return the LinkProperties for the named apn or null if not available
294      */
getLinkProperties(String apnType)295     LinkProperties getLinkProperties(String apnType);
296 
297     /**
298      * Return the NetworkCapabilities
299      */
getNetworkCapabilities(String apnType)300     NetworkCapabilities getNetworkCapabilities(String apnType);
301 
302     /**
303      * Get current signal strength. No change notification available on this
304      * interface. Use <code>PhoneStateNotifier</code> or an equivalent.
305      * An ASU is 0-31 or -1 if unknown (for GSM, dBm = -113 - 2 * asu).
306      * The following special values are defined:</p>
307      * <ul><li>0 means "-113 dBm or less".</li>
308      * <li>31 means "-51 dBm or greater".</li></ul>
309      *
310      * @return Current signal strength as SignalStrength
311      */
getSignalStrength()312     SignalStrength getSignalStrength();
313 
314     /**
315      * Notifies when a previously untracked non-ringing/waiting connection has appeared.
316      * This is likely due to some other entity (eg, SIM card application) initiating a call.
317      */
registerForUnknownConnection(Handler h, int what, Object obj)318     void registerForUnknownConnection(Handler h, int what, Object obj);
319 
320     /**
321      * Unregisters for unknown connection notifications.
322      */
unregisterForUnknownConnection(Handler h)323     void unregisterForUnknownConnection(Handler h);
324 
325     /**
326      * Notifies when a Handover happens due to SRVCC or Silent Redial
327      */
registerForHandoverStateChanged(Handler h, int what, Object obj)328     void registerForHandoverStateChanged(Handler h, int what, Object obj);
329 
330     /**
331      * Unregisters for handover state notifications
332      */
unregisterForHandoverStateChanged(Handler h)333     void unregisterForHandoverStateChanged(Handler h);
334 
335     /**
336      * Register for getting notifications for change in the Call State {@link Call.State}
337      * This is called PreciseCallState because the call state is more precise than the
338      * {@link PhoneConstants.State} which can be obtained using the {@link PhoneStateListener}
339      *
340      * Resulting events will have an AsyncResult in <code>Message.obj</code>.
341      * AsyncResult.userData will be set to the obj argument here.
342      * The <em>h</em> parameter is held only by a weak reference.
343      */
registerForPreciseCallStateChanged(Handler h, int what, Object obj)344     void registerForPreciseCallStateChanged(Handler h, int what, Object obj);
345 
346     /**
347      * Unregisters for voice call state change notifications.
348      * Extraneous calls are tolerated silently.
349      */
unregisterForPreciseCallStateChanged(Handler h)350     void unregisterForPreciseCallStateChanged(Handler h);
351 
352     /**
353      * Notifies when a new ringing or waiting connection has appeared.<p>
354      *
355      *  Messages received from this:
356      *  Message.obj will be an AsyncResult
357      *  AsyncResult.userObj = obj
358      *  AsyncResult.result = a Connection. <p>
359      *  Please check Connection.isRinging() to make sure the Connection
360      *  has not dropped since this message was posted.
361      *  If Connection.isRinging() is true, then
362      *   Connection.getCall() == Phone.getRingingCall()
363      */
registerForNewRingingConnection(Handler h, int what, Object obj)364     void registerForNewRingingConnection(Handler h, int what, Object obj);
365 
366     /**
367      * Unregisters for new ringing connection notification.
368      * Extraneous calls are tolerated silently
369      */
370 
unregisterForNewRingingConnection(Handler h)371     void unregisterForNewRingingConnection(Handler h);
372 
373     /**
374      * Notifies when an incoming call rings.<p>
375      *
376      *  Messages received from this:
377      *  Message.obj will be an AsyncResult
378      *  AsyncResult.userObj = obj
379      *  AsyncResult.result = a Connection. <p>
380      */
registerForIncomingRing(Handler h, int what, Object obj)381     void registerForIncomingRing(Handler h, int what, Object obj);
382 
383     /**
384      * Unregisters for ring notification.
385      * Extraneous calls are tolerated silently
386      */
387 
unregisterForIncomingRing(Handler h)388     void unregisterForIncomingRing(Handler h);
389 
390     /**
391      * Notifies when out-band ringback tone is needed.<p>
392      *
393      *  Messages received from this:
394      *  Message.obj will be an AsyncResult
395      *  AsyncResult.userObj = obj
396      *  AsyncResult.result = boolean, true to start play ringback tone
397      *                       and false to stop. <p>
398      */
registerForRingbackTone(Handler h, int what, Object obj)399     void registerForRingbackTone(Handler h, int what, Object obj);
400 
401     /**
402      * Unregisters for ringback tone notification.
403      */
404 
unregisterForRingbackTone(Handler h)405     void unregisterForRingbackTone(Handler h);
406 
407     /**
408      * Notifies when out-band on-hold tone is needed.<p>
409      *
410      *  Messages received from this:
411      *  Message.obj will be an AsyncResult
412      *  AsyncResult.userObj = obj
413      *  AsyncResult.result = boolean, true to start play on-hold tone
414      *                       and false to stop. <p>
415      */
registerForOnHoldTone(Handler h, int what, Object obj)416     void registerForOnHoldTone(Handler h, int what, Object obj);
417 
418     /**
419      * Unregisters for on-hold tone notification.
420      */
421 
unregisterForOnHoldTone(Handler h)422     void unregisterForOnHoldTone(Handler h);
423 
424     /**
425      * Registers the handler to reset the uplink mute state to get
426      * uplink audio.
427      */
registerForResendIncallMute(Handler h, int what, Object obj)428     void registerForResendIncallMute(Handler h, int what, Object obj);
429 
430     /**
431      * Unregisters for resend incall mute notifications.
432      */
unregisterForResendIncallMute(Handler h)433     void unregisterForResendIncallMute(Handler h);
434 
435     /**
436      * Notifies when a voice connection has disconnected, either due to local
437      * or remote hangup or error.
438      *
439      *  Messages received from this will have the following members:<p>
440      *  <ul><li>Message.obj will be an AsyncResult</li>
441      *  <li>AsyncResult.userObj = obj</li>
442      *  <li>AsyncResult.result = a Connection object that is
443      *  no longer connected.</li></ul>
444      */
registerForDisconnect(Handler h, int what, Object obj)445     void registerForDisconnect(Handler h, int what, Object obj);
446 
447     /**
448      * Unregisters for voice disconnection notification.
449      * Extraneous calls are tolerated silently
450      */
unregisterForDisconnect(Handler h)451     void unregisterForDisconnect(Handler h);
452 
453 
454     /**
455      * Register for notifications of initiation of a new MMI code request.
456      * MMI codes for GSM are discussed in 3GPP TS 22.030.<p>
457      *
458      * Example: If Phone.dial is called with "*#31#", then the app will
459      * be notified here.<p>
460      *
461      * The returned <code>Message.obj</code> will contain an AsyncResult.
462      *
463      * <code>obj.result</code> will be an "MmiCode" object.
464      */
registerForMmiInitiate(Handler h, int what, Object obj)465     void registerForMmiInitiate(Handler h, int what, Object obj);
466 
467     /**
468      * Unregisters for new MMI initiate notification.
469      * Extraneous calls are tolerated silently
470      */
unregisterForMmiInitiate(Handler h)471     void unregisterForMmiInitiate(Handler h);
472 
473     /**
474      * Register for notifications that an MMI request has completed
475      * its network activity and is in its final state. This may mean a state
476      * of COMPLETE, FAILED, or CANCELLED.
477      *
478      * <code>Message.obj</code> will contain an AsyncResult.
479      * <code>obj.result</code> will be an "MmiCode" object
480      */
registerForMmiComplete(Handler h, int what, Object obj)481     void registerForMmiComplete(Handler h, int what, Object obj);
482 
483     /**
484      * Unregisters for MMI complete notification.
485      * Extraneous calls are tolerated silently
486      */
unregisterForMmiComplete(Handler h)487     void unregisterForMmiComplete(Handler h);
488 
489     /**
490      * Registration point for Ecm timer reset
491      * @param h handler to notify
492      * @param what user-defined message code
493      * @param obj placed in Message.obj
494      */
registerForEcmTimerReset(Handler h, int what, Object obj)495     public void registerForEcmTimerReset(Handler h, int what, Object obj);
496 
497     /**
498      * Unregister for notification for Ecm timer reset
499      * @param h Handler to be removed from the registrant list.
500      */
unregisterForEcmTimerReset(Handler h)501     public void unregisterForEcmTimerReset(Handler h);
502 
503     /**
504      * Returns a list of MMI codes that are pending. (They have initiated
505      * but have not yet completed).
506      * Presently there is only ever one.
507      * Use <code>registerForMmiInitiate</code>
508      * and <code>registerForMmiComplete</code> for change notification.
509      */
getPendingMmiCodes()510     public List<? extends MmiCode> getPendingMmiCodes();
511 
512     /**
513      * Sends user response to a USSD REQUEST message.  An MmiCode instance
514      * representing this response is sent to handlers registered with
515      * registerForMmiInitiate.
516      *
517      * @param ussdMessge    Message to send in the response.
518      */
sendUssdResponse(String ussdMessge)519     public void sendUssdResponse(String ussdMessge);
520 
521     /**
522      * Register for ServiceState changed.
523      * Message.obj will contain an AsyncResult.
524      * AsyncResult.result will be a ServiceState instance
525      */
registerForServiceStateChanged(Handler h, int what, Object obj)526     void registerForServiceStateChanged(Handler h, int what, Object obj);
527 
528     /**
529      * Unregisters for ServiceStateChange notification.
530      * Extraneous calls are tolerated silently
531      */
unregisterForServiceStateChanged(Handler h)532     void unregisterForServiceStateChanged(Handler h);
533 
534     /**
535      * Register for Supplementary Service notifications from the network.
536      * Message.obj will contain an AsyncResult.
537      * AsyncResult.result will be a SuppServiceNotification instance.
538      *
539      * @param h Handler that receives the notification message.
540      * @param what User-defined message code.
541      * @param obj User object.
542      */
registerForSuppServiceNotification(Handler h, int what, Object obj)543     void registerForSuppServiceNotification(Handler h, int what, Object obj);
544 
545     /**
546      * Unregisters for Supplementary Service notifications.
547      * Extraneous calls are tolerated silently
548      *
549      * @param h Handler to be removed from the registrant list.
550      */
unregisterForSuppServiceNotification(Handler h)551     void unregisterForSuppServiceNotification(Handler h);
552 
553     /**
554      * Register for notifications when a supplementary service attempt fails.
555      * Message.obj will contain an AsyncResult.
556      *
557      * @param h Handler that receives the notification message.
558      * @param what User-defined message code.
559      * @param obj User object.
560      */
registerForSuppServiceFailed(Handler h, int what, Object obj)561     void registerForSuppServiceFailed(Handler h, int what, Object obj);
562 
563     /**
564      * Unregister for notifications when a supplementary service attempt fails.
565      * Extraneous calls are tolerated silently
566      *
567      * @param h Handler to be removed from the registrant list.
568      */
unregisterForSuppServiceFailed(Handler h)569     void unregisterForSuppServiceFailed(Handler h);
570 
571     /**
572      * Register for notifications when a sInCall VoicePrivacy is enabled
573      *
574      * @param h Handler that receives the notification message.
575      * @param what User-defined message code.
576      * @param obj User object.
577      */
registerForInCallVoicePrivacyOn(Handler h, int what, Object obj)578     void registerForInCallVoicePrivacyOn(Handler h, int what, Object obj);
579 
580     /**
581      * Unegister for notifications when a sInCall VoicePrivacy is enabled
582      *
583      * @param h Handler to be removed from the registrant list.
584      */
unregisterForInCallVoicePrivacyOn(Handler h)585     void unregisterForInCallVoicePrivacyOn(Handler h);
586 
587     /**
588      * Register for notifications when a sInCall VoicePrivacy is disabled
589      *
590      * @param h Handler that receives the notification message.
591      * @param what User-defined message code.
592      * @param obj User object.
593      */
registerForInCallVoicePrivacyOff(Handler h, int what, Object obj)594     void registerForInCallVoicePrivacyOff(Handler h, int what, Object obj);
595 
596     /**
597      * Unregister for notifications when a sInCall VoicePrivacy is disabled
598      *
599      * @param h Handler to be removed from the registrant list.
600      */
unregisterForInCallVoicePrivacyOff(Handler h)601     void unregisterForInCallVoicePrivacyOff(Handler h);
602 
603     /**
604      * Register for notifications when CDMA OTA Provision status change
605      *
606      * @param h Handler that receives the notification message.
607      * @param what User-defined message code.
608      * @param obj User object.
609      */
registerForCdmaOtaStatusChange(Handler h, int what, Object obj)610     void registerForCdmaOtaStatusChange(Handler h, int what, Object obj);
611 
612     /**
613      * Unregister for notifications when CDMA OTA Provision status change
614      * @param h Handler to be removed from the registrant list.
615      */
unregisterForCdmaOtaStatusChange(Handler h)616     void unregisterForCdmaOtaStatusChange(Handler h);
617 
618     /**
619      * Registration point for subscription info ready
620      * @param h handler to notify
621      * @param what what code of message when delivered
622      * @param obj placed in Message.obj
623      */
registerForSubscriptionInfoReady(Handler h, int what, Object obj)624     public void registerForSubscriptionInfoReady(Handler h, int what, Object obj);
625 
626     /**
627      * Unregister for notifications for subscription info
628      * @param h Handler to be removed from the registrant list.
629      */
unregisterForSubscriptionInfoReady(Handler h)630     public void unregisterForSubscriptionInfoReady(Handler h);
631 
632     /**
633      * Registration point for Sim records loaded
634      * @param h handler to notify
635      * @param what what code of message when delivered
636      * @param obj placed in Message.obj
637      */
registerForSimRecordsLoaded(Handler h, int what, Object obj)638     public void registerForSimRecordsLoaded(Handler h, int what, Object obj);
639 
640     /**
641      * Unregister for notifications for Sim records loaded
642      * @param h Handler to be removed from the registrant list.
643      */
unregisterForSimRecordsLoaded(Handler h)644     public void unregisterForSimRecordsLoaded(Handler h);
645 
646     /**
647      * Register for TTY mode change notifications from the network.
648      * Message.obj will contain an AsyncResult.
649      * AsyncResult.result will be an Integer containing new mode.
650      *
651      * @param h Handler that receives the notification message.
652      * @param what User-defined message code.
653      * @param obj User object.
654      */
registerForTtyModeReceived(Handler h, int what, Object obj)655     public void registerForTtyModeReceived(Handler h, int what, Object obj);
656 
657     /**
658      * Unregisters for TTY mode change notifications.
659      * Extraneous calls are tolerated silently
660      *
661      * @param h Handler to be removed from the registrant list.
662      */
unregisterForTtyModeReceived(Handler h)663     public void unregisterForTtyModeReceived(Handler h);
664 
665     /**
666      * Returns SIM record load state. Use
667      * <code>getSimCard().registerForReady()</code> for change notification.
668      *
669      * @return true if records from the SIM have been loaded and are
670      * available (if applicable). If not applicable to the underlying
671      * technology, returns true as well.
672      */
getIccRecordsLoaded()673     boolean getIccRecordsLoaded();
674 
675     /**
676      * Returns the ICC card interface for this phone, or null
677      * if not applicable to underlying technology.
678      */
getIccCard()679     IccCard getIccCard();
680 
681     /**
682      * Answers a ringing or waiting call. Active calls, if any, go on hold.
683      * Answering occurs asynchronously, and final notification occurs via
684      * {@link #registerForPreciseCallStateChanged(android.os.Handler, int,
685      * java.lang.Object) registerForPreciseCallStateChanged()}.
686      *
687      * @param videoState The video state in which to answer the call.
688      * @exception CallStateException when no call is ringing or waiting
689      */
acceptCall(int videoState)690     void acceptCall(int videoState) throws CallStateException;
691 
692     /**
693      * Reject (ignore) a ringing call. In GSM, this means UDUB
694      * (User Determined User Busy). Reject occurs asynchronously,
695      * and final notification occurs via
696      * {@link #registerForPreciseCallStateChanged(android.os.Handler, int,
697      * java.lang.Object) registerForPreciseCallStateChanged()}.
698      *
699      * @exception CallStateException when no call is ringing or waiting
700      */
rejectCall()701     void rejectCall() throws CallStateException;
702 
703     /**
704      * Places any active calls on hold, and makes any held calls
705      *  active. Switch occurs asynchronously and may fail.
706      * Final notification occurs via
707      * {@link #registerForPreciseCallStateChanged(android.os.Handler, int,
708      * java.lang.Object) registerForPreciseCallStateChanged()}.
709      *
710      * @exception CallStateException if a call is ringing, waiting, or
711      * dialing/alerting. In these cases, this operation may not be performed.
712      */
switchHoldingAndActive()713     void switchHoldingAndActive() throws CallStateException;
714 
715     /**
716      * Whether or not the phone can conference in the current phone
717      * state--that is, one call holding and one call active.
718      * @return true if the phone can conference; false otherwise.
719      */
canConference()720     boolean canConference();
721 
722     /**
723      * Conferences holding and active. Conference occurs asynchronously
724      * and may fail. Final notification occurs via
725      * {@link #registerForPreciseCallStateChanged(android.os.Handler, int,
726      * java.lang.Object) registerForPreciseCallStateChanged()}.
727      *
728      * @exception CallStateException if canConference() would return false.
729      * In these cases, this operation may not be performed.
730      */
conference()731     void conference() throws CallStateException;
732 
733     /**
734      * Enable or disable enhanced Voice Privacy (VP). If enhanced VP is
735      * disabled, normal VP is enabled.
736      *
737      * @param enable whether true or false to enable or disable.
738      * @param onComplete a callback message when the action is completed.
739      */
enableEnhancedVoicePrivacy(boolean enable, Message onComplete)740     void enableEnhancedVoicePrivacy(boolean enable, Message onComplete);
741 
742     /**
743      * Get the currently set Voice Privacy (VP) mode.
744      *
745      * @param onComplete a callback message when the action is completed.
746      */
getEnhancedVoicePrivacy(Message onComplete)747     void getEnhancedVoicePrivacy(Message onComplete);
748 
749     /**
750      * Whether or not the phone can do explicit call transfer in the current
751      * phone state--that is, one call holding and one call active.
752      * @return true if the phone can do explicit call transfer; false otherwise.
753      */
canTransfer()754     boolean canTransfer();
755 
756     /**
757      * Connects the two calls and disconnects the subscriber from both calls
758      * Explicit Call Transfer occurs asynchronously
759      * and may fail. Final notification occurs via
760      * {@link #registerForPreciseCallStateChanged(android.os.Handler, int,
761      * java.lang.Object) registerForPreciseCallStateChanged()}.
762      *
763      * @exception CallStateException if canTransfer() would return false.
764      * In these cases, this operation may not be performed.
765      */
explicitCallTransfer()766     void explicitCallTransfer() throws CallStateException;
767 
768     /**
769      * Clears all DISCONNECTED connections from Call connection lists.
770      * Calls that were in the DISCONNECTED state become idle. This occurs
771      * synchronously.
772      */
clearDisconnected()773     void clearDisconnected();
774 
775 
776     /**
777      * Gets the foreground call object, which represents all connections that
778      * are dialing or active (all connections
779      * that have their audio path connected).<p>
780      *
781      * The foreground call is a singleton object. It is constant for the life
782      * of this phone. It is never null.<p>
783      *
784      * The foreground call will only ever be in one of these states:
785      * IDLE, ACTIVE, DIALING, ALERTING, or DISCONNECTED.
786      *
787      * State change notification is available via
788      * {@link #registerForPreciseCallStateChanged(android.os.Handler, int,
789      * java.lang.Object) registerForPreciseCallStateChanged()}.
790      */
getForegroundCall()791     Call getForegroundCall();
792 
793     /**
794      * Gets the background call object, which represents all connections that
795      * are holding (all connections that have been accepted or connected, but
796      * do not have their audio path connected). <p>
797      *
798      * The background call is a singleton object. It is constant for the life
799      * of this phone object . It is never null.<p>
800      *
801      * The background call will only ever be in one of these states:
802      * IDLE, HOLDING or DISCONNECTED.
803      *
804      * State change notification is available via
805      * {@link #registerForPreciseCallStateChanged(android.os.Handler, int,
806      * java.lang.Object) registerForPreciseCallStateChanged()}.
807      */
getBackgroundCall()808     Call getBackgroundCall();
809 
810     /**
811      * Gets the ringing call object, which represents an incoming
812      * connection (if present) that is pending answer/accept. (This connection
813      * may be RINGING or WAITING, and there may be only one.)<p>
814 
815      * The ringing call is a singleton object. It is constant for the life
816      * of this phone. It is never null.<p>
817      *
818      * The ringing call will only ever be in one of these states:
819      * IDLE, INCOMING, WAITING or DISCONNECTED.
820      *
821      * State change notification is available via
822      * {@link #registerForPreciseCallStateChanged(android.os.Handler, int,
823      * java.lang.Object) registerForPreciseCallStateChanged()}.
824      */
getRingingCall()825     Call getRingingCall();
826 
827     /**
828      * Initiate a new voice connection. This happens asynchronously, so you
829      * cannot assume the audio path is connected (or a call index has been
830      * assigned) until PhoneStateChanged notification has occurred.
831      *
832      * @param dialString The dial string.
833      * @param videoState The desired video state for the connection.
834      * @exception CallStateException if a new outgoing call is not currently
835      * possible because no more call slots exist or a call exists that is
836      * dialing, alerting, ringing, or waiting.  Other errors are
837      * handled asynchronously.
838      */
dial(String dialString, int videoState)839     Connection dial(String dialString, int videoState) throws CallStateException;
840 
841     /**
842      * Initiate a new voice connection with supplementary User to User
843      * Information. This happens asynchronously, so you cannot assume the audio
844      * path is connected (or a call index has been assigned) until
845      * PhoneStateChanged notification has occurred.
846      *
847      * @param dialString The dial string.
848      * @param uusInfo The UUSInfo.
849      * @param videoState The desired video state for the connection.
850      * @exception CallStateException if a new outgoing call is not currently
851      *                possible because no more call slots exist or a call exists
852      *                that is dialing, alerting, ringing, or waiting. Other
853      *                errors are handled asynchronously.
854      */
dial(String dialString, UUSInfo uusInfo, int videoState)855     Connection dial(String dialString, UUSInfo uusInfo, int videoState) throws CallStateException;
856 
857     /**
858      * Handles PIN MMI commands (PIN/PIN2/PUK/PUK2), which are initiated
859      * without SEND (so <code>dial</code> is not appropriate).
860      *
861      * @param dialString the MMI command to be executed.
862      * @return true if MMI command is executed.
863      */
handlePinMmi(String dialString)864     boolean handlePinMmi(String dialString);
865 
866     /**
867      * Handles in-call MMI commands. While in a call, or while receiving a
868      * call, use this to execute MMI commands.
869      * see 3GPP 20.030, section 6.5.5.1 for specs on the allowed MMI commands.
870      *
871      * @param command the MMI command to be executed.
872      * @return true if the MMI command is executed.
873      * @throws CallStateException
874      */
handleInCallMmiCommands(String command)875     boolean handleInCallMmiCommands(String command) throws CallStateException;
876 
877     /**
878      * Play a DTMF tone on the active call. Ignored if there is no active call.
879      * @param c should be one of 0-9, '*' or '#'. Other values will be
880      * silently ignored.
881      */
sendDtmf(char c)882     void sendDtmf(char c);
883 
884     /**
885      * Start to paly a DTMF tone on the active call. Ignored if there is no active call
886      * or there is a playing DTMF tone.
887      * @param c should be one of 0-9, '*' or '#'. Other values will be
888      * silently ignored.
889      */
startDtmf(char c)890     void startDtmf(char c);
891 
892     /**
893      * Stop the playing DTMF tone. Ignored if there is no playing DTMF
894      * tone or no active call.
895      */
stopDtmf()896     void stopDtmf();
897 
898     /**
899      * send burst DTMF tone, it can send the string as single character or multiple character
900      * ignore if there is no active call or not valid digits string.
901      * Valid digit means only includes characters ISO-LATIN characters 0-9, *, #
902      * The difference between sendDtmf and sendBurstDtmf is sendDtmf only sends one character,
903      * this api can send single character and multiple character, also, this api has response
904      * back to caller.
905      *
906      * @param dtmfString is string representing the dialing digit(s) in the active call
907      * @param on the DTMF ON length in milliseconds, or 0 for default
908      * @param off the DTMF OFF length in milliseconds, or 0 for default
909      * @param onComplete is the callback message when the action is processed by BP
910      *
911      */
sendBurstDtmf(String dtmfString, int on, int off, Message onComplete)912     void sendBurstDtmf(String dtmfString, int on, int off, Message onComplete);
913 
914     /**
915      * Sets the radio power on/off state (off is sometimes
916      * called "airplane mode"). Current state can be gotten via
917      * {@link #getServiceState()}.{@link
918      * android.telephony.ServiceState#getState() getState()}.
919      * <strong>Note: </strong>This request is asynchronous.
920      * getServiceState().getState() will not change immediately after this call.
921      * registerForServiceStateChanged() to find out when the
922      * request is complete.
923      *
924      * @param power true means "on", false means "off".
925      */
setRadioPower(boolean power)926     void setRadioPower(boolean power);
927 
928     /**
929      * Get voice message waiting indicator status. No change notification
930      * available on this interface. Use PhoneStateNotifier or similar instead.
931      *
932      * @return true if there is a voice message waiting
933      */
getMessageWaitingIndicator()934     boolean getMessageWaitingIndicator();
935 
936     /**
937      * Get voice call forwarding indicator status. No change notification
938      * available on this interface. Use PhoneStateNotifier or similar instead.
939      *
940      * @return true if there is a voice call forwarding
941      */
getCallForwardingIndicator()942     boolean getCallForwardingIndicator();
943 
944     /**
945      * Get the line 1 phone number (MSISDN). For CDMA phones, the MDN is returned
946      * and {@link #getMsisdn()} will return the MSISDN on CDMA/LTE phones.<p>
947      *
948      * @return phone number. May return null if not
949      * available or the SIM is not ready
950      */
getLine1Number()951     String getLine1Number();
952 
953     /**
954      * Returns the alpha tag associated with the msisdn number.
955      * If there is no alpha tag associated or the record is not yet available,
956      * returns a default localized string. <p>
957      */
getLine1AlphaTag()958     String getLine1AlphaTag();
959 
960     /**
961      * Sets the MSISDN phone number in the SIM card.
962      *
963      * @param alphaTag the alpha tag associated with the MSISDN phone number
964      *        (see getMsisdnAlphaTag)
965      * @param number the new MSISDN phone number to be set on the SIM.
966      * @param onComplete a callback message when the action is completed.
967      *
968      * @return true if req is sent, false otherwise. If req is not sent there will be no response,
969      * that is, onComplete will never be sent.
970      */
setLine1Number(String alphaTag, String number, Message onComplete)971     boolean setLine1Number(String alphaTag, String number, Message onComplete);
972 
973     /**
974      * Get the voice mail access phone number. Typically dialed when the
975      * user holds the "1" key in the phone app. May return null if not
976      * available or the SIM is not ready.<p>
977      */
getVoiceMailNumber()978     String getVoiceMailNumber();
979 
980     /**
981      * Returns unread voicemail count. This count is shown when the  voicemail
982      * notification is expanded.<p>
983      */
getVoiceMessageCount()984     int getVoiceMessageCount();
985 
986     /**
987      * Returns the alpha tag associated with the voice mail number.
988      * If there is no alpha tag associated or the record is not yet available,
989      * returns a default localized string. <p>
990      *
991      * Please use this value instead of some other localized string when
992      * showing a name for this number in the UI. For example, call log
993      * entries should show this alpha tag. <p>
994      *
995      * Usage of this alpha tag in the UI is a common carrier requirement.
996      */
getVoiceMailAlphaTag()997     String getVoiceMailAlphaTag();
998 
999     /**
1000      * setVoiceMailNumber
1001      * sets the voicemail number in the SIM card.
1002      *
1003      * @param alphaTag the alpha tag associated with the voice mail number
1004      *        (see getVoiceMailAlphaTag)
1005      * @param voiceMailNumber the new voicemail number to be set on the SIM.
1006      * @param onComplete a callback message when the action is completed.
1007      */
setVoiceMailNumber(String alphaTag, String voiceMailNumber, Message onComplete)1008     void setVoiceMailNumber(String alphaTag,
1009                             String voiceMailNumber,
1010                             Message onComplete);
1011 
1012     /**
1013      * getCallForwardingOptions
1014      * gets a call forwarding option. The return value of
1015      * ((AsyncResult)onComplete.obj) is an array of CallForwardInfo.
1016      *
1017      * @param commandInterfaceCFReason is one of the valid call forwarding
1018      *        CF_REASONS, as defined in
1019      *        <code>com.android.internal.telephony.CommandsInterface.</code>
1020      * @param onComplete a callback message when the action is completed.
1021      *        @see com.android.internal.telephony.CallForwardInfo for details.
1022      */
getCallForwardingOption(int commandInterfaceCFReason, Message onComplete)1023     void getCallForwardingOption(int commandInterfaceCFReason,
1024                                   Message onComplete);
1025 
1026     /**
1027      * setCallForwardingOptions
1028      * sets a call forwarding option.
1029      *
1030      * @param commandInterfaceCFReason is one of the valid call forwarding
1031      *        CF_REASONS, as defined in
1032      *        <code>com.android.internal.telephony.CommandsInterface.</code>
1033      * @param commandInterfaceCFAction is one of the valid call forwarding
1034      *        CF_ACTIONS, as defined in
1035      *        <code>com.android.internal.telephony.CommandsInterface.</code>
1036      * @param dialingNumber is the target phone number to forward calls to
1037      * @param timerSeconds is used by CFNRy to indicate the timeout before
1038      *        forwarding is attempted.
1039      * @param onComplete a callback message when the action is completed.
1040      */
setCallForwardingOption(int commandInterfaceCFReason, int commandInterfaceCFAction, String dialingNumber, int timerSeconds, Message onComplete)1041     void setCallForwardingOption(int commandInterfaceCFReason,
1042                                  int commandInterfaceCFAction,
1043                                  String dialingNumber,
1044                                  int timerSeconds,
1045                                  Message onComplete);
1046 
1047     /**
1048      * getOutgoingCallerIdDisplay
1049      * gets outgoing caller id display. The return value of
1050      * ((AsyncResult)onComplete.obj) is an array of int, with a length of 2.
1051      *
1052      * @param onComplete a callback message when the action is completed.
1053      *        @see com.android.internal.telephony.CommandsInterface#getCLIR for details.
1054      */
getOutgoingCallerIdDisplay(Message onComplete)1055     void getOutgoingCallerIdDisplay(Message onComplete);
1056 
1057     /**
1058      * setOutgoingCallerIdDisplay
1059      * sets a call forwarding option.
1060      *
1061      * @param commandInterfaceCLIRMode is one of the valid call CLIR
1062      *        modes, as defined in
1063      *        <code>com.android.internal.telephony.CommandsInterface./code>
1064      * @param onComplete a callback message when the action is completed.
1065      */
setOutgoingCallerIdDisplay(int commandInterfaceCLIRMode, Message onComplete)1066     void setOutgoingCallerIdDisplay(int commandInterfaceCLIRMode,
1067                                     Message onComplete);
1068 
1069     /**
1070      * getCallWaiting
1071      * gets call waiting activation state. The return value of
1072      * ((AsyncResult)onComplete.obj) is an array of int, with a length of 1.
1073      *
1074      * @param onComplete a callback message when the action is completed.
1075      *        @see com.android.internal.telephony.CommandsInterface#queryCallWaiting for details.
1076      */
getCallWaiting(Message onComplete)1077     void getCallWaiting(Message onComplete);
1078 
1079     /**
1080      * setCallWaiting
1081      * sets a call forwarding option.
1082      *
1083      * @param enable is a boolean representing the state that you are
1084      *        requesting, true for enabled, false for disabled.
1085      * @param onComplete a callback message when the action is completed.
1086      */
setCallWaiting(boolean enable, Message onComplete)1087     void setCallWaiting(boolean enable, Message onComplete);
1088 
1089     /**
1090      * Scan available networks. This method is asynchronous; .
1091      * On completion, <code>response.obj</code> is set to an AsyncResult with
1092      * one of the following members:.<p>
1093      *<ul>
1094      * <li><code>response.obj.result</code> will be a <code>List</code> of
1095      * <code>OperatorInfo</code> objects, or</li>
1096      * <li><code>response.obj.exception</code> will be set with an exception
1097      * on failure.</li>
1098      * </ul>
1099      */
getAvailableNetworks(Message response)1100     void getAvailableNetworks(Message response);
1101 
1102     /**
1103      * Switches network selection mode to "automatic", re-scanning and
1104      * re-selecting a network if appropriate.
1105      *
1106      * @param response The message to dispatch when the network selection
1107      * is complete.
1108      *
1109      * @see #selectNetworkManually(OperatorInfo, android.os.Message )
1110      */
setNetworkSelectionModeAutomatic(Message response)1111     void setNetworkSelectionModeAutomatic(Message response);
1112 
1113     /**
1114      * Manually selects a network. <code>response</code> is
1115      * dispatched when this is complete.  <code>response.obj</code> will be
1116      * an AsyncResult, and <code>response.obj.exception</code> will be non-null
1117      * on failure.
1118      *
1119      * @see #setNetworkSelectionModeAutomatic(Message)
1120      */
selectNetworkManually(OperatorInfo network, Message response)1121     void selectNetworkManually(OperatorInfo network,
1122                             Message response);
1123 
1124     /**
1125      * Query the radio for the current network selection mode.
1126      *
1127      * Return values:
1128      *     0 - automatic.
1129      *     1 - manual.
1130      */
getNetworkSelectionMode(Message response)1131     void getNetworkSelectionMode(Message response);
1132 
1133     /**
1134      *  Requests to set the preferred network type for searching and registering
1135      * (CS/PS domain, RAT, and operation mode)
1136      * @param networkType one of  NT_*_TYPE
1137      * @param response is callback message
1138      */
setPreferredNetworkType(int networkType, Message response)1139     void setPreferredNetworkType(int networkType, Message response);
1140 
1141     /**
1142      *  Query the preferred network type setting
1143      *
1144      * @param response is callback message to report one of  NT_*_TYPE
1145      */
getPreferredNetworkType(Message response)1146     void getPreferredNetworkType(Message response);
1147 
1148     /**
1149      * Gets the default SMSC address.
1150      *
1151      * @param result Callback message contains the SMSC address.
1152      */
getSmscAddress(Message result)1153     void getSmscAddress(Message result);
1154 
1155     /**
1156      * Sets the default SMSC address.
1157      *
1158      * @param address new SMSC address
1159      * @param result Callback message is empty on completion
1160      */
setSmscAddress(String address, Message result)1161     void setSmscAddress(String address, Message result);
1162 
1163     /**
1164      * Query neighboring cell IDs.  <code>response</code> is dispatched when
1165      * this is complete.  <code>response.obj</code> will be an AsyncResult,
1166      * and <code>response.obj.exception</code> will be non-null on failure.
1167      * On success, <code>AsyncResult.result</code> will be a <code>String[]</code>
1168      * containing the neighboring cell IDs.  Index 0 will contain the count
1169      * of available cell IDs.  Cell IDs are in hexadecimal format.
1170      *
1171      * @param response callback message that is dispatched when the query
1172      * completes.
1173      */
getNeighboringCids(Message response)1174     void getNeighboringCids(Message response);
1175 
1176     /**
1177      * Sets an event to be fired when the telephony system processes
1178      * a post-dial character on an outgoing call.<p>
1179      *
1180      * Messages of type <code>what</code> will be sent to <code>h</code>.
1181      * The <code>obj</code> field of these Message's will be instances of
1182      * <code>AsyncResult</code>. <code>Message.obj.result</code> will be
1183      * a Connection object.<p>
1184      *
1185      * Message.arg1 will be the post dial character being processed,
1186      * or 0 ('\0') if end of string.<p>
1187      *
1188      * If Connection.getPostDialState() == WAIT,
1189      * the application must call
1190      * {@link com.android.internal.telephony.Connection#proceedAfterWaitChar()
1191      * Connection.proceedAfterWaitChar()} or
1192      * {@link com.android.internal.telephony.Connection#cancelPostDial()
1193      * Connection.cancelPostDial()}
1194      * for the telephony system to continue playing the post-dial
1195      * DTMF sequence.<p>
1196      *
1197      * If Connection.getPostDialState() == WILD,
1198      * the application must call
1199      * {@link com.android.internal.telephony.Connection#proceedAfterWildChar
1200      * Connection.proceedAfterWildChar()}
1201      * or
1202      * {@link com.android.internal.telephony.Connection#cancelPostDial()
1203      * Connection.cancelPostDial()}
1204      * for the telephony system to continue playing the
1205      * post-dial DTMF sequence.<p>
1206      *
1207      * Only one post dial character handler may be set. <p>
1208      * Calling this method with "h" equal to null unsets this handler.<p>
1209      */
setOnPostDialCharacter(Handler h, int what, Object obj)1210     void setOnPostDialCharacter(Handler h, int what, Object obj);
1211 
1212 
1213     /**
1214      * Mutes or unmutes the microphone for the active call. The microphone
1215      * is automatically unmuted if a call is answered, dialed, or resumed
1216      * from a holding state.
1217      *
1218      * @param muted true to mute the microphone,
1219      * false to activate the microphone.
1220      */
1221 
setMute(boolean muted)1222     void setMute(boolean muted);
1223 
1224     /**
1225      * Gets current mute status. Use
1226      * {@link #registerForPreciseCallStateChanged(android.os.Handler, int,
1227      * java.lang.Object) registerForPreciseCallStateChanged()}
1228      * as a change notifcation, although presently phone state changed is not
1229      * fired when setMute() is called.
1230      *
1231      * @return true is muting, false is unmuting
1232      */
getMute()1233     boolean getMute();
1234 
1235     /**
1236      * Enables or disables echo suppression.
1237      */
setEchoSuppressionEnabled()1238     void setEchoSuppressionEnabled();
1239 
1240     /**
1241      * Invokes RIL_REQUEST_OEM_HOOK_RAW on RIL implementation.
1242      *
1243      * @param data The data for the request.
1244      * @param response <strong>On success</strong>,
1245      * (byte[])(((AsyncResult)response.obj).result)
1246      * <strong>On failure</strong>,
1247      * (((AsyncResult)response.obj).result) == null and
1248      * (((AsyncResult)response.obj).exception) being an instance of
1249      * com.android.internal.telephony.gsm.CommandException
1250      *
1251      * @see #invokeOemRilRequestRaw(byte[], android.os.Message)
1252      */
invokeOemRilRequestRaw(byte[] data, Message response)1253     void invokeOemRilRequestRaw(byte[] data, Message response);
1254 
1255     /**
1256      * Invokes RIL_REQUEST_OEM_HOOK_Strings on RIL implementation.
1257      *
1258      * @param strings The strings to make available as the request data.
1259      * @param response <strong>On success</strong>, "response" bytes is
1260      * made available as:
1261      * (String[])(((AsyncResult)response.obj).result).
1262      * <strong>On failure</strong>,
1263      * (((AsyncResult)response.obj).result) == null and
1264      * (((AsyncResult)response.obj).exception) being an instance of
1265      * com.android.internal.telephony.gsm.CommandException
1266      *
1267      * @see #invokeOemRilRequestStrings(java.lang.String[], android.os.Message)
1268      */
invokeOemRilRequestStrings(String[] strings, Message response)1269     void invokeOemRilRequestStrings(String[] strings, Message response);
1270 
1271     /**
1272      * Get the current active Data Call list
1273      *
1274      * @param response <strong>On success</strong>, "response" bytes is
1275      * made available as:
1276      * (String[])(((AsyncResult)response.obj).result).
1277      * <strong>On failure</strong>,
1278      * (((AsyncResult)response.obj).result) == null and
1279      * (((AsyncResult)response.obj).exception) being an instance of
1280      * com.android.internal.telephony.gsm.CommandException
1281      */
getDataCallList(Message response)1282     void getDataCallList(Message response);
1283 
1284     /**
1285      * Update the ServiceState CellLocation for current network registration.
1286      */
updateServiceLocation()1287     void updateServiceLocation();
1288 
1289     /**
1290      * Enable location update notifications.
1291      */
enableLocationUpdates()1292     void enableLocationUpdates();
1293 
1294     /**
1295      * Disable location update notifications.
1296      */
disableLocationUpdates()1297     void disableLocationUpdates();
1298 
1299     /**
1300      * For unit tests; don't send notifications to "Phone"
1301      * mailbox registrants if true.
1302      */
setUnitTestMode(boolean f)1303     void setUnitTestMode(boolean f);
1304 
1305     /**
1306      * @return true If unit test mode is enabled
1307      */
getUnitTestMode()1308     boolean getUnitTestMode();
1309 
1310     /**
1311      * Assign a specified band for RF configuration.
1312      *
1313      * @param bandMode one of BM_*_BAND
1314      * @param response is callback message
1315      */
setBandMode(int bandMode, Message response)1316     void setBandMode(int bandMode, Message response);
1317 
1318     /**
1319      * Query the list of band mode supported by RF.
1320      *
1321      * @param response is callback message
1322      *        ((AsyncResult)response.obj).result  is an int[] where int[0] is
1323      *        the size of the array and the rest of each element representing
1324      *        one available BM_*_BAND
1325      */
queryAvailableBandMode(Message response)1326     void queryAvailableBandMode(Message response);
1327 
1328     /**
1329      * @return true if enable data connection on roaming
1330      */
getDataRoamingEnabled()1331     boolean getDataRoamingEnabled();
1332 
1333     /**
1334      * @param enable set true if enable data connection on roaming
1335      */
setDataRoamingEnabled(boolean enable)1336     void setDataRoamingEnabled(boolean enable);
1337 
1338     /**
1339      * @return true if user has enabled data
1340      */
getDataEnabled()1341     boolean getDataEnabled();
1342 
1343     /**
1344      * @param @enable set {@code true} if enable data connection
1345      */
setDataEnabled(boolean enable)1346     void setDataEnabled(boolean enable);
1347 
1348     /**
1349      *  Query the CDMA roaming preference setting
1350      *
1351      * @param response is callback message to report one of  CDMA_RM_*
1352      */
queryCdmaRoamingPreference(Message response)1353     void queryCdmaRoamingPreference(Message response);
1354 
1355     /**
1356      *  Requests to set the CDMA roaming preference
1357      * @param cdmaRoamingType one of  CDMA_RM_*
1358      * @param response is callback message
1359      */
setCdmaRoamingPreference(int cdmaRoamingType, Message response)1360     void setCdmaRoamingPreference(int cdmaRoamingType, Message response);
1361 
1362     /**
1363      *  Requests to set the CDMA subscription mode
1364      * @param cdmaSubscriptionType one of  CDMA_SUBSCRIPTION_*
1365      * @param response is callback message
1366      */
setCdmaSubscription(int cdmaSubscriptionType, Message response)1367     void setCdmaSubscription(int cdmaSubscriptionType, Message response);
1368 
1369     /**
1370      * If this is a simulated phone interface, returns a SimulatedRadioControl.
1371      * @return SimulatedRadioControl if this is a simulated interface;
1372      * otherwise, null.
1373      */
getSimulatedRadioControl()1374     SimulatedRadioControl getSimulatedRadioControl();
1375 
1376     /**
1377      * Report on whether data connectivity is allowed.
1378      */
isDataConnectivityPossible()1379     boolean isDataConnectivityPossible();
1380 
1381     /**
1382      * Report on whether data connectivity is allowed for an APN.
1383      */
isDataConnectivityPossible(String apnType)1384     boolean isDataConnectivityPossible(String apnType);
1385 
1386     /**
1387      * Retrieves the unique device ID, e.g., IMEI for GSM phones and MEID for CDMA phones.
1388      */
getDeviceId()1389     String getDeviceId();
1390 
1391     /**
1392      * Retrieves the software version number for the device, e.g., IMEI/SV
1393      * for GSM phones.
1394      */
getDeviceSvn()1395     String getDeviceSvn();
1396 
1397     /**
1398      * Retrieves the unique subscriber ID, e.g., IMSI for GSM phones.
1399      */
getSubscriberId()1400     String getSubscriberId();
1401 
1402     /**
1403      * Retrieves the Group Identifier Level1 for GSM phones.
1404      */
getGroupIdLevel1()1405     String getGroupIdLevel1();
1406 
1407     /**
1408      * Retrieves the serial number of the ICC, if applicable.
1409      */
getIccSerialNumber()1410     String getIccSerialNumber();
1411 
1412     /* CDMA support methods */
1413 
1414     /**
1415      * Retrieves the MIN for CDMA phones.
1416      */
getCdmaMin()1417     String getCdmaMin();
1418 
1419     /**
1420      * Check if subscription data has been assigned to mMin
1421      *
1422      * return true if MIN info is ready; false otherwise.
1423      */
isMinInfoReady()1424     boolean isMinInfoReady();
1425 
1426     /**
1427      *  Retrieves PRL Version for CDMA phones
1428      */
getCdmaPrlVersion()1429     String getCdmaPrlVersion();
1430 
1431     /**
1432      * Retrieves the ESN for CDMA phones.
1433      */
getEsn()1434     String getEsn();
1435 
1436     /**
1437      * Retrieves MEID for CDMA phones.
1438      */
getMeid()1439     String getMeid();
1440 
1441     /**
1442      * Retrieves the MSISDN from the UICC. For GSM/UMTS phones, this is equivalent to
1443      * {@link #getLine1Number()}. For CDMA phones, {@link #getLine1Number()} returns
1444      * the MDN, so this method is provided to return the MSISDN on CDMA/LTE phones.
1445      */
getMsisdn()1446     String getMsisdn();
1447 
1448     /**
1449      * Retrieves IMEI for phones. Returns null if IMEI is not set.
1450      */
getImei()1451     String getImei();
1452 
1453     /**
1454      * Retrieves Nai for phones. Returns null if Nai is not set.
1455      */
getNai()1456     String getNai();
1457 
1458     /**
1459      * Retrieves the PhoneSubInfo of the Phone
1460      */
getPhoneSubInfo()1461     public PhoneSubInfo getPhoneSubInfo();
1462 
1463     /**
1464      * Retrieves the IccPhoneBookInterfaceManager of the Phone
1465      */
getIccPhoneBookInterfaceManager()1466     public IccPhoneBookInterfaceManager getIccPhoneBookInterfaceManager();
1467 
1468     /**
1469      * setTTYMode
1470      * sets a TTY mode option.
1471      * @param ttyMode is a one of the following:
1472      * - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF}
1473      * - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL}
1474      * - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO}
1475      * - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO}
1476      * @param onComplete a callback message when the action is completed
1477      */
setTTYMode(int ttyMode, Message onComplete)1478     void setTTYMode(int ttyMode, Message onComplete);
1479 
1480    /**
1481      * setUiTTYMode
1482      * sets a TTY mode option.
1483      * @param ttyMode is a one of the following:
1484      * - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF}
1485      * - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL}
1486      * - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO}
1487      * - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO}
1488      * @param onComplete a callback message when the action is completed
1489      */
setUiTTYMode(int uiTtyMode, Message onComplete)1490     void setUiTTYMode(int uiTtyMode, Message onComplete);
1491 
1492     /**
1493      * queryTTYMode
1494      * query the status of the TTY mode
1495      *
1496      * @param onComplete a callback message when the action is completed.
1497      */
queryTTYMode(Message onComplete)1498     void queryTTYMode(Message onComplete);
1499 
1500     /**
1501      * Activate or deactivate cell broadcast SMS.
1502      *
1503      * @param activate
1504      *            0 = activate, 1 = deactivate
1505      * @param response
1506      *            Callback message is empty on completion
1507      */
activateCellBroadcastSms(int activate, Message response)1508     void activateCellBroadcastSms(int activate, Message response);
1509 
1510     /**
1511      * Query the current configuration of cdma cell broadcast SMS.
1512      *
1513      * @param response
1514      *            Callback message is empty on completion
1515      */
getCellBroadcastSmsConfig(Message response)1516     void getCellBroadcastSmsConfig(Message response);
1517 
1518     /**
1519      * Configure cell broadcast SMS.
1520      *
1521      * TODO: Change the configValuesArray to a RIL_BroadcastSMSConfig
1522      *
1523      * @param response
1524      *            Callback message is empty on completion
1525      */
setCellBroadcastSmsConfig(int[] configValuesArray, Message response)1526     public void setCellBroadcastSmsConfig(int[] configValuesArray, Message response);
1527 
notifyDataActivity()1528     public void notifyDataActivity();
1529 
1530     /**
1531      * Returns the CDMA ERI icon index to display
1532      */
getCdmaEriIconIndex()1533     public int getCdmaEriIconIndex();
1534 
1535     /**
1536      * Returns the CDMA ERI icon mode,
1537      * 0 - ON
1538      * 1 - FLASHING
1539      */
getCdmaEriIconMode()1540     public int getCdmaEriIconMode();
1541 
1542     /**
1543      * Returns the CDMA ERI text,
1544      */
getCdmaEriText()1545     public String getCdmaEriText();
1546 
1547     /**
1548      * request to exit emergency call back mode
1549      * the caller should use setOnECMModeExitResponse
1550      * to receive the emergency callback mode exit response
1551      */
exitEmergencyCallbackMode()1552     void exitEmergencyCallbackMode();
1553 
1554     /**
1555      * this decides if the dial number is OTA(Over the air provision) number or not
1556      * @param dialStr is string representing the dialing digit(s)
1557      * @return  true means the dialStr is OTA number, and false means the dialStr is not OTA number
1558      */
isOtaSpNumber(String dialStr)1559     boolean isOtaSpNumber(String dialStr);
1560 
1561     /**
1562      * Returns true if OTA Service Provisioning needs to be performed.
1563      */
needsOtaServiceProvisioning()1564     boolean needsOtaServiceProvisioning();
1565 
1566     /**
1567      * Register for notifications when CDMA call waiting comes
1568      *
1569      * @param h Handler that receives the notification message.
1570      * @param what User-defined message code.
1571      * @param obj User object.
1572      */
registerForCallWaiting(Handler h, int what, Object obj)1573     void registerForCallWaiting(Handler h, int what, Object obj);
1574 
1575     /**
1576      * Unegister for notifications when CDMA Call waiting comes
1577      * @param h Handler to be removed from the registrant list.
1578      */
unregisterForCallWaiting(Handler h)1579     void unregisterForCallWaiting(Handler h);
1580 
1581 
1582     /**
1583      * Register for signal information notifications from the network.
1584      * Message.obj will contain an AsyncResult.
1585      * AsyncResult.result will be a SuppServiceNotification instance.
1586      *
1587      * @param h Handler that receives the notification message.
1588      * @param what User-defined message code.
1589      * @param obj User object.
1590      */
1591 
registerForSignalInfo(Handler h, int what, Object obj)1592     void registerForSignalInfo(Handler h, int what, Object obj) ;
1593     /**
1594      * Unregisters for signal information notifications.
1595      * Extraneous calls are tolerated silently
1596      *
1597      * @param h Handler to be removed from the registrant list.
1598      */
unregisterForSignalInfo(Handler h)1599     void unregisterForSignalInfo(Handler h);
1600 
1601     /**
1602      * Register for display information notifications from the network.
1603      * Message.obj will contain an AsyncResult.
1604      * AsyncResult.result will be a SuppServiceNotification instance.
1605      *
1606      * @param h Handler that receives the notification message.
1607      * @param what User-defined message code.
1608      * @param obj User object.
1609      */
registerForDisplayInfo(Handler h, int what, Object obj)1610     void registerForDisplayInfo(Handler h, int what, Object obj);
1611 
1612     /**
1613      * Unregisters for display information notifications.
1614      * Extraneous calls are tolerated silently
1615      *
1616      * @param h Handler to be removed from the registrant list.
1617      */
unregisterForDisplayInfo(Handler h)1618     void unregisterForDisplayInfo(Handler h) ;
1619 
1620     /**
1621      * Register for CDMA number information record notification from the network.
1622      * Message.obj will contain an AsyncResult.
1623      * AsyncResult.result will be a CdmaInformationRecords.CdmaNumberInfoRec
1624      * instance.
1625      *
1626      * @param h Handler that receives the notification message.
1627      * @param what User-defined message code.
1628      * @param obj User object.
1629      */
registerForNumberInfo(Handler h, int what, Object obj)1630     void registerForNumberInfo(Handler h, int what, Object obj);
1631 
1632     /**
1633      * Unregisters for number information record notifications.
1634      * Extraneous calls are tolerated silently
1635      *
1636      * @param h Handler to be removed from the registrant list.
1637      */
unregisterForNumberInfo(Handler h)1638     void unregisterForNumberInfo(Handler h);
1639 
1640     /**
1641      * Register for CDMA redirected number information record notification
1642      * from the network.
1643      * Message.obj will contain an AsyncResult.
1644      * AsyncResult.result will be a CdmaInformationRecords.CdmaRedirectingNumberInfoRec
1645      * instance.
1646      *
1647      * @param h Handler that receives the notification message.
1648      * @param what User-defined message code.
1649      * @param obj User object.
1650      */
registerForRedirectedNumberInfo(Handler h, int what, Object obj)1651     void registerForRedirectedNumberInfo(Handler h, int what, Object obj);
1652 
1653     /**
1654      * Unregisters for redirected number information record notification.
1655      * Extraneous calls are tolerated silently
1656      *
1657      * @param h Handler to be removed from the registrant list.
1658      */
unregisterForRedirectedNumberInfo(Handler h)1659     void unregisterForRedirectedNumberInfo(Handler h);
1660 
1661     /**
1662      * Register for CDMA line control information record notification
1663      * from the network.
1664      * Message.obj will contain an AsyncResult.
1665      * AsyncResult.result will be a CdmaInformationRecords.CdmaLineControlInfoRec
1666      * instance.
1667      *
1668      * @param h Handler that receives the notification message.
1669      * @param what User-defined message code.
1670      * @param obj User object.
1671      */
registerForLineControlInfo(Handler h, int what, Object obj)1672     void registerForLineControlInfo(Handler h, int what, Object obj);
1673 
1674     /**
1675      * Unregisters for line control information notifications.
1676      * Extraneous calls are tolerated silently
1677      *
1678      * @param h Handler to be removed from the registrant list.
1679      */
unregisterForLineControlInfo(Handler h)1680     void unregisterForLineControlInfo(Handler h);
1681 
1682     /**
1683      * Register for CDMA T53 CLIR information record notifications
1684      * from the network.
1685      * Message.obj will contain an AsyncResult.
1686      * AsyncResult.result will be a CdmaInformationRecords.CdmaT53ClirInfoRec
1687      * instance.
1688      *
1689      * @param h Handler that receives the notification message.
1690      * @param what User-defined message code.
1691      * @param obj User object.
1692      */
registerFoT53ClirlInfo(Handler h, int what, Object obj)1693     void registerFoT53ClirlInfo(Handler h, int what, Object obj);
1694 
1695     /**
1696      * Unregisters for T53 CLIR information record notification
1697      * Extraneous calls are tolerated silently
1698      *
1699      * @param h Handler to be removed from the registrant list.
1700      */
unregisterForT53ClirInfo(Handler h)1701     void unregisterForT53ClirInfo(Handler h);
1702 
1703     /**
1704      * Register for CDMA T53 audio control information record notifications
1705      * from the network.
1706      * Message.obj will contain an AsyncResult.
1707      * AsyncResult.result will be a CdmaInformationRecords.CdmaT53AudioControlInfoRec
1708      * instance.
1709      *
1710      * @param h Handler that receives the notification message.
1711      * @param what User-defined message code.
1712      * @param obj User object.
1713      */
registerForT53AudioControlInfo(Handler h, int what, Object obj)1714     void registerForT53AudioControlInfo(Handler h, int what, Object obj);
1715 
1716     /**
1717      * Unregisters for T53 audio control information record notifications.
1718      * Extraneous calls are tolerated silently
1719      *
1720      * @param h Handler to be removed from the registrant list.
1721      */
unregisterForT53AudioControlInfo(Handler h)1722     void unregisterForT53AudioControlInfo(Handler h);
1723 
1724     /**
1725      * Register for radio off or not available
1726      *
1727      * @param h Handler that receives the notification message.
1728      * @param what User-defined message code.
1729      * @param obj User object.
1730      */
registerForRadioOffOrNotAvailable(Handler h, int what, Object obj)1731     public void registerForRadioOffOrNotAvailable(Handler h, int what, Object obj);
1732 
1733     /**
1734      * Unregisters for radio off or not available
1735      *
1736      * @param h Handler to be removed from the registrant list.
1737      */
unregisterForRadioOffOrNotAvailable(Handler h)1738     public void unregisterForRadioOffOrNotAvailable(Handler h);
1739 
1740     /**
1741      * registers for exit emergency call back mode request response
1742      *
1743      * @param h Handler that receives the notification message.
1744      * @param what User-defined message code.
1745      * @param obj User object.
1746      */
1747 
setOnEcbModeExitResponse(Handler h, int what, Object obj)1748     void setOnEcbModeExitResponse(Handler h, int what, Object obj);
1749 
1750     /**
1751      * Unregisters for exit emergency call back mode request response
1752      *
1753      * @param h Handler to be removed from the registrant list.
1754      */
unsetOnEcbModeExitResponse(Handler h)1755     void unsetOnEcbModeExitResponse(Handler h);
1756 
1757     /**
1758      * Return if the current radio is LTE on CDMA. This
1759      * is a tri-state return value as for a period of time
1760      * the mode may be unknown.
1761      *
1762      * @return {@link PhoneConstants#LTE_ON_CDMA_UNKNOWN}, {@link PhoneConstants#LTE_ON_CDMA_FALSE}
1763      * or {@link PhoneConstants#LTE_ON_CDMA_TRUE}
1764      */
getLteOnCdmaMode()1765     public int getLteOnCdmaMode();
1766 
1767     /**
1768      * TODO: Adding a function for each property is not good.
1769      * A fucntion of type getPhoneProp(propType) where propType is an
1770      * enum of GSM+CDMA+LTE props would be a better approach.
1771      *
1772      * Get "Restriction of menu options for manual PLMN selection" bit
1773      * status from EF_CSP data, this belongs to "Value Added Services Group".
1774      * @return true if this bit is set or EF_CSP data is unavailable,
1775      * false otherwise
1776      */
isCspPlmnEnabled()1777     boolean isCspPlmnEnabled();
1778 
1779     /**
1780      * Return an interface to retrieve the ISIM records for IMS, if available.
1781      * @return the interface to retrieve the ISIM records, or null if not supported
1782      */
getIsimRecords()1783     IsimRecords getIsimRecords();
1784 
1785     /**
1786      * Sets the SIM voice message waiting indicator records.
1787      * @param line GSM Subscriber Profile Number, one-based. Only '1' is supported
1788      * @param countWaiting The number of messages waiting, if known. Use
1789      *                     -1 to indicate that an unknown number of
1790      *                      messages are waiting
1791      */
setVoiceMessageWaiting(int line, int countWaiting)1792     void setVoiceMessageWaiting(int line, int countWaiting);
1793 
1794     /**
1795      * Gets the USIM service table from the UICC, if present and available.
1796      * @return an interface to the UsimServiceTable record, or null if not available
1797      */
getUsimServiceTable()1798     UsimServiceTable getUsimServiceTable();
1799 
1800     /**
1801      * Gets the Uicc card corresponding to this phone.
1802      * @return the UiccCard object corresponding to the phone ID.
1803      */
getUiccCard()1804     UiccCard getUiccCard();
1805 
1806     /**
1807      * Unregister from all events it registered for and dispose objects
1808      * created by this object.
1809      */
dispose()1810     void dispose();
1811 
1812     /**
1813      * Remove references to external object stored in this object.
1814      */
removeReferences()1815     void removeReferences();
1816 
1817     /**
1818      * Update the phone object if the voice radio technology has changed
1819      *
1820      * @param voiceRadioTech The new voice radio technology
1821      */
updatePhoneObject(int voiceRadioTech)1822     void updatePhoneObject(int voiceRadioTech);
1823 
1824     /**
1825      * Read one of the NV items defined in {@link RadioNVItems} / {@code ril_nv_items.h}.
1826      * Used for device configuration by some CDMA operators.
1827      *
1828      * @param itemID the ID of the item to read
1829      * @param response callback message with the String response in the obj field
1830      */
nvReadItem(int itemID, Message response)1831     void nvReadItem(int itemID, Message response);
1832 
1833     /**
1834      * Write one of the NV items defined in {@link RadioNVItems} / {@code ril_nv_items.h}.
1835      * Used for device configuration by some CDMA operators.
1836      *
1837      * @param itemID the ID of the item to read
1838      * @param itemValue the value to write, as a String
1839      * @param response Callback message.
1840      */
nvWriteItem(int itemID, String itemValue, Message response)1841     void nvWriteItem(int itemID, String itemValue, Message response);
1842 
1843     /**
1844      * Update the CDMA Preferred Roaming List (PRL) in the radio NV storage.
1845      * Used for device configuration by some CDMA operators.
1846      *
1847      * @param preferredRoamingList byte array containing the new PRL
1848      * @param response Callback message.
1849      */
nvWriteCdmaPrl(byte[] preferredRoamingList, Message response)1850     void nvWriteCdmaPrl(byte[] preferredRoamingList, Message response);
1851 
1852     /**
1853      * Perform the specified type of NV config reset. The radio will be taken offline
1854      * and the device must be rebooted after erasing the NV. Used for device
1855      * configuration by some CDMA operators.
1856      *
1857      * @param resetType reset type: 1: reload NV reset, 2: erase NV reset, 3: factory NV reset
1858      * @param response Callback message.
1859      */
nvResetConfig(int resetType, Message response)1860     void nvResetConfig(int resetType, Message response);
1861 
1862     /*
1863      * Returns the subscription id.
1864      */
getSubId()1865     public int getSubId();
1866 
1867     /*
1868      * Returns the phone id.
1869      */
getPhoneId()1870     public int getPhoneId();
1871 
1872     /**
1873      * Get P-CSCF address from PCO after data connection is established or modified.
1874      * @param apnType the apnType, "ims" for IMS APN, "emergency" for EMERGENCY APN
1875      */
getPcscfAddress(String apnType)1876     public String[] getPcscfAddress(String apnType);
1877 
1878     /**
1879      * Set IMS registration state
1880      */
setImsRegistrationState(boolean registered)1881     public void setImsRegistrationState(boolean registered);
1882 
1883     /**
1884      * Return the ImsPhone phone co-managed with this phone
1885      * @return an instance of an ImsPhone phone
1886      */
getImsPhone()1887     public Phone getImsPhone();
1888 
1889     /**
1890      * Release the local instance of the ImsPhone and disconnect from
1891      * the phone.
1892      * @return the instance of the ImsPhone phone previously owned
1893      */
relinquishOwnershipOfImsPhone()1894     public ImsPhone relinquishOwnershipOfImsPhone();
1895 
1896     /**
1897      * Take ownership and wire-up the input ImsPhone
1898      * @param imsPhone ImsPhone to be used.
1899      */
acquireOwnershipOfImsPhone(ImsPhone imsPhone)1900     public void acquireOwnershipOfImsPhone(ImsPhone imsPhone);
1901 
1902     /**
1903      * Return the service state of mImsPhone if it is STATE_IN_SERVICE
1904      * otherwise return the current voice service state
1905      */
getVoicePhoneServiceState()1906     int getVoicePhoneServiceState();
1907 
1908     /**
1909      * Override the service provider name and the operator name for the current ICCID.
1910      */
setOperatorBrandOverride(String brand)1911     public boolean setOperatorBrandOverride(String brand);
1912 
1913     /**
1914      * Override the roaming indicator for the current ICCID.
1915      */
setRoamingOverride(List<String> gsmRoamingList, List<String> gsmNonRoamingList, List<String> cdmaRoamingList, List<String> cdmaNonRoamingList)1916     public boolean setRoamingOverride(List<String> gsmRoamingList,
1917             List<String> gsmNonRoamingList, List<String> cdmaRoamingList,
1918             List<String> cdmaNonRoamingList);
1919 
1920     /**
1921      * Is Radio Present on the device and is it accessible
1922      */
isRadioAvailable()1923     public boolean isRadioAvailable();
1924 
1925     /**
1926      * shutdown Radio gracefully
1927      */
shutdownRadio()1928     public void shutdownRadio();
1929 
1930     /**
1931      *  Set phone radio capability
1932      *
1933      *  @param rc the phone radio capability defined in
1934      *         RadioCapability. It's a input object used to transfer parameter to logic modem
1935      *  @param response Callback message.
1936      */
setRadioCapability(RadioCapability rc, Message response)1937     public void setRadioCapability(RadioCapability rc, Message response);
1938 
1939     /**
1940      *  Get phone radio access family
1941      *
1942      *  @return a bit mask to identify the radio access family.
1943      */
getRadioAccessFamily()1944     public int getRadioAccessFamily();
1945 
1946     /**
1947      *  Get supported phone radio access family
1948      *
1949      *  @return a bit mask to identify the radio access family.
1950      */
getSupportedRadioAccessFamily()1951     public int getSupportedRadioAccessFamily();
1952 
1953     /**
1954      * Registers the handler when phone radio  capability is changed.
1955      *
1956      * @param h Handler for notification message.
1957      * @param what User-defined message code.
1958      * @param obj User object.
1959      */
registerForRadioCapabilityChanged(Handler h, int what, Object obj)1960     public void registerForRadioCapabilityChanged(Handler h, int what, Object obj);
1961 
1962     /**
1963      * Unregister for notifications when phone radio type and access technology is changed.
1964      *
1965      * @param h Handler to be removed from the registrant list.
1966      */
unregisterForRadioCapabilityChanged(Handler h)1967     public void unregisterForRadioCapabilityChanged(Handler h);
1968 
1969     /**
1970      * Query the IMS Registration Status.
1971      *
1972      * @return true if IMS is Registered
1973      */
isImsRegistered()1974     public boolean isImsRegistered();
1975 }
1976