The Tor Browser: mobile/android/base/fxa/authenticator/AccountPickler.java@6474c204b198 (annotated)

mobile/android/base/fxa/authenticator/AccountPickler.java@6474c204b198 (annotated)

mobile/android/base/fxa/authenticator/AccountPickler.java

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* 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.fxa.authenticator;
 import java.io.FileOutputStream;
 import java.io.PrintStream;
 import java.security.NoSuchAlgorithmException;
 import java.security.spec.InvalidKeySpecException;
 import org.mozilla.gecko.background.common.log.Logger;
 import org.mozilla.gecko.fxa.FxAccountConstants;
 import org.mozilla.gecko.fxa.login.State;
 import org.mozilla.gecko.fxa.login.State.StateLabel;
 import org.mozilla.gecko.fxa.login.StateFactory;
 import org.mozilla.gecko.sync.ExtendedJSONObject;
 import org.mozilla.gecko.sync.NonObjectJSONException;
 import org.mozilla.gecko.sync.Utils;
 import android.content.Context;
 /**
  * Android deletes Account objects when the Authenticator that owns the Account
  * disappears. This happens when an App is installed to the SD card and the SD
  * card is un-mounted or the device is rebooted.
  * <p>
  * We work around this by pickling the current Firefox account data every sync
  * and unpickling when we check if Firefox accounts exist (called from Fennec).
  * <p>
  * Android just doesn't support installing Apps that define long-lived Services
  * and/or own Account types onto the SD card. The documentation says not to do
  * it. There are hordes of developers who want to do it, and have tried to
  * register for almost every "package installation changed" broadcast intent
  * that Android supports. They all explicitly state that the package that has
  * changed does *not* receive the broadcast intent, thereby preventing an App
  * from re-establishing its state.
  * <p>
  * <a href="http://developer.android.com/guide/topics/data/install-location.html">Reference.</a>
  * <p>
  * <b>Quote</b>: Your AbstractThreadedSyncAdapter and all its sync functionality
  * will not work until external storage is remounted.
  * <p>
  * <b>Quote</b>: Your running Service will be killed and will not be restarted
  * when external storage is remounted. You can, however, register for the
  * ACTION_EXTERNAL_APPLICATIONS_AVAILABLE broadcast Intent, which will notify
  * your application when applications installed on external storage have become
  * available to the system again. At which time, you can restart your Service.
  * <p>
  * Problem: <a href="http://code.google.com/p/android/issues/detail?id=8485">that intent doesn't work</a>!
  * <p>
  * See bug 768102 for more information in the context of Sync.
  */
 public class AccountPickler {
   public static final String LOG_TAG = AccountPickler.class.getSimpleName();
   public static final long PICKLE_VERSION = 2;
   private static final String KEY_PICKLE_VERSION = "pickle_version";
   private static final String KEY_PICKLE_TIMESTAMP = "pickle_timestamp";
   private static final String KEY_ACCOUNT_VERSION = "account_version";
   private static final String KEY_ACCOUNT_TYPE = "account_type";
   private static final String KEY_EMAIL = "email";
   private static final String KEY_PROFILE = "profile";
   private static final String KEY_IDP_SERVER_URI = "idpServerURI";
   private static final String KEY_TOKEN_SERVER_URI = "tokenServerURI";
   private static final String KEY_IS_SYNCING_ENABLED = "isSyncingEnabled";
   private static final String KEY_BUNDLE = "bundle";
   /**
    * Remove Firefox account persisted to disk.
    *
    * @param context Android context.
    * @param filename name of persisted pickle file; must not contain path separators.
    * @return <code>true</code> if given pickle existed and was successfully deleted.
    */
   public static boolean deletePickle(final Context context, final String filename) {
     return context.deleteFile(filename);
   }
   /**
    * Persist Firefox account to disk as a JSON object.
    *
    * @param AndroidFxAccount the account to persist to disk
    * @param filename name of file to persist to; must not contain path separators.
    */
   public static void pickle(final AndroidFxAccount account, final String filename) {
     final ExtendedJSONObject o = new ExtendedJSONObject();
     o.put(KEY_PICKLE_VERSION, Long.valueOf(PICKLE_VERSION));
     o.put(KEY_PICKLE_TIMESTAMP, Long.valueOf(System.currentTimeMillis()));
     o.put(KEY_ACCOUNT_VERSION, AndroidFxAccount.CURRENT_ACCOUNT_VERSION);
     o.put(KEY_ACCOUNT_TYPE, FxAccountConstants.ACCOUNT_TYPE);
     o.put(KEY_EMAIL, account.getEmail());
     o.put(KEY_PROFILE, account.getProfile());
     o.put(KEY_IDP_SERVER_URI, account.getAccountServerURI());
     o.put(KEY_TOKEN_SERVER_URI, account.getTokenServerURI());
     o.put(KEY_IS_SYNCING_ENABLED, account.isSyncing());
     // TODO: If prefs version changes under us, SyncPrefsPath will change, "clearing" prefs.
     final ExtendedJSONObject bundle = account.unbundle();
     if (bundle == null) {
       Logger.warn(LOG_TAG, "Unable to obtain account bundle; aborting.");
       return;
     }
     o.put(KEY_BUNDLE, bundle);
     writeToDisk(account.context, filename, o);
   }
   private static void writeToDisk(final Context context, final String filename,
       final ExtendedJSONObject pickle) {
     try {
       final FileOutputStream fos = context.openFileOutput(filename, Context.MODE_PRIVATE);
       try {
         final PrintStream ps = new PrintStream(fos);
         try {
           ps.print(pickle.toJSONString());
           Logger.debug(LOG_TAG, "Persisted " + pickle.keySet().size() +
               " account settings to " + filename + ".");
         } finally {
           ps.close();
         }
       } finally {
         fos.close();
       }
     } catch (Exception e) {
       Logger.warn(LOG_TAG, "Caught exception persisting account settings to " + filename +
           "; ignoring.", e);
     }
   }
   /**
    * Create Android account from saved JSON object. Assumes that an account does not exist.
    *
    * @param context
    *          Android context.
    * @param filename
    *          name of file to read from; must not contain path separators.
    * @return created Android account, or null on error.
    */
   public static AndroidFxAccount unpickle(final Context context, final String filename) {
     final String jsonString = Utils.readFile(context, filename);
     if (jsonString == null) {
       Logger.info(LOG_TAG, "Pickle file '" + filename + "' not found; aborting.");
       return null;
     }
     ExtendedJSONObject json = null;
     try {
       json = ExtendedJSONObject.parseJSONObject(jsonString);
     } catch (Exception e) {
       Logger.warn(LOG_TAG, "Got exception reading pickle file '" + filename + "'; aborting.", e);
       return null;
     }
     final UnpickleParams params;
     try {
       params = UnpickleParams.fromJSON(json);
     } catch (Exception e) {
       Logger.warn(LOG_TAG, "Got exception extracting unpickle json; aborting.", e);
       return null;
     }
     final AndroidFxAccount account;
     try {
       account = AndroidFxAccount.addAndroidAccount(context, params.email, params.profile,
           params.idpServerURI, params.tokenServerURI, params.state, params.accountVersion,
           params.isSyncingEnabled, true, params.bundle);
     } catch (Exception e) {
       Logger.warn(LOG_TAG, "Exception when adding Android Account; aborting.", e);
       return null;
     }
     if (account == null) {
       Logger.warn(LOG_TAG, "Failed to add Android Account; aborting.");
       return null;
     }
     Long timestamp = json.getLong(KEY_PICKLE_TIMESTAMP);
     if (timestamp == null) {
       Logger.warn(LOG_TAG, "Did not find timestamp in pickle file; ignoring.");
       timestamp = Long.valueOf(-1);
     }
     Logger.info(LOG_TAG, "Un-pickled Android account named " + params.email + " (version " +
         params.pickleVersion + ", pickled at " + timestamp + ").");
     return account;
   }
   private static class UnpickleParams {
     private Long pickleVersion;
     private int accountVersion;
     private String email;
     private String profile;
     private String idpServerURI;
     private String tokenServerURI;
     private boolean isSyncingEnabled;
     private ExtendedJSONObject bundle;
     private State state;
     private UnpickleParams() {
     }
     private static UnpickleParams fromJSON(final ExtendedJSONObject json)
         throws InvalidKeySpecException, NoSuchAlgorithmException, NonObjectJSONException {
       final UnpickleParams params = new UnpickleParams();
       params.pickleVersion = json.getLong(KEY_PICKLE_VERSION);
       if (params.pickleVersion == null) {
         throw new IllegalStateException("Pickle version not found.");
       }
       /*
        * Version 1 and version 2 are identical, except version 2 throws if the
        * internal Android Account type has changed. Version 1 used to throw in
        * this case, but we intentionally used the pickle file to migrate across
        * Account types, bumping the version simultaneously.
        */
       switch (params.pickleVersion.intValue()) {
         case 2: {
           // Sanity check.
           final String accountType = json.getString(KEY_ACCOUNT_TYPE);
           if (!FxAccountConstants.ACCOUNT_TYPE.equals(accountType)) {
             throw new IllegalStateException("Account type has changed from " + accountType + " to " + FxAccountConstants.ACCOUNT_TYPE + ".");
           }
           params.unpickleV1(json);
         }
         break;
         case 1: {
           // Warn about account type changing, but don't throw over it.
           final String accountType = json.getString(KEY_ACCOUNT_TYPE);
           if (!FxAccountConstants.ACCOUNT_TYPE.equals(accountType)) {
             Logger.warn(LOG_TAG, "Account type has changed from " + accountType + " to " + FxAccountConstants.ACCOUNT_TYPE + "; ignoring.");
           }
           params.unpickleV1(json);
         }
         break;
         default:
           throw new IllegalStateException("Unknown pickle version, " + params.pickleVersion + ".");
       }
       return params;
     }
     private void unpickleV1(final ExtendedJSONObject json)
         throws NonObjectJSONException, NoSuchAlgorithmException, InvalidKeySpecException {
       this.accountVersion = json.getIntegerSafely(KEY_ACCOUNT_VERSION);
       this.email = json.getString(KEY_EMAIL);
       this.profile = json.getString(KEY_PROFILE);
       this.idpServerURI = json.getString(KEY_IDP_SERVER_URI);
       this.tokenServerURI = json.getString(KEY_TOKEN_SERVER_URI);
       this.isSyncingEnabled = json.getBoolean(KEY_IS_SYNCING_ENABLED);
       this.bundle = json.getObject(KEY_BUNDLE);
       if (bundle == null) {
         throw new IllegalStateException("Pickle bundle is null.");
       }
       this.state = getState(bundle);
     }
     private State getState(final ExtendedJSONObject bundle) throws InvalidKeySpecException,
             NonObjectJSONException, NoSuchAlgorithmException {
       // TODO: Should copy-pasta BUNDLE_KEY_STATE & LABEL to this file to ensure we maintain
       // old versions?
       final StateLabel stateLabel = StateLabel.valueOf(
           bundle.getString(AndroidFxAccount.BUNDLE_KEY_STATE_LABEL));
       final String stateString = bundle.getString(AndroidFxAccount.BUNDLE_KEY_STATE);
       if (stateLabel == null) {
         throw new IllegalStateException("stateLabel must not be null");
       }
       if (stateString == null) {
         throw new IllegalStateException("stateString must not be null");
       }
       try {
         return StateFactory.fromJSONObject(stateLabel, new ExtendedJSONObject(stateString));
       } catch (Exception e) {
         throw new IllegalStateException("could not get state", e);
       }
     }
   }
 }

The Tor Browser / annotate

mobile/android/base/fxa/authenticator/AccountPickler.java@6474c204b198 (annotated)

mobile/android/base/fxa/authenticator/AccountPickler.java