इस पेज का अनुवाद Cloud Translation API से किया गया है.

बिटमैप को कैश मेमोरी में सेव करना

ध्यान दें: ज़्यादातर मामलों के लिए, हमारा सुझाव है कि कि आप Glide का इस्तेमाल करते हैं लाइब्रेरी का इस्तेमाल किया जा सकता है, ताकि ऐप्लिकेशन में बिटमैप फ़ेच किए जा सकें, डिकोड किए जा सकें, और दिखाए जा सकें. ग्लाइड करके ऐब्सट्रैक्ट ज़्यादातर, इन्हें मैनेज करने में मुश्किल आ रही है और Android पर बिटमैप और अन्य इमेज पर काम करने से जुड़े अन्य टास्क. Glide का इस्तेमाल करने और उसे डाउनलोड करने के बारे में जानकारी के लिए, यहां जाएं GitHub पर Glide डेटा स्टोर करने की जगह.

अपने यूज़र इंटरफ़ेस (यूआई) में एक बिटमैप लोड करना आसान है. हालांकि, अगर आपको एक साथ कई इमेज लोड करनी हैं, तो चीज़ें ज़्यादा मुश्किल हो जाती हैं. कई मामलों में (जैसे, ListView, GridView या ViewPager जैसे कॉम्पोनेंट), स्क्रीन पर मौजूद इमेज की कुल संख्या जितना जल्दी हो सके, स्क्रीन पर अनलिमिटेड स्क्रोल करने की सुविधा मिलती है.

मेमोरी के इस्तेमाल को इस तरह के कॉम्पोनेंट के साथ कम करके रखा जाता है. इसके लिए, व्यू के दौरान बच्चे के व्यू को रीसाइकल किया जाता है करते हैं. यह मानते हुए कि गार्बिज कलेक्टर आपके लोड किए गए बिटमैप को भी खाली कर देता है, यह मानते हुए कि आपको का इस्तेमाल लंबे समय तक रहा. यह पूरी तरह से अच्छा है, लेकिन एक आसान और तेज़ी से लोड होने वाले यूज़र इंटरफ़ेस (यूआई) को बनाए रखने के लिए आप चाहते हैं कि जब भी इमेज दोबारा स्क्रीन पर आएं, तो उन्हें लगातार प्रोसेस न किया जाए. मेमोरी और डिस्क कैश से अक्सर मदद मिल सकती है. इससे, प्रोसेस की गई इमेज को कॉम्पोनेंट तुरंत रीलोड कर सकते हैं.

इस लेसन में आपको रिस्पॉन्सिवनेस को बेहतर बनाने के लिए मेमोरी और डिस्क बिटमैप कैश का इस्तेमाल करने का तरीका बताया गया है और कई बिटमैप लोड करते समय आपके यूज़र इंटरफ़ेस (यूआई) की तरलता.

मेमोरी कैश का इस्तेमाल करें

मेमोरी कैश, बिटमैप को तेज़ी से ऐक्सेस करने की सुविधा देता है. हालांकि, इसके लिए ऐप्लिकेशन की ज़रूरी मेमोरी का इस्तेमाल किया जाता है. LruCache क्लास (वापस इस्तेमाल करने के लिए सहायता लाइब्रेरी में भी उपलब्ध है एपीआई लेवल 4 तक सीमित है) किसी मज़बूत रेफ़र किए गए LinkedHashMap में मौजूद ऑब्जेक्ट और कम से कम कैश मेमोरी के तय साइज़ से ज़्यादा होने से पहले, हाल ही में इस्तेमाल किया गया सदस्य.

ध्यान दें: पहले, मेमोरी कैश को लागू करने का एक लोकप्रिय तरीका हालांकि, SoftReference या WeakReference बिट मैप कैश हम इसका सुझाव नहीं देते. Android 2.3 (एपीआई लेवल 9) और इसके बाद के वर्शन में, गै़रबेज कलेक्टर बेहतर होता है कम/कमज़ोर संदर्भ इकट्ठा करने के साथ ज़्यादा सक्रिय, जो उन्हें पूरी तरह से बेअसर बनाते हैं. इसके अलावा, Android 3.0 (एपीआई लेवल 11) से पहले के वर्शन में, बिटमैप का बैकिंग डेटा, नेटिव मेमोरी में सेव होता था. यह उसे अनुमानित तरीके से जारी नहीं किया जाता, जिससे ऐप्लिकेशन की रिलीज़ के लिए, मेमोरी की सीमाएं और क्रैश.

