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

Commit fc8e8991 authored by Chaohui Wang's avatar Chaohui Wang
Browse files

Clean up InternetPreferenceController 

And also the flag.

Bug: 339884322
Flag: com.android.settings.flags.internet_preference_controller_v2
Test: manual - Network & internet
Change-Id: Icb3427f6624db0442c05f5e149dbe522d1497e83
parent bb8199e8

aconfig/settings_experience_flag_declarations.aconfig

+0 −10
Original line number Diff line number Diff line
@@ -17,13 +17,3 @@ flag { 
        purpose: PURPOSE_BUGFIX

    }

}
 


flag {

    name: "internet_preference_controller_v2"

    namespace: "settings_experience"

    description: "New InternetPreferenceControllerV2."

    bug: "339884322"

    metadata {

        purpose: PURPOSE_BUGFIX

    }

}

res/xml/network_provider_internet.xml

+2 −1
Original line number Diff line number Diff line
@@ -29,7 +29,8 @@ 
        android:order="-30"

        settings:allowDividerAbove="true"

        settings:keywords="@string/keywords_internet"

        settings:useAdminDisabledSummary="true" />

        settings:useAdminDisabledSummary="true"

        settings:controller="com.android.settings.network.InternetPreferenceControllerV2" />



    <com.android.settingslib.RestrictedPreference

        android:key="calls_and_sms"

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

deleted100644 → 0
+0 −316
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2020 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 static androidx.lifecycle.Lifecycle.Event.ON_PAUSE;

import static androidx.lifecycle.Lifecycle.Event.ON_RESUME;



import static com.android.settings.network.InternetUpdater.INTERNET_CELLULAR;

import static com.android.settings.network.InternetUpdater.INTERNET_ETHERNET;

import static com.android.settings.network.InternetUpdater.INTERNET_NETWORKS_AVAILABLE;

import static com.android.settings.network.InternetUpdater.INTERNET_OFF;

import static com.android.settings.network.InternetUpdater.INTERNET_WIFI;

import static com.android.settingslib.wifi.WifiUtils.getHotspotIconResource;



import android.content.Context;

import android.graphics.drawable.Drawable;

import android.telephony.SubscriptionManager;



import androidx.annotation.IdRes;

import androidx.annotation.VisibleForTesting;

import androidx.lifecycle.Lifecycle;

import androidx.lifecycle.LifecycleObserver;

import androidx.lifecycle.LifecycleOwner;

import androidx.lifecycle.OnLifecycleEvent;

import androidx.preference.Preference;

import androidx.preference.PreferenceScreen;



import com.android.settings.R;

import com.android.settings.widget.SummaryUpdater;

import com.android.settings.wifi.WifiPickerTrackerHelper;

import com.android.settings.wifi.WifiSummaryUpdater;

import com.android.settings.wifi.repository.SharedConnectivityRepository;

import com.android.settingslib.Utils;

import com.android.settingslib.core.AbstractPreferenceController;

import com.android.settingslib.mobile.dataservice.SubscriptionInfoEntity;

import com.android.settingslib.utils.ThreadUtils;

import com.android.wifitrackerlib.HotspotNetworkEntry;

import com.android.wifitrackerlib.WifiEntry;

import com.android.wifitrackerlib.WifiPickerTracker;



import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;



/**

 * PreferenceController to update the internet state.

 */

