PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove redundant swipe down notification and one handed sub settings

Browse Source 
1. Remove "Swipe down for notification" item code.
2. Remove "Exit when switching apps & "Timeout" items code.

Bug: 175851783

Test: build & verify Settings > System > Gestures
Test: make RunSettingsRoboTests ROBOTEST_FILTER=
      "com.android.settings.gestures
      .OneHandedEnablePreferenceControllerTest"

Change-Id: I77be5ff5542f6310fa0b9649ddfc1d3c16fa4261
This commit is contained in:
Jason Chang
2021-06-02 20:01:51 +08:00
committed by Bill Lin
parent ad84b3dd39
commit 1c310ef44b
12 changed files with 1 additions and 859 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
res/xml/gestures.xml
View File

@@ -33,13 +33,6 @@
settings:searchable="false"
settings:controller="com.android.settings.gestures.SwipeToNotificationPreferenceController" />
<Preference
android:key="gesture_swipe_bottom_to_notification"
android:title="@string/swipe_bottom_to_notifications_title"
android:fragment="com.android.settings.gestures.SwipeBottomToNotificationSettings"
settings:searchable="false"
settings:controller="com.android.settings.gestures.SwipeBottomToNotificationPreferenceController" />
<Preference
android:key="gesture_double_tap_power_input_summary"
android:title="@string/double_tap_power_for_camera_title"

38
res/xml/swipe_bottom_to_notification_settings.xml
View File

@@ -1,38 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
~ Copyright (C) 2020 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.
-->
<PreferenceScreen
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:settings="http://schemas.android.com/apk/res-auto"
android:title="@string/swipe_bottom_to_notifications_title">
<com.android.settingslib.widget.LayoutPreference
android:key="one_handed_header"
android:layout="@layout/one_handed_header"
android:persistent="false"
android:selectable="false"
settings:allowDividerBelow="false"
settings:searchable="false"/>
<SwitchPreference
android:key="gesture_swipe_bottom_to_notification"
android:title="@string/swipe_bottom_to_notifications_title"
android:summary="@string/swipe_bottom_to_notifications_summary"
settings:controller="com.android.settings.gestures.SwipeBottomToNotificationPreferenceController"
settings:allowDividerAbove="true" />
</PreferenceScreen>

94
src/com/android/settings/gestures/OneHandedAppTapsExitPreferenceController.java
View File

@@ -1,94 +0,0 @@
/*
* Copyright (C) 2020 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.gestures;
import android.content.Context;
import android.net.Uri;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.core.TogglePreferenceController;
import com.android.settingslib.core.lifecycle.LifecycleObserver;
import com.android.settingslib.core.lifecycle.events.OnStart;
import com.android.settingslib.core.lifecycle.events.OnStop;
/**
* The Controller to handle app taps to exit of one-handed mode
*/
public class OneHandedAppTapsExitPreferenceController extends TogglePreferenceController implements
LifecycleObserver, OnStart, OnStop, OneHandedSettingsUtils.TogglesCallback {
private final OneHandedSettingsUtils mUtils;
private Preference mPreference;
public OneHandedAppTapsExitPreferenceController(Context context, String key) {
super(context, key);
mUtils = new OneHandedSettingsUtils(context);
// By default, app taps to stop one-handed is enabled, this will get default value once.
OneHandedSettingsUtils.setTapsAppToExitEnabled(mContext, isChecked());
}
@Override
public int getAvailabilityStatus() {
return OneHandedSettingsUtils.isOneHandedModeEnabled(mContext)
? AVAILABLE : DISABLED_DEPENDENT_SETTING;
}
@Override
public void displayPreference(PreferenceScreen screen) {
super.displayPreference(screen);
mPreference = screen.findPreference(getPreferenceKey());
}
@Override
public void updateState(Preference preference) {
super.updateState(preference);
final int availabilityStatus = getAvailabilityStatus();
preference.setEnabled(
availabilityStatus == AVAILABLE || availabilityStatus == AVAILABLE_UNSEARCHABLE);
}
@Override
public boolean setChecked(boolean isChecked) {
return OneHandedSettingsUtils.setTapsAppToExitEnabled(mContext, isChecked);
}
@Override
public boolean isChecked() {
return OneHandedSettingsUtils.isTapsAppToExitEnabled(mContext);
}
@Override
public void onStart() {
mUtils.registerToggleAwareObserver(this);
}
@Override
public void onStop() {
mUtils.unregisterToggleAwareObserver();
}
@Override
public void onChange(Uri uri) {
updateState(mPreference);
}
}