LruCache के लिए सही साइज़ चुनने के लिए, कई बातों पर ध्यान दिया जाता है पर ध्यान दिया जाना चाहिए, उदाहरण के लिए:

आपकी बाकी गतिविधि और/या ऐप्लिकेशन की मेमोरी कितनी ज़्यादा है?
स्क्रीन पर एक बार में कितनी इमेज दिखेंगी? कितने लोग आने के लिए तैयार रहें ऑन-स्क्रीन?
डिवाइस की स्क्रीन का साइज़ और सघनता क्या है? अतिरिक्त उच्च सघनता स्क्रीन (xhdpi) डिवाइस जैसे कि Galaxy Nexus को बड़ी कैश मेमोरी का इस्तेमाल करें, ताकि Nexus S (hdpi) जैसे डिवाइस की तुलना में, मेमोरी में उतनी ही संख्या में इमेज सेव हों.
बिट मैप कौन-कौनसे डाइमेंशन और कॉन्फ़िगरेशन हैं. इसलिए, हर एक बिट मैप में कितनी मेमोरी लेगा ऊपर?
इमेज कितनी बार ऐक्सेस की जाएंगी? क्या कुछ ऐप्लिकेशन को दूसरों के मुकाबले ज़्यादा तेज़ी से ऐक्सेस किया जा सकता है? अगर ऐसा है, तो हो सकता है कि आप कुछ आइटम को हमेशा मेमोरी में रखना चाहें या बिटमैप के अलग-अलग ग्रुप के लिए एक से ज़्यादा LruCache ऑब्जेक्ट रखना चाहें.
क्या आप वीडियो की संख्या और क्वालिटी के बीच संतुलन बना सकते हैं? कभी-कभी, कम क्वालिटी वाले ज़्यादा बिटमैप स्टोर करना ज़्यादा फ़ायदेमंद हो सकता है. इससे, बैकग्राउंड में चल रहे किसी दूसरे टास्क में अच्छी क्वालिटी वाला वर्शन लोड किया जा सकता है.

सभी ऐप्लिकेशन के लिए कोई तय साइज़ या फ़ॉर्मूला नहीं है. इसलिए, अपने प्रॉडक्ट का विश्लेषण करने के लिए उसका इस्तेमाल करके उसका समाधान ढूंढ सकें. बहुत छोटा कैश होने की वजह से अतिरिक्त ओवरहेड होता है कोई फ़ायदा नहीं. बहुत बड़ी कैश मेमोरी की वजह से एक बार फिर से java.lang.OutOfMemory अपवाद हो सकते हैं और काम करने के लिए अपने ऐप्लिकेशन के शेष हिस्से को छोड़ दें.

बिटमैप के लिए LruCache सेट अप करने का उदाहरण यहां दिया गया है:

Kotlin

private lateinit var memoryCache: LruCache<String, Bitmap>

override fun onCreate(savedInstanceState: Bundle?) {
    ...
    // Get max available VM memory, exceeding this amount will throw an
    // OutOfMemory exception. Stored in kilobytes as LruCache takes an
    // int in its constructor.
    val maxMemory = (Runtime.getRuntime().maxMemory() / 1024).toInt()

    // Use 1/8th of the available memory for this memory cache.
    val cacheSize = maxMemory / 8

    memoryCache = object : LruCache<String, Bitmap>(cacheSize) {

        override fun sizeOf(key: String, bitmap: Bitmap): Int {
            // The cache size will be measured in kilobytes rather than
            // number of items.
            return bitmap.byteCount / 1024
        }
    }
    ...
}

Java

private LruCache<String, Bitmap> memoryCache;

@Override
protected void onCreate(Bundle savedInstanceState) {
    ...
    // Get max available VM memory, exceeding this amount will throw an
    // OutOfMemory exception. Stored in kilobytes as LruCache takes an
    // int in its constructor.
    final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);

    // Use 1/8th of the available memory for this memory cache.
    final int cacheSize = maxMemory / 8;

    memoryCache = new LruCache<String, Bitmap>(cacheSize) {
        @Override
        protected int sizeOf(String key, Bitmap bitmap) {
            // The cache size will be measured in kilobytes rather than
            // number of items.
            return bitmap.getByteCount() / 1024;
        }
    };
    ...
}

