/* * 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.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. *
registerForServiceStateChanged
to be informed of
* updates.
*/
ServiceState getServiceState();
/**
* Get the current CellLocation.
*/
CellLocation getCellLocation();
/**
* @return all available cell information or null if none.
*/
public List* If the phone has an active call and call waiting occurs, * then the phone state is RINGING not OFFHOOK * Note: * This registration point provides notification of finer-grained * changes.
*
*/
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();
/**
* 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 PhoneStateNotifier
or an equivalent.
* An ASU is 0-31 or -1 if unknown (for GSM, dBm = -113 - 2 * asu).
* The following special values are defined:
Message.obj
.
* AsyncResult.userData will be set to the obj argument here.
* The h 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.* * Messages received from this: * Message.obj will be an AsyncResult * AsyncResult.userObj = obj * AsyncResult.result = a Connection.
* 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.
* * Messages received from this: * Message.obj will be an AsyncResult * AsyncResult.userObj = obj * AsyncResult.result = a Connection.
*/ 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.
* * 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.
*/ 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.
* * 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.
*/ 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:
*
* * Example: If Phone.dial is called with "*#31#", then the app will * be notified here.
*
* The returned Message.obj
will contain an AsyncResult.
*
* obj.result
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.
*
* Message.obj
will contain an AsyncResult.
* obj.result
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 registerForMmiInitiate
* and registerForMmiComplete
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);
/**
* Returns SIM record load state. Use
* getSimCard().registerForReady()
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).
* * The foreground call is a singleton object. It is constant for the life * of this phone. It is never null.
* * 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).
* * The background call is a singleton object. It is constant for the life * of this phone object . It is never null.
* * 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.)
* The ringing call is a singleton object. It is constant for the life * of this phone. It is never null.
*
* 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 dial
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()}.
* Note: 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.
* * @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.
*/ 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. */ void 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.
*/ String getVoiceMailNumber(); /** * Returns unread voicemail count. This count is shown when the voicemail * notification is expanded.
*/ 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.
* * 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.
*
* 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
*
*
*
* Messages of type
*
* Message.arg1 will be the post dial character being processed,
* or 0 ('\0') if end of string.
*
* 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.
*
* 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.
*
* Only one post dial character handler may be set.
* Calling this method with "h" equal to null unsets this handler.
*/
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 On success,
* (byte[])(((AsyncResult)response.obj).result)
* On failure,
* (((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 On success, "response" bytes is
* made available as:
* (String[])(((AsyncResult)response.obj).result).
* On failure,
* (((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 On success, "response" bytes is
* made available as:
* (String[])(((AsyncResult)response.obj).result).
* On failure,
* (((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 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);
/**
* 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);
/**
* 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 long 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);
/**
* Is Radio Present on the device and is it accessible
*/
public boolean isRadioAvailable();
/**
* shutdown Radio gracefully
*/
public void shutdownRadio();
}
com.android.internal.telephony.CommandsInterface.
* @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
* com.android.internal.telephony.CommandsInterface.
* @param commandInterfaceCFAction is one of the valid call forwarding
* CF_ACTIONS, as defined in
* com.android.internal.telephony.CommandsInterface.
* @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
* 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,
response.obj
is set to an AsyncResult with
* one of the following members:.
*
*/
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. response.obj.result
will be a List
of
* OperatorInfo
objects, orresponse.obj.exception
will be set with an exception
* on failure.response
is
* dispatched when this is complete. response.obj
will be
* an AsyncResult, and response.obj.exception
will be non-null
* on failure.
*
* @see #setNetworkSelectionModeAutomatic(Message)
*/
void selectNetworkManually(OperatorInfo network,
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. response
is dispatched when
* this is complete. response.obj
will be an AsyncResult,
* and response.obj.exception
will be non-null on failure.
* On success, AsyncResult.result
will be a String[]
* 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.what
will be sent to h
.
* The obj
field of these Message's will be instances of
* AsyncResult
. Message.obj.result
will be
* a Connection object.