Attendre un SMS

Résumé

Nom interne : WaitSms
Catégorie : SMS
Objectif : Bloquer l'exécution du workflow et attendre la réception d'un SMS correspondant à des filtres optionnels sur l'expéditeur et le contenu, puis capturer le message dans des variables de workflow.
Type de tâche : Normale

Compatibilité

Version minimale AndroMate : 1.1.0
Version maximale AndroMate : 1.1.0
Android minimum : Android 13 (API 33)
Android maximum testé : Android 16 (API 36)
Constructeurs supportés :
- ✅ Samsung (One UI 6.x / 7.x / 8.x)
- ✅ Google Pixel (Android Stock)
- ⚠️ Autres constructeurs — non testés
Permissions requises :
- RECEIVE_SMS

Description détaillée

La tâche Attendre un SMS bloque l'exécution et écoute l'arrivée d'un SMS entrant sur l'appareil. Elle s'abonne au bus d'événements SMS interne d'AndroMate et attend qu'un SMS correspondant soit reçu ou que le délai d'attente expire.

Lorsqu'un SMS correspondant est reçu, la tâche capture :

Le corps du message du SMS reçu
Le numéro de téléphone de l'expéditeur (MSISDN)
L'horodatage (en millisecondes) auquel le SMS a été reçu

Règles de correspondance :

Si expected_msisdn est vide → accepte les SMS de n'importe quel expéditeur
Si expected_msisdn est renseigné → l'expéditeur doit correspondre exactement
Si expected_message est vide → accepte n'importe quel corps de message
Si expected_message est renseigné et use_regex est false → le corps doit correspondre exactement
Si expected_message est renseigné et use_regex est true → le corps est testé contre la valeur comme une expression régulière Java

Paramètres d'entrée

Paramètre	Type	Obligatoire	Valeurs possibles	Compatibilité Android	Compatibilité AndroMate	Défaut
`expected_msisdn`	String	Non	Numéro de téléphone E.164 ou `""` pour accepter tout expéditeur — supporte les références `$variable`	Android 13 (API 33) → Android 16 (API 36)	1.1.0 → 1.1.0	`""`
`expected_message`	String	Non	Toute chaîne ou pattern regex — `""` pour accepter tout message — supporte les références `$variable`	Android 13 (API 33) → Android 16 (API 36)	1.1.0 → 1.1.0	`""`
`use_regex`	Boolean	Non	`true` / `false`	Android 13 (API 33) → Android 16 (API 36)	1.1.0 → 1.1.0	`false`
`wait_sms_timeout_s`	Integer	Non	Entier ≥ 0 (secondes)	Android 13 (API 33) → Android 16 (API 36)	1.1.0 → 1.1.0	`10`

Paramètres de sortie

Champ	Type	Condition de déclenchement	Compatibilité Android	Compatibilité AndroMate	Défaut
`message_received_output`	String	Écrit lorsqu'un SMS correspondant est reçu — contient le corps du message	Android 13 (API 33) → Android 16 (API 36)	1.1.0 → 1.1.0	`<ANDROMATE_NULL_VALUE>`
`msisdn_sender_output`	String	Écrit lorsqu'un SMS correspondant est reçu — contient le numéro de l'expéditeur	Android 13 (API 33) → Android 16 (API 36)	1.1.0 → 1.1.0	`<ANDROMATE_NULL_VALUE>`
`wait_time_output`	Long	Écrit lorsqu'un SMS correspondant est reçu — contient l'horodatage de réception en millisecondes	Android 13 (API 33) → Android 16 (API 36)	1.1.0 → 1.1.0	`<ANDROMATE_NULL_VALUE>`

Remarque : Les variables de sortie ne sont écrites que si la variable workflow correspondante existe déjà dans le contexte d'exécution (déclarée dans la tâche Start).

Exceptions

Code	Nom de l'exception	Description
`WAIT-SMS-TASK-001`	Délai d'attente SMS expiré	Aucun SMS correspondant n'a été reçu dans le délai imparti par `wait_sms_timeout_s`.
`ERROR-000`	Autre erreur	Une erreur runtime inattendue s'est produite pendant l'exécution.

Diagramme d'exécution

Le diagramme suivant illustre l'implémentation réelle basée sur le code Android :

