| /* |
| * Copyright (C) 2007 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.internal.telephony; |
| |
| import android.content.Context; |
| import android.net.LinkProperties; |
| import android.net.NetworkCapabilities; |
| import android.os.Handler; |
| import android.os.Message; |
| import android.telephony.CellInfo; |
| import android.telephony.CellLocation; |
| import android.telephony.PhoneStateListener; |
| import android.telephony.ServiceState; |
| import android.telephony.SignalStrength; |
| |
| import com.android.internal.telephony.imsphone.ImsPhone; |
| import com.android.internal.telephony.RadioCapability; |
| import com.android.internal.telephony.test.SimulatedRadioControl; |
| import com.android.internal.telephony.uicc.IsimRecords; |
| import com.android.internal.telephony.uicc.UiccCard; |
| import com.android.internal.telephony.uicc.UsimServiceTable; |
| |
| import com.android.internal.telephony.PhoneConstants.*; // ???? |
| |
| import java.util.List; |
| |
| /** |
| * Internal interface used to control the phone; SDK developers cannot |
| * obtain this interface. |
| * |
| * {@hide} |
| * |
| */ |
| public interface Phone { |
| |
| /** used to enable additional debug messages */ |
| static final boolean DEBUG_PHONE = true; |
| |
| public enum DataActivityState { |
| /** |
| * The state of a data activity. |
| * <ul> |
| * <li>NONE = No traffic</li> |
| * <li>DATAIN = Receiving IP ppp traffic</li> |
| * <li>DATAOUT = Sending IP ppp traffic</li> |
| * <li>DATAINANDOUT = Both receiving and sending IP ppp traffic</li> |
| * <li>DORMANT = The data connection is still active, |
| but physical link is down</li> |
| * </ul> |
| */ |
| NONE, DATAIN, DATAOUT, DATAINANDOUT, DORMANT; |
| } |
| |
| enum SuppService { |
| UNKNOWN, SWITCH, SEPARATE, TRANSFER, CONFERENCE, REJECT, HANGUP, RESUME; |
| } |
| |
| // "Features" accessible through the connectivity manager |
| static final String FEATURE_ENABLE_MMS = "enableMMS"; |
| static final String FEATURE_ENABLE_SUPL = "enableSUPL"; |
| static final String FEATURE_ENABLE_DUN = "enableDUN"; |
| static final String FEATURE_ENABLE_HIPRI = "enableHIPRI"; |
| static final String FEATURE_ENABLE_DUN_ALWAYS = "enableDUNAlways"; |
| static final String FEATURE_ENABLE_FOTA = "enableFOTA"; |
| static final String FEATURE_ENABLE_IMS = "enableIMS"; |
| static final String FEATURE_ENABLE_CBS = "enableCBS"; |
| static final String FEATURE_ENABLE_EMERGENCY = "enableEmergency"; |
| |
| /** |
| * Optional reasons for disconnect and connect |
| */ |
| static final String REASON_ROAMING_ON = "roamingOn"; |
| static final String REASON_ROAMING_OFF = "roamingOff"; |
| static final String REASON_DATA_DISABLED = "dataDisabled"; |
| static final String REASON_DATA_ENABLED = "dataEnabled"; |
| static final String REASON_DATA_ATTACHED = "dataAttached"; |
| static final String REASON_DATA_DETACHED = "dataDetached"; |
| static final String REASON_CDMA_DATA_ATTACHED = "cdmaDataAttached"; |
| static final String REASON_CDMA_DATA_DETACHED = "cdmaDataDetached"; |
| static final String REASON_APN_CHANGED = "apnChanged"; |
| static final String REASON_APN_SWITCHED = "apnSwitched"; |
| static final String REASON_APN_FAILED = "apnFailed"; |
| static final String REASON_RESTORE_DEFAULT_APN = "restoreDefaultApn"; |
| static final String REASON_RADIO_TURNED_OFF = "radioTurnedOff"; |
| static final String REASON_PDP_RESET = "pdpReset"; |
| static final String REASON_VOICE_CALL_ENDED = "2GVoiceCallEnded"; |
| static final String REASON_VOICE_CALL_STARTED = "2GVoiceCallStarted"; |
| static final String REASON_PS_RESTRICT_ENABLED = "psRestrictEnabled"; |
| static final String REASON_PS_RESTRICT_DISABLED = "psRestrictDisabled"; |
| static final String REASON_SIM_LOADED = "simLoaded"; |
| static final String REASON_NW_TYPE_CHANGED = "nwTypeChanged"; |
| static final String REASON_DATA_DEPENDENCY_MET = "dependencyMet"; |
| static final String REASON_DATA_DEPENDENCY_UNMET = "dependencyUnmet"; |
| static final String REASON_LOST_DATA_CONNECTION = "lostDataConnection"; |
| static final String REASON_CONNECTED = "connected"; |
| static final String REASON_SINGLE_PDN_ARBITRATION = "SinglePdnArbitration"; |
| static final String REASON_DATA_SPECIFIC_DISABLED = "specificDisabled"; |
| static final String REASON_SIM_NOT_READY = "simNotReady"; |
| |
| // Used for band mode selection methods |
| static final int BM_UNSPECIFIED = 0; // selected by baseband automatically |
| static final int BM_EURO_BAND = 1; // GSM-900 / DCS-1800 / WCDMA-IMT-2000 |
| static final int BM_US_BAND = 2; // GSM-850 / PCS-1900 / WCDMA-850 / WCDMA-PCS-1900 |
| static final int BM_JPN_BAND = 3; // WCDMA-800 / WCDMA-IMT-2000 |
| static final int BM_AUS_BAND = 4; // GSM-900 / DCS-1800 / WCDMA-850 / WCDMA-IMT-2000 |
| static final int BM_AUS2_BAND = 5; // GSM-900 / DCS-1800 / WCDMA-850 |
| static final int BM_BOUNDARY = 6; // upper band boundary |
| |
| // Used for preferred network type |
| // Note NT_* substitute RILConstants.NETWORK_MODE_* above the Phone |
| int NT_MODE_WCDMA_PREF = RILConstants.NETWORK_MODE_WCDMA_PREF; |
| int NT_MODE_GSM_ONLY = RILConstants.NETWORK_MODE_GSM_ONLY; |
| int NT_MODE_WCDMA_ONLY = RILConstants.NETWORK_MODE_WCDMA_ONLY; |
| int NT_MODE_GSM_UMTS = RILConstants.NETWORK_MODE_GSM_UMTS; |
| |
| int NT_MODE_CDMA = RILConstants.NETWORK_MODE_CDMA; |
| |
| int NT_MODE_CDMA_NO_EVDO = RILConstants.NETWORK_MODE_CDMA_NO_EVDO; |
| int NT_MODE_EVDO_NO_CDMA = RILConstants.NETWORK_MODE_EVDO_NO_CDMA; |
| int NT_MODE_GLOBAL = RILConstants.NETWORK_MODE_GLOBAL; |
| |
| int NT_MODE_LTE_CDMA_AND_EVDO = RILConstants.NETWORK_MODE_LTE_CDMA_EVDO; |
| int NT_MODE_LTE_GSM_WCDMA = RILConstants.NETWORK_MODE_LTE_GSM_WCDMA; |
| int NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA = RILConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA; |
| int NT_MODE_LTE_ONLY = RILConstants.NETWORK_MODE_LTE_ONLY; |
| int NT_MODE_LTE_WCDMA = RILConstants.NETWORK_MODE_LTE_WCDMA; |
| int PREFERRED_NT_MODE = RILConstants.PREFERRED_NETWORK_MODE; |
| |
| // Used for CDMA roaming mode |
| static final int CDMA_RM_HOME = 0; // Home Networks only, as defined in PRL |
| static final int CDMA_RM_AFFILIATED = 1; // Roaming an Affiliated networks, as defined in PRL |
| static final int CDMA_RM_ANY = 2; // Roaming on Any Network, as defined in PRL |
| |
| // Used for CDMA subscription mode |
| static final int CDMA_SUBSCRIPTION_UNKNOWN =-1; // Unknown |
| static final int CDMA_SUBSCRIPTION_RUIM_SIM = 0; // RUIM/SIM (default) |
| static final int CDMA_SUBSCRIPTION_NV = 1; // NV -> non-volatile memory |
| |
| static final int PREFERRED_CDMA_SUBSCRIPTION = CDMA_SUBSCRIPTION_NV; |
| |
| static final int TTY_MODE_OFF = 0; |
| static final int TTY_MODE_FULL = 1; |
| static final int TTY_MODE_HCO = 2; |
| static final int TTY_MODE_VCO = 3; |
| |
| /** |
| * CDMA OTA PROVISION STATUS, the same as RIL_CDMA_OTA_Status in ril.h |
| */ |
| |
| public static final int CDMA_OTA_PROVISION_STATUS_SPL_UNLOCKED = 0; |
| public static final int CDMA_OTA_PROVISION_STATUS_SPC_RETRIES_EXCEEDED = 1; |
| public static final int CDMA_OTA_PROVISION_STATUS_A_KEY_EXCHANGED = 2; |
| public static final int CDMA_OTA_PROVISION_STATUS_SSD_UPDATED = 3; |
| public static final int CDMA_OTA_PROVISION_STATUS_NAM_DOWNLOADED = 4; |
| public static final int CDMA_OTA_PROVISION_STATUS_MDN_DOWNLOADED = 5; |
| public static final int CDMA_OTA_PROVISION_STATUS_IMSI_DOWNLOADED = 6; |
| public static final int CDMA_OTA_PROVISION_STATUS_PRL_DOWNLOADED = 7; |
| public static final int CDMA_OTA_PROVISION_STATUS_COMMITTED = 8; |
| public static final int CDMA_OTA_PROVISION_STATUS_OTAPA_STARTED = 9; |
| public static final int CDMA_OTA_PROVISION_STATUS_OTAPA_STOPPED = 10; |
| public static final int CDMA_OTA_PROVISION_STATUS_OTAPA_ABORTED = 11; |
| |
| |
| /** |
| * Get the current ServiceState. Use |
| * <code>registerForServiceStateChanged</code> to be informed of |
| * updates. |
| */ |
| ServiceState getServiceState(); |
| |
| /** |
| * Get the current CellLocation. |
| */ |
| CellLocation getCellLocation(); |
| |
| /** |
| * @return all available cell information or null if none. |
| */ |
| public List<CellInfo> getAllCellInfo(); |
| |
| /** |
| * Sets the minimum time in milli-seconds between {@link PhoneStateListener#onCellInfoChanged |
| * PhoneStateListener.onCellInfoChanged} will be invoked. |
| * |
| * The default, 0, means invoke onCellInfoChanged when any of the reported |
| * information changes. Setting the value to INT_MAX(0x7fffffff) means never issue |
| * A onCellInfoChanged. |
| * |
| * @param rateInMillis the rate |
| */ |
| public void setCellInfoListRate(int rateInMillis); |
| |
| /** |
| * Get the current for the default apn DataState. No change notification |
| * exists at this interface -- use |
| * {@link android.telephony.PhoneStateListener} instead. |
| */ |
| DataState getDataConnectionState(); |
| |
| /** |
| * Get the current DataState. No change notification exists at this |
| * interface -- use |
| * {@link android.telephony.PhoneStateListener} instead. |
| * @param apnType specify for which apn to get connection state info. |
| */ |
| DataState getDataConnectionState(String apnType); |
| |
| /** |
| * Get the current DataActivityState. No change notification exists at this |
| * interface -- use |
| * {@link android.telephony.TelephonyManager} instead. |
| */ |
| DataActivityState getDataActivityState(); |
| |
| /** |
| * Gets the context for the phone, as set at initialization time. |
| */ |
| Context getContext(); |
| |
| /** |
| * Disables the DNS check (i.e., allows "0.0.0.0"). |
| * Useful for lab testing environment. |
| * @param b true disables the check, false enables. |
| */ |
| void disableDnsCheck(boolean b); |
| |
| /** |
| * Returns true if the DNS check is currently disabled. |
| */ |
| boolean isDnsCheckDisabled(); |
| |
| /** |
| * Get current coarse-grained voice call state. |
| * Use {@link #registerForPreciseCallStateChanged(Handler, int, Object) |
| * registerForPreciseCallStateChanged()} for change notification. <p> |
| * If the phone has an active call and call waiting occurs, |
| * then the phone state is RINGING not OFFHOOK |
| * <strong>Note:</strong> |
| * This registration point provides notification of finer-grained |
| * changes.<p> |
| * |
| */ |
| State getState(); |
| |
| /** |
| * Returns a string identifier for this phone interface for parties |
| * outside the phone app process. |
| * @return The string name. |
| */ |
| String getPhoneName(); |
| |
| /** |
| * Return a numerical identifier for the phone radio interface. |
| * @return PHONE_TYPE_XXX as defined above. |
| */ |
| int getPhoneType(); |
| |
| /** |
| * Returns an array of string identifiers for the APN types serviced by the |
| * currently active. |
| * @return The string array will always return at least one entry, Phone.APN_TYPE_DEFAULT. |
| * TODO: Revisit if we always should return at least one entry. |
| */ |
| String[] getActiveApnTypes(); |
| |
| /** |
| * Check if TETHER_DUN_APN setting or config_tether_apndata includes APN that matches |
| * current operator. |
| * @return true if there is a matching DUN APN. |
| */ |
| boolean hasMatchedTetherApnSetting(); |
| |
| /** |
| * Returns string for the active APN host. |
| * @return type as a string or null if none. |
| */ |
| String getActiveApnHost(String apnType); |
| |
| /** |
| * Return the LinkProperties for the named apn or null if not available |
| */ |
| LinkProperties getLinkProperties(String apnType); |
| |
| /** |
| * Return the NetworkCapabilities |
| */ |
| NetworkCapabilities getNetworkCapabilities(String apnType); |
| |
| /** |
| * Get current signal strength. No change notification available on this |
| * interface. Use <code>PhoneStateNotifier</code> or an equivalent. |
| * An ASU is 0-31 or -1 if unknown (for GSM, dBm = -113 - 2 * asu). |
| * The following special values are defined:</p> |
| * <ul><li>0 means "-113 dBm or less".</li> |
| * <li>31 means "-51 dBm or greater".</li></ul> |
| * |
| * @return Current signal strength as SignalStrength |
| */ |
| SignalStrength getSignalStrength(); |
| |
| /** |
| * Notifies when a previously untracked non-ringing/waiting connection has appeared. |
| * This is likely due to some other entity (eg, SIM card application) initiating a call. |
| */ |
| void registerForUnknownConnection(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for unknown connection notifications. |
| */ |
| void unregisterForUnknownConnection(Handler h); |
| |
| /** |
| * Notifies when a Handover happens due to SRVCC or Silent Redial |
| */ |
| void registerForHandoverStateChanged(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for handover state notifications |
| */ |
| void unregisterForHandoverStateChanged(Handler h); |
| |
| /** |
| * Register for getting notifications for change in the Call State {@link Call.State} |
| * This is called PreciseCallState because the call state is more precise than the |
| * {@link PhoneConstants.State} which can be obtained using the {@link PhoneStateListener} |
| * |
| * Resulting events will have an AsyncResult in <code>Message.obj</code>. |
| * AsyncResult.userData will be set to the obj argument here. |
| * The <em>h</em> parameter is held only by a weak reference. |
| */ |
| void registerForPreciseCallStateChanged(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for voice call state change notifications. |
| * Extraneous calls are tolerated silently. |
| */ |
| void unregisterForPreciseCallStateChanged(Handler h); |
| |
| /** |
| * Notifies when a new ringing or waiting connection has appeared.<p> |
| * |
| * Messages received from this: |
| * Message.obj will be an AsyncResult |
| * AsyncResult.userObj = obj |
| * AsyncResult.result = a Connection. <p> |
| * Please check Connection.isRinging() to make sure the Connection |
| * has not dropped since this message was posted. |
| * If Connection.isRinging() is true, then |
| * Connection.getCall() == Phone.getRingingCall() |
| */ |
| void registerForNewRingingConnection(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for new ringing connection notification. |
| * Extraneous calls are tolerated silently |
| */ |
| |
| void unregisterForNewRingingConnection(Handler h); |
| |
| /** |
| * Notifies when an incoming call rings.<p> |
| * |
| * Messages received from this: |
| * Message.obj will be an AsyncResult |
| * AsyncResult.userObj = obj |
| * AsyncResult.result = a Connection. <p> |
| */ |
| void registerForIncomingRing(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for ring notification. |
| * Extraneous calls are tolerated silently |
| */ |
| |
| void unregisterForIncomingRing(Handler h); |
| |
| /** |
| * Notifies when out-band ringback tone is needed.<p> |
| * |
| * Messages received from this: |
| * Message.obj will be an AsyncResult |
| * AsyncResult.userObj = obj |
| * AsyncResult.result = boolean, true to start play ringback tone |
| * and false to stop. <p> |
| */ |
| void registerForRingbackTone(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for ringback tone notification. |
| */ |
| |
| void unregisterForRingbackTone(Handler h); |
| |
| /** |
| * Notifies when out-band on-hold tone is needed.<p> |
| * |
| * Messages received from this: |
| * Message.obj will be an AsyncResult |
| * AsyncResult.userObj = obj |
| * AsyncResult.result = boolean, true to start play on-hold tone |
| * and false to stop. <p> |
| */ |
| void registerForOnHoldTone(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for on-hold tone notification. |
| */ |
| |
| void unregisterForOnHoldTone(Handler h); |
| |
| /** |
| * Registers the handler to reset the uplink mute state to get |
| * uplink audio. |
| */ |
| void registerForResendIncallMute(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for resend incall mute notifications. |
| */ |
| void unregisterForResendIncallMute(Handler h); |
| |
| /** |
| * Notifies when a voice connection has disconnected, either due to local |
| * or remote hangup or error. |
| * |
| * Messages received from this will have the following members:<p> |
| * <ul><li>Message.obj will be an AsyncResult</li> |
| * <li>AsyncResult.userObj = obj</li> |
| * <li>AsyncResult.result = a Connection object that is |
| * no longer connected.</li></ul> |
| */ |
| void registerForDisconnect(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for voice disconnection notification. |
| * Extraneous calls are tolerated silently |
| */ |
| void unregisterForDisconnect(Handler h); |
| |
| |
| /** |
| * Register for notifications of initiation of a new MMI code request. |
| * MMI codes for GSM are discussed in 3GPP TS 22.030.<p> |
| * |
| * Example: If Phone.dial is called with "*#31#", then the app will |
| * be notified here.<p> |
| * |
| * The returned <code>Message.obj</code> will contain an AsyncResult. |
| * |
| * <code>obj.result</code> will be an "MmiCode" object. |
| */ |
| void registerForMmiInitiate(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for new MMI initiate notification. |
| * Extraneous calls are tolerated silently |
| */ |
| void unregisterForMmiInitiate(Handler h); |
| |
| /** |
| * Register for notifications that an MMI request has completed |
| * its network activity and is in its final state. This may mean a state |
| * of COMPLETE, FAILED, or CANCELLED. |
| * |
| * <code>Message.obj</code> will contain an AsyncResult. |
| * <code>obj.result</code> will be an "MmiCode" object |
| */ |
| void registerForMmiComplete(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for MMI complete notification. |
| * Extraneous calls are tolerated silently |
| */ |
| void unregisterForMmiComplete(Handler h); |
| |
| /** |
| * Registration point for Ecm timer reset |
| * @param h handler to notify |
| * @param what user-defined message code |
| * @param obj placed in Message.obj |
| */ |
| public void registerForEcmTimerReset(Handler h, int what, Object obj); |
| |
| /** |
| * Unregister for notification for Ecm timer reset |
| * @param h Handler to be removed from the registrant list. |
| */ |
| public void unregisterForEcmTimerReset(Handler h); |
| |
| /** |
| * Returns a list of MMI codes that are pending. (They have initiated |
| * but have not yet completed). |
| * Presently there is only ever one. |
| * Use <code>registerForMmiInitiate</code> |
| * and <code>registerForMmiComplete</code> for change notification. |
| */ |
| public List<? extends MmiCode> getPendingMmiCodes(); |
| |
| /** |
| * Sends user response to a USSD REQUEST message. An MmiCode instance |
| * representing this response is sent to handlers registered with |
| * registerForMmiInitiate. |
| * |
| * @param ussdMessge Message to send in the response. |
| */ |
| public void sendUssdResponse(String ussdMessge); |
| |
| /** |
| * Register for ServiceState changed. |
| * Message.obj will contain an AsyncResult. |
| * AsyncResult.result will be a ServiceState instance |
| */ |
| void registerForServiceStateChanged(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for ServiceStateChange notification. |
| * Extraneous calls are tolerated silently |
| */ |
| void unregisterForServiceStateChanged(Handler h); |
| |
| /** |
| * Register for Supplementary Service notifications from the network. |
| * Message.obj will contain an AsyncResult. |
| * AsyncResult.result will be a SuppServiceNotification instance. |
| * |
| * @param h Handler that receives the notification message. |
| * @param what User-defined message code. |
| * @param obj User object. |
| */ |
| void registerForSuppServiceNotification(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for Supplementary Service notifications. |
| * Extraneous calls are tolerated silently |
| * |
| * @param h Handler to be removed from the registrant list. |
| */ |
| void unregisterForSuppServiceNotification(Handler h); |
| |
| /** |
| * Register for notifications when a supplementary service attempt fails. |
| * Message.obj will contain an AsyncResult. |
| * |
| * @param h Handler that receives the notification message. |
| * @param what User-defined message code. |
| * @param obj User object. |
| */ |
| void registerForSuppServiceFailed(Handler h, int what, Object obj); |
| |
| /** |
| * Unregister for notifications when a supplementary service attempt fails. |
| * Extraneous calls are tolerated silently |
| * |
| * @param h Handler to be removed from the registrant list. |
| */ |
| void unregisterForSuppServiceFailed(Handler h); |
| |
| /** |
| * Register for notifications when a sInCall VoicePrivacy is enabled |
| * |
| * @param h Handler that receives the notification message. |
| * @param what User-defined message code. |
| * @param obj User object. |
| */ |
| void registerForInCallVoicePrivacyOn(Handler h, int what, Object obj); |
| |
| /** |
| * Unegister for notifications when a sInCall VoicePrivacy is enabled |
| * |
| * @param h Handler to be removed from the registrant list. |
| */ |
| void unregisterForInCallVoicePrivacyOn(Handler h); |
| |
| /** |
| * Register for notifications when a sInCall VoicePrivacy is disabled |
| * |
| * @param h Handler that receives the notification message. |
| * @param what User-defined message code. |
| * @param obj User object. |
| */ |
| void registerForInCallVoicePrivacyOff(Handler h, int what, Object obj); |
| |
| /** |
| * Unregister for notifications when a sInCall VoicePrivacy is disabled |
| * |
| * @param h Handler to be removed from the registrant list. |
| */ |
| void unregisterForInCallVoicePrivacyOff(Handler h); |
| |
| /** |
| * Register for notifications when CDMA OTA Provision status change |
| * |
| * @param h Handler that receives the notification message. |
| * @param what User-defined message code. |
| * @param obj User object. |
| */ |
| void registerForCdmaOtaStatusChange(Handler h, int what, Object obj); |
| |
| /** |
| * Unregister for notifications when CDMA OTA Provision status change |
| * @param h Handler to be removed from the registrant list. |
| */ |
| void unregisterForCdmaOtaStatusChange(Handler h); |
| |
| /** |
| * Registration point for subscription info ready |
| * @param h handler to notify |
| * @param what what code of message when delivered |
| * @param obj placed in Message.obj |
| */ |
| public void registerForSubscriptionInfoReady(Handler h, int what, Object obj); |
| |
| /** |
| * Unregister for notifications for subscription info |
| * @param h Handler to be removed from the registrant list. |
| */ |
| public void unregisterForSubscriptionInfoReady(Handler h); |
| |
| /** |
| * Registration point for Sim records loaded |
| * @param h handler to notify |
| * @param what what code of message when delivered |
| * @param obj placed in Message.obj |
| */ |
| public void registerForSimRecordsLoaded(Handler h, int what, Object obj); |
| |
| /** |
| * Unregister for notifications for Sim records loaded |
| * @param h Handler to be removed from the registrant list. |
| */ |
| public void unregisterForSimRecordsLoaded(Handler h); |
| |
| /** |
| * Register for TTY mode change notifications from the network. |
| * Message.obj will contain an AsyncResult. |
| * AsyncResult.result will be an Integer containing new mode. |
| * |
| * @param h Handler that receives the notification message. |
| * @param what User-defined message code. |
| * @param obj User object. |
| */ |
| public void registerForTtyModeReceived(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for TTY mode change notifications. |
| * Extraneous calls are tolerated silently |
| * |
| * @param h Handler to be removed from the registrant list. |
| */ |
| public void unregisterForTtyModeReceived(Handler h); |
| |
| /** |
| * Returns SIM record load state. Use |
| * <code>getSimCard().registerForReady()</code> for change notification. |
| * |
| * @return true if records from the SIM have been loaded and are |
| * available (if applicable). If not applicable to the underlying |
| * technology, returns true as well. |
| */ |
| boolean getIccRecordsLoaded(); |
| |
| /** |
| * Returns the ICC card interface for this phone, or null |
| * if not applicable to underlying technology. |
| */ |
| IccCard getIccCard(); |
| |
| /** |
| * Answers a ringing or waiting call. Active calls, if any, go on hold. |
| * Answering occurs asynchronously, and final notification occurs via |
| * {@link #registerForPreciseCallStateChanged(android.os.Handler, int, |
| * java.lang.Object) registerForPreciseCallStateChanged()}. |
| * |
| * @param videoState The video state in which to answer the call. |
| * @exception CallStateException when no call is ringing or waiting |
| */ |
| void acceptCall(int videoState) throws CallStateException; |
| |
| /** |
| * Reject (ignore) a ringing call. In GSM, this means UDUB |
| * (User Determined User Busy). Reject occurs asynchronously, |
| * and final notification occurs via |
| * {@link #registerForPreciseCallStateChanged(android.os.Handler, int, |
| * java.lang.Object) registerForPreciseCallStateChanged()}. |
| * |
| * @exception CallStateException when no call is ringing or waiting |
| */ |
| void rejectCall() throws CallStateException; |
| |
| /** |
| * Places any active calls on hold, and makes any held calls |
| * active. Switch occurs asynchronously and may fail. |
| * Final notification occurs via |
| * {@link #registerForPreciseCallStateChanged(android.os.Handler, int, |
| * java.lang.Object) registerForPreciseCallStateChanged()}. |
| * |
| * @exception CallStateException if a call is ringing, waiting, or |
| * dialing/alerting. In these cases, this operation may not be performed. |
| */ |
| void switchHoldingAndActive() throws CallStateException; |
| |
| /** |
| * Whether or not the phone can conference in the current phone |
| * state--that is, one call holding and one call active. |
| * @return true if the phone can conference; false otherwise. |
| */ |
| boolean canConference(); |
| |
| /** |
| * Conferences holding and active. Conference occurs asynchronously |
| * and may fail. Final notification occurs via |
| * {@link #registerForPreciseCallStateChanged(android.os.Handler, int, |
| * java.lang.Object) registerForPreciseCallStateChanged()}. |
| * |
| * @exception CallStateException if canConference() would return false. |
| * In these cases, this operation may not be performed. |
| */ |
| void conference() throws CallStateException; |
| |
| /** |
| * Enable or disable enhanced Voice Privacy (VP). If enhanced VP is |
| * disabled, normal VP is enabled. |
| * |
| * @param enable whether true or false to enable or disable. |
| * @param onComplete a callback message when the action is completed. |
| */ |
| void enableEnhancedVoicePrivacy(boolean enable, Message onComplete); |
| |
| /** |
| * Get the currently set Voice Privacy (VP) mode. |
| * |
| * @param onComplete a callback message when the action is completed. |
| */ |
| void getEnhancedVoicePrivacy(Message onComplete); |
| |
| /** |
| * Whether or not the phone can do explicit call transfer in the current |
| * phone state--that is, one call holding and one call active. |
| * @return true if the phone can do explicit call transfer; false otherwise. |
| */ |
| boolean canTransfer(); |
| |
| /** |
| * Connects the two calls and disconnects the subscriber from both calls |
| * Explicit Call Transfer occurs asynchronously |
| * and may fail. Final notification occurs via |
| * {@link #registerForPreciseCallStateChanged(android.os.Handler, int, |
| * java.lang.Object) registerForPreciseCallStateChanged()}. |
| * |
| * @exception CallStateException if canTransfer() would return false. |
| * In these cases, this operation may not be performed. |
| */ |
| void explicitCallTransfer() throws CallStateException; |
| |
| /** |
| * Clears all DISCONNECTED connections from Call connection lists. |
| * Calls that were in the DISCONNECTED state become idle. This occurs |
| * synchronously. |
| */ |
| void clearDisconnected(); |
| |
| |
| /** |
| * Gets the foreground call object, which represents all connections that |
| * are dialing or active (all connections |
| * that have their audio path connected).<p> |
| * |
| * The foreground call is a singleton object. It is constant for the life |
| * of this phone. It is never null.<p> |
| * |
| * The foreground call will only ever be in one of these states: |
| * IDLE, ACTIVE, DIALING, ALERTING, or DISCONNECTED. |
| * |
| * State change notification is available via |
| * {@link #registerForPreciseCallStateChanged(android.os.Handler, int, |
| * java.lang.Object) registerForPreciseCallStateChanged()}. |
| */ |
| Call getForegroundCall(); |
| |
| /** |
| * Gets the background call object, which represents all connections that |
| * are holding (all connections that have been accepted or connected, but |
| * do not have their audio path connected). <p> |
| * |
| * The background call is a singleton object. It is constant for the life |
| * of this phone object . It is never null.<p> |
| * |
| * The background call will only ever be in one of these states: |
| * IDLE, HOLDING or DISCONNECTED. |
| * |
| * State change notification is available via |
| * {@link #registerForPreciseCallStateChanged(android.os.Handler, int, |
| * java.lang.Object) registerForPreciseCallStateChanged()}. |
| */ |
| Call getBackgroundCall(); |
| |
| /** |
| * Gets the ringing call object, which represents an incoming |
| * connection (if present) that is pending answer/accept. (This connection |
| * may be RINGING or WAITING, and there may be only one.)<p> |
| |
| * The ringing call is a singleton object. It is constant for the life |
| * of this phone. It is never null.<p> |
| * |
| * The ringing call will only ever be in one of these states: |
| * IDLE, INCOMING, WAITING or DISCONNECTED. |
| * |
| * State change notification is available via |
| * {@link #registerForPreciseCallStateChanged(android.os.Handler, int, |
| * java.lang.Object) registerForPreciseCallStateChanged()}. |
| */ |
| Call getRingingCall(); |
| |
| /** |
| * Initiate a new voice connection. This happens asynchronously, so you |
| * cannot assume the audio path is connected (or a call index has been |
| * assigned) until PhoneStateChanged notification has occurred. |
| * |
| * @param dialString The dial string. |
| * @param videoState The desired video state for the connection. |
| * @exception CallStateException if a new outgoing call is not currently |
| * possible because no more call slots exist or a call exists that is |
| * dialing, alerting, ringing, or waiting. Other errors are |
| * handled asynchronously. |
| */ |
| Connection dial(String dialString, int videoState) throws CallStateException; |
| |
| /** |
| * Initiate a new voice connection with supplementary User to User |
| * Information. This happens asynchronously, so you cannot assume the audio |
| * path is connected (or a call index has been assigned) until |
| * PhoneStateChanged notification has occurred. |
| * |
| * @param dialString The dial string. |
| * @param uusInfo The UUSInfo. |
| * @param videoState The desired video state for the connection. |
| * @exception CallStateException if a new outgoing call is not currently |
| * possible because no more call slots exist or a call exists |
| * that is dialing, alerting, ringing, or waiting. Other |
| * errors are handled asynchronously. |
| */ |
| Connection dial(String dialString, UUSInfo uusInfo, int videoState) throws CallStateException; |
| |
| /** |
| * Handles PIN MMI commands (PIN/PIN2/PUK/PUK2), which are initiated |
| * without SEND (so <code>dial</code> is not appropriate). |
| * |
| * @param dialString the MMI command to be executed. |
| * @return true if MMI command is executed. |
| */ |
| boolean handlePinMmi(String dialString); |
| |
| /** |
| * Handles in-call MMI commands. While in a call, or while receiving a |
| * call, use this to execute MMI commands. |
| * see 3GPP 20.030, section 6.5.5.1 for specs on the allowed MMI commands. |
| * |
| * @param command the MMI command to be executed. |
| * @return true if the MMI command is executed. |
| * @throws CallStateException |
| */ |
| boolean handleInCallMmiCommands(String command) throws CallStateException; |
| |
| /** |
| * Play a DTMF tone on the active call. Ignored if there is no active call. |
| * @param c should be one of 0-9, '*' or '#'. Other values will be |
| * silently ignored. |
| */ |
| void sendDtmf(char c); |
| |
| /** |
| * Start to paly a DTMF tone on the active call. Ignored if there is no active call |
| * or there is a playing DTMF tone. |
| * @param c should be one of 0-9, '*' or '#'. Other values will be |
| * silently ignored. |
| */ |
| void startDtmf(char c); |
| |
| /** |
| * Stop the playing DTMF tone. Ignored if there is no playing DTMF |
| * tone or no active call. |
| */ |
| void stopDtmf(); |
| |
| /** |
| * send burst DTMF tone, it can send the string as single character or multiple character |
| * ignore if there is no active call or not valid digits string. |
| * Valid digit means only includes characters ISO-LATIN characters 0-9, *, # |
| * The difference between sendDtmf and sendBurstDtmf is sendDtmf only sends one character, |
| * this api can send single character and multiple character, also, this api has response |
| * back to caller. |
| * |
| * @param dtmfString is string representing the dialing digit(s) in the active call |
| * @param on the DTMF ON length in milliseconds, or 0 for default |
| * @param off the DTMF OFF length in milliseconds, or 0 for default |
| * @param onComplete is the callback message when the action is processed by BP |
| * |
| */ |
| void sendBurstDtmf(String dtmfString, int on, int off, Message onComplete); |
| |
| /** |
| * Sets the radio power on/off state (off is sometimes |
| * called "airplane mode"). Current state can be gotten via |
| * {@link #getServiceState()}.{@link |
| * android.telephony.ServiceState#getState() getState()}. |
| * <strong>Note: </strong>This request is asynchronous. |
| * getServiceState().getState() will not change immediately after this call. |
| * registerForServiceStateChanged() to find out when the |
| * request is complete. |
| * |
| * @param power true means "on", false means "off". |
| */ |
| void setRadioPower(boolean power); |
| |
| /** |
| * Get voice message waiting indicator status. No change notification |
| * available on this interface. Use PhoneStateNotifier or similar instead. |
| * |
| * @return true if there is a voice message waiting |
| */ |
| boolean getMessageWaitingIndicator(); |
| |
| /** |
| * Get voice call forwarding indicator status. No change notification |
| * available on this interface. Use PhoneStateNotifier or similar instead. |
| * |
| * @return true if there is a voice call forwarding |
| */ |
| boolean getCallForwardingIndicator(); |
| |
| /** |
| * Get the line 1 phone number (MSISDN). For CDMA phones, the MDN is returned |
| * and {@link #getMsisdn()} will return the MSISDN on CDMA/LTE phones.<p> |
| * |
| * @return phone number. May return null if not |
| * available or the SIM is not ready |
| */ |
| String getLine1Number(); |
| |
| /** |
| * Returns the alpha tag associated with the msisdn number. |
| * If there is no alpha tag associated or the record is not yet available, |
| * returns a default localized string. <p> |
| */ |
| String getLine1AlphaTag(); |
| |
| /** |
| * Sets the MSISDN phone number in the SIM card. |
| * |
| * @param alphaTag the alpha tag associated with the MSISDN phone number |
| * (see getMsisdnAlphaTag) |
| * @param number the new MSISDN phone number to be set on the SIM. |
| * @param onComplete a callback message when the action is completed. |
| * |
| * @return true if req is sent, false otherwise. If req is not sent there will be no response, |
| * that is, onComplete will never be sent. |
| */ |
| boolean setLine1Number(String alphaTag, String number, Message onComplete); |
| |
| /** |
| * Get the voice mail access phone number. Typically dialed when the |
| * user holds the "1" key in the phone app. May return null if not |
| * available or the SIM is not ready.<p> |
| */ |
| String getVoiceMailNumber(); |
| |
| /** |
| * Returns unread voicemail count. This count is shown when the voicemail |
| * notification is expanded.<p> |
| */ |
| int getVoiceMessageCount(); |
| |
| /** |
| * Returns the alpha tag associated with the voice mail number. |
| * If there is no alpha tag associated or the record is not yet available, |
| * returns a default localized string. <p> |
| * |
| * Please use this value instead of some other localized string when |
| * showing a name for this number in the UI. For example, call log |
| * entries should show this alpha tag. <p> |
| * |
| * Usage of this alpha tag in the UI is a common carrier requirement. |
| */ |
| String getVoiceMailAlphaTag(); |
| |
| /** |
| * setVoiceMailNumber |
| * sets the voicemail number in the SIM card. |
| * |
| * @param alphaTag the alpha tag associated with the voice mail number |
| * (see getVoiceMailAlphaTag) |
| * @param voiceMailNumber the new voicemail number to be set on the SIM. |
| * @param onComplete a callback message when the action is completed. |
| */ |
| void setVoiceMailNumber(String alphaTag, |
| String voiceMailNumber, |
| Message onComplete); |
| |
| /** |
| * getCallForwardingOptions |
| * gets a call forwarding option. The return value of |
| * ((AsyncResult)onComplete.obj) is an array of CallForwardInfo. |
| * |
| * @param commandInterfaceCFReason is one of the valid call forwarding |
| * CF_REASONS, as defined in |
| * <code>com.android.internal.telephony.CommandsInterface.</code> |
| * @param onComplete a callback message when the action is completed. |
| * @see com.android.internal.telephony.CallForwardInfo for details. |
| */ |
| void getCallForwardingOption(int commandInterfaceCFReason, |
| Message onComplete); |
| |
| /** |
| * setCallForwardingOptions |
| * sets a call forwarding option. |
| * |
| * @param commandInterfaceCFReason is one of the valid call forwarding |
| * CF_REASONS, as defined in |
| * <code>com.android.internal.telephony.CommandsInterface.</code> |
| * @param commandInterfaceCFAction is one of the valid call forwarding |
| * CF_ACTIONS, as defined in |
| * <code>com.android.internal.telephony.CommandsInterface.</code> |
| * @param dialingNumber is the target phone number to forward calls to |
| * @param timerSeconds is used by CFNRy to indicate the timeout before |
| * forwarding is attempted. |
| * @param onComplete a callback message when the action is completed. |
| */ |
| void setCallForwardingOption(int commandInterfaceCFReason, |
| int commandInterfaceCFAction, |
| String dialingNumber, |
| int timerSeconds, |
| Message onComplete); |
| |
| /** |
| * getOutgoingCallerIdDisplay |
| * gets outgoing caller id display. The return value of |
| * ((AsyncResult)onComplete.obj) is an array of int, with a length of 2. |
| * |
| * @param onComplete a callback message when the action is completed. |
| * @see com.android.internal.telephony.CommandsInterface#getCLIR for details. |
| */ |
| void getOutgoingCallerIdDisplay(Message onComplete); |
| |
| /** |
| * setOutgoingCallerIdDisplay |
| * sets a call forwarding option. |
| * |
| * @param commandInterfaceCLIRMode is one of the valid call CLIR |
| * modes, as defined in |
| * <code>com.android.internal.telephony.CommandsInterface./code> |
| * @param onComplete a callback message when the action is completed. |
| */ |
| void setOutgoingCallerIdDisplay(int commandInterfaceCLIRMode, |
| Message onComplete); |
| |
| /** |
| * getCallWaiting |
| * gets call waiting activation state. The return value of |
| * ((AsyncResult)onComplete.obj) is an array of int, with a length of 1. |
| * |
| * @param onComplete a callback message when the action is completed. |
| * @see com.android.internal.telephony.CommandsInterface#queryCallWaiting for details. |
| */ |
| void getCallWaiting(Message onComplete); |
| |
| /** |
| * setCallWaiting |
| * sets a call forwarding option. |
| * |
| * @param enable is a boolean representing the state that you are |
| * requesting, true for enabled, false for disabled. |
| * @param onComplete a callback message when the action is completed. |
| */ |
| void setCallWaiting(boolean enable, Message onComplete); |
| |
| /** |
| * Scan available networks. This method is asynchronous; . |
| * On completion, <code>response.obj</code> is set to an AsyncResult with |
| * one of the following members:.<p> |
| *<ul> |
| * <li><code>response.obj.result</code> will be a <code>List</code> of |
| * <code>OperatorInfo</code> objects, or</li> |
| * <li><code>response.obj.exception</code> will be set with an exception |
| * on failure.</li> |
| * </ul> |
| */ |
| void getAvailableNetworks(Message response); |
| |
| /** |
| * Switches network selection mode to "automatic", re-scanning and |
| * re-selecting a network if appropriate. |
| * |
| * @param response The message to dispatch when the network selection |
| * is complete. |
| * |
| * @see #selectNetworkManually(OperatorInfo, android.os.Message ) |
| */ |
| void setNetworkSelectionModeAutomatic(Message response); |
| |
| /** |
| * Manually selects a network. <code>response</code> is |
| * dispatched when this is complete. <code>response.obj</code> will be |
| * an AsyncResult, and <code>response.obj.exception</code> will be non-null |
| * on failure. |
| * |
| * @see #setNetworkSelectionModeAutomatic(Message) |
| */ |
| void selectNetworkManually(OperatorInfo network, |
| Message response); |
| |
| /** |
| * Query the radio for the current network selection mode. |
| * |
| * Return values: |
| * 0 - automatic. |
| * 1 - manual. |
| */ |
| void getNetworkSelectionMode(Message response); |
| |
| /** |
| * Requests to set the preferred network type for searching and registering |
| * (CS/PS domain, RAT, and operation mode) |
| * @param networkType one of NT_*_TYPE |
| * @param response is callback message |
| */ |
| void setPreferredNetworkType(int networkType, Message response); |
| |
| /** |
| * Query the preferred network type setting |
| * |
| * @param response is callback message to report one of NT_*_TYPE |
| */ |
| void getPreferredNetworkType(Message response); |
| |
| /** |
| * Gets the default SMSC address. |
| * |
| * @param result Callback message contains the SMSC address. |
| */ |
| void getSmscAddress(Message result); |
| |
| /** |
| * Sets the default SMSC address. |
| * |
| * @param address new SMSC address |
| * @param result Callback message is empty on completion |
| */ |
| void setSmscAddress(String address, Message result); |
| |
| /** |
| * Query neighboring cell IDs. <code>response</code> is dispatched when |
| * this is complete. <code>response.obj</code> will be an AsyncResult, |
| * and <code>response.obj.exception</code> will be non-null on failure. |
| * On success, <code>AsyncResult.result</code> will be a <code>String[]</code> |
| * containing the neighboring cell IDs. Index 0 will contain the count |
| * of available cell IDs. Cell IDs are in hexadecimal format. |
| * |
| * @param response callback message that is dispatched when the query |
| * completes. |
| */ |
| void getNeighboringCids(Message response); |
| |
| /** |
| * Sets an event to be fired when the telephony system processes |
| * a post-dial character on an outgoing call.<p> |
| * |
| * Messages of type <code>what</code> will be sent to <code>h</code>. |
| * The <code>obj</code> field of these Message's will be instances of |
| * <code>AsyncResult</code>. <code>Message.obj.result</code> will be |
| * a Connection object.<p> |
| * |
| * Message.arg1 will be the post dial character being processed, |
| * or 0 ('\0') if end of string.<p> |
| * |
| * If Connection.getPostDialState() == WAIT, |
| * the application must call |
| * {@link com.android.internal.telephony.Connection#proceedAfterWaitChar() |
| * Connection.proceedAfterWaitChar()} or |
| * {@link com.android.internal.telephony.Connection#cancelPostDial() |
| * Connection.cancelPostDial()} |
| * for the telephony system to continue playing the post-dial |
| * DTMF sequence.<p> |
| * |
| * If Connection.getPostDialState() == WILD, |
| * the application must call |
| * {@link com.android.internal.telephony.Connection#proceedAfterWildChar |
| * Connection.proceedAfterWildChar()} |
| * or |
| * {@link com.android.internal.telephony.Connection#cancelPostDial() |
| * Connection.cancelPostDial()} |
| * for the telephony system to continue playing the |
| * post-dial DTMF sequence.<p> |
| * |
| * Only one post dial character handler may be set. <p> |
| * Calling this method with "h" equal to null unsets this handler.<p> |
| */ |
| void setOnPostDialCharacter(Handler h, int what, Object obj); |
| |
| |
| /** |
| * Mutes or unmutes the microphone for the active call. The microphone |
| * is automatically unmuted if a call is answered, dialed, or resumed |
| * from a holding state. |
| * |
| * @param muted true to mute the microphone, |
| * false to activate the microphone. |
| */ |
| |
| void setMute(boolean muted); |
| |
| /** |
| * Gets current mute status. Use |
| * {@link #registerForPreciseCallStateChanged(android.os.Handler, int, |
| * java.lang.Object) registerForPreciseCallStateChanged()} |
| * as a change notifcation, although presently phone state changed is not |
| * fired when setMute() is called. |
| * |
| * @return true is muting, false is unmuting |
| */ |
| boolean getMute(); |
| |
| /** |
| * Enables or disables echo suppression. |
| */ |
| void setEchoSuppressionEnabled(); |
| |
| /** |
| * Invokes RIL_REQUEST_OEM_HOOK_RAW on RIL implementation. |
| * |
| * @param data The data for the request. |
| * @param response <strong>On success</strong>, |
| * (byte[])(((AsyncResult)response.obj).result) |
| * <strong>On failure</strong>, |
| * (((AsyncResult)response.obj).result) == null and |
| * (((AsyncResult)response.obj).exception) being an instance of |
| * com.android.internal.telephony.gsm.CommandException |
| * |
| * @see #invokeOemRilRequestRaw(byte[], android.os.Message) |
| */ |
| void invokeOemRilRequestRaw(byte[] data, Message response); |
| |
| /** |
| * Invokes RIL_REQUEST_OEM_HOOK_Strings on RIL implementation. |
| * |
| * @param strings The strings to make available as the request data. |
| * @param response <strong>On success</strong>, "response" bytes is |
| * made available as: |
| * (String[])(((AsyncResult)response.obj).result). |
| * <strong>On failure</strong>, |
| * (((AsyncResult)response.obj).result) == null and |
| * (((AsyncResult)response.obj).exception) being an instance of |
| * com.android.internal.telephony.gsm.CommandException |
| * |
| * @see #invokeOemRilRequestStrings(java.lang.String[], android.os.Message) |
| */ |
| void invokeOemRilRequestStrings(String[] strings, Message response); |
| |
| /** |
| * Get the current active Data Call list |
| * |
| * @param response <strong>On success</strong>, "response" bytes is |
| * made available as: |
| * (String[])(((AsyncResult)response.obj).result). |
| * <strong>On failure</strong>, |
| * (((AsyncResult)response.obj).result) == null and |
| * (((AsyncResult)response.obj).exception) being an instance of |
| * com.android.internal.telephony.gsm.CommandException |
| */ |
| void getDataCallList(Message response); |
| |
| /** |
| * Update the ServiceState CellLocation for current network registration. |
| */ |
| void updateServiceLocation(); |
| |
| /** |
| * Enable location update notifications. |
| */ |
| void enableLocationUpdates(); |
| |
| /** |
| * Disable location update notifications. |
| */ |
| void disableLocationUpdates(); |
| |
| /** |
| * For unit tests; don't send notifications to "Phone" |
| * mailbox registrants if true. |
| */ |
| void setUnitTestMode(boolean f); |
| |
| /** |
| * @return true If unit test mode is enabled |
| */ |
| boolean getUnitTestMode(); |
| |
| /** |
| * Assign a specified band for RF configuration. |
| * |
| * @param bandMode one of BM_*_BAND |
| * @param response is callback message |
| */ |
| void setBandMode(int bandMode, Message response); |
| |
| /** |
| * Query the list of band mode supported by RF. |
| * |
| * @param response is callback message |
| * ((AsyncResult)response.obj).result is an int[] where int[0] is |
| * the size of the array and the rest of each element representing |
| * one available BM_*_BAND |
| */ |
| void queryAvailableBandMode(Message response); |
| |
| /** |
| * @return true if enable data connection on roaming |
| */ |
| boolean getDataRoamingEnabled(); |
| |
| /** |
| * @param enable set true if enable data connection on roaming |
| */ |
| void setDataRoamingEnabled(boolean enable); |
| |
| /** |
| * @return true if user has enabled data |
| */ |
| boolean getDataEnabled(); |
| |
| /** |
| * @param @enable set {@code true} if enable data connection |
| */ |
| void setDataEnabled(boolean enable); |
| |
| /** |
| * Query the CDMA roaming preference setting |
| * |
| * @param response is callback message to report one of CDMA_RM_* |
| */ |
| void queryCdmaRoamingPreference(Message response); |
| |
| /** |
| * Requests to set the CDMA roaming preference |
| * @param cdmaRoamingType one of CDMA_RM_* |
| * @param response is callback message |
| */ |
| void setCdmaRoamingPreference(int cdmaRoamingType, Message response); |
| |
| /** |
| * Requests to set the CDMA subscription mode |
| * @param cdmaSubscriptionType one of CDMA_SUBSCRIPTION_* |
| * @param response is callback message |
| */ |
| void setCdmaSubscription(int cdmaSubscriptionType, Message response); |
| |
| /** |
| * If this is a simulated phone interface, returns a SimulatedRadioControl. |
| * @return SimulatedRadioControl if this is a simulated interface; |
| * otherwise, null. |
| */ |
| SimulatedRadioControl getSimulatedRadioControl(); |
| |
| /** |
| * Report on whether data connectivity is allowed. |
| */ |
| boolean isDataConnectivityPossible(); |
| |
| /** |
| * Report on whether data connectivity is allowed for an APN. |
| */ |
| boolean isDataConnectivityPossible(String apnType); |
| |
| /** |
| * Retrieves the unique device ID, e.g., IMEI for GSM phones and MEID for CDMA phones. |
| */ |
| String getDeviceId(); |
| |
| /** |
| * Retrieves the software version number for the device, e.g., IMEI/SV |
| * for GSM phones. |
| */ |
| String getDeviceSvn(); |
| |
| /** |
| * Retrieves the unique subscriber ID, e.g., IMSI for GSM phones. |
| */ |
| String getSubscriberId(); |
| |
| /** |
| * Retrieves the Group Identifier Level1 for GSM phones. |
| */ |
| String getGroupIdLevel1(); |
| |
| /** |
| * Retrieves the serial number of the ICC, if applicable. |
| */ |
| String getIccSerialNumber(); |
| |
| /* CDMA support methods */ |
| |
| /** |
| * Retrieves the MIN for CDMA phones. |
| */ |
| String getCdmaMin(); |
| |
| /** |
| * Check if subscription data has been assigned to mMin |
| * |
| * return true if MIN info is ready; false otherwise. |
| */ |
| boolean isMinInfoReady(); |
| |
| /** |
| * Retrieves PRL Version for CDMA phones |
| */ |
| String getCdmaPrlVersion(); |
| |
| /** |
| * Retrieves the ESN for CDMA phones. |
| */ |
| String getEsn(); |
| |
| /** |
| * Retrieves MEID for CDMA phones. |
| */ |
| String getMeid(); |
| |
| /** |
| * Retrieves the MSISDN from the UICC. For GSM/UMTS phones, this is equivalent to |
| * {@link #getLine1Number()}. For CDMA phones, {@link #getLine1Number()} returns |
| * the MDN, so this method is provided to return the MSISDN on CDMA/LTE phones. |
| */ |
| String getMsisdn(); |
| |
| /** |
| * Retrieves IMEI for phones. Returns null if IMEI is not set. |
| */ |
| String getImei(); |
| |
| /** |
| * Retrieves Nai for phones. Returns null if Nai is not set. |
| */ |
| String getNai(); |
| |
| /** |
| * Retrieves the PhoneSubInfo of the Phone |
| */ |
| public PhoneSubInfo getPhoneSubInfo(); |
| |
| /** |
| * Retrieves the IccPhoneBookInterfaceManager of the Phone |
| */ |
| public IccPhoneBookInterfaceManager getIccPhoneBookInterfaceManager(); |
| |
| /** |
| * setTTYMode |
| * sets a TTY mode option. |
| * @param ttyMode is a one of the following: |
| * - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF} |
| * - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL} |
| * - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO} |
| * - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO} |
| * @param onComplete a callback message when the action is completed |
| */ |
| void setTTYMode(int ttyMode, Message onComplete); |
| |
| /** |
| * setUiTTYMode |
| * sets a TTY mode option. |
| * @param ttyMode is a one of the following: |
| * - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF} |
| * - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL} |
| * - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO} |
| * - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO} |
| * @param onComplete a callback message when the action is completed |
| */ |
| void setUiTTYMode(int uiTtyMode, Message onComplete); |
| |
| /** |
| * queryTTYMode |
| * query the status of the TTY mode |
| * |
| * @param onComplete a callback message when the action is completed. |
| */ |
| void queryTTYMode(Message onComplete); |
| |
| /** |
| * Activate or deactivate cell broadcast SMS. |
| * |
| * @param activate |
| * 0 = activate, 1 = deactivate |
| * @param response |
| * Callback message is empty on completion |
| */ |
| void activateCellBroadcastSms(int activate, Message response); |
| |
| /** |
| * Query the current configuration of cdma cell broadcast SMS. |
| * |
| * @param response |
| * Callback message is empty on completion |
| */ |
| void getCellBroadcastSmsConfig(Message response); |
| |
| /** |
| * Configure cell broadcast SMS. |
| * |
| * TODO: Change the configValuesArray to a RIL_BroadcastSMSConfig |
| * |
| * @param response |
| * Callback message is empty on completion |
| */ |
| public void setCellBroadcastSmsConfig(int[] configValuesArray, Message response); |
| |
| public void notifyDataActivity(); |
| |
| /** |
| * Returns the CDMA ERI icon index to display |
| */ |
| public int getCdmaEriIconIndex(); |
| |
| /** |
| * Returns the CDMA ERI icon mode, |
| * 0 - ON |
| * 1 - FLASHING |
| */ |
| public int getCdmaEriIconMode(); |
| |
| /** |
| * Returns the CDMA ERI text, |
| */ |
| public String getCdmaEriText(); |
| |
| /** |
| * request to exit emergency call back mode |
| * the caller should use setOnECMModeExitResponse |
| * to receive the emergency callback mode exit response |
| */ |
| void exitEmergencyCallbackMode(); |
| |
| /** |
| * this decides if the dial number is OTA(Over the air provision) number or not |
| * @param dialStr is string representing the dialing digit(s) |
| * @return true means the dialStr is OTA number, and false means the dialStr is not OTA number |
| */ |
| boolean isOtaSpNumber(String dialStr); |
| |
| /** |
| * Returns true if OTA Service Provisioning needs to be performed. |
| */ |
| boolean needsOtaServiceProvisioning(); |
| |
| /** |
| * Register for notifications when CDMA call waiting comes |
| * |
| * @param h Handler that receives the notification message. |
| * @param what User-defined message code. |
| * @param obj User object. |
| */ |
| void registerForCallWaiting(Handler h, int what, Object obj); |
| |
| /** |
| * Unegister for notifications when CDMA Call waiting comes |
| * @param h Handler to be removed from the registrant list. |
| */ |
| void unregisterForCallWaiting(Handler h); |
| |
| |
| /** |
| * Register for signal information notifications from the network. |
| * Message.obj will contain an AsyncResult. |
| * AsyncResult.result will be a SuppServiceNotification instance. |
| * |
| * @param h Handler that receives the notification message. |
| * @param what User-defined message code. |
| * @param obj User object. |
| */ |
| |
| void registerForSignalInfo(Handler h, int what, Object obj) ; |
| /** |
| * Unregisters for signal information notifications. |
| * Extraneous calls are tolerated silently |
| * |
| * @param h Handler to be removed from the registrant list. |
| */ |
| void unregisterForSignalInfo(Handler h); |
| |
| /** |
| * Register for display information notifications from the network. |
| * Message.obj will contain an AsyncResult. |
| * AsyncResult.result will be a SuppServiceNotification instance. |
| * |
| * @param h Handler that receives the notification message. |
| * @param what User-defined message code. |
| * @param obj User object. |
| */ |
| void registerForDisplayInfo(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for display information notifications. |
| * Extraneous calls are tolerated silently |
| * |
| * @param h Handler to be removed from the registrant list. |
| */ |
| void unregisterForDisplayInfo(Handler h) ; |
| |
| /** |
| * Register for CDMA number information record notification from the network. |
| * Message.obj will contain an AsyncResult. |
| * AsyncResult.result will be a CdmaInformationRecords.CdmaNumberInfoRec |
| * instance. |
| * |
| * @param h Handler that receives the notification message. |
| * @param what User-defined message code. |
| * @param obj User object. |
| */ |
| void registerForNumberInfo(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for number information record notifications. |
| * Extraneous calls are tolerated silently |
| * |
| * @param h Handler to be removed from the registrant list. |
| */ |
| void unregisterForNumberInfo(Handler h); |
| |
| /** |
| * Register for CDMA redirected number information record notification |
| * from the network. |
| * Message.obj will contain an AsyncResult. |
| * AsyncResult.result will be a CdmaInformationRecords.CdmaRedirectingNumberInfoRec |
| * instance. |
| * |
| * @param h Handler that receives the notification message. |
| * @param what User-defined message code. |
| * @param obj User object. |
| */ |
| void registerForRedirectedNumberInfo(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for redirected number information record notification. |
| * Extraneous calls are tolerated silently |
| * |
| * @param h Handler to be removed from the registrant list. |
| */ |
| void unregisterForRedirectedNumberInfo(Handler h); |
| |
| /** |
| * Register for CDMA line control information record notification |
| * from the network. |
| * Message.obj will contain an AsyncResult. |
| * AsyncResult.result will be a CdmaInformationRecords.CdmaLineControlInfoRec |
| * instance. |
| * |
| * @param h Handler that receives the notification message. |
| * @param what User-defined message code. |
| * @param obj User object. |
| */ |
| void registerForLineControlInfo(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for line control information notifications. |
| * Extraneous calls are tolerated silently |
| * |
| * @param h Handler to be removed from the registrant list. |
| */ |
| void unregisterForLineControlInfo(Handler h); |
| |
| /** |
| * Register for CDMA T53 CLIR information record notifications |
| * from the network. |
| * Message.obj will contain an AsyncResult. |
| * AsyncResult.result will be a CdmaInformationRecords.CdmaT53ClirInfoRec |
| * instance. |
| * |
| * @param h Handler that receives the notification message. |
| * @param what User-defined message code. |
| * @param obj User object. |
| */ |
| void registerFoT53ClirlInfo(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for T53 CLIR information record notification |
| * Extraneous calls are tolerated silently |
| * |
| * @param h Handler to be removed from the registrant list. |
| */ |
| void unregisterForT53ClirInfo(Handler h); |
| |
| /** |
| * Register for CDMA T53 audio control information record notifications |
| * from the network. |
| * Message.obj will contain an AsyncResult. |
| * AsyncResult.result will be a CdmaInformationRecords.CdmaT53AudioControlInfoRec |
| * instance. |
| * |
| * @param h Handler that receives the notification message. |
| * @param what User-defined message code. |
| * @param obj User object. |
| */ |
| void registerForT53AudioControlInfo(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for T53 audio control information record notifications. |
| * Extraneous calls are tolerated silently |
| * |
| * @param h Handler to be removed from the registrant list. |
| */ |
| void unregisterForT53AudioControlInfo(Handler h); |
| |
| /** |
| * Register for radio off or not available |
| * |
| * @param h Handler that receives the notification message. |
| * @param what User-defined message code. |
| * @param obj User object. |
| */ |
| public void registerForRadioOffOrNotAvailable(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for radio off or not available |
| * |
| * @param h Handler to be removed from the registrant list. |
| */ |
| public void unregisterForRadioOffOrNotAvailable(Handler h); |
| |
| /** |
| * registers for exit emergency call back mode request response |
| * |
| * @param h Handler that receives the notification message. |
| * @param what User-defined message code. |
| * @param obj User object. |
| */ |
| |
| void setOnEcbModeExitResponse(Handler h, int what, Object obj); |
| |
| /** |
| * Unregisters for exit emergency call back mode request response |
| * |
| * @param h Handler to be removed from the registrant list. |
| */ |
| void unsetOnEcbModeExitResponse(Handler h); |
| |
| /** |
| * Return if the current radio is LTE on CDMA. This |
| * is a tri-state return value as for a period of time |
| * the mode may be unknown. |
| * |
| * @return {@link PhoneConstants#LTE_ON_CDMA_UNKNOWN}, {@link PhoneConstants#LTE_ON_CDMA_FALSE} |
| * or {@link PhoneConstants#LTE_ON_CDMA_TRUE} |
| */ |
| public int getLteOnCdmaMode(); |
| |
| /** |
| * TODO: Adding a function for each property is not good. |
| * A fucntion of type getPhoneProp(propType) where propType is an |
| * enum of GSM+CDMA+LTE props would be a better approach. |
| * |
| * Get "Restriction of menu options for manual PLMN selection" bit |
| * status from EF_CSP data, this belongs to "Value Added Services Group". |
| * @return true if this bit is set or EF_CSP data is unavailable, |
| * false otherwise |
| */ |
| boolean isCspPlmnEnabled(); |
| |
| /** |
| * Return an interface to retrieve the ISIM records for IMS, if available. |
| * @return the interface to retrieve the ISIM records, or null if not supported |
| */ |
| IsimRecords getIsimRecords(); |
| |
| /** |
| * Sets the SIM voice message waiting indicator records. |
| * @param line GSM Subscriber Profile Number, one-based. Only '1' is supported |
| * @param countWaiting The number of messages waiting, if known. Use |
| * -1 to indicate that an unknown number of |
| * messages are waiting |
| */ |
| void setVoiceMessageWaiting(int line, int countWaiting); |
| |
| /** |
| * Gets the USIM service table from the UICC, if present and available. |
| * @return an interface to the UsimServiceTable record, or null if not available |
| */ |
| UsimServiceTable getUsimServiceTable(); |
| |
| /** |
| * Gets the Uicc card corresponding to this phone. |
| * @return the UiccCard object corresponding to the phone ID. |
| */ |
| UiccCard getUiccCard(); |
| |
| /** |
| * Unregister from all events it registered for and dispose objects |
| * created by this object. |
| */ |
| void dispose(); |
| |
| /** |
| * Remove references to external object stored in this object. |
| */ |
| void removeReferences(); |
| |
| /** |
| * Update the phone object if the voice radio technology has changed |
| * |
| * @param voiceRadioTech The new voice radio technology |
| */ |
| void updatePhoneObject(int voiceRadioTech); |
| |
| /** |
| * Read one of the NV items defined in {@link RadioNVItems} / {@code ril_nv_items.h}. |
| * Used for device configuration by some CDMA operators. |
| * |
| * @param itemID the ID of the item to read |
| * @param response callback message with the String response in the obj field |
| */ |
| void nvReadItem(int itemID, Message response); |
| |
| /** |
| * Write one of the NV items defined in {@link RadioNVItems} / {@code ril_nv_items.h}. |
| * Used for device configuration by some CDMA operators. |
| * |
| * @param itemID the ID of the item to read |
| * @param itemValue the value to write, as a String |
| * @param response Callback message. |
| */ |
| void nvWriteItem(int itemID, String itemValue, Message response); |
| |
| /** |
| * Update the CDMA Preferred Roaming List (PRL) in the radio NV storage. |
| * Used for device configuration by some CDMA operators. |
| * |
| * @param preferredRoamingList byte array containing the new PRL |
| * @param response Callback message. |
| */ |
| void nvWriteCdmaPrl(byte[] preferredRoamingList, Message response); |
| |
| /** |
| * Perform the specified type of NV config reset. The radio will be taken offline |
| * and the device must be rebooted after erasing the NV. Used for device |
| * configuration by some CDMA operators. |
| * |
| * @param resetType reset type: 1: reload NV reset, 2: erase NV reset, 3: factory NV reset |
| * @param response Callback message. |
| */ |
| void nvResetConfig(int resetType, Message response); |
| |
| /* |
| * Returns the subscription id. |
| */ |
| public int getSubId(); |
| |
| /* |
| * Returns the phone id. |
| */ |
| public int getPhoneId(); |
| |
| /** |
| * Get P-CSCF address from PCO after data connection is established or modified. |
| * @param apnType the apnType, "ims" for IMS APN, "emergency" for EMERGENCY APN |
| */ |
| public String[] getPcscfAddress(String apnType); |
| |
| /** |
| * Set IMS registration state |
| */ |
| public void setImsRegistrationState(boolean registered); |
| |
| /** |
| * Return the ImsPhone phone co-managed with this phone |
| * @return an instance of an ImsPhone phone |
| */ |
| public Phone getImsPhone(); |
| |
| /** |
| * Release the local instance of the ImsPhone and disconnect from |
| * the phone. |
| * @return the instance of the ImsPhone phone previously owned |
| */ |
| public ImsPhone relinquishOwnershipOfImsPhone(); |
| |
| /** |
| * Take ownership and wire-up the input ImsPhone |
| * @param imsPhone ImsPhone to be used. |
| */ |
| public void acquireOwnershipOfImsPhone(ImsPhone imsPhone); |
| |
| /** |
| * Return the service state of mImsPhone if it is STATE_IN_SERVICE |
| * otherwise return the current voice service state |
| */ |
| int getVoicePhoneServiceState(); |
| |
| /** |
| * Override the service provider name and the operator name for the current ICCID. |
| */ |
| public boolean setOperatorBrandOverride(String brand); |
| |
| /** |
| * Override the roaming indicator for the current ICCID. |
| */ |
| public boolean setRoamingOverride(List<String> gsmRoamingList, |
| List<String> gsmNonRoamingList, List<String> cdmaRoamingList, |
| List<String> cdmaNonRoamingList); |
| |
| /** |
| * Is Radio Present on the device and is it accessible |
| */ |
| public boolean isRadioAvailable(); |
| |
| /** |
| * shutdown Radio gracefully |
| */ |
| public void shutdownRadio(); |
| |
| /** |
| * Set phone radio capability |
| * |
| * @param rc the phone radio capability defined in |
| * RadioCapability. It's a input object used to transfer parameter to logic modem |
| * @param response Callback message. |
| */ |
| public void setRadioCapability(RadioCapability rc, Message response); |
| |
| /** |
| * Get phone radio access family |
| * |
| * @return a bit mask to identify the radio access family. |
| */ |
| public int getRadioAccessFamily(); |
| |
| /** |
| * Get supported phone radio access family |
| * |
| * @return a bit mask to identify the radio access family. |
| */ |
| public int getSupportedRadioAccessFamily(); |
| |
| /** |
| * Registers the handler when phone radio capability is changed. |
| * |
| * @param h Handler for notification message. |
| * @param what User-defined message code. |
| * @param obj User object. |
| */ |
| public void registerForRadioCapabilityChanged(Handler h, int what, Object obj); |
| |
| /** |
| * Unregister for notifications when phone radio type and access technology is changed. |
| * |
| * @param h Handler to be removed from the registrant list. |
| */ |
| public void unregisterForRadioCapabilityChanged(Handler h); |
| |
| /** |
| * Query the IMS Registration Status. |
| * |
| * @return true if IMS is Registered |
| */ |
| public boolean isImsRegistered(); |
| } |