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

Commit 1a5e7357 authored by Yi Jiang's avatar Yi Jiang
Browse files

Removes TimeoutPreferenceController in Settings. 

Test: unit tests
Bug: 173450342
Change-Id: I16470192fc41afe83cf601baa79fea360e8dc1d1
parent 268a8e24

src/com/android/settings/display/ScreenTimeoutPreferenceController.java

+17 −1
Original line number Diff line number Diff line
@@ -65,7 +65,7 @@ public class ScreenTimeoutPreferenceController extends BasePreferenceController 
                R.array.screen_timeout_entries);

        final CharSequence[] timeoutValues = mContext.getResources().getStringArray(

                R.array.screen_timeout_values);

        final CharSequence description = TimeoutPreferenceController.getTimeoutDescription(

        final CharSequence description = getTimeoutDescription(

                currentTimeout, timeoutEntries, timeoutValues);

        return mContext.getString(R.string.screen_timeout_summary, description);

    }
@@ -84,4 +84,20 @@ public class ScreenTimeoutPreferenceController extends BasePreferenceController 
        return Settings.System.getLong(mContext.getContentResolver(),

                SCREEN_OFF_TIMEOUT, FALLBACK_SCREEN_TIMEOUT_VALUE);

    }



    private static CharSequence getTimeoutDescription(

            long currentTimeout, CharSequence[] entries, CharSequence[] values) {

        if (currentTimeout < 0 || entries == null || values == null

                || values.length != entries.length) {

            return null;

        }



        for (int i = 0; i < values.length; i++) {

            long timeout = Long.parseLong(values[i].toString());

            if (currentTimeout == timeout) {

                return entries[i];

            }

        }

        return null;

    }

}

src/com/android/settings/display/TimeoutPreferenceController.java

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

 * Copyright (C) 2016 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.display;



import static android.provider.Settings.System.SCREEN_OFF_TIMEOUT;



import android.app.admin.DevicePolicyManager;

import android.content.Context;

import android.os.UserHandle;

import android.os.UserManager;

import android.provider.Settings;

import android.util.Log;



import androidx.preference.Preference;



import com.android.settings.R;

import com.android.settings.core.PreferenceControllerMixin;

import com.android.settingslib.RestrictedLockUtils;

import com.android.settingslib.RestrictedLockUtils.EnforcedAdmin;

import com.android.settingslib.RestrictedLockUtilsInternal;

import com.android.settingslib.core.AbstractPreferenceController;



