1 files changed, 297 insertions, 0 deletions
diff --git a/java/com/android/contacts/common/list/ContactListFilter.java b/java/com/android/contacts/common/list/ContactListFilter.java
new file mode 100644
index 000000000..1a03bb64c
--- /dev/null
+++ b/java/com/android/contacts/common/list/ContactListFilter.java
@@ -0,0 +1,297 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+package com.android.contacts.common.list;
+
+import android.content.SharedPreferences;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.provider.ContactsContract.RawContacts;
+import android.text.TextUtils;
+
+/** Contact list filter parameters. */
+public final class ContactListFilter implements Comparable<ContactListFilter>, Parcelable {
+
+  public static final int FILTER_TYPE_DEFAULT = -1;
+  public static final int FILTER_TYPE_ALL_ACCOUNTS = -2;
+  public static final int FILTER_TYPE_CUSTOM = -3;
+  public static final int FILTER_TYPE_STARRED = -4;
+  public static final int FILTER_TYPE_WITH_PHONE_NUMBERS_ONLY = -5;
+  public static final int FILTER_TYPE_SINGLE_CONTACT = -6;
+
+  public static final int FILTER_TYPE_ACCOUNT = 0;
+  public static final Parcelable.Creator<ContactListFilter> CREATOR =
+      new Parcelable.Creator<ContactListFilter>() {
+        @Override
+        public ContactListFilter createFromParcel(Parcel source) {
+          int filterType = source.readInt();
+          String accountName = source.readString();
+          String accountType = source.readString();
+          String dataSet = source.readString();
+          return new ContactListFilter(filterType, accountType, accountName, dataSet, null);
+        }
+
+        @Override
+        public ContactListFilter[] newArray(int size) {
+          return new ContactListFilter[size];
+        }
+      };
+  /**
+   * Obsolete filter which had been used in Honeycomb. This may be stored in {@link
+   * SharedPreferences}, but should be replaced with ALL filter when it is found.
+   *
+   * <p>TODO: "group" filter and relevant variables are all obsolete. Remove them.
+   */
+  private static final int FILTER_TYPE_GROUP = 1;
+
+  private static final String KEY_FILTER_TYPE = "filter.type";
+  private static final String KEY_ACCOUNT_NAME = "filter.accountName";
+  private static final String KEY_ACCOUNT_TYPE = "filter.accountType";
+  private static final String KEY_DATA_SET = "filter.dataSet";
+  public final int filterType;
+  public final String accountType;
+  public final String accountName;
+  public final String dataSet;
+  public final Drawable icon;
+  private String mId;
+
+  public ContactListFilter(
+      int filterType, String accountType, String accountName, String dataSet, Drawable icon) {
+    this.filterType = filterType;
+    this.accountType = accountType;
+    this.accountName = accountName;
+    this.dataSet = dataSet;
+    this.icon = icon;
+  }
+
+  public static ContactListFilter createFilterWithType(int filterType) {
+    return new ContactListFilter(filterType, null, null, null, null);
+  }
+
+  public static ContactListFilter createAccountFilter(
+      String accountType, String accountName, String dataSet, Drawable icon) {
+    return new ContactListFilter(
+        ContactListFilter.FILTER_TYPE_ACCOUNT, accountType, accountName, dataSet, icon);
+  }
+
+  /**
+   * Store the given {@link ContactListFilter} to preferences. If the requested filter is of type
+   * {@link #FILTER_TYPE_SINGLE_CONTACT} then do not save it to preferences because it is a
+   * temporary state.
+   */
+  public static void storeToPreferences(SharedPreferences prefs, ContactListFilter filter) {
+    if (filter != null && filter.filterType == FILTER_TYPE_SINGLE_CONTACT) {
+      return;
+    }
+    prefs
+        .edit()
+        .putInt(KEY_FILTER_TYPE, filter == null ? FILTER_TYPE_DEFAULT : filter.filterType)
+        .putString(KEY_ACCOUNT_NAME, filter == null ? null : filter.accountName)
+        .putString(KEY_ACCOUNT_TYPE, filter == null ? null : filter.accountType)
+        .putString(KEY_DATA_SET, filter == null ? null : filter.dataSet)
+        .apply();
+  }
+
+  /**
+   * Try to obtain ContactListFilter object saved in SharedPreference. If there's no info there,
+   * return ALL filter instead.
+   */
+  public static ContactListFilter restoreDefaultPreferences(SharedPreferences prefs) {
+    ContactListFilter filter = restoreFromPreferences(prefs);
+    if (filter == null) {
+      filter = ContactListFilter.createFilterWithType(FILTER_TYPE_ALL_ACCOUNTS);
+    }
+    // "Group" filter is obsolete and thus is not exposed anymore. The "single contact mode"
+    // should also not be stored in preferences anymore since it is a temporary state.
+    if (filter.filterType == FILTER_TYPE_GROUP || filter.filterType == FILTER_TYPE_SINGLE_CONTACT) {
+      filter = ContactListFilter.createFilterWithType(FILTER_TYPE_ALL_ACCOUNTS);
+    }
+    return filter;
+  }
+
+  private static ContactListFilter restoreFromPreferences(SharedPreferences prefs) {
+    int filterType = prefs.getInt(KEY_FILTER_TYPE, FILTER_TYPE_DEFAULT);
+    if (filterType == FILTER_TYPE_DEFAULT) {
+      return null;
+    }
+
+    String accountName = prefs.getString(KEY_ACCOUNT_NAME, null);
+    String accountType = prefs.getString(KEY_ACCOUNT_TYPE, null);
+    String dataSet = prefs.getString(KEY_DATA_SET, null);
+    return new ContactListFilter(filterType, accountType, accountName, dataSet, null);
+  }
+
+  public static final String filterTypeToString(int filterType) {
+    switch (filterType) {
+      case FILTER_TYPE_DEFAULT:
+        return "FILTER_TYPE_DEFAULT";
+      case FILTER_TYPE_ALL_ACCOUNTS:
+        return "FILTER_TYPE_ALL_ACCOUNTS";
+      case FILTER_TYPE_CUSTOM:
+        return "FILTER_TYPE_CUSTOM";
+      case FILTER_TYPE_STARRED:
+        return "FILTER_TYPE_STARRED";
+      case FILTER_TYPE_WITH_PHONE_NUMBERS_ONLY:
+        return "FILTER_TYPE_WITH_PHONE_NUMBERS_ONLY";
+      case FILTER_TYPE_SINGLE_CONTACT:
+        return "FILTER_TYPE_SINGLE_CONTACT";
+      case FILTER_TYPE_ACCOUNT:
+        return "FILTER_TYPE_ACCOUNT";
+      default:
+        return "(unknown)";
+    }
+  }
+
+  /** Returns true if this filter is based on data and may become invalid over time. */
+  public boolean isValidationRequired() {
+    return filterType == FILTER_TYPE_ACCOUNT;
+  }
+
+  @Override
+  public String toString() {
+    switch (filterType) {
+      case FILTER_TYPE_DEFAULT:
+        return "default";
+      case FILTER_TYPE_ALL_ACCOUNTS:
+        return "all_accounts";
+      case FILTER_TYPE_CUSTOM:
+        return "custom";
+      case FILTER_TYPE_STARRED:
+        return "starred";
+      case FILTER_TYPE_WITH_PHONE_NUMBERS_ONLY:
+        return "with_phones";
+      case FILTER_TYPE_SINGLE_CONTACT:
+        return "single";
+      case FILTER_TYPE_ACCOUNT:
+        return "account: "
+            + accountType
+            + (dataSet != null ? "/" + dataSet : "")
+            + " "
+            + accountName;
+    }
+    return super.toString();
+  }
+
+  @Override
+  public int compareTo(ContactListFilter another) {
+    int res = accountName.compareTo(another.accountName);
+    if (res != 0) {
+      return res;
+    }
+
+    res = accountType.compareTo(another.accountType);
+    if (res != 0) {
+      return res;
+    }
+
+    return filterType - another.filterType;
+  }
+
+  @Override
+  public int hashCode() {
+    int code = filterType;
+    if (accountType != null) {
+      code = code * 31 + accountType.hashCode();
+      code = code * 31 + accountName.hashCode();
+    }
+    if (dataSet != null) {
+      code = code * 31 + dataSet.hashCode();
+    }
+    return code;
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    if (this == other) {
+      return true;
+    }
+
+    if (!(other instanceof ContactListFilter)) {
+      return false;
+    }
+
+    ContactListFilter otherFilter = (ContactListFilter) other;
+    return filterType == otherFilter.filterType
+        && TextUtils.equals(accountName, otherFilter.accountName)
+        && TextUtils.equals(accountType, otherFilter.accountType)
+        && TextUtils.equals(dataSet, otherFilter.dataSet);
+
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    dest.writeInt(filterType);
+    dest.writeString(accountName);
+    dest.writeString(accountType);
+    dest.writeString(dataSet);
+  }
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  /** Returns a string that can be used as a stable persistent identifier for this filter. */
+  public String getId() {
+    if (mId == null) {
+      StringBuilder sb = new StringBuilder();
+      sb.append(filterType);
+      if (accountType != null) {
+        sb.append('-').append(accountType);
+      }
+      if (dataSet != null) {
+        sb.append('/').append(dataSet);
+      }
+      if (accountName != null) {
+        sb.append('-').append(accountName.replace('-', '_'));
+      }
+      mId = sb.toString();
+    }
+    return mId;
+  }
+
+  /**
+   * Adds the account query parameters to the given {@code uriBuilder}.
+   *
+   * @throws IllegalStateException if the filter type is not {@link #FILTER_TYPE_ACCOUNT}.
+   */
+  public Uri.Builder addAccountQueryParameterToUrl(Uri.Builder uriBuilder) {
+    if (filterType != FILTER_TYPE_ACCOUNT) {
+      throw new IllegalStateException("filterType must be FILTER_TYPE_ACCOUNT");
+    }
+    uriBuilder.appendQueryParameter(RawContacts.ACCOUNT_NAME, accountName);
+    uriBuilder.appendQueryParameter(RawContacts.ACCOUNT_TYPE, accountType);
+    if (!TextUtils.isEmpty(dataSet)) {
+      uriBuilder.appendQueryParameter(RawContacts.DATA_SET, dataSet);
+    }
+    return uriBuilder;
+  }
+
+  public String toDebugString() {
+    final StringBuilder builder = new StringBuilder();
+    builder.append("[filter type: " + filterType + " (" + filterTypeToString(filterType) + ")");
+    if (filterType == FILTER_TYPE_ACCOUNT) {
+      builder
+          .append(", accountType: " + accountType)
+          .append(", accountName: " + accountName)
+          .append(", dataSet: " + dataSet);
+    }
+    builder.append(", icon: " + icon + "]");
+    return builder.toString();
+  }
+}