En esta página

Chat QtGrpc

Una aplicación de chat para compartir mensajes de cualquier tipo en una sala de chat.

El ejemplo «Chat» muestra un uso avanzado de la API de cliente Qt GRPC. El servidor permite a los usuarios registrarse y autenticarse, lo que les permite unirse a la sala de chat. Una vez en la sala, los usuarios pueden compartir con el resto de participantes diversos tipos de mensajes, como mensajes de texto, imágenes, actividad de usuario o cualquier otro archivo de su disco.

Ventana de chat para móvil Ventana de inicio de sesión

Ejecución del ejemplo

  • Asegúrate de que el servidor qtgrpc_chat_server esté en ejecución y a la escucha correctamente.
  • Si te encuentras en el mismo equipo que el servidor, la dirección predeterminada localhost debería ser suficiente al ejecutar el comando qtgrpc_chat_client. Si utilizas un dispositivo distinto al que aloja el servidor, especifica la dirección IP correcta del host que ejecuta el servidor en el cuadro de diálogo «Configuración».
  • Asegúrate de que la opción de CMake « GRPC_CHAT_USE_EMOJI_FONT » esté activada en el cliente para disfrutar de una experiencia fluida con los emojis 🚀.

Imagen de la ventana de configuración de conexión

Para ejecutar el ejemplo de Qt Creator, abre el modo « Welcome » y selecciona el ejemplo de Examples. Para obtener más información, consulta Qt Creator: Tutorial: Compilar y ejecutar.

Módulos y clases relevantes.

Este ejemplo presenta los siguientes módulos y clases de Qt.

Esquema Protobuf

El esquema Protobuf define la estructura de los mensajes y servicios utilizados en la aplicación de chat. El esquema se divide en dos archivos:

syntax = "proto3";

package chat;

import "chatmessages.proto";

service QtGrpcChat {
    // Register a user with \a Credentials.
    rpc Register(Credentials) returns (None);
    // Join as a registered user and exchange \a ChatMessage(s)
    rpc ChatRoom(stream ChatMessage) returns (stream ChatMessage) {}
}

El archivo « qtgrpcchat.proto » especifica el servicio QtGrpcChat, que proporciona dos métodos RPC:

  • Register: Registra a un usuario con el Credentials facilitado. El servidor almacena y verifica a los usuarios a partir de una base de datos en texto sin cifrar.
  • ChatRoom: Establece un flujo bidireccional para intercambiar mensajes de « ChatMessage » entre todos los clientes conectados. El servidor retransmite todos los mensajes entrantes a los demás clientes conectados.
syntax = "proto3";

package chat;

import "QtCore/QtCore.proto";

message ChatMessage {
    string username = 1;
    int64 timestamp = 2;
    oneof content {
        TextMessage text = 3;
        FileMessage file = 4;
        UserStatus user_status = 5;
    }
}

El archivo chatmessages.proto define ChatMessage, que es una unión etiquetada (también conocida como tipo suma). Representa todos los mensajes individuales que pueden enviarse a través del RPC de transmisión ChatRoom. Cada ChatMessage debe incluir un username y un timestamp para identificar al remitente.

Se incluye la importación « QtCore/QtCore.proto » para habilitar los tipos del módulo « QtProtobufQtCoreTypes », lo que permite una conversión fluida entre los tipos específicos de « QtCore » y sus equivalentes en Protobuf.

message FileMessage {
    enum Type {
        UNKNOWN = 0;
        IMAGE = 1;
        AUDIO = 2;
        VIDEO = 3;
        TEXT = 4;
    }
    Type type = 1;
    string name = 2;
    bytes content = 3;
    uint64 size = 4;

    message Continuation {
        uint64 index = 1;
        uint64 count = 2;
        QtCore.QUuid uuid = 3;
    }
    optional Continuation continuation = 5;
}

FileMessage es uno de los tipos de mensaje compatibles con el tipo suma ChatMessage. Permite envolver cualquier archivo local en un mensaje. El campo opcional Continuation garantiza una entrega fiable al gestionar las transferencias de archivos de gran tamaño por partes.

Nota: Para obtener más detalles sobre el uso del módulo ProtobufQtCoreTypes en tu esquema de Protobuf y en el código de la aplicación, consulta Qt Core usage.

