android-13.0.0_r83/s

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

package com.android.server.wifi;

import static com.android.server.wifi.ActiveModeManager.ROLE_CLIENT_PRIMARY;
import static com.android.server.wifi.ActiveModeManager.ROLE_CLIENT_SECONDARY_LONG_LIVED;

import android.annotation.IntDef;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.content.Context;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Handler;
import android.os.WorkSource;
import android.util.Log;
import android.util.SparseArray;

import com.android.internal.annotations.VisibleForTesting;
import com.android.modules.utils.build.SdkLevel;

import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

/**
 * Manages STA + STA for multi internet networks.
 */
public class MultiInternetManager {
    private static final String TAG = "WifiMultiInternet";

    private final ActiveModeWarden mActiveModeWarden;
    private final FrameworkFacade mFrameworkFacade;
    private final Context mContext;
    private final ClientModeImplMonitor mCmiMonitor;
    private final WifiSettingsStore mSettingsStore;
    private final Handler mEventHandler;
    private final Clock mClock;
    private int mStaConcurrencyMultiInternetMode = WifiManager.WIFI_MULTI_INTERNET_MODE_DISABLED;
    @MultiInternetState
    private int mMultiInternetConnectionState = MULTI_INTERNET_STATE_NONE;
    private ConnectionStatusListener mConnectionStatusListener;

    private SparseArray<NetworkConnectionState> mNetworkConnectionStates = new SparseArray<>();
    private boolean mVerboseLoggingEnabled = false;

    /** No multi internet connection needed. */
    public static final int MULTI_INTERNET_STATE_NONE = 0;
    /** Multi internet connection is connecting. */
    public static final int MULTI_INTERNET_STATE_CONNECTION_REQUESTED = 1;
    /** No multi internet connection is connected. */
    public static final int MULTI_INTERNET_STATE_CONNECTED = 2;
    /** @hide */
    @Retention(RetentionPolicy.SOURCE)
    @IntDef(prefix = {"MULTI_INTERNET_STATE_"}, value = {
            MULTI_INTERNET_STATE_NONE,
            MULTI_INTERNET_STATE_CONNECTION_REQUESTED,
            MULTI_INTERNET_STATE_CONNECTED})
    public @interface MultiInternetState {}

    /** The internal network connection state per each Wi-Fi band. */
    class NetworkConnectionState {
        // If the supplicant connection is completed.
        private boolean mConnected;
        // If the internet has been validated.
        private boolean mValidated;
        // The connection start time in millisecond
        public long connectionStartTimeMillis;
        // The WorkSource of the connection requestor.
        public WorkSource requestorWorkSource;

        NetworkConnectionState(WorkSource workSource) {
            this(workSource, -1L);
        }

        NetworkConnectionState(WorkSource workSource, long connectionStartTime) {
            requestorWorkSource = workSource;
            connectionStartTimeMillis = connectionStartTime;

            mConnected = false;
            mValidated = false;
        }

        public NetworkConnectionState setConnected(boolean connected) {
            mConnected = connected;
            return this;
        }

        @VisibleForTesting
        public boolean isConnected() {
            return mConnected;
        }

        public NetworkConnectionState setValidated(boolean validated) {
            mValidated = validated;
            return this;
        }

        @VisibleForTesting
        public boolean isValidated() {
            return mValidated;
        }
    }

    @VisibleForTesting
    SparseArray<NetworkConnectionState> getNetworkConnectionState() {
        return mNetworkConnectionStates;
    }

    /** The Multi Internet Connection Status Listener. The registered listener will be notified
     * for the connection status change and scan needed. */
    public interface ConnectionStatusListener {
        /** Called when connection status changed */
        void onStatusChange(
                @MultiInternetManager.MultiInternetState int state,
                WorkSource requestorWs);
        /** Called when a scan is needed */
        void onStartScan(WorkSource requestorWs);
    }

    @Nullable private WorkSource getRequestorWorkSource(int band) {
        if (!mNetworkConnectionStates.contains(band)) {
            return null;
        }
        return mNetworkConnectionStates.get(band).requestorWorkSource;
    }