3
src/com/android/settings/gestures/OneHandedEnablePreferenceController.java
View File

@@ -32,8 +32,7 @@ public class OneHandedEnablePreferenceController extends SettingsMainSwitchPrefe
@Override
public int getAvailabilityStatus() {
return OneHandedSettingsUtils.isFeatureAvailable(mContext)
? AVAILABLE : UNSUPPORTED_ON_DEVICE;
return AVAILABLE;
}
@Override

9
src/com/android/settings/gestures/OneHandedSettingsUtils.java
View File

@@ -189,15 +189,6 @@ public class OneHandedSettingsUtils {
Settings.Secure.NAVIGATION_MODE, 2 /* fully gestural */, sCurrentUserId);
}
/**
*
* @param context App context
* @return Support One-Handed mode feature or not.
*/
public static boolean isFeatureAvailable(Context context) {
return isSupportOneHandedMode() && getNavigationBarMode(context) != 0;
}
/**
* Registers callback for observing Settings.Secure.ONE_HANDED_MODE_ENABLED state.
* @param callback for state changes

138
src/com/android/settings/gestures/OneHandedTimeoutPreferenceController.java
View File

@@ -1,138 +0,0 @@
/*
* Copyright (C) 2020 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.gestures;
import android.content.Context;
import android.net.Uri;
import androidx.preference.ListPreference;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.R;
import com.android.settings.core.BasePreferenceController;
import com.android.settingslib.core.lifecycle.LifecycleObserver;
import com.android.settingslib.core.lifecycle.events.OnStart;
import com.android.settingslib.core.lifecycle.events.OnStop;
import java.util.HashMap;
import java.util.Map;
/**
* The Controller to handle one-handed mode timeout state.
**/
public class OneHandedTimeoutPreferenceController extends BasePreferenceController implements
Preference.OnPreferenceChangeListener, LifecycleObserver, OnStart, OnStop,
OneHandedSettingsUtils.TogglesCallback {
private final Map<String, String> mTimeoutMap;
private final OneHandedSettingsUtils mUtils;
private Preference mTimeoutPreference;
public OneHandedTimeoutPreferenceController(Context context, String preferenceKey) {
super(context, preferenceKey);
mTimeoutMap = new HashMap<>();
initTimeoutMap();
mUtils = new OneHandedSettingsUtils(context);
}
@Override
public int getAvailabilityStatus() {
return OneHandedSettingsUtils.isOneHandedModeEnabled(mContext)
? AVAILABLE : DISABLED_DEPENDENT_SETTING;
}
@Override
public boolean onPreferenceChange(Preference preference, Object object) {
if (!(preference instanceof ListPreference)) {
return false;
}
final int newValue = Integer.parseInt((String) object);
OneHandedSettingsUtils.setTimeoutValue(mContext, newValue);
updateState(preference);
return true;
}
@Override
public void updateState(Preference preference) {
super.updateState(preference);
if (!(preference instanceof ListPreference)) {
return;
}
final ListPreference listPreference = (ListPreference) preference;
listPreference.setValue(getTimeoutValue());
final int availabilityStatus = getAvailabilityStatus();
preference.setEnabled(
availabilityStatus == AVAILABLE || availabilityStatus == AVAILABLE_UNSEARCHABLE);
}
@Override
public CharSequence getSummary() {
if (OneHandedSettingsUtils.getTimeoutValue(mContext) == 0) {
return mContext.getResources().getString(R.string.screensaver_settings_summary_never);
}
return String.format(mContext.getResources().getString(
R.string.screen_timeout_summary), mTimeoutMap.get(getTimeoutValue()));
}
@Override
public void displayPreference(PreferenceScreen screen) {
super.displayPreference(screen);
mTimeoutPreference = screen.findPreference(mPreferenceKey);
}
@Override
public void onStart() {
mUtils.registerToggleAwareObserver(this);
}
@Override
public void onStop() {
mUtils.unregisterToggleAwareObserver();
}
@Override
public void onChange(Uri uri) {
updateState(mTimeoutPreference);
}
private String getTimeoutValue() {
return String.valueOf(OneHandedSettingsUtils.getTimeoutValue(mContext));
}
private void initTimeoutMap() {
if (mTimeoutMap.size() != 0) {
return;
}
final String[] timeoutValues = mContext.getResources().getStringArray(
R.array.one_handed_timeout_values);
final String[] timeoutTitles = mContext.getResources().getStringArray(
R.array.one_handed_timeout_title);
if (timeoutValues.length != timeoutTitles.length) {
return;
}
for (int i = 0; i < timeoutValues.length; i++) {
mTimeoutMap.put(timeoutValues[i], timeoutTitles[i]);
}
}
}

