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

Commit 193b366e authored by Tyler Freeman's avatar Tyler Freeman
Browse files

feat(#AlwaysOnMagnifier): add preference for enabling Always On Magnification to Settings 

Hide behind feature flag so no one sees the preference unless its enabled.

Defaults to enabled.

Bug: b/265086261

Test: manual

Change-Id: Ic32353f2b139772fe905137c9ec137925ef6ebb9
parent 22fc2f38

res/values/strings.xml

+4 −0
Original line number Diff line number Diff line
@@ -3972,6 +3972,10 @@ 
    <string name="accessibility_screen_magnification_follow_typing_title">Magnify typing</string>

    <!-- Summary for accessibility follow typing preference for magnification. [CHAR LIMIT=none] -->

    <string name="accessibility_screen_magnification_follow_typing_summary">Magnifier follows text as you type</string>

    <!-- Title for accessibility magnifier preference where the magnifier never turns off on its own. [CHAR LIMIT=35] -->

    <string name="accessibility_screen_magnification_always_on_title">Always On</string>

    <!-- Summary for accessibility magnifier preference where the magnifier never turns off on its own. [CHAR LIMIT=none] -->

    <string name="accessibility_screen_magnification_always_on_summary">Instead of deactivating magnification when changing apps, it simply zooms out to normal size. Pinch to zoom back in whenever you want.</string>

    <!-- Title for screen magnification footer. [CHAR LIMIT=60] -->

    <string name="accessibility_screen_magnification_about_title">About magnification</string>

    <!-- Screen magnification footer link content description [CHAR LIMIT=NONE] -->

src/com/android/settings/accessibility/MagnificationAlwaysOnPreferenceController.java

0 → 100644
+94 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2022 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.accessibility;



import static com.android.settings.accessibility.AccessibilityUtil.State.OFF;

import static com.android.settings.accessibility.AccessibilityUtil.State.ON;



import android.content.Context;

import android.provider.Settings;



import androidx.lifecycle.Lifecycle;

import androidx.lifecycle.LifecycleObserver;

import androidx.lifecycle.OnLifecycleEvent;

import androidx.preference.PreferenceScreen;

import androidx.preference.SwitchPreference;



import com.android.settings.R;

import com.android.settings.core.TogglePreferenceController;



/**

 * Controller that accesses and switches the preference status of the magnification always on

 * feature, where the magnifier will not deactivate on Activity transitions; it will only zoom out

 * to 100%.

 */

public class MagnificationAlwaysOnPreferenceController extends TogglePreferenceController

        implements LifecycleObserver {



    private static final String TAG =

            MagnificationAlwaysOnPreferenceController.class.getSimpleName();

    static final String PREF_KEY = Settings.Secure.ACCESSIBILITY_MAGNIFICATION_ALWAYS_ON_ENABLED;



    private SwitchPreference mSwitchPreference;



    public MagnificationAlwaysOnPreferenceController(Context context, String preferenceKey) {

        super(context, preferenceKey);

    }



    @Override

    public int getAvailabilityStatus() {

        return AVAILABLE;

    }



    @Override

    public boolean isChecked() {

        return Settings.Secure.getInt(mContext.getContentResolver(),

                Settings.Secure.ACCESSIBILITY_MAGNIFICATION_ALWAYS_ON_ENABLED, ON) == ON;

    }



    @Override

    public boolean setChecked(boolean isChecked) {

        return Settings.Secure.putInt(mContext.getContentResolver(),

                Settings.Secure.ACCESSIBILITY_MAGNIFICATION_ALWAYS_ON_ENABLED,

                (isChecked ? ON : OFF));

    }



    @Override

    public int getSliceHighlightMenuRes() {

        return R.string.menu_key_accessibility;

    }



    @Override

    public void displayPreference(PreferenceScreen screen) {

        super.displayPreference(screen);

        mSwitchPreference = screen.findPreference(getPreferenceKey());

    }



    // TODO(b/186731461): Remove it when this controller is used in DashBoardFragment only.

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)

    void onResume() {

        updateState();

    }



    /**

     * Updates the state of preference components which has been displayed by

     * {@link MagnificationAlwaysOnPreferenceController#displayPreference}.

     */

    void updateState() {

        updateState(mSwitchPreference);

    }

}

src/com/android/settings/accessibility/ToggleScreenMagnificationPreferenceFragment.java

+27 −0
Original line number Diff line number Diff line
@@ -31,6 +31,7 @@ import android.content.pm.PackageManager; 
import android.icu.text.CaseMap;

import android.net.Uri;

import android.os.Bundle;

import android.provider.DeviceConfig;

import android.provider.Settings;

import android.text.TextUtils;

