| /* |
| * Copyright (C) 2013 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 android.annotation.IntDef; |
| import android.hardware.radio.V1_4.DataConnActiveStatus; |
| import android.net.LinkAddress; |
| import android.os.AsyncResult; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.RegistrantList; |
| import android.telephony.AccessNetworkConstants; |
| import android.telephony.DataFailCause; |
| import android.telephony.data.ApnSetting; |
| import android.telephony.data.DataCallResponse; |
| |
| import com.android.internal.annotations.VisibleForTesting; |
| import com.android.internal.telephony.DctConstants; |
| import com.android.internal.telephony.Phone; |
| import com.android.internal.telephony.dataconnection.DataConnection.UpdateLinkPropertyResult; |
| import com.android.internal.telephony.util.TelephonyUtils; |
| import com.android.net.module.util.LinkPropertiesUtils; |
| import com.android.net.module.util.LinkPropertiesUtils.CompareOrUpdateResult; |
| import com.android.net.module.util.NetUtils; |
| import com.android.telephony.Rlog; |
| |
| import java.io.FileDescriptor; |
| import java.io.PrintWriter; |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Objects; |
| |
| /** |
| * Data Connection Controller which is a package visible class and controls |
| * multiple data connections. For instance listening for unsolicited messages |
| * and then demultiplexing them to the appropriate DC. |
| */ |
| public class DcController extends Handler { |
| private static final boolean DBG = true; |
| private static final boolean VDBG = false; |
| |
| /** Physical link state unknown */ |
| public static final int PHYSICAL_LINK_UNKNOWN = 0; |
| |
| /** Physical link state inactive (i.e. RRC idle) */ |
| public static final int PHYSICAL_LINK_NOT_ACTIVE = 1; |
| |
| /** Physical link state active (i.e. RRC connected) */ |
| public static final int PHYSICAL_LINK_ACTIVE = 2; |
| |
| /** @hide */ |
| @IntDef(prefix = { "PHYSICAL_LINK_" }, value = { |
| PHYSICAL_LINK_UNKNOWN, |
| PHYSICAL_LINK_NOT_ACTIVE, |
| PHYSICAL_LINK_ACTIVE |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface PhysicalLinkState{} |
| |
| private final Phone mPhone; |
| private final DcTracker mDct; |
| private final String mTag; |
| private final DataServiceManager mDataServiceManager; |
| private final DcTesterDeactivateAll mDcTesterDeactivateAll; |
| |
| // package as its used by Testing code |
| // @GuardedBy("mDcListAll") |
| final ArrayList<DataConnection> mDcListAll = new ArrayList<>(); |
| // @GuardedBy("mDcListAll") |
| private final HashMap<Integer, DataConnection> mDcListActiveByCid = new HashMap<>(); |
| |
| /** |
| * Aggregated physical link state from all data connections. This reflects the device's RRC |
| * connection state. |
| * If {@link CarrierConfigManager.KEY_LTE_ENDC_USING_USER_DATA_FOR_RRC_DETECTION_BOOL} is true, |
| * then This reflects "internet data connection" instead of RRC state. |
| */ |
| private @PhysicalLinkState int mPhysicalLinkState = PHYSICAL_LINK_UNKNOWN; |
| |
| private RegistrantList mPhysicalLinkStateChangedRegistrants = new RegistrantList(); |
| |
| /** |
| * Constructor. |
| * |
| * @param name to be used for the Controller |
| * @param phone the phone associated with Dcc and Dct |
| * @param dct the DataConnectionTracker associated with Dcc |
| * @param dataServiceManager the data service manager that manages data services |
| * @param looper looper for this handler |
| */ |
| private DcController(String name, Phone phone, DcTracker dct, |
| DataServiceManager dataServiceManager, Looper looper) { |
| super(looper); |
| mPhone = phone; |
| mDct = dct; |
| mTag = name; |
| mDataServiceManager = dataServiceManager; |
| |
| mDcTesterDeactivateAll = (TelephonyUtils.IS_DEBUGGABLE) |
| ? new DcTesterDeactivateAll(mPhone, DcController.this, this) |
| : null; |
| mDataServiceManager.registerForDataCallListChanged(this, |
| DataConnection.EVENT_DATA_STATE_CHANGED); |
| } |
| |
| public static DcController makeDcc(Phone phone, DcTracker dct, |
| DataServiceManager dataServiceManager, Looper looper, |
| String tagSuffix) { |
| return new DcController("Dcc" + tagSuffix, phone, dct, dataServiceManager, looper); |
| } |
| |
| void addDc(DataConnection dc) { |
| synchronized (mDcListAll) { |
| mDcListAll.add(dc); |
| } |
| } |
| |
| void removeDc(DataConnection dc) { |
| synchronized (mDcListAll) { |
| mDcListActiveByCid.remove(dc.mCid); |
| mDcListAll.remove(dc); |
| } |
| } |
| |
| public void addActiveDcByCid(DataConnection dc) { |
| if (DBG && dc.mCid < 0) { |
| log("addActiveDcByCid dc.mCid < 0 dc=" + dc); |
| } |
| synchronized (mDcListAll) { |
| mDcListActiveByCid.put(dc.mCid, dc); |
| } |
| } |
| |
| DataConnection getActiveDcByCid(int cid) { |
| synchronized (mDcListAll) { |
| return mDcListActiveByCid.get(cid); |
| } |
| } |
| |
| void removeActiveDcByCid(DataConnection dc) { |
| synchronized (mDcListAll) { |
| DataConnection removedDc = mDcListActiveByCid.remove(dc.mCid); |
| if (DBG && removedDc == null) { |
| log("removeActiveDcByCid removedDc=null dc=" + dc); |
| } |
| } |
| } |
| |
| boolean isDefaultDataActive() { |
| synchronized (mDcListAll) { |
| return mDcListActiveByCid.values().stream() |
| .anyMatch(dc -> dc.getApnContexts().stream() |
| .anyMatch(apn -> apn.getApnTypeBitmask() == ApnSetting.TYPE_DEFAULT)); |
| } |
| } |
| |
| @Override |
| public void handleMessage(Message msg) { |
| AsyncResult ar; |
| |
| switch (msg.what) { |
| case DataConnection.EVENT_DATA_STATE_CHANGED: |
| ar = (AsyncResult) msg.obj; |
| if (ar.exception == null) { |
| onDataStateChanged((ArrayList<DataCallResponse>) ar.result); |
| } else { |
| log("EVENT_DATA_STATE_CHANGED: exception; likely radio not available, ignore"); |
| } |
| break; |
| default: |
| loge("Unexpected event " + msg); |
| break; |
| } |
| } |
| |
| /** |
| * Process the new list of "known" Data Calls |
| * @param dcsList as sent by RIL_UNSOL_DATA_CALL_LIST_CHANGED |
| */ |
| private void onDataStateChanged(ArrayList<DataCallResponse> dcsList) { |
| final HashMap<Integer, DataConnection> dcListActiveByCid; |
| synchronized (mDcListAll) { |
| dcListActiveByCid = new HashMap<>(mDcListActiveByCid); |
| } |
| |
| if (DBG) { |
| log("onDataStateChanged: dcsList=" + dcsList |
| + " dcListActiveByCid=" + dcListActiveByCid); |
| } |
| |
| // Create hashmap of cid to DataCallResponse |
| HashMap<Integer, DataCallResponse> dataCallResponseListByCid = |
| new HashMap<Integer, DataCallResponse>(); |
| for (DataCallResponse dcs : dcsList) { |
| dataCallResponseListByCid.put(dcs.getId(), dcs); |
| } |
| |
| // Add a DC that is active but not in the |
| // dcsList to the list of DC's to retry |
| ArrayList<DataConnection> dcsToRetry = new ArrayList<DataConnection>(); |
| for (DataConnection dc : dcListActiveByCid.values()) { |
| if (dataCallResponseListByCid.get(dc.mCid) == null) { |
| if (DBG) log("onDataStateChanged: add to retry dc=" + dc); |
| dcsToRetry.add(dc); |
| } |
| } |
| if (DBG) log("onDataStateChanged: dcsToRetry=" + dcsToRetry); |
| |
| // Find which connections have changed state and send a notification or cleanup |
| // and any that are in active need to be retried. |
| ArrayList<ApnContext> apnsToCleanup = new ArrayList<ApnContext>(); |
| |
| boolean isAnyDataCallDormant = false; |
| boolean isAnyDataCallActive = false; |
| boolean isInternetDataCallActive = false; |
| |
| for (DataCallResponse newState : dcsList) { |
| |
| DataConnection dc = dcListActiveByCid.get(newState.getId()); |
| if (dc == null) { |
| // UNSOL_DATA_CALL_LIST_CHANGED arrived before SETUP_DATA_CALL completed. |
| loge("onDataStateChanged: no associated DC yet, ignore"); |
| continue; |
| } |
| |
| List<ApnContext> apnContexts = dc.getApnContexts(); |
| if (apnContexts.size() == 0) { |
| if (DBG) loge("onDataStateChanged: no connected apns, ignore"); |
| } else { |
| // Determine if the connection/apnContext should be cleaned up |
| // or just a notification should be sent out. |
| if (DBG) { |
| log("onDataStateChanged: Found ConnId=" + newState.getId() |
| + " newState=" + newState.toString()); |
| } |
| if (apnContexts.stream().anyMatch( |
| i -> ApnSetting.TYPE_DEFAULT_STRING.equals(i.getApnType())) |
| && newState.getLinkStatus() == DataConnActiveStatus.ACTIVE) { |
| isInternetDataCallActive = true; |
| } |
| if (newState.getLinkStatus() == DataConnActiveStatus.INACTIVE) { |
| if (mDct.isCleanupRequired.get()) { |
| apnsToCleanup.addAll(apnContexts); |
| mDct.isCleanupRequired.set(false); |
| } else { |
| int failCause = DataFailCause.getFailCause(newState.getCause()); |
| if (DataFailCause.isRadioRestartFailure(mPhone.getContext(), failCause, |
| mPhone.getSubId())) { |
| if (DBG) { |
| log("onDataStateChanged: X restart radio, failCause=" |
| + failCause); |
| } |
| mDct.sendRestartRadio(); |
| } else if (mDct.isPermanentFailure(failCause)) { |
| if (DBG) { |
| log("onDataStateChanged: inactive, add to cleanup list. " |
| + "failCause=" + failCause); |
| } |
| apnsToCleanup.addAll(apnContexts); |
| } else { |
| if (DBG) { |
| log("onDataStateChanged: inactive, add to retry list. " |
| + "failCause=" + failCause); |
| } |
| dcsToRetry.add(dc); |
| } |
| } |
| } else { |
| // Update the pdu session id |
| dc.setPduSessionId(newState.getPduSessionId()); |
| |
| dc.updatePcscfAddr(newState); |
| |
| // Its active so update the DataConnections link properties |
| UpdateLinkPropertyResult result = dc.updateLinkProperty(newState); |
| dc.updateResponseFields(newState); |
| if (result.oldLp.equals(result.newLp)) { |
| if (DBG) log("onDataStateChanged: no change"); |
| } else { |
| if (LinkPropertiesUtils.isIdenticalInterfaceName( |
| result.oldLp, result.newLp)) { |
| if (!LinkPropertiesUtils.isIdenticalDnses( |
| result.oldLp, result.newLp) |
| || !LinkPropertiesUtils.isIdenticalRoutes( |
| result.oldLp, result.newLp) |
| || !LinkPropertiesUtils.isIdenticalHttpProxy( |
| result.oldLp, result.newLp) |
| || !LinkPropertiesUtils.isIdenticalAddresses( |
| result.oldLp, result.newLp)) { |
| // If the same address type was removed and |
| // added we need to cleanup |
| CompareOrUpdateResult<Integer, LinkAddress> car = |
| new CompareOrUpdateResult( |
| result.oldLp != null |
| ? result.oldLp.getLinkAddresses() : null, |
| result.newLp != null |
| ? result.newLp.getLinkAddresses() : null, |
| (la) -> Objects.hash(((LinkAddress) la) |
| .getAddress(), |
| ((LinkAddress) la).getPrefixLength(), |
| ((LinkAddress) la).getScope())); |
| if (DBG) { |
| log("onDataStateChanged: oldLp=" + result.oldLp |
| + " newLp=" + result.newLp + " car=" + car); |
| } |
| boolean needToClean = false; |
| for (LinkAddress added : car.added) { |
| for (LinkAddress removed : car.removed) { |
| if (NetUtils.addressTypeMatches( |
| removed.getAddress(), |
| added.getAddress())) { |
| needToClean = true; |
| break; |
| } |
| } |
| } |
| if (needToClean) { |
| if (DBG) { |
| log("onDataStateChanged: addr change," |
| + " cleanup apns=" + apnContexts |
| + " oldLp=" + result.oldLp |
| + " newLp=" + result.newLp); |
| } |
| apnsToCleanup.addAll(apnContexts); |
| } |
| } else { |
| if (DBG) { |
| log("onDataStateChanged: no changes"); |
| } |
| } |
| } else { |
| apnsToCleanup.addAll(apnContexts); |
| if (DBG) { |
| log("onDataStateChanged: interface change, cleanup apns=" |
| + apnContexts); |
| } |
| } |
| } |
| } |
| } |
| |
| if (newState.getLinkStatus() == DataConnActiveStatus.ACTIVE) { |
| isAnyDataCallActive = true; |
| } |
| if (newState.getLinkStatus() == DataConnActiveStatus.DORMANT) { |
| isAnyDataCallDormant = true; |
| } |
| } |
| |
| if (mDataServiceManager.getTransportType() |
| == AccessNetworkConstants.TRANSPORT_TYPE_WWAN) { |
| boolean isPhysicalLinkStateFocusingOnInternetData = |
| mDct.getLteEndcUsingUserDataForIdleDetection(); |
| int physicalLinkState = |
| (isPhysicalLinkStateFocusingOnInternetData |
| ? isInternetDataCallActive : isAnyDataCallActive) |
| ? PHYSICAL_LINK_ACTIVE : PHYSICAL_LINK_NOT_ACTIVE; |
| if (mPhysicalLinkState != physicalLinkState) { |
| mPhysicalLinkState = physicalLinkState; |
| mPhysicalLinkStateChangedRegistrants.notifyResult(mPhysicalLinkState); |
| } |
| if (isAnyDataCallDormant && !isAnyDataCallActive) { |
| // There is no way to indicate link activity per APN right now. So |
| // Link Activity will be considered dormant only when all data calls |
| // are dormant. |
| // If a single data call is in dormant state and none of the data |
| // calls are active broadcast overall link state as dormant. |
| if (DBG) { |
| log("onDataStateChanged: Data activity DORMANT. stopNetStatePoll"); |
| } |
| mDct.sendStopNetStatPoll(DctConstants.Activity.DORMANT); |
| } else { |
| if (DBG) { |
| log("onDataStateChanged: Data Activity updated to NONE. " |
| + "isAnyDataCallActive = " + isAnyDataCallActive |
| + " isAnyDataCallDormant = " + isAnyDataCallDormant); |
| } |
| if (isAnyDataCallActive) { |
| mDct.sendStartNetStatPoll(DctConstants.Activity.NONE); |
| } |
| } |
| } |
| |
| if (DBG) { |
| log("onDataStateChanged: dcsToRetry=" + dcsToRetry |
| + " apnsToCleanup=" + apnsToCleanup); |
| } |
| |
| // Cleanup connections that have changed |
| for (ApnContext apnContext : apnsToCleanup) { |
| mDct.cleanUpConnection(apnContext); |
| } |
| |
| // Retry connections that have disappeared |
| for (DataConnection dc : dcsToRetry) { |
| if (DBG) log("onDataStateChanged: send EVENT_LOST_CONNECTION dc.mTag=" + dc.mTag); |
| dc.sendMessage(DataConnection.EVENT_LOST_CONNECTION, dc.mTag); |
| } |
| |
| if (VDBG) log("onDataStateChanged: X"); |
| } |
| |
| /** |
| * Register for physical link state (i.e. RRC state) changed event. |
| * if {@link CarrierConfigManager.KEY_LTE_ENDC_USING_USER_DATA_FOR_RRC_DETECTION_BOOL} is true, |
| * then physical link state is focusing on "internet data connection" instead of RRC state. |
| * @param h The handler |
| * @param what The event |
| */ |
| @VisibleForTesting |
| public void registerForPhysicalLinkStateChanged(Handler h, int what) { |
| mPhysicalLinkStateChangedRegistrants.addUnique(h, what, null); |
| } |
| |
| /** |
| * Unregister from physical link state (i.e. RRC state) changed event. |
| * |
| * @param h The previously registered handler |
| */ |
| void unregisterForPhysicalLinkStateChanged(Handler h) { |
| mPhysicalLinkStateChangedRegistrants.remove(h); |
| } |
| |
| private void log(String s) { |
| Rlog.d(mTag, s); |
| } |
| |
| private void loge(String s) { |
| Rlog.e(mTag, s); |
| } |
| |
| @Override |
| public String toString() { |
| synchronized (mDcListAll) { |
| return "mDcListAll=" + mDcListAll + " mDcListActiveByCid=" + mDcListActiveByCid; |
| } |
| } |
| |
| public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { |
| pw.println(" mPhone=" + mPhone); |
| synchronized (mDcListAll) { |
| pw.println(" mDcListAll=" + mDcListAll); |
| pw.println(" mDcListActiveByCid=" + mDcListActiveByCid); |
| } |
| } |
| } |