Servidor

Nota: La aplicación de servidor que aquí se describe utiliza la gRPC™ biblioteca.

La aplicación de servidor utiliza la API de devolución de llamada asíncrona gRPC. Esto nos permite beneficiarnos de las ventajas de rendimiento de la API asíncrona sin la complejidad que supone gestionar manualmente las colas de finalización.

class QtGrpcChatService final : public chat::QtGrpcChat::CallbackService

Se declara la clase ` QtGrpcChatService `, que es una subclase de ` CallbackService ` del servicio ` QtGrpcChat ` generado.

    grpc::ServerBidiReactor<chat::ChatMessage, chat::ChatMessage> *
    ChatRoom(grpc::CallbackServerContext *context) override
    {
        return new ChatRoomReactor(this, context);
    }

    grpc::ServerUnaryReactor *Register(grpc::CallbackServerContext *context,
                                       const chat::Credentials *request,
                                       chat::None * /*response*/) override

Además, sobrescribe las funciones virtuales para implementar la funcionalidad de los dos métodos gRPC que proporciona el servicio:

  • El método ` Register ` verifica y almacena a los usuarios en una base de datos de texto sin formato.
  • El método ` ChatRoom ` comprueba las credenciales proporcionadas en los metadatos cotejándolas con la base de datos. Si la comprobación es satisfactoria, establece un flujo bidireccional para la comunicación.
    // Broadcast \a message to all connected clients. Optionally \a skip a client
    void broadcast(const std::shared_ptr<chat::ChatMessage> &message, const ChatRoomReactor *skip)
    {
        for (auto *client : activeClients()) {
            assert(client);
            if (skip && client == skip)
                continue;
            client->startSharedWrite(message);
        }
    }

La implementación del servicio realiza un seguimiento de todos los clientes activos que se conectan o desconectan a través del método ChatRoom. Esto permite la funcionalidad « broadcast », que comparte mensajes con todos los clientes conectados. Para reducir el almacenamiento y la sobrecarga, el método ChatMessage se envuelve en un shared_ptr.

    // Share \a response. It will be kept alive until the last write operation finishes.
    void startSharedWrite(std::shared_ptr<chat::ChatMessage> response)
    {
        std::scoped_lock lock(m_writeMtx);
        if (m_response) {
            m_responseQueue.emplace(std::move(response));
        } else {
            m_response = std::move(response);
            StartWrite(m_response.get());
        }
    }

El método ` startSharedWrite ` es una función miembro de ` ChatRoomReactor`. Si el reactor está escribiendo en ese momento, el mensaje se almacena en una cola. De lo contrario, se inicia una operación de escritura. Existe un único mensaje compartido entre todos los clientes. Cada copia del mensaje ` response ` incrementa el contador ` use_count`. Una vez que todos los clientes han terminado de escribir el mensaje y su contador ` use_count ` desciende a 0, se liberan sus recursos.

    // Distribute the incoming message to all other clients.
    m_service->broadcast(m_request, this);
    m_request = std::make_shared<chat::ChatMessage>(); // detach
    StartRead(m_request.get());

Este fragmento forma parte del método virtual ChatRoomReactor::OnReadDone. Cada vez que se invoca este método, se ha recibido un nuevo mensaje del cliente. El mensaje se difunde a todos los demás clientes, omitiendo al remitente.

    std::scoped_lock lock(m_writeMtx);

    if (!m_responseQueue.empty()) {
        m_response = std::move(m_responseQueue.front());
        m_responseQueue.pop();
        StartWrite(m_response.get());
        return;
    }

    m_response.reset();

Este fragmento forma parte del método virtual « ChatRoomReactor::OnWriteDone ». Cada vez que se invoca este método, se ha escrito un mensaje al cliente. Si hay mensajes almacenados en la cola, se escribe el siguiente mensaje. De lo contrario, se restablece « m_response » para indicar que no hay ninguna operación de escritura en curso. Se utiliza un bloqueo para evitar conflictos con el método « broadcast ».

Cliente

