Wottrich

SwipeToDeleteItem(
    onDeleteItem = { onDeleteTask(task) },
    onBackground = { state -> BackgroundSwipeToDeleteItem(state) },
    onDismissContent = {
        TaskItem(
            task = task,
            showDeleteItem = showDeleteItem,
            onCheckChange = onCheckChange,
            onDeleteTask = onDeleteTask
        )

Wottrich

/**
 * Used as a wrapper for data that is exposed via a LiveData that represents an event.
 */
open class Event<out T>(private val content: T) {

    @Suppress("MemberVisibilityCanBePrivate")
    var hasBeenHandled = false
        private set // Allow external read but not write

    /**

Wottrich

import androidx.annotation.MainThread
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.Observer
import java.util.concurrent.atomic.AtomicBoolean

class SingleLiveEvent<T> : MutableLiveData<T> {

    constructor() : super()
    constructor(initialValue: T) : super(initialValue)

Wottrich

class LauncherActivity : AppCompactActivity() {

    private val inAppUpdateViewModel by viewModel<InAppUpdateViewModel>()
    private val appUpdateInfoProvider by inject<AppUpdateInfoWrapper>()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        //Essa feature não funciona em DEBUG, 
      	//então precisamos fazer isso para conseguir utilizar o ambiente de dev
	if (BuildConfig.DEBUG) {

Wottrich

val playCoreModule = module {
    single { AppUpdateInfoWrapper(androidContext()) }
    single<AppUpdateInfoDefinitions> { AppUpdateInfoDefinitionsImpl() }
    factory<InAppUpdateStatusIterator> { InAppUpdateStatusIteratorImpl(get(), get()) }
    viewModel { InAppUpdateViewModel(get()) }
}

Wottrich

class InAppUpdateViewModel(
    private val inAppUpdateStatusIterator: InAppUpdateStatusIterator
) : ViewModel() {

    private val _inAppUpdateAction = MediatorLiveData<Resource<InAppUpdateStatus>>()

    fun getAppUpdateActionLiveData(): LiveData<Resource<InAppUpdateStatus>> {
        if (_inAppUpdateAction.value == null) {
            checkAvailableVersion()
        }

Wottrich

class AppUpdateInfoWrapper(context: Context) {

    private val appUpdateManager: AppUpdateManager = AppUpdateManagerFactory.create(context)
    private var appUpdateInfo: AppUpdateInfo? = null

    suspend fun getAppUpdateInfo(): Resource<AppUpdatePertinentInfo> {
        //...
    }

    @Throws(IllegalStateException::class)

Wottrich

class InAppUpdateStatusIteratorImpl(
    appUpdateInfoWrapper: AppUpdateInfoWrapper,
    definitions: AppUpdateInfoDefinitions
) : InAppUpdateStatusIterator(appUpdateInfoWrapper, definitions) {

   override fun getSuccessInAppUpdateStatus(definitions: AppUpdateInfoDefinitions): InAppUpdateStatus {
       return when {
           //Utilizamos shouldNotifyUpdateVersion para saber se precisamos notificar uma atualização 
           definitions.shouldNotifyUpdateVersion() -> getAvailableVersionUpdate(definitions)
           else -> InAppUpdateStatus.NoNeedUpdate

Wottrich

abstract class InAppUpdateStatusIterator(
    private val appUpdateInfoWrapper: AppUpdateInfoWrapper,
    private val definitions: AppUpdateInfoDefinitions
) {

    suspend fun getInAppUpdateStatus(): Resource<InAppUpdateStatus> {
        val resourceDefinitions = appUpdateInfoWrapper.getAppUpdateInfo().mapNotNull { appUpdatePertinentInfo ->
            definitions.apply {
                setupAppUpdatePertinentInfo(appUpdatePertinentInfo)
            }

Wottrich

class AppUpdateInfoDefinitionsImpl : AppUpdateInfoDefinitions() {

    override fun shouldNotifyUpdateVersion() =
        (hasUpdateAvailable() && !isNoNotifyUpdateVersion())

    private fun hasUpdateAvailable() =                  /*UpdateAvailability.UPDATE_AVAILABLE*/
        appUpdatePertinentInfo?.updateAvailability() == appUpdatePertinentInfo?.updateAvailableValue
        
    private fun isNoNotifyUpdateVersion() =
        appUpdatePertinentInfo?.updatePriority() == NO_NOTIFY