Reconnexion et résilience du réseau

Les commutateurs réseau et les coupures de connexion de courte durée peuvent interrompre la transmission multimédia des appels. Le SDK gère automatiquement la reconnexion dans la plupart des cas : utilisez les événements liés au cycle de vie multimédia et les API de reconnexion pour tenir les utilisateurs informés et rétablir la connexion lorsque cela est possible.

Fonctionnement de la reconnexion automatique

Lorsque le SDK détecte une interruption de la transmission multimédia (échec de la connexion ICE, changement de réseau), il tente automatiquement de rétablir la connexion en relançant ICE sur la connexion du pair.

Synchronisation et comportement en cas de nouvelle tentative

Que se passe-t-il à chaque étape ?

1. Se reconnecter — Le SDK détecte une interruption de la diffusion multimédia et déclenche onCallMediaReconnecting. Il effectue jusqu’à 5 tentatives de redémarrage de l’ICE, espacées de 3 secondes. Aucune intervention de la part du développeur n’est requise pendant cette phase.

2. Reconnecté — Si l'une des tentatives de réessai aboutit, le SDK déclenche onCallMediaReconnection. Le flux audio est rétabli et l'appel se poursuit normalement.

3. Échec — Si les 5 tentatives automatiques ont été épuisées, ou si le serveur renvoie une erreur lors de la reconnexion, le SDK déclenche onCallMediaDisconnect. À ce stade :

   • Le son s'est arrêté
   • La session d'appel est peut-être encore active sur le serveur
   • Le développeur peut tenter une restauration manuelle à l'aide de reconnectCall(callId) si la connexion réseau a été rétablie
   • Si aucune reprise n'intervient, le serveur finira par mettre fin à l'appel et onCallHangup incendies avec mediaTimeout raison

Reconnexion au niveau de la session

Outre la reconnexion des médias, le SDK reconnecte également automatiquement la session WebSocket en cas de perte de connexion :

Incendies liés à la reconnexion de session onReconnecting et onReconnection événements (à ne pas confondre avec les événements « call media » mentionnés ci-dessus).

onCallMediaDisconnect

Se déclenche en cas de perte définitive de la connexion multimédia — une fois les 5 tentatives de reconnexion automatique épuisées, ou à la suite d’une erreur serveur irrémédiable. À ce stade, le flux audio est interrompu, mais la session d’appel peut encore être active sur le serveur. Vous pouvez tenter une récupération manuelle à l’aide de reconnectCall(callId).

client.on(
  'callMediaDisconnect',
  (callId: string, reason: CallDisconnectReason) => {
    if (reason === 'networkChange') {
      console.log(`Call ${callId} was disconnected due to a network change`);
    } else {
      exhaustiveCheck(reason);
    }
  }
);

 client.setOnCallMediaDisconnectListener { legId, reason ->
     when (reason) {
         CallDisconnectReason.networkChange -> println("Received call media disconnect $reason for Call $legId")
     }

 }

 client.setOnCallMediaDisconnectListener((legId, reason) -> {
     if (reason == CallDisconnectReason.networkChange) {
         System.out.println("Received call media disconnect " + reason + " for Call " + legId);
     }
     return null;
 });

 func voiceClient(_ client: VGVoiceClient, didReceiveMediaDisconnectForCall callId: VGCallId, reason: VGCallDisconnectReason) {
     print("leg \(callId) has received media disconnect for \(reason)")
 }

 - (void) voiceClient:(VGVoiceClient *)client didReceiveMediaDisconnectForCall:(VGCallId)callId reason:(VGCallDisconnectReason)reason {
     NSLog(@"Leg %@ has received media disconnect for reason %ld", callId, reason);
 }

onCallMediaReconnecting

Se déclenche lorsque le SDK détecte une interruption de la transmission multimédia (comme le passage du Wi-Fi au réseau mobile) et tente automatiquement de rétablir la connexion. Aucune intervention de l'utilisateur n'est nécessaire : affichez un indicateur « reconnexion en cours » dans votre interface utilisateur.

