Merge "Add Instant hotspot preference" into udc-qpr-dev
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 9a4812f..468f3fa 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -2098,6 +2098,13 @@
<!-- The footer message for Wi-Fi hotspot security settings [CHAR LIMIT=NONE] -->
<string name="wifi_hotspot_security_footer">Security settings may change if you change the hotspot’s frequency</string>
+ <!-- Title for the instant hotspot state [CHAR LIMIT=NONE]-->
+ <string name="wifi_hotspot_instant_title">Instant hotspot</string>
+ <!-- Summary text when instant hotspot is turned on -->
+ <string name="wifi_hotspot_instant_summary_on">On</string>
+ <!-- Summary text when instant hotspot is turned off -->
+ <string name="wifi_hotspot_instant_summary_off">Off</string>
+
<!-- Summary text when turning hotspot on -->
<string name="wifi_tether_starting">Turning hotspot on\u2026</string>
<!-- Summary text when turning hotspot off -->
diff --git a/res/xml/wifi_tether_settings.xml b/res/xml/wifi_tether_settings.xml
index a85d9ea..b8b810f 100644
--- a/res/xml/wifi_tether_settings.xml
+++ b/res/xml/wifi_tether_settings.xml
@@ -59,4 +59,10 @@
android:summary="@string/summary_placeholder"
android:fragment="com.android.settings.wifi.tether.WifiHotspotSpeedSettings"
settings:isPreferenceVisible="@bool/config_show_wifi_hotspot_speed"/>
+
+ <Preference
+ android:key="wifi_hotspot_instant"
+ android:title="@string/wifi_hotspot_instant_title"
+ android:summary="@string/summary_placeholder"
+ settings:isPreferenceVisible="false"/>
</PreferenceScreen>
diff --git a/src/com/android/settings/wifi/factory/WifiFeatureProvider.java b/src/com/android/settings/wifi/factory/WifiFeatureProvider.java
index c61cf51..3f0d62f 100644
--- a/src/com/android/settings/wifi/factory/WifiFeatureProvider.java
+++ b/src/com/android/settings/wifi/factory/WifiFeatureProvider.java
@@ -26,6 +26,7 @@
import androidx.lifecycle.ViewModelProvider;
import androidx.lifecycle.ViewModelStoreOwner;
+import com.android.settings.wifi.repository.SharedConnectivityRepository;
import com.android.settings.wifi.repository.WifiHotspotRepository;
import com.android.settings.wifi.tether.WifiHotspotSecurityViewModel;
import com.android.settings.wifi.tether.WifiHotspotSpeedViewModel;
@@ -44,6 +45,7 @@
private TetheringManager mTetheringManager;
private WifiVerboseLogging mWifiVerboseLogging;
private WifiHotspotRepository mWifiHotspotRepository;
+ private SharedConnectivityRepository mSharedConnectivityRepository;
public WifiFeatureProvider(@NonNull Context appContext) {
mAppContext = appContext;
@@ -93,6 +95,17 @@
}
/**
+ * Gets SharedConnectivityRepository
+ */
+ public SharedConnectivityRepository getSharedConnectivityRepository() {
+ if (mSharedConnectivityRepository == null) {
+ mSharedConnectivityRepository = new SharedConnectivityRepository(mAppContext);
+ verboseLog(TAG, "getSharedConnectivityRepository():" + mSharedConnectivityRepository);
+ }
+ return mSharedConnectivityRepository;
+ }
+
+ /**
* Gets WifiTetherViewModel
*/
public WifiTetherViewModel getWifiTetherViewModel(@NotNull ViewModelStoreOwner owner) {
diff --git a/src/com/android/settings/wifi/repository/SharedConnectivityRepository.java b/src/com/android/settings/wifi/repository/SharedConnectivityRepository.java
new file mode 100644
index 0000000..5daa5f3
--- /dev/null
+++ b/src/com/android/settings/wifi/repository/SharedConnectivityRepository.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2023 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.settings.wifi.repository;
+
+import android.app.PendingIntent;
+import android.content.Context;
+import android.net.wifi.sharedconnectivity.app.HotspotNetwork;
+import android.net.wifi.sharedconnectivity.app.HotspotNetworkConnectionStatus;
+import android.net.wifi.sharedconnectivity.app.KnownNetwork;
+import android.net.wifi.sharedconnectivity.app.KnownNetworkConnectionStatus;
+import android.net.wifi.sharedconnectivity.app.SharedConnectivityClientCallback;
+import android.net.wifi.sharedconnectivity.app.SharedConnectivityManager;
+import android.net.wifi.sharedconnectivity.app.SharedConnectivitySettingsState;
+import android.os.HandlerThread;
+import android.provider.DeviceConfig;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.VisibleForTesting;
+import androidx.annotation.WorkerThread;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.MutableLiveData;
+
+import com.android.settings.overlay.FeatureFactory;
+
+import java.util.List;
+import java.util.concurrent.Executor;
+
+/**
+ * Shared Connectivity Repository for {@link SharedConnectivityManager}
+ */
+public class SharedConnectivityRepository {
+ private static final String TAG = "SharedConnectivityRepository";
+ private static final String DEVICE_CONFIG_NAMESPACE = "wifi";
+ private static final String DEVICE_CONFIG_KEY = "shared_connectivity_enabled";
+
+ private Context mAppContext;
+ private SharedConnectivityManager mManager;
+ private ClientCallback mClientCallback = new ClientCallback();
+ private HandlerThread mWorkerThread = new HandlerThread(TAG);
+ private Executor mWorkerExecutor = cmd -> mWorkerThread.getThreadHandler().post(cmd);
+ private Runnable mLaunchSettingsRunnable = () -> handleLaunchSettings();
+ @VisibleForTesting
+ MutableLiveData<SharedConnectivitySettingsState> mSettingsState = new MutableLiveData<>();
+
+ public SharedConnectivityRepository(@NonNull Context appContext) {
+ this(appContext,
+ DeviceConfig.getBoolean(DEVICE_CONFIG_NAMESPACE, DEVICE_CONFIG_KEY, false));
+ }
+
+ @VisibleForTesting
+ SharedConnectivityRepository(@NonNull Context appContext, boolean isConfigEnabled) {
+ mAppContext = appContext;
+ if (!isConfigEnabled) {
+ return;
+ }
+ mManager = mAppContext.getSystemService(SharedConnectivityManager.class);
+ if (mManager == null) {
+ Log.w(TAG, "Failed to get SharedConnectivityManager");
+ return;
+ }
+ mWorkerThread.start();
+ mManager.registerCallback(mWorkerExecutor, mClientCallback);
+ }
+
+ /**
+ * Return whether Wi-Fi Shared Connectivity service is available or not.
+ *
+ * @return {@code true} if Wi-Fi Shared Connectivity service is available
+ */
+ public boolean isServiceAvailable() {
+ return mManager != null;
+ }
+
+ /**
+ * Gets SharedConnectivitySettingsState LiveData
+ */
+ public LiveData<SharedConnectivitySettingsState> getSettingsState() {
+ return mSettingsState;
+ }
+
+ /**
+ * Launch Instant Hotspot Settings
+ */
+ public void launchSettings() {
+ mWorkerExecutor.execute(mLaunchSettingsRunnable);
+ }
+
+ @WorkerThread
+ @VisibleForTesting
+ void handleLaunchSettings() {
+ if (mManager == null) {
+ return;
+ }
+ SharedConnectivitySettingsState state = mManager.getSettingsState();
+ log("handleLaunchSettings(), state:" + state);
+ if (state == null) {
+ Log.e(TAG, "No SettingsState to launch Instant Hotspot settings");
+ return;
+ }
+ PendingIntent intent = state.getInstantTetherSettingsPendingIntent();
+ if (intent == null) {
+ Log.e(TAG, "No PendingIntent to launch Instant Hotspot settings");
+ return;
+ }
+ sendSettingsIntent(intent);
+ }
+
+ @WorkerThread
+ @VisibleForTesting
+ void sendSettingsIntent(@NonNull PendingIntent intent) {
+ try {
+ log("sendSettingsIntent(), sent intent:" + intent);
+ intent.send();
+ } catch (PendingIntent.CanceledException e) {
+ Log.e(TAG, "Failed to launch Instant Hotspot settings", e);
+ }
+ }
+
+ @WorkerThread
+ class ClientCallback implements SharedConnectivityClientCallback {
+
+ @Override
+ public void onHotspotNetworkConnectionStatusChanged(HotspotNetworkConnectionStatus status) {
+ log("onHotspotNetworkConnectionStatusChanged(), status:" + status);
+ }
+
+ @Override
+ public void onHotspotNetworksUpdated(List<HotspotNetwork> networks) {
+ log("onHotspotNetworksUpdated(), networks:" + networks);
+ }
+
+ @Override
+ public void onKnownNetworkConnectionStatusChanged(KnownNetworkConnectionStatus status) {
+ log("onKnownNetworkConnectionStatusChanged(), status:" + status);
+ }
+
+ @Override
+ public void onKnownNetworksUpdated(List<KnownNetwork> networks) {
+ log("onKnownNetworksUpdated(), networks:" + networks);
+ }
+
+ @Override
+ public void onRegisterCallbackFailed(Exception e) {
+ Log.e(TAG, "onRegisterCallbackFailed(), e:" + e);
+ }
+
+ @Override
+ public void onServiceConnected() {
+ SharedConnectivitySettingsState state = mManager.getSettingsState();
+ Log.d(TAG, "onServiceConnected(), Manager#getSettingsState:" + state);
+ mSettingsState.postValue(state);
+ }
+
+ @Override
+ public void onServiceDisconnected() {
+ log("onServiceDisconnected()");
+ }
+
+ @Override
+ public void onSharedConnectivitySettingsChanged(SharedConnectivitySettingsState state) {
+ Log.d(TAG, "onSharedConnectivitySettingsChanged(), state:" + state);
+ mSettingsState.postValue(state);
+ }
+ }
+
+ private void log(String msg) {
+ FeatureFactory.getFactory(mAppContext).getWifiFeatureProvider().verboseLog(TAG, msg);
+ }
+}
diff --git a/src/com/android/settings/wifi/tether/WifiTetherSettings.java b/src/com/android/settings/wifi/tether/WifiTetherSettings.java
index d8c3908..fa897b7 100644
--- a/src/com/android/settings/wifi/tether/WifiTetherSettings.java
+++ b/src/com/android/settings/wifi/tether/WifiTetherSettings.java
@@ -76,6 +76,8 @@
static final String KEY_WIFI_HOTSPOT_SECURITY = "wifi_hotspot_security";
@VisibleForTesting
static final String KEY_WIFI_HOTSPOT_SPEED = "wifi_hotspot_speed";
+ @VisibleForTesting
+ static final String KEY_INSTANT_HOTSPOT = "wifi_hotspot_instant";
@VisibleForTesting
SettingsMainSwitchBar mMainSwitchBar;
@@ -103,6 +105,8 @@
Preference mWifiHotspotSecurity;
@VisibleForTesting
Preference mWifiHotspotSpeed;
+ @VisibleForTesting
+ Preference mInstantHotspot;
static {
TETHER_STATE_CHANGE_FILTER = new IntentFilter(WIFI_AP_STATE_CHANGED_ACTION);
@@ -148,6 +152,7 @@
.getWifiTetherViewModel(this);
if (mWifiTetherViewModel != null) {
setupSpeedFeature(mWifiTetherViewModel.isSpeedFeatureAvailable());
+ setupInstantHotspot(mWifiTetherViewModel.isInstantHotspotFeatureAvailable());
mWifiTetherViewModel.getRestarting().observe(this, this::onRestartingChanged);
}
}
@@ -167,6 +172,24 @@
}
}
+ @VisibleForTesting
+ void setupInstantHotspot(boolean isFeatureAvailable) {
+ if (!isFeatureAvailable) {
+ return;
+ }
+ mInstantHotspot = findPreference(KEY_INSTANT_HOTSPOT);
+ if (mInstantHotspot == null) {
+ Log.e(TAG, "Failed to find Instant Hotspot preference:" + KEY_INSTANT_HOTSPOT);
+ return;
+ }
+ mWifiTetherViewModel.getInstantHotspotSummary()
+ .observe(this, this::onInstantHotspotChanged);
+ mInstantHotspot.setOnPreferenceClickListener(p -> {
+ mWifiTetherViewModel.launchInstantHotspotSettings();
+ return true;
+ });
+ }
+
@Override
public void onAttach(Context context) {
super.onAttach(context);
@@ -279,6 +302,16 @@
}
@VisibleForTesting
+ void onInstantHotspotChanged(String summary) {
+ if (summary == null) {
+ mInstantHotspot.setVisible(false);
+ return;
+ }
+ mInstantHotspot.setVisible(true);
+ mInstantHotspot.setSummary(summary);
+ }
+
+ @VisibleForTesting
SoftApConfiguration buildNewConfig() {
SoftApConfiguration currentConfig = mWifiTetherViewModel.getSoftApConfiguration();
SoftApConfiguration.Builder configBuilder = new SoftApConfiguration.Builder(currentConfig);
diff --git a/src/com/android/settings/wifi/tether/WifiTetherViewModel.java b/src/com/android/settings/wifi/tether/WifiTetherViewModel.java
index fb2160f..b0a18a8 100644
--- a/src/com/android/settings/wifi/tether/WifiTetherViewModel.java
+++ b/src/com/android/settings/wifi/tether/WifiTetherViewModel.java
@@ -28,7 +28,9 @@
import android.app.Application;
import android.net.wifi.SoftApConfiguration;
+import android.net.wifi.sharedconnectivity.app.SharedConnectivitySettingsState;
+import androidx.annotation.VisibleForTesting;
import androidx.lifecycle.AndroidViewModel;
import androidx.lifecycle.LiveData;
import androidx.lifecycle.MutableLiveData;
@@ -36,6 +38,8 @@
import com.android.settings.R;
import com.android.settings.overlay.FeatureFactory;
+import com.android.settings.wifi.factory.WifiFeatureProvider;
+import com.android.settings.wifi.repository.SharedConnectivityRepository;
import com.android.settings.wifi.repository.WifiHotspotRepository;
import org.jetbrains.annotations.NotNull;
@@ -48,6 +52,8 @@
*/
public class WifiTetherViewModel extends AndroidViewModel {
private static final String TAG = "WifiTetherViewModel";
+ static final int RES_INSTANT_HOTSPOT_SUMMARY_ON = R.string.wifi_hotspot_instant_summary_on;
+ static final int RES_INSTANT_HOTSPOT_SUMMARY_OFF = R.string.wifi_hotspot_instant_summary_off;
static Map<Integer, Integer> sSecuritySummaryResMap = new HashMap<>();
@@ -75,10 +81,23 @@
protected final Observer<Integer> mSecurityTypeObserver = st -> onSecurityTypeChanged(st);
protected final Observer<Integer> mSpeedTypeObserver = st -> onSpeedTypeChanged(st);
+ private SharedConnectivityRepository mSharedConnectivityRepository;
+ @VisibleForTesting
+ MutableLiveData<String> mInstantHotspotSummary = new MutableLiveData<>();
+ @VisibleForTesting
+ Observer<SharedConnectivitySettingsState> mInstantHotspotStateObserver =
+ state -> onInstantHotspotStateChanged(state);
+
public WifiTetherViewModel(@NotNull Application application) {
super(application);
- mWifiHotspotRepository = FeatureFactory.getFactory(application).getWifiFeatureProvider()
- .getWifiHotspotRepository();
+ WifiFeatureProvider featureProvider = FeatureFactory.getFactory(application)
+ .getWifiFeatureProvider();
+ mWifiHotspotRepository = featureProvider.getWifiHotspotRepository();
+ mSharedConnectivityRepository = featureProvider.getSharedConnectivityRepository();
+ if (mSharedConnectivityRepository.isServiceAvailable()) {
+ mSharedConnectivityRepository.getSettingsState()
+ .observeForever(mInstantHotspotStateObserver);
+ }
}
@Override
@@ -89,6 +108,10 @@
if (mSpeedSummary != null) {
mWifiHotspotRepository.getSpeedType().removeObserver(mSpeedTypeObserver);
}
+ if (mSharedConnectivityRepository.isServiceAvailable()) {
+ mSharedConnectivityRepository.getSettingsState()
+ .removeObserver(mInstantHotspotStateObserver);
+ }
}
/**
@@ -169,4 +192,47 @@
public LiveData<Boolean> getRestarting() {
return mWifiHotspotRepository.getRestarting();
}
+
+ /**
+ * Return whether Wi-Fi Instant Hotspot feature is available or not.
+ *
+ * @return {@code true} if Wi-Fi Instant Hotspot feature is available
+ */
+ public boolean isInstantHotspotFeatureAvailable() {
+ return mSharedConnectivityRepository.isServiceAvailable();
+ }
+
+ /**
+ * Gets InstantHotspotSummary
+ */
+ public LiveData<String> getInstantHotspotSummary() {
+ return mInstantHotspotSummary;
+ }
+
+ @VisibleForTesting
+ void onInstantHotspotStateChanged(SharedConnectivitySettingsState state) {
+ log("onInstantHotspotStateChanged(), state:" + state);
+ if (state == null) {
+ mInstantHotspotSummary.setValue(null);
+ return;
+ }
+ mInstantHotspotSummary.setValue(getInstantHotspotSummary(state.isInstantTetherEnabled()));
+ }
+
+ private String getInstantHotspotSummary(boolean enabled) {
+ return getApplication().getString(
+ enabled ? RES_INSTANT_HOTSPOT_SUMMARY_ON : RES_INSTANT_HOTSPOT_SUMMARY_OFF);
+ }
+
+ /**
+ * Launch Instant Hotspot Settings
+ */
+ public void launchInstantHotspotSettings() {
+ mSharedConnectivityRepository.launchSettings();
+ }
+
+ private void log(String msg) {
+ FeatureFactory.getFactory(getApplication().getApplicationContext()).getWifiFeatureProvider()
+ .verboseLog(TAG, msg);
+ }
}
diff --git a/tests/robotests/src/com/android/settings/wifi/tether/WifiTetherSettingsTest.java b/tests/robotests/src/com/android/settings/wifi/tether/WifiTetherSettingsTest.java
index 75d49fe..e67717d 100644
--- a/tests/robotests/src/com/android/settings/wifi/tether/WifiTetherSettingsTest.java
+++ b/tests/robotests/src/com/android/settings/wifi/tether/WifiTetherSettingsTest.java
@@ -23,6 +23,7 @@
import static com.android.settings.wifi.WifiUtils.setCanShowWifiHotspotCached;
import static com.android.settings.wifi.repository.WifiHotspotRepository.BAND_2GHZ_5GHZ_6GHZ;
+import static com.android.settings.wifi.tether.WifiTetherSettings.KEY_INSTANT_HOTSPOT;
import static com.android.settings.wifi.tether.WifiTetherSettings.KEY_WIFI_HOTSPOT_SECURITY;
import static com.android.settings.wifi.tether.WifiTetherSettings.KEY_WIFI_HOTSPOT_SPEED;
@@ -90,6 +91,7 @@
private static final String[] WIFI_REGEXS = {"wifi_regexs"};
private static final String SSID = "ssid";
private static final String PASSWORD = "password";
+ private static final String SUMMARY = "summary";
@Rule
public final MockitoRule mMockitoRule = MockitoJUnit.rule();
@@ -133,6 +135,10 @@
private WifiTetherAutoOffPreferenceController mWifiTetherAutoOffPreferenceController;
@Mock
private WifiTetherMaximizeCompatibilityPreferenceController mMaxCompatibilityPrefController;
+ @Mock
+ private Preference mInstantHotspot;
+ @Mock
+ private LiveData<String> mInstantHotspotSummary;
private WifiTetherSettings mSettings;
@@ -155,8 +161,10 @@
when(provider.getWifiTetherViewModel(mock(ViewModelStoreOwner.class)))
.thenReturn(mWifiTetherViewModel);
when(mWifiTetherViewModel.isSpeedFeatureAvailable()).thenReturn(false);
+ when(mWifiTetherViewModel.isInstantHotspotFeatureAvailable()).thenReturn(true);
when(mWifiTetherViewModel.getSecuritySummary()).thenReturn(mSecuritySummary);
when(mWifiTetherViewModel.getSpeedSummary()).thenReturn(mSpeedSummary);
+ when(mWifiTetherViewModel.getInstantHotspotSummary()).thenReturn(mInstantHotspotSummary);
mSettings = spy(new WifiTetherSettings(mWifiRestriction));
mSettings.mMainSwitchBar = mMainSwitchBar;
@@ -172,6 +180,8 @@
mSettings.mWifiTetherViewModel = mWifiTetherViewModel;
when(mSettings.findPreference(KEY_WIFI_HOTSPOT_SECURITY)).thenReturn(mWifiHotspotSecurity);
when(mSettings.findPreference(KEY_WIFI_HOTSPOT_SPEED)).thenReturn(mWifiHotspotSpeed);
+ when(mSettings.findPreference(KEY_INSTANT_HOTSPOT)).thenReturn(mInstantHotspot);
+ mSettings.mInstantHotspot = mInstantHotspot;
}
@Test
@@ -373,6 +383,47 @@
}
@Test
+ public void setupInstantHotspot_featureNotAvailable_doNothing() {
+ mSettings.setupInstantHotspot(false /* isFeatureAvailable */);
+
+ verify(mSettings, never()).findPreference(KEY_INSTANT_HOTSPOT);
+ verify(mWifiTetherViewModel, never()).getInstantHotspotSummary();
+ }
+
+ @Test
+ public void setupInstantHotspot_featureAvailable_doSetup() {
+ when(mWifiTetherViewModel.isInstantHotspotFeatureAvailable()).thenReturn(true);
+
+ mSettings.setupInstantHotspot(true /* isFeatureAvailable */);
+
+ verify(mSettings).findPreference(KEY_INSTANT_HOTSPOT);
+ verify(mInstantHotspotSummary).observe(any(), any());
+ verify(mInstantHotspot).setOnPreferenceClickListener(any());
+ }
+
+ @Test
+ public void onInstantHotspotChanged_nullRecord_setVisibleFalse() {
+ mSettings.onInstantHotspotChanged(null);
+
+ verify(mInstantHotspot).setVisible(false);
+ }
+
+ @Test
+ public void onInstantHotspotChanged_summaryNull_setVisibleFalse() {
+ mSettings.onInstantHotspotChanged(null);
+
+ verify(mInstantHotspot).setVisible(false);
+ }
+
+ @Test
+ public void onInstantHotspotChanged_summaryNotNull_setVisibleAndSummary() {
+ mSettings.onInstantHotspotChanged(SUMMARY);
+
+ verify(mInstantHotspot).setVisible(true);
+ verify(mInstantHotspot).setSummary(SUMMARY);
+ }
+
+ @Test
public void buildNewConfig_speedFeatureIsAvailableAndPasswordChanged_bandShouldNotBeLost() {
String newPassword = "new" + PASSWORD;
SoftApConfiguration currentConfig = new SoftApConfiguration.Builder()
diff --git a/tests/unit/src/com/android/settings/wifi/repository/SharedConnectivityRepositoryTest.java b/tests/unit/src/com/android/settings/wifi/repository/SharedConnectivityRepositoryTest.java
new file mode 100644
index 0000000..4aef552
--- /dev/null
+++ b/tests/unit/src/com/android/settings/wifi/repository/SharedConnectivityRepositoryTest.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2023 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.settings.wifi.repository;
+
+import static android.app.PendingIntent.FLAG_IMMUTABLE;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.net.wifi.sharedconnectivity.app.SharedConnectivityManager;
+import android.net.wifi.sharedconnectivity.app.SharedConnectivitySettingsState;
+
+import androidx.test.core.app.ApplicationProvider;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+public class SharedConnectivityRepositoryTest {
+
+ @Rule
+ public final MockitoRule mMockitoRule = MockitoJUnit.rule();
+ @Spy
+ private Context mContext = ApplicationProvider.getApplicationContext();
+ @Mock
+ private SharedConnectivityManager mManager;
+
+ private SharedConnectivityRepository mRepository;
+ private PendingIntent mIntent = PendingIntent
+ .getActivity(mContext, 0, new Intent("test"), FLAG_IMMUTABLE);
+ private SharedConnectivitySettingsState mState = new SharedConnectivitySettingsState.Builder()
+ .setInstantTetherSettingsPendingIntent(mIntent).build();
+
+ @Before
+ public void setUp() {
+ when(mContext.getSystemService(SharedConnectivityManager.class)).thenReturn(mManager);
+ when(mManager.getSettingsState()).thenReturn(mState);
+
+ mRepository = spy(new SharedConnectivityRepository(mContext, true /* isConfigEnabled */));
+ }
+
+ @Test
+ public void constructor_configEnabled_registerCallback() {
+ verify(mManager).registerCallback(any(), any());
+ }
+
+ @Test
+ public void constructor_configNotEnabled_doNotRegisterCallback() {
+ SharedConnectivityManager manager = mock(SharedConnectivityManager.class);
+ when(mContext.getSystemService(SharedConnectivityManager.class)).thenReturn(manager);
+
+ mRepository = new SharedConnectivityRepository(mContext, false /* isConfigEnabled */);
+
+ verify(manager, never()).registerCallback(any(), any());
+ }
+
+ @Test
+ public void isServiceAvailable_configEnabled_returnTrue() {
+ mRepository = new SharedConnectivityRepository(mContext, true /* isConfigEnabled */);
+
+ assertThat(mRepository.isServiceAvailable()).isTrue();
+ }
+
+ @Test
+ public void isServiceAvailable_configNotEnabled_returnFalse() {
+ mRepository = new SharedConnectivityRepository(mContext, false /* isConfigEnabled */);
+
+ assertThat(mRepository.isServiceAvailable()).isFalse();
+ }
+
+ @Test
+ public void getSettingsState_isNotNull() {
+ assertThat(mRepository.getSettingsState()).isNotNull();
+ }
+
+ @Test
+ public void handleLaunchSettings_managerNull_doNothing() {
+ when(mContext.getSystemService(SharedConnectivityManager.class)).thenReturn(null);
+ mRepository = spy(new SharedConnectivityRepository(mContext, true /* isConfigEnabled */));
+
+ mRepository.handleLaunchSettings();
+
+ verify(mRepository, never()).sendSettingsIntent(mIntent);
+ }
+
+ @Test
+ public void handleLaunchSettings_stageNull_doNothing() {
+ when(mManager.getSettingsState()).thenReturn(null);
+
+ mRepository.handleLaunchSettings();
+
+ verify(mRepository, never()).sendSettingsIntent(mIntent);
+ }
+
+ @Test
+ public void handleLaunchSettings_intentNull_doNothing() {
+ mState = new SharedConnectivitySettingsState.Builder()
+ .setInstantTetherSettingsPendingIntent(null).build();
+ when(mManager.getSettingsState()).thenReturn(mState);
+
+ mRepository.handleLaunchSettings();
+
+ verify(mRepository, never()).sendSettingsIntent(mIntent);
+ }
+
+ @Test
+ public void handleLaunchSettings_allReady_sendSettingsIntent() {
+ mRepository.handleLaunchSettings();
+
+ verify(mRepository).sendSettingsIntent(mIntent);
+ }
+}
diff --git a/tests/unit/src/com/android/settings/wifi/tether/WifiTetherViewModelTest.java b/tests/unit/src/com/android/settings/wifi/tether/WifiTetherViewModelTest.java
index af1f62b..1c1473f 100644
--- a/tests/unit/src/com/android/settings/wifi/tether/WifiTetherViewModelTest.java
+++ b/tests/unit/src/com/android/settings/wifi/tether/WifiTetherViewModelTest.java
@@ -16,6 +16,9 @@
package com.android.settings.wifi.tether;
+import static com.android.settings.wifi.tether.WifiTetherViewModel.RES_INSTANT_HOTSPOT_SUMMARY_OFF;
+import static com.android.settings.wifi.tether.WifiTetherViewModel.RES_INSTANT_HOTSPOT_SUMMARY_ON;
+
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.verify;
@@ -23,12 +26,15 @@
import android.app.Application;
import android.net.wifi.SoftApConfiguration;
+import android.net.wifi.sharedconnectivity.app.SharedConnectivitySettingsState;
import androidx.lifecycle.MutableLiveData;
import androidx.test.annotation.UiThreadTest;
+import androidx.test.core.app.ApplicationProvider;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import com.android.settings.testutils.FakeFeatureFactory;
+import com.android.settings.wifi.repository.SharedConnectivityRepository;
import com.android.settings.wifi.repository.WifiHotspotRepository;
import org.junit.Before;
@@ -36,6 +42,7 @@
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
+import org.mockito.Spy;
import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.MockitoRule;
@@ -45,8 +52,8 @@
public class WifiTetherViewModelTest {
@Rule
public final MockitoRule mMockitoRule = MockitoJUnit.rule();
- @Mock
- Application mApplication;
+ @Spy
+ Application mApplication = ApplicationProvider.getApplicationContext();
@Mock
Executor mExecutor;
@Mock
@@ -57,6 +64,12 @@
MutableLiveData<Integer> mSpeedType;
@Mock
private MutableLiveData<Boolean> mRestarting;
+ @Mock
+ private SharedConnectivityRepository mSharedConnectivityRepository;
+ @Mock
+ private MutableLiveData<SharedConnectivitySettingsState> mSettingsState;
+ @Mock
+ private MutableLiveData<String> mInstantHotspotSummary;
WifiTetherViewModel mViewModel;
@@ -70,8 +83,18 @@
when(mWifiHotspotRepository.getSecurityType()).thenReturn(mSecurityType);
when(mWifiHotspotRepository.getSpeedType()).thenReturn(mSpeedType);
when(mWifiHotspotRepository.getRestarting()).thenReturn(mRestarting);
+ when(featureFactory.getWifiFeatureProvider().getSharedConnectivityRepository())
+ .thenReturn(mSharedConnectivityRepository);
+ when(mSharedConnectivityRepository.isServiceAvailable()).thenReturn(true);
+ when(mSharedConnectivityRepository.getSettingsState()).thenReturn(mSettingsState);
mViewModel = new WifiTetherViewModel(mApplication);
+ mViewModel.mInstantHotspotSummary = mInstantHotspotSummary;
+ }
+
+ @Test
+ public void constructor_observeData() {
+ verify(mSettingsState).observeForever(mViewModel.mInstantHotspotStateObserver);
}
@Test
@@ -83,6 +106,7 @@
verify(mSecurityType).removeObserver(mViewModel.mSecurityTypeObserver);
verify(mSpeedType).removeObserver(mViewModel.mSpeedTypeObserver);
+ verify(mSettingsState).removeObserver(mViewModel.mInstantHotspotStateObserver);
}
@Test
@@ -141,4 +165,59 @@
public void getRestarting_shouldNotReturnNull() {
assertThat(mViewModel.getRestarting()).isNotNull();
}
+
+ @Test
+ public void isInstantHotspotFeatureAvailable_serviceAvailable_returnTrue() {
+ when(mSharedConnectivityRepository.isServiceAvailable()).thenReturn(true);
+
+ assertThat(mViewModel.isInstantHotspotFeatureAvailable()).isTrue();
+ }
+
+ @Test
+ public void isInstantHotspotFeatureAvailable_serviceNotAvailable_returnFalse() {
+ when(mSharedConnectivityRepository.isServiceAvailable()).thenReturn(false);
+
+ assertThat(mViewModel.isInstantHotspotFeatureAvailable()).isFalse();
+ }
+
+ @Test
+ public void getInstantHotspotSummary_isNotNull() {
+ assertThat(mViewModel.getInstantHotspotSummary()).isNotNull();
+ }
+
+ @Test
+ public void onInstantHotspotStateChanged_stageNull_summarySetValueNull() {
+ mViewModel.onInstantHotspotStateChanged(null);
+
+ verify(mInstantHotspotSummary).setValue(null);
+ }
+
+ @Test
+ public void onInstantHotspotStateChanged_stateEnabled_summarySetValueOn() {
+ SharedConnectivitySettingsState state = new SharedConnectivitySettingsState.Builder()
+ .setInstantTetherEnabled(true).build();
+
+ mViewModel.onInstantHotspotStateChanged(state);
+
+ verify(mInstantHotspotSummary)
+ .setValue(mApplication.getString(RES_INSTANT_HOTSPOT_SUMMARY_ON));
+ }
+
+ @Test
+ public void onInstantHotspotStateChanged_stateNotEnabled_recordVisibleSummaryOff() {
+ SharedConnectivitySettingsState state = new SharedConnectivitySettingsState.Builder()
+ .setInstantTetherEnabled(false).build();
+
+ mViewModel.onInstantHotspotStateChanged(state);
+
+ verify(mInstantHotspotSummary)
+ .setValue(mApplication.getString(RES_INSTANT_HOTSPOT_SUMMARY_OFF));
+ }
+
+ @Test
+ public void launchInstantHotspotSettings_launchSettingsByRepository() {
+ mViewModel.launchInstantHotspotSettings();
+
+ verify(mSharedConnectivityRepository).launchSettings();
+ }
}