Umstellung auf das Vonage Client SDK

Wenn Sie mit dem Nexmo Client SDK vertraut sind oder es in Ihrer Anwendung verwenden, gibt es einige Änderungen zu beachten, wenn Sie zum Vonage Client SDK wechseln.

Client-Instantiierung

Für Android und iOS ist der SDK-Client nicht länger ein Singleton.

// Nexmo SDK
let client = new NexmoClient()

// Vonage SDK

// If loaded with a <script> tag:
const client = new vonageClientSDK.VonageClient();

// If loaded via import:
const client = new VonageClient();

// Nexmo SDK
client = NexmoClient.Builder().build(this)

// Vonage SDK
client = VoiceClient(this)

// Nexmo SDK
let client = NXMClient.shared

// Vonage SDK
let client = VGVoiceClient()

Sitzungsmanagement

Zuvor mussten Sie im Nexmo Client SDK auf Android und iOS login/createSession und erhalten Sie über einen Listener Updates zur Erstellung Ihrer ersten Sitzung.

Im JavaScript Vonage Client SDK erhalten Sie nicht mehr ein App-Objekt, sondern eine Session-ID.

Das Vonage Client SDK verfügt über einen Callback, mit dem Sie feststellen können, ob der erste Sitzungsaufbau erfolgreich war oder nicht. Weitere Sitzungsaktualisierungen, einschließlich der Wiederherstellung der Verbindung, sind über Listener/Delegate-Methoden verfügbar.

// Nexmo SDK
client.createSession(token)
  .then(app => {
    ...
  })
  .catch(error => {
    ...
  });

// Vonage SDK
client.createSession(token)
  .then(sessionId => {
    ...
  })
  .catch(error => {
    ...
  });

// Nexmo SDK
client.login(token)

client.setConnectionListener { connectionStatus, _ ->
    when (connectionStatus) {
        ConnectionStatus.CONNECTED ->
        ConnectionStatus.DISCONNECTED ->
        ConnectionStatus.CONNECTING ->
        ConnectionStatus.UNKNOWN ->
    }
}


// Vonage SDK
client.createSession(token) { err, sessionId ->
    when(err) {
        null ->  // Session created 🎉
        else ->  // Handle error
    }
}

client.setSessionErrorListener { err -> }

client.setReconnectingListener {}

client.setReconnectionListener {}

// NexmoSDK
client.login(withAuthToken: token)

class ExampleClientDelegate: NSObject, NXMClientDelegate {
    func client(_ client: NXMClient, didChange status: NXMConnectionStatus, reason: NXMConnectionStatusReason) {
        switch status {
        case .connected:
        case .disconnected:
        case .connecting:
    }
}

// Vonage SDK
client.createSession(token) { error, sessionId in
    if (error != nil) {
        // Handle error
    } else {
        // Session created 🎉
    }
}

class ExampleClientDelegate: NSObject, VGClientDelegate {
    func client(_ client: VGBaseClient, didReceiveSessionErrorWith reason: VGSessionErrorReason) {}

    func clientWillReconnect(_ client: VGBaseClient) {}

    func clientDidReconnect(_ client: VGBaseClient) {}
}

Anrufe

Im Vonage Client SDK sind Serveranrufe die einzige Art von Anrufen, die Sie tätigen können, der vorherige inApp wurde veraltet. Dies bedeutet, dass ein NCCO-Webhook-Server jetzt für alle Anrufabläufe obligatorisch ist.

Die Parameter für einen Serveraufruf haben sich geändert, das frühere Bis- und das Kontextfeld sind jetzt ein Parameter. Aus Gründen der Abwärtskompatibilität mit bestehenden NCCO-Webhooks können Sie Folgendes angeben to als Teil des Kontextobjekts, das wie zuvor an Ihren Webhook weitergeleitet wird.

Andernfalls verwenden Sie den Kontext-Parameter, um benutzerdefinierte Daten an Ihre answer_url Webhook.

// Nexmo SDK
application.callServer("PHONE_NUMBER")
    .then(nxmCall => {
        ...
    })
    .catch(error => {
        ...
    });

// Vonage SDK
client.serverCall({ to: "PHONE_NUMBER" })
    .then(callId => {
        ...
    })
    .catch(error => {
        ...
    });

// NexmoSDK
client.serverCall("PHONE_NUMBER", null, object : NexmoRequestListener<NexmoCall> {
    override fun onSuccess(call: NexmoCall?) {
        // Handle call
    }

    override fun onError(apiError: NexmoApiError) {
        // Handle error
    }
})

// VonageSDK
client.serverCall(mapOf("to" to "PHONE_NUMBER")) { err, voiceCall ->
    when(err) {
        null -> {
            // Handle call
        }
        else -> // Handle error
    }
}

// Nexmo SDK
client.serverCall(withCallee: "PHONE_NUMBER", customData: nil) { (error, call) in
    // Handle error/call
}

// Vonage SDK
client.serverCall(["to":"PHONE_NUMBER"]) { (error, call) in
    // Handle error/call
}

Anrufe/Chat-Aktionen

Das Vonage Client SDK verfügt auch nicht mehr über Methoden auf Objekten, um Aktionen wie das Beenden eines Anrufs, das Stummschalten eines Anrufs oder das Senden einer Nachricht durchzuführen. Alle diese Aktionen sind als Methoden auf dem Client verfügbar. Um diese Aktionen auszuführen, müssen Sie die Anruf- oder Gesprächs-ID speichern, für die Sie eine Aktion ausführen möchten.

Zum Beispiel, um einen Anruf stumm zu schalten:

// Nexmo SDK
conversation.me.mute(true);

// Vonage SDK
client.mute(callId)
    .then(() => {
        // Mute successful
    })
    .catch(error => {
        // Handle muting error
    });

// Nexmo SDK
callMember?.enableMute(muteListener)

// Vonage SDK
client.mute(callId) { 
    error ->
    when {
        error != null -> {
            // Handle muting error
        }
    }
}

// Nexmo SDK
callMember.enableMute()

// Vonage SDK
client.mute(callId) { error in
    if error != nil {
        // Handle muting error
    }
}

Oder um eine Nachricht zu senden:

// Nexmo SDK
conversation.sendMessage({
    "message_type": "text",
    "text": "Hello world!"
}).then((event) => {
    ...
}).catch((error)=>{
    ...
});


// Vonage SDK
client.sendMessageTextEvent("CONV_ID", "Hello world!")
    .then(timestamp => {
        ...
    }).catch(error => {
        ...
    });

// Nexmo SDK
conversation.sendMessage("Hello world!", object : NexmoRequestListener<Void> {
   ...
})

// Vonage SDK
client.sendMessageTextEvent("CONV_ID", "Hello world!") { error, timestamp ->
    ...
}

// Nexmo SDK
conversation.sendMessage("Hello world!") { error in
   ...
}

// Vonage SDK
client.sendMessageTextEvent("CONV_ID", text: "Hello world!") { error, timestamp in
    ...
}