flowchart TD
    Start([Démarrer WaitSmsTask]) --> ResolveParams[🔄 Résoudre expected_msisdn\n+ expected_message]
    ResolveParams --> Subscribe[📡 S'abonner au\nSmsEventBus]
    Subscribe --> WaitLoop{Attendre un événement SMS\ndans le délai imparti}

    WaitLoop -->|SMS reçu| CheckMsisdn{Vérifier le MSISDN\nde l'expéditeur}

    CheckMsisdn -->|expected_msisdn vide| MsisdnOk[✅ MSISDN accepté\nn'importe quel expéditeur]
    CheckMsisdn -->|correspond à expected_msisdn| MsisdnOk
    CheckMsisdn -->|ne correspond pas| WaitLoop

    MsisdnOk --> CheckBody{Vérifier le corps\ndu message}

    CheckBody -->|expected_message vide| BodyOk[✅ Corps accepté\nn'importe quel contenu]
    CheckBody -->|use_regex = false\ncorrespond exactement| BodyOk
    CheckBody -->|use_regex = true\ncorrespond au regex| BodyOk
    CheckBody -->|ne correspond pas| WaitLoop

    BodyOk --> Capture[💾 Capturer corps → message_received_output\nCapturer expéditeur → msisdn_sender_output\nCapturer horodatage → wait_time_output]
    Capture --> Unsubscribe[🔕 Se désabonner du SmsEventBus]
    Unsubscribe --> Success([✅ WaitSmsResult])

    WaitLoop -->|Délai expiré| E1[❌ WAIT-SMS-TASK-001]
    E1 --> Error([❌ Exception])

    style Start fill:#e3f2fd
    style Success fill:#c8e6c9
    style Error fill:#ffcdd2
    style E1 fill:#ffcdd2
    style ResolveParams fill:#fff9c4
    style Subscribe fill:#e3f2fd
    style MsisdnOk fill:#c8e6c9
    style BodyOk fill:#c8e6c9
    style Capture fill:#c8e6c9
    style Unsubscribe fill:#fff9c4

Comment ça fonctionne :

Résoudre les paramètres : expected_msisdn et expected_message sont résolus depuis le contexte workflow
S'abonner : enregistre un listener sur le bus d'événements SMS interne d'AndroMate
Boucle d'attente : pour chaque SMS entrant dans la fenêtre de délai :
Vérification MSISDN : si expected_msisdn est renseigné, compare avec l'expéditeur — ignore si pas de correspondance
Vérification corps : si expected_message est renseigné, compare en exact ou regex — ignore si pas de correspondance
Correspondance trouvée : capture corps, expéditeur et horodatage dans les variables de sortie ; se désabonne du bus
Délai dépassé : si aucun SMS correspondant n'arrive dans wait_sms_timeout_s secondes — lève WAIT-SMS-TASK-001

Exemples de code

Exemple 1 — Attendre n'importe quel SMS (tout expéditeur, tout contenu)

{
  "WaitSms": [
    {
      "id": "1",
      "title": "Attendre n'importe quel SMS",
      "wait_sms_timeout_s": 30,
      "message_received_output": "$corps_recu",
      "msisdn_sender_output": "$numero_expediteur"
    }
  ]
}

Exemple 2 — Attendre un SMS d'un expéditeur spécifique

{
  "WaitSms": [
    {
      "id": "2",
      "title": "Attendre SMS du serveur",
      "expected_msisdn": "+33600000000",
      "wait_sms_timeout_s": 60,
      "message_received_output": "$corps_sms",
      "msisdn_sender_output": "$expediteur_sms"
    }
  ]
}

Exemple 3 — Attendre un SMS correspondant à un pattern regex

{
  "WaitSms": [
    {
      "id": "3",
      "title": "Attendre un code OTP",
      "expected_msisdn": "+33600000000",
      "expected_message": ".*code[:\\s]+\\d{6}.*",
      "use_regex": true,
      "wait_sms_timeout_s": 120,
      "message_received_output": "$sms_otp",
      "msisdn_sender_output": "$expediteur_otp",
      "wait_time_output": "$otp_recu_a_ms"
    }
  ]
}

Exemple 4 — Attendre un contenu exact

{
  "WaitSms": [
    {
      "id": "4",
      "title": "Attendre ACK",
      "expected_message": "ACK",
      "use_regex": false,
      "wait_sms_timeout_s": 30,
      "message_received_output": "$corps_ack"
    }
  ]
}

Détails des paramètres d'entrée

1. Paramètre d'entrée : `expected_msisdn`

Numéro de téléphone de l'expéditeur SMS attendu au format E.164. Si vide, la tâche accepte les SMS de n'importe quel expéditeur.

Défaut : "" (accepter tout expéditeur)
Supporte les variables : Oui

2. Paramètre d'entrée : `expected_message`

Contenu attendu du corps du SMS. Si vide, la tâche accepte n'importe quel contenu de message.

Quand use_regex = false : le corps reçu doit correspondre exactement (comparaison de contenu)
Quand use_regex = true : le corps reçu est testé contre cette valeur comme une expression régulière Java
Défaut : "" (accepter tout contenu)
Supporte les variables : Oui

3. Paramètre d'entrée : `use_regex`

Contrôle comment expected_message est appliqué quand il n'est pas vide.

Valeur	Mode de correspondance
`false`	Comparaison de contenu exacte
`true`	Correspondance par pattern regex Java (`String.matches()`)

Défaut : false

4. Paramètre d'entrée : `wait_sms_timeout_s`

Durée maximale en secondes pendant laquelle la tâche bloque en attendant un SMS correspondant. Si aucun SMS correspondant n'arrive avant l'expiration, lève WAIT-SMS-TASK-001.

Défaut : 10 secondes
Minimum recommandé : 5 secondes

Détails des paramètres de sortie

1. Variable résultat : `message_received_output`

Stocke le corps du SMS reçu dans la variable workflow spécifiée.

2. Variable résultat : `msisdn_sender_output`

Stocke le numéro de téléphone de l'expéditeur (tel que rapporté par l'API téléphonie Android) dans la variable workflow spécifiée.

3. Variable résultat : `wait_time_output`

Stocke l'horodatage (en millisecondes depuis l'époque) auquel le SMS a été reçu, tel que rapporté par le SmsEvent. Utile pour mesurer la latence de livraison des SMS.

Exemple JSON complet

{
  "WaitSms": [
    {
      "id": "1",
      "title": "Attendre SMS OTP",
      "expected_msisdn": "+33600000000",
      "expected_message": ".*code[:\\s]+\\d{6}.*",
      "use_regex": true,
      "wait_sms_timeout_s": 60,
      "message_received_output": "$corps_sms",
      "msisdn_sender_output": "$expediteur_sms",
      "wait_time_output": "$sms_recu_a"
    }
  ]
}