Configurar chamadas individuais e notificações por push na Biblioteca da Interface do Usuário

A Biblioteca de Interface do Usuário dá suporte imediato para fazer chamadas individuais usando identificadores de participantes dos Serviços de Comunicação do Azure. Para dar suporte a chamadas individuais, a Biblioteca da interface do usuário fornece notificações de chamadas recebidas. Você também pode usar os Serviços de Comunicação do Azure como uma fonte de eventos da Grade de Eventos do Azure para chamadas.

Neste artigo, você aprenderá a fazer chamadas individuais corretamente usando a Biblioteca da Interface do Usuário em seu aplicativo.

Pré-requisitos

• Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.
• Um recurso dos Serviços de Comunicação implantado. Crie um recurso dos Serviços de Comunicação.
• Um token de acesso do usuário para habilitar o cliente de chamada. Obter um token de acesso do usuário.
• Opcional: Conclusão do Início Rápido para a introdução à compostos da Biblioteca da Interface do Usuário.

Configurar os recursos

Para obter mais informações, veja Biblioteca de UI do Android de código aberto e o código de aplicativo de exemplo.

Configurar permissões para notificações por push

Para configurar as notificações por push, você precisa de uma conta do Firebase com o Firebase Cloud Messaging (FCM) habilitado. Seu serviço FCM deve estar conectado a uma instância dos Hubs de Notificação do Azure. Para obter mais informações, consulte Notificações dos Serviços de Comunicação. Você também precisa usar o Android Studio versão 3.6 ou posterior para criar seu aplicativo.

Para que o aplicativo Android receba mensagens de notificação do FCM, ele precisa de um conjunto de permissões. Em seu arquivo AndroidManifest.xml, adicione o seguinte conjunto de permissões após a marca <manifest ...> ou </application>.

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.GET_ACCOUNTS"/>
<uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" />

Adicionar notificações de entrada ao seu aplicativo móvel

Os Serviços de Comunicação do Azure se integram à Grade de Eventos do Azure e aos Hubs de Notificação do Azure, que permitem adicionar notificações por push aos aplicativos no Azure.

Registrar/Cancelar o registro para notificações push do hub de notificação

Para se registrar para notificações por push, o aplicativo precisa chamar registerPushNotification() em uma instância CallComposite com um token de registro de dispositivo.

Para obter o token de registro do dispositivo, adicione o SDK do Firebase à instância build.gradle do módulo do aplicativo. Para receber notificações do Firebase, integre os Hubs de Notificação do Azure seguindo as instruções em Notificações dos Serviços de Comunicação.

Kotlin

    val deviceRegistrationToken = "" // From Firebase
    callComposite.registerPushNotification(deviceRegistrationToken).whenComplete { _, throwable ->
        if (throwable != null) {
            // Handle error
        }
    }

Java

    String deviceRegistrationToken = ""; // From Firebase
    callComposite.registerPushNotification(deviceRegistrationToken)
    .whenComplete((aVoid, throwable) -> {
            if (throwable != null) {
                // Handle error
            }
    });

Tratar as notificações por push recebidas da Grade de Eventos ou do hub de notificação

Para receber notificações por push para chamadas recebidas, chame handlePushNotification em uma instância CallComposite com um payload.

Para obter o conteúdo do FCM, comece criando um serviço (Arquivo>Novo>Serviço>Serviço) que estende a classe FirebaseMessagingService do SDK do Firebase e substitui o método onMessageReceived. Esse método é o manipulador de eventos que é chamado quando o FCM entrega a notificação por push ao aplicativo.

Kotlin

    // On Firebase onMessageReceived
    val pushNotification = CallCompositePushNotification(remoteMessage.data)
    callComposite.handlePushNotification(pushNotification).whenComplete { _, throwable ->
        if (throwable != null) {
            // Handle error
        }
    }

Java

    // On Firebase onMessageReceived
    // push notification contains from/to communication identifiers and event type
    CallCompositePushNotification pushNotification = 
            new CallCompositePushNotification(remoteMessage.data)

    callComposite.handlePushNotification(pushNotification)
    .whenComplete((aVoid, throwable) -> {
            if (throwable != null) {
                // Handle error
            }
    });

Registro para notificações de chamadas recebidas

Para receber notificações de chamadas recebidas após handlePushNotification, inscreva-se em CallCompositeIncomingCallEvent e CallCompositeIncomingCallCancelledEvent. CallCompositeIncomingCallEvent contém a callId de entrada e as informações do chamador. CallCompositeIncomingCallCancelledEvent contém a callId e o código de cancelamento da chamada da Solução de Problemas nos Serviços de Comunicação do Azure.

