syntax = "proto3";
package client.guide; // enclosing namespace

message Request {
    int64 time = 1;
    sint32 num = 2;
}

message Response {
    int64 time = 1;
    sint32 num = 2;
}

service ClientGuideService {
    rpc UnaryCall (Request) returns (Response);
    rpc ServerStreaming (Request) returns (stream Response);
    rpc ClientStreaming (stream Request) returns (Response);
    rpc BidirectionalStreaming (stream Request) returns (stream Response);
}

set(proto_files "${CMAKE_CURRENT_LIST_DIR}/../proto/clientguide.proto")

find_package(Qt6 COMPONENTS Protobuf Grpc)
qt_standard_project_setup(REQUIRES 6.9)

qt_add_executable(clientguide_client main.cpp)

# Using the executable as input target will append the generated files to it.
qt_add_protobuf(clientguide_client
    PROTO_FILES ${proto_files}
)
qt_add_grpc(clientguide_client CLIENT
    PROTO_FILES ${proto_files}
)

target_link_libraries(clientguide_client PRIVATE Qt6::Protobuf Qt6::Grpc)

namespace client::guide {
namespace ClientGuideService {

class Client : public QGrpcClientBase
{
    ...
    std::unique_ptr<QGrpcCallReply> UnaryCall(const client::guide::Request &arg);
    std::unique_ptr<QGrpcServerStream> ServerStreaming(const client::guide::Request &arg);
    std::unique_ptr<QGrpcClientStream> ClientStreaming(const client::guide::Request &arg);
    std::unique_ptr<QGrpcBidiStream> BidirectionalStreaming(const client::guide::Request &arg);
    ...
};

} // namespace ClientGuideService
} // namespace client::guide

const auto time = now();
if (request->time() > time)
    return { grpc::StatusCode::INVALID_ARGUMENT, "Request time is in the future!" };

response->set_num(request->num());
response->set_time(time);
return grpc::Status::OK;

#include "clientguide.qpb.h"
#include "clientguide_client.grpc.qpb.h"

auto channel = std::make_shared<QGrpcHttp2Channel>(
    QUrl("http://localhost:50056")
    /* without channel options. */
);
ClientGuide clientGuide(channel);

explicit ClientGuide(std::shared_ptr<QAbstractGrpcChannel> channel)
{
    m_client.attachChannel(std::move(channel));
}

static guide::Request createRequest(int32_t num, bool fail = false)
{
    guide::Request request;
    request.setNum(num);
    // The server-side logic fails the RPC if the time is in the future.
    request.setTime(fail ? std::numeric_limits<int64_t>::max()
                         : QDateTime::currentMSecsSinceEpoch());
    return request;
}

std::unique_ptr<QGrpcCallReply> reply = m_client.UnaryCall(requestMessage);
const auto *replyPtr = reply.get(); // 1
QObject::connect(
    replyPtr, &QGrpcCallReply::finished, replyPtr,
    [reply = std::move(reply)](const QGrpcStatus &status) {
        ...
    },
    Qt::SingleShotConnection        // 2
);

voidunaryCall(constguide::Request&request) { std::unique_ptr<QGrpcCallReply>reply=m_client.UnaryCall(request)；const auto *replyPtr =reply.get()；    QObject:：connect( replyPtr, &QGrpcCallReply::finished,replyPtr,[reply =std::move(reply)](constQGrpcStatus&status) {if(status.isOk()) {if(const autoresponse=  reply->read<guide::Response>())                    qDebug() << "Client (UnaryCall) finished, received:" << *response;
               不然                    qDebug("Client (UnaryCall) deserialization failed");
           否则{                qDebug() << "Client (UnaryCall) failed:" << status;
            }},  Qt::SingleShotConnection); }

voidserverStreaming(constguide::Request&initialRequest) { std::unique_ptr<QGrpcServerStream>stream=m_client.ServerStreaming(initialRequest);const auto *streamPtr =stream.get()；    QObject::connect( streamPtr, &QGrpcServerStream::finished,streamPtr,[stream =std::move(stream)](constQGrpcStatus&status) {if(status.isOk())                qDebug("Client (ServerStreaming) finished");
           不然                qDebug() << "Client (ServerStreaming) failed:" << status;
       },  Qt::SingleShotConnection);

QObject::connect(streamPtr, &QGrpcServerStream::messageReceived,streamPtr, [streamPtr]{if(const autoresponse=  streamPtr->read<guide::Response>())        qDebug() << "Client (ServerStream) received:" << *response;
   不然        qDebug("Client (ServerStream) deserialization failed");
}); }

voidclientStreaming(constguide::Request&initialRequest) { m_clientStream=m_client.ClientStreaming(initialRequest);for(int32_t i= 1; i< 3;++i) m_clientStream->writeMessage(createRequest(initialRequest.num()+i)); m_clientStream->writesDone()；    QObject连接（m_clientStream.get(), &QGrpcClientStream::finished,m_clientStream.get(),[this](constQGrpcStatus&status) {if(status.isOk()) {if(const autoresponse=  m_clientStream->read<guide::Response>())                                 qDebug() << "Client (ClientStreaming) finished, received:"
                                         << *response; m_clientStream.reset(); }else{                             qDebug() << "Client (ClientStreaming) failed:" << status;
                             qDebug("Restarting the client stream");
                             clientStreaming(createRequest(0)); } }); }

std::unique_ptr<QGrpcBidiStream> m_bidiStream;
guide::Response m_bidiResponse;

void bidirectionalStreaming(const guide::Request &initialRequest)
{
    m_bidiStream = m_client.BidirectionalStreaming(initialRequest);
    connect(m_bidiStream.get(), &QGrpcBidiStream::finished, this, &ClientGuide::bidiFinished);
    connect(m_bidiStream.get(), &QGrpcBidiStream::messageReceived, this,
            &ClientGuide::bidiMessageReceived);
}

voidbidiFinished(constQGrpcStatus&status) {if(status.isOk()        qDebug("Client (BidirectionalStreaming) finished");
   不然        qDebug() << "Client (BidirectionalStreaming) failed:" << status;
    m_bidiStream.reset(); }

voidbidiMessageReceived() {if(m_bidiStream->read(&m_bidiResponse)) {        qDebug() << "Client (BidirectionalStreaming) received:" << m_bidiResponse;
       如果(m_bidiResponse.num()> 0) { m_bidiStream->writeMessage(createRequest(m_bidiResponse.num()- 1));return; } }else{        qDebug("Client (BidirectionalStreaming) deserialization failed");
    } m_bidiStream->writesDone(); }