/* * Copyright (C) 2010 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; import android.app.Activity; import android.app.Dialog; import android.app.DialogFragment; import android.app.Fragment; import android.content.ContentResolver; import android.content.Context; import android.content.DialogInterface; import android.content.Intent; import android.content.pm.PackageManager; import android.os.Bundle; import android.support.annotation.XmlRes; import android.support.v7.preference.Preference; import android.support.v7.preference.PreferenceGroup; import android.support.v7.preference.PreferenceGroupAdapter; import android.support.v7.preference.PreferenceScreen; import android.support.v7.preference.PreferenceViewHolder; import android.support.v7.widget.LinearLayoutManager; import android.support.v7.widget.RecyclerView; import android.text.TextUtils; import android.util.ArrayMap; import android.util.Log; import android.view.LayoutInflater; import android.view.Menu; import android.view.MenuInflater; import android.view.View; import android.view.ViewGroup; import android.widget.Button; import com.android.settings.applications.LayoutPreference; import com.android.settings.widget.FloatingActionButton; import com.android.settingslib.HelpUtils; import java.util.UUID; /** * Base class for Settings fragments, with some helper functions and dialog management. */ public abstract class SettingsPreferenceFragment extends InstrumentedPreferenceFragment implements DialogCreatable { /** * The Help Uri Resource key. This can be passed as an extra argument when creating the * Fragment. **/ public static final String HELP_URI_RESOURCE_KEY = "help_uri_resource"; private static final String TAG = "SettingsPreference"; private static final int DELAY_HIGHLIGHT_DURATION_MILLIS = 600; private static final String SAVE_HIGHLIGHTED_KEY = "android:preference_highlighted"; private SettingsDialogFragment mDialogFragment; private String mHelpUri; private static final int ORDER_FIRST = -1; private static final int ORDER_LAST = Integer.MAX_VALUE -1; // Cache the content resolver for async callbacks private ContentResolver mContentResolver; private String mPreferenceKey; private boolean mPreferenceHighlighted = false; private RecyclerView.Adapter mCurrentRootAdapter; private boolean mIsDataSetObserverRegistered = false; private RecyclerView.AdapterDataObserver mDataSetObserver = new RecyclerView.AdapterDataObserver() { @Override public void onChanged() { onDataSetChanged(); } }; private ViewGroup mPinnedHeaderFrameLayout; private FloatingActionButton mFloatingActionButton; private ViewGroup mButtonBar; private LayoutPreference mHeader; private LayoutPreference mFooter; private View mEmptyView; private LinearLayoutManager mLayoutManager; private HighlightablePreferenceGroupAdapter mAdapter; private ArrayMap mPreferenceCache; private boolean mAnimationAllowed; @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); if (icicle != null) { mPreferenceHighlighted = icicle.getBoolean(SAVE_HIGHLIGHTED_KEY); } // Prepare help url and enable menu if necessary Bundle arguments = getArguments(); int helpResource; if (arguments != null && arguments.containsKey(HELP_URI_RESOURCE_KEY)) { helpResource = arguments.getInt(HELP_URI_RESOURCE_KEY); } else { helpResource = getHelpResource(); } if (helpResource != 0) { mHelpUri = getResources().getString(helpResource); } } @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { final View root = super.onCreateView(inflater, container, savedInstanceState); mPinnedHeaderFrameLayout = (ViewGroup) root.findViewById(R.id.pinned_header); mFloatingActionButton = (FloatingActionButton) root.findViewById(R.id.fab); mButtonBar = (ViewGroup) root.findViewById(R.id.button_bar); return root; } @Override public void onCreatePreferences(Bundle savedInstanceState, String rootKey) { } @Override public void addPreferencesFromResource(@XmlRes int preferencesResId) { super.addPreferencesFromResource(preferencesResId); checkAvailablePrefs(getPreferenceScreen()); } private void checkAvailablePrefs(PreferenceGroup preferenceGroup) { if (preferenceGroup == null) return; for (int i = 0; i < preferenceGroup.getPreferenceCount(); i++) { Preference pref = preferenceGroup.getPreference(i); if (pref instanceof SelfAvailablePreference && !((SelfAvailablePreference) pref).isAvailable(getContext())) { preferenceGroup.removePreference(pref); } else if (pref instanceof PreferenceGroup) { checkAvailablePrefs((PreferenceGroup) pref); } } } public FloatingActionButton getFloatingActionButton() { return mFloatingActionButton; } public ViewGroup getButtonBar() { return mButtonBar; } public View setPinnedHeaderView(int layoutResId) { final LayoutInflater inflater = getActivity().getLayoutInflater(); final View pinnedHeader = inflater.inflate(layoutResId, mPinnedHeaderFrameLayout, false); setPinnedHeaderView(pinnedHeader); return pinnedHeader; } public void setPinnedHeaderView(View pinnedHeader) { mPinnedHeaderFrameLayout.addView(pinnedHeader); mPinnedHeaderFrameLayout.setVisibility(View.VISIBLE); } @Override public void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); outState.putBoolean(SAVE_HIGHLIGHTED_KEY, mPreferenceHighlighted); } @Override public void onActivityCreated(Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); setHasOptionsMenu(true); } @Override public void onResume() { super.onResume(); final Bundle args = getArguments(); if (args != null) { mPreferenceKey = args.getString(SettingsActivity.EXTRA_FRAGMENT_ARG_KEY); highlightPreferenceIfNeeded(); } } @Override protected void onBindPreferences() { registerObserverIfNeeded(); } @Override protected void onUnbindPreferences() { unregisterObserverIfNeeded(); } public void showLoadingWhenEmpty() { View loading = getView().findViewById(R.id.loading_container); setEmptyView(loading); } public void setLoading(boolean loading, boolean animate) { View loading_container = getView().findViewById(R.id.loading_container); Utils.handleLoadingContainer(loading_container, getListView(), !loading, animate); } public void registerObserverIfNeeded() { if (!mIsDataSetObserverRegistered) { if (mCurrentRootAdapter != null) { mCurrentRootAdapter.unregisterAdapterDataObserver(mDataSetObserver); } mCurrentRootAdapter = getListView().getAdapter(); mCurrentRootAdapter.registerAdapterDataObserver(mDataSetObserver); mIsDataSetObserverRegistered = true; onDataSetChanged(); } } public void unregisterObserverIfNeeded() { if (mIsDataSetObserverRegistered) { if (mCurrentRootAdapter != null) { mCurrentRootAdapter.unregisterAdapterDataObserver(mDataSetObserver); mCurrentRootAdapter = null; } mIsDataSetObserverRegistered = false; } } public void highlightPreferenceIfNeeded() { if (isAdded() && !mPreferenceHighlighted &&!TextUtils.isEmpty(mPreferenceKey)) { highlightPreference(mPreferenceKey); } } protected void onDataSetChanged() { highlightPreferenceIfNeeded(); updateEmptyView(); } public LayoutPreference getHeaderView() { return mHeader; } public LayoutPreference getFooterView() { return mFooter; } protected void setHeaderView(int resource) { mHeader = new LayoutPreference(getPrefContext(), resource); addPreferenceToTop(mHeader); } protected void setHeaderView(View view) { mHeader = new LayoutPreference(getPrefContext(), view); addPreferenceToTop(mHeader); } private void addPreferenceToTop(LayoutPreference preference) { preference.setOrder(ORDER_FIRST); if (getPreferenceScreen() != null) { getPreferenceScreen().addPreference(preference); } } protected void setFooterView(int resource) { setFooterView(resource != 0 ? new LayoutPreference(getPrefContext(), resource) : null); } protected void setFooterView(View v) { setFooterView(v != null ? new LayoutPreference(getPrefContext(), v) : null); } private void setFooterView(LayoutPreference footer) { if (getPreferenceScreen() != null && mFooter != null) { getPreferenceScreen().removePreference(mFooter); } if (footer != null) { mFooter = footer; mFooter.setOrder(ORDER_LAST); if (getPreferenceScreen() != null) { getPreferenceScreen().addPreference(mFooter); } } else { mFooter = null; } } @Override public void setPreferenceScreen(PreferenceScreen preferenceScreen) { if (preferenceScreen != null && !preferenceScreen.isAttached()) { // Without ids generated, the RecyclerView won't animate changes to the preferences. preferenceScreen.setShouldUseGeneratedIds(mAnimationAllowed); } super.setPreferenceScreen(preferenceScreen); if (preferenceScreen != null) { if (mHeader != null) { preferenceScreen.addPreference(mHeader); } if (mFooter != null) { preferenceScreen.addPreference(mFooter); } } } private void updateEmptyView() { if (mEmptyView == null) return; if (getPreferenceScreen() != null) { boolean show = (getPreferenceScreen().getPreferenceCount() - (mHeader != null ? 1 : 0) - (mFooter != null ? 1 : 0)) <= 0; mEmptyView.setVisibility(show ? View.VISIBLE : View.GONE); } else { mEmptyView.setVisibility(View.VISIBLE); } } public void setEmptyView(View v) { if (mEmptyView != null) { mEmptyView.setVisibility(View.GONE); } mEmptyView = v; updateEmptyView(); } public View getEmptyView() { return mEmptyView; } /** * Return a valid ListView position or -1 if none is found */ private int canUseListViewForHighLighting(String key) { if (getListView() == null) { return -1; } RecyclerView listView = getListView(); RecyclerView.Adapter adapter = listView.getAdapter(); if (adapter != null && adapter instanceof PreferenceGroupAdapter) { return findListPositionFromKey((PreferenceGroupAdapter) adapter, key); } return -1; } @Override public RecyclerView.LayoutManager onCreateLayoutManager() { mLayoutManager = new LinearLayoutManager(getContext()); return mLayoutManager; } @Override protected RecyclerView.Adapter onCreateAdapter(PreferenceScreen preferenceScreen) { mAdapter = new HighlightablePreferenceGroupAdapter(preferenceScreen); return mAdapter; } protected void setAnimationAllowed(boolean animationAllowed) { mAnimationAllowed = animationAllowed; } protected void cacheRemoveAllPrefs(PreferenceGroup group) { mPreferenceCache = new ArrayMap(); final int N = group.getPreferenceCount(); for (int i = 0; i < N; i++) { Preference p = group.getPreference(i); if (TextUtils.isEmpty(p.getKey())) { continue; } mPreferenceCache.put(p.getKey(), p); } } protected Preference getCachedPreference(String key) { return mPreferenceCache != null ? mPreferenceCache.remove(key) : null; } protected void removeCachedPrefs(PreferenceGroup group) { for (Preference p : mPreferenceCache.values()) { group.removePreference(p); } } protected int getCachedCount() { return mPreferenceCache.size(); } private void highlightPreference(String key) { final int position = canUseListViewForHighLighting(key); if (position >= 0) { mPreferenceHighlighted = true; mLayoutManager.scrollToPosition(position); getView().postDelayed(new Runnable() { @Override public void run() { mAdapter.highlight(position); } }, DELAY_HIGHLIGHT_DURATION_MILLIS); } } private int findListPositionFromKey(PreferenceGroupAdapter adapter, String key) { final int count = adapter.getItemCount(); for (int n = 0; n < count; n++) { final Preference preference = adapter.getItem(n); final String preferenceKey = preference.getKey(); if (preferenceKey != null && preferenceKey.equals(key)) { return n; } } return -1; } protected void removePreference(String key) { Preference pref = findPreference(key); if (pref != null) { getPreferenceScreen().removePreference(pref); } } /** * Override this if you want to show a help item in the menu, by returning the resource id. * @return the resource id for the help url */ protected int getHelpResource() { return R.string.help_uri_default; } @Override public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) { if (mHelpUri != null && getActivity() != null) { HelpUtils.prepareHelpMenuItem(getActivity(), menu, mHelpUri, getClass().getName()); } } /* * The name is intentionally made different from Activity#finish(), so that * users won't misunderstand its meaning. */ public final void finishFragment() { getActivity().onBackPressed(); } // Some helpers for functions used by the settings fragments when they were activities /** * Returns the ContentResolver from the owning Activity. */ protected ContentResolver getContentResolver() { Context context = getActivity(); if (context != null) { mContentResolver = context.getContentResolver(); } return mContentResolver; } /** * Returns the specified system service from the owning Activity. */ protected Object getSystemService(final String name) { return getActivity().getSystemService(name); } /** * Returns the PackageManager from the owning Activity. */ protected PackageManager getPackageManager() { return getActivity().getPackageManager(); } @Override public void onDetach() { if (isRemoving()) { if (mDialogFragment != null) { mDialogFragment.dismiss(); mDialogFragment = null; } } super.onDetach(); } // Dialog management protected void showDialog(int dialogId) { if (mDialogFragment != null) { Log.e(TAG, "Old dialog fragment not null!"); } mDialogFragment = new SettingsDialogFragment(this, dialogId); mDialogFragment.show(getChildFragmentManager(), Integer.toString(dialogId)); } public Dialog onCreateDialog(int dialogId) { return null; } protected void removeDialog(int dialogId) { // mDialogFragment may not be visible yet in parent fragment's onResume(). // To be able to dismiss dialog at that time, don't check // mDialogFragment.isVisible(). if (mDialogFragment != null && mDialogFragment.getDialogId() == dialogId) { mDialogFragment.dismiss(); } mDialogFragment = null; } /** * Sets the OnCancelListener of the dialog shown. This method can only be * called after showDialog(int) and before removeDialog(int). The method * does nothing otherwise. */ protected void setOnCancelListener(DialogInterface.OnCancelListener listener) { if (mDialogFragment != null) { mDialogFragment.mOnCancelListener = listener; } } /** * Sets the OnDismissListener of the dialog shown. This method can only be * called after showDialog(int) and before removeDialog(int). The method * does nothing otherwise. */ protected void setOnDismissListener(DialogInterface.OnDismissListener listener) { if (mDialogFragment != null) { mDialogFragment.mOnDismissListener = listener; } } public void onDialogShowing() { // override in subclass to attach a dismiss listener, for instance } @Override public void onDisplayPreferenceDialog(Preference preference) { if (preference.getKey() == null) { // Auto-key preferences that don't have a key, so the dialog can find them. preference.setKey(UUID.randomUUID().toString()); } DialogFragment f = null; if (preference instanceof RestrictedListPreference) { f = RestrictedListPreference.RestrictedListPreferenceDialogFragment .newInstance(preference.getKey()); } else if (preference instanceof CustomListPreference) { f = CustomListPreference.CustomListPreferenceDialogFragment .newInstance(preference.getKey()); } else if (preference instanceof CustomDialogPreference) { f = CustomDialogPreference.CustomPreferenceDialogFragment .newInstance(preference.getKey()); } else if (preference instanceof CustomEditTextPreference) { f = CustomEditTextPreference.CustomPreferenceDialogFragment .newInstance(preference.getKey()); } else { super.onDisplayPreferenceDialog(preference); return; } f.setTargetFragment(this, 0); f.show(getFragmentManager(), "dialog_preference"); onDialogShowing(); } public static class SettingsDialogFragment extends DialogFragment { private static final String KEY_DIALOG_ID = "key_dialog_id"; private static final String KEY_PARENT_FRAGMENT_ID = "key_parent_fragment_id"; private int mDialogId; private Fragment mParentFragment; private DialogInterface.OnCancelListener mOnCancelListener; private DialogInterface.OnDismissListener mOnDismissListener; public SettingsDialogFragment() { /* do nothing */ } public SettingsDialogFragment(DialogCreatable fragment, int dialogId) { mDialogId = dialogId; if (!(fragment instanceof Fragment)) { throw new IllegalArgumentException("fragment argument must be an instance of " + Fragment.class.getName()); } mParentFragment = (Fragment) fragment; } @Override public void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); if (mParentFragment != null) { outState.putInt(KEY_DIALOG_ID, mDialogId); outState.putInt(KEY_PARENT_FRAGMENT_ID, mParentFragment.getId()); } } @Override public void onStart() { super.onStart(); if (mParentFragment != null && mParentFragment instanceof SettingsPreferenceFragment) { ((SettingsPreferenceFragment) mParentFragment).onDialogShowing(); } } @Override public Dialog onCreateDialog(Bundle savedInstanceState) { if (savedInstanceState != null) { mDialogId = savedInstanceState.getInt(KEY_DIALOG_ID, 0); mParentFragment = getParentFragment(); int mParentFragmentId = savedInstanceState.getInt(KEY_PARENT_FRAGMENT_ID, -1); if (mParentFragment == null) { mParentFragment = getFragmentManager().findFragmentById(mParentFragmentId); } if (!(mParentFragment instanceof DialogCreatable)) { throw new IllegalArgumentException( (mParentFragment != null ? mParentFragment.getClass().getName() : mParentFragmentId) + " must implement " + DialogCreatable.class.getName()); } // This dialog fragment could be created from non-SettingsPreferenceFragment if (mParentFragment instanceof SettingsPreferenceFragment) { // restore mDialogFragment in mParentFragment ((SettingsPreferenceFragment) mParentFragment).mDialogFragment = this; } } return ((DialogCreatable) mParentFragment).onCreateDialog(mDialogId); } @Override public void onCancel(DialogInterface dialog) { super.onCancel(dialog); if (mOnCancelListener != null) { mOnCancelListener.onCancel(dialog); } } @Override public void onDismiss(DialogInterface dialog) { super.onDismiss(dialog); if (mOnDismissListener != null) { mOnDismissListener.onDismiss(dialog); } } public int getDialogId() { return mDialogId; } @Override public void onDetach() { super.onDetach(); // This dialog fragment could be created from non-SettingsPreferenceFragment if (mParentFragment instanceof SettingsPreferenceFragment) { // in case the dialog is not explicitly removed by removeDialog() if (((SettingsPreferenceFragment) mParentFragment).mDialogFragment == this) { ((SettingsPreferenceFragment) mParentFragment).mDialogFragment = null; } } } } protected boolean hasNextButton() { return ((ButtonBarHandler)getActivity()).hasNextButton(); } protected Button getNextButton() { return ((ButtonBarHandler)getActivity()).getNextButton(); } public void finish() { Activity activity = getActivity(); if (activity == null) return; if (getFragmentManager().getBackStackEntryCount() > 0) { getFragmentManager().popBackStack(); } else { activity.finish(); } } protected Intent getIntent() { if (getActivity() == null) { return null; } return getActivity().getIntent(); } protected void setResult(int result, Intent intent) { if (getActivity() == null) { return; } getActivity().setResult(result, intent); } protected void setResult(int result) { if (getActivity() == null) { return; } getActivity().setResult(result); } protected final Context getPrefContext() { return getPreferenceManager().getContext(); } public boolean startFragment(Fragment caller, String fragmentClass, int titleRes, int requestCode, Bundle extras) { final Activity activity = getActivity(); if (activity instanceof SettingsActivity) { SettingsActivity sa = (SettingsActivity) activity; sa.startPreferencePanel(fragmentClass, extras, titleRes, null, caller, requestCode); return true; } else { Log.w(TAG, "Parent isn't SettingsActivity nor PreferenceActivity, thus there's no way to " + "launch the given Fragment (name: " + fragmentClass + ", requestCode: " + requestCode + ")"); return false; } } public static class HighlightablePreferenceGroupAdapter extends PreferenceGroupAdapter { private int mHighlightPosition = -1; public HighlightablePreferenceGroupAdapter(PreferenceGroup preferenceGroup) { super(preferenceGroup); } public void highlight(int position) { mHighlightPosition = position; notifyDataSetChanged(); } @Override public void onBindViewHolder(PreferenceViewHolder holder, int position) { super.onBindViewHolder(holder, position); if (position == mHighlightPosition) { View v = holder.itemView; if (v.getBackground() != null) { final int centerX = v.getWidth() / 2; final int centerY = v.getHeight() / 2; v.getBackground().setHotspot(centerX, centerY); } v.setPressed(true); v.setPressed(false); mHighlightPosition = -1; } } } }