Dans le développement des applications vocales Twilio, la mise en attente de l'appel et la récupération ultérieure est une exigence commune. Cependant, les opérations de mise à jour directes sur une seule étape d'appel, comme la modification de son URL Twiml, conduisent souvent à une déconnexion inattendue des appels de l'autre partie. En effet, lorsqu'une instruction TWIML pour une jambe d'appel est exécutée ou redirigée, Twilio considérera que le processus actuel pour cette jambe est terminé. Cet article introduira deux fa?ons d'activer la rétention et la récupération des appels: l'utilisation des fonctionnalités de conférence Twilio (recommandées) et la gestion des jambes d'appel indépendantes.

Méthode 1: Utilisez la conférence Twilio (recommandée)

La fonction de conférence Twilio est le moyen le plus simple et le plus robuste de garder les appels et de récupérer. Une réunion est essentiellement une salle virtuelle qui relie plusieurs participants ensemble. Dans ce mode, vous pouvez contr?ler indépendamment l'état de chaque participant à la réunion, y compris le mettre en état de maintien.

1. Mettez les participants en attente

Lorsqu'une jambe d'appel rejoint une réunion en tant que participant, vous pouvez la mettre en attente en mettant à jour les ressources de ce participant. Cela implique d'envoyer une demande de mise à jour à l'API Twilio, de définir la propriété Hold du participant à True et de spécifier un HoldUrl pour jouer la musique Hold.

Exemple de code (PHP):

  Php
// Supposons que vous avez installé la bibliothèque Twilio PHP require_once 'fournisseur / autoload.php' via Composer;

Utilisez Twilio \ REST \ CLIENT;

// votre compte Twilio SID et Auth
$ sid = "acxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; // remplace par votre compte sid
$ token = "your_auth_token"; // Remplacez par votre jeton AUTH
$ client = nouveau client ($ sid, $ token);

// Supposons que vous ayez déjà une conférence Sid et un participant SID
$ conférencesId = "Cfxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx; // votre SID de réunion
$ participantsID = "Caxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx; // participant SID pour maintenir

essayer {
    $ participant = $ client
        -> Conférences ($ conférencesID)
        -> Participants ($ participants à)
        -> Mise à jour ([
            "Hold" => true,
            "HoldUrl" => "http://www.myapp.com/hold_music.mp3" // Gardez l'URL de la musique
        ]));

    écho "participant". $ participant-> CALDID. "Placé avec succès dans l'état de main. \ N";
} catch (exception $ e) {
    écho "Une erreur s'est produite tout en mettant les participants à l'état de maintien:". $ e-> getMessage (). "\ n";
}
?>

Dans le code ci-dessus, lorsque Hold est défini sur True, Twilio jouera l'audio spécifié par Holdurl au participant, et d'autres participants à la réunion ne pourront pas entendre le participant.

2. Reprendre l'appel

Pour restaurer un participant de Keep à la réunion, mettez simplement à jour la ressource du participant et définissez la propriété Hold sur False.

Exemple de code (PHP):

  Php
// Supposons que vous avez installé la bibliothèque Twilio PHP require_once 'fournisseur / autoload.php' via Composer;

Utilisez Twilio \ REST \ CLIENT;

// votre compte Twilio SID et Auth
$ sid = "acxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; // remplace par votre compte sid
$ token = "your_auth_token"; // Remplacez par votre jeton AUTH
$ client = nouveau client ($ sid, $ token);

// Supposons que vous ayez déjà une conférence Sid et un participant SID
$ conférencesId = "Cfxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx; // votre SID de réunion
$ participantsID = "Caxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx; // Le participant est restauré pour être restauré

essayer {
    $ participant = $ client
        -> Conférences ($ conférencesID)
        -> Participants ($ participants à)
        -> Mise à jour ([
            "Hold" => false
        ]));

    écho "participant". $ participant-> CALDID. "Récupéré avec succès de Hold. \ N";
} catch (exception $ e) {
    écho "Une erreur s'est produite lors de la récupération des participants:". $ e-> getMessage (). "\ n";
}
?>

Notes:

• Utilisez la fonction de réunion pour simplifier la gestion de l'état car Twilio gère la logique de connexion à l'intérieur de la réunion.
• HoldUrl peut être n'importe quelle URL de fichier audio accessible, prenant en charge les formats MP3 et WAV.

Méthode 2: gérer les jambes d'appel indépendantes (avancé)

Si vous choisissez de ne pas utiliser la fonction de réunion, mais gérez plut?t directement deux pattes d'appel distinctes, il sera plus compliqué pour obtenir la tenue des appels. En effet, lorsque vous mettez à jour le Twiml d'une jambe d'appel (par exemple, le redirigeant vers un hold Twiml), l'instruction TWIML actuelle d'une autre étape d'appel continue d'exécuter et une fois exécutée, la jambe d'appel raccroche.

1. Comprendre la question: pourquoi l'autre partie se casse-t-elle?