71
src/com/android/settings/gestures/SwipeBottomToNotificationPreferenceController.java
View File

@@ -1,71 +0,0 @@
/*
* Copyright (C) 2020 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.gestures;
import android.content.Context;
import com.android.settings.R;
import com.android.settings.core.TogglePreferenceController;
/**
* Handles swipe bottom to expand notification panel gesture.
**/
public class SwipeBottomToNotificationPreferenceController extends TogglePreferenceController {
public SwipeBottomToNotificationPreferenceController(Context context, String key) {
super(context, key);
}
@Override
public int getAvailabilityStatus() {
return OneHandedSettingsUtils.isFeatureAvailable(mContext)
? AVAILABLE : UNSUPPORTED_ON_DEVICE;
}
@Override
public boolean isSliceable() {
return true;
}
@Override
public boolean isPublicSlice() {
return true;
}
@Override
public boolean setChecked(boolean isChecked) {
if (isChecked) {
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, false);
}
OneHandedSettingsUtils.setSwipeDownNotificationEnabled(mContext, isChecked);
return true;
}
@Override
public boolean isChecked() {
return OneHandedSettingsUtils.isSwipeDownNotificationEnabled(mContext);
}
@Override
public CharSequence getSummary() {
// This toggle preference summary will be updated in gesture preference page since we bound
// it with entry preference in gesture.xml
return mContext.getText(
isChecked() ? R.string.gesture_setting_on : R.string.gesture_setting_off);
}
}

59
src/com/android/settings/gestures/SwipeBottomToNotificationSettings.java
View File

@@ -1,59 +0,0 @@
/*
* Copyright (C) 2020 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.gestures;
import android.app.settings.SettingsEnums;
import android.content.Context;
import com.android.settings.R;
import com.android.settings.dashboard.DashboardFragment;
import com.android.settings.search.BaseSearchIndexProvider;
/**
* The Fragment for swipe bottom to notification gesture settings.
*/
public class SwipeBottomToNotificationSettings extends DashboardFragment {
private static final String TAG = "SwipeBottomToNotificationSettings";
@Override
public int getMetricsCategory() {
return SettingsEnums.SETTINGS_SWIPE_BOTTOM_TO_NOTIFICATION;
}
@Override
protected String getLogTag() {
return TAG;
}
@Override
protected int getPreferenceScreenResId() {
return R.xml.swipe_bottom_to_notification_settings;
}
public static final BaseSearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
new BaseSearchIndexProvider(R.xml.swipe_bottom_to_notification_settings) {
@Override
protected boolean isPageSearchEnabled(Context context) {
if (!OneHandedSettingsUtils.isSupportOneHandedMode()) {
return false;
}
return !OneHandedSettingsUtils.isOneHandedModeEnabled(context);
}
};
}

