Transition vers le Client SDK de Vonage

Si vous connaissez ou utilisez le Client SDK de Nexmo dans votre application, il y a quelques changements à prendre en compte lorsque vous passez au Client SDK de Vonage.

Instanciation du client

Pour Android et iOS, le Client SDK n'est plus un 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()

Gestion des sessions

Auparavant, dans le Client SDK Nexmo sur Android et iOS, vous appeliez login/createSession et recevez des informations sur la création de votre session initiale par l'intermédiaire d'un auditeur.

Dans le Client Vonage Client SDK JavaScript, vous ne recevrez plus d'objet d'application, mais un identifiant de session.

Le Client SDK de Vonage dispose d'un rappel qui vous permet de savoir si la création de la session initiale a réussi ou non. D'autres mises à jour de la session, y compris la reconnexion, sont disponibles sur les méthodes d'écoute/déléguées.

// 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) {}
}

Appels

Dans le Client SDK de Vonage, les appels de serveur sont le seul type d'appels que vous pouvez faire, le précédent inApp a été supprimé. Cela signifie qu'un serveur webhook NCCO est désormais obligatoire pour tous les flux d'appels.

Les paramètres pour effectuer un appel au serveur ont changé, les anciens champs "to" et "context" ne forment plus qu'un seul paramètre. Pour une compatibilité ascendante avec les webhooks NCCO existants, vous pouvez spécifier to en tant qu'élément de l'objet contextuel, qui sera transmis à votre webhook comme précédemment.

Sinon, utilisez le paramètre contextuel pour envoyer des données personnalisées à votre 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
}

Actions d'appel/de chat

Le Client SDK de Vonage n'a plus de méthodes sur les objets pour effectuer des actions telles que la fin d'un appel, la mise en sourdine d'un appel ou l'envoi d'un message. Toutes ces actions sont disponibles en tant que méthodes sur le client. Pour effectuer ces actions, vous devrez stocker l'ID de l'appel ou de la conversation sur lequel vous souhaitez effectuer une action.

Par exemple, pour mettre un appel en sourdine :

// 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
    }
}

Ou pour envoyer un message :

// 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
    ...
}