What is the difference between emit and emitSource with LiveData ? ( as in REAL time USE-CASE )

As you mentioned, I don't think it solves anything in your stated problem, but I usually use it like this:

If I want to show cached data to the user from the db while I get fresh data from remote, with only emit it would look something like this:

liveData{
    emit(db.getData())
    val latest = webService.getLatestData()
    db.insert(latest)
    emit(db.getData())
}

But with emitSource it looks like this:

liveData{
    emitSource(db.getData())
    val latest = webService.getLatestData()
    db.insert(latest)
}

Don't need to call emit again since the liveData already have a source.

From what I understand emit(someValue) is similar to myData.value = someValue whereas emitSource(someLiveValue) is similar to myData = someLiveValue. This means that you can use emit whenever you want to set a value once, but if you want to connect your live data to another live data value you use emit source. An example would be emitting live data from a call to room (using emitSource(someLiveData)) then performing a network query and emitting an error (using emit(someError)).

I found a real use-case which depicts the use of emitSource over emit which I have used many times in production now. :D The use-case:

Suppose u have some user data (User which has some fields like userId, userName ) returned by some ApiService.

The User Model:

data class User(var userId: String, var userName: String)

The userName is required by the view/activity to paint the UI. And the userId is used to make another API call which returns the UserData like profileImage , emailId.

The UserData Model:

data class UserData(var profileImage: String, var emailId: String)

This can be achieved internally using emitSource by wiring the two liveData in the ViewModel like:

User liveData -

val userLiveData: LiveData<User> = liveData {
   emit(service.getUser())
}

UserData liveData -

val userDataLiveData: LiveData<UserData> = liveData {
   emitSource(userLiveData.switchMap {
       liveData {
           emit(service.getUserData(it.userId))
       }
   })
}

So, in the activity / view one can ONLY call getUser() and the getUserData(userId) will be automatically triggered internally via switchMap.

You need not manually call the getUserData(id) by passing the id.

This is a simple example, imagine there is a chain of dependent-tasks which needs to be executed one after the other, each of which is observed in the activity. emitSource comes in handy

With emitSource() you can not only emit a single value, but attach your LiveData to another LiveData and start emitting from it. Anyway, each emit() or emitSource() call will remove the previously added source.

var someData = liveData {
    val cachedData = dataRepository.getCachedData()
    emit(cachedData)

    val actualData = dataRepository.getData()
    emitSource(actualData)
}

The activity that’s observing the someData object, will quickly receive the cached data on the device and update the UI. Then, the LiveData itself will take care of making the network request and replace the cached data with a new live stream of data, that will eventually trigger the Activity observer and update the UI with the updated info.

Source: Exploring new Coroutines and Lifecycle Architectural Components integration on Android

I will like share a example where we use "emit" and "emitsource" both to communicate from UI -> View Model -> Repository

Repository layer we use emit to send the values downstream :

suspend fun fetchNews(): Flow<Result<List<Article>>> {
    val queryPath = QueryPath("tata", apikey = AppConstant.API_KEY)
    return flow {
        emit(
            Result.success(
                openNewsAPI.getResponse(
                    "everything",
                    queryPath.searchTitle,
                    queryPath.page,
                    queryPath.apikey
                ).articles
            )
        )
    }.catch { exception ->
        emit(Result.failure(RuntimeException(exception.message)));
    }
}

ViewModel layer we use emitsource to pass the live data object to UI for subscriptions

val loader = MutableLiveData<Boolean>()

val newsListLiveData = liveData<Result<List<Article>>> {
    loader.postValue(true)
    emitSource(newRepo.fetchNews()
        .onEach {
            loader.postValue(false)
        }
        .asLiveData())
}

UI Layer - we observe the live data emitted by emitsource

 viewModel.newsListLiveData.observe(viewLifecycleOwner, { result ->
        val listArticle = result.getOrNull()
        if (result.isSuccess && listArticle != null) {
            setupList(binding.list, listArticle)
        } else {
            Toast.makeText(
                appContext,
                result.exceptionOrNull()?.message + "Error",
                Toast.LENGTH_LONG
            ).show()
        }
    })

We convert Flow observable to LiveData in viewModel