> For the complete documentation index, see [llms.txt](https://docs.medcrypt.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.medcrypt.com/fr/guardian/api-overview/api-reference/classes/classmedcrypt-guardian-guardian.md).

# medcrypt::guardian::Guardian

## Présentation

La `Guardian` classe est l’interface principale de la plateforme de sécurité Guardian. Elle fournit des fonctionnalités de provisionnement des appareils, de communication sécurisée et d’opérations cryptographiques pour les dispositifs médicaux. Elle prend en charge les opérations suivantes tout au long du cycle de vie de l’appareil :

* Établissement de l’identité de l’appareil
* Connexions sécurisées
* Gestion des certificats

**Inclure**

```cpp
#include <Guardian.h>
```

### Fonctions de provisionnement des appareils

* [Guardian](#function-guardian)  : le constructeur ne fait rien d’autre qu’initialiser les variables membres.
* [Initialize](#function-initialize) : utilise les fichiers de profil, d’identité et de confiance fournis pour initialiser le système Guardian.
* [GenerateProvisionRequest](#function-generateprovisionrequest) : il s’agit de la première étape du processus de provisionnement de l’appareil.
* [StartProvisioningOnline](#function-startprovisioningonline) : lance le processus de provisionnement en ligne de l’appareil.
* [IsProvisioningRunning](#function-isprovisioningrunning) : vérifie si le processus de provisionnement est actif.
* [GetProvisionedProfile](#function-getprovisionedprofile): Extraire le profil certifié provisionné pour l’appareil après la réussite du provisionnement de l’appareil.

### Fonctions de gestion des certificats

* [GetCertificateManager :](#function-getcertificatemanager) Récupérer le gestionnaire de certificats en cours d’exécution.
* [GetProvisionedRevocationList](#function-getprovisionedrevocationlist): Récupérer la liste de révocation des certificats et la charger dans un tampon.

### **Fonctions des opérations de sécurité**

* [FindSecureOperation](#function-findsecureoperation): Effectuer une recherche pour obtenir le gestionnaire d’opérations sécurisées destiné à la signature et à la vérification

### **Fonctions de gestion des services**

* [FindService](#function-findservice) : recherche un service par son nom afin de localiser un service configuré.
* [CreateTask](#function-createtask): Créer une tâche pour les opérations de service, de session ou de canal, qui sépare l’objet fourni et tous ses objets enfants de [Run](#function-run).

### **Fonctions de gestion du système**

* [GetAuthenticationManager](#function-getauthenticationmanager): Récupérer le gestionnaire d’authentification en cours d’exécution.
* [GetTelemetryManager](#function-gettelemetrymanager): Récupérer le gestionnaire de télémétrie en cours d’exécution.
* [\~Guardian](#function-~guardian)  : le destructeur tente un arrêt progressif de Guardian.
* [Shutdown](#function-shutdown): Arrêt propre de Guardian

## Flux de configuration et de provisionnement de l’appareil

### Vue d’ensemble des étapes

#### [Prérequis : créer une instance de Guardian](#function-guardian)

**Fonction :** `Guardian()`

* Crée une nouvelle instance de Guardian
* Première étape avant toute autre opération
* Initialise les variables membres et place le système dans son état de démarrage

#### [Étape 1 : configuration de l’appareil](#function-initialize)

**Fonction :** `Initialize()`

* Doit être appelée en premier après la création de l’instance de Guardian
* Configure Guardian avec la configuration initiale
* Requise avant toute opération de provisionnement

#### [Étape 2 : génération de la demande de provisionnement](#function-generateprovisionrequest)

**Fonction :** `GenerateProvisionRequest()`

* Crée les fichiers de demande de provisionnement (.mcpr) et d’identité privée (.mcpi)
* Utilise le package de provisionnement pour générer les clés de l’appareil
* Doit être appelée une fois avant toute autre opération de provisionnement

#### [Étape 3 : envoi et traitement de la demande](#function-startprovisioningonline)

**Fonction :** `StartProvisioningOnline()`

* Lance la machine à états du provisionnement en ligne
* Envoie la demande de provisionnement à Guardian Cloud
* Lance le flux de traitement automatisé

#### [Étape 4 : suivi du provisionnement et récupération du profil certifié de l’appareil](#function-getprovisionedprofile)

**Fonctions :** `Run()`, `IsProvisioningRunning()`, `GetProvisionedProfile()`

* `Run()`  : exécute les tâches de provisionnement en arrière-plan
* `IsProvisioningRunning()`  : vérifie si le processus de provisionnement est toujours en cours
* `GetProvisionedProfile()` - Récupère le profil certifié finalisé de l’appareil

### Étape 1 : exécuter Guardian() <a href="#function-guardian" id="function-guardian"></a>

* **Description :**
  * Crée une nouvelle instance de Guardian.
  * Il s’agit de la première étape avant l’initialisation de Guardian avec les identifiants de l’appareil.
  * Ce constructeur initialise uniquement les variables membres.
* **Dépendances :** Aucune — il s’agit de la première fonction à appeler
* **Paramètres :** Aucun — le constructeur par défaut ne prend aucun paramètre
* **Renvoie :** Rien, puisqu’il s’agit d’un constructeur.
* **Action :** Place l’instance de Guardian dans l’état de démarrage, prête pour l’initialisation (`m_p_guardian`).

**Syntaxe**

```cpp
Guardian()
```

### Étape 2 : exécuter Initialize() <a href="#function-initialize" id="function-initialize"></a>

* **Description :** Initialise Guardian avec les identifiants de l’appareil et les fichiers de configuration. Utilise le profil, l’identité et les fichiers de confiance fournis pour initialiser le système Guardian.
* **Dépendances :**
  * Doit être appelée après [la création d’une instance de Guardian](#function-guardian) (`Guardian()` ).
  * Doit être appelée avant toute autre opération de Guardian
* **Paramètres :**
  * `in_files`: Identifiants de l’appareil et fichiers de configuration
  * `in_component_handle`: Identifiant unique du composant utilisé pour le provisionnement.
    * **Type :** `const char*`
  * `in_hardware_identifier`: Identifiant matériel unique.
    * **Limites de longueur :** 36 (37 avec le caractère nul de fin)
    * **Type :** `const char*`
  * `in_options`: Options de configuration supplémentaires pour l’initialisation
* **Valeur de retour :** Code d’état indiquant la réussite ou l’échec.
  * **Code de réussite :** `OK`**.** Le système Guardian a été initialisé avec succès.
  * **Codes d’erreur :**
    * `FAIL`: Échec général. Guardian n’a pas été initialisé correctement. Consultez le fichier journal pour plus d’informations.
    * `BADPARAM`: L’une des entrées est nulle ou vide.
    * `FILENOTFOUND`: Un fichier d’entrée requis est indisponible.
    * `OUTOFMEMORY` **:** Mémoire insuffisante pour initialiser Guardian.
  * **Voir aussi :** [Tous les codes d’état](/fr/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action :** Configure Guardian avec l’identité de l’appareil et le prépare aux opérations sécurisées.

**Syntaxe**

```cpp
Status Initialize(
    const utilities::InitializeFiles & in_files,
    const char * in_component_handle,
    const char * in_hardware_identifier,
    const InitializeOptions & in_options
)
```

### Étape 3 : exécuter GenerateProvisionRequest() <a href="#function-generateprovisionrequest" id="function-generateprovisionrequest"></a>

* **Description :** Crée une demande de provisionnement pour établir l’identité de l’appareil.
  * Il s’agit de la première étape du processus de provisionnement.
  * Il s’agit de la seule étape du processus de provisionnement hors ligne.
  * Utilise les fichiers d’entrée pour générer une demande de provisionnement et une identité privée
* **Dépendances :**
  * Doit être appelé après `Initialize()`
  * Doit être appelé une fois avant toute autre action de provisionnement ou de reprovisionnement.
  * Requis avant `StartProvisioningOnline()`
* **Paramètres :**
  * `io_files` : structure des fichiers de provisionnement.\
    `in_provisioning_component_handle` : identifiant unique du composant utilisé pour le provisionnement.
    * **Type :** `const char*`
  * `in_provisioning_system` : nom unique du système transmis à Guardian Cloud.
    * **Limites de longueur :** 36 (37 avec le caractère nul de fin)
    * **Type :** `const char*`
  * `in_hardware_identifier` - Il s’agit de l’identifiant matériel unique.
    * **Limites de longueur :** 36 (37 avec le caractère nul de fin)
    * **Type :** `const char*`
* **Valeur de retour :** Code d’état indiquant la réussite ou l’échec.
  * **Code de réussite :** `OK`**.** La demande de provisionnement a été créée avec succès
  * **Codes d’erreur :**
    * `FAIL`: Échec général. Consultez le fichier journal pour plus d’informations.
    * `BADPARAM`: L’une des entrées est nulle ou vide
    * `FILENOTFOUND`: Un fichier d’entrée requis est indisponible
    * `NOWRITE`: Impossible d’écrire un fichier de sortie requis
    * `OUTOFMEMORY` : Mémoire insuffisante pour le provisionnement
  * **Voir aussi :** [Tous les codes d’état](/fr/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Actions :**
  * Génère les clés de l’appareil et crée une demande de provisionnement.
  * Crée une identité privée ( `PrivateIdentity` ) pour l’appareil, ainsi que sa demande de provisionnement ( `ProvisionRequest` ).
    * ) `PrivateIdentity` contient les clés générées pour l’appareil. Il s’agit du fichier **.mcpi** .
    * La `ProvisionRequest` peut être téléversée manuellement vers Guardian Cloud ou envoyée à l’aide des méthodes en ligne disponibles dans le profil. Il s’agit du fichier **.mcpr** .

**Syntaxe**

```cpp
Status GenerateProvisionRequest(
    utilities::ProvisionFiles & io_files,
    const char * in_provisioning_component_handle,
    const char * in_provisioning_system,
    const char * in_hardware_identifier
)
```

### Étape 4 : StartProvisioningOnline() <a href="#function-startprovisioningonline" id="function-startprovisioningonline"></a>

* **Description :** Démarre le processus de provisionnement en ligne afin de soumettre une demande de provisionnement à Guardian Cloud.
* **Dépendances :** Doit être exécuté après [GenerateProvisionRequest()](#function-generateprovisionrequest).
* **Paramètres :**
  * `in_files`: fichiers requis pour le provisionnement en ligne
  * `in_options`: options de configuration supplémentaires et facultatives pour le provisionnement, notamment les délais d’attente
* **Valeur de retour :** Code d’état indiquant la réussite ou l’échec.
  * **Code de réussite :** `OK` : le provisionnement en ligne a démarré avec succès
  * **Codes d’erreur :**
    * `FAIL` : échec général du démarrage du provisionnement. Consultez le fichier journal pour en savoir plus.
    * `BADPARAM` : l’une des entrées est nulle ou non valide
    * `FILENOTFOUND` : un fichier requis pour le provisionnement est indisponible
  * **Voir aussi :** [Tous les codes d’état](/fr/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action :** Démarre la machine à états interne de provisionnement et commence la communication avec Guardian Cloud

**Syntaxe**

```cpp
Status StartProvisioningOnline(
    const utilities::ProvisionOnlineFiles & in_files,
    const ProvisioningOptions & in_options
)
```

### Étape 5 : surveiller le provisionnement et récupérer le profil certifié de l’appareil

**Présentation du processus :**

1. Appelez [`Run()`](#function-run) à plusieurs reprises pour traiter les tâches de provisionnement.
2. Appelez [`IsProvisioningRunning()`](#function-isprovisioningrunning) pour vérifier si le provisionnement est terminé.
3. Lorsque `IsProvisioningRunning()` renvoie false, appelez [`GetProvisionedProfile()`](#function-getprovisionedprofile) pour récupérer le profil certifié.

#### Run() <a href="#function-run" id="function-run"></a>

* **Description :**
  * Exécute les tâches d’arrière-plan de Guardian, notamment le traitement de la machine à états du provisionnement.
  * Comprend le provisionnement, la télémétrie, les échanges de prise de contact, l’authentification, les services, les sessions et les canaux qui n’ont pas été placés sur un autre thread, ni dont un élément parent n’a été placé sur un autre thread par [CreateTask](#function-createtask). Cette fonction doit être appelée par la boucle principale du programme ou du thread.
  * Doit être appelée régulièrement et à plusieurs reprises pendant le provisionnement en ligne.
  * Utilisez [IsProvisioningRunning()](#function-isprovisioningrunning) pour vérifier quand le provisionnement est terminé et cesser d’appeler Run().
* **Paramètres :** Aucun paramètre
* **Valeur de retour :** Code d’état indiquant la réussite ou l’échec.
  * **Code de réussite :** `OK` - Les tâches d’arrière-plan ont été exécutées avec succès
  * **Codes d’erreur :**
    * `FAIL` - Échec général du traitement en arrière-plan. Consultez le fichier journal pour en savoir plus.
    * `SHUTDOWN` : Guardian est en état d’arrêt et doit être réinitialisé avant tout nouvel appel à Run.
  * **Voir aussi :** [Tous les codes d’état](/fr/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action :** Traite les machines à états internes et gère la communication avec Guardian Cloud

#### IsProvisioningRunning() <a href="#function-isprovisioningrunning" id="function-isprovisioningrunning"></a>

* **Description :** Vérifie si le processus de provisionnement est toujours actif.
* **Dépendances :**
  * Doit être appelé après `StartProvisioningOnline()`
  * Sert à déterminer quand cesser d’appeler [Run()](#function-run) et tenter de récupérer le profil provisionné.
* **Paramètres :** Aucun : cette fonction ne prend aucun paramètre
* **Valeur de retour :** Valeur booléenne indiquant l’état du provisionnement
  * `true` - Le provisionnement est toujours en cours. Continuez à appeler [Run()](#function-run)
  * `false` - Le provisionnement est terminé (avec succès ou échec). Vous devez maintenant appeler [GetProvisionedProfile()](#function-getprovisionedprofile).
  * Avant le démarrage du processus de provisionnement en ligne, renvoie `false`.
  * Une fois le provisionnement en ligne terminé, qu’il ait réussi ou échoué, renvoie de nouveau `false`.
* **Action :** Indique si le processus de provisionnement est toujours actif

**Syntaxe**

```cpp
bool IsProvisioningRunning()
```

#### GetProvisionedProfile() <a href="#function-getprovisionedprofile" id="function-getprovisionedprofile"></a>

* **Description :**
  * Extrait le profil provisionné après un provisionnement en ligne réussi.
* **Dépendances :**
  * Ne doit être appelé qu’après [IsProvisioningRunning()](#function-isprovisioningrunning) renvoie `false`.
  * Nécessite la réussite de `StartProvisioningOnline()` et de la `Run()` boucle
* **Paramètres :**
  * `out_profile`: Tampon qui recevra le profil provisionné.
    * Type : `char`
  * `io_size`:
    * Indiquez la taille du tampon ( `out_profile` ) en entrée. Une fois le provisionnement réussi, `out_profile` est défini sur la taille réelle du profil.
    * Type : `size_t`
* **Valeur de retour :** Code d’état indiquant la réussite ou l’échec.
  * **Code de réussite :** `OK` : Le profil provisionné a été récupéré avec succès.
    * Le tampon contient un profil certifié valide dans `out_profile` de taille `io_size`.
  * **Codes d’erreur :**
    * `FAIL` : Échec général. Consultez le fichier journal pour plus d’informations.
    * `INCOMPLETE` : Le processus de provisionnement n’est pas terminé ; aucun profil n’est donc disponible.
    * `BADPARAM` - `out_profile` ou `io_size` est un pointeur nul (`nullptr`), ou `io_size` est égal à 0
    * `DENIED` - Le processus de provisionnement en ligne est toujours en cours
    * `FILENOTFOUND` - Le provisionnement est terminé, mais aucun profil provisionné n’est disponible
    * `BADPARAM` - Le paramètre de tampon ou de taille n’est pas valide
  * **Voir aussi :** [Tous les codes d’état](/fr/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action :** Copie le profil provisionné terminé dans le tampon fourni.

**Syntaxe**

```cpp
Status GetProvisionedProfile(
    char * out_profile,
    size_t * io_size
)
```

## Fonctions de gestion des certificats

### GetCertificateManager() <a href="#function-getcertificatemanager" id="function-getcertificatemanager"></a>

* **Description :** Récupère le gestionnaire de certificats pour gérer les certificats de l’appareil. Donne accès aux opérations sur les certificats et à la gestion de leur cycle de vie.
* **Dépendances :**
  * Peut éventuellement être appelé après `Initialize()`
* **Paramètres :**
  * `out_certificate_manager` : pointeur de sortie destiné à recevoir l’instance du gestionnaire de certificats
* **Valeur de retour :** Code d’état indiquant la réussite ou l’échec.
  * **Code de réussite :** `OK` :
    * Gestionnaire de certificats récupéré avec succès
    * Le pointeur dans `out_certificate_manager` est valide
  * **Codes d’erreur :**
    * `FAIL` : Échec général. Consultez le fichier journal pour plus d’informations.
    * `BADPARAM` : `out_certificate_manager` est un pointeur nul et ne peut pas être renseigné
    * `DENIED`  : Guardian n’est pas initialisé
    * `MISCONFIGURED`  : le profil provisionné chargé n’est pas configuré pour autoriser les opérations sur les certificats.
  * **Voir aussi :** [Tous les codes d’état](/fr/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action :**
  * Utilisez le gestionnaire de certificats récupéré pour importer et exporter des certificats.

**Syntaxe**

```cpp
Status GetCertificateManager(
    std::unique_ptr< CertificateManager > * out_certificate_manager
)
```

### GetProvisionedRevocationList() <a href="#function-getprovisionedrevocationlist" id="function-getprovisionedrevocationlist"></a>

* **Description :**
  * Récupère la liste de révocation des certificats (CRL) afin de vérifier la validité des certificats.
  * Permet d’identifier les certificats révoqués auxquels il ne faut plus faire confiance.
* **Dépendances :**
  * Peut éventuellement être appelé après la réussite du provisionnement (après `GetProvisionedProfile` )
* **Paramètres :**
  * `out_ccrl` : tampon destiné à recevoir la liste de révocation des certificats
    * Type : `char*`
  * `io_size` : taille du tampon en entrée, taille réelle en sortie
    * Indiquez la taille du tampon ( `out_ccrl` ) en entrée. Après un provisionnement réussi, `out_ccrl` est défini sur la taille réelle de la CRL.
    * Type : `size_t`
* **Valeur de retour :** Code d’état indiquant la réussite ou l’échec.
  * **Code de réussite :** `OK`
    * `out_ccrl` contient une liste de révocation valide de taille `io_size`
  * **Codes d’erreur :**
    * `FAIL` - Échec général. Consultez le fichier journal pour plus d’informations.
    * `INCOMPLETE` - Le processus de provisionnement n’est pas terminé ; aucune liste de révocation n’est disponible
    * `BADPARAM` : `out_ccrl` ou `io_size` est un pointeur nul, ou `io_size` est égal à 0
    * `DENIED` - Le processus de provisionnement en ligne est toujours en cours
    * `FILENOTFOUND` - Le provisionnement est terminé, mais aucune liste de révocation n’est disponible
  * **Voir aussi :** [Tous les codes d’état](/fr/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action :** Copie la liste de révocation des certificats dans le tampon fourni

**Syntaxe**

```cpp
Status GetProvisionedRevocationList(
    char * out_ccrl,
    size_t * io_size
)
```

## Fonction des opérations de sécurité

### FindSecureOperation() <a href="#function-findsecureoperation" id="function-findsecureoperation"></a>

* **Description :**
  * Recherche le nom d’une opération de sécurité.
  * Récupère le gestionnaire d’opérations de sécurité pour les opérations de signature et de vérification.
* **Dépendances :**
  * Peut éventuellement être appelé après `Initialize()`
* **Paramètres :**
  * `in_secureop_name`: Nom de l’opération de sécurité, terminé par un caractère nul.
    * **Type**: `const char*`
  * `out_secureop`: Pointeur vers le stockage `unique_ptr` de l’opération de sécurité localisée
* **Valeur de retour :** Code d’état indiquant la réussite ou l’échec.
* **Code de réussite :** `OK` : Le pointeur dans `out_secureop` est valide
* **Codes d’erreur :**
  * `FAIL` : Impossible de trouver l’opération spécifiée par `in_secureop_name`
  * `BADPARAM` : `out_secureop` est un pointeur nul et ne peut pas être renseigné
  * `DENIED`  : Guardian n’est pas initialisé
* **Voir aussi :** [Tous les codes d’état](/fr/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action :**
  * Définit `out_secureop` sur l’opération localisée
  * Ne modifie pas `out_secureop` si l’opération `in_secureop_name` n’est pas localisée

**Syntaxe**

```cpp
Status FindSecureOperation(
    const char * in_secureop_name,
    std::unique_ptr< SecureOperation > * out_secureop
)
```

## Fonctions de gestion des services

### FindService() <a href="#function-findservice" id="function-findservice"></a>

* **Description :**
  * Recherche un service par son nom afin de localiser un service configuré.
* **Dépendances :**
  * Doit être appelé après `Initialize()`
* **Paramètres :**
  * `in_service_name`: Nom du service, terminé par un caractère nul
    * **Type :** `const char*`
  * `out_service`: Pointeur vers l’espace de stockage de unique\_ptr pour le service trouvé
* **Valeur de retour :** Code d’état indiquant la réussite ou l’échec.
  * **Code de réussite :** `OK` : Le pointeur dans `out_service` est valide
  * **Codes d’erreur :**
    * `FAIL` : Impossible de trouver le service indiqué par `in_service_name`
    * `BADPARAM` : `out_service` est un pointeur nul et ne peut pas être renseigné
    * `DENIED`  : Guardian n’est pas initialisé
  * **Voir aussi :** [Tous les codes d’état](/fr/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action :**
  * Définit `out_service` sur le service trouvé
  * Ne modifie pas `out_service` si le service indiqué dans `in_service_name` n’est pas trouvé
  * ou le laisse inchangé si le service est introuvable

**Syntaxe**

```cpp
Status FindService(
    const char * in_service_name,
    std::unique_ptr< Service > * out_service
)
```

### **CreateTask() - variante Service** <a href="#function-createtask" id="function-createtask"></a>

* **Description :**
  * Crée une tâche pour les opérations sur un service, en dissociant l’objet fourni et tous ses enfants de Run.
  * Permet d’exécuter des objets distincts dans des threads en les retirant de la boucle principale Guardian Run.
* **Dépendances :**
  * Doit être appelé après `Initialize()`
  * L’objet Service doit être valide
* **Paramètres :**
  * `io_service`: Composant Service à placer dans un thread ; il sera consommé en cas de réussite et restera inchangé en cas d’échec
  * `out_task`: Pointeur vers l’espace de stockage de unique\_ptr pour la tâche
* **Valeur de retour :** Code d’état indiquant la réussite ou l’échec.
  * **Code de réussite :** `OK` : out\_task contient une tâche valide
  * **Codes d’erreur :**
    * `FAIL` : Échec général. Consultez le fichier journal pour plus d’informations.
    * `BADPARAM` : io\_service ou out\_task est un pointeur nul
    * `DENIED` : Le service indiqué appartient déjà à une tâche
  * **Voir aussi :** [Tous les codes d’état](/fr/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action :** Un composant placé dans une Task avec tous ses enfants ne sera pas exécuté lors de l’appel de Guardian Run, ce qui permet d’exécuter des objets distincts dans des threads

**Syntaxe**

```cpp
Status CreateTask(
    std::unique_ptr< Service > * io_service,
    std::unique_ptr< Task > * out_task
)
```

### CreateTask() - variante Session <a href="#function-createtask-session" id="function-createtask-session"></a>

* **Description :**
  * Crée une tâche pour les opérations sur un service, en dissociant l’objet fourni et tous ses enfants de Run.
  * Permet d’exécuter séparément des objets dans des threads en les retirant de la boucle principale [Run](#function-run) .
* **Dépendances :**
  * Peut éventuellement être appelé après `Initialize()`
  * L’objet Service doit être valide
* **Paramètres :**
  * `io_service`: Composant Service à placer dans un thread. Il sera consommé en cas de réussite, mais restera inchangé en cas d’échec.
  * `out_task`: Pointeur vers `unique_ptr` espace de stockage de la tâche
* **Valeur de retour :** Code d’état indiquant la réussite ou l’échec.
  * **Code de réussite :** `OK` : `out_task` contient une tâche valide
  * **Codes d’erreur :**
    * `FAIL` : Échec général. Consultez le fichier journal pour plus d’informations.
    * `BADPARAM` : `io_service` ou `out_task` est un pointeur nul
    * `DENIED` : Le service indiqué appartient déjà à une tâche
  * **Voir aussi :** [Tous les codes d’état](/fr/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action :**
  * Un composant placé sur une Task avec tous ses enfants ne s’exécutera pas lorsque [Run](#function-run) est appelé, ce qui permet d’exécuter séparément des objets dans des threads.
  * Pour réintégrer un objet dans la boucle Run principale, détruisez le unique\_ptr.

**Syntaxe**

```cpp
Status CreateTask(
    std::unique_ptr< Session > * io_session,
    std::unique_ptr< Task > * out_task
)
```

### CreateTask() - variante ChannelGuard <a href="#function-createtask-channelguard" id="function-createtask-channelguard"></a>

* **Description :**
  * Crée une tâche pour les opérations de canal qui sépare l’objet fourni et tous ses enfants de [Run](#function-run).
  * Permet d’exécuter séparément des objets dans des threads en les retirant de la boucle principale [Run](#function-run) .
* **Dépendances :**
  * Doit être appelé après `Initialize()`
  * `ChannelGuard` l’objet doit être valide
* **Paramètres :**
  * `io_channelguard`: `ChannelGuard` composant à placer sur un thread
  * `out_task`: Pointeur vers `unique_ptr` espace de stockage de la tâche
* **Valeur de retour :** Code d’état indiquant la réussite ou l’échec.
  * **Code de réussite :** `OK` : `out_task` contient une tâche valide
  * **Codes d’erreur :**
    * `FAIL` : Échec général. Consultez le fichier journal pour plus d’informations.
    * `BADPARAM` : `io_channelguard` ou `out_task` est un pointeur nul
    * `DENIED` : le `ChannelGuard` spécifié est déjà dans une tâche et n’a pas été réintégré
  * **Voir aussi :** [Tous les codes d’état](/fr/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action :**
  * Un composant placé sur une Task avec tous ses enfants ne s’exécutera pas lorsque [Run](#function-run) est appelé, ce qui permet d’exécuter séparément des objets dans des threads.
  * Pour réintégrer un objet dans la boucle Run principale, détruisez le unique\_ptr.

**Syntaxe**

```cpp
Status CreateTask(
    std::unique_ptr< ChannelGuard > * io_channelguard,
    std::unique_ptr< Task > * out_task
)
```

## **Fonctions de gestion du système**

### GetAuthenticationManager() <a href="#function-getauthenticationmanager" id="function-getauthenticationmanager"></a>

* **Description :**
  * Récupère le gestionnaire d’authentification en cours d’exécution.
  * Donne accès aux opérations d’authentification ainsi qu’aux listes d’autorisation et de refus pour les connexions gérées par l’utilisateur.
* **Dépendances :**
  * Peut éventuellement être appelé après `Initialize()`
* **Paramètres :**
  * `out_authentication_manager` : pointeur vers le stockage unique\_ptr du gestionnaire d’authentification
* **Valeur de retour :** Code d’état indiquant la réussite ou l’échec.
  * **Code de réussite :** `OK` : le pointeur dans `out_authentication_manager` est valide
  * **Codes d’erreur :**
    * `FAIL` : Échec général. Consultez le fichier journal pour plus d’informations.
    * `BADPARAM` : `out_authentication_manager` est un pointeur nul et ne peut pas être renseigné
    * `DENIED`  : Guardian n’est pas initialisé
    * `MISCONFIGURED`  : Le profil chargé n’est pas configuré pour autoriser les opérations d’authentification externe
  * **Voir aussi :** [Tous les codes d’état](/fr/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action :** Utilisez le gestionnaire d’authentification récupéré pour obtenir les listes d’autorisation et de refus des connexions gérées par l’utilisateur

**Syntaxe**

```cpp
Status GetAuthenticationManager(
    std::unique_ptr< AuthenticationManager > * out_authentication_manager
)
```

Récupère le gestionnaire d’authentification en cours d’exécution.

### GetTelemetryManager() <a href="#function-gettelemetrymanager" id="function-gettelemetrymanager"></a>

* **Description :**
  * Récupère le gestionnaire de télémétrie en cours d’exécution.
  * Permet d’accéder aux interactions avec le service de télémétrie.
* **Dépendances :**
  * Peut éventuellement être appelé après `Initialize()`
* **Paramètres :**
  * `out_telemtry_manager` : Pointeur vers `unique_ptr` destiné au stockage du gestionnaire de télémétrie
* **Valeur de retour :** Code d’état indiquant la réussite ou l’échec.
  * **Code de réussite :** `OK`  : Le pointeur dans `out_telemtry_manager` est valide
  * **Codes d’erreur :**
    * `FAIL` : Échec général. Consultez le fichier journal pour plus d’informations.
    * `BADPARAM` : `out_telemtry_manager` est un pointeur nul et ne peut pas être renseigné
    * `DENIED`  : Guardian n’est pas initialisé ou aucun gestionnaire de télémétrie n’est en cours d’exécution
    * `MISCONFIGURED`  : Le profil chargé n’est pas configuré pour la télémétrie
  * **Voir aussi :** [Tous les codes d’état](/fr/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action :** Utilisez le gestionnaire de télémétrie récupéré pour interagir avec le service de télémétrie

**Syntaxe**

```cpp
Status GetTelemetryManager(
    std::unique_ptr< Telemetry > * out_telemtry_manager
)
```

### \~Guardian() <a href="#function-guardian" id="function-guardian"></a>

* **Description :** Le destructeur tente d’arrêter Guardian correctement.
* **Dépendances :** Aucune : le destructeur est appelé automatiquement lorsque l’objet sort de sa portée ou est explicitement supprimé
* **Paramètres :** Aucun : le destructeur ne prend aucun paramètre
* **Valeur de retour :** Aucune, puisqu’il s’agit d’un destructeur.
* **Action :** Le destructeur tentera d’appeler [Shutdown](#function-shutdown) pour effectuer un arrêt en douceur, puis Guardian sera détruit.

**Syntaxe**

```cpp
~Guardian()
```

### Shutdown() <a href="#function-shutdown" id="function-shutdown"></a>

* **Description :**
  * Tente d’arrêter toutes les machines à états internes et de mettre Guardian hors service.
  * Cela inclut le provisionnement, la télémétrie, les poignées de main, l’authentification, les services, les sessions et les canaux, Y COMPRIS ceux qui ont été placés sur un autre thread, ou dont un parent y a été placé, par [CreateTask](#function-createtask).
* **Dépendances :**
  * Peut éventuellement être appelé après `Initialize()`
  * Si des données sont en attente d’envoi, cette fonction renverra un code d’échec ou nécessitera `in_force`
* **Paramètres :**
  * `in_force` : Abandonner toutes les données d’envoi en file d’attente et arrêter le système. La valeur par défaut est `false`.
* **Valeur de retour :** Code d’état indiquant la réussite ou l’échec.
  * **Code de réussite :** `OK` : Guardian s’est arrêté correctement
  * **Codes d’erreur :**
    * `FAIL` : Échec général. Consultez le fichier journal pour plus d’informations.
    * `AGAIN` : Un ou plusieurs transports ont des données en attente d’envoi
  * **Voir aussi :** [Tous les codes d’état](/fr/guardian/api-overview/api-reference/namespaces/namespacemedcrypt-guardian-guardianstatusenum.md)
* **Action :** Arrête toutes les machines à états internes, notamment celles liées au provisionnement, à la télémétrie, aux poignées de main, à l’authentification, aux services, aux sessions et aux canaux.

**Syntaxe**

```cpp
Status Shutdown(
    const bool & in_force =false
)
```

## Débogage et journalisation

Guardian ne crée pas de fichiers journaux. La journalisation est plutôt contrôlée par l’application :

* Guardian écrit les journaux dans `stdout` et `stderr`, qui s’affichent dans le terminal/la CLI de l’application en cours d’exécution. Recherchez dans la sortie les codes d’erreur spécifiques ou les échecs de connexion.
* **Journalisation personnalisée :** Utilisez `SetLoggingCallback` pour rediriger les messages de journalisation vers une fonction de rappel, interrompre leur affichage dans le terminal et permettre un traitement personnalisé des journaux
* **Contrôle de la journalisation :** Les applications peuvent contrôler le niveau et le degré de détail de la journalisation.
* **Interface utilisateur de Guardian Cloud**: Consultez l’interface Guardian Cloud pour obtenir des détails supplémentaires sur les erreurs et connaître l’état du provisionnement.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.medcrypt.com/fr/guardian/api-overview/api-reference/classes/classmedcrypt-guardian-guardian.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.