public class InternetPreferenceController extends AbstractPreferenceController implements

        LifecycleObserver, SummaryUpdater.OnSummaryChangeListener,

        InternetUpdater.InternetChangeListener, MobileNetworkRepository.MobileNetworkCallback,

        DefaultSubscriptionReceiver.DefaultSubscriptionListener,

        WifiPickerTracker.WifiPickerTrackerCallback {



    public static final String KEY = "internet_settings";



    private Preference mPreference;

    @VisibleForTesting

    WifiSummaryUpdater mSummaryHelper;

    private InternetUpdater mInternetUpdater;

    private @InternetUpdater.InternetType int mInternetType;

    private LifecycleOwner mLifecycleOwner;

    private MobileNetworkRepository mMobileNetworkRepository;

    private List<SubscriptionInfoEntity> mSubInfoEntityList = new ArrayList<>();

    private int mDefaultDataSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;

    private DefaultSubscriptionReceiver mDataSubscriptionChangedReceiver;

    private boolean mIsHotspotNetworkEnabled = SharedConnectivityRepository.isDeviceConfigEnabled();

    @VisibleForTesting

    WifiPickerTrackerHelper mWifiPickerTrackerHelper;



    @VisibleForTesting

    static Map<Integer, Integer> sIconMap = new HashMap<>();

    static {

        sIconMap.put(INTERNET_OFF, R.drawable.ic_no_internet_unavailable);

        sIconMap.put(INTERNET_NETWORKS_AVAILABLE, R.drawable.ic_no_internet_available);

        sIconMap.put(INTERNET_WIFI, R.drawable.ic_wifi_signal_4);

        sIconMap.put(INTERNET_CELLULAR, R.drawable.ic_network_cell);

        sIconMap.put(INTERNET_ETHERNET, R.drawable.ic_settings_ethernet);

    }



    private static Map<Integer, Integer> sSummaryMap = new HashMap<>();

    static {

        sSummaryMap.put(INTERNET_OFF, R.string.condition_airplane_title);

        sSummaryMap.put(INTERNET_NETWORKS_AVAILABLE, R.string.networks_available);

        sSummaryMap.put(INTERNET_WIFI, 0);

        sSummaryMap.put(INTERNET_CELLULAR, 0);

        sSummaryMap.put(INTERNET_ETHERNET, R.string.to_switch_networks_disconnect_ethernet);

    }



    public InternetPreferenceController(Context context, Lifecycle lifecycle,

            LifecycleOwner lifecycleOwner) {

        super(context);

        if (lifecycle == null) {

            throw new IllegalArgumentException("Lifecycle must be set");

        }

        mSummaryHelper = new WifiSummaryUpdater(mContext, this);

        mInternetUpdater = new InternetUpdater(context, lifecycle, this);

        mInternetType = mInternetUpdater.getInternetType();

        mLifecycleOwner = lifecycleOwner;

        mMobileNetworkRepository = MobileNetworkRepository.getInstance(context);

        mDataSubscriptionChangedReceiver = new DefaultSubscriptionReceiver(context, this);

        if (mIsHotspotNetworkEnabled) {

            mWifiPickerTrackerHelper = new WifiPickerTrackerHelper(lifecycle, context, this);

        }

        lifecycle.addObserver(this);

    }



    @Override

    public void displayPreference(PreferenceScreen screen) {

        super.displayPreference(screen);

        mPreference = screen.findPreference(KEY);

    }



    private void drawIcon(int iconResId) {

        Drawable drawable = mContext.getDrawable(iconResId);

        if (drawable != null) {

            drawable.setTintList(Utils.getColorAttr(mContext, android.R.attr.colorControlNormal));

            mPreference.setIcon(drawable);

        }

    }



    @Override

    public void updateState(Preference preference) {

        if (mPreference == null) {

            return;

        }



        if (mInternetType == INTERNET_WIFI && updateHotspotNetwork()) {

            return;

        }



        final @IdRes int icon = sIconMap.get(mInternetType);

        if (icon != 0) {

            drawIcon(icon);

        }



        if (mInternetType == INTERNET_WIFI) {

            mPreference.setSummary(mSummaryHelper.getSummary());

            return;

        }



        if (mInternetType == INTERNET_CELLULAR) {

            updateCellularSummary();

            return;

        }



        final @IdRes int summary = sSummaryMap.get(mInternetType);

        if (summary != 0) {

            mPreference.setSummary(summary);

        }

    }



    @VisibleForTesting

    boolean updateHotspotNetwork() {

        if (mWifiPickerTrackerHelper == null) {

            return false;

        }

        WifiEntry entry = mWifiPickerTrackerHelper.getWifiPickerTracker().getConnectedWifiEntry();

        if (!(entry instanceof HotspotNetworkEntry)) {

            return false;

        }

        drawIcon(getHotspotIconResource(((HotspotNetworkEntry) entry).getDeviceType()));

        mPreference.setSummary(((HotspotNetworkEntry) entry).getAlternateSummary());

        return true;

    }



    @Override

    public boolean isAvailable() {

        return mContext.getResources().getBoolean(R.bool.config_show_internet_settings);

    }



    @Override

    public String getPreferenceKey() {

        return KEY;

    }



    /** @OnLifecycleEvent(ON_RESUME) */

    @OnLifecycleEvent(ON_RESUME)

    public void onResume() {

        mMobileNetworkRepository.addRegister(mLifecycleOwner, this,

                SubscriptionManager.INVALID_SUBSCRIPTION_ID);

        mMobileNetworkRepository.updateEntity();

        mSummaryHelper.register(true);

        mDataSubscriptionChangedReceiver.registerReceiver();

        mDefaultDataSubId = SubscriptionManager.getDefaultDataSubscriptionId();

    }



    /** @OnLifecycleEvent(ON_PAUSE) */

    @OnLifecycleEvent(ON_PAUSE)

    public void onPause() {

        mMobileNetworkRepository.removeRegister(this);

        mSummaryHelper.register(false);

        mDataSubscriptionChangedReceiver.unRegisterReceiver();

    }



    /**

     * Called when internet type is changed.

     *

     * @param internetType the internet type

     */

    @Override

    public void onInternetTypeChanged(@InternetUpdater.InternetType int internetType) {

        final boolean needUpdate = (internetType != mInternetType);

        mInternetType = internetType;

        if (needUpdate) {

            ThreadUtils.postOnMainThread(() -> {

                updateState(mPreference);

            });

        }

    }



    /**

     * Called when airplane mode state is changed.

     */

    @Override

    public void onAirplaneModeChanged(boolean isAirplaneModeOn) {

        ThreadUtils.postOnMainThread(() -> {

            updateState(mPreference);

        });

    }



    @Override

    public void onSummaryChanged(String summary) {

        if (mInternetType == INTERNET_WIFI) {

            updateState(mPreference);

        }

    }



    @VisibleForTesting

    void updateCellularSummary() {

        CharSequence summary = null;

        SubscriptionInfoEntity activeSubInfo = null;

        SubscriptionInfoEntity defaultSubInfo = null;



        for (SubscriptionInfoEntity subInfo : getSubscriptionInfoList()) {

            if (subInfo.isActiveDataSubscriptionId) {

                activeSubInfo = subInfo;

            }

            if (subInfo.getSubId() == getDefaultDataSubscriptionId()) {

                defaultSubInfo = subInfo;

            }

        }

        if (activeSubInfo == null || defaultSubInfo == null) {

            return;

        }

        activeSubInfo = activeSubInfo.isSubscriptionVisible ? activeSubInfo : defaultSubInfo;



        if (activeSubInfo.equals(defaultSubInfo)) {

            // DDS is active

            summary = activeSubInfo.uniqueName;

        } else {

            summary = mContext.getString(

                    R.string.mobile_data_temp_using, activeSubInfo.uniqueName);

        }



        mPreference.setSummary(summary);

    }



    @VisibleForTesting

    protected List<SubscriptionInfoEntity> getSubscriptionInfoList() {

        return mSubInfoEntityList;

    }



    @VisibleForTesting

    protected int getDefaultDataSubscriptionId() {

        return mDefaultDataSubId;

    }



    @Override

    public void onAvailableSubInfoChanged(List<SubscriptionInfoEntity> subInfoEntityList) {

        mSubInfoEntityList = subInfoEntityList;

        updateState(mPreference);

    }



    @Override

    public void onDefaultDataChanged(int defaultDataSubId) {

        mDefaultDataSubId = defaultDataSubId;

        updateState(mPreference);

    }



    @Override

    public void onWifiEntriesChanged() {

        if (mInternetType == INTERNET_WIFI) {

            updateState(mPreference);

        }

    }



    @Override

    public void onWifiStateChanged() {

        // Do nothing

    }



    @Override

    public void onNumSavedNetworksChanged() {

        // Do nothing

    }



    @Override

    public void onNumSavedSubscriptionsChanged() {

        // Do nothing

    }

}

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

