Wiederherstellung der Verbindung und Netzwerkresilienz

Netzwerk-Switches und kurze Verbindungsunterbrechungen können die Medienübertragung während eines Anrufs unterbrechen. Das SDK kümmert sich in den meisten Fällen automatisch um die Wiederherstellung der Verbindung – nutzen Sie Ereignisse im Medienlebenszyklus und APIs zur Wiederherstellung der Verbindung, um die Nutzer auf dem Laufenden zu halten und die Verbindung nach Möglichkeit wiederherzustellen.

So funktioniert die automatische Wiederverbindung

Wenn das SDK eine Medienunterbrechung feststellt (ICE-Verbindungsfehler, Netzwerkwechsel), versucht es automatisch, die Verbindung wiederherzustellen, indem es einen ICE-Neustart für die Peer-Verbindung durchführt.

Zeitplanung und Wiederholungsverhalten

Was passiert in den einzelnen Phasen?

1. Wiederherstellung der Verbindung — Das SDK erkennt eine Medienunterbrechung und löst onCallMediaReconnecting. Es führt bis zu 5 ICE-Neustartversuche im Abstand von jeweils 3 Sekunden durch. In dieser Phase sind keine Maßnahmen seitens des Entwicklers erforderlich.

2. Wiederverbunden — Wenn ein Wiederholungsversuch erfolgreich ist, löst das SDK Folgendes aus: onCallMediaReconnection. Der Audiostream wird wiederhergestellt und das Gespräch wird normal fortgesetzt.

3. Gescheitert — Wenn alle 5 automatischen Wiederholungsversuche ausgeschöpft sind oder der Server während der Wiederherstellung der Verbindung einen Fehler zurückgibt, löst das SDK Folgendes aus: onCallMediaDisconnect. An dieser Stelle:

   • Der Ton ist ausgefallen
   • Die Anrufsitzung ist möglicherweise noch auf dem Server aktiv
   • Der Entwickler kann eine manuelle Wiederherstellung versuchen mit reconnectCall(callId) wenn die Netzwerkverbindung wiederhergestellt ist
   • Wenn keine Wiederherstellung erfolgt, bricht der Server den Aufruf schließlich ab und onCallHangup Feuer mit mediaTimeout Grund

Wiederherstellung der Verbindung auf Sitzungsebene

Unabhängig von der Wiederherstellung der Medienverbindung stellt das SDK auch automatisch die WebSocket-Sitzung wieder her, wenn die Verbindung unterbrochen wird:

Fehler bei der Wiederherstellung der Sitzung onReconnecting und onReconnection Ereignisse (im Unterschied zu den oben genannten Call-Media-Ereignissen).

onCallMediaDisconnect

Wird ausgelöst, wenn die Medienverbindung endgültig unterbrochen ist – nachdem alle 5 automatischen Wiederverbindungsversuche ausgeschöpft sind oder nach einem nicht behebbaren Serverfehler. Zu diesem Zeitpunkt ist der Audiostream unterbrochen, die Anrufsitzung kann jedoch auf dem Server weiterhin aktiv sein. Sie können eine manuelle Wiederherstellung versuchen mit 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);
 }

onCallMedia wird neu verbunden

Wird ausgelöst, wenn das SDK eine Medienunterbrechung erkennt (z. B. einen Netzwerkwechsel zwischen WLAN und Mobilfunk) und automatisch versucht, die Verbindung wiederherzustellen. Es ist keine Benutzeraktion erforderlich – zeigen Sie in Ihrer Benutzeroberfläche einen Hinweis „Wiederverbindung wird hergestellt“ an.

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);
 }

onCallMediaReconnection

Wird ausgelöst, wenn das SDK die Medienverbindung nach einer Unterbrechung erfolgreich wiederherstellt. Die Anzeige für die Wiederherstellung der Verbindung wird ausgeblendet, und die Benutzeroberfläche kehrt zum normalen Gesprächsmodus zurück.

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);
 }

Manuelle Wiederherstellung der Verbindung

Verwenden Sie reconnectCall(callId) wenn Ihre App die Wiederherstellung explizit auslöst – beispielsweise nach dem Empfang von onCallMediaDisconnect und um zu überprüfen, ob die Netzwerkverbindung wiederhergestellt ist.

Auch die manuelle Wiederherstellung der Verbindung folgt nach ihrer Auslösung derselben Wiederholungslogik (bis zu 5 Versuche im Abstand von jeweils 3 Sekunden).

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);
         }
 }];

Android-Anforderungen

Für die automatische Wiederherstellung nach einem Netzwerkwechsel unter Android ist Folgendes erforderlich:

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

Fehlerverhalten und Benutzererfahrung

• Falls alle automatischen Wiederholungsversuche fehlschlagen und keine manuelle Wiederherstellung der Verbindung gelingt, onCallHangup wird schließlich mit mediaTimeout Grund.
• Eine Anzeige für die Wiederherstellung der Verbindung anzeigen, wenn onCallMediaReconnecting Brände.
• Erst dann zur normalen Anrufoberfläche zurückkehren, wenn onCallMediaReconnection Brände.
• Am onCallMediaDisconnect, den Benutzer darüber informieren und optional eine Schaltfläche „Erneut versuchen“ anbieten, die reconnectCall(callId).