LineageOS/android_packages_modules_Connectivity
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove dead code 2.

Browse Source 
Removing ConnectivityService.NetworkFactory.  This requires disabling
the ConnectivityServiceTest, but that's been broken since we stopped
using NetworkStateTrackers anyway.

Change-Id: I9b86bd37eb9d018c40f60dca5b00d62c36d4e3ad
This commit is contained in:
Robert Greenwalt
2014-07-27 12:06:40 -07:00
parent 73b0009b50
commit 00c1c93a3e
2 changed files with 143 additions and 326 deletions
Download Patch File Download Diff File Expand all files Collapse all files

186
services/core/java/com/android/server/ConnectivityService.java
View File

@@ -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();

283
services/tests/servicestests/src/com/android/server/ConnectivityServiceTest.java
View File

@@ -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);
}
}