common/preference/ContactsPreferences.java

/*
 * Copyright (C) 2010 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.contacts.common.preference;

import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
import android.os.Handler;
import android.preference.PreferenceManager;
import android.provider.Settings;
import android.provider.Settings.SettingNotFoundException;
import android.text.TextUtils;
import com.android.contacts.common.R;
import com.android.contacts.common.model.account.AccountWithDataSet;
import com.android.dialer.strictmode.StrictModeUtils;

/** Manages user preferences for contacts. */
public class ContactsPreferences implements OnSharedPreferenceChangeListener {

  /** The value for the DISPLAY_ORDER key to show the given name first. */
  public static final int DISPLAY_ORDER_PRIMARY = 1;

  /** The value for the DISPLAY_ORDER key to show the family name first. */
  public static final int DISPLAY_ORDER_ALTERNATIVE = 2;

  public static final String DISPLAY_ORDER_KEY = "android.contacts.DISPLAY_ORDER";

  /** The value for the SORT_ORDER key corresponding to sort by given name first. */
  public static final int SORT_ORDER_PRIMARY = 1;

  public static final String SORT_ORDER_KEY = "android.contacts.SORT_ORDER";

  /** The value for the SORT_ORDER key corresponding to sort by family name first. */
  public static final int SORT_ORDER_ALTERNATIVE = 2;

  public static final String PREF_DISPLAY_ONLY_PHONES = "only_phones";

  public static final boolean PREF_DISPLAY_ONLY_PHONES_DEFAULT = false;

  /**
   * Value to use when a preference is unassigned and needs to be read from the shared preferences
   */
  private static final int PREFERENCE_UNASSIGNED = -1;

  private final Context mContext;
  private final SharedPreferences mPreferences;
  private int mSortOrder = PREFERENCE_UNASSIGNED;
  private int mDisplayOrder = PREFERENCE_UNASSIGNED;
  private String mDefaultAccount = null;
  private ChangeListener mListener = null;
  private Handler mHandler;
  private String mDefaultAccountKey;
  private String mDefaultAccountSavedKey;

  public ContactsPreferences(Context context) {
    mContext = context;
    mHandler = new Handler();
    mPreferences =
        mContext
            .getApplicationContext()
            .getSharedPreferences(context.getPackageName(), Context.MODE_PRIVATE);
    mDefaultAccountKey =
        mContext.getResources().getString(R.string.contact_editor_default_account_key);
    mDefaultAccountSavedKey =
        mContext.getResources().getString(R.string.contact_editor_anything_saved_key);
    maybeMigrateSystemSettings();
  }

  private boolean isSortOrderUserChangeable() {
    return mContext.getResources().getBoolean(R.bool.config_sort_order_user_changeable);
  }

  private int getDefaultSortOrder() {
    if (mContext.getResources().getBoolean(R.bool.config_default_sort_order_primary)) {
      return SORT_ORDER_PRIMARY;
    } else {
      return SORT_ORDER_ALTERNATIVE;
    }
  }

  public int getSortOrder() {
    if (!isSortOrderUserChangeable()) {
      return getDefaultSortOrder();
    }
    if (mSortOrder == PREFERENCE_UNASSIGNED) {
      mSortOrder = mPreferences.getInt(SORT_ORDER_KEY, getDefaultSortOrder());
    }
    return mSortOrder;
  }

  public void setSortOrder(int sortOrder) {
    mSortOrder = sortOrder;
    final Editor editor = mPreferences.edit();
    editor.putInt(SORT_ORDER_KEY, sortOrder);
    StrictModeUtils.bypass(editor::commit);
  }

  private boolean isDisplayOrderUserChangeable() {
    return mContext.getResources().getBoolean(R.bool.config_display_order_user_changeable);
  }

  private int getDefaultDisplayOrder() {
    if (mContext.getResources().getBoolean(R.bool.config_default_display_order_primary)) {
      return DISPLAY_ORDER_PRIMARY;
    } else {
      return DISPLAY_ORDER_ALTERNATIVE;
    }
  }

  public int getDisplayOrder() {
    if (!isDisplayOrderUserChangeable()) {
      return getDefaultDisplayOrder();
    }
    if (mDisplayOrder == PREFERENCE_UNASSIGNED) {
      mDisplayOrder = mPreferences.getInt(DISPLAY_ORDER_KEY, getDefaultDisplayOrder());
    }
    return mDisplayOrder;
  }

  public void setDisplayOrder(int displayOrder) {
    mDisplayOrder = displayOrder;
    final Editor editor = mPreferences.edit();
    editor.putInt(DISPLAY_ORDER_KEY, displayOrder);
    StrictModeUtils.bypass(editor::commit);
  }