111
tests/robotests/src/com/android/settings/gestures/OneHandedTimeoutPreferenceControllerTest.java
View File

@@ -1,111 +0,0 @@
/*
* Copyright (C) 2020 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.gestures;
import static com.google.common.truth.Truth.assertThat;
import android.content.Context;
import android.os.UserHandle;
import androidx.preference.ListPreference;
import com.android.settings.R;
import com.android.settings.core.BasePreferenceController;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
@RunWith(RobolectricTestRunner.class)
public class OneHandedTimeoutPreferenceControllerTest {
private static final String KEY = "gesture_one_handed_timeout";
private Context mContext;
private OneHandedTimeoutPreferenceController mController;
private ListPreference mPreference;
@Before
public void setUp() {
mContext = RuntimeEnvironment.application;
mController = new OneHandedTimeoutPreferenceController(mContext, KEY);
mPreference = new ListPreference(mContext);
mPreference.setKey(KEY);
OneHandedSettingsUtils.setUserId(UserHandle.myUserId());
}
@Test
public void getAvailabilityStatus_enabledOneHanded_shouldAvailable() {
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, true);
assertThat(mController.getAvailabilityStatus())
.isEqualTo(BasePreferenceController.AVAILABLE);
}
@Test
public void getAvailabilityStatus_disableOneHanded_shouldUnavailable() {
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, false);
assertThat(mController.getAvailabilityStatus())
.isEqualTo(BasePreferenceController.DISABLED_DEPENDENT_SETTING);
}
@Test
public void updateState_enableOneHanded_switchShouldEnabled() {
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, true);
mController.updateState(mPreference);
assertThat(mPreference.isEnabled()).isTrue();
}
@Test
public void updateState_disableOneHanded_switchShouldDisabled() {
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, false);
mController.updateState(mPreference);
assertThat(mPreference.isEnabled()).isFalse();
}
@Test
public void getSummary_setTimeoutNever_shouldReturnNeverSummary() {
final String[] timeoutTitles = mContext.getResources().getStringArray(
R.array.one_handed_timeout_title);
OneHandedSettingsUtils.setTimeoutValue(mContext,
OneHandedSettingsUtils.OneHandedTimeout.NEVER.getValue());
assertThat(mController.getSummary()).isEqualTo(
timeoutTitles[OneHandedSettingsUtils.OneHandedTimeout.NEVER.ordinal()]);
}
@Test
public void getSummary_setTimeoutShort_shouldReturnShortSummary() {
final String[] timeoutTitles = mContext.getResources().getStringArray(
R.array.one_handed_timeout_title);
OneHandedSettingsUtils.setTimeoutValue(mContext,
OneHandedSettingsUtils.OneHandedTimeout.SHORT.getValue());
assertThat(mController.getSummary()).isEqualTo(String.format(
mContext.getResources().getString(R.string.screen_timeout_summary),
timeoutTitles[OneHandedSettingsUtils.OneHandedTimeout.SHORT.ordinal()]));
}
}

134
tests/robotests/src/com/android/settings/gestures/SwipeBottomToNotificationPreferenceControllerTest.java
View File

@@ -1,134 +0,0 @@
/*
* Copyright (C) 2020 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.gestures;
import static com.android.settings.core.BasePreferenceController.AVAILABLE;
import static com.google.common.truth.Truth.assertThat;
import android.content.Context;
import android.os.SystemProperties;
import android.os.UserHandle;
import android.provider.Settings;
import com.android.settings.R;
import com.android.settings.core.BasePreferenceController;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Answers;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
@RunWith(RobolectricTestRunner.class)
public class SwipeBottomToNotificationPreferenceControllerTest {
private static final String KEY = "gesture_swipe_bottom_to_notification";
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private SwipeBottomToNotificationPreferenceController mController;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mController = new SwipeBottomToNotificationPreferenceController(mContext, KEY);
}
@Test
public void setChecked_toggledOn_enablesSwipeBottomToNotification() {
mController.setChecked(true);
assertThat(OneHandedSettingsUtils.isSwipeDownNotificationEnabled(mContext)).isTrue();
assertThat(OneHandedSettingsUtils.isOneHandedModeEnabled(mContext)).isFalse();
}
@Test
public void setChecked_toggledOff_disablesSwipeBottomToNotification() {
mController.setChecked(false);
assertThat(OneHandedSettingsUtils.isSwipeDownNotificationEnabled(mContext)).isFalse();
}
@Test
public void getAvailabilityStatus_oneHandedUnsupported_returnsUnsupport() {
SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "false");
setNavigationBarMode(mContext, "2" /* fully gestural */);
assertThat(mController.getAvailabilityStatus()).isEqualTo(
BasePreferenceController.UNSUPPORTED_ON_DEVICE);
}
@Test
public void getAvailabilityStatus_oneHandedSupported_returnsAvailable() {
SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "true");
setNavigationBarMode(mContext, "2" /* fully gestural */);
assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
}
@Test
public void getAvailabilityStatus_set3ButtonModeProperty_returnsUnsupport() {
SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "true");
setNavigationBarMode(mContext, "0" /* 3-button */);
assertThat(mController.getAvailabilityStatus())
.isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE);
}
@Test
public void getSummary_gestureEnabled_returnsOnSummary() {
mController.setChecked(true);
assertThat(mController.getSummary()).isEqualTo(
mContext.getText(R.string.gesture_setting_on));
}
@Test
public void getSummary_gestureDisabled_returnsOffSummary() {
mController.setChecked(false);
assertThat(mController.getSummary()).isEqualTo(
mContext.getText(R.string.gesture_setting_off));
}
@Test
public void isChecked_getDefaultConfig_returnFalse() {
SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "false");
Settings.Secure.resetToDefaults(mContext.getContentResolver(),
Settings.Secure.ONE_HANDED_MODE_ENABLED);
assertThat(mController.isChecked()).isFalse();
}
/**
* Set NavigationBar mode flag to Settings provider.
* @param context App context
* @param value Navigation bar mode:
* 0 = 3 button
* 1 = 2 button
* 2 = fully gestural
* @return true if the value was set, false on database errors.
*/
private boolean setNavigationBarMode(Context context, String value) {
return Settings.Secure.putStringForUser(context.getContentResolver(),
Settings.Secure.NAVIGATION_MODE, value, UserHandle.myUserId());
}
}

