wire-grpc-client/com.squareup.wire/GrpcClientStreamingCall

GrpcClientStreamingCall

interface GrpcClientStreamingCall<S : Any, R : Any>

A single streaming call to a remote server.

This class handles a client streaming call . The send channel or message sink accept zero or more messages. The returned deferred repsonse will ensure that the corresponding send channel or message sink is closed before returning the single response message.

A gRPC call cannot be executed twice.

gRPC calls can be suspending or blocking. Use whichever mechanism works at your call site: the bytes transmitted on the network are the same.

Properties

method

abstract val method: GrpcMethod<S, R>

The method invoked by this call.

requestMetadata

abstract var requestMetadata: Map<String, String>

A map containing request metadata. This is initially empty; it can be assigned to any other map of metadata before the call is executed. It is an error to set this value after the call is executed.

responseMetadata

abstract val responseMetadata: Map<String, String>?

A map containing response metadata. This is null until the call has executed, at which point it will be non-null if the call completed successfully. It may also be non-null in failure cases if the failure was not a problem of connectivity. For example, if the gRPC call fails with an HTTP 503 error, response metadata will be present.

timeout

abstract val timeout: Timeout

Configures how long the call can take to complete before it is automatically canceled. The timeout applies to the full set of messages transmitted. For long-running streams you must configure a sufficiently long timeout.

Functions

cancel

abstract fun cancel()

Attempts to cancel the call. This function is safe to call concurrently with execution. When canceled, execution fails with an immediate IOException rather than waiting to complete normally.

clientStream

inline suspend fun <S : Any, R : Any> GrpcClientStreamingCall<S, R>.clientStream(scope: CoroutineScope, crossinline block: suspend SendChannel<S>.() -> Unit): R

Executes a Client Streaming RPC call In this use case, all outbound request messages are sent before the inbound response message.

clientStreamBlocking

inline fun <S : Any, R : Any> GrpcClientStreamingCall<S, R>.clientStreamBlocking(crossinline block: MessageSink<S>.() -> Unit): R

Executes a blocking Client Streaming RPC call In this use case, all outbound request messages are sent before the inbound response message.

clone

abstract fun clone(): GrpcClientStreamingCall<S, R>

Create a new, identical gRPC call to this one which can be enqueued or executed even if this call has already been.

executeBlocking

abstract fun executeBlocking(): Pair<MessageSink<S>, GrpcDeferredResponse<R>>

Enqueues this call for execution and returns a stream to send call's messages and a deferred response that will ensure the sender is closed and return the single response. Reads and writes on the returned streams are blocking.

executeIn

abstract fun executeIn(scope: CoroutineScope): Pair<SendChannel<S>, Deferred<R>>

Enqueues this call for execution and returns a channel to send the call's messages and a deferred response that will ensure the sender is closed and return the single response. This uses the Dispatchers.IO to transmit outbound messages.

isCanceled

abstract fun isCanceled(): Boolean

True if cancel was called.

isExecuted

abstract fun isExecuted(): Boolean

Returns true if executeIn or executeBlocking was called. It is an error to execute a call more than once.