import android.view.LayoutInflater;
@@ -212,6 +213,32 @@ public class ToggleScreenMagnificationPreferenceFragment extends 
                getContext(), MagnificationFollowTypingPreferenceController.PREF_KEY);

        getSettingsLifecycle().addObserver(mFollowTypingPreferenceController);

        mFollowTypingPreferenceController.displayPreference(getPreferenceScreen());



        addAlwaysOnSetting(generalCategory);

    }



    private void addAlwaysOnSetting(PreferenceCategory generalCategory) {

        if (!DeviceConfig.getBoolean(

                DeviceConfig.NAMESPACE_WINDOW_MANAGER,

                "AlwaysOnMagnifier__enable_always_on_magnifier",

                false

        )) {

            return;

        }



        var alwaysOnPreference = new SwitchPreference(getPrefContext());

        alwaysOnPreference.setTitle(

                R.string.accessibility_screen_magnification_always_on_title);

        alwaysOnPreference.setSummary(

                R.string.accessibility_screen_magnification_always_on_summary);

        alwaysOnPreference.setKey(

                MagnificationAlwaysOnPreferenceController.PREF_KEY);

        generalCategory.addPreference(alwaysOnPreference);



        var alwaysOnPreferenceController = new MagnificationAlwaysOnPreferenceController(

                getContext(), MagnificationAlwaysOnPreferenceController.PREF_KEY);

        getSettingsLifecycle().addObserver(alwaysOnPreferenceController);

        alwaysOnPreferenceController.displayPreference(getPreferenceScreen());

    }



    @Override

tests/robotests/src/com/android/settings/accessibility/MagnificationAlwaysOnPreferenceControllerTest.java

0 → 100644
+108 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2022 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.accessibility;



import static com.android.settings.accessibility.AccessibilityUtil.State.OFF;

import static com.android.settings.accessibility.AccessibilityUtil.State.ON;



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



import static org.mockito.Mockito.spy;

import static org.mockito.Mockito.verify;



import android.content.Context;

import android.provider.Settings;



import androidx.preference.PreferenceManager;

import androidx.preference.PreferenceScreen;

import androidx.preference.SwitchPreference;

import androidx.test.core.app.ApplicationProvider;



import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.robolectric.RobolectricTestRunner;



@RunWith(RobolectricTestRunner.class)

public class MagnificationAlwaysOnPreferenceControllerTest {



    private static final String KEY_ALWAYS_ON =

            Settings.Secure.ACCESSIBILITY_MAGNIFICATION_ALWAYS_ON_ENABLED;



    private final Context mContext = ApplicationProvider.getApplicationContext();

    private final SwitchPreference mSwitchPreference = spy(new SwitchPreference(mContext));

    private final MagnificationAlwaysOnPreferenceController mController =

            new MagnificationAlwaysOnPreferenceController(mContext,

                    MagnificationAlwaysOnPreferenceController.PREF_KEY);



    @Before

    public void setUp() {

        final PreferenceManager preferenceManager = new PreferenceManager(mContext);

        final PreferenceScreen screen = preferenceManager.createPreferenceScreen(mContext);

        mSwitchPreference.setKey(MagnificationAlwaysOnPreferenceController.PREF_KEY);

        screen.addPreference(mSwitchPreference);

        mController.displayPreference(screen);

    }



    @Test

    public void isChecked_defaultStateForAlwaysOn_onResumeShouldReturnTrue() {

        mController.onResume();



        assertThat(mController.isChecked()).isTrue();

        assertThat(mSwitchPreference.isChecked()).isTrue();

    }



    @Test

    public void isChecked_enableAlwaysOn_onResumeShouldReturnTrue() {

        Settings.Secure.putInt(mContext.getContentResolver(), KEY_ALWAYS_ON, ON);

        mController.onResume();



        assertThat(mController.isChecked()).isTrue();

        assertThat(mSwitchPreference.isChecked()).isTrue();

    }



    @Test

    public void isChecked_disableAlwaysOn_onResumeShouldReturnFalse() {

        Settings.Secure.putInt(mContext.getContentResolver(), KEY_ALWAYS_ON, OFF);

        mController.onResume();



        assertThat(mController.isChecked()).isFalse();

        assertThat(mSwitchPreference.isChecked()).isFalse();

    }



    @Test

    public void performClick_switchDefaultStateForAlwaysOn_shouldReturnFalse() {

        mController.onResume();



        mSwitchPreference.performClick();



        verify(mSwitchPreference).setChecked(false);

        assertThat(mController.isChecked()).isFalse();

        assertThat(mSwitchPreference.isChecked()).isFalse();

    }



    @Test

    public void updateState_disableAlwaysOn_shouldReturnFalse() {

        Settings.Secure.putInt(mContext.getContentResolver(), KEY_ALWAYS_ON, OFF);



        mController.updateState();



        verify(mSwitchPreference).setChecked(false);

        assertThat(mController.isChecked()).isFalse();

        assertThat(mSwitchPreference.isChecked()).isFalse();

    }

}