The Tor Browser: comparison mobile/android/base/widget/ActivityChooserModel.java

--1:000000000000
+:3f28891df408
+/*
+* 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 / file comparison

comparison: mobile/android/base/widget/ActivityChooserModel.java

mobile/android/base/widget/ActivityChooserModel.java