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

Commit b747be07 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge changes from topic 'onarevert' into oc-dev 

* changes:
  Update "Open networks available" setting.
  Revert "Update "Open networks available" toggle to instead open notification channel preferences."
parents b38c1e53 a5cf6fbf

res/xml/wifi_configure_settings.xml

+3 −2
Original line number Diff line number Diff line
@@ -31,10 +31,11 @@ 
        android:title="@string/use_open_wifi_automatically_title"

        android:summary="@string/use_open_wifi_automatically_summary" />



    <Preference

    <SwitchPreference

            android:key="notify_open_networks"

            android:title="@string/wifi_notify_open_networks"

            android:icon="@drawable/ic_open_wifi_notifications"/>

            android:icon="@drawable/ic_open_wifi_notifications"

            android:summary="@string/wifi_notify_open_networks_summary" />



    <SwitchPreference

        android:key="wifi_cellular_data_fallback"

src/com/android/settings/utils/NotificationChannelHelper.java

deleted100644 → 0
+0 −64
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.utils;



import android.app.INotificationManager;

import android.app.NotificationChannel;

import android.os.RemoteException;



/**

 * Wrappers around methods in {@link INotificationManager} and {@link NotificationChannel} to

 * facilitate unit testing.

 *

 * TODO: delete this class once robolectric supports Android O

 */

public class NotificationChannelHelper {

    private INotificationManager mNotificationManager;



    public NotificationChannelHelper(

            INotificationManager notificationManager) {

        mNotificationManager = notificationManager;

    }



    /**

     * Returns the notification channel settings for a app given its package name, user id, and

     * channel id.

     */

    public NotificationChannelWrapper getNotificationChannelForPackage(String pkg, int uid,

            String channelId, boolean includeDeleted) throws RemoteException {

        NotificationChannel channel = mNotificationManager.getNotificationChannelForPackage(

                pkg, uid, channelId, includeDeleted);

        return channel == null ? null : new NotificationChannelWrapper(channel);

    }



    /**

     * Wrapper around {@link NotificationChannel} to facilitate unit testing.

     *

     * TODO: delete this class once robolectric supports Android O

     */

    public class NotificationChannelWrapper {

        private NotificationChannel mChannel;



        public NotificationChannelWrapper(NotificationChannel channel) {

            mChannel = channel;

        }



        public int getImportance() {

            return mChannel.getImportance();

        }

    }

}

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

+6 −9
Original line number Diff line number Diff line
@@ -15,13 +15,15 @@ 
 */

package com.android.settings.wifi;



import android.app.INotificationManager;

import static android.content.Context.NETWORK_SCORE_SERVICE;

import static android.content.Context.WIFI_SERVICE;



import android.content.Context;

import android.content.Intent;

import android.net.NetworkScoreManager;

import android.net.wifi.WifiManager;

import android.os.ServiceManager;

import android.provider.SearchIndexableResource;



import com.android.internal.logging.nano.MetricsProto.MetricsEvent;

import com.android.settings.R;

import com.android.settings.SettingsActivity;
@@ -32,7 +34,6 @@ import com.android.settings.network.NetworkScorerPickerPreferenceController; 
import com.android.settings.network.WifiCallingPreferenceController;

import com.android.settings.search.BaseSearchIndexProvider;

import com.android.settings.search.Indexable;

import com.android.settings.utils.NotificationChannelHelper;

import com.android.settings.wifi.p2p.WifiP2pPreferenceController;



