mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
232 lines
8.6 KiB
Java
232 lines
8.6 KiB
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 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;
|
|
}
|
|
|
|
}
|