/* * Copyright (C) 2016 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 android.net.wifi.WifiManager.SAP_CLIENT_DISCONNECT_REASON_CODE_UNSPECIFIED; import android.annotation.NonNull; import android.annotation.Nullable; import android.app.compat.CompatChanges; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.net.MacAddress; import android.net.wifi.OuiKeyedData; import android.net.wifi.ScanResult; import android.net.wifi.SoftApCapability; import android.net.wifi.SoftApConfiguration; import android.net.wifi.SoftApInfo; import android.net.wifi.SoftApState; import android.net.wifi.WifiAnnotations; import android.net.wifi.WifiClient; import android.net.wifi.WifiContext; import android.net.wifi.WifiInfo; import android.net.wifi.WifiManager; import android.net.wifi.WifiScanner; import android.net.wifi.WifiSsid; import android.net.wifi.nl80211.DeviceWiphyCapabilities; import android.net.wifi.util.WifiResourceCache; import android.os.BatteryManager; import android.os.Handler; import android.os.Looper; import android.os.Message; import android.os.SystemClock; import android.os.UserHandle; import android.os.WorkSource; import android.text.TextUtils; import android.util.Log; import androidx.annotation.IntDef; import com.android.internal.annotations.VisibleForTesting; import com.android.internal.util.IState; import com.android.internal.util.Preconditions; import com.android.internal.util.State; import com.android.internal.util.StateMachine; import com.android.internal.util.WakeupMessage; import com.android.modules.utils.build.SdkLevel; import com.android.server.wifi.WifiNative.InterfaceCallback; import com.android.server.wifi.WifiNative.SoftApHalCallback; import com.android.server.wifi.coex.CoexManager; import com.android.server.wifi.coex.CoexManager.CoexListener; import com.android.server.wifi.util.ApConfigUtil; import com.android.server.wifi.util.WaitingState; import com.android.wifi.flags.Flags; import com.android.wifi.resources.R; import com.google.common.collect.ImmutableList; import java.io.FileDescriptor; import java.io.PrintWriter; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.Date; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.Set; import java.util.stream.Collectors; /** * Manage WiFi in AP mode. * The internal state machine runs under the ClientModeImpl handler thread context. */ public class SoftApManager implements ActiveModeManager { private static final String TAG = "SoftApManager"; @VisibleForTesting public static final String SOFT_AP_SEND_MESSAGE_TIMEOUT_TAG = TAG + " Soft AP Send Message Timeout on "; // Start result codes. These should reflect the SoftApStopped.StartResult metrics codes. @Retention(RetentionPolicy.SOURCE) @IntDef(value = { START_RESULT_UNKNOWN, START_RESULT_SUCCESS, START_RESULT_FAILURE_GENERAL, START_RESULT_FAILURE_NO_CHANNEL, START_RESULT_FAILURE_UNSUPPORTED_CONFIG, START_RESULT_FAILURE_START_HAL, START_RESULT_FAILURE_START_HOSTAPD, START_RESULT_FAILURE_INTERFACE_CONFLICT_USER_REJECTED, START_RESULT_FAILURE_INTERFACE_CONFLICT, START_RESULT_FAILURE_CREATE_INTERFACE, START_RESULT_FAILURE_SET_COUNTRY_CODE, START_RESULT_FAILURE_SET_MAC_ADDRESS, START_RESULT_FAILURE_REGISTER_AP_CALLBACK_HOSTAPD, START_RESULT_FAILURE_REGISTER_AP_CALLBACK_WIFICOND, START_RESULT_FAILURE_ADD_AP_HOSTAPD, }) public @interface StartResult {} // Unknown start result public static final int START_RESULT_UNKNOWN = 0; // Successful start public static final int START_RESULT_SUCCESS = 1; // General failure public static final int START_RESULT_FAILURE_GENERAL = 2; // Failed due to no channel available public static final int START_RESULT_FAILURE_NO_CHANNEL = 3; // Failed due to config being unsupported public static final int START_RESULT_FAILURE_UNSUPPORTED_CONFIG = 4; // Failed to start the HAL public static final int START_RESULT_FAILURE_START_HAL = 5; // Failed to start hostapd public static final int START_RESULT_FAILURE_START_HOSTAPD = 6; // Failed due to interface conflict with user rejection public static final int START_RESULT_FAILURE_INTERFACE_CONFLICT_USER_REJECTED = 7; // Failed due to interface conflict public static final int START_RESULT_FAILURE_INTERFACE_CONFLICT = 8; // Failed to create interface in vendor HAL public static final int START_RESULT_FAILURE_CREATE_INTERFACE = 9; // Failed to set country code public static final int START_RESULT_FAILURE_SET_COUNTRY_CODE = 10; // Failed to set mac address public static final int START_RESULT_FAILURE_SET_MAC_ADDRESS = 11; // Failed to register AP callback with hostapd public static final int START_RESULT_FAILURE_REGISTER_AP_CALLBACK_HOSTAPD = 12; // Failed to register AP callback with wificond public static final int START_RESULT_FAILURE_REGISTER_AP_CALLBACK_WIFICOND = 13; // Failed to add AP to hostapd public static final int START_RESULT_FAILURE_ADD_AP_HOSTAPD = 14; // Stop event codes. These should reflect the SoftApStopped.StopEvent metrics codes. @Retention(RetentionPolicy.SOURCE) @IntDef(value = { STOP_EVENT_UNKNOWN, STOP_EVENT_STOPPED, STOP_EVENT_INTERFACE_DOWN, STOP_EVENT_INTERFACE_DESTROYED, STOP_EVENT_HOSTAPD_FAILURE, STOP_EVENT_NO_USAGE_TIMEOUT, }) public @interface StopEvent {} // Unknown stop event public static final int STOP_EVENT_UNKNOWN = 0; // Stopped by the user public static final int STOP_EVENT_STOPPED = 1; // Stopped due to interface down public static final int STOP_EVENT_INTERFACE_DOWN = 2; // Stopped due to interface destroyed public static final int STOP_EVENT_INTERFACE_DESTROYED = 3; // Stopped due to hostapd failure public static final int STOP_EVENT_HOSTAPD_FAILURE = 4; // Stopped due to no usage timeout public static final int STOP_EVENT_NO_USAGE_TIMEOUT = 5; private final WifiContext mContext; private final FrameworkFacade mFrameworkFacade; private final WifiNative mWifiNative; // This will only be null if SdkLevel is not at least S @Nullable private final CoexManager mCoexManager; private final ClientModeImplMonitor mCmiMonitor; private final ActiveModeWarden mActiveModeWarden; private final SoftApNotifier mSoftApNotifier; private final InterfaceConflictManager mInterfaceConflictManager; private final WifiInjector mWifiInjector; private final WifiResourceCache mResourceCache; @VisibleForTesting static final long SOFT_AP_PENDING_DISCONNECTION_CHECK_DELAY_MS = 1000; private static final long SCHEDULE_IDLE_INSTANCE_SHUTDOWN_TIMEOUT_DELAY_MS = 10; private String mCountryCode; private final SoftApStateMachine mStateMachine; private final Listener mModeListener; private final WifiServiceImpl.SoftApCallbackInternal mSoftApCallback; private String mApInterfaceName; private boolean mIfaceIsUp; private boolean mIfaceIsDestroyed; private final WifiApConfigStore mWifiApConfigStore; private final ClientModeImplListener mCmiListener = new ClientModeImplListener() { @Override public void onL2Connected(@NonNull ConcreteClientModeManager clientModeManager) { SoftApManager.this.onL2Connected(clientModeManager); } }; private final WifiMetrics mWifiMetrics; private final long mId; private boolean mIsUnsetBssid; private boolean mVerboseLoggingEnabled = false; // Whether this device supports multiple link operation in a single MLD. private boolean mIsMLDApSupportMLO = false; // Whether this SoftApManager (i.e. this AP interface) is using multiple link operation. private boolean mIsUsingMlo = false; private int mMaximumNumberOfMLDSupported; private int mCurrentExistingMLD; /** * The specified configuration passed in during initialization or during a configuration update * that doesn't require a restart. * * Use it when doing configuration update to know if the input configuration was changed. For * others use case, it should use {@code mCurrentSoftApConfiguration}. */ @NonNull private SoftApModeConfiguration mSpecifiedModeConfiguration; /** * Current Soft AP configuration which is used to start Soft AP. * The configuration may be changed because * 1. bssid is changed because MAC randomization * 2. bands are changed because fallback to single AP mode mechanism. */ @Nullable private SoftApConfiguration mCurrentSoftApConfiguration; /** * Whether the configuration being used is the user's persistent SoftApConfiguration. */ private boolean mIsUsingPersistentSoftApConfiguration = false; @NonNull private Map mCurrentSoftApInfoMap = new HashMap<>(); @NonNull private SoftApCapability mCurrentSoftApCapability; private Map> mConnectedClientWithApInfoMap = new HashMap<>(); @VisibleForTesting Map mPendingDisconnectClients = new HashMap<>(); private boolean mTimeoutEnabled = false; private boolean mBridgedModeOpportunisticsShutdownTimeoutEnabled = false; private final SarManager mSarManager; private long mStartTimestampMs; private long mDefaultShutdownTimeoutMillis; private long mDefaultShutdownIdleInstanceInBridgedModeTimeoutMillis; private final boolean mIsDisableShutDownBridgedModeIdleInstanceTimerWhenPlugged; private static final SimpleDateFormat FORMATTER = new SimpleDateFormat("MM-dd HH:mm:ss.SSS"); private WifiDiagnostics mWifiDiagnostics; @Nullable private SoftApRole mRole = null; @Nullable private WorkSource mRequestorWs = null; private boolean mEverReportMetricsForMaxClient = false; @NonNull private Set mBlockedClientList = new HashSet<>(); @NonNull private Set mAllowedClientList = new HashSet<>(); @NonNull private Set mSafeChannelFrequencyList = new HashSet<>(); private boolean mIsPlugged = false; private int mCurrentApState = WifiManager.WIFI_AP_STATE_DISABLED; private boolean mIsSoftApStartedEventWritten = false; private int mMaxConnectedClients = 0; /** * A map stores shutdown timeouts for each Soft Ap instance. * There are three timeout messages now. * 1. which uses to monitor whole Soft AP interface. * It works on single AP mode and bridged AP mode. * * 2. which is used to shutdown the AP when there are no * connected devices. It is scheduled only in bridged mode to move dual mode AP to single * mode AP in lower band. * * 3. which is used to shutdown the AP when there are no * connected devices. It is scheduled only in bridged mode to move dual mode AP to single * mode AP in higher band. */ @VisibleForTesting public Map mSoftApTimeoutMessageMap = new HashMap<>(); /** * Listener for soft AP events. */ private final SoftApHalCallback mSoftApHalCallback = new SoftApHalCallback() { @Override public void onFailure() { mStateMachine.sendMessage(SoftApStateMachine.CMD_FAILURE); } @Override public void onInstanceFailure(String instanceName) { mStateMachine.sendMessage(SoftApStateMachine.CMD_FAILURE, instanceName); } @Override public void onInfoChanged(String apIfaceInstance, int frequency, @WifiAnnotations.Bandwidth int bandwidth, @WifiAnnotations.WifiStandard int generation, @Nullable MacAddress apIfaceInstanceMacAddress, @Nullable MacAddress mldAddress, @NonNull List vendorData) { SoftApInfo apInfo = new SoftApInfo(); apInfo.setFrequency(frequency); apInfo.setBandwidth(bandwidth); apInfo.setWifiStandard(generation); if (apIfaceInstanceMacAddress != null) { apInfo.setBssid(apIfaceInstanceMacAddress); } if (mldAddress != null) { apInfo.setMldAddress(mldAddress); } apInfo.setApInstanceIdentifier(apIfaceInstance != null ? apIfaceInstance : mApInterfaceName); if (SdkLevel.isAtLeastV() && vendorData != null && !vendorData.isEmpty()) { apInfo.setVendorData(vendorData); } mStateMachine.sendMessage( SoftApStateMachine.CMD_AP_INFO_CHANGED, 0, 0, apInfo); } @Override public void onConnectedClientsChanged(String apIfaceInstance, MacAddress clientAddress, boolean isConnected, @WifiAnnotations.SoftApDisconnectReason int disconnectReason) { if (clientAddress != null) { WifiClient client = new WifiClient(clientAddress, apIfaceInstance != null ? apIfaceInstance : mApInterfaceName, disconnectReason); mStateMachine.sendMessage(SoftApStateMachine.CMD_ASSOCIATED_STATIONS_CHANGED, isConnected ? 1 : 0, 0, client); } else { Log.e(getTag(), "onConnectedClientsChanged: Invalid type returned"); } } }; // This will only be null if SdkLevel is not at least S @Nullable private final CoexListener mCoexListener; private void updateSafeChannelFrequencyList() { if (!SdkLevel.isAtLeastS() || mCurrentSoftApConfiguration == null) { return; } mSafeChannelFrequencyList.clear(); for (int configuredBand : mCurrentSoftApConfiguration.getBands()) { for (int band : SoftApConfiguration.BAND_TYPES) { if ((band & configuredBand) == 0) { continue; } for (int channel : mCurrentSoftApCapability.getSupportedChannelList(band)) { mSafeChannelFrequencyList.add( ApConfigUtil.convertChannelToFrequency(channel, band)); } } } if ((mCoexManager.getCoexRestrictions() & WifiManager.COEX_RESTRICTION_SOFTAP) != 0) { mSafeChannelFrequencyList.removeAll( ApConfigUtil.getUnsafeChannelFreqsFromCoex(mCoexManager)); } if (isBridgedMode() && mCurrentSoftApInfoMap.size() == 2) { // Logging only for bridged use case since it only used to fallback to single AP mode. Log.d(getTag(), "SafeChannelFrequencyList = " + mSafeChannelFrequencyList); } } private void configureInternalConfiguration() { if (mCurrentSoftApConfiguration == null) { return; } mBlockedClientList = new HashSet<>(mCurrentSoftApConfiguration.getBlockedClientList()); mAllowedClientList = new HashSet<>(mCurrentSoftApConfiguration.getAllowedClientList()); mTimeoutEnabled = mCurrentSoftApConfiguration.isAutoShutdownEnabled(); mBridgedModeOpportunisticsShutdownTimeoutEnabled = mCurrentSoftApConfiguration.isBridgedModeOpportunisticShutdownEnabledInternal(); } private void updateChangeableConfiguration(SoftApConfiguration newConfig) { if (mCurrentSoftApConfiguration == null || newConfig == null) { return; } /** * update configurations only which mentioned in WifiManager#setSoftApConfiguration */ long newShutdownTimeoutMillis = newConfig.getShutdownTimeoutMillis(); // Compatibility check is used for unit test only since the SoftApManager is created by // the unit test thread (not the system_server) when running unit test. In other cases, // the SoftApManager would run in system server(i.e. always bypasses the app compat check). if (CompatChanges.isChangeEnabled(SoftApConfiguration.REMOVE_ZERO_FOR_TIMEOUT_SETTING) && newShutdownTimeoutMillis == 0) { newShutdownTimeoutMillis = SoftApConfiguration.DEFAULT_TIMEOUT; } SoftApConfiguration.Builder newConfigurBuilder = new SoftApConfiguration.Builder(mCurrentSoftApConfiguration) .setAllowedClientList(newConfig.getAllowedClientList()) .setBlockedClientList(newConfig.getBlockedClientList()) .setClientControlByUserEnabled(newConfig.isClientControlByUserEnabled()) .setMaxNumberOfClients(newConfig.getMaxNumberOfClients()) .setShutdownTimeoutMillis(newShutdownTimeoutMillis) .setAutoShutdownEnabled(newConfig.isAutoShutdownEnabled()); if (SdkLevel.isAtLeastS()) { newConfigurBuilder.setBridgedModeOpportunisticShutdownEnabled( newConfig.isBridgedModeOpportunisticShutdownEnabledInternal()); } mCurrentSoftApConfiguration = newConfigurBuilder.build(); configureInternalConfiguration(); } public SoftApManager( @NonNull WifiContext context, @NonNull Looper looper, @NonNull FrameworkFacade framework, @NonNull WifiNative wifiNative, @NonNull WifiInjector wifiInjector, @NonNull CoexManager coexManager, @NonNull InterfaceConflictManager interfaceConflictManager, @NonNull Listener listener, @NonNull WifiServiceImpl.SoftApCallbackInternal callback, @NonNull WifiApConfigStore wifiApConfigStore, @NonNull SoftApModeConfiguration apConfig, @NonNull WifiMetrics wifiMetrics, @NonNull SarManager sarManager, @NonNull WifiDiagnostics wifiDiagnostics, @NonNull SoftApNotifier softApNotifier, @NonNull ClientModeImplMonitor cmiMonitor, @NonNull ActiveModeWarden activeModeWarden, long id, @NonNull WorkSource requestorWs, @NonNull SoftApRole role, boolean verboseLoggingEnabled) { mContext = context; mFrameworkFacade = framework; mSoftApNotifier = softApNotifier; mWifiNative = wifiNative; mWifiInjector = wifiInjector; mCoexManager = coexManager; mInterfaceConflictManager = interfaceConflictManager; mResourceCache = mContext.getResourceCache(); if (SdkLevel.isAtLeastS()) { mCoexListener = new CoexListener() { @Override public void onCoexUnsafeChannelsChanged() { if (mCurrentSoftApConfiguration == null) { return; } mStateMachine.sendMessage( SoftApStateMachine.CMD_SAFE_CHANNEL_FREQUENCY_CHANGED); } }; } else { mCoexListener = null; } mCountryCode = apConfig.getCountryCode(); mModeListener = listener; mSoftApCallback = callback; mWifiApConfigStore = wifiApConfigStore; mCurrentSoftApConfiguration = apConfig.getSoftApConfiguration(); mCurrentSoftApCapability = apConfig.getCapability(); // null is a valid input and means we use the user-configured tethering settings. if (mCurrentSoftApConfiguration == null) { mCurrentSoftApConfiguration = mWifiApConfigStore.getApConfiguration(); mIsUsingPersistentSoftApConfiguration = true; // may still be null if we fail to load the default config } // Store mode configuration before update the configuration. mSpecifiedModeConfiguration = new SoftApModeConfiguration( apConfig.getTargetMode(), mCurrentSoftApConfiguration, mCurrentSoftApCapability, mCountryCode, apConfig.getTetheringRequest()); if (mCurrentSoftApConfiguration != null) { mIsUnsetBssid = mCurrentSoftApConfiguration.getBssid() == null; if (mCurrentSoftApCapability.areFeaturesSupported( SoftApCapability.SOFTAP_FEATURE_MAC_ADDRESS_CUSTOMIZATION)) { mCurrentSoftApConfiguration = mWifiApConfigStore.randomizeBssidIfUnset( mContext, mCurrentSoftApConfiguration); } } mWifiMetrics = wifiMetrics; mSarManager = sarManager; mWifiDiagnostics = wifiDiagnostics; mStateMachine = new SoftApStateMachine(looper); configureInternalConfiguration(); mDefaultShutdownTimeoutMillis = mResourceCache.getInteger( R.integer.config_wifiFrameworkSoftApShutDownTimeoutMilliseconds); mDefaultShutdownIdleInstanceInBridgedModeTimeoutMillis = mResourceCache .getInteger(R.integer .config_wifiFrameworkSoftApShutDownIdleInstanceInBridgedModeTimeoutMillisecond); mIsDisableShutDownBridgedModeIdleInstanceTimerWhenPlugged = mResourceCache .getBoolean(R.bool .config_wifiFrameworkSoftApDisableBridgedModeShutdownIdleInstanceWhenCharging); mCmiMonitor = cmiMonitor; mActiveModeWarden = activeModeWarden; mCmiMonitor.registerListener(mCmiListener); updateSafeChannelFrequencyList(); mId = id; mRole = role; // chip support it && overlay configuration is set. mIsMLDApSupportMLO = mWifiNative.isMLDApSupportMLO(); mMaximumNumberOfMLDSupported = ApConfigUtil.getMaximumSupportedMLD( mContext, mWifiNative.isMultipleMLDSupportedOnSap()); mCurrentExistingMLD = mActiveModeWarden.getCurrentMLDAp(); mIsUsingMlo = useMultilinkMloSoftAp(); enableVerboseLogging(verboseLoggingEnabled); mStateMachine.sendMessage(SoftApStateMachine.CMD_START, requestorWs); } @Override public long getId() { return mId; } private String getTag() { return TAG + "[" + (mApInterfaceName == null ? "unknown" : mApInterfaceName) + "]"; } /** * Stop soft AP. */ @Override public void stop() { Log.d(getTag(), " currentstate: " + getCurrentStateName()); mStateMachine.sendMessage(SoftApStateMachine.CMD_STOP); } public boolean isUsingMlo() { return mIsUsingMlo; } private boolean useMultilinkMloSoftAp() { if (!Flags.mloSap()) { return false; } if (SdkLevel.isAtLeastT() && mCurrentSoftApConfiguration != null && mCurrentSoftApConfiguration.isIeee80211beEnabled() && isBridgedMode() && mIsMLDApSupportMLO) { if (ApConfigUtil.is11beAllowedForThisConfiguration( null /* Wiphy capability can be ignored for MLO case*/, mContext, mCurrentSoftApConfiguration, true /* isBridgedMode */, mMaximumNumberOfMLDSupported, mCurrentExistingMLD, true /* isMLDApSupportMLO */)) { return true; } } return false; } private boolean isOweTransition() { return (SdkLevel.isAtLeastT() && mCurrentSoftApConfiguration != null && mCurrentSoftApConfiguration.getSecurityType() == SoftApConfiguration.SECURITY_TYPE_WPA3_OWE_TRANSITION); } public boolean isBridgedMode() { return (SdkLevel.isAtLeastS() && mCurrentSoftApConfiguration != null && (mCurrentSoftApConfiguration.getBands().length > 1)); } private boolean isBridgeRequired() { return isBridgedMode() || isOweTransition(); } private long getShutdownTimeoutMillis() { long timeout = mCurrentSoftApConfiguration.getShutdownTimeoutMillis(); return timeout > 0 ? timeout : mDefaultShutdownTimeoutMillis; } private long getShutdownIdleInstanceInBridgedModeTimeoutMillis() { long timeout = mCurrentSoftApConfiguration .getBridgedModeOpportunisticShutdownTimeoutMillisInternal(); return timeout > 0 ? timeout : mDefaultShutdownIdleInstanceInBridgedModeTimeoutMillis; } private List getVendorData() { return (SdkLevel.isAtLeastV() && mCurrentSoftApConfiguration != null) ? mCurrentSoftApConfiguration.getVendorData() : new ArrayList<>(); } private String getHighestFrequencyInstance(Set candidateInstances) { int currentHighestFrequencyOnAP = 0; String highestFrequencyInstance = null; for (String instance : candidateInstances) { SoftApInfo info = mCurrentSoftApInfoMap.get(instance); if (info == null) { Log.wtf(getTag(), "Invalid instance name, no way to get the frequency"); return ""; } int frequencyOnInstance = info.getFrequency(); if (frequencyOnInstance > currentHighestFrequencyOnAP) { currentHighestFrequencyOnAP = frequencyOnInstance; highestFrequencyInstance = instance; } } return highestFrequencyInstance; } @Override @Nullable public SoftApRole getRole() { return mRole; } @Override @Nullable public ClientRole getPreviousRole() { return null; } @Override public long getLastRoleChangeSinceBootMs() { return 0; } /** Set the role of this SoftApManager */ public void setRole(SoftApRole role) { // softap does not allow in-place switching of roles. Preconditions.checkState(mRole == null); mRole = role; } @Override public String getInterfaceName() { return mApInterfaceName; } @Override public WorkSource getRequestorWs() { return mRequestorWs; } /** * Update AP capability. Called when carrier config or device resouce config changed. * * @param capability new AP capability. */ public void updateCapability(@NonNull SoftApCapability capability) { mStateMachine.sendMessage(SoftApStateMachine.CMD_UPDATE_CAPABILITY, capability); } /** * Update AP configuration. Called when setting update config via * {@link WifiManager#setSoftApConfiguration(SoftApConfiguration)} * * @param config new AP config. */ public void updateConfiguration(@NonNull SoftApConfiguration config) { mStateMachine.sendMessage(SoftApStateMachine.CMD_UPDATE_CONFIG, config); } /** * Retrieve the {@link SoftApModeConfiguration} instance associated with this mode manager. */ public SoftApModeConfiguration getSoftApModeConfiguration() { return new SoftApModeConfiguration( mSpecifiedModeConfiguration.getTargetMode(), mSpecifiedModeConfiguration.getSoftApConfiguration(), mCurrentSoftApCapability, mCountryCode, mSpecifiedModeConfiguration.getTetheringRequest()); } /** * Retrieve the name of the Bridged AP iface instance to remove for a downgrade, or null if a * downgrade is not possible. */ public String getBridgedApDowngradeIfaceInstanceForRemoval() { if (!isBridgedMode() || mCurrentSoftApInfoMap.size() == 0) { return null; } List instances = mWifiNative.getBridgedApInstances(mApInterfaceName); if (instances == null || instances.size() == 1) { return null; } return getHighestFrequencyInstance(mCurrentSoftApInfoMap.keySet()); } /** * Return true when current softap state is enabled. */ public boolean isStarted() { return mCurrentApState == WifiManager.WIFI_AP_STATE_ENABLED; } /** * Dump info about this softap manager. */ @Override public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { pw.println("Dump of SoftApManager id=" + mId); pw.println("current StateMachine mode: " + getCurrentStateName()); pw.println("mRole: " + mRole); pw.println("mApInterfaceName: " + mApInterfaceName); pw.println("mIfaceIsUp: " + mIfaceIsUp); pw.println("mSoftApCountryCode: " + mCountryCode); pw.println( "mSpecifiedModeConfiguration.targetMode: " + mSpecifiedModeConfiguration.getTargetMode()); pw.println("mCurrentSoftApConfiguration: " + mCurrentSoftApConfiguration); pw.println("mCurrentSoftApCapability: " + mCurrentSoftApCapability); pw.println("getConnectedClientList().size(): " + getConnectedClientList().size()); pw.println("mTimeoutEnabled: " + mTimeoutEnabled); pw.println("mBridgedModeOpportunisticsShutdownTimeoutEnabled: " + mBridgedModeOpportunisticsShutdownTimeoutEnabled); pw.println("mCurrentSoftApInfoMap " + mCurrentSoftApInfoMap); pw.println("mStartTimestamp: " + FORMATTER.format(new Date(mStartTimestampMs))); pw.println("mSafeChannelFrequencyList: " + mSafeChannelFrequencyList.stream() .map(Object::toString) .collect(Collectors.joining(","))); mStateMachine.dump(fd, pw, args); } @Override public void enableVerboseLogging(boolean verbose) { mVerboseLoggingEnabled = verbose; } @Override public String toString() { return "SoftApManager{id=" + getId() + " iface=" + getInterfaceName() + " role=" + getRole() + "}"; } /** * A ClientModeImpl instance has been L2 connected. * * @param newPrimary the corresponding ConcreteClientModeManager instance for the ClientModeImpl * that has been L2 connected. */ private void onL2Connected(@NonNull ConcreteClientModeManager clientModeManager) { Log.d(getTag(), "onL2Connected called"); mStateMachine.sendMessage(SoftApStateMachine.CMD_HANDLE_WIFI_CONNECTED, clientModeManager); } private String getCurrentStateName() { IState currentState = mStateMachine.getCurrentState(); if (currentState != null) { return currentState.getName(); } return "StateMachine not active"; } /** * Update AP state. * * @param newState new AP state * @param currentState current AP state * @param reason Failure reason if the new AP state is in failure state */ private void updateApState(int newState, int currentState, int reason) { mCurrentApState = newState; mSoftApCallback.onStateChanged(new SoftApState( newState, reason, mSpecifiedModeConfiguration.getTetheringRequest(), mApInterfaceName)); //send the AP state change broadcast final Intent intent = new Intent(WifiManager.WIFI_AP_STATE_CHANGED_ACTION); intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT); intent.putExtra(WifiManager.EXTRA_WIFI_AP_STATE, newState); intent.putExtra(WifiManager.EXTRA_PREVIOUS_WIFI_AP_STATE, currentState); if (newState == WifiManager.WIFI_AP_STATE_FAILED) { //only set reason number when softAP start failed intent.putExtra(WifiManager.EXTRA_WIFI_AP_FAILURE_REASON, reason); } intent.putExtra(WifiManager.EXTRA_WIFI_AP_INTERFACE_NAME, mApInterfaceName); intent.putExtra( WifiManager.EXTRA_WIFI_AP_MODE, mSpecifiedModeConfiguration.getTargetMode()); if (SdkLevel.isAtLeastSv2()) { mContext.sendBroadcastAsUser(intent, UserHandle.ALL, android.Manifest.permission.ACCESS_WIFI_STATE); } else { mContext.sendStickyBroadcastAsUser(intent, UserHandle.ALL); } } private int setMacAddress() { MacAddress mac = mCurrentSoftApConfiguration.getBssid(); if (mac == null) { // If no BSSID is explicitly requested, (re-)configure the factory MAC address. Some // drivers may not support setting the MAC at all, so fail soft in this case. if (!mWifiNative.resetApMacToFactoryMacAddress(mApInterfaceName)) { Log.w(getTag(), "failed to reset to factory MAC address; " + "continuing with current MAC"); } } else { if (mWifiNative.isApSetMacAddressSupported(mApInterfaceName)) { if (!mWifiNative.setApMacAddress(mApInterfaceName, mac)) { Log.e(getTag(), "failed to set explicitly requested MAC address"); return START_RESULT_FAILURE_SET_MAC_ADDRESS; } } else if (!mIsUnsetBssid) { // If hardware does not support MAC address setter, // only report the error for non randomization. return START_RESULT_FAILURE_UNSUPPORTED_CONFIG; } } return START_RESULT_SUCCESS; } /** * Dynamic update the country code when Soft AP enabled. * * @param countryCode 2 byte ASCII string. For ex: US, CA. * @return true if request is sent successfully, false otherwise. */ public boolean updateCountryCode(@NonNull String countryCode) { if (ApConfigUtil.isSoftApDynamicCountryCodeSupported(mContext) && mCurrentSoftApCapability.areFeaturesSupported( SoftApCapability.SOFTAP_FEATURE_ACS_OFFLOAD)) { mStateMachine.sendMessage(SoftApStateMachine.CMD_UPDATE_COUNTRY_CODE, countryCode); return true; } return false; } private boolean setCountryCode() { int band = mCurrentSoftApConfiguration.getBand(); if (TextUtils.isEmpty(mCountryCode)) { if (band == SoftApConfiguration.BAND_5GHZ || band == SoftApConfiguration.BAND_6GHZ) { // Country code is mandatory for 5GHz/6GHz band. Log.e(getTag(), "Invalid country code, " + "required for setting up soft ap in band:" + band); return false; } // Absence of country code is not fatal for 2Ghz & Any band options. return true; } if (!mWifiNative.setApCountryCode( mApInterfaceName, mCountryCode.toUpperCase(Locale.ROOT))) { if (band == SoftApConfiguration.BAND_5GHZ || band == SoftApConfiguration.BAND_6GHZ) { // Return an error if failed to set country code when AP is configured for // 5GHz/6GHz band. Log.e(getTag(), "Failed to set country code, " + "required for setting up soft ap in band: " + band); return false; } // Failure to set country code is not fatal for other band options. } return true; } /** * Start a soft AP instance as configured. * * @return One of {@link StartResult} */ private @StartResult int startSoftAp() { if (SdkLevel.isAtLeastS()) { Log.d(getTag(), "startSoftAp: channels " + mCurrentSoftApConfiguration.getChannels() + " iface " + mApInterfaceName + " country " + mCountryCode); } else { Log.d(getTag(), "startSoftAp: band " + mCurrentSoftApConfiguration.getBand()); } updateApState(WifiManager.WIFI_AP_STATE_ENABLING, WifiManager.WIFI_AP_STATE_DISABLED, 0); int startResult = setMacAddress(); if (startResult != START_RESULT_SUCCESS) { return startResult; } // Make a copy of configuration for updating AP band and channel. SoftApConfiguration.Builder localConfigBuilder = new SoftApConfiguration.Builder(mCurrentSoftApConfiguration); startResult = ApConfigUtil.updateApChannelConfig( mWifiNative, mCoexManager, mResourceCache, mCountryCode, localConfigBuilder, mCurrentSoftApConfiguration, mCurrentSoftApCapability); if (startResult != START_RESULT_SUCCESS) { Log.e(getTag(), "Failed to update AP band and channel"); return startResult; } if (mCurrentSoftApConfiguration.isHiddenSsid()) { Log.d(getTag(), "SoftAP is a hidden network"); } if (!ApConfigUtil.checkSupportAllConfiguration( mCurrentSoftApConfiguration, mCurrentSoftApCapability)) { Log.d(getTag(), "Unsupported Configuration detect! config = " + mCurrentSoftApConfiguration); return START_RESULT_FAILURE_UNSUPPORTED_CONFIG; } startResult = mWifiNative.startSoftAp( mApInterfaceName, localConfigBuilder.build(), mSpecifiedModeConfiguration.getTargetMode() == WifiManager.IFACE_IP_MODE_TETHERED, mSoftApHalCallback, mIsUsingMlo); if (startResult != START_RESULT_SUCCESS) { Log.e(getTag(), "Soft AP start failed"); return startResult; } mWifiDiagnostics.startLogging(mApInterfaceName); mStartTimestampMs = mWifiInjector.getClock().getWallClockMillis(); Log.d(getTag(), "Soft AP is started "); return START_RESULT_SUCCESS; } /** * Handles a start failure and writes the start failure metrics. * @param startResult One of {@link StartResult}. */ private void handleStartSoftApFailure(@StartResult int startResult) { if (startResult == START_RESULT_SUCCESS) { Log.wtf(TAG, "handleStartSoftApFailure called with START_RESULT_SUCCESS"); return; } int wifiManagerFailureReason = WifiManager.SAP_START_FAILURE_GENERAL; if (startResult == START_RESULT_FAILURE_NO_CHANNEL) { wifiManagerFailureReason = WifiManager.SAP_START_FAILURE_NO_CHANNEL; } else if (startResult == START_RESULT_FAILURE_UNSUPPORTED_CONFIG) { wifiManagerFailureReason = WifiManager.SAP_START_FAILURE_UNSUPPORTED_CONFIGURATION; } else if (startResult == START_RESULT_FAILURE_INTERFACE_CONFLICT_USER_REJECTED) { wifiManagerFailureReason = WifiManager.SAP_START_FAILURE_USER_REJECTED; } updateApState(WifiManager.WIFI_AP_STATE_FAILED, mCurrentApState, wifiManagerFailureReason); stopSoftAp(); mWifiMetrics.incrementSoftApStartResult(false, wifiManagerFailureReason); mModeListener.onStartFailure(SoftApManager.this); writeSoftApStartedEvent(startResult); } /** * Disconnect all connected clients on active softap interface(s). * This is usually done just before stopSoftAp(). */ private void disconnectAllClients() { for (WifiClient client : getConnectedClientList()) { mWifiNative.forceClientDisconnect(mApInterfaceName, client.getMacAddress(), SAP_CLIENT_DISCONNECT_REASON_CODE_UNSPECIFIED); } } /** * Teardown soft AP and teardown the interface. */ private void stopSoftAp() { disconnectAllClients(); mWifiDiagnostics.stopLogging(mApInterfaceName); mWifiNative.teardownInterface(mApInterfaceName); Log.d(getTag(), "Soft AP is stopped"); } private void addClientToPendingDisconnectionList(WifiClient client, int reason) { Log.d(getTag(), "Fail to disconnect client: " + client.getMacAddress() + ", add it into pending list"); mPendingDisconnectClients.put(client, reason); mStateMachine.getHandler().removeMessages( SoftApStateMachine.CMD_FORCE_DISCONNECT_PENDING_CLIENTS); mStateMachine.sendMessageDelayed( SoftApStateMachine.CMD_FORCE_DISCONNECT_PENDING_CLIENTS, SOFT_AP_PENDING_DISCONNECTION_CHECK_DELAY_MS); } private List getConnectedClientList() { List connectedClientList = new ArrayList<>(); for (List it : mConnectedClientWithApInfoMap.values()) { connectedClientList.addAll(it); } return connectedClientList; } private boolean checkSoftApClient(SoftApConfiguration config, WifiClient newClient) { if (!mCurrentSoftApCapability.areFeaturesSupported( SoftApCapability.SOFTAP_FEATURE_CLIENT_FORCE_DISCONNECT)) { return true; } if (mBlockedClientList.contains(newClient.getMacAddress())) { Log.d(getTag(), "Force disconnect for client: " + newClient + "in blocked list"); if (!mWifiNative.forceClientDisconnect( mApInterfaceName, newClient.getMacAddress(), WifiManager.SAP_CLIENT_BLOCK_REASON_CODE_BLOCKED_BY_USER)) { addClientToPendingDisconnectionList(newClient, WifiManager.SAP_CLIENT_BLOCK_REASON_CODE_BLOCKED_BY_USER); } return false; } if (config.isClientControlByUserEnabled() && !mAllowedClientList.contains(newClient.getMacAddress())) { mSoftApCallback.onBlockedClientConnecting(newClient, WifiManager.SAP_CLIENT_BLOCK_REASON_CODE_BLOCKED_BY_USER); Log.d(getTag(), "Force disconnect for unauthorized client: " + newClient); if (!mWifiNative.forceClientDisconnect( mApInterfaceName, newClient.getMacAddress(), WifiManager.SAP_CLIENT_BLOCK_REASON_CODE_BLOCKED_BY_USER)) { addClientToPendingDisconnectionList(newClient, WifiManager.SAP_CLIENT_BLOCK_REASON_CODE_BLOCKED_BY_USER); } return false; } int maxConfig = mCurrentSoftApCapability.getMaxSupportedClients(); if (config.getMaxNumberOfClients() > 0) { maxConfig = Math.min(maxConfig, config.getMaxNumberOfClients()); } if (getConnectedClientList().size() >= maxConfig) { Log.i(getTag(), "No more room for new client:" + newClient); if (!mWifiNative.forceClientDisconnect( mApInterfaceName, newClient.getMacAddress(), WifiManager.SAP_CLIENT_BLOCK_REASON_CODE_NO_MORE_STAS)) { addClientToPendingDisconnectionList(newClient, WifiManager.SAP_CLIENT_BLOCK_REASON_CODE_NO_MORE_STAS); } mSoftApCallback.onBlockedClientConnecting(newClient, WifiManager.SAP_CLIENT_BLOCK_REASON_CODE_NO_MORE_STAS); // Avoid report the max client blocked in the same settings. if (!mEverReportMetricsForMaxClient) { mWifiMetrics.noteSoftApClientBlocked(maxConfig); mEverReportMetricsForMaxClient = true; } return false; } return true; } private class SoftApStateMachine extends StateMachine { // Commands for the state machine. public static final int CMD_START = 0; public static final int CMD_STOP = 1; public static final int CMD_FAILURE = 2; public static final int CMD_INTERFACE_STATUS_CHANGED = 3; public static final int CMD_ASSOCIATED_STATIONS_CHANGED = 4; public static final int CMD_NO_ASSOCIATED_STATIONS_TIMEOUT = 5; public static final int CMD_INTERFACE_DESTROYED = 7; public static final int CMD_INTERFACE_DOWN = 8; public static final int CMD_AP_INFO_CHANGED = 9; public static final int CMD_UPDATE_CAPABILITY = 10; public static final int CMD_UPDATE_CONFIG = 11; public static final int CMD_FORCE_DISCONNECT_PENDING_CLIENTS = 12; public static final int CMD_NO_ASSOCIATED_STATIONS_TIMEOUT_ON_ONE_INSTANCE = 13; public static final int CMD_SAFE_CHANNEL_FREQUENCY_CHANGED = 14; public static final int CMD_HANDLE_WIFI_CONNECTED = 15; public static final int CMD_UPDATE_COUNTRY_CODE = 16; public static final int CMD_DRIVER_COUNTRY_CODE_CHANGED = 17; public static final int CMD_DRIVER_COUNTRY_CODE_CHANGE_TIMED_OUT = 18; public static final int CMD_PLUGGED_STATE_CHANGED = 19; private final State mActiveState = new ActiveState(); private final State mIdleState; private final State mWaitingForDriverCountryCodeChangedState; private final WaitingState mWaitingForIcmDialogState = new WaitingState(this); private final State mStartedState; private final InterfaceCallback mWifiNativeInterfaceCallback = new InterfaceCallback() { @Override public void onDestroyed(String ifaceName) { sendMessage(CMD_INTERFACE_DESTROYED, ifaceName); } @Override public void onUp(String ifaceName) { if (mApInterfaceName != null && mApInterfaceName.equals(ifaceName)) { sendMessage(CMD_INTERFACE_STATUS_CHANGED, 1); } } @Override public void onDown(String ifaceName) { if (mApInterfaceName != null && mApInterfaceName.equals(ifaceName)) { sendMessage(CMD_INTERFACE_STATUS_CHANGED, 0); } } }; SoftApStateMachine(Looper looper) { super(TAG, looper); final int threshold = mResourceCache.getInteger( R.integer.config_wifiConfigurationWifiRunnerThresholdInMs); mIdleState = new IdleState(threshold); mWaitingForDriverCountryCodeChangedState = new WaitingForDriverCountryCodeChangedState(threshold); mStartedState = new StartedState(threshold); // CHECKSTYLE:OFF IndentationCheck addState(mActiveState); addState(mIdleState, mActiveState); addState(mWaitingForDriverCountryCodeChangedState, mActiveState); addState(mWaitingForIcmDialogState, mActiveState); addState(mStartedState, mActiveState); // CHECKSTYLE:ON IndentationCheck setInitialState(mIdleState); start(); } private class ActiveState extends State { @Override public void exit() { mModeListener.onStopped(SoftApManager.this); mCmiMonitor.unregisterListener(mCmiListener); } } @Override protected String getWhatToString(int what) { switch (what) { case CMD_START: return "CMD_START"; case CMD_STOP: return "CMD_STOP"; case CMD_FAILURE: return "CMD_FAILURE"; case CMD_INTERFACE_STATUS_CHANGED: return "CMD_INTERFACE_STATUS_CHANGED"; case CMD_ASSOCIATED_STATIONS_CHANGED: return "CMD_ASSOCIATED_STATIONS_CHANGED"; case CMD_NO_ASSOCIATED_STATIONS_TIMEOUT: return "CMD_NO_ASSOCIATED_STATIONS_TIMEOUT"; case CMD_INTERFACE_DESTROYED: return "CMD_INTERFACE_DESTROYED"; case CMD_INTERFACE_DOWN: return "CMD_INTERFACE_DOWN"; case CMD_AP_INFO_CHANGED: return "CMD_AP_INFO_CHANGED"; case CMD_UPDATE_CAPABILITY: return "CMD_UPDATE_CAPABILITY"; case CMD_UPDATE_CONFIG: return "CMD_UPDATE_CONFIG"; case CMD_FORCE_DISCONNECT_PENDING_CLIENTS: return "CMD_FORCE_DISCONNECT_PENDING_CLIENTS"; case CMD_NO_ASSOCIATED_STATIONS_TIMEOUT_ON_ONE_INSTANCE: return "CMD_NO_ASSOCIATED_STATIONS_TIMEOUT_ON_ONE_INSTANCE"; case CMD_SAFE_CHANNEL_FREQUENCY_CHANGED: return "CMD_SAFE_CHANNEL_FREQUENCY_CHANGED"; case CMD_HANDLE_WIFI_CONNECTED: return "CMD_HANDLE_WIFI_CONNECTED"; case CMD_UPDATE_COUNTRY_CODE: return "CMD_UPDATE_COUNTRY_CODE"; case CMD_DRIVER_COUNTRY_CODE_CHANGED: return "CMD_DRIVER_COUNTRY_CODE_CHANGED"; case CMD_DRIVER_COUNTRY_CODE_CHANGE_TIMED_OUT: return "CMD_DRIVER_COUNTRY_CODE_CHANGE_TIMED_OUT"; case CMD_PLUGGED_STATE_CHANGED: return "CMD_PLUGGED_STATE_CHANGED"; case RunnerState.STATE_ENTER_CMD: return "Enter"; case RunnerState.STATE_EXIT_CMD: return "Exit"; default: return "what:" + what; } } private class IdleState extends RunnerState { IdleState(int threshold) { super(threshold, mWifiInjector.getWifiHandlerLocalLog()); } @Override public void enterImpl() { mApInterfaceName = null; mIfaceIsUp = false; mIfaceIsDestroyed = false; } @Override public void exitImpl() { } @Override public String getMessageLogRec(int what) { return SoftApManager.class.getSimpleName() + "." + IdleState.class.getSimpleName() + "." + getWhatToString(what); } @Override public boolean processMessageImpl(Message message) { switch (message.what) { case CMD_STOP: writeSoftApStoppedEvent(STOP_EVENT_STOPPED); quitNow(); break; case CMD_START: boolean isCountryCodeChanged = false; boolean shouldwaitForDriverCountryCodeIfNoCountryToSet = false; mRequestorWs = (WorkSource) message.obj; WifiSsid wifiSsid = mCurrentSoftApConfiguration != null ? mCurrentSoftApConfiguration.getWifiSsid() : null; if (wifiSsid == null || wifiSsid.getBytes().length == 0) { Log.e(getTag(), "Unable to start soft AP without valid configuration"); handleStartSoftApFailure(START_RESULT_FAILURE_GENERAL); break; } if (TextUtils.isEmpty(mCountryCode) && mResourceCache .getBoolean( R.bool.config_wifiDriverSupportedNl80211RegChangedEvent)) { Log.i(getTag(), "No country code set in the framework." + " Should Wait for driver country code update to start AP"); shouldwaitForDriverCountryCodeIfNoCountryToSet = true; } if (!TextUtils.isEmpty(mCountryCode) && !TextUtils.equals( mCountryCode, mCurrentSoftApCapability.getCountryCode())) { isCountryCodeChanged = true; Log.i(getTag(), "CountryCode changed - " + " mCountryCode = " + mCountryCode + ", base country in SoftApCapability = " + mCurrentSoftApCapability.getCountryCode()); } if (isBridgedMode()) { if (!isCountryCodeChanged) { SoftApConfiguration tempConfig = ApConfigUtil.removeUnavailableBandsFromConfig( mCurrentSoftApConfiguration, mCurrentSoftApCapability, mCoexManager, mContext); if (tempConfig == null) { handleStartSoftApFailure( START_RESULT_FAILURE_UNSUPPORTED_CONFIG); break; } mCurrentSoftApConfiguration = tempConfig; } if (!isBridgedApAvailable() || mCurrentSoftApConfiguration.getBands().length == 1) { int newSingleApBand = 0; for (int configuredBand : mCurrentSoftApConfiguration.getBands()) { newSingleApBand |= configuredBand; } newSingleApBand = ApConfigUtil.append24GToBandIf24GSupported( newSingleApBand, mContext); Log.i(getTag(), "Fallback to single AP mode with band " + newSingleApBand); mCurrentSoftApConfiguration = new SoftApConfiguration.Builder(mCurrentSoftApConfiguration) .setBand(newSingleApBand) .build(); } } else if (!isCountryCodeChanged && isBridgedApAvailable() && mIsUsingPersistentSoftApConfiguration) { // Try upgrading config to 2 + 5 GHz Dual Band if the available config // bands only include 2 or 5 Ghz. This is to handle cases where the // config was previously set to single band in a CC that didn't support // DBS, but the current one does. mCurrentSoftApConfiguration = ApConfigUtil.upgradeTo2g5gBridgedIfAvailableBandsAreSubset( mCurrentSoftApConfiguration, mCurrentSoftApCapability, mContext); } // Remove 6GHz from requested bands if security type is restricted // Note: 6GHz only band is already handled by initial validation SoftApConfiguration tempConfig = ApConfigUtil.remove6gBandForUnsupportedSecurity( mResourceCache, mCurrentSoftApConfiguration, isBridgedMode()); if (tempConfig == null) { handleStartSoftApFailure(START_RESULT_FAILURE_UNSUPPORTED_CONFIG); break; } mCurrentSoftApConfiguration = tempConfig; // Don't show the ICM dialog if this is for tethering. boolean bypassDialog = mSpecifiedModeConfiguration.getTargetMode() == WifiManager.IFACE_IP_MODE_TETHERED; int icmResult = mInterfaceConflictManager .manageInterfaceConflictForStateMachine( TAG, message, mStateMachine, mWaitingForIcmDialogState, mIdleState, isBridgeRequired() ? HalDeviceManager.HDM_CREATE_IFACE_AP_BRIDGE : HalDeviceManager.HDM_CREATE_IFACE_AP, mRequestorWs, bypassDialog); if (icmResult == InterfaceConflictManager.ICM_ABORT_COMMAND) { Log.e(getTag(), "User refused to set up interface"); handleStartSoftApFailure( START_RESULT_FAILURE_INTERFACE_CONFLICT_USER_REJECTED); break; } else if (icmResult == InterfaceConflictManager.ICM_SKIP_COMMAND_WAIT_FOR_USER) { break; } mApInterfaceName = mWifiNative.setupInterfaceForSoftApMode( mWifiNativeInterfaceCallback, mRequestorWs, mCurrentSoftApConfiguration.getBand(), isBridgeRequired(), SoftApManager.this, getVendorData(), mIsUsingMlo); if (TextUtils.isEmpty(mApInterfaceName)) { Log.e(getTag(), "setup failure when creating ap interface."); // Only check if it's possible to create single AP, since a DBS request // already falls back to single AP if we can't create DBS. if (!mWifiNative.isItPossibleToCreateApIface(mRequestorWs)) { handleStartSoftApFailure(START_RESULT_FAILURE_INTERFACE_CONFLICT); } else { handleStartSoftApFailure(START_RESULT_FAILURE_CREATE_INTERFACE); } break; } if (!mIsUsingMlo && SdkLevel.isAtLeastT() && mCurrentSoftApConfiguration.isIeee80211beEnabled()) { DeviceWiphyCapabilities capabilities = mWifiNative.getDeviceWiphyCapabilities( mApInterfaceName, isBridgeRequired()); if (!ApConfigUtil.is11beAllowedForThisConfiguration(capabilities, mContext, mCurrentSoftApConfiguration, isBridgedMode(), mMaximumNumberOfMLDSupported, mCurrentExistingMLD, mIsMLDApSupportMLO)) { Log.d(getTag(), "11BE is not allowed," + " removing from configuration"); mCurrentSoftApConfiguration = new SoftApConfiguration.Builder( mCurrentSoftApConfiguration).setIeee80211beEnabled( false).build(); } } mSoftApNotifier.dismissSoftApShutdownTimeoutExpiredNotification(); if (!shouldwaitForDriverCountryCodeIfNoCountryToSet && !setCountryCode()) { handleStartSoftApFailure(START_RESULT_FAILURE_SET_COUNTRY_CODE); break; } // Wait for driver country code if driver supports regulatory change event. if (isCountryCodeChanged || shouldwaitForDriverCountryCodeIfNoCountryToSet) { Log.i(getTag(), "Need to wait for driver country code update before" + " starting"); transitionTo(mWaitingForDriverCountryCodeChangedState); break; } int startResult = startSoftAp(); if (startResult != START_RESULT_SUCCESS) { handleStartSoftApFailure(startResult); break; } transitionTo(mStartedState); break; case CMD_UPDATE_CAPABILITY: SoftApCapability capability = (SoftApCapability) message.obj; mCurrentSoftApCapability = new SoftApCapability(capability); updateSafeChannelFrequencyList(); break; case CMD_UPDATE_CONFIG: { SoftApConfiguration newConfig = (SoftApConfiguration) message.obj; mSpecifiedModeConfiguration = new SoftApModeConfiguration( mSpecifiedModeConfiguration.getTargetMode(), newConfig, mCurrentSoftApCapability, mCountryCode, mSpecifiedModeConfiguration.getTetheringRequest()); Log.d(getTag(), "Configuration changed to " + newConfig); // Idle mode, update all configurations. mCurrentSoftApConfiguration = newConfig; configureInternalConfiguration(); break; } case CMD_UPDATE_COUNTRY_CODE: String countryCode = (String) message.obj; if (!TextUtils.isEmpty(countryCode)) { mCountryCode = countryCode; } break; default: // Ignore all other commands. break; } return HANDLED; } } private boolean isBridgedApAvailable() { // Skip if bridged mode isn't supported. if (!ApConfigUtil.isBridgedModeSupported(mContext, mWifiNative)) { return false; } // Checking STA status only when device supports STA + AP concurrency // since STA would be dropped when device doesn't support it. final List cmms = mActiveModeWarden.getClientModeManagers(); if (cmms.size() != 0 && mWifiNative.isStaApConcurrencySupported()) { if (ApConfigUtil.isStaWithBridgedModeSupported(mContext, mWifiNative)) { for (ClientModeManager cmm : mActiveModeWarden.getClientModeManagers()) { WifiInfo wifiConnectedInfo = cmm.getConnectionInfo(); int wifiFrequency = wifiConnectedInfo.getFrequency(); if (wifiFrequency > 0 && !mSafeChannelFrequencyList.contains( wifiFrequency)) { Log.d(getTag(), "Wifi connected to unavailable freq: " + wifiFrequency); return false; } } } else { // The client mode exist but DUT doesn't support // STA + bridged AP, we should fallback to single AP mode. Log.d(getTag(), " STA iface exist but device doesn't support STA + Bridged AP"); return false; } } // Fallback if the target country code is world mode. if (mCountryCode != null && mCountryCode.equalsIgnoreCase( mResourceCache.getString( R.string.config_wifiDriverWorldModeCountryCode))) { Log.i(getTag(), "Country code changed to world mode - fallback to single AP"); return false; } // Fall back to Single AP if it's not possible to create a Bridged AP. if (!mWifiNative.isItPossibleToCreateBridgedApIface(mRequestorWs)) { Log.i(getTag(), "Not possible to create bridged AP iface - fallback to single AP"); return false; } // Fall back to single AP if creating a single AP does not require // destroying an exististng iface, but creating a bridged AP does. if (mWifiNative.shouldDowngradeToSingleApForConcurrency(mRequestorWs)) { Log.d(getTag(), "Creating bridged AP will destroy an existing" + " iface, but single AP will not."); return false; } return true; } private class WaitingForDriverCountryCodeChangedState extends RunnerState { private static final int TIMEOUT_MS = 5_000; private final WifiCountryCode.ChangeListener mCountryCodeChangeListener = countryCode -> sendMessage(CMD_DRIVER_COUNTRY_CODE_CHANGED, countryCode); WaitingForDriverCountryCodeChangedState(int threshold) { super(threshold, mWifiInjector.getWifiHandlerLocalLog()); } @Override public void enterImpl() { mWifiInjector.getWifiCountryCode().registerListener(mCountryCodeChangeListener); sendMessageDelayed(CMD_DRIVER_COUNTRY_CODE_CHANGE_TIMED_OUT, TIMEOUT_MS); } @Override public void exitImpl() { mWifiInjector.getWifiCountryCode().unregisterListener(mCountryCodeChangeListener); removeMessages(CMD_DRIVER_COUNTRY_CODE_CHANGE_TIMED_OUT); } @Override public boolean processMessageImpl(Message message) { if (message.what == CMD_DRIVER_COUNTRY_CODE_CHANGED) { if (!TextUtils.isEmpty(mCountryCode) && !TextUtils.equals(mCountryCode, (String) message.obj)) { Log.i(getTag(), "Ignore country code changed: " + message.obj); return HANDLED; } Log.i(getTag(), "Driver country code change to " + message.obj + ", continue starting."); mCountryCode = (String) message.obj; mCurrentSoftApCapability.setCountryCode(mCountryCode); mCurrentSoftApCapability = ApConfigUtil.updateSoftApCapabilityWithAvailableChannelList( mCurrentSoftApCapability, mContext, mWifiNative, null); updateSafeChannelFrequencyList(); int[] oldBands = mCurrentSoftApConfiguration.getBands(); if (isBridgedApAvailable() && mIsUsingPersistentSoftApConfiguration) { mCurrentSoftApConfiguration = ApConfigUtil.upgradeTo2g5gBridgedIfAvailableBandsAreSubset( mCurrentSoftApConfiguration, mCurrentSoftApCapability, mContext); } if (isBridgedMode()) { SoftApConfiguration tempConfig = ApConfigUtil.removeUnavailableBandsFromConfig( mCurrentSoftApConfiguration, mCurrentSoftApCapability, mCoexManager, mContext); if (tempConfig == null) { handleStartSoftApFailure(START_RESULT_FAILURE_UNSUPPORTED_CONFIG); transitionTo(mIdleState); return HANDLED; } mCurrentSoftApConfiguration = tempConfig; if (mCurrentSoftApConfiguration.getBands().length != oldBands.length) { Log.i(getTag(), "Restarting AP interface to accommodate band change" + " from " + Arrays.toString(oldBands) + " to " + Arrays.toString(mCurrentSoftApConfiguration.getBands())); mWifiNative.teardownInterface(mApInterfaceName); mApInterfaceName = mWifiNative.setupInterfaceForSoftApMode( mWifiNativeInterfaceCallback, mRequestorWs, mCurrentSoftApConfiguration.getBand(), isBridgeRequired(), SoftApManager.this, getVendorData(), mIsUsingMlo); if (TextUtils.isEmpty(mApInterfaceName)) { Log.e(getTag(), "setup failure when creating single AP iface"); handleStartSoftApFailure(START_RESULT_FAILURE_GENERAL); transitionTo(mIdleState); return HANDLED; } } } } else if (message.what == CMD_DRIVER_COUNTRY_CODE_CHANGE_TIMED_OUT) { Log.i(getTag(), "Timed out waiting for driver country code change, " + "continue starting anyway."); } else { Log.i(getTag(), "Defer " + getWhatToString(message.what) + " while waiting for driver country code change."); deferMessage(message); return HANDLED; } int startResult = startSoftAp(); if (startResult != START_RESULT_SUCCESS) { handleStartSoftApFailure(startResult); transitionTo(mIdleState); return HANDLED; } transitionTo(mStartedState); return HANDLED; } @Override public String getMessageLogRec(int what) { return SoftApManager.class.getSimpleName() + "." + RunnerState.class.getSimpleName() + "." + getWhatToString(what); } } private class StartedState extends RunnerState { StartedState(int threshold) { super(threshold, mWifiInjector.getWifiHandlerLocalLog()); } BroadcastReceiver mBatteryPluggedReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { sendMessage(CMD_PLUGGED_STATE_CHANGED, intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, 0)); } }; private void rescheduleBothBridgedInstancesTimeoutMessage() { Set instances = mCurrentSoftApInfoMap.keySet(); String HighestFrequencyInstance = getHighestFrequencyInstance(instances); // Schedule bridged mode timeout on all instances if needed for (String instance : instances) { long timeout = getShutdownIdleInstanceInBridgedModeTimeoutMillis(); if (!TextUtils.equals(instance, HighestFrequencyInstance)) { // Make sure that we shutdown the higher frequency instance first by adding // offset for lower frequency instance. timeout += SCHEDULE_IDLE_INSTANCE_SHUTDOWN_TIMEOUT_DELAY_MS; } rescheduleTimeoutMessageIfNeeded(instance, timeout); } } /** * Schedule timeout message depends on Soft Ap instance * * @param changedInstance the schedule should change on specific instance only. * If changedInstance is mApInterfaceName, it means that * we need to reschedule all of timeout message. */ private void rescheduleTimeoutMessages(@NonNull String changedInstance) { // Don't trigger bridged mode shutdown timeout when only one active instance // In Dual AP, one instance may already be closed due to LTE coexistence or DFS // restrictions or due to inactivity. i.e. mCurrentSoftApInfoMap.size() is 1) if (isBridgedMode() && mCurrentSoftApInfoMap.size() == 2) { if (TextUtils.equals(mApInterfaceName, changedInstance)) { rescheduleBothBridgedInstancesTimeoutMessage(); } else { rescheduleTimeoutMessageIfNeeded(changedInstance, getShutdownIdleInstanceInBridgedModeTimeoutMillis()); } } // Always evaluate timeout schedule on tetheringInterface rescheduleTimeoutMessageIfNeeded(mApInterfaceName, getShutdownTimeoutMillis()); } private void removeIfaceInstanceFromBridgedApIface(String instanceName) { if (TextUtils.isEmpty(instanceName)) { return; } if (mCurrentSoftApInfoMap.containsKey(instanceName)) { Log.i(getTag(), "remove instance " + instanceName + "(" + mCurrentSoftApInfoMap.get(instanceName).getFrequency() + ") from bridged iface " + mApInterfaceName); mWifiNative.removeIfaceInstanceFromBridgedApIface(mApInterfaceName, instanceName, mIsUsingMlo); // Remove the info and update it. updateSoftApInfo(mCurrentSoftApInfoMap.get(instanceName), true); } } /** * Schedule the timeout message when timeout control is enabled and there is no client * connect to the instance. * * @param instance The key of the {@code mSoftApTimeoutMessageMap}, * @see mSoftApTimeoutMessageMap for details. */ private void rescheduleTimeoutMessageIfNeeded(String instance, long timeoutValue) { final boolean isTetheringInterface = TextUtils.equals(mApInterfaceName, instance); final boolean timeoutEnabled = isTetheringInterface ? mTimeoutEnabled : (mBridgedModeOpportunisticsShutdownTimeoutEnabled && !mIsPlugged); final int clientNumber = isTetheringInterface ? getConnectedClientList().size() : mConnectedClientWithApInfoMap.get(instance).size(); Log.d(getTag(), "rescheduleTimeoutMessageIfNeeded " + instance + ", timeoutEnabled=" + timeoutEnabled + ", isPlugged=" + mIsPlugged + ", clientNumber=" + clientNumber); if (!timeoutEnabled || clientNumber != 0) { cancelTimeoutMessage(instance); return; } scheduleTimeoutMessage(instance, timeoutValue); } private void scheduleTimeoutMessage(String instance, long timeout) { if (mSoftApTimeoutMessageMap.containsKey(instance)) { mSoftApTimeoutMessageMap.get(instance).schedule( SystemClock.elapsedRealtime() + timeout); Log.d(getTag(), "Timeout message scheduled, on " + instance + ", delay = " + timeout); } } private void cancelTimeoutMessage(String instance) { if (mSoftApTimeoutMessageMap.containsKey(instance)) { mSoftApTimeoutMessageMap.get(instance).cancel(); Log.d(getTag(), "Timeout message canceled on " + instance); } } /** * When configuration changed, it need to force some clients disconnect to match the * configuration. */ private void updateClientConnection() { if (!mCurrentSoftApCapability.areFeaturesSupported( SoftApCapability.SOFTAP_FEATURE_CLIENT_FORCE_DISCONNECT)) { return; } final int maxAllowedClientsByHardwareAndCarrier = mCurrentSoftApCapability.getMaxSupportedClients(); final int userApConfigMaxClientCount = mCurrentSoftApConfiguration.getMaxNumberOfClients(); int finalMaxClientCount = maxAllowedClientsByHardwareAndCarrier; if (userApConfigMaxClientCount > 0) { finalMaxClientCount = Math.min(userApConfigMaxClientCount, maxAllowedClientsByHardwareAndCarrier); } List currentClients = getConnectedClientList(); int targetDisconnectClientNumber = currentClients.size() - finalMaxClientCount; List allowedConnectedList = new ArrayList<>(); Iterator iterator = currentClients.iterator(); while (iterator.hasNext()) { WifiClient client = iterator.next(); if (mBlockedClientList.contains(client.getMacAddress()) || (mCurrentSoftApConfiguration.isClientControlByUserEnabled() && !mAllowedClientList.contains(client.getMacAddress()))) { Log.d(getTag(), "Force disconnect for not allowed client: " + client); if (!mWifiNative.forceClientDisconnect( mApInterfaceName, client.getMacAddress(), WifiManager.SAP_CLIENT_BLOCK_REASON_CODE_BLOCKED_BY_USER)) { addClientToPendingDisconnectionList(client, WifiManager.SAP_CLIENT_BLOCK_REASON_CODE_BLOCKED_BY_USER); } targetDisconnectClientNumber--; } else { allowedConnectedList.add(client); } } if (targetDisconnectClientNumber > 0) { Iterator allowedClientIterator = allowedConnectedList.iterator(); while (allowedClientIterator.hasNext()) { if (targetDisconnectClientNumber == 0) break; WifiClient allowedClient = allowedClientIterator.next(); Log.d(getTag(), "Force disconnect for client due to no more room: " + allowedClient); if (!mWifiNative.forceClientDisconnect( mApInterfaceName, allowedClient.getMacAddress(), WifiManager.SAP_CLIENT_BLOCK_REASON_CODE_NO_MORE_STAS)) { addClientToPendingDisconnectionList(allowedClient, WifiManager.SAP_CLIENT_BLOCK_REASON_CODE_NO_MORE_STAS); } targetDisconnectClientNumber--; } } } /** * Set stations associated with this soft AP * @param client The station for which connection state changed. * @param isConnected True for the connection changed to connect, otherwise false. */ private void updateConnectedClients(WifiClient client, boolean isConnected) { if (client == null) { return; } if (null != mPendingDisconnectClients.remove(client)) { Log.d(getTag(), "Remove client: " + client.getMacAddress() + "from pending disconnectionlist"); } String apInstanceIdentifier = client.getApInstanceIdentifier(); List clientList = mConnectedClientWithApInfoMap.computeIfAbsent( apInstanceIdentifier, k -> new ArrayList<>()); int index = clientList.indexOf(client); if ((index != -1) == isConnected) { Log.e(getTag(), "Drop client connection event, client " + client + "isConnected: " + isConnected + " , duplicate event or client is blocked"); return; } if (isConnected) { boolean isAllow = checkSoftApClient(mCurrentSoftApConfiguration, client); if (isAllow) { clientList.add(client); mMaxConnectedClients = clientList.size() > mMaxConnectedClients ? clientList.size() : mMaxConnectedClients; } else { return; } } else { if (null == clientList.remove(index)) { Log.e(getTag(), "client doesn't exist in list, it should NOT happen"); } } // Update clients list. mConnectedClientWithApInfoMap.put(apInstanceIdentifier, clientList); SoftApInfo currentInfoWithClientsChanged = mCurrentSoftApInfoMap .get(apInstanceIdentifier); Log.d(getTag(), "The connected wifi stations have changed with count: " + clientList.size() + ": " + clientList + " on the AP which info is " + currentInfoWithClientsChanged); if (mSoftApCallback != null) { if (Flags.softapDisconnectReason() && !isConnected) { // Client successfully disconnected, should also notify callback mWifiMetrics.reportOnClientsDisconnected(client.getDisconnectReason(), mRequestorWs); mSoftApCallback.onClientsDisconnected( currentInfoWithClientsChanged, ImmutableList.of(client)); } mSoftApCallback.onConnectedClientsOrInfoChanged(mCurrentSoftApInfoMap, mConnectedClientWithApInfoMap, isBridgeRequired()); } else { Log.e(getTag(), "SoftApCallback is null. Dropping ConnectedClientsChanged event."); } mWifiMetrics.addSoftApNumAssociatedStationsChangedEvent( getConnectedClientList().size(), mConnectedClientWithApInfoMap.get(apInstanceIdentifier).size(), mSpecifiedModeConfiguration.getTargetMode(), mCurrentSoftApInfoMap.get(apInstanceIdentifier)); rescheduleTimeoutMessages(apInstanceIdentifier); } /** * @param apInfo, the new SoftApInfo changed. Null used to clean up. */ private void updateSoftApInfo(@Nullable SoftApInfo apInfo, boolean isRemoved) { Log.d(getTag(), "SoftApInfo update " + apInfo + ", isRemoved: " + isRemoved); if (apInfo == null) { // Clean up mCurrentSoftApInfoMap.clear(); mConnectedClientWithApInfoMap.clear(); mSoftApCallback.onConnectedClientsOrInfoChanged(mCurrentSoftApInfoMap, mConnectedClientWithApInfoMap, isBridgeRequired()); return; } String changedInstance = apInfo.getApInstanceIdentifier(); if (apInfo.equals(mCurrentSoftApInfoMap.get(changedInstance))) { if (isRemoved) { boolean isClientConnected = mConnectedClientWithApInfoMap.get(changedInstance).size() > 0; mCurrentSoftApInfoMap.remove(changedInstance); mSoftApTimeoutMessageMap.remove(changedInstance); mConnectedClientWithApInfoMap.remove(changedInstance); mSoftApCallback.onConnectedClientsOrInfoChanged(mCurrentSoftApInfoMap, mConnectedClientWithApInfoMap, isBridgeRequired()); if (isClientConnected) { mWifiMetrics.addSoftApNumAssociatedStationsChangedEvent( getConnectedClientList().size(), 0, mSpecifiedModeConfiguration.getTargetMode(), apInfo); } if (isBridgeRequired()) { mWifiMetrics.addSoftApInstanceDownEventInDualMode( mSpecifiedModeConfiguration.getTargetMode(), apInfo); } } return; } // Make sure an empty client list is created when info updated List clientList = mConnectedClientWithApInfoMap.computeIfAbsent( changedInstance, k -> new ArrayList<>()); if (clientList.size() != 0) { Log.e(getTag(), "The info: " + apInfo + " changed when client connected, it should NOT happen!!"); } mCurrentSoftApInfoMap.put(changedInstance, new SoftApInfo(apInfo)); mSoftApCallback.onConnectedClientsOrInfoChanged(mCurrentSoftApInfoMap, mConnectedClientWithApInfoMap, isBridgeRequired()); boolean isNeedToScheduleTimeoutMessage = false; if (!mSoftApTimeoutMessageMap.containsKey(mApInterfaceName)) { // First info update, create WakeupMessage for mApInterfaceName. mSoftApTimeoutMessageMap.put(mApInterfaceName, new WakeupMessage( mContext, mStateMachine.getHandler(), SOFT_AP_SEND_MESSAGE_TIMEOUT_TAG + mApInterfaceName, SoftApStateMachine.CMD_NO_ASSOCIATED_STATIONS_TIMEOUT)); isNeedToScheduleTimeoutMessage = true; } if (isBridgedMode() && !mSoftApTimeoutMessageMap.containsKey(changedInstance)) { mSoftApTimeoutMessageMap.put(changedInstance, new WakeupMessage(mContext, mStateMachine.getHandler(), SOFT_AP_SEND_MESSAGE_TIMEOUT_TAG + changedInstance, SoftApStateMachine.CMD_NO_ASSOCIATED_STATIONS_TIMEOUT_ON_ONE_INSTANCE, 0, 0, changedInstance)); isNeedToScheduleTimeoutMessage = true; } // Trigger schedule after mCurrentSoftApInfoMap is updated. if (isNeedToScheduleTimeoutMessage) { rescheduleTimeoutMessages(mApInterfaceName); } // ignore invalid freq and softap disable case for metrics if (apInfo.getFrequency() > 0 && apInfo.getBandwidth() != SoftApInfo.CHANNEL_WIDTH_INVALID) { mWifiMetrics.addSoftApChannelSwitchedEvent( new ArrayList<>(mCurrentSoftApInfoMap.values()), mSpecifiedModeConfiguration.getTargetMode(), isBridgeRequired()); updateUserBandPreferenceViolationMetricsIfNeeded(apInfo); } } private void onUpChanged(boolean isUp) { if (isUp == mIfaceIsUp) { return; // no change } mIfaceIsUp = isUp; if (isUp) { Log.d(getTag(), "SoftAp is ready for use"); updateApState(WifiManager.WIFI_AP_STATE_ENABLED, WifiManager.WIFI_AP_STATE_ENABLING, 0); mModeListener.onStarted(SoftApManager.this); mWifiMetrics.incrementSoftApStartResult(true, 0); mCurrentSoftApInfoMap.clear(); mConnectedClientWithApInfoMap.clear(); if (mSoftApCallback != null) { mSoftApCallback.onConnectedClientsOrInfoChanged(mCurrentSoftApInfoMap, mConnectedClientWithApInfoMap, isBridgeRequired()); } } else { // the interface was up, but goes down sendMessage(CMD_INTERFACE_DOWN); } mWifiMetrics.addSoftApUpChangedEvent( isUp, mSpecifiedModeConfiguration.getTargetMode(), mDefaultShutdownTimeoutMillis, isBridgeRequired()); if (isUp) { mWifiMetrics.updateSoftApConfiguration( mCurrentSoftApConfiguration, mSpecifiedModeConfiguration.getTargetMode(), isBridgeRequired()); mWifiMetrics.updateSoftApCapability( mCurrentSoftApCapability, mSpecifiedModeConfiguration.getTargetMode(), isBridgeRequired()); } } @Override public void enterImpl() { mIfaceIsUp = false; mIfaceIsDestroyed = false; onUpChanged(mWifiNative.isInterfaceUp(mApInterfaceName)); Handler handler = mStateMachine.getHandler(); if (SdkLevel.isAtLeastS()) { mCoexManager.registerCoexListener(mCoexListener); } if (mIsDisableShutDownBridgedModeIdleInstanceTimerWhenPlugged) { Intent stickyIntent = mContext.registerReceiver(mBatteryPluggedReceiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED)); mIsPlugged = stickyIntent.getIntExtra(BatteryManager.EXTRA_STATUS, 0) != 0; } mSarManager.setSapWifiState(WifiManager.WIFI_AP_STATE_ENABLED); Log.d(getTag(), "Resetting connected clients on start"); mConnectedClientWithApInfoMap.clear(); mPendingDisconnectClients.clear(); mEverReportMetricsForMaxClient = false; writeSoftApStartedEvent(START_RESULT_SUCCESS); } @Override public void exitImpl() { if (!mIfaceIsDestroyed) { stopSoftAp(); } if (SdkLevel.isAtLeastS()) { mCoexManager.unregisterCoexListener(mCoexListener); } if (getConnectedClientList().size() != 0) { Log.d(getTag(), "Resetting num stations on stop"); for (List it : mConnectedClientWithApInfoMap.values()) { if (it.size() != 0) { mWifiMetrics.addSoftApNumAssociatedStationsChangedEvent( 0, 0, mSpecifiedModeConfiguration.getTargetMode(), mCurrentSoftApInfoMap.get(it.get(0).getApInstanceIdentifier())); } } mConnectedClientWithApInfoMap.clear(); if (mSoftApCallback != null) { mSoftApCallback.onConnectedClientsOrInfoChanged(mCurrentSoftApInfoMap, mConnectedClientWithApInfoMap, isBridgeRequired()); } } mPendingDisconnectClients.clear(); for (String key : mSoftApTimeoutMessageMap.keySet()) { cancelTimeoutMessage(key); } mSoftApTimeoutMessageMap.clear(); if (mIsDisableShutDownBridgedModeIdleInstanceTimerWhenPlugged) { mContext.unregisterReceiver(mBatteryPluggedReceiver); } // Need this here since we are exiting |Started| state and won't handle any // future CMD_INTERFACE_STATUS_CHANGED events after this point mWifiMetrics.addSoftApUpChangedEvent( false, mSpecifiedModeConfiguration.getTargetMode(), mDefaultShutdownTimeoutMillis, isBridgeRequired()); updateApState(WifiManager.WIFI_AP_STATE_DISABLED, WifiManager.WIFI_AP_STATE_DISABLING, 0); mSarManager.setSapWifiState(WifiManager.WIFI_AP_STATE_DISABLED); mApInterfaceName = null; mIfaceIsUp = false; mIfaceIsDestroyed = false; mRole = null; updateSoftApInfo(null, false); } private void updateUserBandPreferenceViolationMetricsIfNeeded(SoftApInfo apInfo) { // The band preference violation only need to detect in single AP mode. if (isBridgeRequired()) return; int band = mCurrentSoftApConfiguration.getBand(); boolean bandPreferenceViolated = (ScanResult.is24GHz(apInfo.getFrequency()) && !ApConfigUtil.containsBand(band, SoftApConfiguration.BAND_2GHZ)) || (ScanResult.is5GHz(apInfo.getFrequency()) && !ApConfigUtil.containsBand(band, SoftApConfiguration.BAND_5GHZ)) || (ScanResult.is6GHz(apInfo.getFrequency()) && !ApConfigUtil.containsBand(band, SoftApConfiguration.BAND_6GHZ)); if (bandPreferenceViolated) { Log.e(getTag(), "Channel does not satisfy user band preference: " + apInfo.getFrequency()); mWifiMetrics.incrementNumSoftApUserBandPreferenceUnsatisfied(); } } @Override public String getMessageLogRec(int what) { return SoftApManager.class.getSimpleName() + "." + RunnerState.class.getSimpleName() + "." + getWhatToString(what); } @Override public boolean processMessageImpl(Message message) { switch (message.what) { case CMD_ASSOCIATED_STATIONS_CHANGED: if (!(message.obj instanceof WifiClient)) { Log.e(getTag(), "Invalid type returned for" + " CMD_ASSOCIATED_STATIONS_CHANGED"); break; } boolean isConnected = (message.arg1 == 1); WifiClient client = (WifiClient) message.obj; Log.d(getTag(), "CMD_ASSOCIATED_STATIONS_CHANGED, Client: " + client.getMacAddress().toString() + " isConnected: " + isConnected + " disconnectReason: " + client.getDisconnectReason()); updateConnectedClients(client, isConnected); break; case CMD_AP_INFO_CHANGED: if (!(message.obj instanceof SoftApInfo)) { Log.e(getTag(), "Invalid type returned for" + " CMD_AP_INFO_CHANGED"); break; } SoftApInfo apInfo = (SoftApInfo) message.obj; if (apInfo.getFrequency() < 0) { Log.e(getTag(), "Invalid ap channel frequency: " + apInfo.getFrequency()); break; } // Update shutdown timeout apInfo.setAutoShutdownTimeoutMillis(mTimeoutEnabled ? getShutdownTimeoutMillis() : 0); updateSoftApInfo(apInfo, false); break; case CMD_INTERFACE_STATUS_CHANGED: boolean isUp = message.arg1 == 1; onUpChanged(isUp); break; case CMD_STOP: if (mIfaceIsUp) { updateApState(WifiManager.WIFI_AP_STATE_DISABLING, WifiManager.WIFI_AP_STATE_ENABLED, 0); } else { updateApState(WifiManager.WIFI_AP_STATE_DISABLING, WifiManager.WIFI_AP_STATE_ENABLING, 0); } writeSoftApStoppedEvent(STOP_EVENT_STOPPED); quitNow(); break; case CMD_START: // Already started, ignore this command. break; case CMD_NO_ASSOCIATED_STATIONS_TIMEOUT: if (!mTimeoutEnabled) { Log.i(getTag(), "Timeout message received while timeout is disabled." + " Dropping."); break; } if (getConnectedClientList().size() != 0) { Log.i(getTag(), "Timeout message received but has clients. " + "Dropping."); break; } mSoftApNotifier.showSoftApShutdownTimeoutExpiredNotification(); Log.i(getTag(), "Timeout message received. Stopping soft AP."); updateApState(WifiManager.WIFI_AP_STATE_DISABLING, WifiManager.WIFI_AP_STATE_ENABLED, 0); writeSoftApStoppedEvent(STOP_EVENT_NO_USAGE_TIMEOUT); quitNow(); break; case CMD_NO_ASSOCIATED_STATIONS_TIMEOUT_ON_ONE_INSTANCE: String idleInstance = (String) message.obj; if (!isBridgedMode() || mCurrentSoftApInfoMap.size() != 2) { Log.d(getTag(), "Ignore Bridged Mode Timeout message received" + " in single AP state. Dropping it from " + idleInstance); break; } if (!mBridgedModeOpportunisticsShutdownTimeoutEnabled) { Log.i(getTag(), "Bridged Mode Timeout message received" + " while timeout is disabled. Dropping."); break; } Log.d(getTag(), "Instance idle timout on " + idleInstance); removeIfaceInstanceFromBridgedApIface(idleInstance); break; case CMD_INTERFACE_DESTROYED: String ifaceName = (String) message.obj; Log.d(getTag(), "Interface: " + ifaceName + " was cleanly destroyed."); if (mApInterfaceName == null) { Log.e(getTag(), "softAp interface is null" + " - Drop interface destroyed message"); break; } if (!mApInterfaceName.equals(ifaceName)) { Log.d(getTag(), "Drop stale interface destroyed message"); break; } updateApState(WifiManager.WIFI_AP_STATE_DISABLING, WifiManager.WIFI_AP_STATE_ENABLED, 0); mIfaceIsDestroyed = true; writeSoftApStoppedEvent(STOP_EVENT_INTERFACE_DESTROYED); quitNow(); break; case CMD_FAILURE: String instance = (String) message.obj; if (isBridgedMode()) { List instances = mWifiNative.getBridgedApInstances(mApInterfaceName); if (instance != null) { Log.i(getTag(), "receive instanceFailure on " + instance); removeIfaceInstanceFromBridgedApIface(instance); instances = mWifiNative.getBridgedApInstances(mApInterfaceName); // Check if there's any instance still active. if (instances != null && instances.size() > 0) { break; } } else if (mCurrentSoftApInfoMap.size() == 1 && instances != null && instances.size() == 1) { if (!mCurrentSoftApInfoMap.containsKey(instances.get(0))) { // there is an available instance but the info doesn't be // updated, keep AP on and remove unavailable instance info. for (String unavailableInstance : mCurrentSoftApInfoMap.keySet()) { removeIfaceInstanceFromBridgedApIface(unavailableInstance); } break; } } } Log.w(getTag(), "hostapd failure, stop and report failure"); writeSoftApStoppedEvent(STOP_EVENT_HOSTAPD_FAILURE); /* fall through */ case CMD_INTERFACE_DOWN: Log.w(getTag(), "interface error, stop and report failure"); updateApState(WifiManager.WIFI_AP_STATE_FAILED, WifiManager.WIFI_AP_STATE_ENABLED, WifiManager.SAP_START_FAILURE_GENERAL); updateApState(WifiManager.WIFI_AP_STATE_DISABLING, WifiManager.WIFI_AP_STATE_FAILED, 0); writeSoftApStoppedEvent(STOP_EVENT_INTERFACE_DOWN); quitNow(); break; case CMD_UPDATE_CAPABILITY: SoftApCapability capability = (SoftApCapability) message.obj; mCurrentSoftApCapability = new SoftApCapability(capability); mWifiMetrics.updateSoftApCapability( mCurrentSoftApCapability, mSpecifiedModeConfiguration.getTargetMode(), isBridgeRequired()); updateClientConnection(); updateSafeChannelFrequencyList(); break; case CMD_UPDATE_CONFIG: { SoftApConfiguration newConfig = (SoftApConfiguration) message.obj; SoftApConfiguration originalConfig = mSpecifiedModeConfiguration.getSoftApConfiguration(); if (!ApConfigUtil.checkConfigurationChangeNeedToRestart( originalConfig, newConfig)) { mSpecifiedModeConfiguration = new SoftApModeConfiguration( mSpecifiedModeConfiguration.getTargetMode(), newConfig, mCurrentSoftApCapability, mCountryCode, mSpecifiedModeConfiguration.getTetheringRequest()); Log.d(getTag(), "Configuration changed to " + newConfig); if (mCurrentSoftApConfiguration.getMaxNumberOfClients() != newConfig.getMaxNumberOfClients()) { Log.d(getTag(), "Max Client changed, reset to record the metrics"); mEverReportMetricsForMaxClient = false; } boolean needRescheduleTimeoutMessage = mCurrentSoftApConfiguration.getShutdownTimeoutMillis() != newConfig.getShutdownTimeoutMillis() || mTimeoutEnabled != newConfig.isAutoShutdownEnabled() || mBridgedModeOpportunisticsShutdownTimeoutEnabled != newConfig .isBridgedModeOpportunisticShutdownEnabledInternal(); updateChangeableConfiguration(newConfig); updateClientConnection(); if (needRescheduleTimeoutMessage) { for (String key : mSoftApTimeoutMessageMap.keySet()) { cancelTimeoutMessage(key); } rescheduleTimeoutMessages(mApInterfaceName); // Update SoftApInfo for (SoftApInfo info : mCurrentSoftApInfoMap.values()) { SoftApInfo newInfo = new SoftApInfo(info); newInfo.setAutoShutdownTimeoutMillis(mTimeoutEnabled ? getShutdownTimeoutMillis() : 0); updateSoftApInfo(newInfo, false); } } mWifiMetrics.updateSoftApConfiguration( mCurrentSoftApConfiguration, mSpecifiedModeConfiguration.getTargetMode(), isBridgeRequired()); } else { Log.d(getTag(), "Ignore the config: " + newConfig + " update since it requires restart"); } break; } case CMD_UPDATE_COUNTRY_CODE: String countryCode = (String) message.obj; if (!TextUtils.isEmpty(countryCode) && !TextUtils.equals(mCountryCode, countryCode) && mWifiNative.setApCountryCode( mApInterfaceName, countryCode.toUpperCase(Locale.ROOT))) { Log.i(getTag(), "Update country code when Soft AP enabled from " + mCountryCode + " to " + countryCode); mCountryCode = countryCode; } break; case CMD_FORCE_DISCONNECT_PENDING_CLIENTS: if (mPendingDisconnectClients.size() != 0) { Log.d(getTag(), "Disconnect pending list is NOT empty"); mPendingDisconnectClients.forEach((pendingClient, reason)-> mWifiNative.forceClientDisconnect(mApInterfaceName, pendingClient.getMacAddress(), reason)); sendMessageDelayed( SoftApStateMachine.CMD_FORCE_DISCONNECT_PENDING_CLIENTS, SOFT_AP_PENDING_DISCONNECTION_CHECK_DELAY_MS); } break; case CMD_SAFE_CHANNEL_FREQUENCY_CHANGED: updateSafeChannelFrequencyList(); if (!isBridgedMode() || mCurrentSoftApInfoMap.size() != 2) { Log.d(getTag(), "Ignore safe channel changed in single AP state"); break; } Set unavailableInstances = new HashSet<>(); for (SoftApInfo currentInfo : mCurrentSoftApInfoMap.values()) { int sapFreq = currentInfo.getFrequency(); if (!mSafeChannelFrequencyList.contains(sapFreq)) { int sapBand = ApConfigUtil.convertFrequencyToBand(sapFreq); if (sapBand != ApConfigUtil.removeUnavailableBands( mCurrentSoftApCapability, sapBand, mCoexManager)) { unavailableInstances.add(currentInfo.getApInstanceIdentifier()); } } } removeIfaceInstanceFromBridgedApIface( getHighestFrequencyInstance(unavailableInstances)); break; case CMD_HANDLE_WIFI_CONNECTED: if (!isBridgeRequired() || mCurrentSoftApInfoMap.size() != 2) { Log.d(getTag(), "Ignore wifi connected in single AP state"); break; } ConcreteClientModeManager cmm = (ConcreteClientModeManager) message.obj; String wifiInterface = cmm.getInterfaceName(); WifiInfo wifiInfo = cmm.getConnectionInfo(); int wifiFreq = wifiInfo.getFrequency(); int wifiBand = ApConfigUtil.convertFrequencyToBand(wifiFreq); List bands = new ArrayList(); bands.add(wifiBand); String targetShutDownInstance = ""; if (wifiFreq > 0 && !mSafeChannelFrequencyList.contains(wifiFreq)) { Log.i(getTag(), "Wifi connected to freq:" + wifiFreq + " which is unavailable for SAP"); for (SoftApInfo sapInfo : mCurrentSoftApInfoMap.values()) { int sapBand = ApConfigUtil.convertFrequencyToBand(sapInfo.getFrequency()); if (sapBand == wifiBand) { targetShutDownInstance = sapInfo.getApInstanceIdentifier(); Log.d(getTag(), "Remove the " + targetShutDownInstance + " instance which is running on the same band as " + "the wifi connection on an unsafe channel"); } else { bands.add(sapBand); } } // Wifi may connect to different band as the SAP. For instances: // Wifi connect to 6Ghz but bridged AP is running on 2.4Ghz + 5Ghz. // In this case, targetShutDownInstance will be empty, check whether // the chip supports this combination. If not, shutdown the highest // frequency instance. if (TextUtils.isEmpty(targetShutDownInstance)) { // We have to use STA ifacename to query band combinations. if (!mWifiNative.isBandCombinationSupported(wifiInterface, bands)) { removeIfaceInstanceFromBridgedApIface( getHighestFrequencyInstance( mCurrentSoftApInfoMap.keySet())); } } else { removeIfaceInstanceFromBridgedApIface(targetShutDownInstance); } } break; case CMD_PLUGGED_STATE_CHANGED: boolean newIsPlugged = (message.arg1 != 0); if (mIsPlugged != newIsPlugged) { mIsPlugged = newIsPlugged; if (mCurrentSoftApInfoMap.size() == 2) { rescheduleBothBridgedInstancesTimeoutMessage(); } } break; default: return NOT_HANDLED; } return HANDLED; } } } // Logging code private int getCurrentStaFreqMhz() { int staFreqMhz = WifiInfo.UNKNOWN_FREQUENCY; for (ClientModeManager cmm : mActiveModeWarden.getClientModeManagers()) { WifiInfo wifiConnectedInfo = cmm.getConnectionInfo(); if (wifiConnectedInfo != null) { staFreqMhz = wifiConnectedInfo.getFrequency(); break; } } return staFreqMhz; } /** * Writes the SoftApStarted event to metrics. Only the first call will write the metrics, any * subsequent calls will be ignored. */ public void writeSoftApStartedEvent(@StartResult int startResult) { if (mIsSoftApStartedEventWritten) { return; } mIsSoftApStartedEventWritten = true; int band1 = WifiScanner.WIFI_BAND_UNSPECIFIED; int band2 = WifiScanner.WIFI_BAND_UNSPECIFIED; @SoftApConfiguration.SecurityType int securityType = SoftApConfiguration.SECURITY_TYPE_OPEN; if (mCurrentSoftApConfiguration != null) { int[] bands = mCurrentSoftApConfiguration.getBands(); if (bands.length >= 1) { band1 = bands[0]; } if (bands.length >= 2) { band2 = bands[1]; } securityType = mCurrentSoftApConfiguration.getSecurityType(); } mWifiMetrics.writeSoftApStartedEvent(startResult, getRole(), band1, band2, ApConfigUtil.isBridgedModeSupported(mContext, mWifiNative), mWifiNative.isStaApConcurrencySupported(), ApConfigUtil.isStaWithBridgedModeSupported(mContext, mWifiNative), getCurrentStaFreqMhz(), securityType, mRequestorWs); } private void writeSoftApStoppedEvent(@StopEvent int stopEvent) { @WifiScanner.WifiBand int band = WifiScanner.WIFI_BAND_UNSPECIFIED; @WifiAnnotations.WifiStandard int standard = ScanResult.WIFI_STANDARD_UNKNOWN; for (SoftApInfo info : mCurrentSoftApInfoMap.values()) { band |= ScanResult.toBand(info.getFrequency()); if (SdkLevel.isAtLeastS()) { standard = info.getWifiStandard(); } } @SoftApConfiguration.SecurityType int securityType = SoftApConfiguration.SECURITY_TYPE_OPEN; if (mCurrentSoftApConfiguration != null) { securityType = mCurrentSoftApConfiguration.getSecurityType(); } int durationSeconds = (int) ((mWifiInjector.getClock().getWallClockMillis() - mStartTimestampMs) / 1000); // TODO(b/245824786): Fill out the rest of the fields mWifiMetrics.writeSoftApStoppedEvent( stopEvent, getRole(), band, isBridgedMode(), mWifiNative.isStaApConcurrencySupported(), ApConfigUtil.isStaWithBridgedModeSupported(mContext, mWifiNative), getCurrentStaFreqMhz(), mDefaultShutdownTimeoutMillis > 0, durationSeconds, securityType, standard, mMaxConnectedClients, mDefaultShutdownIdleInstanceInBridgedModeTimeoutMillis > 0, -1, -1, null); } }