Improving the Caching Game on Android in Kotlin

allprojects {
    repositories {
        google()
        jcenter()
        maven { url 'https://jitpack.io' }
    }
}

apply plugin: 'com.android.application'

apply plugin: 'kotlin-android'

apply plugin: 'kotlin-android-extensions'
apply plugin: "kotlin-kapt"

implementation "com.github.crypticminds.ColdStorage:coldstoragecache:2.0.1"
kapt "com.github.crypticminds.ColdStorage:coldstoragecompiler:2.0.1"
implementation "com.github.crypticminds.ColdStorage:coldstorageannotation:2.0.1"

import com.arcane.coldstorageannotation.Refrigerate
import java.net.URL

class MakeRemoteCall {

    /**
     * A method that makes a call to the "https://httpbin.org/get"
     * endpoint. This endpoint simply returns the arguments that were passed to it.
     * For the caching logic the parameter passed to the endpoint will act as
     * the key of the cache.
     *
     * Since there is only one parameter we don't need to specify the the keys
     * field in the annotation.
     */
    @Refrigerate(operation = "CallToServiceA")
    fun makeRemoteCallToServiceA(value: String): String {
        val url = "https://httpbin.org/get?param1=$value"
        val textResponse = URL(url).readText()
        return textResponse
    }


    /**
     * We will use the same endpoint but this time we will pass 3 parameters.
     * However , out cache key should only be the first 2.
     * We can configure the "keys" field in the annotation by specifying
     * the variable names that should act as the key of the cache.
     * In this case "parameter1" and "parameter2"
     */
    @Refrigerate(
        operation = "CallToServiceB", timeToLive = 10000,
        keys = ["parameter1", "parameter2"]
    )
    fun makeRemoteCallToServiceB(parameter1: String, parameter2: String, parameter3: String): String {
        val url = "https://httpbin.org/get?param1=$parameter1&param2=$parameter2&param3=$parameter3"
        val textResponse = URL(url).readText()
        return textResponse
    }
}

import android.os.Bundle
import android.widget.Button
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity
import com.arcane.coldstoragecache.callback.OnOperationSuccessfulCallback
import com.arcane.coldstorageexamples.remotecall.MakeRemoteCall
import com.arcane.generated.GeneratedCacheLayer

class MainActivity : AppCompatActivity(), OnOperationSuccessfulCallback<String?> {

    /**
     * The make remote call object.
     *
     * @see MakeRemoteCall for details.
     */
    private val makeremoteCall = MakeRemoteCall()

    private lateinit var button: Button

    private lateinit var firstRemoteCall: TextView

    private lateinit var secondRemoteCall: TextView

    private val valueArray = arrayListOf("a", "b", "c")

    private var counter = 1

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        button = findViewById(R.id.button)
        firstRemoteCall = findViewById(R.id.remotecall1)
        secondRemoteCall = findViewById(R.id.remotecall2)


        /**
         * On button click random values from the array will be used to make the
         * remote calls.
         * The counter variable is used to control the two calls are made alternatively
         * on button clicks.
         */
        button.setOnClickListener {
            if (counter % 2 == 0) {
                GeneratedCacheLayer.makeRemoteCallToServiceA(
                    valueArray.random(),
                    makeremoteCall,
                    this
                )
            } else {
                GeneratedCacheLayer.makeRemoteCallToServiceB(
                    valueArray.random(),
                    valueArray.random(),
                    "constantvalue", makeremoteCall, this
                )
            }
            counter += 1
        }
    }

    /**
     * Populate the first text view with the response.
     */
    private fun populateFirstTextView(s: String) {
        runOnUiThread {
            firstRemoteCall.text = s
        }

    }

    /**
     * Populate the second text view with the response.
     */
    private fun populateSecondTextView(s: String) {
        runOnUiThread {
            secondRemoteCall.text = s
        }
    }

    /**
     * The callback implementation via which the result is
     * returned by the generated cache layer.
     */
    override fun onSuccess(output: String?, operation: String) {
        when (operation) {
            "CallToServiceA" -> populateFirstTextView(output!!)
            else ->            populateSecondTextView(output!!)
        }
    }
}

import com.arcane.generated.GeneratedCacheLayer

GeneratedCacheLayer.makeRemoteCallToServiceA(
                    valueArray.random(),
                    makeremoteCall,
                    this
                )