  private boolean isDefaultAccountUserChangeable() {
    return mContext.getResources().getBoolean(R.bool.config_default_account_user_changeable);
  }

  private String getDefaultAccount() {
    if (!isDefaultAccountUserChangeable()) {
      return mDefaultAccount;
    }
    if (TextUtils.isEmpty(mDefaultAccount)) {
      final String accountString = mPreferences.getString(mDefaultAccountKey, mDefaultAccount);
      if (!TextUtils.isEmpty(accountString)) {
        final AccountWithDataSet accountWithDataSet = AccountWithDataSet.unstringify(accountString);
        mDefaultAccount = accountWithDataSet.name;
      }
    }
    return mDefaultAccount;
  }

  private void setDefaultAccount(AccountWithDataSet accountWithDataSet) {
    mDefaultAccount = accountWithDataSet == null ? null : accountWithDataSet.name;
    final Editor editor = mPreferences.edit();
    if (TextUtils.isEmpty(mDefaultAccount)) {
      editor.remove(mDefaultAccountKey);
    } else {
      editor.putString(mDefaultAccountKey, accountWithDataSet.stringify());
    }
    editor.putBoolean(mDefaultAccountSavedKey, true);
    StrictModeUtils.bypass(editor::commit);
  }

  public void registerChangeListener(ChangeListener listener) {
    if (mListener != null) {
      unregisterChangeListener();
    }

    mListener = listener;

    // Reset preferences to "unknown" because they may have changed while the
    // listener was unregistered.
    mDisplayOrder = PREFERENCE_UNASSIGNED;
    mSortOrder = PREFERENCE_UNASSIGNED;
    mDefaultAccount = null;

    mPreferences.registerOnSharedPreferenceChangeListener(this);
  }

  public void unregisterChangeListener() {
    if (mListener != null) {
      mListener = null;
    }

    mPreferences.unregisterOnSharedPreferenceChangeListener(this);
  }

  @Override
  public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, final String key) {
    // This notification is not sent on the Ui thread. Use the previously created Handler
    // to switch to the Ui thread
    mHandler.post(
        new Runnable() {
          @Override
          public void run() {
            refreshValue(key);
          }
        });
  }

  /**
   * Forces the value for the given key to be looked up from shared preferences and notifies the
   * registered {@link ChangeListener}
   *
   * @param key the {@link SharedPreferences} key to look up
   */
  public void refreshValue(String key) {
    if (DISPLAY_ORDER_KEY.equals(key)) {
      mDisplayOrder = PREFERENCE_UNASSIGNED;
      mDisplayOrder = getDisplayOrder();
    } else if (SORT_ORDER_KEY.equals(key)) {
      mSortOrder = PREFERENCE_UNASSIGNED;
      mSortOrder = getSortOrder();
    } else if (mDefaultAccountKey.equals(key)) {
      mDefaultAccount = null;
      mDefaultAccount = getDefaultAccount();
    }
    if (mListener != null) {
      mListener.onChange();
    }
  }

  /**
   * If there are currently no preferences (which means this is the first time we are run), For sort
   * order and display order, check to see if there are any preferences stored in system settings
   * (pre-L) which can be copied into our own SharedPreferences. For default account setting, check
   * to see if there are any preferences stored in the previous SharedPreferences which can be
   * copied into current SharedPreferences.
   */
  private void maybeMigrateSystemSettings() {
    if (!mPreferences.contains(SORT_ORDER_KEY)) {
      int sortOrder = getDefaultSortOrder();
      try {
        sortOrder = Settings.System.getInt(mContext.getContentResolver(), SORT_ORDER_KEY);
      } catch (SettingNotFoundException e) {
      }
      setSortOrder(sortOrder);
    }

    if (!mPreferences.contains(DISPLAY_ORDER_KEY)) {
      int displayOrder = getDefaultDisplayOrder();
      try {
        displayOrder = Settings.System.getInt(mContext.getContentResolver(), DISPLAY_ORDER_KEY);
      } catch (SettingNotFoundException e) {
      }
      setDisplayOrder(displayOrder);
    }

    if (!mPreferences.contains(mDefaultAccountKey)) {
      final SharedPreferences previousPrefs =
          PreferenceManager.getDefaultSharedPreferences(mContext.getApplicationContext());
      final String defaultAccount = previousPrefs.getString(mDefaultAccountKey, null);
      if (!TextUtils.isEmpty(defaultAccount)) {
        final AccountWithDataSet accountWithDataSet =
            AccountWithDataSet.unstringify(defaultAccount);
        setDefaultAccount(accountWithDataSet);
      }
    }
  }

  public interface ChangeListener {

    void onChange();
  }
}