bugfix/error_signing_redirect: Added error handling

* Added a retrofit exception that transforms all the retrofit rx calls
to the retrofit exception. Retrofit exception is of 3 types, http,
network and unexpected.
* Added WebViewException, RetrofitException and EmptyResultsException.
WebViewException is called when the webview fails to load an url.
EmptyResultsException is thrown in case the data retrieved from both
database and network is null or empty.
* Added a base fragment, namely, BaseViewModelFragment where we handle
the error received from the viewmodel by overriding onError method.
* Added error handling when login fails.
* Replaced all this from methods like viewModel.obj.observer(this, ...)
with viewLifecycleOwner.
* Created a few utility methods in Utils.
* Improvd Result class so now it supports success and error checks.
* Added error codes for not authorized, unknown and not found.
* Added some error messages to the strings.xml.
* Added logs for unknown actions.
* Added todos for not fixed errors.

Author: AndreiToader-stanescu-TomTom

app/src/main/java/ro/code4/monitorizarevot/data/dao/FormsDao.kt

@@ -115,7 +115,7 @@ interface FormsDao {
         pollingStationNumber: Int,
         formId: Int,
         synced: Boolean = true
-    )
+    ): Completable
 
     @Query("UPDATE question SET hasNotes=:hasNotes WHERE id=:questionId")
     fun updateQuestionWithNotes(

app/src/main/java/ro/code4/monitorizarevot/exceptions/EmptyResultsException.kt

@@ -0,0 +1,5 @@
+package ro.code4.monitorizarevot.exceptions
+
+import java.lang.Exception
+
+class EmptyResultsException(message: String, thr: Throwable? = null) : Exception(message, thr)

app/src/main/java/ro/code4/monitorizarevot/exceptions/ErrorCodes.kt

@@ -0,0 +1,7 @@
+package ro.code4.monitorizarevot.exceptions
+
+object ErrorCodes {
+    const val UNAUTHORIZED = 401
+    const val NOT_FOUND = 404
+    const val UNKNOWN = 400
+}

app/src/main/java/ro/code4/monitorizarevot/exceptions/RetrofitException.kt

@@ -0,0 +1,106 @@
+package ro.code4.monitorizarevot.exceptions
+
+import okhttp3.ResponseBody
+import retrofit2.Converter
+import retrofit2.Response
+import retrofit2.Retrofit
+import java.io.IOException
+
+
+/**
+ * Exception that is retrieved from retrofit. It is of three types, http, network and unexpected.
+ */
+open class RetrofitException internal constructor(
+    message: String?,
+    /**
+     * RobResponse object containing status code, headers, body, etc.
+     */
+    val response: Response<*>?,
+    /**
+     * The event kind which triggered this error.
+     */
+    val kind: Kind,
+    val exception: Throwable?,
+    /**
+     * The Retrofit this request was executed on
+     */
+    val retrofit: Retrofit?
+) :
+    RuntimeException(message, exception) {
+    /**
+     * Identifies the event kind which triggered a [RetrofitException].
+     */
+    enum class Kind {
+        /**
+         * An [IOException] occurred while communicating to the server.
+         */
+        NETWORK,
+
+        /**
+         * A non-200 HTTP status code was received from the server.
+         */
+        HTTP,
+
+        /**
+         * An internal error occurred while attempting to execute a request. It is best practice to
+         * re-throw this exception so your application crashes.
+         */
+        UNEXPECTED
+    }
+
+    /**
+     * HTTP response body converted to specified `type`. `null` if there is no
+     * response.
+     *
+     * @param type
+     * @throws IOException if unable to convert the body to the specified `type`.
+     */
+    @Throws(IOException::class)
+    fun <T> getErrorBodyAs(type: Class<*>?): T? {
+        if (response?.errorBody() == null) {
+            return null
+        }
+        val converter: Converter<ResponseBody?, T> =
+            retrofit!!.responseBodyConverter(type, arrayOfNulls(0))
+        return converter.convert(response.errorBody())
+    }
+
+    companion object {
+        fun httpError(
+            response: Response<*>,
+            retrofit: Retrofit?
+        ): RetrofitException {
+            val message = response.code().toString() + " " + response.message()
+            return RetrofitException(
+                message,
+                response,
+                Kind.HTTP,
+                null,
+                retrofit
+            )
+        }
+
+        fun networkError(exception: IOException): RetrofitException {
+            return RetrofitException(
+                exception.message,
+                null,
+                Kind.NETWORK,
+                exception,
+                null
+            )
+        }
+
+        fun unexpectedError(exception: Throwable): RetrofitException {
+            return RetrofitException(
+                exception.message,
+                null,
+                Kind.UNEXPECTED,
+                exception,
+                null
+            )
+        }
+    }
+
+}
+
+

app/src/main/java/ro/code4/monitorizarevot/exceptions/WebViewException.kt

@@ -0,0 +1,8 @@
+package ro.code4.monitorizarevot.exceptions
+
+import java.lang.Exception
+
+/**
+ * Exception thrown when there is an issue with webview, loading paage, etc.
+ */
+class WebViewException(override val message: String, val code: Int = -1) : Exception(message)

app/src/main/java/ro/code4/monitorizarevot/extensions/RetrofitExtensions.kt

@@ -0,0 +1,9 @@
+package ro.code4.monitorizarevot.extensions
+
+import retrofit2.HttpException
+import retrofit2.Response
+
+fun <T> Response<T>.successOrThrow(): Boolean {
+    if (!isSuccessful) throw HttpException(this)
+    return true
+}

app/src/main/java/ro/code4/monitorizarevot/extensions/RxErrorHandlingCallAdapterFactory.kt

@@ -0,0 +1,114 @@
+package ro.code4.monitorizarevot.extensions
+
+import io.reactivex.*
+import retrofit2.Call
+import retrofit2.CallAdapter
+import retrofit2.HttpException
+import retrofit2.Retrofit
+import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory
+import ro.code4.monitorizarevot.exceptions.RetrofitException
+import ro.code4.monitorizarevot.exceptions.RetrofitException.Companion.httpError
+import ro.code4.monitorizarevot.exceptions.RetrofitException.Companion.networkError
+import ro.code4.monitorizarevot.exceptions.RetrofitException.Companion.unexpectedError
+import java.io.IOException
+import java.lang.reflect.ParameterizedType
+import java.lang.reflect.Type
+
+/**
+ * Rxjava error handling CallAdapter factory. This class ensures the mapping of errors to
+ * one of the following exceptions: http, network or unexpected exceptions.
+ */
+class RxErrorHandlingCallAdapterFactory private constructor() : CallAdapter.Factory() {
+    private val original: RxJava2CallAdapterFactory = RxJava2CallAdapterFactory.create()
+
+    override fun get(
+        returnType: Type, annotations: Array<Annotation>,
+        retrofit: Retrofit
+    ): CallAdapter<*, *> {
+        return RxCallAdapterWrapper(
+            returnType,
+            retrofit,
+            (original.get(returnType, annotations, retrofit) as CallAdapter<Any, Any>)
+        )
+    }
+
+    internal inner class RxCallAdapterWrapper(
+        private val returnType: Type,
+        private val retrofit: Retrofit,
+        private val wrapped: CallAdapter<Any, Any>
+    ) :
+        CallAdapter<Any, Any> {
+        override fun responseType(): Type {
+            return wrapped.responseType()
+        }
+
+        override fun adapt(call: Call<Any>): Any? {
+            val rawType = getRawType(returnType)
+
+            val isFlowable = rawType == Flowable::class.java
+            val isSingle = rawType == Single::class.java
+            val isMaybe = rawType == Maybe::class.java
+            val isCompletable = rawType == Completable::class.java
+            if (rawType != Observable::class.java && !isFlowable && !isSingle && !isMaybe) {
+                return null
+            }
+            if (returnType !is ParameterizedType) {
+                val name = if (isFlowable)
+                    "Flowable"
+                else if (isSingle) "Single" else if (isMaybe) "Maybe" else "Observable"
+                throw IllegalStateException(
+                    name
+                            + " return type must be parameterized"
+                            + " as "
+                            + name
+                            + "<Foo> or "
+                            + name
+                            + "<? extends Foo>"
+                )
+            }
+
+            if (isFlowable) {
+                return (wrapped.adapt(call) as Flowable<*>).onErrorResumeNext { throwable: Throwable ->
+                    Flowable.error(asRetrofitException(throwable))
+                }
+            }
+            if (isSingle) {
+                return (wrapped.adapt(call) as Single<*>).onErrorResumeNext { throwable ->
+                    Single.error(asRetrofitException(throwable))
+                }
+            }
+            if (isMaybe) {
+                return (wrapped.adapt(call) as Maybe<*>).onErrorResumeNext { throwable: Throwable ->
+                    Maybe.error(asRetrofitException(throwable))
+                }
+            }
+            if (isCompletable) {
+                return (wrapped.adapt(call) as Completable).onErrorResumeNext { throwable ->
+                    Completable.error(asRetrofitException(throwable))
+                }
+            }
+            return (wrapped.adapt(call) as Observable<*>).onErrorResumeNext { throwable: Throwable ->
+                Observable.error(asRetrofitException(throwable))
+            }
+        }
+
+        private fun asRetrofitException(throwable: Throwable): RetrofitException {
+            if (throwable is HttpException) {
+                val response = throwable.response()
+                return httpError(response!!, retrofit)
+            } else if (throwable is IOException) {
+                return networkError(throwable)
+            }
+            return unexpectedError(throwable)
+        }
+    }
+
+    companion object {
+        const val TAG = "RxErrorHandlingCallAdapterFactory"
+
+        fun create(): CallAdapter.Factory {
+            return RxErrorHandlingCallAdapterFactory()
+        }
+    }
+}
+

app/src/main/java/ro/code4/monitorizarevot/helper/APIError400.kt

@@ -1,13 +1,21 @@
 package ro.code4.monitorizarevot.helper
 
+
 /**
- * .:.:.:. Created by @henrikhorbovyi on 13/10/19 .:.:.:.
+
+ * Class that encapsulates successful result with a value of type [T] or
+ * a failure with a [Throwable] exception.
  */
 sealed class Result<out T> {
-    class Failure(val error: Throwable, val message: String = "") : Result<Nothing>()
-    class Success<out T>(val data: T? = null) : Result<T>()
+    data class Error(val exception: Throwable) : Result<Nothing>()
+    data class Success<out T>(val data: T? = null) : Result<T>()
     object Loading : Result<Nothing>()
 
+    fun exceptionOrNull(): Throwable? =
+        when (this) {
+            is Error -> exception
+            else -> null
+        }
 
     fun handle(
         onSuccess: (T?) -> Unit = {},
@@ -16,8 +24,32 @@ sealed class Result<out T> {
     ) {
         when (this) {
             is Success -> onSuccess(data)
-            is Failure -> onFailure(error)
+            is Error -> onFailure(exception)
             is Loading -> onLoading()
         }
     }
-}
+
+    override fun toString(): String {
+        return when (this) {
+            is Success<*> -> "Success[data=$data]"
+            is Error -> "Error[exception=$exception]"
+            Loading -> "Loading"
+        }
+    }
+}
+
+val Result<*>.succeeded
+    get() = this is Result.Success && data != null
+
+val Result<*>.error
+    get() = this is Result.Error
+
+inline fun <R, T : R> Result<T>.getOrThrow(onFailure: (exception: Throwable) -> R): R {
+    return when (val exception = exceptionOrNull()) {
+        null -> data as T
+        else -> onFailure(exception)
+    }
+}
+
+val <T> Result<T>.data: T?
+    get() = (this as? Result.Success)?.data