102
tests/robotests/src/com/android/settings/gestures/SwipeBottomToNotificationSettingsTest.java
View File

@@ -1,102 +0,0 @@
/*
* Copyright (C) 2020 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.gestures;
import static com.google.common.truth.Truth.assertThat;
import android.content.Context;
import android.os.SystemProperties;
import android.provider.SearchIndexableResource;
import com.android.settings.R;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Answers;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.util.ReflectionHelpers;
import java.util.List;
@RunWith(RobolectricTestRunner.class)
public class SwipeBottomToNotificationSettingsTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private SwipeBottomToNotificationSettings mSettings = new SwipeBottomToNotificationSettings();
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void getPreferenceScreenResId_shouldReturnsXml() {
assertThat(mSettings.getPreferenceScreenResId())
.isEqualTo(R.xml.swipe_bottom_to_notification_settings);
}
@Test
public void searchIndexProvider_shouldIndexResource() {
final List<SearchIndexableResource> indexRes =
SwipeBottomToNotificationSettings.SEARCH_INDEX_DATA_PROVIDER.getXmlResourcesToIndex(
mContext, true /* enabled */);
assertThat(indexRes.get(0).xmlResId).isEqualTo(mSettings.getPreferenceScreenResId());
}
@Test
public void isPageSearchEnabled_oneHandedUnsupported_shouldReturnFalse() {
SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "false");
final Object obj = ReflectionHelpers.callInstanceMethod(
SwipeBottomToNotificationSettings.SEARCH_INDEX_DATA_PROVIDER, "isPageSearchEnabled",
ReflectionHelpers.ClassParameter.from(Context.class, mContext));
final boolean isEnabled = (Boolean) obj;
assertThat(isEnabled).isFalse();
}
@Test
public void isPageSearchEnabled_oneHandedDisabled_shouldReturnTrue() {
SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "true");
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, false);
final Object obj = ReflectionHelpers.callInstanceMethod(
SwipeBottomToNotificationSettings.SEARCH_INDEX_DATA_PROVIDER, "isPageSearchEnabled",
ReflectionHelpers.ClassParameter.from(Context.class, mContext));
final boolean isEnabled = (Boolean) obj;
assertThat(isEnabled).isTrue();
}
@Test
public void isPageSearchEnabled_oneHandedEnabled_shouldReturnFalse() {
SystemProperties.set(OneHandedSettingsUtils.SUPPORT_ONE_HANDED_MODE, "true");
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, true);
final Object obj = ReflectionHelpers.callInstanceMethod(
SwipeBottomToNotificationSettings.SEARCH_INDEX_DATA_PROVIDER, "isPageSearchEnabled",
ReflectionHelpers.ClassParameter.from(Context.class, mContext));
final boolean isEnabled = (Boolean) obj;
assertThat(isEnabled).isFalse();
}
}

