RxJava2 Retry with exponential backoff, maximum amount of retries and evaluator

ExponentialBackoffRetryHandler.kt

class ExponentialBackoffRetryHandler<T : Throwable>(private val maxRetries: Int = 3, 
                                                    private val retryDelayMs: Long = 2500, 
                                                    private val evaluator: (Throwable, Int) -> Boolean = { _, _ -> true }): 
Function<Flowable<T>, Publisher<*>> {

    companion object {
        private const val TAG: String = "ExponentialRetryHandler"
    }
  
    private var retryCount: Int = 0

    @Throws(Exception::class)
    override fun apply(attempts: Flowable<T>): Publisher<*> {
        return attempts
                .concatMap { ex ->
                    retryCount++
                    val throwable = ex as Throwable
                    val shouldRetry = evaluator.invoke(throwable, retryCount)

                    if ((retryCount<= maxRetries) && shouldRetry) {
                        val delayMs = retryDelayMs * retryCount

                        Log.w(TAG, "Retrying... attempt #$retryCount will be executed in ${delayMs / 1000F} seconds")

                        return@concatMap Flowable.timer(delayMs, TimeUnit.MILLISECONDS)
                    }

                    return@concatMap Flowable.error<T>(throwable)
                }
    }
}

Usage.kt

ApiClient.operation()
    .retryWhen(ExponentialBackoffRetryHandler shouldRetry@{ ex, retryCount ->
        // Evaluator will be invoked before each retry attempt. Evaluate
        // whatever needed and decide if should retry.

       return@shouldRetry true // or false if we don't wanna retry.
    })
    //...
    .subscribe()