Merge "Remove dead code 2." into lmp-dev (a3464420) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/ConnectivityService.java

+1 −185

Original line number	Diff line number	Diff line
		@@ -441,17 +441,6 @@ public class ConnectivityService extends IConnectivityManager.Stub {
		NetworkConfig[] mNetConfigs;
		int mNetworksDefined;

		private static class RadioAttributes {
		public int mSimultaneity;
		public int mType;
		public RadioAttributes(String init) {
		String fragments[] = init.split(",");
		mType = Integer.parseInt(fragments[0]);
		mSimultaneity = Integer.parseInt(fragments[1]);
		}
		}
		RadioAttributes[] mRadioAttributes;

		// the set of network types that can only be enabled by system/sig apps
		List mProtectedNetworks;

		@@ -581,16 +570,8 @@ public class ConnectivityService extends IConnectivityManager.Stub {
		}
		private LegacyTypeTracker mLegacyTypeTracker = new LegacyTypeTracker();

		public ConnectivityService(Context context, INetworkManagementService netd,
		INetworkStatsService statsService, INetworkPolicyManager policyManager) {
		// Currently, omitting a NetworkFactory will create one internally
		// TODO: create here when we have cleaner WiMAX support
		this(context, netd, statsService, policyManager, null);
		}

		public ConnectivityService(Context context, INetworkManagementService netManager,
		INetworkStatsService statsService, INetworkPolicyManager policyManager,
		NetworkFactory netFactory) {
		INetworkStatsService statsService, INetworkPolicyManager policyManager) {
		if (DBG) log("ConnectivityService starting up");

		NetworkCapabilities netCap = new NetworkCapabilities();
		@@ -606,10 +587,6 @@ public class ConnectivityService extends IConnectivityManager.Stub {
		mHandler = new InternalHandler(handlerThread.getLooper());
		mTrackerHandler = new NetworkStateTrackerHandler(handlerThread.getLooper());

		if (netFactory == null) {
		netFactory = new DefaultNetworkFactory(context, mTrackerHandler);
		}

		// setup our unique device name
		if (TextUtils.isEmpty(SystemProperties.get("net.hostname"))) {
		String id = Settings.Secure.getString(context.getContentResolver(),
		@@ -655,27 +632,8 @@ public class ConnectivityService extends IConnectivityManager.Stub {
		mNetTrackers = new NetworkStateTracker[
		ConnectivityManager.MAX_NETWORK_TYPE+1];

		mRadioAttributes = new RadioAttributes[ConnectivityManager.MAX_RADIO_TYPE+1];
		mNetConfigs = new NetworkConfig[ConnectivityManager.MAX_NETWORK_TYPE+1];

		// Load device network attributes from resources
		String[] raStrings = context.getResources().getStringArray(
		com.android.internal.R.array.radioAttributes);
		for (String raString : raStrings) {
		RadioAttributes r = new RadioAttributes(raString);
		if (VDBG) log("raString=" + raString + " r=" + r);
		if (r.mType > ConnectivityManager.MAX_RADIO_TYPE) {
		loge("Error in radioAttributes - ignoring attempt to define type " + r.mType);
		continue;
		}
		if (mRadioAttributes[r.mType] != null) {
		loge("Error in radioAttributes - ignoring attempt to redefine type " +
		r.mType);
		continue;
		}
		mRadioAttributes[r.mType] = r;
		}

		// TODO: What is the "correct" way to do determine if this is a wifi only device?
		boolean wifiOnly = SystemProperties.getBoolean("ro.radio.noril", false);
		log("wifiOnly=" + wifiOnly);
		@@ -700,11 +658,6 @@ public class ConnectivityService extends IConnectivityManager.Stub {
		n.type);
		continue;
		}
		if (mRadioAttributes[n.radio] == null) {
		loge("Error in networkAttributes - ignoring attempt to use undefined " +
		"radio " + n.radio + " in network type " + n.type);
		continue;
		}
		mLegacyTypeTracker.addSupportedType(n.type);

		mNetConfigs[n.type] = n;
		@@ -758,25 +711,6 @@ public class ConnectivityService extends IConnectivityManager.Stub {
		mTestMode = SystemProperties.get("cm.test.mode").equals("true")
		&& SystemProperties.get("ro.build.type").equals("eng");

		// Create and start trackers for hard-coded networks
		for (int targetNetworkType : mPriorityList) {
		final NetworkConfig config = mNetConfigs[targetNetworkType];
		final NetworkStateTracker tracker;
		try {
		tracker = netFactory.createTracker(targetNetworkType, config);
		mNetTrackers[targetNetworkType] = tracker;
		} catch (IllegalArgumentException e) {
		Slog.e(TAG, "Problem creating " + getNetworkTypeName(targetNetworkType)
		+ " tracker: " + e);
		continue;
		}

		tracker.startMonitoring(context, mTrackerHandler);
		if (config.isDefault()) {
		tracker.reconnect();
		}
		}

		mTethering = new Tethering(mContext, mNetd, statsService, mHandler.getLooper());

		//set up the listener for user state for creating user VPNs
		@@ -841,124 +775,6 @@ public class ConnectivityService extends IConnectivityManager.Stub {
		return netId;
		}

		/**
		* Factory that creates {@link NetworkStateTracker} instances using given
		* {@link NetworkConfig}.
		*
		* TODO - this is obsolete and will be deleted. It's replaced by the
		* registerNetworkFactory call and protocol.
		* @Deprecated in favor of registerNetworkFactory dynamic bindings
		*/
		public interface NetworkFactory {
		public NetworkStateTracker createTracker(int targetNetworkType, NetworkConfig config);
		}

		private static class DefaultNetworkFactory implements NetworkFactory {
		private final Context mContext;
		private final Handler mTrackerHandler;

		public DefaultNetworkFactory(Context context, Handler trackerHandler) {
		mContext = context;
		mTrackerHandler = trackerHandler;
		}

		@Override
		public NetworkStateTracker createTracker(int targetNetworkType, NetworkConfig config) {
		switch (config.radio) {
		case TYPE_WIMAX:
		return makeWimaxStateTracker(mContext, mTrackerHandler);
		case TYPE_PROXY:
		return new ProxyDataTracker();
		default:
		throw new IllegalArgumentException(
		"Trying to create a NetworkStateTracker for an unknown radio type: "
		+ config.radio);
		}
		}
		}

		/**
		* Loads external WiMAX library and registers as system service, returning a
		* {@link NetworkStateTracker} for WiMAX. Caller is still responsible for
		* invoking {@link NetworkStateTracker#startMonitoring(Context, Handler)}.
		*/
		private static NetworkStateTracker makeWimaxStateTracker(
		Context context, Handler trackerHandler) {
		// Initialize Wimax
		DexClassLoader wimaxClassLoader;
		Class wimaxStateTrackerClass = null;
		Class wimaxServiceClass = null;
		Class wimaxManagerClass;
		String wimaxJarLocation;
		String wimaxLibLocation;
		String wimaxManagerClassName;
		String wimaxServiceClassName;
		String wimaxStateTrackerClassName;

		NetworkStateTracker wimaxStateTracker = null;

		boolean isWimaxEnabled = context.getResources().getBoolean(
		com.android.internal.R.bool.config_wimaxEnabled);

		if (isWimaxEnabled) {
		try {
		wimaxJarLocation = context.getResources().getString(
		com.android.internal.R.string.config_wimaxServiceJarLocation);
		wimaxLibLocation = context.getResources().getString(
		com.android.internal.R.string.config_wimaxNativeLibLocation);
		wimaxManagerClassName = context.getResources().getString(
		com.android.internal.R.string.config_wimaxManagerClassname);
		wimaxServiceClassName = context.getResources().getString(
		com.android.internal.R.string.config_wimaxServiceClassname);
		wimaxStateTrackerClassName = context.getResources().getString(
		com.android.internal.R.string.config_wimaxStateTrackerClassname);

		if (DBG) log("wimaxJarLocation: " + wimaxJarLocation);
		wimaxClassLoader = new DexClassLoader(wimaxJarLocation,
		new ContextWrapper(context).getCacheDir().getAbsolutePath(),
		wimaxLibLocation, ClassLoader.getSystemClassLoader());

		try {
		wimaxManagerClass = wimaxClassLoader.loadClass(wimaxManagerClassName);
		wimaxStateTrackerClass = wimaxClassLoader.loadClass(wimaxStateTrackerClassName);
		wimaxServiceClass = wimaxClassLoader.loadClass(wimaxServiceClassName);
		} catch (ClassNotFoundException ex) {
		loge("Exception finding Wimax classes: " + ex.toString());
		return null;
		}
		} catch(Resources.NotFoundException ex) {
		loge("Wimax Resources does not exist!!! ");
		return null;
		}

		try {
		if (DBG) log("Starting Wimax Service... ");

		Constructor wmxStTrkrConst = wimaxStateTrackerClass.getConstructor
		(new Class[] {Context.class, Handler.class});
		wimaxStateTracker = (NetworkStateTracker) wmxStTrkrConst.newInstance(
		context, trackerHandler);

		Constructor wmxSrvConst = wimaxServiceClass.getDeclaredConstructor
		(new Class[] {Context.class, wimaxStateTrackerClass});
		wmxSrvConst.setAccessible(true);
		IBinder svcInvoker = (IBinder)wmxSrvConst.newInstance(context, wimaxStateTracker);
		wmxSrvConst.setAccessible(false);

		ServiceManager.addService(WimaxManagerConstants.WIMAX_SERVICE, svcInvoker);

		} catch(Exception ex) {
		loge("Exception creating Wimax classes: " + ex.toString());
		return null;
		}
		} else {
		loge("Wimax is not enabled or not added to the network attributes!!! ");
		return null;
		}

		return wimaxStateTracker;
		}

		private int getConnectivityChangeDelay() {
		final ContentResolver cr = mContext.getContentResolver();

services/tests/servicestests/src/com/android/server/ConnectivityServiceTest.java

+142 −141

Original line number	Diff line number	Diff line
		@@ -38,7 +38,6 @@ import android.net.LinkProperties;
		import android.net.NetworkConfig;
		import android.net.NetworkInfo;
		import android.net.NetworkInfo.DetailedState;
		import android.net.NetworkStateTracker;
		import android.net.RouteInfo;
		import android.os.Handler;
		import android.os.INetworkManagementService;
		@@ -77,152 +76,154 @@ public class ConnectivityServiceTest extends AndroidTestCase {
		private INetworkManagementService mNetManager;
		private INetworkStatsService mStatsService;
		private INetworkPolicyManager mPolicyService;
		private ConnectivityService.NetworkFactory mNetFactory;
		// private ConnectivityService.NetworkFactory mNetFactory;

		private BroadcastInterceptingContext mServiceContext;
		private ConnectivityService mService;

		private MockNetwork mMobile;
		private MockNetwork mWifi;

		private Handler mTrackerHandler;

		private static class MockNetwork {
		public NetworkStateTracker tracker;
		public NetworkInfo info;
		public LinkProperties link;

		public MockNetwork(int type) {
		tracker = mock(NetworkStateTracker.class);
		info = new NetworkInfo(type, -1, getNetworkTypeName(type), null);
		link = new LinkProperties();
		}

		public void doReturnDefaults() {
		// TODO: eventually CS should make defensive copies
		doReturn(new NetworkInfo(info)).when(tracker).getNetworkInfo();
		doReturn(new LinkProperties(link)).when(tracker).getLinkProperties();

		// fallback to default TCP buffers
		doReturn("").when(tracker).getTcpBufferSizesPropName();
		}
		}

		@Override
		public void setUp() throws Exception {
		super.setUp();

		mServiceContext = new BroadcastInterceptingContext(getContext());

		mNetManager = mock(INetworkManagementService.class);
		mStatsService = mock(INetworkStatsService.class);
		mPolicyService = mock(INetworkPolicyManager.class);
		mNetFactory = mock(ConnectivityService.NetworkFactory.class);

		mMobile = new MockNetwork(TYPE_MOBILE);
		mWifi = new MockNetwork(TYPE_WIFI);

		// omit most network trackers
		doThrow(new IllegalArgumentException("Not supported in test environment"))
		.when(mNetFactory).createTracker(anyInt(), isA(NetworkConfig.class));

		doReturn(mMobile.tracker)
		.when(mNetFactory).createTracker(eq(TYPE_MOBILE), isA(NetworkConfig.class));
		doReturn(mWifi.tracker)
		.when(mNetFactory).createTracker(eq(TYPE_WIFI), isA(NetworkConfig.class));

		final ArgumentCaptor<Handler> trackerHandler = ArgumentCaptor.forClass(Handler.class);
		doNothing().when(mMobile.tracker)
		.startMonitoring(isA(Context.class), trackerHandler.capture());

		mService = new ConnectivityService(
		mServiceContext, mNetManager, mStatsService, mPolicyService, mNetFactory);
		mService.systemReady();

		mTrackerHandler = trackerHandler.getValue();
		mTrackerHandler.getLooper().setMessageLogging(new LogPrinter(Log.INFO, TAG));
		}

		@Override
		public void tearDown() throws Exception {
		super.tearDown();
		}

		public void testMobileConnectedAddedRoutes() throws Exception {
		Future<?> nextConnBroadcast;

		// bring up mobile network
		mMobile.info.setDetailedState(DetailedState.CONNECTED, null, null);
		mMobile.link.setInterfaceName(MOBILE_IFACE);
		mMobile.link.addRoute(MOBILE_ROUTE_V4);
		mMobile.link.addRoute(MOBILE_ROUTE_V6);
		mMobile.doReturnDefaults();

		nextConnBroadcast = mServiceContext.nextBroadcastIntent(CONNECTIVITY_ACTION_IMMEDIATE);
		mTrackerHandler.obtainMessage(EVENT_STATE_CHANGED, mMobile.info).sendToTarget();
		nextConnBroadcast.get();

		// verify that both routes were added
		int mobileNetId = mMobile.tracker.getNetwork().netId;
		verify(mNetManager).addRoute(eq(mobileNetId), eq(MOBILE_ROUTE_V4));
		verify(mNetManager).addRoute(eq(mobileNetId), eq(MOBILE_ROUTE_V6));
		}

		public void testMobileWifiHandoff() throws Exception {
		Future<?> nextConnBroadcast;

		// bring up mobile network
		mMobile.info.setDetailedState(DetailedState.CONNECTED, null, null);
		mMobile.link.setInterfaceName(MOBILE_IFACE);
		mMobile.link.addRoute(MOBILE_ROUTE_V4);
		mMobile.link.addRoute(MOBILE_ROUTE_V6);
		mMobile.doReturnDefaults();

		nextConnBroadcast = mServiceContext.nextBroadcastIntent(CONNECTIVITY_ACTION_IMMEDIATE);
		mTrackerHandler.obtainMessage(EVENT_STATE_CHANGED, mMobile.info).sendToTarget();
		nextConnBroadcast.get();

		reset(mNetManager);

		// now bring up wifi network
		mWifi.info.setDetailedState(DetailedState.CONNECTED, null, null);
		mWifi.link.setInterfaceName(WIFI_IFACE);
		mWifi.link.addRoute(WIFI_ROUTE_V4);
		mWifi.link.addRoute(WIFI_ROUTE_V6);
		mWifi.doReturnDefaults();

		// expect that mobile will be torn down
		doReturn(true).when(mMobile.tracker).teardown();

		nextConnBroadcast = mServiceContext.nextBroadcastIntent(CONNECTIVITY_ACTION_IMMEDIATE);
		mTrackerHandler.obtainMessage(EVENT_STATE_CHANGED, mWifi.info).sendToTarget();
		nextConnBroadcast.get();

		// verify that wifi routes added, and teardown requested
		int wifiNetId = mWifi.tracker.getNetwork().netId;
		verify(mNetManager).addRoute(eq(wifiNetId), eq(WIFI_ROUTE_V4));
		verify(mNetManager).addRoute(eq(wifiNetId), eq(WIFI_ROUTE_V6));
		verify(mMobile.tracker).teardown();

		int mobileNetId = mMobile.tracker.getNetwork().netId;

		reset(mNetManager, mMobile.tracker);

		// tear down mobile network, as requested
		mMobile.info.setDetailedState(DetailedState.DISCONNECTED, null, null);
		mMobile.link.clear();
		mMobile.doReturnDefaults();

		nextConnBroadcast = mServiceContext.nextBroadcastIntent(CONNECTIVITY_ACTION_IMMEDIATE);
		mTrackerHandler.obtainMessage(EVENT_STATE_CHANGED, mMobile.info).sendToTarget();
		nextConnBroadcast.get();

		verify(mNetManager).removeRoute(eq(mobileNetId), eq(MOBILE_ROUTE_V4));
		verify(mNetManager).removeRoute(eq(mobileNetId), eq(MOBILE_ROUTE_V6));

		}
		// TODO: rework with network factory
		// private MockNetwork mMobile;
		// private MockNetwork mWifi;
		//
		// private Handler mTrackerHandler;
		//
		// private static class MockNetwork {
		// public NetworkStateTracker tracker;
		// public NetworkInfo info;
		// public LinkProperties link;
		//
		// public MockNetwork(int type) {
		// tracker = mock(NetworkStateTracker.class);
		// info = new NetworkInfo(type, -1, getNetworkTypeName(type), null);
		// link = new LinkProperties();
		// }
		//
		// public void doReturnDefaults() {
		// // TODO: eventually CS should make defensive copies
		// doReturn(new NetworkInfo(info)).when(tracker).getNetworkInfo();
		// doReturn(new LinkProperties(link)).when(tracker).getLinkProperties();
		//
		// // fallback to default TCP buffers
		// doReturn("").when(tracker).getTcpBufferSizesPropName();
		// }
		// }
		//
		// @Override
		// public void setUp() throws Exception {
		// super.setUp();
		//
		// mServiceContext = new BroadcastInterceptingContext(getContext());
		//
		// mNetManager = mock(INetworkManagementService.class);
		// mStatsService = mock(INetworkStatsService.class);
		// mPolicyService = mock(INetworkPolicyManager.class);
		// mNetFactory = mock(ConnectivityService.NetworkFactory.class);
		//
		// mMobile = new MockNetwork(TYPE_MOBILE);
		// mWifi = new MockNetwork(TYPE_WIFI);
		//
		// // omit most network trackers
		// doThrow(new IllegalArgumentException("Not supported in test environment"))
		// .when(mNetFactory).createTracker(anyInt(), isA(NetworkConfig.class));
		//
		// doReturn(mMobile.tracker)
		// .when(mNetFactory).createTracker(eq(TYPE_MOBILE), isA(NetworkConfig.class));
		// doReturn(mWifi.tracker)
		// .when(mNetFactory).createTracker(eq(TYPE_WIFI), isA(NetworkConfig.class));
		//
		// final ArgumentCaptor<Handler> trackerHandler = ArgumentCaptor.forClass(Handler.class);
		// doNothing().when(mMobile.tracker)
		// .startMonitoring(isA(Context.class), trackerHandler.capture());
		//
		// mService = new ConnectivityService(
		// mServiceContext, mNetManager, mStatsService, mPolicyService);
		// mService.systemReady();
		//
		// mTrackerHandler = trackerHandler.getValue();
		// mTrackerHandler.getLooper().setMessageLogging(new LogPrinter(Log.INFO, TAG));
		// }
		//
		// @Override
		// public void tearDown() throws Exception {
		// super.tearDown();
		// }
		//
		// public void testMobileConnectedAddedRoutes() throws Exception {
		// Future<?> nextConnBroadcast;
		//
		// // bring up mobile network
		// mMobile.info.setDetailedState(DetailedState.CONNECTED, null, null);
		// mMobile.link.setInterfaceName(MOBILE_IFACE);
		// mMobile.link.addRoute(MOBILE_ROUTE_V4);
		// mMobile.link.addRoute(MOBILE_ROUTE_V6);
		// mMobile.doReturnDefaults();
		//
		// nextConnBroadcast = mServiceContext.nextBroadcastIntent(CONNECTIVITY_ACTION_IMMEDIATE);
		// mTrackerHandler.obtainMessage(EVENT_STATE_CHANGED, mMobile.info).sendToTarget();
		// nextConnBroadcast.get();
		//
		// // verify that both routes were added
		// int mobileNetId = mMobile.tracker.getNetwork().netId;
		// verify(mNetManager).addRoute(eq(mobileNetId), eq(MOBILE_ROUTE_V4));
		// verify(mNetManager).addRoute(eq(mobileNetId), eq(MOBILE_ROUTE_V6));
		// }
		//
		// public void testMobileWifiHandoff() throws Exception {
		// Future<?> nextConnBroadcast;
		//
		// // bring up mobile network
		// mMobile.info.setDetailedState(DetailedState.CONNECTED, null, null);
		// mMobile.link.setInterfaceName(MOBILE_IFACE);
		// mMobile.link.addRoute(MOBILE_ROUTE_V4);
		// mMobile.link.addRoute(MOBILE_ROUTE_V6);
		// mMobile.doReturnDefaults();
		//
		// nextConnBroadcast = mServiceContext.nextBroadcastIntent(CONNECTIVITY_ACTION_IMMEDIATE);
		// mTrackerHandler.obtainMessage(EVENT_STATE_CHANGED, mMobile.info).sendToTarget();
		// nextConnBroadcast.get();
		//
		// reset(mNetManager);
		//
		// // now bring up wifi network
		// mWifi.info.setDetailedState(DetailedState.CONNECTED, null, null);
		// mWifi.link.setInterfaceName(WIFI_IFACE);
		// mWifi.link.addRoute(WIFI_ROUTE_V4);
		// mWifi.link.addRoute(WIFI_ROUTE_V6);
		// mWifi.doReturnDefaults();
		//
		// // expect that mobile will be torn down
		// doReturn(true).when(mMobile.tracker).teardown();
		//
		// nextConnBroadcast = mServiceContext.nextBroadcastIntent(CONNECTIVITY_ACTION_IMMEDIATE);
		// mTrackerHandler.obtainMessage(EVENT_STATE_CHANGED, mWifi.info).sendToTarget();
		// nextConnBroadcast.get();
		//
		// // verify that wifi routes added, and teardown requested
		// int wifiNetId = mWifi.tracker.getNetwork().netId;
		// verify(mNetManager).addRoute(eq(wifiNetId), eq(WIFI_ROUTE_V4));
		// verify(mNetManager).addRoute(eq(wifiNetId), eq(WIFI_ROUTE_V6));
		// verify(mMobile.tracker).teardown();
		//
		// int mobileNetId = mMobile.tracker.getNetwork().netId;
		//
		// reset(mNetManager, mMobile.tracker);
		//
		// // tear down mobile network, as requested
		// mMobile.info.setDetailedState(DetailedState.DISCONNECTED, null, null);
		// mMobile.link.clear();
		// mMobile.doReturnDefaults();
		//
		// nextConnBroadcast = mServiceContext.nextBroadcastIntent(CONNECTIVITY_ACTION_IMMEDIATE);
		// mTrackerHandler.obtainMessage(EVENT_STATE_CHANGED, mMobile.info).sendToTarget();
		// nextConnBroadcast.get();
		//
		// verify(mNetManager).removeRoute(eq(mobileNetId), eq(MOBILE_ROUTE_V4));
		// verify(mNetManager).removeRoute(eq(mobileNetId), eq(MOBILE_ROUTE_V6));
		//
		// }

		private static InetAddress parse(String addr) {
		return InetAddress.parseNumericAddress(addr);
		}

		}