Merge "[Provider Model] Hide Connectivity Subsystems when recovering" into sc-dev am: 80fd8a7cce (19fe74f9) · Commits · e / os / android_packages_apps_Settings

src/com/android/settings/network/InternetResetHelper.java

0 → 100644

+262 −0

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

		package com.android.settings.network;

		import android.content.BroadcastReceiver;
		import android.content.Context;
		import android.content.Intent;
		import android.content.IntentFilter;
		import android.net.wifi.WifiManager;
		import android.os.Handler;
		import android.os.HandlerThread;
		import android.os.Process;
		import android.text.TextUtils;
		import android.util.Log;

		import androidx.annotation.UiThread;
		import androidx.annotation.VisibleForTesting;
		import androidx.annotation.WorkerThread;
		import androidx.lifecycle.Lifecycle;
		import androidx.lifecycle.LifecycleObserver;
		import androidx.lifecycle.OnLifecycleEvent;
		import androidx.preference.Preference;
		import androidx.preference.PreferenceCategory;

		import com.android.settingslib.connectivity.ConnectivitySubsystemsRecoveryManager;

		import java.util.ArrayList;
		import java.util.List;

		/**
		* Helper class to restart connectivity for all requested subsystems.
		*/
		public class InternetResetHelper implements LifecycleObserver,
		ConnectivitySubsystemsRecoveryManager.RecoveryStatusCallback {

		protected static final String TAG = "InternetResetHelper";
		public static final long RESTART_TIMEOUT_MS = 15_000; // 15 seconds

		protected final Context mContext;
		protected Preference mResettingPreference;
		protected NetworkMobileProviderController mMobileNetworkController;
		protected Preference mWifiTogglePreferences;
		protected List<PreferenceCategory> mWifiNetworkPreferences =
		new ArrayList<PreferenceCategory>();

		protected final WifiManager mWifiManager;
		protected final IntentFilter mWifiStateFilter;
		protected final BroadcastReceiver mWifiStateReceiver = new BroadcastReceiver() {
		@Override
		@WorkerThread
		public void onReceive(Context context, Intent intent) {
		if (intent != null && TextUtils.equals(intent.getAction(),
		WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
		updateWifiStateChange();
		}
		}
		};

		protected ConnectivitySubsystemsRecoveryManager mConnectivitySubsystemsRecoveryManager;
		protected HandlerThread mWorkerThread;
		protected boolean mIsRecoveryReady;
		protected boolean mIsWifiReady;
		protected HandlerInjector mHandlerInjector;
		protected final Runnable mResumeRunnable = () -> {
		resumePreferences();
		};
		protected final Runnable mTimeoutRunnable = () -> {
		mIsRecoveryReady = true;
		mIsWifiReady = true;
		resumePreferences();
		};

		public InternetResetHelper(Context context, Lifecycle lifecycle) {
		mContext = context;
		mHandlerInjector = new HandlerInjector(context);
		mWifiManager = mContext.getSystemService(WifiManager.class);
		mWifiStateFilter = new IntentFilter(WifiManager.NETWORK_STATE_CHANGED_ACTION);

		mWorkerThread = new HandlerThread(TAG
		+ "{" + Integer.toHexString(System.identityHashCode(this)) + "}",
		Process.THREAD_PRIORITY_BACKGROUND);
		mWorkerThread.start();
		mConnectivitySubsystemsRecoveryManager = new ConnectivitySubsystemsRecoveryManager(
		mContext, mWorkerThread.getThreadHandler());

		if (lifecycle != null) {
		lifecycle.addObserver(this);
		}
		}

		/** @OnLifecycleEvent(Lifecycle.Event.ON_RESUME) */
		@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
		public void onResume() {
		mContext.registerReceiver(mWifiStateReceiver, mWifiStateFilter);
		}

		/** @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE) */
		@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
		public void onPause() {
		mContext.unregisterReceiver(mWifiStateReceiver);
		}

		/** @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY) */
		@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
		public void onDestroy() {
		mHandlerInjector.removeCallbacks(mResumeRunnable);
		mHandlerInjector.removeCallbacks(mTimeoutRunnable);
		mWorkerThread.quit();
		}

		@Override
		@WorkerThread
		public void onSubsystemRestartOperationBegin() {
		Log.d(TAG, "The connectivity subsystem is starting for recovery.");
		}

		@Override
		@WorkerThread
		public void onSubsystemRestartOperationEnd() {
		Log.d(TAG, "The connectivity subsystem is done for recovery.");
		if (!mIsRecoveryReady) {
		mIsRecoveryReady = true;
		mHandlerInjector.postDelayed(mResumeRunnable, 0 /* delayMillis */);
		}
		}

		@VisibleForTesting
		@WorkerThread
		protected void updateWifiStateChange() {
		if (!mIsWifiReady && mWifiManager.isWifiEnabled()) {
		Log.d(TAG, "The Wi-Fi subsystem is done for recovery.");
		mIsWifiReady = true;
		mHandlerInjector.postDelayed(mResumeRunnable, 0 /* delayMillis */);
		}
		}

		/**
		* Sets the resetting preference.
		*/
		@UiThread
		public void setResettingPreference(Preference preference) {
		mResettingPreference = preference;
		}

		/**
		* Sets the mobile network controller.
		*/
		@UiThread
		public void setMobileNetworkController(NetworkMobileProviderController controller) {
		mMobileNetworkController = controller;
		}

		/**
		* Sets the Wi-Fi toggle preference.
		*/
		@UiThread
		public void setWifiTogglePreference(Preference preference) {
		mWifiTogglePreferences = preference;
		}

		/**
		* Adds the Wi-Fi network preference.
		*/
		@UiThread
		public void addWifiNetworkPreference(PreferenceCategory preference) {
		if (preference != null) {
		mWifiNetworkPreferences.add(preference);
		}
		}

		@UiThread
		protected void suspendPreferences() {
		Log.d(TAG, "Suspend the subsystem preferences");
		if (mMobileNetworkController != null) {
		mMobileNetworkController.hidePreference(true /* hide /, true / immediately */);
		}
		if (mWifiTogglePreferences != null) {
		mWifiTogglePreferences.setVisible(false);
		}
		for (PreferenceCategory pref : mWifiNetworkPreferences) {
		pref.removeAll();
		pref.setVisible(false);
		}
		if (mResettingPreference != null) {
		mResettingPreference.setVisible(true);
		}
		}

		@UiThread
		protected void resumePreferences() {
		if (mIsRecoveryReady && mMobileNetworkController != null) {
		Log.d(TAG, "Resume the Mobile Network controller");
		mMobileNetworkController.hidePreference(false /* hide /, false / immediately */);
		}
		if (mIsWifiReady && mWifiTogglePreferences != null) {
		Log.d(TAG, "Resume the Wi-Fi preferences");
		mWifiTogglePreferences.setVisible(true);
		for (PreferenceCategory pref : mWifiNetworkPreferences) {
		pref.setVisible(true);
		}
		}
		if (mIsRecoveryReady && mIsWifiReady) {
		mHandlerInjector.removeCallbacks(mTimeoutRunnable);
		if (mResettingPreference != null) {
		Log.d(TAG, "Resume the Resetting preference");
		mResettingPreference.setVisible(false);
		}
		}
		}

		/**
		* Restart connectivity for all requested subsystems.
		*/
		@UiThread
		public void restart() {
		if (!mConnectivitySubsystemsRecoveryManager.isRecoveryAvailable()) {
		Log.e(TAG, "The connectivity subsystem is not available to restart.");
		return;
		}

		Log.d(TAG, "The connectivity subsystem is restarting for recovery.");
		suspendPreferences();
		mIsRecoveryReady = false;
		mIsWifiReady = !mWifiManager.isWifiEnabled();
		mHandlerInjector.postDelayed(mTimeoutRunnable, RESTART_TIMEOUT_MS);
		mConnectivitySubsystemsRecoveryManager.triggerSubsystemRestart(null /* reason */, this);
		}

		/**
		* Wrapper for testing compatibility.
		*/
		@VisibleForTesting
		static class HandlerInjector {
		protected final Handler mHandler;

		HandlerInjector(Context context) {
		mHandler = context.getMainThreadHandler();
		}

		public void postDelayed(Runnable runnable, long delayMillis) {
		mHandler.postDelayed(runnable, delayMillis);
		}

		public void removeCallbacks(Runnable runnable) {
		mHandler.removeCallbacks(runnable);
		}
		}
		}

src/com/android/settings/network/NetworkMobileProviderController.java

+12 −1

Original line number	Diff line number	Diff line
		@@ -50,6 +50,7 @@ public class NetworkMobileProviderController extends BasePreferenceController im
		private SubscriptionsPreferenceController mSubscriptionsController;

		private int mOriginalExpandedChildrenCount;
		private boolean mHide;

		public NetworkMobileProviderController(Context context, String key) {
		super(context, key);
		@@ -94,7 +95,7 @@ public class NetworkMobileProviderController extends BasePreferenceController im

		@Override
		public int getAvailabilityStatus() {
		if (mSubscriptionsController == null) {
		if (mHide \|\| mSubscriptionsController == null) {
		return CONDITIONALLY_UNAVAILABLE;
		}
		return mSubscriptionsController.isAvailable() ? AVAILABLE : CONDITIONALLY_UNAVAILABLE;
		@@ -122,4 +123,14 @@ public class NetworkMobileProviderController extends BasePreferenceController im
		mSubscriptionsController.setWifiPickerTrackerHelper(helper);
		}
		}

		/**
		* Hides the preference.
		*/
		public void hidePreference(boolean hide, boolean immediately) {
		mHide = hide;
		if (immediately) {
		mPreferenceCategory.setVisible(hide ? false : isAvailable());
		}
		}
		}

src/com/android/settings/network/NetworkProviderSettings.java

+12 −40

Original line number	Diff line number	Diff line
		@@ -32,9 +32,7 @@ import android.net.wifi.WifiConfiguration;
		import android.net.wifi.WifiManager;
		import android.os.Bundle;
		import android.os.Handler;
		import android.os.HandlerThread;
		import android.os.PowerManager;
		import android.os.Process;
		import android.provider.Settings;
		import android.telephony.TelephonyManager;
		import android.text.TextUtils;
		@@ -78,7 +76,6 @@ import com.android.settings.wifi.dpp.WifiDppUtils;
		import com.android.settingslib.HelpUtils;
		import com.android.settingslib.RestrictedLockUtils;
		import com.android.settingslib.RestrictedLockUtilsInternal;
		import com.android.settingslib.connectivity.ConnectivitySubsystemsRecoveryManager;
		import com.android.settingslib.search.Indexable;
		import com.android.settingslib.search.SearchIndexable;
		import com.android.settingslib.utils.ThreadUtils;
		@@ -101,7 +98,6 @@ import java.util.Optional;
		public class NetworkProviderSettings extends RestrictedSettingsFragment
		implements Indexable, WifiPickerTracker.WifiPickerTrackerCallback,
		WifiDialog2.WifiDialog2Listener, DialogInterface.OnDismissListener,
		ConnectivitySubsystemsRecoveryManager.RecoveryStatusCallback,
		AirplaneModeEnabler.OnAirplaneModeChangedListener, InternetUpdater.InternetChangeListener {

		public static final String ACTION_NETWORK_PROVIDER_SETTINGS =
		@@ -192,9 +188,7 @@ public class NetworkProviderSettings extends RestrictedSettingsFragment
		private WifiManager.ActionListener mSaveListener;
		private WifiManager.ActionListener mForgetListener;

		@VisibleForTesting
		protected ConnectivitySubsystemsRecoveryManager mConnectivitySubsystemsRecoveryManager;
		private HandlerThread mRecoveryThread;
		protected InternetResetHelper mInternetResetHelper;

		/**
		* The state of {@link #isUiRestricted()} at {@link #onCreate(Bundle)}}. This is necessary to
		@@ -1274,39 +1268,17 @@ public class NetworkProviderSettings extends RestrictedSettingsFragment
		}

		private void fixConnectivity() {
		if (mConnectivitySubsystemsRecoveryManager == null) {
		mRecoveryThread = new HandlerThread(TAG
		+ "{" + Integer.toHexString(System.identityHashCode(this)) + "}",
		Process.THREAD_PRIORITY_BACKGROUND);
		mRecoveryThread.start();
		mConnectivitySubsystemsRecoveryManager = new ConnectivitySubsystemsRecoveryManager(
		getContext(), mRecoveryThread.getThreadHandler());
		}
		if (mConnectivitySubsystemsRecoveryManager.isRecoveryAvailable()) {
		mConnectivitySubsystemsRecoveryManager.triggerSubsystemRestart(null /* reason */, this);
		}
		}

		/**
		* Callback for the internet recovery started.
		*/
		public void onSubsystemRestartOperationBegin() {
		if (mResetInternetPreference != null) {
		mResetInternetPreference.setVisible(true);
		}
		updateAirplaneModeMsgPreference(false /* visible */);
		}

		/**
		* Callback for the internet recovery ended.
		*/
		public void onSubsystemRestartOperationEnd() {
		if (mResetInternetPreference != null) {
		mResetInternetPreference.setVisible(false);
		}
		if (mAirplaneModeEnabler.isAirplaneModeOn()) {
		updateAirplaneModeMsgPreference(true /* visible */);
		}
		if (mInternetResetHelper == null) {
		mInternetResetHelper = new InternetResetHelper(getContext(), getLifecycle());
		mInternetResetHelper.setResettingPreference(mResetInternetPreference);
		mInternetResetHelper.setMobileNetworkController(mNetworkMobileProviderController);
		mInternetResetHelper.setWifiTogglePreference(
		findPreference(WifiSwitchPreferenceController.KEY));
		mInternetResetHelper.addWifiNetworkPreference(mConnectedWifiEntryPreferenceCategory);
		mInternetResetHelper.addWifiNetworkPreference(mFirstWifiEntryPreferenceCategory);
		mInternetResetHelper.addWifiNetworkPreference(mWifiEntryPreferenceCategory);
		}
		mInternetResetHelper.restart();
		}

		/**

tests/robotests/src/com/android/settings/network/NetworkProviderSettingsTest.java

+4 −40

Original line number	Diff line number	Diff line
		@@ -66,7 +66,6 @@ import com.android.settings.wifi.AddWifiNetworkPreference;
		import com.android.settings.wifi.ConnectedWifiEntryPreference;
		import com.android.settings.wifi.WifiConfigController2;
		import com.android.settings.wifi.WifiDialog2;
		import com.android.settingslib.connectivity.ConnectivitySubsystemsRecoveryManager;
		import com.android.settingslib.widget.LayoutPreference;
		import com.android.settingslib.wifi.LongPressWifiEntryPreference;
		import com.android.wifitrackerlib.WifiEntry;
		@@ -105,7 +104,7 @@ public class NetworkProviderSettingsTest {
		@Mock
		private PreferenceManager mPreferenceManager;
		@Mock
		private ConnectivitySubsystemsRecoveryManager mConnectivitySubsystemsRecoveryManager;
		private InternetResetHelper mInternetResetHelper;
		@Mock
		private Preference mAirplaneModeMsgPreference;
		@Mock
		@@ -439,49 +438,14 @@ public class NetworkProviderSettingsTest {
		}

		@Test
		public void onOptionsItemSelected_fixConnectivity_triggerSubsystemRestart() {
		doReturn(true).when(mConnectivitySubsystemsRecoveryManager).isRecoveryAvailable();
		mNetworkProviderSettings.mConnectivitySubsystemsRecoveryManager =
		mConnectivitySubsystemsRecoveryManager;
		public void onOptionsItemSelected_fixConnectivity_restartInternet() {
		mNetworkProviderSettings.mInternetResetHelper = mInternetResetHelper;
		doReturn(false).when(mNetworkProviderSettings).isPhoneOnCall();
		doReturn(NetworkProviderSettings.MENU_FIX_CONNECTIVITY).when(mMenuItem).getItemId();

		mNetworkProviderSettings.onOptionsItemSelected(mMenuItem);

		verify(mConnectivitySubsystemsRecoveryManager).triggerSubsystemRestart(any(), any());
		}

		@Test
		public void onOptionsItemSelected_fixConnectivityOnCall_neverTriggerSubsystemRestart() {
		doReturn(true).when(mConnectivitySubsystemsRecoveryManager).isRecoveryAvailable();
		mNetworkProviderSettings.mConnectivitySubsystemsRecoveryManager =
		mConnectivitySubsystemsRecoveryManager;
		doReturn(true).when(mNetworkProviderSettings).isPhoneOnCall();
		doNothing().when(mNetworkProviderSettings).showResetInternetDialog();
		doReturn(NetworkProviderSettings.MENU_FIX_CONNECTIVITY).when(mMenuItem).getItemId();

		mNetworkProviderSettings.onOptionsItemSelected(mMenuItem);

		verify(mConnectivitySubsystemsRecoveryManager, never()).triggerSubsystemRestart(any(),
		any());
		}

		@Test
		public void onSubsystemRestartOperationBegin_showResetInternetHideApmMsg() {
		mNetworkProviderSettings.onSubsystemRestartOperationBegin();

		verify(mResetInternetPreference).setVisible(true);
		verify(mAirplaneModeMsgPreference).setVisible(false);
		}

		@Test
		public void onSubsystemRestartOperationEnd_showApmMsgHideResetInternet() {
		doReturn(true).when(mAirplaneModeEnabler).isAirplaneModeOn();

		mNetworkProviderSettings.onSubsystemRestartOperationEnd();

		verify(mResetInternetPreference).setVisible(false);
		verify(mAirplaneModeMsgPreference).setVisible(true);
		verify(mInternetResetHelper).restart();
		}

		@Test

tests/unit/src/com/android/settings/network/InternetResetHelperTest.java

0 → 100644

+282 −0

File added.

Preview size limit exceeded, changes collapsed.