ColdStorage library makes it easy to generate cache layers in an android application using just annotations. For details such as usage and examples check out the repository :- https://github.com/crypticminds/ColdStorage. For details about each annotation and other components check out the project wiki:- https://github.com/crypticminds/ColdStorage/wiki

Programming language: Kotlin
Latest version: v4.1.0

ColdStorage alternatives and similar packages

Based on the "Kotlin" category

Do you think we are missing an alternative of ColdStorage or a related project?

Add another 'Kotlin' Package



A lightweight caching library for android

License Downloads Codacy Badge Build Status Gitter

  • Feature requests: Got a new requirement? Request it here and it will be delivered.
  • Bugs: Report a bug here and it will be squashed.
  • Questions: Get your questions about contributing, usage or anything related to the library answered here.
  • Examples : Check out various examples here.
  • Suggestions/Complaints/Feedbacks: Got something in your mind regarding this library? Please share and help us improve.
  • Upcoming features : If you are interested to see all the exciting features lined up for delivery.


Check the latest release to get the newest features.

You need to initialize the cache when the application starts. The initialization takes care of pulling previously cached data and loading them into the memory .

  • Create an application class and initialize the cache in the onCreate() method.

        import android.app.Application
        import com.arcane.coldstoragecache.cache.Cache
        class Application : Application() {
        override fun onCreate() {
            Cache.initialize(context = applicationContext)

    You can configure the cache with additional parameters such as a global time to live, maximum cache size etc. Refer the [wiki](https://github.com/crypticminds/ColdStorage/wiki/Initialize-cache) for more details.

  • Register your application in the android manifest file by providing the android:name attribute

    # Quick guide

This guide will only provide a basic usage guide. For detailed description of each component, usage and examples check the wiki

@LoadImage Annotation

You can annotate any ImageView present in an Activity , fragement or another view to load images from an URL and cache it for future use.

        placeHolder = R.drawable.loading, enableLoadingAnimation = true, persistImageToDisk = true
    lateinit var imageWithAnimation: ImageView

Images can be persisted into the internal storage using the "persistImageToDisk" parameter.

After the image views have been annotated , bind the class where the image views are present using the method Cache.bind(object).

You can pass the activity, fragement or the view to which the annotated ImageViews belong to.

In an activity, the method should be called after setContentView and in a fragemnt it should be called in onViewCreated method.

     override fun onCreate(savedInstanceState: Bundle?) {

Currently the cache can only be bound to an Activity , fragment or view.

@Freeze Annotation

Annotate your class using the freeze annotation to apply caching logic on top of all the public methods present in the class.

@Freeze(generatedClassName = "MyBeautifulCacheLayer")
class MakeRemoteCallWithFreeze {

    fun makeRemoteCallToServiceA(value: String): String {
        val url = "https://httpbin.org/get?param1=$value"
        val textResponse = URL(url).readText()
        return textResponse

     * Here I am marking the parameters that will together form the cache key
     * with @CacheKey
    fun makeRemoteCallToServiceB(
        @CacheKey parameter1: String,
        @CacheKey parameter2: String,
        parameter3: String
    ): String {
        val url = "https://httpbin.org/get?param1=$parameter1&param2=$parameter2&param3=$parameter3"
        val textResponse = URL(url).readText()
        return textResponse

This will generate a class called "MyBeautifulCacheLayer" . You can use this class to call the methods.

//you need to implement the OnOperationSuccessfulCallback interface.
val callback = object : OnOperationSuccessfulCallback<String>{
        override fun onSuccess(output: String?, operation: String) {
            //handle the output here.
        //operation is the name of the method that returns the output. In this case the output
        //can be "makeRemoteCallToServiceB" or "makeRemoteCallToServiceA" . You can handle the output
        //based on which method is returning it.

val cacheLayer = MyBeautifulCacheLayer()

cacheLayer.makeRemoteCallToServiceA("someString" , callback)

cacheLayer.makeRemoteCallToServiceB(.... )

@Refrigerate Annotation

Annotate your functions with refrigerate to cache the output of the function for a given set of inputs.

    @Refrigerate(timeToLive : 2000, operation = "cacheImage")
    fun downloadImage(@CacheKey url : String , @CacheKey data : String , variableThatIsNotAKey : String) : Bitmap {

This will keep the bitmap in the cache for 2 seconds.

In the above example url and data will together form the key of the cache , such that if it determines that the same url and data is passed to the function (until the value expires in the cache) irrespective of the value of "variableThatIsNotAKey" it will return the data from the cache.

During compilation the annotations will generate a class "GeneratedCacheLayer and instead of using your annotated functions directly you will use them via this class.

To invoke the above functions you will call :-

    GeneratedCacheLayer.downloadImage("myurl", objectOfTheClassWhereTheMethodBelongs , callback)

    GeneratedCacheLayer.callRemoteService("myurl", "mydata" , "myrandomVariable" , objectOfTheClassWhereTheMethodBelongs , callback)

The generated method will have the same name and accept the same variables as the original method but with two extra parameters , one is the object of the class where the original annotated method is present in and the second is the callback (OnOperationsuccessfulCallback) which will be used to pass the cached data to the main thread from the background thread.

Create a custom cache layer

Create your cache layer by extending the Cache class. You will have to implement the update method. The update method should take care of fetching the data when the data is stale or is not present in the cache.

    import android.graphics.Bitmap
    import android.graphics.BitmapFactory
    import android.util.Base64
    import android.util.Log
    import com.arcane.coldstoragecache.cache.Cache
    import java.io.ByteArrayOutputStream
    import java.net.URL

     * An example class that is used to cache images
     * after downloading them from a given url.
    class ImageCache : Cache() {

         * The update function is only required here to specify
         * where to fetch the data from if the key is not present in the
         * cache.
         * @param key Here the key is the url from where the
         * image needs to be downloaded.
        override fun update(key: String): String? {
            return try {
                val url = URL(key)
                val connection = url.openConnection()
                connection.doInput = true
                val input = connection.getInputStream()
                val myBitmap = BitmapFactory.decodeStream(input)
            } catch (e: Exception) {
                Log.e("EXCEPTION", "Unable to download image", e)
                return null

         * A transformer to convert the bitmap to string.
        private fun bitMapToString(bitmap: Bitmap): String? {
            val baos = ByteArrayOutputStream()
            bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos)
            val b: ByteArray = baos.toByteArray()
            return Base64.encodeToString(b, Base64.DEFAULT)

The update method should return the value to be cached in form of a string. If you are planning to store complex objects , serialize them into a string and return them from the method.

Your cache is now ready. To use the cache create an instance of it and call the get method of the cache.

The get method accepts the key that needs to be fetched from the cache and a callback which will be used to return the result to the main thread. The cache performs all operations in a background thread and will never block the UI thread. You will need to implement the OnValueFetchedCallback interface and pass it to the get method of the cache. The cache will fetch the value and pass it to the callback method from where you can access it and use in the UI thread.

Optionally you can also pass a time to live value and a converter. They are explained in detail below.

    import android.graphics.Bitmap
    import android.os.Bundle
    import android.view.Menu
    import android.view.MenuItem
    import android.widget.Button
    import android.widget.ImageView
    import androidx.appcompat.app.AppCompatActivity
    import com.arcane.coldstorage.cache.ImageCache
    import com.arcane.coldstoragecache.callback.OnValueFetchedCallback
    import com.arcane.coldstoragecache.converter.impl.StringToBitmapConverter

    class MainActivity : AppCompatActivity(), OnValueFetchedCallback<Any?> {

        companion object {
            val URLS = arrayListOf(

         * An instance of image cache.
        private val imageCache: ImageCache = ImageCache()

         * The image view where the images will be displayed.
        private lateinit var imageView: ImageView

         * The button used to change the image.
        private lateinit var changeButton: Button

        override fun onCreate(savedInstanceState: Bundle?) {
            imageView = findViewById(R.id.image_view)
            changeButton = findViewById(R.id.change)
            changeButton.setOnClickListener {

         * Method to test image caching.
        private fun checkImageCaching() {
            val converter = StringToBitmapConverter()


         * When the image is downloaded , adding the image to
         * the image view.
        override fun valueFetched(output: Any?) {
            runOnUiThread {
                val outputAsBitmap = output as Bitmap

The time to live value in the get method to specify how long a data needs to be stored in the cache.

The converter object takes care of deserializing the string into the object you need. It is an optional parameter. If the converter is not passed the cache will return the value as string.


Copyright 2020 Anurag Mandal

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at


Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
See the License for the specific language governing permissions and
limitations under the License.


Anurag Mandal LinkedIn

*Note that all licence references and agreements mentioned in the ColdStorage README section above are relevant to that project's source code only.