Background
----------

I'm creating some SDK library, and I want to offer some liveData as a returned object for a function, that will allow to monitor data on the DB.

The problem
-----------

I don't want to reveal the real objects from the DB and their fields (like the ID), and so I wanted to use a transformation of them.

So, suppose I have this liveData from the DB:

```
val dbLiveData = Database.getInstance(context).getSomeDao().getAllAsLiveData()

```

What I did to get the liveData to provide outside, is:

```
val resultLiveData: LiveData<List<SomeClass>> = Transformations.map(
    dbLiveData) { data ->
    data.map { SomeClass(it) }
}

```

This works very well.

However, the problem is that the first line (to get `dbLiveData`) should work on a background thread, as the DB might need to initialize/update, and yet the `Transformations.map` part is supposed to be on the UI thread (including the mapping itself, sadly).

What I've tried
---------------

This lead me to this kind of ugly solution, of having a listener to a live data, to be run on the UI thread:

```
@UiThread
fun getAsLiveData(someContext: Context,listener: OnLiveDataReadyListener) {
    val context = someContext.applicationContext ?: someContext
    val handler = Handler(Looper.getMainLooper())
    Executors.storageExecutor.execute {
        val dbLiveData = Database.getInstance(context).getSomeDao().getAllAsLiveData()
        handler.post {
            val resultLiveData: LiveData<List<SomeClass>> = Transformations.map(
                dbLiveData) { data ->
                data.map { SomeClass(it) }
            }
            listener.onLiveDataReadyListener(resultLiveData)
        }
    }
}

```

Note: I use simple threading solution because it's an SDK, so I wanted to avoid importing libraries when possible. Plus it's quite a simple case anyway.

The question
------------

Is there some way to offer the transformed live data on the UI thread even when it's all not prepared yet, without any listener ?

Meaning some kind of "lazy" initialization of the transformed live data. One that only when some observer is active, it will initialize/update the DB and start the real fetching&conversion (both in the background thread, of course).