src.com.android.internal.telephony.dataconnection.ApnContext Maven / Gradle / Ivy
/*
* 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 android.app.PendingIntent;
import android.net.ConnectivityManager;
import android.net.NetworkCapabilities;
import android.net.NetworkConfig;
import android.net.NetworkRequest;
import android.os.Message;
import android.telephony.Rlog;
import android.telephony.data.ApnSetting;
import android.telephony.data.ApnSetting.ApnType;
import android.text.TextUtils;
import android.util.LocalLog;
import android.util.SparseIntArray;
import com.android.internal.R;
import com.android.internal.telephony.DctConstants;
import com.android.internal.telephony.Phone;
import com.android.internal.telephony.RetryManager;
import com.android.internal.telephony.dataconnection.DcTracker.ReleaseNetworkType;
import com.android.internal.telephony.dataconnection.DcTracker.RequestNetworkType;
import com.android.internal.util.IndentingPrintWriter;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Maintain the Apn context
*/
public class ApnContext {
public final String LOG_TAG;
private final static String SLOG_TAG = "ApnContext";
protected static final boolean DBG = false;
private final Phone mPhone;
private final String mApnType;
private DctConstants.State mState;
public final int priority;
private ApnSetting mApnSetting;
private DataConnection mDataConnection;
String mReason;
PendingIntent mReconnectAlarmIntent;
/**
* user/app requested connection on this APN
*/
AtomicBoolean mDataEnabled;
private final Object mRefCountLock = new Object();
private int mRefCount = 0;
/**
* carrier requirements met
*/
AtomicBoolean mDependencyMet;
private final DcTracker mDcTracker;
/**
* Remember this as a change in this value to a more permissive state
* should cause us to retry even permanent failures
*/
private boolean mConcurrentVoiceAndDataAllowed;
/**
* used to track a single connection request so disconnects can get ignored if
* obsolete.
*/
private final AtomicInteger mConnectionGeneration = new AtomicInteger(0);
/**
* Retry manager that handles the APN retry and delays.
*/
private final RetryManager mRetryManager;
/**
* AonContext constructor
* @param phone phone object
* @param apnType APN type (e.g. default, supl, mms, etc...)
* @param logTag Tag for logging
* @param config Network configuration
* @param tracker Data call tracker
*/
public ApnContext(Phone phone, String apnType, String logTag, NetworkConfig config,
DcTracker tracker) {
mPhone = phone;
mApnType = apnType;
mState = DctConstants.State.IDLE;
setReason(Phone.REASON_DATA_ENABLED);
mDataEnabled = new AtomicBoolean(false);
mDependencyMet = new AtomicBoolean(config.dependencyMet);
priority = config.priority;
LOG_TAG = logTag;
mDcTracker = tracker;
mRetryManager = new RetryManager(phone, apnType);
}
/**
* Get the APN type
* @return The APN type
*/
public String getApnType() {
return mApnType;
}
/**
* Gets the APN type bitmask.
* @return The APN type bitmask
*/
public int getApnTypeBitmask() {
return ApnSetting.getApnTypesBitmaskFromString(mApnType);
}
/**
* Get the associated data connection
* @return The data connection
*/
public synchronized DataConnection getDataConnection() {
return mDataConnection;
}
/**
* Set the associated data connection.
* @param dc data connection
*/
public synchronized void setDataConnection(DataConnection dc) {
log("setDataConnectionAc: old=" + mDataConnection + ",new=" + dc + " this=" + this);
mDataConnection = dc;
}
/**
* Release data connection.
* @param reason The reason of releasing data connection
*/
public synchronized void releaseDataConnection(String reason) {
if (mDataConnection != null) {
mDataConnection.tearDown(this, reason, null);
mDataConnection = null;
}
setState(DctConstants.State.IDLE);
}
/**
* Get the reconnect intent.
* @return The reconnect intent
*/
public synchronized PendingIntent getReconnectIntent() {
return mReconnectAlarmIntent;
}
/**
* Save the reconnect intent which can be used for cancelling later.
* @param intent The reconnect intent
*/
public synchronized void setReconnectIntent(PendingIntent intent) {
mReconnectAlarmIntent = intent;
}
/**
* Get the current APN setting.
* @return APN setting
*/
public synchronized ApnSetting getApnSetting() {
log("getApnSetting: apnSetting=" + mApnSetting);
return mApnSetting;
}
/**
* Set the APN setting.
* @param apnSetting APN setting
*/
public synchronized void setApnSetting(ApnSetting apnSetting) {
log("setApnSetting: apnSetting=" + apnSetting);
mApnSetting = apnSetting;
}
/**
* Set the list of APN candidates which will be used for data call setup later.
* @param waitingApns List of APN candidates
*/
public synchronized void setWaitingApns(ArrayList waitingApns) {
mRetryManager.setWaitingApns(waitingApns);
}
/**
* Get the next available APN to try.
* @return APN setting which will be used for data call setup. Return null if there is no
* APN can be retried.
*/
public ApnSetting getNextApnSetting() {
return mRetryManager.getNextApnSetting();
}
/**
* Save the modem suggested delay for retrying the current APN.
* This method is called when we get the suggested delay from RIL.
* @param delay The delay in milliseconds
*/
public void setModemSuggestedDelay(long delay) {
mRetryManager.setModemSuggestedDelay(delay);
}
/**
* Get the delay for trying the next APN setting if the current one failed.
* @param failFastEnabled True if fail fast mode enabled. In this case we'll use a shorter
* delay.
* @return The delay in milliseconds
*/
public long getDelayForNextApn(boolean failFastEnabled) {
return mRetryManager.getDelayForNextApn(failFastEnabled || isFastRetryReason());
}
/**
* Mark the current APN setting permanently failed, which means it will not be retried anymore.
* @param apn APN setting
*/
public void markApnPermanentFailed(ApnSetting apn) {
mRetryManager.markApnPermanentFailed(apn);
}
/**
* Get the list of waiting APNs.
* @return the list of waiting APNs
*/
public ArrayList getWaitingApns() {
return mRetryManager.getWaitingApns();
}
/**
* Save the state indicating concurrent voice/data allowed.
* @param allowed True if concurrent voice/data is allowed
*/
public synchronized void setConcurrentVoiceAndDataAllowed(boolean allowed) {
mConcurrentVoiceAndDataAllowed = allowed;
}
/**
* Get the state indicating concurrent voice/data allowed.
* @return True if concurrent voice/data is allowed
*/
public synchronized boolean isConcurrentVoiceAndDataAllowed() {
return mConcurrentVoiceAndDataAllowed;
}
/**
* Set the current data call state.
* @param s Current data call state
*/
public synchronized void setState(DctConstants.State s) {
log("setState: " + s + ", previous state:" + mState);
if (mState != s) {
mStateLocalLog.log("State changed from " + mState + " to " + s);
mState = s;
}
if (mState == DctConstants.State.FAILED) {
if (mRetryManager.getWaitingApns() != null) {
// when teardown the connection and set to IDLE
mRetryManager.getWaitingApns().clear();
}
}
}
/**
* Get the current data call state.
* @return The current data call state
*/
public synchronized DctConstants.State getState() {
return mState;
}
/**
* Check whether the data call is disconnected or not.
* @return True if the data call is disconnected
*/
public boolean isDisconnected() {
DctConstants.State currentState = getState();
return ((currentState == DctConstants.State.IDLE) ||
currentState == DctConstants.State.FAILED);
}
/**
* Set the reason for data call connection.
* @param reason Reason for data call connection
*/
public synchronized void setReason(String reason) {
log("set reason as " + reason + ",current state " + mState);
mReason = reason;
}
/**
* Get the reason for data call connection.
* @return The reason for data call connection
*/
public synchronized String getReason() {
return mReason;
}
/**
* Check if ready for data call connection
* @return True if ready, otherwise false.
*/
public boolean isReady() {
return mDataEnabled.get() && mDependencyMet.get();
}
/**
* Check if the data call is in the state which allow connecting.
* @return True if allowed, otherwise false.
*/
public boolean isConnectable() {
return isReady() && ((mState == DctConstants.State.IDLE)
|| (mState == DctConstants.State.RETRYING)
|| (mState == DctConstants.State.FAILED));
}
/**
* Check if apn reason is fast retry reason which should apply shorter delay between apn re-try.
* @return True if it is fast retry reason, otherwise false.
*/
private boolean isFastRetryReason() {
return Phone.REASON_NW_TYPE_CHANGED.equals(mReason) ||
Phone.REASON_APN_CHANGED.equals(mReason);
}
/** Check if the data call is in connected or connecting state.
* @return True if the data call is in connected or connecting state
*/
public boolean isConnectedOrConnecting() {
return isReady() && ((mState == DctConstants.State.CONNECTED)
|| (mState == DctConstants.State.CONNECTING)
|| (mState == DctConstants.State.RETRYING));
}
/**
* Set data call enabled/disabled state.
* @param enabled True if data call is enabled
*/
public void setEnabled(boolean enabled) {
log("set enabled as " + enabled + ", current state is " + mDataEnabled.get());
mDataEnabled.set(enabled);
}
/**
* Check if the data call is enabled or not.
* @return True if enabled
*/
public boolean isEnabled() {
return mDataEnabled.get();
}
public boolean isDependencyMet() {
return mDependencyMet.get();
}
public boolean isProvisioningApn() {
String provisioningApn = mPhone.getContext().getResources()
.getString(R.string.mobile_provisioning_apn);
if (!TextUtils.isEmpty(provisioningApn) &&
(mApnSetting != null) && (mApnSetting.getApnName() != null)) {
return (mApnSetting.getApnName().equals(provisioningApn));
} else {
return false;
}
}
private final LocalLog mLocalLog = new LocalLog(150);
private final ArrayList mNetworkRequests = new ArrayList<>();
private final LocalLog mStateLocalLog = new LocalLog(50);
public void requestLog(String str) {
synchronized (mLocalLog) {
mLocalLog.log(str);
}
}
public void requestNetwork(NetworkRequest networkRequest, @RequestNetworkType int type,
Message onCompleteMsg) {
synchronized (mRefCountLock) {
mNetworkRequests.add(networkRequest);
logl("requestNetwork for " + networkRequest + ", type="
+ DcTracker.requestTypeToString(type));
mDcTracker.enableApn(ApnSetting.getApnTypesBitmaskFromString(mApnType), type,
onCompleteMsg);
if (mDataConnection != null) {
// New network request added. Should re-evaluate properties of
// the data connection. For example, the score may change.
mDataConnection.reevaluateDataConnectionProperties();
}
}
}
public void releaseNetwork(NetworkRequest networkRequest, @ReleaseNetworkType int type) {
synchronized (mRefCountLock) {
if (mNetworkRequests.contains(networkRequest) == false) {
logl("releaseNetwork can't find this request (" + networkRequest + ")");
} else {
mNetworkRequests.remove(networkRequest);
if (mDataConnection != null) {
// New network request added. Should re-evaluate properties of
// the data connection. For example, the score may change.
mDataConnection.reevaluateDataConnectionProperties();
}
logl("releaseNetwork left with " + mNetworkRequests.size()
+ " requests.");
if (mNetworkRequests.size() == 0
|| type == DcTracker.RELEASE_TYPE_DETACH
|| type == DcTracker.RELEASE_TYPE_HANDOVER) {
mDcTracker.disableApn(ApnSetting.getApnTypesBitmaskFromString(mApnType), type);
}
}
}
}
/**
* @param excludeDun True if excluding requests that have DUN capability
* @return True if the attached network requests contain restricted capability.
*/
public boolean hasRestrictedRequests(boolean excludeDun) {
synchronized (mRefCountLock) {
for (NetworkRequest nr : mNetworkRequests) {
if (excludeDun &&
nr.networkCapabilities.hasCapability(
NetworkCapabilities.NET_CAPABILITY_DUN)) {
continue;
}
if (!nr.networkCapabilities.hasCapability(
NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)) {
return true;
}
}
}
return false;
}
private final SparseIntArray mRetriesLeftPerErrorCode = new SparseIntArray();
public void resetErrorCodeRetries() {
logl("ApnContext.resetErrorCodeRetries");
String[] config = mPhone.getContext().getResources().getStringArray(
com.android.internal.R.array.config_cell_retries_per_error_code);
synchronized (mRetriesLeftPerErrorCode) {
mRetriesLeftPerErrorCode.clear();
for (String c : config) {
String errorValue[] = c.split(",");
if (errorValue != null && errorValue.length == 2) {
int count = 0;
int errorCode = 0;
try {
errorCode = Integer.parseInt(errorValue[0]);
count = Integer.parseInt(errorValue[1]);
} catch (NumberFormatException e) {
log("Exception parsing config_retries_per_error_code: " + e);
continue;
}
if (count > 0 && errorCode > 0) {
mRetriesLeftPerErrorCode.put(errorCode, count);
}
} else {
log("Exception parsing config_retries_per_error_code: " + c);
}
}
}
}
public boolean restartOnError(int errorCode) {
boolean result = false;
int retriesLeft = 0;
synchronized(mRetriesLeftPerErrorCode) {
retriesLeft = mRetriesLeftPerErrorCode.get(errorCode);
switch (retriesLeft) {
case 0: {
// not set, never restart modem
break;
}
case 1: {
resetErrorCodeRetries();
result = true;
break;
}
default: {
mRetriesLeftPerErrorCode.put(errorCode, retriesLeft - 1);
result = false;
}
}
}
logl("ApnContext.restartOnError(" + errorCode + ") found " + retriesLeft
+ " and returned " + result);
return result;
}
public int incAndGetConnectionGeneration() {
return mConnectionGeneration.incrementAndGet();
}
public int getConnectionGeneration() {
return mConnectionGeneration.get();
}
long getRetryAfterDisconnectDelay() {
return mRetryManager.getRetryAfterDisconnectDelay();
}
public static int getApnTypeFromNetworkType(int networkType) {
switch (networkType) {
case ConnectivityManager.TYPE_MOBILE:
return ApnSetting.TYPE_DEFAULT;
case ConnectivityManager.TYPE_MOBILE_MMS:
return ApnSetting.TYPE_MMS;
case ConnectivityManager.TYPE_MOBILE_SUPL:
return ApnSetting.TYPE_SUPL;
case ConnectivityManager.TYPE_MOBILE_DUN:
return ApnSetting.TYPE_DUN;
case ConnectivityManager.TYPE_MOBILE_FOTA:
return ApnSetting.TYPE_FOTA;
case ConnectivityManager.TYPE_MOBILE_IMS:
return ApnSetting.TYPE_IMS;
case ConnectivityManager.TYPE_MOBILE_CBS:
return ApnSetting.TYPE_CBS;
case ConnectivityManager.TYPE_MOBILE_IA:
return ApnSetting.TYPE_IA;
case ConnectivityManager.TYPE_MOBILE_EMERGENCY:
return ApnSetting.TYPE_EMERGENCY;
default:
return ApnSetting.TYPE_NONE;
}
}
static @ApnType int getApnTypeFromNetworkRequest(NetworkRequest nr) {
NetworkCapabilities nc = nr.networkCapabilities;
// For now, ignore the bandwidth stuff
if (nc.getTransportTypes().length > 0 &&
nc.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) == false) {
return ApnSetting.TYPE_NONE;
}
// in the near term just do 1-1 matches.
// TODO - actually try to match the set of capabilities
int apnType = ApnSetting.TYPE_NONE;
boolean error = false;
if (nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)) {
apnType = ApnSetting.TYPE_DEFAULT;
}
if (nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_MMS)) {
if (apnType != ApnSetting.TYPE_NONE) error = true;
apnType = ApnSetting.TYPE_MMS;
}
if (nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_SUPL)) {
if (apnType != ApnSetting.TYPE_NONE) error = true;
apnType = ApnSetting.TYPE_SUPL;
}
if (nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_DUN)) {
if (apnType != ApnSetting.TYPE_NONE) error = true;
apnType = ApnSetting.TYPE_DUN;
}
if (nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_FOTA)) {
if (apnType != ApnSetting.TYPE_NONE) error = true;
apnType = ApnSetting.TYPE_FOTA;
}
if (nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_IMS)) {
if (apnType != ApnSetting.TYPE_NONE) error = true;
apnType = ApnSetting.TYPE_IMS;
}
if (nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_CBS)) {
if (apnType != ApnSetting.TYPE_NONE) error = true;
apnType = ApnSetting.TYPE_CBS;
}
if (nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_IA)) {
if (apnType != ApnSetting.TYPE_NONE) error = true;
apnType = ApnSetting.TYPE_IA;
}
if (nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_EIMS)) {
if (apnType != ApnSetting.TYPE_NONE) error = true;
apnType = ApnSetting.TYPE_EMERGENCY;
}
if (nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_MCX)) {
if (apnType != ApnSetting.TYPE_NONE) error = true;
apnType = ApnSetting.TYPE_MCX;
}
if (error) {
// TODO: If this error condition is removed, the framework's handling of
// NET_CAPABILITY_NOT_RESTRICTED will need to be updated so requests for
// say FOTA and INTERNET are marked as restricted. This is not how
// NetworkCapabilities.maybeMarkCapabilitiesRestricted currently works.
Rlog.d(SLOG_TAG, "Multiple apn types specified in request - result is unspecified!");
}
if (apnType == ApnSetting.TYPE_NONE) {
Rlog.d(SLOG_TAG, "Unsupported NetworkRequest in Telephony: nr=" + nr);
}
return apnType;
}
public List getNetworkRequests() {
synchronized (mRefCountLock) {
return new ArrayList(mNetworkRequests);
}
}
@Override
public synchronized String toString() {
// We don't print mDataConnection because its recursive.
return "{mApnType=" + mApnType + " mState=" + getState() + " mWaitingApns={" +
mRetryManager.getWaitingApns() + "}" + " mApnSetting={" + mApnSetting +
"} mReason=" + mReason + " mDataEnabled=" + mDataEnabled + " mDependencyMet=" +
mDependencyMet + "}";
}
private void log(String s) {
if (DBG) {
Rlog.d(LOG_TAG, "[ApnContext:" + mApnType + "] " + s);
}
}
private void logl(String s) {
log(s);
mLocalLog.log(s);
}
public void dump(FileDescriptor fd, PrintWriter printWriter, String[] args) {
final IndentingPrintWriter pw = new IndentingPrintWriter(printWriter, " ");
synchronized (mRefCountLock) {
pw.println(toString());
if (mNetworkRequests.size() > 0) {
pw.println("NetworkRequests:");
pw.increaseIndent();
for (NetworkRequest nr : mNetworkRequests) {
pw.println(nr);
}
pw.decreaseIndent();
}
pw.increaseIndent();
pw.println("-----");
pw.println("Local log:");
mLocalLog.dump(fd, pw, args);
pw.println("-----");
pw.decreaseIndent();
pw.println("Historical APN state:");
pw.increaseIndent();
mStateLocalLog.dump(fd, pw, args);
pw.decreaseIndent();
pw.println(mRetryManager);
pw.println("--------------------------");
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy