Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Cliente Hub SDK
<a name="hub-sdk-client"></a>

La biblioteca cliente del SDK de Hub sirve como interfaz entre las integraciones gestionadas del SDK de Hub y tu propia pila de protocolos que se ejecuta en el mismo hub. Expone un conjunto de API públicas para facilitar la interacción de tu pila de protocolos con los componentes del SDK de Device Hub. Los casos de uso incluyen el control de complementos personalizados, el aprovisionador de complementos personalizado y el controlador local.

**Topics**
+ [Obtenga su SDK de integraciones gestionadas (Hub SDK)](#custom-protocol-plugin-getting-started)
+ [Acerca del kit de herramientas del SDK de Hub](#custom-protocol-plugin-toolkit)
+ [Crea tu aplicación personalizada con el cliente Hub SDK](#custom-protocol-plugin-create-app)
+ [Ejecutando tu aplicación personalizada](#custom-protocol-plugin-running-application)
+ [Referencia de la API de cliente del SDK de Hub](hub-sdk-client-api-reference.md)
+ [Tipos de datos](#custom-protocol-plugin-data-types)

## Obtenga su SDK de integraciones gestionadas (Hub SDK)
<a name="custom-protocol-plugin-getting-started"></a>

El cliente Hub SDK viene con el SDK de integraciones gestionadas. Ponte en contacto con nosotros desde la [consola de integraciones gestionadas](https://console.aws.amazon.com/iot/home#/managed-integrations/intro) para acceder al SDK del hub.

## Acerca del kit de herramientas del SDK de Hub
<a name="custom-protocol-plugin-toolkit"></a>

Tras la descarga, verás una `IotMI-DeviceSDK-Toolkit` carpeta que contiene todos los archivos de cabecera públicos y `.so` los archivos que puedes consumir en tu aplicación. El equipo de integraciones gestionadas también proporciona un ejemplo `main.cpp` con fines de demostración, junto con el binario de la aplicación de demostración, `bin/` que puede ejecutar directamente. Si lo desea, puede usarlo como punto de partida para su aplicación. 

## Crea tu aplicación personalizada con el cliente Hub SDK
<a name="custom-protocol-plugin-create-app"></a>

Sigue los siguientes pasos para crear tu aplicación personalizada.

1. Incluya los archivos de encabezado (.h) y los archivos de objetos compartidos (.so) en su aplicación.

   Debe incluir los archivos de encabezado públicos (.h) y los archivos de objetos compartidos (.so) en su aplicación. En el caso de los archivos.so, puede colocarlos en una carpeta lib. El diseño final será similar al siguiente:

   ```
   ├── include
   │   ├── iotmi_device_sdk_client
   │   │   └── iotmi_device_sdk_client_common_types.h
   │   ├── iotmi_device_sdk_client.h
   │   └── iotshd_status.h
   ├── lib
   │   ├── libiotmi_devicesdk_client_module.so
   │   └── libiotmi_log_c.so
   ```

1. Crea un cliente Hub SDK en tu aplicación principal.

   1. En tu aplicación principal, primero debes inicializar el cliente del SDK de Hub para poder usarlo para procesar las solicitudes. Simplemente puede crear el cliente con un`clientId`.

   1. Una vez que tenga el cliente, puede conectarlo al SDK de dispositivos de integraciones administradas.

      A continuación, se muestra un ejemplo de cómo crear el cliente del SDK de Hub y cómo conectarlo.

      ```
      #include <cstdlib>
      #include <string>
      #include "iotshd_status.h"
      #include "iotmi_device_sdk_client.h"
      
      auto client = std::make_unique<DeviceSDKClient>({{your_own_clientId}});
      iotmi_statusCode_t status = client->connect();
      ```
**nota**  
{{your\_own\_clientId}}debe ser el mismo que especifiques en [start-device-discovery](https://docs.aws.amazon.com/cli/latest/reference/iot-managed-integrations/start-device-discovery.html) en la configuración guiada por el usuario, o en el caso de [create-managed-thing](https://docs.aws.amazon.com/cli/latest/reference/iot-managed-integrations/create-managed-thing.html) en el flujo de aprovisionamiento de la configuración simple.

1. Para publicar y suscribirse, siga estos pasos.

   1. Una vez establecida la conexión, ya puedes suscribirte a las tareas entrantes desde el SDK de Hub para integraciones gestionadas. Las tareas entrantes pueden ser tareas de control o tareas de aprovisionamiento. También debes definir tu propia función de devolución de llamadas en función de las tareas recibidas y tu propio contexto personalizado para tus propios fines de seguimiento.

      ```
            // subscribe to provisioning tasks
            iotmi_statusCode_t status = client->iotmi_provision_subscribe_to_tasks(
            example_subscriber_callback, custom_context);
            
            // subscribe to control tasks
            iotmi_statusCode_t status = client->iotmi_control_subscribe_to_tasks(
            example_subscriber_callback, custom_context);
      ```

   1. Una vez establecida la conexión, ahora puedes publicar las solicitudes de tu aplicación en el SDK de Hub para integraciones gestionadas. Puedes definir tu propio tipo de mensaje de tarea, con diferentes cargas útiles para distintos fines empresariales. Las solicitudes pueden incluir tanto solicitudes de control como solicitudes de aprovisionamiento, de forma similar al flujo de suscripción. Por último, puedes asignarte una dirección `rspPayload` para obtener la respuesta del SDK de Hub de integraciones gestionadas de forma sincronizada. 

      ```
      // publish control request
        iotmi_client_request_t api_payload = {
                  .messageType = C2MIMessageType::C2MI_CONTROL_EVENT,
                  .reqPayload = (uint8_t *)"{{define_your_req_payload}}",
                  .rspPayload = (uint8_t *)calloc(1000, sizeof(uint8_t))
        };
      
        status = client->iotmi_control_publish_request(&api_payload); 
        
        // publish provision request 
        iotmi_client_request_t api_payload = {
                  .messageType = C2MIMessageType::C2MI_DEVICE_ONBOARDED,
                  .reqPayload = (uint8_t *)"{{define_your_req_payload}}",
                  .rspPayload = (uint8_t *)calloc(1000, sizeof(uint8_t))
        };
        status = client->iotmi_provision_publish_request(&api_payload);
      ```

1. Cree la suya propia `CMakeLists.txt` y cree su aplicación a partir de ahí. El resultado final podría ser un binario ejecutable, como `MyFirstApplication`

## Ejecutando tu aplicación personalizada
<a name="custom-protocol-plugin-running-application"></a>

Antes de ejecutar la aplicación personalizada, complete los siguientes pasos para configurar su hub e iniciar el SDK de Hub de integraciones gestionadas:
+ Sigue las instrucciones de incorporación que aparecen en. [Incorpore sus hubs a las integraciones gestionadas](managedintegrations-sdk-v2-cookbook-usinghub.md)
+ Complete el proceso de instalación documentado en[Instale y valide el SDK de Hub de integraciones administradas](managedintegrations-sdk-v2-cookbook-deployment.md).

Una vez que se cumplan los requisitos previos, podrá ejecutar su aplicación personalizada. Por ejemplo:

```
./MyFirstApplication
```

**importante**  
Debe actualizar manualmente el script de inicio que aparece en la lista [Implemente el SDK de Hub con un script](managedintegrations-sdk-v2-cookbook-deployment-nogg.md) con un script para iniciar su propia aplicación. El orden importa, no lo cambie.  
Actualiza lo siguiente. Cambio  

```
./IotMI-DeviceSDK-Toolkit/bin/DeviceSDKClientDemo >> $LOGS_DIR/logDeviceSDKClientDemo_logs.txt &
```
a  

```
./MyFirstApplication >> $LOGS_DIR/MyFirstApplication_logs.txtt &
```

## Tipos de datos
<a name="custom-protocol-plugin-data-types"></a>

En esta sección se definen los tipos de datos que se utilizan para el complemento de protocolo personalizado.

**iotmi\_client\_request\_t**  
Representa una solicitud para publicarse en los componentes de integraciones gestionadas.    
**MessageType**  
El tipo de mensaje (CommonTypes::). C2MIMessageType La siguiente lista muestra los valores válidos.  
+ `C2MI_DEVICE_ONBOARDED`: Indica un mensaje de incorporación del dispositivo con la carga útil relacionada.
+ `C2MI_DE_PROVISIONING_PRE_ASSOCIATED_COMPLETE`: Indica una notificación de finalización de una tarea de desaprovisionamiento para un dispositivo preasociado.
+ `C2MI_DE_PROVISIONING_ACTIVATED_COMPLETE`: Indica una notificación de finalización de una tarea de desaprovisionamiento para un dispositivo activado.
+ `C2MI_DE_PROVISIONING_COMPLETE_RESPONSE`: Indica la respuesta completa a una tarea de desaprovisionamiento.
+ `C2MI_CONTROL_EVENT`: Indica un evento de control con un posible cambio de estado del dispositivo.
+ `C2MI_CONTROL_SEND_COMMAND`: Indica un comando de control de un controlador local.
+ `C2MI_CONTROL_SEND_DEVICE_STATE_QUERY`: Indica una consulta del estado del dispositivo de control desde un controlador local.  
**ReqPayload**  
La carga útil de la solicitud, normalmente una cadena. JSON-formatted   
**Carga útil de RSP**  
La carga útil de respuesta, compuesta por los componentes de las integraciones gestionadas.

**iotmi\_client\_event\_t**  
Representa un evento recibido de los componentes de integraciones gestionadas.    
**event\_id**  
El identificador único del evento.  
**longitud**  
La longitud de los datos del evento.  
**data**  
Un puntero a los datos del evento, incluido el`messageType`. La siguiente lista muestra los valores posibles.  
+ `C2MI_PROVISION_UGS_TASK`: Indica una tarea de aprovisionamiento para el flujo de UGS.
+ `C2MI_PROVISION_SS_TASK`: Indica una tarea de aprovisionamiento para el SimpleSetup flujo.
+ `C2MI_DE_PROVISION_PRE_ASSOCIATED_TASK`: Indica una tarea de desaprovisionamiento para un dispositivo preasociado.
+ `C2MI_DE_PROVISION_ACTIVATED_TASK`: Indica una tarea de desaprovisionamiento para un dispositivo activado.
+ `C2MI_DEVICE_ONBOARDED_RESPONSE`: Indica una respuesta de incorporación del dispositivo.
+ `C2MI_CONTROL_TASK`: Indica una tarea de control.
+ `C2MI_CONTROL_EVENT_NOTIFICATION`: Indica una notificación de evento de control para un controlador local.  
**ctx**  
Un contexto personalizado asociado al evento.