public class TimeoutPreferenceController extends AbstractPreferenceController implements

        PreferenceControllerMixin, Preference.OnPreferenceChangeListener {



    private static final String TAG = "TimeoutPrefContr";



    /** If there is no setting in the provider, use this. */

    public static final int FALLBACK_SCREEN_TIMEOUT_VALUE = 30000;



    private final String mScreenTimeoutKey;



    public TimeoutPreferenceController(Context context, String key) {

        super(context);

        mScreenTimeoutKey = key;

    }



    @Override

    public boolean isAvailable() {

        return true;

    }



    @Override

    public String getPreferenceKey() {

        return mScreenTimeoutKey;

    }



    @Override

    public void updateState(Preference preference) {

        final TimeoutListPreference timeoutListPreference = (TimeoutListPreference) preference;

        final long currentTimeout = Settings.System.getLong(mContext.getContentResolver(),

                SCREEN_OFF_TIMEOUT, FALLBACK_SCREEN_TIMEOUT_VALUE);

        timeoutListPreference.setValue(String.valueOf(currentTimeout));

        final DevicePolicyManager dpm =

                (DevicePolicyManager) mContext.getSystemService(Context.DEVICE_POLICY_SERVICE);

        if (dpm != null) {

            final RestrictedLockUtils.EnforcedAdmin admin =

                    RestrictedLockUtilsInternal.checkIfMaximumTimeToLockIsSet(mContext);

            final long maxTimeout =

                    dpm.getMaximumTimeToLock(null /* admin */, UserHandle.myUserId());

            timeoutListPreference.removeUnusableTimeouts(maxTimeout, admin);

        }

        updateTimeoutPreferenceDescription(timeoutListPreference,

                Long.parseLong(timeoutListPreference.getValue()));



        final EnforcedAdmin admin = RestrictedLockUtilsInternal.checkIfRestrictionEnforced(

                mContext, UserManager.DISALLOW_CONFIG_SCREEN_TIMEOUT,

                UserHandle.myUserId());

        if (admin != null) {

            timeoutListPreference.removeUnusableTimeouts(0/* disable all*/, admin);

        }

    }



    @Override

    public boolean onPreferenceChange(Preference preference, Object newValue) {

        try {

            int value = Integer.parseInt((String) newValue);

            Settings.System.putInt(mContext.getContentResolver(), SCREEN_OFF_TIMEOUT, value);

            updateTimeoutPreferenceDescription((TimeoutListPreference) preference, value);

        } catch (NumberFormatException e) {

            Log.e(TAG, "could not persist screen timeout setting", e);

        }

        return true;

    }



    public static CharSequence getTimeoutDescription(

            long currentTimeout, CharSequence[] entries, CharSequence[] values) {

        if (currentTimeout < 0 || entries == null || values == null

                || values.length != entries.length) {

            return null;

        }



        for (int i = 0; i < values.length; i++) {

            long timeout = Long.parseLong(values[i].toString());

            if (currentTimeout == timeout) {

                return entries[i];

            }

        }

        return null;

    }



    private void updateTimeoutPreferenceDescription(TimeoutListPreference preference,

            long currentTimeout) {

        final CharSequence[] entries = preference.getEntries();

        final CharSequence[] values = preference.getEntryValues();

        final String summary;

        if (preference.isDisabledByAdmin()) {

            summary = mContext.getString(com.android.settings.R.string.disabled_by_policy_title);

        } else {

            final CharSequence timeoutDescription = getTimeoutDescription(

                    currentTimeout, entries, values);

            summary = timeoutDescription == null

                    ? ""

                    : mContext.getString(R.string.screen_timeout_summary, timeoutDescription);

        }

        preference.setSummary(summary);

    }



}

tests/robotests/src/com/android/settings/display/TimeoutPreferenceControllerTest.java

deleted100644 → 0
+0 −161
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.display;



import static android.provider.Settings.System.SCREEN_OFF_TIMEOUT;



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



import static org.mockito.Mockito.anyInt;

import static org.mockito.Mockito.spy;

import static org.mockito.Mockito.times;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;



import android.content.Context;

import android.os.UserHandle;

import android.os.UserManager;

import android.provider.Settings;



import com.android.settings.R;

import com.android.settings.testutils.shadow.ShadowDevicePolicyManager;

import com.android.settings.testutils.shadow.ShadowRestrictedLockUtilsInternal;

import com.android.settingslib.RestrictedLockUtils.EnforcedAdmin;



import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.ArgumentCaptor;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;

import org.robolectric.RobolectricTestRunner;

import org.robolectric.RuntimeEnvironment;

import org.robolectric.annotation.Config;



import java.util.ArrayList;

import java.util.Collections;

import java.util.List;



@RunWith(RobolectricTestRunner.class)

@Config(shadows = ShadowDevicePolicyManager.class)

public class TimeoutPreferenceControllerTest {



    private static final int TIMEOUT = 30;

    private static final String KEY_SCREEN_TIMEOUT = "screen_timeout";

    private static final String DEFAULT_TIMEOUT = "300000"; // 5 minutes



    private Context mContext;

    @Mock

    private TimeoutListPreference mPreference;

    @Mock

    private UserManager mUserManager;



    private TimeoutPreferenceController mController;



    @Before

    public void setUp() {

        MockitoAnnotations.initMocks(this);

        mContext = spy(RuntimeEnvironment.application);

        when(mContext.getSystemService(Context.USER_SERVICE)).thenReturn(mUserManager);

        when(mPreference.getValue()).thenReturn(DEFAULT_TIMEOUT);

        mController = new TimeoutPreferenceController(mContext, KEY_SCREEN_TIMEOUT);

    }



    @After

    public void tearDown() {

          ShadowRestrictedLockUtilsInternal.reset();

    }



    @Test

