Aperçu des Tâches

Qu'est-ce qu'une tâche ?

Une tâche est l'unité d'exécution fondamentale d'un workflow. Chaque tâche représente une action unique effectuée sur un appareil Android — exécuter une commande shell, envoyer une requête HTTP, comparer des valeurs, détecter des erreurs, et bien plus encore.

Les tâches sont les nœuds du graphe de workflow. Le moteur d'exécution parcourt ce graphe à partir du nœud START et exécute chaque tâche dans l'ordre jusqu'à atteindre un nœud END.

Trois types de tâches

AndroMate distingue trois catégories de tâches, qui diffèrent dans la façon dont elles se connectent au reste du workflow.

1. Tâches Normales

Une tâche normale effectue une action spécifique et possède exactement un seul lien sortant. Une fois terminée, le moteur passe inconditionnellement à la tâche suivante définie par le champ "to".

Exemples : CmdStage, HttpRequest, Sleep, TextReport, GetCurrentLocation, DnsLookup, SetVariable, NtpSync, ScreenAutomator, etc.

Format JSON du lien :

{
  "from": "1",
  "to": "2"
}

Flux d'exécution :

[Tâche 1] ──→ [Tâche 2] ──→ [Tâche 3] ──→ ...

Exceptions de tâche

Chaque tâche normale peut générer une exception en cas de problème (échec réseau, erreur de l'appareil, délai d'attente dépassé, entrée invalide, etc.). Le moteur d'exécution enregistre cette exception dans le contexte d'exécution et l'associe à la tâche qui l'a déclenchée.

Une exception contient :

Champ	Description
Code d'erreur	Un identifiant numérique ou textuel du type d'erreur
Description	Un message lisible expliquant ce qui s'est passé
ID de la tâche	L'identifiant de la tâche qui a échoué

Le workflow ne s'arrête pas automatiquement sur une exception (sauf si la politique d'exécution est configurée à STOP_ON_ERROR). Vous pouvez inspecter explicitement la dernière exception grâce à la tâche conditionnelle dédiée : Exception ?.

2. Tâches Conditionnelles

Une tâche conditionnelle évalue une condition et retourne un résultat booléen (true ou false). Selon ce résultat, le moteur dirige l'exécution vers l'une de deux branches distinctes.

Exemples : CompareStrings, CompareNumber, AndromateException

Format JSON du lien :

{
  "from": "2",
  "true": "3",
  "false": "4"
}

Signification :

La condition de la tâche 2 est true → exécuter la tâche 3
La condition de la tâche 2 est false → exécuter la tâche 4

Flux d'exécution :

[Tâche Conditionnelle]
    ├─→ TRUE  ──→ [Branche A]
    └─→ FALSE ──→ [Branche B]

Tâches conditionnelles disponibles

Clé JSON	Nom affiché	Description
`CompareStrings`	Comparer des chaînes	Compare deux valeurs textuelles
`CompareNumber`	Comparer des nombres	Compare deux valeurs numériques
`AndromateException`	Exception ?	Vérifie si la tâche précédente a levé une exception

3. Tâches Connecteur

Une tâche connecteur ressemble de l'extérieur à une tâche normale — elle possède exactement un seul lien sortant ("to"), et le moteur continue toujours vers celui-ci une fois la tâche connecteur terminée. Ce qui la distingue : une tâche connecteur enveloppe un sous-workflow imbriqué, intégré directement dans sa propre entrée JSON sous une clé "do", et exécute ce sous-workflow un certain nombre de fois avant de continuer.

C'est le mécanisme natif d'AndroMate pour exprimer une boucle — une alternative à la technique manuelle consistant à faire pointer un Links vers une tâche antérieure (toujours valide, et toujours la seule option pour les boucles conditionnelles/de nouvelle tentative).

Exemples : Iterate, ForEachElement

Format JSON du lien (graphe externe) :

{
  "from": "1",
  "to": "2"
}

Identique à une tâche normale — le bouclage de la tâche connecteur est entièrement interne ; elle n'introduit jamais de chemin sortant supplémentaire dans le graphe externe.

Le sous-workflow imbriqué ("do") :

{
  "do": {
    "StartSubTask": [{ "id": "sub-0" }],
    "TextReport": [{ "id": "sub-1", "texte": "iteration", "texte_type": 0 }],
    "End": [{ "id": "sub-100" }],
    "Links": [
      { "from": "sub-0", "to": "sub-1" },
      { "from": "sub-1", "to": "sub-100" }
    ]
  }
}

Le point d'entrée du sous-workflow est StartSubTask, et non Start — il ne porte qu'un "id", sans variables/Time_out/exec_policy (qui appartiennent exclusivement au Start réel du workflow externe).
Il possède son propre End et ses propres Links, limités aux ids du sous-workflow — donnez-leur un motif distinct (ex. un préfixe sub-) pour qu'ils n'entrent jamais en collision avec les ids du graphe externe.
N'importe quel type de tâche peut être utilisé dans "do", y compris une autre tâche connecteur (boucles imbriquées).
Les variables sont partagées, pas isolées : le sous-workflow lit et écrit exactement le même dictionnaire de variables que le workflow externe. Une variable déclarée dans le Start.variables externe est visible dans "do", et toute sortie produite par une tâche à l'intérieur de "do" est immédiatement visible par les tâches qui suivent la tâche connecteur dans le graphe externe.

Flux d'exécution (exemple Iterate) :

[Tâche Connecteur] ──exécute le sous-workflow "do" N fois──┐
                                                             │
        ┌────────────────────────────────────────────────────┘
        ▼
[Tâche suivante dans le graphe externe] ──→ ...

Tâches connecteur disponibles