La aplicación cliente utiliza el esquema Protobuf proporcionado para comunicarse con el servidor. Ofrece capacidades tanto de front-end como de back-end para registrar usuarios y gestionar el flujo bidireccional de larga duración del método ChatRoom gRPC . Esto permite la visualización y la comunicación de ChatMessages.

Configuración
add_library(qtgrpc_chat_client_proto STATIC)
qt_add_protobuf(qtgrpc_chat_client_proto
    QML
    QML_URI QtGrpcChat.Proto
    PROTO_FILES
        ../proto/chatmessages.proto
    PROTO_INCLUDES
        $<TARGET_PROPERTY:Qt6::ProtobufQtCoreTypes,QT_PROTO_INCLUDES>
)

qt_add_grpc(qtgrpc_chat_client_proto CLIENT
    PROTO_FILES
        ../proto/qtgrpcchat.proto
    PROTO_INCLUDES
        $<TARGET_PROPERTY:Qt6::ProtobufQtCoreTypes,QT_PROTO_INCLUDES>
)

En primer lugar, genera los archivos fuente a partir del esquema Protobuf. Dado que el archivo qtgrpcchat.proto no contiene ninguna definición de message, solo es necesaria la generación con qtgrpcgen. Proporciona también el PROTO_INCLUDES del módulo ProtobufQtCoreTypes para garantizar que la importación de "QtCore/QtCore.proto" sea válida.

target_link_libraries(qtgrpc_chat_client_proto
    PUBLIC
        Qt6::Protobuf
        Qt6::ProtobufQtCoreTypes
        Qt6::Grpc
)

Asegúrese de que el objetivo independiente qtgrpc_chat_client_proto esté enlazado públicamente con sus dependencias, incluido el módulo ProtobufQtCoreTypes. A continuación, el objetivo de la aplicación se enlaza con esta biblioteca.

Lógica del backend

El backend de la aplicación se basa en cuatro elementos fundamentales:

  • ChatEngine: Un singleton orientado a QML que gestiona la lógica de la aplicación.
  • ClientWorker: Un objeto «worker» que proporciona de forma asíncrona la funcionalidad del cliente « gRPC ».
  • ChatMessageModel: Un « QAbstractListModel » personalizado para gestionar y almacenar los « ChatMessage».
  • UserStatusModel: Un « QAbstractListModel » personalizado para gestionar la actividad del usuario.
    explicit ChatEngine(QObject *parent = nullptr);
    ~ChatEngine() override;

    // Register operations
    Q_INVOKABLE void registerUser(const chat::Credentials &credentials);
    // ChatRoom operations
    Q_INVOKABLE void login(const chat::Credentials &credentials);
    Q_INVOKABLE void logout();
    Q_INVOKABLE void sendText(const QString &message);
    Q_INVOKABLE void sendFile(const QUrl &url);
    Q_INVOKABLE void sendFiles(const QList<QUrl> &urls);
    Q_INVOKABLE bool sendFilesFromClipboard();

El fragmento de código anterior muestra algunas de las funciones de « Q_INVOKABLE » que se invocan desde QML para interactuar con el servidor.

    explicit ClientWorker(std::shared_ptr<LogModel> logger, QObject *parent = nullptr);
    ~ClientWorker() override;

public Q_SLOTS:
    void registerUser(const chat::Credentials &credentials);
    void login(const chat::Credentials &credentials);
    void logout();
    void sendFile(const QUrl &url);
    void sendFiles(const QList<QUrl> &urls);
    void sendMessage(const chat::ChatMessage &message);

Las ranuras que ofrece ClientWorker reflejan en cierta medida la API expuesta por ChatEngine. ClientWorker funciona en un hilo dedicado para gestionar en segundo plano operaciones que consumen muchos recursos, como la transmisión o recepción de archivos de gran tamaño.

m_clientWorker->moveToThread(&m_clientThread);
m_clientThread.start();
connect(&m_clientThread, &QThread::finished, m_clientWorker, &QObject::deleteLater);
connect(m_clientWorker, &ClientWorker::registerFinished, this, &ChatEngine::registerFinished);
connect(m_clientWorker, &ClientWorker::chatError, this, &ChatEngine::chatError);
...

En el constructor de ChatEngine, asigna el ClientWorker a su hilo de trabajo dedicado y continúa gestionando y reenviando sus señales para que estén disponibles en el lado de QML.

