gecko/mobile/android/base/sync/config/activities/SelectEnginesActivity.java

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

package org.mozilla.gecko.sync.config.activities;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.mozilla.gecko.R;
import org.mozilla.gecko.background.common.log.Logger;
import org.mozilla.gecko.sync.SyncConfiguration;
import org.mozilla.gecko.sync.ThreadPool;
import org.mozilla.gecko.sync.setup.SyncAccounts;
import org.mozilla.gecko.sync.syncadapter.SyncAdapter;

import android.accounts.Account;
import android.accounts.AccountManager;
import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnDismissListener;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.widget.ListView;
import android.widget.Toast;

/**
 * Provides a user-facing interface for selecting engines to sync. This activity
 * can be launched from the Sync Settings preferences screen, and will save the
 * selected engines to the
 * <code>SyncConfiguration.PREF_USER_SELECTED_ENGINES_TO_SYNC</code> pref.
 *
 * On launch, it displays the engines stored in the saved pref if it exists, or
 * <code>SyncConfiguration.enabledEngineNames()</code> if it doesn't, defaulting
 * to <code>SyncConfiguration.validEngineNames()</code> if neither exists.
 *
 * During a sync, the
 * <code>SyncConfiguration.PREF_USER_SELECTED_ENGINES_TO_SYNC</code> pref will
 * be cleared after the engine changes are applied to meta/global.
 */

public class SelectEnginesActivity extends Activity implements
    DialogInterface.OnClickListener, DialogInterface.OnMultiChoiceClickListener {
  public final static String LOG_TAG = "SelectEnginesAct";

  protected AccountManager mAccountManager;
  protected Context mContext;

  // Collections names corresponding to displayed (localized) engine options.
  final String[] _collectionsNames = new String[] {
    "bookmarks",
    "passwords",
    "history",
    "tabs"
  };

  // Engine names localized for display in Sync Settings.
  protected String[] _options;
  // Selection state of engines corresponding to _options array.
  final boolean[] _selections = new boolean[_collectionsNames.length];
  protected Account account;
  protected SharedPreferences accountPrefs;

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mContext = getApplicationContext();
    mAccountManager = AccountManager.get(mContext);
    _options = new String[] {
        getString(R.string.sync_configure_engines_title_bookmarks),
        getString(R.string.sync_configure_engines_title_passwords),
        getString(R.string.sync_configure_engines_title_history),
        getString(R.string.sync_configure_engines_title_tabs) };

    // Fetch account prefs for configuring engines.
    ThreadPool.run(new Runnable() {
      @Override
      public void run() {
        Account[] accounts = SyncAccounts.syncAccounts(mContext);
        if (accounts.length == 0) {
          Logger.error(LOG_TAG, "Failed to get account!");
          finish();
          return;
        } else {
          // Only supports one account per type.
          account = accounts[0];
          try {
            if (accountPrefs == null) {
              accountPrefs = SyncAccounts.blockingPrefsFromDefaultProfileV0(mContext, mAccountManager, account);
            }
          } catch (Exception e) {
            Logger.error(LOG_TAG, "Failed to get sync account info or shared preferences.", e);
            finish();
          }
          setSelectionsInArray(getEnginesToSelect(accountPrefs), _selections);
        }
      }
    });
  }

  @Override
  public void onResume() {
    super.onResume();
    if (accountPrefs != null) {
      setSelectionsInArray(getEnginesToSelect(accountPrefs), _selections);
    }
    AlertDialog dialog = new AlertDialog.Builder(this)
        .setTitle(R.string.sync_configure_engines_sync_my_title)
        .setMultiChoiceItems(_options, _selections, this)
        .setIcon(R.drawable.icon).setPositiveButton(android.R.string.ok, this)
        .setNegativeButton(android.R.string.cancel, this).create();

    dialog.setOnDismissListener(new OnDismissListener() {
      @Override
      public void onDismiss(DialogInterface dialog) {
        finish();
      }
    });

    dialog.show();
  }

  private static Set<String> getEnginesFromPrefs(SharedPreferences syncPrefs) {
    Set<String> engines = SyncConfiguration.getEnabledEngineNames(syncPrefs);
    if (engines == null) {
      engines = SyncConfiguration.validEngineNames();
    }
    return engines;
  }

  /**
   * Fetches the engine names that should be displayed as selected for syncing.
   * Check first for selected engines set by this activity, then the enabled
   * engines, and finally default to the set of valid engine names for Android
   * Sync if neither exists.
   *
   * @param syncPrefs
   *          <code>SharedPreferences</code> of Account being modified.
   * @return Set<String> of engine names to display as selected. Should never be
   *         null.
   */
  public static Set<String> getEnginesToSelect(SharedPreferences syncPrefs) {
    Set<String> engines = getEnginesFromPrefs(syncPrefs);
    Map<String, Boolean> engineSelections = SyncConfiguration.getUserSelectedEngines(syncPrefs);
    if (engineSelections != null) {
      for (Entry<String, Boolean> pair : engineSelections.entrySet()) {
        if (pair.getValue()) {
          engines.add(pair.getKey());
        } else {
          engines.remove(pair.getKey());
        }
      }
    }
    return engines;
  }

  public void setSelectionsInArray(Set<String> selected, boolean[] array) {
    for (int i = 0; i < _collectionsNames.length; i++) {
      array[i] = selected.contains(_collectionsNames[i]);
    }
  }

  @Override
  public void onClick(DialogInterface dialog, int which) {
    if (which == DialogInterface.BUTTON_POSITIVE) {
      Logger.debug(LOG_TAG, "Saving selected engines.");
      saveSelections();
      setResult(RESULT_OK);
      Toast.makeText(this, R.string.sync_notification_savedprefs, Toast.LENGTH_SHORT).show();
    } else {
      setResult(RESULT_CANCELED);
    }
    finish();
  }

  @Override
  public void onClick(DialogInterface dialog, int which, boolean isChecked) {
    // Display multi-selection clicks in UI.
    _selections[which] = isChecked;
    ListView selectionsList = ((AlertDialog) dialog).getListView();
    selectionsList.setItemChecked(which, isChecked);
  }

  /**
   * Persists engine selection state to SharedPreferences if it has changed.
   *
   * @return true if changed, false otherwise.
   */
  private void saveSelections() {
    boolean[] origSelections = new boolean[_options.length];
    setSelectionsInArray(getEnginesFromPrefs(accountPrefs), origSelections);

    Map<String, Boolean> engineSelections = new HashMap<String, Boolean>();
    for (int i = 0; i < _selections.length; i++) {
      if (_selections[i] != origSelections[i]) {
        engineSelections.put(_collectionsNames[i], _selections[i]);
      }
    }

    // No GlobalSession.config, so store directly to prefs.
    SyncConfiguration.storeSelectedEnginesToPrefs(accountPrefs, engineSelections);

    // Request immediate sync.
    SyncAdapter.requestImmediateSync(account, null);
  }
}