    public void testOnPreferenceChange_SetTimeout_ReturnCorrectTimeout() {

        mController.onPreferenceChange(mPreference, Integer.toString(TIMEOUT));



        final int mode = Settings.System.getInt(mContext.getContentResolver(),

                SCREEN_OFF_TIMEOUT, 0);

        assertThat(mode).isEqualTo(TIMEOUT);

    }



    @Test

    public void testUpdateStateNoAdminTimeouts() {

        when(mUserManager.getProfiles(anyInt())).thenReturn(Collections.emptyList());

        mController.updateState(mPreference);

        verify(mPreference).removeUnusableTimeouts(0, null);

    }



    @Test

    public void testUpdateStateWithAdminTimeouts() {

        final int profileUserId = UserHandle.myUserId();

        final long timeout = 10000;

        when(mUserManager.getProfiles(profileUserId)).thenReturn(Collections.emptyList());

        ShadowDevicePolicyManager.getShadow().setMaximumTimeToLock(profileUserId, timeout);



        mController.updateState(mPreference);

        verify(mPreference).removeUnusableTimeouts(timeout, null);

    }



    @Test

    public void testUpdateStateWithAdminTimeoutsAndRestriction() {

        final int profileUserId = UserHandle.myUserId();

        final long timeout = 100;

        when(mUserManager.getProfiles(profileUserId)).thenReturn(Collections.emptyList());

        ShadowDevicePolicyManager.getShadow().setMaximumTimeToLock(profileUserId, timeout);



        int userId = UserHandle.myUserId();

        List<UserManager.EnforcingUser> enforcingUsers = new ArrayList<>();

        // Add two enforcing users so that RestrictedLockUtils.checkIfRestrictionEnforced returns

        // non-null.

        enforcingUsers.add(new UserManager.EnforcingUser(userId,

                UserManager.RESTRICTION_SOURCE_DEVICE_OWNER));

        enforcingUsers.add(new UserManager.EnforcingUser(userId,

                UserManager.RESTRICTION_SOURCE_PROFILE_OWNER));

        when(mUserManager.getUserRestrictionSources(

                UserManager.DISALLOW_CONFIG_SCREEN_TIMEOUT, UserHandle.of(userId)))

                .thenReturn(enforcingUsers);



        mController.updateState(mPreference);



        ArgumentCaptor<Long> longCaptor = ArgumentCaptor.forClass(Long.class);

        ArgumentCaptor<EnforcedAdmin> adminCaptor = ArgumentCaptor.forClass(EnforcedAdmin.class);



        verify(mPreference, times(2))

                .removeUnusableTimeouts(longCaptor.capture(), adminCaptor.capture());

        assertThat(longCaptor.getValue()).isEqualTo(0);

        assertThat(adminCaptor.getValue()).isNotNull();

    }



    @Test

    @Config(shadows = ShadowRestrictedLockUtilsInternal.class)

    public void updateState_selectedTimeoutLargerThanAdminMax_shouldSetSummaryToUpdatedPrefValue() {

        final int profileUserId = UserHandle.myUserId();

        final long allowedTimeout = 480000L; // 8 minutes

        when(mUserManager.getProfiles(profileUserId)).thenReturn(Collections.emptyList());

        ShadowDevicePolicyManager.getShadow().setMaximumTimeToLock(profileUserId, allowedTimeout);

        ShadowRestrictedLockUtilsInternal.setMaximumTimeToLockIsSet(true);

        final CharSequence[] timeouts = {"15000", "30000", "60000", "120000", "300000", "600000"};

        final CharSequence[] summaries = {"15s", "30s", "1m", "2m", "5m", "10m"};

        // set current timeout to be 10 minutes, which is longer than the allowed 8 minutes

        Settings.System.putLong(mContext.getContentResolver(), SCREEN_OFF_TIMEOUT, 600000L);

        when(mPreference.getEntries()).thenReturn(summaries);

        when(mPreference.getEntryValues()).thenReturn(timeouts);

        when(mPreference.getValue()).thenReturn("300000");



        mController.updateState(mPreference);



        verify(mPreference).setSummary(mContext.getString(R.string.screen_timeout_summary, "5m"));

    }

}