public void testSyncID() {
SyncConfiguration config = null;
SharedPreferences prefs = getPrefs(TEST_PREFS_NAME, 0);
config = new SyncConfiguration(TEST_PREFS_NAME, this);
config.syncID = "test1";
config.persistToPrefs();
assertTrue(prefs.contains(SyncConfiguration.PREF_SYNC_ID));
config = new SyncConfiguration(TEST_PREFS_NAME, this);
assertEquals("test1", config.syncID);
}
public void testsSelectedEnginesNoHistoryNorForms() {
SharedPreferences prefs = getPrefs(TEST_PREFS_NAME, 0);
// Store engines, excluding history/forms special case.
Map<String, Boolean> storedEngines = new HashMap<String, Boolean>();
storedEngines.put("forms", true);
SyncConfiguration.storeSelectedEnginesToPrefs(prefs, storedEngines);
// Read values from selectedEngines.
assertTrue(prefs.contains(SyncConfiguration.PREF_USER_SELECTED_ENGINES_TO_SYNC));
SyncConfiguration config = null;
config = new SyncConfiguration(TEST_PREFS_NAME, this);
config.loadFromPrefs(prefs);
// Forms should not be selected if history is not present.
assertTrue(config.userSelectedEngines.isEmpty());
}
/** Tests dependency of forms engine on history engine. */
public void testSelectedEnginesHistoryAndForms() {
SharedPreferences prefs = getPrefs(TEST_PREFS_NAME, 0);
// Store engines, excluding history/forms special case.
Map<String, Boolean> storedEngines = new HashMap<String, Boolean>();
storedEngines.put("history", true);
SyncConfiguration.storeSelectedEnginesToPrefs(prefs, storedEngines);
// Expected engines.
storedEngines.put("forms", true);
// Read values from selectedEngines.
assertTrue(prefs.contains(SyncConfiguration.PREF_USER_SELECTED_ENGINES_TO_SYNC));
SyncConfiguration config = null;
config = new SyncConfiguration(TEST_PREFS_NAME, this);
config.loadFromPrefs(prefs);
assertEquals(storedEngines, config.userSelectedEngines);
}
/**
* Query shared prefs for the current engine state, and update the UI accordingly.
*
* <p>In future, we might want this to be on a background thread, or implemented as a Loader.
*/
protected void updateSelectedEngines() {
try {
SharedPreferences syncPrefs = fxAccount.getSyncPrefs();
Map<String, Boolean> engines = SyncConfiguration.getUserSelectedEngines(syncPrefs);
if (engines != null) {
bookmarksPreference.setChecked(
engines.containsKey("bookmarks") && engines.get("bookmarks"));
historyPreference.setChecked(engines.containsKey("history") && engines.get("history"));
passwordsPreference.setChecked(
engines.containsKey("passwords") && engines.get("passwords"));
tabsPreference.setChecked(engines.containsKey("tabs") && engines.get("tabs"));
return;
}
// We don't have user specified preferences. Perhaps we have seen a meta/global?
Set<String> enabledNames = SyncConfiguration.getEnabledEngineNames(syncPrefs);
if (enabledNames != null) {
bookmarksPreference.setChecked(enabledNames.contains("bookmarks"));
historyPreference.setChecked(enabledNames.contains("history"));
passwordsPreference.setChecked(enabledNames.contains("passwords"));
tabsPreference.setChecked(enabledNames.contains("tabs"));
return;
}
// Okay, we don't have userSelectedEngines or enabledEngines. That means
// the user hasn't specified to begin with, we haven't specified here, and
// we haven't already seen, Sync engines. We don't know our state, so
// let's check everything (the default) and disable everything.
bookmarksPreference.setChecked(true);
historyPreference.setChecked(true);
passwordsPreference.setChecked(true);
tabsPreference.setChecked(true);
setCheckboxesEnabled(false);
} catch (Exception e) {
Logger.warn(LOG_TAG, "Got exception getting engines to select; ignoring.", e);
return;
}
}
public void testEnabledEngineNames() {
SyncConfiguration config = null;
SharedPreferences prefs = getPrefs(TEST_PREFS_NAME, 0);
config = new SyncConfiguration(TEST_PREFS_NAME, this);
config.enabledEngineNames = new HashSet<String>();
config.enabledEngineNames.add("test1");
config.enabledEngineNames.add("test2");
config.persistToPrefs();
assertTrue(prefs.contains(SyncConfiguration.PREF_ENABLED_ENGINE_NAMES));
config = new SyncConfiguration(TEST_PREFS_NAME, this);
Set<String> expected = new HashSet<String>();
for (String name : new String[] {"test1", "test2"}) {
expected.add(name);
}
assertEquals(expected, config.enabledEngineNames);
config.enabledEngineNames = null;
config.persistToPrefs();
assertFalse(prefs.contains(SyncConfiguration.PREF_ENABLED_ENGINE_NAMES));
config = new SyncConfiguration(TEST_PREFS_NAME, this);
assertNull(config.enabledEngineNames);
}
@Override
public void run() {
try {
// Name shadowing -- do you like it, or do you love it?
AndroidFxAccount fxAccount = FxAccountStatusFragment.this.fxAccount;
if (fxAccount == null) {
return;
}
Logger.info(LOG_TAG, "Persisting engine selections: " + engineSelections.toString());
SyncConfiguration.storeSelectedEnginesToPrefs(fxAccount.getSyncPrefs(), engineSelections);
requestDelayedSync();
} catch (Exception e) {
Logger.warn(LOG_TAG, "Got exception persisting selected engines; ignoring.", e);
return;
}
}
@Override
public void handleSuccess(LoginResponse result) {
Logger.info(LOG_TAG, "Got success response; adding Android account.");
// We're on the UI thread, but it's okay to create the account here.
AndroidFxAccount fxAccount;
try {
final String profile = Constants.DEFAULT_PROFILE;
final String tokenServerURI = getTokenServerEndpoint();
// It is crucial that we use the email address provided by the server
// (rather than whatever the user entered), because the user's keys are
// wrapped and salted with the initial email they provided to
// /create/account. Of course, we want to pass through what the user
// entered locally as much as possible, so we create the Android account
// with their entered email address, etc.
// The passwordStretcher should have seen this email address before, so
// we shouldn't be calculating the expensive stretch twice.
byte[] quickStretchedPW =
passwordStretcher.getQuickStretchedPW(result.remoteEmail.getBytes("UTF-8"));
byte[] unwrapkB = FxAccountUtils.generateUnwrapBKey(quickStretchedPW);
State state =
new Engaged(
email,
result.uid,
result.verified,
unwrapkB,
result.sessionToken,
result.keyFetchToken);
fxAccount =
AndroidFxAccount.addAndroidAccount(
getApplicationContext(), email, profile, serverURI, tokenServerURI, state);
if (fxAccount == null) {
throw new RuntimeException("Could not add Android account.");
}
if (selectedEngines != null) {
Logger.info(LOG_TAG, "User has selected engines; storing to prefs.");
SyncConfiguration.storeSelectedEnginesToPrefs(fxAccount.getSyncPrefs(), selectedEngines);
}
} catch (Exception e) {
handleError(e);
return;
}
// For great debugging.
if (FxAccountUtils.LOG_PERSONAL_INFORMATION) {
fxAccount.dump();
}
// The GetStarted activity has called us and needs to return a result to the authenticator.
final Intent intent = new Intent();
intent.putExtra(AccountManager.KEY_ACCOUNT_NAME, email);
intent.putExtra(AccountManager.KEY_ACCOUNT_TYPE, FxAccountConstants.ACCOUNT_TYPE);
// intent.putExtra(AccountManager.KEY_AUTHTOKEN, accountType);
setResult(RESULT_OK, intent);
// Show success activity depending on verification status.
Intent successIntent = makeSuccessIntent(email, result);
startActivity(successIntent);
finish();
}