1 /*
2  * Copyright (C) 2011 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.contacts.common.model.account;
18 
19 import android.accounts.Account;
20 import android.content.Context;
21 import android.database.Cursor;
22 import android.net.Uri;
23 import android.os.Parcelable;
24 import android.os.Parcel;
25 import android.provider.BaseColumns;
26 import android.provider.ContactsContract;
27 import android.provider.ContactsContract.RawContacts;
28 import android.text.TextUtils;
29 
30 import com.google.common.base.Objects;
31 import com.google.common.collect.Lists;
32 
33 import java.util.ArrayList;
34 import java.util.List;
35 import java.util.regex.Pattern;
36 
37 /**
38  * Wrapper for an account that includes a data set (which may be null).
39  */
40 public class AccountWithDataSet implements Parcelable {
41     private static final String STRINGIFY_SEPARATOR = "\u0001";
42     private static final String ARRAY_STRINGIFY_SEPARATOR = "\u0002";
43 
44     private static final Pattern STRINGIFY_SEPARATOR_PAT =
45             Pattern.compile(Pattern.quote(STRINGIFY_SEPARATOR));
46     private static final Pattern ARRAY_STRINGIFY_SEPARATOR_PAT =
47             Pattern.compile(Pattern.quote(ARRAY_STRINGIFY_SEPARATOR));
48 
49     public final String name;
50     public final String type;
51     public final String dataSet;
52     private final AccountTypeWithDataSet mAccountTypeWithDataSet;
53 
54     private static final String[] ID_PROJECTION = new String[] {BaseColumns._ID};
55     private static final Uri RAW_CONTACTS_URI_LIMIT_1 = RawContacts.CONTENT_URI.buildUpon()
56             .appendQueryParameter(ContactsContract.LIMIT_PARAM_KEY, "1").build();
57 
58 
AccountWithDataSet(String name, String type, String dataSet)59     public AccountWithDataSet(String name, String type, String dataSet) {
60         this.name = emptyToNull(name);
61         this.type = emptyToNull(type);
62         this.dataSet = emptyToNull(dataSet);
63         mAccountTypeWithDataSet = AccountTypeWithDataSet.get(type, dataSet);
64     }
65 
emptyToNull(String text)66     private static final String emptyToNull(String text) {
67         return TextUtils.isEmpty(text) ? null : text;
68     }
69 
AccountWithDataSet(Parcel in)70     public AccountWithDataSet(Parcel in) {
71         this.name = in.readString();
72         this.type = in.readString();
73         this.dataSet = in.readString();
74         mAccountTypeWithDataSet = AccountTypeWithDataSet.get(type, dataSet);
75     }
76 
isLocalAccount()77     public boolean isLocalAccount() {
78         return name == null && type == null;
79     }
80 
getAccountOrNull()81     public Account getAccountOrNull() {
82         if (name != null && type != null) {
83             return new Account(name, type);
84         }
85         return null;
86     }
87 
describeContents()88     public int describeContents() {
89         return 0;
90     }
91 
writeToParcel(Parcel dest, int flags)92     public void writeToParcel(Parcel dest, int flags) {
93         dest.writeString(name);
94         dest.writeString(type);
95         dest.writeString(dataSet);
96     }
97 
98     // For Parcelable
99     public static final Creator<AccountWithDataSet> CREATOR = new Creator<AccountWithDataSet>() {
100         public AccountWithDataSet createFromParcel(Parcel source) {
101             return new AccountWithDataSet(source);
102         }
103 
104         public AccountWithDataSet[] newArray(int size) {
105             return new AccountWithDataSet[size];
106         }
107     };
108 
getAccountTypeWithDataSet()109     public AccountTypeWithDataSet getAccountTypeWithDataSet() {
110         return mAccountTypeWithDataSet;
111     }
112 
113     /**
114      * Return {@code true} if this account has any contacts in the database.
115      * Touches DB.  Don't use in the UI thread.
116      */
hasData(Context context)117     public boolean hasData(Context context) {
118         final String BASE_SELECTION =
119                 RawContacts.ACCOUNT_TYPE + " = ?" + " AND " + RawContacts.ACCOUNT_NAME + " = ?";
120         final String selection;
121         final String[] args;
122         if (TextUtils.isEmpty(dataSet)) {
123             selection = BASE_SELECTION + " AND " + RawContacts.DATA_SET + " IS NULL";
124             args = new String[] {type, name};
125         } else {
126             selection = BASE_SELECTION + " AND " + RawContacts.DATA_SET + " = ?";
127             args = new String[] {type, name, dataSet};
128         }
129 
130         final Cursor c = context.getContentResolver().query(RAW_CONTACTS_URI_LIMIT_1,
131                 ID_PROJECTION, selection, args, null);
132         if (c == null) return false;
133         try {
134             return c.moveToFirst();
135         } finally {
136             c.close();
137         }
138     }
139 
equals(Object obj)140     public boolean equals(Object obj) {
141         if (obj instanceof AccountWithDataSet) {
142             AccountWithDataSet other = (AccountWithDataSet) obj;
143             return Objects.equal(name, other.name)
144                     && Objects.equal(type, other.type)
145                     && Objects.equal(dataSet, other.dataSet);
146         }
147         return false;
148     }
149 
hashCode()150     public int hashCode() {
151         int result = 17;
152         result = 31 * result + (name != null ? name.hashCode() : 0);
153         result = 31 * result + (type != null ? type.hashCode() : 0);
154         result = 31 * result + (dataSet != null ? dataSet.hashCode() : 0);
155         return result;
156     }
157 
toString()158     public String toString() {
159         return "AccountWithDataSet {name=" + name + ", type=" + type + ", dataSet=" + dataSet + "}";
160     }
161 
addStringified(StringBuilder sb, AccountWithDataSet account)162     private static StringBuilder addStringified(StringBuilder sb, AccountWithDataSet account) {
163         if (!TextUtils.isEmpty(account.name)) sb.append(account.name);
164         sb.append(STRINGIFY_SEPARATOR);
165         if (!TextUtils.isEmpty(account.type)) sb.append(account.type);
166         sb.append(STRINGIFY_SEPARATOR);
167         if (!TextUtils.isEmpty(account.dataSet)) sb.append(account.dataSet);
168 
169         return sb;
170     }
171 
172     /**
173      * Pack the instance into a string.
174      */
stringify()175     public String stringify() {
176         return addStringified(new StringBuilder(), this).toString();
177     }
178 
179     /**
180      * Unpack a string created by {@link #stringify}.
181      *
182      * @throws IllegalArgumentException if it's an invalid string.
183      */
unstringify(String s)184     public static AccountWithDataSet unstringify(String s) {
185         final String[] array = STRINGIFY_SEPARATOR_PAT.split(s, 3);
186         if (array.length < 3) {
187             throw new IllegalArgumentException("Invalid string " + s);
188         }
189         return new AccountWithDataSet(array[0], array[1],
190                 TextUtils.isEmpty(array[2]) ? null : array[2]);
191     }
192 
193     /**
194      * Pack a list of {@link AccountWithDataSet} into a string.
195      */
stringifyList(List<AccountWithDataSet> accounts)196     public static String stringifyList(List<AccountWithDataSet> accounts) {
197         final StringBuilder sb = new StringBuilder();
198 
199         for (AccountWithDataSet account : accounts) {
200             if (sb.length() > 0) {
201                 sb.append(ARRAY_STRINGIFY_SEPARATOR);
202             }
203             addStringified(sb, account);
204         }
205 
206         return sb.toString();
207     }
208 
209     /**
210      * Unpack a list of {@link AccountWithDataSet} into a string.
211      *
212      * @throws IllegalArgumentException if it's an invalid string.
213      */
unstringifyList(String s)214     public static List<AccountWithDataSet> unstringifyList(String s) {
215         final ArrayList<AccountWithDataSet> ret = Lists.newArrayList();
216         if (TextUtils.isEmpty(s)) {
217             return ret;
218         }
219 
220         final String[] array = ARRAY_STRINGIFY_SEPARATOR_PAT.split(s);
221 
222         for (int i = 0; i < array.length; i++) {
223             ret.add(unstringify(array[i]));
224         }
225 
226         return ret;
227     }
228 }
229