1 files changed, 226 insertions, 0 deletions
diff --git a/mobile/android/services/src/main/java/org/mozilla/gecko/background/preferences/PreferenceManagerCompat.java b/mobile/android/services/src/main/java/org/mozilla/gecko/background/preferences/PreferenceManagerCompat.java
new file mode 100644
index 000000000..22c62e431
--- /dev/null
+++ b/mobile/android/services/src/main/java/org/mozilla/gecko/background/preferences/PreferenceManagerCompat.java
@@ -0,0 +1,226 @@
+/*
+ * 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 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;
+  }
+
+}