    private class ModeChangeCallback implements ActiveModeWarden.ModeChangeCallback {
        @Override
        public void onActiveModeManagerAdded(@NonNull ActiveModeManager activeModeManager) {
            if (!mActiveModeWarden.isStaStaConcurrencySupportedForMultiInternet()
                    || !isStaConcurrencyForMultiInternetEnabled()) {
                return;
            }
            if (!(activeModeManager instanceof ConcreteClientModeManager)) {
                return;
            }
            final ConcreteClientModeManager ccm = (ConcreteClientModeManager) activeModeManager;
            // TODO: b/197670907 : Add client role ROLE_CLIENT_SECONDARY_INTERNET
            if (ccm.getRole() != ROLE_CLIENT_SECONDARY_LONG_LIVED || !ccm.isSecondaryInternet()) {
                return;
            }
            if (mVerboseLoggingEnabled) {
                Log.v(TAG, "Secondary ClientModeManager created for internet, connecting!");
            }
            updateNetworkConnectionStates();
        }

        @Override
        public void onActiveModeManagerRemoved(@NonNull ActiveModeManager activeModeManager) {
            if (!mActiveModeWarden.isStaStaConcurrencySupportedForMultiInternet()
                    || !isStaConcurrencyForMultiInternetEnabled()) {
                return;
            }
            if (!(activeModeManager instanceof ConcreteClientModeManager)) {
                return;
            }
            final ConcreteClientModeManager ccm = (ConcreteClientModeManager) activeModeManager;
            // TODO: b/197670907 : Add client role ROLE_CLIENT_SECONDARY_INTERNET
            if (ccm.getRole() != ROLE_CLIENT_SECONDARY_LONG_LIVED || !ccm.isSecondaryInternet()) {
                return;
            }
            if (mVerboseLoggingEnabled) {
                Log.v(TAG, "ClientModeManager for internet removed");
            }
            // A secondary cmm was removed because of the connection was lost, start scan
            // to find the new network connection.
            updateNetworkConnectionStates();
            if (hasPendingConnectionRequests()) {
                startConnectivityScan();
            }
        }

        @Override
        public void onActiveModeManagerRoleChanged(@NonNull ActiveModeManager activeModeManager) {
            if (!mActiveModeWarden.isStaStaConcurrencySupportedForMultiInternet()
                    || !isStaConcurrencyForMultiInternetEnabled()) {
                return;
            }
            if (!(activeModeManager instanceof ConcreteClientModeManager)) {
                return;
            }
            final ConcreteClientModeManager ccm = (ConcreteClientModeManager) activeModeManager;
            if (ccm.getPreviousRole() == ROLE_CLIENT_SECONDARY_LONG_LIVED
                    && ccm.isSecondaryInternet()) {
                Log.w(TAG, "Secondary client mode manager changed role to "
                        + ccm.getRole());
            }
            updateNetworkConnectionStates();
        }
    }

    private class ClientModeListenerInternal implements ClientModeImplListener {
        @Override
        public void onInternetValidated(@NonNull ConcreteClientModeManager clientModeManager) {
            if (!mActiveModeWarden.isStaStaConcurrencySupportedForMultiInternet()
                    || !isStaConcurrencyForMultiInternetEnabled()) {
                return;
            }
            final WifiInfo info = clientModeManager.syncRequestConnectionInfo();
            if (info != null) {
                final int band = ScanResult.toBand(info.getFrequency());
                if (mNetworkConnectionStates.contains(band)) {
                    mNetworkConnectionStates.get(band).setValidated(true);
                }
            }
            if (mVerboseLoggingEnabled) {
                Log.v(TAG, "ClientModeManager role " + clientModeManager.getRole()
                        + " internet validated for connection");
            }
            // If the primary role was connected and internet validated, update the connection state
            // immediately and issue scan for secondary network connection if needed.
            // If the secondary role was connected and internet validated, update the connection
            // state and notify connectivity manager.
            // TODO: b/197670907 : Add client role ROLE_CLIENT_SECONDARY_INTERNET
            if (clientModeManager.getRole() == ROLE_CLIENT_PRIMARY) {
                updateNetworkConnectionStates();
                final int band = findUnconnectedRequestBand();
                if (band != ScanResult.UNSPECIFIED) {
                    // Trigger the connectivity scan
                    mConnectionStatusListener.onStartScan(getRequestorWorkSource(band));
                }
            } else if (clientModeManager.getRole() == ROLE_CLIENT_SECONDARY_LONG_LIVED
                    && clientModeManager.isSecondaryInternet()) {
                updateNetworkConnectionStates();
            }
        }

