1 /*
2  * Copyright (C) 2024 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.settings.accessibility;
18 
19 import static com.android.settings.accessibility.AccessibilityUtil.State.OFF;
20 import static com.android.settings.accessibility.AccessibilityUtil.State.ON;
21 import static com.android.settings.accessibility.MagnificationCapabilities.MagnificationMode;
22 import static com.android.settings.core.BasePreferenceController.AVAILABLE;
23 import static com.android.settings.core.BasePreferenceController.CONDITIONALLY_UNAVAILABLE;
24 
25 import static com.google.common.truth.Truth.assertThat;
26 
27 import static org.mockito.Mockito.reset;
28 import static org.mockito.Mockito.spy;
29 import static org.mockito.Mockito.verify;
30 
31 import android.content.Context;
32 import android.provider.Settings;
33 
34 import androidx.preference.PreferenceManager;
35 import androidx.preference.PreferenceScreen;
36 import androidx.preference.SwitchPreference;
37 import androidx.test.core.app.ApplicationProvider;
38 
39 import com.android.settings.R;
40 
41 import org.junit.Before;
42 import org.junit.Test;
43 import org.junit.runner.RunWith;
44 import org.robolectric.RobolectricTestRunner;
45 import org.robolectric.shadow.api.Shadow;
46 import org.robolectric.shadows.ShadowContentResolver;
47 
48 @RunWith(RobolectricTestRunner.class)
49 public class MagnificationOneFingerPanningPreferenceControllerTest {
50     private static final String ONE_FINGER_PANNING_KEY =
51             Settings.Secure.ACCESSIBILITY_SINGLE_FINGER_PANNING_ENABLED;
52 
53     private final Context mContext = ApplicationProvider.getApplicationContext();
54     private ShadowContentResolver mShadowContentResolver;
55     private final SwitchPreference mSwitchPreference = spy(new SwitchPreference(mContext));
56     private final MagnificationOneFingerPanningPreferenceController mController =
57             new MagnificationOneFingerPanningPreferenceController(mContext);
58 
59     @Before
setUp()60     public void setUp() {
61         mShadowContentResolver = Shadow.extract(mContext.getContentResolver());
62 
63         final PreferenceManager preferenceManager = new PreferenceManager(mContext);
64         final PreferenceScreen screen = preferenceManager.createPreferenceScreen(mContext);
65         mSwitchPreference.setKey(MagnificationOneFingerPanningPreferenceController.PREF_KEY);
66         screen.addPreference(mSwitchPreference);
67         mController.displayPreference(screen);
68     }
69 
70     @Test
onResume_verifyRegisterCapabilityObserver()71     public void onResume_verifyRegisterCapabilityObserver() {
72         mController.onResume();
73         assertThat(mShadowContentResolver.getContentObservers(
74                 Settings.Secure.getUriFor(Settings.Secure.ACCESSIBILITY_MAGNIFICATION_CAPABILITY)))
75                 .hasSize(1);
76     }
77 
78     @Test
onPause_verifyUnregisterCapabilityObserver()79     public void onPause_verifyUnregisterCapabilityObserver() {
80         mController.onResume();
81         mController.onPause();
82         assertThat(mShadowContentResolver.getContentObservers(
83                 Settings.Secure.getUriFor(Settings.Secure.ACCESSIBILITY_MAGNIFICATION_CAPABILITY)))
84                 .isEmpty();
85     }
86 
87     @Test
updateState_windowModeOnly_preferenceIsUnavailable()88     public void updateState_windowModeOnly_preferenceIsUnavailable() {
89         MagnificationCapabilities.setCapabilities(mContext, MagnificationMode.WINDOW);
90         mController.updateState(mSwitchPreference);
91 
92         assertThat(mSwitchPreference.isEnabled()).isFalse();
93     }
94 
95     @Test
updateState_fullscreenModeOnly_preferenceIsAvailable()96     public void updateState_fullscreenModeOnly_preferenceIsAvailable() {
97         MagnificationCapabilities.setCapabilities(mContext, MagnificationMode.FULLSCREEN);
98         mController.updateState(mSwitchPreference);
99 
100         assertThat(mSwitchPreference.isEnabled()).isTrue();
101     }
102 
103     @Test
updateState_switchMode_preferenceIsAvailable()104     public void updateState_switchMode_preferenceIsAvailable() {
105         MagnificationCapabilities.setCapabilities(mContext, MagnificationMode.ALL);
106         mController.updateState(mSwitchPreference);
107 
108         assertThat(mSwitchPreference.isEnabled()).isTrue();
109     }
110 
111     @Test
isChecked_defaultState_returnFalse()112     public void isChecked_defaultState_returnFalse() {
113         mController.updateState(mSwitchPreference);
114 
115         assertThat(mController.isChecked()).isFalse();
116         assertThat(mSwitchPreference.isChecked()).isFalse();
117     }
118 
119     @Test
isChecked_settingsOn_returnTrue()120     public void isChecked_settingsOn_returnTrue() {
121         Settings.Secure.putInt(mContext.getContentResolver(), ONE_FINGER_PANNING_KEY, ON);
122         mController.updateState(mSwitchPreference);
123 
124         assertThat(mController.isChecked()).isTrue();
125     }
126 
127     @Test
isChecked_settingsOff_returnFalse()128     public void isChecked_settingsOff_returnFalse() {
129         Settings.Secure.putInt(mContext.getContentResolver(), ONE_FINGER_PANNING_KEY, OFF);
130         mController.updateState(mSwitchPreference);
131 
132         assertThat(mController.isChecked()).isFalse();
133     }
134 
135     @Test
getSummary_switchModeAndSettingsOff_disabledSummaryTextUsed()136     public void getSummary_switchModeAndSettingsOff_disabledSummaryTextUsed() {
137         MagnificationCapabilities.setCapabilities(mContext, MagnificationMode.ALL);
138         Settings.Secure.putInt(mContext.getContentResolver(), ONE_FINGER_PANNING_KEY, OFF);
139 
140         mController.updateState(mSwitchPreference);
141 
142         assertThat(mController.getSummary()).isEqualTo(disabledSummary());
143     }
144 
145     @Test
getSummary_switchModeAndSettingsOn_enabledSummaryTextUsed()146     public void getSummary_switchModeAndSettingsOn_enabledSummaryTextUsed() {
147         MagnificationCapabilities.setCapabilities(mContext, MagnificationMode.ALL);
148         Settings.Secure.putInt(mContext.getContentResolver(), ONE_FINGER_PANNING_KEY, ON);
149 
150         mController.updateState(mSwitchPreference);
151 
152         assertThat(mController.getSummary()).isEqualTo(enabledSummary());
153     }
154 
155     @Test
getSummary_windowModeOnly_unavailableSummaryTextUsed()156     public void getSummary_windowModeOnly_unavailableSummaryTextUsed() {
157         MagnificationCapabilities.setCapabilities(mContext, MagnificationMode.WINDOW);
158 
159         mController.updateState(mSwitchPreference);
160 
161         assertThat(mController.getSummary()).isEqualTo(unavailableSummary());
162     }
163 
164     @Test
performClick_defaultSettings_toggleOn()165     public void performClick_defaultSettings_toggleOn() {
166         MagnificationCapabilities.setCapabilities(mContext, MagnificationMode.ALL);
167         mController.updateState(mSwitchPreference);
168         reset(mSwitchPreference);
169 
170         mSwitchPreference.performClick();
171 
172         verify(mSwitchPreference).setChecked(true);
173         assertThat(mController.isChecked()).isTrue();
174         assertThat(mSwitchPreference.isChecked()).isTrue();
175     }
176 
177     @Test
performClick_settingsOn_toggleOff()178     public void performClick_settingsOn_toggleOff() {
179         MagnificationCapabilities.setCapabilities(mContext, MagnificationMode.ALL);
180         Settings.Secure.putInt(mContext.getContentResolver(), ONE_FINGER_PANNING_KEY, ON);
181         mController.updateState(mSwitchPreference);
182         reset(mSwitchPreference);
183 
184         mSwitchPreference.performClick();
185 
186         verify(mSwitchPreference).setChecked(false);
187         assertThat(mController.isChecked()).isFalse();
188         assertThat(mSwitchPreference.isChecked()).isFalse();
189     }
190 
191     @Test
getAvailableStatus_notInSetupWizard_returnAvailable()192     public void getAvailableStatus_notInSetupWizard_returnAvailable() {
193         assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
194     }
195 
196     @Test
getAvailableStatus_inSetupWizard_returnConditionallyUnavailable()197     public void getAvailableStatus_inSetupWizard_returnConditionallyUnavailable() {
198         mController.setInSetupWizard(true);
199         assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
200     }
201 
enabledSummary()202     private String enabledSummary() {
203         return mContext.getString(
204                 R.string.accessibility_magnification_one_finger_panning_summary_on);
205     }
206 
disabledSummary()207     private String disabledSummary() {
208         return mContext.getString(
209                 R.string.accessibility_magnification_one_finger_panning_summary_off);
210     }
211 
unavailableSummary()212     private String unavailableSummary() {
213         return mContext.getString(
214                 R.string.accessibility_magnification_one_finger_panning_summary_unavailable);
215     }
216 }
217