Links
Android Sites
Language
Results
Loading...
1
/*
2
* Copyright (C) 2012 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.example.android.displayingbitmaps.util;
18
19
import android.annotation.TargetApi;
20
import android.content.Context;
21
import android.graphics.Bitmap;
22
import android.graphics.Bitmap.CompressFormat;
23
import android.graphics.Bitmap.Config;
24
import android.graphics.BitmapFactory;
25
import android.graphics.drawable.BitmapDrawable;
26
import android.os.Build.VERSION_CODES;
27
import android.os.Bundle;
28
import android.os.Environment;
29
import android.os.StatFs;
30
import android.support.v4.app.Fragment;
31
import android.support.v4.app.FragmentManager;
32
import android.support.v4.util.LruCache;
33
34
import com.example.android.common.logger.Log;
35
import com.example.android.displayingbitmaps.BuildConfig;
36
37
import java.io.File;
38
import java.io.FileDescriptor;
39
import java.io.FileInputStream;
40
import java.io.IOException;
41
import java.io.InputStream;
42
import java.io.OutputStream;
43
import java.lang.ref.SoftReference;
44
import java.security.MessageDigest;
45
import java.security.NoSuchAlgorithmException;
46
import java.util.Collections;
47
import java.util.HashSet;
48
import java.util.Iterator;
49
import java.util.Set;
50
51
/**
52
* This class handles disk and memory caching of bitmaps in conjunction with the
53
* {@link ImageWorker} class and its subclasses. Use
54
* {@link ImageCache#getInstance(android.support.v4.app.FragmentManager, ImageCacheParams)} to get an instance of this
55
* class, although usually a cache should be added directly to an {@link ImageWorker} by calling
56
* {@link ImageWorker#addImageCache(android.support.v4.app.FragmentManager, ImageCacheParams)}.
57
*/
58
public class ImageCache {
59
private static final String TAG = "ImageCache";
60
61
// Default memory cache size in kilobytes
62
private static final int DEFAULT_MEM_CACHE_SIZE = 1024 * 5; // 5MB
63
64
// Default disk cache size in bytes
65
private static final int DEFAULT_DISK_CACHE_SIZE = 1024 * 1024 * 10; // 10MB
66
67
// Compression settings when writing images to disk cache
68
private static final CompressFormat DEFAULT_COMPRESS_FORMAT = CompressFormat.JPEG;
69
private static final int DEFAULT_COMPRESS_QUALITY = 70;
70
private static final int DISK_CACHE_INDEX = 0;
71
72
// Constants to easily toggle various caches
73
private static final boolean DEFAULT_MEM_CACHE_ENABLED = true;
74
private static final boolean DEFAULT_DISK_CACHE_ENABLED = true;
75
private static final boolean DEFAULT_INIT_DISK_CACHE_ON_CREATE = false;
76
77
private DiskLruCache mDiskLruCache;
78
private LruCache<String, BitmapDrawable> mMemoryCache;
79
private ImageCacheParams mCacheParams;
80
private final Object mDiskCacheLock = new Object();
81
private boolean mDiskCacheStarting = true;
82
83
private Set<SoftReference<Bitmap>> mReusableBitmaps;
84
85
/**
86
* Create a new ImageCache object using the specified parameters. This should not be
87
* called directly by other classes, instead use
88
* {@link ImageCache#getInstance(android.support.v4.app.FragmentManager, ImageCacheParams)} to fetch an ImageCache
89
* instance.
90
*
91
* @param cacheParams The cache parameters to use to initialize the cache
92
*/
93
private ImageCache(ImageCacheParams cacheParams) {
94
init(cacheParams);
95
}
96
97
/**
98
* Return an {@link ImageCache} instance. A {@link RetainFragment} is used to retain the
99
* ImageCache object across configuration changes such as a change in device orientation.
100
*
101
* @param fragmentManager The fragment manager to use when dealing with the retained fragment.
102
* @param cacheParams The cache parameters to use if the ImageCache needs instantiation.
103
* @return An existing retained ImageCache object or a new one if one did not exist
104
*/
105
public static ImageCache getInstance(
106
FragmentManager fragmentManager, ImageCacheParams cacheParams) {
107
108
// Search for, or create an instance of the non-UI RetainFragment
109
final RetainFragment mRetainFragment = findOrCreateRetainFragment(fragmentManager);
110
111
// See if we already have an ImageCache stored in RetainFragment
112
ImageCache imageCache = (ImageCache) mRetainFragment.getObject();
113
114
// No existing ImageCache, create one and store it in RetainFragment
115
if (imageCache == null) {
116
imageCache = new ImageCache(cacheParams);
117
mRetainFragment.setObject(imageCache);
118
}
119
120
return imageCache;
121
}
122
123
/**
124
* Initialize the cache, providing all parameters.
125
*
126
* @param cacheParams The cache parameters to initialize the cache
127
*/
128
private void init(ImageCacheParams cacheParams) {
129
mCacheParams = cacheParams;
130
132
// Set up memory cache
133
if (mCacheParams.memoryCacheEnabled) {
134
if (BuildConfig.DEBUG) {
135
Log.d(TAG, "Memory cache created (size = " + mCacheParams.memCacheSize + ")");
136
}
137
138
// If we're running on Honeycomb or newer, create a set of reusable bitmaps that can be
139
// populated into the inBitmap field of BitmapFactory.Options. Note that the set is
140
// of SoftReferences which will actually not be very effective due to the garbage
141
// collector being aggressive clearing Soft/WeakReferences. A better approach
142
// would be to use a strongly references bitmaps, however this would require some
143
// balancing of memory usage between this set and the bitmap LruCache. It would also
144
// require knowledge of the expected size of the bitmaps. From Honeycomb to JellyBean
145
// the size would need to be precise, from KitKat onward the size would just need to
146
// be the upper bound (due to changes in how inBitmap can re-use bitmaps).
147
if (Utils.hasHoneycomb()) {
148
mReusableBitmaps =
149
Collections.synchronizedSet(new HashSet<SoftReference<Bitmap>>());
150
}
151
152
mMemoryCache = new LruCache<String, BitmapDrawable>(mCacheParams.memCacheSize) {
153
154
/**
155
* Notify the removed entry that is no longer being cached
156
*/
157
@Override
158
protected void entryRemoved(boolean evicted, String key,
159
BitmapDrawable oldValue, BitmapDrawable newValue) {
160
if (RecyclingBitmapDrawable.class.isInstance(oldValue)) {
161
// The removed entry is a recycling drawable, so notify it
162
// that it has been removed from the memory cache
163
((RecyclingBitmapDrawable) oldValue).setIsCached(false);
164
} else {
165
// The removed entry is a standard BitmapDrawable
166
167
if (Utils.hasHoneycomb()) {
168
// We're running on Honeycomb or later, so add the bitmap
169
// to a SoftReference set for possible use with inBitmap later
170
mReusableBitmaps.add(new SoftReference<Bitmap>(oldValue.getBitmap()));
171
}
172
}
173
}
174
175
/**
176
* Measure item size in kilobytes rather than units which is more practical
177
* for a bitmap cache
178
*/
179
@Override
180
protected int sizeOf(String key, BitmapDrawable value) {
181
final int bitmapSize = getBitmapSize(value) / 1024;
182
return bitmapSize == 0 ? 1 : bitmapSize;
183
}
184
};
185
}
187
188
// By default the disk cache is not initialized here as it should be initialized
189
// on a separate thread due to disk access.
190
if (cacheParams.initDiskCacheOnCreate) {
191
// Set up disk cache
192
initDiskCache();
193
}
194
}
195
196
/**
197
* Initializes the disk cache. Note that this includes disk access so this should not be
198
* executed on the main/UI thread. By default an ImageCache does not initialize the disk
199
* cache when it is created, instead you should call initDiskCache() to initialize it on a
200
* background thread.
201
*/
202
public void initDiskCache() {
203
// Set up disk cache
204
synchronized (mDiskCacheLock) {
205
if (mDiskLruCache == null || mDiskLruCache.isClosed()) {
206
File diskCacheDir = mCacheParams.diskCacheDir;
207
if (mCacheParams.diskCacheEnabled && diskCacheDir != null) {
208
if (!diskCacheDir.exists()) {
209
diskCacheDir.mkdirs();
210
}
211
if (getUsableSpace(diskCacheDir) > mCacheParams.diskCacheSize) {
212
try {
213
mDiskLruCache = DiskLruCache.open(
214
diskCacheDir, 1, 1, mCacheParams.diskCacheSize);
215
if (BuildConfig.DEBUG) {
216
Log.d(TAG, "Disk cache initialized");
217
}
218
} catch (final IOException e) {
219
mCacheParams.diskCacheDir = null;
220
Log.e(TAG, "initDiskCache - " + e);
221
}
222
}
223
}
224
}
225
mDiskCacheStarting = false;
226
mDiskCacheLock.notifyAll();
227
}
228
}
229
230
/**
231
* Adds a bitmap to both memory and disk cache.
232
* @param data Unique identifier for the bitmap to store
233
* @param value The bitmap drawable to store
234
*/
235
public void addBitmapToCache(String data, BitmapDrawable value) {
237
if (data == null || value == null) {
238
return;
239
}
240
241
// Add to memory cache
242
if (mMemoryCache != null) {
243
if (RecyclingBitmapDrawable.class.isInstance(value)) {
244
// The removed entry is a recycling drawable, so notify it
245
// that it has been added into the memory cache
246
((RecyclingBitmapDrawable) value).setIsCached(true);
247
}
248
mMemoryCache.put(data, value);
249
}
250
251
synchronized (mDiskCacheLock) {
252
// Add to disk cache
253
if (mDiskLruCache != null) {
254
final String key = hashKeyForDisk(data);
255
OutputStream out = null;
256
try {
257
DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);
258
if (snapshot == null) {
259
final DiskLruCache.Editor editor = mDiskLruCache.edit(key);
260
if (editor != null) {
261
out = editor.newOutputStream(DISK_CACHE_INDEX);
262
value.getBitmap().compress(
263
mCacheParams.compressFormat, mCacheParams.compressQuality, out);
264
editor.commit();
265
out.close();
266
}
267
} else {
268
snapshot.getInputStream(DISK_CACHE_INDEX).close();
269
}
270
} catch (final IOException e) {
271
Log.e(TAG, "addBitmapToCache - " + e);
272
} catch (Exception e) {
273
Log.e(TAG, "addBitmapToCache - " + e);
274
} finally {
275
try {
276
if (out != null) {
277
out.close();
278
}
279
} catch (IOException e) {}
280
}
281
}
282
}
284
}
285
286
/**
287
* Get from memory cache.
288
*
289
* @param data Unique identifier for which item to get
290
* @return The bitmap drawable if found in cache, null otherwise
291
*/
292
public BitmapDrawable getBitmapFromMemCache(String data) {
294
BitmapDrawable memValue = null;
295
296
if (mMemoryCache != null) {
297
memValue = mMemoryCache.get(data);
298
}
299
300
if (BuildConfig.DEBUG && memValue != null) {
301
Log.d(TAG, "Memory cache hit");
302
}
303
304
return memValue;
306
}
307
308
/**
309
* Get from disk cache.
310
*
311
* @param data Unique identifier for which item to get
312
* @return The bitmap if found in cache, null otherwise
313
*/
314
public Bitmap getBitmapFromDiskCache(String data) {
316
final String key = hashKeyForDisk(data);
317
Bitmap bitmap = null;
318
319
synchronized (mDiskCacheLock) {
320
while (mDiskCacheStarting) {
321
try {
322
mDiskCacheLock.wait();
323
} catch (InterruptedException e) {}
324
}
325
if (mDiskLruCache != null) {
326
InputStream inputStream = null;
327
try {
328
final DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);
329
if (snapshot != null) {
330
if (BuildConfig.DEBUG) {
331
Log.d(TAG, "Disk cache hit");
332
}
333
inputStream = snapshot.getInputStream(DISK_CACHE_INDEX);
334
if (inputStream != null) {
335
FileDescriptor fd = ((FileInputStream) inputStream).getFD();
336
337
// Decode bitmap, but we don't want to sample so give
338
// MAX_VALUE as the target dimensions
339
bitmap = ImageResizer.decodeSampledBitmapFromDescriptor(
340
fd, Integer.MAX_VALUE, Integer.MAX_VALUE, this);
341
}
342
}
343
} catch (final IOException e) {
344
Log.e(TAG, "getBitmapFromDiskCache - " + e);
345
} finally {
346
try {
347
if (inputStream != null) {
348
inputStream.close();
349
}
350
} catch (IOException e) {}
351
}
352
}
353
return bitmap;
354
}
356
}
357
358
/**
359
* @param options - BitmapFactory.Options with out* options populated
360
* @return Bitmap that case be used for inBitmap
361
*/
362
protected Bitmap getBitmapFromReusableSet(BitmapFactory.Options options) {
364
Bitmap bitmap = null;
365
366
if (mReusableBitmaps != null && !mReusableBitmaps.isEmpty()) {
367
synchronized (mReusableBitmaps) {
368
final Iterator<SoftReference<Bitmap>> iterator = mReusableBitmaps.iterator();
369
Bitmap item;
370
371
while (iterator.hasNext()) {
372
item = iterator.next().get();
373
374
if (null != item && item.isMutable()) {
375
// Check to see it the item can be used for inBitmap
376
if (canUseForInBitmap(item, options)) {
377
bitmap = item;
378
379
// Remove from reusable set so it can't be used again
380
iterator.remove();
381
break;
382
}
383
} else {
384
// Remove from the set if the reference has been cleared.
385
iterator.remove();
386
}
387
}
388
}
389
}
390
391
return bitmap;
393
}
394
395
/**
396
* Clears both the memory and disk cache associated with this ImageCache object. Note that
397
* this includes disk access so this should not be executed on the main/UI thread.
398
*/
399
public void clearCache() {
400
if (mMemoryCache != null) {
401
mMemoryCache.evictAll();
402
if (BuildConfig.DEBUG) {
403
Log.d(TAG, "Memory cache cleared");
404
}
405
}
406
407
synchronized (mDiskCacheLock) {
408
mDiskCacheStarting = true;
409
if (mDiskLruCache != null && !mDiskLruCache.isClosed()) {
410
try {
411
mDiskLruCache.delete();
412
if (BuildConfig.DEBUG) {
413
Log.d(TAG, "Disk cache cleared");
414
}
415
} catch (IOException e) {
416
Log.e(TAG, "clearCache - " + e);
417
}
418
mDiskLruCache = null;
419
initDiskCache();
420
}
421
}
422
}
423
424
/**
425
* Flushes the disk cache associated with this ImageCache object. Note that this includes
426
* disk access so this should not be executed on the main/UI thread.
427
*/
428
public void flush() {
429
synchronized (mDiskCacheLock) {
430
if (mDiskLruCache != null) {
431
try {
432
mDiskLruCache.flush();
433
if (BuildConfig.DEBUG) {
434
Log.d(TAG, "Disk cache flushed");
435
}
436
} catch (IOException e) {
437
Log.e(TAG, "flush - " + e);
438
}
439
}
440
}
441
}
442
443
/**
444
* Closes the disk cache associated with this ImageCache object. Note that this includes
445
* disk access so this should not be executed on the main/UI thread.
446
*/
447
public void close() {
448
synchronized (mDiskCacheLock) {
449
if (mDiskLruCache != null) {
450
try {
451
if (!mDiskLruCache.isClosed()) {
452
mDiskLruCache.close();
453
mDiskLruCache = null;
454
if (BuildConfig.DEBUG) {
455
Log.d(TAG, "Disk cache closed");
456
}
457
}
458
} catch (IOException e) {
459
Log.e(TAG, "close - " + e);
460
}
461
}
462
}
463
}
464
465
/**
466
* A holder class that contains cache parameters.
467
*/
468
public static class ImageCacheParams {
469
public int memCacheSize = DEFAULT_MEM_CACHE_SIZE;
470
public int diskCacheSize = DEFAULT_DISK_CACHE_SIZE;
471
public File diskCacheDir;
472
public CompressFormat compressFormat = DEFAULT_COMPRESS_FORMAT;
473
public int compressQuality = DEFAULT_COMPRESS_QUALITY;
474
public boolean memoryCacheEnabled = DEFAULT_MEM_CACHE_ENABLED;
475
public boolean diskCacheEnabled = DEFAULT_DISK_CACHE_ENABLED;
476
public boolean initDiskCacheOnCreate = DEFAULT_INIT_DISK_CACHE_ON_CREATE;
477
478
/**
479
* Create a set of image cache parameters that can be provided to
480
* {@link ImageCache#getInstance(android.support.v4.app.FragmentManager, ImageCacheParams)} or
481
* {@link ImageWorker#addImageCache(android.support.v4.app.FragmentManager, ImageCacheParams)}.
482
* @param context A context to use.
483
* @param diskCacheDirectoryName A unique subdirectory name that will be appended to the
484
* application cache directory. Usually "cache" or "images"
485
* is sufficient.
486
*/
487
public ImageCacheParams(Context context, String diskCacheDirectoryName) {
488
diskCacheDir = getDiskCacheDir(context, diskCacheDirectoryName);
489
}
490
491
/**
492
* Sets the memory cache size based on a percentage of the max available VM memory.
493
* Eg. setting percent to 0.2 would set the memory cache to one fifth of the available
494
* memory. Throws {@link IllegalArgumentException} if percent is < 0.01 or > .8.
495
* memCacheSize is stored in kilobytes instead of bytes as this will eventually be passed
496
* to construct a LruCache which takes an int in its constructor.
497
*
498
* This value should be chosen carefully based on a number of factors
499
* Refer to the corresponding Android Training class for more discussion:
500
* http://developer.android.com/training/displaying-bitmaps/
501
*
502
* @param percent Percent of available app memory to use to size memory cache
503
*/
504
public void setMemCacheSizePercent(float percent) {
505
if (percent < 0.01f || percent > 0.8f) {
506
throw new IllegalArgumentException("setMemCacheSizePercent - percent must be "
507
+ "between 0.01 and 0.8 (inclusive)");
508
}
509
memCacheSize = Math.round(percent * Runtime.getRuntime().maxMemory() / 1024);
510
}
511
}
512
513
/**
514
* @param candidate - Bitmap to check
515
* @param targetOptions - Options that have the out* value populated
516
* @return true if <code>candidate</code> can be used for inBitmap re-use with
517
* <code>targetOptions</code>
518
*/
519
@TargetApi(VERSION_CODES.KITKAT)
520
private static boolean canUseForInBitmap(
521
Bitmap candidate, BitmapFactory.Options targetOptions) {
523
if (!Utils.hasKitKat()) {
524
// On earlier versions, the dimensions must match exactly and the inSampleSize must be 1
525
return candidate.getWidth() == targetOptions.outWidth
526
&& candidate.getHeight() == targetOptions.outHeight
527
&& targetOptions.inSampleSize == 1;
528
}
529
530
// From Android 4.4 (KitKat) onward we can re-use if the byte size of the new bitmap
531
// is smaller than the reusable bitmap candidate allocation byte count.
532
int width = targetOptions.outWidth / targetOptions.inSampleSize;
533
int height = targetOptions.outHeight / targetOptions.inSampleSize;
534
int byteCount = width * height * getBytesPerPixel(candidate.getConfig());
535
return byteCount <= candidate.getAllocationByteCount();
537
}
538
539
/**
540
* Return the byte usage per pixel of a bitmap based on its configuration.
541
* @param config The bitmap configuration.
542
* @return The byte usage per pixel.
543
*/
544
private static int getBytesPerPixel(Config config) {
545
if (config == Config.ARGB_8888) {
546
return 4;
547
} else if (config == Config.RGB_565) {
548
return 2;
549
} else if (config == Config.ARGB_4444) {
550
return 2;
551
} else if (config == Config.ALPHA_8) {
552
return 1;
553
}
554
return 1;
555
}
556
557
/**
558
* Get a usable cache directory (external if available, internal otherwise).
559
*
560
* @param context The context to use
561
* @param uniqueName A unique directory name to append to the cache dir
562
* @return The cache dir
563
*/
564
public static File getDiskCacheDir(Context context, String uniqueName) {
565
// Check if media is mounted or storage is built-in, if so, try and use external cache dir
566
// otherwise use internal cache dir
567
final String cachePath =
568
Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()) ||
569
!isExternalStorageRemovable() ? getExternalCacheDir(context).getPath() :
570
context.getCacheDir().getPath();
571
572
return new File(cachePath + File.separator + uniqueName);
573
}
574
575
/**
576
* A hashing method that changes a string (like a URL) into a hash suitable for using as a
577
* disk filename.
578
*/
579
public static String hashKeyForDisk(String key) {
580
String cacheKey;
581
try {
582
final MessageDigest mDigest = MessageDigest.getInstance("MD5");
583
mDigest.update(key.getBytes());
584
cacheKey = bytesToHexString(mDigest.digest());
585
} catch (NoSuchAlgorithmException e) {
586
cacheKey = String.valueOf(key.hashCode());
587
}
588
return cacheKey;
589
}
590
591
private static String bytesToHexString(byte[] bytes) {
592
// http://stackoverflow.com/questions/332079
593
StringBuilder sb = new StringBuilder();
594
for (int i = 0; i < bytes.length; i++) {
595
String hex = Integer.toHexString(0xFF & bytes[i]);
596
if (hex.length() == 1) {
597
sb.append('0');
598
}
599
sb.append(hex);
600
}
601
return sb.toString();
602
}
603
604
/**
605
* Get the size in bytes of a bitmap in a BitmapDrawable. Note that from Android 4.4 (KitKat)
606
* onward this returns the allocated memory size of the bitmap which can be larger than the
607
* actual bitmap data byte count (in the case it was re-used).
608
*
609
* @param value
610
* @return size in bytes
611
*/
612
@TargetApi(VERSION_CODES.KITKAT)
613
public static int getBitmapSize(BitmapDrawable value) {
614
Bitmap bitmap = value.getBitmap();
615
616
// From KitKat onward use getAllocationByteCount() as allocated bytes can potentially be
617
// larger than bitmap byte count.
618
if (Utils.hasKitKat()) {
619
return bitmap.getAllocationByteCount();
620
}
621
622
if (Utils.hasHoneycombMR1()) {
623
return bitmap.getByteCount();
624
}
625
626
// Pre HC-MR1
627
return bitmap.getRowBytes() * bitmap.getHeight();
628
}
629
630
/**
631
* Check if external storage is built-in or removable.
632
*
633
* @return True if external storage is removable (like an SD card), false
634
* otherwise.
635
*/
636
@TargetApi(VERSION_CODES.GINGERBREAD)
637
public static boolean isExternalStorageRemovable() {
638
if (Utils.hasGingerbread()) {
639
return Environment.isExternalStorageRemovable();
640
}
641
return true;
642
}
643
644
/**
645
* Get the external app cache directory.
646
*
647
* @param context The context to use
648
* @return The external cache dir
649
*/
650
@TargetApi(VERSION_CODES.FROYO)
651
public static File getExternalCacheDir(Context context) {
652
if (Utils.hasFroyo()) {
653
return context.getExternalCacheDir();
654
}
655
656
// Before Froyo we need to construct the external cache dir ourselves
657
final String cacheDir = "/Android/data/" + context.getPackageName() + "/cache/";
658
return new File(Environment.getExternalStorageDirectory().getPath() + cacheDir);
659
}
660
661
/**
662
* Check how much usable space is available at a given path.
663
*
664
* @param path The path to check
665
* @return The space available in bytes
666
*/
667
@TargetApi(VERSION_CODES.GINGERBREAD)
668
public static long getUsableSpace(File path) {
669
if (Utils.hasGingerbread()) {
670
return path.getUsableSpace();
671
}
672
final StatFs stats = new StatFs(path.getPath());
673
return (long) stats.getBlockSize() * (long) stats.getAvailableBlocks();
674
}
675
676
/**
677
* Locate an existing instance of this Fragment or if not found, create and
678
* add it using FragmentManager.
679
*
680
* @param fm The FragmentManager manager to use.
681
* @return The existing instance of the Fragment or the new instance if just
682
* created.
683
*/
684
private static RetainFragment findOrCreateRetainFragment(FragmentManager fm) {
686
// Check to see if we have retained the worker fragment.
687
RetainFragment mRetainFragment = (RetainFragment) fm.findFragmentByTag(TAG);
688
689
// If not retained (or first time running), we need to create and add it.
690
if (mRetainFragment == null) {
691
mRetainFragment = new RetainFragment();
692
fm.beginTransaction().add(mRetainFragment, TAG).commitAllowingStateLoss();
693
}
694
695
return mRetainFragment;
697
}
698
699
/**
700
* A simple non-UI Fragment that stores a single Object and is retained over configuration
701
* changes. It will be used to retain the ImageCache object.
702
*/
703
public static class RetainFragment extends Fragment {
704
private Object mObject;
705
706
/**
707
* Empty constructor as per the Fragment documentation
708
*/
709
public RetainFragment() {}
710
711
@Override
712
public void onCreate(Bundle savedInstanceState) {
713
super.onCreate(savedInstanceState);
714
715
// Make sure this Fragment is retained over a configuration change
716
setRetainInstance(true);
717
}
718
719
/**
720
* Store a single object in this Fragment.
721
*
722
* @param object The object to store
723
*/
724
public void setObject(Object object) {
725
mObject = object;
726
}
727
728
/**
729
* Get the stored object.
730
*
731
* @return The stored object
732
*/
733
public Object getObject() {
734
return mObject;
735
}
736
}
737
738
}