        // TODO(b/175896748): not yet triggered by ClientModeImpl
        @Override
        public void onL3Connected(@NonNull ConcreteClientModeManager clientModeManager) {
            if (!mActiveModeWarden.isStaStaConcurrencySupportedForMultiInternet()
                    || !isStaConcurrencyForMultiInternetEnabled()) {
                return;
            }
            // TODO: b/197670907 : Add client role ROLE_CLIENT_SECONDARY_INTERNET
            if (clientModeManager.getRole() != ROLE_CLIENT_SECONDARY_LONG_LIVED
                    || !clientModeManager.isSecondaryInternet()) {
                return;
            }
            updateNetworkConnectionStates();
            // If no pending connection requests, update connection listener.
            if (!hasPendingConnectionRequests()) {
                final int band = getSecondaryConnectedNetworkBand();
                if (band == ScanResult.UNSPECIFIED) return;
                final long connectionTime = mClock.getElapsedSinceBootMillis()
                        - mNetworkConnectionStates.get(band).connectionStartTimeMillis;
                if (mVerboseLoggingEnabled) {
                    Log.v(TAG, "ClientModeManager for internet L3 connected for "
                            + connectionTime + " ms.");
                }
                handleConnectionStateChange(MULTI_INTERNET_STATE_CONNECTED,
                        getRequestorWorkSource(band));
            }
        }

        @Override
        public void onConnectionEnd(@NonNull ConcreteClientModeManager clientModeManager) {
            if (!mActiveModeWarden.isStaStaConcurrencySupportedForMultiInternet()
                    || !isStaConcurrencyForMultiInternetEnabled()) {
                return;
            }
            if (clientModeManager.getRole() == ROLE_CLIENT_PRIMARY) {
                if (mVerboseLoggingEnabled) {
                    Log.v(TAG, "Connection end on primary client mode manager");
                }
                // When the primary network connection is ended, disconnect the secondary network,
                // as the secondary network is opportunistic.
                // TODO: b/197670907 : Add client role ROLE_CLIENT_SECONDARY_INTERNET
                for (ConcreteClientModeManager cmm : mActiveModeWarden.getClientModeManagersInRoles(
                        ROLE_CLIENT_SECONDARY_LONG_LIVED)) {
                    if (cmm.isSecondaryInternet()) {
                        if (mVerboseLoggingEnabled) {
                            Log.v(TAG, "Disconnect secondary client mode manager");
                        }
                        cmm.disconnect();
                    }
                }
                // As the secondary network is disconnected, mark all bands as disconnected.
                for (int i = 0; i < mNetworkConnectionStates.size(); i++) {
                    mNetworkConnectionStates.valueAt(i).setConnected(false);
                }
            }
            updateNetworkConnectionStates();
        }
    }

    public MultiInternetManager(
            @NonNull ActiveModeWarden activeModeWarden,
            @NonNull FrameworkFacade frameworkFacade,
            @NonNull Context context,
            @NonNull ClientModeImplMonitor cmiMonitor,
            @NonNull WifiSettingsStore settingsStore,
            @NonNull Handler handler,
            @NonNull Clock clock) {
        mActiveModeWarden = activeModeWarden;
        mFrameworkFacade = frameworkFacade;
        mContext = context;
        mCmiMonitor = cmiMonitor;
        mSettingsStore = settingsStore;
        mEventHandler = handler;
        mClock = clock;
        mActiveModeWarden.registerModeChangeCallback(new ModeChangeCallback());
        cmiMonitor.registerListener(new ClientModeListenerInternal());
        mStaConcurrencyMultiInternetMode = mSettingsStore.getWifiMultiInternetMode();
    }

    /**
     * Check if Wi-Fi multi internet use case is enabled.
     *
     * @return true if Wi-Fi multi internet use case is enabled.
     */
    public boolean isStaConcurrencyForMultiInternetEnabled() {
        return mStaConcurrencyMultiInternetMode
            != WifiManager.WIFI_MULTI_INTERNET_MODE_DISABLED;
    }

