1package com.xtremelabs.robolectric.shadows; 2 3import static com.xtremelabs.robolectric.Robolectric.shadowOf_; 4 5import java.io.Serializable; 6import java.util.ArrayList; 7import java.util.HashMap; 8import java.util.Map; 9import java.util.Set; 10 11import android.os.Build; 12import android.os.Bundle; 13import android.os.Parcelable; 14 15import com.xtremelabs.robolectric.Robolectric; 16import com.xtremelabs.robolectric.internal.Implementation; 17import com.xtremelabs.robolectric.internal.Implements; 18 19@SuppressWarnings({ "UnusedDeclaration" }) 20@Implements(Bundle.class) 21public class ShadowBundle { 22 Map<String, Object> map = new HashMap<String, Object>(); 23 24 public void __constructor__(Bundle b) { 25 putAll(b); 26 } 27 28 @Implementation 29 public void clear() { 30 map.clear(); 31 } 32 33 @Implementation 34 public void remove(String key) { 35 map.remove(key); 36 } 37 38 @Implementation 39 public Object get(String key) { 40 return map.get(key); 41 } 42 43 @Implementation 44 public void putString(String key, String value) { 45 map.put(key, value); 46 } 47 48 @Implementation 49 public String getString(String key) { 50 Object value = map.get(key); 51 return value == null || !(value instanceof String) ? null : (String) value; 52 } 53 54 @Implementation 55 public String getString(String key, String defaultValue) { 56 if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR1) { 57 throw new RuntimeException(new NoSuchMethodException("Requires API_12")); 58 } 59 Object value = map.get(key); 60 return value == null || !(value instanceof String) ? defaultValue : (String) value; 61 } 62 63 @Implementation 64 public void putLong(String key, long value) { 65 map.put(key, value); 66 } 67 68 @Implementation 69 public long getLong(String key) { 70 return getLong(key, 0); 71 } 72 73 @Implementation 74 public long getLong(String key, long defaultValue) { 75 Object value = map.get(key); 76 return value == null || !(value instanceof Long) ? defaultValue : (Long) value; 77 } 78 79 @Implementation 80 public void putInt(String key, int value) { 81 map.put(key, value); 82 } 83 84 @Implementation 85 public int getInt(String key) { 86 return getInt(key, 0); 87 } 88 89 @Implementation 90 public int getInt(String key, int defaultValue) { 91 Object value = map.get(key); 92 return value == null || !(value instanceof Integer) ? defaultValue : (Integer) value; 93 } 94 95 @Implementation 96 public void putDouble(String key, double value) { 97 map.put(key, value); 98 } 99 100 @Implementation 101 public double getDouble(String key) { 102 return getDouble(key, 0); 103 } 104 105 @Implementation 106 public double getDouble(String key, double defaultValue) { 107 Object value = map.get(key); 108 return value == null || !(value instanceof Double) ? defaultValue : (Double) value; 109 } 110 111 @Implementation 112 public void putBoolean(String key, boolean value) { 113 map.put(key, value); 114 } 115 116 @Implementation 117 public boolean getBoolean(String key) { 118 return getBoolean(key, false); 119 } 120 121 @Implementation 122 public boolean getBoolean(String key, boolean defaultValue) { 123 Object value = map.get(key); 124 return value == null || !(value instanceof Boolean) ? defaultValue : (Boolean) value; 125 } 126 127 @Implementation 128 public void putChar(String key, char value) { 129 map.put(key, value); 130 } 131 132 @Implementation 133 public char getChar(String key) { 134 return getChar(key, (char) 0); 135 } 136 137 @Implementation 138 public char getChar(String key, char defaultValue) { 139 Object value = map.get(key); 140 return value == null || !(value instanceof Character) ? defaultValue : (Character) value; 141 } 142 143 @Implementation 144 public void putCharSequence(String key, CharSequence value) { 145 map.put(key, value); 146 } 147 148 @Implementation 149 public CharSequence getCharSequence(String key) { 150 Object value = map.get(key); 151 return value == null || !(value instanceof CharSequence) ? null : (CharSequence) value; 152 } 153 154 @Implementation 155 public void putFloat(String key, float value) { 156 map.put(key, value); 157 } 158 159 @Implementation 160 public float getFloat(String key) { 161 return getFloat(key, 0); 162 } 163 164 @Implementation 165 public float getFloat(String key, float defaultValue) { 166 Object value = map.get(key); 167 return value == null || !(value instanceof Float) ? defaultValue : (Float) value; 168 } 169 170 @Implementation 171 public void putSerializable(String key, Serializable value) { 172 map.put(key, value); 173 } 174 175 @Implementation 176 public Serializable getSerializable(String key) { 177 Object value = map.get(key); 178 return value == null || !(value instanceof Serializable) ? null : (Serializable) value; 179 } 180 181 @Implementation 182 public void putParcelable(String key, Parcelable value) { 183 map.put(key, value); 184 } 185 186 @Implementation 187 public void putParcelableArrayList(String key, ArrayList<? extends Parcelable> value) { 188 map.put(key, value); 189 } 190 191 @Implementation 192 public Parcelable getParcelable(String key) { 193 Object value = map.get(key); 194 return value == null || !(value instanceof Parcelable) ? null : (Parcelable) value; 195 } 196 197 @Implementation 198 public ArrayList<Parcelable> getParcelableArrayList(String key) { 199 Object value = map.get(key); 200 return value == null || !(value instanceof ArrayList) ? null 201 : (ArrayList<Parcelable>) value; 202 } 203 204 @Implementation 205 public Parcelable[] getParcelableArray(String key) { 206 Object value = map.get(key); 207 return value == null || !(value instanceof Parcelable[]) ? null : (Parcelable[]) value; 208 } 209 210 @Implementation 211 public void putParcelableArray(String key, Parcelable[] value) { 212 map.put(key, value); 213 } 214 215 @Implementation 216 public void putStringArrayList(String key, ArrayList<String> value) { 217 map.put(key, value); 218 } 219 220 @Implementation 221 public ArrayList<String> getStringArrayList(String key) { 222 Object value = map.get(key); 223 return value == null || !(value instanceof ArrayList) ? null : (ArrayList<String>) value; 224 } 225 226 @Implementation 227 public void putCharSequenceArrayList(String key, ArrayList<CharSequence> value) { 228 map.put(key, value); 229 } 230 231 @Implementation 232 public ArrayList<CharSequence> getCharSequenceArrayList(String key) { 233 Object value = map.get(key); 234 return value == null || !(value instanceof ArrayList) ? null 235 : (ArrayList<CharSequence>) value; 236 } 237 238 @Implementation 239 public void putIntegerArrayList(String key, ArrayList<Integer> value) { 240 map.put(key, value); 241 } 242 243 @Implementation 244 public ArrayList<Integer> getIntegerArrayList(String key) { 245 Object value = map.get(key); 246 return value == null || !(value instanceof ArrayList) ? null : (ArrayList<Integer>) value; 247 } 248 249 @Implementation 250 public void putBundle(String key, Bundle value) { 251 map.put(key, value); 252 } 253 254 @Implementation 255 public Bundle getBundle(String key) { 256 Object value = map.get(key); 257 return value == null || !(value instanceof Bundle) ? null : (Bundle) value; 258 } 259 260 @Implementation 261 public void putBooleanArray(String key, boolean[] value) { 262 map.put(key, value); 263 } 264 265 @Implementation 266 public boolean[] getBooleanArray(String key) { 267 Object value = map.get(key); 268 return value == null || !(value instanceof boolean[]) ? null : (boolean[]) value; 269 } 270 271 @Implementation 272 public void putByteArray(String key, byte[] value) { 273 map.put(key, value); 274 } 275 276 @Implementation 277 public byte[] getByteArray(String key) { 278 Object value = map.get(key); 279 return value == null || !(value instanceof byte[]) ? null : (byte[]) value; 280 } 281 282 @Implementation 283 public void putCharArray(String key, char[] value) { 284 map.put(key, value); 285 } 286 287 @Implementation 288 public char[] getCharArray(String key) { 289 Object value = map.get(key); 290 return value == null || !(value instanceof char[]) ? null : (char[]) value; 291 } 292 293 @Implementation 294 public void putDoubleArray(String key, double[] value) { 295 map.put(key, value); 296 } 297 298 @Implementation 299 public double[] getDoubleArray(String key) { 300 Object value = map.get(key); 301 return value == null || !(value instanceof double[]) ? null : (double[]) value; 302 } 303 304 @Implementation 305 public void putFloatArray(String key, float[] value) { 306 map.put(key, value); 307 } 308 309 @Implementation 310 public float[] getFloatArray(String key) { 311 Object value = map.get(key); 312 return value == null || !(value instanceof float[]) ? null : (float[]) value; 313 } 314 315 @Implementation 316 public void putIntArray(String key, int[] value) { 317 map.put(key, value); 318 } 319 320 @Implementation 321 public int[] getIntArray(String key) { 322 Object value = map.get(key); 323 return value == null || !(value instanceof int[]) ? null : (int[]) value; 324 } 325 326 @Implementation 327 public void putLongArray(String key, long[] value) { 328 map.put(key, value); 329 } 330 331 @Implementation 332 public long[] getLongArray(String key) { 333 Object value = map.get(key); 334 return value == null || !(value instanceof long[]) ? null : (long[]) value; 335 } 336 337 @Implementation 338 public void putShortArray(String key, short[] value) { 339 map.put(key, value); 340 } 341 342 @Implementation 343 public short[] getShortArray(String key) { 344 Object value = map.get(key); 345 return value == null || !(value instanceof short[]) ? null : (short[]) value; 346 } 347 348 @Implementation 349 public void putAll(Bundle bundle) { 350 map.putAll(((ShadowBundle) Robolectric.shadowOf_(bundle)).map); 351 } 352 353 @Implementation 354 public void putStringArray(String key, String[] value) { 355 map.put(key, value); 356 } 357 358 @Implementation 359 public String[] getStringArray(String key) { 360 Object value = map.get(key); 361 return value == null || !(value instanceof String[]) ? null : (String[]) value; 362 } 363 364 @Implementation 365 public void putCharSequenceArray(String key, CharSequence[] value) { 366 map.put(key, value); 367 } 368 369 @Implementation 370 public CharSequence[] getCharSequenceArray(String key) { 371 Object value = map.get(key); 372 return value == null || !(value instanceof CharSequence[]) ? null : (CharSequence[]) value; 373 } 374 375 @Implementation 376 public boolean containsKey(String key) { 377 return map.containsKey(key); 378 } 379 380 @Implementation 381 public boolean isEmpty() { 382 return map.isEmpty(); 383 } 384 385 @Implementation 386 public Set<String> keySet() { 387 return map.keySet(); 388 } 389 390 @Implementation 391 public int size() { 392 return map.size(); 393 } 394 395 @Override 396 @Implementation 397 public boolean equals(Object o) { 398 if (o == null) 399 return false; 400 o = shadowOf_(o); 401 if (o == null) 402 return false; 403 if (this == o) 404 return true; 405 if (getClass() != o.getClass()) 406 return false; 407 408 ShadowBundle that = (ShadowBundle) o; 409 410 if (map != null ? !map.equals(that.map) : that.map != null) 411 return false; 412 413 return true; 414 } 415 416 @Override 417 @Implementation 418 public int hashCode() { 419 return map != null ? map.hashCode() : 0; 420 } 421} 422