void ChatEngine::registerUser(const chat::Credentials &credentials)
{
    QMetaObject::invokeMethod(m_clientWorker, &ClientWorker::registerUser, credentials);
}
...
void ClientWorker::registerUser(const chat::Credentials &credentials)
{
    if (credentials.name().isEmpty() || credentials.password().isEmpty()) {
        emit chatError(tr("Invalid credentials for registration"));
        return;
    }

    if ((!m_client || m_hostUriDirty) && !initializeClient()) {
        emit chatError(tr("Failed registration: unabled to initialize client"));
        return;
    }

    auto reply = m_client->Register(credentials, QGrpcCallOptions{}.setDeadlineTimeout(2s));
    const auto *replyPtr = reply.get();
    connect(
        replyPtr, &QGrpcCallReply::finished, this,
        [this, reply = std::move(reply)](const QGrpcStatus &status) {
            emit registerFinished(status);
        },
        Qt::SingleShotConnection);
}

Esto muestra cómo el ` ChatEngine ` interactúa con el ` ClientWorker ` para registrar usuarios. Dado que el ` ClientWorker ` se ejecuta en su propio hilo, es importante utilizar ` invokeMethod ` para llamar a sus funciones miembro de forma segura.

En ` ClientWorker`, se comprueba si el cliente no está inicializado o si la URI del host ha cambiado. Si se cumple alguna de estas condiciones, se llama a ` initializeClient`, que crea un nuevo ` QGrpcHttp2Channel`. Dado que se trata de una operación costosa, se debe minimizar su frecuencia.

Para gestionar el RPC « Register », utiliza la opción « setDeadlineTimeout » para evitar la inactividad del servidor. Por lo general, se recomienda establecer un plazo límite para los RPC unarios.

void ClientWorker::login(const chat::Credentials &credentials)
{
    if (credentials.name().isEmpty() || credentials.password().isEmpty()) {
        emit chatError(tr("Invalid credentials for login"));
        return;
    }
    ...
    QGrpcCallOptions opts;
    opts.setMetadata({
        { "user-name",     credentials.name().toUtf8()     },
        { "user-password", credentials.password().toUtf8() },
    });
    connectStream(opts);
}

Al iniciar sesión en el ChatRoom, puede utilizar la opción setMetadata para proporcionar las credenciales de usuario, tal y como exige el servidor para la autenticación. La llamada propiamente dicha y el establecimiento de la conexión se gestionan en el método connectStream.

