Remove dead code, mostly DataStateTracker. (7fad4eb4) · Commits · e / os / android_frameworks_base

core/java/android/net/BaseNetworkStateTracker.java

deleted100644 → 0

+0 −205

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2012 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 android.net;

		import android.content.Context;
		import android.os.Handler;
		import android.os.Messenger;

		import java.util.concurrent.atomic.AtomicBoolean;

		import com.android.internal.util.Preconditions;

		/**
		* Interface to control and observe state of a specific network, hiding
		* network-specific details from {@link ConnectivityManager}. Surfaces events
		* through the registered {@link Handler} to enable {@link ConnectivityManager}
		* to respond to state changes over time.
		*
		* @hide
		*/
		public abstract class BaseNetworkStateTracker implements NetworkStateTracker {
		// TODO: better document threading expectations
		// TODO: migrate to make NetworkStateTracker abstract class

		public static final String PROP_TCP_BUFFER_UNKNOWN = "net.tcp.buffersize.unknown";
		public static final String PROP_TCP_BUFFER_WIFI = "net.tcp.buffersize.wifi";

		protected Context mContext;
		private Handler mTarget;

		protected NetworkInfo mNetworkInfo;
		protected LinkProperties mLinkProperties;
		protected NetworkCapabilities mNetworkCapabilities;
		protected Network mNetwork = new Network(ConnectivityManager.NETID_UNSET);

		private AtomicBoolean mTeardownRequested = new AtomicBoolean(false);
		private AtomicBoolean mPrivateDnsRouteSet = new AtomicBoolean(false);
		private AtomicBoolean mDefaultRouteSet = new AtomicBoolean(false);

		public BaseNetworkStateTracker(int networkType) {
		mNetworkInfo = new NetworkInfo(
		networkType, -1, ConnectivityManager.getNetworkTypeName(networkType), null);
		mLinkProperties = new LinkProperties();
		mNetworkCapabilities = new NetworkCapabilities();
		}

		protected BaseNetworkStateTracker() {
		// By default, let the sub classes construct everything
		}

		@Deprecated
		protected Handler getTargetHandler() {
		return mTarget;
		}

		protected final void dispatchStateChanged() {
		// TODO: include snapshot of other fields when sending
		mTarget.obtainMessage(EVENT_STATE_CHANGED, getNetworkInfo()).sendToTarget();
		}

		protected final void dispatchConfigurationChanged() {
		// TODO: include snapshot of other fields when sending
		mTarget.obtainMessage(EVENT_CONFIGURATION_CHANGED, getNetworkInfo()).sendToTarget();
		}

		@Override
		public void startMonitoring(Context context, Handler target) {
		mContext = Preconditions.checkNotNull(context);
		mTarget = Preconditions.checkNotNull(target);
		startMonitoringInternal();
		}

		protected void startMonitoringInternal() {

		}

		@Override
		public NetworkInfo getNetworkInfo() {
		return new NetworkInfo(mNetworkInfo);
		}

		@Override
		public LinkProperties getLinkProperties() {
		return new LinkProperties(mLinkProperties);
		}

		@Override
		public NetworkCapabilities getNetworkCapabilities() {
		return new NetworkCapabilities(mNetworkCapabilities);
		}

		@Override
		public LinkQualityInfo getLinkQualityInfo() {
		return null;
		}

		@Override
		public void captivePortalCheckCompleted(boolean isCaptivePortal) {
		// not implemented
		}

		@Override
		public boolean setRadio(boolean turnOn) {
		// Base tracker doesn't handle radios
		return true;
		}

		@Override
		public boolean isAvailable() {
		return mNetworkInfo.isAvailable();
		}

		@Override
		public void setUserDataEnable(boolean enabled) {
		// Base tracker doesn't handle enabled flags
		}

		@Override
		public void setPolicyDataEnable(boolean enabled) {
		// Base tracker doesn't handle enabled flags
		}

		@Override
		public boolean isPrivateDnsRouteSet() {
		return mPrivateDnsRouteSet.get();
		}

		@Override
		public void privateDnsRouteSet(boolean enabled) {
		mPrivateDnsRouteSet.set(enabled);
		}

		@Override
		public boolean isDefaultRouteSet() {
		return mDefaultRouteSet.get();
		}

		@Override
		public void defaultRouteSet(boolean enabled) {
		mDefaultRouteSet.set(enabled);
		}

		@Override
		public boolean isTeardownRequested() {
		return mTeardownRequested.get();
		}

		@Override
		public void setTeardownRequested(boolean isRequested) {
		mTeardownRequested.set(isRequested);
		}

		@Override
		public void setDependencyMet(boolean met) {
		// Base tracker doesn't handle dependencies
		}

		@Override
		public void supplyMessenger(Messenger messenger) {
		// not supported on this network
		}

		@Override
		public String getNetworkInterfaceName() {
		if (mLinkProperties != null) {
		return mLinkProperties.getInterfaceName();
		} else {
		return null;
		}
		}

		@Override
		public void startSampling(SamplingDataTracker.SamplingSnapshot s) {
		// nothing to do
		}

		@Override
		public void stopSampling(SamplingDataTracker.SamplingSnapshot s) {
		// nothing to do
		}

		@Override
		public void setNetId(int netId) {
		mNetwork = new Network(netId);
		}

		@Override
		public Network getNetwork() {
		return mNetwork;
		}
		}

