The Tor Browser: mobile/android/base/widget/ActivityChooserModel.java@6474c204b198 (annotated)

mobile/android/base/widget/ActivityChooserModel.java@6474c204b198 (annotated)

mobile/android/base/widget/ActivityChooserModel.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.

 /*
  * Copyright (C) 2011 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.
  */
 /**
  * Mozilla: Changing the package.
  */
 //package android.widget;
 package org.mozilla.gecko.widget;
 // Mozilla: New import
 import org.mozilla.gecko.Distribution;
 import org.mozilla.gecko.GeckoProfile;
 import java.io.File;
 import android.content.BroadcastReceiver;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.pm.ResolveInfo;
 import android.database.DataSetObservable;
 import android.os.AsyncTask;
 import android.text.TextUtils;
 import android.util.Log;
 import android.util.Xml;
 /**
  * Mozilla: Unused import.
  */
 //import com.android.internal.content.PackageMonitor;
 import org.xmlpull.v1.XmlPullParser;
 import org.xmlpull.v1.XmlPullParserException;
 import org.xmlpull.v1.XmlSerializer;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 /**
  * <p>
  * This class represents a data model for choosing a component for handing a
  * given {@link Intent}. The model is responsible for querying the system for
  * activities that can handle the given intent and order found activities
  * based on historical data of previous choices. The historical data is stored
  * in an application private file. If a client does not want to have persistent
  * choice history the file can be omitted, thus the activities will be ordered
  * based on historical usage for the current session.
  * <p>
  * </p>
  * For each backing history file there is a singleton instance of this class. Thus,
  * several clients that specify the same history file will share the same model. Note
  * that if multiple clients are sharing the same model they should implement semantically
  * equivalent functionality since setting the model intent will change the found
  * activities and they may be inconsistent with the functionality of some of the clients.
  * For example, choosing a share activity can be implemented by a single backing
  * model and two different views for performing the selection. If however, one of the
  * views is used for sharing but the other for importing, for example, then each
  * view should be backed by a separate model.
  * </p>
  * <p>
  * The way clients interact with this class is as follows:
  * </p>
  * <p>
  * <pre>
  * <code>
  *  // Get a model and set it to a couple of clients with semantically similar function.
  *  ActivityChooserModel dataModel =
  *      ActivityChooserModel.get(context, "task_specific_history_file_name.xml");
  *
  *  ActivityChooserModelClient modelClient1 = getActivityChooserModelClient1();
  *  modelClient1.setActivityChooserModel(dataModel);
  *
  *  ActivityChooserModelClient modelClient2 = getActivityChooserModelClient2();
  *  modelClient2.setActivityChooserModel(dataModel);
  *
  *  // Set an intent to choose a an activity for.
  *  dataModel.setIntent(intent);
  * <pre>
  * <code>
  * </p>
  * <p>
  * <strong>Note:</strong> This class is thread safe.
  * </p>
  *
  * @hide
  */
 public class ActivityChooserModel extends DataSetObservable {
     /**
      * Client that utilizes an {@link ActivityChooserModel}.
      */
     public interface ActivityChooserModelClient {
         /**
          * Sets the {@link ActivityChooserModel}.
          *
          * @param dataModel The model.
          */
         public void setActivityChooserModel(ActivityChooserModel dataModel);
     }
     /**
      * Defines a sorter that is responsible for sorting the activities
      * based on the provided historical choices and an intent.
      */
     public interface ActivitySorter {
         /**
          * Sorts the <code>activities</code> in descending order of relevance
          * based on previous history and an intent.
          *
          * @param intent The {@link Intent}.
          * @param activities Activities to be sorted.
          * @param historicalRecords Historical records.
          */
         // This cannot be done by a simple comparator since an Activity weight
         // is computed from history. Note that Activity implements Comparable.
         public void sort(Intent intent, List<ActivityResolveInfo> activities,
                 List<HistoricalRecord> historicalRecords);
     }
     /**
      * Listener for choosing an activity.
      */
     public interface OnChooseActivityListener {
         /**
          * Called when an activity has been chosen. The client can decide whether
          * an activity can be chosen and if so the caller of
          * {@link ActivityChooserModel#chooseActivity(int)} will receive and {@link Intent}
          * for launching it.
          * <p>
          * <strong>Note:</strong> Modifying the intent is not permitted and
          *     any changes to the latter will be ignored.
          * </p>
          *
          * @param host The listener's host model.
          * @param intent The intent for launching the chosen activity.
          * @return Whether the intent is handled and should not be delivered to clients.
          *
          * @see ActivityChooserModel#chooseActivity(int)
          */
         public boolean onChooseActivity(ActivityChooserModel host, Intent intent);
     }
     /**
      * Flag for selecting debug mode.
      */
     private static final boolean DEBUG = false;
     /**
      * Tag used for logging.
      */
     private static final String LOG_TAG = ActivityChooserModel.class.getSimpleName();
     /**
      * The root tag in the history file.
      */
     private static final String TAG_HISTORICAL_RECORDS = "historical-records";
     /**
      * The tag for a record in the history file.
      */
     private static final String TAG_HISTORICAL_RECORD = "historical-record";
     /**
      * Attribute for the activity.
      */
     private static final String ATTRIBUTE_ACTIVITY = "activity";
     /**
      * Attribute for the choice time.
      */
     private static final String ATTRIBUTE_TIME = "time";
     /**
      * Attribute for the choice weight.
      */
     private static final String ATTRIBUTE_WEIGHT = "weight";
     /**
      * The default name of the choice history file.
      */
     public static final String DEFAULT_HISTORY_FILE_NAME =
         "activity_choser_model_history.xml";
     /**
      * The default maximal length of the choice history.
      */
     public static final int DEFAULT_HISTORY_MAX_LENGTH = 50;
     /**
      * The amount with which to inflate a chosen activity when set as default.
      */
     private static final int DEFAULT_ACTIVITY_INFLATION = 5;
     /**
      * Default weight for a choice record.
      */
     private static final float DEFAULT_HISTORICAL_RECORD_WEIGHT = 1.0f;
     /**
      * The extension of the history file.
      */
     private static final String HISTORY_FILE_EXTENSION = ".xml";
     /**
      * An invalid item index.
      */
     private static final int INVALID_INDEX = -1;
     /**
      * Lock to guard the model registry.
      */
     private static final Object sRegistryLock = new Object();
     /**
      * This the registry for data models.
      */
     private static final Map<String, ActivityChooserModel> sDataModelRegistry =
         new HashMap<String, ActivityChooserModel>();
     /**
      * Lock for synchronizing on this instance.
      */
     private final Object mInstanceLock = new Object();
     /**
      * List of activities that can handle the current intent.
      */
     private final List<ActivityResolveInfo> mActivities = new ArrayList<ActivityResolveInfo>();
     /**
      * List with historical choice records.
      */
     private final List<HistoricalRecord> mHistoricalRecords = new ArrayList<HistoricalRecord>();
     /**
      * Monitor for added and removed packages.
      */
     /**
      * Mozilla: Converted from a PackageMonitor to a DataModelPackageMonitor to avoid importing a new class.
      */
     private final DataModelPackageMonitor mPackageMonitor = new DataModelPackageMonitor();
     /**
      * Context for accessing resources.
      */
     private final Context mContext;
     /**
      * The name of the history file that backs this model.
      */
     private final String mHistoryFileName;
     /**
      * The intent for which a activity is being chosen.
      */
     private Intent mIntent;
     /**
      * The sorter for ordering activities based on intent and past choices.
      */
     private ActivitySorter mActivitySorter = new DefaultSorter();
     /**
      * The maximal length of the choice history.
      */
     private int mHistoryMaxSize = DEFAULT_HISTORY_MAX_LENGTH;
     /**
      * Flag whether choice history can be read. In general many clients can
      * share the same data model and {@link #readHistoricalDataIfNeeded()} may be called
      * by arbitrary of them any number of times. Therefore, this class guarantees
      * that the very first read succeeds and subsequent reads can be performed
      * only after a call to {@link #persistHistoricalDataIfNeeded()} followed by change
      * of the share records.
      */
     private boolean mCanReadHistoricalData = true;
     /**
      * Flag whether the choice history was read. This is used to enforce that
      * before calling {@link #persistHistoricalDataIfNeeded()} a call to
      * {@link #persistHistoricalDataIfNeeded()} has been made. This aims to avoid a
      * scenario in which a choice history file exits, it is not read yet and
      * it is overwritten. Note that always all historical records are read in
      * full and the file is rewritten. This is necessary since we need to
      * purge old records that are outside of the sliding window of past choices.
      */
     private boolean mReadShareHistoryCalled = false;
     /**
      * Flag whether the choice records have changed. In general many clients can
      * share the same data model and {@link #persistHistoricalDataIfNeeded()} may be called
      * by arbitrary of them any number of times. Therefore, this class guarantees
      * that choice history will be persisted only if it has changed.
      */
     private boolean mHistoricalRecordsChanged = true;
     /**
      * Flag whether to reload the activities for the current intent.
      */
     private boolean mReloadActivities = false;
     /**
      * Policy for controlling how the model handles chosen activities.
      */
     private OnChooseActivityListener mActivityChoserModelPolicy;
     /**
      * Gets the data model backed by the contents of the provided file with historical data.
      * Note that only one data model is backed by a given file, thus multiple calls with
      * the same file name will return the same model instance. If no such instance is present
      * it is created.
      * <p>
      * <strong>Note:</strong> To use the default historical data file clients should explicitly
      * pass as file name {@link #DEFAULT_HISTORY_FILE_NAME}. If no persistence of the choice
      * history is desired clients should pass <code>null</code> for the file name. In such
      * case a new model is returned for each invocation.
      * </p>
      *
      * <p>
      * <strong>Always use difference historical data files for semantically different actions.
      * For example, sharing is different from importing.</strong>
      * </p>
      *
      * @param context Context for loading resources.
      * @param historyFileName File name with choice history, <code>null</code>
      *        if the model should not be backed by a file. In this case the activities
      *        will be ordered only by data from the current session.
      *
      * @return The model.
      */
     public static ActivityChooserModel get(Context context, String historyFileName) {
         synchronized (sRegistryLock) {
             ActivityChooserModel dataModel = sDataModelRegistry.get(historyFileName);
             if (dataModel == null) {
                 dataModel = new ActivityChooserModel(context, historyFileName);
                 sDataModelRegistry.put(historyFileName, dataModel);
             }
             return dataModel;
         }
     }
     /**
      * Creates a new instance.
      *
      * @param context Context for loading resources.
      * @param historyFileName The history XML file.
      */
     private ActivityChooserModel(Context context, String historyFileName) {
         mContext = context.getApplicationContext();
         if (!TextUtils.isEmpty(historyFileName)
                 && !historyFileName.endsWith(HISTORY_FILE_EXTENSION)) {
             mHistoryFileName = historyFileName + HISTORY_FILE_EXTENSION;
         } else {
             mHistoryFileName = historyFileName;
         }
         /**
          * Mozilla: Uses modified receiver
          */
         mPackageMonitor.register(mContext);
     }
     /**
      * Sets an intent for which to choose a activity.
      * <p>
      * <strong>Note:</strong> Clients must set only semantically similar
      * intents for each data model.
      * <p>
      *
      * @param intent The intent.
      */
     public void setIntent(Intent intent) {
         synchronized (mInstanceLock) {
             if (mIntent == intent) {
                 return;
             }
             mIntent = intent;
             mReloadActivities = true;
             ensureConsistentState();
         }
     }
     /**
      * Gets the intent for which a activity is being chosen.
      *
      * @return The intent.
      */
     public Intent getIntent() {
         synchronized (mInstanceLock) {
             return mIntent;
         }
     }
     /**
      * Gets the number of activities that can handle the intent.
      *
      * @return The activity count.
      *
      * @see #setIntent(Intent)
      */
     public int getActivityCount() {
         synchronized (mInstanceLock) {
             ensureConsistentState();
             return mActivities.size();
         }
     }
     /**
      * Gets an activity at a given index.
      *
      * @return The activity.
      *
      * @see ActivityResolveInfo
      * @see #setIntent(Intent)
      */
     public ResolveInfo getActivity(int index) {
         synchronized (mInstanceLock) {
             ensureConsistentState();
             return mActivities.get(index).resolveInfo;
         }
     }
     /**
      * Gets the index of a the given activity.
      *
      * @param activity The activity index.
      *
      * @return The index if found, -1 otherwise.
      */
     public int getActivityIndex(ResolveInfo activity) {
         synchronized (mInstanceLock) {
             ensureConsistentState();
             List<ActivityResolveInfo> activities = mActivities;
             final int activityCount = activities.size();
             for (int i = 0; i < activityCount; i++) {
                 ActivityResolveInfo currentActivity = activities.get(i);
                 if (currentActivity.resolveInfo == activity) {
                     return i;
                 }
             }
             return INVALID_INDEX;
         }
     }
     /**
      * Chooses a activity to handle the current intent. This will result in
      * adding a historical record for that action and construct intent with
      * its component name set such that it can be immediately started by the
      * client.
      * <p>
      * <strong>Note:</strong> By calling this method the client guarantees
      * that the returned intent will be started. This intent is returned to
      * the client solely to let additional customization before the start.
      * </p>
      *
      * @return An {@link Intent} for launching the activity or null if the
      *         policy has consumed the intent or there is not current intent
      *         set via {@link #setIntent(Intent)}.
      *
      * @see HistoricalRecord
      * @see OnChooseActivityListener
      */
     public Intent chooseActivity(int index) {
         synchronized (mInstanceLock) {
             if (mIntent == null) {
                 return null;
             }
             ensureConsistentState();
             ActivityResolveInfo chosenActivity = mActivities.get(index);
             ComponentName chosenName = new ComponentName(
                     chosenActivity.resolveInfo.activityInfo.packageName,
                     chosenActivity.resolveInfo.activityInfo.name);
             Intent choiceIntent = new Intent(mIntent);
             choiceIntent.setComponent(chosenName);
             if (mActivityChoserModelPolicy != null) {
                 // Do not allow the policy to change the intent.
                 Intent choiceIntentCopy = new Intent(choiceIntent);
                 final boolean handled = mActivityChoserModelPolicy.onChooseActivity(this,
                         choiceIntentCopy);
                 if (handled) {
                     return null;
                 }
             }
             HistoricalRecord historicalRecord = new HistoricalRecord(chosenName,
                     System.currentTimeMillis(), DEFAULT_HISTORICAL_RECORD_WEIGHT);
             addHistoricalRecord(historicalRecord);
             return choiceIntent;
         }
     }
     /**
      * Sets the listener for choosing an activity.
      *
      * @param listener The listener.
      */
     public void setOnChooseActivityListener(OnChooseActivityListener listener) {
         synchronized (mInstanceLock) {
             mActivityChoserModelPolicy = listener;
         }
     }
     /**
      * Gets the default activity, The default activity is defined as the one
      * with highest rank i.e. the first one in the list of activities that can
      * handle the intent.
      *
      * @return The default activity, <code>null</code> id not activities.
      *
      * @see #getActivity(int)
      */
     public ResolveInfo getDefaultActivity() {
         synchronized (mInstanceLock) {
             ensureConsistentState();
             if (!mActivities.isEmpty()) {
                 return mActivities.get(0).resolveInfo;
             }
         }
         return null;
     }
     /**
      * Sets the default activity. The default activity is set by adding a
      * historical record with weight high enough that this activity will
      * become the highest ranked. Such a strategy guarantees that the default
      * will eventually change if not used. Also the weight of the record for
      * setting a default is inflated with a constant amount to guarantee that
      * it will stay as default for awhile.
      *
      * @param index The index of the activity to set as default.
      */
     public void setDefaultActivity(int index) {
         synchronized (mInstanceLock) {
             ensureConsistentState();
             ActivityResolveInfo newDefaultActivity = mActivities.get(index);
             ActivityResolveInfo oldDefaultActivity = mActivities.get(0);
             final float weight;
             if (oldDefaultActivity != null) {
                 // Add a record with weight enough to boost the chosen at the top.
                 weight = oldDefaultActivity.weight - newDefaultActivity.weight
                     + DEFAULT_ACTIVITY_INFLATION;
             } else {
                 weight = DEFAULT_HISTORICAL_RECORD_WEIGHT;
             }
             ComponentName defaultName = new ComponentName(
                     newDefaultActivity.resolveInfo.activityInfo.packageName,
                     newDefaultActivity.resolveInfo.activityInfo.name);
             HistoricalRecord historicalRecord = new HistoricalRecord(defaultName,
                     System.currentTimeMillis(), weight);
             addHistoricalRecord(historicalRecord);
         }
     }
     /**
      * Persists the history data to the backing file if the latter
      * was provided. Calling this method before a call to {@link #readHistoricalDataIfNeeded()}
      * throws an exception. Calling this method more than one without choosing an
      * activity has not effect.
      *
      * @throws IllegalStateException If this method is called before a call to
      *         {@link #readHistoricalDataIfNeeded()}.
      */
     private void persistHistoricalDataIfNeeded() {
         if (!mReadShareHistoryCalled) {
             throw new IllegalStateException("No preceding call to #readHistoricalData");
         }
         if (!mHistoricalRecordsChanged) {
             return;
         }
         mHistoricalRecordsChanged = false;
         if (!TextUtils.isEmpty(mHistoryFileName)) {
             /**
              * Mozilla: Converted to a normal task.execute call so that this works on < ICS phones.
              */
             new PersistHistoryAsyncTask().execute(new ArrayList<HistoricalRecord>(mHistoricalRecords), mHistoryFileName);
         }
     }
     /**
      * Sets the sorter for ordering activities based on historical data and an intent.
      *
      * @param activitySorter The sorter.
      *
      * @see ActivitySorter
      */
     public void setActivitySorter(ActivitySorter activitySorter) {
         synchronized (mInstanceLock) {
             if (mActivitySorter == activitySorter) {
                 return;
             }
             mActivitySorter = activitySorter;
             if (sortActivitiesIfNeeded()) {
                 notifyChanged();
             }
         }
     }
     /**
      * Sets the maximal size of the historical data. Defaults to
      * {@link #DEFAULT_HISTORY_MAX_LENGTH}
      * <p>
      *   <strong>Note:</strong> Setting this property will immediately
      *   enforce the specified max history size by dropping enough old
      *   historical records to enforce the desired size. Thus, any
      *   records that exceed the history size will be discarded and
      *   irreversibly lost.
      * </p>
      *
      * @param historyMaxSize The max history size.
      */
     public void setHistoryMaxSize(int historyMaxSize) {
         synchronized (mInstanceLock) {
             if (mHistoryMaxSize == historyMaxSize) {
                 return;
             }
             mHistoryMaxSize = historyMaxSize;
             pruneExcessiveHistoricalRecordsIfNeeded();
             if (sortActivitiesIfNeeded()) {
                 notifyChanged();
             }
         }
     }
     /**
      * Gets the history max size.
      *
      * @return The history max size.
      */
     public int getHistoryMaxSize() {
         synchronized (mInstanceLock) {
             return mHistoryMaxSize;
         }
     }
     /**
      * Gets the history size.
      *
      * @return The history size.
      */
     public int getHistorySize() {
         synchronized (mInstanceLock) {
             ensureConsistentState();
             return mHistoricalRecords.size();
         }
     }
     public int getDistinctActivityCountInHistory() {
         synchronized (mInstanceLock) {
             ensureConsistentState();
             final List<String> packages = new ArrayList<String>();
             for (HistoricalRecord record : mHistoricalRecords) {
               String activity = record.activity.flattenToString();
               if (!packages.contains(activity)) {
                 packages.add(activity);
               }
             }
             return packages.size();
         }
     }
     @Override
     protected void finalize() throws Throwable {
         super.finalize();
         /**
          * Mozilla: Not needed for the application.
          */
         mPackageMonitor.unregister();
     }
     /**
      * Ensures the model is in a consistent state which is the
      * activities for the current intent have been loaded, the
      * most recent history has been read, and the activities
      * are sorted.
      */
     private void ensureConsistentState() {
         boolean stateChanged = loadActivitiesIfNeeded();
         stateChanged |= readHistoricalDataIfNeeded();
         pruneExcessiveHistoricalRecordsIfNeeded();
         if (stateChanged) {
             sortActivitiesIfNeeded();
             notifyChanged();
         }
     }
     /**
      * Sorts the activities if necessary which is if there is a
      * sorter, there are some activities to sort, and there is some
      * historical data.
      *
      * @return Whether sorting was performed.
      */
     private boolean sortActivitiesIfNeeded() {
         if (mActivitySorter != null && mIntent != null
                 && !mActivities.isEmpty() && !mHistoricalRecords.isEmpty()) {
             mActivitySorter.sort(mIntent, mActivities,
                     Collections.unmodifiableList(mHistoricalRecords));
             return true;
         }
         return false;
     }
     /**
      * Loads the activities for the current intent if needed which is
      * if they are not already loaded for the current intent.
      *
      * @return Whether loading was performed.
      */
     private boolean loadActivitiesIfNeeded() {
         if (mReloadActivities && mIntent != null) {
             mReloadActivities = false;
             mActivities.clear();
             List<ResolveInfo> resolveInfos = mContext.getPackageManager()
                     .queryIntentActivities(mIntent, 0);
             final int resolveInfoCount = resolveInfos.size();
             for (int i = 0; i < resolveInfoCount; i++) {
                 ResolveInfo resolveInfo = resolveInfos.get(i);
                 mActivities.add(new ActivityResolveInfo(resolveInfo));
             }
             return true;
         }
         return false;
     }
     /**
      * Reads the historical data if necessary which is it has
      * changed, there is a history file, and there is not persist
      * in progress.
      *
      * @return Whether reading was performed.
      */
     private boolean readHistoricalDataIfNeeded() {
         if (mCanReadHistoricalData && mHistoricalRecordsChanged &&
                 !TextUtils.isEmpty(mHistoryFileName)) {
             mCanReadHistoricalData = false;
             mReadShareHistoryCalled = true;
             readHistoricalDataImpl();
             return true;
         }
         return false;
     }
     /**
      * Adds a historical record.
      *
      * @param historicalRecord The record to add.
      * @return True if the record was added.
      */
     private boolean addHistoricalRecord(HistoricalRecord historicalRecord) {
         final boolean added = mHistoricalRecords.add(historicalRecord);
         if (added) {
             mHistoricalRecordsChanged = true;
             pruneExcessiveHistoricalRecordsIfNeeded();
             persistHistoricalDataIfNeeded();
             sortActivitiesIfNeeded();
             notifyChanged();
         }
         return added;
     }
     /**
      * Removes all historical records for this pkg.
      *
      * @param historicalRecord The pkg to delete records for.
      * @return True if the record was added.
      */
     private boolean removeHistoricalRecordsForPackage(final String pkg) {
         boolean removed = false;
         for (Iterator<HistoricalRecord> i = mHistoricalRecords.iterator(); i.hasNext();) {
             final HistoricalRecord record = i.next();
             if (record.activity.getPackageName().equals(pkg)) {
                 i.remove();
                 removed = true;
             }
         }
         if (removed) {
             mHistoricalRecordsChanged = true;
             pruneExcessiveHistoricalRecordsIfNeeded();
             persistHistoricalDataIfNeeded();
             sortActivitiesIfNeeded();
             notifyChanged();
         }
         return removed;
     }
     /**
      * Prunes older excessive records to guarantee maxHistorySize.
      */
     private void pruneExcessiveHistoricalRecordsIfNeeded() {
         final int pruneCount = mHistoricalRecords.size() - mHistoryMaxSize;
         if (pruneCount <= 0) {
             return;
         }
         mHistoricalRecordsChanged = true;
         for (int i = 0; i < pruneCount; i++) {
             HistoricalRecord prunedRecord = mHistoricalRecords.remove(0);
             if (DEBUG) {
                 Log.i(LOG_TAG, "Pruned: " + prunedRecord);
             }
         }
     }
     /**
      * Represents a record in the history.
      */
     public final static class HistoricalRecord {
         /**
          * The activity name.
          */
         public final ComponentName activity;
         /**
          * The choice time.
          */
         public final long time;
         /**
          * The record weight.
          */
         public final float weight;
         /**
          * Creates a new instance.
          *
          * @param activityName The activity component name flattened to string.
          * @param time The time the activity was chosen.
          * @param weight The weight of the record.
          */
         public HistoricalRecord(String activityName, long time, float weight) {
             this(ComponentName.unflattenFromString(activityName), time, weight);
         }
         /**
          * Creates a new instance.
          *
          * @param activityName The activity name.
          * @param time The time the activity was chosen.
          * @param weight The weight of the record.
          */
         public HistoricalRecord(ComponentName activityName, long time, float weight) {
             this.activity = activityName;
             this.time = time;
             this.weight = weight;
         }
         @Override
         public int hashCode() {
             final int prime = 31;
             int result = 1;
             result = prime * result + ((activity == null) ? 0 : activity.hashCode());
             result = prime * result + (int) (time ^ (time >>> 32));
             result = prime * result + Float.floatToIntBits(weight);
             return result;
         }
         @Override
         public boolean equals(Object obj) {
             if (this == obj) {
                 return true;
             }
             if (obj == null) {
                 return false;
             }
             if (getClass() != obj.getClass()) {
                 return false;
             }
             HistoricalRecord other = (HistoricalRecord) obj;
             if (activity == null) {
                 if (other.activity != null) {
                     return false;
                 }
             } else if (!activity.equals(other.activity)) {
                 return false;
             }
             if (time != other.time) {
                 return false;
             }
             if (Float.floatToIntBits(weight) != Float.floatToIntBits(other.weight)) {
                 return false;
             }
             return true;
         }
         @Override
         public String toString() {
             StringBuilder builder = new StringBuilder();
             builder.append("[");
             builder.append("; activity:").append(activity);
             builder.append("; time:").append(time);
             builder.append("; weight:").append(new BigDecimal(weight));
             builder.append("]");
             return builder.toString();
         }
     }
     /**
      * Represents an activity.
      */
     public final class ActivityResolveInfo implements Comparable<ActivityResolveInfo> {
         /**
          * The {@link ResolveInfo} of the activity.
          */
         public final ResolveInfo resolveInfo;
         /**
          * Weight of the activity. Useful for sorting.
          */
         public float weight;
         /**
          * Creates a new instance.
          *
          * @param resolveInfo activity {@link ResolveInfo}.
          */
         public ActivityResolveInfo(ResolveInfo resolveInfo) {
             this.resolveInfo = resolveInfo;
         }
         @Override
         public int hashCode() {
             return 31 + Float.floatToIntBits(weight);
         }
         @Override
         public boolean equals(Object obj) {
             if (this == obj) {
                 return true;
             }
             if (obj == null) {
                 return false;
             }
             if (getClass() != obj.getClass()) {
                 return false;
             }
             ActivityResolveInfo other = (ActivityResolveInfo) obj;
             if (Float.floatToIntBits(weight) != Float.floatToIntBits(other.weight)) {
                 return false;
             }
             return true;
         }
         public int compareTo(ActivityResolveInfo another) {
              return  Float.floatToIntBits(another.weight) - Float.floatToIntBits(weight);
         }
         @Override
         public String toString() {
             StringBuilder builder = new StringBuilder();
             builder.append("[");
             builder.append("resolveInfo:").append(resolveInfo.toString());
             builder.append("; weight:").append(new BigDecimal(weight));
             builder.append("]");
             return builder.toString();
         }
     }
     /**
      * Default activity sorter implementation.
      */
     private final class DefaultSorter implements ActivitySorter {
         private static final float WEIGHT_DECAY_COEFFICIENT = 0.95f;
         private final Map<String, ActivityResolveInfo> mPackageNameToActivityMap =
             new HashMap<String, ActivityResolveInfo>();
         public void sort(Intent intent, List<ActivityResolveInfo> activities,
                 List<HistoricalRecord> historicalRecords) {
             Map<String, ActivityResolveInfo> packageNameToActivityMap =
                 mPackageNameToActivityMap;
             packageNameToActivityMap.clear();
             final int activityCount = activities.size();
             for (int i = 0; i < activityCount; i++) {
                 ActivityResolveInfo activity = activities.get(i);
                 activity.weight = 0.0f;
                 // Make sure we're using a non-ambiguous name here
                 ComponentName chosenName = new ComponentName(
                         activity.resolveInfo.activityInfo.packageName,
                         activity.resolveInfo.activityInfo.name);
                 String packageName = chosenName.flattenToString();
                 packageNameToActivityMap.put(packageName, activity);
             }
             final int lastShareIndex = historicalRecords.size() - 1;
             float nextRecordWeight = 1;
             for (int i = lastShareIndex; i >= 0; i--) {
                 HistoricalRecord historicalRecord = historicalRecords.get(i);
                 String packageName = historicalRecord.activity.flattenToString();
                 ActivityResolveInfo activity = packageNameToActivityMap.get(packageName);
                 if (activity != null) {
                     activity.weight += historicalRecord.weight * nextRecordWeight;
                     nextRecordWeight = nextRecordWeight * WEIGHT_DECAY_COEFFICIENT;
                 }
             }
             Collections.sort(activities);
             if (DEBUG) {
                 for (int i = 0; i < activityCount; i++) {
                     Log.i(LOG_TAG, "Sorted: " + activities.get(i));
                 }
             }
         }
     }
     /**
      * Command for reading the historical records from a file off the UI thread.
      */
     private void readHistoricalDataImpl() {
         FileInputStream fis = null;
         try {
             GeckoProfile profile = GeckoProfile.get(mContext);
             File f = profile.getFile(mHistoryFileName);
             if (!f.exists()) {
                 // Fall back to the non-profile aware file if it exists...
                 File oldFile = new File(mHistoryFileName);
                 oldFile.renameTo(f);
             }
             fis = new FileInputStream(f);
         } catch (FileNotFoundException fnfe) {
             try {
                 Distribution dist = new Distribution(mContext);
                 File distFile = dist.getDistributionFile("quickshare/" + mHistoryFileName);
                 if (distFile == null) {
                     if (DEBUG) {
                         Log.i(LOG_TAG, "Could not open historical records file: " + mHistoryFileName);
                     }
                     return;
                 }
                 fis = new FileInputStream(distFile);
             } catch(Exception ex) {
                 if (DEBUG) {
                     Log.i(LOG_TAG, "Could not open historical records file: " + mHistoryFileName);
                 }
                 return;
             }
         }
         try {
             XmlPullParser parser = Xml.newPullParser();
             parser.setInput(fis, null);
             int type = XmlPullParser.START_DOCUMENT;
             while (type != XmlPullParser.END_DOCUMENT && type != XmlPullParser.START_TAG) {
                 type = parser.next();
             }
             if (!TAG_HISTORICAL_RECORDS.equals(parser.getName())) {
                 throw new XmlPullParserException("Share records file does not start with "
                         + TAG_HISTORICAL_RECORDS + " tag.");
             }
             List<HistoricalRecord> historicalRecords = mHistoricalRecords;
             historicalRecords.clear();
             while (true) {
                 type = parser.next();
                 if (type == XmlPullParser.END_DOCUMENT) {
                     break;
                 }
                 if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
                     continue;
                 }
                 String nodeName = parser.getName();
                 if (!TAG_HISTORICAL_RECORD.equals(nodeName)) {
                     throw new XmlPullParserException("Share records file not well-formed.");
                 }
                 String activity = parser.getAttributeValue(null, ATTRIBUTE_ACTIVITY);
                 final long time =
                     Long.parseLong(parser.getAttributeValue(null, ATTRIBUTE_TIME));
                 final float weight =
                     Float.parseFloat(parser.getAttributeValue(null, ATTRIBUTE_WEIGHT));
                  HistoricalRecord readRecord = new HistoricalRecord(activity, time, weight);
                 historicalRecords.add(readRecord);
                 if (DEBUG) {
                     Log.i(LOG_TAG, "Read " + readRecord.toString());
                 }
             }
             if (DEBUG) {
                 Log.i(LOG_TAG, "Read " + historicalRecords.size() + " historical records.");
             }
         } catch (XmlPullParserException xppe) {
             Log.e(LOG_TAG, "Error reading historical recrod file: " + mHistoryFileName, xppe);
         } catch (IOException ioe) {
             Log.e(LOG_TAG, "Error reading historical recrod file: " + mHistoryFileName, ioe);
         } finally {
             if (fis != null) {
                 try {
                     fis.close();
                 } catch (IOException ioe) {
                     /* ignore */
                 }
             }
         }
     }
     /**
      * Command for persisting the historical records to a file off the UI thread.
      */
     private final class PersistHistoryAsyncTask extends AsyncTask<Object, Void, Void> {
         @Override
         @SuppressWarnings("unchecked")
         public Void doInBackground(Object... args) {
             List<HistoricalRecord> historicalRecords = (List<HistoricalRecord>) args[0];
             String historyFileName = (String) args[1];
             FileOutputStream fos = null;
             try {
                 // Mozilla - Update the location we save files to
                 GeckoProfile profile = GeckoProfile.get(mContext);
                 File file = profile.getFile(historyFileName);
                 fos = new FileOutputStream(file);
             } catch (FileNotFoundException fnfe) {
                 Log.e(LOG_TAG, "Error writing historical record file: " + historyFileName, fnfe);
                 return null;
             }
             XmlSerializer serializer = Xml.newSerializer();
             try {
                 serializer.setOutput(fos, null);
                 serializer.startDocument("UTF-8", true);
                 serializer.startTag(null, TAG_HISTORICAL_RECORDS);
                 final int recordCount = historicalRecords.size();
                 for (int i = 0; i < recordCount; i++) {
                     HistoricalRecord record = historicalRecords.remove(0);
                     serializer.startTag(null, TAG_HISTORICAL_RECORD);
                     serializer.attribute(null, ATTRIBUTE_ACTIVITY,
                             record.activity.flattenToString());
                     serializer.attribute(null, ATTRIBUTE_TIME, String.valueOf(record.time));
                     serializer.attribute(null, ATTRIBUTE_WEIGHT, String.valueOf(record.weight));
                     serializer.endTag(null, TAG_HISTORICAL_RECORD);
                     if (DEBUG) {
                         Log.i(LOG_TAG, "Wrote " + record.toString());
                     }
                 }
                 serializer.endTag(null, TAG_HISTORICAL_RECORDS);
                 serializer.endDocument();
                 if (DEBUG) {
                     Log.i(LOG_TAG, "Wrote " + recordCount + " historical records.");
                 }
             } catch (IllegalArgumentException iae) {
                 Log.e(LOG_TAG, "Error writing historical recrod file: " + mHistoryFileName, iae);
             } catch (IllegalStateException ise) {
                 Log.e(LOG_TAG, "Error writing historical recrod file: " + mHistoryFileName, ise);
             } catch (IOException ioe) {
                 Log.e(LOG_TAG, "Error writing historical recrod file: " + mHistoryFileName, ioe);
             } finally {
                 mCanReadHistoricalData = true;
                 if (fos != null) {
                     try {
                         fos.close();
                     } catch (IOException e) {
                         /* ignore */
                     }
                 }
             }
             return null;
         }
     }
     /**
      * Keeps in sync the historical records and activities with the installed applications.
      */
     /**
      * Mozilla: Adapted significantly
      */
     private static final String LOGTAG = "GeckoActivityChooserModel";
     private final class DataModelPackageMonitor extends BroadcastReceiver {
         private Context mContext;
         public DataModelPackageMonitor() { }
         public void register(Context context) {
             mContext = context;
             String[] intents = new String[] {
                 Intent.ACTION_PACKAGE_REMOVED,
                 Intent.ACTION_PACKAGE_ADDED,
                 Intent.ACTION_PACKAGE_CHANGED
             };
             for (String intent : intents) {
                 IntentFilter removeFilter = new IntentFilter(intent);
                 removeFilter.addDataScheme("package");
                 context.registerReceiver(this, removeFilter);
             }
         }
         public void unregister() {
             mContext.unregisterReceiver(this);
             mContext = null;
         }
         @Override
         public void onReceive(Context context, Intent intent) {
             String action = intent.getAction();
             if (Intent.ACTION_PACKAGE_REMOVED.equals(action)) {
                 String packageName = intent.getData().getSchemeSpecificPart();
                 removeHistoricalRecordsForPackage(packageName);
             }
             mReloadActivities = true;
         }
     }
 }

The Tor Browser / annotate

mobile/android/base/widget/ActivityChooserModel.java@6474c204b198 (annotated)

mobile/android/base/widget/ActivityChooserModel.java