+0 −9
Original line number Diff line number Diff line
@@ -25,7 +25,6 @@ import com.android.settings.R; 
import com.android.settings.SettingsDumpService;

import com.android.settings.core.OnActivityResultListener;

import com.android.settings.dashboard.DashboardFragment;

import com.android.settings.flags.Flags;

import com.android.settings.search.BaseSearchIndexProvider;

import com.android.settingslib.core.AbstractPreferenceController;

import com.android.settingslib.core.lifecycle.Lifecycle;
@@ -90,14 +89,6 @@ public class NetworkDashboardFragment extends DashboardFragment implements 


        controllers.add(new MobileNetworkSummaryController(context, lifecycle, lifecycleOwner));

        controllers.add(vpnPreferenceController);



        if (Flags.internetPreferenceControllerV2()) {

            controllers.add(

                    new InternetPreferenceControllerV2(context, InternetPreferenceController.KEY));

        } else {

            controllers.add(new InternetPreferenceController(context, lifecycle, lifecycleOwner));

        }



        controllers.add(privateDnsPreferenceController);



        // Start SettingsDumpService after the MobileNetworkRepository is created.

src/com/android/settings/wifi/WifiSummaryUpdater.java

deleted100644 → 0
+0 −110
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 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;



import android.content.BroadcastReceiver;

