Message.obj.
* AsyncResult.userData will be set to the obj argument here.
* The h parameter is held only by a weak reference.
*/
public void registerForPreciseCallStateChanged(Handler h, int what, Object obj) {
checkCorrectThread(h);
mPreciseCallStateRegistrants.addUnique(h, what, obj);
}
/**
* Unregisters for voice call state change notifications.
* Extraneous calls are tolerated silently.
*/
public void unregisterForPreciseCallStateChanged(Handler h) {
mPreciseCallStateRegistrants.remove(h);
}
/**
* Subclasses of Phone probably want to replace this with a
* version scoped to their packages
*/
protected void notifyPreciseCallStateChangedP() {
AsyncResult ar = new AsyncResult(null, this, null);
mPreciseCallStateRegistrants.notifyRegistrants(ar);
mNotifier.notifyPreciseCallState(this);
}
/**
* Notifies when a Handover happens due to SRVCC or Silent Redial
*/
public void registerForHandoverStateChanged(Handler h, int what, Object obj) {
checkCorrectThread(h);
mHandoverRegistrants.addUnique(h, what, obj);
}
/**
* Unregisters for handover state notifications
*/
public void unregisterForHandoverStateChanged(Handler h) {
mHandoverRegistrants.remove(h);
}
/**
* Subclasses of Phone probably want to replace this with a
* version scoped to their packages
*/
public void notifyHandoverStateChanged(Connection cn) {
AsyncResult ar = new AsyncResult(null, cn, null);
mHandoverRegistrants.notifyRegistrants(ar);
}
protected void setIsInEmergencyCall() {
}
protected void migrateFrom(Phone from) {
migrate(mHandoverRegistrants, from.mHandoverRegistrants);
migrate(mPreciseCallStateRegistrants, from.mPreciseCallStateRegistrants);
migrate(mNewRingingConnectionRegistrants, from.mNewRingingConnectionRegistrants);
migrate(mIncomingRingRegistrants, from.mIncomingRingRegistrants);
migrate(mDisconnectRegistrants, from.mDisconnectRegistrants);
migrate(mServiceStateRegistrants, from.mServiceStateRegistrants);
migrate(mMmiCompleteRegistrants, from.mMmiCompleteRegistrants);
migrate(mMmiRegistrants, from.mMmiRegistrants);
migrate(mUnknownConnectionRegistrants, from.mUnknownConnectionRegistrants);
migrate(mSuppServiceFailedRegistrants, from.mSuppServiceFailedRegistrants);
if (from.isInEmergencyCall()) {
setIsInEmergencyCall();
}
}
protected void migrate(RegistrantList to, RegistrantList from) {
from.removeCleared();
for (int i = 0, n = from.size(); i < n; i++) {
Registrant r = (Registrant) from.get(i);
Message msg = r.messageForRegistrant();
// Since CallManager has already registered with both CS and IMS phones,
// the migrate should happen only for those registrants which are not
// registered with CallManager.Hence the below check is needed to add
// only those registrants to the registrant list which are not
// coming from the CallManager.
if (msg != null) {
if (msg.obj == CallManager.getInstance().getRegistrantIdentifier()) {
continue;
} else {
to.add((Registrant) from.get(i));
}
} else {
Rlog.d(LOG_TAG, "msg is null");
}
}
}
/**
* Notifies when a previously untracked non-ringing/waiting connection has appeared.
* This is likely due to some other entity (eg, SIM card application) initiating a call.
*/
public void registerForUnknownConnection(Handler h, int what, Object obj) {
checkCorrectThread(h);
mUnknownConnectionRegistrants.addUnique(h, what, obj);
}
/**
* Unregisters for unknown connection notifications.
*/
public void unregisterForUnknownConnection(Handler h) {
mUnknownConnectionRegistrants.remove(h);
}
/**
* Notifies when a new ringing or waiting connection has appeared.* * Messages received from this: * Message.obj will be an AsyncResult * AsyncResult.userObj = obj * AsyncResult.result = a Connection.
* Please check Connection.isRinging() to make sure the Connection * has not dropped since this message was posted. * If Connection.isRinging() is true, then * Connection.getCall() == Phone.getRingingCall() */ public void registerForNewRingingConnection( Handler h, int what, Object obj) { checkCorrectThread(h); mNewRingingConnectionRegistrants.addUnique(h, what, obj); } /** * Unregisters for new ringing connection notification. * Extraneous calls are tolerated silently */ public void unregisterForNewRingingConnection(Handler h) { mNewRingingConnectionRegistrants.remove(h); } /** * Notifies when phone's video capabilities changes
* * Messages received from this: * Message.obj will be an AsyncResult * AsyncResult.userObj = obj * AsyncResult.result = true if phone supports video calling
*/ public void registerForVideoCapabilityChanged( Handler h, int what, Object obj) { checkCorrectThread(h); mVideoCapabilityChangedRegistrants.addUnique(h, what, obj); // Notify any registrants of the cached video capability as soon as they register. notifyForVideoCapabilityChanged(mIsVideoCapable); } /** * Unregisters for video capability changed notification. * Extraneous calls are tolerated silently */ public void unregisterForVideoCapabilityChanged(Handler h) { mVideoCapabilityChangedRegistrants.remove(h); } /** * Register for notifications when a sInCall VoicePrivacy is enabled * * @param h Handler that receives the notification message. * @param what User-defined message code. * @param obj User object. */ public void registerForInCallVoicePrivacyOn(Handler h, int what, Object obj){ mCi.registerForInCallVoicePrivacyOn(h, what, obj); } /** * Unegister for notifications when a sInCall VoicePrivacy is enabled * * @param h Handler to be removed from the registrant list. */ public void unregisterForInCallVoicePrivacyOn(Handler h){ mCi.unregisterForInCallVoicePrivacyOn(h); } /** * Register for notifications when a sInCall VoicePrivacy is disabled * * @param h Handler that receives the notification message. * @param what User-defined message code. * @param obj User object. */ public void registerForInCallVoicePrivacyOff(Handler h, int what, Object obj){ mCi.registerForInCallVoicePrivacyOff(h, what, obj); } /** * Unregister for notifications when a sInCall VoicePrivacy is disabled * * @param h Handler to be removed from the registrant list. */ public void unregisterForInCallVoicePrivacyOff(Handler h){ mCi.unregisterForInCallVoicePrivacyOff(h); } /** * Notifies when an incoming call rings.
* * Messages received from this: * Message.obj will be an AsyncResult * AsyncResult.userObj = obj * AsyncResult.result = a Connection.
*/ public void registerForIncomingRing( Handler h, int what, Object obj) { checkCorrectThread(h); mIncomingRingRegistrants.addUnique(h, what, obj); } /** * Unregisters for ring notification. * Extraneous calls are tolerated silently */ public void unregisterForIncomingRing(Handler h) { mIncomingRingRegistrants.remove(h); } /** * Notifies when a voice connection has disconnected, either due to local * or remote hangup or error. * * Messages received from this will have the following members:
*
* * Example: If Phone.dial is called with "*#31#", then the app will * be notified here.
*
* The returned
*
* Messages received from this:
* Message.obj will be an AsyncResult
* AsyncResult.userObj = obj
* AsyncResult.result = boolean, true to start play ringback tone
* and false to stop.
*/
public void registerForRingbackTone(Handler h, int what, Object obj) {
mCi.registerForRingbackTone(h, what, obj);
}
/**
* Unregisters for ringback tone notification.
*/
public void unregisterForRingbackTone(Handler h) {
mCi.unregisterForRingbackTone(h);
}
/**
* Notifies when out-band on-hold tone is needed.
*
* Messages received from this:
* Message.obj will be an AsyncResult
* AsyncResult.userObj = obj
* AsyncResult.result = boolean, true to start play on-hold tone
* and false to stop.
*/
public void registerForOnHoldTone(Handler h, int what, Object obj) {
}
/**
* Unregisters for on-hold tone notification.
*/
public void unregisterForOnHoldTone(Handler h) {
}
/**
* Registers the handler to reset the uplink mute state to get
* uplink audio.
*/
public void registerForResendIncallMute(Handler h, int what, Object obj) {
mCi.registerForResendIncallMute(h, what, obj);
}
/**
* Unregisters for resend incall mute notifications.
*/
public void unregisterForResendIncallMute(Handler h) {
mCi.unregisterForResendIncallMute(h);
}
/**
* Enables or disables echo suppression.
*/
public void setEchoSuppressionEnabled() {
// no need for regular phone
}
/**
* Subclasses of Phone probably want to replace this with a
* version scoped to their packages
*/
protected void notifyServiceStateChangedP(ServiceState ss) {
AsyncResult ar = new AsyncResult(null, ss, null);
mServiceStateRegistrants.notifyRegistrants(ar);
mNotifier.notifyServiceState(this);
}
/**
* If this is a simulated phone interface, returns a SimulatedRadioControl.
* @return SimulatedRadioControl if this is a simulated interface;
* otherwise, null.
*/
public SimulatedRadioControl getSimulatedRadioControl() {
return mSimulatedRadioControl;
}
/**
* Verifies the current thread is the same as the thread originally
* used in the initialization of this instance. Throws RuntimeException
* if not.
*
* @exception RuntimeException if the current thread is not
* the thread that originally obtained this Phone instance.
*/
private void checkCorrectThread(Handler h) {
if (h.getLooper() != mLooper) {
throw new RuntimeException(
"com.android.internal.telephony.Phone must be used from within one thread");
}
}
/**
* Set the properties by matching the carrier string in
* a string-array resource
*/
private static Locale getLocaleFromCarrierProperties(Context ctx) {
String carrier = SystemProperties.get("ro.carrier");
if (null == carrier || 0 == carrier.length() || "unknown".equals(carrier)) {
return null;
}
CharSequence[] carrierLocales = ctx.getResources().getTextArray(R.array.carrier_properties);
for (int i = 0; i < carrierLocales.length; i+=3) {
String c = carrierLocales[i].toString();
if (carrier.equals(c)) {
return Locale.forLanguageTag(carrierLocales[i + 1].toString().replace('_', '-'));
}
}
return null;
}
/**
* Get current coarse-grained voice call state.
* Use {@link #registerForPreciseCallStateChanged(Handler, int, Object)
* registerForPreciseCallStateChanged()} for change notification.
* If the phone has an active call and call waiting occurs,
* then the phone state is RINGING not OFFHOOK
* Note:
* This registration point provides notification of finer-grained
* changes.
*/
public abstract PhoneConstants.State getState();
/**
* Retrieves the IccFileHandler of the Phone instance
*/
public IccFileHandler getIccFileHandler(){
UiccCardApplication uiccApplication = mUiccApplication.get();
IccFileHandler fh;
if (uiccApplication == null) {
Rlog.d(LOG_TAG, "getIccFileHandler: uiccApplication == null, return null");
fh = null;
} else {
fh = uiccApplication.getIccFileHandler();
}
Rlog.d(LOG_TAG, "getIccFileHandler: fh=" + fh);
return fh;
}
/*
* Retrieves the Handler of the Phone instance
*/
public Handler getHandler() {
return this;
}
/**
* Update the phone object if the voice radio technology has changed
*
* @param voiceRadioTech The new voice radio technology
*/
public void updatePhoneObject(int voiceRadioTech) {
}
/**
* Retrieves the ServiceStateTracker of the phone instance.
*/
public ServiceStateTracker getServiceStateTracker() {
return null;
}
/**
* Get call tracker
*/
public CallTracker getCallTracker() {
return null;
}
/**
* Update voice activation state
*/
public void setVoiceActivationState(int state) {
mSimActivationTracker.setVoiceActivationState(state);
}
/**
* Update data activation state
*/
public void setDataActivationState(int state) {
mSimActivationTracker.setDataActivationState(state);
}
/**
* Returns voice activation state
*/
public int getVoiceActivationState() {
return mSimActivationTracker.getVoiceActivationState();
}
/**
* Returns data activation state
*/
public int getDataActivationState() {
return mSimActivationTracker.getDataActivationState();
}
/**
* Update voice mail count related fields and notify listeners
*/
public void updateVoiceMail() {
Rlog.e(LOG_TAG, "updateVoiceMail() should be overridden");
}
public AppType getCurrentUiccAppType() {
UiccCardApplication currentApp = mUiccApplication.get();
if (currentApp != null) {
return currentApp.getType();
}
return AppType.APPTYPE_UNKNOWN;
}
/**
* Returns the ICC card interface for this phone, or null
* if not applicable to underlying technology.
*/
public IccCard getIccCard() {
return null;
//throw new Exception("getIccCard Shouldn't be called from Phone");
}
/**
* Retrieves the serial number of the ICC, if applicable. Returns only the decimal digits before
* the first hex digit in the ICC ID.
*/
public String getIccSerialNumber() {
IccRecords r = mIccRecords.get();
return (r != null) ? r.getIccId() : null;
}
/**
* Retrieves the full serial number of the ICC (including hex digits), if applicable.
*/
public String getFullIccSerialNumber() {
IccRecords r = mIccRecords.get();
return (r != null) ? r.getFullIccId() : null;
}
/**
* Returns SIM record load state. Use
*
*/
public int getVoiceMessageCount(){
return mVmCount;
}
/** sets the voice mail count of the phone and notifies listeners. */
public void setVoiceMessageCount(int countWaiting) {
mVmCount = countWaiting;
int subId = getSubId();
if (SubscriptionManager.isValidSubscriptionId(subId)) {
Rlog.d(LOG_TAG, "setVoiceMessageCount: Storing Voice Mail Count = " + countWaiting +
" for mVmCountKey = " + VM_COUNT + subId + " in preferences.");
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(mContext);
SharedPreferences.Editor editor = sp.edit();
editor.putInt(VM_COUNT + subId, countWaiting);
editor.apply();
} else {
Rlog.e(LOG_TAG, "setVoiceMessageCount in sharedPreference: invalid subId " + subId);
}
// notify listeners of voice mail
notifyMessageWaitingIndicator();
}
/** gets the voice mail count from preferences */
protected int getStoredVoiceMessageCount() {
int countVoiceMessages = 0;
int subId = getSubId();
if (SubscriptionManager.isValidSubscriptionId(subId)) {
int invalidCount = -2; //-1 is not really invalid. It is used for unknown number of vm
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(mContext);
int countFromSP = sp.getInt(VM_COUNT + subId, invalidCount);
if (countFromSP != invalidCount) {
countVoiceMessages = countFromSP;
Rlog.d(LOG_TAG, "getStoredVoiceMessageCount: from preference for subId " + subId +
"= " + countVoiceMessages);
} else {
// Check for old preference if count not found for current subId. This part of the
// code is needed only when upgrading from M to N.
String subscriberId = sp.getString(VM_ID, null);
if (subscriberId != null) {
String currentSubscriberId = getSubscriberId();
if (currentSubscriberId != null && currentSubscriberId.equals(subscriberId)) {
// get voice mail count from preferences
countVoiceMessages = sp.getInt(VM_COUNT, 0);
setVoiceMessageCount(countVoiceMessages);
Rlog.d(LOG_TAG, "getStoredVoiceMessageCount: from preference = " +
countVoiceMessages);
} else {
Rlog.d(LOG_TAG, "getStoredVoiceMessageCount: returning 0 as count for " +
"matching subscriberId not found");
}
// get rid of old preferences.
SharedPreferences.Editor editor = sp.edit();
editor.remove(VM_ID);
editor.remove(VM_COUNT);
editor.apply();
}
}
} else {
Rlog.e(LOG_TAG, "getStoredVoiceMessageCount: invalid subId " + subId);
}
return countVoiceMessages;
}
/**
* send secret dialer codes to launch arbitrary activities.
* an Intent is started with the android_secret_code://
*
* Messages of type
*
* Message.arg1 will be the post dial character being processed,
* or 0 ('\0') if end of string.
*
* If Connection.getPostDialState() == WAIT,
* the application must call
* {@link com.android.internal.telephony.Connection#proceedAfterWaitChar()
* Connection.proceedAfterWaitChar()} or
* {@link com.android.internal.telephony.Connection#cancelPostDial()
* Connection.cancelPostDial()}
* for the telephony system to continue playing the post-dial
* DTMF sequence.
*
* If Connection.getPostDialState() == WILD,
* the application must call
* {@link com.android.internal.telephony.Connection#proceedAfterWildChar
* Connection.proceedAfterWildChar()}
* or
* {@link com.android.internal.telephony.Connection#cancelPostDial()
* Connection.cancelPostDial()}
* for the telephony system to continue playing the
* post-dial DTMF sequence.
*
* Only one post dial character handler may be set.
* Calling this method with "h" equal to null unsets this handler.
*/
public void setOnPostDialCharacter(Handler h, int what, Object obj) {
mPostDialHandler = new Registrant(h, what, obj);
}
public Registrant getPostDialHandler() {
return mPostDialHandler;
}
/**
* request to exit emergency call back mode
* the caller should use setOnECMModeExitResponse
* to receive the emergency callback mode exit response
*/
public void exitEmergencyCallbackMode() {
}
/**
* Register for notifications when CDMA OTA Provision status change
*
* @param h Handler that receives the notification message.
* @param what User-defined message code.
* @param obj User object.
*/
public void registerForCdmaOtaStatusChange(Handler h, int what, Object obj) {
}
/**
* Unregister for notifications when CDMA OTA Provision status change
* @param h Handler to be removed from the registrant list.
*/
public void unregisterForCdmaOtaStatusChange(Handler h) {
}
/**
* Registration point for subscription info ready
* @param h handler to notify
* @param what what code of message when delivered
* @param obj placed in Message.obj
*/
public void registerForSubscriptionInfoReady(Handler h, int what, Object obj) {
}
/**
* Unregister for notifications for subscription info
* @param h Handler to be removed from the registrant list.
*/
public void unregisterForSubscriptionInfoReady(Handler h) {
}
/**
* Returns true if OTA Service Provisioning needs to be performed.
*/
public boolean needsOtaServiceProvisioning() {
return false;
}
/**
* this decides if the dial number is OTA(Over the air provision) number or not
* @param dialStr is string representing the dialing digit(s)
* @return true means the dialStr is OTA number, and false means the dialStr is not OTA number
*/
public boolean isOtaSpNumber(String dialStr) {
return false;
}
/**
* Register for notifications when CDMA call waiting comes
*
* @param h Handler that receives the notification message.
* @param what User-defined message code.
* @param obj User object.
*/
public void registerForCallWaiting(Handler h, int what, Object obj){
}
/**
* Unegister for notifications when CDMA Call waiting comes
* @param h Handler to be removed from the registrant list.
*/
public void unregisterForCallWaiting(Handler h){
}
/**
* Registration point for Ecm timer reset
* @param h handler to notify
* @param what user-defined message code
* @param obj placed in Message.obj
*/
public void registerForEcmTimerReset(Handler h, int what, Object obj) {
}
/**
* Unregister for notification for Ecm timer reset
* @param h Handler to be removed from the registrant list.
*/
public void unregisterForEcmTimerReset(Handler h) {
}
/**
* Register for signal information notifications from the network.
* Message.obj will contain an AsyncResult.
* AsyncResult.result will be a SuppServiceNotification instance.
*
* @param h Handler that receives the notification message.
* @param what User-defined message code.
* @param obj User object.
*/
public void registerForSignalInfo(Handler h, int what, Object obj) {
mCi.registerForSignalInfo(h, what, obj);
}
/**
* Unregisters for signal information notifications.
* Extraneous calls are tolerated silently
*
* @param h Handler to be removed from the registrant list.
*/
public void unregisterForSignalInfo(Handler h) {
mCi.unregisterForSignalInfo(h);
}
/**
* Register for display information notifications from the network.
* Message.obj will contain an AsyncResult.
* AsyncResult.result will be a SuppServiceNotification instance.
*
* @param h Handler that receives the notification message.
* @param what User-defined message code.
* @param obj User object.
*/
public void registerForDisplayInfo(Handler h, int what, Object obj) {
mCi.registerForDisplayInfo(h, what, obj);
}
/**
* Unregisters for display information notifications.
* Extraneous calls are tolerated silently
*
* @param h Handler to be removed from the registrant list.
*/
public void unregisterForDisplayInfo(Handler h) {
mCi.unregisterForDisplayInfo(h);
}
/**
* Register for CDMA number information record notification from the network.
* Message.obj will contain an AsyncResult.
* AsyncResult.result will be a CdmaInformationRecords.CdmaNumberInfoRec
* instance.
*
* @param h Handler that receives the notification message.
* @param what User-defined message code.
* @param obj User object.
*/
public void registerForNumberInfo(Handler h, int what, Object obj) {
mCi.registerForNumberInfo(h, what, obj);
}
/**
* Unregisters for number information record notifications.
* Extraneous calls are tolerated silently
*
* @param h Handler to be removed from the registrant list.
*/
public void unregisterForNumberInfo(Handler h) {
mCi.unregisterForNumberInfo(h);
}
/**
* Register for CDMA redirected number information record notification
* from the network.
* Message.obj will contain an AsyncResult.
* AsyncResult.result will be a CdmaInformationRecords.CdmaRedirectingNumberInfoRec
* instance.
*
* @param h Handler that receives the notification message.
* @param what User-defined message code.
* @param obj User object.
*/
public void registerForRedirectedNumberInfo(Handler h, int what, Object obj) {
mCi.registerForRedirectedNumberInfo(h, what, obj);
}
/**
* Unregisters for redirected number information record notification.
* Extraneous calls are tolerated silently
*
* @param h Handler to be removed from the registrant list.
*/
public void unregisterForRedirectedNumberInfo(Handler h) {
mCi.unregisterForRedirectedNumberInfo(h);
}
/**
* Register for CDMA line control information record notification
* from the network.
* Message.obj will contain an AsyncResult.
* AsyncResult.result will be a CdmaInformationRecords.CdmaLineControlInfoRec
* instance.
*
* @param h Handler that receives the notification message.
* @param what User-defined message code.
* @param obj User object.
*/
public void registerForLineControlInfo(Handler h, int what, Object obj) {
mCi.registerForLineControlInfo(h, what, obj);
}
/**
* Unregisters for line control information notifications.
* Extraneous calls are tolerated silently
*
* @param h Handler to be removed from the registrant list.
*/
public void unregisterForLineControlInfo(Handler h) {
mCi.unregisterForLineControlInfo(h);
}
/**
* Register for CDMA T53 CLIR information record notifications
* from the network.
* Message.obj will contain an AsyncResult.
* AsyncResult.result will be a CdmaInformationRecords.CdmaT53ClirInfoRec
* instance.
*
* @param h Handler that receives the notification message.
* @param what User-defined message code.
* @param obj User object.
*/
public void registerFoT53ClirlInfo(Handler h, int what, Object obj) {
mCi.registerFoT53ClirlInfo(h, what, obj);
}
/**
* Unregisters for T53 CLIR information record notification
* Extraneous calls are tolerated silently
*
* @param h Handler to be removed from the registrant list.
*/
public void unregisterForT53ClirInfo(Handler h) {
mCi.unregisterForT53ClirInfo(h);
}
/**
* Register for CDMA T53 audio control information record notifications
* from the network.
* Message.obj will contain an AsyncResult.
* AsyncResult.result will be a CdmaInformationRecords.CdmaT53AudioControlInfoRec
* instance.
*
* @param h Handler that receives the notification message.
* @param what User-defined message code.
* @param obj User object.
*/
public void registerForT53AudioControlInfo(Handler h, int what, Object obj) {
mCi.registerForT53AudioControlInfo(h, what, obj);
}
/**
* Unregisters for T53 audio control information record notifications.
* Extraneous calls are tolerated silently
*
* @param h Handler to be removed from the registrant list.
*/
public void unregisterForT53AudioControlInfo(Handler h) {
mCi.unregisterForT53AudioControlInfo(h);
}
/**
* registers for exit emergency call back mode request response
*
* @param h Handler that receives the notification message.
* @param what User-defined message code.
* @param obj User object.
*/
public void setOnEcbModeExitResponse(Handler h, int what, Object obj){
}
/**
* Unregisters for exit emergency call back mode request response
*
* @param h Handler to be removed from the registrant list.
*/
public void unsetOnEcbModeExitResponse(Handler h){
}
/**
* Register for radio off or not available
*
* @param h Handler that receives the notification message.
* @param what User-defined message code.
* @param obj User object.
*/
public void registerForRadioOffOrNotAvailable(Handler h, int what, Object obj) {
mRadioOffOrNotAvailableRegistrants.addUnique(h, what, obj);
}
/**
* Unregisters for radio off or not available
*
* @param h Handler to be removed from the registrant list.
*/
public void unregisterForRadioOffOrNotAvailable(Handler h) {
mRadioOffOrNotAvailableRegistrants.remove(h);
}
/**
* Returns an array of string identifiers for the APN types serviced by the
* currently active.
* @return The string array will always return at least one entry, Phone.APN_TYPE_DEFAULT.
* TODO: Revisit if we always should return at least one entry.
*/
public String[] getActiveApnTypes() {
if (mDcTracker == null) {
return null;
}
return mDcTracker.getActiveApnTypes();
}
/**
* Check if TETHER_DUN_APN setting or config_tether_apndata includes APN that matches
* current operator.
* @return true if there is a matching DUN APN.
*/
public boolean hasMatchedTetherApnSetting() {
return mDcTracker.hasMatchedTetherApnSetting();
}
/**
* Returns string for the active APN host.
* @return type as a string or null if none.
*/
public String getActiveApnHost(String apnType) {
return mDcTracker.getActiveApnString(apnType);
}
/**
* Return the LinkProperties for the named apn or null if not available
*/
public LinkProperties getLinkProperties(String apnType) {
return mDcTracker.getLinkProperties(apnType);
}
/**
* Return the NetworkCapabilities
*/
public NetworkCapabilities getNetworkCapabilities(String apnType) {
return mDcTracker.getNetworkCapabilities(apnType);
}
/**
* Report on whether data connectivity is allowed.
*
* @return True if data is allowed to be established.
*/
public boolean isDataAllowed() {
return ((mDcTracker != null) && (mDcTracker.isDataAllowed(null)));
}
/**
* Report on whether data connectivity is allowed.
*
* @param reasons The reasons that data can/can't be established. This is an output param.
* @return True if data is allowed to be established
*/
public boolean isDataAllowed(DataConnectionReasons reasons) {
return ((mDcTracker != null) && (mDcTracker.isDataAllowed(reasons)));
}
/**
* Action set from carrier signalling broadcast receivers to enable/disable metered apns.
*/
public void carrierActionSetMeteredApnsEnabled(boolean enabled) {
mCarrierActionAgent.carrierActionSetMeteredApnsEnabled(enabled);
}
/**
* Action set from carrier signalling broadcast receivers to enable/disable radio
*/
public void carrierActionSetRadioEnabled(boolean enabled) {
mCarrierActionAgent.carrierActionSetRadioEnabled(enabled);
}
/**
* Action set from carrier app to start/stop reporting default network condition.
*/
public void carrierActionReportDefaultNetworkStatus(boolean report) {
mCarrierActionAgent.carrierActionReportDefaultNetworkStatus(report);
}
/**
* Notify registrants of a new ringing Connection.
* Subclasses of Phone probably want to replace this with a
* version scoped to their packages
*/
public void notifyNewRingingConnectionP(Connection cn) {
if (!mIsVoiceCapable)
return;
AsyncResult ar = new AsyncResult(null, cn, null);
mNewRingingConnectionRegistrants.notifyRegistrants(ar);
}
/**
* Notify registrants of a new unknown connection.
*/
public void notifyUnknownConnectionP(Connection cn) {
mUnknownConnectionRegistrants.notifyResult(cn);
}
/**
* Notify registrants if phone is video capable.
*/
public void notifyForVideoCapabilityChanged(boolean isVideoCallCapable) {
// Cache the current video capability so that we don't lose the information.
mIsVideoCapable = isVideoCallCapable;
AsyncResult ar = new AsyncResult(null, isVideoCallCapable, null);
mVideoCapabilityChangedRegistrants.notifyRegistrants(ar);
}
/**
* Notify registrants of a RING event.
*/
private void notifyIncomingRing() {
if (!mIsVoiceCapable)
return;
AsyncResult ar = new AsyncResult(null, this, null);
mIncomingRingRegistrants.notifyRegistrants(ar);
}
/**
* Send the incoming call Ring notification if conditions are right.
*/
private void sendIncomingCallRingNotification(int token) {
if (mIsVoiceCapable && !mDoesRilSendMultipleCallRing &&
(token == mCallRingContinueToken)) {
Rlog.d(LOG_TAG, "Sending notifyIncomingRing");
notifyIncomingRing();
sendMessageDelayed(
obtainMessage(EVENT_CALL_RING_CONTINUE, token, 0), mCallRingDelay);
} else {
Rlog.d(LOG_TAG, "Ignoring ring notification request,"
+ " mDoesRilSendMultipleCallRing=" + mDoesRilSendMultipleCallRing
+ " token=" + token
+ " mCallRingContinueToken=" + mCallRingContinueToken
+ " mIsVoiceCapable=" + mIsVoiceCapable);
}
}
/**
* TODO: Adding a function for each property is not good.
* A fucntion of type getPhoneProp(propType) where propType is an
* enum of GSM+CDMA+LTE props would be a better approach.
*
* Get "Restriction of menu options for manual PLMN selection" bit
* status from EF_CSP data, this belongs to "Value Added Services Group".
* @return true if this bit is set or EF_CSP data is unavailable,
* false otherwise
*/
public boolean isCspPlmnEnabled() {
return false;
}
/**
* Return an interface to retrieve the ISIM records for IMS, if available.
* @return the interface to retrieve the ISIM records, or null if not supported
*/
public IsimRecords getIsimRecords() {
Rlog.e(LOG_TAG, "getIsimRecords() is only supported on LTE devices");
return null;
}
/**
* Retrieves the MSISDN from the UICC. For GSM/UMTS phones, this is equivalent to
* {@link #getLine1Number()}. For CDMA phones, {@link #getLine1Number()} returns
* the MDN, so this method is provided to return the MSISDN on CDMA/LTE phones.
*/
public String getMsisdn() {
return null;
}
/**
* Retrieves the EF_PNN from the UICC For GSM/UMTS phones.
*/
public String getPlmn() {
return null;
}
/**
* Get the current for the default apn DataState. No change notification
* exists at this interface -- use
* {@link android.telephony.PhoneStateListener} instead.
*/
public PhoneConstants.DataState getDataConnectionState() {
return getDataConnectionState(PhoneConstants.APN_TYPE_DEFAULT);
}
public void notifyCallForwardingIndicator() {
}
public void notifyDataConnectionFailed(String reason, String apnType) {
mNotifier.notifyDataConnectionFailed(this, reason, apnType);
}
public void notifyPreciseDataConnectionFailed(String reason, String apnType, String apn,
String failCause) {
mNotifier.notifyPreciseDataConnectionFailed(this, reason, apnType, apn, failCause);
}
/**
* Return if the current radio is LTE on CDMA. This
* is a tri-state return value as for a period of time
* the mode may be unknown.
*
* @return {@link PhoneConstants#LTE_ON_CDMA_UNKNOWN}, {@link PhoneConstants#LTE_ON_CDMA_FALSE}
* or {@link PhoneConstants#LTE_ON_CDMA_TRUE}
*/
public int getLteOnCdmaMode() {
return mCi.getLteOnCdmaMode();
}
/**
* Sets the SIM voice message waiting indicator records.
* @param line GSM Subscriber Profile Number, one-based. Only '1' is supported
* @param countWaiting The number of messages waiting, if known. Use
* -1 to indicate that an unknown number of
* messages are waiting
*/
public void setVoiceMessageWaiting(int line, int countWaiting) {
// This function should be overridden by class GsmCdmaPhone.
Rlog.e(LOG_TAG, "Error! This function should never be executed, inactive Phone.");
}
/**
* Gets the USIM service table from the UICC, if present and available.
* @return an interface to the UsimServiceTable record, or null if not available
*/
public UsimServiceTable getUsimServiceTable() {
IccRecords r = mIccRecords.get();
return (r != null) ? r.getUsimServiceTable() : null;
}
/**
* Gets the Uicc card corresponding to this phone.
* @return the UiccCard object corresponding to the phone ID.
*/
public UiccCard getUiccCard() {
return mUiccController.getUiccCard(mPhoneId);
}
/**
* Get P-CSCF address from PCO after data connection is established or modified.
* @param apnType the apnType, "ims" for IMS APN, "emergency" for EMERGENCY APN
*/
public String[] getPcscfAddress(String apnType) {
return mDcTracker.getPcscfAddress(apnType);
}
/**
* Set IMS registration state
*/
public void setImsRegistrationState(boolean registered) {
}
/**
* Return an instance of a IMS phone
*/
public Phone getImsPhone() {
return mImsPhone;
}
/**
* Returns Carrier specific information that will be used to encrypt the IMSI and IMPI.
* @param keyType whether the key is being used for WLAN or ePDG.
* @return ImsiEncryptionInfo which includes the Key Type, the Public Key
* {@link java.security.PublicKey} and the Key Identifier.
* The keyIdentifier This is used by the server to help it locate the private key to
* decrypt the permanent identity.
*/
public ImsiEncryptionInfo getCarrierInfoForImsiEncryption(int keyType) {
return null;
}
/**
* Sets the carrier information needed to encrypt the IMSI and IMPI.
* @param imsiEncryptionInfo Carrier specific information that will be used to encrypt the
* IMSI and IMPI. This includes the Key type, the Public key
* {@link java.security.PublicKey} and the Key identifier.
*/
public void setCarrierInfoForImsiEncryption(ImsiEncryptionInfo imsiEncryptionInfo) {
return;
}
public int getCarrierId() {
return TelephonyManager.UNKNOWN_CARRIER_ID;
}
public String getCarrierName() {
return null;
}
public int getCarrierIdListVersion() {
return TelephonyManager.UNKNOWN_CARRIER_ID_LIST_VERSION;
}
/**
* Resets the Carrier Keys in the database. This involves 2 steps:
* 1. Delete the keys from the database.
* 2. Send an intent to download new Certificates.
*/
public void resetCarrierKeysForImsiEncryption() {
return;
}
/**
* Return if UT capability of ImsPhone is enabled or not
*/
public boolean isUtEnabled() {
if (mImsPhone != null) {
return mImsPhone.isUtEnabled();
}
return false;
}
public void dispose() {
}
private void updateImsPhone() {
Rlog.d(LOG_TAG, "updateImsPhone"
+ " mImsServiceReady=" + mImsServiceReady);
if (mImsServiceReady && (mImsPhone == null)) {
mImsPhone = PhoneFactory.makeImsPhone(mNotifier, this);
CallManager.getInstance().registerPhone(mImsPhone);
mImsPhone.registerForSilentRedial(
this, EVENT_INITIATE_SILENT_REDIAL, null);
} else if (!mImsServiceReady && (mImsPhone != null)) {
CallManager.getInstance().unregisterPhone(mImsPhone);
mImsPhone.unregisterForSilentRedial(this);
mImsPhone.dispose();
// Potential GC issue if someone keeps a reference to ImsPhone.
// However: this change will make sure that such a reference does
// not access functions through NULL pointer.
//mImsPhone.removeReferences();
mImsPhone = null;
}
}
/**
* Dials a number.
*
* @param dialString The number to dial.
* @param dialArgs Parameters to dial with.
* @return The Connection.
* @throws CallStateException
*/
protected Connection dialInternal(String dialString, DialArgs dialArgs)
throws CallStateException {
// dialInternal shall be overriden by GsmCdmaPhone
return null;
}
/*
* Returns the subscription id.
*/
public int getSubId() {
return SubscriptionController.getInstance().getSubIdUsingPhoneId(mPhoneId);
}
/**
* Returns the phone id.
*/
public int getPhoneId() {
return mPhoneId;
}
/**
* Return the service state of mImsPhone if it is STATE_IN_SERVICE
* otherwise return the current voice service state
*/
public int getVoicePhoneServiceState() {
Phone imsPhone = mImsPhone;
if (imsPhone != null
&& imsPhone.getServiceState().getState() == ServiceState.STATE_IN_SERVICE) {
return ServiceState.STATE_IN_SERVICE;
}
return getServiceState().getState();
}
/**
* Override the service provider name and the operator name for the current ICCID.
*/
public boolean setOperatorBrandOverride(String brand) {
return false;
}
/**
* Override the roaming indicator for the current ICCID.
*/
public boolean setRoamingOverride(ListMessage.obj will contain an AsyncResult.
*
* obj.result will be an "MmiCode" object.
*/
public void registerForMmiInitiate(Handler h, int what, Object obj) {
checkCorrectThread(h);
mMmiRegistrants.addUnique(h, what, obj);
}
/**
* Unregisters for new MMI initiate notification.
* Extraneous calls are tolerated silently
*/
public void unregisterForMmiInitiate(Handler h) {
mMmiRegistrants.remove(h);
}
/**
* Register for notifications that an MMI request has completed
* its network activity and is in its final state. This may mean a state
* of COMPLETE, FAILED, or CANCELLED.
*
* Message.obj will contain an AsyncResult.
* obj.result will be an "MmiCode" object
*/
public void registerForMmiComplete(Handler h, int what, Object obj) {
checkCorrectThread(h);
mMmiCompleteRegistrants.addUnique(h, what, obj);
}
/**
* Unregisters for MMI complete notification.
* Extraneous calls are tolerated silently
*/
public void unregisterForMmiComplete(Handler h) {
checkCorrectThread(h);
mMmiCompleteRegistrants.remove(h);
}
/**
* Registration point for Sim records loaded
* @param h handler to notify
* @param what what code of message when delivered
* @param obj placed in Message.obj
*/
public void registerForSimRecordsLoaded(Handler h, int what, Object obj) {
}
/**
* Unregister for notifications for Sim records loaded
* @param h Handler to be removed from the registrant list.
*/
public void unregisterForSimRecordsLoaded(Handler h) {
}
/**
* Register for TTY mode change notifications from the network.
* Message.obj will contain an AsyncResult.
* AsyncResult.result will be an Integer containing new mode.
*
* @param h Handler that receives the notification message.
* @param what User-defined message code.
* @param obj User object.
*/
public void registerForTtyModeReceived(Handler h, int what, Object obj) {
}
/**
* Unregisters for TTY mode change notifications.
* Extraneous calls are tolerated silently
*
* @param h Handler to be removed from the registrant list.
*/
public void unregisterForTtyModeReceived(Handler h) {
}
/**
* Switches network selection mode to "automatic", re-scanning and
* re-selecting a network if appropriate.
*
* @param response The message to dispatch when the network selection
* is complete.
*
* @see #selectNetworkManually(OperatorInfo, boolean, android.os.Message)
*/
public void setNetworkSelectionModeAutomatic(Message response) {
Rlog.d(LOG_TAG, "setNetworkSelectionModeAutomatic, querying current mode");
// we don't want to do this unecesarily - it acutally causes
// the radio to repeate network selection and is costly
// first check if we're already in automatic mode
Message msg = obtainMessage(EVENT_CHECK_FOR_NETWORK_AUTOMATIC);
msg.obj = response;
mCi.getNetworkSelectionMode(msg);
}
private void onCheckForNetworkSelectionModeAutomatic(Message fromRil) {
AsyncResult ar = (AsyncResult)fromRil.obj;
Message response = (Message)ar.userObj;
boolean doAutomatic = true;
if (ar.exception == null && ar.result != null) {
try {
int[] modes = (int[])ar.result;
if (modes[0] == 0) {
// already confirmed to be in automatic mode - don't resend
doAutomatic = false;
}
} catch (Exception e) {
// send the setting on error
}
}
// wrap the response message in our own message along with
// an empty string (to indicate automatic selection) for the
// operator's id.
NetworkSelectMessage nsm = new NetworkSelectMessage();
nsm.message = response;
nsm.operatorNumeric = "";
nsm.operatorAlphaLong = "";
nsm.operatorAlphaShort = "";
if (doAutomatic) {
Message msg = obtainMessage(EVENT_SET_NETWORK_AUTOMATIC_COMPLETE, nsm);
mCi.setNetworkSelectionModeAutomatic(msg);
} else {
Rlog.d(LOG_TAG, "setNetworkSelectionModeAutomatic - already auto, ignoring");
// let the calling application know that the we are ignoring automatic mode switch.
if (nsm.message != null) {
nsm.message.arg1 = ALREADY_IN_AUTO_SELECTION;
}
ar.userObj = nsm;
handleSetSelectNetwork(ar);
}
updateSavedNetworkOperator(nsm);
}
/**
* Query the radio for the current network selection mode.
*
* Return values:
* 0 - automatic.
* 1 - manual.
*/
public void getNetworkSelectionMode(Message message) {
mCi.getNetworkSelectionMode(message);
}
public Listresponse is
* dispatched when this is complete. response.obj will be
* an AsyncResult, and response.obj.exception will be non-null
* on failure.
*
* @see #setNetworkSelectionModeAutomatic(Message)
*/
public void selectNetworkManually(OperatorInfo network, boolean persistSelection,
Message response) {
// wrap the response message in our own message along with
// the operator's id.
NetworkSelectMessage nsm = new NetworkSelectMessage();
nsm.message = response;
nsm.operatorNumeric = network.getOperatorNumeric();
nsm.operatorAlphaLong = network.getOperatorAlphaLong();
nsm.operatorAlphaShort = network.getOperatorAlphaShort();
Message msg = obtainMessage(EVENT_SET_NETWORK_MANUAL_COMPLETE, nsm);
mCi.setNetworkSelectionModeManual(network.getOperatorNumeric(), msg);
if (persistSelection) {
updateSavedNetworkOperator(nsm);
} else {
clearSavedNetworkSelection();
}
}
/**
* Registration point for emergency call/callback mode start. Message.obj is AsyncResult and
* Message.obj.result will be Integer indicating start of call by value 1 or end of call by
* value 0
* @param h handler to notify
* @param what what code of message when delivered
* @param obj placed in Message.obj.userObj
*/
public void registerForEmergencyCallToggle(Handler h, int what, Object obj) {
Registrant r = new Registrant(h, what, obj);
mEmergencyCallToggledRegistrants.add(r);
}
public void unregisterForEmergencyCallToggle(Handler h) {
mEmergencyCallToggledRegistrants.remove(h);
}
private void updateSavedNetworkOperator(NetworkSelectMessage nsm) {
int subId = getSubId();
if (SubscriptionManager.isValidSubscriptionId(subId)) {
// open the shared preferences editor, and write the value.
// nsm.operatorNumeric is "" if we're in automatic.selection.
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getContext());
SharedPreferences.Editor editor = sp.edit();
editor.putString(NETWORK_SELECTION_KEY + subId, nsm.operatorNumeric);
editor.putString(NETWORK_SELECTION_NAME_KEY + subId, nsm.operatorAlphaLong);
editor.putString(NETWORK_SELECTION_SHORT_KEY + subId, nsm.operatorAlphaShort);
// commit and log the result.
if (!editor.commit()) {
Rlog.e(LOG_TAG, "failed to commit network selection preference");
}
} else {
Rlog.e(LOG_TAG, "Cannot update network selection preference due to invalid subId " +
subId);
}
}
/**
* Used to track the settings upon completion of the network change.
*/
private void handleSetSelectNetwork(AsyncResult ar) {
// look for our wrapper within the asyncresult, skip the rest if it
// is null.
if (!(ar.userObj instanceof NetworkSelectMessage)) {
Rlog.e(LOG_TAG, "unexpected result from user object.");
return;
}
NetworkSelectMessage nsm = (NetworkSelectMessage) ar.userObj;
// found the object, now we send off the message we had originally
// attached to the request.
if (nsm.message != null) {
AsyncResult.forMessage(nsm.message, ar.result, ar.exception);
nsm.message.sendToTarget();
}
}
/**
* Method to retrieve the saved operator from the Shared Preferences
*/
private OperatorInfo getSavedNetworkSelection() {
// open the shared preferences and search with our key.
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getContext());
String numeric = sp.getString(NETWORK_SELECTION_KEY + getSubId(), "");
String name = sp.getString(NETWORK_SELECTION_NAME_KEY + getSubId(), "");
String shrt = sp.getString(NETWORK_SELECTION_SHORT_KEY + getSubId(), "");
return new OperatorInfo(name, shrt, numeric);
}
/**
* Clears the saved network selection.
*/
private void clearSavedNetworkSelection() {
// open the shared preferences and search with our key.
PreferenceManager.getDefaultSharedPreferences(getContext()).edit().
remove(NETWORK_SELECTION_KEY + getSubId()).
remove(NETWORK_SELECTION_NAME_KEY + getSubId()).
remove(NETWORK_SELECTION_SHORT_KEY + getSubId()).commit();
}
/**
* Method to restore the previously saved operator id, or reset to
* automatic selection, all depending upon the value in the shared
* preferences.
*/
private void restoreSavedNetworkSelection(Message response) {
// retrieve the operator
OperatorInfo networkSelection = getSavedNetworkSelection();
// set to auto if the id is empty, otherwise select the network.
if (networkSelection == null || TextUtils.isEmpty(networkSelection.getOperatorNumeric())) {
setNetworkSelectionModeAutomatic(response);
} else {
selectNetworkManually(networkSelection, true, response);
}
}
/**
* Saves CLIR setting so that we can re-apply it as necessary
* (in case the RIL resets it across reboots).
*/
public void saveClirSetting(int commandInterfaceCLIRMode) {
// Open the shared preferences editor, and write the value.
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getContext());
SharedPreferences.Editor editor = sp.edit();
editor.putInt(CLIR_KEY + getPhoneId(), commandInterfaceCLIRMode);
Rlog.i(LOG_TAG, "saveClirSetting: " + CLIR_KEY + getPhoneId() + "=" +
commandInterfaceCLIRMode);
// Commit and log the result.
if (!editor.commit()) {
Rlog.e(LOG_TAG, "Failed to commit CLIR preference");
}
}
/**
* For unit tests; don't send notifications to "Phone"
* mailbox registrants if true.
*/
private void setUnitTestMode(boolean f) {
mUnitTestMode = f;
}
/**
* @return true If unit test mode is enabled
*/
public boolean getUnitTestMode() {
return mUnitTestMode;
}
/**
* To be invoked when a voice call Connection disconnects.
*
* Subclasses of Phone probably want to replace this with a
* version scoped to their packages
*/
protected void notifyDisconnectP(Connection cn) {
AsyncResult ar = new AsyncResult(null, cn, null);
mDisconnectRegistrants.notifyRegistrants(ar);
}
/**
* Register for ServiceState changed.
* Message.obj will contain an AsyncResult.
* AsyncResult.result will be a ServiceState instance
*/
public void registerForServiceStateChanged(
Handler h, int what, Object obj) {
mServiceStateRegistrants.add(h, what, obj);
}
/**
* Unregisters for ServiceStateChange notification.
* Extraneous calls are tolerated silently
*/
public void unregisterForServiceStateChanged(Handler h) {
mServiceStateRegistrants.remove(h);
}
/**
* Notifies when out-band ringback tone is needed.getSimCard().registerForReady() for change notification.
*
* @return true if records from the SIM have been loaded and are
* available (if applicable). If not applicable to the underlying
* technology, returns true as well.
*/
public boolean getIccRecordsLoaded() {
IccRecords r = mIccRecords.get();
return (r != null) ? r.getRecordsLoaded() : false;
}
/**
* @param workSource calling WorkSource
* @return all available cell information or null if none.
*/
public ListPhoneStateNotifier or an equivalent.
* An ASU is 0-31 or -1 if unknown (for GSM, dBm = -113 - 2 * asu).
* The following special values are defined:
*
* @return Current signal strength as SignalStrength
*/
public SignalStrength getSignalStrength() {
ServiceStateTracker sst = getServiceStateTracker();
if (sst == null) {
return new SignalStrength();
} else {
return sst.getSignalStrength();
}
}
/**
* @return true, if the device is in a state where both voice and data
* are supported simultaneously. This can change based on location or network condition.
*/
public boolean isConcurrentVoiceAndDataAllowed() {
ServiceStateTracker sst = getServiceStateTracker();
return sst == null ? false : sst.isConcurrentVoiceAndDataAllowed();
}
/**
* Requests to set the CDMA roaming preference
* @param cdmaRoamingType one of CDMA_RM_*
* @param response is callback message
*/
public void setCdmaRoamingPreference(int cdmaRoamingType, Message response) {
mCi.setCdmaRoamingPreference(cdmaRoamingType, response);
}
/**
* Requests to set the CDMA subscription mode
* @param cdmaSubscriptionType one of CDMA_SUBSCRIPTION_*
* @param response is callback message
*/
public void setCdmaSubscription(int cdmaSubscriptionType, Message response) {
mCi.setCdmaSubscriptionSource(cdmaSubscriptionType, response);
}
/**
* Requests to set the preferred network type for searching and registering
* (CS/PS domain, RAT, and operation mode)
* @param networkType one of NT_*_TYPE
* @param response is callback message
*/
public void setPreferredNetworkType(int networkType, Message response) {
// Only set preferred network types to that which the modem supports
int modemRaf = getRadioAccessFamily();
int rafFromType = RadioAccessFamily.getRafFromNetworkType(networkType);
if (modemRaf == RadioAccessFamily.RAF_UNKNOWN
|| rafFromType == RadioAccessFamily.RAF_UNKNOWN) {
Rlog.d(LOG_TAG, "setPreferredNetworkType: Abort, unknown RAF: "
+ modemRaf + " " + rafFromType);
if (response != null) {
CommandException ex;
ex = new CommandException(CommandException.Error.GENERIC_FAILURE);
AsyncResult.forMessage(response, null, ex);
response.sendToTarget();
}
return;
}
int filteredRaf = (rafFromType & modemRaf);
int filteredType = RadioAccessFamily.getNetworkTypeFromRaf(filteredRaf);
Rlog.d(LOG_TAG, "setPreferredNetworkType: networkType = " + networkType
+ " modemRaf = " + modemRaf
+ " rafFromType = " + rafFromType
+ " filteredType = " + filteredType);
mCi.setPreferredNetworkType(filteredType, response);
}
/**
* Query the preferred network type setting
*
* @param response is callback message to report one of NT_*_TYPE
*/
public void getPreferredNetworkType(Message response) {
mCi.getPreferredNetworkType(response);
}
/**
* Gets the default SMSC address.
*
* @param result Callback message contains the SMSC address.
*/
public void getSmscAddress(Message result) {
mCi.getSmscAddress(result);
}
/**
* Sets the default SMSC address.
*
* @param address new SMSC address
* @param result Callback message is empty on completion
*/
public void setSmscAddress(String address, Message result) {
mCi.setSmscAddress(address, result);
}
/**
* setTTYMode
* sets a TTY mode option.
* @param ttyMode is a one of the following:
* - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF}
* - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL}
* - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO}
* - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO}
* @param onComplete a callback message when the action is completed
*/
public void setTTYMode(int ttyMode, Message onComplete) {
mCi.setTTYMode(ttyMode, onComplete);
}
/**
* setUiTTYMode
* sets a TTY mode option.
* @param ttyMode is a one of the following:
* - {@link com.android.internal.telephony.Phone#TTY_MODE_OFF}
* - {@link com.android.internal.telephony.Phone#TTY_MODE_FULL}
* - {@link com.android.internal.telephony.Phone#TTY_MODE_HCO}
* - {@link com.android.internal.telephony.Phone#TTY_MODE_VCO}
* @param onComplete a callback message when the action is completed
*/
public void setUiTTYMode(int uiTtyMode, Message onComplete) {
Rlog.d(LOG_TAG, "unexpected setUiTTYMode method call");
}
/**
* queryTTYMode
* query the status of the TTY mode
*
* @param onComplete a callback message when the action is completed.
*/
public void queryTTYMode(Message onComplete) {
mCi.queryTTYMode(onComplete);
}
/**
* Enable or disable enhanced Voice Privacy (VP). If enhanced VP is
* disabled, normal VP is enabled.
*
* @param enable whether true or false to enable or disable.
* @param onComplete a callback message when the action is completed.
*/
public void enableEnhancedVoicePrivacy(boolean enable, Message onComplete) {
}
/**
* Get the currently set Voice Privacy (VP) mode.
*
* @param onComplete a callback message when the action is completed.
*/
public void getEnhancedVoicePrivacy(Message onComplete) {
}
/**
* Assign a specified band for RF configuration.
*
* @param bandMode one of BM_*_BAND
* @param response is callback message
*/
public void setBandMode(int bandMode, Message response) {
mCi.setBandMode(bandMode, response);
}
/**
* Query the list of band mode supported by RF.
*
* @param response is callback message
* ((AsyncResult)response.obj).result is an int[] where int[0] is
* the size of the array and the rest of each element representing
* one available BM_*_BAND
*/
public void queryAvailableBandMode(Message response) {
mCi.queryAvailableBandMode(response);
}
/**
* Invokes RIL_REQUEST_OEM_HOOK_RAW on RIL implementation.
*
* @param data The data for the request.
* @param response On success,
* (byte[])(((AsyncResult)response.obj).result)
* On failure,
* (((AsyncResult)response.obj).result) == null and
* (((AsyncResult)response.obj).exception) being an instance of
* com.android.internal.telephony.gsm.CommandException
*
* @see #invokeOemRilRequestRaw(byte[], android.os.Message)
* @deprecated OEM needs a vendor-extension hal and their apps should use that instead
*/
@Deprecated
public void invokeOemRilRequestRaw(byte[] data, Message response) {
mCi.invokeOemRilRequestRaw(data, response);
}
/**
* Invokes RIL_REQUEST_OEM_HOOK_Strings on RIL implementation.
*
* @param strings The strings to make available as the request data.
* @param response On success, "response" bytes is
* made available as:
* (String[])(((AsyncResult)response.obj).result).
* On failure,
* (((AsyncResult)response.obj).result) == null and
* (((AsyncResult)response.obj).exception) being an instance of
* com.android.internal.telephony.gsm.CommandException
*
* @see #invokeOemRilRequestStrings(java.lang.String[], android.os.Message)
* @deprecated OEM needs a vendor-extension hal and their apps should use that instead
*/
@Deprecated
public void invokeOemRilRequestStrings(String[] strings, Message response) {
mCi.invokeOemRilRequestStrings(strings, response);
}
/**
* Read one of the NV items defined in {@link RadioNVItems} / {@code ril_nv_items.h}.
* Used for device configuration by some CDMA operators.
*
* @param itemID the ID of the item to read
* @param response callback message with the String response in the obj field
*/
public void nvReadItem(int itemID, Message response) {
mCi.nvReadItem(itemID, response);
}
/**
* Write one of the NV items defined in {@link RadioNVItems} / {@code ril_nv_items.h}.
* Used for device configuration by some CDMA operators.
*
* @param itemID the ID of the item to read
* @param itemValue the value to write, as a String
* @param response Callback message.
*/
public void nvWriteItem(int itemID, String itemValue, Message response) {
mCi.nvWriteItem(itemID, itemValue, response);
}
/**
* Update the CDMA Preferred Roaming List (PRL) in the radio NV storage.
* Used for device configuration by some CDMA operators.
*
* @param preferredRoamingList byte array containing the new PRL
* @param response Callback message.
*/
public void nvWriteCdmaPrl(byte[] preferredRoamingList, Message response) {
mCi.nvWriteCdmaPrl(preferredRoamingList, response);
}
/**
* Perform the specified type of NV config reset. The radio will be taken offline
* and the device must be rebooted after erasing the NV. Used for device
* configuration by some CDMA operators.
*
* @param resetType reset type: 1: reload NV reset, 2: erase NV reset, 3: factory NV reset
* @param response Callback message.
*/
public void nvResetConfig(int resetType, Message response) {
mCi.nvResetConfig(resetType, response);
}
public void notifyDataActivity() {
mNotifier.notifyDataActivity(this);
}
private void notifyMessageWaitingIndicator() {
// Do not notify voice mail waiting if device doesn't support voice
if (!mIsVoiceCapable)
return;
// This function is added to send the notification to DefaultPhoneNotifier.
mNotifier.notifyMessageWaitingChanged(this);
}
public void notifyDataConnection(String reason, String apnType,
PhoneConstants.DataState state) {
mNotifier.notifyDataConnection(this, reason, apnType, state);
}
public void notifyDataConnection(String reason, String apnType) {
mNotifier.notifyDataConnection(this, reason, apnType, getDataConnectionState(apnType));
}
public void notifyDataConnection(String reason) {
String types[] = getActiveApnTypes();
for (String apnType : types) {
mNotifier.notifyDataConnection(this, reason, apnType, getDataConnectionState(apnType));
}
}
public void notifyOtaspChanged(int otaspMode) {
mNotifier.notifyOtaspChanged(this, otaspMode);
}
public void notifyVoiceActivationStateChanged(int state) {
mNotifier.notifyVoiceActivationStateChanged(this, state);
}
public void notifyDataActivationStateChanged(int state) {
mNotifier.notifyDataActivationStateChanged(this, state);
}
public void notifyUserMobileDataStateChanged(boolean state) {
mNotifier.notifyUserMobileDataStateChanged(this, state);
}
public void notifySignalStrength() {
mNotifier.notifySignalStrength(this);
}
public void notifyCellInfo(List URI.
*
* @param code stripped version of secret code without *#*# prefix and #*#* suffix
*/
public void sendDialerSpecialCode(String code) {
if (!TextUtils.isEmpty(code)) {
Intent intent = new Intent(TelephonyIntents.SECRET_CODE_ACTION,
Uri.parse("android_secret_code://" + code));
intent.addFlags(Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND);
mContext.sendBroadcast(intent);
}
}
/**
* Returns the CDMA ERI icon index to display
*/
public int getCdmaEriIconIndex() {
return -1;
}
/**
* Returns the CDMA ERI icon mode,
* 0 - ON
* 1 - FLASHING
*/
public int getCdmaEriIconMode() {
return -1;
}
/**
* Returns the CDMA ERI text,
*/
public String getCdmaEriText() {
return "GSM nw, no ERI";
}
/**
* Retrieves the MIN for CDMA phones.
*/
public String getCdmaMin() {
return null;
}
/**
* Check if subscription data has been assigned to mMin
*
* return true if MIN info is ready; false otherwise.
*/
public boolean isMinInfoReady() {
return false;
}
/**
* Retrieves PRL Version for CDMA phones
*/
public String getCdmaPrlVersion(){
return null;
}
/**
* send burst DTMF tone, it can send the string as single character or multiple character
* ignore if there is no active call or not valid digits string.
* Valid digit means only includes characters ISO-LATIN characters 0-9, *, #
* The difference between sendDtmf and sendBurstDtmf is sendDtmf only sends one character,
* this api can send single character and multiple character, also, this api has response
* back to caller.
*
* @param dtmfString is string representing the dialing digit(s) in the active call
* @param on the DTMF ON length in milliseconds, or 0 for default
* @param off the DTMF OFF length in milliseconds, or 0 for default
* @param onComplete is the callback message when the action is processed by BP
*
*/
public void sendBurstDtmf(String dtmfString, int on, int off, Message onComplete) {
}
/**
* Sets an event to be fired when the telephony system processes
* a post-dial character on an outgoing call.what will be sent to h.
* The obj field of these Message's will be instances of
* AsyncResult. Message.obj.result will be
* a Connection object.