Retrofit does not support Flow. So if I need to merge concurrent requests using 'flatMapMerge' what ...

# coroutines

[ahulyk]

Retrofit does not support Flow. So if I need to merge concurrent requests using 'flatMapMerge' what is the right way to do this?

[Dominaezzz]

You don't need Flow for this.

[Dominaezzz]

You just need List<Deferred<T>>.awaitAll().

[Dominaezzz]

You can do something like,

val requests = listOf(
    async { api.getUser() },
    async { api.getComments() }
)
val responses = requests.awaitAll()

[louiscad]

Also, make sure to wrap these in a local coroutineScope { … } and handle errors around it.

[ahulyk]

Flow has great API and I need ConflatedBroadcastChannel for some reasons. What i did:

flowOf(StreamType.values().asFlow()
                        .flatMapMerge(10) { stream ->
                            flowOf(stream to async { apiService.getCurrentInfo(stream.path) })
                        }
                        .map { Pair(it.first, it.second.await()) }
                        .fold(mutableMapOf(), { map: MutableMap<StreamType, ContentMetadataDto>, pair: Pair<StreamType, ContentMetadataDto> ->
                            map.apply { put(pair.first, pair.second) }
                        }))
                        .onEach { map ->
                            contentMetadata.send(map)
                        }
                        .catch {
                            emit(StreamType.values().map { it to ContentMetadataDto.NO_DATA }.toMap(mutableMapOf()))
                        }
                        .collect {
                            contentMetadata.send(it)
                        }

[Dominaezzz]

I think you can replace the first flowOf with

StreamType.values().associateWith { stream -> async { apiService.getCurrentInfo(stream.path) } }.mapValues { it.second.await() }

(I'm not sure, it's hard to read).

[Dominaezzz]

flowOf(StreamType.values().asFlow()
    .flatMapMerge(10) { stream ->
        flowOf(stream to async { apiService.getCurrentInfo(stream.path) })
    }
    .associate { Pair(it.first, it.second.await()) }))
    .onEach { map ->
         contentMetadata.send(map)
    }
    .catch {
         emit(StreamType.values().associateWith { ContentMetadataDto.NO_DATA }
    }
    .collect {
        contentMetadata.send(it)
    }

[ahulyk]

yeap, but this works fine - thank you)

[Dico]

Also you can use associateWith