Le scénario décrit dans la question initiale, c'est-à-dire que "lorsque l'appel est maintenu, l'appel est déconnecté", est une incarnation de ce mécanisme. Lorsque vous mettez à jour un appel via l'API (par exemple, pointant son Twiml vers une URL qui joue et tient de la musique), le flux Twiml de cette jambe d'appel est interrompu et pointe vers la nouvelle URL. Une autre jambe d'appel qui lui est connectée, son instruction TWIML (généralement ) supposera que sa cible de connexion a été "terminée", ce qui fait que le processus TWIML de cette jambe continue l'exécution et raccroche automatiquement s'il n'y a pas d'autres instructions à l'avenir.

Analyse de l'extrait de code d'origine:

 // ...
$ rr = array (
  "URL" => "http://demo.twilio.com/docs/voice.xml", // nouvelle URL Twiml
  "méthode" => "post"
));
$ call = $ client-> appels ($ callId) -> Update ($ rr); // Mette à jour l'appelant // ...

Ce code met à jour la source Twiml de la jambe d'appel représentée par $ CALSID à http://demo.twilio.com/docs/voice.xml. Si $ CALSID est l'appel et qu'il a été précédemment connecté à l'appel via , alors lorsque le TWIML de l'appel est mis à jour, l'instruction exécutée par l'appel examinera sa connexion "terminée", et le Twiml de l'appel continuera d'être exécuté (s'il y en aura une suivante), sinon il raccrochera.

2. Fournir un suivi Twiml pour les jambes non-resserrées

Pour éviter la déconnexion des jambes non qui ne retient que lorsque l'appelant est tenu, vous devez fournir des instructions de suivi dans son Twiml. Par exemple, ajoutez après la directive pour faire passer l'appel vers une autre URL:

Exemple Twiml:

 <spepply>
  <sallow> Customer_number  
  <dedirect> https://example.com/hold_waiting  
</dedirect></sallow></spepply>

Dans cet exemple, lorsque l'opération est terminée (par exemple, car l'autre jambe est maintenue ou redirigea), l'appel ne raccrochera pas, mais redirigera vers Twiml fourni par https://example.com/hold_waiting. Ce Twiml peut lire une tonalité rapide pour informer l'utilisateur qu'il attend.

3. Mettre en ?uvre une stratégie pour garder et restaurer

Pour obtenir une rétention et une récupération complètes, les stratégies suivantes peuvent être adoptées:

• Gardez-le en action:

  • Mettez à jour le Twiml des jambes d'appel (par exemple, les jambes de l'agent) qui doivent être conservées via l'API pour jouer l'URL Twiml de la musique de maintien.
  • Mettez à jour le Twiml d'une autre étape d'appel (par exemple, la jambe du client) via l'API à l'URL Twiml qui fait la queue pour l'appel (). De cette fa?on, les jambes du client ne raccrocheront pas, mais seront dans une file d'attente en attente.

  Exemple Twiml pour la file d'attente:

   <spepply>
    <enqueue waitlurl="http://www.myapp.com/wait_music.mp3"> myCustomerQueue  Enqueue>
  </enqueue></spepply>

• Opération de récupération:

  • Mettez à jour le Twiml de la jambe de l'agent vers l'URL Twiml qui se connecte à la file d'attente du client via la directive .
  • Lorsque les jambes de l'agent sont composées dans la file d'attente, Twilio connectera les jambes de l'agent aux jambes du client en attente dans la file d'attente.

  Exemple Twiml pour composer la file d'attente:

   <spepply>
    <alal> <outre> MyCustomerQueue  queue> 
  </outre></alal></spepply>

Notes:

• Cette approche vous oblige à gérer manuellement l'état des deux pattes d'appel et le flux Twiml, avec une augmentation significative de la complexité.
• Vous devez vous assurer que votre application est en mesure de suivre l'état actuel et le SID d'appel correspondant de chaque étape d'appel.
• La gestion des erreurs et les cas de bord (comme les clients qui n'attendent pas dans la file d'attente) doivent être soigneusement considérés.

Résumé et meilleures pratiques

D'après les deux méthodes ci-dessus, on peut voir que l'utilisation de la fonction de conférence Twilio est le moyen le plus recommandé de maintenir et de restaurer les appels. Il fournit une gestion intégrée de l'état et des API simplifiées qui réduisent considérablement la complexité du développement.

• Plan préféré: réunion Twilio. Si votre cas d'utilisation permet les réunions, assurez-vous de sélectionner ce scénario. Il fournit des fonctionnalités plus puissantes (telles que plusieurs participants, muet, coups de pied, etc.) et maintient et restaure les opérations intuitives et faciles à mettre en ?uvre.
• Solution avancée: jambes d'appel indépendantes. Envisagez de gérer manuellement les jambes d'appel indépendantes uniquement si votre scénario de demande a des restrictions spéciales et ne peut pas utiliser la fonction de réunion. Cette approche vous oblige à avoir une compréhension approfondie des flux TWIML et des appels API de Twilio, et nécessite plus de code pour gérer l'état des appels, reconnecter la logique et les situations d'erreur.

Quelle que soit la méthode que vous choisissez, il est crucial de comprendre comment fonctionne Twilio Twiml et comment l'API affecte l'état de l'appel. En concevant rationnellement votre logique Twiml et backend, vous pouvez créer une application vocale Twilio robuste et expérimentée.