| /* |
| * Copyright (C) 2006 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.dataconnection; |
| |
| |
| import com.android.internal.telephony.CommandException; |
| import com.android.internal.telephony.DctConstants; |
| import com.android.internal.telephony.Phone; |
| import com.android.internal.telephony.PhoneBase; |
| import com.android.internal.telephony.PhoneConstants; |
| import com.android.internal.telephony.RILConstants; |
| import com.android.internal.telephony.RetryManager; |
| import com.android.internal.util.AsyncChannel; |
| import com.android.internal.util.FastPrintWriter; |
| import com.android.internal.util.Protocol; |
| import com.android.internal.util.State; |
| import com.android.internal.util.StateMachine; |
| |
| import android.app.PendingIntent; |
| import android.content.Context; |
| import android.net.ConnectivityManager; |
| import android.net.LinkProperties; |
| import android.net.NetworkAgent; |
| import android.net.NetworkCapabilities; |
| import android.net.NetworkInfo; |
| import android.net.NetworkMisc; |
| import android.net.ProxyInfo; |
| import android.os.AsyncResult; |
| import android.os.Build; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.Messenger; |
| import android.os.SystemClock; |
| import android.os.SystemProperties; |
| import android.telephony.Rlog; |
| import android.telephony.ServiceState; |
| import android.telephony.TelephonyManager; |
| import android.text.TextUtils; |
| import android.util.Pair; |
| import android.util.Patterns; |
| import android.util.TimeUtils; |
| |
| import java.io.FileDescriptor; |
| import java.io.OutputStream; |
| import java.io.PrintWriter; |
| import java.io.StringWriter; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.concurrent.atomic.AtomicInteger; |
| import java.net.InetAddress; |
| import java.util.Collection; |
| |
| /** |
| * {@hide} |
| * |
| * DataConnection StateMachine. |
| * |
| * This a class for representing a single data connection, with instances of this |
| * class representing a connection via the cellular network. There may be multiple |
| * data connections and all of them are managed by the <code>DataConnectionTracker</code>. |
| * |
| * A recent change is to move retry handling into this class, with that change the |
| * old retry manager is now used internally rather than exposed to the DCT. Also, |
| * bringUp now has an initialRetry which is used limit the number of retries |
| * during the initial bring up of the connection. After the connection becomes active |
| * the current max retry is restored to the configured value. |
| * |
| * NOTE: All DataConnection objects must be running on the same looper, which is the default |
| * as the coordinator has members which are used without synchronization. |
| */ |
| public final class DataConnection extends StateMachine { |
| private static final boolean DBG = true; |
| private static final boolean VDBG = true; |
| |
| /** Retry configuration: A doubling of retry times from 5secs to 30minutes */ |
| private static final String DEFAULT_DATA_RETRY_CONFIG = "default_randomization=2000," |
| + "5000,10000,20000,40000,80000:5000,160000:5000," |
| + "320000:5000,640000:5000,1280000:5000,1800000:5000"; |
| |
| /** Retry configuration for secondary networks: 4 tries in 20 sec */ |
| private static final String SECONDARY_DATA_RETRY_CONFIG = |
| "max_retries=3, 5000, 5000, 5000"; |
| |
| private static final String NETWORK_TYPE = "MOBILE"; |
| |
| // The data connection controller |
| private DcController mDcController; |
| |
| // The Tester for failing all bringup's |
| private DcTesterFailBringUpAll mDcTesterFailBringUpAll; |
| |
| private static AtomicInteger mInstanceNumber = new AtomicInteger(0); |
| private AsyncChannel mAc; |
| |
| // Utilities for the DataConnection |
| private DcRetryAlarmController mDcRetryAlarmController; |
| |
| // The DCT that's talking to us, we only support one! |
| private DcTrackerBase mDct = null; |
| |
| protected String[] mPcscfAddr; |
| |
| /** |
| * Used internally for saving connecting parameters. |
| */ |
| static class ConnectionParams { |
| int mTag; |
| ApnContext mApnContext; |
| int mInitialMaxRetry; |
| int mProfileId; |
| int mRilRat; |
| boolean mRetryWhenSSChange; |
| Message mOnCompletedMsg; |
| |
| ConnectionParams(ApnContext apnContext, int initialMaxRetry, int profileId, |
| int rilRadioTechnology, boolean retryWhenSSChange, Message onCompletedMsg) { |
| mApnContext = apnContext; |
| mInitialMaxRetry = initialMaxRetry; |
| mProfileId = profileId; |
| mRilRat = rilRadioTechnology; |
| mRetryWhenSSChange = retryWhenSSChange; |
| mOnCompletedMsg = onCompletedMsg; |
| } |
| |
| @Override |
| public String toString() { |
| return "{mTag=" + mTag + " mApnContext=" + mApnContext |
| + " mInitialMaxRetry=" + mInitialMaxRetry + " mProfileId=" + mProfileId |
| + " mRat=" + mRilRat |
| + " mOnCompletedMsg=" + msgToString(mOnCompletedMsg) + "}"; |
| } |
| } |
| |
| /** |
| * Used internally for saving disconnecting parameters. |
| */ |
| static class DisconnectParams { |
| int mTag; |
| ApnContext mApnContext; |
| String mReason; |
| Message mOnCompletedMsg; |
| |
| DisconnectParams(ApnContext apnContext, String reason, Message onCompletedMsg) { |
| mApnContext = apnContext; |
| mReason = reason; |
| mOnCompletedMsg = onCompletedMsg; |
| } |
| |
| @Override |
| public String toString() { |
| return "{mTag=" + mTag + " mApnContext=" + mApnContext |
| + " mReason=" + mReason |
| + " mOnCompletedMsg=" + msgToString(mOnCompletedMsg) + "}"; |
| } |
| } |
| |
| private ApnSetting mApnSetting; |
| private ConnectionParams mConnectionParams; |
| private DisconnectParams mDisconnectParams; |
| private DcFailCause mDcFailCause; |
| |
| private PhoneBase mPhone; |
| private LinkProperties mLinkProperties = new LinkProperties(); |
| private long mCreateTime; |
| private long mLastFailTime; |
| private DcFailCause mLastFailCause; |
| private static final String NULL_IP = "0.0.0.0"; |
| private Object mUserData; |
| private int mRilRat = Integer.MAX_VALUE; |
| private int mDataRegState = Integer.MAX_VALUE; |
| private NetworkInfo mNetworkInfo; |
| private NetworkAgent mNetworkAgent; |
| |
| //***** Package visible variables |
| int mTag; |
| int mCid; |
| List<ApnContext> mApnContexts = null; |
| PendingIntent mReconnectIntent = null; |
| RetryManager mRetryManager = new RetryManager(); |
| |
| |
| // ***** Event codes for driving the state machine, package visible for Dcc |
| static final int BASE = Protocol.BASE_DATA_CONNECTION; |
| static final int EVENT_CONNECT = BASE + 0; |
| static final int EVENT_SETUP_DATA_CONNECTION_DONE = BASE + 1; |
| static final int EVENT_GET_LAST_FAIL_DONE = BASE + 2; |
| static final int EVENT_DEACTIVATE_DONE = BASE + 3; |
| static final int EVENT_DISCONNECT = BASE + 4; |
| static final int EVENT_RIL_CONNECTED = BASE + 5; |
| static final int EVENT_DISCONNECT_ALL = BASE + 6; |
| static final int EVENT_DATA_STATE_CHANGED = BASE + 7; |
| static final int EVENT_TEAR_DOWN_NOW = BASE + 8; |
| static final int EVENT_LOST_CONNECTION = BASE + 9; |
| static final int EVENT_RETRY_CONNECTION = BASE + 10; |
| static final int EVENT_DATA_CONNECTION_DRS_OR_RAT_CHANGED = BASE + 11; |
| static final int EVENT_DATA_CONNECTION_ROAM_ON = BASE + 12; |
| static final int EVENT_DATA_CONNECTION_ROAM_OFF = BASE + 13; |
| |
| private static final int CMD_TO_STRING_COUNT = EVENT_DATA_CONNECTION_ROAM_OFF - BASE + 1; |
| private static String[] sCmdToString = new String[CMD_TO_STRING_COUNT]; |
| static { |
| sCmdToString[EVENT_CONNECT - BASE] = "EVENT_CONNECT"; |
| sCmdToString[EVENT_SETUP_DATA_CONNECTION_DONE - BASE] = |
| "EVENT_SETUP_DATA_CONNECTION_DONE"; |
| sCmdToString[EVENT_GET_LAST_FAIL_DONE - BASE] = "EVENT_GET_LAST_FAIL_DONE"; |
| sCmdToString[EVENT_DEACTIVATE_DONE - BASE] = "EVENT_DEACTIVATE_DONE"; |
| sCmdToString[EVENT_DISCONNECT - BASE] = "EVENT_DISCONNECT"; |
| sCmdToString[EVENT_RIL_CONNECTED - BASE] = "EVENT_RIL_CONNECTED"; |
| sCmdToString[EVENT_DISCONNECT_ALL - BASE] = "EVENT_DISCONNECT_ALL"; |
| sCmdToString[EVENT_DATA_STATE_CHANGED - BASE] = "EVENT_DATA_STATE_CHANGED"; |
| sCmdToString[EVENT_TEAR_DOWN_NOW - BASE] = "EVENT_TEAR_DOWN_NOW"; |
| sCmdToString[EVENT_LOST_CONNECTION - BASE] = "EVENT_LOST_CONNECTION"; |
| sCmdToString[EVENT_RETRY_CONNECTION - BASE] = "EVENT_RETRY_CONNECTION"; |
| sCmdToString[EVENT_DATA_CONNECTION_DRS_OR_RAT_CHANGED - BASE] = |
| "EVENT_DATA_CONNECTION_DRS_OR_RAT_CHANGED"; |
| sCmdToString[EVENT_DATA_CONNECTION_ROAM_ON - BASE] = "EVENT_DATA_CONNECTION_ROAM_ON"; |
| sCmdToString[EVENT_DATA_CONNECTION_ROAM_OFF - BASE] = "EVENT_DATA_CONNECTION_ROAM_OFF"; |
| } |
| // Convert cmd to string or null if unknown |
| static String cmdToString(int cmd) { |
| String value; |
| cmd -= BASE; |
| if ((cmd >= 0) && (cmd < sCmdToString.length)) { |
| value = sCmdToString[cmd]; |
| } else { |
| value = DcAsyncChannel.cmdToString(cmd + BASE); |
| } |
| if (value == null) { |
| value = "0x" + Integer.toHexString(cmd + BASE); |
| } |
| return value; |
| } |
| |
| /** |
| * Create the connection object |
| * |
| * @param phone the Phone |
| * @param id the connection id |
| * @return DataConnection that was created. |
| */ |
| static DataConnection makeDataConnection(PhoneBase phone, int id, |
| DcTrackerBase dct, DcTesterFailBringUpAll failBringUpAll, |
| DcController dcc) { |
| DataConnection dc = new DataConnection(phone, |
| "DC-" + mInstanceNumber.incrementAndGet(), id, dct, failBringUpAll, dcc); |
| dc.start(); |
| if (DBG) dc.log("Made " + dc.getName()); |
| return dc; |
| } |
| |
| void dispose() { |
| log("dispose: call quiteNow()"); |
| quitNow(); |
| } |
| |
| /* Getter functions */ |
| |
| NetworkCapabilities getCopyNetworkCapabilities() { |
| return makeNetworkCapabilities(); |
| } |
| |
| LinkProperties getCopyLinkProperties() { |
| return new LinkProperties(mLinkProperties); |
| } |
| |
| boolean getIsInactive() { |
| return getCurrentState() == mInactiveState; |
| } |
| |
| int getCid() { |
| return mCid; |
| } |
| |
| ApnSetting getApnSetting() { |
| return mApnSetting; |
| } |
| |
| void setLinkPropertiesHttpProxy(ProxyInfo proxy) { |
| mLinkProperties.setHttpProxy(proxy); |
| } |
| |
| static class UpdateLinkPropertyResult { |
| public DataCallResponse.SetupResult setupResult = DataCallResponse.SetupResult.SUCCESS; |
| public LinkProperties oldLp; |
| public LinkProperties newLp; |
| public UpdateLinkPropertyResult(LinkProperties curLp) { |
| oldLp = curLp; |
| newLp = curLp; |
| } |
| } |
| |
| public boolean isIpv4Connected() { |
| boolean ret = false; |
| Collection <InetAddress> addresses = mLinkProperties.getAddresses(); |
| |
| for (InetAddress addr: addresses) { |
| if (addr instanceof java.net.Inet4Address) { |
| java.net.Inet4Address i4addr = (java.net.Inet4Address) addr; |
| if (!i4addr.isAnyLocalAddress() && !i4addr.isLinkLocalAddress() && |
| !i4addr.isLoopbackAddress() && !i4addr.isMulticastAddress()) { |
| ret = true; |
| break; |
| } |
| } |
| } |
| return ret; |
| } |
| |
| public boolean isIpv6Connected() { |
| boolean ret = false; |
| Collection <InetAddress> addresses = mLinkProperties.getAddresses(); |
| |
| for (InetAddress addr: addresses) { |
| if (addr instanceof java.net.Inet6Address) { |
| java.net.Inet6Address i6addr = (java.net.Inet6Address) addr; |
| if (!i6addr.isAnyLocalAddress() && !i6addr.isLinkLocalAddress() && |
| !i6addr.isLoopbackAddress() && !i6addr.isMulticastAddress()) { |
| ret = true; |
| break; |
| } |
| } |
| } |
| return ret; |
| } |
| |
| UpdateLinkPropertyResult updateLinkProperty(DataCallResponse newState) { |
| UpdateLinkPropertyResult result = new UpdateLinkPropertyResult(mLinkProperties); |
| |
| if (newState == null) return result; |
| |
| DataCallResponse.SetupResult setupResult; |
| result.newLp = new LinkProperties(); |
| |
| // set link properties based on data call response |
| result.setupResult = setLinkProperties(newState, result.newLp); |
| if (result.setupResult != DataCallResponse.SetupResult.SUCCESS) { |
| if (DBG) log("updateLinkProperty failed : " + result.setupResult); |
| return result; |
| } |
| // copy HTTP proxy as it is not part DataCallResponse. |
| result.newLp.setHttpProxy(mLinkProperties.getHttpProxy()); |
| |
| checkSetMtu(mApnSetting, result.newLp); |
| |
| mLinkProperties = result.newLp; |
| |
| updateTcpBufferSizes(mRilRat); |
| |
| if (DBG && (! result.oldLp.equals(result.newLp))) { |
| log("updateLinkProperty old LP=" + result.oldLp); |
| log("updateLinkProperty new LP=" + result.newLp); |
| } |
| |
| if (result.newLp.equals(result.oldLp) == false && |
| mNetworkAgent != null) { |
| mNetworkAgent.sendLinkProperties(mLinkProperties); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Read the MTU value from link properties where it can be set from network. In case |
| * not set by the network, set it again using the mtu szie value defined in the APN |
| * database for the connected APN |
| */ |
| private void checkSetMtu(ApnSetting apn, LinkProperties lp) { |
| if (lp == null) return; |
| |
| if (apn == null || lp == null) return; |
| |
| if (lp.getMtu() != PhoneConstants.UNSET_MTU) { |
| if (DBG) log("MTU set by call response to: " + lp.getMtu()); |
| return; |
| } |
| |
| if (apn != null && apn.mtu != PhoneConstants.UNSET_MTU) { |
| lp.setMtu(apn.mtu); |
| if (DBG) log("MTU set by APN to: " + apn.mtu); |
| return; |
| } |
| |
| int mtu = mPhone.getContext().getResources().getInteger( |
| com.android.internal.R.integer.config_mobile_mtu); |
| if (mtu != PhoneConstants.UNSET_MTU) { |
| lp.setMtu(mtu); |
| if (DBG) log("MTU set by config resource to: " + mtu); |
| } |
| } |
| |
| //***** Constructor (NOTE: uses dcc.getHandler() as its Handler) |
| private DataConnection(PhoneBase phone, String name, int id, |
| DcTrackerBase dct, DcTesterFailBringUpAll failBringUpAll, |
| DcController dcc) { |
| super(name, dcc.getHandler()); |
| setLogRecSize(300); |
| setLogOnlyTransitions(true); |
| if (DBG) log("DataConnection constructor E"); |
| |
| mPhone = phone; |
| mDct = dct; |
| mDcTesterFailBringUpAll = failBringUpAll; |
| mDcController = dcc; |
| mId = id; |
| mCid = -1; |
| mDcRetryAlarmController = new DcRetryAlarmController(mPhone, this); |
| ServiceState ss = mPhone.getServiceState(); |
| mRilRat = ss.getRilDataRadioTechnology(); |
| mDataRegState = mPhone.getServiceState().getDataRegState(); |
| int networkType = ss.getDataNetworkType(); |
| mNetworkInfo = new NetworkInfo(ConnectivityManager.TYPE_MOBILE, |
| networkType, NETWORK_TYPE, TelephonyManager.getNetworkTypeName(networkType)); |
| mNetworkInfo.setRoaming(ss.getDataRoaming()); |
| mNetworkInfo.setIsAvailable(true); |
| |
| addState(mDefaultState); |
| addState(mInactiveState, mDefaultState); |
| addState(mActivatingState, mDefaultState); |
| addState(mRetryingState, mDefaultState); |
| addState(mActiveState, mDefaultState); |
| addState(mDisconnectingState, mDefaultState); |
| addState(mDisconnectingErrorCreatingConnection, mDefaultState); |
| setInitialState(mInactiveState); |
| |
| mApnContexts = new ArrayList<ApnContext>(); |
| if (DBG) log("DataConnection constructor X"); |
| } |
| |
| private String getRetryConfig(boolean forDefault) { |
| int nt = mPhone.getServiceState().getNetworkType(); |
| |
| if (Build.IS_DEBUGGABLE) { |
| String config = SystemProperties.get("test.data_retry_config"); |
| if (! TextUtils.isEmpty(config)) { |
| return config; |
| } |
| } |
| |
| if ((nt == TelephonyManager.NETWORK_TYPE_CDMA) || |
| (nt == TelephonyManager.NETWORK_TYPE_1xRTT) || |
| (nt == TelephonyManager.NETWORK_TYPE_EVDO_0) || |
| (nt == TelephonyManager.NETWORK_TYPE_EVDO_A) || |
| (nt == TelephonyManager.NETWORK_TYPE_EVDO_B) || |
| (nt == TelephonyManager.NETWORK_TYPE_EHRPD)) { |
| // CDMA variant |
| return SystemProperties.get("ro.cdma.data_retry_config"); |
| } else { |
| // Use GSM variant for all others. |
| if (forDefault) { |
| return SystemProperties.get("ro.gsm.data_retry_config"); |
| } else { |
| return SystemProperties.get("ro.gsm.2nd_data_retry_config"); |
| } |
| } |
| } |
| |
| private void configureRetry(boolean forDefault) { |
| String retryConfig = getRetryConfig(forDefault); |
| |
| if (!mRetryManager.configure(retryConfig)) { |
| if (forDefault) { |
| if (!mRetryManager.configure(DEFAULT_DATA_RETRY_CONFIG)) { |
| // Should never happen, log an error and default to a simple linear sequence. |
| loge("configureRetry: Could not configure using " + |
| "DEFAULT_DATA_RETRY_CONFIG=" + DEFAULT_DATA_RETRY_CONFIG); |
| mRetryManager.configure(5, 2000, 1000); |
| } |
| } else { |
| if (!mRetryManager.configure(SECONDARY_DATA_RETRY_CONFIG)) { |
| // Should never happen, log an error and default to a simple sequence. |
| loge("configureRetry: Could note configure using " + |
| "SECONDARY_DATA_RETRY_CONFIG=" + SECONDARY_DATA_RETRY_CONFIG); |
| mRetryManager.configure(5, 2000, 1000); |
| } |
| } |
| } |
| if (DBG) { |
| log("configureRetry: forDefault=" + forDefault + " mRetryManager=" + mRetryManager); |
| } |
| } |
| |
| /** |
| * Begin setting up a data connection, calls setupDataCall |
| * and the ConnectionParams will be returned with the |
| * EVENT_SETUP_DATA_CONNECTION_DONE AsyncResul.userObj. |
| * |
| * @param cp is the connection parameters |
| */ |
| private void onConnect(ConnectionParams cp) { |
| if (DBG) log("onConnect: carrier='" + mApnSetting.carrier |
| + "' APN='" + mApnSetting.apn |
| + "' proxy='" + mApnSetting.proxy + "' port='" + mApnSetting.port + "'"); |
| |
| // Check if we should fake an error. |
| if (mDcTesterFailBringUpAll.getDcFailBringUp().mCounter > 0) { |
| DataCallResponse response = new DataCallResponse(); |
| response.version = mPhone.mCi.getRilVersion(); |
| response.status = mDcTesterFailBringUpAll.getDcFailBringUp().mFailCause.getErrorCode(); |
| response.cid = 0; |
| response.active = 0; |
| response.type = ""; |
| response.ifname = ""; |
| response.addresses = new String[0]; |
| response.dnses = new String[0]; |
| response.gateways = new String[0]; |
| response.suggestedRetryTime = |
| mDcTesterFailBringUpAll.getDcFailBringUp().mSuggestedRetryTime; |
| response.pcscf = new String[0]; |
| response.mtu = PhoneConstants.UNSET_MTU; |
| |
| Message msg = obtainMessage(EVENT_SETUP_DATA_CONNECTION_DONE, cp); |
| AsyncResult.forMessage(msg, response, null); |
| sendMessage(msg); |
| if (DBG) { |
| log("onConnect: FailBringUpAll=" + mDcTesterFailBringUpAll.getDcFailBringUp() |
| + " send error response=" + response); |
| } |
| mDcTesterFailBringUpAll.getDcFailBringUp().mCounter -= 1; |
| return; |
| } |
| |
| mCreateTime = -1; |
| mLastFailTime = -1; |
| mLastFailCause = DcFailCause.NONE; |
| |
| // msg.obj will be returned in AsyncResult.userObj; |
| Message msg = obtainMessage(EVENT_SETUP_DATA_CONNECTION_DONE, cp); |
| msg.obj = cp; |
| |
| int authType = mApnSetting.authType; |
| if (authType == -1) { |
| authType = TextUtils.isEmpty(mApnSetting.user) ? RILConstants.SETUP_DATA_AUTH_NONE |
| : RILConstants.SETUP_DATA_AUTH_PAP_CHAP; |
| } |
| |
| String protocol; |
| if (mPhone.getServiceState().getDataRoaming()) { |
| protocol = mApnSetting.roamingProtocol; |
| } else { |
| protocol = mApnSetting.protocol; |
| } |
| |
| mPhone.mCi.setupDataCall( |
| Integer.toString(cp.mRilRat + 2), |
| Integer.toString(cp.mProfileId), |
| mApnSetting.apn, mApnSetting.user, mApnSetting.password, |
| Integer.toString(authType), |
| protocol, msg); |
| } |
| |
| /** |
| * TearDown the data connection when the deactivation is complete a Message with |
| * msg.what == EVENT_DEACTIVATE_DONE and msg.obj == AsyncResult with AsyncResult.obj |
| * containing the parameter o. |
| * |
| * @param o is the object returned in the AsyncResult.obj. |
| */ |
| private void tearDownData(Object o) { |
| int discReason = RILConstants.DEACTIVATE_REASON_NONE; |
| if ((o != null) && (o instanceof DisconnectParams)) { |
| DisconnectParams dp = (DisconnectParams)o; |
| |
| if (TextUtils.equals(dp.mReason, Phone.REASON_RADIO_TURNED_OFF)) { |
| discReason = RILConstants.DEACTIVATE_REASON_RADIO_OFF; |
| } else if (TextUtils.equals(dp.mReason, Phone.REASON_PDP_RESET)) { |
| discReason = RILConstants.DEACTIVATE_REASON_PDP_RESET; |
| } |
| } |
| if (mPhone.mCi.getRadioState().isOn()) { |
| if (DBG) log("tearDownData radio is on, call deactivateDataCall"); |
| mPhone.mCi.deactivateDataCall(mCid, discReason, |
| obtainMessage(EVENT_DEACTIVATE_DONE, mTag, 0, o)); |
| } else { |
| if (DBG) log("tearDownData radio is off sendMessage EVENT_DEACTIVATE_DONE immediately"); |
| AsyncResult ar = new AsyncResult(o, null, null); |
| sendMessage(obtainMessage(EVENT_DEACTIVATE_DONE, mTag, 0, ar)); |
| } |
| } |
| |
| private void notifyAllWithEvent(ApnContext alreadySent, int event, String reason) { |
| mNetworkInfo.setDetailedState(mNetworkInfo.getDetailedState(), reason, |
| mNetworkInfo.getExtraInfo()); |
| for (ApnContext apnContext : mApnContexts) { |
| if (apnContext == alreadySent) continue; |
| if (reason != null) apnContext.setReason(reason); |
| Message msg = mDct.obtainMessage(event, apnContext); |
| AsyncResult.forMessage(msg); |
| msg.sendToTarget(); |
| } |
| } |
| |
| private void notifyAllOfConnected(String reason) { |
| notifyAllWithEvent(null, DctConstants.EVENT_DATA_SETUP_COMPLETE, reason); |
| } |
| |
| private void notifyAllOfDisconnectDcRetrying(String reason) { |
| notifyAllWithEvent(null, DctConstants.EVENT_DISCONNECT_DC_RETRYING, reason); |
| } |
| private void notifyAllDisconnectCompleted(DcFailCause cause) { |
| notifyAllWithEvent(null, DctConstants.EVENT_DISCONNECT_DONE, cause.toString()); |
| } |
| |
| |
| /** |
| * Send the connectionCompletedMsg. |
| * |
| * @param cp is the ConnectionParams |
| * @param cause and if no error the cause is DcFailCause.NONE |
| * @param sendAll is true if all contexts are to be notified |
| */ |
| private void notifyConnectCompleted(ConnectionParams cp, DcFailCause cause, boolean sendAll) { |
| ApnContext alreadySent = null; |
| |
| if (cp != null && cp.mOnCompletedMsg != null) { |
| // Get the completed message but only use it once |
| Message connectionCompletedMsg = cp.mOnCompletedMsg; |
| cp.mOnCompletedMsg = null; |
| if (connectionCompletedMsg.obj instanceof ApnContext) { |
| alreadySent = (ApnContext)connectionCompletedMsg.obj; |
| } |
| |
| long timeStamp = System.currentTimeMillis(); |
| connectionCompletedMsg.arg1 = mCid; |
| |
| if (cause == DcFailCause.NONE) { |
| mCreateTime = timeStamp; |
| AsyncResult.forMessage(connectionCompletedMsg); |
| } else { |
| mLastFailCause = cause; |
| mLastFailTime = timeStamp; |
| |
| // Return message with a Throwable exception to signify an error. |
| if (cause == null) cause = DcFailCause.UNKNOWN; |
| AsyncResult.forMessage(connectionCompletedMsg, cause, |
| new Throwable(cause.toString())); |
| } |
| if (DBG) { |
| log("notifyConnectCompleted at " + timeStamp + " cause=" + cause |
| + " connectionCompletedMsg=" + msgToString(connectionCompletedMsg)); |
| } |
| |
| connectionCompletedMsg.sendToTarget(); |
| } |
| if (sendAll) { |
| notifyAllWithEvent(alreadySent, DctConstants.EVENT_DATA_SETUP_COMPLETE_ERROR, |
| cause.toString()); |
| } |
| } |
| |
| /** |
| * Send ar.userObj if its a message, which is should be back to originator. |
| * |
| * @param dp is the DisconnectParams. |
| */ |
| private void notifyDisconnectCompleted(DisconnectParams dp, boolean sendAll) { |
| if (VDBG) log("NotifyDisconnectCompleted"); |
| |
| ApnContext alreadySent = null; |
| String reason = null; |
| |
| if (dp != null && dp.mOnCompletedMsg != null) { |
| // Get the completed message but only use it once |
| Message msg = dp.mOnCompletedMsg; |
| dp.mOnCompletedMsg = null; |
| if (msg.obj instanceof ApnContext) { |
| alreadySent = (ApnContext)msg.obj; |
| } |
| reason = dp.mReason; |
| if (VDBG) { |
| log(String.format("msg=%s msg.obj=%s", msg.toString(), |
| ((msg.obj instanceof String) ? (String) msg.obj : "<no-reason>"))); |
| } |
| AsyncResult.forMessage(msg); |
| msg.sendToTarget(); |
| } |
| if (sendAll) { |
| if (reason == null) { |
| reason = DcFailCause.UNKNOWN.toString(); |
| } |
| notifyAllWithEvent(alreadySent, DctConstants.EVENT_DISCONNECT_DONE, reason); |
| } |
| if (DBG) log("NotifyDisconnectCompleted DisconnectParams=" + dp); |
| } |
| |
| /* |
| * ************************************************************************** |
| * Begin Members and methods owned by DataConnectionTracker but stored |
| * in a DataConnection because there is one per connection. |
| * ************************************************************************** |
| */ |
| |
| /* |
| * The id is owned by DataConnectionTracker. |
| */ |
| private int mId; |
| |
| /** |
| * Get the DataConnection ID |
| */ |
| public int getDataConnectionId() { |
| return mId; |
| } |
| |
| /* |
| * ************************************************************************** |
| * End members owned by DataConnectionTracker |
| * ************************************************************************** |
| */ |
| |
| /** |
| * Clear all settings called when entering mInactiveState. |
| */ |
| private void clearSettings() { |
| if (DBG) log("clearSettings"); |
| |
| mCreateTime = -1; |
| mLastFailTime = -1; |
| mLastFailCause = DcFailCause.NONE; |
| mCid = -1; |
| |
| mPcscfAddr = new String[5]; |
| |
| mLinkProperties = new LinkProperties(); |
| mApnContexts.clear(); |
| mApnSetting = null; |
| mDcFailCause = null; |
| } |
| |
| /** |
| * Process setup completion. |
| * |
| * @param ar is the result |
| * @return SetupResult. |
| */ |
| private DataCallResponse.SetupResult onSetupConnectionCompleted(AsyncResult ar) { |
| DataCallResponse response = (DataCallResponse) ar.result; |
| ConnectionParams cp = (ConnectionParams) ar.userObj; |
| DataCallResponse.SetupResult result; |
| |
| if (cp.mTag != mTag) { |
| if (DBG) { |
| log("onSetupConnectionCompleted stale cp.tag=" + cp.mTag + ", mtag=" + mTag); |
| } |
| result = DataCallResponse.SetupResult.ERR_Stale; |
| } else if (ar.exception != null) { |
| if (DBG) { |
| log("onSetupConnectionCompleted failed, ar.exception=" + ar.exception + |
| " response=" + response); |
| } |
| |
| if (ar.exception instanceof CommandException |
| && ((CommandException) (ar.exception)).getCommandError() |
| == CommandException.Error.RADIO_NOT_AVAILABLE) { |
| result = DataCallResponse.SetupResult.ERR_BadCommand; |
| result.mFailCause = DcFailCause.RADIO_NOT_AVAILABLE; |
| } else if ((response == null) || (response.version < 4)) { |
| result = DataCallResponse.SetupResult.ERR_GetLastErrorFromRil; |
| } else { |
| result = DataCallResponse.SetupResult.ERR_RilError; |
| result.mFailCause = DcFailCause.fromInt(response.status); |
| } |
| } else if (response.status != 0) { |
| result = DataCallResponse.SetupResult.ERR_RilError; |
| result.mFailCause = DcFailCause.fromInt(response.status); |
| } else { |
| if (DBG) log("onSetupConnectionCompleted received DataCallResponse: " + response); |
| mCid = response.cid; |
| |
| mPcscfAddr = response.pcscf; |
| |
| result = updateLinkProperty(response).setupResult; |
| } |
| |
| return result; |
| } |
| |
| private boolean isDnsOk(String[] domainNameServers) { |
| if (NULL_IP.equals(domainNameServers[0]) && NULL_IP.equals(domainNameServers[1]) |
| && !mPhone.isDnsCheckDisabled()) { |
| // Work around a race condition where QMI does not fill in DNS: |
| // Deactivate PDP and let DataConnectionTracker retry. |
| // Do not apply the race condition workaround for MMS APN |
| // if Proxy is an IP-address. |
| // Otherwise, the default APN will not be restored anymore. |
| if (!mApnSetting.types[0].equals(PhoneConstants.APN_TYPE_MMS) |
| || !isIpAddress(mApnSetting.mmsProxy)) { |
| log(String.format( |
| "isDnsOk: return false apn.types[0]=%s APN_TYPE_MMS=%s isIpAddress(%s)=%s", |
| mApnSetting.types[0], PhoneConstants.APN_TYPE_MMS, mApnSetting.mmsProxy, |
| isIpAddress(mApnSetting.mmsProxy))); |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| private static final String TCP_BUFFER_SIZES_GPRS = "4092,8760,48000,4096,8760,48000"; |
| private static final String TCP_BUFFER_SIZES_EDGE = "4093,26280,70800,4096,16384,70800"; |
| private static final String TCP_BUFFER_SIZES_UMTS = "58254,349525,1048576,58254,349525,1048576"; |
| private static final String TCP_BUFFER_SIZES_1XRTT= "16384,32768,131072,4096,16384,102400"; |
| private static final String TCP_BUFFER_SIZES_EVDO = "4094,87380,262144,4096,16384,262144"; |
| private static final String TCP_BUFFER_SIZES_EHRPD= "131072,262144,1048576,4096,16384,524288"; |
| private static final String TCP_BUFFER_SIZES_HSDPA= "61167,367002,1101005,8738,52429,262114"; |
| private static final String TCP_BUFFER_SIZES_HSPA = "40778,244668,734003,16777,100663,301990"; |
| private static final String TCP_BUFFER_SIZES_LTE = |
| "524288,1048576,2097152,262144,524288,1048576"; |
| private static final String TCP_BUFFER_SIZES_HSPAP= "122334,734003,2202010,32040,192239,576717"; |
| |
| private void updateTcpBufferSizes(int rilRat) { |
| String sizes = null; |
| String ratName = ServiceState.rilRadioTechnologyToString(rilRat).toLowerCase(Locale.ROOT); |
| // ServiceState gives slightly different names for EVDO tech ("evdo-rev.0" for ex) |
| // - patch it up: |
| if (rilRat == ServiceState.RIL_RADIO_TECHNOLOGY_EVDO_0 || |
| rilRat == ServiceState.RIL_RADIO_TECHNOLOGY_EVDO_A || |
| rilRat == ServiceState.RIL_RADIO_TECHNOLOGY_EVDO_B) { |
| ratName = "evdo"; |
| } |
| |
| // in the form: "ratname:rmem_min,rmem_def,rmem_max,wmem_min,wmem_def,wmem_max" |
| String[] configOverride = mPhone.getContext().getResources().getStringArray( |
| com.android.internal.R.array.config_mobile_tcp_buffers); |
| for (int i = 0; i < configOverride.length; i++) { |
| String[] split = configOverride[i].split(":"); |
| if (ratName.equals(split[0]) && split.length == 2) { |
| sizes = split[1]; |
| break; |
| } |
| } |
| |
| if (sizes == null) { |
| // no override - use telephony defaults |
| // doing it this way allows device or carrier to just override the types they |
| // care about and inherit the defaults for the others. |
| switch (rilRat) { |
| case ServiceState.RIL_RADIO_TECHNOLOGY_GPRS: |
| sizes = TCP_BUFFER_SIZES_GPRS; |
| break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_EDGE: |
| sizes = TCP_BUFFER_SIZES_EDGE; |
| break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_UMTS: |
| sizes = TCP_BUFFER_SIZES_UMTS; |
| break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_1xRTT: |
| sizes = TCP_BUFFER_SIZES_1XRTT; |
| break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_EVDO_0: |
| case ServiceState.RIL_RADIO_TECHNOLOGY_EVDO_A: |
| case ServiceState.RIL_RADIO_TECHNOLOGY_EVDO_B: |
| sizes = TCP_BUFFER_SIZES_EVDO; |
| break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_EHRPD: |
| sizes = TCP_BUFFER_SIZES_EHRPD; |
| break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_HSDPA: |
| sizes = TCP_BUFFER_SIZES_HSDPA; |
| break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_HSPA: |
| case ServiceState.RIL_RADIO_TECHNOLOGY_HSUPA: |
| sizes = TCP_BUFFER_SIZES_HSPA; |
| break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_LTE: |
| sizes = TCP_BUFFER_SIZES_LTE; |
| break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_HSPAP: |
| sizes = TCP_BUFFER_SIZES_HSPAP; |
| break; |
| default: |
| // Leave empty - this will let ConnectivityService use the system default. |
| break; |
| } |
| } |
| mLinkProperties.setTcpBufferSizes(sizes); |
| } |
| |
| private NetworkCapabilities makeNetworkCapabilities() { |
| NetworkCapabilities result = new NetworkCapabilities(); |
| result.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR); |
| |
| if (mApnSetting != null) { |
| for (String type : mApnSetting.types) { |
| switch (type) { |
| case PhoneConstants.APN_TYPE_ALL: { |
| result.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); |
| result.addCapability(NetworkCapabilities.NET_CAPABILITY_MMS); |
| result.addCapability(NetworkCapabilities.NET_CAPABILITY_SUPL); |
| result.addCapability(NetworkCapabilities.NET_CAPABILITY_FOTA); |
| result.addCapability(NetworkCapabilities.NET_CAPABILITY_IMS); |
| result.addCapability(NetworkCapabilities.NET_CAPABILITY_CBS); |
| result.addCapability(NetworkCapabilities.NET_CAPABILITY_IA); |
| break; |
| } |
| case PhoneConstants.APN_TYPE_DEFAULT: { |
| result.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET); |
| break; |
| } |
| case PhoneConstants.APN_TYPE_MMS: { |
| result.addCapability(NetworkCapabilities.NET_CAPABILITY_MMS); |
| break; |
| } |
| case PhoneConstants.APN_TYPE_SUPL: { |
| result.addCapability(NetworkCapabilities.NET_CAPABILITY_SUPL); |
| break; |
| } |
| case PhoneConstants.APN_TYPE_DUN: { |
| ApnSetting securedDunApn = mDct.fetchDunApn(); |
| if (securedDunApn == null || securedDunApn.equals(mApnSetting)) { |
| result.addCapability(NetworkCapabilities.NET_CAPABILITY_DUN); |
| } |
| break; |
| } |
| case PhoneConstants.APN_TYPE_FOTA: { |
| result.addCapability(NetworkCapabilities.NET_CAPABILITY_FOTA); |
| break; |
| } |
| case PhoneConstants.APN_TYPE_IMS: { |
| result.addCapability(NetworkCapabilities.NET_CAPABILITY_IMS); |
| break; |
| } |
| case PhoneConstants.APN_TYPE_CBS: { |
| result.addCapability(NetworkCapabilities.NET_CAPABILITY_CBS); |
| break; |
| } |
| case PhoneConstants.APN_TYPE_IA: { |
| result.addCapability(NetworkCapabilities.NET_CAPABILITY_IA); |
| break; |
| } |
| default: |
| } |
| } |
| ConnectivityManager.maybeMarkCapabilitiesRestricted(result); |
| } |
| int up = 14; |
| int down = 14; |
| switch (mRilRat) { |
| case ServiceState.RIL_RADIO_TECHNOLOGY_GPRS: up = 80; down = 80; break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_EDGE: up = 59; down = 236; break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_UMTS: up = 384; down = 384; break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_IS95A: // fall through |
| case ServiceState.RIL_RADIO_TECHNOLOGY_IS95B: up = 14; down = 14; break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_EVDO_0: up = 153; down = 2457; break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_EVDO_A: up = 1843; down = 3174; break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_1xRTT: up = 100; down = 100; break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_HSDPA: up = 2048; down = 14336; break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_HSUPA: up = 5898; down = 14336; break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_HSPA: up = 5898; down = 14336; break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_EVDO_B: up = 1843; down = 5017; break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_LTE: up = 51200; down = 102400; break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_EHRPD: up = 153; down = 2516; break; |
| case ServiceState.RIL_RADIO_TECHNOLOGY_HSPAP: up = 11264; down = 43008; break; |
| default: |
| } |
| result.setLinkUpstreamBandwidthKbps(up); |
| result.setLinkDownstreamBandwidthKbps(down); |
| |
| result.setNetworkSpecifier(Integer.toString(mPhone.getSubId())); |
| |
| return result; |
| } |
| |
| private boolean isIpAddress(String address) { |
| if (address == null) return false; |
| |
| return Patterns.IP_ADDRESS.matcher(address).matches(); |
| } |
| |
| private DataCallResponse.SetupResult setLinkProperties(DataCallResponse response, |
| LinkProperties lp) { |
| // Check if system property dns usable |
| boolean okToUseSystemPropertyDns = false; |
| String propertyPrefix = "net." + response.ifname + "."; |
| String dnsServers[] = new String[2]; |
| dnsServers[0] = SystemProperties.get(propertyPrefix + "dns1"); |
| dnsServers[1] = SystemProperties.get(propertyPrefix + "dns2"); |
| okToUseSystemPropertyDns = isDnsOk(dnsServers); |
| |
| // set link properties based on data call response |
| return response.setLinkProperties(lp, okToUseSystemPropertyDns); |
| } |
| |
| /** |
| * Initialize connection, this will fail if the |
| * apnSettings are not compatible. |
| * |
| * @param cp the Connection paramemters |
| * @return true if initialization was successful. |
| */ |
| private boolean initConnection(ConnectionParams cp) { |
| ApnContext apnContext = cp.mApnContext; |
| if (mApnSetting == null) { |
| // Only change apn setting if it isn't set, it will |
| // only NOT be set only if we're in DcInactiveState. |
| mApnSetting = apnContext.getApnSetting(); |
| } |
| if (mApnSetting == null || !mApnSetting.canHandleType(apnContext.getApnType())) { |
| if (DBG) { |
| log("initConnection: incompatible apnSetting in ConnectionParams cp=" + cp |
| + " dc=" + DataConnection.this); |
| } |
| return false; |
| } |
| mTag += 1; |
| mConnectionParams = cp; |
| mConnectionParams.mTag = mTag; |
| |
| if (!mApnContexts.contains(apnContext)) { |
| mApnContexts.add(apnContext); |
| } |
| configureRetry(mApnSetting.canHandleType(PhoneConstants.APN_TYPE_DEFAULT)); |
| mRetryManager.setRetryCount(0); |
| mRetryManager.setCurMaxRetryCount(mConnectionParams.mInitialMaxRetry); |
| mRetryManager.setRetryForever(false); |
| |
| if (DBG) { |
| log("initConnection: " |
| + " RefCount=" + mApnContexts.size() |
| + " mApnList=" + mApnContexts |
| + " mConnectionParams=" + mConnectionParams); |
| } |
| return true; |
| } |
| |
| /** |
| * The parent state for all other states. |
| */ |
| private class DcDefaultState extends State { |
| @Override |
| public void enter() { |
| if (DBG) log("DcDefaultState: enter"); |
| |
| // Register for DRS or RAT change |
| mPhone.getServiceStateTracker().registerForDataRegStateOrRatChanged(getHandler(), |
| DataConnection.EVENT_DATA_CONNECTION_DRS_OR_RAT_CHANGED, null); |
| |
| mPhone.getServiceStateTracker().registerForDataRoamingOn(getHandler(), |
| DataConnection.EVENT_DATA_CONNECTION_ROAM_ON, null); |
| mPhone.getServiceStateTracker().registerForDataRoamingOff(getHandler(), |
| DataConnection.EVENT_DATA_CONNECTION_ROAM_OFF, null); |
| |
| // Add ourselves to the list of data connections |
| mDcController.addDc(DataConnection.this); |
| } |
| @Override |
| public void exit() { |
| if (DBG) log("DcDefaultState: exit"); |
| |
| // Unregister for DRS or RAT change. |
| mPhone.getServiceStateTracker().unregisterForDataRegStateOrRatChanged(getHandler()); |
| |
| mPhone.getServiceStateTracker().unregisterForDataRoamingOn(getHandler()); |
| mPhone.getServiceStateTracker().unregisterForDataRoamingOff(getHandler()); |
| |
| // Remove ourselves from the DC lists |
| mDcController.removeDc(DataConnection.this); |
| |
| if (mAc != null) { |
| mAc.disconnected(); |
| mAc = null; |
| } |
| mDcRetryAlarmController.dispose(); |
| mDcRetryAlarmController = null; |
| mApnContexts = null; |
| mReconnectIntent = null; |
| mDct = null; |
| mApnSetting = null; |
| mPhone = null; |
| mLinkProperties = null; |
| mLastFailCause = null; |
| mUserData = null; |
| mDcController = null; |
| mDcTesterFailBringUpAll = null; |
| } |
| |
| @Override |
| public boolean processMessage(Message msg) { |
| boolean retVal = HANDLED; |
| |
| if (VDBG) { |
| log("DcDefault msg=" + getWhatToString(msg.what) |
| + " RefCount=" + mApnContexts.size()); |
| } |
| switch (msg.what) { |
| case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION: { |
| if (mAc != null) { |
| if (VDBG) log("Disconnecting to previous connection mAc=" + mAc); |
| mAc.replyToMessage(msg, AsyncChannel.CMD_CHANNEL_FULLY_CONNECTED, |
| AsyncChannel.STATUS_FULL_CONNECTION_REFUSED_ALREADY_CONNECTED); |
| } else { |
| mAc = new AsyncChannel(); |
| mAc.connected(null, getHandler(), msg.replyTo); |
| if (VDBG) log("DcDefaultState: FULL_CONNECTION reply connected"); |
| mAc.replyToMessage(msg, AsyncChannel.CMD_CHANNEL_FULLY_CONNECTED, |
| AsyncChannel.STATUS_SUCCESSFUL, mId, "hi"); |
| } |
| break; |
| } |
| case AsyncChannel.CMD_CHANNEL_DISCONNECTED: { |
| if (DBG) { |
| log("DcDefault: CMD_CHANNEL_DISCONNECTED before quiting call dump"); |
| dumpToLog(); |
| } |
| |
| quit(); |
| break; |
| } |
| case DcAsyncChannel.REQ_IS_INACTIVE: { |
| boolean val = getIsInactive(); |
| if (VDBG) log("REQ_IS_INACTIVE isInactive=" + val); |
| mAc.replyToMessage(msg, DcAsyncChannel.RSP_IS_INACTIVE, val ? 1 : 0); |
| break; |
| } |
| case DcAsyncChannel.REQ_GET_CID: { |
| int cid = getCid(); |
| if (VDBG) log("REQ_GET_CID cid=" + cid); |
| mAc.replyToMessage(msg, DcAsyncChannel.RSP_GET_CID, cid); |
| break; |
| } |
| case DcAsyncChannel.REQ_GET_APNSETTING: { |
| ApnSetting apnSetting = getApnSetting(); |
| if (VDBG) log("REQ_GET_APNSETTING mApnSetting=" + apnSetting); |
| mAc.replyToMessage(msg, DcAsyncChannel.RSP_GET_APNSETTING, apnSetting); |
| break; |
| } |
| case DcAsyncChannel.REQ_GET_LINK_PROPERTIES: { |
| LinkProperties lp = getCopyLinkProperties(); |
| if (VDBG) log("REQ_GET_LINK_PROPERTIES linkProperties" + lp); |
| mAc.replyToMessage(msg, DcAsyncChannel.RSP_GET_LINK_PROPERTIES, lp); |
| break; |
| } |
| case DcAsyncChannel.REQ_SET_LINK_PROPERTIES_HTTP_PROXY: { |
| ProxyInfo proxy = (ProxyInfo) msg.obj; |
| if (VDBG) log("REQ_SET_LINK_PROPERTIES_HTTP_PROXY proxy=" + proxy); |
| setLinkPropertiesHttpProxy(proxy); |
| mAc.replyToMessage(msg, DcAsyncChannel.RSP_SET_LINK_PROPERTIES_HTTP_PROXY); |
| break; |
| } |
| case DcAsyncChannel.REQ_GET_NETWORK_CAPABILITIES: { |
| NetworkCapabilities nc = getCopyNetworkCapabilities(); |
| if (VDBG) log("REQ_GET_NETWORK_CAPABILITIES networkCapabilities" + nc); |
| mAc.replyToMessage(msg, DcAsyncChannel.RSP_GET_NETWORK_CAPABILITIES, nc); |
| break; |
| } |
| case DcAsyncChannel.REQ_RESET: |
| if (VDBG) log("DcDefaultState: msg.what=REQ_RESET"); |
| transitionTo(mInactiveState); |
| break; |
| case EVENT_CONNECT: |
| if (DBG) log("DcDefaultState: msg.what=EVENT_CONNECT, fail not expected"); |
| ConnectionParams cp = (ConnectionParams) msg.obj; |
| notifyConnectCompleted(cp, DcFailCause.UNKNOWN, false); |
| break; |
| |
| case EVENT_DISCONNECT: |
| if (DBG) { |
| log("DcDefaultState deferring msg.what=EVENT_DISCONNECT RefCount=" |
| + mApnContexts.size()); |
| } |
| deferMessage(msg); |
| break; |
| |
| case EVENT_DISCONNECT_ALL: |
| if (DBG) { |
| log("DcDefaultState deferring msg.what=EVENT_DISCONNECT_ALL RefCount=" |
| + mApnContexts.size()); |
| } |
| deferMessage(msg); |
| break; |
| |
| case EVENT_TEAR_DOWN_NOW: |
| if (DBG) log("DcDefaultState EVENT_TEAR_DOWN_NOW"); |
| mPhone.mCi.deactivateDataCall(mCid, 0, null); |
| break; |
| |
| case EVENT_LOST_CONNECTION: |
| if (DBG) { |
| String s = "DcDefaultState ignore EVENT_LOST_CONNECTION" |
| + " tag=" + msg.arg1 + ":mTag=" + mTag; |
| logAndAddLogRec(s); |
| } |
| break; |
| |
| case EVENT_RETRY_CONNECTION: |
| if (DBG) { |
| String s = "DcDefaultState ignore EVENT_RETRY_CONNECTION" |
| + " tag=" + msg.arg1 + ":mTag=" + mTag; |
| logAndAddLogRec(s); |
| } |
| break; |
| |
| case EVENT_DATA_CONNECTION_DRS_OR_RAT_CHANGED: |
| AsyncResult ar = (AsyncResult)msg.obj; |
| Pair<Integer, Integer> drsRatPair = (Pair<Integer, Integer>)ar.result; |
| mDataRegState = drsRatPair.first; |
| if (mRilRat != drsRatPair.second) { |
| updateTcpBufferSizes(drsRatPair.second); |
| } |
| mRilRat = drsRatPair.second; |
| if (DBG) { |
| log("DcDefaultState: EVENT_DATA_CONNECTION_DRS_OR_RAT_CHANGED" |
| + " drs=" + mDataRegState |
| + " mRilRat=" + mRilRat); |
| } |
| ServiceState ss = mPhone.getServiceState(); |
| int networkType = ss.getDataNetworkType(); |
| mNetworkInfo.setSubtype(networkType, |
| TelephonyManager.getNetworkTypeName(networkType)); |
| if (mNetworkAgent != null) { |
| mNetworkAgent.sendNetworkCapabilities(makeNetworkCapabilities()); |
| mNetworkAgent.sendNetworkInfo(mNetworkInfo); |
| mNetworkAgent.sendLinkProperties(mLinkProperties); |
| } |
| break; |
| |
| case EVENT_DATA_CONNECTION_ROAM_ON: |
| mNetworkInfo.setRoaming(true); |
| break; |
| |
| case EVENT_DATA_CONNECTION_ROAM_OFF: |
| mNetworkInfo.setRoaming(false); |
| break; |
| |
| default: |
| if (DBG) { |
| log("DcDefaultState: shouldn't happen but ignore msg.what=" |
| + getWhatToString(msg.what)); |
| } |
| break; |
| } |
| |
| return retVal; |
| } |
| } |
| private DcDefaultState mDefaultState = new DcDefaultState(); |
| |
| /** |
| * The state machine is inactive and expects a EVENT_CONNECT. |
| */ |
| private class DcInactiveState extends State { |
| // Inform all contexts we've failed connecting |
| public void setEnterNotificationParams(ConnectionParams cp, DcFailCause cause) { |
| if (VDBG) log("DcInactiveState: setEnterNoticationParams cp,cause"); |
| mConnectionParams = cp; |
| mDisconnectParams = null; |
| mDcFailCause = cause; |
| } |
| |
| // Inform all contexts we've failed disconnected |
| public void setEnterNotificationParams(DisconnectParams dp) { |
| if (VDBG) log("DcInactiveState: setEnterNoticationParams dp"); |
| mConnectionParams = null; |
| mDisconnectParams = dp; |
| mDcFailCause = DcFailCause.NONE; |
| } |
| |
| // Inform all contexts of the failure cause |
| public void setEnterNotificationParams(DcFailCause cause) { |
| mConnectionParams = null; |
| mDisconnectParams = null; |
| mDcFailCause = cause; |
| } |
| |
| @Override |
| public void enter() { |
| mTag += 1; |
| if (DBG) log("DcInactiveState: enter() mTag=" + mTag); |
| |
| if (mConnectionParams != null) { |
| if (DBG) { |
| log("DcInactiveState: enter notifyConnectCompleted +ALL failCause=" |
| + mDcFailCause); |
| } |
| notifyConnectCompleted(mConnectionParams, mDcFailCause, true); |
| } |
| if (mDisconnectParams != null) { |
| if (DBG) { |
| log("DcInactiveState: enter notifyDisconnectCompleted +ALL failCause=" |
| + mDcFailCause); |
| } |
| notifyDisconnectCompleted(mDisconnectParams, true); |
| } |
| if (mDisconnectParams == null && mConnectionParams == null && mDcFailCause != null) { |
| if (DBG) { |
| log("DcInactiveState: enter notifyAllDisconnectCompleted failCause=" |
| + mDcFailCause); |
| } |
| notifyAllDisconnectCompleted(mDcFailCause); |
| } |
| |
| // Remove ourselves from cid mapping, before clearSettings |
| mDcController.removeActiveDcByCid(DataConnection.this); |
| |
| clearSettings(); |
| } |
| |
| @Override |
| public void exit() { |
| } |
| |
| @Override |
| public boolean processMessage(Message msg) { |
| boolean retVal; |
| |
| switch (msg.what) { |
| case DcAsyncChannel.REQ_RESET: |
| if (DBG) { |
| log("DcInactiveState: msg.what=RSP_RESET, ignore we're already reset"); |
| } |
| retVal = HANDLED; |
| break; |
| |
| case EVENT_CONNECT: |
| if (DBG) log("DcInactiveState: mag.what=EVENT_CONNECT"); |
| ConnectionParams cp = (ConnectionParams) msg.obj; |
| if (initConnection(cp)) { |
| onConnect(mConnectionParams); |
| transitionTo(mActivatingState); |
| } else { |
| if (DBG) { |
| log("DcInactiveState: msg.what=EVENT_CONNECT initConnection failed"); |
| } |
| notifyConnectCompleted(cp, DcFailCause.UNACCEPTABLE_NETWORK_PARAMETER, |
| false); |
| } |
| retVal = HANDLED; |
| break; |
| |
| case EVENT_DISCONNECT: |
| if (DBG) log("DcInactiveState: msg.what=EVENT_DISCONNECT"); |
| notifyDisconnectCompleted((DisconnectParams)msg.obj, false); |
| retVal = HANDLED; |
| break; |
| |
| case EVENT_DISCONNECT_ALL: |
| if (DBG) log("DcInactiveState: msg.what=EVENT_DISCONNECT_ALL"); |
| notifyDisconnectCompleted((DisconnectParams)msg.obj, false); |
| retVal = HANDLED; |
| break; |
| |
| default: |
| if (VDBG) { |
| log("DcInactiveState nothandled msg.what=" + getWhatToString(msg.what)); |
| } |
| retVal = NOT_HANDLED; |
| break; |
| } |
| return retVal; |
| } |
| } |
| private DcInactiveState mInactiveState = new DcInactiveState(); |
| |
| /** |
| * The state machine is retrying and expects a EVENT_RETRY_CONNECTION. |
| */ |
| private class DcRetryingState extends State { |
| @Override |
| public void enter() { |
| if ((mConnectionParams.mRilRat != mRilRat) |
| || (mDataRegState != ServiceState.STATE_IN_SERVICE)){ |
| // RAT has changed or we're not in service so don't even begin retrying. |
| if (DBG) { |
| String s = "DcRetryingState: enter() not retrying rat changed" |
| + ", mConnectionParams.mRilRat=" + mConnectionParams.mRilRat |
| + " != mRilRat:" + mRilRat |
| + " transitionTo(mInactiveState)"; |
| logAndAddLogRec(s); |
| } |
| mInactiveState.setEnterNotificationParams(DcFailCause.LOST_CONNECTION); |
| transitionTo(mInactiveState); |
| } else { |
| if (DBG) { |
| log("DcRetryingState: enter() mTag=" + mTag |
| + ", call notifyAllOfDisconnectDcRetrying lostConnection"); |
| } |
| |
| notifyAllOfDisconnectDcRetrying(Phone.REASON_LOST_DATA_CONNECTION); |
| |
| // Remove ourselves from cid mapping |
| mDcController.removeActiveDcByCid(DataConnection.this); |
| mCid = -1; |
| } |
| } |
| |
| @Override |
| public boolean processMessage(Message msg) { |
| boolean retVal; |
| |
| switch (msg.what) { |
| case EVENT_DATA_CONNECTION_DRS_OR_RAT_CHANGED: |
| AsyncResult ar = (AsyncResult)msg.obj; |
| Pair<Integer, Integer> drsRatPair = (Pair<Integer, Integer>)ar.result; |
| int drs = drsRatPair.first; |
| int rat = drsRatPair.second; |
| if ((rat == mRilRat) && (drs == mDataRegState)) { |
| if (DBG) { |
| log("DcRetryingState: EVENT_DATA_CONNECTION_DRS_OR_RAT_CHANGED" |
| + " strange no change in drs=" + drs |
| + " rat=" + rat + " ignoring"); |
| } |
| } else { |
| // have to retry connecting since no attach event will come |
| if (mConnectionParams.mRetryWhenSSChange) { |
| retVal = NOT_HANDLED; |
| break; |
| } |
| // We've lost the connection and we're retrying but DRS or RAT changed |
| // so we may never succeed, might as well give up. |
| mInactiveState.setEnterNotificationParams(DcFailCause.LOST_CONNECTION); |
| deferMessage(msg); |
| transitionTo(mInactiveState); |
| |
| if (DBG) { |
| String s = "DcRetryingState: EVENT_DATA_CONNECTION_DRS_OR_RAT_CHANGED" |
| + " giving up changed from " + mRilRat |
| + " to rat=" + rat |
| + " or drs changed from " + mDataRegState + " to drs=" + drs; |
| logAndAddLogRec(s); |
| } |
| mDataRegState = drs; |
| mRilRat = rat; |
| // TODO - pass the other type here too? |
| ServiceState ss = mPhone.getServiceState(); |
| int networkType = ss.getDataNetworkType(); |
| mNetworkInfo.setSubtype(networkType, |
| TelephonyManager.getNetworkTypeName(networkType)); |
| } |
| retVal = HANDLED; |
| break; |
| |
| case EVENT_RETRY_CONNECTION: { |
| if (msg.arg1 == mTag) { |
| mRetryManager.increaseRetryCount(); |
| if (DBG) { |
| log("DcRetryingState EVENT_RETRY_CONNECTION" |
| + " RetryCount=" + mRetryManager.getRetryCount() |
| + " mConnectionParams=" + mConnectionParams); |
| } |
| onConnect(mConnectionParams); |
| transitionTo(mActivatingState); |
| } else { |
| if (DBG) { |
| log("DcRetryingState stale EVENT_RETRY_CONNECTION" |
| + " tag:" + msg.arg1 + " != mTag:" + mTag); |
| } |
| } |
| retVal = HANDLED; |
| break; |
| } |
| case DcAsyncChannel.REQ_RESET: { |
| if (DBG) { |
| log("DcRetryingState: msg.what=RSP_RESET, ignore we're already reset"); |
| } |
| mInactiveState.setEnterNotificationParams(mConnectionParams, |
| DcFailCause.RESET_BY_FRAMEWORK); |
| transitionTo(mInactiveState); |
| retVal = HANDLED; |
| break; |
| } |
| case EVENT_CONNECT: { |
| ConnectionParams cp = (ConnectionParams) msg.obj; |
| if (DBG) { |
| log("DcRetryingState: msg.what=EVENT_CONNECT" |
| + " RefCount=" + mApnContexts.size() + " cp=" + cp |
| + " mConnectionParams=" + mConnectionParams); |
| } |
| if (initConnection(cp)) { |
| onConnect(mConnectionParams); |
| transitionTo(mActivatingState); |
| } else { |
| if (DBG) { |
| log("DcRetryingState: msg.what=EVENT_CONNECT initConnection failed"); |
| } |
| notifyConnectCompleted(cp, DcFailCause.UNACCEPTABLE_NETWORK_PARAMETER, |
| false); |
| } |
| retVal = HANDLED; |
| break; |
| } |
| case EVENT_DISCONNECT: { |
| DisconnectParams dp = (DisconnectParams) msg.obj; |
| |
| if (mApnContexts.remove(dp.mApnContext) && mApnContexts.size() == 0) { |
| if (DBG) { |
| log("DcRetryingState msg.what=EVENT_DISCONNECT " + " RefCount=" |
| + mApnContexts.size() + " dp=" + dp); |
| } |
| mInactiveState.setEnterNotificationParams(dp); |
| transitionTo(mInactiveState); |
| } else { |
| if (DBG) log("DcRetryingState: msg.what=EVENT_DISCONNECT"); |
| notifyDisconnectCompleted(dp, false); |
| } |
| retVal = HANDLED; |
| break; |
| } |
| case EVENT_DISCONNECT_ALL: { |
| if (DBG) { |
| log("DcRetryingState msg.what=EVENT_DISCONNECT/DISCONNECT_ALL " |
| + "RefCount=" + mApnContexts.size()); |
| } |
| mInactiveState.setEnterNotificationParams(DcFailCause.LOST_CONNECTION); |
| transitionTo(mInactiveState); |
| retVal = HANDLED; |
| break; |
| } |
| default: { |
| if (VDBG) { |
| log("DcRetryingState nothandled msg.what=" + getWhatToString(msg.what)); |
| } |
| retVal = NOT_HANDLED; |
| break; |
| } |
| } |
| return retVal; |
| } |
| } |
| private DcRetryingState mRetryingState = new DcRetryingState(); |
| |
| /** |
| * The state machine is activating a connection. |
| */ |
| private class DcActivatingState extends State { |
| @Override |
| public boolean processMessage(Message msg) { |
| boolean retVal; |
| AsyncResult ar; |
| ConnectionParams cp; |
| |
| if (DBG) log("DcActivatingState: msg=" + msgToString(msg)); |
| switch (msg.what) { |
| case EVENT_DATA_CONNECTION_DRS_OR_RAT_CHANGED: |
| case EVENT_CONNECT: |
| // Activating can't process until we're done. |
| deferMessage(msg); |
| retVal = HANDLED; |
| break; |
| |
| case EVENT_SETUP_DATA_CONNECTION_DONE: |
| ar = (AsyncResult) msg.obj; |
| cp = (ConnectionParams) ar.userObj; |
| |
| DataCallResponse.SetupResult result = onSetupConnectionCompleted(ar); |
| if (result != DataCallResponse.SetupResult.ERR_Stale) { |
| if (mConnectionParams != cp) { |
| loge("DcActivatingState: WEIRD mConnectionsParams:"+ mConnectionParams |
| + " != cp:" + cp); |
| } |
| } |
| if (DBG) { |
| log("DcActivatingState onSetupConnectionCompleted result=" + result |
| + " dc=" + DataConnection.this); |
| } |
| switch (result) { |
| case SUCCESS: |
| // All is well |
| mDcFailCause = DcFailCause.NONE; |
| transitionTo(mActiveState); |
| break; |
| case ERR_BadCommand: |
| // Vendor ril rejected the command and didn't connect. |
| // Transition to inactive but send notifications after |
| // we've entered the mInactive state. |
| mInactiveState.setEnterNotificationParams(cp, result.mFailCause); |
| transitionTo(mInactiveState); |
| break; |
| case ERR_UnacceptableParameter: |
| // The addresses given from the RIL are bad |
| tearDownData(cp); |
| transitionTo(mDisconnectingErrorCreatingConnection); |
| break; |
| case ERR_GetLastErrorFromRil: |
| // Request failed and this is an old RIL |
| mPhone.mCi.getLastDataCallFailCause( |
| obtainMessage(EVENT_GET_LAST_FAIL_DONE, cp)); |
| break; |
| case ERR_RilError: |
| int delay = mDcRetryAlarmController.getSuggestedRetryTime( |
| DataConnection.this, ar); |
| if (DBG) { |
| log("DcActivatingState: ERR_RilError " |
| + " delay=" + delay |
| + " isRetryNeeded=" + mRetryManager.isRetryNeeded() |
| + " result=" + result |
| + " result.isRestartRadioFail=" + |
| result.mFailCause.isRestartRadioFail() |
| + " result.isPermanentFail=" + |
| mDct.isPermanentFail(result.mFailCause)); |
| } |
| if (result.mFailCause.isRestartRadioFail()) { |
| if (DBG) log("DcActivatingState: ERR_RilError restart radio"); |
| mDct.sendRestartRadio(); |
| mInactiveState.setEnterNotificationParams(cp, result.mFailCause); |
| transitionTo(mInactiveState); |
| } else if (mDct.isPermanentFail(result.mFailCause)) { |
| if (DBG) log("DcActivatingState: ERR_RilError perm error"); |
| mInactiveState.setEnterNotificationParams(cp, result.mFailCause); |
| transitionTo(mInactiveState); |
| } else if (delay >= 0) { |
| if (DBG) log("DcActivatingState: ERR_RilError retry"); |
| mDcRetryAlarmController.startRetryAlarm(EVENT_RETRY_CONNECTION, |
| mTag, delay); |
| transitionTo(mRetryingState); |
| } else { |
| if (DBG) log("DcActivatingState: ERR_RilError no retry"); |
| mInactiveState.setEnterNotificationParams(cp, result.mFailCause); |
| transitionTo(mInactiveState); |
| } |
| break; |
| case ERR_Stale: |
| loge("DcActivatingState: stale EVENT_SETUP_DATA_CONNECTION_DONE" |
| + " tag:" + cp.mTag + " != mTag:" + mTag); |
| break; |
| default: |
| throw new RuntimeException("Unknown SetupResult, should not happen"); |
| } |
| retVal = HANDLED; |
| break; |
| |
| case EVENT_GET_LAST_FAIL_DONE: |
| ar = (AsyncResult) msg.obj; |
| cp = (ConnectionParams) ar.userObj; |
| if (cp.mTag == mTag) { |
| if (mConnectionParams != cp) { |
| loge("DcActivatingState: WEIRD mConnectionsParams:" + mConnectionParams |
| + " != cp:" + cp); |
| } |
| |
| DcFailCause cause = DcFailCause.UNKNOWN; |
| |
| if (ar.exception == null) { |
| int rilFailCause = ((int[]) (ar.result))[0]; |
| cause = DcFailCause.fromInt(rilFailCause); |
| if (cause == DcFailCause.NONE) { |
| if (DBG) { |
| log("DcActivatingState msg.what=EVENT_GET_LAST_FAIL_DONE" |
| + " BAD: error was NONE, change to UNKNOWN"); |
| } |
| cause = DcFailCause.UNKNOWN; |
| } |
| } |
| mDcFailCause = cause; |
| |
| int retryDelay = mRetryManager.getRetryTimer(); |
| if (DBG) { |
| log("DcActivatingState msg.what=EVENT_GET_LAST_FAIL_DONE" |
| + " cause=" + cause |
| + " retryDelay=" + retryDelay |
| + " isRetryNeeded=" + mRetryManager.isRetryNeeded() |
| + " dc=" + DataConnection.this); |
| } |
| if (cause.isRestartRadioFail()) { |
| if (DBG) { |
| log("DcActivatingState: EVENT_GET_LAST_FAIL_DONE" |
| + " restart radio"); |
| } |
| mDct.sendRestartRadio(); |
| mInactiveState.setEnterNotificationParams(cp, cause); |
| transitionTo(mInactiveState); |
| } else if (mDct.isPermanentFail(cause)) { |
| if (DBG) log("DcActivatingState: EVENT_GET_LAST_FAIL_DONE perm er"); |
| mInactiveState.setEnterNotificationParams(cp, cause); |
| transitionTo(mInactiveState); |
| } else if ((retryDelay >= 0) && (mRetryManager.isRetryNeeded())) { |
| if (DBG) log("DcActivatingState: EVENT_GET_LAST_FAIL_DONE retry"); |
| mDcRetryAlarmController.startRetryAlarm(EVENT_RETRY_CONNECTION, mTag, |
| retryDelay); |
| transitionTo(mRetryingState); |
| } else { |
| if (DBG) log("DcActivatingState: EVENT_GET_LAST_FAIL_DONE no retry"); |
| mInactiveState.setEnterNotificationParams(cp, cause); |
| transitionTo(mInactiveState); |
| } |
| } else { |
| loge("DcActivatingState: stale EVENT_GET_LAST_FAIL_DONE" |
| + " tag:" + cp.mTag + " != mTag:" + mTag); |
| } |
| |
| retVal = HANDLED; |
| break; |
| |
| default: |
| if (VDBG) { |
| log("DcActivatingState not handled msg.what=" + |
| getWhatToString(msg.what) + " RefCount=" + mApnContexts.size()); |
| } |
| retVal = NOT_HANDLED; |
| break; |
| } |
| return retVal; |
| } |
| } |
| private DcActivatingState mActivatingState = new DcActivatingState(); |
| |
| /** |
| * The state machine is connected, expecting an EVENT_DISCONNECT. |
| */ |
| private class DcActiveState extends State { |
| @Override public void enter() { |
| if (DBG) log("DcActiveState: enter dc=" + DataConnection.this); |
| |
| if (mRetryManager.getRetryCount() != 0) { |
| log("DcActiveState: connected after retrying call notifyAllOfConnected"); |
| mRetryManager.setRetryCount(0); |
| } |
| // If we were retrying there maybe more than one, otherwise they'll only be one. |
| notifyAllOfConnected(Phone.REASON_CONNECTED); |
| |
| // If the EVENT_CONNECT set the current max retry restore it here |
| // if it didn't then this is effectively a NOP. |
| mRetryManager.restoreCurMaxRetryCount(); |
| mDcController.addActiveDcByCid(DataConnection.this); |
| |
| mNetworkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTED, |
| mNetworkInfo.getReason(), null); |
| mNetworkInfo.setExtraInfo(mApnSetting.apn); |
| updateTcpBufferSizes(mRilRat); |
| |
| final NetworkMisc misc = new NetworkMisc(); |
| misc.subscriberId = mPhone.getSubscriberId(); |
| mNetworkAgent = new DcNetworkAgent(getHandler().getLooper(), mPhone.getContext(), |
| "DcNetworkAgent", mNetworkInfo, makeNetworkCapabilities(), mLinkProperties, |
| 50, misc); |
| } |
| |
| @Override |
| public void exit() { |
| if (DBG) log("DcActiveState: exit dc=" + this); |
| mNetworkInfo.setDetailedState(NetworkInfo.DetailedState.DISCONNECTED, |
| mNetworkInfo.getReason(), mNetworkInfo.getExtraInfo()); |
| mNetworkAgent.sendNetworkInfo(mNetworkInfo); |
| mNetworkAgent = null; |
| } |
| |
| @Override |
| public boolean processMessage(Message msg) { |
| boolean retVal; |
| |
| switch (msg.what) { |
| case EVENT_CONNECT: { |
| ConnectionParams cp = (ConnectionParams) msg.obj; |
| if (DBG) { |
| log("DcActiveState: EVENT_CONNECT cp=" + cp + " dc=" + DataConnection.this); |
| } |
| if (mApnContexts.contains(cp.mApnContext)) { |
| log("DcActiveState ERROR already added apnContext=" + cp.mApnContext); |
| } else { |
| mApnContexts.add(cp.mApnContext); |
| if (DBG) { |
| log("DcActiveState msg.what=EVENT_CONNECT RefCount=" |
| + mApnContexts.size()); |
| } |
| } |
| notifyConnectCompleted(cp, DcFailCause.NONE, false); |
| retVal = HANDLED; |
| break; |
| } |
| case EVENT_DISCONNECT: { |
| DisconnectParams dp = (DisconnectParams) msg.obj; |
| if (DBG) { |
| log("DcActiveState: EVENT_DISCONNECT dp=" + dp |
| + " dc=" + DataConnection.this); |
| } |
| if (mApnContexts.contains(dp.mApnContext)) { |
| if (DBG) { |
| log("DcActiveState msg.what=EVENT_DISCONNECT RefCount=" |
| + mApnContexts.size()); |
| } |
| |
| if (mApnContexts.size() == 1) { |
| mApnContexts.clear(); |
| mDisconnectParams = dp; |
| mConnectionParams = null; |
| dp.mTag = mTag; |
| tearDownData(dp); |
| transitionTo(mDisconnectingState); |
| } else { |
| mApnContexts.remove(dp.mApnContext); |
| notifyDisconnectCompleted(dp, false); |
| } |
| } else { |
| log("DcActiveState ERROR no such apnContext=" + dp.mApnContext |
| + " in this dc=" + DataConnection.this); |
| notifyDisconnectCompleted(dp, false); |
| } |
| retVal = HANDLED; |
| break; |
| } |
| case EVENT_DISCONNECT_ALL: { |
| if (DBG) { |
| log("DcActiveState EVENT_DISCONNECT clearing apn contexts," |
| + " dc=" + DataConnection.this); |
| } |
| DisconnectParams dp = (DisconnectParams) msg.obj; |
| mDisconnectParams = dp; |
| mConnectionParams = null; |
| dp.mTag = mTag; |
| tearDownData(dp); |
| transitionTo(mDisconnectingState); |
| retVal = HANDLED; |
| break; |
| } |
| case EVENT_LOST_CONNECTION: { |
| if (DBG) { |
| log("DcActiveState EVENT_LOST_CONNECTION dc=" + DataConnection.this); |
| } |
| if (mRetryManager.isRetryNeeded()) { |
| // We're going to retry |
| int delayMillis = mRetryManager.getRetryTimer(); |
| if (DBG) { |
| log("DcActiveState EVENT_LOST_CONNECTION startRetryAlarm" |
| + " mTag=" + mTag + " delay=" + delayMillis + "ms"); |
| } |
| mDcRetryAlarmController.startRetryAlarm(EVENT_RETRY_CONNECTION, mTag, |
| delayMillis); |
| transitionTo(mRetryingState); |
| } else { |
| mInactiveState.setEnterNotificationParams(DcFailCause.LOST_CONNECTION); |
| transitionTo(mInactiveState); |
| } |
| retVal = HANDLED; |
| break; |
| } |
| case EVENT_DATA_CONNECTION_ROAM_ON: { |
| mNetworkInfo.setRoaming(true); |
| mNetworkAgent.sendNetworkInfo(mNetworkInfo); |
| retVal = HANDLED; |
| break; |
| } |
| case EVENT_DATA_CONNECTION_ROAM_OFF: { |
| mNetworkInfo.setRoaming(false); |
| mNetworkAgent.sendNetworkInfo(mNetworkInfo); |
| retVal = HANDLED; |
| break; |
| } |
| default: |
| if (VDBG) { |
| log("DcActiveState not handled msg.what=" + getWhatToString(msg.what)); |
| } |
| retVal = NOT_HANDLED; |
| break; |
| } |
| return retVal; |
| } |
| } |
| private DcActiveState mActiveState = new DcActiveState(); |
| |
| /** |
| * The state machine is disconnecting. |
| */ |
| private class DcDisconnectingState extends State { |
| @Override |
| public boolean processMessage(Message msg) { |
| boolean retVal; |
| |
| switch (msg.what) { |
| case EVENT_CONNECT: |
| if (DBG) log("DcDisconnectingState msg.what=EVENT_CONNECT. Defer. RefCount = " |
| + mApnContexts.size()); |
| deferMessage(msg); |
| retVal = HANDLED; |
| break; |
| |
| case EVENT_DEACTIVATE_DONE: |
| if (DBG) log("DcDisconnectingState msg.what=EVENT_DEACTIVATE_DONE RefCount=" |
| + mApnContexts.size()); |
| AsyncResult ar = (AsyncResult) msg.obj; |
| DisconnectParams dp = (DisconnectParams) ar.userObj; |
| if (dp.mTag == mTag) { |
| // Transition to inactive but send notifications after |
| // we've entered the mInactive state. |
| mInactiveState.setEnterNotificationParams((DisconnectParams) ar.userObj); |
| transitionTo(mInactiveState); |
| } else { |
| if (DBG) log("DcDisconnectState stale EVENT_DEACTIVATE_DONE" |
| + " dp.tag=" + dp.mTag + " mTag=" + mTag); |
| } |
| retVal = HANDLED; |
| break; |
| |
| default: |
| if (VDBG) { |
| log("DcDisconnectingState not handled msg.what=" |
| + getWhatToString(msg.what)); |
| } |
| retVal = NOT_HANDLED; |
| break; |
| } |
| return retVal; |
| } |
| } |
| private DcDisconnectingState mDisconnectingState = new DcDisconnectingState(); |
| |
| /** |
| * The state machine is disconnecting after an creating a connection. |
| */ |
| private class DcDisconnectionErrorCreatingConnection extends State { |
| @Override |
| public boolean processMessage(Message msg) { |
| boolean retVal; |
| |
| switch (msg.what) { |
| case EVENT_DEACTIVATE_DONE: |
| AsyncResult ar = (AsyncResult) msg.obj; |
| ConnectionParams cp = (ConnectionParams) ar.userObj; |
| if (cp.mTag == mTag) { |
| if (DBG) { |
| log("DcDisconnectionErrorCreatingConnection" + |
| " msg.what=EVENT_DEACTIVATE_DONE"); |
| } |
| |
| // Transition to inactive but send notifications after |
| // we've entered the mInactive state. |
| mInactiveState.setEnterNotificationParams(cp, |
| DcFailCause.UNACCEPTABLE_NETWORK_PARAMETER); |
| transitionTo(mInactiveState); |
| } else { |
| if (DBG) { |
| log("DcDisconnectionErrorCreatingConnection stale EVENT_DEACTIVATE_DONE" |
| + " dp.tag=" + cp.mTag + ", mTag=" + mTag); |
| } |
| } |
| retVal = HANDLED; |
| break; |
| |
| default: |
| if (VDBG) { |
| log("DcDisconnectionErrorCreatingConnection not handled msg.what=" |
| + getWhatToString(msg.what)); |
| } |
| retVal = NOT_HANDLED; |
| break; |
| } |
| return retVal; |
| } |
| } |
| private DcDisconnectionErrorCreatingConnection mDisconnectingErrorCreatingConnection = |
| new DcDisconnectionErrorCreatingConnection(); |
| |
| |
| private class DcNetworkAgent extends NetworkAgent { |
| public DcNetworkAgent(Looper l, Context c, String TAG, NetworkInfo ni, |
| NetworkCapabilities nc, LinkProperties lp, int score, NetworkMisc misc) { |
| super(l, c, TAG, ni, nc, lp, score, misc); |
| } |
| |
| @Override |
| protected void unwanted() { |
| if (mNetworkAgent != this) { |
| log("DcNetworkAgent: unwanted found mNetworkAgent=" + mNetworkAgent + |
| ", which isn't me. Aborting unwanted"); |
| return; |
| } |
| // this can only happen if our exit has been called - we're already disconnected |
| if (mApnContexts == null) return; |
| for (ApnContext apnContext : mApnContexts) { |
| log("DcNetworkAgent: [unwanted]: disconnect apnContext=" + apnContext); |
| Message msg = mDct.obtainMessage(DctConstants.EVENT_DISCONNECT_DONE, apnContext); |
| DisconnectParams dp = new DisconnectParams(apnContext, apnContext.getReason(), msg); |
| DataConnection.this.sendMessage(DataConnection.this. |
| obtainMessage(EVENT_DISCONNECT, dp)); |
| } |
| } |
| } |
| |
| // ******* "public" interface |
| |
| /** |
| * Used for testing purposes. |
| */ |
| /* package */ void tearDownNow() { |
| if (DBG) log("tearDownNow()"); |
| sendMessage(obtainMessage(EVENT_TEAR_DOWN_NOW)); |
| } |
| |
| /** |
| * @return the string for msg.what as our info. |
| */ |
| @Override |
| protected String getWhatToString(int what) { |
| return cmdToString(what); |
| } |
| |
| private static String msgToString(Message msg) { |
| String retVal; |
| if (msg == null) { |
| retVal = "null"; |
| } else { |
| StringBuilder b = new StringBuilder(); |
| |
| b.append("{what="); |
| b.append(cmdToString(msg.what)); |
| |
| b.append(" when="); |
| TimeUtils.formatDuration(msg.getWhen() - SystemClock.uptimeMillis(), b); |
| |
| if (msg.arg1 != 0) { |
| b.append(" arg1="); |
| b.append(msg.arg1); |
| } |
| |
| if (msg.arg2 != 0) { |
| b.append(" arg2="); |
| b.append(msg.arg2); |
| } |
| |
| if (msg.obj != null) { |
| b.append(" obj="); |
| b.append(msg.obj); |
| } |
| |
| b.append(" target="); |
| b.append(msg.getTarget()); |
| |
| b.append(" replyTo="); |
| b.append(msg.replyTo); |
| |
| b.append("}"); |
| |
| retVal = b.toString(); |
| } |
| return retVal; |
| } |
| |
| static void slog(String s) { |
| Rlog.d("DC", s); |
| } |
| |
| /** |
| * Log with debug |
| * |
| * @param s is string log |
| */ |
| @Override |
| protected void log(String s) { |
| Rlog.d(getName(), s); |
| } |
| |
| /** |
| * Log with debug attribute |
| * |
| * @param s is string log |
| */ |
| @Override |
| protected void logd(String s) { |
| Rlog.d(getName(), s); |
| } |
| |
| /** |
| * Log with verbose attribute |
| * |
| * @param s is string log |
| */ |
| @Override |
| protected void logv(String s) { |
| Rlog.v(getName(), s); |
| } |
| |
| /** |
| * Log with info attribute |
| * |
| * @param s is string log |
| */ |
| @Override |
| protected void logi(String s) { |
| Rlog.i(getName(), s); |
| } |
| |
| /** |
| * Log with warning attribute |
| * |
| * @param s is string log |
| */ |
| @Override |
| protected void logw(String s) { |
| Rlog.w(getName(), s); |
| } |
| |
| /** |
| * Log with error attribute |
| * |
| * @param s is string log |
| */ |
| @Override |
| protected void loge(String s) { |
| Rlog.e(getName(), s); |
| } |
| |
| /** |
| * Log with error attribute |
| * |
| * @param s is string log |
| * @param e is a Throwable which logs additional information. |
| */ |
| @Override |
| protected void loge(String s, Throwable e) { |
| Rlog.e(getName(), s, e); |
| } |
| |
| /** Doesn't print mApnList of ApnContext's which would be recursive */ |
| public String toStringSimple() { |
| return getName() + ": State=" + getCurrentState().getName() |
| + " mApnSetting=" + mApnSetting + " RefCount=" + mApnContexts.size() |
| + " mCid=" + mCid + " mCreateTime=" + mCreateTime |
| + " mLastastFailTime=" + mLastFailTime |
| + " mLastFailCause=" + mLastFailCause |
| + " mTag=" + mTag |
| + " mRetryManager=" + mRetryManager |
| + " mLinkProperties=" + mLinkProperties |
| + " linkCapabilities=" + makeNetworkCapabilities(); |
| } |
| |
| @Override |
| public String toString() { |
| return "{" + toStringSimple() + " mApnContexts=" + mApnContexts + "}"; |
| } |
| |
| private void dumpToLog() { |
| dump(null, new PrintWriter(new StringWriter(0)) { |
| @Override |
| public void println(String s) { |
| DataConnection.this.logd(s); |
| } |
| |
| @Override |
| public void flush() { |
| } |
| }, null); |
| } |
| |
| /** |
| * Dump the current state. |
| * |
| * @param fd |
| * @param pw |
| * @param args |
| */ |
| @Override |
| public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { |
| pw.print("DataConnection "); |
| super.dump(fd, pw, args); |
| pw.println(" mApnContexts.size=" + mApnContexts.size()); |
| pw.println(" mApnContexts=" + mApnContexts); |
| pw.flush(); |
| pw.println(" mDataConnectionTracker=" + mDct); |
| pw.println(" mApnSetting=" + mApnSetting); |
| pw.println(" mTag=" + mTag); |
| pw.println(" mCid=" + mCid); |
| pw.println(" mRetryManager=" + mRetryManager); |
| pw.println(" mConnectionParams=" + mConnectionParams); |
| pw.println(" mDisconnectParams=" + mDisconnectParams); |
| pw.println(" mDcFailCause=" + mDcFailCause); |
| pw.flush(); |
| pw.println(" mPhone=" + mPhone); |
| pw.flush(); |
| pw.println(" mLinkProperties=" + mLinkProperties); |
| pw.flush(); |
| pw.println(" mDataRegState=" + mDataRegState); |
| pw.println(" mRilRat=" + mRilRat); |
| pw.println(" mNetworkCapabilities=" + makeNetworkCapabilities()); |
| pw.println(" mCreateTime=" + TimeUtils.logTimeOfDay(mCreateTime)); |
| pw.println(" mLastFailTime=" + TimeUtils.logTimeOfDay(mLastFailTime)); |
| pw.println(" mLastFailCause=" + mLastFailCause); |
| pw.flush(); |
| pw.println(" mUserData=" + mUserData); |
| pw.println(" mInstanceNumber=" + mInstanceNumber); |
| pw.println(" mAc=" + mAc); |
| pw.println(" mDcRetryAlarmController=" + mDcRetryAlarmController); |
| pw.flush(); |
| } |
| } |
