An event wrapper for data that is exposed via a LiveData that represents an event.

Event.kt

/**
 * 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) {

    var hasBeenHandled = false
        private set // Allow external read but not write

    /**
     * Returns the content and prevents its use again.
     */
    fun getContentIfNotHandled(): T? {
        return if (hasBeenHandled) {
            null
        } else {
            hasBeenHandled = true
            content
        }
    }

    /**
     * Returns the content, even if it's already been handled.
     */
    fun peekContent(): T = content
}

That looks nearly like my latest solution. However, I don't use a special EventObserver, since a Kotlin extension function can do the job:

class Event<out T>(private val content: T) {
    private val consumedScopes = HashSet<String>()

    fun isConsumed(scope: String = "") = consumedScopes.contains(scope)

    @MainThread
    fun consume(scope: String = ""): T? {
        return if (isConsumed(scope)) {
            null
        } else {
            consumedScopes.add(scope)
            content
        }
    }

    fun peek(): T = content
}

fun <T> LiveData<Event<T>>.observeEvent(lifecycleOwner: LifecycleOwner, scope: String = "", observer: Observer<T>) {
    observe(lifecycleOwner) { event ->
        event?.consume(scope)?.let { observer.onChanged(it) }
    }
}

// How to use it
myObservable.observeEvent { ... }
myObservable.observeEvent("specialScope") { ... }

This is so concise.

In Kotlin, passing events to a single observer is also possible with Channel.receiveAsFlow() and lifecycle-aware collector. Advantages:

1. Can queue multiple events while observer is inactive (configuration change, app in background, fragment in back stack), with customizable buffer size and onBufferOverflow strategy
2. Optionally supports null values
3. No need to wrap data in Event

That looks nearly like my latest solution. However, I don't use a special EventObserver, since a Kotlin extension function can do the job:

class Event<out T>(private val content: T) {
    private val consumedScopes = HashSet<String>()

Adding more syntactic sugar to choirwire's contribution

class Event<out T>(private val content: T) {
    private val consumedScopes by lazy { HashSet<String>() }

    fun isConsumed(scope: String = "") = scope in consumedScopes

    @MainThread
    fun consume(scope: String = ""): T? {
        return content.takeIf { !isConsumed(scope) }?.also { consumedScopes.add(scope) }
    }

    fun peek(): T = content
}