[Android kotlin collaboration] use coroutinecontext to realize the retry logic after a network request fails

Preface

stay Android There is a typical scenario in development ： Try again after the network request fails ： The general logic is to pop up a Dialog Remind users “ Network request failed ”, And provide a retry button .

If the current page has only one network request , Then the logic is very simple ： Just call the method that initiates the network request again . When a page has multiple network requests , My common method is to add status for failure callback , Call different methods according to different states . But this method is somewhat cumbersome , It's also a little unsafe . First , You need to add extra status , And pass it around . In some cases , You even need to reinitialize the network request parameters . What's worse ： You have to manage this state , Once mismanaged , Will result in calling methods that should not be called , Introduce serious BUG.

Until one day I saw CoroutineExceptionHandler, Flash of light —— You can use the collaboration context to save network requests and... That may need to be retried in the future Request data , This will solve the above problem .

Because most of the projects I have developed adopt ViewModel Implement network request logic and UI Decoupling of layers , The network request is basically based on Coroutine+Retrofit The way to achieve , It's basically using viewModelScope.

viewModelScope.launch() { 
	request()
} 

viewModelScope It's essentially a ViewModel The extension function of , It can be used conveniently in ViewModel Create coroutines , The specific code will not be expanded . By default , its CoroutineContext from Job and CoroutineDispatcher form . The context of a collaborative process is essentially an implementation key-value Linked list structure of access mode . We can do it through inheritance AbstractCoroutineContextElement To implement custom CoroutineContext Context ：

class RetryCallback(val callback: () -> Unit) : AbstractCoroutineContextElement(RetryCallback) {
    companion object Key : CoroutineContext.Key<RetryCallback>
} 

Then , When the network request is abnormal CoroutineExceptionHandler Get the operation we need to perform again ：

val coroutineExceptionHandler = CoroutineExceptionHandler { coroutineContext, throwable ->
     val callback = coroutineContext[RetryCallback]
        ?.callback
} 

Then , To put coroutineExceptionHandler Add to the context of the process that initiates the network request ：

viewModelScope.launch(exceptionHandler
      + RetryCallback { request() }) { 
	request()
} 

here , Just get it on the page that initiates the network request callback, And call it when you click the retry button , The logic of retry can be realized .

Further encapsulate it and add automatic retry logic after failure , Create for ViewModel Interface used , Subsequent logic used to handle network request errors ：

interface ViewModelFailed {
    /**
     * @param throwable: Abnormal information 
     * @param callback: Function to retry 
     * */
    fun requestFailed(throwable: Throwable, callback: () -> Unit)
} 

Create an extension function for it , Used to create CoroutineExceptionHandler and RetryCallback Context instance ：

/**
 * @param autoReTry: Retry automatically 
 * @param callback: Function to retry 
 * */
fun ViewModelFailed.initRetry(autoReTry: Boolean = false, callback: () -> Unit) =
    CoroutineExceptionHandler { coroutineContext, throwable ->
        val retryCallBack = {
            coroutineContext[RetryCallback]
                ?.callback?.invoke()
        }
        if (autoReTry) {
            // Automatic start retry logic 
            onRetry()
            retryCallBack.invoke()
        } else {
            // Do not automatically start retry , Subsequent operations are left to the user for decision 
            requestFailed(throwable) {
                retryCallBack
            }
        }
    } + RetryCallback(callback) 

ViewModel Need to achieve ViewModelFailed Interface , And calls in the association of the network requests. initRetry Method to add an exception handling context ：

 class MainViewViewModel : ViewModel(), ViewModelFailed {
    val liveData: MutableLiveData<BaseData> = MutableLiveData()


      /**
     * @param num: For demonstration Request Request data 
     * @param repeat: Number of automatic retries after failure 
     * */
    fun request(num: Int, repeat: Int = 0) {
        liveData.value = BaseData.loading()
        viewModelScope.launch(initRetry(repeat > 0) {
            request(num,repeat - 1)
        }) {
            liveData.value = BaseData.success(simulateHttp(num))
        }
    }

    private suspend fun simulateHttp(num: Int) = withContext(Dispatchers.IO) {
        // Simulate network requests 
        ...
    }

    override fun requestFailed(throwable: Throwable, callback: () -> Unit) {
        // Processing failure logic 
        dialog()
        // retry 
        callback.invoke()
    }
    
    override fun onRetry() {
        
    }

} 

Last

Android Learning is a long way to go , What we need to learn is not only superficial technology , We have to go down to the bottom , Figure out the following principle , That's the only way , We can improve our competitiveness , In today's highly competitive world .

Life can't be smooth , When there are peaks, there are valleys , To believe in , Those who can't beat us , It will make us stronger in the end , To be your own ferry man .

I've sorted myself out in this period of time Android The most important and popular learning direction materials are placed in the QR code below , There are also different directions of self-study programming route 、 Interview question set / Face the 、 And a series of technical articles .**

Resources are constantly updated , Welcome to study and discuss together .