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

Commit de57c124 authored by changbetty's avatar changbetty
Browse files

Remove Connect to public network for Network Rating Provider 

According we remove the Network Rating Provider in ag/14675092, and the
Connect to public network item is tied to the Network Rating Provider.
So need to remove together.

Bug: 187119482
Test: Manaul test
      make RunSettingsRoboTests ROBOTEST_FILTER=ConfigureWifiSettingsTest
Change-Id: Ie8a8d5c8d9f2c5db11d6c9e6f84af7864e78814f
parent 2076ebf2

res/xml/wifi_configure_settings.xml

+0 −7
Original line number Diff line number Diff line
@@ -26,13 +26,6 @@ 
        android:summary="@string/wifi_wakeup_summary"

        settings:controller="com.android.settings.wifi.WifiWakeupPreferenceController"/>



    <SwitchPreference

        android:key="use_open_wifi_automatically"

        android:icon="@drawable/ic_open_wifi_autoconnect"

        android:title="@string/use_open_wifi_automatically_title"

        android:summary="@string/use_open_wifi_automatically_summary"

        settings:controller="com.android.settings.wifi.UseOpenWifiPreferenceController"/>



    <SwitchPreference

        android:key="notify_open_networks"

        android:title="@string/wifi_notify_open_networks"

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