public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
    if (getBitmapFromMemCache(key) == null) {
        memoryCache.put(key, bitmap);
    }
}

public Bitmap getBitmapFromMemCache(String key) {
    return memoryCache.get(key);
}

ध्यान दें: इस उदाहरण में, ऐप्लिकेशन मेमोरी का आठवां हिस्सा कैश मेमोरी के लिए तय किया गया है. किसी सामान्य/एचडीपीआई डिवाइस पर इसका साइज़ कम से कम 4 एमबी (32/8) होना चाहिए. एक पूरा 800x480 रिज़ॉल्यूशन वाले डिवाइस में इमेज से भरी GridView स्क्रीन करीब 1.5 एमबी (800*480*4 बाइट) का इस्तेमाल करें. इससे कम से कम 2.5 पेजों की इमेज कैश मेमोरी में सेव होंगी मेमोरी.

किसी ImageView में बिटमैप लोड करते समय, LruCache पहले चेक किया जाता है. अगर कोई एंट्री मिलती है, तो ImageView को अपडेट करने के लिए तुरंत उसका इस्तेमाल किया जाता है. ऐसा न करने पर, इमेज को प्रोसेस करने के लिए एक बैकग्राउंड थ्रेड जनरेट किया जाता है:

Kotlin

fun loadBitmap(resId: Int, imageView: ImageView) {
    val imageKey: String = resId.toString()

    val bitmap: Bitmap? = getBitmapFromMemCache(imageKey)?.also {
        mImageView.setImageBitmap(it)
    } ?: run {
        mImageView.setImageResource(R.drawable.image_placeholder)
        val task = BitmapWorkerTask()
        task.execute(resId)
        null
    }
}

Java

public void loadBitmap(int resId, ImageView imageView) {
    final String imageKey = String.valueOf(resId);

    final Bitmap bitmap = getBitmapFromMemCache(imageKey);
    if (bitmap != null) {
        mImageView.setImageBitmap(bitmap);
    } else {
        mImageView.setImageResource(R.drawable.image_placeholder);
        BitmapWorkerTask task = new BitmapWorkerTask(mImageView);
        task.execute(resId);
    }
}

BitmapWorkerTask यह भी होना चाहिए कि को मेमोरी कैश में जोड़ने के लिए अपडेट किया गया:

Kotlin

private inner class BitmapWorkerTask : AsyncTask<Int, Unit, Bitmap>() {
    ...
    // Decode image in background.
    override fun doInBackground(vararg params: Int?): Bitmap? {
        return params[0]?.let { imageId ->
            decodeSampledBitmapFromResource(resources, imageId, 100, 100)?.also { bitmap ->
                addBitmapToMemoryCache(imageId.toString(), bitmap)
            }
        }
    }
    ...
}

Java

class BitmapWorkerTask extends AsyncTask<Integer, Void, Bitmap> {
    ...
    // Decode image in background.
    @Override
    protected Bitmap doInBackground(Integer... params) {
        final Bitmap bitmap = decodeSampledBitmapFromResource(
                getResources(), params[0], 100, 100));
        addBitmapToMemoryCache(String.valueOf(params[0]), bitmap);
        return bitmap;
    }
    ...
}

डिस्क कैश का इस्तेमाल करें

मेमोरी कैश की मदद से, हाल ही में देखे गए बिटमैप को तेज़ी से ऐक्सेस किया जा सकता है. हालांकि, ये काम नहीं किए जा सकते इस कैश मेमोरी में मौजूद इमेज पर निर्भर करता है. GridView जैसे कॉम्पोनेंट के साथ बड़े डेटासेट आसानी से मेमोरी कैश भर सकते हैं. आपके ऐप्लिकेशन में किसी अन्य वजह से रुकावट आ सकती है काम करता है, जो बैकग्राउंड में हो सकता है और मेमोरी कैश में सेव हो सकता है नष्ट कर दिया गया. उपयोगकर्ता के फिर से शुरू करने पर, आपके ऐप्लिकेशन को हर इमेज को फिर से प्रोसेस करना होगा.