    /**
     * Check if Wi-Fi multi internet use case allows multi AP.
     *
     * @return true if Wi-Fi multi internet use case allows multi AP.
     */
    public boolean isStaConcurrencyForMultiInternetMultiApAllowed() {
        return mStaConcurrencyMultiInternetMode
                == WifiManager.WIFI_MULTI_INTERNET_MODE_MULTI_AP;
    }

    /**
     * Return Wi-Fi multi internet use case mode.
     *
     * @return Current mode of Wi-Fi multi internet use case.
     */
    public @WifiManager.WifiMultiInternetMode int getStaConcurrencyForMultiInternetMode() {
        if (mActiveModeWarden.isStaStaConcurrencySupportedForMultiInternet()) {
            return mStaConcurrencyMultiInternetMode;
        }
        return WifiManager.WIFI_MULTI_INTERNET_MODE_DISABLED;
    }

    /**
     * Set the multi internet use case mode.
     * @return true if the mode set successfully, false if failed.
     */
    public boolean setStaConcurrencyForMultiInternetMode(
            @WifiManager.WifiMultiInternetMode int mode) {
        final boolean enabled = (mode != WifiManager.WIFI_MULTI_INTERNET_MODE_DISABLED);
        if (!mActiveModeWarden.isStaStaConcurrencySupportedForMultiInternet()) {
            return false;
        }

        if (mode == mStaConcurrencyMultiInternetMode) {
            return true;
        }
        // If the STA+STA multi internet feature was disabled, disconnect the secondary cmm.
        // TODO: b/197670907 : Add client role ROLE_CLIENT_SECONDARY_INTERNET
        if (!enabled) {
            for (ConcreteClientModeManager cmm : mActiveModeWarden.getClientModeManagersInRoles(
                    ROLE_CLIENT_SECONDARY_LONG_LIVED)) {
                if (cmm.isSecondaryInternet()) {
                    cmm.disconnect();
                }
            }
            for (int i = 0; i < mNetworkConnectionStates.size(); i++) {
                // Clear the connection state for all bands.
                mNetworkConnectionStates.setValueAt(i, new NetworkConnectionState(null));
            }
            handleConnectionStateChange(MULTI_INTERNET_STATE_NONE, null);
        } else {
            updateNetworkConnectionStates();
            final int band = findUnconnectedRequestBand();
            if (band != ScanResult.UNSPECIFIED) {
                handleConnectionStateChange(MULTI_INTERNET_STATE_CONNECTION_REQUESTED,
                        getRequestorWorkSource(band));
            }
        }
        mStaConcurrencyMultiInternetMode = mode;
        mSettingsStore.handleWifiMultiInternetMode(mode);
        // Check if there is already multi internet request then start scan for connection.
        if (hasPendingConnectionRequests()) {
            startConnectivityScan();
        }
        return true;
    }

    public void setVerboseLoggingEnabled(boolean enabled) {
        mVerboseLoggingEnabled = enabled;
    }

    /** Set the Multi Internet Connection Status listener.
     *
     * @param listener The Multi Internet Connection Status listener.
     */
    public void setConnectionStatusListener(ConnectionStatusListener listener) {
        mConnectionStatusListener = listener;
    }

    /** Notify the BSSID associated event from ClientModeImpl. Triggered by
     *  WifiMonitor.ASSOCIATED_BSSID_EVENT.
     *  @param clientModeManager the client mode manager with BSSID associated event.
     */
    public void notifyBssidAssociatedEvent(ConcreteClientModeManager clientModeManager) {
        if (clientModeManager.getRole() != ROLE_CLIENT_PRIMARY
                || !mActiveModeWarden.isStaStaConcurrencySupportedForMultiInternet()
                || !isStaConcurrencyForMultiInternetEnabled()) {
            return;
        }
        // If primary CMM has associated to a new BSSID, need to check if it is in a different band
        // of secondary CMM.
        final WifiInfo info = clientModeManager.syncRequestConnectionInfo();
        final ConcreteClientModeManager secondaryCcmm =
                mActiveModeWarden.getClientModeManagerInRole(ROLE_CLIENT_SECONDARY_LONG_LIVED);
        // If no secondary client mode manager then it's ok
        if (secondaryCcmm == null) return;
        // If secondary client mode manager is not connected or not for secondary internet
        if (!secondaryCcmm.isConnected() || !secondaryCcmm.isSecondaryInternet()) return;
        final WifiInfo info2 = secondaryCcmm.syncRequestConnectionInfo();
        // If secondary network is in same band as primary now
        if (ScanResult.toBand(info.getFrequency()) == ScanResult.toBand(info2.getFrequency())) {
            // Need to disconnect secondary network
            secondaryCcmm.disconnect();
            // As the secondary network is disconnected, mark all bands as disconnected.
            for (int i = 0; i < mNetworkConnectionStates.size(); i++) {
                mNetworkConnectionStates.valueAt(i).setConnected(false);
            }
            updateNetworkConnectionStates();
        }
    }

