common/src/com/android/tv/common/CommonPreferences.java - platform/packages/apps/TV - Git at Google

 /*
  * Copyright (C) 2017 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 com.android.tv.common;

 import android.content.ContentResolver;
 import android.content.ContentValues;
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.database.ContentObserver;
 import android.database.Cursor;
 import android.os.AsyncTask;
 import android.os.Bundle;
 import android.os.Handler;
 import android.support.annotation.GuardedBy;
 import android.support.annotation.IntDef;
 import android.support.annotation.MainThread;
 import android.util.Log;
 import com.android.tv.common.CommonPreferenceProvider.Preferences;
 import com.android.tv.common.util.CommonUtils;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.util.HashMap;
 import java.util.Map;

 /** A helper class for setting/getting common preferences across applications. */
 public class CommonPreferences {
     private static final String TAG = "CommonPreferences";

     private static final String PREFS_KEY_LAUNCH_SETUP = "launch_setup";
     private static final String PREFS_KEY_STORE_TS_STREAM = "store_ts_stream";
     private static final String PREFS_KEY_TRICKPLAY_SETTING = "trickplay_setting";
     private static final String PREFS_KEY_LAST_POSTAL_CODE = "last_postal_code";

     private static final Map<String, Class> sPref2TypeMapping = new HashMap<>();

     static {
         sPref2TypeMapping.put(PREFS_KEY_TRICKPLAY_SETTING, int.class);
         sPref2TypeMapping.put(PREFS_KEY_STORE_TS_STREAM, boolean.class);
         sPref2TypeMapping.put(PREFS_KEY_LAUNCH_SETUP, boolean.class);
         sPref2TypeMapping.put(PREFS_KEY_LAST_POSTAL_CODE, String.class);
     }

     private static final String SHARED_PREFS_NAME =
             CommonConstants.BASE_PACKAGE + ".common.preferences";

     @IntDef({TRICKPLAY_SETTING_NOT_SET, TRICKPLAY_SETTING_DISABLED, TRICKPLAY_SETTING_ENABLED})
     @Retention(RetentionPolicy.SOURCE)
     public @interface TrickplaySetting {}

     /** Trickplay setting is not changed by a user. Trickplay will be enabled in this case. */
     public static final int TRICKPLAY_SETTING_NOT_SET = -1;

     /** Trickplay setting is disabled. */
     public static final int TRICKPLAY_SETTING_DISABLED = 0;

     /** Trickplay setting is enabled. */
     public static final int TRICKPLAY_SETTING_ENABLED = 1;

     @GuardedBy("CommonPreferences.class")
     private static final Bundle sPreferenceValues = new Bundle();

     private static LoadPreferencesTask sLoadPreferencesTask;
     private static ContentObserver sContentObserver;
     private static CommonPreferencesChangedListener sPreferencesChangedListener = null;

     protected static boolean sInitialized;

     /** Listeners for CommonPreferences change. */
     public interface CommonPreferencesChangedListener {
         void onCommonPreferencesChanged();
     }

     /** Initializes the common preferences. */
     @MainThread
     public static void initialize(final Context context) {
         if (sInitialized) {
             return;
         }
         sInitialized = true;
         if (useContentProvider(context)) {
             loadPreferences(context);
             sContentObserver =
                     new ContentObserver(new Handler()) {
                         @Override
                         public void onChange(boolean selfChange) {
                             loadPreferences(context);
                         }
                     };
             context.getContentResolver()
                     .registerContentObserver(Preferences.CONTENT_URI, true, sContentObserver);
         } else {
             new AsyncTask<Void, Void, Void>() {
                 @Override
                 protected Void doInBackground(Void... params) {
                     getSharedPreferences(context);
                     return null;
                 }
             }.execute();
         }
     }

     /** Releases the resources. */
     public static synchronized void release(Context context) {
         if (useContentProvider(context) && sContentObserver != null) {
             context.getContentResolver().unregisterContentObserver(sContentObserver);
         }
         setCommonPreferencesChangedListener(null);
     }

     /** Sets the listener for CommonPreferences change. */
     public static void setCommonPreferencesChangedListener(
             CommonPreferencesChangedListener listener) {
         sPreferencesChangedListener = listener;
     }

     /**
      * Loads the preferences from database.
      *
      * <p>This preferences is used across processes, so the preferences should be loaded again when
      * the databases changes.
      */
     @MainThread
     public static void loadPreferences(Context context) {
         if (sLoadPreferencesTask != null
                 && sLoadPreferencesTask.getStatus() != AsyncTask.Status.FINISHED) {
             sLoadPreferencesTask.cancel(true);
         }
         sLoadPreferencesTask = new LoadPreferencesTask(context);
         sLoadPreferencesTask.execute();
     }

     private static boolean useContentProvider(Context context) {
         // If TIS is a part of LC, it should use ContentProvider to resolve multiple process access.
         return CommonUtils.isPackagedWithLiveChannels(context);
     }

     public static synchronized boolean shouldShowSetupActivity(Context context) {
         SoftPreconditions.checkState(sInitialized);
         if (useContentProvider(context)) {
             return sPreferenceValues.getBoolean(PREFS_KEY_LAUNCH_SETUP);
         } else {
             return getSharedPreferences(context).getBoolean(PREFS_KEY_LAUNCH_SETUP, false);
         }
     }

     public static synchronized void setShouldShowSetupActivity(Context context, boolean need) {
         if (useContentProvider(context)) {
             setPreference(context, PREFS_KEY_LAUNCH_SETUP, need);
         } else {
             getSharedPreferences(context).edit().putBoolean(PREFS_KEY_LAUNCH_SETUP, need).apply();
         }
     }

     public static synchronized @TrickplaySetting int getTrickplaySetting(Context context) {
         SoftPreconditions.checkState(sInitialized);
         if (useContentProvider(context)) {
             return sPreferenceValues.getInt(PREFS_KEY_TRICKPLAY_SETTING, TRICKPLAY_SETTING_NOT_SET);
         } else {
             return getSharedPreferences(context)
                     .getInt(PREFS_KEY_TRICKPLAY_SETTING, TRICKPLAY_SETTING_NOT_SET);
         }
     }

     public static synchronized void setTrickplaySetting(
             Context context, @TrickplaySetting int trickplaySetting) {
         SoftPreconditions.checkState(sInitialized);
         SoftPreconditions.checkArgument(trickplaySetting != TRICKPLAY_SETTING_NOT_SET);
         if (useContentProvider(context)) {
             setPreference(context, PREFS_KEY_TRICKPLAY_SETTING, trickplaySetting);
         } else {
             getSharedPreferences(context)
                     .edit()
                     .putInt(PREFS_KEY_TRICKPLAY_SETTING, trickplaySetting)
                     .apply();
         }
     }

     public static synchronized boolean getStoreTsStream(Context context) {
         SoftPreconditions.checkState(sInitialized);
         if (useContentProvider(context)) {
             return sPreferenceValues.getBoolean(PREFS_KEY_STORE_TS_STREAM, false);
         } else {
             return getSharedPreferences(context).getBoolean(PREFS_KEY_STORE_TS_STREAM, false);
         }
     }

     public static synchronized void setStoreTsStream(Context context, boolean shouldStore) {
         if (useContentProvider(context)) {
             setPreference(context, PREFS_KEY_STORE_TS_STREAM, shouldStore);
         } else {
             getSharedPreferences(context)
                     .edit()
                     .putBoolean(PREFS_KEY_STORE_TS_STREAM, shouldStore)
                     .apply();
         }
     }

     public static synchronized String getLastPostalCode(Context context) {
         SoftPreconditions.checkState(sInitialized);
         if (useContentProvider(context)) {
             return sPreferenceValues.getString(PREFS_KEY_LAST_POSTAL_CODE);
         } else {
             return getSharedPreferences(context).getString(PREFS_KEY_LAST_POSTAL_CODE, null);
         }
     }

     public static synchronized void setLastPostalCode(Context context, String postalCode) {
         if (useContentProvider(context)) {
             setPreference(context, PREFS_KEY_LAST_POSTAL_CODE, postalCode);
         } else {
             getSharedPreferences(context)
                     .edit()
                     .putString(PREFS_KEY_LAST_POSTAL_CODE, postalCode)
                     .apply();
         }
     }

     protected static SharedPreferences getSharedPreferences(Context context) {
         return context.getSharedPreferences(SHARED_PREFS_NAME, Context.MODE_PRIVATE);
     }

     private static synchronized void setPreference(Context context, String key, String value) {
         sPreferenceValues.putString(key, value);
         savePreference(context, key, value);
     }

     private static synchronized void setPreference(Context context, String key, int value) {
         sPreferenceValues.putInt(key, value);
         savePreference(context, key, Integer.toString(value));
     }

     private static synchronized void setPreference(Context context, String key, long value) {
         sPreferenceValues.putLong(key, value);
         savePreference(context, key, Long.toString(value));
     }

     private static synchronized void setPreference(Context context, String key, boolean value) {
         sPreferenceValues.putBoolean(key, value);
         savePreference(context, key, Boolean.toString(value));
     }

     private static void savePreference(
             final Context context, final String key, final String value) {
         new AsyncTask<Void, Void, Void>() {
             @Override
             protected Void doInBackground(Void... params) {
                 ContentResolver resolver = context.getContentResolver();
                 ContentValues values = new ContentValues();
                 values.put(Preferences.COLUMN_KEY, key);
                 values.put(Preferences.COLUMN_VALUE, value);
                 try {
                     resolver.insert(Preferences.CONTENT_URI, values);
                 } catch (Exception e) {
                     SoftPreconditions.warn(
                             TAG, "setPreference", e, "Error writing preference values");
                 }
                 return null;
             }
         }.execute();
     }

     private static class LoadPreferencesTask extends AsyncTask<Void, Void, Bundle> {
         private final Context mContext;

         private LoadPreferencesTask(Context context) {
             mContext = context;
         }

         @Override
         protected Bundle doInBackground(Void... params) {
             Bundle bundle = new Bundle();
             ContentResolver resolver = mContext.getContentResolver();
             String[] projection = new String[] {Preferences.COLUMN_KEY, Preferences.COLUMN_VALUE};
             try (Cursor cursor =
                     resolver.query(Preferences.CONTENT_URI, projection, null, null, null)) {
                 if (cursor != null) {
                     while (!isCancelled() && cursor.moveToNext()) {
                         String key = cursor.getString(0);
                         String value = cursor.getString(1);
                         Class prefClass = sPref2TypeMapping.get(key);
                         if (prefClass == int.class) {
                             try {
                                 bundle.putInt(key, Integer.parseInt(value));
                             } catch (NumberFormatException e) {
                                 Log.w(TAG, "Invalid format, key=" + key + ", value=" + value);
                             }
                         } else if (prefClass == long.class) {
                             try {
                                 bundle.putLong(key, Long.parseLong(value));
                             } catch (NumberFormatException e) {
                                 Log.w(TAG, "Invalid format, key=" + key + ", value=" + value);
                             }
                         } else if (prefClass == boolean.class) {
                             bundle.putBoolean(key, Boolean.parseBoolean(value));
                         } else {
                             bundle.putString(key, value);
                         }
                     }
                 }
             } catch (Exception e) {
                 SoftPreconditions.warn(TAG, "getPreference", e, "Error querying preference values");
                 return null;
             }
             return bundle;
         }

         @Override
         protected void onPostExecute(Bundle bundle) {
             synchronized (CommonPreferences.class) {
                 if (bundle != null) {
                     sPreferenceValues.putAll(bundle);
                 }
             }
             if (sPreferencesChangedListener != null) {
                 sPreferencesChangedListener.onCommonPreferencesChanged();
             }
         }
     }
 }
	/*
	* Copyright (C) 2017 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 com.android.tv.common;

	import android.content.ContentResolver;
	import android.content.ContentValues;
	import android.content.Context;
	import android.content.SharedPreferences;
	import android.database.ContentObserver;
	import android.database.Cursor;
	import android.os.AsyncTask;
	import android.os.Bundle;
	import android.os.Handler;
	import android.support.annotation.GuardedBy;
	import android.support.annotation.IntDef;
	import android.support.annotation.MainThread;
	import android.util.Log;
	import com.android.tv.common.CommonPreferenceProvider.Preferences;
	import com.android.tv.common.util.CommonUtils;
	import java.lang.annotation.Retention;
	import java.lang.annotation.RetentionPolicy;
	import java.util.HashMap;
	import java.util.Map;

	/** A helper class for setting/getting common preferences across applications. */
	public class CommonPreferences {
	private static final String TAG = "CommonPreferences";

	private static final String PREFS_KEY_LAUNCH_SETUP = "launch_setup";
	private static final String PREFS_KEY_STORE_TS_STREAM = "store_ts_stream";
	private static final String PREFS_KEY_TRICKPLAY_SETTING = "trickplay_setting";
	private static final String PREFS_KEY_LAST_POSTAL_CODE = "last_postal_code";

	private static final Map<String, Class> sPref2TypeMapping = new HashMap<>();

	static {
	sPref2TypeMapping.put(PREFS_KEY_TRICKPLAY_SETTING, int.class);
	sPref2TypeMapping.put(PREFS_KEY_STORE_TS_STREAM, boolean.class);
	sPref2TypeMapping.put(PREFS_KEY_LAUNCH_SETUP, boolean.class);
	sPref2TypeMapping.put(PREFS_KEY_LAST_POSTAL_CODE, String.class);
	}

	private static final String SHARED_PREFS_NAME =
	CommonConstants.BASE_PACKAGE + ".common.preferences";

	@IntDef({TRICKPLAY_SETTING_NOT_SET, TRICKPLAY_SETTING_DISABLED, TRICKPLAY_SETTING_ENABLED})
	@Retention(RetentionPolicy.SOURCE)
	public @interface TrickplaySetting {}

	/** Trickplay setting is not changed by a user. Trickplay will be enabled in this case. */
	public static final int TRICKPLAY_SETTING_NOT_SET = -1;

	/** Trickplay setting is disabled. */
	public static final int TRICKPLAY_SETTING_DISABLED = 0;

	/** Trickplay setting is enabled. */
	public static final int TRICKPLAY_SETTING_ENABLED = 1;

	@GuardedBy("CommonPreferences.class")
	private static final Bundle sPreferenceValues = new Bundle();

	private static LoadPreferencesTask sLoadPreferencesTask;
	private static ContentObserver sContentObserver;
	private static CommonPreferencesChangedListener sPreferencesChangedListener = null;

	protected static boolean sInitialized;

	/** Listeners for CommonPreferences change. */
	public interface CommonPreferencesChangedListener {
	void onCommonPreferencesChanged();
	}

	/** Initializes the common preferences. */
	@MainThread
	public static void initialize(final Context context) {
	if (sInitialized) {
	return;
	}
	sInitialized = true;
	if (useContentProvider(context)) {
	loadPreferences(context);
	sContentObserver =
	new ContentObserver(new Handler()) {
	@Override
	public void onChange(boolean selfChange) {
	loadPreferences(context);
	}
	};
	context.getContentResolver()
	.registerContentObserver(Preferences.CONTENT_URI, true, sContentObserver);
	} else {
	new AsyncTask<Void, Void, Void>() {
	@Override
	protected Void doInBackground(Void... params) {
	getSharedPreferences(context);
	return null;
	}
	}.execute();
	}
	}

	/** Releases the resources. */
	public static synchronized void release(Context context) {
	if (useContentProvider(context) && sContentObserver != null) {
	context.getContentResolver().unregisterContentObserver(sContentObserver);
	}
	setCommonPreferencesChangedListener(null);
	}

	/** Sets the listener for CommonPreferences change. */
	public static void setCommonPreferencesChangedListener(
	CommonPreferencesChangedListener listener) {
	sPreferencesChangedListener = listener;
	}

	/**
	* Loads the preferences from database.
	*
	* <p>This preferences is used across processes, so the preferences should be loaded again when
	* the databases changes.
	*/
	@MainThread
	public static void loadPreferences(Context context) {
	if (sLoadPreferencesTask != null
	&& sLoadPreferencesTask.getStatus() != AsyncTask.Status.FINISHED) {
	sLoadPreferencesTask.cancel(true);
	}
	sLoadPreferencesTask = new LoadPreferencesTask(context);
	sLoadPreferencesTask.execute();
	}

	private static boolean useContentProvider(Context context) {
	// If TIS is a part of LC, it should use ContentProvider to resolve multiple process access.
	return CommonUtils.isPackagedWithLiveChannels(context);
	}

	public static synchronized boolean shouldShowSetupActivity(Context context) {
	SoftPreconditions.checkState(sInitialized);
	if (useContentProvider(context)) {
	return sPreferenceValues.getBoolean(PREFS_KEY_LAUNCH_SETUP);
	} else {
	return getSharedPreferences(context).getBoolean(PREFS_KEY_LAUNCH_SETUP, false);
	}
	}

	public static synchronized void setShouldShowSetupActivity(Context context, boolean need) {
	if (useContentProvider(context)) {
	setPreference(context, PREFS_KEY_LAUNCH_SETUP, need);
	} else {
	getSharedPreferences(context).edit().putBoolean(PREFS_KEY_LAUNCH_SETUP, need).apply();
	}
	}

	public static synchronized @TrickplaySetting int getTrickplaySetting(Context context) {
	SoftPreconditions.checkState(sInitialized);
	if (useContentProvider(context)) {
	return sPreferenceValues.getInt(PREFS_KEY_TRICKPLAY_SETTING, TRICKPLAY_SETTING_NOT_SET);
	} else {
	return getSharedPreferences(context)
	.getInt(PREFS_KEY_TRICKPLAY_SETTING, TRICKPLAY_SETTING_NOT_SET);
	}
	}

	public static synchronized void setTrickplaySetting(
	Context context, @TrickplaySetting int trickplaySetting) {
	SoftPreconditions.checkState(sInitialized);
	SoftPreconditions.checkArgument(trickplaySetting != TRICKPLAY_SETTING_NOT_SET);
	if (useContentProvider(context)) {
	setPreference(context, PREFS_KEY_TRICKPLAY_SETTING, trickplaySetting);
	} else {
	getSharedPreferences(context)
	.edit()
	.putInt(PREFS_KEY_TRICKPLAY_SETTING, trickplaySetting)
	.apply();
	}
	}

	public static synchronized boolean getStoreTsStream(Context context) {
	SoftPreconditions.checkState(sInitialized);
	if (useContentProvider(context)) {
	return sPreferenceValues.getBoolean(PREFS_KEY_STORE_TS_STREAM, false);
	} else {
	return getSharedPreferences(context).getBoolean(PREFS_KEY_STORE_TS_STREAM, false);
	}
	}

	public static synchronized void setStoreTsStream(Context context, boolean shouldStore) {
	if (useContentProvider(context)) {
	setPreference(context, PREFS_KEY_STORE_TS_STREAM, shouldStore);
	} else {
	getSharedPreferences(context)
	.edit()
	.putBoolean(PREFS_KEY_STORE_TS_STREAM, shouldStore)
	.apply();
	}
	}

	public static synchronized String getLastPostalCode(Context context) {
	SoftPreconditions.checkState(sInitialized);
	if (useContentProvider(context)) {
	return sPreferenceValues.getString(PREFS_KEY_LAST_POSTAL_CODE);
	} else {
	return getSharedPreferences(context).getString(PREFS_KEY_LAST_POSTAL_CODE, null);
	}
	}

	public static synchronized void setLastPostalCode(Context context, String postalCode) {
	if (useContentProvider(context)) {
	setPreference(context, PREFS_KEY_LAST_POSTAL_CODE, postalCode);
	} else {
	getSharedPreferences(context)
	.edit()
	.putString(PREFS_KEY_LAST_POSTAL_CODE, postalCode)
	.apply();
	}
	}

	protected static SharedPreferences getSharedPreferences(Context context) {
	return context.getSharedPreferences(SHARED_PREFS_NAME, Context.MODE_PRIVATE);
	}

	private static synchronized void setPreference(Context context, String key, String value) {
	sPreferenceValues.putString(key, value);
	savePreference(context, key, value);
	}

	private static synchronized void setPreference(Context context, String key, int value) {
	sPreferenceValues.putInt(key, value);
	savePreference(context, key, Integer.toString(value));
	}

	private static synchronized void setPreference(Context context, String key, long value) {
	sPreferenceValues.putLong(key, value);
	savePreference(context, key, Long.toString(value));
	}

	private static synchronized void setPreference(Context context, String key, boolean value) {
	sPreferenceValues.putBoolean(key, value);
	savePreference(context, key, Boolean.toString(value));
	}

	private static void savePreference(
	final Context context, final String key, final String value) {
	new AsyncTask<Void, Void, Void>() {
	@Override
	protected Void doInBackground(Void... params) {
	ContentResolver resolver = context.getContentResolver();
	ContentValues values = new ContentValues();
	values.put(Preferences.COLUMN_KEY, key);
	values.put(Preferences.COLUMN_VALUE, value);
	try {
	resolver.insert(Preferences.CONTENT_URI, values);
	} catch (Exception e) {
	SoftPreconditions.warn(
	TAG, "setPreference", e, "Error writing preference values");
	}
	return null;
	}
	}.execute();
	}

	private static class LoadPreferencesTask extends AsyncTask<Void, Void, Bundle> {
	private final Context mContext;

	private LoadPreferencesTask(Context context) {
	mContext = context;
	}

	@Override
	protected Bundle doInBackground(Void... params) {
	Bundle bundle = new Bundle();
	ContentResolver resolver = mContext.getContentResolver();
	String[] projection = new String[] {Preferences.COLUMN_KEY, Preferences.COLUMN_VALUE};
	try (Cursor cursor =
	resolver.query(Preferences.CONTENT_URI, projection, null, null, null)) {
	if (cursor != null) {
	while (!isCancelled() && cursor.moveToNext()) {
	String key = cursor.getString(0);
	String value = cursor.getString(1);
	Class prefClass = sPref2TypeMapping.get(key);
	if (prefClass == int.class) {
	try {
	bundle.putInt(key, Integer.parseInt(value));
	} catch (NumberFormatException e) {
	Log.w(TAG, "Invalid format, key=" + key + ", value=" + value);
	}
	} else if (prefClass == long.class) {
	try {
	bundle.putLong(key, Long.parseLong(value));
	} catch (NumberFormatException e) {
	Log.w(TAG, "Invalid format, key=" + key + ", value=" + value);
	}
	} else if (prefClass == boolean.class) {
	bundle.putBoolean(key, Boolean.parseBoolean(value));
	} else {
	bundle.putString(key, value);
	}
	}
	}
	} catch (Exception e) {
	SoftPreconditions.warn(TAG, "getPreference", e, "Error querying preference values");
	return null;
	}
	return bundle;
	}

	@Override
	protected void onPostExecute(Bundle bundle) {
	synchronized (CommonPreferences.class) {
	if (bundle != null) {
	sPreferenceValues.putAll(bundle);
	}
	}
	if (sPreferencesChangedListener != null) {
	sPreferencesChangedListener.onCommonPreferencesChanged();
	}
	}
	}
	}