प्रोसेस किए गए बिटमैप को सेव रखने के लिए, इन मामलों में डिस्क कैश का इस्तेमाल किया जा सकता है. साथ ही, मेमोरी कैश में इमेज उपलब्ध न होने पर, लोड होने में लगने वाले समय को कम करने में भी मदद मिलती है. ज़ाहिर है, डिस्क से इमेज फ़ेच की जा रही हैं यह मेमोरी से लोड होने में धीमी है. इसे बैकग्राउंड थ्रेड में पूरा करना चाहिए, क्योंकि डिस्क में ज़्यादा समय लग सकता है अंदाज़ा लगाना मुश्किल हो सकता है.

ध्यान दें: अगर कैश मेमोरी में सेव की गई इमेज को बार-बार ऐक्सेस किया जाता है, तो हो सकता है कि ContentProvider उनके लिए बेहतर स्टोरेज हो. उदाहरण के लिए, इमेज गैलरी ऐप्लिकेशन में.

इस क्लास का सैंपल कोड, DiskLruCache को लागू करने के तरीके का इस्तेमाल करता है. इसे Android सोर्स. यहां अपडेट किया गया उदाहरण कोड दिया गया है, जो मौजूदा मेमोरी कैश के साथ-साथ डिस्क कैश भी जोड़ता है:

Kotlin

private const val DISK_CACHE_SIZE = 1024 * 1024 * 10 // 10MB
private const val DISK_CACHE_SUBDIR = "thumbnails"
...
private var diskLruCache: DiskLruCache? = null
private val diskCacheLock = ReentrantLock()
private val diskCacheLockCondition: Condition = diskCacheLock.newCondition()
private var diskCacheStarting = true

override fun onCreate(savedInstanceState: Bundle?) {
    ...
    // Initialize memory cache
    ...
    // Initialize disk cache on background thread
    val cacheDir = getDiskCacheDir(this, DISK_CACHE_SUBDIR)
    InitDiskCacheTask().execute(cacheDir)
    ...
}

internal inner class InitDiskCacheTask : AsyncTask<File, Void, Void>() {
    override fun doInBackground(vararg params: File): Void? {
        diskCacheLock.withLock {
            val cacheDir = params[0]
            diskLruCache = DiskLruCache.open(cacheDir, DISK_CACHE_SIZE)
            diskCacheStarting = false // Finished initialization
            diskCacheLockCondition.signalAll() // Wake any waiting threads
        }
        return null
    }
}

internal inner class  BitmapWorkerTask : AsyncTask<Int, Unit, Bitmap>() {
    ...

    // Decode image in background.
    override fun doInBackground(vararg params: Int?): Bitmap? {
        val imageKey = params[0].toString()

        // Check disk cache in background thread
        return getBitmapFromDiskCache(imageKey) ?:
                // Not found in disk cache
                decodeSampledBitmapFromResource(resources, params[0], 100, 100)
                        ?.also {
                            // Add final bitmap to caches
                            addBitmapToCache(imageKey, it)
                        }
    }
}

fun addBitmapToCache(key: String, bitmap: Bitmap) {
    // Add to memory cache as before
    if (getBitmapFromMemCache(key) == null) {
        memoryCache.put(key, bitmap)
    }

    // Also add to disk cache
    synchronized(diskCacheLock) {
        diskLruCache?.apply {
            if (!containsKey(key)) {
                put(key, bitmap)
            }
        }
    }
}

fun getBitmapFromDiskCache(key: String): Bitmap? =
        diskCacheLock.withLock {
            // Wait while disk cache is started from background thread
            while (diskCacheStarting) {
                try {
                    diskCacheLockCondition.await()
                } catch (e: InterruptedException) {
                }

            }
            return diskLruCache?.get(key)
        }

// Creates a unique subdirectory of the designated app cache directory. Tries to use external
// but if not mounted, falls back on internal storage.
fun getDiskCacheDir(context: Context, uniqueName: String): File {
    // Check if media is mounted or storage is built-in, if so, try and use external cache dir
    // otherwise use internal cache dir
    val cachePath =
            if (Environment.MEDIA_MOUNTED == Environment.getExternalStorageState()
                    || !isExternalStorageRemovable()) {
                context.externalCacheDir.path
            } else {
                context.cacheDir.path
            }

    return File(cachePath + File.separator + uniqueName)
}

Java