import java.util.ArrayList;
@@ -72,18 +73,14 @@ public class ConfigureWifiSettings extends DashboardFragment { 
    protected List<PreferenceController> getPreferenceControllers(Context context) {

        final NetworkScoreManagerWrapper networkScoreManagerWrapper =

                new NetworkScoreManagerWrapper(context.getSystemService(NetworkScoreManager.class));

        final NotificationChannelHelper notificationChannelHelper =

                new NotificationChannelHelper(INotificationManager.Stub.asInterface(

                        ServiceManager.getService(Context.NOTIFICATION_SERVICE)));

        final WifiManager wifiManager = context.getSystemService(WifiManager.class);

        mUseOpenWifiPreferenceController = new UseOpenWifiPreferenceController(context, this,

                networkScoreManagerWrapper, getLifecycle());

        final WifiManager wifiManager = (WifiManager) getSystemService(WIFI_SERVICE);

        final List<PreferenceController> controllers = new ArrayList<>();

        controllers.add(new WifiWakeupPreferenceController(context, getLifecycle()));

        controllers.add(new NetworkScorerPickerPreferenceController(context,

                networkScoreManagerWrapper));

        controllers.add(new NotifyOpenNetworksPreferenceController(context,

                networkScoreManagerWrapper, notificationChannelHelper, getPackageManager()));

        controllers.add(new NotifyOpenNetworksPreferenceController(context, getLifecycle()));

        controllers.add(mUseOpenWifiPreferenceController);

        controllers.add(new WifiSleepPolicyPreferenceController(context));

        controllers.add(new WifiInfoPreferenceController(context, getLifecycle(), wifiManager));

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

+73 −63
Original line number Diff line number Diff line
@@ -16,56 +16,61 @@ 


package com.android.settings.wifi;



import android.app.NotificationChannel;

import android.app.NotificationManager;

import android.content.ContentResolver;

import android.content.Context;

import android.content.Intent;

import android.content.pm.PackageManager;

import android.net.NetworkScorerAppData;

import android.os.RemoteException;

import android.database.ContentObserver;

import android.net.Uri;

import android.os.Handler;

import android.provider.Settings;

import android.support.annotation.Nullable;

import android.support.v14.preference.SwitchPreference;

import android.support.v7.preference.Preference;

import android.support.v7.preference.PreferenceScreen;

import android.text.TextUtils;

import android.util.Log;

import com.android.settings.R;



import com.android.settings.core.PreferenceController;

import com.android.settings.network.NetworkScoreManagerWrapper;

import com.android.settings.utils.NotificationChannelHelper;

import com.android.settings.utils.NotificationChannelHelper.NotificationChannelWrapper;

import com.android.settings.core.lifecycle.Lifecycle;

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

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

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



/**

 * {@link PreferenceController} that shows whether we should notify user when open network is

 * available. The preference links to {@link NotificationChannel} settings.

 * {@link PreferenceController} that controls whether we should notify user when open network is

 * available.

 */

public class NotifyOpenNetworksPreferenceController extends PreferenceController {

public class NotifyOpenNetworksPreferenceController extends PreferenceController implements

        LifecycleObserver, OnResume, OnPause {



    private static final String TAG = "OpenNetworks";

    private static final String KEY_NOTIFY_OPEN_NETWORKS = "notify_open_networks";

    private SettingObserver mSettingObserver;



    private NetworkScoreManagerWrapper mNetworkScoreManager;

    private NotificationChannelHelper mNotificationChannelHelper;

    private PackageManager mPackageManager;



    public NotifyOpenNetworksPreferenceController(

            Context context,

            NetworkScoreManagerWrapper networkScoreManager,

            NotificationChannelHelper notificationChannelHelper,

            PackageManager packageManager) {

    public NotifyOpenNetworksPreferenceController(Context context, Lifecycle lifecycle) {

        super(context);

        mNetworkScoreManager = networkScoreManager;

        mNotificationChannelHelper = notificationChannelHelper;

        mPackageManager = packageManager;

        lifecycle.addObserver(this);

    }



    @Override

    public String getPreferenceKey() {

        return KEY_NOTIFY_OPEN_NETWORKS;

    public void displayPreference(PreferenceScreen screen) {

        super.displayPreference(screen);

        mSettingObserver = new SettingObserver(screen.findPreference(KEY_NOTIFY_OPEN_NETWORKS));

    }



    @Override

    public void onResume() {

        if (mSettingObserver != null) {

            mSettingObserver.register(mContext.getContentResolver(), true /* register */);

        }

    }



    @Override

    public void onPause() {

        if (mSettingObserver != null) {

            mSettingObserver.register(mContext.getContentResolver(), false /* register */);

        }

    }



    @Override

    public boolean isAvailable() {

        return getNotificationChannel() != null;

        return true;

    }



    @Override
@@ -73,50 +78,55 @@ public class NotifyOpenNetworksPreferenceController extends PreferenceController 
        if (!TextUtils.equals(preference.getKey(), KEY_NOTIFY_OPEN_NETWORKS)) {

            return false;

        }

        NetworkScorerAppData scorer = mNetworkScoreManager.getActiveScorer();

        if (scorer == null) {

        if (!(preference instanceof SwitchPreference)) {

            return false;

        }



        Intent intent = new Intent(Settings.ACTION_CHANNEL_NOTIFICATION_SETTINGS);

        intent.putExtra(Settings.EXTRA_CHANNEL_ID,

                scorer.getNetworkAvailableNotificationChannelId());

        intent.putExtra(Settings.EXTRA_APP_PACKAGE, scorer.getRecommendationServicePackageName());

        mContext.startActivity(intent);

        Settings.Global.putInt(mContext.getContentResolver(),

                Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON,

                ((SwitchPreference) preference).isChecked() ? 1 : 0);

        return true;

    }



    @Override

    public String getPreferenceKey() {

        return KEY_NOTIFY_OPEN_NETWORKS;

    }



    @Override

    public void updateState(Preference preference) {

        NotificationChannelWrapper channel = getNotificationChannel();

        if (channel == null) {

            preference.setSummary(null);

        if (!(preference instanceof SwitchPreference)) {

            return;

        }

        final SwitchPreference notifyOpenNetworks = (SwitchPreference) preference;

        notifyOpenNetworks.setChecked(Settings.Global.getInt(mContext.getContentResolver(),

                Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 0) == 1);

    }



    class SettingObserver extends ContentObserver {

        private final Uri NETWORKS_AVAILABLE_URI = Settings.Global.getUriFor(

                Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON);



        private final Preference mPreference;



        public SettingObserver(Preference preference) {

            super(new Handler());

            mPreference = preference;

        }



        public void register(ContentResolver cr, boolean register) {

            if (register) {

                cr.registerContentObserver(NETWORKS_AVAILABLE_URI, false, this);

            } else {

            preference.setSummary(channel.getImportance() != NotificationManager.IMPORTANCE_NONE ?

                    R.string.notification_toggle_on : R.string.notification_toggle_off);

        }

    }



    @Nullable

    private NotificationChannelWrapper getNotificationChannel() {

        NetworkScorerAppData scorer = mNetworkScoreManager.getActiveScorer();

        if (scorer == null) {

            return null;

        }

        String packageName = scorer.getRecommendationServicePackageName();

        String channelId = scorer.getNetworkAvailableNotificationChannelId();

        if (packageName == null || channelId == null) {

            return null;

        }

        try {

            return mNotificationChannelHelper.getNotificationChannelForPackage(

                    packageName,

                    mPackageManager.getPackageUid(packageName, 0 /* flags */),

                    channelId,

                    false /* includeDeleted */ );

        } catch (RemoteException | PackageManager.NameNotFoundException e) {

            Log.d(TAG, "Failed to get notification channel.", e);

            return null;

                cr.unregisterContentObserver(this);

            }

        }



        @Override

        public void onChange(boolean selfChange, Uri uri) {

            super.onChange(selfChange, uri);

            if (NETWORKS_AVAILABLE_URI.equals(uri)) {

                updateState(mPreference);

            }

        }

    }

}

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

+34 −94
Original line number Diff line number Diff line
@@ -16,29 +16,25 @@ 


package com.android.settings.wifi;



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



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

import static org.mockito.Mockito.anyBoolean;

import static org.mockito.Mockito.anyInt;

import static org.mockito.Mockito.anyString;

import static org.mockito.Mockito.when;



import android.app.NotificationManager;

import android.content.ComponentName;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.verify;



import android.content.Context;

import android.content.pm.PackageManager;

import android.net.NetworkScorerAppData;

import android.os.RemoteException;

import android.provider.Settings;

import android.support.v14.preference.SwitchPreference;

import android.support.v7.preference.Preference;

import com.android.settings.R;



import com.android.settings.SettingsRobolectricTestRunner;

import com.android.settings.TestConfig;

import com.android.settings.network.NetworkScoreManagerWrapper;

import com.android.settings.utils.NotificationChannelHelper;

import com.android.settings.utils.NotificationChannelHelper.NotificationChannelWrapper;

import com.android.settings.core.lifecycle.Lifecycle;



import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;

import org.robolectric.RuntimeEnvironment;

import org.robolectric.annotation.Config;
@@ -47,123 +43,67 @@ import org.robolectric.annotation.Config; 
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)

public class NotifyOpenNetworkPreferenceControllerTest {



    private static final String TEST_SCORER_PACKAGE = "Test Package";

    private static final String TEST_SCORER_CLASS = "Test Class";

    private static final String TEST_SCORER_LABEL = "Test Label";

    private static final String NOTIFICATION_ID = "Notification Id";

    private static final CharSequence NOTIFICATION_NAME = "Notification Name";



    private Context mContext;

    private NotifyOpenNetworksPreferenceController mController;

    @Mock private NetworkScoreManagerWrapper mNetworkScorer;

    @Mock private NotificationChannelHelper mNotificationChannelHelper;

    @Mock private PackageManager mPackageManager;

    @Mock private NotificationChannelWrapper mChannel;



    @Before

    public void setUp() {

        MockitoAnnotations.initMocks(this);

        mContext = RuntimeEnvironment.application;

        mController = new NotifyOpenNetworksPreferenceController(

                mContext, mNetworkScorer, mNotificationChannelHelper, mPackageManager);

        ComponentName scorer = new ComponentName(TEST_SCORER_PACKAGE, TEST_SCORER_CLASS);



        NetworkScorerAppData scorerAppData = new NetworkScorerAppData(

                0, scorer, TEST_SCORER_LABEL, null /* enableUseOpenWifiActivity */,

                NOTIFICATION_ID);

        when(mNetworkScorer.getActiveScorer()).thenReturn(scorerAppData);

    }



    @Test

    public void testIsAvailable_shouldReturnFalseWhenScorerDoesNotExist()

            throws RemoteException {

        when(mNetworkScorer.getActiveScorer()).thenReturn(null);



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

    }



    @Test

    public void testIsAvailable_shouldReturnFalseWhenNotificationChannelIdDoesNotExist()

            throws RemoteException {

        ComponentName scorer = new ComponentName(TEST_SCORER_PACKAGE, TEST_SCORER_CLASS);

        NetworkScorerAppData scorerAppData = new NetworkScorerAppData(

                0, scorer, TEST_SCORER_LABEL, null /* enableUseOpenWifiActivity */,

                null /* networkAvailableNotificationChannelId */);

        when(mNetworkScorer.getActiveScorer()).thenReturn(scorerAppData);



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

    }



    @Test

    public void testIsAvailable_shouldReturnFalseWhenNotificationChannelDoesNotExist()

            throws RemoteException {

        when(mNotificationChannelHelper.getNotificationChannelForPackage(

                anyString(), anyInt(), anyString(), anyBoolean())).thenReturn(null);



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

        mController = new NotifyOpenNetworksPreferenceController(mContext, mock(Lifecycle.class));

    }



    @Test

    public void testIsAvailable_shouldReturnTrueWhenNotificationChannelExists()

            throws RemoteException {

        when(mNotificationChannelHelper.getNotificationChannelForPackage(

                anyString(), anyInt(), anyString(), anyBoolean())).thenReturn(mChannel);



    public void testIsAvailable_shouldAlwaysReturnTrue() {

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

    }



    @Test

    public void handlePreferenceTreeClick_nonMatchingKey_shouldDoNothing() {

        final Preference pref = new Preference(mContext);

        final SwitchPreference pref = new SwitchPreference(mContext);



        assertThat(mController.handlePreferenceTreeClick(pref)).isFalse();

    }



    @Test

    public void handlePreferenceTreeClick_nullScorer_shouldDoNothing() {

    public void handlePreferenceTreeClick_nonMatchingType_shouldDoNothing() {

        final Preference pref = new Preference(mContext);

        pref.setKey(mController.getPreferenceKey());

        when(mNetworkScorer.getActiveScorer()).thenReturn(null);



        assertThat(mController.handlePreferenceTreeClick(pref)).isFalse();

    }



    @Test

    public void handlePreferenceTreeClick_matchingKeyAndScorerExists_shouldLaunchActivity()

            throws RemoteException {

        final Preference pref = new Preference(mContext);

    public void handlePreferenceTreeClick_matchingKeyAndType_shouldUpdateSetting() {

        final SwitchPreference pref = new SwitchPreference(mContext);

        pref.setChecked(true);

        pref.setKey(mController.getPreferenceKey());

        when(mNotificationChannelHelper.getNotificationChannelForPackage(

                anyString(), anyInt(), anyString(), anyBoolean())).thenReturn(mChannel);



        assertThat(mController.handlePreferenceTreeClick(pref)).isTrue();

        assertThat(Settings.Global.getInt(mContext.getContentResolver(),

                WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 0))

                .isEqualTo(1);

    }



    @Test

    public void updateState_notificationsEnabled_shouldShowEnabledSummary() throws RemoteException {

        final Preference pref = new Preference(mContext);

        pref.setKey(mController.getPreferenceKey());

        when(mNotificationChannelHelper.getNotificationChannelForPackage(

                anyString(), anyInt(), anyString(), anyBoolean())).thenReturn(mChannel);

        when(mChannel.getImportance()).thenReturn(NotificationManager.IMPORTANCE_DEFAULT);

        mController.updateState(pref);

    public void updateState_preferenceSetCheckedWhenSettingsAreEnabled() {

        final SwitchPreference preference = mock(SwitchPreference.class);

        Settings.System.putInt(mContext.getContentResolver(),

                WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 1);



        mController.updateState(preference);



        assertThat(pref.getSummary()).isEqualTo(

                mContext.getString(R.string.notification_toggle_on));

        verify(preference).setChecked(true);

    }



    @Test

    public void updateState_notificationsEnabled_shouldShowDisabledSummary()

            throws RemoteException {

        final Preference pref = new Preference(mContext);

        pref.setKey(mController.getPreferenceKey());

        when(mNotificationChannelHelper.getNotificationChannelForPackage(

                anyString(), anyInt(), anyString(), anyBoolean())).thenReturn(mChannel);

        when(mChannel.getImportance()).thenReturn(NotificationManager.IMPORTANCE_NONE);

        mController.updateState(pref);

    public void updateState_preferenceSetCheckedWhenSettingsAreDisabled() {

        final SwitchPreference preference = mock(SwitchPreference.class);

        Settings.System.putInt(mContext.getContentResolver(),

                WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 0);



        assertThat(pref.getSummary()).isEqualTo(

                mContext.getString(R.string.notification_toggle_off));

    }

        mController.updateState(preference);



        verify(preference).setChecked(false);

    }

}