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 java.lang.reflect.Constructor;

 import java.lang.reflect.Field;

 import java.lang.reflect.InvocationHandler;

 import java.lang.reflect.Method;

 import java.lang.reflect.Proxy;

 import android.app.Activity;

 import android.content.Context;

 import android.content.Intent;

 import android.preference.Preference;

 import android.preference.PreferenceManager;

 import android.preference.PreferenceScreen;

 import android.util.Log;

 public class PreferenceManagerCompat {

 	private static final String TAG = PreferenceManagerCompat.class.getSimpleName();

     /**

      * Interface definition for a callback to be invoked when a

      * {@link Preference} in the hierarchy rooted at this {@link PreferenceScreen} is

      * clicked.

      */

     interface OnPreferenceTreeClickListener {

         /**

          * Called when a preference in the tree rooted at this

          * {@link PreferenceScreen} has been clicked.

          *

          * @param preferenceScreen The {@link PreferenceScreen} that the

          *        preference is located in.

          * @param preference The preference that was clicked.

          * @return Whether the click was handled.

          */

         boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference);

     }

 	static PreferenceManager newInstance(Activity activity, int firstRequestCode) {

 		try {

 			Constructor<PreferenceManager> c = PreferenceManager.class.getDeclaredConstructor(Activity.class, int.class);

 			c.setAccessible(true);

 			return c.newInstance(activity, firstRequestCode);

 		} catch (Exception e) {

 			Log.w(TAG, "Couldn't call constructor PreferenceManager by reflection", e);

 		}

 		return null;

 	}

 	/**

      * Sets the owning preference fragment

      */

     static void setFragment(PreferenceManager manager, PreferenceFragment fragment) {

 	// stub

     }

     /**

      * Sets the callback to be invoked when a {@link Preference} in the

      * hierarchy rooted at this {@link PreferenceManager} is clicked.

      *

      * @param listener The callback to be invoked.

      */

 	static void setOnPreferenceTreeClickListener(PreferenceManager manager, final OnPreferenceTreeClickListener listener) {

 		try {

 			Field onPreferenceTreeClickListener = PreferenceManager.class.getDeclaredField("mOnPreferenceTreeClickListener");

 			onPreferenceTreeClickListener.setAccessible(true);

 			if (listener != null) {

 				Object proxy = Proxy.newProxyInstance(

 						onPreferenceTreeClickListener.getType().getClassLoader(),

 						new Class<?>[] { onPreferenceTreeClickListener.getType() },

 						new InvocationHandler() {

 					@Override

           public Object invoke(Object proxy, Method method, Object[] args) {

 						if (method.getName().equals("onPreferenceTreeClick")) {

 							return Boolean.valueOf(listener.onPreferenceTreeClick((PreferenceScreen) args[0], (Preference) args[1]));

 						} else {

 							return null;

 						}

 					}

 				});

 				onPreferenceTreeClickListener.set(manager, proxy);

 			} else {

 				onPreferenceTreeClickListener.set(manager, null);

 			}

 		} catch (Exception e) {

 			Log.w(TAG, "Couldn't set PreferenceManager.mOnPreferenceTreeClickListener by reflection", e);

 		}

 	}

 	/**

      * Inflates a preference hierarchy from the preference hierarchies of

      * {@link Activity Activities} that match the given {@link Intent}. An

      * {@link Activity} defines its preference hierarchy with meta-data using

      * the {@link #METADATA_KEY_PREFERENCES} key.

      * <p>

      * If a preference hierarchy is given, the new preference hierarchies will

      * be merged in.

      *

      * @param queryIntent The intent to match activities.

      * @param rootPreferences Optional existing hierarchy to merge the new

      *            hierarchies into.

      * @return The root hierarchy (if one was not provided, the new hierarchy's

      *         root).

      */

 	static PreferenceScreen inflateFromIntent(PreferenceManager manager, Intent intent, PreferenceScreen screen) {

 		try {

             Method m = PreferenceManager.class.getDeclaredMethod("inflateFromIntent", Intent.class, PreferenceScreen.class);

             m.setAccessible(true);

             PreferenceScreen prefScreen = (PreferenceScreen) m.invoke(manager, intent, screen);

             return prefScreen;

         } catch (Exception e) {

 			Log.w(TAG, "Couldn't call PreferenceManager.inflateFromIntent by reflection", e);

 		}

 		return null;

 	}

 	/**

      * Inflates a preference hierarchy from XML. If a preference hierarchy is

      * given, the new preference hierarchies will be merged in.

      *

      * @param context The context of the resource.

      * @param resId The resource ID of the XML to inflate.

      * @param rootPreferences Optional existing hierarchy to merge the new

      *            hierarchies into.

      * @return The root hierarchy (if one was not provided, the new hierarchy's

      *         root).

      * @hide

      */

 	static PreferenceScreen inflateFromResource(PreferenceManager manager, Activity activity, int resId, PreferenceScreen screen) {

 		try {

             Method m = PreferenceManager.class.getDeclaredMethod("inflateFromResource", Context.class, int.class, PreferenceScreen.class);

             m.setAccessible(true);

             PreferenceScreen prefScreen = (PreferenceScreen) m.invoke(manager, activity, resId, screen);

             return prefScreen;

         } catch (Exception e) {

 			Log.w(TAG, "Couldn't call PreferenceManager.inflateFromResource by reflection", e);

 		}

 		return null;

 	}

 	/**

      * Returns the root of the preference hierarchy managed by this class.

      *

      * @return The {@link PreferenceScreen} object that is at the root of the hierarchy.

      */

 	static PreferenceScreen getPreferenceScreen(PreferenceManager manager) {

 		try {

             Method m = PreferenceManager.class.getDeclaredMethod("getPreferenceScreen");

             m.setAccessible(true);

             return (PreferenceScreen) m.invoke(manager);

         } catch (Exception e) {

 			Log.w(TAG, "Couldn't call PreferenceManager.getPreferenceScreen by reflection", e);

 		}

 		return null;

 	}

 	/**

      * Called by the {@link PreferenceManager} to dispatch a subactivity result.

      */

 	static void dispatchActivityResult(PreferenceManager manager, int requestCode, int resultCode, Intent data) {

 		try {

             Method m = PreferenceManager.class.getDeclaredMethod("dispatchActivityResult", int.class, int.class, Intent.class);

             m.setAccessible(true);

             m.invoke(manager, requestCode, resultCode, data);

         } catch (Exception e) {

 			Log.w(TAG, "Couldn't call PreferenceManager.dispatchActivityResult by reflection", e);

 		}

 	}

 	/**

      * Called by the {@link PreferenceManager} to dispatch the activity stop

      * event.

      */

 	static void dispatchActivityStop(PreferenceManager manager) {

 		try {

             Method m = PreferenceManager.class.getDeclaredMethod("dispatchActivityStop");

             m.setAccessible(true);

             m.invoke(manager);

         } catch (Exception e) {

 			Log.w(TAG, "Couldn't call PreferenceManager.dispatchActivityStop by reflection", e);

 		}

 	}

 	/**

      * Called by the {@link PreferenceManager} to dispatch the activity destroy

      * event.

      */

 	static void dispatchActivityDestroy(PreferenceManager manager) {

 		try {

 			Method m = PreferenceManager.class.getDeclaredMethod("dispatchActivityDestroy");

 			m.setAccessible(true);

 			m.invoke(manager);

 		} catch (Exception e) {

 			Log.w(TAG, "Couldn't call PreferenceManager.dispatchActivityDestroy by reflection", e);

 		}

 	}

 	/**

      * Sets the root of the preference hierarchy.

      *

      * @param preferenceScreen The root {@link PreferenceScreen} of the preference hierarchy.

      * @return Whether the {@link PreferenceScreen} given is different than the previous.

      */

 	static boolean setPreferences(PreferenceManager manager, PreferenceScreen screen) {

 		try {

 			Method m = PreferenceManager.class.getDeclaredMethod("setPreferences", PreferenceScreen.class);

 			m.setAccessible(true);

 			return ((Boolean) m.invoke(manager, screen));

 		} catch (Exception e) {

 			Log.w(TAG, "Couldn't call PreferenceManager.setPreferences by reflection", e);

 		}

 		return false;

 	}

 }