gecko/mobile/android/base/background/preferences/PreferenceFragment.java

/*
 * Copyright (C) 2013 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 org.mozilla.gecko.background.preferences;

import org.mozilla.gecko.R;

import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.preference.Preference;
import android.preference.PreferenceGroup;
import android.preference.PreferenceManager;
import android.preference.PreferenceScreen;
import android.support.v4.app.Fragment;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnKeyListener;
import android.view.ViewGroup;
import android.widget.ListView;

public abstract class PreferenceFragment extends Fragment implements PreferenceManagerCompat.OnPreferenceTreeClickListener {
  private static final String PREFERENCES_TAG = "android:preferences";

  private PreferenceManager mPreferenceManager;
  private ListView mList;
  private boolean mHavePrefs;
  private boolean mInitDone;

  /**
   * The starting request code given out to preference framework.
   */
  private static final int FIRST_REQUEST_CODE = 100;

  private static final int MSG_BIND_PREFERENCES = 1;

  // This triggers "This Handler class should be static or leaks might occur".
  // The issue is that the Handler references the Fragment; messages targeting
  // the Handler reference it; and if such messages are long lived, the Fragment
  // cannot be GCed. This is not an issue for us; our messages are short-lived.
  private Handler mHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
      switch (msg.what) {

      case MSG_BIND_PREFERENCES:
        bindPreferences();
        break;
      }
    }
  };

  final private Runnable mRequestFocus = new Runnable() {
    @Override
    public void run() {
      mList.focusableViewAvailable(mList);
    }
  };

  /**
   * Interface that PreferenceFragment's containing activity should
   * implement to be able to process preference items that wish to
   * switch to a new fragment.
   */
  public interface OnPreferenceStartFragmentCallback {
    /**
     * Called when the user has clicked on a Preference that has
     * a fragment class name associated with it.  The implementation
     * to should instantiate and switch to an instance of the given
     * fragment.
     */
    boolean onPreferenceStartFragment(PreferenceFragment caller, Preference pref);
  }

  @Override
  public void onCreate(Bundle paramBundle) {
    super.onCreate(paramBundle);
    mPreferenceManager = PreferenceManagerCompat.newInstance(getActivity(), FIRST_REQUEST_CODE);
    PreferenceManagerCompat.setFragment(mPreferenceManager, this);
  }

  @Override
  public View onCreateView(LayoutInflater paramLayoutInflater, ViewGroup paramViewGroup, Bundle paramBundle) {
    return paramLayoutInflater.inflate(R.layout.fxaccount_preference_list_fragment, paramViewGroup,
        false);
  }

  @Override
  public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);

    if (mHavePrefs) {
      bindPreferences();
    }

    mInitDone = true;

    if (savedInstanceState != null) {
      Bundle container = savedInstanceState.getBundle(PREFERENCES_TAG);
      if (container != null) {
        final PreferenceScreen preferenceScreen = getPreferenceScreen();
        if (preferenceScreen != null) {
          preferenceScreen.restoreHierarchyState(container);
        }
      }
    }
  }

  @Override
  public void onStart() {
    super.onStart();
    PreferenceManagerCompat.setOnPreferenceTreeClickListener(mPreferenceManager, this);
  }

  @Override
  public void onStop() {
    super.onStop();
    PreferenceManagerCompat.dispatchActivityStop(mPreferenceManager);
    PreferenceManagerCompat.setOnPreferenceTreeClickListener(mPreferenceManager, null);
  }

  @Override
  public void onDestroyView() {
    mList = null;
    mHandler.removeCallbacks(mRequestFocus);
    mHandler.removeMessages(MSG_BIND_PREFERENCES);
    super.onDestroyView();
  }

  @Override
  public void onDestroy() {
    super.onDestroy();
    PreferenceManagerCompat.dispatchActivityDestroy(mPreferenceManager);
  }

  @Override
  public void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);

    final PreferenceScreen preferenceScreen = getPreferenceScreen();
    if (preferenceScreen != null) {
      Bundle container = new Bundle();
      preferenceScreen.saveHierarchyState(container);
      outState.putBundle(PREFERENCES_TAG, container);
    }
  }

  @Override
  public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);

    PreferenceManagerCompat.dispatchActivityResult(mPreferenceManager, requestCode, resultCode, data);
  }

  /**
   * Returns the {@link PreferenceManager} used by this fragment.
   * @return The {@link PreferenceManager}.
   */
  public PreferenceManager getPreferenceManager() {
    return mPreferenceManager;
  }

  /**
   * Sets the root of the preference hierarchy that this fragment is showing.
   *
   * @param preferenceScreen The root {@link PreferenceScreen} of the preference hierarchy.
   */
  public void setPreferenceScreen(PreferenceScreen preferenceScreen) {
    if (PreferenceManagerCompat.setPreferences(mPreferenceManager, preferenceScreen) && preferenceScreen != null) {
      mHavePrefs = true;
      if (mInitDone) {
        postBindPreferences();
      }
    }
  }

  /**
   * Gets the root of the preference hierarchy that this fragment is showing.
   *
   * @return The {@link PreferenceScreen} that is the root of the preference
   *         hierarchy.
   */
  public PreferenceScreen getPreferenceScreen() {
    return PreferenceManagerCompat.getPreferenceScreen(mPreferenceManager);
  }

  /**
   * Adds preferences from activities that match the given {@link Intent}.
   *
   * @param intent The {@link Intent} to query activities.
   */
  public void addPreferencesFromIntent(Intent intent) {
    requirePreferenceManager();

    setPreferenceScreen(PreferenceManagerCompat.inflateFromIntent(mPreferenceManager, intent, getPreferenceScreen()));
  }

  /**
   * Inflates the given XML resource and adds the preference hierarchy to the current
   * preference hierarchy.
   *
   * @param preferencesResId The XML resource ID to inflate.
   */
  public void addPreferencesFromResource(int preferencesResId) {
    requirePreferenceManager();

    setPreferenceScreen(PreferenceManagerCompat.inflateFromResource(mPreferenceManager, getActivity(),
        preferencesResId, getPreferenceScreen()));
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen,
      Preference preference) {
    //if (preference.getFragment() != null &&
    if (
        getActivity() instanceof OnPreferenceStartFragmentCallback) {
      return ((OnPreferenceStartFragmentCallback)getActivity()).onPreferenceStartFragment(
          this, preference);
    }
    return false;
  }

  /**
   * Finds a {@link Preference} based on its key.
   *
   * @param key The key of the preference to retrieve.
   * @return The {@link Preference} with the key, or null.
   * @see PreferenceGroup#findPreference(CharSequence)
   */
  public Preference findPreference(CharSequence key) {
    if (mPreferenceManager == null) {
      return null;
    }
    return mPreferenceManager.findPreference(key);
  }

  private void requirePreferenceManager() {
    if (mPreferenceManager == null) {
      throw new RuntimeException("This should be called after super.onCreate.");
    }
  }

  private void postBindPreferences() {
    if (mHandler.hasMessages(MSG_BIND_PREFERENCES)) return;
    mHandler.obtainMessage(MSG_BIND_PREFERENCES).sendToTarget();
  }

  private void bindPreferences() {
    final PreferenceScreen preferenceScreen = getPreferenceScreen();
    if (preferenceScreen != null) {
      preferenceScreen.bind(getListView());
    }
  }

  public ListView getListView() {
    ensureList();
    return mList;
  }

  private void ensureList() {
    if (mList != null) {
      return;
    }
    View root = getView();
    if (root == null) {
      throw new IllegalStateException("Content view not yet created");
    }
    View rawListView = root.findViewById(android.R.id.list);
    if (!(rawListView instanceof ListView)) {
      throw new RuntimeException(
          "Content has view with id attribute 'android.R.id.list' "
              + "that is not a ListView class");
    }
    mList = (ListView)rawListView;
    if (mList == null) {
      throw new RuntimeException(
          "Your content must have a ListView whose id attribute is " +
          "'android.R.id.list'");
    }
    mList.setOnKeyListener(mListOnKeyListener);
    mHandler.post(mRequestFocus);
  }

  private OnKeyListener mListOnKeyListener = new OnKeyListener() {

    @Override
    public boolean onKey(View v, int keyCode, KeyEvent event) {
      Object selectedItem = mList.getSelectedItem();
      if (selectedItem instanceof Preference) {
        @SuppressWarnings("unused")
        View selectedView = mList.getSelectedView();
        //return ((Preference)selectedItem).onKey(
        //        selectedView, keyCode, event);
        return false;
      }
      return false;
    }

  };
}