Kotlin

    private var incomingCallEvent: IncomingCallEvent? = null
    private var incomingCallCancelledEvent: IncomingCallCancelledEvent? = null

    class IncomingCallEvent : CallCompositeEventHandler<CallCompositeIncomingCallEvent> {
        override fun handle(eventArgs: CallCompositeIncomingCallEvent?) {
            // Display incoming call UI to accept/decline a call
            // CallCompositeIncomingCallEvent contains call id and caller information
        }
    }

    class IncomingCallCancelledEvent : CallCompositeEventHandler<CallCompositeIncomingCallCancelledEvent> {
        override fun handle(eventArgs: CallCompositeIncomingCallCancelledEvent?) {
            // Call-ended event when a call is declined or not accepted
        }
    }

    // Event subscription
    incomingCallEvent = IncomingCallEvent()
    callComposite.addOnIncomingCallEventHandler(incomingCallEvent)

    incomingCallCancelledEvent = IncomingCallCancelledEvent()
    callComposite.addOnIncomingCallCancelledEventHandler(incomingCallEndEvent)

    // Event unsubscribe
    callComposite.removeOnIncomingCallEventHandler(incomingCallEvent)
    callComposite.removeOnIncomingCallCancelledEventHandler(incomingCallEndEvent)

Java

    callComposite.addOnIncomingCallEventHandler((call) -> {
        // Display incoming call UI to accept/decline a call
        // incomingCallEvent.getCallId()
        // incomingCallEvent.getCallerIdentifier()
        // incomingCallEvent.getCallerDisplayName()
    });

    callComposite.addOnIncomingCallCancelledEventHandler((call) -> {
        // Call-ended event when a call is declined or not accepted
        // incomingCallCancelledEvent.getCallId()
        // incomingCallCancelledEvent.getCode()
        // incomingCallCancelledEvent.getSubCode()
    });

Identificador de chamadas

Para aceitar chamadas, faça uma chamada para accept. Para recusar chamadas, faça uma chamada para reject.

Kotlin

// Accept call
callComposite.accept(applicationContext, incomingCallId, localOptions)

// Decline call
callComposite.reject(incomingCallId)

Java

// Accept call
callComposite.accept(applicationContext, incomingCallId, localOptions);

// Decline call
callComposite.reject(incomingCallId);

Discar para outros participantes

Para iniciar chamadas com outros participantes, crie CallCompositeStartCallOptions com as IDs brutas dos participantes de CommunicationIdentity e launch.

Kotlin

    val participants: List<CommunicationIdentifier> // participants to dial
    callComposite.launch(context, participants, localOptions)

Java

    Collection<CommunicationIdentifier> participants; // participants to dial
    callComposite.launch(applicationContext, participants, localOptions);

Para obter mais informações, veja a Biblioteca de UI do iOS de código aberto e o código de aplicativo de amostra.

Configurar notificações por push

A notificação por push móvel é a notificação de item pop-up que você obtém no dispositivo móvel. Este artigo foca nas notificações por push de voz sobre Protocolo de Internet (VoIP).

As seções a seguir descrevem como registrar-se para identificar e cancelar o registro de notificações por push. Antes de iniciar estas tarefas, conclua estes pré-requisitos:

1. Em Xcode, vá paraAssinatura e Funcionalidades. Adicione uma funcionalidade selecionando+ funcionalidadee,em seguida, selecioneNotificações por Push.
2. Adicione outra funcionalidade selecionando+ funcionalidadee, em seguida, selecioneModos de Segundo Plano.
3. Em caixas de seleção ou botões de opçãoModos de Segundo Plano,selecione oProtocolo de chamada de voz por IPe Notificações Remotas.

Adicionar notificações de entrada ao seu aplicativo móvel

Os Serviços de Comunicação do Azure se integram à Grade de Eventos do Azure e aos Hubs de Notificação do Azure, que permitem adicionar notificações por push aos aplicativos no Azure.

Registrar/cancelar o registro para notificações push do hub de notificações

Para se registrar para notificações por push, o aplicativo precisa chamar registerPushNotifications() em uma instância CallComposite com um token de registro de dispositivo.

    // to register
    let deviceToken: Data = pushRegistry?.pushToken(for: PKPushType.voIP)
    callComposite.registerPushNotifications(
        deviceRegistrationToken: deviceToken) { result in
        switch result {
            case .success:
                // success
            case .failure(let error):
                // failure
        }
    }

    // to unregister
    callComposite.unregisterPushNotification()

