LiveData Transformations.map() con múltiples argumentos

Queremos enseñarte la mejor información que hallamos por todo internet. Nuestro deseo es que te resulte de ayuda y si puedes compartir alguna mejora puedes hacerlo..

Solución:

ACTUALIZAR

Basado en mi respuesta anterior, creé una forma genérica en la que podemos agregar tantos datos en vivo como queramos.

import androidx.lifecycle.LiveData
import androidx.lifecycle.MediatorLiveData

/**
 * CombinedLiveData is a helper class to combine results from multiple LiveData sources.
 * @param liveDatas Variable number of LiveData arguments.
 * @param combine   Function reference that will be used to combine all LiveData data.
 * @param R         The type of data returned after combining all LiveData data.
 * Usage:
 * CombinedLiveData(
 *     getLiveData1(),
 *     getLiveData2(),
 *     ... ,
 *     getLiveDataN()
 * )  datas: List ->
 *     // Use datas[0], datas[1], ..., datas[N] to return a SomeType value
 * 
 */
class CombinedLiveData(vararg liveDatas: LiveData<*>,
                          private val combine: (datas: List) -> R) : MediatorLiveData() 

    private val datas: MutableList = MutableList(liveDatas.size)  null 

    init 
        for(i in liveDatas.indices)
            super.addSource(liveDatas[i]) 
                datas[i] = it
                value = combine(datas)
            
        
    

VIEJO

Al final usé MediatorLiveData para lograr el mismo objetivo.

fun mapBasketTotal(source1: LiveData>, source2: LiveData): LiveData 
    val result = MediatorLiveData()
    uiThread 
        var subtotal: Int = 0
        var shipPrice: Int = 0
        fun sumAndFormat() result.value = format(subtotal + shipPrice)
        result.addSource(source1,  items ->
            if (items != null) 
                subtotal = getSubtotalPrice(items)
                sumAndFormat()
            
        )
        result.addSource(source2,  price ->
            if (price != null) 
                shipPrice = price
                sumAndFormat()
            
        )
    
    return result

Puedes usar cambiarMapa() para tal caso, porque devuelve el objeto LiveData que puede ser Transformaciones.map()

En el siguiente código obtengo la suma de la cantidad final de dos objetos hacia adelanteSeleccionarPresupuesto y volverSeleccionarPresupuesto

finalAmount = Transformations.switchMap(onwardSelectQuote)  data1 ->
            Transformations.map(returnSelectQuote)  data2 -> ViewUtils.formatRupee((data1.finalAmount!!.toFloat() + data2.finalAmount!!.toFloat()).toString())
            
        

Se me ocurre otra solución.

class PairLiveData(first: LiveData, second: LiveData) : MediatorLiveData>() 
    init 
        addSource(first)  value = it to second.value 
        addSource(second)  value = first.value to it 
    


class TripleLiveData(first: LiveData, second: LiveData, third: LiveData) : MediatorLiveData>() 
    init 
        addSource(first)  value = Triple(it, second.value, third.value) 
        addSource(second)  value = Triple(first.value, it, third.value) 
        addSource(third)  value = Triple(first.value, second.value, it) 
    


fun  LiveData.combine(other: LiveData): PairLiveData 
    return PairLiveData(this, other)


fun  LiveData.combine(second: LiveData, third: LiveData): TripleLiveData 
    return TripleLiveData(this, second, third)

val totalLiveData = Transformations.map(itemsLiveData.combine(shipPriceLiveData)) 
    // Do your stuff