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