The Tor Browser / file revision

 /*

  * 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;

     }

   };

 }