+0 −8
Original line number Diff line number Diff line
@@ -42,7 +42,6 @@ public class ConfigureWifiSettings extends DashboardFragment { 
    public static final int WIFI_WAKEUP_REQUEST_CODE = 600;



    private WifiWakeupPreferenceController mWifiWakeupPreferenceController;

    private UseOpenWifiPreferenceController mUseOpenWifiPreferenceController;



    @Override

    public void onCreate(Bundle icicle) {
@@ -83,9 +82,6 @@ public class ConfigureWifiSettings extends DashboardFragment { 


        mWifiWakeupPreferenceController = use(WifiWakeupPreferenceController.class);

        mWifiWakeupPreferenceController.setFragment(this);



        mUseOpenWifiPreferenceController = use(UseOpenWifiPreferenceController.class);

        mUseOpenWifiPreferenceController.setFragment(this);

    }



    @Override
@@ -94,10 +90,6 @@ public class ConfigureWifiSettings extends DashboardFragment { 
            mWifiWakeupPreferenceController.onActivityResult(requestCode, resultCode);

            return;

        }

        if (requestCode == UseOpenWifiPreferenceController.REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY) {

            mUseOpenWifiPreferenceController.onActivityResult(requestCode, resultCode);

            return;

        }

        super.onActivityResult(requestCode, resultCode, data);

    }

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

deleted100644 → 0
+0 −192
Original line number Diff line number Diff line 
package com.android.settings.wifi;



import android.app.Activity;

import android.content.ComponentName;

import android.content.ContentResolver;

import android.content.Context;

import android.content.Intent;

import android.database.ContentObserver;

import android.net.NetworkScoreManager;

import android.net.NetworkScorerAppData;

import android.net.Uri;

import android.os.Handler;

import android.os.Looper;

import android.provider.Settings;

import android.text.TextUtils;



import androidx.fragment.app.Fragment;

import androidx.preference.Preference;

import androidx.preference.PreferenceScreen;



import com.android.settings.R;

import com.android.settings.core.PreferenceControllerMixin;

import com.android.settings.core.TogglePreferenceController;

import com.android.settingslib.core.lifecycle.LifecycleObserver;

import com.android.settingslib.core.lifecycle.events.OnPause;

import com.android.settingslib.core.lifecycle.events.OnResume;



import java.util.List;



/**

 * {@link TogglePreferenceController} that controls whether a user wants to enable the "use open

 * networks automatically" feature provided by the current network recommendation provider.

 */

public class UseOpenWifiPreferenceController extends TogglePreferenceController

        implements PreferenceControllerMixin, Preference.OnPreferenceChangeListener,

        LifecycleObserver, OnResume, OnPause {

    public static final int REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY = 400;



    private static final String KEY_USE_OPEN_WIFI_AUTOMATICALLY = "use_open_wifi_automatically";



    private final ContentResolver mContentResolver;

    private Fragment mFragment;

    private final NetworkScoreManager mNetworkScoreManager;

    private final SettingObserver mSettingObserver;



    private Preference mPreference;

    private ComponentName mEnableUseWifiComponentName;

    private boolean mDoFeatureSupportedScorersExist;



    public UseOpenWifiPreferenceController(Context context) {

        super(context, KEY_USE_OPEN_WIFI_AUTOMATICALLY);

        mContentResolver = context.getContentResolver();

        mNetworkScoreManager =

                (NetworkScoreManager) context.getSystemService(Context.NETWORK_SCORE_SERVICE);

        mSettingObserver = new SettingObserver();

        updateEnableUseWifiComponentName();

        checkForFeatureSupportedScorers();

    }



    public void setFragment(Fragment hostFragment) {

        mFragment = hostFragment;

    }



    private void updateEnableUseWifiComponentName() {

        NetworkScorerAppData appData = mNetworkScoreManager.getActiveScorer();

        mEnableUseWifiComponentName =

                appData == null ? null : appData.getEnableUseOpenWifiActivity();

    }



    private void checkForFeatureSupportedScorers() {

        if (mEnableUseWifiComponentName != null) {

            mDoFeatureSupportedScorersExist = true;

            return;

        }

        List<NetworkScorerAppData> scorers = mNetworkScoreManager.getAllValidScorers();

        for (NetworkScorerAppData scorer : scorers) {

            if (scorer.getEnableUseOpenWifiActivity() != null) {

                mDoFeatureSupportedScorersExist = true;

                return;

            }

        }

        mDoFeatureSupportedScorersExist = false;

    }



    @Override

    public void displayPreference(PreferenceScreen screen) {

        super.displayPreference(screen);

        mPreference = screen.findPreference(getPreferenceKey());

    }



    @Override

    public void onResume() {

        mSettingObserver.register(mContentResolver);

    }



    @Override

    public void onPause() {

        mSettingObserver.unregister(mContentResolver);

    }



    @Override

    public int getAvailabilityStatus() {

        // It is possible that mEnableUseWifiComponentName is no longer enabled by

        // USE_OPEN_WIFI_PACKAGE. So update this component to reflect correct availability.

        updateEnableUseWifiComponentName();

        checkForFeatureSupportedScorers();

        return mDoFeatureSupportedScorersExist ? AVAILABLE : CONDITIONALLY_UNAVAILABLE;

    }



    @Override

    public void updateState(Preference preference) {

        super.updateState(preference);



        final boolean isScorerSet = mNetworkScoreManager.getActiveScorerPackage() != null;

        final boolean doesActiveScorerSupportFeature = mEnableUseWifiComponentName != null;



        preference.setEnabled(isScorerSet && doesActiveScorerSupportFeature);

        if (!isScorerSet) {

            preference.setSummary(R.string.use_open_wifi_automatically_summary_scoring_disabled);

        } else if (!doesActiveScorerSupportFeature) {

            preference.setSummary(

                    R.string.use_open_wifi_automatically_summary_scorer_unsupported_disabled);

        } else {

            preference.setSummary(R.string.use_open_wifi_automatically_summary);

        }

    }



    @Override

    public boolean isChecked() {

        final String enabledUseOpenWifiPackage = Settings.Global.getString(mContentResolver,

                Settings.Global.USE_OPEN_WIFI_PACKAGE);

        final String currentUseOpenWifiPackage = mEnableUseWifiComponentName == null

                ? null : mEnableUseWifiComponentName.getPackageName();

        return TextUtils.equals(enabledUseOpenWifiPackage, currentUseOpenWifiPackage);

    }



    @Override

    public boolean setChecked(boolean isChecked) {

        if (isChecked) {

            if (mFragment == null) {

                throw new IllegalStateException("No fragment to start activity");

            }



            final Intent intent = new Intent(NetworkScoreManager.ACTION_CUSTOM_ENABLE);

            intent.setComponent(mEnableUseWifiComponentName);

            mFragment.startActivityForResult(intent, REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY);

            return false; // Updating state is done in onActivityResult.

        } else {

            Settings.Global.putString(mContentResolver, Settings.Global.USE_OPEN_WIFI_PACKAGE, "");

            return true;

        }

    }



    public boolean onActivityResult(int requestCode, int resultCode) {

        if (requestCode != REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY) {

            return false;

        }



        if (resultCode == Activity.RESULT_OK) {

            Settings.Global.putString(mContentResolver, Settings.Global.USE_OPEN_WIFI_PACKAGE,

                    mEnableUseWifiComponentName.getPackageName());

        }

        return true;

    }



    class SettingObserver extends ContentObserver {

        private final Uri NETWORK_RECOMMENDATIONS_ENABLED_URI =

                Settings.Global.getUriFor(Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED);



        public SettingObserver() {

            super(new Handler(Looper.getMainLooper()));

        }



        public void register(ContentResolver cr) {

            cr.registerContentObserver(NETWORK_RECOMMENDATIONS_ENABLED_URI, false, this);

            onChange(true /* selfChange */, NETWORK_RECOMMENDATIONS_ENABLED_URI);

        }



        public void unregister(ContentResolver cr) {

            cr.unregisterContentObserver(this);

        }



        @Override

        public void onChange(boolean selfChange, Uri uri) {

            super.onChange(selfChange, uri);

            if (NETWORK_RECOMMENDATIONS_ENABLED_URI.equals(uri)) {

                updateEnableUseWifiComponentName();

                updateState(mPreference);

            }

        }

    }

}

tests/robotests/src/com/android/settings/wifi/UseOpenWifiPreferenceControllerTest.java

deleted100644 → 0
+0 −266
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 static android.content.Context.NETWORK_SCORE_SERVICE;

import static android.provider.Settings.Global.USE_OPEN_WIFI_PACKAGE;



import static com.android.settings.wifi.UseOpenWifiPreferenceController

        .REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY;



import static com.google.common.truth.Truth.assertThat;



import static org.mockito.ArgumentMatchers.eq;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;



import android.annotation.NonNull;

import android.app.Activity;

import android.content.ComponentName;

import android.content.Context;

import android.content.Intent;

import android.net.NetworkScoreManager;

import android.net.NetworkScorerAppData;

import android.provider.Settings;



import androidx.fragment.app.Fragment;

import androidx.preference.SwitchPreference;



import com.android.settings.R;



import com.google.common.collect.Lists;



import org.junit.Before;

import org.junit.BeforeClass;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.ArgumentCaptor;

import org.mockito.Captor;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;

import org.robolectric.RobolectricTestRunner;

import org.robolectric.RuntimeEnvironment;

import org.robolectric.shadows.ShadowApplication;



import java.util.ArrayList;

import java.util.List;



@RunWith(RobolectricTestRunner.class)

public class UseOpenWifiPreferenceControllerTest {



    private static ComponentName sEnableActivityComponent;

    private static NetworkScorerAppData sAppData;

    private static NetworkScorerAppData sAppDataNoActivity;



    @BeforeClass

    public static void beforeClass() {

        sEnableActivityComponent = new ComponentName("package", "activityClass");

        sAppData = new NetworkScorerAppData(0, null, null, sEnableActivityComponent, null);

        sAppDataNoActivity = new NetworkScorerAppData(0, null, null, null, null);

    }



    @Mock

    private Fragment mFragment;

    @Mock

    private NetworkScoreManager mNetworkScoreManager;

    @Captor

    private ArgumentCaptor<Intent> mIntentCaptor;

    private Context mContext;

    private UseOpenWifiPreferenceController mController;



    @Before

    public void setUp() {

        MockitoAnnotations.initMocks(this);



        mContext = RuntimeEnvironment.application;

        ShadowApplication.getInstance()

                .setSystemService(NETWORK_SCORE_SERVICE, mNetworkScoreManager);

    }



    private void createController() {

        mController = new UseOpenWifiPreferenceController(mContext);

        mController.setFragment(mFragment);

    }



    /**

     * Sets the scorers.

     *

     * @param scorers list of scorers returned by {@link NetworkScoreManager#getAllValidScorers()}.

     *                First scorer in the list is the active scorer.

     */

    private void setupScorers(@NonNull List<NetworkScorerAppData> scorers) {

        when(mNetworkScoreManager.getActiveScorerPackage())

                .thenReturn(sEnableActivityComponent.getPackageName());

        when(mNetworkScoreManager.getAllValidScorers()).thenReturn(scorers);

        when(mNetworkScoreManager.getActiveScorer()).thenReturn(scorers.get(0));

    }



    @Test

    public void testIsAvailable_returnsFalseWhenNoScorerSet() {

        createController();



        assertThat(mController.isAvailable()).isFalse();

    }



    @Test

    public void testIsAvailable_returnsFalseWhenScorersNotSupported() {

        setupScorers(Lists.newArrayList(sAppDataNoActivity));

        createController();



        assertThat(mController.isAvailable()).isFalse();

    }



    @Test

    public void testIsAvailable_returnsTrueIfActiveScorerSupported() {

        setupScorers(Lists.newArrayList(sAppData, sAppDataNoActivity));

        createController();



        assertThat(mController.isAvailable()).isTrue();

    }



    @Test

    public void testIsAvailable_returnsTrueIfNonActiveScorerSupported() {

        setupScorers(Lists.newArrayList(sAppDataNoActivity, sAppData));

        when(mNetworkScoreManager.getActiveScorer()).thenReturn(sAppDataNoActivity);

        createController();



        assertThat(mController.isAvailable()).isTrue();

    }



    @Test

    public void isAvailable_disableUseOpenWifiComponentBetweenCalls_returnsTrueThenReturnsFalse() {

        setupScorers(Lists.newArrayList(sAppData));

        createController();



        assertThat(mController.isAvailable()).isTrue();



        // Update NetworkScorerAppData so that it no longer has openWifiActivity.

        setupScorers(Lists.newArrayList(sAppDataNoActivity));



        assertThat(mController.isAvailable()).isFalse();

    }



    @Test

    public void setChecked_withTrue_enableShouldStartEnableActivity() {

        setupScorers(Lists.newArrayList(sAppData, sAppDataNoActivity));

        createController();



        mController.setChecked(true);



        verify(mFragment).startActivityForResult(mIntentCaptor.capture(),

                eq(REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY));

        final Intent activityIntent = mIntentCaptor.getValue();

        assertThat(activityIntent.getComponent()).isEqualTo(sEnableActivityComponent);

        assertThat(activityIntent.getAction()).isEqualTo(NetworkScoreManager.ACTION_CUSTOM_ENABLE);

    }



    @Test

    public void setChecked_withFalse_disableShouldUpdateSetting() {

        setupScorers(Lists.newArrayList(sAppData, sAppDataNoActivity));

        Settings.Global.putString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE,

                sEnableActivityComponent.getPackageName());

        createController();



        mController.setChecked(false);



        assertThat(Settings.Global.getString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE))

                .isEqualTo("");

    }



    @Test

    public void onActivityResult_nonmatchingRequestCode_shouldDoNothing() {

        setupScorers(Lists.newArrayList(sAppData, sAppDataNoActivity));

        createController();



        assertThat(mController.onActivityResult(234 /* requestCode */, Activity.RESULT_OK))

                .isEqualTo(false);

        assertThat(Settings.Global.getString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE))

                .isNull();

    }



    @Test

    public void onActivityResult_matchingRequestCode_nonOkResult_shouldDoNothing() {

        setupScorers(Lists.newArrayList(sAppData, sAppDataNoActivity));

        createController();



        assertThat(mController

                .onActivityResult(REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY, Activity.RESULT_CANCELED))

                .isEqualTo(true);

        assertThat(Settings.Global.getString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE))

                .isNull();

    }



    @Test

    public void onActivityResult_matchingRequestCode_okResult_updatesSetting() {

        setupScorers(Lists.newArrayList(sAppData, sAppDataNoActivity));

        createController();



        assertThat(mController

                .onActivityResult(REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY, Activity.RESULT_OK))

                .isEqualTo(true);

        assertThat(Settings.Global.getString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE))

                .isEqualTo(sEnableActivityComponent.getPackageName());

    }



    @Test

    public void updateState_noEnableActivity_preferenceDisabled_summaryChanged() {

        setupScorers(Lists.newArrayList(sAppDataNoActivity));

        createController();



        final SwitchPreference preference = mock(SwitchPreference.class);

        Settings.Global.putString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE,

                sEnableActivityComponent.getPackageName());



        mController.updateState(preference);



        verify(preference).setChecked(false);

        verify(preference).setSummary(

                R.string.use_open_wifi_automatically_summary_scorer_unsupported_disabled);

    }



    @Test

    public void updateState_noScorer_preferenceDisabled_summaryChanged() {

        when(mNetworkScoreManager.getAllValidScorers()).thenReturn(new ArrayList<>());

        createController();



        final SwitchPreference preference = mock(SwitchPreference.class);

        Settings.Global.putString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE,

                sEnableActivityComponent.getPackageName());



        mController.updateState(preference);



        verify(preference).setChecked(false);

        verify(preference).setSummary(

                R.string.use_open_wifi_automatically_summary_scoring_disabled);

    }



    @Test

    public void updateState_enableActivityExists_preferenceEnabled() {

        setupScorers(Lists.newArrayList(sAppData, sAppDataNoActivity));

        createController();



        final SwitchPreference preference = mock(SwitchPreference.class);

        Settings.Global.putString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE,

                sEnableActivityComponent.getPackageName());



        mController.updateState(preference);



        verify(preference).setChecked(true);

        verify(preference).setSummary(R.string.use_open_wifi_automatically_summary);

    }

}