Transición al Client SDK de Vonage

Si estás familiarizado con el Client SDK de Nexmo o lo usas en tu aplicación, debes tener en cuenta algunos cambios al migrar al Client SDK de Vonage.

Instanciación del cliente

Para Android e iOS el SDK Client ya no es 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()

Gestión de sesiones

Anteriormente, en el Client SDK de Nexmo en Android e iOS se llamaba a login/createSession y recibir actualizaciones sobre la creación de su sesión inicial a través de un oyente.

En el JavaScript Vonage Client SDK ya no recibirás un objeto de aplicación, en su lugar obtendrás un ID de sesión.

El Vonage Client SDK tiene un callback que te permite saber si la creación de la sesión inicial fue exitosa o no. Las actualizaciones posteriores de la sesión, incluida la reconexión, están disponibles en los métodos listeners/delegate.

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

Llamadas

En el Vonage Client SDK, las llamadas al servidor son el único tipo de llamadas que puedes realizar, el anterior inApp ha quedado obsoleto. Esto significa que ahora es obligatorio un servidor de webhook NCCO para todos los flujos de llamadas.

Los parámetros para realizar una llamada al servidor han cambiado, el campo anterior para y contexto son ahora un solo parámetro. Para la compatibilidad con los webhooks NCCO existentes, puede especificar to como parte del objeto de contexto, que será reenviado a su webhook como antes.

De lo contrario, utilice el parámetro de contexto para enviar datos personalizados a su 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
}

Acciones de llamada/chat

El Vonage Client SDK tampoco tiene métodos en objetos para realizar acciones como finalizar una llamada, silenciar una llamada o enviar un mensaje. Todas estas acciones están disponibles como métodos en el cliente. Para realizar estas acciones, deberás almacenar el ID de llamada o conversación sobre el que deseas realizar una acción.

Por ejemplo, para silenciar una llamada:

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

O para enviar un mensaje:

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