core/java/android/net/ConnectivityManager.java

+0 −33

Original line number	Diff line number	Diff line
		@@ -1792,25 +1792,6 @@ public class ConnectivityManager {
		}
		}

		/**
		* Sets a secondary requirement bit for the given networkType.
		* This requirement bit is generally under the control of the carrier
		* or its agents and is not directly controlled by the user.
		*
		* @param networkType The network who's dependence has changed
		* @param met Boolean - true if network use is OK, false if not
		*
		* <p>This method requires the call to hold the permission
		* {@link android.Manifest.permission#CONNECTIVITY_INTERNAL}.
		* {@hide}
		*/
		public void setDataDependency(int networkType, boolean met) {
		try {
		mService.setDataDependency(networkType, met);
		} catch (RemoteException e) {
		}
		}

		/**
		* Returns true if the hardware supports the given network type
		* else it returns false. This doesn't indicate we have coverage
		@@ -1891,20 +1872,6 @@ public class ConnectivityManager {
		}
		}

		/**
		* Supply the backend messenger for a network tracker
		*
		* @param networkType NetworkType to set
		* @param messenger {@link Messenger}
		* {@hide}
		*/
		public void supplyMessenger(int networkType, Messenger messenger) {
		try {
		mService.supplyMessenger(networkType, messenger);
		} catch (RemoteException e) {
		}
		}

		/**
		* Check mobile provisioning.
		*

core/java/android/net/IConnectivityManager.aidl

+0 −4

Original line number	Diff line number	Diff line
		@@ -102,8 +102,6 @@ interface IConnectivityManager

		ProxyInfo getDefaultProxy();

		void setDataDependency(int networkType, boolean met);

		boolean prepareVpn(String oldPackage, String newPackage);

		void setVpnPackageAuthorization(boolean authorized);
		@@ -120,8 +118,6 @@ interface IConnectivityManager

		void captivePortalCheckCompleted(in NetworkInfo info, boolean isCaptivePortal);

		void supplyMessenger(int networkType, in Messenger messenger);

		int findConnectionTypeForIface(in String iface);

		int checkMobileProvisioning(int suggestedTimeOutMs);

core/java/android/net/MobileDataStateTracker.java

deleted100644 → 0

+0 −909

File deleted.

Preview size limit exceeded, changes collapsed.

core/java/android/net/NetworkStateTracker.java

deleted100644 → 0

+0 −250

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2008 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package android.net;

		import android.content.Context;
		import android.os.Handler;
		import android.os.Messenger;

		import static com.android.internal.util.Protocol.BASE_NETWORK_STATE_TRACKER;

		/**
		* Interface provides the {@link com.android.server.ConnectivityService}
		* with three services. Events to the ConnectivityService when
		* changes occur, an API for controlling the network and storage
		* for network specific information.
		*
		* The Connectivity will call startMonitoring before any other
		* method is called.
		*
		* {@hide}
		*/
		public interface NetworkStateTracker {

		/**
		* -------------------------------------------------------------
		* Event Interface back to ConnectivityService.
		*
		* The events that are to be sent back to the Handler passed
		* to startMonitoring when the particular event occurs.
		* -------------------------------------------------------------
		*/

		/**
		* The network state has changed and the NetworkInfo object
		* contains the new state.
		*
		* msg.what = EVENT_STATE_CHANGED
		* msg.obj = NetworkInfo object
		*/
		public static final int EVENT_STATE_CHANGED = BASE_NETWORK_STATE_TRACKER;

		/**
		* msg.what = EVENT_CONFIGURATION_CHANGED
		* msg.obj = NetworkInfo object
		*/
		public static final int EVENT_CONFIGURATION_CHANGED = BASE_NETWORK_STATE_TRACKER + 1;

		/**
		* msg.what = EVENT_RESTORE_DEFAULT_NETWORK
		* msg.obj = FeatureUser object
		*/
		public static final int EVENT_RESTORE_DEFAULT_NETWORK = BASE_NETWORK_STATE_TRACKER + 2;

		/**
		* msg.what = EVENT_NETWORK_SUBTYPE_CHANGED
		* msg.obj = NetworkInfo object
		*/
		public static final int EVENT_NETWORK_SUBTYPE_CHANGED = BASE_NETWORK_STATE_TRACKER + 3;

		/**
		* msg.what = EVENT_NETWORK_CONNECTED
		* msg.obj = LinkProperties object
		*/
		public static final int EVENT_NETWORK_CONNECTED = BASE_NETWORK_STATE_TRACKER + 4;

		/**
		* msg.what = EVENT_NETWORK_CONNECTION_DISCONNECTED
		* msg.obj = LinkProperties object, same iface name
		*/
		public static final int EVENT_NETWORK_DISCONNECTED = BASE_NETWORK_STATE_TRACKER + 5;

		/**
		* -------------------------------------------------------------
		* Control Interface
		* -------------------------------------------------------------
		*/
		/**
		* Begin monitoring data connectivity.
		*
		* This is the first method called when this interface is used.
		*
		* @param context is the current Android context
		* @param target is the Hander to which to return the events.
		*/
		public void startMonitoring(Context context, Handler target);

		/**
		* Fetch NetworkInfo for the network
		*/
		public NetworkInfo getNetworkInfo();

		/**
		* Return the LinkProperties for the connection.
		*
		* @return a copy of the LinkProperties, is never null.
		*/
		public LinkProperties getLinkProperties();

		/**
		* @return a copy of this connections capabilities, may be empty but never null.
		*/
		public NetworkCapabilities getNetworkCapabilities();

		/**
		* Get interesting information about this network link
		* @return a copy of link information, null if not available
		*/
		public LinkQualityInfo getLinkQualityInfo();

		/**
		* Return the system properties name associated with the tcp buffer sizes
		* for this network.
		*/
		public String getTcpBufferSizesPropName();

		/**
		* Disable connectivity to a network
		* @return {@code true} if a teardown occurred, {@code false} if the
		* teardown did not occur.
		*/
		public boolean teardown();

		/**
		* Reenable connectivity to a network after a {@link #teardown()}.
		* @return {@code true} if we're connected or expect to be connected
		*/
		public boolean reconnect();

		/**
		* Captive portal check has completed
		*/
		public void captivePortalCheckCompleted(boolean isCaptive);

		/**
		* Turn the wireless radio off for a network.
		* @param turnOn {@code true} to turn the radio on, {@code false}
		*/
		public boolean setRadio(boolean turnOn);

		/**
		* Returns an indication of whether this network is available for
		* connections. A value of {@code false} means that some quasi-permanent
		* condition prevents connectivity to this network.
		*
		* NOTE that this is broken on multi-connection devices. Should be fixed in J release
		* TODO - fix on multi-pdp devices
		*/
		public boolean isAvailable();

		/**
		* User control of data connection through this network, typically persisted
		* internally.
		*/
		public void setUserDataEnable(boolean enabled);

		/**
		* Policy control of data connection through this network, typically not
		* persisted internally. Usually used when {@link NetworkPolicy#limitBytes}
		* is passed.
		*/
		public void setPolicyDataEnable(boolean enabled);

		/**
		* -------------------------------------------------------------
		* Storage API used by ConnectivityService for saving
		* Network specific information.
		* -------------------------------------------------------------
		*/

		/**
		* Check if private DNS route is set for the network
		*/
		public boolean isPrivateDnsRouteSet();

		/**
		* Set a flag indicating private DNS route is set
		*/
		public void privateDnsRouteSet(boolean enabled);

		/**
		* Check if default route is set
		*/
		public boolean isDefaultRouteSet();

		/**
		* Set a flag indicating default route is set for the network
		*/
		public void defaultRouteSet(boolean enabled);

		/**
		* Check if tear down was requested
		*/
		public boolean isTeardownRequested();

		/**
		* Indicate tear down requested from connectivity
		*/
		public void setTeardownRequested(boolean isRequested);

		/**
		* An external dependency has been met/unmet
		*/
		public void setDependencyMet(boolean met);

		/*
		* Called once to setup async channel between this and
		* the underlying network specific code.
		*/
		public void supplyMessenger(Messenger messenger);

		/*
		* Network interface name that we'll lookup for sampling data
		*/
		public String getNetworkInterfaceName();

		/*
		* Save the starting sample
		*/
		public void startSampling(SamplingDataTracker.SamplingSnapshot s);

		/*
		* Save the ending sample
		*/
		public void stopSampling(SamplingDataTracker.SamplingSnapshot s);

		/*
		* Record the current netId
		*/
		public void setNetId(int netId);

		/*
		* ?
		*/
		public Network getNetwork();

		}