void ClientWorker::connectStream(const QGrpcCallOptions &opts)
{
    ...
    m_chatStream = m_client->ChatRoom(*initialMessage, opts);
    ...
    connect(m_chatStream.get(), &QGrpcBidiStream::finished, this,
            [this, opts](const QGrpcStatus &status) {
                if (m_chatState == ChatState::Connected) {
                    // If we're connected retry again in 250 ms, no matter the error.
                    QTimer::singleShot(250, [this, opts]() { connectStream(opts); });
                } else {
                    setState(ChatState::Disconnected);
                    m_chatResponse = {};
                    m_userCredentials = {};
                    m_chatStream.reset();
                    emit chatStreamFinished(status);
                }
            });
    ...

Para implementar una lógica básica de reconexión en caso de que el flujo finalice de forma abrupta mientras aún se mantiene la conexión. Para ello, basta con volver a llamar a connectStream utilizando el objeto ` QGrpcCallOptions ` de la llamada inicial. De este modo se garantiza que todas las conexiones necesarias también se actualicen.

Nota: El modo Doze/App-Standbyde Android puede activarse, por ejemplo, al utilizar el FileDialog o al cambiar a otra aplicación. Este modo desactiva el acceso a la red, cerrando todas las conexiones activas de ` QTcpSocket ` y provocando que el flujo pase a estar en estado ` finished`. Puedes solucionar este problema con la lógica de reconexión.

    connect(m_chatStream.get(), &QGrpcBidiStream::messageReceived, this, [this] {
        ...
        switch (m_chatResponse.contentField()) {
        case chat::ChatMessage::ContentFields::UninitializedField:
            qDebug("Received uninitialized message");
           return;
        case chat::ChatMessage::ContentFields::Text:
            if (m_chatResponse.text().content().isEmpty())
                return;
            break;
        case chat::ChatMessage::ContentFields::File:
           // Descargar cualquier mensaje de archivo y almacenar la URL descargada en el
            // contenido, permitiendo que el modelo pueda hacer referencia a ella desde allí.
            m_chatResponse.file()
                .setContent(saveFileRequest(m_chatResponse.file()).toString().toUtf8());
           break;
        ...
        emit chatStreamMessageReceived(m_chatResponse);
    });
    setState(Backend::ChatState::Connecting);
}

Cuando se reciben mensajes, el ` ClientWorker ` realiza un procesamiento previo, como guardar el contenido de ` FileMessage `, de modo que el ` ChatEngine ` solo tenga que centrarse en los modelos. Utiliza la enumeración ` ContentFields ` para comprobar de forma segura el campo ` oneof content ` de nuestro tipo suma `ChatMessage`.

void ChatEngine::sendText(const QString &message)
{
    if (message.trimmed().isEmpty())
        return;

    if (auto request = m_clientWorker->createMessage()) {
        chat::TextMessage tmsg;
        tmsg.setContent(message.toUtf8());
        request->setText(std::move(tmsg));
        QMetaObject::invokeMethod(m_clientWorker, &ClientWorker::sendMessage, *request);
        m_chatMessageModel->appendMessage(*request);
    }
}
...
void ClientWorker::sendMessage(const chat::ChatMessage &message)
{
    if (!m_chatStream || m_chatState != ChatState::Connected) {
        emit chatError(tr("Unable to send message"));
        return;
    }
    m_chatStream->writeMessage(message);
}

Al enviar mensajes, el ChatEngine crea solicitudes con el formato adecuado. Por ejemplo, el método sendText acepta un QString y utiliza la función createMessage para generar un mensaje válido con los campos username y timestamp configurados. A continuación, se invoca al cliente para enviar el mensaje y se añade una copia a la cola de nuestro propio ChatMessageModel.

Interfaz de usuario QML
import QtGrpc
import QtGrpcChat
import QtGrpcChat.Proto

En el código QML se utilizan las siguientes importaciones:

  • QtGrpc: Proporciona la funcionalidad QML de QtGrpc, como el StatusCode.
  • QtGrpcChat: Nuestro módulo de aplicación, que incluye componentes como el singleton ChatEngine.
  • QtGrpcChat.Proto: Proporciona acceso QML a nuestros tipos protobuf generados.
    Connections {
        target: ChatEngine
        function onChatStreamFinished(status) {
            root.handleStatus(status)
            loginView.clear()
        }
        function onChatStateChanged() {
            if (ChatEngine.chatState === Backend.ChatState.Connected && mainView.depth === 1)
                mainView.push("ChatView.qml")
            else if (ChatEngine.chatState === Backend.ChatState.Disconnected && mainView.depth > 1)
                mainView.pop()
        }
        function onRegisterFinished(status) {
            root.handleStatus(status)
        }
        function onChatError(message) {
            statusDisplay.text = message
            statusDisplay.color = "yellow"
            statusDisplay.restart()
        }
    }

Main.qml gestiona las señales principales emitidas por ChatEngine. La mayoría de estas señales se gestionan de forma global y se visualizan en cualquier estado de la aplicación.

Rectangle {
    id: root

    property credentials creds
    ...
    ColumnLayout {
        id: credentialsItem
        ...
        RowLayout {
            id: buttonLayout
            ...
            Button {
                id: loginButton
                ...
                enabled: nameField.text && passwordField.text
                text: qsTr("Login")
                onPressed: {
                    root.creds.name = nameField.text
                    root.creds.password = passwordField.text
                    ChatEngine.login(root.creds)
                }
            }

Se puede acceder en QML a los tipos de mensajes generados a partir del esquema protobuf, ya que son « QML_VALUE_TYPE» (una versión en camelCase de la definición del mensaje). El « LoginView.qml » utiliza la propiedad de tipo de valor « credentials » para iniciar el « login » en el « ChatEngine ».

        ListView {
            id: chatMessageView
            ...
            component DelegateBase: Item {
                id: base

                required property chatMessage display
                default property alias data: chatLayout.data
                ...
            }
            ...
            // We use the DelegateChooser and the 'whatThis' role to determine
            // the correct delegate for any ChatMessage
            delegate: DelegateChooser {
                role: "whatsThis"
                ...
                DelegateChoice {
                    roleValue: "text"
                    delegate: DelegateBase {
                        id: dbt
                        TextDelegate {
                            Layout.fillWidth: true
                            Layout.maximumWidth: root.maxMessageBoxWidth
                            Layout.preferredHeight: implicitHeight
                            Layout.bottomMargin: root.margin
                            Layout.leftMargin: root.margin
                            Layout.rightMargin: root.margin

                            message: dbt.display.text
                            selectionColor: dbt.lightColor
                            selectedTextColor: dbt.darkColor
                        }
                    }
                }

En ChatView.qml, el ListView muestra los mensajes en el ChatRoom. Esto es un poco más complejo, ya que hay que gestionar el tipo suma ChatMessage de forma condicional.

Puedes utilizar un DelegateChooser, que nos permite seleccionar el delegado adecuado en función del tipo de mensaje. Utiliza el rol predeterminado « whatThis » del modelo, que proporciona el tipo de mensaje para cada instancia de « ChatMessage ». A continuación, el componente « DelegateBase » accede al rol « display » del modelo, lo que permite que los datos de «chatMessage» estén disponibles para su representación.

TextEdit {
    id: root

    required property textMessage message

    text: message.content
    color: "#f3f3f3"
    font.pointSize: 14
    wrapMode: TextEdit.Wrap
    readOnly: true
    selectByMouse: true
}

Este es uno de los componentes que visualiza el tipo TextMessage. Utiliza el tipo de valor textMessage del módulo protobuf para visualizar el texto.

                TextArea.flickable: TextArea {
                    id: inputField

                    function sendTextMessage() : void {
                        if (text === "")
                            return
                        ChatEngine.sendText(text)
                        text = ""
                    }
                    ...
                    Keys.onPressed: (event) => {
                        if (event.key === Qt.Key_Return && event.modifiers & Qt.ControlModifier) {
                            sendTextMessage()
                            event.accepted = true
                        } else if (event.key === Qt.Key_V && event.modifiers & Qt.ControlModifier) {
                            if (ChatEngine.sendFilesFromClipboard())
                                event.accepted = true
                        }
                    }

El cliente de chat ofrece varios puntos de acceso para enviar mensajes, como:

  • Aceptar archivos que se arrastren y suelten en la aplicación.
  • <Ctrl + V> para enviar cualquier contenido almacenado en el portapapeles de Qt.
  • <Ctrl + Intro> para enviar el mensaje desde el inputField
  • Hacer clic en el botón de envío para el inputField
  • Seleccionar archivos mediante un cuadro de diálogo de archivos

SSL

Para garantizar la seguridad de la comunicación entre el servidor y los clientes, se utiliza el cifrado SSL/TLS. Esto requiere, como mínimo, lo siguiente:

  • Clave privada: contiene la clave privada del servidor, que se utiliza para establecer conexiones seguras. Debe mantenerse confidencial y nunca debe compartirse.
  • Certificado: contiene el certificado público del servidor, que se comparte con los clientes para verificar la identidad del servidor. Normalmente está firmado por una autoridad de certificación (CA) o puede ser autofirmado con fines de prueba.
  • Certificado de CA raíz opcional: si utilizas una Autoridad de Certificación (CA) personalizada para firmar el certificado de tu servidor, se requiere el certificado de CA raíz en el lado del cliente para validar la cadena de certificados del servidor. Esto garantiza que el cliente pueda confiar en el certificado del servidor, ya que el certificado raíz de la CA personalizada no está preinstalado en el almacén de confianza del cliente, a diferencia de los de las CA públicas.

Utiliza OpenSSL para crear estos archivos y configurar nuestra comunicación gRPC para que utilice SSL/TLS.

        grpc::SslServerCredentialsOptions sslOpts;
        sslOpts.pem_key_cert_pairs.emplace_back(grpc::SslServerCredentialsOptions::PemKeyCertPair{
            LocalhostKey,
            LocalhostCert,
        });
        builder.AddListeningPort(QtGrpcChatService::httpsAddress(), grpc::SslServerCredentials(sslOpts));
        builder.AddListeningPort(QtGrpcChatService::httpAddress(), grpc::InsecureServerCredentials());

Debes proporcionar la clave privada y el certificado al servidor gRPC. Con ello, podrás configurar el archivo SslServerCredentials para habilitar TLS en el lado del servidor. Además de la comunicación segura, permite también el acceso sin cifrar.

El servidor escucha en las siguientes direcciones:

  • HTTPS: 0.0.0.0:65002
  • HTTP: 0.0.0.0:65003

El servidor se vincula a 0.0.0.0 para escuchar en todas las interfaces de red, lo que permite el acceso desde cualquier dispositivo de la misma red.

if (m_hostUri.scheme()== "https") {
    if (!QSslSocket::supportsSsl()) {
        emit chatError(tr("El dispositivo no es compatible con SSL. Utiliza el esquema 'http'."));
        return false;
    }
    QFile crtFile(":/res/root.crt");
    if (!crtFile.open(QFile::ReadOnly)) {
        qFatal("Unable to load root certificate");
       return false;
    }

    QSslConfiguration sslConfig;
    QSslCertificate crt(crtFile.readAll());
    sslConfig.addCaCertificate(crt);
    sslConfig.setProtocol(QSsl::TlsV1_2OrLater);
    sslConfig.setAllowedNextProtocols({ "h2" }); // Permitir HTTP/2 

    // Desactivar la verificación del nombre de host para permitir conexiones desde cualquier IP local.
   // Aceptable para el desarrollo, pero se debe evitar en producción por motivos de seguridad.
    sslConfig.setPeerVerifyMode(QSslSocket::VerifyNone);
    opts.setSslConfiguration(sslConfig);
}

El cliente carga el certificado de la CA raíz, ya que has autofirmado la CA. Este certificado se utiliza para crear el QSslCertificate. Es importante indicar el protocolo "h2" con setAllowedNextProtocols, ya que estás utilizando HTTP/2.

Interceptores

El cliente de chat utiliza un QGrpcInterceptorChain para supervisar toda la actividad RPC. Durante la inicialización, un LoggingInterceptor se conecta al canal, lo que proporciona a la aplicación una visión en tiempo real de cada operación que pasa por la cadena.

QGrpcInterceptorChain interceptorChain;
interceptorChain.add(std::make_unique<LoggingInterceptor>(m_logModel));
auto channel = std::make_shared<QGrpcHttp2Channel>(m_hostUri, opts,
                                                   std::move(interceptorChain));

Se crea un ` QGrpcInterceptorChain ` y se le añade el interceptor mediante su sobrecarga ` unique_ptr `, que transfiere la propiedad a la cadena. A continuación, se pasa la cadena al constructor ` QGrpcHttp2Channel `. Una vez que el canal asume la propiedad, el interceptor sigue siendo válido durante todo el ciclo de vida del canal.

class LoggingInterceptor final : public QGrpcStartInterceptor,
                                 public QGrpcInitialMetadataInterceptor,
                                 public QGrpcMessageReceivedInterceptor,
                                 public QGrpcWriteMessageInterceptor,
                                 public QGrpcWritesDoneInterceptor,
                                 public QGrpcTrailingMetadataInterceptor,
                                 public QGrpcCancelInterceptor,
                                 public QGrpcFinishedInterceptor
{
public:
    explicit LoggingInterceptor(std::shared_ptr<LogModel> logModel);
    ~LoggingInterceptor() override;

    Continuation onStart(QGrpcInterceptionContext &context, QProtobufMessage &message,
                         QGrpcCallOptions &callOptions) override;

    void onInitialMetadata(QGrpcInterceptionContext &context,
                           QMultiHash<QByteArray, QByteArray> &metadata) override;

    void onMessageReceived(QGrpcInterceptionContext &context, QByteArray &messageData) override;

    void onWriteMessage(QGrpcInterceptionContext &context, QProtobufMessage &message) override;

    void onWritesDone(QGrpcInterceptionContext &context) override;

    void onTrailingMetadata(QGrpcInterceptionContext &context,
                            QMultiHash<QByteArray, QByteArray> &metadata) override;

    void onCancel(QGrpcInterceptionContext &context) override;

    void onFinished(QGrpcInterceptionContext &context, QGrpcStatus &status) override;

private:
    std::shared_ptr<LogModel> m_log;
    using Clock = std::chrono::steady_clock;
    using Ms = std::chrono::duration<double, std::milli>;
    QHash<quint64, Clock::time_point> m_activeRPCs;
};

LoggingInterceptor Implementa todas las interfaces de interceptor disponibles, cubriendo todo el ciclo de vida de la RPC. Contiene una referencia ` shared_ptr ` a un ` LogModel ` para añadir entradas de registro, y una referencia ` QHash ` para realizar un seguimiento de las operaciones activas por ID.

Implementación del interceptor de registro

Los siguientes fragmentos de código muestran cómo funcionan los puntos de interceptación onStart y onFinished. El resto de puntos de interceptación realizan un registro básico de sus respectivos eventos.

LoggingInterceptor::Continuation LoggingInterceptor::onStart(QGrpcInterceptionContext &context,
                                                             QProtobufMessage &, QGrpcCallOptions &)
{
    const auto id = context.operationId();
    m_activeRPCs.insert(id, Clock::now());
    m_log->add(LogModel::Level::Debug, id, context.descriptor(), u"Starting"_s);
    return Continuation::Proceed;
}

En onStart, el interceptor almacena la marca de tiempo actual en un QHash con clave el operationId(). Al devolver Continuation::Proceed, se pasa la llamada por la cadena.

void LoggingInterceptor::onFinished(QGrpcInterceptionContext &context, QGrpcStatus &status)
{
    const auto it = m_activeRPCs.find(context.operationId());
    Q_ASSERT(it != m_activeRPCs.cend());
    const auto duration = Ms(Clock::now() - it.value()).count();
    m_activeRPCs.erase(it);

    const auto codeStr = QDebug::toString(status.code()).section("::", -1);
    auto msg = u"Finished in %1 ms. StatusCode: %2"_s.arg(duration).arg(codeStr);
    if (!status.message().isEmpty())
        msg += u", Message: "_s + status.message();

    const auto level = [&] {
        switch (status.code()) {
        case QtGrpc::StatusCode::Ok:
            return LogModel::Level::Info;
        case QtGrpc::StatusCode::NotFound:
        case QtGrpc::StatusCode::Unauthenticated:
            return LogModel::Level::Warning;
        default:
            return LogModel::Level::Error;
        }
    }();

    m_log->add(level, context.operationId(), context.descriptor(), msg);
}

En onFinished, se busca la marca de tiempo almacenada mediante el ID de la operación para calcular la duración de la RPC. El nivel de registro se deriva del código de estado, y la entrada final se añade a LogModel.

Las entradas de registro acumuladas se exponen a QML a través de la propiedad ChatEngine::logModel. Un LogDialog dedicado las muestra en un ListView:

Dialog {
    id: root
    title: "Interceptor Logs"
    ...
    ListView {
        ScrollIndicator.horizontal: ScrollIndicator { }
        ScrollIndicator.vertical: ScrollIndicator { }

        anchors.fill: parent
        model: ChatEngine.logModel
        clip: true

        delegate: ItemDelegate {
            id: delegate

            required property int level
            required property string timestamp
            required property int operationId
            required property string service
            required property string method
            required property int rpcType
            required property string message

            width: ListView.view.width

            contentItem: ColumnLayout {
                RowLayout {
                    Label {
                        font.bold: true
                        text: root.levelToString(delegate.level)
                        color: root.levelToColor(delegate.level)
                    }
                    Item { Layout.fillWidth: true }
                    Label {
                        text: delegate.timestamp
                        opacity: 0.7
                    }
                }
                // further entries for visualizing the RPC context and message.
                ...
            }
        }
    }
}

Cada elemento muestra el nivel de registro, la marca de tiempo y los detalles del RPC. El LogModel antepone las nuevas entradas para que la actividad más reciente aparezca en la parte superior.

Cuadro de diálogo «Registros del interceptor» con entradas de actividad RPC

Archivos fuente

Proyecto de ejemplo en code.qt.io

Véase también Todos los ejemplos de Qt.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.