client.on('callMediaReconnecting', (callId) => {
  console.log(`Call media is reconnecting for call ${callId}`);
});

 client.setOnCallMediaReconnectingListener { legId ->
     println("Received call media reconnecting for Call $legId")
 }

 client.setOnCallMediaReconnectingListener((legId) -> {
     System.out.println("Received call media reconnecting for Call " + legId);
     return null;
 });

 func voiceClient(_ client: VGVoiceClient, didReceiveMediaReconnectingForCall callId: VGCallId) {
     print("leg \(callId) is Reconnecting")
 }

 - (void) voiceClient:(VGVoiceClient *)client didReceiveMediaReconnectingForCall:(VGCallId)callId {
     NSLog(@"Leg %@ is reconnecting", callId);
 }

Reconnexion multimédia à la demande

Se déclenche lorsque le SDK rétablit avec succès la connexion multimédia après une interruption. Supprime l'indicateur de reconnexion et revient à l'interface utilisateur normale de l'appel.

client.on('callMediaReconnection', (callId) => {
  console.log(`Call media is reconnected for call ${callId}`);
});

 client.setOnCallMediaReconnectionListener { legId ->
     println("Received call media reconnection for Call $legId")
 }

 client.setOnCallMediaReconnectionListener((legId) -> {
     System.out.println("Received call media reconnection for Call " + legId);
     return null;
 });

 func voiceClient(_ client: VGVoiceClient, didReceiveMediaReconnectionForCall callId: VGCallId) {
     print("leg \(callId) has received media reconnection")
 }

 - (void) voiceClient:(VGVoiceClient *)client didReceiveMediaReconnectionForCall:(VGCallId)callId {
     NSLog(@"Leg %@ has received media reconnection", callId);
 }

Reconnexion manuelle

Utilisation reconnectCall(callId) lorsque votre application décide de déclencher explicitement la procédure de récupération — par exemple, après avoir reçu onCallMediaDisconnect et vérifier que la connexion au réseau a bien été rétablie.

La reconnexion manuelle suit également la même logique de réessai (jusqu'à 5 tentatives, espacées de 3 secondes) une fois déclenchée.

const callId = 'callId';
await client.reconnectCall(callId);

 // Callback
 client.reconnectCall("callId") {
     it?.let { err ->
         // Handle Error in reconnecting call
         println("Error in reconnecting call: $err")
     }
 }
 // Coroutine
 try {
     client.reconnectCall("callId")
 }
 catch (e:Error) {
     // Handle Error in reconnecting call
 }

 client.reconnectCall("callId", it -> {
     if (it != null) {
         // Handle Error in reconnecting call
         System.out.println("Error in reconnecting call: " + it);
     }
     return null;
 });

 // Callback
 client.reconnectCall("someCallId") { error in
     guard error != nil else {
         print("Failed to reconnect \(error?.localizedDescription ?? "")")
         return
     }
 }
 
 /// Async Await
 Task.detached {
     do {
         try await client.reconnectCall("someCallId")
     }
     catch {
         print("error")
     }
 }

 [client reconnect:@"someCallId" callback:^(NSError * _Nullable error) {
         if(error){
             NSLog(@"Failed to reconnect: %@", error);
         }
 }];

Configuration requise pour Android

La récupération automatique après un changement de réseau sur Android nécessite :

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>

Comportement en cas de défaillance et expérience utilisateur

• Si toutes les tentatives de reconnexion automatiques échouent et qu'aucune reconnexion manuelle ne aboutit, onCallHangup finit par se déclencher avec mediaTimeout raison.
• Afficher un indicateur de reconnexion lorsque onCallMediaReconnecting incendies.
• Ne revenir à l'interface utilisateur normale des appels qu'après onCallMediaReconnection incendies.
• Le onCallMediaDisconnect, informer l'utilisateur et, le cas échéant, proposer un bouton « Réessayer » qui appelle reconnectCall(callId).