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 SyncAdapterType(String authority, String accountType, boolean userVisible, boolean supportsUploading)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 */ SyncAdapterType(String authority, String accountType, boolean userVisible, boolean supportsUploading, boolean isAlwaysSyncable, boolean allowParallelSyncs, String settingsActivity)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 SyncAdapterType(String authority, String accountType)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 supportsUploading()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 isUserVisible()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 */ allowParallelSyncs()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 */ isAlwaysSyncable()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 */ getSettingsActivity()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 newKey(String authority, String accountType)151 public static SyncAdapterType newKey(String authority, String accountType) { 152 return new SyncAdapterType(authority, accountType); 153 } 154 equals(Object o)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 hashCode()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 toString()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 describeContents()188 public int describeContents() { 189 return 0; 190 } 191 writeToParcel(Parcel dest, int flags)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 SyncAdapterType(Parcel source)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