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

Commit 7a26ba37 authored by Erik Kline's avatar Erik Kline
Browse files

Refactor isTetheringSupported() calls 

Tethering currently wants access to complex isTetheringSupported
logic that is only available in ConnectivityService. Instead of
trying to access that via ConnectivityManager, pass this capability
in to Tethering directly, in the TetheringDependencies object.

Also:
    - ConnectivityManager is only a source of static constants now,
      so "import static" all the constants that are actually used.

Test: as follows
    - built
    - flashed
    - booted
    - runtest frameworks-net works
    - manual USB towards WiFi tethering works
Bug: 68951715

Merged-In: Ifa121b057f9959ddb980edc940327929e48ea973
Merged-In: Iad6358dc2f1d10b322d22ec90543adc50882962d
Change-Id: Ia64faaadefb4a5d84a50da98bdebd544b6fda101
(cherry picked from commit 465ff3a0)
parent ea31cbea

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

+6 −1
Original line number Diff line number Diff line
@@ -910,7 +910,12 @@ public class ConnectivityService extends IConnectivityManager.Stub 


    private Tethering makeTethering() {

        // TODO: Move other elements into @Overridden getters.

        final TetheringDependencies deps = new TetheringDependencies();

        final TetheringDependencies deps = new TetheringDependencies() {

            @Override

            public boolean isTetheringSupported() {

                return ConnectivityService.this.isTetheringSupported();

            }

        };

        return new Tethering(mContext, mNetd, mStatsService, mPolicyManager,

                IoThread.get().getLooper(), new MockableSystemProperties(),

                deps);

services/core/java/com/android/server/connectivity/Tethering.java

+88 −78
Original line number Diff line number Diff line
@@ -19,6 +19,27 @@ package com.android.server.connectivity; 
import static android.hardware.usb.UsbManager.USB_CONFIGURED;

import static android.hardware.usb.UsbManager.USB_CONNECTED;

import static android.hardware.usb.UsbManager.USB_FUNCTION_RNDIS;

import static android.net.ConnectivityManager.ACTION_TETHER_STATE_CHANGED;

import static android.net.ConnectivityManager.CONNECTIVITY_ACTION;

import static android.net.ConnectivityManager.EXTRA_ACTIVE_LOCAL_ONLY;

import static android.net.ConnectivityManager.EXTRA_ACTIVE_TETHER;

import static android.net.ConnectivityManager.EXTRA_ADD_TETHER_TYPE;

import static android.net.ConnectivityManager.EXTRA_AVAILABLE_TETHER;

import static android.net.ConnectivityManager.EXTRA_ERRORED_TETHER;

import static android.net.ConnectivityManager.EXTRA_NETWORK_INFO;

import static android.net.ConnectivityManager.EXTRA_PROVISION_CALLBACK;

import static android.net.ConnectivityManager.EXTRA_REM_TETHER_TYPE;

import static android.net.ConnectivityManager.EXTRA_RUN_PROVISION;

import static android.net.ConnectivityManager.EXTRA_SET_ALARM;

import static android.net.ConnectivityManager.TETHER_ERROR_MASTER_ERROR;

import static android.net.ConnectivityManager.TETHER_ERROR_NO_ERROR;

import static android.net.ConnectivityManager.TETHER_ERROR_SERVICE_UNAVAIL;

import static android.net.ConnectivityManager.TETHER_ERROR_UNKNOWN_IFACE;

import static android.net.ConnectivityManager.TETHER_ERROR_UNAVAIL_IFACE;

import static android.net.ConnectivityManager.TETHERING_BLUETOOTH;

import static android.net.ConnectivityManager.TETHERING_INVALID;

import static android.net.ConnectivityManager.TETHERING_USB;

import static android.net.ConnectivityManager.TETHERING_WIFI;

import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;

import static android.net.wifi.WifiManager.EXTRA_WIFI_AP_INTERFACE_NAME;

import static android.net.wifi.WifiManager.EXTRA_WIFI_AP_MODE;
@@ -45,7 +66,6 @@ import android.content.Intent; 
import android.content.IntentFilter;

import android.content.res.Resources;

import android.hardware.usb.UsbManager;

import android.net.ConnectivityManager;

import android.net.INetworkPolicyManager;

import android.net.INetworkStatsService;

import android.net.IpPrefix;
@@ -148,7 +168,7 @@ public class Tethering extends BaseNetworkObserver { 
            stateMachine = sm;

            // Assume all state machines start out available and with no errors.

            lastState = IControlsTethering.STATE_AVAILABLE;

            lastError = ConnectivityManager.TETHER_ERROR_NO_ERROR;

            lastError = TETHER_ERROR_NO_ERROR;

        }



        public boolean isCurrentlyServing() {
@@ -216,7 +236,7 @@ public class Tethering extends BaseNetworkObserver { 


        final Handler smHandler = mTetherMasterSM.getHandler();

        mOffloadController = new OffloadController(smHandler,

                deps.getOffloadHardwareInterface(smHandler, mLog),

                mDeps.getOffloadHardwareInterface(smHandler, mLog),

                mContext.getContentResolver(), mNMService,

                mLog);

        mUpstreamNetworkMonitor = deps.getUpstreamNetworkMonitor(mContext, mTetherMasterSM, mLog,
@@ -243,7 +263,7 @@ public class Tethering extends BaseNetworkObserver { 
        mStateReceiver = new StateReceiver();

        filter = new IntentFilter();

        filter.addAction(UsbManager.ACTION_USB_STATE);

        filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);

        filter.addAction(CONNECTIVITY_ACTION);

        filter.addAction(WifiManager.WIFI_AP_STATE_CHANGED_ACTION);

        filter.addAction(Intent.ACTION_CONFIGURATION_CHANGED);

        mContext.registerReceiver(mStateReceiver, filter, null, smHandler);
@@ -265,12 +285,6 @@ public class Tethering extends BaseNetworkObserver { 
        updateConfiguration();

    }



    // We can't do this once in the Tethering() constructor and cache the value, because the

    // CONNECTIVITY_SERVICE is registered only after the Tethering() constructor has completed.

    private ConnectivityManager getConnectivityManager() {

        return (ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE);

    }



    private WifiManager getWifiManager() {

        return (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);

    }
@@ -296,7 +310,7 @@ public class Tethering extends BaseNetworkObserver { 
            if (up) {

                maybeTrackNewInterfaceLocked(iface);

            } else {

                if (ifaceNameToType(iface) == ConnectivityManager.TETHERING_BLUETOOTH) {

                if (ifaceNameToType(iface) == TETHERING_BLUETOOTH) {

                    stopTrackingInterfaceLocked(iface);

                } else {

                    // Ignore usb0 down after enabling RNDIS.
@@ -318,13 +332,13 @@ public class Tethering extends BaseNetworkObserver { 
        final TetheringConfiguration cfg = mConfig;



        if (cfg.isWifi(iface)) {

            return ConnectivityManager.TETHERING_WIFI;

            return TETHERING_WIFI;

        } else if (cfg.isUsb(iface)) {

            return ConnectivityManager.TETHERING_USB;

            return TETHERING_USB;

        } else if (cfg.isBluetooth(iface)) {

            return ConnectivityManager.TETHERING_BLUETOOTH;

            return TETHERING_BLUETOOTH;

        }

        return ConnectivityManager.TETHERING_INVALID;

        return TETHERING_INVALID;

    }



    @Override
@@ -426,26 +440,26 @@ public class Tethering extends BaseNetworkObserver { 
        boolean isProvisioningRequired = enable && isTetherProvisioningRequired();

        int result;

        switch (type) {

            case ConnectivityManager.TETHERING_WIFI:

            case TETHERING_WIFI:

                result = setWifiTethering(enable);

                if (isProvisioningRequired && result == ConnectivityManager.TETHER_ERROR_NO_ERROR) {

                if (isProvisioningRequired && result == TETHER_ERROR_NO_ERROR) {

                    scheduleProvisioningRechecks(type);

                }

                sendTetherResult(receiver, result);

                break;

            case ConnectivityManager.TETHERING_USB:

            case TETHERING_USB:

                result = setUsbTethering(enable);

                if (isProvisioningRequired && result == ConnectivityManager.TETHER_ERROR_NO_ERROR) {

                if (isProvisioningRequired && result == TETHER_ERROR_NO_ERROR) {

                    scheduleProvisioningRechecks(type);

                }

                sendTetherResult(receiver, result);

                break;

            case ConnectivityManager.TETHERING_BLUETOOTH:

            case TETHERING_BLUETOOTH:

                setBluetoothTethering(enable, receiver);

                break;

            default:

                Log.w(TAG, "Invalid tether type.");

                sendTetherResult(receiver, ConnectivityManager.TETHER_ERROR_UNKNOWN_IFACE);

                sendTetherResult(receiver, TETHER_ERROR_UNKNOWN_IFACE);

        }

    }
@@ -456,7 +470,7 @@ public class Tethering extends BaseNetworkObserver { 
    }



    private int setWifiTethering(final boolean enable) {

        int rval = ConnectivityManager.TETHER_ERROR_MASTER_ERROR;

        int rval = TETHER_ERROR_MASTER_ERROR;

        final long ident = Binder.clearCallingIdentity();

        try {

            synchronized (mPublicSync) {
@@ -464,7 +478,7 @@ public class Tethering extends BaseNetworkObserver { 
                final WifiManager mgr = getWifiManager();

                if ((enable && mgr.startSoftAp(null /* use existing wifi config */)) ||

                    (!enable && mgr.stopSoftAp())) {

                    rval = ConnectivityManager.TETHER_ERROR_NO_ERROR;

                    rval = TETHER_ERROR_NO_ERROR;

                }

            }

        } finally {
@@ -478,7 +492,7 @@ public class Tethering extends BaseNetworkObserver { 
        if (adapter == null || !adapter.isEnabled()) {

            Log.w(TAG, "Tried to enable bluetooth tethering with null or disabled adapter. null: " +

                    (adapter == null));

            sendTetherResult(receiver, ConnectivityManager.TETHER_ERROR_SERVICE_UNAVAIL);

            sendTetherResult(receiver, TETHER_ERROR_SERVICE_UNAVAIL);

            return;

        }
@@ -491,12 +505,12 @@ public class Tethering extends BaseNetworkObserver { 
                ((BluetoothPan) proxy).setBluetoothTethering(enable);

                // TODO: Enabling bluetooth tethering can fail asynchronously here.

                // We should figure out a way to bubble up that failure instead of sending success.

                int result = ((BluetoothPan) proxy).isTetheringOn() == enable ?

                        ConnectivityManager.TETHER_ERROR_NO_ERROR :

                        ConnectivityManager.TETHER_ERROR_MASTER_ERROR;

                final int result = (((BluetoothPan) proxy).isTetheringOn() == enable)

                        ? TETHER_ERROR_NO_ERROR

                        : TETHER_ERROR_MASTER_ERROR;

                sendTetherResult(receiver, result);

                if (enable && isTetherProvisioningRequired()) {

                    scheduleProvisioningRechecks(ConnectivityManager.TETHERING_BLUETOOTH);

                    scheduleProvisioningRechecks(TETHERING_BLUETOOTH);

                }

                adapter.closeProfileProxy(BluetoothProfile.PAN, proxy);

            }
@@ -510,8 +524,8 @@ public class Tethering extends BaseNetworkObserver { 


    private void sendUiTetherProvisionIntent(int type, ResultReceiver receiver) {

        Intent intent = new Intent(Settings.ACTION_TETHER_PROVISIONING);

        intent.putExtra(ConnectivityManager.EXTRA_ADD_TETHER_TYPE, type);

        intent.putExtra(ConnectivityManager.EXTRA_PROVISION_CALLBACK, receiver);

        intent.putExtra(EXTRA_ADD_TETHER_TYPE, type);

        intent.putExtra(EXTRA_PROVISION_CALLBACK, receiver);

        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

        final long ident = Binder.clearCallingIdentity();

        try {
@@ -534,7 +548,7 @@ public class Tethering extends BaseNetworkObserver { 
            @Override

            protected void onReceiveResult(int resultCode, Bundle resultData) {

                // If provisioning is successful, enable tethering, otherwise just send the error.

                if (resultCode == ConnectivityManager.TETHER_ERROR_NO_ERROR) {

                if (resultCode == TETHER_ERROR_NO_ERROR) {

                    enableTetheringInternal(type, true, receiver);

                } else {

                    sendTetherResult(receiver, resultCode);
@@ -554,8 +568,8 @@ public class Tethering extends BaseNetworkObserver { 


    private void scheduleProvisioningRechecks(int type) {

        Intent intent = new Intent();

        intent.putExtra(ConnectivityManager.EXTRA_ADD_TETHER_TYPE, type);

        intent.putExtra(ConnectivityManager.EXTRA_SET_ALARM, true);

        intent.putExtra(EXTRA_ADD_TETHER_TYPE, type);

        intent.putExtra(EXTRA_SET_ALARM, true);

        intent.setComponent(TETHER_SERVICE);

        final long ident = Binder.clearCallingIdentity();

        try {
@@ -572,9 +586,9 @@ public class Tethering extends BaseNetworkObserver { 


    private void sendSilentTetherProvisionIntent(int type, ResultReceiver receiver) {

        Intent intent = new Intent();

        intent.putExtra(ConnectivityManager.EXTRA_ADD_TETHER_TYPE, type);

        intent.putExtra(ConnectivityManager.EXTRA_RUN_PROVISION, true);

        intent.putExtra(ConnectivityManager.EXTRA_PROVISION_CALLBACK, receiver);

        intent.putExtra(EXTRA_ADD_TETHER_TYPE, type);

        intent.putExtra(EXTRA_RUN_PROVISION, true);

        intent.putExtra(EXTRA_PROVISION_CALLBACK, receiver);

        intent.setComponent(TETHER_SERVICE);

        final long ident = Binder.clearCallingIdentity();

        try {
@@ -585,9 +599,9 @@ public class Tethering extends BaseNetworkObserver { 
    }



    private void cancelTetherProvisioningRechecks(int type) {

        if (getConnectivityManager().isTetheringSupported()) {

        if (mDeps.isTetheringSupported()) {

            Intent intent = new Intent();

            intent.putExtra(ConnectivityManager.EXTRA_REM_TETHER_TYPE, type);

            intent.putExtra(EXTRA_REM_TETHER_TYPE, type);

            intent.setComponent(TETHER_SERVICE);

            final long ident = Binder.clearCallingIdentity();

            try {
@@ -602,8 +616,8 @@ public class Tethering extends BaseNetworkObserver { 
    // TODO: De-duplicate with above code, where possible.

    private void startProvisionIntent(int tetherType) {

        final Intent startProvIntent = new Intent();

        startProvIntent.putExtra(ConnectivityManager.EXTRA_ADD_TETHER_TYPE, tetherType);

        startProvIntent.putExtra(ConnectivityManager.EXTRA_RUN_PROVISION, true);

        startProvIntent.putExtra(EXTRA_ADD_TETHER_TYPE, tetherType);

        startProvIntent.putExtra(EXTRA_RUN_PROVISION, true);

        startProvIntent.setComponent(TETHER_SERVICE);

        mContext.startServiceAsUser(startProvIntent, UserHandle.CURRENT);

    }
@@ -618,13 +632,13 @@ public class Tethering extends BaseNetworkObserver { 
            TetherState tetherState = mTetherStates.get(iface);

            if (tetherState == null) {

                Log.e(TAG, "Tried to Tether an unknown iface: " + iface + ", ignoring");

                return ConnectivityManager.TETHER_ERROR_UNKNOWN_IFACE;

                return TETHER_ERROR_UNKNOWN_IFACE;

            }

            // Ignore the error status of the interface.  If the interface is available,

            // the errors are referring to past tethering attempts anyway.

            if (tetherState.lastState != IControlsTethering.STATE_AVAILABLE) {

                Log.e(TAG, "Tried to Tether an unavailable iface: " + iface + ", ignoring");

                return ConnectivityManager.TETHER_ERROR_UNAVAIL_IFACE;

                return TETHER_ERROR_UNAVAIL_IFACE;

            }

            // NOTE: If a CMD_TETHER_REQUESTED message is already in the TISM's

            // queue but not yet processed, this will be a no-op and it will not
@@ -633,7 +647,7 @@ public class Tethering extends BaseNetworkObserver { 
            // TODO: reexamine the threading and messaging model.

            tetherState.stateMachine.sendMessage(

                    TetherInterfaceStateMachine.CMD_TETHER_REQUESTED, requestedState);

            return ConnectivityManager.TETHER_ERROR_NO_ERROR;

            return TETHER_ERROR_NO_ERROR;

        }

    }
@@ -643,22 +657,22 @@ public class Tethering extends BaseNetworkObserver { 
            TetherState tetherState = mTetherStates.get(iface);

            if (tetherState == null) {

                Log.e(TAG, "Tried to Untether an unknown iface :" + iface + ", ignoring");

                return ConnectivityManager.TETHER_ERROR_UNKNOWN_IFACE;

                return TETHER_ERROR_UNKNOWN_IFACE;

            }

            if (!tetherState.isCurrentlyServing()) {

                Log.e(TAG, "Tried to untether an inactive iface :" + iface + ", ignoring");

                return ConnectivityManager.TETHER_ERROR_UNAVAIL_IFACE;

                return TETHER_ERROR_UNAVAIL_IFACE;

            }

            tetherState.stateMachine.sendMessage(

                    TetherInterfaceStateMachine.CMD_TETHER_UNREQUESTED);

            return ConnectivityManager.TETHER_ERROR_NO_ERROR;

            return TETHER_ERROR_NO_ERROR;

        }

    }



    public void untetherAll() {

        stopTethering(ConnectivityManager.TETHERING_WIFI);

        stopTethering(ConnectivityManager.TETHERING_USB);

        stopTethering(ConnectivityManager.TETHERING_BLUETOOTH);

        stopTethering(TETHERING_WIFI);

        stopTethering(TETHERING_USB);

        stopTethering(TETHERING_BLUETOOTH);

    }



    public int getLastTetherError(String iface) {
@@ -667,7 +681,7 @@ public class Tethering extends BaseNetworkObserver { 
            if (tetherState == null) {

                Log.e(TAG, "Tried to getLastTetherError on an unknown iface :" + iface +

                        ", ignoring");

                return ConnectivityManager.TETHER_ERROR_UNKNOWN_IFACE;

                return TETHER_ERROR_UNKNOWN_IFACE;

            }

            return tetherState.lastError;

        }
@@ -675,7 +689,7 @@ public class Tethering extends BaseNetworkObserver { 


    // TODO: Figure out how to update for local hotspot mode interfaces.

    private void sendTetherStateChangedBroadcast() {

        if (!getConnectivityManager().isTetheringSupported()) return;

        if (!mDeps.isTetheringSupported()) return;



        final ArrayList<String> availableList = new ArrayList<>();

        final ArrayList<String> tetherList = new ArrayList<>();
@@ -692,7 +706,7 @@ public class Tethering extends BaseNetworkObserver { 
            for (int i = 0; i < mTetherStates.size(); i++) {

                TetherState tetherState = mTetherStates.valueAt(i);

                String iface = mTetherStates.keyAt(i);

                if (tetherState.lastError != ConnectivityManager.TETHER_ERROR_NO_ERROR) {

                if (tetherState.lastError != TETHER_ERROR_NO_ERROR) {

                    erroredList.add(iface);

                } else if (tetherState.lastState == IControlsTethering.STATE_AVAILABLE) {

                    availableList.add(iface);
@@ -710,13 +724,13 @@ public class Tethering extends BaseNetworkObserver { 
                }

            }

        }

        final Intent bcast = new Intent(ConnectivityManager.ACTION_TETHER_STATE_CHANGED);

        final Intent bcast = new Intent(ACTION_TETHER_STATE_CHANGED);

        bcast.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING |

                Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);

        bcast.putStringArrayListExtra(ConnectivityManager.EXTRA_AVAILABLE_TETHER, availableList);

        bcast.putStringArrayListExtra(ConnectivityManager.EXTRA_ACTIVE_LOCAL_ONLY, localOnlyList);

        bcast.putStringArrayListExtra(ConnectivityManager.EXTRA_ACTIVE_TETHER, tetherList);

        bcast.putStringArrayListExtra(ConnectivityManager.EXTRA_ERRORED_TETHER, erroredList);

        bcast.putStringArrayListExtra(EXTRA_AVAILABLE_TETHER, availableList);

        bcast.putStringArrayListExtra(EXTRA_ACTIVE_LOCAL_ONLY, localOnlyList);

        bcast.putStringArrayListExtra(EXTRA_ACTIVE_TETHER, tetherList);

        bcast.putStringArrayListExtra(EXTRA_ERRORED_TETHER, erroredList);

        mContext.sendStickyBroadcastAsUser(bcast, UserHandle.ALL);

        if (DBG) {

            Log.d(TAG, String.format(
@@ -839,7 +853,7 @@ public class Tethering extends BaseNetworkObserver { 


            if (action.equals(UsbManager.ACTION_USB_STATE)) {

                handleUsbAction(intent);

            } else if (action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) {

            } else if (action.equals(CONNECTIVITY_ACTION)) {

                handleConnectivityAction(intent);

            } else if (action.equals(WifiManager.WIFI_AP_STATE_CHANGED_ACTION)) {

                handleWifiApAction(intent);
@@ -850,8 +864,8 @@ public class Tethering extends BaseNetworkObserver { 
        }



        private void handleConnectivityAction(Intent intent) {

            final NetworkInfo networkInfo = (NetworkInfo)intent.getParcelableExtra(

                    ConnectivityManager.EXTRA_NETWORK_INFO);

            final NetworkInfo networkInfo =

                    (NetworkInfo) intent.getParcelableExtra(EXTRA_NETWORK_INFO);

            if (networkInfo == null ||

                    networkInfo.getDetailedState() == NetworkInfo.DetailedState.FAILED) {

                return;
@@ -887,14 +901,10 @@ public class Tethering extends BaseNetworkObserver { 
            synchronized (Tethering.this.mPublicSync) {

                if (!usbConnected && mRndisEnabled) {

                    // Turn off tethering if it was enabled and there is a disconnect.

                    tetherMatchingInterfaces(

                            IControlsTethering.STATE_AVAILABLE,

                            ConnectivityManager.TETHERING_USB);

                    tetherMatchingInterfaces(IControlsTethering.STATE_AVAILABLE, TETHERING_USB);

                } else if (usbConfigured && rndisEnabled) {

                    // Tether if rndis is enabled and usb is configured.

                    tetherMatchingInterfaces(

                            IControlsTethering.STATE_TETHERED,

                            ConnectivityManager.TETHERING_USB);

                    tetherMatchingInterfaces(IControlsTethering.STATE_TETHERED, TETHERING_USB);

                }

                mRndisEnabled = usbConfigured && rndisEnabled;

            }
@@ -975,7 +985,7 @@ public class Tethering extends BaseNetworkObserver { 


        for (int i = 0; i < mTetherStates.size(); i++) {

            TetherInterfaceStateMachine tism = mTetherStates.valueAt(i).stateMachine;

            if (tism.interfaceType() == ConnectivityManager.TETHERING_WIFI) {

            if (tism.interfaceType() == TETHERING_WIFI) {

                tism.unwanted();

                return;

            }
@@ -1003,7 +1013,7 @@ public class Tethering extends BaseNetworkObserver { 
        }



        if (!TextUtils.isEmpty(ifname)) {

            maybeTrackNewInterfaceLocked(ifname, ConnectivityManager.TETHERING_WIFI);

            maybeTrackNewInterfaceLocked(ifname, TETHERING_WIFI);

            changeInterfaceState(ifname, ipServingMode);

        } else {

            mLog.e(String.format(
@@ -1062,7 +1072,7 @@ public class Tethering extends BaseNetworkObserver { 
                Log.wtf(TAG, "Unknown interface state: " + requestedState);

                return;

        }

        if (result != ConnectivityManager.TETHER_ERROR_NO_ERROR) {

        if (result != TETHER_ERROR_NO_ERROR) {

            Log.e(TAG, "unable start or stop tethering on iface " + ifname);

            return;

        }
@@ -1104,7 +1114,7 @@ public class Tethering extends BaseNetworkObserver { 
            usbManager.setCurrentFunctions(enable ? UsbManager.FUNCTION_RNDIS

                    : UsbManager.FUNCTION_NONE);

        }

        return ConnectivityManager.TETHER_ERROR_NO_ERROR;

        return TETHER_ERROR_NO_ERROR;

    }



    // TODO review API - figure out how to delete these entirely.
@@ -1143,7 +1153,7 @@ public class Tethering extends BaseNetworkObserver { 
        synchronized (mPublicSync) {

            for (int i = 0; i < mTetherStates.size(); i++) {

                TetherState tetherState = mTetherStates.valueAt(i);

                if (tetherState.lastError != ConnectivityManager.TETHER_ERROR_NO_ERROR) {

                if (tetherState.lastError != TETHER_ERROR_NO_ERROR) {

                    list.add(mTetherStates.keyAt(i));

                }

            }
@@ -1189,7 +1199,7 @@ public class Tethering extends BaseNetworkObserver { 
                }

                String iface = mTetherStates.keyAt(i);

                int interfaceType = ifaceNameToType(iface);

                if (interfaceType != ConnectivityManager.TETHERING_INVALID) {

                if (interfaceType != TETHERING_INVALID) {

                    tethered.add(interfaceType);

                }

            }
@@ -1439,7 +1449,7 @@ public class Tethering extends BaseNetworkObserver { 
            }



            // If this is a Wi-Fi interface, notify WifiManager of the active serving state.

            if (who.interfaceType() == ConnectivityManager.TETHERING_WIFI) {

            if (who.interfaceType() == TETHERING_WIFI) {

                final WifiManager mgr = getWifiManager();

                final String iface = who.interfaceName();

                switch (mode) {
@@ -1463,8 +1473,8 @@ public class Tethering extends BaseNetworkObserver { 
            mForwardedDownstreams.remove(who);



            // If this is a Wi-Fi interface, tell WifiManager of any errors.

            if (who.interfaceType() == ConnectivityManager.TETHERING_WIFI) {

                if (who.lastError() != ConnectivityManager.TETHER_ERROR_NO_ERROR) {

            if (who.interfaceType() == TETHERING_WIFI) {

                if (who.lastError() != TETHER_ERROR_NO_ERROR) {

                    getWifiManager().updateInterfaceIpState(

                            who.interfaceName(), IFACE_IP_MODE_CONFIGURATION_ERROR);

                }
@@ -1669,7 +1679,7 @@ public class Tethering extends BaseNetworkObserver { 
                        who.sendMessage(mErrorNotification);

                        break;

                    case CMD_CLEAR_ERROR:

                        mErrorNotification = ConnectivityManager.TETHER_ERROR_NO_ERROR;

                        mErrorNotification = TETHER_ERROR_NO_ERROR;

                        transitionTo(mInitialState);

                        break;

                    default:
@@ -1931,7 +1941,7 @@ public class Tethering extends BaseNetworkObserver { 
        // If TetherMasterSM is in ErrorState, TetherMasterSM stays there.

        // Thus we give a chance for TetherMasterSM to recover to InitialState

        // by sending CMD_CLEAR_ERROR

        if (error == ConnectivityManager.TETHER_ERROR_MASTER_ERROR) {

        if (error == TETHER_ERROR_MASTER_ERROR) {

            mTetherMasterSM.sendMessage(TetherMasterSM.CMD_CLEAR_ERROR, who);

        }

        int which;
@@ -1975,7 +1985,7 @@ public class Tethering extends BaseNetworkObserver { 
    private void maybeTrackNewInterfaceLocked(final String iface) {

        // If we don't care about this type of interface, ignore.

        final int interfaceType = ifaceNameToType(iface);

        if (interfaceType == ConnectivityManager.TETHERING_INVALID) {

        if (interfaceType == TETHERING_INVALID) {

            mLog.log(iface + " is not a tetherable iface, ignoring");

            return;

        }

services/core/java/com/android/server/connectivity/tethering/TetheringDependencies.java

+4 −0
Original line number Diff line number Diff line
@@ -60,4 +60,8 @@ public class TetheringDependencies { 
    public INetd getNetdService() {

        return NetdService.getInstance();

    }



    public boolean isTetheringSupported() {

        return true;

    }

}