Configurare le notifiche push e chiamate uno-a-uno nella libreria dell'interfaccia utente

Per altre informazioni, vedere la libreria dell'interfaccia utente Android open source e il codice dell'applicazione di esempio.

Configurare le autorizzazioni per le notifiche push

Per configurare le notifiche push, è necessario un account Firebase con Firebase Cloud Messaging (FCM) abilitato. Il servizio FCM deve essere connesso a un'istanza di Hub di notifica di Azure. Per altre informazioni, vedere Notifiche di Servizi di comunicazione. È anche necessario usare Android Studio versione 3.6 o successiva per compilare l'applicazione.

Affinché l'applicazione Android riceva messaggi di notifica da FCM, è necessario un set di autorizzazioni. Nel file AndroidManifest.xml, aggiungere il set di autorizzazioni seguente dopo il tag <manifest ...> o </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" />

Aggiungere notifiche in ingresso all'app per dispositivi mobili

Servizi di comunicazione di Azure si integra con Griglia di eventi di Azure e Hub di notifica di Azure, in modo da poter aggiungere notifiche push alle app in Azure.

Registrare/Annullare la registrazione per le notifiche push dell'hub di notifica

Per eseguire la registrazione per le notifiche push, l'applicazione deve chiamare registerPushNotification() su un'istanza CallComposite con un token di registrazione del dispositivo.

Per ottenere il token di registrazione del dispositivo, aggiungere Firebase SDK all'istanza del modulo dell'applicazione build.gradle. Per ricevere notifiche da Firebase, integrare Hub di notifica di Azure seguendo le istruzioni riportate in Notifiche di Servizi di comunicazione.

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

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

Gestire le notifiche push ricevute da Griglia di eventi o dall'hub di notifica

Per ricevere notifiche push per le chiamate in ingresso, chiamare handlePushNotification su un'istanza CallComposite con un payload.

Per ottenere il payload da FCM, iniziare creando un nuovo servizio (File>Neuovo>Servizio>Servizio) che estende la classe Firebase SDK FirebaseMessagingService ed esegue l'override del metodo onMessageReceived. Questo metodo è il gestore eventi che ha chiamato quando FCM recapita la notifica push all'applicazione.

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

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

Eseguire la registrazione per le notifiche di chiamata in ingresso

Per ricevere notifiche di chiamata in arrivo dopo handlePushNotification, sottoscrivere CallCompositeIncomingCallEvent e CallCompositeIncomingCallCancelledEvent. CallCompositeIncomingCallEvent contiene le informazioni callId e chiamante in ingresso. CallCompositeIncomingCallCancelledEvent contiene callId e codice di annullamento delle chiamate Risoluzione dei problemi in Servizi di comunicazione di Azure.

    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)

    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()
    });

Gestire le chiamate

Per accettare le chiamate, effettuare una chiamata a accept. Per rifiutare le chiamate, effettuare una chiamata a reject.

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

// Decline call
callComposite.reject(incomingCallId)

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

// Decline call
callComposite.reject(incomingCallId);

Comporre altri partecipanti

Per iniziare le chiamate con altri partecipanti, creare CallCompositeStartCallOptions con gli ID non elaborati dei partecipanti da CommunicationIdentity e launch.

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

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

Per altre informazioni, vedere la libreria dell'interfaccia utente iOS open source e il codice dell'applicazione di esempio.

Impostazione delle notifiche push

Una notifica push per dispositivi mobili è la notifica popup visualizzata nel dispositivo mobile. Questo articolo è incentrato sulle notifiche push voice over Internet Protocol (VoIP).

Le sezioni seguenti descrivono come registrarsi, gestire e annullare la registrazione per le notifiche push. Prima di avviare tali attività, completare questi prerequisiti:

1. In Xcode passare a Firma e funzionalità. Aggiungere una funzionalità selezionando + Funzionalità e quindi selezionare Notifiche push.
2. Aggiungere un'altra funzionalità selezionando + Funzionalità e quindi selezionare Modalità in background.
3. In Modalità in background, selezionare le caselle di controllo Voice over IP e Notifiche remote.

Aggiungere notifiche in ingresso all'app per dispositivi mobili

Servizi di comunicazione di Azure si integra con Griglia di eventi di Azure e Hub di notifica di Azure, in modo da poter aggiungere notifiche push alle app in Azure.

Registrare/annullare la registrazione per le notifiche push dell'hub di notifica

Per eseguire la registrazione per le notifiche push, l'applicazione deve chiamare registerPushNotifications() su un'istanza CallComposite con un token di registrazione del 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()

Gestire le notifiche push ricevute da Griglia di eventi o dall'hub di notifica

Per ricevere notifiche push per le chiamate in ingresso, chiamare handlePushNotification() su un'istanza CallComposite con un payload del dizionario.

Quando si usano handlePushNotification() e le opzioni CallKit sono impostate, si riceve una notifica callkit per accettare o rifiutare le chiamate.

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

Eseguire la registrazione per le notifiche di chiamata in ingresso sull'handle push

Per ricevere notifiche di chiamata in arrivo dopo handlePushNotification, sottoscrivere onIncomingCall e onIncomingCallCancelled. IncomingCall contiene le informazioni callId e chiamante in ingresso. IncomingCallCancelled contiene callId e codice di annullamento delle chiamate Risoluzione dei problemi in Servizi di comunicazione di 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

Disabilitare il push interno per la chiamata in ingresso

Per ricevere notifiche push solo da EventGrid e APNS impostare disableInternalPushForIncomingCall su true in CallCompositeOptions. Se disableInternalPushForIncomingCall è true, l'evento di notifica push dalla libreria dell'interfaccia utente ha ricevuto solo quando handlePushNotification verrà chiamato. L'opzione disableInternalPushForIncomingCall consente di interrompere la ricezione di notifiche da CallComposite in modalità in primo piano. Questa impostazione non controlla le impostazioni EventGrid e NotificationHub.

    let options = CallCompositeOptions(disableInternalPushForIncomingCall: true)

Avviare composito nella chiamata in ingresso accettata dalla chiamata SDK CallKit

L'SDK Calling iOS di Servizi di comunicazione di Azure iOS SDK supporta l'integrazione di CallKit. È possibile abilitare questa integrazione nella libreria dell'interfaccia utente configurando un'istanza di CallCompositeCallKitOption. Per altre informazioni, vedere Integrare con CallKit.

Sottoscrivere onIncomingCallAcceptedFromCallKit se CallKit dalla chiamata dell'SDK è abilitato. Alla chiamata accettata, avviare callComposite con ID chiamata.

    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)

Gestire le chiamate con CallComposite

Per accettare le chiamate, effettuare una chiamata a accept. Per rifiutare le chiamate, effettuare una chiamata a reject.

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

// Decline call
callComposite.reject(incomingCallId)

Comporre altri partecipanti

Per iniziare le chiamate con altri partecipanti, avviare callComposite con l'elenco dei partecipanti di CommunicationIdentifier.

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