1 /* 2 * Copyright (C) 2009 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 android.content; 18 19 import android.text.TextUtils; 20 import android.os.Parcelable; 21 import android.os.Parcel; 22 23 /** 24 * Value type that represents a SyncAdapterType. This object overrides {@link #equals} and 25 * {@link #hashCode}, making it suitable for use as the key of a {@link java.util.Map} 26 */ 27 public class SyncAdapterType implements Parcelable { 28 public final String authority; 29 public final String accountType; 30 public final boolean isKey; 31 private final boolean userVisible; 32 private final boolean supportsUploading; 33 private final boolean isAlwaysSyncable; 34 private final boolean allowParallelSyncs; 35 private final String settingsActivity; 36 37 public SyncAdapterType(String authority, String accountType, boolean userVisible, 38 boolean supportsUploading) { 39 if (TextUtils.isEmpty(authority)) { 40 throw new IllegalArgumentException("the authority must not be empty: " + authority); 41 } 42 if (TextUtils.isEmpty(accountType)) { 43 throw new IllegalArgumentException("the accountType must not be empty: " + accountType); 44 } 45 this.authority = authority; 46 this.accountType = accountType; 47 this.userVisible = userVisible; 48 this.supportsUploading = supportsUploading; 49 this.isAlwaysSyncable = false; 50 this.allowParallelSyncs = false; 51 this.settingsActivity = null; 52 this.isKey = false; 53 } 54 55 /** @hide */ 56 public SyncAdapterType(String authority, String accountType, boolean userVisible, 57 boolean supportsUploading, 58 boolean isAlwaysSyncable, 59 boolean allowParallelSyncs, 60 String settingsActivity) { 61 if (TextUtils.isEmpty(authority)) { 62 throw new IllegalArgumentException("the authority must not be empty: " + authority); 63 } 64 if (TextUtils.isEmpty(accountType)) { 65 throw new IllegalArgumentException("the accountType must not be empty: " + accountType); 66 } 67 this.authority = authority; 68 this.accountType = accountType; 69 this.userVisible = userVisible; 70 this.supportsUploading = supportsUploading; 71 this.isAlwaysSyncable = isAlwaysSyncable; 72 this.allowParallelSyncs = allowParallelSyncs; 73 this.settingsActivity = settingsActivity; 74 this.isKey = false; 75 } 76 77 private SyncAdapterType(String authority, String accountType) { 78 if (TextUtils.isEmpty(authority)) { 79 throw new IllegalArgumentException("the authority must not be empty: " + authority); 80 } 81 if (TextUtils.isEmpty(accountType)) { 82 throw new IllegalArgumentException("the accountType must not be empty: " + accountType); 83 } 84 this.authority = authority; 85 this.accountType = accountType; 86 this.userVisible = true; 87 this.supportsUploading = true; 88 this.isAlwaysSyncable = false; 89 this.allowParallelSyncs = false; 90 this.settingsActivity = null; 91 this.isKey = true; 92 } 93 94 public boolean supportsUploading() { 95 if (isKey) { 96 throw new IllegalStateException( 97 "this method is not allowed to be called when this is a key"); 98 } 99 return supportsUploading; 100 } 101 102 public boolean isUserVisible() { 103 if (isKey) { 104 throw new IllegalStateException( 105 "this method is not allowed to be called when this is a key"); 106 } 107 return userVisible; 108 } 109 110 /** 111 * @return True if this SyncAdapter supports syncing multiple accounts simultaneously. 112 * If false then the SyncManager will take care to only start one sync at a time 113 * using this SyncAdapter. 114 */ 115 public boolean allowParallelSyncs() { 116 if (isKey) { 117 throw new IllegalStateException( 118 "this method is not allowed to be called when this is a key"); 119 } 120 return allowParallelSyncs; 121 } 122 123 /** 124 * If true then the SyncManager will never issue an initialization sync to the SyncAdapter 125 * and will instead automatically call 126 * {@link ContentResolver#setIsSyncable(android.accounts.Account, String, int)} with a 127 * value of 1 for each account and provider that this sync adapter supports. 128 * @return true if the SyncAdapter does not require initialization and if it is ok for the 129 * SyncAdapter to treat it as syncable automatically. 130 */ 131 public boolean isAlwaysSyncable() { 132 if (isKey) { 133 throw new IllegalStateException( 134 "this method is not allowed to be called when this is a key"); 135 } 136 return isAlwaysSyncable; 137 } 138 139 /** 140 * @return The activity to use to invoke this SyncAdapter's settings activity. 141 * May be null. 142 */ 143 public String getSettingsActivity() { 144 if (isKey) { 145 throw new IllegalStateException( 146 "this method is not allowed to be called when this is a key"); 147 } 148 return settingsActivity; 149 } 150 151 public static SyncAdapterType newKey(String authority, String accountType) { 152 return new SyncAdapterType(authority, accountType); 153 } 154 155 public boolean equals(Object o) { 156 if (o == this) return true; 157 if (!(o instanceof SyncAdapterType)) return false; 158 final SyncAdapterType other = (SyncAdapterType)o; 159 // don't include userVisible or supportsUploading in the equality check 160 return authority.equals(other.authority) && accountType.equals(other.accountType); 161 } 162 163 public int hashCode() { 164 int result = 17; 165 result = 31 * result + authority.hashCode(); 166 result = 31 * result + accountType.hashCode(); 167 // don't include userVisible or supportsUploading the hash 168 return result; 169 } 170 171 public String toString() { 172 if (isKey) { 173 return "SyncAdapterType Key {name=" + authority 174 + ", type=" + accountType 175 + "}"; 176 } else { 177 return "SyncAdapterType {name=" + authority 178 + ", type=" + accountType 179 + ", userVisible=" + userVisible 180 + ", supportsUploading=" + supportsUploading 181 + ", isAlwaysSyncable=" + isAlwaysSyncable 182 + ", allowParallelSyncs=" + allowParallelSyncs 183 + ", settingsActivity=" + settingsActivity 184 + "}"; 185 } 186 } 187 188 public int describeContents() { 189 return 0; 190 } 191 192 public void writeToParcel(Parcel dest, int flags) { 193 if (isKey) { 194 throw new IllegalStateException("keys aren't parcelable"); 195 } 196 197 dest.writeString(authority); 198 dest.writeString(accountType); 199 dest.writeInt(userVisible ? 1 : 0); 200 dest.writeInt(supportsUploading ? 1 : 0); 201 dest.writeInt(isAlwaysSyncable ? 1 : 0); 202 dest.writeInt(allowParallelSyncs ? 1 : 0); 203 dest.writeString(settingsActivity); 204 } 205 206 public SyncAdapterType(Parcel source) { 207 this( 208 source.readString(), 209 source.readString(), 210 source.readInt() != 0, 211 source.readInt() != 0, 212 source.readInt() != 0, 213 source.readInt() != 0, 214 source.readString()); 215 } 216 217 public static final Creator<SyncAdapterType> CREATOR = new Creator<SyncAdapterType>() { 218 public SyncAdapterType createFromParcel(Parcel source) { 219 return new SyncAdapterType(source); 220 } 221 222 public SyncAdapterType[] newArray(int size) { 223 return new SyncAdapterType[size]; 224 } 225 }; 226 } 227
