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.accounts.Account;
import android.content.ContentResolver;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.preference.PreferenceManager;
import android.provider.ContactsContract;
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.contacts.common.model.account.GoogleAccountType;
import com.android.contacts.common.model.AccountTypeManager;

import java.util.ArrayList;
import java.util.List;

/**
 * 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;

    public static final String DO_NOT_SYNC_CONTACT_METADATA_MSG = "Do not sync metadata";

    public static final String CONTACT_METADATA_AUTHORITY = "com.android.contacts.metadata";

    public static final String SHOULD_CLEAR_METADATA_BEFORE_SYNCING =
            "should_clear_metadata_before_syncing";

    public static final String ONLY_CLEAR_DONOT_SYNC = "only_clear_donot_sync";
    /**
     * 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 int mSortOrder = PREFERENCE_UNASSIGNED;
    private int mDisplayOrder = PREFERENCE_UNASSIGNED;
    private String mDefaultAccount = null;
    private ChangeListener mListener = null;
    private Handler mHandler;
    private final SharedPreferences mPreferences;
    private String mDefaultAccountKey;
    private String mDefaultAccountSavedKey;

    public ContactsPreferences(Context context) {
        mContext = context;
        mHandler = new Handler();
        mPreferences = mContext.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();
    }

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

    public 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);
        editor.commit();
    }

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

    public 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);
        editor.commit();
    }

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

    public 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;
    }

    public 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);
        editor.commit();
    }

    public String getContactMetadataSyncAccountName() {
        final Account syncAccount = getContactMetadataSyncAccount();
        return syncAccount == null ? DO_NOT_SYNC_CONTACT_METADATA_MSG : syncAccount.name;
    }

    public void setContactMetadataSyncAccount(AccountWithDataSet accountWithDataSet) {
        final String mContactMetadataSyncAccount =
                accountWithDataSet == null ? null : accountWithDataSet.name;
        requestMetadataSyncForAccount(mContactMetadataSyncAccount);
    }

    private Account getContactMetadataSyncAccount() {
        for (Account account : getFocusGoogleAccounts()) {
            if (ContentResolver.getIsSyncable(account, CONTACT_METADATA_AUTHORITY) == 1
                    && ContentResolver.getSyncAutomatically(account, CONTACT_METADATA_AUTHORITY)) {
                return account;
            }
        }
        return null;
    }

    /**
     * Turn on contact metadata sync for this {@param accountName} and turn off automatic sync
     * for other accounts. If accountName is null, then turn off automatic sync for all accounts.
     */
    private void requestMetadataSyncForAccount(String accountName) {
        for (Account account : getFocusGoogleAccounts()) {
            if (!TextUtils.isEmpty(accountName) && accountName.equals(account.name)) {
                // Request sync.
                final Bundle b = new Bundle();
                b.putBoolean(SHOULD_CLEAR_METADATA_BEFORE_SYNCING, true);
                b.putBoolean(ONLY_CLEAR_DONOT_SYNC, false);
                b.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);
                b.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true);
                ContentResolver.requestSync(account, CONTACT_METADATA_AUTHORITY, b);

                ContentResolver.setSyncAutomatically(account, CONTACT_METADATA_AUTHORITY, true);
            } else if (ContentResolver.getSyncAutomatically(account, CONTACT_METADATA_AUTHORITY)) {
                // Turn off automatic sync for previous sync account.
                ContentResolver.setSyncAutomatically(account, CONTACT_METADATA_AUTHORITY, false);
                if (TextUtils.isEmpty(accountName)) {
                    // Request sync to clear old data.
                    final Bundle b = new Bundle();
                    b.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);
                    b.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true);
                    b.putBoolean(SHOULD_CLEAR_METADATA_BEFORE_SYNCING, true);
                    b.putBoolean(ONLY_CLEAR_DONOT_SYNC, true);
                    ContentResolver.requestSync(account, CONTACT_METADATA_AUTHORITY, b);
                }
            }
        }
    }

    /**
     * @return google accounts with "com.google" account type and null data set.
     */
    private List<Account> getFocusGoogleAccounts() {
        List<Account> focusGoogleAccounts = new ArrayList<Account>();
        final AccountTypeManager accountTypeManager = AccountTypeManager.getInstance(mContext);
        List<AccountWithDataSet> accounts = accountTypeManager.getAccounts(true);
        for (AccountWithDataSet account : accounts) {
            if (GoogleAccountType.ACCOUNT_TYPE.equals(account.type) && account.dataSet == null) {
                focusGoogleAccounts.add(account.getAccountOrNull());
            }
        }
        return focusGoogleAccounts;
    }

    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();
    }

    public interface ChangeListener {
        void 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);
            final String defaultAccount = previousPrefs.getString(mDefaultAccountKey, null);
            if (!TextUtils.isEmpty(defaultAccount)) {
                final AccountWithDataSet accountWithDataSet = AccountWithDataSet.unstringify(
                        defaultAccount);
                setDefaultAccount(accountWithDataSet);
            }
        }
    }
}