94
tests/unit/src/com/android/settings/gestures/OneHandedAppTapsExitPreferenceControllerTest.java
View File

@@ -1,94 +0,0 @@
/*
* Copyright (C) 2020 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.gestures;
import static com.google.common.truth.Truth.assertThat;
import android.content.Context;
import android.os.UserHandle;
import androidx.preference.SwitchPreference;
import androidx.test.core.app.ApplicationProvider;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import com.android.settings.core.TogglePreferenceController;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(AndroidJUnit4.class)
public class OneHandedAppTapsExitPreferenceControllerTest {
private static final String KEY = "gesture_app_taps_to_exit";
private Context mContext;
private SwitchPreference mSwitchPreference;
private OneHandedAppTapsExitPreferenceController mController;
@Before
public void setUp() {
mContext = ApplicationProvider.getApplicationContext();
mController = new OneHandedAppTapsExitPreferenceController(mContext, KEY);
mSwitchPreference = new SwitchPreference(mContext);
mSwitchPreference.setKey(KEY);
OneHandedSettingsUtils.setUserId(UserHandle.myUserId());
}
@Test
public void setChecked_setBoolean_checkIsTrueOrFalse() {
mController.setChecked(false);
assertThat(mController.isChecked()).isFalse();
mController.setChecked(true);
assertThat(mController.isChecked()).isTrue();
}
@Test
public void getAvailabilityStatus_enabledOneHanded_shouldAvailable() {
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, true);
assertThat(mController.getAvailabilityStatus())
.isEqualTo(TogglePreferenceController.AVAILABLE);
}
@Test
public void getAvailabilityStatus_disabledOneHanded_shouldUnavailable() {
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, false);
assertThat(mController.getAvailabilityStatus())
.isEqualTo(TogglePreferenceController.DISABLED_DEPENDENT_SETTING);
}
@Test
public void updateState_enableOneHanded_switchShouldEnabled() {
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, true);
mController.updateState(mSwitchPreference);
assertThat(mSwitchPreference.isEnabled()).isTrue();
}
@Test
public void updateState_disableOneHanded_switchShouldDisabled() {
OneHandedSettingsUtils.setOneHandedModeEnabled(mContext, false);
mController.updateState(mSwitchPreference);
assertThat(mSwitchPreference.isEnabled()).isFalse();
}
}