marenovakovic

package com.marko.presentation.coins

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import com.marko.domain.entities.CoinEntity
import com.marko.domain.result.Result
import com.marko.domain.usecase.GetCoins
import com.marko.domain.usecase.invoke
import com.marko.presentation.base.BaseViewModel
import com.marko.presentation.entities.Coin

marenovakovic

package com.marko.domain.usecase

import com.marko.domain.CoroutineDispatchers
import com.marko.domain.coins.CoinsRepository
import com.marko.domain.entities.CoinEntity
import javax.inject.Inject

class GetCoins @Inject constructor(
	coroutineDispatchers: CoroutineDispatchers,
	private val coinsRepository: CoinsRepository

marenovakovic

package com.marko.domain.usecase

import com.marko.domain.CoroutineDispatchers
import com.marko.domain.result.Result
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.channels.ReceiveChannel
import kotlinx.coroutines.withContext

abstract class UseCase<in P, R>(private val coroutineDispatchers: CoroutineDispatchers) {

marenovakovic

package com.marko.presentation.base

import androidx.lifecycle.ViewModel
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlin.coroutines.CoroutineContext

abstract class BaseViewModel : ViewModel(), CoroutineScope {

marenovakovic

sealed class NetworkStatus {
    object Available : NetworkStatus()
    object Unavailable : NetworkStatus()
}

marenovakovic

class NetworkStatusTracker(context: Context) {
    private val connectivityManager =
        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    
    init {
        val networkStatusCallback = object : ConnectivityManager.NetworkCallback() {
            override fun onUnavailable() = println("onUnavailable")
            override fun onAvailable(network: Network) = println("onAvailable")
            override fun onLost(network: Network) = println("onLost")
        }

marenovakovic

class NetworkStatusTracker(context: Context) {
    private val connectivityManager =
        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
}

marenovakovic

class NetworkStatusTracker(context: Context) {
    
    private val connectivityManager =
        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

    val networkStatus = callbackFlow<NetworkStatus> {
        val networkStatusCallback = object : ConnectivityManager.NetworkCallback() {
            override fun onUnavailable() {
                offer(NetworkStatus.Unavailable)
            }

marenovakovic

sealed class MyState {
    object Fetched : MyState()
    object Error : MyState()
}

class NetworkStatusViewModel(
    networkStatusTracker: NetworkStatusTracker,
) : ViewModel() {

    val state =

marenovakovic

class MainActivity : AppCompatActivity() {

    private val viewModel: NetworkStatusViewModel by lazy {
        ViewModelProvider(
            this,
            object : ViewModelProvider.Factory {
                override fun <T : ViewModel?> create(modelClass: Class<T>): T {
                    val networkStatusTracker = NetworkStatusTracker(this@MainActivity)
                    return NetworkStatusViewModel(networkStatusTracker) as T
                }