Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6831f1d8 authored by Robert Greenwalt's avatar Robert Greenwalt
Browse files

Remove dead code 2. 

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

Change-Id: I9b86bd37eb9d018c40f60dca5b00d62c36d4e3ad
parent 9e614364

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

    }



}