| Methods Summary |
|---|
| public void | captivePortalCheckCompleted(boolean isCaptivePortal)
if (mIsCaptivePortal.getAndSet(isCaptivePortal) != isCaptivePortal) {
// Captive portal change enable/disable failing fast
setEnableFailFastMobileData(
isCaptivePortal ? DctConstants.ENABLED : DctConstants.DISABLED);
}
|
| public void | defaultRouteSet(boolean enabled)
mDefaultRouteSet = enabled;
|
| public void | enableMobileProvisioning(java.lang.String url)Inform DCT mobile provisioning has started, it ends when provisioning completes.
if (DBG) log("enableMobileProvisioning(url=" + url + ")");
final AsyncChannel channel = mDataConnectionTrackerAc;
if (channel != null) {
Message msg = Message.obtain();
msg.what = DctConstants.CMD_ENABLE_MOBILE_PROVISIONING;
msg.setData(Bundle.forPair(DctConstants.PROVISIONING_URL_KEY, url));
channel.sendMessage(msg);
}
|
| public LinkProperties | getLinkProperties()
return new LinkProperties(mLinkProperties);
|
| public LinkQualityInfo | getLinkQualityInfo()
if (mNetworkInfo == null || mNetworkInfo.getType() == ConnectivityManager.TYPE_NONE) {
// no data available yet; just return
return null;
}
MobileLinkQualityInfo li = new MobileLinkQualityInfo();
li.setNetworkType(mNetworkInfo.getType());
mSamplingDataTracker.setCommonLinkQualityInfoFields(li);
if (mNetworkInfo.getSubtype() != TelephonyManager.NETWORK_TYPE_UNKNOWN) {
li.setMobileNetworkType(mNetworkInfo.getSubtype());
NetworkDataEntry entry = getNetworkDataEntry(mNetworkInfo.getSubtype());
if (entry != null) {
li.setTheoreticalRxBandwidth(entry.downloadBandwidth);
li.setTheoreticalRxBandwidth(entry.uploadBandwidth);
li.setTheoreticalLatency(entry.latency);
}
if (mSignalStrength != null) {
li.setNormalizedSignalStrength(getNormalizedSignalStrength(
li.getMobileNetworkType(), mSignalStrength));
}
}
SignalStrength ss = mSignalStrength;
if (ss != null) {
li.setRssi(ss.getGsmSignalStrength());
li.setGsmErrorRate(ss.getGsmBitErrorRate());
li.setCdmaDbm(ss.getCdmaDbm());
li.setCdmaEcio(ss.getCdmaEcio());
li.setEvdoDbm(ss.getEvdoDbm());
li.setEvdoEcio(ss.getEvdoEcio());
li.setEvdoSnr(ss.getEvdoSnr());
li.setLteSignalStrength(ss.getLteSignalStrength());
li.setLteRsrp(ss.getLteRsrp());
li.setLteRsrq(ss.getLteRsrq());
li.setLteRssnr(ss.getLteRssnr());
li.setLteCqi(ss.getLteCqi());
}
if (VDBG) {
Slog.d(TAG, "Returning LinkQualityInfo with"
+ " MobileNetworkType = " + String.valueOf(li.getMobileNetworkType())
+ " Theoretical Rx BW = " + String.valueOf(li.getTheoreticalRxBandwidth())
+ " gsm Signal Strength = " + String.valueOf(li.getRssi())
+ " cdma Signal Strength = " + String.valueOf(li.getCdmaDbm())
+ " evdo Signal Strength = " + String.valueOf(li.getEvdoDbm())
+ " Lte Signal Strength = " + String.valueOf(li.getLteSignalStrength()));
}
return li;
|
| private static android.net.MobileDataStateTracker$NetworkDataEntry | getNetworkDataEntry(int networkType)
for (NetworkDataEntry entry : mTheoreticalBWTable) {
if (entry.networkType == networkType) {
return entry;
}
}
Slog.e(TAG, "Could not find Theoretical BW entry for " + String.valueOf(networkType));
return null;
|
| public NetworkInfo | getNetworkInfo()
return mNetworkInfo;
|
| private static int | getNormalizedSignalStrength(int networkType, android.telephony.SignalStrength ss)
int level;
switch(networkType) {
case TelephonyManager.NETWORK_TYPE_EDGE:
case TelephonyManager.NETWORK_TYPE_GPRS:
case TelephonyManager.NETWORK_TYPE_UMTS:
case TelephonyManager.NETWORK_TYPE_HSDPA:
case TelephonyManager.NETWORK_TYPE_HSUPA:
case TelephonyManager.NETWORK_TYPE_HSPA:
case TelephonyManager.NETWORK_TYPE_HSPAP:
level = ss.getGsmLevel();
break;
case TelephonyManager.NETWORK_TYPE_CDMA:
case TelephonyManager.NETWORK_TYPE_1xRTT:
level = ss.getCdmaLevel();
break;
case TelephonyManager.NETWORK_TYPE_EVDO_0:
case TelephonyManager.NETWORK_TYPE_EVDO_A:
case TelephonyManager.NETWORK_TYPE_EVDO_B:
level = ss.getEvdoLevel();
break;
case TelephonyManager.NETWORK_TYPE_LTE:
level = ss.getLteLevel();
break;
case TelephonyManager.NETWORK_TYPE_IDEN:
case TelephonyManager.NETWORK_TYPE_EHRPD:
default:
return UNKNOWN;
}
return (level * LinkQualityInfo.NORMALIZED_SIGNAL_STRENGTH_RANGE) /
SignalStrength.NUM_SIGNAL_STRENGTH_BINS;
|
| private void | getPhoneService(boolean forceRefresh)
if ((mPhoneService == null) || forceRefresh) {
mPhoneService = ITelephony.Stub.asInterface(ServiceManager.getService("phone"));
}
|
| public java.lang.String | getTcpBufferSizesPropName()Return the system properties name associated with the tcp buffer sizes
for this network.
String networkTypeStr = "unknown";
TelephonyManager tm = new TelephonyManager(mContext);
//TODO We have to edit the parameter for getNetworkType regarding CDMA
switch(tm.getNetworkType()) {
case TelephonyManager.NETWORK_TYPE_GPRS:
networkTypeStr = "gprs";
break;
case TelephonyManager.NETWORK_TYPE_EDGE:
networkTypeStr = "edge";
break;
case TelephonyManager.NETWORK_TYPE_UMTS:
networkTypeStr = "umts";
break;
case TelephonyManager.NETWORK_TYPE_HSDPA:
networkTypeStr = "hsdpa";
break;
case TelephonyManager.NETWORK_TYPE_HSUPA:
networkTypeStr = "hsupa";
break;
case TelephonyManager.NETWORK_TYPE_HSPA:
networkTypeStr = "hspa";
break;
case TelephonyManager.NETWORK_TYPE_HSPAP:
networkTypeStr = "hspap";
break;
case TelephonyManager.NETWORK_TYPE_CDMA:
networkTypeStr = "cdma";
break;
case TelephonyManager.NETWORK_TYPE_1xRTT:
networkTypeStr = "1xrtt";
break;
case TelephonyManager.NETWORK_TYPE_EVDO_0:
networkTypeStr = "evdo";
break;
case TelephonyManager.NETWORK_TYPE_EVDO_A:
networkTypeStr = "evdo";
break;
case TelephonyManager.NETWORK_TYPE_EVDO_B:
networkTypeStr = "evdo";
break;
case TelephonyManager.NETWORK_TYPE_IDEN:
networkTypeStr = "iden";
break;
case TelephonyManager.NETWORK_TYPE_LTE:
networkTypeStr = "lte";
break;
case TelephonyManager.NETWORK_TYPE_EHRPD:
networkTypeStr = "ehrpd";
break;
default:
loge("unknown network type: " + tm.getNetworkType());
}
return "net.tcp.buffersize." + networkTypeStr;
|
| public boolean | isAvailable()Report whether data connectivity is possible.
return mNetworkInfo.isAvailable();
|
| public boolean | isDefaultRouteSet()
return mDefaultRouteSet;
|
| public boolean | isPrivateDnsRouteSet()
return mPrivateDnsRouteSet;
|
| public boolean | isProvisioningNetwork()Return if this network is the provisioning network. Valid only if connected.
boolean retVal;
try {
Message msg = Message.obtain();
msg.what = DctConstants.CMD_IS_PROVISIONING_APN;
msg.setData(Bundle.forPair(DctConstants.APN_TYPE_KEY, mApnType));
Message result = mDataConnectionTrackerAc.sendMessageSynchronously(msg);
retVal = result.arg1 == DctConstants.ENABLED;
} catch (NullPointerException e) {
loge("isProvisioningNetwork: X " + e);
retVal = false;
}
if (DBG) log("isProvisioningNetwork: retVal=" + retVal);
return retVal;
|
| public boolean | isReady()
return mDataConnectionTrackerAc != null;
|
| public boolean | isTeardownRequested()
return mTeardownRequested;
|
| private void | log(java.lang.String s)
Slog.d(TAG, mApnType + ": " + s);
|
| private void | loge(java.lang.String s)
Slog.e(TAG, mApnType + ": " + s);
|
| public static java.lang.String | networkTypeToApnType(int netType)
switch(netType) {
case ConnectivityManager.TYPE_MOBILE:
return PhoneConstants.APN_TYPE_DEFAULT; // TODO - use just one of these
case ConnectivityManager.TYPE_MOBILE_MMS:
return PhoneConstants.APN_TYPE_MMS;
case ConnectivityManager.TYPE_MOBILE_SUPL:
return PhoneConstants.APN_TYPE_SUPL;
case ConnectivityManager.TYPE_MOBILE_DUN:
return PhoneConstants.APN_TYPE_DUN;
case ConnectivityManager.TYPE_MOBILE_HIPRI:
return PhoneConstants.APN_TYPE_HIPRI;
case ConnectivityManager.TYPE_MOBILE_FOTA:
return PhoneConstants.APN_TYPE_FOTA;
case ConnectivityManager.TYPE_MOBILE_IMS:
return PhoneConstants.APN_TYPE_IMS;
case ConnectivityManager.TYPE_MOBILE_CBS:
return PhoneConstants.APN_TYPE_CBS;
case ConnectivityManager.TYPE_MOBILE_IA:
return PhoneConstants.APN_TYPE_IA;
case ConnectivityManager.TYPE_MOBILE_EMERGENCY:
return PhoneConstants.APN_TYPE_EMERGENCY;
default:
sloge("Error mapping networkType " + netType + " to apnType.");
return null;
}
|
| public void | privateDnsRouteSet(boolean enabled)
mPrivateDnsRouteSet = enabled;
|
| public boolean | reconnect()Re-enable mobile data connectivity after a {@link #teardown()}.
TODO - make async and always get a notification?
boolean retValue = false; //connected or expect to be?
setTeardownRequested(false);
switch (setEnableApn(mApnType, true)) {
case PhoneConstants.APN_ALREADY_ACTIVE:
// need to set self to CONNECTING so the below message is handled.
retValue = true;
break;
case PhoneConstants.APN_REQUEST_STARTED:
// set IDLE here , avoid the following second FAILED not sent out
mNetworkInfo.setDetailedState(DetailedState.IDLE, null, null);
retValue = true;
break;
case PhoneConstants.APN_REQUEST_FAILED:
case PhoneConstants.APN_TYPE_NOT_AVAILABLE:
break;
default:
loge("Error in reconnect - unexpected response.");
break;
}
return retValue;
|
| public void | releaseWakeLock()This is not implemented.
|
| public void | setDependencyMet(boolean met)carrier dependency is met/unmet
Bundle bundle = Bundle.forPair(DctConstants.APN_TYPE_KEY, mApnType);
try {
if (DBG) log("setDependencyMet: E met=" + met);
Message msg = Message.obtain();
msg.what = DctConstants.CMD_SET_DEPENDENCY_MET;
msg.arg1 = (met ? DctConstants.ENABLED : DctConstants.DISABLED);
msg.setData(bundle);
mDataConnectionTrackerAc.sendMessage(msg);
if (VDBG) log("setDependencyMet: X met=" + met);
} catch (NullPointerException e) {
loge("setDependencyMet: X mAc was null" + e);
}
|
| private void | setDetailedState(android.net.NetworkInfo.DetailedState state, java.lang.String reason, java.lang.String extraInfo)Record the detailed state of a network, and if it is a
change from the previous state, send a notification to
any listeners.
if (DBG) log("setDetailed state, old ="
+ mNetworkInfo.getDetailedState() + " and new state=" + state);
if (state != mNetworkInfo.getDetailedState()) {
boolean wasConnecting = (mNetworkInfo.getState() == NetworkInfo.State.CONNECTING);
String lastReason = mNetworkInfo.getReason();
/*
* If a reason was supplied when the CONNECTING state was entered, and no
* reason was supplied for entering the CONNECTED state, then retain the
* reason that was supplied when going to CONNECTING.
*/
if (wasConnecting && state == NetworkInfo.DetailedState.CONNECTED && reason == null
&& lastReason != null)
reason = lastReason;
mNetworkInfo.setDetailedState(state, reason, extraInfo);
Message msg = mTarget.obtainMessage(EVENT_STATE_CHANGED, new NetworkInfo(mNetworkInfo));
msg.sendToTarget();
}
|
| private int | setEnableApn(java.lang.String apnType, boolean enable)Internal method supporting the ENABLE_MMS feature.
getPhoneService(false);
/*
* If the phone process has crashed in the past, we'll get a
* RemoteException and need to re-reference the service.
*/
for (int retry = 0; retry < 2; retry++) {
if (mPhoneService == null) {
loge("Ignoring feature request because could not acquire PhoneService");
break;
}
// try {
// if (enable) {
// return mPhoneService.enableApnType(apnType);
// } else {
// return mPhoneService.disableApnType(apnType);
// }
// } catch (RemoteException e) {
// if (retry == 0) getPhoneService(true);
// }
}
loge("Could not " + (enable ? "enable" : "disable") + " APN type \"" + apnType + "\"");
return PhoneConstants.APN_REQUEST_FAILED;
|
| public void | setEnableFailFastMobileData(int enabled)Eanble/disable FailFast
if (DBG) log("setEnableFailFastMobileData(enabled=" + enabled + ")");
final AsyncChannel channel = mDataConnectionTrackerAc;
if (channel != null) {
channel.sendMessage(DctConstants.CMD_SET_ENABLE_FAIL_FAST_MOBILE_DATA, enabled);
}
|
| public void | setInternalDataEnable(boolean enabled)
if (DBG) log("setInternalDataEnable: E enabled=" + enabled);
final AsyncChannel channel = mDataConnectionTrackerAc;
if (channel != null) {
channel.sendMessage(DctConstants.EVENT_SET_INTERNAL_DATA_ENABLE,
enabled ? DctConstants.ENABLED : DctConstants.DISABLED);
}
if (VDBG) log("setInternalDataEnable: X enabled=" + enabled);
|
| public void | setPolicyDataEnable(boolean enabled)
if (DBG) log("setPolicyDataEnable(enabled=" + enabled + ")");
final AsyncChannel channel = mDataConnectionTrackerAc;
if (channel != null) {
channel.sendMessage(DctConstants.CMD_SET_POLICY_DATA_ENABLE,
enabled ? DctConstants.ENABLED : DctConstants.DISABLED);
mPolicyDataEnabled = enabled;
}
|
| public boolean | setRadio(boolean turnOn)Turn on or off the mobile radio. No connectivity will be possible while the
radio is off. The operation is a no-op if the radio is already in the desired state.
getPhoneService(false);
/*
* If the phone process has crashed in the past, we'll get a
* RemoteException and need to re-reference the service.
*/
for (int retry = 0; retry < 2; retry++) {
if (mPhoneService == null) {
loge("Ignoring mobile radio request because could not acquire PhoneService");
break;
}
try {
return mPhoneService.setRadio(turnOn);
} catch (RemoteException e) {
if (retry == 0) getPhoneService(true);
}
}
loge("Could not set radio power to " + (turnOn ? "on" : "off"));
return false;
|
| public void | setTeardownRequested(boolean isRequested)
mTeardownRequested = isRequested;
|
| public void | setUserDataEnable(boolean enabled)
if (DBG) log("setUserDataEnable: E enabled=" + enabled);
final AsyncChannel channel = mDataConnectionTrackerAc;
if (channel != null) {
channel.sendMessage(DctConstants.CMD_SET_USER_DATA_ENABLE,
enabled ? DctConstants.ENABLED : DctConstants.DISABLED);
mUserDataEnabled = enabled;
}
if (VDBG) log("setUserDataEnable: X enabled=" + enabled);
|
| private static void | sloge(java.lang.String s)
Slog.e(TAG, s);
|
| public void | startMonitoring(android.content.Context context, android.os.Handler target)Begin monitoring data connectivity.
mTarget = target;
mContext = context;
mHandler = new MdstHandler(target.getLooper(), this);
IntentFilter filter = new IntentFilter();
filter.addAction(TelephonyIntents.ACTION_ANY_DATA_CONNECTION_STATE_CHANGED);
filter.addAction(TelephonyIntents.ACTION_DATA_CONNECTION_CONNECTED_TO_PROVISIONING_APN);
filter.addAction(TelephonyIntents.ACTION_DATA_CONNECTION_FAILED);
mContext.registerReceiver(new MobileDataStateReceiver(), filter);
mMobileDataState = PhoneConstants.DataState.DISCONNECTED;
TelephonyManager tm = (TelephonyManager)mContext.getSystemService(
Context.TELEPHONY_SERVICE);
tm.listen(mPhoneStateListener, PhoneStateListener.LISTEN_SIGNAL_STRENGTHS);
|
| public void | startSampling(SamplingDataTracker.SamplingSnapshot s)
mSamplingDataTracker.startSampling(s);
|
| public void | stopSampling(SamplingDataTracker.SamplingSnapshot s)
mSamplingDataTracker.stopSampling(s);
|
| public void | supplyMessenger(android.os.Messenger messenger)
if (VDBG) log(mApnType + " got supplyMessenger");
AsyncChannel ac = new AsyncChannel();
ac.connect(mContext, MobileDataStateTracker.this.mHandler, messenger);
|
| public boolean | teardown()Tear down mobile data connectivity, i.e., disable the ability to create
mobile data connections.
TODO - make async and return nothing?
setTeardownRequested(true);
return (setEnableApn(mApnType, false) != PhoneConstants.APN_REQUEST_FAILED);
|
| public java.lang.String | toString()
final CharArrayWriter writer = new CharArrayWriter();
final PrintWriter pw = new PrintWriter(writer);
pw.print("Mobile data state: "); pw.println(mMobileDataState);
pw.print("Data enabled: user="); pw.print(mUserDataEnabled);
pw.print(", policy="); pw.println(mPolicyDataEnabled);
return writer.toString();
|
| private void | updateLinkProperitesAndCapatilities(android.content.Intent intent)
mLinkProperties = intent.getParcelableExtra(
PhoneConstants.DATA_LINK_PROPERTIES_KEY);
if (mLinkProperties == null) {
loge("CONNECTED event did not supply link properties.");
mLinkProperties = new LinkProperties();
}
mLinkProperties.setMtu(mContext.getResources().getInteger(
com.android.internal.R.integer.config_mobile_mtu));
mNetworkCapabilities = intent.getParcelableExtra(
PhoneConstants.DATA_NETWORK_CAPABILITIES_KEY);
if (mNetworkCapabilities == null) {
loge("CONNECTED event did not supply network capabilities.");
mNetworkCapabilities = new NetworkCapabilities();
}
|
