test

example controller

class HomeController private constructor(
    dispatcher: DispatcherProvider,
    private val lifecycleOwner: LifecycleOwner,
    private val view: HomeContract.View,
    private val viewModel: HomeContract.ViewModel,
    private val prefs: PlumPrefs
) : HomeContract.Controller, BaseController(dispatcher), CoroutineScope {

    init {
        jobTracker = Job()
    }

    override val coroutineContext: CoroutineContext
        get() = dispatcher.provideUIContext() + jobTracker

    class Builder {
        private lateinit var lifecycleOwner: LifecycleOwner
        private lateinit var view: HomeContract.View
        private lateinit var viewModel: HomeContract.ViewModel
        private lateinit var appPrefs: PlumPrefs
        private lateinit var dispatcher: DispatcherProvider

        fun dispatcher(dispatcher: DispatcherProvider) = apply { this.dispatcher = dispatcher }
        fun view(view: HomeContract.View) = apply { this.view = view }
        fun viewModel(viewModel: HomeContract.ViewModel) = apply { this.viewModel = viewModel }
        fun lifecycleOwner(lifecycleOwner: LifecycleOwner) = apply { this.lifecycleOwner = lifecycleOwner }
        fun appPrefs(appPrefs: PlumPrefs) = apply { this.appPrefs = appPrefs }
        fun build() = HomeController(dispatcher, lifecycleOwner, view, viewModel, appPrefs)
    }


    override fun onEvent(event: HomeEvents) = when (event) {
        HomeEvents.OnCreate -> onCreate()
        HomeEvents.OnDestory -> onDestroy()
    }

    private fun onCreate() {
        lifecycleOwner.lifecycle.addObserver(this)
        view.attachEvents()
        checkForUpdate()
    }

    private fun checkForUpdate() {
        val lastTime = prefs.lastSync
        val today = Calendar.getInstance().get(Calendar.DATE)

        if (today != lastTime) {
            view.onUpdatingFromRemote()
            viewModel.getRemotePlumPics()
                .observe(lifecycleOwner, androidx.lifecycle.Observer { result ->
                when (result) {
                    is PlumResult.Success -> onRemoteData(result.value)
                    is PlumResult.Error -> onError(result.error)
                }
            })
        }
    }

    private fun onError(error: Exception) {
        view.onError(error.localizedMessage)
        Timber.e(error)
    }

    private fun onRemoteData(value: PlumImage) {
        val plumItem = value.urls.map {
            PlumItem(
                url = "https:$it",
                downloads = Random().nextInt(1000).toLong(),
                likes = Random().nextInt(1000).toLong(),
                dateCreated = Calendar.getInstance().timeInMillis
            )
        }
        viewModel.saveToLocalDb(plumItem).observe(lifecycleOwner, androidx.lifecycle.Observer { result ->
            when (result) {
                is PlumResult.Success -> {
                    view.onUpdateSuccessful()
                    prefs.lastSync = Calendar.getInstance().get(Calendar.DATE)
                }
                is PlumResult.Error -> onError(result.error)
            }
        })
    }



    override fun onDestroy() {
        lifecycleOwner.lifecycle.removeObserver(this)
        //release any rxObservables
        coroutineContext.cancel()

    }



}