Clé JSON	Nom affiché	Description
`Iterate`	Iterate	Exécute le sous-workflow `"do"` une fois par entier de `start_index` à `end_index` inclus, en exposant la valeur courante dans `iteration_variable_input`
`ForEachElement`	For Each Element	Exécute le sous-workflow `"do"` une fois par élément d'une variable liste, en exposant l'élément courant dans `element_variable_input`

Voir les pages Iterate et For Each Element pour le détail complet des paramètres et exceptions.

La tâche `Exception ?` (`AndromateException`)

La tâche Exception ? est une tâche conditionnelle spéciale dédiée à la gestion des erreurs. Elle inspecte le contexte d'exécution pour déterminer si la dernière tâche exécutée a produit une exception.

Retourne true — la tâche précédente a échoué (une exception a été levée)
Retourne false — la tâche précédente s'est terminée avec succès (aucune exception)

Placez-la après toute tâche susceptible d'échouer pour détecter les erreurs et bifurquer en conséquence. Elle peut également capturer les détails de l'exception dans des variables du workflow pour les rapports ou les traitements ultérieurs :

Champ JSON	Description
`code_output`	Variable pour stocker le code d'erreur
`description_output`	Variable pour stocker la description de l'erreur
`task_id_output`	Variable pour stocker l'ID de la tâche en échec

Exemple JSON :

{
  "CmdStage": [
    {
      "id": "1",
      "title": "Lancer le ping",
      "cmd_text": "ping -c 1 8.8.8.8"
    }
  ],

  "AndromateException": [
    {
      "id": "2",
      "title": "Exception ?",
      "code_output": "$code_erreur",
      "description_output": "$desc_erreur",
      "task_id_output": "$id_tache_echouee"
    }
  ],

  "TextReport": [
    {
      "id": "3",
      "title": "Journaliser l'erreur",
      "texte": "Tâche $id_tache_echouee en échec : [$code_erreur] $desc_erreur"
    },
    {
      "id": "4",
      "title": "Journaliser le succès",
      "texte": "Ping terminé avec succès"
    }
  ],

  "End": [{ "id": "100", "title": "Fin" }],

  "Links": [
    { "from": "0", "to": "1" },
    { "from": "1", "to": "2" },
    { "from": "2", "true": "3", "false": "4" },
    { "from": "3", "to": "100" },
    { "from": "4", "to": "100" }
  ]
}

Exécution du workflow sous forme de graphe

Les workflows sont représentés sous forme de graphes orientés. Le moteur d'exécution les parcourt en suivant cet algorithme :

Démarrer au nœud START (point d'entrée du workflow)
Exécuter la tâche courante
Déterminer le nœud suivant :
Tâche normale → suivre le lien "to"
Tâche conditionnelle → évaluer la condition, puis suivre "true" ou "false"
Tâche connecteur → exécuter son sous-workflow imbriqué "do" jusqu'à la fin (éventuellement plusieurs fois), puis suivre le lien "to"
Répéter à partir de l'étape 2 avec le nœud suivant
S'arrêter en atteignant un nœud END

Le graphe supporte les boucles (une tâche conditionnelle pointant vers une tâche antérieure), utiles pour la logique de nouvelle tentative ou d'attente. Un maximum de 5000 itérations est imposé pour éviter les boucles infinies.

flowchart TD
    START([▶ START]) --> T1[Tâche Normale 1]
    T1 --> T2[Tâche Normale 2]
    T2 --> COND{Tâche Conditionnelle}
    COND -->|TRUE| T3[Branche A]
    COND -->|FALSE| T4[Branche B]
    T3 --> END([⏹ END])
    T4 --> END

    style START fill:#e3f2fd
    style END fill:#c8e6c9
    style COND fill:#fff9c4
    style T3 fill:#e0f0e0
    style T4 fill:#ffe0e0

Récapitulatif des formats de liens

Type de tâche	Champs JSON	Chemins sortants	Comportement
Tâche normale	`"from"`, `"to"`	1	Continue toujours vers `"to"`
Tâche conditionnelle	`"from"`, `"true"`, `"false"`	2	Dirige vers `"true"` ou `"false"` selon l'évaluation
Tâche connecteur	`"from"`, `"to"` (externe) + `"do"` (sous-workflow imbriqué)	1	Exécute le sous-workflow `"do"` jusqu'à la fin, éventuellement plusieurs fois, puis continue toujours vers `"to"`

Lien normal associé

Chaque tâche normale est connectée par un lien normal. Elle possède exactement un chemin sortant — le workflow continue toujours vers "to" quel que soit le résultat de la tâche.

{ "from": "1", "to": "2" }

Champ	Description
`"from"`	ID de la tâche normale courante
`"to"`	ID de la prochaine tâche à exécuter

Lien conditionnel associé

Chaque tâche conditionnelle est connectée par un lien conditionnel. Elle possède exactement deux chemins sortants — le moteur évalue le résultat booléen et dirige en conséquence.

{ "from": "2", "true": "3", "false": "4" }

Champ	Description
`"from"`	ID de la tâche conditionnelle
`"true"`	ID de la tâche à exécuter si la condition vaut `true`
`"false"`	ID de la tâche à exécuter si la condition vaut `false`

Lien connecteur associé

Chaque tâche connecteur est connectée par un lien normal dans le graphe externe — exactement comme une tâche normale, un seul chemin sortant via "to". Le comportement de bouclage vit entièrement dans le champ "do" de la tâche, pas dans le lien.

{ "from": "1", "to": "2" }

Champ	Description
`"from"`	ID de la tâche connecteur
`"to"`	ID de la prochaine tâche à exécuter, une fois le sous-workflow `"do"` terminé