| /* |
| * Copyright (C) 2008 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.cdma; |
| |
| import com.android.internal.telephony.TelephonyProperties; |
| import com.android.internal.telephony.MccTable; |
| import com.android.internal.telephony.EventLogTags; |
| import com.android.internal.telephony.RILConstants; |
| |
| import android.content.Intent; |
| import android.telephony.SignalStrength; |
| import android.telephony.ServiceState; |
| import android.telephony.cdma.CdmaCellLocation; |
| import android.os.AsyncResult; |
| import android.os.Message; |
| import android.provider.Telephony.Intents; |
| |
| import android.text.TextUtils; |
| import android.util.Log; |
| import android.util.EventLog; |
| |
| import com.android.internal.telephony.gsm.GsmDataConnectionTracker; |
| |
| public class CdmaLteServiceStateTracker extends CdmaServiceStateTracker { |
| CDMALTEPhone mCdmaLtePhone; |
| |
| private ServiceState mLteSS; // The last LTE state from Voice Registration |
| private boolean mNeedToRegForSimLoaded = true; |
| |
| public CdmaLteServiceStateTracker(CDMALTEPhone phone) { |
| super(phone); |
| cm.registerForSIMReady(this, EVENT_SIM_READY, null); |
| mCdmaLtePhone = phone; |
| |
| mLteSS = new ServiceState(); |
| if (DBG) log("CdmaLteServiceStateTracker Constructors"); |
| } |
| |
| @Override |
| public void dispose() { |
| cm.unregisterForSIMReady(this); |
| super.dispose(); |
| } |
| |
| @Override |
| public void handleMessage(Message msg) { |
| AsyncResult ar; |
| int[] ints; |
| String[] strings; |
| switch (msg.what) { |
| case EVENT_POLL_STATE_GPRS: |
| if (DBG) log("handleMessage EVENT_POLL_STATE_GPRS"); |
| ar = (AsyncResult)msg.obj; |
| handlePollStateResult(msg.what, ar); |
| break; |
| case EVENT_SIM_READY: |
| if (DBG) log("handleMessage EVENT_SIM_READY"); |
| isSubscriptionFromRuim = false; |
| // Register SIM_RECORDS_LOADED dynamically. |
| // This is to avoid confilct with RUIM_READY scenario) |
| if (mNeedToRegForSimLoaded) { |
| phone.mIccRecords.registerForRecordsLoaded(this, EVENT_SIM_RECORDS_LOADED, null); |
| mNeedToRegForSimLoaded = false; |
| } |
| pollState(); |
| // Signal strength polling stops when radio is off. |
| queueNextSignalStrengthPoll(); |
| |
| // load ERI file |
| phone.prepareEri(); |
| break; |
| case EVENT_SIM_RECORDS_LOADED: |
| CdmaLteUiccRecords sim = (CdmaLteUiccRecords)phone.mIccRecords; |
| if ((sim != null) && sim.isProvisioned()) { |
| mMdn = sim.getMdn(); |
| mMin = sim.getMin(); |
| parseSidNid(sim.getSid(), sim.getNid()); |
| mPrlVersion = sim.getPrlVersion();; |
| mIsMinInfoReady = true; |
| updateOtaspState(); |
| } |
| // SID/NID/PRL is loaded. Poll service state |
| // again to update to the roaming state with |
| // the latest variables. |
| pollState(); |
| break; |
| default: |
| super.handleMessage(msg); |
| } |
| } |
| |
| /** |
| * Set the cdmaSS for EVENT_POLL_STATE_REGISTRATION_CDMA |
| */ |
| @Override |
| protected void setCdmaTechnology(int radioTechnology) { |
| // Called on voice registration state response. |
| // Just record new CDMA radio technology |
| newSS.setRadioTechnology(radioTechnology); |
| } |
| |
| /** |
| * Handle the result of one of the pollState()-related requests |
| */ |
| @Override |
| protected void handlePollStateResultMessage(int what, AsyncResult ar) { |
| if (what == EVENT_POLL_STATE_GPRS) { |
| if (DBG) log("handlePollStateResultMessage: EVENT_POLL_STATE_GPRS"); |
| String states[] = (String[])ar.result; |
| |
| int type = 0; |
| int regState = -1; |
| if (states.length > 0) { |
| try { |
| regState = Integer.parseInt(states[0]); |
| |
| // states[3] (if present) is the current radio technology |
| if (states.length >= 4 && states[3] != null) { |
| type = Integer.parseInt(states[3]); |
| } |
| } catch (NumberFormatException ex) { |
| loge("handlePollStateResultMessage: error parsing GprsRegistrationState: " |
| + ex); |
| } |
| } |
| |
| mLteSS.setRadioTechnology(type); |
| mLteSS.setState(regCodeToServiceState(regState)); |
| } else { |
| super.handlePollStateResultMessage(what, ar); |
| } |
| } |
| |
| @Override |
| protected void setSignalStrengthDefaultValues() { |
| // TODO Make a constructor only has boolean gsm as parameter |
| mSignalStrength = new SignalStrength(99, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, SignalStrength.INVALID_SNR, -1, false); |
| } |
| |
| @Override |
| protected void pollState() { |
| pollingContext = new int[1]; |
| pollingContext[0] = 0; |
| |
| switch (cm.getRadioState()) { |
| case RADIO_UNAVAILABLE: |
| newSS.setStateOutOfService(); |
| newCellLoc.setStateInvalid(); |
| setSignalStrengthDefaultValues(); |
| mGotCountryCode = false; |
| |
| pollStateDone(); |
| break; |
| |
| case RADIO_OFF: |
| newSS.setStateOff(); |
| newCellLoc.setStateInvalid(); |
| setSignalStrengthDefaultValues(); |
| mGotCountryCode = false; |
| |
| pollStateDone(); |
| break; |
| |
| default: |
| // Issue all poll-related commands at once, then count |
| // down the responses which are allowed to arrive |
| // out-of-order. |
| |
| pollingContext[0]++; |
| // RIL_REQUEST_OPERATOR is necessary for CDMA |
| cm.getOperator(obtainMessage(EVENT_POLL_STATE_OPERATOR_CDMA, pollingContext)); |
| |
| pollingContext[0]++; |
| // RIL_REQUEST_VOICE_REGISTRATION_STATE is necessary for CDMA |
| cm.getVoiceRegistrationState(obtainMessage(EVENT_POLL_STATE_REGISTRATION_CDMA, |
| pollingContext)); |
| |
| int networkMode = android.provider.Settings.Secure.getInt(phone.getContext() |
| .getContentResolver(), |
| android.provider.Settings.Secure.PREFERRED_NETWORK_MODE, |
| RILConstants.PREFERRED_NETWORK_MODE); |
| if (DBG) log("pollState: network mode here is = " + networkMode); |
| if ((networkMode == RILConstants.NETWORK_MODE_GLOBAL) |
| || (networkMode == RILConstants.NETWORK_MODE_LTE_ONLY)) { |
| pollingContext[0]++; |
| // RIL_REQUEST_DATA_REGISTRATION_STATE |
| cm.getDataRegistrationState(obtainMessage(EVENT_POLL_STATE_GPRS, |
| pollingContext)); |
| } |
| break; |
| } |
| } |
| |
| @Override |
| protected void pollStateDone() { |
| // determine data NetworkType from both LET and CDMA SS |
| if (mLteSS.getState() == ServiceState.STATE_IN_SERVICE) { |
| //in LTE service |
| newNetworkType = mLteSS.getRadioTechnology(); |
| mNewDataConnectionState = mLteSS.getState(); |
| newSS.setRadioTechnology(newNetworkType); |
| log("pollStateDone LTE/eHRPD STATE_IN_SERVICE newNetworkType = " + newNetworkType); |
| } else { |
| // LTE out of service, get CDMA Service State |
| newNetworkType = newSS.getRadioTechnology(); |
| mNewDataConnectionState = radioTechnologyToDataServiceState(newNetworkType); |
| log("pollStateDone CDMA STATE_IN_SERVICE newNetworkType = " + newNetworkType + |
| " mNewDataConnectionState = " + mNewDataConnectionState); |
| } |
| |
| // TODO: Add proper support for LTE Only, we should be looking at |
| // the preferred network mode, to know when newSS state should |
| // be coming from mLteSs state. This was needed to pass a VZW |
| // LTE Only test. |
| // |
| // If CDMA service is OOS, double check if the device is running with LTE only |
| // mode. If that is the case, derive the service state from LTE side. |
| // To set in LTE only mode, sqlite3 /data/data/com.android.providers.settings/ |
| // databases/settings.db "update secure set value='11' where name='preferred_network_mode'" |
| if (newSS.getState() == ServiceState.STATE_OUT_OF_SERVICE) { |
| int networkMode = android.provider.Settings.Secure.getInt(phone.getContext() |
| .getContentResolver(), |
| android.provider.Settings.Secure.PREFERRED_NETWORK_MODE, |
| RILConstants.PREFERRED_NETWORK_MODE); |
| if (networkMode == RILConstants.NETWORK_MODE_LTE_ONLY) { |
| if (DBG) log("pollState: LTE Only mode"); |
| newSS.setState(mLteSS.getState()); |
| } |
| } |
| |
| if (DBG) log("pollStateDone: oldSS=[" + ss + "] newSS=[" + newSS + "]"); |
| |
| boolean hasRegistered = ss.getState() != ServiceState.STATE_IN_SERVICE |
| && newSS.getState() == ServiceState.STATE_IN_SERVICE; |
| |
| boolean hasDeregistered = ss.getState() == ServiceState.STATE_IN_SERVICE |
| && newSS.getState() != ServiceState.STATE_IN_SERVICE; |
| |
| boolean hasCdmaDataConnectionAttached = |
| mDataConnectionState != ServiceState.STATE_IN_SERVICE |
| && mNewDataConnectionState == ServiceState.STATE_IN_SERVICE; |
| |
| boolean hasCdmaDataConnectionDetached = |
| mDataConnectionState == ServiceState.STATE_IN_SERVICE |
| && mNewDataConnectionState != ServiceState.STATE_IN_SERVICE; |
| |
| boolean hasCdmaDataConnectionChanged = |
| mDataConnectionState != mNewDataConnectionState; |
| |
| boolean hasNetworkTypeChanged = networkType != newNetworkType; |
| |
| boolean hasChanged = !newSS.equals(ss); |
| |
| boolean hasRoamingOn = !ss.getRoaming() && newSS.getRoaming(); |
| |
| boolean hasRoamingOff = ss.getRoaming() && !newSS.getRoaming(); |
| |
| boolean hasLocationChanged = !newCellLoc.equals(cellLoc); |
| |
| boolean has4gHandoff = |
| mNewDataConnectionState == ServiceState.STATE_IN_SERVICE && |
| (((networkType == ServiceState.RADIO_TECHNOLOGY_LTE) && |
| (newNetworkType == ServiceState.RADIO_TECHNOLOGY_EHRPD)) || |
| ((networkType == ServiceState.RADIO_TECHNOLOGY_EHRPD) && |
| (newNetworkType == ServiceState.RADIO_TECHNOLOGY_LTE))); |
| |
| boolean hasMultiApnSupport = |
| (((newNetworkType == ServiceState.RADIO_TECHNOLOGY_LTE) || |
| (newNetworkType == ServiceState.RADIO_TECHNOLOGY_EHRPD)) && |
| ((networkType != ServiceState.RADIO_TECHNOLOGY_LTE) && |
| (networkType != ServiceState.RADIO_TECHNOLOGY_EHRPD))); |
| |
| boolean hasLostMultiApnSupport = |
| ((newNetworkType >= ServiceState.RADIO_TECHNOLOGY_IS95A) && |
| (newNetworkType <= ServiceState.RADIO_TECHNOLOGY_EVDO_A)); |
| |
| if (DBG) { |
| log("pollStateDone:" |
| + " hasRegistered=" + hasRegistered |
| + " hasDeegistered=" + hasDeregistered |
| + " hasCdmaDataConnectionAttached=" + hasCdmaDataConnectionAttached |
| + " hasCdmaDataConnectionDetached=" + hasCdmaDataConnectionDetached |
| + " hasCdmaDataConnectionChanged=" + hasCdmaDataConnectionChanged |
| + " hasNetworkTypeChanged = " + hasNetworkTypeChanged |
| + " hasChanged=" + hasChanged |
| + " hasRoamingOn=" + hasRoamingOn |
| + " hasRoamingOff=" + hasRoamingOff |
| + " hasLocationChanged=" + hasLocationChanged |
| + " has4gHandoff = " + has4gHandoff |
| + " hasMultiApnSupport=" + hasMultiApnSupport |
| + " hasLostMultiApnSupport=" + hasLostMultiApnSupport); |
| } |
| // Add an event log when connection state changes |
| if (ss.getState() != newSS.getState() |
| || mDataConnectionState != mNewDataConnectionState) { |
| EventLog.writeEvent(EventLogTags.CDMA_SERVICE_STATE_CHANGE, ss.getState(), |
| mDataConnectionState, newSS.getState(), mNewDataConnectionState); |
| } |
| |
| ServiceState tss; |
| tss = ss; |
| ss = newSS; |
| newSS = tss; |
| // clean slate for next time |
| newSS.setStateOutOfService(); |
| mLteSS.setStateOutOfService(); |
| |
| if ((hasMultiApnSupport) |
| && (phone.mDataConnectionTracker instanceof CdmaDataConnectionTracker)) { |
| if (DBG) log("GsmDataConnectionTracker Created"); |
| phone.mDataConnectionTracker.dispose(); |
| phone.mDataConnectionTracker = new GsmDataConnectionTracker(mCdmaLtePhone); |
| } |
| |
| if ((hasLostMultiApnSupport) |
| && (phone.mDataConnectionTracker instanceof GsmDataConnectionTracker)) { |
| if (DBG)log("GsmDataConnectionTracker disposed"); |
| phone.mDataConnectionTracker.dispose(); |
| phone.mDataConnectionTracker = new CdmaDataConnectionTracker(phone); |
| } |
| |
| CdmaCellLocation tcl = cellLoc; |
| cellLoc = newCellLoc; |
| newCellLoc = tcl; |
| |
| mDataConnectionState = mNewDataConnectionState; |
| networkType = newNetworkType; |
| |
| newSS.setStateOutOfService(); // clean slate for next time |
| |
| if (hasNetworkTypeChanged) { |
| phone.setSystemProperty(TelephonyProperties.PROPERTY_DATA_NETWORK_TYPE, |
| ServiceState.radioTechnologyToString(networkType)); |
| } |
| |
| if (hasRegistered) { |
| mNetworkAttachedRegistrants.notifyRegistrants(); |
| } |
| |
| if (hasChanged) { |
| if (phone.isEriFileLoaded()) { |
| String eriText; |
| // Now the CDMAPhone sees the new ServiceState so it can get the |
| // new ERI text |
| if (ss.getState() == ServiceState.STATE_IN_SERVICE) { |
| eriText = phone.getCdmaEriText(); |
| } else { |
| // Note that ServiceState.STATE_OUT_OF_SERVICE is valid used |
| // for |
| // mRegistrationState 0,2,3 and 4 |
| eriText = phone.getContext() |
| .getText(com.android.internal.R.string.roamingTextSearching).toString(); |
| } |
| ss.setOperatorAlphaLong(eriText); |
| } |
| |
| if (cm.getSimState().isSIMReady()) { |
| // SIM is found on the device. If ERI roaming is OFF and SID/NID matches |
| // one configfured in SIM, use operator name from CSIM record. |
| boolean showSpn = |
| ((CdmaLteUiccRecords)phone.mIccRecords).getCsimSpnDisplayCondition(); |
| int iconIndex = ss.getCdmaEriIconIndex(); |
| |
| if (showSpn && (iconIndex == EriInfo.ROAMING_INDICATOR_OFF) && |
| isInHomeSidNid(ss.getSystemId(), ss.getNetworkId())) { |
| ss.setOperatorAlphaLong(phone.mIccRecords.getServiceProviderName()); |
| } |
| } |
| |
| String operatorNumeric; |
| |
| phone.setSystemProperty(TelephonyProperties.PROPERTY_OPERATOR_ALPHA, |
| ss.getOperatorAlphaLong()); |
| |
| operatorNumeric = ss.getOperatorNumeric(); |
| phone.setSystemProperty(TelephonyProperties.PROPERTY_OPERATOR_NUMERIC, operatorNumeric); |
| |
| if (operatorNumeric == null) { |
| phone.setSystemProperty(TelephonyProperties.PROPERTY_OPERATOR_ISO_COUNTRY, ""); |
| mGotCountryCode = false; |
| } else { |
| String isoCountryCode = ""; |
| try { |
| isoCountryCode = MccTable.countryCodeForMcc(Integer.parseInt(operatorNumeric |
| .substring(0, 3))); |
| } catch (NumberFormatException ex) { |
| loge("countryCodeForMcc error" + ex); |
| } catch (StringIndexOutOfBoundsException ex) { |
| loge("countryCodeForMcc error" + ex); |
| } |
| |
| phone.setSystemProperty(TelephonyProperties.PROPERTY_OPERATOR_ISO_COUNTRY, |
| isoCountryCode); |
| mGotCountryCode = true; |
| if (mNeedFixZone) { |
| fixTimeZone(isoCountryCode); |
| } |
| } |
| |
| phone.setSystemProperty(TelephonyProperties.PROPERTY_OPERATOR_ISROAMING, |
| ss.getRoaming() ? "true" : "false"); |
| |
| updateSpnDisplay(); |
| phone.notifyServiceStateChanged(ss); |
| } |
| |
| if (hasCdmaDataConnectionAttached || has4gHandoff) { |
| mAttachedRegistrants.notifyRegistrants(); |
| } |
| |
| if (hasCdmaDataConnectionDetached) { |
| mDetachedRegistrants.notifyRegistrants(); |
| } |
| |
| if ((hasCdmaDataConnectionChanged || hasNetworkTypeChanged)) { |
| phone.notifyDataConnection(null); |
| } |
| |
| if (hasRoamingOn) { |
| mRoamingOnRegistrants.notifyRegistrants(); |
| } |
| |
| if (hasRoamingOff) { |
| mRoamingOffRegistrants.notifyRegistrants(); |
| } |
| |
| if (hasLocationChanged) { |
| phone.notifyLocationChanged(); |
| } |
| } |
| |
| @Override |
| protected void onSignalStrengthResult(AsyncResult ar) { |
| SignalStrength oldSignalStrength = mSignalStrength; |
| |
| if (ar.exception != null) { |
| // Most likely radio is resetting/disconnected change to default |
| // values. |
| setSignalStrengthDefaultValues(); |
| } else { |
| int[] ints = (int[])ar.result; |
| |
| int lteRssi = -1; |
| int lteRsrp = -1; |
| int lteRsrq = -1; |
| int lteRssnr = SignalStrength.INVALID_SNR; |
| int lteCqi = -1; |
| |
| int offset = 2; |
| int cdmaDbm = (ints[offset] > 0) ? -ints[offset] : -120; |
| int cdmaEcio = (ints[offset + 1] > 0) ? -ints[offset + 1] : -160; |
| int evdoRssi = (ints[offset + 2] > 0) ? -ints[offset + 2] : -120; |
| int evdoEcio = (ints[offset + 3] > 0) ? -ints[offset + 3] : -1; |
| int evdoSnr = ((ints[offset + 4] > 0) && (ints[offset + 4] <= 8)) ? ints[offset + 4] |
| : -1; |
| |
| if (networkType == ServiceState.RADIO_TECHNOLOGY_LTE) { |
| lteRssi = ints[offset+5]; |
| lteRsrp = ints[offset+6]; |
| lteRsrq = ints[offset+7]; |
| lteRssnr = ints[offset+8]; |
| lteCqi = ints[offset+9]; |
| } |
| |
| if (networkType != ServiceState.RADIO_TECHNOLOGY_LTE) { |
| mSignalStrength = new SignalStrength(99, -1, cdmaDbm, cdmaEcio, evdoRssi, evdoEcio, |
| evdoSnr, false); |
| } else { |
| mSignalStrength = new SignalStrength(99, -1, cdmaDbm, cdmaEcio, evdoRssi, evdoEcio, |
| evdoSnr, lteRssi, lteRsrp, lteRsrq, lteRssnr, lteCqi, true); |
| } |
| } |
| |
| try { |
| phone.notifySignalStrength(); |
| } catch (NullPointerException ex) { |
| loge("onSignalStrengthResult() Phone already destroyed: " + ex |
| + "SignalStrength not notified"); |
| } |
| } |
| |
| @Override |
| public boolean isConcurrentVoiceAndDataAllowed() { |
| // Note: it needs to be confirmed which CDMA network types |
| // can support voice and data calls concurrently. |
| // For the time-being, the return value will be false. |
| return (networkType == ServiceState.RADIO_TECHNOLOGY_LTE); |
| } |
| |
| /** |
| * Check whether the specified SID and NID pair appears in the HOME SID/NID list |
| * read from NV or SIM. |
| * |
| * @return true if provided sid/nid pair belongs to operator's home network. |
| */ |
| private boolean isInHomeSidNid(int sid, int nid) { |
| // if SID/NID is not available, assume this is home network. |
| if (isSidsAllZeros()) return true; |
| |
| // length of SID/NID shold be same |
| if (mHomeSystemId.length != mHomeNetworkId.length) return true; |
| |
| if (sid == 0) return true; |
| |
| for (int i = 0; i < mHomeSystemId.length; i++) { |
| // Use SID only if NID is a reserved value. |
| // SID 0 and NID 0 and 65535 are reserved. (C.0005 2.6.5.2) |
| if ((mHomeSystemId[i] == sid) && |
| ((mHomeNetworkId[i] == 0) || (mHomeNetworkId[i] == 65535) || |
| (nid == 0) || (nid == 65535) || (mHomeNetworkId[i] == nid))) { |
| return true; |
| } |
| } |
| // SID/NID are not in the list. So device is not in home network |
| return false; |
| } |
| |
| @Override |
| protected void log(String s) { |
| Log.d(LOG_TAG, "[CdmaLteSST] " + s); |
| } |
| |
| @Override |
| protected void loge(String s) { |
| Log.e(LOG_TAG, "[CdmaLteSST] " + s); |
| } |
| } |
