Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7a45b33c authored by Weng Su's avatar Weng Su
Browse files

[Provider Model] Hide Connectivity Subsystems when recovering 

- Hide Carrier Network

- Hide Wi-Fi toggle

- Hide all of Wi-Fi Networks

Bug: 186590805
Test: manual test
atest InternetResetHelperTest
atest NetworkMobileProviderControllerTest
make RunSettingsRoboTests ROBOTEST_FILTER=NetworkProviderSettingsTest

Change-Id: Ib8462f890847d14bfc6ef533d1147822fd797a13
parent 416a24d8

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.