Generic grpc requests in kotlin

Question

class API {

    val nonBlockingStub: HealthcareAPIGrpc.HealthcareAPIStub //Generated Java GRPC Stub

    suspend fun exampleRequest(params: Params) : ReturnedResult = suspendCancellableCoroutine { routine ->
        val obs = object : StreamObserver<ReturnedResult> {
            override fun onNext(value: ReturnedResult?) {
                routine.resume(value!!)
            }

            override fun onError(t: Throwable?) {
                routine.resumeWithException(t!!)
            }

            override fun onCompleted() {
            }
        }
        nonBlockingStub.exampleRequest(params, obs)
    }
}

So I'm working on an Kotlin android application, which has a grpc client generated in java. Recently I had to move all the API requests to use kotlin coroutines. For every request I have to copy-paste this exampleRequest function.

I am curious if it's possible to make a generic function which does this, takes some params and calls the underlying stub function

Answer 1

Ideally there should be a stub generator that generates the appropriate calls as suspend / Flow methods, but you can still abstract much of the conversion with a dedicated helper function:

fun <T> grpcFlow(
    @BuilderInference block: suspend (StreamObserver<T>) -> Unit
): Flow<T> = callbackFlow {
    // Use ClientCallStreamObserver to support cancellation
    val observer = object : ClientCallStreamObserver<T>() {
        override fun onNext(value: T) {
            sendBlocking(value)
        }

        override fun onError(t: Throwable) {
            cancel(CancellationException("GRPC Error", t))
        }

        override fun onCompleted() = channel.close()
    }

    block(observer)

    awaitClose { 
        observer.cancel("flow cancellation", null)
    }
}

Then your API simply becomes:

class API {
    val nonBlockingStub: HealthcareAPIGrpc.HealthcareAPIStub

    suspend fun exampleRequest(params: Params) = grpcFlow {
        // @BuilderInference should ensure the correct type is used
        nonBlockingStub.exampleRequest(params, it)
    }.single() // Since we only expect a single response value.

    // And for returns (stream ReturnedResult)
    suspend fun exampleStreamingRequest(params: Params) = gcpcFlow {
        nonBlockingStub.exampleStreamingRequest(params, it)
    } // Flow<ReturnedResult>

}