Tratar as notificações por push recebidas da Grade de Eventos ou do hub de notificação

Para receber notificações de chamadas recebidas por push, em uma chamadahandlePushNotification()de instânciaCallCompositecom um conteúdo de dicionário.

Quando você usa handlePushNotification() e as opções do CallKit estão definidas, você recebe uma notificação do CallKit para aceitar ou recusar chamadas.

    // App is in the background
    // push notification contains from/to communication identifiers and event type
    let pushNotification = PushNotification(data: payload.dictionaryPayload)
    let callKitOptions = CallKitOptions(...//CallKit options)
    CallComposite.reportIncomingCall(pushNotification: pushNotification,
                                    callKitOptions: callKitOptions) { result in
        if case .success() = result {
            DispatchQueue.global().async {
                // You don't need to wait for a Communication Services token to handle the push because 
                // Communication Services common receives a callback function to get the token with refresh options
                // create call composite and handle push notification
                callComposite.handlePushNotification(pushNotification: pushNotification)
            }
        }
    }

    // App is in the foreground
    let pushNotification = PushNotification(data: dictionaryPayload)
    callComposite.handlePushNotification(pushNotification: pushNotification) { result in
        switch result {
            case .success:
                // success
            case .failure(let error):
                // failure
        }
    }

Registre-se para receber as notificações de chamadas recebidas no push do identificador

Para receber notificações de chamadas recebidas após handlePushNotification, inscreva-se em onIncomingCall e onIncomingCallCancelled. IncomingCall contém a callId de entrada e as informações do chamador. IncomingCallCancelled contém a callId e o código de cancelamento da chamada da Solução de Problemas nos Serviços de Comunicação do Azure.

    let onIncomingCall: (IncomingCall) -> Void = { [] incomingCall in
        // Incoming call id and caller info
    }
    let onIncomingCallEnded: (IncomingCallCancelled) -> Void = { [] incomingCallCancelled in
        // Incoming call cancelled code with callId
    }
    callComposite.events.onIncomingCall = onIncomingCall
    callComposite.events.onIncomingCallEnded = onIncomingCallEnded

Desabilitar o push interno para chamadas recebidas

Para receber notificações por push somente de EventGrid e APNS, defina disableInternalPushForIncomingCall como verdadeiro em CallCompositeOptions. Se disableInternalPushForIncomingCall for verdadeiro, o evento de notificação por push da biblioteca da interface do usuário será recebido somente quando handlePushNotification for chamado. A opção disableInternalPushForIncomingCall ajuda a interromper o recebimento de notificações de CallComposite no modo de primeiro plano. Essa configuração não controla as configurações EventGrid e NotificationHub.

    let options = CallCompositeOptions(disableInternalPushForIncomingCall: true)

Inicie a composição na chamada recebida aceita pelo CallKit do SDK de chamada

O SDK do iOS para chamadas dos Serviços de Comunicação do Azure dá suporte à integração com o CallKit. Você pode habilitar essa integração na Biblioteca da Interface do Usuário configurando uma instância de CallCompositeCallKitOption. Para obter mais informações, consulte Integrar com o CallKit.

Assine onIncomingCallAcceptedFromCallKit se a CallKit do SDK de chamada estiver habilitada. Quando a chamada for aceita, inicie callComposite com a ID da chamada.

    let onIncomingCallAcceptedFromCallKit: (callId) -> Void = { [] callId in
        // Incoming call accepted call id
    }
    
    callComposite.events.onIncomingCallAcceptedFromCallKit = onIncomingCallAcceptedFromCallKit

    // launch composite with/without local options
    // Note: as call is already accepted, setup screen will not be displayed
    callComposite.launch(callIdAcceptedFromCallKit: callId)

Identificar chamadas com o CallComposite

Para aceitar chamadas, faça uma chamada para accept. Para recusar chamadas, faça uma chamada para reject.

// Accept call
callComposite.accept(incomingCallId, 
                     ... // CallKit and local options
                     )

// Decline call
callComposite.reject(incomingCallId)

Discar para outros participantes

Para iniciar chamadas com outros participantes, inicie callComposite com a lista de participantes de CommunicationIdentifier.

    // [CommunicationIdentifier]
    // use createCommunicationIdentifier(fromRawId: "raw id")
    callComposite.launch(participants: <list of CommunicationIdentifier>,
                         localOptions: localOptions)

Próximas etapas

• Saiba mais sobre a Biblioteca UI