PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Restart Wi-Fi tethering automatically if configuration change" into udc-dev am: 9cdf565458

Browse Source 
Original change: https://googleplex-android-review.googlesource.com/c/platform/packages/apps/Settings/+/22762556

Change-Id: Id871118108437270ddac593adefa863b910d9762
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
This commit is contained in:
Treehugger Robot
2023-04-26 04:33:03 +00:00
committed by Automerger Merge Worker
parent 2727a730ee 9cdf565458
commit 03ec360960
15 changed files with 552 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
src/com/android/settings/wifi/factory/WifiFeatureProvider.java
View File

@@ -18,6 +18,7 @@ package com.android.settings.wifi.factory;
import android.annotation.Nullable;
import android.content.Context;
import android.net.TetheringManager;
import android.net.wifi.WifiManager;
import android.util.Log;
@@ -40,6 +41,7 @@ public class WifiFeatureProvider {
private final Context mAppContext;
private WifiManager mWifiManager;
private TetheringManager mTetheringManager;
private WifiVerboseLogging mWifiVerboseLogging;
private WifiHotspotRepository mWifiHotspotRepository;
@@ -48,7 +50,7 @@ public class WifiFeatureProvider {
}
/**
* Get WifiManager
* Gets WifiManager
*/
public WifiManager getWifiManager() {
if (mWifiManager == null) {
@@ -58,7 +60,18 @@ public class WifiFeatureProvider {
}
/**
* Get WifiVerboseLogging
* Gets TetheringManager
*/
public TetheringManager getTetheringManager() {
if (mTetheringManager == null) {
mTetheringManager = mAppContext.getSystemService(TetheringManager.class);
verboseLog(TAG, "getTetheringManager():" + mTetheringManager);
}
return mTetheringManager;
}
/**
* Gets WifiVerboseLogging
*/
public WifiVerboseLogging getWifiVerboseLogging() {
if (mWifiVerboseLogging == null) {
@@ -68,25 +81,26 @@ public class WifiFeatureProvider {
}
/**
* Get WifiHotspotRepository
* Gets WifiHotspotRepository
*/
public WifiHotspotRepository getWifiHotspotRepository() {
if (mWifiHotspotRepository == null) {
mWifiHotspotRepository = new WifiHotspotRepository(mAppContext, getWifiManager());
mWifiHotspotRepository = new WifiHotspotRepository(mAppContext, getWifiManager(),
getTetheringManager());
verboseLog(TAG, "getWifiHotspotRepository():" + mWifiHotspotRepository);
}
return mWifiHotspotRepository;
}
/**
* Get WifiTetherViewModel
* Gets WifiTetherViewModel
*/
public WifiTetherViewModel getWifiTetherViewModel(@NotNull ViewModelStoreOwner owner) {
return new ViewModelProvider(owner).get(WifiTetherViewModel.class);
}
/**
* Get WifiHotspotSecurityViewModel
* Gets WifiHotspotSecurityViewModel
*/
public WifiHotspotSecurityViewModel getWifiHotspotSecurityViewModel(
@NotNull ViewModelStoreOwner owner) {
@@ -97,7 +111,7 @@ public class WifiFeatureProvider {
}
/**
* Get WifiHotspotSpeedViewModel
* Gets WifiHotspotSpeedViewModel
*/
public WifiHotspotSpeedViewModel getWifiHotspotSpeedViewModel(
@NotNull ViewModelStoreOwner owner) {

139
src/com/android/settings/wifi/repository/WifiHotspotRepository.java
View File

@@ -16,14 +16,18 @@
package com.android.settings.wifi.repository;
import static android.net.TetheringManager.TETHERING_WIFI;
import static android.net.wifi.SoftApConfiguration.BAND_2GHZ;
import static android.net.wifi.SoftApConfiguration.BAND_5GHZ;
import static android.net.wifi.SoftApConfiguration.BAND_6GHZ;
import static android.net.wifi.SoftApConfiguration.SECURITY_TYPE_OPEN;
import static android.net.wifi.SoftApConfiguration.SECURITY_TYPE_WPA3_SAE;
import static android.net.wifi.WifiAvailableChannel.OP_MODE_SAP;
import static android.net.wifi.WifiManager.WIFI_AP_STATE_DISABLED;
import static android.net.wifi.WifiManager.WIFI_AP_STATE_ENABLED;
import android.content.Context;
import android.net.TetheringManager;
import android.net.wifi.SoftApConfiguration;
import android.net.wifi.WifiAvailableChannel;
import android.net.wifi.WifiManager;
@@ -51,6 +55,8 @@ import java.util.function.Consumer;
public class WifiHotspotRepository {
private static final String TAG = "WifiHotspotRepository";
private static final int RESTART_INTERVAL_MS = 100;
/** Wi-Fi hotspot band unknown. */
public static final int BAND_UNKNOWN = 0;
/** Wi-Fi hotspot band 2.4GHz and 5GHz. */
@@ -79,8 +85,9 @@ public class WifiHotspotRepository {
sSpeedMap.put(BAND_2GHZ_5GHZ, SPEED_2GHZ_5GHZ);
}
protected final Context mAppContext;
protected final WifiManager mWifiManager;
private final Context mAppContext;
private final WifiManager mWifiManager;
private final TetheringManager mTetheringManager;
protected String mLastPassword;
protected LastPasswordListener mLastPasswordListener = new LastPasswordListener();
@@ -102,9 +109,24 @@ public class WifiHotspotRepository {
Boolean mIsConfigShowSpeed;
private Boolean mIsSpeedFeatureAvailable;
public WifiHotspotRepository(@NonNull Context appContext, @NonNull WifiManager wifiManager) {
@VisibleForTesting
SoftApCallback mSoftApCallback = new SoftApCallback();
@VisibleForTesting
StartTetheringCallback mStartTetheringCallback;
@VisibleForTesting
int mWifiApState = WIFI_AP_STATE_DISABLED;
@VisibleForTesting
boolean mIsRestarting;
@VisibleForTesting
MutableLiveData<Boolean> mRestarting;
public WifiHotspotRepository(@NonNull Context appContext, @NonNull WifiManager wifiManager,
@NonNull TetheringManager tetheringManager) {
mAppContext = appContext;
mWifiManager = wifiManager;
mTetheringManager = tetheringManager;
mWifiManager.registerSoftApCallback(mAppContext.getMainExecutor(), mSoftApCallback);
}
/**
@@ -126,6 +148,15 @@ public class WifiHotspotRepository {
return !TextUtils.isEmpty(mLastPassword) ? mLastPassword : generateRandomPassword();
}
@VisibleForTesting
String generatePassword(SoftApConfiguration config) {
String password = config.getPassphrase();
if (TextUtils.isEmpty(password)) {
password = generatePassword();
}
return password;
}
private class LastPasswordListener implements Consumer<String> {
@Override
public void accept(String password) {
@@ -139,14 +170,28 @@ public class WifiHotspotRepository {
return randomUUID.substring(0, 8) + randomUUID.substring(9, 13);
}
/**
* Gets the Wi-Fi tethered AP Configuration.
*
* @return AP details in {@link SoftApConfiguration}
*/
public SoftApConfiguration getSoftApConfiguration() {
return mWifiManager.getSoftApConfiguration();
}
/**
* Sets the tethered Wi-Fi AP Configuration.
*
* @param config A valid SoftApConfiguration specifying the configuration of the SAP.
*/
public void setSoftApConfiguration(@NonNull SoftApConfiguration config) {
if (mIsRestarting) {
Log.e(TAG, "Skip setSoftApConfiguration because hotspot is restarting.");
return;
}
mWifiManager.setSoftApConfiguration(config);
refresh();
restartTetheringIfNeeded();
}
/**
@@ -217,13 +262,7 @@ public class WifiHotspotRepository {
return;
}
SoftApConfiguration.Builder configBuilder = new SoftApConfiguration.Builder(config);
String passphrase = null;
if (securityType != SECURITY_TYPE_OPEN) {
passphrase = config.getPassphrase();
if (TextUtils.isEmpty(passphrase)) {
passphrase = generatePassword();
}
}
String passphrase = (securityType == SECURITY_TYPE_OPEN) ? null : generatePassword(config);
configBuilder.setPassphrase(passphrase, securityType);
setSoftApConfiguration(configBuilder.build());
@@ -302,7 +341,7 @@ public class WifiHotspotRepository {
configBuilder.setBand(BAND_2GHZ_5GHZ_6GHZ);
if (config.getSecurityType() != SECURITY_TYPE_WPA3_SAE) {
log("setSpeedType(), setPassphrase(SECURITY_TYPE_WPA3_SAE)");
configBuilder.setPassphrase(generatePassword(), SECURITY_TYPE_WPA3_SAE);
configBuilder.setPassphrase(generatePassword(config), SECURITY_TYPE_WPA3_SAE);
}
} else if (speedType == SPEED_5GHZ) {
log("setSpeedType(), setBand(BAND_2GHZ_5GHZ)");
@@ -543,6 +582,84 @@ public class WifiHotspotRepository {
}
}
/**
* Gets Restarting LiveData
*/
public LiveData<Boolean> getRestarting() {
if (mRestarting == null) {
mRestarting = new MutableLiveData<>();
mRestarting.setValue(mIsRestarting);
}
return mRestarting;
}
private void setRestarting(boolean isRestarting) {
log("setRestarting(), isRestarting:" + isRestarting);
mIsRestarting = isRestarting;
if (mRestarting != null) {
mRestarting.setValue(mIsRestarting);
}
}
@VisibleForTesting
void restartTetheringIfNeeded() {
if (mWifiApState != WIFI_AP_STATE_ENABLED) {
return;
}
log("restartTetheringIfNeeded()");
mAppContext.getMainThreadHandler().postDelayed(() -> {
setRestarting(true);
stopTethering();
}, RESTART_INTERVAL_MS);
}
private void startTethering() {
if (mStartTetheringCallback == null) {
mStartTetheringCallback = new StartTetheringCallback();
}
log("startTethering()");
mTetheringManager.startTethering(TETHERING_WIFI, mAppContext.getMainExecutor(),
mStartTetheringCallback);
}
private void stopTethering() {
log("startTethering()");
mTetheringManager.stopTethering(TETHERING_WIFI);
}
@VisibleForTesting
class SoftApCallback implements WifiManager.SoftApCallback {
@Override
public void onStateChanged(int state, int failureReason) {
log("onStateChanged(), state:" + state + ", failureReason:" + failureReason);
mWifiApState = state;
if (!mIsRestarting) {
return;
}
if (state == WIFI_AP_STATE_DISABLED) {
mAppContext.getMainThreadHandler().postDelayed(() -> startTethering(),
RESTART_INTERVAL_MS);
return;
}
if (state == WIFI_AP_STATE_ENABLED) {
refresh();
setRestarting(false);
}
}
}
private class StartTetheringCallback implements TetheringManager.StartTetheringCallback {
@Override
public void onTetheringStarted() {
log("onTetheringStarted()");
}
@Override
public void onTetheringFailed(int error) {
log("onTetheringFailed(), error:" + error);
}
}
private void log(String msg) {
FeatureFactory.getFactory(mAppContext).getWifiFeatureProvider().verboseLog(TAG, msg);
}

8
src/com/android/settings/wifi/tether/WifiHotspotSecuritySettings.java
View File

@@ -19,6 +19,7 @@ package com.android.settings.wifi.tether;
import android.app.settings.SettingsEnums;
import android.os.Bundle;
import androidx.annotation.VisibleForTesting;
import androidx.lifecycle.LiveData;
import com.android.settings.R;
@@ -72,6 +73,7 @@ public class WifiHotspotSecuritySettings extends DashboardFragment implements
SelectorWithWidgetPreference preference = findPreference(viewItem.mKey);
preference.setOnClickListener(this);
}
mWifiHotspotSecurityViewModel.getRestarting().observe(this, this::onRestartingChanged);
}
protected void onViewItemListDataChanged(
@@ -96,6 +98,12 @@ public class WifiHotspotSecuritySettings extends DashboardFragment implements
}
}
@VisibleForTesting
void onRestartingChanged(Boolean restarting) {
log("onRestartingChanged(), restarting:" + restarting);
setLoading(restarting, false);
}
@Override
public void onRadioButtonClicked(SelectorWithWidgetPreference emiter) {
String key = emiter.getKey();

7
src/com/android/settings/wifi/tether/WifiHotspotSecurityViewModel.java
View File

@@ -129,6 +129,13 @@ public class WifiHotspotSecurityViewModel extends AndroidViewModel {
mViewInfoListData.setValue(mViewItemMap.values().stream().toList());
}
/**
* Gets Restarting LiveData
*/
public LiveData<Boolean> getRestarting() {
return mWifiHotspotRepository.getRestarting();
}
/**
* Wi-Fi Hotspot View Item
*/

9
src/com/android/settings/wifi/tether/WifiHotspotSpeedSettings.java
View File

@@ -24,6 +24,8 @@ import static com.android.settings.wifi.repository.WifiHotspotRepository.SPEED_6
import android.app.settings.SettingsEnums;
import android.os.Bundle;
import androidx.annotation.VisibleForTesting;
import com.android.settings.R;
import com.android.settings.dashboard.DashboardFragment;
import com.android.settings.overlay.FeatureFactory;
@@ -80,6 +82,7 @@ public class WifiHotspotSpeedSettings extends DashboardFragment implements
onSpeedInfoMapDataChanged(mWifiHotspotSpeedViewModel.getSpeedInfoMapData().getValue());
mWifiHotspotSpeedViewModel.getSpeedInfoMapData()
.observe(this, this::onSpeedInfoMapDataChanged);
mWifiHotspotSpeedViewModel.getRestarting().observe(this, this::onRestartingChanged);
}
protected void loadPreferences() {
@@ -117,6 +120,12 @@ public class WifiHotspotSpeedSettings extends DashboardFragment implements
}
}
@VisibleForTesting
void onRestartingChanged(Boolean restarting) {
log("onRestartingChanged(), restarting:" + restarting);
setLoading(restarting, false);
}
@Override
public void onRadioButtonClicked(SelectorWithWidgetPreference emiter) {
String key = emiter.getKey();

7
src/com/android/settings/wifi/tether/WifiHotspotSpeedViewModel.java
View File

@@ -130,6 +130,13 @@ public class WifiHotspotSpeedViewModel extends AndroidViewModel {
}
}
/**
* Gets Restarting LiveData
*/
public LiveData<Boolean> getRestarting() {
return mWifiHotspotRepository.getRestarting();
}
/**
* Wi-Fi Hotspot Speed Information
*/

54
src/com/android/settings/wifi/tether/WifiTetherSettings.java
View File

@@ -17,6 +17,8 @@
package com.android.settings.wifi.tether;
import static android.net.wifi.WifiManager.WIFI_AP_STATE_CHANGED_ACTION;
import static android.view.View.INVISIBLE;
import static android.view.View.VISIBLE;
import static com.android.settings.wifi.WifiUtils.canShowWifiHotspot;
@@ -26,7 +28,6 @@ import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.wifi.SoftApConfiguration;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.os.UserManager;
import android.util.FeatureFlagUtils;
@@ -76,6 +77,8 @@ public class WifiTetherSettings extends RestrictedDashboardFragment
@VisibleForTesting
static final String KEY_WIFI_HOTSPOT_SPEED = "wifi_hotspot_speed";
@VisibleForTesting
SettingsMainSwitchBar mMainSwitchBar;
private WifiTetherSwitchBarController mSwitchBarController;
private WifiTetherSSIDPreferenceController mSSIDPreferenceController;
private WifiTetherPasswordPreferenceController mPasswordPreferenceController;
@@ -83,8 +86,6 @@ public class WifiTetherSettings extends RestrictedDashboardFragment
private WifiTetherMaximizeCompatibilityPreferenceController mMaxCompatibilityPrefController;
private WifiTetherAutoOffPreferenceController mWifiTetherAutoOffPreferenceController;
private WifiManager mWifiManager;
private boolean mRestartWifiApAfterConfigChange;
private boolean mUnavailable;
private WifiRestriction mWifiRestriction;
@VisibleForTesting
@@ -138,6 +139,7 @@ public class WifiTetherSettings extends RestrictedDashboardFragment
.getWifiTetherViewModel(this);
if (mWifiTetherViewModel != null) {
setupSpeedFeature(mWifiTetherViewModel.isSpeedFeatureAvailable());
mWifiTetherViewModel.getRestarting().observe(this, this::onRestartingChanged);
}
}
@@ -159,7 +161,6 @@ public class WifiTetherSettings extends RestrictedDashboardFragment
@Override
public void onAttach(Context context) {
super.onAttach(context);
mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
mTetherChangeReceiver = new TetherChangeReceiver();
mSSIDPreferenceController = use(WifiTetherSSIDPreferenceController.class);
@@ -179,11 +180,11 @@ public class WifiTetherSettings extends RestrictedDashboardFragment
// Assume we are in a SettingsActivity. This is only safe because we currently use
// SettingsActivity as base for all preference fragments.
final SettingsActivity activity = (SettingsActivity) getActivity();
final SettingsMainSwitchBar switchBar = activity.getSwitchBar();
switchBar.setTitle(getContext().getString(R.string.use_wifi_hotsopt_main_switch_title));
mSwitchBarController = new WifiTetherSwitchBarController(activity, switchBar);
mMainSwitchBar = activity.getSwitchBar();
mMainSwitchBar.setTitle(getString(R.string.use_wifi_hotsopt_main_switch_title));
mSwitchBarController = new WifiTetherSwitchBarController(activity, mMainSwitchBar);
getSettingsLifecycle().addObserver(mSwitchBarController);
switchBar.show();
mMainSwitchBar.show();
}
@Override
@@ -259,40 +260,34 @@ public class WifiTetherSettings extends RestrictedDashboardFragment
final SoftApConfiguration config = buildNewConfig();
mPasswordPreferenceController.setSecurityType(config.getSecurityType());
/**
* if soft AP is stopped, bring up
* else restart with new config
* TODO: update config on a running access point when framework support is added
*/
if (mWifiManager.getWifiApState() == WifiManager.WIFI_AP_STATE_ENABLED) {
Log.d("TetheringSettings",
"Wifi AP config changed while enabled, stop and restart");
mRestartWifiApAfterConfigChange = true;
mSwitchBarController.stopTether();
}
mWifiTetherViewModel.setSoftApConfiguration(config);
}
@VisibleForTesting
void onRestartingChanged(Boolean restarting) {
mMainSwitchBar.setVisibility((restarting) ? INVISIBLE : VISIBLE);
setLoading(restarting, false);
}
private SoftApConfiguration buildNewConfig() {
final SoftApConfiguration.Builder configBuilder = new SoftApConfiguration.Builder();
final int securityType = mSecurityPreferenceController.getSecurityType();
SoftApConfiguration.Builder configBuilder = new SoftApConfiguration.Builder();
int securityType = (mWifiTetherViewModel.isSpeedFeatureAvailable())
? mWifiTetherViewModel.getSoftApConfiguration().getSecurityType()
: mSecurityPreferenceController.getSecurityType();
configBuilder.setSsid(mSSIDPreferenceController.getSSID());
if (securityType != SoftApConfiguration.SECURITY_TYPE_OPEN) {
configBuilder.setPassphrase(
mPasswordPreferenceController.getPasswordValidated(securityType),
securityType);
}
if (!mWifiTetherViewModel.isSpeedFeatureAvailable()) {
mMaxCompatibilityPrefController.setupMaximizeCompatibility(configBuilder);
}
configBuilder.setAutoShutdownEnabled(
mWifiTetherAutoOffPreferenceController.isEnabled());
return configBuilder.build();
}
private void startTether() {
mRestartWifiApAfterConfigChange = false;
mSwitchBarController.startTether();
}
private void updateDisplayWithNewConfig() {
use(WifiTetherSSIDPreferenceController.class).updateDisplay();
use(WifiTetherSecurityPreferenceController.class).updateDisplay();
@@ -369,13 +364,6 @@ public class WifiTetherSettings extends RestrictedDashboardFragment
String action = intent.getAction();
Log.d(TAG, "updating display config due to receiving broadcast action " + action);
updateDisplayWithNewConfig();
if (action.equals(WIFI_AP_STATE_CHANGED_ACTION)) {
int state = intent.getIntExtra(WifiManager.EXTRA_WIFI_AP_STATE, 0);
if (state == WifiManager.WIFI_AP_STATE_DISABLED
&& mRestartWifiApAfterConfigChange) {
startTether();
}
}
}
}
}

16
src/com/android/settings/wifi/tether/WifiTetherViewModel.java
View File

@@ -100,6 +100,15 @@ public class WifiTetherViewModel extends AndroidViewModel {
return mWifiHotspotRepository.isSpeedFeatureAvailable();
}
/**
* Gets the Wi-Fi tethered AP Configuration.
*
* @return AP details in {@link SoftApConfiguration}
*/
public SoftApConfiguration getSoftApConfiguration() {
return mWifiHotspotRepository.getSoftApConfiguration();
}
/**
* Sets the tethered Wi-Fi AP Configuration.
*
@@ -153,4 +162,11 @@ public class WifiTetherViewModel extends AndroidViewModel {
}
mSpeedSummary.setValue(resId);
}
/**
* Gets Restarting LiveData
*/
public LiveData<Boolean> getRestarting() {
return mWifiHotspotRepository.getRestarting();
}
}

23
tests/robotests/src/com/android/settings/wifi/tether/WifiHotspotSpeedSettingsTest.java
View File

@@ -25,6 +25,9 @@ import static com.android.settings.wifi.tether.WifiHotspotSpeedSettings.KEY_SPEE
import static com.android.settings.wifi.tether.WifiHotspotSpeedSettings.KEY_SPEED_5GHZ;
import static com.android.settings.wifi.tether.WifiHotspotSpeedSettings.KEY_SPEED_6GHZ;
import static org.mockito.Mockito.anyBoolean;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -80,7 +83,7 @@ public class WifiHotspotSpeedSettingsTest {
WifiFeatureProvider provider = FakeFeatureFactory.setupForTest().getWifiFeatureProvider();
when(provider.getWifiHotspotSpeedViewModel(mViewModelStoreOwner)).thenReturn(mViewModel);
mSettings = new WifiHotspotSpeedSettings();
mSettings = spy(new WifiHotspotSpeedSettings());
mSettings.mWifiHotspotSpeedViewModel = mViewModel;
}
@@ -180,6 +183,24 @@ public class WifiHotspotSpeedSettingsTest {
verifyRadioButton(true, false, true);
}
@Test
public void onRestartingChanged_restartingTrue_setLoadingTrue() {
doNothing().when(mSettings).setLoading(anyBoolean(), anyBoolean());
mSettings.onRestartingChanged(true);
verify(mSettings).setLoading(true, false);
}
@Test
public void onRestartingChanged_restartingFalse_setLoadingFalse() {
doNothing().when(mSettings).setLoading(anyBoolean(), anyBoolean());
mSettings.onRestartingChanged(false);
verify(mSettings).setLoading(false, false);
}
@Test
public void onRadioButtonClicked_toSpeed2g_setSpeedType2g() {
when(mRadioButton.getKey()).thenReturn(KEY_SPEED_2GHZ);

28
tests/robotests/src/com/android/settings/wifi/tether/WifiTetherSettingsTest.java
View File

@@ -16,6 +16,9 @@
package com.android.settings.wifi.tether;
import static android.view.View.INVISIBLE;
import static android.view.View.VISIBLE;
import static com.android.settings.wifi.WifiUtils.setCanShowWifiHotspotCached;
import static com.android.settings.wifi.tether.WifiTetherSettings.KEY_WIFI_HOTSPOT_SECURITY;
import static com.android.settings.wifi.tether.WifiTetherSettings.KEY_WIFI_HOTSPOT_SPEED;
@@ -25,6 +28,7 @@ import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.anyBoolean;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
@@ -55,6 +59,7 @@ import com.android.settings.core.FeatureFlags;
import com.android.settings.dashboard.RestrictedDashboardFragment;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.shadow.ShadowFragment;
import com.android.settings.widget.SettingsMainSwitchBar;
import com.android.settings.wifi.factory.WifiFeatureProvider;
import com.android.settings.wifi.repository.WifiHotspotRepository;
@@ -110,6 +115,8 @@ public class WifiTetherSettingsTest {
private Preference mWifiHotspotSpeed;
@Mock
private LiveData<Integer> mSpeedSummary;
@Mock
private SettingsMainSwitchBar mMainSwitchBar;
private WifiTetherSettings mSettings;
@@ -135,6 +142,7 @@ public class WifiTetherSettingsTest {
when(mWifiTetherViewModel.getSpeedSummary()).thenReturn(mSpeedSummary);
mSettings = spy(new WifiTetherSettings(mWifiRestriction));
mSettings.mMainSwitchBar = mMainSwitchBar;
mSettings.mWifiTetherViewModel = mWifiTetherViewModel;
when(mSettings.findPreference(KEY_WIFI_HOTSPOT_SECURITY)).thenReturn(mWifiHotspotSecurity);
when(mSettings.findPreference(KEY_WIFI_HOTSPOT_SPEED)).thenReturn(mWifiHotspotSpeed);
@@ -308,6 +316,26 @@ public class WifiTetherSettingsTest {
verify(mSpeedSummary, never()).observe(any(), any());
}
@Test
public void onRestartingChanged_restartingTrue_setLoadingTrue() {
doNothing().when(mSettings).setLoading(anyBoolean(), anyBoolean());
mSettings.onRestartingChanged(true);
verify(mMainSwitchBar).setVisibility(INVISIBLE);
verify(mSettings).setLoading(true, false);
}
@Test
public void onRestartingChanged_restartingFalse_setLoadingFalse() {
doNothing().when(mSettings).setLoading(anyBoolean(), anyBoolean());
mSettings.onRestartingChanged(false);
verify(mMainSwitchBar).setVisibility(VISIBLE);
verify(mSettings).setLoading(false, false);
}
private void spyWifiTetherSettings() {
mSettings = spy(new WifiTetherSettings(mWifiRestriction));
final FragmentActivity activity = mock(FragmentActivity.class);

358
tests/unit/src/com/android/settings/wifi/repository/WifiHotspotRepositoryTest.java
View File

@@ -16,12 +16,15 @@
package com.android.settings.wifi.repository;
import static android.net.TetheringManager.TETHERING_WIFI;
import static android.net.wifi.SoftApConfiguration.BAND_2GHZ;
import static android.net.wifi.SoftApConfiguration.SECURITY_TYPE_OPEN;
import static android.net.wifi.SoftApConfiguration.SECURITY_TYPE_WPA2_PSK;
import static android.net.wifi.SoftApConfiguration.SECURITY_TYPE_WPA3_SAE;
import static android.net.wifi.SoftApConfiguration.SECURITY_TYPE_WPA3_SAE_TRANSITION;
import static android.net.wifi.WifiAvailableChannel.OP_MODE_SAP;
import static android.net.wifi.WifiManager.WIFI_AP_STATE_DISABLED;
import static android.net.wifi.WifiManager.WIFI_AP_STATE_ENABLED;
import static com.android.settings.wifi.repository.WifiHotspotRepository.BAND_2GHZ_5GHZ;
import static com.android.settings.wifi.repository.WifiHotspotRepository.BAND_2GHZ_5GHZ_6GHZ;
@@ -42,12 +45,17 @@ import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.net.TetheringManager;
import android.net.wifi.SoftApConfiguration;
import android.net.wifi.WifiAvailableChannel;
import android.net.wifi.WifiManager;
import android.net.wifi.WifiScanner;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.SparseIntArray;
import androidx.annotation.NonNull;
import androidx.lifecycle.MutableLiveData;
import androidx.test.annotation.UiThreadTest;
import androidx.test.core.app.ApplicationProvider;
@@ -81,30 +89,33 @@ public class WifiHotspotRepositoryTest {
@Rule
public final MockitoRule mMockitoRule = MockitoJUnit.rule();
@Spy
Context mContext = ApplicationProvider.getApplicationContext();
private Context mContext = ApplicationProvider.getApplicationContext();
@Mock
WifiManager mWifiManager;
private WifiManager mWifiManager;
@Mock
MutableLiveData<Integer> mSecurityType;
private TetheringManager mTetheringManager;
@Mock
MutableLiveData<Integer> mSpeedType;
private MutableLiveData<Integer> mSecurityType;
@Mock
private MutableLiveData<Integer> mSpeedType;
WifiHotspotRepository mWifiHotspotRepository;
SoftApConfiguration mSoftApConfiguration;
ArgumentCaptor<SoftApConfiguration> mSoftApConfigCaptor =
private WifiHotspotRepository mRepository;
private SoftApConfiguration mSoftApConfiguration = new SoftApConfiguration.Builder().build();
private ArgumentCaptor<SoftApConfiguration> mSoftApConfigCaptor =
ArgumentCaptor.forClass(SoftApConfiguration.class);
@Before
public void setUp() {
doReturn(new TestHandler()).when(mContext).getMainThreadHandler();
doReturn(SPEED_6GHZ).when(mSpeedType).getValue();
mWifiHotspotRepository = new WifiHotspotRepository(mContext, mWifiManager);
mWifiHotspotRepository.mSecurityType = mSecurityType;
mWifiHotspotRepository.mSpeedType = mSpeedType;
mWifiHotspotRepository.mCurrentCountryCode = WIFI_CURRENT_COUNTRY_CODE;
mWifiHotspotRepository.mIsDualBand = true;
mWifiHotspotRepository.mIs5gAvailable = true;
mWifiHotspotRepository.mIs6gAvailable = true;
mRepository = new WifiHotspotRepository(mContext, mWifiManager, mTetheringManager);
mRepository.mSecurityType = mSecurityType;
mRepository.mSpeedType = mSpeedType;
mRepository.mCurrentCountryCode = WIFI_CURRENT_COUNTRY_CODE;
mRepository.mIsDualBand = true;
mRepository.mIs5gAvailable = true;
mRepository.mIs6gAvailable = true;
}
@Test
@@ -115,7 +126,7 @@ public class WifiHotspotRepositoryTest {
.build();
when(mWifiManager.getSoftApConfiguration()).thenReturn(mSoftApConfiguration);
mWifiHotspotRepository.queryLastPasswordIfNeeded();
mRepository.queryLastPasswordIfNeeded();
verify(mWifiManager).queryLastConfiguredTetheredApPassphraseSinceBoot(any(), any());
}
@@ -128,7 +139,7 @@ public class WifiHotspotRepositoryTest {
.build();
when(mWifiManager.getSoftApConfiguration()).thenReturn(mSoftApConfiguration);
mWifiHotspotRepository.queryLastPasswordIfNeeded();
mRepository.queryLastPasswordIfNeeded();
verify(mWifiManager, never())
.queryLastConfiguredTetheredApPassphraseSinceBoot(any(), any());
@@ -136,46 +147,74 @@ public class WifiHotspotRepositoryTest {
@Test
public void generatePassword_haveLastPassword_returnLastPassword() {
mWifiHotspotRepository.mLastPassword = WIFI_PASSWORD;
mRepository.mLastPassword = WIFI_PASSWORD;
assertThat(mWifiHotspotRepository.generatePassword()).isEqualTo(WIFI_PASSWORD);
assertThat(mRepository.generatePassword()).isEqualTo(WIFI_PASSWORD);
}
@Test
public void generatePassword_noLastPassword_returnRandomPassword() {
mWifiHotspotRepository.mLastPassword = "";
mRepository.mLastPassword = "";
String password = mWifiHotspotRepository.generatePassword();
assertThat(password).isNotEqualTo(WIFI_PASSWORD);
assertThat(password.length()).isNotEqualTo(0);
assertThat(mRepository.generatePassword().length()).isNotEqualTo(0);
}
@Test
public void setSoftApConfiguration_setConfigByWifiManager() {
SoftApConfiguration config = new SoftApConfiguration.Builder().build();
public void generatePassword_configPasswordIsNotEmpty_returnConfigPassword() {
mSoftApConfiguration = new SoftApConfiguration.Builder()
.setPassphrase(WIFI_PASSWORD, SECURITY_TYPE_WPA2_PSK)
.build();
mWifiHotspotRepository.setSoftApConfiguration(config);
assertThat(mRepository.generatePassword(mSoftApConfiguration)).isEqualTo(WIFI_PASSWORD);
}
verify(mWifiManager).setSoftApConfiguration(config);
@Test
public void generatePassword_configPasswordIsEmpty_returnConfigPassword() {
mSoftApConfiguration = new SoftApConfiguration.Builder().build();
mRepository.mLastPassword = WIFI_PASSWORD;
assertThat(mRepository.generatePassword(mSoftApConfiguration)).isEqualTo(WIFI_PASSWORD);
}
@Test
public void getSoftApConfiguration_getConfigFromWifiManager() {
mRepository.getSoftApConfiguration();
verify(mWifiManager).getSoftApConfiguration();
}
@Test
public void setSoftApConfiguration_setConfigToWifiManager() {
mRepository.setSoftApConfiguration(mSoftApConfiguration);
verify(mWifiManager).setSoftApConfiguration(mSoftApConfiguration);
}
@Test
public void setSoftApConfiguration_isRestarting_doNotSetConfig() {
mRepository.mIsRestarting = true;
mRepository.setSoftApConfiguration(mSoftApConfiguration);
verify(mWifiManager, never()).setSoftApConfiguration(mSoftApConfiguration);
}
@Test
public void refresh_liveDataNotUsed_doNothing() {
// If LiveData is not used then it's null.
mWifiHotspotRepository.mSecurityType = null;
mWifiHotspotRepository.mSpeedType = null;
mRepository.mSecurityType = null;
mRepository.mSpeedType = null;
mWifiHotspotRepository.refresh();
mRepository.refresh();
verify(mWifiManager, never()).getSoftApConfiguration();
}
@Test
public void refresh_liveDataIsUsed_getConfigAndUpdateLiveData() {
mWifiHotspotRepository.getSpeedType();
mRepository.getSpeedType();
mWifiHotspotRepository.refresh();
mRepository.refresh();
verify(mWifiManager, atLeast(1)).getSoftApConfiguration();
verify(mSpeedType).setValue(anyInt());
@@ -183,18 +222,18 @@ public class WifiHotspotRepositoryTest {
@Test
public void setAutoRefresh_setEnabled_registerCallback() {
mWifiHotspotRepository.mActiveCountryCodeChangedCallback = null;
mRepository.mActiveCountryCodeChangedCallback = null;
mWifiHotspotRepository.setAutoRefresh(true);
mRepository.setAutoRefresh(true);
verify(mWifiManager).registerActiveCountryCodeChangedCallback(any(), any());
}
@Test
public void setAutoRefresh_setDisabled_registerCallback() {
mWifiHotspotRepository.setAutoRefresh(true);
mRepository.setAutoRefresh(true);
mWifiHotspotRepository.setAutoRefresh(false);
mRepository.setAutoRefresh(false);
verify(mWifiManager).unregisterActiveCountryCodeChangedCallback(any());
}
@@ -203,17 +242,17 @@ public class WifiHotspotRepositoryTest {
@UiThreadTest
public void getSecurityType_shouldNotReturnNull() {
// If LiveData is not used then it's null.
mWifiHotspotRepository.mSecurityType = null;
mRepository.mSecurityType = null;
mockConfigSecurityType(SECURITY_TYPE_OPEN);
assertThat(mWifiHotspotRepository.getSecurityType()).isNotNull();
assertThat(mRepository.getSecurityType()).isNotNull();
}
@Test
public void updateSecurityType_securityTypeOpen_setValueCorrectly() {
mockConfigSecurityType(SECURITY_TYPE_OPEN);
mWifiHotspotRepository.updateSecurityType();
mRepository.updateSecurityType();
verify(mSecurityType).setValue(SECURITY_TYPE_OPEN);
}
@@ -222,7 +261,7 @@ public class WifiHotspotRepositoryTest {
public void updateSecurityType_securityTypeWpa2_setValueCorrectly() {
mockConfigSecurityType(SECURITY_TYPE_WPA2_PSK);
mWifiHotspotRepository.updateSecurityType();
mRepository.updateSecurityType();
verify(mSecurityType).setValue(SECURITY_TYPE_WPA2_PSK);
}
@@ -231,7 +270,7 @@ public class WifiHotspotRepositoryTest {
public void updateSecurityType_securityTypeWpa2Wpa3_setValueCorrectly() {
mockConfigSecurityType(SECURITY_TYPE_WPA3_SAE_TRANSITION);
mWifiHotspotRepository.updateSecurityType();
mRepository.updateSecurityType();
verify(mSecurityType).setValue(SECURITY_TYPE_WPA3_SAE_TRANSITION);
}
@@ -240,7 +279,7 @@ public class WifiHotspotRepositoryTest {
public void updateSecurityType_securityTypeWpa3_setValueCorrectly() {
mockConfigSecurityType(SECURITY_TYPE_WPA3_SAE);
mWifiHotspotRepository.updateSecurityType();
mRepository.updateSecurityType();
verify(mSecurityType).setValue(SECURITY_TYPE_WPA3_SAE);
}
@@ -249,7 +288,7 @@ public class WifiHotspotRepositoryTest {
public void setSecurityType_sameValue_doNotSetConfig() {
mockConfigSecurityType(SECURITY_TYPE_WPA3_SAE);
mWifiHotspotRepository.setSecurityType(SECURITY_TYPE_WPA3_SAE);
mRepository.setSecurityType(SECURITY_TYPE_WPA3_SAE);
verify(mWifiManager, never()).setSoftApConfiguration(any());
}
@@ -258,7 +297,7 @@ public class WifiHotspotRepositoryTest {
public void setSecurityType_wpa3ToWpa2Wpa3_setConfigCorrectly() {
mockConfigSecurityType(SECURITY_TYPE_WPA3_SAE);
mWifiHotspotRepository.setSecurityType(SECURITY_TYPE_WPA3_SAE_TRANSITION);
mRepository.setSecurityType(SECURITY_TYPE_WPA3_SAE_TRANSITION);
verify(mWifiManager).setSoftApConfiguration(mSoftApConfigCaptor.capture());
assertThat(mSoftApConfigCaptor.getValue().getSecurityType())
@@ -269,7 +308,7 @@ public class WifiHotspotRepositoryTest {
public void setSecurityType_Wpa2Wpa3ToWpa2_setConfigCorrectly() {
mockConfigSecurityType(SECURITY_TYPE_WPA3_SAE_TRANSITION);
mWifiHotspotRepository.setSecurityType(SECURITY_TYPE_WPA2_PSK);
mRepository.setSecurityType(SECURITY_TYPE_WPA2_PSK);
verify(mWifiManager).setSoftApConfiguration(mSoftApConfigCaptor.capture());
assertThat(mSoftApConfigCaptor.getValue().getSecurityType())
@@ -280,7 +319,7 @@ public class WifiHotspotRepositoryTest {
public void setSecurityType_Wpa2ToOpen_setConfigCorrectly() {
mockConfigSecurityType(SECURITY_TYPE_WPA2_PSK);
mWifiHotspotRepository.setSecurityType(SECURITY_TYPE_OPEN);
mRepository.setSecurityType(SECURITY_TYPE_OPEN);
verify(mWifiManager).setSoftApConfiguration(mSoftApConfigCaptor.capture());
assertThat(mSoftApConfigCaptor.getValue().getSecurityType())
@@ -291,7 +330,7 @@ public class WifiHotspotRepositoryTest {
public void setSecurityType_OpenToWpa3_setConfigCorrectly() {
mockConfigSecurityType(SECURITY_TYPE_OPEN);
mWifiHotspotRepository.setSecurityType(SECURITY_TYPE_WPA3_SAE);
mRepository.setSecurityType(SECURITY_TYPE_WPA3_SAE);
verify(mWifiManager).setSoftApConfiguration(mSoftApConfigCaptor.capture());
assertThat(mSoftApConfigCaptor.getValue().getSecurityType())
@@ -302,109 +341,109 @@ public class WifiHotspotRepositoryTest {
@UiThreadTest
public void getSpeedType_shouldNotReturnNull() {
// If LiveData is not used then it's null.
mWifiHotspotRepository.mSpeedType = null;
mRepository.mSpeedType = null;
SoftApConfiguration config = new SoftApConfiguration.Builder().setBand(BAND_2GHZ).build();
when(mWifiManager.getSoftApConfiguration()).thenReturn(config);
assertThat(mWifiHotspotRepository.getSpeedType()).isNotNull();
assertThat(mRepository.getSpeedType()).isNotNull();
}
@Test
public void updateSpeedType_singleBand2g_get2gSpeedType() {
mWifiHotspotRepository.mIsDualBand = false;
mRepository.mIsDualBand = false;
SoftApConfiguration config = new SoftApConfiguration.Builder().setBand(BAND_2GHZ).build();
when(mWifiManager.getSoftApConfiguration()).thenReturn(config);
mWifiHotspotRepository.updateSpeedType();
mRepository.updateSpeedType();
verify(mSpeedType).setValue(SPEED_2GHZ);
}
@Test
public void updateSpeedType_singleBand5gPreferred_get5gSpeedType() {
mWifiHotspotRepository.mIsDualBand = false;
mRepository.mIsDualBand = false;
SoftApConfiguration config = new SoftApConfiguration.Builder()
.setBand(WIFI_5GHZ_BAND_PREFERRED).build();
when(mWifiManager.getSoftApConfiguration()).thenReturn(config);
mWifiHotspotRepository.updateSpeedType();
mRepository.updateSpeedType();
verify(mSpeedType).setValue(SPEED_5GHZ);
}
@Test
public void updateSpeedType_singleBand5gPreferredBut5gUnavailable_get2gSpeedType() {
mWifiHotspotRepository.mIsDualBand = false;
mWifiHotspotRepository.mIs5gAvailable = false;
mRepository.mIsDualBand = false;
mRepository.mIs5gAvailable = false;
SoftApConfiguration config = new SoftApConfiguration.Builder()
.setBand(WIFI_5GHZ_BAND_PREFERRED).build();
when(mWifiManager.getSoftApConfiguration()).thenReturn(config);
mWifiHotspotRepository.updateSpeedType();
mRepository.updateSpeedType();
verify(mSpeedType).setValue(SPEED_2GHZ);
}
@Test
public void updateSpeedType_singleBand6gPreferred_get6gSpeedType() {
mWifiHotspotRepository.mIsDualBand = false;
mRepository.mIsDualBand = false;
SoftApConfiguration config = new SoftApConfiguration.Builder()
.setBand(WIFI_6GHZ_BAND_PREFERRED).build();
when(mWifiManager.getSoftApConfiguration()).thenReturn(config);
mWifiHotspotRepository.updateSpeedType();
mRepository.updateSpeedType();
verify(mSpeedType).setValue(SPEED_6GHZ);
}
@Test
public void updateSpeedType_singleBand6gPreferredBut6gUnavailable_get5gSpeedType() {
mWifiHotspotRepository.mIsDualBand = false;
mWifiHotspotRepository.mIs6gAvailable = false;
mRepository.mIsDualBand = false;
mRepository.mIs6gAvailable = false;
SoftApConfiguration config = new SoftApConfiguration.Builder()
.setBand(WIFI_6GHZ_BAND_PREFERRED).build();
when(mWifiManager.getSoftApConfiguration()).thenReturn(config);
mWifiHotspotRepository.updateSpeedType();
mRepository.updateSpeedType();
verify(mSpeedType).setValue(SPEED_5GHZ);
}
@Test
public void updateSpeedType_singleBand6gPreferredBut5gAnd6gUnavailable_get2gSpeedType() {
mWifiHotspotRepository.mIsDualBand = false;
mWifiHotspotRepository.mIs5gAvailable = false;
mWifiHotspotRepository.mIs6gAvailable = false;
mRepository.mIsDualBand = false;
mRepository.mIs5gAvailable = false;
mRepository.mIs6gAvailable = false;
SoftApConfiguration config = new SoftApConfiguration.Builder()
.setBand(WIFI_6GHZ_BAND_PREFERRED).build();
when(mWifiManager.getSoftApConfiguration()).thenReturn(config);
mWifiHotspotRepository.updateSpeedType();
mRepository.updateSpeedType();
verify(mSpeedType).setValue(SPEED_2GHZ);
}
@Test
public void updateSpeedType_dualBand2gAnd5g_get2gAnd5gSpeedType() {
mWifiHotspotRepository.mIsDualBand = true;
mRepository.mIsDualBand = true;
SoftApConfiguration config = new SoftApConfiguration.Builder()
.setBand(WIFI_5GHZ_BAND_PREFERRED).build();
when(mWifiManager.getSoftApConfiguration()).thenReturn(config);
mWifiHotspotRepository.updateSpeedType();
mRepository.updateSpeedType();
verify(mSpeedType).setValue(SPEED_2GHZ_5GHZ);
}
@Test
public void updateSpeedType_dualBand2gAnd5gBut5gUnavailable_get2gSpeedType() {
mWifiHotspotRepository.mIsDualBand = true;
mWifiHotspotRepository.mIs5gAvailable = false;
mRepository.mIsDualBand = true;
mRepository.mIs5gAvailable = false;
SoftApConfiguration config = new SoftApConfiguration.Builder()
.setBand(WIFI_5GHZ_BAND_PREFERRED).build();
when(mWifiManager.getSoftApConfiguration()).thenReturn(config);
mWifiHotspotRepository.updateSpeedType();
mRepository.updateSpeedType();
verify(mSpeedType).setValue(SPEED_2GHZ);
}
@@ -413,7 +452,7 @@ public class WifiHotspotRepositoryTest {
public void setSpeedType_sameValue_doNotSetConfig() {
doReturn(SPEED_6GHZ).when(mSpeedType).getValue();
mWifiHotspotRepository.setSpeedType(SPEED_6GHZ);
mRepository.setSpeedType(SPEED_6GHZ);
verify(mWifiManager, never()).setSoftApConfiguration(any());
}
@@ -422,7 +461,7 @@ public class WifiHotspotRepositoryTest {
public void setSpeedType_2g5ghzTo6ghz_setConfigBandTo6ghzPreferred() {
mockConfigSpeedType(SPEED_2GHZ_5GHZ);
mWifiHotspotRepository.setSpeedType(SPEED_6GHZ);
mRepository.setSpeedType(SPEED_6GHZ);
verify(mWifiManager).setSoftApConfiguration(mSoftApConfigCaptor.capture());
assertThat(mSoftApConfigCaptor.getValue().getBand()).isEqualTo(BAND_2GHZ_5GHZ_6GHZ);
@@ -432,7 +471,7 @@ public class WifiHotspotRepositoryTest {
public void setSpeedType_2g5ghzTo6ghz_setConfigSecurityToWpa3() {
mockConfig(SPEED_2GHZ_5GHZ, SECURITY_TYPE_WPA3_SAE_TRANSITION);
mWifiHotspotRepository.setSpeedType(SPEED_6GHZ);
mRepository.setSpeedType(SPEED_6GHZ);
verify(mWifiManager).setSoftApConfiguration(mSoftApConfigCaptor.capture());
assertThat(mSoftApConfigCaptor.getValue().getSecurityType())
@@ -442,9 +481,9 @@ public class WifiHotspotRepositoryTest {
@Test
public void setSpeedType_6ghzTo2g5ghz_setConfigBandsTo2g5ghz() {
mockConfigSpeedType(SPEED_6GHZ);
mWifiHotspotRepository.mIsDualBand = true;
mRepository.mIsDualBand = true;
mWifiHotspotRepository.setSpeedType(SPEED_2GHZ_5GHZ);
mRepository.setSpeedType(SPEED_2GHZ_5GHZ);
verify(mWifiManager).setSoftApConfiguration(mSoftApConfigCaptor.capture());
SparseIntArray channels = mSoftApConfigCaptor.getValue().getChannels();
@@ -456,7 +495,7 @@ public class WifiHotspotRepositoryTest {
public void setSpeedType_2ghzTo5ghz_setConfigBandTo5ghzPreferred() {
mockConfigSpeedType(SPEED_2GHZ);
mWifiHotspotRepository.setSpeedType(SPEED_5GHZ);
mRepository.setSpeedType(SPEED_5GHZ);
verify(mWifiManager).setSoftApConfiguration(mSoftApConfigCaptor.capture());
assertThat(mSoftApConfigCaptor.getValue().getBand()).isEqualTo(WIFI_5GHZ_BAND_PREFERRED);
@@ -466,7 +505,7 @@ public class WifiHotspotRepositoryTest {
public void setSpeedType_5ghzTo6ghz_setConfigBandTo6ghzPreferred() {
mockConfigSpeedType(SPEED_5GHZ);
mWifiHotspotRepository.setSpeedType(SPEED_6GHZ);
mRepository.setSpeedType(SPEED_6GHZ);
verify(mWifiManager).setSoftApConfiguration(mSoftApConfigCaptor.capture());
assertThat(mSoftApConfigCaptor.getValue().getBand()).isEqualTo(WIFI_6GHZ_BAND_PREFERRED);
@@ -476,7 +515,7 @@ public class WifiHotspotRepositoryTest {
public void setSpeedType_6ghzTo2ghz_setConfigBandTo2ghz() {
mockConfigSpeedType(SPEED_6GHZ);
mWifiHotspotRepository.setSpeedType(SPEED_2GHZ);
mRepository.setSpeedType(SPEED_2GHZ);
verify(mWifiManager).setSoftApConfiguration(mSoftApConfigCaptor.capture());
assertThat(mSoftApConfigCaptor.getValue().getBand()).isEqualTo(BAND_2GHZ);
@@ -485,171 +524,227 @@ public class WifiHotspotRepositoryTest {
@Test
public void isDualBand_resultSameAsWifiManager() {
// Reset mIsDualBand to trigger an update
mWifiHotspotRepository.mIsDualBand = null;
mRepository.mIsDualBand = null;
when(mWifiManager.isBridgedApConcurrencySupported()).thenReturn(true);
assertThat(mWifiHotspotRepository.isDualBand()).isTrue();
assertThat(mRepository.isDualBand()).isTrue();
// Reset mIsDualBand to trigger an update
mWifiHotspotRepository.mIsDualBand = null;
mRepository.mIsDualBand = null;
when(mWifiManager.isBridgedApConcurrencySupported()).thenReturn(false);
assertThat(mWifiHotspotRepository.isDualBand()).isFalse();
assertThat(mRepository.isDualBand()).isFalse();
}
@Test
public void is5GHzBandSupported_resultSameAsWifiManager() {
// Reset mIs5gBandSupported to trigger an update
mWifiHotspotRepository.mIs5gBandSupported = null;
mRepository.mIs5gBandSupported = null;
when(mWifiManager.is5GHzBandSupported()).thenReturn(true);
assertThat(mWifiHotspotRepository.is5GHzBandSupported()).isTrue();
assertThat(mRepository.is5GHzBandSupported()).isTrue();
// Reset mIs5gBandSupported to trigger an update
mWifiHotspotRepository.mIs5gBandSupported = null;
mRepository.mIs5gBandSupported = null;
when(mWifiManager.is5GHzBandSupported()).thenReturn(false);
assertThat(mWifiHotspotRepository.is5GHzBandSupported()).isFalse();
assertThat(mRepository.is5GHzBandSupported()).isFalse();
}
@Test
public void is5gAvailable_hasUsableChannels_returnTrue() {
mWifiHotspotRepository.mIs5gBandSupported = true;
mRepository.mIs5gBandSupported = true;
// Reset mIs5gAvailable to trigger an update
mWifiHotspotRepository.mIs5gAvailable = null;
mRepository.mIs5gAvailable = null;
List<WifiAvailableChannel> channels =
Arrays.asList(new WifiAvailableChannel(FREQ_5GHZ, OP_MODE_SAP));
when(mWifiManager.getUsableChannels(WifiScanner.WIFI_BAND_5_GHZ_WITH_DFS, OP_MODE_SAP))
.thenReturn(channels);
assertThat(mWifiHotspotRepository.is5gAvailable()).isTrue();
assertThat(mRepository.is5gAvailable()).isTrue();
}
@Test
public void is5gAvailable_noUsableChannels_returnFalse() {
mWifiHotspotRepository.mIs5gBandSupported = true;
mRepository.mIs5gBandSupported = true;
// Reset mIs5gAvailable to trigger an update
mWifiHotspotRepository.mIs5gAvailable = null;
mRepository.mIs5gAvailable = null;
when(mWifiManager.getUsableChannels(WifiScanner.WIFI_BAND_5_GHZ_WITH_DFS, OP_MODE_SAP))
.thenReturn(null);
assertThat(mWifiHotspotRepository.is5gAvailable()).isFalse();
assertThat(mRepository.is5gAvailable()).isFalse();
}
@Test
@UiThreadTest
public void get5gAvailable_shouldNotReturnNull() {
// Reset m5gAvailable to trigger an update
mWifiHotspotRepository.m5gAvailable = null;
mRepository.m5gAvailable = null;
assertThat(mWifiHotspotRepository.get5gAvailable()).isNotNull();
assertThat(mRepository.get5gAvailable()).isNotNull();
}
@Test
public void is6GHzBandSupported_resultSameAsWifiManager() {
// Reset mIs6gBandSupported to trigger an update
mWifiHotspotRepository.mIs6gBandSupported = null;
mRepository.mIs6gBandSupported = null;
when(mWifiManager.is6GHzBandSupported()).thenReturn(true);
assertThat(mWifiHotspotRepository.is6GHzBandSupported()).isTrue();
assertThat(mRepository.is6GHzBandSupported()).isTrue();
// Reset mIs6gBandSupported to trigger an update
mWifiHotspotRepository.mIs6gBandSupported = null;
mRepository.mIs6gBandSupported = null;
when(mWifiManager.is6GHzBandSupported()).thenReturn(false);
assertThat(mWifiHotspotRepository.is6GHzBandSupported()).isFalse();
assertThat(mRepository.is6GHzBandSupported()).isFalse();
}
@Test
public void is6gAvailable_hasUsableChannels_returnTrue() {
mWifiHotspotRepository.mIs6gBandSupported = true;
mRepository.mIs6gBandSupported = true;
// Reset mIs6gAvailable to trigger an update
mWifiHotspotRepository.mIs6gAvailable = null;
mRepository.mIs6gAvailable = null;
List<WifiAvailableChannel> channels =
Arrays.asList(new WifiAvailableChannel(FREQ_6GHZ, OP_MODE_SAP));
when(mWifiManager.getUsableChannels(WifiScanner.WIFI_BAND_6_GHZ, OP_MODE_SAP))
.thenReturn(channels);
assertThat(mWifiHotspotRepository.is6gAvailable()).isTrue();
assertThat(mRepository.is6gAvailable()).isTrue();
}
@Test
public void is6gAvailable_noUsableChannels_returnFalse() {
mWifiHotspotRepository.mIs6gBandSupported = true;
mRepository.mIs6gBandSupported = true;
// Reset mIs6gAvailable to trigger an update
mWifiHotspotRepository.mIs6gAvailable = null;
mRepository.mIs6gAvailable = null;
when(mWifiManager.getUsableChannels(WifiScanner.WIFI_BAND_6_GHZ, OP_MODE_SAP))
.thenReturn(null);
assertThat(mWifiHotspotRepository.is6gAvailable()).isFalse();
assertThat(mRepository.is6gAvailable()).isFalse();
}
@Test
@UiThreadTest
public void get6gAvailable_shouldNotReturnNull() {
// Reset m6gAvailable to trigger an update
mWifiHotspotRepository.m6gAvailable = null;
mRepository.m6gAvailable = null;
assertThat(mWifiHotspotRepository.get6gAvailable()).isNotNull();
assertThat(mRepository.get6gAvailable()).isNotNull();
}
@Test
public void isSpeedFeatureAvailable_configNotShow_returnFalse() {
mWifiHotspotRepository.mIsConfigShowSpeed = false;
mRepository.mIsConfigShowSpeed = false;
assertThat(mWifiHotspotRepository.isSpeedFeatureAvailable()).isFalse();
assertThat(mRepository.isSpeedFeatureAvailable()).isFalse();
}
@Test
public void isSpeedFeatureAvailable_5gBandNotSupported_returnFalse() {
mWifiHotspotRepository.mIsConfigShowSpeed = true;
mWifiHotspotRepository.mIs5gBandSupported = false;
mRepository.mIsConfigShowSpeed = true;
mRepository.mIs5gBandSupported = false;
assertThat(mWifiHotspotRepository.isSpeedFeatureAvailable()).isFalse();
assertThat(mRepository.isSpeedFeatureAvailable()).isFalse();
}
@Test
public void isSpeedFeatureAvailable_throwExceptionWhenGet5gSapChannel_returnFalse() {
mWifiHotspotRepository.mIsConfigShowSpeed = true;
mWifiHotspotRepository.mIs5gBandSupported = true;
mRepository.mIsConfigShowSpeed = true;
mRepository.mIs5gBandSupported = true;
doThrow(IllegalArgumentException.class).when(mWifiManager)
.getUsableChannels(WifiScanner.WIFI_BAND_5_GHZ_WITH_DFS, OP_MODE_SAP);
assertThat(mWifiHotspotRepository.isSpeedFeatureAvailable()).isFalse();
assertThat(mRepository.isSpeedFeatureAvailable()).isFalse();
doThrow(UnsupportedOperationException.class).when(mWifiManager)
.getUsableChannels(WifiScanner.WIFI_BAND_5_GHZ_WITH_DFS, OP_MODE_SAP);
assertThat(mWifiHotspotRepository.isSpeedFeatureAvailable()).isFalse();
assertThat(mRepository.isSpeedFeatureAvailable()).isFalse();
}
@Test
public void isSpeedFeatureAvailable_throwExceptionWhenGet6gSapChannel_returnFalse() {
mWifiHotspotRepository.mIsConfigShowSpeed = true;
mWifiHotspotRepository.mIs5gBandSupported = true;
mRepository.mIsConfigShowSpeed = true;
mRepository.mIs5gBandSupported = true;
doReturn(Arrays.asList(new WifiAvailableChannel(FREQ_5GHZ, OP_MODE_SAP))).when(mWifiManager)
.getUsableChannels(WifiScanner.WIFI_BAND_5_GHZ_WITH_DFS, OP_MODE_SAP);
doThrow(IllegalArgumentException.class).when(mWifiManager)
.getUsableChannels(WifiScanner.WIFI_BAND_6_GHZ, OP_MODE_SAP);
assertThat(mWifiHotspotRepository.isSpeedFeatureAvailable()).isFalse();
assertThat(mRepository.isSpeedFeatureAvailable()).isFalse();
doThrow(UnsupportedOperationException.class).when(mWifiManager)
.getUsableChannels(WifiScanner.WIFI_BAND_6_GHZ, OP_MODE_SAP);
assertThat(mWifiHotspotRepository.isSpeedFeatureAvailable()).isFalse();
assertThat(mRepository.isSpeedFeatureAvailable()).isFalse();
}
@Test
public void isSpeedFeatureAvailable_conditionsAreReady_returnTrue() {
mWifiHotspotRepository.mIsConfigShowSpeed = true;
mWifiHotspotRepository.mIs5gBandSupported = true;
mRepository.mIsConfigShowSpeed = true;
mRepository.mIs5gBandSupported = true;
doReturn(Arrays.asList(new WifiAvailableChannel(FREQ_5GHZ, OP_MODE_SAP))).when(mWifiManager)
.getUsableChannels(WifiScanner.WIFI_BAND_5_GHZ_WITH_DFS, OP_MODE_SAP);
doReturn(Arrays.asList(new WifiAvailableChannel(FREQ_6GHZ, OP_MODE_SAP))).when(mWifiManager)
.getUsableChannels(WifiScanner.WIFI_BAND_6_GHZ, OP_MODE_SAP);
assertThat(mWifiHotspotRepository.isSpeedFeatureAvailable()).isTrue();
assertThat(mRepository.isSpeedFeatureAvailable()).isTrue();
}
@Test
@UiThreadTest
public void getRestarting_shouldNotReturnNull() {
// Reset mIsRestarting to trigger an update
mRepository.mRestarting = null;
assertThat(mRepository.getRestarting()).isNotNull();
}
@Test
public void restartTetheringIfNeeded_stateDisabled_doNotStopTethering() {
mRepository.mWifiApState = WIFI_AP_STATE_DISABLED;
mRepository.restartTetheringIfNeeded();
verify(mTetheringManager, never()).stopTethering(TETHERING_WIFI);
}
@Test
public void restartTetheringIfNeeded_stateEnabled_stopTethering() {
mRepository.mWifiApState = WIFI_AP_STATE_ENABLED;
mRepository.restartTetheringIfNeeded();
verify(mTetheringManager).stopTethering(TETHERING_WIFI);
}
@Test
public void onStateChanged_stateDisabledAndRestartingFalse_doNotStartTethering() {
mRepository.mIsRestarting = false;
mRepository.mSoftApCallback.onStateChanged(WIFI_AP_STATE_DISABLED, 0);
verify(mTetheringManager, never()).startTethering(TETHERING_WIFI,
mContext.getMainExecutor(), mRepository.mStartTetheringCallback);
}
@Test
public void onStateChanged_stateDisabledAndRestartingTrue_startTethering() {
mRepository.mIsRestarting = true;
mRepository.mSoftApCallback.onStateChanged(WIFI_AP_STATE_DISABLED, 0);
verify(mTetheringManager).startTethering(TETHERING_WIFI, mContext.getMainExecutor(),
mRepository.mStartTetheringCallback);
}
@Test
public void onStateChanged_stateEnabledAndRestartingTrue_setRestartingFalse() {
mRepository.mIsRestarting = true;
mRepository.mSoftApCallback.onStateChanged(WIFI_AP_STATE_ENABLED, 0);
assertThat(mRepository.mIsRestarting).isFalse();
}
private void mockConfigSecurityType(int securityType) {
@@ -669,12 +764,12 @@ public class WifiHotspotRepositoryTest {
// Speed Type
doReturn(speedType).when(mSpeedType).getValue();
mWifiHotspotRepository.mIsDualBand = true;
mRepository.mIsDualBand = true;
if (speedType == SPEED_2GHZ) {
mWifiHotspotRepository.mIsDualBand = false;
mRepository.mIsDualBand = false;
configBuilder.setBand(BAND_2GHZ);
} else if (speedType == SPEED_5GHZ) {
mWifiHotspotRepository.mIsDualBand = false;
mRepository.mIsDualBand = false;
configBuilder.setBand(BAND_2GHZ_5GHZ);
} else if (speedType == SPEED_2GHZ_5GHZ) {
int[] bands = {BAND_2GHZ, BAND_2GHZ_5GHZ};
@@ -684,4 +779,17 @@ public class WifiHotspotRepositoryTest {
}
when(mWifiManager.getSoftApConfiguration()).thenReturn(configBuilder.build());
}
private static class TestHandler extends Handler {
TestHandler() {
super(Looper.getMainLooper());
}
@Override
public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
msg.getCallback().run();
return true;
}
}
}

20
tests/unit/src/com/android/settings/wifi/tether/WifiHotspotSecuritySettingsTest.java
View File

@@ -26,6 +26,8 @@ import static com.android.settings.wifi.tether.WifiHotspotSecurityViewModel.KEY_
import static com.android.settings.wifi.tether.WifiHotspotSecurityViewModel.KEY_SECURITY_WPA2_WPA3;
import static com.android.settings.wifi.tether.WifiHotspotSecurityViewModel.KEY_SECURITY_WPA3;
import static org.mockito.Mockito.anyBoolean;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -143,6 +145,24 @@ public class WifiHotspotSecuritySettingsTest {
verify(mRadioButtonNone).setEnabled(false);
}
@Test
public void onRestartingChanged_restartingTrue_setLoadingTrue() {
doNothing().when(mSettings).setLoading(anyBoolean(), anyBoolean());
mSettings.onRestartingChanged(true);
verify(mSettings).setLoading(true, false);
}
@Test
public void onRestartingChanged_restartingFalse_setLoadingFalse() {
doNothing().when(mSettings).setLoading(anyBoolean(), anyBoolean());
mSettings.onRestartingChanged(false);
verify(mSettings).setLoading(false, false);
}
@Test
public void onRadioButtonClicked_clickedWpa3_setSecurityTypeCorrectly() {
mSettings.onRadioButtonClicked(mRadioButtonWpa3);

8
tests/unit/src/com/android/settings/wifi/tether/WifiHotspotSecurityViewModelTest.java
View File

@@ -65,6 +65,8 @@ public class WifiHotspotSecurityViewModelTest {
MutableLiveData<Integer> mSecurityType;
@Mock
MutableLiveData<Integer> mSpeedType;
@Mock
private MutableLiveData<Boolean> mRestarting;
WifiHotspotSecurityViewModel mViewModel;
@@ -75,6 +77,7 @@ public class WifiHotspotSecurityViewModelTest {
.thenReturn(mWifiHotspotRepository);
when(mWifiHotspotRepository.getSecurityType()).thenReturn(mSecurityType);
when(mWifiHotspotRepository.getSpeedType()).thenReturn(mSpeedType);
when(mWifiHotspotRepository.getRestarting()).thenReturn(mRestarting);
mViewModel = new WifiHotspotSecurityViewModel((Application) mContext);
}
@@ -185,6 +188,11 @@ public class WifiHotspotSecurityViewModelTest {
assertThat(mViewModel.getViewItemListData()).isNotNull();
}
@Test
public void getRestarting_shouldNotReturnNull() {
assertThat(mViewModel.getRestarting()).isNotNull();
}
private void assertItemChecked(boolean checkedWpa3, boolean checkedWpa2Wpa3,
boolean checkedWpa2, boolean checkedNone) {
assertThat(mViewModel.mViewItemMap.get(SECURITY_TYPE_WPA3_SAE).mIsChecked)

8
tests/unit/src/com/android/settings/wifi/tether/WifiHotspotSpeedViewModelTest.java
View File

@@ -64,6 +64,8 @@ public class WifiHotspotSpeedViewModelTest {
MutableLiveData<Boolean> m6gAvailable;
@Mock
MutableLiveData<Map<Integer, WifiHotspotSpeedViewModel.SpeedInfo>> mSpeedInfoMapData;
@Mock
private MutableLiveData<Boolean> mRestarting;
WifiHotspotSpeedViewModel mViewModel;
@@ -77,6 +79,7 @@ public class WifiHotspotSpeedViewModelTest {
when(mWifiHotspotRepository.get5gAvailable()).thenReturn(m5gAvailable);
when(mWifiHotspotRepository.is6GHzBandSupported()).thenReturn(true);
when(mWifiHotspotRepository.get6gAvailable()).thenReturn(m6gAvailable);
when(mWifiHotspotRepository.getRestarting()).thenReturn(mRestarting);
mViewModel = new WifiHotspotSpeedViewModel((Application) mContext);
mViewModel.mSpeedInfoMapData = mSpeedInfoMapData;
@@ -284,4 +287,9 @@ public class WifiHotspotSpeedViewModelTest {
assertThat(mViewModel.getSpeedInfoMapData()).isNotNull();
}
@Test
public void getRestarting_shouldNotReturnNull() {
assertThat(mViewModel.getRestarting()).isNotNull();
}
}

15
tests/unit/src/com/android/settings/wifi/tether/WifiTetherViewModelTest.java
View File

@@ -55,6 +55,8 @@ public class WifiTetherViewModelTest {
MutableLiveData<Integer> mSecurityType;
@Mock
MutableLiveData<Integer> mSpeedType;
@Mock
private MutableLiveData<Boolean> mRestarting;
WifiTetherViewModel mViewModel;
@@ -67,6 +69,7 @@ public class WifiTetherViewModelTest {
.thenReturn(mWifiHotspotRepository);
when(mWifiHotspotRepository.getSecurityType()).thenReturn(mSecurityType);
when(mWifiHotspotRepository.getSpeedType()).thenReturn(mSpeedType);
when(mWifiHotspotRepository.getRestarting()).thenReturn(mRestarting);
mViewModel = new WifiTetherViewModel(mApplication);
}
@@ -82,6 +85,13 @@ public class WifiTetherViewModelTest {
verify(mSpeedType).removeObserver(mViewModel.mSpeedTypeObserver);
}
@Test
public void getSoftApConfiguration_getConfigFromRepository() {
mViewModel.getSoftApConfiguration();
verify(mWifiHotspotRepository).getSoftApConfiguration();
}
@Test
public void setSoftApConfiguration_setConfigByRepository() {
SoftApConfiguration config = new SoftApConfiguration.Builder().build();
@@ -126,4 +136,9 @@ public class WifiTetherViewModelTest {
verify(mWifiHotspotRepository).isSpeedFeatureAvailable();
}
@Test
public void getRestarting_shouldNotReturnNull() {
assertThat(mViewModel.getRestarting()).isNotNull();
}
}