| /* |
| * Copyright (C) 2007 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.internal.telephony; |
| |
| import android.app.ActivityManagerNative; |
| import android.app.IActivityManager; |
| import android.content.Context; |
| import android.content.res.Configuration; |
| import android.content.SharedPreferences; |
| import android.net.wifi.WifiManager; |
| import android.os.AsyncResult; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.RegistrantList; |
| import android.os.SystemProperties; |
| import android.preference.PreferenceManager; |
| import android.provider.Settings; |
| import android.telephony.ServiceState; |
| import android.text.TextUtils; |
| import android.util.Log; |
| |
| import com.android.internal.R; |
| import com.android.internal.telephony.gsm.GsmDataConnection; |
| import com.android.internal.telephony.test.SimulatedRadioControl; |
| |
| import java.util.List; |
| import java.util.Locale; |
| |
| |
| /** |
| * (<em>Not for SDK use</em>) |
| * A base implementation for the com.android.internal.telephony.Phone interface. |
| * |
| * Note that implementations of Phone.java are expected to be used |
| * from a single application thread. This should be the same thread that |
| * originally called PhoneFactory to obtain the interface. |
| * |
| * {@hide} |
| * |
| */ |
| |
| public abstract class PhoneBase extends Handler implements Phone { |
| private static final String LOG_TAG = "PHONE"; |
| private static final boolean LOCAL_DEBUG = true; |
| |
| // Key used to read and write the saved network selection numeric value |
| public static final String NETWORK_SELECTION_KEY = "network_selection_key"; |
| // Key used to read and write the saved network selection operator name |
| public static final String NETWORK_SELECTION_NAME_KEY = "network_selection_name_key"; |
| |
| |
| // Key used to read/write "disable data connection on boot" pref (used for testing) |
| public static final String DATA_DISABLED_ON_BOOT_KEY = "disabled_on_boot_key"; |
| |
| /* Event Constants */ |
| protected static final int EVENT_RADIO_AVAILABLE = 1; |
| /** Supplementary Service Notification received. */ |
| protected static final int EVENT_SSN = 2; |
| protected static final int EVENT_SIM_RECORDS_LOADED = 3; |
| protected static final int EVENT_MMI_DONE = 4; |
| protected static final int EVENT_RADIO_ON = 5; |
| protected static final int EVENT_GET_BASEBAND_VERSION_DONE = 6; |
| protected static final int EVENT_USSD = 7; |
| protected static final int EVENT_RADIO_OFF_OR_NOT_AVAILABLE = 8; |
| protected static final int EVENT_GET_IMEI_DONE = 9; |
| protected static final int EVENT_GET_IMEISV_DONE = 10; |
| protected static final int EVENT_GET_SIM_STATUS_DONE = 11; |
| protected static final int EVENT_SET_CALL_FORWARD_DONE = 12; |
| protected static final int EVENT_GET_CALL_FORWARD_DONE = 13; |
| protected static final int EVENT_CALL_RING = 14; |
| protected static final int EVENT_CALL_RING_CONTINUE = 15; |
| |
| // Used to intercept the carrier selection calls so that |
| // we can save the values. |
| protected static final int EVENT_SET_NETWORK_MANUAL_COMPLETE = 16; |
| protected static final int EVENT_SET_NETWORK_AUTOMATIC_COMPLETE = 17; |
| protected static final int EVENT_SET_CLIR_COMPLETE = 18; |
| protected static final int EVENT_REGISTERED_TO_NETWORK = 19; |
| protected static final int EVENT_SET_VM_NUMBER_DONE = 20; |
| // Events for CDMA support |
| protected static final int EVENT_GET_DEVICE_IDENTITY_DONE = 21; |
| protected static final int EVENT_RUIM_RECORDS_LOADED = 22; |
| protected static final int EVENT_NV_READY = 23; |
| protected static final int EVENT_SET_ENHANCED_VP = 24; |
| protected static final int EVENT_EMERGENCY_CALLBACK_MODE_ENTER = 25; |
| protected static final int EVENT_EXIT_EMERGENCY_CALLBACK_RESPONSE = 26; |
| |
| // Key used to read/write current CLIR setting |
| public static final String CLIR_KEY = "clir_key"; |
| |
| // Key used to read/write "disable DNS server check" pref (used for testing) |
| public static final String DNS_SERVER_CHECK_DISABLED_KEY = "dns_server_check_disabled_key"; |
| |
| /* Instance Variables */ |
| public CommandsInterface mCM; |
| protected IccFileHandler mIccFileHandler; |
| boolean mDnsCheckDisabled = false; |
| public DataConnectionTracker mDataConnection; |
| boolean mDoesRilSendMultipleCallRing; |
| int mCallRingContinueToken = 0; |
| int mCallRingDelay; |
| public boolean mIsTheCurrentActivePhone = true; |
| |
| /** |
| * Set a system property, unless we're in unit test mode |
| */ |
| public void |
| setSystemProperty(String property, String value) { |
| if(getUnitTestMode()) { |
| return; |
| } |
| SystemProperties.set(property, value); |
| } |
| |
| |
| protected final RegistrantList mPreciseCallStateRegistrants |
| = new RegistrantList(); |
| |
| protected final RegistrantList mNewRingingConnectionRegistrants |
| = new RegistrantList(); |
| |
| protected final RegistrantList mIncomingRingRegistrants |
| = new RegistrantList(); |
| |
| protected final RegistrantList mDisconnectRegistrants |
| = new RegistrantList(); |
| |
| protected final RegistrantList mServiceStateRegistrants |
| = new RegistrantList(); |
| |
| protected final RegistrantList mMmiCompleteRegistrants |
| = new RegistrantList(); |
| |
| protected final RegistrantList mMmiRegistrants |
| = new RegistrantList(); |
| |
| protected final RegistrantList mUnknownConnectionRegistrants |
| = new RegistrantList(); |
| |
| protected final RegistrantList mSuppServiceFailedRegistrants |
| = new RegistrantList(); |
| |
| protected Looper mLooper; /* to insure registrants are in correct thread*/ |
| |
| protected Context mContext; |
| |
| /** |
| * PhoneNotifier is an abstraction for all system-wide |
| * state change notification. DefaultPhoneNotifier is |
| * used here unless running we're inside a unit test. |
| */ |
| protected PhoneNotifier mNotifier; |
| |
| protected SimulatedRadioControl mSimulatedRadioControl; |
| |
| boolean mUnitTestMode; |
| |
| /** |
| * Constructs a PhoneBase in normal (non-unit test) mode. |
| * |
| * @param context Context object from hosting application |
| * @param notifier An instance of DefaultPhoneNotifier, |
| * unless unit testing. |
| */ |
| protected PhoneBase(PhoneNotifier notifier, Context context, CommandsInterface ci) { |
| this(notifier, context, ci, false); |
| } |
| |
| /** |
| * Constructs a PhoneBase in normal (non-unit test) mode. |
| * |
| * @param context Context object from hosting application |
| * @param notifier An instance of DefaultPhoneNotifier, |
| * unless unit testing. |
| * @param unitTestMode when true, prevents notifications |
| * of state change events |
| */ |
| protected PhoneBase(PhoneNotifier notifier, Context context, CommandsInterface ci, |
| boolean unitTestMode) { |
| this.mNotifier = notifier; |
| this.mContext = context; |
| mLooper = Looper.myLooper(); |
| mCM = ci; |
| |
| setPropertiesByCarrier(); |
| |
| setUnitTestMode(unitTestMode); |
| |
| SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context); |
| mDnsCheckDisabled = sp.getBoolean(DNS_SERVER_CHECK_DISABLED_KEY, false); |
| mCM.setOnCallRing(this, EVENT_CALL_RING, null); |
| |
| /** |
| * Some RIL's don't always send RIL_UNSOL_CALL_RING so it needs |
| * to be generated locally. Ideally all ring tones should be loops |
| * and this wouldn't be necessary. But to minimize changes to upper |
| * layers it is requested that it be generated by lower layers. |
| * |
| * By default old phones won't have the property set but do generate |
| * the RIL_UNSOL_CALL_RING so the default if there is no property is |
| * true. |
| */ |
| mDoesRilSendMultipleCallRing = SystemProperties.getBoolean( |
| TelephonyProperties.PROPERTY_RIL_SENDS_MULTIPLE_CALL_RING, true); |
| Log.d(LOG_TAG, "mDoesRilSendMultipleCallRing=" + mDoesRilSendMultipleCallRing); |
| |
| mCallRingDelay = SystemProperties.getInt( |
| TelephonyProperties.PROPERTY_CALL_RING_DELAY, 3000); |
| Log.d(LOG_TAG, "mCallRingDelay=" + mCallRingDelay); |
| } |
| |
| public void dispose() { |
| synchronized(PhoneProxy.lockForRadioTechnologyChange) { |
| mCM.unSetOnCallRing(this); |
| mDataConnection.onCleanUpConnection(false, REASON_RADIO_TURNED_OFF); |
| mIsTheCurrentActivePhone = false; |
| } |
| } |
| |
| /** |
| * When overridden the derived class needs to call |
| * super.handleMessage(msg) so this method has a |
| * a chance to process the message. |
| * |
| * @param msg |
| */ |
| @Override |
| public void handleMessage(Message msg) { |
| AsyncResult ar; |
| |
| switch(msg.what) { |
| case EVENT_CALL_RING: |
| Log.d(LOG_TAG, "Event EVENT_CALL_RING Received state=" + getState()); |
| ar = (AsyncResult)msg.obj; |
| if (ar.exception == null) { |
| Phone.State state = getState(); |
| if ((!mDoesRilSendMultipleCallRing) |
| && ((state == Phone.State.RINGING) || (state == Phone.State.IDLE))) { |
| mCallRingContinueToken += 1; |
| sendIncomingCallRingNotification(mCallRingContinueToken); |
| } else { |
| notifyIncomingRing(); |
| } |
| } |
| break; |
| |
| case EVENT_CALL_RING_CONTINUE: |
| Log.d(LOG_TAG, "Event EVENT_CALL_RING_CONTINUE Received stat=" + getState()); |
| if (getState() == Phone.State.RINGING) { |
| sendIncomingCallRingNotification(msg.arg1); |
| } |
| break; |
| |
| default: |
| throw new RuntimeException("unexpected event not handled"); |
| } |
| } |
| |
| // Inherited documentation suffices. |
| public Context getContext() { |
| return mContext; |
| } |
| |
| /** |
| * Disables the DNS check (i.e., allows "0.0.0.0"). |
| * Useful for lab testing environment. |
| * @param b true disables the check, false enables. |
| */ |
| public void disableDnsCheck(boolean b) { |
| mDnsCheckDisabled = b; |
| SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getContext()); |
| SharedPreferences.Editor editor = sp.edit(); |
| editor.putBoolean(DNS_SERVER_CHECK_DISABLED_KEY, b); |
| editor.apply(); |
| } |
| |
| /** |
| * Returns true if the DNS check is currently disabled. |
| */ |
| public boolean isDnsCheckDisabled() { |
| return mDnsCheckDisabled; |
| } |
| |
| // Inherited documentation suffices. |
| public void registerForPreciseCallStateChanged(Handler h, int what, Object obj) { |
| checkCorrectThread(h); |
| |
| mPreciseCallStateRegistrants.addUnique(h, what, obj); |
| } |
| |
| // Inherited documentation suffices. |
| 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); |
| } |
| |
| // Inherited documentation suffices. |
| public void registerForUnknownConnection(Handler h, int what, Object obj) { |
| checkCorrectThread(h); |
| |
| mUnknownConnectionRegistrants.addUnique(h, what, obj); |
| } |
| |
| // Inherited documentation suffices. |
| public void unregisterForUnknownConnection(Handler h) { |
| mUnknownConnectionRegistrants.remove(h); |
| } |
| |
| // Inherited documentation suffices. |
| public void registerForNewRingingConnection( |
| Handler h, int what, Object obj) { |
| checkCorrectThread(h); |
| |
| mNewRingingConnectionRegistrants.addUnique(h, what, obj); |
| } |
| |
| // Inherited documentation suffices. |
| public void unregisterForNewRingingConnection(Handler h) { |
| mNewRingingConnectionRegistrants.remove(h); |
| } |
| |
| // Inherited documentation suffices. |
| public void registerForInCallVoicePrivacyOn(Handler h, int what, Object obj){ |
| mCM.registerForInCallVoicePrivacyOn(h,what,obj); |
| } |
| |
| // Inherited documentation suffices. |
| public void unregisterForInCallVoicePrivacyOn(Handler h){ |
| mCM.unregisterForInCallVoicePrivacyOn(h); |
| } |
| |
| // Inherited documentation suffices. |
| public void registerForInCallVoicePrivacyOff(Handler h, int what, Object obj){ |
| mCM.registerForInCallVoicePrivacyOff(h,what,obj); |
| } |
| |
| // Inherited documentation suffices. |
| public void unregisterForInCallVoicePrivacyOff(Handler h){ |
| mCM.unregisterForInCallVoicePrivacyOff(h); |
| } |
| |
| // Inherited documentation suffices. |
| public void registerForIncomingRing( |
| Handler h, int what, Object obj) { |
| checkCorrectThread(h); |
| |
| mIncomingRingRegistrants.addUnique(h, what, obj); |
| } |
| |
| // Inherited documentation suffices. |
| public void unregisterForIncomingRing(Handler h) { |
| mIncomingRingRegistrants.remove(h); |
| } |
| |
| // Inherited documentation suffices. |
| public void registerForDisconnect(Handler h, int what, Object obj) { |
| checkCorrectThread(h); |
| |
| mDisconnectRegistrants.addUnique(h, what, obj); |
| } |
| |
| // Inherited documentation suffices. |
| public void unregisterForDisconnect(Handler h) { |
| mDisconnectRegistrants.remove(h); |
| } |
| |
| // Inherited documentation suffices. |
| public void registerForSuppServiceFailed(Handler h, int what, Object obj) { |
| checkCorrectThread(h); |
| |
| mSuppServiceFailedRegistrants.addUnique(h, what, obj); |
| } |
| |
| // Inherited documentation suffices. |
| public void unregisterForSuppServiceFailed(Handler h) { |
| mSuppServiceFailedRegistrants.remove(h); |
| } |
| |
| // Inherited documentation suffices. |
| public void registerForMmiInitiate(Handler h, int what, Object obj) { |
| checkCorrectThread(h); |
| |
| mMmiRegistrants.addUnique(h, what, obj); |
| } |
| |
| // Inherited documentation suffices. |
| public void unregisterForMmiInitiate(Handler h) { |
| mMmiRegistrants.remove(h); |
| } |
| |
| // Inherited documentation suffices. |
| public void registerForMmiComplete(Handler h, int what, Object obj) { |
| checkCorrectThread(h); |
| |
| mMmiCompleteRegistrants.addUnique(h, what, obj); |
| } |
| |
| // Inherited documentation suffices. |
| public void unregisterForMmiComplete(Handler h) { |
| checkCorrectThread(h); |
| |
| mMmiCompleteRegistrants.remove(h); |
| } |
| |
| /** |
| * Method to retrieve the saved operator id from the Shared Preferences |
| */ |
| private String getSavedNetworkSelection() { |
| // open the shared preferences and search with our key. |
| SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getContext()); |
| return sp.getString(NETWORK_SELECTION_KEY, ""); |
| } |
| |
| /** |
| * Method to restore the previously saved operator id, or reset to |
| * automatic selection, all depending upon the value in the shared |
| * preferences. |
| */ |
| public void restoreSavedNetworkSelection(Message response) { |
| // retrieve the operator id |
| String networkSelection = getSavedNetworkSelection(); |
| |
| // set to auto if the id is empty, otherwise select the network. |
| if (TextUtils.isEmpty(networkSelection)) { |
| mCM.setNetworkSelectionModeAutomatic(response); |
| } else { |
| mCM.setNetworkSelectionModeManual(networkSelection, response); |
| } |
| } |
| |
| // Inherited documentation suffices. |
| public void setUnitTestMode(boolean f) { |
| mUnitTestMode = f; |
| } |
| |
| // Inherited documentation suffices. |
| 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); |
| } |
| |
| // Inherited documentation suffices. |
| public void registerForServiceStateChanged( |
| Handler h, int what, Object obj) { |
| checkCorrectThread(h); |
| |
| mServiceStateRegistrants.add(h, what, obj); |
| } |
| |
| // Inherited documentation suffices. |
| public void unregisterForServiceStateChanged(Handler h) { |
| mServiceStateRegistrants.remove(h); |
| } |
| |
| // Inherited documentation suffices. |
| public void registerForRingbackTone(Handler h, int what, Object obj) { |
| mCM.registerForRingbackTone(h,what,obj); |
| } |
| |
| // Inherited documentation suffices. |
| public void unregisterForRingbackTone(Handler h) { |
| mCM.unregisterForRingbackTone(h); |
| } |
| |
| // Inherited documentation suffices. |
| public void registerForResendIncallMute(Handler h, int what, Object obj) { |
| mCM.registerForResendIncallMute(h,what,obj); |
| } |
| |
| // Inherited documentation suffices. |
| public void unregisterForResendIncallMute(Handler h) { |
| mCM.unregisterForResendIncallMute(h); |
| } |
| |
| public void setEchoSuppressionEnabled(boolean enabled) { |
| // 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); |
| } |
| |
| // Inherited documentation suffices. |
| 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 PhoneBase 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 void setPropertiesByCarrier() { |
| String carrier = SystemProperties.get("ro.carrier"); |
| |
| if (null == carrier || 0 == carrier.length() || "unknown".equals(carrier)) { |
| return; |
| } |
| |
| CharSequence[] carrierLocales = mContext. |
| getResources().getTextArray(R.array.carrier_properties); |
| |
| for (int i = 0; i < carrierLocales.length; i+=3) { |
| String c = carrierLocales[i].toString(); |
| if (carrier.equals(c)) { |
| String l = carrierLocales[i+1].toString(); |
| int wifiChannels = 0; |
| try { |
| wifiChannels = Integer.parseInt( |
| carrierLocales[i+2].toString()); |
| } catch (NumberFormatException e) { } |
| |
| String language = l.substring(0, 2); |
| String country = ""; |
| if (l.length() >=5) { |
| country = l.substring(3, 5); |
| } |
| setSystemLocale(language, country); |
| |
| if (wifiChannels != 0) { |
| try { |
| Settings.Secure.getInt(mContext.getContentResolver(), |
| Settings.Secure.WIFI_NUM_ALLOWED_CHANNELS); |
| } catch (Settings.SettingNotFoundException e) { |
| // note this is not persisting |
| WifiManager wM = (WifiManager) |
| mContext.getSystemService(Context.WIFI_SERVICE); |
| wM.setNumAllowedChannels(wifiChannels, false); |
| } |
| } |
| return; |
| } |
| } |
| } |
| |
| /** |
| * Utility code to set the system locale if it's not set already |
| * @param language Two character language code desired |
| * @param country Two character country code desired |
| * |
| * {@hide} |
| */ |
| public void setSystemLocale(String language, String country) { |
| String l = SystemProperties.get("persist.sys.language"); |
| String c = SystemProperties.get("persist.sys.country"); |
| |
| if (null == language) { |
| return; // no match possible |
| } |
| language = language.toLowerCase(); |
| if (null == country) { |
| country = ""; |
| } |
| country = country.toUpperCase(); |
| |
| if((null == l || 0 == l.length()) && (null == c || 0 == c.length())) { |
| try { |
| // try to find a good match |
| String[] locales = mContext.getAssets().getLocales(); |
| final int N = locales.length; |
| String bestMatch = null; |
| for(int i = 0; i < N; i++) { |
| // only match full (lang + country) locales |
| if (locales[i]!=null && locales[i].length() >= 5 && |
| locales[i].substring(0,2).equals(language)) { |
| if (locales[i].substring(3,5).equals(country)) { |
| bestMatch = locales[i]; |
| break; |
| } else if (null == bestMatch) { |
| bestMatch = locales[i]; |
| } |
| } |
| } |
| if (null != bestMatch) { |
| IActivityManager am = ActivityManagerNative.getDefault(); |
| Configuration config = am.getConfiguration(); |
| config.locale = new Locale(bestMatch.substring(0,2), |
| bestMatch.substring(3,5)); |
| config.userSetLocale = true; |
| am.updateConfiguration(config); |
| } |
| } catch (Exception e) { |
| // Intentionally left blank |
| } |
| } |
| } |
| |
| /** |
| * Get state |
| */ |
| public abstract Phone.State getState(); |
| |
| /** |
| * Retrieves the IccFileHandler of the Phone instance |
| */ |
| public abstract IccFileHandler getIccFileHandler(); |
| |
| /* |
| * Retrieves the Handler of the Phone instance |
| */ |
| public Handler getHandler() { |
| return this; |
| } |
| |
| /** |
| * Query the status of the CDMA roaming preference |
| */ |
| public void queryCdmaRoamingPreference(Message response) { |
| mCM.queryCdmaRoamingPreference(response); |
| } |
| |
| /** |
| * Set the status of the CDMA roaming preference |
| */ |
| public void setCdmaRoamingPreference(int cdmaRoamingType, Message response) { |
| mCM.setCdmaRoamingPreference(cdmaRoamingType, response); |
| } |
| |
| /** |
| * Set the status of the CDMA subscription mode |
| */ |
| public void setCdmaSubscription(int cdmaSubscriptionType, Message response) { |
| mCM.setCdmaSubscription(cdmaSubscriptionType, response); |
| } |
| |
| /** |
| * Set the preferred Network Type: Global, CDMA only or GSM/UMTS only |
| */ |
| public void setPreferredNetworkType(int networkType, Message response) { |
| mCM.setPreferredNetworkType(networkType, response); |
| } |
| |
| public void getPreferredNetworkType(Message response) { |
| mCM.getPreferredNetworkType(response); |
| } |
| |
| public void getSmscAddress(Message result) { |
| mCM.getSmscAddress(result); |
| } |
| |
| public void setSmscAddress(String address, Message result) { |
| mCM.setSmscAddress(address, result); |
| } |
| |
| public void setTTYMode(int ttyMode, Message onComplete) { |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("setTTYMode"); |
| } |
| |
| public void queryTTYMode(Message onComplete) { |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("queryTTYMode"); |
| } |
| |
| public void enableEnhancedVoicePrivacy(boolean enable, Message onComplete) { |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("enableEnhancedVoicePrivacy"); |
| } |
| |
| public void getEnhancedVoicePrivacy(Message onComplete) { |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("getEnhancedVoicePrivacy"); |
| } |
| |
| public void setBandMode(int bandMode, Message response) { |
| mCM.setBandMode(bandMode, response); |
| } |
| |
| public void queryAvailableBandMode(Message response) { |
| mCM.queryAvailableBandMode(response); |
| } |
| |
| public void invokeOemRilRequestRaw(byte[] data, Message response) { |
| mCM.invokeOemRilRequestRaw(data, response); |
| } |
| |
| public void invokeOemRilRequestStrings(String[] strings, Message response) { |
| mCM.invokeOemRilRequestStrings(strings, response); |
| } |
| |
| public void notifyDataActivity() { |
| mNotifier.notifyDataActivity(this); |
| } |
| |
| public void notifyMessageWaitingIndicator() { |
| // This function is added to send the notification to DefaultPhoneNotifier. |
| mNotifier.notifyMessageWaitingChanged(this); |
| } |
| |
| public void notifyDataConnection(String reason) { |
| mNotifier.notifyDataConnection(this, reason); |
| } |
| |
| public abstract String getPhoneName(); |
| |
| public abstract int getPhoneType(); |
| |
| /** @hide */ |
| public int getVoiceMessageCount(){ |
| return 0; |
| } |
| |
| /** |
| * Returns the CDMA ERI icon index to display |
| */ |
| public int getCdmaEriIconIndex() { |
| logUnexpectedCdmaMethodCall("getCdmaEriIconIndex"); |
| return -1; |
| } |
| |
| /** |
| * Returns the CDMA ERI icon mode, |
| * 0 - ON |
| * 1 - FLASHING |
| */ |
| public int getCdmaEriIconMode() { |
| logUnexpectedCdmaMethodCall("getCdmaEriIconMode"); |
| return -1; |
| } |
| |
| /** |
| * Returns the CDMA ERI text, |
| */ |
| public String getCdmaEriText() { |
| logUnexpectedCdmaMethodCall("getCdmaEriText"); |
| return "GSM nw, no ERI"; |
| } |
| |
| public String getCdmaMin() { |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("getCdmaMin"); |
| return null; |
| } |
| |
| public boolean isMinInfoReady() { |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("isMinInfoReady"); |
| return false; |
| } |
| |
| public String getCdmaPrlVersion(){ |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("getCdmaPrlVersion"); |
| return null; |
| } |
| |
| public void sendBurstDtmf(String dtmfString, int on, int off, Message onComplete) { |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("sendBurstDtmf"); |
| } |
| |
| public void exitEmergencyCallbackMode() { |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("exitEmergencyCallbackMode"); |
| } |
| |
| public void registerForCdmaOtaStatusChange(Handler h, int what, Object obj) { |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("registerForCdmaOtaStatusChange"); |
| } |
| |
| public void unregisterForCdmaOtaStatusChange(Handler h) { |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("unregisterForCdmaOtaStatusChange"); |
| } |
| |
| public void registerForSubscriptionInfoReady(Handler h, int what, Object obj) { |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("registerForSubscriptionInfoReady"); |
| } |
| |
| public void unregisterForSubscriptionInfoReady(Handler h) { |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("unregisterForSubscriptionInfoReady"); |
| } |
| |
| public boolean isOtaSpNumber(String dialStr) { |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("isOtaSpNumber"); |
| return false; |
| } |
| |
| public void registerForCallWaiting(Handler h, int what, Object obj){ |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("registerForCallWaiting"); |
| } |
| |
| public void unregisterForCallWaiting(Handler h){ |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("unregisterForCallWaiting"); |
| } |
| |
| public void registerForEcmTimerReset(Handler h, int what, Object obj) { |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("registerForEcmTimerReset"); |
| } |
| |
| public void unregisterForEcmTimerReset(Handler h) { |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("unregisterForEcmTimerReset"); |
| } |
| |
| public void registerForSignalInfo(Handler h, int what, Object obj) { |
| mCM.registerForSignalInfo(h, what, obj); |
| } |
| |
| public void unregisterForSignalInfo(Handler h) { |
| mCM.unregisterForSignalInfo(h); |
| } |
| |
| public void registerForDisplayInfo(Handler h, int what, Object obj) { |
| mCM.registerForDisplayInfo(h, what, obj); |
| } |
| |
| public void unregisterForDisplayInfo(Handler h) { |
| mCM.unregisterForDisplayInfo(h); |
| } |
| |
| public void registerForNumberInfo(Handler h, int what, Object obj) { |
| mCM.registerForNumberInfo(h, what, obj); |
| } |
| |
| public void unregisterForNumberInfo(Handler h) { |
| mCM.unregisterForNumberInfo(h); |
| } |
| |
| public void registerForRedirectedNumberInfo(Handler h, int what, Object obj) { |
| mCM.registerForRedirectedNumberInfo(h, what, obj); |
| } |
| |
| public void unregisterForRedirectedNumberInfo(Handler h) { |
| mCM.unregisterForRedirectedNumberInfo(h); |
| } |
| |
| public void registerForLineControlInfo(Handler h, int what, Object obj) { |
| mCM.registerForLineControlInfo( h, what, obj); |
| } |
| |
| public void unregisterForLineControlInfo(Handler h) { |
| mCM.unregisterForLineControlInfo(h); |
| } |
| |
| public void registerFoT53ClirlInfo(Handler h, int what, Object obj) { |
| mCM.registerFoT53ClirlInfo(h, what, obj); |
| } |
| |
| public void unregisterForT53ClirInfo(Handler h) { |
| mCM.unregisterForT53ClirInfo(h); |
| } |
| |
| public void registerForT53AudioControlInfo(Handler h, int what, Object obj) { |
| mCM.registerForT53AudioControlInfo( h, what, obj); |
| } |
| |
| public void unregisterForT53AudioControlInfo(Handler h) { |
| mCM.unregisterForT53AudioControlInfo(h); |
| } |
| |
| public void setOnEcbModeExitResponse(Handler h, int what, Object obj){ |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("setOnEcbModeExitResponse"); |
| } |
| |
| public void unsetOnEcbModeExitResponse(Handler h){ |
| // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. |
| logUnexpectedCdmaMethodCall("unsetOnEcbModeExitResponse"); |
| } |
| |
| public String getInterfaceName(String apnType) { |
| return mDataConnection.getInterfaceName(apnType); |
| } |
| |
| public String getIpAddress(String apnType) { |
| return mDataConnection.getIpAddress(apnType); |
| } |
| |
| public boolean isDataConnectivityEnabled() { |
| return mDataConnection.getDataEnabled(); |
| } |
| |
| public String getGateway(String apnType) { |
| return mDataConnection.getGateway(apnType); |
| } |
| |
| public String[] getDnsServers(String apnType) { |
| return mDataConnection.getDnsServers(apnType); |
| } |
| |
| public String[] getActiveApnTypes() { |
| return mDataConnection.getActiveApnTypes(); |
| } |
| |
| public String getActiveApn() { |
| return mDataConnection.getActiveApnString(); |
| } |
| |
| public int enableApnType(String type) { |
| return mDataConnection.enableApnType(type); |
| } |
| |
| public int disableApnType(String type) { |
| return mDataConnection.disableApnType(type); |
| } |
| |
| /** |
| * simulateDataConnection |
| * |
| * simulates various data connection states. This messes with |
| * DataConnectionTracker's internal states, but doesn't actually change |
| * the underlying radio connection states. |
| * |
| * @param state Phone.DataState enum. |
| */ |
| public void simulateDataConnection(Phone.DataState state) { |
| DataConnectionTracker.State dcState; |
| |
| switch (state) { |
| case CONNECTED: |
| dcState = DataConnectionTracker.State.CONNECTED; |
| break; |
| case SUSPENDED: |
| dcState = DataConnectionTracker.State.CONNECTED; |
| break; |
| case DISCONNECTED: |
| dcState = DataConnectionTracker.State.FAILED; |
| break; |
| default: |
| dcState = DataConnectionTracker.State.CONNECTING; |
| break; |
| } |
| |
| mDataConnection.setState(dcState); |
| notifyDataConnection(null); |
| } |
| |
| /** |
| * Notify registrants of a new ringing Connection. |
| * Subclasses of Phone probably want to replace this with a |
| * version scoped to their packages |
| */ |
| protected void notifyNewRingingConnectionP(Connection cn) { |
| AsyncResult ar = new AsyncResult(null, cn, null); |
| mNewRingingConnectionRegistrants.notifyRegistrants(ar); |
| } |
| |
| /** |
| * Notify registrants of a RING event. |
| */ |
| private void notifyIncomingRing() { |
| 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 (!mDoesRilSendMultipleCallRing && (token == mCallRingContinueToken)) { |
| Log.d(LOG_TAG, "Sending notifyIncomingRing"); |
| notifyIncomingRing(); |
| sendMessageDelayed( |
| obtainMessage(EVENT_CALL_RING_CONTINUE, token, 0), mCallRingDelay); |
| } else { |
| Log.d(LOG_TAG, "Ignoring ring notification request," |
| + " mDoesRilSendMultipleCallRing=" + mDoesRilSendMultipleCallRing |
| + " token=" + token |
| + " mCallRingContinueToken=" + mCallRingContinueToken); |
| } |
| } |
| |
| /** |
| * Common error logger method for unexpected calls to CDMA-only methods. |
| */ |
| private void logUnexpectedCdmaMethodCall(String name) |
| { |
| Log.e(LOG_TAG, "Error! " + name + "() in PhoneBase should not be " + |
| "called, CDMAPhone inactive."); |
| } |
| } |