    /** Check if there is a connection request for multi internet
     * @return true if there is one or more connection request
     */
    public boolean hasPendingConnectionRequests() {
        return findUnconnectedRequestBand() != ScanResult.UNSPECIFIED;
    }

    /**
     * Check if there is connection request on a specific band.
     * @param band The band for the connection request.
     * @return true if there is connection request on specific band.
     */
    public boolean hasConnectionRequest(int band) {
        return mNetworkConnectionStates.contains(band)
                ? (getRequestorWorkSource(band) != null) : false;
    }

    /**
     * Check if there is unconnected network connection request.
     * @return the band of the connection request that is still not connected.
     */
    public int findUnconnectedRequestBand() {
        for (int i = 0; i < mNetworkConnectionStates.size(); i++) {
            if (!mNetworkConnectionStates.valueAt(i).isConnected()) {
                return mNetworkConnectionStates.keyAt(i);
            }
        }
        return ScanResult.UNSPECIFIED;
    }

    /**
     * Traverse the client mode managers and update the internal connection states.
     */
    private void updateNetworkConnectionStates() {
        for (int i = 0; i < mNetworkConnectionStates.size(); i++) {
            mNetworkConnectionStates.valueAt(i).setConnected(false);
        }

        for (ClientModeManager clientModeManager :
                mActiveModeWarden.getInternetConnectivityClientModeManagers()) {
            // TODO: b/197670907 : Add client role ROLE_CLIENT_SECONDARY_INTERNET
            if (clientModeManager instanceof ConcreteClientModeManager
                    && (clientModeManager.getRole() == ROLE_CLIENT_PRIMARY
                    || clientModeManager.getRole() == ROLE_CLIENT_SECONDARY_LONG_LIVED)) {
                ConcreteClientModeManager ccmm = (ConcreteClientModeManager) clientModeManager;
                // Exclude the secondary client mode manager not for secondary internet.
                if (ccmm.getRole() == ROLE_CLIENT_SECONDARY_LONG_LIVED
                        && !ccmm.isSecondaryInternet()) {
                    continue;
                }
                WifiInfo info = clientModeManager.syncRequestConnectionInfo();
                // Exclude the network that is not connected or restricted.
                if (info == null || !clientModeManager.isConnected()
                        ||  info.isRestricted()) continue;
                // Exclude the network that is oem paid/private.
                if (SdkLevel.isAtLeastT() && (info.isOemPaid() || info.isOemPrivate())) continue;
                final int band = ScanResult.toBand(info.getFrequency());
                if (mNetworkConnectionStates.contains(band)) {
                    // Update the connected state
                    mNetworkConnectionStates.get(band).setConnected(true);
                }
                if (mVerboseLoggingEnabled) {
                    Log.v(TAG, "network band " + band + " role "
                            + clientModeManager.getRole().toString());
                }
            }
        }
        // Handle the state change and notify listener
        if (!hasPendingConnectionRequests()) {
            if (mNetworkConnectionStates.size() == 0) {
                handleConnectionStateChange(MULTI_INTERNET_STATE_NONE, null);
            } else {
                final int band = getSecondaryConnectedNetworkBand();
                if (band == ScanResult.UNSPECIFIED) return;
                handleConnectionStateChange(MULTI_INTERNET_STATE_CONNECTED,
                        getRequestorWorkSource(band));
            }
        } else {
            final int band = findUnconnectedRequestBand();
            handleConnectionStateChange(MULTI_INTERNET_STATE_CONNECTION_REQUESTED,
                    getRequestorWorkSource(band));
        }
    }