private DiskLruCache diskLruCache;
private final Object diskCacheLock = new Object();
private boolean diskCacheStarting = true;
private static final int DISK_CACHE_SIZE = 1024 * 1024 * 10; // 10MB
private static final String DISK_CACHE_SUBDIR = "thumbnails";

@Override
protected void onCreate(Bundle savedInstanceState) {
    ...
    // Initialize memory cache
    ...
    // Initialize disk cache on background thread
    File cacheDir = getDiskCacheDir(this, DISK_CACHE_SUBDIR);
    new InitDiskCacheTask().execute(cacheDir);
    ...
}

class InitDiskCacheTask extends AsyncTask<File, Void, Void> {
    @Override
    protected Void doInBackground(File... params) {
        synchronized (diskCacheLock) {
            File cacheDir = params[0];
            diskLruCache = DiskLruCache.open(cacheDir, DISK_CACHE_SIZE);
            diskCacheStarting = false; // Finished initialization
            diskCacheLock.notifyAll(); // Wake any waiting threads
        }
        return null;
    }
}

class BitmapWorkerTask extends AsyncTask<Integer, Void, Bitmap> {
    ...
    // Decode image in background.
    @Override
    protected Bitmap doInBackground(Integer... params) {
        final String imageKey = String.valueOf(params[0]);

        // Check disk cache in background thread
        Bitmap bitmap = getBitmapFromDiskCache(imageKey);

        if (bitmap == null) { // Not found in disk cache
            // Process as normal
            final Bitmap bitmap = decodeSampledBitmapFromResource(
                    getResources(), params[0], 100, 100));
        }

        // Add final bitmap to caches
        addBitmapToCache(imageKey, bitmap);

        return bitmap;
    }
    ...
}

public void addBitmapToCache(String key, Bitmap bitmap) {
    // Add to memory cache as before
    if (getBitmapFromMemCache(key) == null) {
        memoryCache.put(key, bitmap);
    }

    // Also add to disk cache
    synchronized (diskCacheLock) {
        if (diskLruCache != null && diskLruCache.get(key) == null) {
            diskLruCache.put(key, bitmap);
        }
    }
}

public Bitmap getBitmapFromDiskCache(String key) {
    synchronized (diskCacheLock) {
        // Wait while disk cache is started from background thread
        while (diskCacheStarting) {
            try {
                diskCacheLock.wait();
            } catch (InterruptedException e) {}
        }
        if (diskLruCache != null) {
            return diskLruCache.get(key);
        }
    }
    return null;
}

// Creates a unique subdirectory of the designated app cache directory. Tries to use external
// but if not mounted, falls back on internal storage.
public static File getDiskCacheDir(Context context, String uniqueName) {
    // Check if media is mounted or storage is built-in, if so, try and use external cache dir
    // otherwise use internal cache dir
    final String cachePath =
            Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()) ||
                    !isExternalStorageRemovable() ? getExternalCacheDir(context).getPath() :
                            context.getCacheDir().getPath();

    return new File(cachePath + File.separator + uniqueName);
}

ध्यान दें: डिस्क कैश को शुरू करने के लिए भी डिस्क ऑपरेशन की ज़रूरत होती है. इसलिए, इसे मुख्य थ्रेड पर नहीं किया जाना चाहिए. हालांकि, इसका मतलब यह है कि कैश मेमोरी को शुरू करने से पहले ऐक्सेस किया जा सकता है. इस समस्या को ठीक करने के लिए, ऊपर बताए गए तरीके में, लॉक ऑब्जेक्ट यह पक्का करता है कि ऐप्लिकेशन डिस्क कैश से तब तक न पढ़े, जब तक कैश मेमोरी को शुरू नहीं किया जाता.

यूज़र इंटरफ़ेस (यूआई) थ्रेड में मेमोरी की कैश मेमोरी की जांच करने के दौरान, डिस्क की कैश मेमोरी की जांच बैकग्राउंड में की जाती है थ्रेड. यूज़र इंटरफ़ेस (यूआई) थ्रेड पर डिस्क की कार्रवाइयां कभी नहीं होनी चाहिए. जब इमेज प्रोसेसिंग यह होती है पूरा हो जाता है, तो अंतिम बिटमैप को भावी उपयोग के लिए मेमोरी और डिस्क कैश दोनों में जोड़ दिया जाता है.

कॉन्फ़िगरेशन में बदलाव करना