import android.content.Context;

import android.content.Intent;

import android.content.IntentFilter;

import android.net.ConnectivityManager;

import android.net.NetworkScoreManager;

import android.net.wifi.WifiInfo;

import android.net.wifi.WifiManager;

import android.text.TextUtils;



import androidx.annotation.VisibleForTesting;



import com.android.settings.R;

import com.android.settings.widget.SummaryUpdater;

import com.android.settingslib.wifi.WifiStatusTracker;



/**

 * Helper class that listeners to wifi callback and notify client when there is update in

 * wifi summary info.

 */

public class WifiSummaryUpdater extends SummaryUpdater {



    private final WifiStatusTracker mWifiTracker;

    private final BroadcastReceiver mReceiver;



    private static final IntentFilter INTENT_FILTER;

    static {

        INTENT_FILTER = new IntentFilter();

        INTENT_FILTER.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);

        INTENT_FILTER.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);

        INTENT_FILTER.addAction(WifiManager.RSSI_CHANGED_ACTION);

    }



    public WifiSummaryUpdater(Context context, OnSummaryChangeListener listener) {

        this(context, listener, null);

    }



    @VisibleForTesting

    public WifiSummaryUpdater(Context context, OnSummaryChangeListener listener,

        WifiStatusTracker wifiTracker) {

        super(context, listener);

        mWifiTracker = wifiTracker != null ? wifiTracker :

                new WifiStatusTracker(context, context.getSystemService(WifiManager.class),

                context.getSystemService(NetworkScoreManager.class),

                context.getSystemService(ConnectivityManager.class),

                        this::notifyChangeIfNeeded);

        mReceiver = new BroadcastReceiver() {

            @Override

            public void onReceive(Context context, Intent intent) {

                mWifiTracker.handleBroadcast(intent);

                notifyChangeIfNeeded();

            }

        };

    }



    @Override

    public void register(boolean register) {

        if (register) {

            mWifiTracker.fetchInitialState();

            notifyChangeIfNeeded();

            mContext.registerReceiver(mReceiver, INTENT_FILTER,

                    Context.RECEIVER_EXPORTED_UNAUDITED);

        } else {

            mContext.unregisterReceiver(mReceiver);

        }

        mWifiTracker.setListening(register);

    }



    @Override

    public String getSummary() {

        if (!mWifiTracker.enabled) {

            return mContext.getString(R.string.switch_off_text);

        }

        if (!mWifiTracker.connected) {

            return mContext.getString(R.string.disconnected);

        }

        String ssid = WifiInfo.sanitizeSsid(mWifiTracker.ssid);

        if (TextUtils.isEmpty(mWifiTracker.statusLabel)) {

            return ssid;

        }

        return mContext.getResources().getString(

                com.android.settingslib.R.string.preference_summary_default_combination,

                ssid, mWifiTracker.statusLabel);

    }



    /**

     * return true if Wi-Fi connected.

     */

    public boolean isWifiConnected() {

        return mWifiTracker.connected;

    }

}