package org.holoeverywhere.preference;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import org.holoeverywhere.HoloEverywhere;
import org.holoeverywhere.HoloEverywhere.PreferenceImpl;
import org.holoeverywhere.app.Activity;
import org.holoeverywhere.app.Application;
import android.annotation.SuppressLint;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.content.pm.ResolveInfo;
import android.content.res.XmlResourceParser;
import android.os.Build.VERSION;
import android.os.Bundle;
import android.util.Log;
public class PreferenceManager {
public interface OnActivityDestroyListener {
void onActivityDestroy();
}
public interface OnActivityResultListener {
boolean onActivityResult(int requestCode, int resultCode, Intent data);
}
public interface OnActivityStopListener {
void onActivityStop();
}
interface OnPreferenceTreeClickListener {
boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen,
Preference preference);
}
public static final String KEY_HAS_SET_DEFAULT_VALUES = "_has_set_default_values";
public static final String METADATA_KEY_PREFERENCES = PreferenceInit.PACKAGE;
private static final String TAG = "PreferenceManager";
public static SharedPreferences getDefaultSharedPreferences(Context context) {
return getDefaultSharedPreferences(context, HoloEverywhere.PREFERENCE_IMPL);
}
public static SharedPreferences getDefaultSharedPreferences(Context context,
PreferenceImpl impl) {
return wrap(context, impl, getDefaultSharedPreferencesName(context),
getDefaultSharedPreferencesMode());
}
private static int getDefaultSharedPreferencesMode() {
return Context.MODE_PRIVATE;
}
private static String getDefaultSharedPreferencesName(Context context) {
return context.getPackageName() + "_preferences";
}
public static String makeNameById(int id) {
if (id > 0) {
if (HoloEverywhere.NAMED_PREFERENCES) {
return Application.getLastInstance().getResources().getResourceEntryName(id);
} else {
return "preference_0x" + Integer.toHexString(id);
}
} else {
return null;
}
}
public static void setDefaultValues(Context context, int resId,
boolean readAgain) {
PreferenceManager.setDefaultValues(context,
PreferenceManager.getDefaultSharedPreferencesName(context),
PreferenceManager.getDefaultSharedPreferencesMode(), resId,
readAgain);
}
@SuppressLint("NewApi")
public static void setDefaultValues(Context context,
String sharedPreferencesName, int sharedPreferencesMode, int resId,
boolean readAgain) {
final SharedPreferences defaultValueSp = PreferenceManager.wrap(
context, PreferenceManager.KEY_HAS_SET_DEFAULT_VALUES,
Context.MODE_PRIVATE);
if (readAgain
|| !defaultValueSp.getBoolean(
PreferenceManager.KEY_HAS_SET_DEFAULT_VALUES, false)) {
final PreferenceManager pm = new PreferenceManager(context);
pm.setSharedPreferencesName(sharedPreferencesName);
pm.setSharedPreferencesMode(sharedPreferencesMode);
pm.inflateFromResource(context, resId, null);
SharedPreferences.Editor editor = defaultValueSp.edit().putBoolean(
PreferenceManager.KEY_HAS_SET_DEFAULT_VALUES, true);
editor.apply();
}
}
public static SharedPreferences wrap(Context context, PreferenceImpl impl,
String name, int mode) {
switch (impl) {
case XML:
return new _SharedPreferencesImpl_XML(context, name, mode);
case JSON:
default:
return new _SharedPreferencesImpl_JSON(context, name, mode);
}
}
public static SharedPreferences wrap(Context context, String name, int mode) {
return PreferenceManager.wrap(context, HoloEverywhere.PREFERENCE_IMPL, name, mode);
}
private Activity mActivity;
private List<OnActivityDestroyListener> mActivityDestroyListeners;
private List<OnActivityResultListener> mActivityResultListeners;
private List<OnActivityStopListener> mActivityStopListeners;
private Context mContext;
private SharedPreferences.Editor mEditor;
private PreferenceFragment mFragment;
private long mNextId = 0;
private int mNextRequestCode;
private boolean mNoCommit;
private OnPreferenceTreeClickListener mOnPreferenceTreeClickListener;
private PreferenceInflater mPreferenceInflater;
private PreferenceScreen mPreferenceScreen;
private List<DialogInterface> mPreferencesScreens;
private SharedPreferences mSharedPreferences;
private int mSharedPreferencesMode;
private String mSharedPreferencesName;
PreferenceManager(Activity activity, int firstRequestCode) {
mActivity = activity;
mNextRequestCode = firstRequestCode;
init(activity);
}
private PreferenceManager(Context context) {
init(context);
}
void addPreferencesScreen(DialogInterface screen) {
synchronized (this) {
if (mPreferencesScreens == null) {
mPreferencesScreens = new ArrayList<DialogInterface>();
}
mPreferencesScreens.add(screen);
}
}
public PreferenceScreen createPreferenceScreen(Context context) {
final PreferenceScreen preferenceScreen = new PreferenceScreen(context,
null);
preferenceScreen.onAttachedToHierarchy(this);
return preferenceScreen;
}
private void dismissAllScreens() {
ArrayList<DialogInterface> screensToDismiss;
synchronized (this) {
if (mPreferencesScreens == null) {
return;
}
screensToDismiss = new ArrayList<DialogInterface>(
mPreferencesScreens);
mPreferencesScreens.clear();
}
for (int i = screensToDismiss.size() - 1; i >= 0; i--) {
screensToDismiss.get(i).dismiss();
}
}
void dispatchActivityDestroy() {
List<OnActivityDestroyListener> list = null;
synchronized (this) {
if (mActivityDestroyListeners != null) {
list = new ArrayList<OnActivityDestroyListener>(
mActivityDestroyListeners);
}
}
if (list != null) {
final int N = list.size();
for (int i = 0; i < N; i++) {
list.get(i).onActivityDestroy();
}
}
dismissAllScreens();
}
void dispatchActivityResult(int requestCode, int resultCode, Intent data) {
List<OnActivityResultListener> list;
synchronized (this) {
if (mActivityResultListeners == null) {
return;
}
list = new ArrayList<OnActivityResultListener>(
mActivityResultListeners);
}
final int N = list.size();
for (int i = 0; i < N; i++) {
if (list.get(i).onActivityResult(requestCode, resultCode, data)) {
break;
}
}
}
void dispatchActivityStop() {
List<OnActivityStopListener> list;
synchronized (this) {
if (mActivityStopListeners == null) {
return;
}
list = new ArrayList<OnActivityStopListener>(mActivityStopListeners);
}
final int N = list.size();
for (int i = 0; i < N; i++) {
list.get(i).onActivityStop();
}
}
void dispatchNewIntent(Intent intent) {
dismissAllScreens();
}
public Preference findPreference(CharSequence key) {
if (mPreferenceScreen == null) {
return null;
}
return mPreferenceScreen.findPreference(key);
}
public Preference findPreference(int id) {
if (mPreferenceScreen == null) {
return null;
}
return mPreferenceScreen.findPreference(id);
}
Activity getActivity() {
return mActivity;
}
Context getContext() {
return mContext;
}
SharedPreferences.Editor getEditor() {
if (mNoCommit) {
if (mEditor == null) {
mEditor = getSharedPreferences().edit();
}
return mEditor;
} else {
return getSharedPreferences().edit();
}
}
PreferenceFragment getFragment() {
return mFragment;
}
long getNextId() {
synchronized (this) {
return mNextId++;
}
}
int getNextRequestCode() {
synchronized (this) {
return mNextRequestCode++;
}
}
OnPreferenceTreeClickListener getOnPreferenceTreeClickListener() {
return mOnPreferenceTreeClickListener;
}
public PreferenceInflater getPreferenceInflater() {
return getPreferenceInflater(mActivity == null ? mContext : mActivity);
}
private PreferenceInflater getPreferenceInflater(Context context) {
if (mPreferenceInflater != null) {
return mPreferenceInflater;
}
mPreferenceInflater = new PreferenceInflater(context, this);
onInitInflater(mPreferenceInflater);
return mPreferenceInflater;
}
PreferenceScreen getPreferenceScreen() {
return mPreferenceScreen;
}
public SharedPreferences getSharedPreferences() {
if (mSharedPreferences == null) {
mSharedPreferences = PreferenceManager.wrap(mContext,
mSharedPreferencesName, mSharedPreferencesMode);
}
return mSharedPreferences;
}
public int getSharedPreferencesMode() {
return mSharedPreferencesMode;
}
public String getSharedPreferencesName() {
return mSharedPreferencesName;
}
PreferenceScreen inflateFromIntent(Intent queryIntent,
PreferenceScreen rootPreferences) {
final List<ResolveInfo> activities = queryIntentActivities(queryIntent);
final HashSet<String> inflatedRes = new HashSet<String>();
for (int i = activities.size() - 1; i >= 0; i--) {
final ActivityInfo activityInfo = activities.get(i).activityInfo;
final Bundle metaData = activityInfo.metaData;
if (metaData == null
|| !metaData
.containsKey(PreferenceManager.METADATA_KEY_PREFERENCES)) {
continue;
}
final String uniqueResId = activityInfo.packageName
+ ":"
+ activityInfo.metaData
.getInt(PreferenceManager.METADATA_KEY_PREFERENCES);
if (!inflatedRes.contains(uniqueResId)) {
inflatedRes.add(uniqueResId);
final Context context;
try {
context = mContext.createPackageContext(
activityInfo.packageName, 0);
} catch (NameNotFoundException e) {
Log.w(PreferenceManager.TAG,
"Could not create context for "
+ activityInfo.packageName + ": "
+ Log.getStackTraceString(e));
continue;
}
final XmlResourceParser parser = activityInfo.loadXmlMetaData(
context.getPackageManager(), PreferenceManager.METADATA_KEY_PREFERENCES);
rootPreferences = (PreferenceScreen) getPreferenceInflater(context).inflate(
parser, rootPreferences);
parser.close();
}
}
rootPreferences.onAttachedToHierarchy(this);
return rootPreferences;
}
public PreferenceScreen inflateFromResource(Context context, int resId,
PreferenceScreen rootPreferences) {
setNoCommit(true);
rootPreferences = (PreferenceScreen) getPreferenceInflater(context).inflate(
resId, rootPreferences);
rootPreferences.onAttachedToHierarchy(this);
setNoCommit(false);
return rootPreferences;
}
private void init(Context context) {
mContext = PreferenceInit.context(context);
setSharedPreferencesName(PreferenceManager
.getDefaultSharedPreferencesName(context));
}
protected void onInitInflater(PreferenceInflater inflater) {
}
private List<ResolveInfo> queryIntentActivities(Intent queryIntent) {
return mContext.getPackageManager().queryIntentActivities(queryIntent,
PackageManager.GET_META_DATA);
}
void registerOnActivityDestroyListener(OnActivityDestroyListener listener) {
synchronized (this) {
if (mActivityDestroyListeners == null) {
mActivityDestroyListeners = new ArrayList<OnActivityDestroyListener>();
}
if (!mActivityDestroyListeners.contains(listener)) {
mActivityDestroyListeners.add(listener);
}
}
}
void registerOnActivityResultListener(OnActivityResultListener listener) {
synchronized (this) {
if (mActivityResultListeners == null) {
mActivityResultListeners = new ArrayList<OnActivityResultListener>();
}
if (!mActivityResultListeners.contains(listener)) {
mActivityResultListeners.add(listener);
}
}
}
void registerOnActivityStopListener(OnActivityStopListener listener) {
synchronized (this) {
if (mActivityStopListeners == null) {
mActivityStopListeners = new ArrayList<OnActivityStopListener>();
}
if (!mActivityStopListeners.contains(listener)) {
mActivityStopListeners.add(listener);
}
}
}
void removePreferencesScreen(DialogInterface screen) {
synchronized (this) {
if (mPreferencesScreens == null) {
return;
}
mPreferencesScreens.remove(screen);
}
}
void setFragment(PreferenceFragment fragment) {
mFragment = fragment;
}
@SuppressLint("NewApi")
private void setNoCommit(boolean noCommit) {
if (!noCommit && mEditor != null) {
try {
if (VERSION.SDK_INT < 9) {
throw new AbstractMethodError();
}
mEditor.apply();
} catch (AbstractMethodError unused) {
mEditor.commit();
}
}
mNoCommit = noCommit;
}
void setOnPreferenceTreeClickListener(OnPreferenceTreeClickListener listener) {
mOnPreferenceTreeClickListener = listener;
}
boolean setPreferences(PreferenceScreen preferenceScreen) {
if (preferenceScreen != mPreferenceScreen) {
mPreferenceScreen = preferenceScreen;
return true;
}
return false;
}
public void setSharedPreferencesMode(int sharedPreferencesMode) {
mSharedPreferencesMode = sharedPreferencesMode;
mSharedPreferences = null;
}
public void setSharedPreferencesName(String sharedPreferencesName) {
mSharedPreferencesName = sharedPreferencesName;
mSharedPreferences = null;
}
boolean shouldCommit() {
return !mNoCommit;
}
void unregisterOnActivityDestroyListener(OnActivityDestroyListener listener) {
synchronized (this) {
if (mActivityDestroyListeners != null) {
mActivityDestroyListeners.remove(listener);
}
}
}
void unregisterOnActivityResultListener(OnActivityResultListener listener) {
synchronized (this) {
if (mActivityResultListeners != null) {
mActivityResultListeners.remove(listener);
}
}
}
void unregisterOnActivityStopListener(OnActivityStopListener listener) {
synchronized (this) {
if (mActivityStopListeners != null) {
mActivityStopListeners.remove(listener);
}
}
}
}