MVVM - Boilerplate
Type Converter
class Converter {
@TypeConverter
fun fromListOfStringsToString(value: List<String>): String {
val gson = Gson()
val type = object : TypeToken<List<String>>() {}.type
return gson.toJson(value, type)
}
@TypeConverter
fun fromStringToListOfStrings(value: String): List<String> {
val gson = Gson()
val type = object : TypeToken<List<String>>() {}.type
return gson.fromJson(value, type)
}
}Network Module
@Module
@InstallIn(SingletonComponent::class)
class NetworkModule {
@Provides
@Singleton
fun provideOkHttpClient(): OkHttpClient {
return OkHttpClient.Builder()
.connectTimeout(30, TimeUnit.SECONDS)
.readTimeout(30, TimeUnit.SECONDS)
.writeTimeout(30, TimeUnit.SECONDS)
.build()
}
@Provides
@Singleton
fun provideRetrofit(client: OkHttpClient): Retrofit {
return Retrofit.Builder()
.baseUrl(BASE_URL)
.client(client)
.addConverterFactory(MoshiConverterFactory.create())
.build()
}
@Provides
@Singleton
fun provideService(retrofit: Retrofit): PostApi {
return retrofit.create(PostApi::class.java)
}
}Handle Internet Connection
private fun hasInternetConnection(): Boolean {
val connectivityManager =
getApplication<Application>().getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
val activeNetwork = connectivityManager.activeNetwork ?: return false
val capabilities = connectivityManager.getNetworkCapabilities(activeNetwork) ?: return false
return when {
capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> true
capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> true
capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) -> true
else -> false
}
}Check Response Data
private fun handleProductResponse(response: Response<Product>): NetworkResult<Product>? {
when {
response.message().contains("timeout") -> {
return NetworkResult.Error("TimeOut")
}
response.code() == 402 -> {
return NetworkResult.Error("API Key Limited")
}
response.body()!!.results.isEmpty() -> {
return NetworkResult.Error("Product not found")
}
response.isSuccessful -> {
return NetworkResult.Success(response.body()!!)
}
else -> {
return NetworkResult.Error(response.message())
}
}
}Coroutine Scope And Exception Handler
val exceptionHandler = CoroutineExceptionHandler { _, throwable ->
onError("Exception handled: ${throwable.localizedMessage}")
} CoroutineScope(Dispatchers.IO + exceptionHandler).launch {
val response = mainRepository.getAllMovies()
}AsynListDiffer - DifferCallback
private val differCallback = object : DiffUtil.ItemCallback<Result>() {
override fun areItemsTheSame(oldItem: Result, newItem: Result): Boolean {
return oldItem.id == newItem.id
}
override fun areContentsTheSame(oldItem: Result, newItem: Result): Boolean {
return oldItem == newItem
}
}
val differ = AsyncListDiffer(this, differCallback)Network Bound Resource
inline fun <T, K> networkBoundResource(
crossinline query: () -> Flow<T>,
crossinline fetch: suspend () -> K,
crossinline saveFetchResult: suspend (K) -> Unit,
crossinline shouldFetch: (T) -> Boolean = { true }
) = channelFlow<Resource<*>> {
val data = query().first()
send(Resource.loading(null))
if (shouldFetch(data)) {
try {
saveFetchResult(fetch())
try {
query().collect { send(Resource.success(it)) }
} catch (e: Exception) {
send(Resource.error(data = null, message = e.localizedMessage ?: "Error!"))
}
} catch (e: Exception) {
try {
query().collect {
send(
Resource.error(
data = null,
message = e.localizedMessage ?: "Error $it"
)
)
}
} catch (e: Exception) {
send(Resource.error(data = null, message = e.localizedMessage ?: "Error"))
}
}
} else {
try {
query().collect { send(Resource.success(it)) }
} catch (e: Exception) {
send(Resource.error(data = null, message = e.localizedMessage ?: "Error"))
}
}
}ViewBinding Delegate
/** Activity binding delegate, may be used since onCreate up to onDestroy (inclusive) */
inline fun <T : ViewBinding> AppCompatActivity.viewBinding(crossinline factory: (LayoutInflater) -> T) =
lazy(LazyThreadSafetyMode.NONE) {
factory(layoutInflater)
}
/** Fragment binding delegate, may be used since onViewCreated up to onDestroyView (inclusive) */
fun <T : ViewBinding> Fragment.viewBinding(factory: (View) -> T): ReadOnlyProperty<Fragment, T> =
object : ReadOnlyProperty<Fragment, T>, DefaultLifecycleObserver {
private var binding: T? = null
override fun getValue(thisRef: Fragment, property: KProperty<*>): T =
binding ?: factory(requireView()).also {
// if binding is accessed after Lifecycle is DESTROYED, create new instance, but don't cache it
if (viewLifecycleOwner.lifecycle.currentState.isAtLeast(Lifecycle.State.INITIALIZED)) {
viewLifecycleOwner.lifecycle.addObserver(this)
binding = it
}
}
override fun onDestroy(owner: LifecycleOwner) {
binding = null
}
}
/** Binding delegate for DialogFragments implementing onCreateDialog (like Activities, they don't
* have a separate view lifecycle), may be used since onCreateDialog up to onDestroy (inclusive) */
inline fun <T : ViewBinding> DialogFragment.viewBinding(crossinline factory: (LayoutInflater) -> T) =
lazy(LazyThreadSafetyMode.NONE) {
factory(layoutInflater)
}
/** Not really a delegate, just a small helper for RecyclerView.ViewHolders */
inline fun <T : ViewBinding> ViewGroup.viewBinding(factory: (LayoutInflater, ViewGroup, Boolean) -> T) =
factory(LayoutInflater.from(context), this, false)Network Resource
sealed class Resource<T> {
data class Success<T>(val data: T) : Resource<T>()
data class Error<T>(val exception: Throwable) : Resource<T>()
data class Loading<T>(val data: T? = null) : Resource<T>()
fun <R> mapData(transform: (T) -> R): Resource<R> = when (this) {
is Success -> Success(
transform(data)
)
is Error -> Error(
exception
)
is Loading -> Loading(
data?.let { transform(it) }
)
}
}
sealed class Status {
object Content : Status()
data class Error(val exception: Throwable) : Status()
object Loading : Status()
object ContentWithLoading : Status()
}
class ResourceError(
@StringRes
val actionText: Int,
@StringRes
val errorTitle: Int,
@StringRes
val errorDesc: Int
)
class NoContentListingException : Exception()
object ErrorResolver {
fun resolve(throwable: Throwable): ResourceError {
return when (throwable) {
is NoContentListingException -> ResourceError(
actionText = R.string.no_content_error_action,
errorDesc = R.string.no_content_error_message,
errorTitle = R.string.default_error_title
)
else ->
ResourceError(
actionText = R.string.common_action_retry,
errorDesc = R.string.default_error_message,
errorTitle = R.string.default_error_title
)
}
}
}
class StatusViewState(private val status: Status) {
fun getStateInfo(context: Context): StateLayout.StateInfo {
return when (status) {
Status.Content -> StateLayout.provideContentStateInfo()
is Status.Error -> provideErrorState(context, status.exception)
Status.Loading -> StateLayout.provideLoadingStateInfo()
Status.ContentWithLoading -> StateLayout.provideLoadingWithContentStateInfo()
}
}
private fun provideErrorState(context: Context, exception: Throwable): StateLayout.StateInfo {
val resourceError = ErrorResolver.resolve(exception)
return StateLayout.StateInfo(
infoImage = R.drawable.state_info,
infoTitle = context.getString(resourceError.errorTitle),
infoMessage = context.getString(resourceError.errorDesc),
infoButtonText = context.getString(resourceError.actionText),
state = StateLayout.State.ERROR
)
}
}Last updated