| /* |
| * |
| * Copyright 2015 gRPC authors. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| #import <Foundation/Foundation.h> |
| |
| // import legacy header for compatibility with users using the ProtoRPC interface |
| #import "ProtoRPCLegacy.h" |
| |
| #import "ProtoMethod.h" |
| |
| NS_ASSUME_NONNULL_BEGIN |
| |
| @class GRPCRequestOptions; |
| @class GRPCCallOptions; |
| @class GPBMessage; |
| |
| /** An object can implement this protocol to receive responses from server from a call. */ |
| @protocol GRPCProtoResponseHandler <NSObject> |
| |
| @required |
| |
| /** |
| * All the responses must be issued to a user-provided dispatch queue. This property specifies the |
| * dispatch queue to be used for issuing the notifications. |
| */ |
| @property(atomic, readonly) dispatch_queue_t dispatchQueue; |
| |
| @optional |
| |
| /** |
| * Issued when initial metadata is received from the server. |
| */ |
| - (void)didReceiveInitialMetadata:(nullable NSDictionary *)initialMetadata; |
| |
| /** |
| * Issued when a message is received from the server. The message is the deserialized proto object. |
| */ |
| - (void)didReceiveProtoMessage:(nullable GPBMessage *)message; |
| |
| /** |
| * Issued when a call finished. If the call finished successfully, \p error is nil and \p |
| * trailingMetadata consists any trailing metadata received from the server. Otherwise, \p error |
| * is non-nil and contains the corresponding error information, including gRPC error codes and |
| * error descriptions. |
| */ |
| - (void)didCloseWithTrailingMetadata:(nullable NSDictionary *)trailingMetadata |
| error:(nullable NSError *)error; |
| |
| /** |
| * Issued when flow control is enabled for the call and a message (written with writeMessage: method |
| * of GRPCStreamingProtoCall or the initializer of GRPCUnaryProtoCall) is passed to gRPC core with |
| * SEND_MESSAGE operation. |
| */ |
| - (void)didWriteMessage; |
| |
| @end |
| |
| /** |
| * A convenience class of objects that act as response handlers of calls. Issues |
| * response to a single handler when the response is completed. |
| * |
| * The object is stateful and should not be reused for multiple calls. If multiple calls share the |
| * same response handling logic, create separate GRPCUnaryResponseHandler objects for each call. |
| */ |
| @interface GRPCUnaryResponseHandler<ResponseType> : NSObject <GRPCProtoResponseHandler> |
| |
| /** |
| * Creates a responsehandler object with a unary call handler. |
| * |
| * responseHandler: The unary handler to be called when the call is completed. |
| * responseDispatchQueue: the dispatch queue on which the response handler |
| * should be issued. If it's nil, the handler will use the main queue. |
| */ |
| - (nullable instancetype)initWithResponseHandler:(void (^)(ResponseType, NSError *))handler |
| responseDispatchQueue:(nullable dispatch_queue_t)dispatchQueue; |
| |
| /** Response headers received during the call. */ |
| @property(readonly, nullable) NSDictionary *responseHeaders; |
| |
| /** Response trailers received during the call. */ |
| @property(readonly, nullable) NSDictionary *responseTrailers; |
| |
| @end |
| |
| /** A unary-request RPC call with Protobuf. */ |
| @interface GRPCUnaryProtoCall : NSObject |
| |
| - (instancetype)init NS_UNAVAILABLE; |
| |
| + (instancetype)new NS_UNAVAILABLE; |
| |
| /** |
| * Users should not use this initializer directly. Call objects will be created, initialized, and |
| * returned to users by methods of the generated service. |
| */ |
| - (nullable instancetype)initWithRequestOptions:(GRPCRequestOptions *)requestOptions |
| message:(GPBMessage *)message |
| responseHandler:(id<GRPCProtoResponseHandler>)handler |
| callOptions:(nullable GRPCCallOptions *)callOptions |
| responseClass:(Class)responseClass NS_DESIGNATED_INITIALIZER; |
| |
| /** |
| * Start the call. This function must only be called once for each instance. |
| */ |
| - (void)start; |
| |
| /** |
| * Cancel the request of this call at best effort. It attempts to notify the server that the RPC |
| * should be cancelled, and issue didCloseWithTrailingMetadata:error: callback with error code |
| * CANCELED if no other error code has already been issued. |
| */ |
| - (void)cancel; |
| |
| @end |
| |
| /** A client-streaming RPC call with Protobuf. */ |
| @interface GRPCStreamingProtoCall : NSObject |
| |
| - (instancetype)init NS_UNAVAILABLE; |
| |
| + (instancetype)new NS_UNAVAILABLE; |
| |
| /** |
| * Users should not use this initializer directly. Call objects will be created, initialized, and |
| * returned to users by methods of the generated service. |
| */ |
| - (nullable instancetype)initWithRequestOptions:(GRPCRequestOptions *)requestOptions |
| responseHandler:(id<GRPCProtoResponseHandler>)handler |
| callOptions:(nullable GRPCCallOptions *)callOptions |
| responseClass:(Class)responseClass NS_DESIGNATED_INITIALIZER; |
| |
| /** |
| * Start the call. This function must only be called once for each instance. |
| */ |
| - (void)start; |
| |
| /** |
| * Cancel the request of this call at best effort. It attempts to notify the server that the RPC |
| * should be cancelled, and issue didCloseWithTrailingMetadata:error: callback with error code |
| * CANCELED if no other error code has already been issued. |
| */ |
| - (void)cancel; |
| |
| /** |
| * Send a message to the server. The message should be a Protobuf message which will be serialized |
| * internally. |
| */ |
| - (void)writeMessage:(GPBMessage *)message; |
| |
| /** |
| * Finish the RPC request and half-close the call. The server may still send messages and/or |
| * trailers to the client. |
| */ |
| - (void)finish; |
| |
| /** |
| * Tell gRPC to receive another message. |
| * |
| * This method should only be used when flow control is enabled. If flow control is enabled, gRPC |
| * will only receive additional messages after the user indicates so by using either |
| * receiveNextMessage: or receiveNextMessages: methods. If flow control is not enabled, messages |
| * will be automatically received after the previous one is delivered. |
| */ |
| - (void)receiveNextMessage; |
| |
| /** |
| * Tell gRPC to receive another N message. |
| * |
| * This method should only be used when flow control is enabled. If flow control is enabled, the |
| * messages received from the server are buffered in gRPC until the user want to receive the next |
| * message. If flow control is not enabled, messages will be automatically received after the |
| * previous one is delivered. |
| */ |
| - (void)receiveNextMessages:(NSUInteger)numberOfMessages; |
| |
| @end |
| |
| NS_ASSUME_NONNULL_END |