रनटाइम कॉन्फ़िगरेशन में बदलाव, जैसे कि स्क्रीन ओरिएंटेशन में बदलाव की वजह से Android बंद हो जाता है और नए कॉन्फ़िगरेशन के साथ चल रही गतिविधि को फिर से चालू करें (इस व्यवहार के बारे में ज़्यादा जानकारी के लिए, रनटाइम में होने वाले बदलावों को मैनेज करना देखें). आपको अपनी सभी इमेज को फिर से प्रोसेस न करना पड़े, ताकि उपयोगकर्ता इमेज को आसानी से और तेज़ी से प्रोसेस कर सके का अनुभव किया जा सकता है.

अच्छी बात यह है कि आपके पास बिटमैप का बढ़िया मेमोरी कैश होता है, जिसे आपने मेमोरी कैश का इस्तेमाल करें सेक्शन में बनाया है. इस कैश मेमोरी को नए Fragment का इस्तेमाल करके गतिविधि इंस्टेंस, जिसे setRetainInstance(true) को कॉल करके सुरक्षित किया गया है. गतिविधि के बाद फिर से बनाया गया, तो कायम रखे गए Fragment को फिर से अटैच कर दिया जाता है और आपको इसकी ऐक्सेस मिल जाती है मौजूदा कैश ऑब्जेक्ट है, जिससे इमेज को तुरंत फ़ेच किया जा सकता है और ImageView ऑब्जेक्ट में फिर से भरा जा सकता है.

यहां कॉन्फ़िगरेशन में LruCache ऑब्जेक्ट को बनाए रखने का उदाहरण दिया गया है Fragment का इस्तेमाल करके बदलाव करता है:

Kotlin

private const val TAG = "RetainFragment"
...
private lateinit var mMemoryCache: LruCache<String, Bitmap>

override fun onCreate(savedInstanceState: Bundle?) {
    ...
    val retainFragment = RetainFragment.findOrCreateRetainFragment(supportFragmentManager)
    mMemoryCache = retainFragment.retainedCache ?: run {
        LruCache<String, Bitmap>(cacheSize).also { memoryCache ->
            ... // Initialize cache here as usual
            retainFragment.retainedCache = memoryCache
        }
    }
    ...
}

class RetainFragment : Fragment() {
    var retainedCache: LruCache<String, Bitmap>? = null

    companion object {
        fun findOrCreateRetainFragment(fm: FragmentManager): RetainFragment {
            return (fm.findFragmentByTag(TAG) as? RetainFragment) ?: run {
                RetainFragment().also {
                    fm.beginTransaction().add(it, TAG).commit()
                }
            }
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        retainInstance = true
    }
}

Java

private LruCache<String, Bitmap> memoryCache;

@Override
protected void onCreate(Bundle savedInstanceState) {
    ...
    RetainFragment retainFragment =
            RetainFragment.findOrCreateRetainFragment(getFragmentManager());
    memoryCache = retainFragment.retainedCache;
    if (memoryCache == null) {
        memoryCache = new LruCache<String, Bitmap>(cacheSize) {
            ... // Initialize cache here as usual
        }
        retainFragment.retainedCache = memoryCache;
    }
    ...
}

class RetainFragment extends Fragment {
    private static final String TAG = "RetainFragment";
    public LruCache<String, Bitmap> retainedCache;

    public RetainFragment() {}

    public static RetainFragment findOrCreateRetainFragment(FragmentManager fm) {
        RetainFragment fragment = (RetainFragment) fm.findFragmentByTag(TAG);
        if (fragment == null) {
            fragment = new RetainFragment();
            fm.beginTransaction().add(fragment, TAG).commit();
        }
        return fragment;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setRetainInstance(true);
    }
}

इसे आज़माने के लिए, Fragment को बनाए रखते हुए और बनाए रखते हुए, डिवाइस को घुमाने की कोशिश करें. आपको थोड़ा या बिलकुल भी इंतज़ार नहीं करना पड़ेगा, क्योंकि कैश मेमोरी सेव रखने पर इमेज, गतिविधि में तुरंत भर जाती हैं. मेमोरी कैश में नहीं मिली इमेज उम्मीद है कि यह डिस्क की कैश मेमोरी में उपलब्ध होगी. अगर ऐसा नहीं होता है, तो उसे सामान्य तरीके से प्रोसेस किया जाता है.