FileDocCategorySizeDatePackage
TelephonyManager.javaAPI DocAndroid 5.1 API140590Thu Mar 12 22:22:42 GMT 2015android.telephony

TelephonyManager

public class TelephonyManager extends Object
Provides access to information about the telephony services on the device. Applications can use the methods in this class to determine telephony services and states, as well as to access some types of subscriber information. Applications can also register a listener to receive notification of telephony state changes.

You do not instantiate this class directly; instead, you retrieve a reference to an instance through {@link android.content.Context#getSystemService Context.getSystemService(Context.TELEPHONY_SERVICE)}.

Note that access to some telephony information is permission-protected. Your application cannot access the protected information unless it has the appropriate permissions declared in its manifest file. Where permissions apply, they are noted in the the methods through which you access the protected information.

Fields Summary
private static final String
TAG
private static com.android.internal.telephony.ITelephonyRegistry
sRegistry
private final android.content.Context
mContext
private SubscriptionManager
mSubscriptionManager
private static String
multiSimConfig
private static TelephonyManager
sInstance
public static final String
ACTION_PHONE_STATE_CHANGED
Broadcast intent action indicating that the call state (cellular) on the device has changed.

The {@link #EXTRA_STATE} extra indicates the new call state. If the new state is RINGING, a second extra {@link #EXTRA_INCOMING_NUMBER} provides the incoming phone number as a String.

Requires the READ_PHONE_STATE permission.

This was a {@link android.content.Context#sendStickyBroadcast sticky} broadcast in version 1.0, but it is no longer sticky. Instead, use {@link #getCallState} to synchronously query the current call state.

public static final String
ACTION_RESPOND_VIA_MESSAGE
The Phone app sends this intent when a user opts to respond-via-message during an incoming call. By default, the device's default SMS app consumes this message and sends a text message to the caller. A third party app can also provide this functionality by consuming this Intent with a {@link android.app.Service} and sending the message using its own messaging system.

The intent contains a URI (available from {@link android.content.Intent#getData}) describing the recipient, using either the {@code sms:}, {@code smsto:}, {@code mms:}, or {@code mmsto:} URI schema. Each of these URI schema carry the recipient information the same way: the path part of the URI contains the recipient's phone number or a comma-separated set of phone numbers if there are multiple recipients. For example, {@code smsto:2065551234}.

The intent may also contain extras for the message text (in {@link android.content.Intent#EXTRA_TEXT}) and a message subject (in {@link android.content.Intent#EXTRA_SUBJECT}).

Note: The intent-filter that consumes this Intent needs to be in a {@link android.app.Service} that requires the permission {@link android.Manifest.permission#SEND_RESPOND_VIA_MESSAGE}.

For example, the service that receives this intent can be declared in the manifest file with an intent filter like this:

<!-- Service that delivers SMS messages received from the phone "quick response" -->
<service android:name=".HeadlessSmsSendService"
android:permission="android.permission.SEND_RESPOND_VIA_MESSAGE"
android:exported="true" >
<intent-filter>
<action android:name="android.intent.action.RESPOND_VIA_MESSAGE" />
<category android:name="android.intent.category.DEFAULT" />
<data android:scheme="sms" />
<data android:scheme="smsto" />
<data android:scheme="mms" />
<data android:scheme="mmsto" />
</intent-filter>
</service>

Output: nothing.

public static final String
EXTRA_STATE
The lookup key used with the {@link #ACTION_PHONE_STATE_CHANGED} broadcast for a String containing the new call state.
public static final String
EXTRA_STATE_IDLE
Value used with {@link #EXTRA_STATE} corresponding to {@link #CALL_STATE_IDLE}.
public static final String
EXTRA_STATE_RINGING
Value used with {@link #EXTRA_STATE} corresponding to {@link #CALL_STATE_RINGING}.
public static final String
EXTRA_STATE_OFFHOOK
Value used with {@link #EXTRA_STATE} corresponding to {@link #CALL_STATE_OFFHOOK}.
public static final String
EXTRA_INCOMING_NUMBER
The lookup key used with the {@link #ACTION_PHONE_STATE_CHANGED} broadcast for a String containing the incoming phone number. Only valid when the new call state is RINGING.

Retrieve with {@link android.content.Intent#getStringExtra(String)}.

public static final String
ACTION_PRECISE_CALL_STATE_CHANGED
Broadcast intent action indicating that a precise call state (cellular) on the device has changed.

The {@link #EXTRA_RINGING_CALL_STATE} extra indicates the ringing call state. The {@link #EXTRA_FOREGROUND_CALL_STATE} extra indicates the foreground call state. The {@link #EXTRA_BACKGROUND_CALL_STATE} extra indicates the background call state. The {@link #EXTRA_DISCONNECT_CAUSE} extra indicates the disconnect cause. The {@link #EXTRA_PRECISE_DISCONNECT_CAUSE} extra indicates the precise disconnect cause.

Requires the READ_PRECISE_PHONE_STATE permission.

public static final String
EXTRA_RINGING_CALL_STATE
The lookup key used with the {@link #ACTION_PRECISE_CALL_STATE_CHANGED} broadcast for an integer containing the state of the current ringing call.
public static final String
EXTRA_FOREGROUND_CALL_STATE
The lookup key used with the {@link #ACTION_PRECISE_CALL_STATE_CHANGED} broadcast for an integer containing the state of the current foreground call.
public static final String
EXTRA_BACKGROUND_CALL_STATE
The lookup key used with the {@link #ACTION_PRECISE_CALL_STATE_CHANGED} broadcast for an integer containing the state of the current background call.
public static final String
EXTRA_DISCONNECT_CAUSE
The lookup key used with the {@link #ACTION_PRECISE_CALL_STATE_CHANGED} broadcast for an integer containing the disconnect cause.
public static final String
EXTRA_PRECISE_DISCONNECT_CAUSE
The lookup key used with the {@link #ACTION_PRECISE_CALL_STATE_CHANGED} broadcast for an integer containing the disconnect cause provided by the RIL.
public static final String
ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED
Broadcast intent action indicating a data connection has changed, providing precise information about the connection.

The {@link #EXTRA_DATA_STATE} extra indicates the connection state. The {@link #EXTRA_DATA_NETWORK_TYPE} extra indicates the connection network type. The {@link #EXTRA_DATA_APN_TYPE} extra indicates the APN type. The {@link #EXTRA_DATA_APN} extra indicates the APN. The {@link #EXTRA_DATA_CHANGE_REASON} extra indicates the connection change reason. The {@link #EXTRA_DATA_IFACE_PROPERTIES} extra indicates the connection interface. The {@link #EXTRA_DATA_FAILURE_CAUSE} extra indicates the connection fail cause.

Requires the READ_PRECISE_PHONE_STATE permission.

public static final String
EXTRA_DATA_STATE
The lookup key used with the {@link #ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED} broadcast for an integer containing the state of the current data connection.
public static final String
EXTRA_DATA_NETWORK_TYPE
The lookup key used with the {@link #ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED} broadcast for an integer containing the network type.
public static final String
EXTRA_DATA_APN_TYPE
The lookup key used with the {@link #ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED} broadcast for an String containing the data APN type.

Retrieve with {@link android.content.Intent#getStringExtra(String name)}.

public static final String
EXTRA_DATA_APN
The lookup key used with the {@link #ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED} broadcast for an String containing the data APN.

Retrieve with {@link android.content.Intent#getStringExtra(String name)}.

public static final String
EXTRA_DATA_CHANGE_REASON
The lookup key used with the {@link #ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED} broadcast for an String representation of the change reason.

Retrieve with {@link android.content.Intent#getStringExtra(String name)}.

public static final String
EXTRA_DATA_LINK_PROPERTIES_KEY
The lookup key used with the {@link #ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED} broadcast for an String representation of the data interface.

Retrieve with {@link android.content.Intent#getParcelableExtra(String name)}.

public static final String
EXTRA_DATA_FAILURE_CAUSE
The lookup key used with the {@link #ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED} broadcast for the data connection fail cause.

Retrieve with {@link android.content.Intent#getStringExtra(String name)}.

public static final int
PHONE_TYPE_NONE
No phone radio.
public static final int
PHONE_TYPE_GSM
Phone radio is GSM.
public static final int
PHONE_TYPE_CDMA
Phone radio is CDMA.
public static final int
PHONE_TYPE_SIP
Phone is via SIP.
private static final String
sKernelCmdLine
Kernel command line
private static final Pattern
sProductTypePattern
Pattern for selecting the product type from the kernel command line
private static final String
sLteOnCdmaProductType
The ProductType used for LTE on CDMA devices
public static final int
NETWORK_TYPE_UNKNOWN
Network type is unknown
public static final int
NETWORK_TYPE_GPRS
Current network is GPRS
public static final int
NETWORK_TYPE_EDGE
Current network is EDGE
public static final int
NETWORK_TYPE_UMTS
Current network is UMTS
public static final int
NETWORK_TYPE_CDMA
Current network is CDMA: Either IS95A or IS95B
public static final int
NETWORK_TYPE_EVDO_0
Current network is EVDO revision 0
public static final int
NETWORK_TYPE_EVDO_A
Current network is EVDO revision A
public static final int
NETWORK_TYPE_1xRTT
Current network is 1xRTT
public static final int
NETWORK_TYPE_HSDPA
Current network is HSDPA
public static final int
NETWORK_TYPE_HSUPA
Current network is HSUPA
public static final int
NETWORK_TYPE_HSPA
Current network is HSPA
public static final int
NETWORK_TYPE_IDEN
Current network is iDen
public static final int
NETWORK_TYPE_EVDO_B
Current network is EVDO revision B
public static final int
NETWORK_TYPE_LTE
Current network is LTE
public static final int
NETWORK_TYPE_EHRPD
Current network is eHRPD
public static final int
NETWORK_TYPE_HSPAP
Current network is HSPA+
public static final int
NETWORK_TYPE_GSM
Current network is GSM {@hide}
public static final int
NETWORK_CLASS_UNKNOWN
Unknown network class. {@hide}
public static final int
NETWORK_CLASS_2_G
Class of broadly defined "2G" networks. {@hide}
public static final int
NETWORK_CLASS_3_G
Class of broadly defined "3G" networks. {@hide}
public static final int
NETWORK_CLASS_4_G
Class of broadly defined "4G" networks. {@hide}
public static final int
SIM_STATE_UNKNOWN
SIM card state: Unknown. Signifies that the SIM is in transition between states. For example, when the user inputs the SIM pin under PIN_REQUIRED state, a query for sim status returns this state before turning to SIM_STATE_READY. These are the ordinal value of IccCardConstants.State.
public static final int
SIM_STATE_ABSENT
SIM card state: no SIM card is available in the device
public static final int
SIM_STATE_PIN_REQUIRED
SIM card state: Locked: requires the user's SIM PIN to unlock
public static final int
SIM_STATE_PUK_REQUIRED
SIM card state: Locked: requires the user's SIM PUK to unlock
public static final int
SIM_STATE_NETWORK_LOCKED
SIM card state: Locked: requires a network PIN to unlock
public static final int
SIM_STATE_READY
SIM card state: Ready
public static final int
SIM_STATE_NOT_READY
SIM card state: SIM Card is NOT READY
public static final int
SIM_STATE_PERM_DISABLED
SIM card state: SIM Card Error, permanently disabled
public static final int
SIM_STATE_CARD_IO_ERROR
SIM card state: SIM Card Error, present but faulty
public static final int
CALL_STATE_IDLE
Device call state: No activity.
public static final int
CALL_STATE_RINGING
Device call state: Ringing. A new call arrived and is ringing or waiting. In the latter case, another call is already active.
public static final int
CALL_STATE_OFFHOOK
Device call state: Off-hook. At least one call exists that is dialing, active, or on hold, and no calls are ringing or waiting.
public static final int
DATA_ACTIVITY_NONE
Data connection activity: No traffic.
public static final int
DATA_ACTIVITY_IN
Data connection activity: Currently receiving IP PPP traffic.
public static final int
DATA_ACTIVITY_OUT
Data connection activity: Currently sending IP PPP traffic.
public static final int
DATA_ACTIVITY_INOUT
Data connection activity: Currently both sending and receiving IP PPP traffic.
public static final int
DATA_ACTIVITY_DORMANT
Data connection is active, but physical link is down
public static final int
DATA_UNKNOWN
Data connection state: Unknown. Used before we know the state.
public static final int
DATA_DISCONNECTED
Data connection state: Disconnected. IP traffic not available.
public static final int
DATA_CONNECTING
Data connection state: Currently setting up a data connection.
public static final int
DATA_CONNECTED
Data connection state: Connected. IP traffic should be available.
public static final int
DATA_SUSPENDED
Data connection state: Suspended. The connection is up, but IP traffic is temporarily unavailable. For example, in a 2G network, data activity may be suspended when a voice call arrives.
public static final int
CARRIER_PRIVILEGE_STATUS_HAS_ACCESS
public static final int
CARRIER_PRIVILEGE_STATUS_NO_ACCESS
public static final int
CARRIER_PRIVILEGE_STATUS_RULES_NOT_LOADED
public static final int
CARRIER_PRIVILEGE_STATUS_ERROR_LOADING_RULES
Constructors Summary
public TelephonyManager(android.content.Context context)

hide


                                  
      
       
        
        
        
        
    

      
       
        Context appContext = context.getApplicationContext();
        if (appContext != null) {
            mContext = appContext;
        } else {
            mContext = context;
        }
        mSubscriptionManager = SubscriptionManager.from(mContext);

        if (sRegistry == null) {
            sRegistry = ITelephonyRegistry.Stub.asInterface(ServiceManager.getService(
                    "telephony.registry"));
        }
private TelephonyManager()

hide

        mContext = null;
Methods Summary
public voidanswerRingingCall()

hide

        try {
            getITelephony().answerRingingCall();
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#answerRingingCall", e);
        }
public voidcall(java.lang.String callingPackage, java.lang.String number)

hide

        try {
            getITelephony().call(callingPackage, number);
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#call", e);
        }
public intcheckCarrierPrivilegesForPackage(java.lang.String pkgname)

hide

        try {
            return getITelephony().checkCarrierPrivilegesForPackage(pkgname);
        } catch (RemoteException ex) {
            Rlog.e(TAG, "checkCarrierPrivilegesForPackage RemoteException", ex);
        } catch (NullPointerException ex) {
            Rlog.e(TAG, "checkCarrierPrivilegesForPackage NPE", ex);
        }
        return CARRIER_PRIVILEGE_STATUS_NO_ACCESS;
public voiddial(java.lang.String number)

hide

        try {
            getITelephony().dial(number);
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#dial", e);
        }
public booleandisableDataConnectivity()

hide

        try {
            return getITelephony().disableDataConnectivity();
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#disableDataConnectivity", e);
        }
        return false;
public voiddisableLocationUpdates()
Disables location update notifications. {@link PhoneStateListener#onCellLocationChanged PhoneStateListener.onCellLocationChanged} will be called on location updates.

Requires Permission: {@link android.Manifest.permission#CONTROL_LOCATION_UPDATES CONTROL_LOCATION_UPDATES}

hide

            disableLocationUpdates(getDefaultSubscription());
public voiddisableLocationUpdates(int subId)

hide

        try {
            getITelephony().disableLocationUpdatesForSubscriber(subId);
        } catch (RemoteException ex) {
        } catch (NullPointerException ex) {
        }
public booleanenableDataConnectivity()

hide

        try {
            return getITelephony().enableDataConnectivity();
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#enableDataConnectivity", e);
        }
        return false;
public voidenableLocationUpdates()
Enables location update notifications. {@link PhoneStateListener#onCellLocationChanged PhoneStateListener.onCellLocationChanged} will be called on location updates.

Requires Permission: {@link android.Manifest.permission#CONTROL_LOCATION_UPDATES CONTROL_LOCATION_UPDATES}

hide

            enableLocationUpdates(getDefaultSubscription());
public voidenableLocationUpdates(int subId)

hide

        try {
            getITelephony().enableLocationUpdatesForSubscriber(subId);
        } catch (RemoteException ex) {
        } catch (NullPointerException ex) {
        }
public voidenableVideoCalling(boolean enable)

hide

        try {
            getITelephony().enableVideoCalling(enable);
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#enableVideoCalling", e);
        }
public booleanendCall()

hide

        try {
            return getITelephony().endCall();
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#endCall", e);
        }
        return false;
public static android.telephony.TelephonyManagerfrom(android.content.Context context)
{@hide}

        return (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
public java.util.ListgetAllCellInfo()
Returns all observed cell information from all radios on the device including the primary and neighboring cells. This does not cause or change the rate of PhoneStateListner#onCellInfoChanged.

The list can include one or more of {@link android.telephony.CellInfoGsm CellInfoGsm}, {@link android.telephony.CellInfoCdma CellInfoCdma}, {@link android.telephony.CellInfoLte CellInfoLte} and {@link android.telephony.CellInfoWcdma CellInfoCdma} in any combination. Specifically on devices with multiple radios it is typical to see instances of one or more of any these in the list. In addition 0, 1 or more CellInfo objects may return isRegistered() true.

This is preferred over using getCellLocation although for older devices this may return null in which case getCellLocation should be called.

return
List of CellInfo or null if info unavailable.

Requires Permission: {@link android.Manifest.permission#ACCESS_COARSE_LOCATION}

        try {
            return getITelephony().getAllCellInfo();
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            return null;
        }
public intgetCallState()
Returns a constant indicating the call state (cellular) on the device.


                    
       
        try {
            return getTelecomService().getCallState();
        } catch (RemoteException | NullPointerException e) {
            return CALL_STATE_IDLE;
        }
public intgetCallState(int subId)
{@hide}

        try {
            return getITelephony().getCallStateForSubscriber(subId);
        } catch (RemoteException ex) {
            // the phone process is restarting.
            return CALL_STATE_IDLE;
        } catch (NullPointerException ex) {
          // the phone process is restarting.
          return CALL_STATE_IDLE;
      }
public java.util.ListgetCarrierPackageNamesForIntent(android.content.Intent intent)

hide

        try {
            return getITelephony().getCarrierPackageNamesForIntent(intent);
        } catch (RemoteException ex) {
            Rlog.e(TAG, "getCarrierPackageNamesForIntent RemoteException", ex);
        } catch (NullPointerException ex) {
            Rlog.e(TAG, "getCarrierPackageNamesForIntent NPE", ex);
        }
        return null;
public intgetCdmaEriIconIndex()
Returns the CDMA ERI icon index to display

hide

        return getCdmaEriIconIndex(getDefaultSubscription());
public intgetCdmaEriIconIndex(int subId)
{@hide}

        try {
            return getITelephony().getCdmaEriIconIndexForSubscriber(subId);
        } catch (RemoteException ex) {
            // the phone process is restarting.
            return -1;
        } catch (NullPointerException ex) {
            return -1;
        }
public intgetCdmaEriIconMode()
Returns the CDMA ERI icon mode, 0 - ON 1 - FLASHING

hide

        return getCdmaEriIconMode(getDefaultSubscription());
public intgetCdmaEriIconMode(int subId)
{@hide}

        try {
            return getITelephony().getCdmaEriIconModeForSubscriber(subId);
        } catch (RemoteException ex) {
            // the phone process is restarting.
            return -1;
        } catch (NullPointerException ex) {
            return -1;
        }
public java.lang.StringgetCdmaEriText()
Returns the CDMA ERI text,

hide

        return getCdmaEriText(getDefaultSubscription());
public java.lang.StringgetCdmaEriText(int subId)
{@hide}

        try {
            return getITelephony().getCdmaEriTextForSubscriber(subId);
        } catch (RemoteException ex) {
            // the phone process is restarting.
            return null;
        } catch (NullPointerException ex) {
            return null;
        }
public java.lang.StringgetCdmaMdn()

hide

        return getCdmaMdn(getDefaultSubscription());
public java.lang.StringgetCdmaMdn(int subId)

hide

        try {
            return getITelephony().getCdmaMdn(subId);
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            return null;
        }
public java.lang.StringgetCdmaMin()

hide

        return getCdmaMin(getDefaultSubscription());
public java.lang.StringgetCdmaMin(int subId)

hide

        try {
            return getITelephony().getCdmaMin(subId);
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            return null;
        }
public CellLocationgetCellLocation()
Returns the current location of the device.

If there is only one radio in the device and that radio has an LTE connection, this method will return null. The implementation must not to try add LTE identifiers into the existing cdma/gsm classes.

In the future this call will be deprecated.

return
Current location of the device or null if not available.

Requires Permission: {@link android.Manifest.permission#ACCESS_COARSE_LOCATION ACCESS_COARSE_LOCATION} or {@link android.Manifest.permission#ACCESS_COARSE_LOCATION ACCESS_FINE_LOCATION}.

        try {
            Bundle bundle = getITelephony().getCellLocation();
            if (bundle.isEmpty()) return null;
            CellLocation cl = CellLocation.newFromBundle(bundle);
            if (cl.isEmpty())
                return null;
            return cl;
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            return null;
        }
public java.lang.StringgetCompleteVoiceMailNumber()
Returns the complete voice mail number. Return null if it is unavailable.

Requires Permission: {@link android.Manifest.permission#CALL_PRIVILEGED CALL_PRIVILEGED}

hide

        return getCompleteVoiceMailNumber(getDefaultSubscription());
public java.lang.StringgetCompleteVoiceMailNumber(int subId)
{@hide}

        try {
            return getSubscriberInfo().getCompleteVoiceMailNumberForSubscriber(subId);
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return null;
        }
public intgetCurrentPhoneType()
Returns the current phone type. TODO: This is a last minute change and hence hidden.

see
#PHONE_TYPE_NONE
see
#PHONE_TYPE_GSM
see
#PHONE_TYPE_CDMA
see
#PHONE_TYPE_SIP {@hide}


                                 
    
       
        return getCurrentPhoneType(getDefaultSubscription());
public intgetCurrentPhoneType(int subId)
{@hide}

        int phoneId = SubscriptionManager.getPhoneId(subId);
        try{
            ITelephony telephony = getITelephony();
            if (telephony != null) {
                return telephony.getActivePhoneTypeForSubscriber(subId);
            } else {
                // This can happen when the ITelephony interface is not up yet.
                return getPhoneTypeFromProperty(phoneId);
            }
        } catch (RemoteException ex) {
            // This shouldn't happen in the normal case, as a backup we
            // read from the system property.
            return getPhoneTypeFromProperty(phoneId);
        } catch (NullPointerException ex) {
            // This shouldn't happen in the normal case, as a backup we
            // read from the system property.
            return getPhoneTypeFromProperty(phoneId);
        }
public intgetDataActivity()
Returns a constant indicating the type of activity on a data connection (cellular).

see
#DATA_ACTIVITY_NONE
see
#DATA_ACTIVITY_IN
see
#DATA_ACTIVITY_OUT
see
#DATA_ACTIVITY_INOUT
see
#DATA_ACTIVITY_DORMANT


                                
       
        try {
            return getITelephony().getDataActivity();
        } catch (RemoteException ex) {
            // the phone process is restarting.
            return DATA_ACTIVITY_NONE;
        } catch (NullPointerException ex) {
          // the phone process is restarting.
          return DATA_ACTIVITY_NONE;
      }
public booleangetDataEnabled()

hide

        return getDataEnabled(SubscriptionManager.getDefaultDataSubId());
public booleangetDataEnabled(int subId)

hide

        boolean retVal = false;
        try {
            retVal = getITelephony().getDataEnabled(subId);
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#getDataEnabled", e);
        } catch (NullPointerException e) {
        }
        Log.d(TAG, "getDataEnabled: retVal=" + retVal);
        return retVal;
public intgetDataNetworkType()
Returns a constant indicating the radio technology (network type) currently in use on the device for data transmission.

return
the network type
see
#NETWORK_TYPE_UNKNOWN
see
#NETWORK_TYPE_GPRS
see
#NETWORK_TYPE_EDGE
see
#NETWORK_TYPE_UMTS
see
#NETWORK_TYPE_HSDPA
see
#NETWORK_TYPE_HSUPA
see
#NETWORK_TYPE_HSPA
see
#NETWORK_TYPE_CDMA
see
#NETWORK_TYPE_EVDO_0
see
#NETWORK_TYPE_EVDO_A
see
#NETWORK_TYPE_EVDO_B
see
#NETWORK_TYPE_1xRTT
see
#NETWORK_TYPE_IDEN
see
#NETWORK_TYPE_LTE
see
#NETWORK_TYPE_EHRPD
see
#NETWORK_TYPE_HSPAP
hide

        return getDataNetworkType(getDefaultSubscription());
public intgetDataNetworkType(int subId)
{@hide}

        try{
            ITelephony telephony = getITelephony();
            if (telephony != null) {
                return telephony.getDataNetworkTypeForSubscriber(subId);
            } else {
                // This can happen when the ITelephony interface is not up yet.
                return NETWORK_TYPE_UNKNOWN;
            }
        } catch(RemoteException ex) {
            // This shouldn't happen in the normal case
            return NETWORK_TYPE_UNKNOWN;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return NETWORK_TYPE_UNKNOWN;
        }
public intgetDataState()
Returns a constant indicating the current data connection state (cellular).

see
#DATA_DISCONNECTED
see
#DATA_CONNECTING
see
#DATA_CONNECTED
see
#DATA_SUSPENDED


                           
       
        try {
            return getITelephony().getDataState();
        } catch (RemoteException ex) {
            // the phone process is restarting.
            return DATA_DISCONNECTED;
        } catch (NullPointerException ex) {
            return DATA_DISCONNECTED;
        }
public static android.telephony.TelephonyManagergetDefault()

hide
/*
deprecated
- use getSystemService as described above


                 
        
        return sInstance;
private static intgetDefaultPhone()
Returns Default phone.

        return SubscriptionManager.getPhoneId(SubscriptionManager.getDefaultSubId());
public intgetDefaultSim()
{@hide}

        return SubscriptionManager.getSlotId(SubscriptionManager.getDefaultSubId());
private static intgetDefaultSubscription()
Returns Default subscription.

        return SubscriptionManager.getDefaultSubId();
public java.lang.StringgetDeviceId()
Returns the unique device ID, for example, the IMEI for GSM and the MEID or ESN for CDMA phones. Return null if device ID is not available.

Requires Permission: {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}

        try {
            return getITelephony().getDeviceId();
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            return null;
        }
public java.lang.StringgetDeviceId(int slotId)
{@hide}

        // FIXME this assumes phoneId == slotId
        try {
            return getSubscriberInfo().getDeviceIdForPhone(slotId);
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            return null;
        }
public java.lang.StringgetDeviceSoftwareVersion()
Returns the software version number for the device, for example, the IMEI/SV for GSM phones. Return null if the software version is not available.

Requires Permission: {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}


    //
    //
    // Device Info
    //
    //

                                        
       
        return getDeviceSoftwareVersion(getDefaultSim());
public java.lang.StringgetDeviceSoftwareVersion(int slotId)
{@hide}

        // FIXME methods taking slot id should not use subscription, instead us Uicc directly
        int[] subId = SubscriptionManager.getSubId(slotId);
        if (subId == null || subId.length == 0) {
            return null;
        }
        try {
            return getSubscriberInfo().getDeviceSvnUsingSubId(subId[0]);
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            return null;
        }
public java.lang.StringgetGroupIdLevel1()
Returns the Group Identifier Level1 for a GSM phone. Return null if it is unavailable.

Requires Permission: {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}

        try {
            return getSubscriberInfo().getGroupIdLevel1();
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return null;
        }
public java.lang.StringgetGroupIdLevel1(int subId)
{@hide}

        try {
            return getSubscriberInfo().getGroupIdLevel1ForSubscriber(subId);
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return null;
        }
private com.android.internal.telephony.ITelephonygetITelephony()

hide

        return ITelephony.Stub.asInterface(ServiceManager.getService(Context.TELEPHONY_SERVICE));
public java.lang.StringgetIccSimChallengeResponse(int subId, int appType, java.lang.String data)
Returns the response of SIM Authentication through RIL. Returns null if the Authentication hasn't been successful

param
subId subscription ID to be queried
param
appType ICC application type (@see com.android.internal.telephony.PhoneConstants#APPTYPE_xxx)
param
data authentication challenge data
return
the response of SIM Authentication, or null if not available
hide

        try {
            return getSubscriberInfo().getIccSimChallengeResponse(subId, appType, data);
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            // This could happen before phone starts
            return null;
        }
public java.lang.StringgetIccSimChallengeResponse(int appType, java.lang.String data)
Returns the response of SIM Authentication through RIL for the default subscription. Returns null if the Authentication hasn't been successful

param
appType ICC application type (@see com.android.internal.telephony.PhoneConstants#APPTYPE_xxx)
param
data authentication challenge data
return
the response of SIM Authentication, or null if not available
hide

        return getIccSimChallengeResponse(getDefaultSubscription(), appType, data);
public java.lang.StringgetImei()
{@hide}

        return getImei(getDefaultSim());
public java.lang.StringgetImei(int slotId)
{@hide}

        int[] subId = SubscriptionManager.getSubId(slotId);
        try {
            return getSubscriberInfo().getImeiForSubscriber(subId[0]);
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            return null;
        }
public static intgetIntAtIndex(android.content.ContentResolver cr, java.lang.String name, int index)
Convenience function for retrieving a value from the secure settings value list as an integer. Note that internally setting values are always stored as strings; this function converts the string to an integer for you.

This version does not take a default value. If the setting has not been set, or the string value is not a number, it throws {@link SettingNotFoundException}.

param
cr The ContentResolver to access.
param
name The name of the setting to retrieve.
param
index The index of the list
throws
SettingNotFoundException Thrown if a setting by the given name can't be found or the setting value is not an integer.
return
The value at the given index of settings.
hide

        String v = android.provider.Settings.Global.getString(cr, name);
        if (v != null) {
            String valArray[] = v.split(",");
            if ((index >= 0) && (index < valArray.length) && (valArray[index] != null)) {
                try {
                    return Integer.parseInt(valArray[index]);
                } catch (NumberFormatException e) {
                    //Log.e(TAG, "Exception while parsing Integer: ", e);
                }
            }
        }
        throw new android.provider.Settings.SettingNotFoundException(name);
public static intgetIntWithSubId(android.content.ContentResolver cr, java.lang.String name, int subId, int def)
This function retrieves value for setting "name+subId", and if that is not found retrieves value for setting "name", and if that is not found uses def as default

hide

        return Settings.Global.getInt(cr, name + subId, Settings.Global.getInt(cr, name, def));
public static intgetIntWithSubId(android.content.ContentResolver cr, java.lang.String name, int subId)
This function retrieves value for setting "name+subId", and if that is not found retrieves value for setting "name", and if that is not found throws SettingNotFoundException

hide

        try {
            return Settings.Global.getInt(cr, name + subId);
        } catch (SettingNotFoundException e) {
            try {
                int val = Settings.Global.getInt(cr, name);
                Settings.Global.putInt(cr, name + subId, val);

                /* We are now moving from 'setting' to 'setting+subId', and using the value stored
                 * for 'setting' as default. Reset the default (since it may have a user set
                 * value). */
                int default_val = val;
                if (name.equals(Settings.Global.MOBILE_DATA)) {
                    default_val = "true".equalsIgnoreCase(
                            SystemProperties.get("ro.com.android.mobiledata", "true")) ? 1 : 0;
                } else if (name.equals(Settings.Global.DATA_ROAMING)) {
                    default_val = "true".equalsIgnoreCase(
                            SystemProperties.get("ro.com.android.dataroaming", "false")) ? 1 : 0;
                }

                if (default_val != val) {
                    Settings.Global.putInt(cr, name, default_val);
                }

                return val;
            } catch (SettingNotFoundException exc) {
                throw new SettingNotFoundException(name);
            }
        }
public java.lang.StringgetIsimChallengeResponse(java.lang.String nonce)
Returns the response of ISIM Authetification through RIL. Returns null if the Authentification hasn't been successed or isn't present iphonesubinfo.

return
the response of ISIM Authetification, or null if not available
hide
deprecated
see
getIccSimChallengeResponse with appType=PhoneConstants.APPTYPE_ISIM

        try {
            return getSubscriberInfo().getIsimChallengeResponse(nonce);
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return null;
        }
public java.lang.StringgetIsimDomain()
Returns the IMS home network domain name that was loaded from the ISIM.

return
the IMS domain name, or null if not present or not loaded
hide

        try {
            return getSubscriberInfo().getIsimDomain();
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return null;
        }
public java.lang.StringgetIsimImpi()
Returns the IMS private user identity (IMPI) that was loaded from the ISIM.

return
the IMPI, or null if not present or not loaded
hide

        try {
            return getSubscriberInfo().getIsimImpi();
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return null;
        }
public java.lang.String[]getIsimImpu()
Returns the IMS public user identities (IMPU) that were loaded from the ISIM.

return
an array of IMPU strings, with one IMPU per string, or null if not present or not loaded
hide

        try {
            return getSubscriberInfo().getIsimImpu();
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return null;
        }
public java.lang.StringgetIsimIst()
Returns the IMS Service Table (IST) that was loaded from the ISIM.

return
IMS Service Table or null if not present or not loaded
hide

        try {
            return getSubscriberInfo().getIsimIst();
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return null;
        }
public java.lang.String[]getIsimPcscf()
Returns the IMS Proxy Call Session Control Function(PCSCF) that were loaded from the ISIM.

return
an array of PCSCF strings with one PCSCF per string, or null if not present or not loaded
hide

        try {
            return getSubscriberInfo().getIsimPcscf();
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return null;
        }
public java.lang.StringgetLine1AlphaTag()
Returns the alphabetic identifier associated with the line 1 number. Return null if it is unavailable.

Requires Permission: {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}

hide
nobody seems to call this.

        return getLine1AlphaTagForSubscriber(getDefaultSubscription());
public java.lang.StringgetLine1AlphaTagForSubscriber(int subId)
{@hide}

        String alphaTag = null;
        try {
            alphaTag = getITelephony().getLine1AlphaTagForDisplay(subId);
        } catch (RemoteException ex) {
        } catch (NullPointerException ex) {
        }
        if (alphaTag != null) {
            return alphaTag;
        }
        try {
            return getSubscriberInfo().getLine1AlphaTagForSubscriber(subId);
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return null;
        }
public java.lang.StringgetLine1Number()
Returns the phone number string for line 1, for example, the MSISDN for a GSM phone. Return null if it is unavailable.

Requires Permission: {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}

        return getLine1NumberForSubscriber(getDefaultSubscription());
public java.lang.StringgetLine1NumberForSubscriber(int subId)
{@hide}

        String number = null;
        try {
            number = getITelephony().getLine1NumberForDisplay(subId);
        } catch (RemoteException ex) {
        } catch (NullPointerException ex) {
        }
        if (number != null) {
            return number;
        }
        try {
            return getSubscriberInfo().getLine1NumberForSubscriber(subId);
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return null;
        }
public intgetLteOnCdmaMode()
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}
hide

        return getLteOnCdmaMode(getDefaultSubscription());
public intgetLteOnCdmaMode(int subId)
{@hide}

        try {
            return getITelephony().getLteOnCdmaModeForSubscriber(subId);
        } catch (RemoteException ex) {
            // Assume no ICC card if remote exception which shouldn't happen
            return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return PhoneConstants.LTE_ON_CDMA_UNKNOWN;
        }
public static intgetLteOnCdmaModeStatic()
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}
hide


                                            
        
        int retVal;
        int curVal;
        String productType = "";

        curVal = SystemProperties.getInt(TelephonyProperties.PROPERTY_LTE_ON_CDMA_DEVICE,
                    PhoneConstants.LTE_ON_CDMA_UNKNOWN);
        retVal = curVal;
        if (retVal == PhoneConstants.LTE_ON_CDMA_UNKNOWN) {
            Matcher matcher = sProductTypePattern.matcher(sKernelCmdLine);
            if (matcher.find()) {
                productType = matcher.group(1);
                if (sLteOnCdmaProductType.equals(productType)) {
                    retVal = PhoneConstants.LTE_ON_CDMA_TRUE;
                } else {
                    retVal = PhoneConstants.LTE_ON_CDMA_FALSE;
                }
            } else {
                retVal = PhoneConstants.LTE_ON_CDMA_FALSE;
            }
        }

        Rlog.d(TAG, "getLteOnCdmaMode=" + retVal + " curVal=" + curVal +
                " product_type='" + productType +
                "' lteOnCdmaProductType='" + sLteOnCdmaProductType + "'");
        return retVal;
public java.lang.String[]getMergedSubscriberIds()
Return the set of subscriber IDs that should be considered as "merged together" for data usage purposes. This is commonly {@code null} to indicate no merging is required. Any returned subscribers are sorted in a deterministic order.

hide

        try {
            return getITelephony().getMergedSubscriberIds();
        } catch (RemoteException ex) {
        } catch (NullPointerException ex) {
        }
        return null;
public java.lang.StringgetMmsUAProfUrl()
Returns the MMS user agent profile URL.

        if (mContext == null) return null;
        return mContext.getResources().getString(
                com.android.internal.R.string.config_mms_user_agent_profile_url);
public java.lang.StringgetMmsUserAgent()
Returns the MMS user agent.

        if (mContext == null) return null;
        return mContext.getResources().getString(
                com.android.internal.R.string.config_mms_user_agent);
public java.lang.StringgetMsisdn()
Returns the MSISDN string. for a GSM phone. Return null if it is unavailable.

Requires Permission: {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}

hide

        return getMsisdn(getDefaultSubscription());
public java.lang.StringgetMsisdn(int subId)
{@hide}

        try {
            return getSubscriberInfo().getMsisdnForSubscriber(subId);
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return null;
        }
public android.telephony.TelephonyManager$MultiSimVariantsgetMultiSimConfiguration()
{@hide}

        String mSimConfig =
            SystemProperties.get(TelephonyProperties.PROPERTY_MULTI_SIM_CONFIG);
        if (mSimConfig.equals("dsds")) {
            return MultiSimVariants.DSDS;
        } else if (mSimConfig.equals("dsda")) {
            return MultiSimVariants.DSDA;
        } else if (mSimConfig.equals("tsts")) {
            return MultiSimVariants.TSTS;
        } else {
            return MultiSimVariants.UNKNOWN;
        }
public java.lang.StringgetNai()
{@hide}

        return getNai(getDefaultSim());
public java.lang.StringgetNai(int slotId)
{@hide}

        int[] subId = SubscriptionManager.getSubId(slotId);
        try {
            String nai = getSubscriberInfo().getNaiForSubscriber(subId[0]);
            if (Log.isLoggable(TAG, Log.VERBOSE)) {
                Rlog.v(TAG, "Nai = " + nai);
            }
            return nai;
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            return null;
        }
public java.util.ListgetNeighboringCellInfo()
Returns the neighboring cell information of the device. The getAllCellInfo is preferred and use this only if getAllCellInfo return nulls or an empty list.

In the future this call will be deprecated.

return
List of NeighboringCellInfo or null if info unavailable.

Requires Permission: (@link android.Manifest.permission#ACCESS_COARSE_UPDATES}

        try {
            return getITelephony().getNeighboringCellInfo(mContext.getOpPackageName());
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            return null;
        }
public static intgetNetworkClass(int networkType)
Return general class of network type, such as "3G" or "4G". In cases where classification is contentious, this method is conservative.

hide


                               
         
        switch (networkType) {
            case NETWORK_TYPE_GPRS:
            case NETWORK_TYPE_GSM:
            case NETWORK_TYPE_EDGE:
            case NETWORK_TYPE_CDMA:
            case NETWORK_TYPE_1xRTT:
            case NETWORK_TYPE_IDEN:
                return NETWORK_CLASS_2_G;
            case NETWORK_TYPE_UMTS:
            case NETWORK_TYPE_EVDO_0:
            case NETWORK_TYPE_EVDO_A:
            case NETWORK_TYPE_HSDPA:
            case NETWORK_TYPE_HSUPA:
            case NETWORK_TYPE_HSPA:
            case NETWORK_TYPE_EVDO_B:
            case NETWORK_TYPE_EHRPD:
            case NETWORK_TYPE_HSPAP:
                return NETWORK_CLASS_3_G;
            case NETWORK_TYPE_LTE:
                return NETWORK_CLASS_4_G;
            default:
                return NETWORK_CLASS_UNKNOWN;
        }
public java.lang.StringgetNetworkCountryIso()
Returns the ISO country code equivalent of the current registered operator's MCC (Mobile Country Code).

Availability: Only when user is registered to a network. Result may be unreliable on CDMA networks (use {@link #getPhoneType()} to determine if on a CDMA network).

        return getNetworkCountryIsoForPhone(getDefaultPhone());
public java.lang.StringgetNetworkCountryIsoForPhone(int phoneId)
{@hide}

        return getTelephonyProperty(phoneId, TelephonyProperties.PROPERTY_OPERATOR_ISO_COUNTRY, "");
public java.lang.StringgetNetworkCountryIsoForSubscription(int subId)
{@hide}

        int phoneId = SubscriptionManager.getPhoneId(subId);
        return getNetworkCountryIsoForPhone(phoneId);
public java.lang.StringgetNetworkOperator()
Returns the numeric name (MCC+MNC) of current registered operator.

Availability: Only when user is registered to a network. Result may be unreliable on CDMA networks (use {@link #getPhoneType()} to determine if on a CDMA network).

        return getNetworkOperatorForPhone(getDefaultPhone());
public java.lang.StringgetNetworkOperatorForPhone(int phoneId)
Returns the numeric name (MCC+MNC) of current registered operator for a particular subscription.

Availability: Only when user is registered to a network. Result may be unreliable on CDMA networks (use {@link #getPhoneType()} to determine if on a CDMA network).

param
phoneId
hide

        return getTelephonyProperty(phoneId, TelephonyProperties.PROPERTY_OPERATOR_NUMERIC, "");
public java.lang.StringgetNetworkOperatorForSubscription(int subId)
{@hide}

        int phoneId = SubscriptionManager.getPhoneId(subId);
        return getNetworkOperatorForPhone(phoneId);
public java.lang.StringgetNetworkOperatorName()
Returns the alphabetic name of current registered operator.

Availability: Only when user is registered to a network. Result may be unreliable on CDMA networks (use {@link #getPhoneType()} to determine if on a CDMA network).

        return getNetworkOperatorName(getDefaultSubscription());
public java.lang.StringgetNetworkOperatorName(int subId)
{@hide}

        int phoneId = SubscriptionManager.getPhoneId(subId);
        return getTelephonyProperty(phoneId, TelephonyProperties.PROPERTY_OPERATOR_ALPHA, "");
public intgetNetworkType()

return
the NETWORK_TYPE_xxxx for current data connection.


                
       
        return getDataNetworkType();
public intgetNetworkType(int subId)
{@hide}

       try {
           ITelephony telephony = getITelephony();
           if (telephony != null) {
               return telephony.getNetworkTypeForSubscriber(subId);
           } else {
               // This can happen when the ITelephony interface is not up yet.
               return NETWORK_TYPE_UNKNOWN;
           }
       } catch(RemoteException ex) {
           // This shouldn't happen in the normal case
           return NETWORK_TYPE_UNKNOWN;
       } catch (NullPointerException ex) {
           // This could happen before phone restarts due to crashing
           return NETWORK_TYPE_UNKNOWN;
       }
public java.lang.StringgetNetworkTypeName()
Returns a string representation of the radio technology (network type) currently in use on the device.

return
the name of the radio technology
hide
pending API council review

        return getNetworkTypeName(getNetworkType());
public static java.lang.StringgetNetworkTypeName(int type)
{@hide}

        switch (type) {
            case NETWORK_TYPE_GPRS:
                return "GPRS";
            case NETWORK_TYPE_EDGE:
                return "EDGE";
            case NETWORK_TYPE_UMTS:
                return "UMTS";
            case NETWORK_TYPE_HSDPA:
                return "HSDPA";
            case NETWORK_TYPE_HSUPA:
                return "HSUPA";
            case NETWORK_TYPE_HSPA:
                return "HSPA";
            case NETWORK_TYPE_CDMA:
                return "CDMA";
            case NETWORK_TYPE_EVDO_0:
                return "CDMA - EvDo rev. 0";
            case NETWORK_TYPE_EVDO_A:
                return "CDMA - EvDo rev. A";
            case NETWORK_TYPE_EVDO_B:
                return "CDMA - EvDo rev. B";
            case NETWORK_TYPE_1xRTT:
                return "CDMA - 1xRTT";
            case NETWORK_TYPE_LTE:
                return "LTE";
            case NETWORK_TYPE_EHRPD:
                return "CDMA - eHRPD";
            case NETWORK_TYPE_IDEN:
                return "iDEN";
            case NETWORK_TYPE_HSPAP:
                return "HSPA+";
            case NETWORK_TYPE_GSM:
                return "GSM";
            default:
                return "UNKNOWN";
        }
public java.lang.StringgetOtaSpNumberSchema(java.lang.String defaultValue)
Get OTASP number schema for the default phone.

param
defaultValue default value
return
OTA SP number schema
hide

        int phoneId = getDefaultPhone();
        return getOtaSpNumberSchemaForPhone(phoneId, defaultValue);
public java.lang.StringgetOtaSpNumberSchemaForPhone(int phoneId, java.lang.String defaultValue)
Get OTASP number schema by phone id.

param
phoneId for which OTA SP number schema is get
param
defaultValue default value
return
OTA SP number schema
hide

        if (SubscriptionManager.isValidPhoneId(phoneId)) {
            return TelephonyManager.getTelephonyProperty(phoneId,
                    TelephonyProperties.PROPERTY_OTASP_NUM_SCHEMA, defaultValue);
        }

        return defaultValue;
public java.lang.String[]getPcscfAddress(java.lang.String apnType)
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
return
array of P-CSCF address
hide

        try {
            return getITelephony().getPcscfAddress(apnType);
        } catch (RemoteException e) {
            return new String[0];
        }
public intgetPhoneCount()
{@hide}

        int phoneCount = 1;
        switch (getMultiSimConfiguration()) {
            case UNKNOWN:
                phoneCount = 1;
                break;
            case DSDS:
            case DSDA:
                phoneCount = PhoneConstants.MAX_PHONE_COUNT_DUAL_SIM;
                break;
            case TSTS:
                phoneCount = PhoneConstants.MAX_PHONE_COUNT_TRI_SIM;
                break;
        }
        return phoneCount;
public intgetPhoneType()
Returns a constant indicating the device phone type. This indicates the type of radio used to transmit voice calls.

see
#PHONE_TYPE_NONE
see
#PHONE_TYPE_GSM
see
#PHONE_TYPE_CDMA
see
#PHONE_TYPE_SIP

        if (!isVoiceCapable()) {
            return PHONE_TYPE_NONE;
        }
        return getCurrentPhoneType();
public static intgetPhoneType(int networkMode)
This function returns the type of the phone, depending on the network mode.

param
networkMode
return
Phone Type
hide

        switch(networkMode) {
        case RILConstants.NETWORK_MODE_CDMA:
        case RILConstants.NETWORK_MODE_CDMA_NO_EVDO:
        case RILConstants.NETWORK_MODE_EVDO_NO_CDMA:
            return PhoneConstants.PHONE_TYPE_CDMA;

        case RILConstants.NETWORK_MODE_WCDMA_PREF:
        case RILConstants.NETWORK_MODE_GSM_ONLY:
        case RILConstants.NETWORK_MODE_WCDMA_ONLY:
        case RILConstants.NETWORK_MODE_GSM_UMTS:
        case RILConstants.NETWORK_MODE_LTE_GSM_WCDMA:
        case RILConstants.NETWORK_MODE_LTE_WCDMA:
        case RILConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA:
            return PhoneConstants.PHONE_TYPE_GSM;

        // Use CDMA Phone for the global mode including CDMA
        case RILConstants.NETWORK_MODE_GLOBAL:
        case RILConstants.NETWORK_MODE_LTE_CDMA_EVDO:
            return PhoneConstants.PHONE_TYPE_CDMA;

        case RILConstants.NETWORK_MODE_LTE_ONLY:
            if (getLteOnCdmaModeStatic() == PhoneConstants.LTE_ON_CDMA_TRUE) {
                return PhoneConstants.PHONE_TYPE_CDMA;
            } else {
                return PhoneConstants.PHONE_TYPE_GSM;
            }
        default:
            return PhoneConstants.PHONE_TYPE_GSM;
        }
private intgetPhoneTypeFromNetworkType()

        return getPhoneTypeFromNetworkType(getDefaultPhone());
private intgetPhoneTypeFromNetworkType(int phoneId)
{@hide}

        // When the system property CURRENT_ACTIVE_PHONE, has not been set,
        // use the system property for default network type.
        // This is a fail safe, and can only happen at first boot.
        String mode = getTelephonyProperty(phoneId, "ro.telephony.default_network", null);
        if (mode != null) {
            return TelephonyManager.getPhoneType(Integer.parseInt(mode));
        }
        return TelephonyManager.PHONE_TYPE_NONE;
private intgetPhoneTypeFromProperty()

        return getPhoneTypeFromProperty(getDefaultPhone());
private intgetPhoneTypeFromProperty(int phoneId)
{@hide}

        String type = getTelephonyProperty(phoneId,
                TelephonyProperties.CURRENT_ACTIVE_PHONE, null);
        if (type == null || type.equals("")) {
            return getPhoneTypeFromNetworkType(phoneId);
        }
        return Integer.parseInt(type);
public intgetPreferredNetworkType()
Get the preferred network type. Used for device configuration by some CDMA operators.

Requires Permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} Or the calling app has carrier privileges. @see #hasCarrierPrivileges

return
the preferred network type, defined in RILConstants.java.
hide

        try {
            return getITelephony().getPreferredNetworkType();
        } catch (RemoteException ex) {
            Rlog.e(TAG, "getPreferredNetworkType RemoteException", ex);
        } catch (NullPointerException ex) {
            Rlog.e(TAG, "getPreferredNetworkType NPE", ex);
        }
        return -1;
private static java.lang.StringgetProcCmdLine()
The contents of the /proc/cmdline file

        String cmdline = "";
        FileInputStream is = null;
        try {
            is = new FileInputStream("/proc/cmdline");
            byte [] buffer = new byte[2048];
            int count = is.read(buffer);
            if (count > 0) {
                cmdline = new String(buffer, 0, count);
            }
        } catch (IOException e) {
            Rlog.d(TAG, "No /proc/cmdline exception=" + e);
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                }
            }
        }
        Rlog.d(TAG, "/proc/cmdline=" + cmdline);
        return cmdline;
public intgetSimCount()

hide

        // FIXME Need to get it from Telephony Dev Controller when that gets implemented!
        // and then this method shouldn't be used at all!
        if(isMultiSimEnabled()) {
            return 2;
        } else {
            return 1;
        }
public java.lang.StringgetSimCountryIso()
Returns the ISO country code equivalent for the SIM provider's country code.

        return getSimCountryIsoForPhone(getDefaultPhone());
public java.lang.StringgetSimCountryIso(int subId)
Returns the ISO country code equivalent for the SIM provider's country code.

param
subId for which SimCountryIso is returned
hide

        return getSimCountryIsoForSubscription(subId);
public java.lang.StringgetSimCountryIsoForPhone(int phoneId)
Returns the ISO country code equivalent for the SIM provider's country code.

hide

        return getTelephonyProperty(phoneId,
                TelephonyProperties.PROPERTY_ICC_OPERATOR_ISO_COUNTRY, "");
public java.lang.StringgetSimCountryIsoForSubscription(int subId)
Returns the ISO country code equivalent for the SIM provider's country code.

param
subId for which SimCountryIso is returned
hide

        int phoneId = SubscriptionManager.getPhoneId(subId);
        return getSimCountryIsoForPhone(phoneId);
public java.lang.StringgetSimOperator()
Returns the MCC+MNC (mobile country code + mobile network code) of the provider of the SIM. 5 or 6 decimal digits.

Availability: SIM state must be {@link #SIM_STATE_READY}

see
#getSimState

        return getSimOperatorNumeric();
public java.lang.StringgetSimOperator(int subId)
Returns the MCC+MNC (mobile country code + mobile network code) of the provider of the SIM. 5 or 6 decimal digits.

Availability: SIM state must be {@link #SIM_STATE_READY}

see
#getSimState
param
subId for which SimOperator is returned
hide

        return getSimOperatorNumericForSubscription(subId);
public java.lang.StringgetSimOperatorName()
Returns the Service Provider Name (SPN).

Availability: SIM state must be {@link #SIM_STATE_READY}

see
#getSimState

        return getSimOperatorNameForPhone(getDefaultPhone());
public java.lang.StringgetSimOperatorNameForPhone(int phoneId)
Returns the Service Provider Name (SPN).

hide

         return getTelephonyProperty(phoneId,
                TelephonyProperties.PROPERTY_ICC_OPERATOR_ALPHA, "");
public java.lang.StringgetSimOperatorNameForSubscription(int subId)
Returns the Service Provider Name (SPN).

Availability: SIM state must be {@link #SIM_STATE_READY}

see
#getSimState
param
subId for which SimOperatorName is returned
hide

        int phoneId = SubscriptionManager.getPhoneId(subId);
        return getSimOperatorNameForPhone(phoneId);
public java.lang.StringgetSimOperatorNumeric()
Returns the MCC+MNC (mobile country code + mobile network code) of the provider of the SIM. 5 or 6 decimal digits.

Availability: SIM state must be {@link #SIM_STATE_READY}

see
#getSimState
hide

        int subId = SubscriptionManager.getDefaultDataSubId();
        if (!SubscriptionManager.isUsableSubIdValue(subId)) {
            subId = SubscriptionManager.getDefaultSmsSubId();
            if (!SubscriptionManager.isUsableSubIdValue(subId)) {
                subId = SubscriptionManager.getDefaultVoiceSubId();
                if (!SubscriptionManager.isUsableSubIdValue(subId)) {
                    subId = SubscriptionManager.getDefaultSubId();
                }
            }
        }
        Rlog.d(TAG, "getSimOperatorNumeric(): default subId=" + subId);
        return getSimOperatorNumericForSubscription(subId);
public java.lang.StringgetSimOperatorNumericForPhone(int phoneId)
Returns the MCC+MNC (mobile country code + mobile network code) of the provider of the SIM for a particular subscription. 5 or 6 decimal digits.

param
phoneId for which SimOperator is returned
hide

        return getTelephonyProperty(phoneId,
                TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC, "");
public java.lang.StringgetSimOperatorNumericForSubscription(int subId)
Returns the MCC+MNC (mobile country code + mobile network code) of the provider of the SIM for a particular subscription. 5 or 6 decimal digits.

Availability: SIM state must be {@link #SIM_STATE_READY}

see
#getSimState
param
subId for which SimOperator is returned
hide

        int phoneId = SubscriptionManager.getPhoneId(subId);
        return getSimOperatorNumericForPhone(phoneId);
public java.lang.StringgetSimSerialNumber()
Returns the serial number of the SIM, if applicable. Return null if it is unavailable.

Requires Permission: {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}

         return getSimSerialNumber(getDefaultSubscription());
public java.lang.StringgetSimSerialNumber(int subId)
{@hide}

        try {
            return getSubscriberInfo().getIccSerialNumberForSubscriber(subId);
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return null;
        }
public intgetSimState()
Returns a constant indicating the state of the default SIM card.

see
#SIM_STATE_UNKNOWN
see
#SIM_STATE_ABSENT
see
#SIM_STATE_PIN_REQUIRED
see
#SIM_STATE_PUK_REQUIRED
see
#SIM_STATE_NETWORK_LOCKED
see
#SIM_STATE_READY
see
#SIM_STATE_NOT_READY
see
#SIM_STATE_PERM_DISABLED
see
#SIM_STATE_CARD_IO_ERROR

        return getSimState(getDefaultSim());
public intgetSimState(int slotIdx)
{@hide}

        int[] subId = SubscriptionManager.getSubId(slotIdx);
        if (subId == null || subId.length == 0) {
            Rlog.d(TAG, "getSimState:- empty subId return SIM_STATE_ABSENT");
            return SIM_STATE_UNKNOWN;
        }
        int simState = SubscriptionManager.getSimStateForSubscriber(subId[0]);
        Rlog.d(TAG, "getSimState: simState=" + simState + " slotIdx=" + slotIdx);
        return simState;
public booleangetSmsReceiveCapable(boolean defaultValue)
Get SMS receive capable from system property for the default phone.

param
defaultValue default value
return
SMS receive capable
hide

        int phoneId = getDefaultPhone();
        return getSmsReceiveCapableForPhone(phoneId, defaultValue);
public booleangetSmsReceiveCapableForPhone(int phoneId, boolean defaultValue)
Get SMS receive capable from system property by phone id.

param
phoneId for which SMS receive capable is get
param
defaultValue default value
return
SMS receive capable
hide

        if (SubscriptionManager.isValidPhoneId(phoneId)) {
            return Boolean.valueOf(TelephonyManager.getTelephonyProperty(phoneId,
                    TelephonyProperties.PROPERTY_SMS_RECEIVE, String.valueOf(defaultValue)));
        }

        return defaultValue;
public booleangetSmsSendCapable(boolean defaultValue)
Get SMS send capable from system property for the default phone.

param
defaultValue default value
return
SMS send capable
hide

        int phoneId = getDefaultPhone();
        return getSmsSendCapableForPhone(phoneId, defaultValue);
public booleangetSmsSendCapableForPhone(int phoneId, boolean defaultValue)
Get SMS send capable from system property by phone id.

param
phoneId for which SMS send capable is get
param
defaultValue default value
return
SMS send capable
hide

        if (SubscriptionManager.isValidPhoneId(phoneId)) {
            return Boolean.valueOf(TelephonyManager.getTelephonyProperty(phoneId,
                    TelephonyProperties.PROPERTY_SMS_SEND, String.valueOf(defaultValue)));
        }

        return defaultValue;
public java.lang.StringgetSubscriberId()
Returns the unique subscriber ID, for example, the IMSI for a GSM phone. Return null if it is unavailable.

Requires Permission: {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}

        return getSubscriberId(getDefaultSubscription());
public java.lang.StringgetSubscriberId(int subId)
{@hide}

        try {
            return getSubscriberInfo().getSubscriberIdForSubscriber(subId);
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return null;
        }
private com.android.internal.telephony.IPhoneSubInfogetSubscriberInfo()

hide

        // get it each time because that process crashes a lot
        return IPhoneSubInfo.Stub.asInterface(ServiceManager.getService("iphonesubinfo"));
private com.android.internal.telecom.ITelecomServicegetTelecomService()

hide

        return ITelecomService.Stub.asInterface(ServiceManager.getService(Context.TELECOM_SERVICE));
public static java.lang.StringgetTelephonyProperty(int phoneId, java.lang.String property, java.lang.String defaultVal)
Gets the telephony property.

hide

        String propVal = null;
        String prop = SystemProperties.get(property);
        if ((prop != null) && (prop.length() > 0)) {
            String values[] = prop.split(",");
            if ((phoneId >= 0) && (phoneId < values.length) && (values[phoneId] != null)) {
                propVal = values[phoneId];
            }
        }
        Rlog.d(TAG, "getTelephonyProperty: return propVal='" + propVal + "' phoneId=" + phoneId
                + " property='" + property + "' defaultVal='" + defaultVal + "' prop=" + prop);
        return propVal == null ? defaultVal : propVal;
public intgetTetherApnRequired()
Check TETHER_DUN_REQUIRED and TETHER_DUN_APN settings, net.tethering.noprovisioning SystemProperty, and config_tether_apndata to decide whether DUN APN is required for tethering.

return
0: Not required. 1: required. 2: Not set.
hide

        try {
            return getITelephony().getTetherApnRequired();
        } catch (RemoteException ex) {
            Rlog.e(TAG, "hasMatchedTetherApnSetting RemoteException", ex);
        } catch (NullPointerException ex) {
            Rlog.e(TAG, "hasMatchedTetherApnSetting NPE", ex);
        }
        return 2;
public java.lang.StringgetVoiceMailAlphaTag()
Retrieves the alphabetic identifier associated with the voice mail number.

Requires Permission: {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}

        return getVoiceMailAlphaTag(getDefaultSubscription());
public java.lang.StringgetVoiceMailAlphaTag(int subId)
{@hide}

        try {
            return getSubscriberInfo().getVoiceMailAlphaTagForSubscriber(subId);
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return null;
        }
public java.lang.StringgetVoiceMailNumber()
Returns the voice mail number. Return null if it is unavailable.

Requires Permission: {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}

        return getVoiceMailNumber(getDefaultSubscription());
public java.lang.StringgetVoiceMailNumber(int subId)
{@hide}

        try {
            return getSubscriberInfo().getVoiceMailNumberForSubscriber(subId);
        } catch (RemoteException ex) {
            return null;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return null;
        }
public intgetVoiceMessageCount()
Returns the voice mail count. Return 0 if unavailable.

Requires Permission: {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE}

hide

        return getVoiceMessageCount(getDefaultSubscription());
public intgetVoiceMessageCount(int subId)
{@hide}

        try {
            return getITelephony().getVoiceMessageCountForSubscriber(subId);
        } catch (RemoteException ex) {
            return 0;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return 0;
        }
public intgetVoiceNetworkType()
Returns the NETWORK_TYPE_xxxx for voice

hide

        return getVoiceNetworkType(getDefaultSubscription());
public intgetVoiceNetworkType(int subId)
{@hide}

        try{
            ITelephony telephony = getITelephony();
            if (telephony != null) {
                return telephony.getVoiceNetworkTypeForSubscriber(subId);
            } else {
                // This can happen when the ITelephony interface is not up yet.
                return NETWORK_TYPE_UNKNOWN;
            }
        } catch(RemoteException ex) {
            // This shouldn't happen in the normal case
            return NETWORK_TYPE_UNKNOWN;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return NETWORK_TYPE_UNKNOWN;
        }
public booleanhandlePinMmi(java.lang.String dialString)

hide

        try {
            return getITelephony().handlePinMmi(dialString);
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#handlePinMmi", e);
        }
        return false;
public booleanhandlePinMmiForSubscriber(int subId, java.lang.String dialString)

hide

        try {
            return getITelephony().handlePinMmiForSubscriber(subId, dialString);
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#handlePinMmi", e);
        }
        return false;
public booleanhasCarrierPrivileges()
Has the calling application been granted carrier privileges by the carrier. If any of the packages in the calling UID has carrier privileges, the call will return true. This access is granted by the owner of the UICC card and does not depend on the registered carrier.

return
true if the app has carrier privileges.


                                                                
       
        try {
            return getITelephony().getCarrierPrivilegeStatus() ==
                CARRIER_PRIVILEGE_STATUS_HAS_ACCESS;
        } catch (RemoteException ex) {
            Rlog.e(TAG, "hasCarrierPrivileges RemoteException", ex);
        } catch (NullPointerException ex) {
            Rlog.e(TAG, "hasCarrierPrivileges NPE", ex);
        }
        return false;
public booleanhasIccCard()

return
true if a ICC card is present


                 
       
        return hasIccCard(getDefaultSim());
public booleanhasIccCard(int slotId)
{@hide}


        try {
            return getITelephony().hasIccCardUsingSlotId(slotId);
        } catch (RemoteException ex) {
            // Assume no ICC card if remote exception which shouldn't happen
            return false;
        } catch (NullPointerException ex) {
            // This could happen before phone restarts due to crashing
            return false;
        }
public booleaniccCloseLogicalChannel(int channel)
Closes a previously opened logical channel to the ICC card. Input parameters equivalent to TS 27.007 AT+CCHC command.

Requires Permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} Or the calling app has carrier privileges. @see #hasCarrierPrivileges

param
channel is the channel id to be closed as retruned by a successful iccOpenLogicalChannel.
return
true if the channel was closed successfully.

        try {
            return getITelephony().iccCloseLogicalChannel(channel);
        } catch (RemoteException ex) {
        } catch (NullPointerException ex) {
        }
        return false;
public byte[]iccExchangeSimIO(int fileID, int command, int p1, int p2, int p3, java.lang.String filePath)
Returns the response APDU for a command APDU sent through SIM_IO.

Requires Permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} Or the calling app has carrier privileges. @see #hasCarrierPrivileges

param
fileID
param
command
param
p1 P1 value of the APDU command.
param
p2 P2 value of the APDU command.
param
p3 P3 value of the APDU command.
param
filePath
return
The APDU response.

        try {
            return getITelephony().iccExchangeSimIO(fileID, command, p1, p2,
                p3, filePath);
        } catch (RemoteException ex) {
        } catch (NullPointerException ex) {
        }
        return null;
public IccOpenLogicalChannelResponseiccOpenLogicalChannel(java.lang.String AID)
Opens a logical channel to the ICC card. Input parameters equivalent to TS 27.007 AT+CCHO command.

Requires Permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} Or the calling app has carrier privileges. @see #hasCarrierPrivileges

param
AID Application id. See ETSI 102.221 and 101.220.
return
an IccOpenLogicalChannelResponse object.

        try {
            return getITelephony().iccOpenLogicalChannel(AID);
        } catch (RemoteException ex) {
        } catch (NullPointerException ex) {
        }
        return null;
public java.lang.StringiccTransmitApduBasicChannel(int cla, int instruction, int p1, int p2, int p3, java.lang.String data)
Transmit an APDU to the ICC card over the basic channel. Input parameters equivalent to TS 27.007 AT+CSIM command.

Requires Permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} Or the calling app has carrier privileges. @see #hasCarrierPrivileges

param
cla Class of the APDU command.
param
instruction Instruction of the APDU command.
param
p1 P1 value of the APDU command.
param
p2 P2 value of the APDU command.
param
p3 P3 value of the APDU command. If p3 is negative a 4 byte APDU is sent to the SIM.
param
data Data to be sent with the APDU.
return
The APDU response from the ICC card with the status appended at the end.

        try {
            return getITelephony().iccTransmitApduBasicChannel(cla,
                    instruction, p1, p2, p3, data);
        } catch (RemoteException ex) {
        } catch (NullPointerException ex) {
        }
        return "";
public java.lang.StringiccTransmitApduLogicalChannel(int channel, int cla, int instruction, int p1, int p2, int p3, java.lang.String data)
Transmit an APDU to the ICC card over a logical channel. Input parameters equivalent to TS 27.007 AT+CGLA command.

Requires Permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} Or the calling app has carrier privileges. @see #hasCarrierPrivileges

param
channel is the channel id to be closed as returned by a successful iccOpenLogicalChannel.
param
cla Class of the APDU command.
param
instruction Instruction of the APDU command.
param
p1 P1 value of the APDU command.
param
p2 P2 value of the APDU command.
param
p3 P3 value of the APDU command. If p3 is negative a 4 byte APDU is sent to the SIM.
param
data Data to be sent with the APDU.
return
The APDU response from the ICC card with the status appended at the end.

        try {
            return getITelephony().iccTransmitApduLogicalChannel(channel, cla,
                    instruction, p1, p2, p3, data);
        } catch (RemoteException ex) {
        } catch (NullPointerException ex) {
        }
        return "";
public intinvokeOemRilRequestRaw(byte[] oemReq, byte[] oemResp)
Returns the result and response from RIL for oem request

param
oemReq the data is sent to ril.
param
oemResp the respose data from RIL.
return
negative value request was not handled or get error 0 request was handled succesfully, but no response data positive value success, data length of response
hide

        try {
            return getITelephony().invokeOemRilRequestRaw(oemReq, oemResp);
        } catch (RemoteException ex) {
        } catch (NullPointerException ex) {
        }
        return -1;
public booleanisDataConnectivityPossible()

hide

        try {
            return getITelephony().isDataConnectivityPossible();
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#isDataConnectivityPossible", e);
        }
        return false;
public booleanisIdle()

hide

        try {
            return getITelephony().isIdle();
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#isIdle", e);
        }
        return true;
public booleanisImsRegistered()
Returns the IMS Registration Status

hide

       try {
           return getITelephony().isImsRegistered();
       } catch (RemoteException ex) {
           return false;
       } catch (NullPointerException ex) {
           return false;
       }
public booleanisMultiSimEnabled()
{@hide}

        return (multiSimConfig.equals("dsds") || multiSimConfig.equals("dsda") ||
            multiSimConfig.equals("tsts"));
public booleanisNetworkRoaming()
Returns true if the device is considered roaming on the current network, for GSM purposes.

Availability: Only when user registered to a network.

        return isNetworkRoaming(getDefaultSubscription());
public booleanisNetworkRoaming(int subId)
{@hide}

        int phoneId = SubscriptionManager.getPhoneId(subId);
        return Boolean.parseBoolean(getTelephonyProperty(phoneId,
                TelephonyProperties.PROPERTY_OPERATOR_ISROAMING, null));
public booleanisOffhook()

hide

        try {
            return getITelephony().isOffhook();
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#isOffhook", e);
        }
        return false;
public booleanisRadioOn()

hide

        try {
            return getITelephony().isRadioOn();
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#isRadioOn", e);
        }
        return false;
public booleanisRinging()

hide

        try {
            return getITelephony().isRinging();
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#isRinging", e);
        }
        return false;
public booleanisSimPinEnabled()

hide

        try {
            return getITelephony().isSimPinEnabled();
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#isSimPinEnabled", e);
        }
        return false;
public booleanisSmsCapable()

return
true if the current device supports sms service.

If true, this means that the device supports both sending and receiving sms via the telephony network.

Note: Voicemail waiting sms, cell broadcasting sms, and MMS are disabled when device doesn't support sms.

        if (mContext == null) return true;
        return mContext.getResources().getBoolean(
                com.android.internal.R.bool.config_sms_capable);
public booleanisVideoCallingEnabled()

hide

        try {
            return getITelephony().isVideoCallingEnabled();
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#isVideoCallingEnabled", e);
        }
        return false;
public booleanisVoiceCapable()

return
true if the current device is "voice capable".

"Voice capable" means that this device supports circuit-switched (i.e. voice) phone calls over the telephony network, and is allowed to display the in-call UI while a cellular voice call is active. This will be false on "data only" devices which can't make voice calls and don't support any in-call UI.

Note: the meaning of this flag is subtly different from the PackageManager.FEATURE_TELEPHONY system feature, which is available on any device with a telephony radio, even if the device is data-only.

        if (mContext == null) return true;
        return mContext.getResources().getBoolean(
                com.android.internal.R.bool.config_voice_capable);
public voidlisten(PhoneStateListener listener, int events)
Registers a listener object to receive notification of changes in specified telephony states.

To register a listener, pass a {@link PhoneStateListener} and specify at least one telephony state of interest in the events argument. At registration, and when a specified telephony state changes, the telephony manager invokes the appropriate callback method on the listener object and passes the current (updated) values.

To unregister a listener, pass the listener object and set the events argument to {@link PhoneStateListener#LISTEN_NONE LISTEN_NONE} (0).

param
listener The {@link PhoneStateListener} object to register (or unregister)
param
events The telephony state(s) of interest to the listener, as a bitwise-OR combination of {@link PhoneStateListener} LISTEN_ flags.

        String pkgForDebug = mContext != null ? mContext.getPackageName() : "<unknown>";
        try {
            Boolean notifyNow = (getITelephony() != null);
            sRegistry.listenForSubscriber(listener.mSubId, pkgForDebug, listener.callback, events, notifyNow);
        } catch (RemoteException ex) {
            // system process dead
        } catch (NullPointerException ex) {
            // system process dead
        }
public booleanneedsOtaServiceProvisioning()

hide

        try {
            return getITelephony().needsOtaServiceProvisioning();
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#needsOtaServiceProvisioning", e);
        }
        return false;
public java.lang.StringnvReadItem(int itemID)
Read one of the NV items defined in com.android.internal.telephony.RadioNVItems. Used for device configuration by some CDMA operators.

Requires Permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} Or the calling app has carrier privileges. @see #hasCarrierPrivileges

param
itemID the ID of the item to read.
return
the NV item as a String, or null on any failure.
hide

        try {
            return getITelephony().nvReadItem(itemID);
        } catch (RemoteException ex) {
            Rlog.e(TAG, "nvReadItem RemoteException", ex);
        } catch (NullPointerException ex) {
            Rlog.e(TAG, "nvReadItem NPE", ex);
        }
        return "";
public booleannvResetConfig(int resetType)
Perform the specified type of NV config reset. The radio will be taken offline and the device must be rebooted after the operation. Used for device configuration by some CDMA operators.

Requires Permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} Or the calling app has carrier privileges. @see #hasCarrierPrivileges

param
resetType reset type: 1: reload NV reset, 2: erase NV reset, 3: factory NV reset
return
true on success; false on any failure.
hide

        try {
            return getITelephony().nvResetConfig(resetType);
        } catch (RemoteException ex) {
            Rlog.e(TAG, "nvResetConfig RemoteException", ex);
        } catch (NullPointerException ex) {
            Rlog.e(TAG, "nvResetConfig NPE", ex);
        }
        return false;
public booleannvWriteCdmaPrl(byte[] preferredRoamingList)
Update the CDMA Preferred Roaming List (PRL) in the radio NV storage. Used for device configuration by some CDMA operators.

Requires Permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} Or the calling app has carrier privileges. @see #hasCarrierPrivileges

param
preferredRoamingList byte array containing the new PRL.
return
true on success; false on any failure.
hide

        try {
            return getITelephony().nvWriteCdmaPrl(preferredRoamingList);
        } catch (RemoteException ex) {
            Rlog.e(TAG, "nvWriteCdmaPrl RemoteException", ex);
        } catch (NullPointerException ex) {
            Rlog.e(TAG, "nvWriteCdmaPrl NPE", ex);
        }
        return false;
public booleannvWriteItem(int itemID, java.lang.String itemValue)
Write one of the NV items defined in com.android.internal.telephony.RadioNVItems. Used for device configuration by some CDMA operators.

Requires Permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} Or the calling app has carrier privileges. @see #hasCarrierPrivileges

param
itemID the ID of the item to read.
param
itemValue the value to write, as a String.
return
true on success; false on any failure.
hide

        try {
            return getITelephony().nvWriteItem(itemID, itemValue);
        } catch (RemoteException ex) {
            Rlog.e(TAG, "nvWriteItem RemoteException", ex);
        } catch (NullPointerException ex) {
            Rlog.e(TAG, "nvWriteItem NPE", ex);
        }
        return false;
public static booleanputIntAtIndex(android.content.ContentResolver cr, java.lang.String name, int index, int value)
Convenience function for updating settings value as coma separated integer values. This will either create a new entry in the table if the given name does not exist, or modify the value of the existing row with that name. Note that internally setting values are always stored as strings, so this function converts the given value to a string before storing it.

param
cr The ContentResolver to access.
param
name The name of the setting to modify.
param
index The index of the list
param
value The new value for the setting to be added to the list.
return
true if the value was set, false on database errors
hide

        String data = "";
        String valArray[] = null;
        String v = android.provider.Settings.Global.getString(cr, name);

        if (index == Integer.MAX_VALUE) {
            throw new RuntimeException("putIntAtIndex index == MAX_VALUE index=" + index);
        }
        if (index < 0) {
            throw new RuntimeException("putIntAtIndex index < 0 index=" + index);
        }
        if (v != null) {
            valArray = v.split(",");
        }

        // Copy the elements from valArray till index
        for (int i = 0; i < index; i++) {
            String str = "";
            if ((valArray != null) && (i < valArray.length)) {
                str = valArray[i];
            }
            data = data + str + ",";
        }

        data = data + value;

        // Copy the remaining elements from valArray if any.
        if (valArray != null) {
            for (int i = index+1; i < valArray.length; i++) {
                data = data + "," + valArray[i];
            }
        }
        return android.provider.Settings.Global.putString(cr, name, data);
public java.lang.StringsendEnvelopeWithStatus(java.lang.String content)
Send ENVELOPE to the SIM and return the response.

Requires Permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} Or the calling app has carrier privileges. @see #hasCarrierPrivileges

param
content String containing SAT/USAT response in hexadecimal format starting with command tag. See TS 102 223 for details.
return
The APDU response from the ICC card in hexadecimal format with the last 4 bytes being the status word. If the command fails, returns an empty string.

        try {
            return getITelephony().sendEnvelopeWithStatus(content);
        } catch (RemoteException ex) {
        } catch (NullPointerException ex) {
        }
        return "";
public voidsetBasebandVersion(java.lang.String version)
Set baseband version for the default phone.

param
version baseband version
hide

        int phoneId = getDefaultPhone();
        setBasebandVersionForPhone(phoneId, version);
public voidsetBasebandVersionForPhone(int phoneId, java.lang.String version)
Set baseband version by phone id.

param
phoneId for which baseband version is set
param
version baseband version
hide

        if (SubscriptionManager.isValidPhoneId(phoneId)) {
            String prop = TelephonyProperties.PROPERTY_BASEBAND_VERSION +
                    ((phoneId == 0) ? "" : Integer.toString(phoneId));
            SystemProperties.set(prop, version);
        }
public voidsetCellInfoListRate(int rateInMillis)
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
hide

        try {
            getITelephony().setCellInfoListRate(rateInMillis);
        } catch (RemoteException ex) {
        } catch (NullPointerException ex) {
        }
public voidsetDataEnabled(boolean enable)

hide

        setDataEnabled(SubscriptionManager.getDefaultDataSubId(), enable);
public voidsetDataEnabled(int subId, boolean enable)

hide

        try {
            Log.d(TAG, "setDataEnabled: enabled=" + enable);
            getITelephony().setDataEnabled(subId, enable);
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#setDataEnabled", e);
        }
public voidsetDataNetworkType(int type)
Set the network type currently in use on the device for data transmission.

param
type the network type currently in use on the device for data transmission
hide

        int phoneId = getDefaultPhone();
        setDataNetworkTypeForPhone(phoneId, type);
public voidsetDataNetworkTypeForPhone(int phoneId, int type)
Set the network type currently in use on the device for data transmission.

param
phoneId which phone you want to set
param
type the network type currently in use on the device for data transmission
hide

        if (SubscriptionManager.isValidPhoneId(phoneId)) {
            setTelephonyProperty(phoneId,
                    TelephonyProperties.PROPERTY_DATA_NETWORK_TYPE,
                    ServiceState.rilRadioTechnologyToString(type));
        }
public voidsetImsRegistrationState(boolean registered)
Set IMS registration state

param
Registration state
hide

        try {
            getITelephony().setImsRegistrationState(registered);
        } catch (RemoteException e) {
        }
public booleansetLine1NumberForDisplay(java.lang.String alphaTag, java.lang.String number)
Set the line 1 phone number string and its alphatag for the current ICCID for display purpose only, for example, displayed in Phone Status. It won't change the actual MSISDN/MDN. To unset alphatag or number, pass in a null value.

Requires that the calling app has carrier privileges.

see
#hasCarrierPrivileges
param
alphaTag alpha-tagging of the dailing nubmer
param
number The dialing number
return
true if the operation was executed correctly.

        return setLine1NumberForDisplayForSubscriber(getDefaultSubscription(), alphaTag, number);
public booleansetLine1NumberForDisplayForSubscriber(int subId, java.lang.String alphaTag, java.lang.String number)
Set the line 1 phone number string and its alphatag for the current ICCID for display purpose only, for example, displayed in Phone Status. It won't change the actual MSISDN/MDN. To unset alphatag or number, pass in a null value.

Requires that the calling app has carrier privileges.

see
#hasCarrierPrivileges
param
subId the subscriber that the alphatag and dialing number belongs to.
param
alphaTag alpha-tagging of the dailing nubmer
param
number The dialing number
return
true if the operation was executed correctly.
hide

        try {
            return getITelephony().setLine1NumberForDisplayForSubscriber(subId, alphaTag, number);
        } catch (RemoteException ex) {
        } catch (NullPointerException ex) {
        }
        return false;
public voidsetNetworkCountryIso(java.lang.String iso)
Set the ISO country code equivalent of the current registered operator's MCC (Mobile Country Code).

param
iso the ISO country code equivalent of the current registered
hide

        int phoneId = getDefaultPhone();
        setNetworkCountryIsoForPhone(phoneId, iso);
public voidsetNetworkCountryIsoForPhone(int phoneId, java.lang.String iso)
Set the ISO country code equivalent of the current registered operator's MCC (Mobile Country Code).

param
phoneId which phone you want to set
param
iso the ISO country code equivalent of the current registered
hide

        if (SubscriptionManager.isValidPhoneId(phoneId)) {
            setTelephonyProperty(phoneId,
                    TelephonyProperties.PROPERTY_OPERATOR_ISO_COUNTRY, iso);
        }
public voidsetNetworkOperatorName(java.lang.String name)
Set the alphabetic name of current registered operator.

param
name the alphabetic name of current registered operator.
hide

        int phoneId = getDefaultPhone();
        setNetworkOperatorNameForPhone(phoneId, name);
public voidsetNetworkOperatorNameForPhone(int phoneId, java.lang.String name)
Set the alphabetic name of current registered operator.

param
phoneId which phone you want to set
param
name the alphabetic name of current registered operator.
hide

        if (SubscriptionManager.isValidPhoneId(phoneId)) {
            setTelephonyProperty(phoneId, TelephonyProperties.PROPERTY_OPERATOR_ALPHA, name);
        }
public voidsetNetworkOperatorNumeric(java.lang.String numeric)
Set the numeric name (MCC+MNC) of current registered operator.

param
operator the numeric name (MCC+MNC) of current registered operator
hide

        int phoneId = getDefaultPhone();
        setNetworkOperatorNumericForPhone(phoneId, numeric);
public voidsetNetworkOperatorNumericForPhone(int phoneId, java.lang.String numeric)
Set the numeric name (MCC+MNC) of current registered operator.

param
phoneId for which phone type is set
param
operator the numeric name (MCC+MNC) of current registered operator
hide

        setTelephonyProperty(phoneId, TelephonyProperties.PROPERTY_OPERATOR_NUMERIC, numeric);
public voidsetNetworkRoaming(boolean isRoaming)
Set roaming state of the current network, for GSM purposes.

param
isRoaming is network in romaing state or not
hide

        int phoneId = getDefaultPhone();
        setNetworkRoamingForPhone(phoneId, isRoaming);
public voidsetNetworkRoamingForPhone(int phoneId, boolean isRoaming)
Set roaming state of the current network, for GSM purposes.

param
phoneId which phone you want to set
param
isRoaming is network in romaing state or not
hide

        if (SubscriptionManager.isValidPhoneId(phoneId)) {
            setTelephonyProperty(phoneId, TelephonyProperties.PROPERTY_OPERATOR_ISROAMING,
                    isRoaming ? "true" : "false");
        }
public booleansetOperatorBrandOverride(java.lang.String brand)
Override the branding for the current ICCID. Once set, whenever the SIM is present in the device, the service provider name (SPN) and the operator name will both be replaced by the brand value input. To unset the value, the same function should be called with a null brand value.

Requires that the calling app has carrier privileges.

see
#hasCarrierPrivileges
param
brand The brand name to display/set.
return
true if the operation was executed correctly.

        try {
            return getITelephony().setOperatorBrandOverride(brand);
        } catch (RemoteException ex) {
            Rlog.e(TAG, "setOperatorBrandOverride RemoteException", ex);
        } catch (NullPointerException ex) {
            Rlog.e(TAG, "setOperatorBrandOverride NPE", ex);
        }
        return false;
public voidsetPhoneType(int type)
Set phone type for the default phone.

param
type phone type
hide

        int phoneId = getDefaultPhone();
        setPhoneType(phoneId, type);
public voidsetPhoneType(int phoneId, int type)
Set phone type by phone id.

param
phoneId for which phone type is set
param
type phone type
hide

        if (SubscriptionManager.isValidPhoneId(phoneId)) {
            TelephonyManager.setTelephonyProperty(phoneId,
                    TelephonyProperties.CURRENT_ACTIVE_PHONE, String.valueOf(type));
        }
public booleansetPreferredNetworkType(int networkType)
Set the preferred network type. Used for device configuration by some CDMA operators.

Requires Permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE} Or the calling app has carrier privileges. @see #hasCarrierPrivileges

param
networkType the preferred network type, defined in RILConstants.java.
return
true on success; false on any failure.
hide

        try {
            return getITelephony().setPreferredNetworkType(networkType);
        } catch (RemoteException ex) {
            Rlog.e(TAG, "setPreferredNetworkType RemoteException", ex);
        } catch (NullPointerException ex) {
            Rlog.e(TAG, "setPreferredNetworkType NPE", ex);
        }
        return false;
public booleansetPreferredNetworkTypeToGlobal()
Set the preferred network type to global mode which includes LTE, CDMA, EvDo and GSM/WCDMA.

Requires that the calling app has carrier privileges.

see
#hasCarrierPrivileges
return
true on success; false on any failure.

        return setPreferredNetworkType(RILConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA);
public booleansetRadio(boolean turnOn)

hide

        try {
            return getITelephony().setRadio(turnOn);
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#setRadio", e);
        }
        return false;
public booleansetRadioPower(boolean turnOn)

hide

        try {
            return getITelephony().setRadioPower(turnOn);
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#setRadioPower", e);
        }
        return false;
public booleansetRoamingOverride(java.util.List gsmRoamingList, java.util.List gsmNonRoamingList, java.util.List cdmaRoamingList, java.util.List cdmaNonRoamingList)
Override the roaming preference for the current ICCID. Using this call, the carrier app (see #hasCarrierPrivileges) can override the platform's notion of a network operator being considered roaming or not. The change only affects the ICCID that was active when this call was made. If null is passed as any of the input, the corresponding value is deleted.

Requires that the caller have carrier privilege. See #hasCarrierPrivileges.

param
gsmRoamingList - List of MCCMNCs to be considered roaming for 3GPP RATs.
param
gsmNonRoamingList - List of MCCMNCs to be considered not roaming for 3GPP RATs.
param
cdmaRoamingList - List of SIDs to be considered roaming for 3GPP2 RATs.
param
cdmaNonRoamingList - List of SIDs to be considered not roaming for 3GPP2 RATs.
return
true if the operation was executed correctly.
hide

        try {
            return getITelephony().setRoamingOverride(gsmRoamingList, gsmNonRoamingList,
                    cdmaRoamingList, cdmaNonRoamingList);
        } catch (RemoteException ex) {
            Rlog.e(TAG, "setRoamingOverride RemoteException", ex);
        } catch (NullPointerException ex) {
            Rlog.e(TAG, "setRoamingOverride NPE", ex);
        }
        return false;
public voidsetSimCountryIso(java.lang.String iso)
Set TelephonyProperties.PROPERTY_ICC_OPERATOR_ISO_COUNTRY for the default phone.

hide

        int phoneId = getDefaultPhone();
        setSimCountryIsoForPhone(phoneId, iso);
public voidsetSimCountryIsoForPhone(int phoneId, java.lang.String iso)
Set TelephonyProperties.PROPERTY_ICC_OPERATOR_ISO_COUNTRY for the given phone.

hide

        setTelephonyProperty(phoneId,
                TelephonyProperties.PROPERTY_ICC_OPERATOR_ISO_COUNTRY, iso);
public voidsetSimOperatorName(java.lang.String name)
Set TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC for the default phone.

hide

        int phoneId = getDefaultPhone();
        setSimOperatorNameForPhone(phoneId, name);
public voidsetSimOperatorNameForPhone(int phoneId, java.lang.String name)
Set TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC for the given phone.

hide

        setTelephonyProperty(phoneId,
                TelephonyProperties.PROPERTY_ICC_OPERATOR_ALPHA, name);
public voidsetSimOperatorNumeric(java.lang.String numeric)
Set TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC for the default phone.

hide

        int phoneId = getDefaultPhone();
        setSimOperatorNumericForPhone(phoneId, numeric);
public voidsetSimOperatorNumericForPhone(int phoneId, java.lang.String numeric)
Set TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC for the given phone.

hide

        setTelephonyProperty(phoneId,
                TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC, numeric);
public voidsetSimState(java.lang.String state)
Set TelephonyProperties.PROPERTY_SIM_STATE for the default phone.

hide

        int phoneId = getDefaultPhone();
        setSimStateForPhone(phoneId, state);
public voidsetSimStateForPhone(int phoneId, java.lang.String state)
Set TelephonyProperties.PROPERTY_SIM_STATE for the given phone.

hide

        setTelephonyProperty(phoneId,
                TelephonyProperties.PROPERTY_SIM_STATE, state);
public static voidsetTelephonyProperty(int phoneId, java.lang.String property, java.lang.String value)
Sets the telephony property with the value specified.

hide

        String propVal = "";
        String p[] = null;
        String prop = SystemProperties.get(property);

        if (value == null) {
            value = "";
        }

        if (prop != null) {
            p = prop.split(",");
        }

        if (!SubscriptionManager.isValidPhoneId(phoneId)) {
            Rlog.d(TAG, "setTelephonyProperty: invalid phoneId=" + phoneId +
                    " property=" + property + " value: " + value + " prop=" + prop);
            return;
        }

        for (int i = 0; i < phoneId; i++) {
            String str = "";
            if ((p != null) && (i < p.length)) {
                str = p[i];
            }
            propVal = propVal + str + ",";
        }

        propVal = propVal + value;
        if (p != null) {
            for (int i = phoneId + 1; i < p.length; i++) {
                propVal = propVal + "," + p[i];
            }
        }

        if (property.length() > SystemProperties.PROP_NAME_MAX
                || propVal.length() > SystemProperties.PROP_VALUE_MAX) {
            Rlog.d(TAG, "setTelephonyProperty: property to long phoneId=" + phoneId +
                    " property=" + property + " value: " + value + " propVal=" + propVal);
            return;
        }

        Rlog.d(TAG, "setTelephonyProperty: success phoneId=" + phoneId +
                " property=" + property + " value: " + value + " propVal=" + propVal);
        SystemProperties.set(property, propVal);
public booleansetVoiceMailNumber(java.lang.String alphaTag, java.lang.String number)
Sets the voice mail number.

Requires that the calling app has carrier privileges.

see
#hasCarrierPrivileges
param
alphaTag The alpha tag to display.
param
number The voicemail number.

        return setVoiceMailNumber(getDefaultSubscription(), alphaTag, number);
public booleansetVoiceMailNumber(int subId, java.lang.String alphaTag, java.lang.String number)
{@hide}

        try {
            return getITelephony().setVoiceMailNumber(subId, alphaTag, number);
        } catch (RemoteException ex) {
        } catch (NullPointerException ex) {
        }
        return false;
public voidsilenceRinger()

hide

        try {
            getTelecomService().silenceRinger();
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelecomService#silenceRinger", e);
        }
public booleansupplyPin(java.lang.String pin)

hide

        try {
            return getITelephony().supplyPin(pin);
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#supplyPin", e);
        }
        return false;
public int[]supplyPinReportResult(java.lang.String pin)

hide

        try {
            return getITelephony().supplyPinReportResult(pin);
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#supplyPinReportResult", e);
        }
        return new int[0];
public booleansupplyPuk(java.lang.String puk, java.lang.String pin)

hide

        try {
            return getITelephony().supplyPuk(puk, pin);
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#supplyPuk", e);
        }
        return false;
public int[]supplyPukReportResult(java.lang.String puk, java.lang.String pin)

hide

        try {
            return getITelephony().supplyPukReportResult(puk, pin);
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#]", e);
        }
        return new int[0];
public voidtoggleRadioOnOff()

hide

        try {
            getITelephony().toggleRadioOnOff();
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#toggleRadioOnOff", e);
        }
public voidupdateServiceLocation()

hide

        try {
            getITelephony().updateServiceLocation();
        } catch (RemoteException e) {
            Log.e(TAG, "Error calling ITelephony#updateServiceLocation", e);
        }