Migração para o Vonage Client SDK

Se você já conhece ou utiliza o Client SDK do Nexmo em seu aplicativo, há algumas mudanças a serem consideradas ao migrar para o Vonage Client SDK.

Instanciação do cliente

No Android e no iOS, o Client SDK não é mais um 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()

Gerenciamento de sessões

Anteriormente, no Client SDK do Nexmo para Android e iOS, você chamava login/createSession e receba atualizações sobre a criação da sua sessão inicial por meio de um ouvinte.

No Vonage Client SDK para JavaScript, você não receberá mais um objeto de aplicativo; em vez disso, receberá um ID de sessão.

O Vonage Client SDK possui um callback que permite saber se a criação inicial da sessão foi bem-sucedida ou não. Outras atualizações da sessão, incluindo a reconexão, estão disponíveis nos 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) {}
}

Chamadas

No Vonage Client SDK, as chamadas de servidor são o único tipo de chamada que você pode realizar; o anterior inApp Esse tipo de chamada foi descontinuado. Isso significa que agora é obrigatório utilizar um servidor de webhooks da NCCO para todos os fluxos de chamadas.

Os parâmetros para realizar uma chamada ao servidor foram alterados; os campos “to” e “context”, que existiam anteriormente, agora constituem um único parâmetro. Para garantir a compatibilidade com os webhooks NCCO já existentes, você pode especificar to como parte do objeto “context”, que será encaminhado para o seu webhook, como antes.

Caso contrário, utilize o parâmetro “context” para enviar dados personalizados para o seu 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
}

Ações de chamada/chat

O Vonage Client SDK também não possui mais métodos nos objetos para realizar ações como encerrar uma chamada, silenciar uma chamada ou enviar uma mensagem. Todas essas ações estão disponíveis como métodos no cliente. Para realizá-las, você precisará armazenar o ID da chamada ou da conversa na qual deseja realizar a ação.

Por exemplo, para silenciar uma chamada:

// 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 para enviar uma mensagem:

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