--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ 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.
+ -->
+
+<LinearLayout
+ xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:background="@drawable/selectable_card_grey"
+ android:gravity="center_vertical"
+ android:minHeight="?android:attr/listPreferredItemHeight"
+ android:orientation="vertical"
+ android:paddingEnd="?android:attr/scrollbarSize">
+ <TextView
+ android:id="@android:id/title"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:layout_gravity="center"/>
+</LinearLayout>
\ No newline at end of file
/**
* Updates the current status of preference (summary, switch state, etc)
*/
- public void updateState(PreferenceScreen screen) {
+ public void updateState(Preference preference) {
+
}
/**
public abstract boolean handlePreferenceTreeClick(Preference preference);
/**
+ * Returns the key for this preference.
+ */
+ public abstract String getPreferenceKey();
+
+ /**
* Removes preference from screen.
*/
protected final void removePreference(PreferenceScreen screen, String key) {
* Returns true if preference is available (should be displayed)
*/
protected abstract boolean isAvailable();
-
- /**
- * Returns the key for this preference.
- */
- protected abstract String getPreferenceKey();
-
}
@CallSuper
@Override
public void onCreate(Bundle savedInstanceState) {
- super.onCreate(savedInstanceState);
mLifecycle.onCreate(savedInstanceState);
+ super.onCreate(savedInstanceState);
}
@CallSuper
public abstract class DashboardFragment extends SettingsPreferenceFragment
implements SettingsDrawerActivity.CategoryListener, Indexable,
SummaryLoader.SummaryConsumer {
+ private static final String TAG = "DashboardFragment";
private final Map<Class, PreferenceController> mPreferenceControllers =
new ArrayMap<>();
private final Set<String> mDashboardTilePrefKeys = new ArraySet<>();
private DashboardDividerDecoration mDividerDecoration;
+ protected ProgressiveDisclosureMixin mProgressiveDisclosureMixin;
protected DashboardFeatureProvider mDashboardFeatureProvider;
private boolean mListeningToCategoryChange;
private SummaryLoader mSummaryLoader;
super.onAttach(context);
mDashboardFeatureProvider =
FeatureFactory.getFactory(context).getDashboardFeatureProvider(context);
+ mProgressiveDisclosureMixin = new ProgressiveDisclosureMixin(context, this);
+ getLifecycle().addObserver(mProgressiveDisclosureMixin);
final List<PreferenceController> controllers = getPreferenceControllers(context);
if (controllers == null) {
}
}
+ @Override
+ public Preference findPreference(CharSequence key) {
+ Preference preference = super.findPreference(key);
+ if (preference == null && mProgressiveDisclosureMixin != null) {
+ preference = mProgressiveDisclosureMixin.findPreference(key);
+ }
+ if (preference == null) {
+ Log.d(TAG, "Cannot find preference with key " + key);
+ }
+ return preference;
+ }
+
protected <T extends PreferenceController> T getPreferenceController(Class<T> clazz) {
PreferenceController controller = mPreferenceControllers.get(clazz);
return (T) controller;
// (larger value has higher priority). However pref order defines smaller value has
// higher priority.
pref.setOrder(-tile.priority);
- screen.addPreference(pref);
+
+ // Either add to screen, or to collapsed list.
+ if (mProgressiveDisclosureMixin.isCollapsed()) {
+ // Already collapsed, add to collapsed list.
+ mProgressiveDisclosureMixin.addToCollapsedList(pref);
+ } else if (mProgressiveDisclosureMixin.shouldCollapse(screen)) {
+ // About to have too many tiles on scree, collapse and add pref to collapsed list.
+ mProgressiveDisclosureMixin.collapse(screen);
+ mProgressiveDisclosureMixin.addToCollapsedList(pref);
+ } else {
+ // No need to collapse, add to screen directly.
+ screen.addPreference(pref);
+ }
}
}
*/
private void updatePreferenceStates() {
Collection<PreferenceController> controllers = mPreferenceControllers.values();
- final PreferenceScreen screen = getPreferenceScreen();
for (PreferenceController controller : controllers) {
- controller.updateState(screen);
+ final String key = controller.getPreferenceKey();
+
+ final Preference preference = findPreference(key);
+ if (preference == null) {
+ Log.d(TAG, "Cannot find preference with key " + key);
+ continue;
+ }
+ controller.updateState(preference);
}
}
*/
private void refreshAllPreferences(final String TAG) {
// First remove old preferences.
- final PreferenceScreen screen = getPreferenceScreen();
- if (screen != null) {
- screen.removeAll();
+ if (getPreferenceScreen() != null) {
+ // Intentionally do not cache PreferenceScreen because it will be recreated later.
+ getPreferenceScreen().removeAll();
}
// Add resource based tiles.
displayResourceTiles();
refreshDashboardTiles(TAG);
+
+ if (!mProgressiveDisclosureMixin.isCollapsed()
+ && mProgressiveDisclosureMixin.shouldCollapse(getPreferenceScreen())) {
+ mProgressiveDisclosureMixin.collapse(getPreferenceScreen());
+ }
}
/**
private void refreshDashboardTiles(final String TAG) {
final PreferenceScreen screen = getPreferenceScreen();
for (String key : mDashboardTilePrefKeys) {
+ // Remove tiles from screen
final Preference pref = screen.findPreference(key);
if (pref != null) {
screen.removePreference(pref);
}
+ // Also remove tile from collapsed set
+ mProgressiveDisclosureMixin.removePreference(screen, key);
}
mDashboardTilePrefKeys.clear();
displayDashboardTiles(TAG, getPreferenceScreen());
--- /dev/null
+/*
+ * 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.dashboard;
+
+import android.content.Context;
+import android.support.v7.preference.Preference;
+import android.util.AttributeSet;
+
+import com.android.settings.R;
+
+public class ExpandPreference extends Preference {
+
+ public ExpandPreference(Context context, AttributeSet attrs,
+ int defStyleAttr, int defStyleRes) {
+ super(context, attrs, defStyleAttr, defStyleRes);
+ init();
+ }
+
+ public ExpandPreference(Context context, AttributeSet attrs, int defStyleAttr) {
+ super(context, attrs, defStyleAttr);
+ init();
+ }
+
+ public ExpandPreference(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ init();
+ }
+
+ public ExpandPreference(Context context) {
+ super(context);
+ init();
+ }
+
+ private void init() {
+ setLayoutResource(R.layout.expand_preference);
+ setTitle(R.string.wifi_more);
+ setOrder(999);
+ }
+}
--- /dev/null
+/*
+ * 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.dashboard;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.support.v14.preference.PreferenceFragment;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceScreen;
+import android.text.TextUtils;
+import android.util.Log;
+
+import com.android.settings.core.lifecycle.LifecycleObserver;
+import com.android.settings.core.lifecycle.events.OnCreate;
+import com.android.settings.core.lifecycle.events.OnSaveInstanceState;
+import com.android.settings.overlay.FeatureFactory;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ProgressiveDisclosureMixin implements Preference.OnPreferenceClickListener,
+ LifecycleObserver, OnCreate, OnSaveInstanceState {
+
+ private static final String TAG = "ProgressiveDisclosure";
+ private static final String STATE_USER_EXPANDED = "state_user_expanded";
+ private static final int DEFAULT_TILE_LIMIT = 3;
+
+ private int mTileLimit = DEFAULT_TILE_LIMIT;
+
+ private final DashboardFeatureProvider mDashboardFeatureProvider;
+ private final List<Preference> collapsedPrefs = new ArrayList<>();
+ private final ExpandPreference mExpandButton;
+ private final PreferenceFragment mFragment;
+
+ private boolean mUserExpanded;
+
+ public ProgressiveDisclosureMixin(Context context, PreferenceFragment fragment) {
+ mFragment = fragment;
+ mExpandButton = new ExpandPreference(context);
+ mExpandButton.setOnPreferenceClickListener(this);
+ mDashboardFeatureProvider = FeatureFactory.getFactory(context)
+ .getDashboardFeatureProvider(context);
+ }
+
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ if (savedInstanceState != null) {
+ mUserExpanded = savedInstanceState.getBoolean(STATE_USER_EXPANDED, false);
+ }
+ }
+
+ @Override
+ public void onSaveInstanceState(Bundle outState) {
+ outState.putBoolean(STATE_USER_EXPANDED, mUserExpanded);
+ }
+
+ @Override
+ public boolean onPreferenceClick(Preference preference) {
+ if (preference instanceof ExpandPreference) {
+ final PreferenceScreen screen = mFragment.getPreferenceScreen();
+ if (screen != null) {
+ screen.removePreference(preference);
+ for (Preference pref : collapsedPrefs) {
+ screen.addPreference(pref);
+ }
+ mUserExpanded = true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Sets the threshold to start collapsing preferences when there are too many.
+ */
+ public void setTileLimit(int limit) {
+ mTileLimit = limit;
+ }
+
+ /**
+ * Whether the controller is in collapsed state.
+ */
+ public boolean isCollapsed() {
+ return !collapsedPrefs.isEmpty();
+ }
+
+ /**
+ * Whether the screen should be collapsed.
+ */
+ public boolean shouldCollapse(PreferenceScreen screen) {
+ return mDashboardFeatureProvider.isEnabled() && screen.getPreferenceCount() >= mTileLimit
+ && !mUserExpanded;
+ }
+
+ /**
+ * Collapse extra preferences and show a "More" button
+ */
+ public void collapse(PreferenceScreen screen) {
+ final int itemCount = screen.getPreferenceCount();
+ if (!shouldCollapse(screen)) {
+ return;
+ }
+ if (!collapsedPrefs.isEmpty()) {
+ Log.w(TAG, "collapsed list should ALWAYS BE EMPTY before collapsing!");
+ }
+
+ for (int i = itemCount - 1; i >= mTileLimit; i--) {
+ final Preference preference = screen.getPreference(i);
+ addToCollapsedList(preference);
+ screen.removePreference(preference);
+ }
+ screen.addPreference(mExpandButton);
+ }
+
+ /**
+ * Add preference to collapsed list.
+ */
+ public void addToCollapsedList(Preference preference) {
+ collapsedPrefs.add(preference);
+ }
+
+ /**
+ * Remove preference from collapsed list. If the preference is not in list, do nothing.
+ */
+ public void removePreference(PreferenceScreen screen, String key) {
+ if (!isCollapsed()) {
+ return;
+ }
+ for (int i = 0; i < collapsedPrefs.size(); i++) {
+ final Preference pref = collapsedPrefs.get(i);
+ if (TextUtils.equals(key, pref.getKey())) {
+ collapsedPrefs.remove(pref);
+ if (collapsedPrefs.isEmpty()) {
+ // Removed last element, remove expand button too.
+ screen.removePreference(mExpandButton);
+ }
+ return;
+ }
+ }
+ }
+
+ /**
+ * Find whether a preference is in collapsed list.
+ */
+ public Preference findPreference(CharSequence key) {
+ for (int i = 0; i < collapsedPrefs.size(); i++) {
+ final Preference pref = collapsedPrefs.get(i);
+ if (TextUtils.equals(key, pref.getKey())) {
+ return pref;
+ }
+ }
+ return null;
+ }
+
+}
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_UPDATE_SETTING;
}
}
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_MANAGE_STORAGE;
}
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_SYSTEM_UPDATE_SETTINGS;
}
import android.provider.Settings;
import android.support.v14.preference.SwitchPreference;
import android.support.v7.preference.Preference;
-import android.support.v7.preference.PreferenceScreen;
import com.android.settings.core.PreferenceController;
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_AUTO_BRIGHTNESS;
}
}
@Override
- public void updateState(PreferenceScreen screen) {
- final SwitchPreference preference =
- (SwitchPreference) screen.findPreference(KEY_AUTO_BRIGHTNESS);
- if (preference == null) {
- return;
- }
+ public void updateState(Preference preference) {
int brightnessMode = Settings.System.getInt(mContext.getContentResolver(),
SCREEN_BRIGHTNESS_MODE, SCREEN_BRIGHTNESS_MODE_MANUAL);
- preference.setChecked(brightnessMode != SCREEN_BRIGHTNESS_MODE_MANUAL);
+ ((SwitchPreference) preference).setChecked(brightnessMode != SCREEN_BRIGHTNESS_MODE_MANUAL);
}
@Override
import android.content.res.Configuration;
import android.support.v7.preference.DropDownPreference;
import android.support.v7.preference.Preference;
-import android.support.v7.preference.PreferenceScreen;
import com.android.internal.logging.MetricsProto;
import com.android.internal.view.RotationPolicy;
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_AUTO_ROTATE;
}
@Override
- public void updateState(PreferenceScreen screen) {
- final DropDownPreference rotatePreference =
- (DropDownPreference) screen.findPreference(KEY_AUTO_ROTATE);
+ public void updateState(Preference preference) {
+ final DropDownPreference rotatePreference = (DropDownPreference) preference;
final int rotateLockedResourceId;
// The following block sets the string used when rotation is locked.
// If the device locks specifically to portrait or landscape (rather than current
1 : 0);
}
-
@Override
public boolean handlePreferenceTreeClick(Preference preference) {
return false;
import android.provider.Settings;
import android.support.v14.preference.SwitchPreference;
import android.support.v7.preference.Preference;
-import android.support.v7.preference.PreferenceScreen;
import com.android.settings.core.PreferenceController;
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_CAMERA_GESTURE;
}
}
@Override
- public void updateState(PreferenceScreen screen) {
- final SwitchPreference preference =
- (SwitchPreference) screen.findPreference(KEY_CAMERA_GESTURE);
- if (preference != null) {
- int value = Settings.Secure.getInt(mContext.getContentResolver(),
- CAMERA_GESTURE_DISABLED, 0);
- preference.setChecked(value == 0);
- }
+ public void updateState(Preference preference) {
+ int value = Settings.Secure.getInt(mContext.getContentResolver(),
+ CAMERA_GESTURE_DISABLED, 0);
+ ((SwitchPreference) preference).setChecked(value == 0);
}
@Override
import android.provider.Settings;
import android.support.v14.preference.SwitchPreference;
import android.support.v7.preference.Preference;
-import android.support.v7.preference.PreferenceScreen;
import android.text.TextUtils;
import com.android.settings.core.PreferenceController;
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_DOZE;
}
}
@Override
- public void updateState(PreferenceScreen screen) {
- final SwitchPreference preference = (SwitchPreference) screen.findPreference(KEY_DOZE);
- // Update doze if it is available.
- if (preference != null) {
- int value = Settings.Secure.getInt(mContext.getContentResolver(), DOZE_ENABLED, 1);
- preference.setChecked(value != 0);
- }
+ public void updateState(Preference preference) {
+ int value = Settings.Secure.getInt(mContext.getContentResolver(), DOZE_ENABLED, 1);
+ ((SwitchPreference) preference).setChecked(value != 0);
}
@Override
import android.content.res.Resources;
import android.provider.Settings;
import android.support.v7.preference.Preference;
-import android.support.v7.preference.PreferenceScreen;
import com.android.settings.R;
import com.android.settings.accessibility.ToggleFontSizePreferenceFragment;
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_FONT_SIZE;
}
@Override
- public void updateState(PreferenceScreen screen) {
- final Preference preference = screen.findPreference(KEY_FONT_SIZE);
- if (preference == null) {
- return;
- }
+ public void updateState(Preference preference) {
final float currentScale = Settings.System.getFloat(mContext.getContentResolver(),
Settings.System.FONT_SCALE, 1.0f);
final Resources res = mContext.getResources();
import android.provider.Settings;
import android.support.v14.preference.SwitchPreference;
import android.support.v7.preference.Preference;
-import android.support.v7.preference.PreferenceScreen;
import com.android.settings.core.PreferenceController;
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_LIFT_TO_WAKE;
}
}
@Override
- public void updateState(PreferenceScreen screen) {
- final SwitchPreference pref = (SwitchPreference) screen.findPreference(KEY_LIFT_TO_WAKE);
- // Update lift-to-wake if it is available.
- if (pref != null) {
- int value =
- Settings.Secure.getInt(mContext.getContentResolver(), WAKE_GESTURE_ENABLED, 0);
- pref.setChecked(value != 0);
- }
+ public void updateState(Preference preference) {
+ int value = Settings.Secure.getInt(mContext.getContentResolver(), WAKE_GESTURE_ENABLED, 0);
+ ((SwitchPreference) preference).setChecked(value != 0);
}
}
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_NIGHT_DISPLAY;
}
}
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_NIGHT_MODE;
}
import android.content.Context;
import android.support.v7.preference.Preference;
-import android.support.v7.preference.PreferenceScreen;
import com.android.settings.DreamSettings;
import com.android.settings.core.PreferenceController;
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_SCREEN_SAVER;
}
}
@Override
- public void updateState(PreferenceScreen screen) {
- final Preference preference = screen.findPreference(KEY_SCREEN_SAVER);
- if (preference != null) {
- preference.setSummary(
- DreamSettings.getSummaryTextWithDreamName(mContext));
- }
+ public void updateState(Preference preference) {
+ preference.setSummary(DreamSettings.getSummaryTextWithDreamName(mContext));
}
}
import android.provider.Settings;
import android.support.v14.preference.SwitchPreference;
import android.support.v7.preference.Preference;
-import android.support.v7.preference.PreferenceScreen;
import com.android.settings.core.PreferenceController;
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_TAP_TO_WAKE;
}
}
@Override
- public void updateState(PreferenceScreen screen) {
- final SwitchPreference preference =
- (SwitchPreference) screen.findPreference(KEY_TAP_TO_WAKE);
- if (preference != null) {
- int value = Settings.Secure.getInt(
- mContext.getContentResolver(), Settings.Secure.DOUBLE_TAP_TO_WAKE, 0);
- preference.setChecked(value != 0);
- }
+ public void updateState(Preference preference) {
+ int value = Settings.Secure.getInt(
+ mContext.getContentResolver(), Settings.Secure.DOUBLE_TAP_TO_WAKE, 0);
+ ((SwitchPreference) preference).setChecked(value != 0);
}
@Override
import android.os.UserHandle;
import android.provider.Settings;
import android.support.v7.preference.Preference;
-import android.support.v7.preference.PreferenceScreen;
import android.util.Log;
import com.android.settings.R;
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_SCREEN_TIMEOUT;
}
}
@Override
- public void updateState(PreferenceScreen screen) {
- final TimeoutListPreference preference =
- (TimeoutListPreference) screen.findPreference(KEY_SCREEN_TIMEOUT);
- if (preference == null) {
- return;
- }
+ 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);
- preference.setValue(String.valueOf(currentTimeout));
+ timeoutListPreference.setValue(String.valueOf(currentTimeout));
final DevicePolicyManager dpm = (DevicePolicyManager) mContext.getSystemService(
Context.DEVICE_POLICY_SERVICE);
if (dpm != null) {
RestrictedLockUtils.checkIfMaximumTimeToLockIsSet(mContext);
final long maxTimeout =
dpm.getMaximumTimeToLockForUserAndProfiles(UserHandle.myUserId());
- preference.removeUnusableTimeouts(maxTimeout, admin);
+ timeoutListPreference.removeUnusableTimeouts(maxTimeout, admin);
}
- updateTimeoutPreferenceDescription(preference, currentTimeout);
+ updateTimeoutPreferenceDescription(timeoutListPreference, currentTimeout);
}
@Override
import android.provider.Settings;
import android.support.v7.preference.DropDownPreference;
import android.support.v7.preference.Preference;
-import android.support.v7.preference.PreferenceScreen;
import android.util.Log;
import com.android.settings.R;
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_VR_DISPLAY_PREF;
}
@Override
- public void updateState(PreferenceScreen screen) {
- final DropDownPreference pref =
- (DropDownPreference) screen.findPreference(KEY_VR_DISPLAY_PREF);
- if (pref == null) {
- Log.d(TAG, "Could not find VR display preference.");
- return;
- }
+ public void updateState(Preference preference) {
+ final DropDownPreference pref = (DropDownPreference) preference;
pref.setEntries(new CharSequence[]{
mContext.getString(R.string.display_vr_pref_low_persistence),
mContext.getString(R.string.display_vr_pref_off),
import android.content.Context;
import android.os.UserHandle;
import android.support.v7.preference.Preference;
-import android.support.v7.preference.PreferenceScreen;
import com.android.settings.core.PreferenceController;
import com.android.settingslib.RestrictedLockUtils;
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_WALLPAPER;
}
@Override
- public void updateState(PreferenceScreen screen) {
- disablePreferenceIfManaged(screen);
+ public void updateState(Preference preference) {
+ disablePreferenceIfManaged((RestrictedPreference) preference);
}
@Override
return false;
}
- private void disablePreferenceIfManaged(PreferenceScreen screen) {
- final RestrictedPreference pref =
- (RestrictedPreference) screen.findPreference(KEY_WALLPAPER);
+ private void disablePreferenceIfManaged(RestrictedPreference pref) {
final String restriction = DISALLOW_SET_WALLPAPER;
if (pref != null) {
pref.setDisabledByAdmin(null);
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_TOGGLE_AIRPLANE;
}
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_MOBILE_NETWORK_SETTINGS;
}
}
return isPrefAllowedForUser && isPrefAllowedOnDevice;
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_MANAGE_MOBILE_PLAN;
}
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_NETWORK_RESET;
}
}
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_PROXY_SETTINGS;
}
}
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_TETHER_SETTINGS;
}
}
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_VPN_SETTINGS;
}
}
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_WFC_SETTINGS;
}
}
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return null;
}
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return KEY_PREF;
}
}
mDashboardCategory.tiles = new ArrayList<>();
mDashboardCategory.tiles.add(new Tile());
mTestFragment = new TestFragment(ShadowApplication.getInstance().getApplicationContext());
- mTestFragment.onAttach(mContext);
+ mTestFragment.onAttach(ShadowApplication.getInstance().getApplicationContext());
when(mFakeFeatureFactory.dashboardFeatureProvider.getTilesForCategory(anyString()))
.thenReturn(mDashboardCategory);
}
}
@Override
- protected String getPreferenceKey() {
+ public String getPreferenceKey() {
return null;
}
--- /dev/null
+/*
+ * 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.dashboard;
+
+import android.content.Context;
+import android.support.v14.preference.PreferenceFragment;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceScreen;
+
+import com.android.settings.TestConfig;
+import com.android.settings.overlay.FeatureFactory;
+import com.android.settings.testutils.FakeFeatureFactory;
+
+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.annotation.Config;
+import org.robolectric.shadows.ShadowApplication;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
+public class ProgressiveDisclosureTest {
+
+ @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+ private Context mContext;
+ @Mock
+ private FakeFeatureFactory mFakeFeatureFactory;
+ @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+ private PreferenceFragment mPreferenceFragment;
+ private Context mAppContext;
+ private Preference mPreference;
+
+ private ProgressiveDisclosureMixin mMixin;
+
+ @Before
+ public void setUp() {
+ MockitoAnnotations.initMocks(this);
+ FakeFeatureFactory.setupForTest(mContext);
+ mAppContext = ShadowApplication.getInstance().getApplicationContext();
+ mFakeFeatureFactory = (FakeFeatureFactory) FeatureFactory.getFactory(mContext);
+ mMixin = new ProgressiveDisclosureMixin(mAppContext, mPreferenceFragment);
+ mPreference = new Preference(mAppContext);
+ mPreference.setKey("test");
+ when(mFakeFeatureFactory.dashboardFeatureProvider.isEnabled()).thenReturn(true);
+ }
+
+ @Test
+ public void shouldNotCollapse_lessPreferenceThanLimit() {
+ when(mPreferenceFragment.getPreferenceScreen().getPreferenceCount()).thenReturn(5);
+
+ mMixin.setTileLimit(10);
+
+ assertThat(mMixin.shouldCollapse(mPreferenceFragment.getPreferenceScreen())).isFalse();
+ }
+
+ @Test
+ public void shouldCollapse_morePreferenceThanLimit() {
+ when(mFakeFeatureFactory.dashboardFeatureProvider.isEnabled()).thenReturn(true);
+ when(mPreferenceFragment.getPreferenceScreen().getPreferenceCount()).thenReturn(5);
+
+ assertThat(mMixin.shouldCollapse(mPreferenceFragment.getPreferenceScreen())).isTrue();
+ }
+
+ @Test
+ public void findPreference_prefInCollapsedList_shouldFindIt() {
+ mMixin.addToCollapsedList(mPreference);
+
+ Preference pref = mMixin.findPreference(mPreference.getKey());
+
+ assertThat(pref).isNotNull();
+ assertThat(pref).isSameAs(mPreference);
+ }
+
+ @Test
+ public void findPreference_prefNotInCollapsedList_shouldNotFindIt() {
+ Preference pref = mMixin.findPreference(mPreference.getKey());
+
+ assertThat(pref).isNull();
+ }
+
+ @Test
+ public void findPreference_prefRemovedFromCollapsedList_shouldNotFindIt() {
+ mMixin.addToCollapsedList(mPreference);
+ mMixin.removePreference(mPreferenceFragment.getPreferenceScreen(), mPreference.getKey());
+ Preference pref = mMixin.findPreference(mPreference.getKey());
+
+ assertThat(pref).isNull();
+ }
+
+ @Test
+ public void removeLastPreference_shouldRemoveExpandButtonToo() {
+ mMixin.addToCollapsedList(mPreference);
+ // Collapsed
+ assertThat(mMixin.isCollapsed()).isTrue();
+
+ mMixin.removePreference(mPreferenceFragment.getPreferenceScreen(), mPreference.getKey());
+
+ // Removing expand button
+ verify(mPreferenceFragment.getPreferenceScreen()).removePreference(any(Preference.class));
+ // No longer collapsed
+ assertThat(mMixin.isCollapsed()).isFalse();
+ }
+
+ @Test
+ public void collapse_shouldDoNothingIfNotCollapsible() {
+ final PreferenceScreen screen = mPreferenceFragment.getPreferenceScreen();
+ when(screen.getPreferenceCount()).thenReturn(5);
+ mMixin.setTileLimit(15);
+
+ mMixin.collapse(screen);
+ assertThat(mMixin.isCollapsed()).isFalse();
+ verify(screen, never()).addPreference(any(Preference.class));
+ verify(screen, never()).removePreference(any(Preference.class));
+ }
+
+ @Test
+ public void collapse_shouldRemovePrefAndAddExpandButton() {
+ final PreferenceScreen screen = mPreferenceFragment.getPreferenceScreen();
+ when(screen.getPreferenceCount()).thenReturn(5);
+ when(screen.getPreference(anyInt())).thenReturn(mPreference);
+ mMixin.setTileLimit(2);
+
+ mMixin.collapse(screen);
+
+ assertThat(mMixin.isCollapsed()).isTrue();
+ verify(screen).addPreference(any(ExpandPreference.class));
+ verify(screen, times(3)).removePreference(any(Preference.class));
+ }
+
+}
OSDN Git Service