    /**
     * Set a network connection request from a requestor WorkSource for a specific band, or clear
     * the connection request if the WorkSource is null.
     * Triggered when {@link MultiInternetWifiNetworkFactory} has a pending network request.
     * @param band The band of the Wi-Fi network requested.
     * @param requestorWs The requestor's WorkSource. Null to clear a network request for a
     * a band.
     */
    public void setMultiInternetConnectionWorksource(int band, WorkSource requestorWs) {
        if (!isStaConcurrencyForMultiInternetEnabled()) {
            Log.w(TAG, "MultInternet is not enabled.");
            return;
        }
        if (mVerboseLoggingEnabled) {
            Log.v(TAG, "setMultiInternetConnectionWorksource: band=" + band + ", requestorWs="
                    + requestorWs);
        }
        if (requestorWs == null) {
            // Disconnect secondary network if the request is removed.
            if (band == getSecondaryConnectedNetworkBand()) {
                for (ConcreteClientModeManager cmm : mActiveModeWarden.getClientModeManagersInRoles(
                        ROLE_CLIENT_SECONDARY_LONG_LIVED)) {
                    if (cmm.isSecondaryInternet()) {
                        cmm.disconnect();
                    }
                }
            }
            mNetworkConnectionStates.remove(band);
            updateNetworkConnectionStates();
            return;
        }
        if (mNetworkConnectionStates.contains(band)) {
            Log.w(TAG, "band " + band + " already requested.");
        }
        mNetworkConnectionStates.put(band, new NetworkConnectionState(requestorWs,
                    mClock.getElapsedSinceBootMillis()));
        startConnectivityScan();
    }

    /** Returns the band of the secondary network connected. */
    private int getSecondaryConnectedNetworkBand() {
        final ConcreteClientModeManager secondaryCcmm =
                mActiveModeWarden.getClientModeManagerInRole(ROLE_CLIENT_SECONDARY_LONG_LIVED);
        if (secondaryCcmm == null) {
            return ScanResult.UNSPECIFIED;
        }
        final WifiInfo info = secondaryCcmm.syncRequestConnectionInfo();
        // Make sure secondary network is connected.
        if (info == null || !secondaryCcmm.isConnected() || !secondaryCcmm.isSecondaryInternet()) {
            return ScanResult.UNSPECIFIED;
        }
        return ScanResult.toBand(info.getFrequency());
    }

    /**
     * Handles the connection state change and notifies the status listener.
     * The listener will only be notified when the state changes. If the state remains the same
     * but with a different requestor WorkSource then the listener is not notified.
     *
     * @param state
     * @param workSource
     */
    private void handleConnectionStateChange(int state, WorkSource workSource) {
        if (mMultiInternetConnectionState == state) {
            return;
        }
        mMultiInternetConnectionState = state;
        mConnectionStatusListener.onStatusChange(state, workSource);
    }

    /**
     * Start a connectivity scan to trigger the network selection process and connect to
     * the requested multi internet networks.
     */
    private void startConnectivityScan() {
        if (!isStaConcurrencyForMultiInternetEnabled()) {
            return;
        }
        updateNetworkConnectionStates();

        final int band = findUnconnectedRequestBand();
        if (band == ScanResult.UNSPECIFIED) return;
        NetworkConnectionState state = mNetworkConnectionStates.get(band);
        if (mVerboseLoggingEnabled) {
            Log.v(TAG, "Schedule connectivity scan for network request with band " + band
                    + " start time " + state.connectionStartTimeMillis + " now "
                    + mClock.getElapsedSinceBootMillis());
        }
        // Trigger the connectivity scan
        mConnectionStatusListener.onStartScan(getRequestorWorkSource(band));
    }

    /** Dump the internal states of MultiInternetManager */
    public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
        pw.println("Dump of MultiInternetManager");
        pw.println(TAG + ": mStaConcurrencyMultiInternetMode "
                + mStaConcurrencyMultiInternetMode);
        for (int i = 0; i < mNetworkConnectionStates.size(); i++) {
            pw.println("band " + mNetworkConnectionStates.keyAt(i) + " connected "
                    + mNetworkConnectionStates.valueAt(i).isConnected()
                    + " validated " + mNetworkConnectionStates.valueAt(i).isValidated());
        }
    }

}