Freigeben über

Einrichten von 1:1-Anrufen und Pushbenachrichtigungen in der Ui-Bibliothek

  • Artikel

Die Benutzeroberflächenbibliothek bietet sofort einsatzbereite Unterstützung für 1:1-Anrufe mithilfe von Azure Communication Services-Teilnehmer-IDs. Zur Unterstützung von 1:1-Anrufen stellt die Benutzeroberflächenbibliothek eingehende Anrufbenachrichtigungen bereit. Sie können Azure Communication Services auch als Azure Event Grid-Ereignisquelle für Anrufe verwenden.

In diesem Artikel erfahren Sie, wie Sie 1:1-Aufrufe ordnungsgemäß ausführen, indem Sie die UI-Bibliothek in Ihrer Anwendung verwenden.

Wichtig

Dieses Feature von Azure Communication Services befindet sich derzeit in der Vorschau.

Vorschau-APIs und -SDKs werden ohne Vereinbarung zum Servicelevel bereitgestellt. Es wird empfohlen, diese nicht für Produktionsworkloads zu verwenden. Einige Features werden möglicherweise nicht unterstützt oder bieten nur eingeschränkte Funktionalität.

Weitere Informationen finden Sie in den ergänzenden Nutzungsbestimmungen für Microsoft Azure-Vorschauversionen.

Voraussetzungen

Einrichten der Features

Weitere Informationen finden Sie in der Open Source Android UI Library und im Beispielanwendungscode.

Einrichten von Berechtigungen für Pushbenachrichtigungen

Zum Einrichten von Pushbenachrichtigungen benötigen Sie ein Firebase-Konto mit aktiviertem Firebase Cloud Messaging (FCM). Ihr FCM-Dienst muss mit einer Azure Notification Hubs-Instanz verbunden sein. Weitere Informationen finden Sie unter Kommunikationsdienstebenachrichtigungen. Sie müssen auch Android Studio, Version 3.6 oder höher, verwenden, um Ihre Anwendung zu erstellen.

Damit die Android-Anwendung Benachrichtigungen von FCM empfängt, benötigt sie eine Reihe von Berechtigungen. Fügen Sie in Ihrer AndroidManifest.xml Datei den folgenden Satz von Berechtigungen nach dem <manifest ...> Tag hinzu </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" />

Registrieren für Pushbenachrichtigungen

Um sich für Pushbenachrichtigungen zu registrieren, muss die Anwendung registerPushNotification() für eine CallComposite-Instanz mit einem Geräteregistrierungstoken aufrufen.

Um das Geräteregistrierungstoken abzurufen, fügen Sie das Firebase SDK zur Instanz Ihres Anwendungsmoduls build.gradle hinzu. Um Benachrichtigungen von Firebase zu erhalten, integrieren Sie Azure Notification Hubs, indem Sie die Anweisungen in Kommunikationsdienstebenachrichtigungen befolgen.

Um aktuelle Einschränkungen zu vermeiden, können Sie mit Azure Event Grid für Pushbenachrichtigungen überspringen registerPushNotification . Weitere Informationen finden Sie unter Verbinden Aufrufen nativer Pushbenachrichtigungen mit Azure Event Grid.

    val deviceRegistrationToken = "" // From Firebase
    callComposite.registerPushNotification(
        applicationContext,
        CallCompositePushNotificationOptions(
            CommunicationTokenCredential...,
            deviceRegistrationToken,
            displayName
        )
    )

Behandeln von Pushbenachrichtigungen

Um Pushbenachrichtigungen für eingehende Anrufe zu empfangen, rufen Sie handlePushNotification eine CallComposite Instanz mit einer Nutzlast an.

Um die Nutzlast von FCM abzurufen, erstellen Sie zunächst einen neuen Dienst (File>New>Service Service>), der die FirebaseMessagingService Firebase SDK-Klasse erweitert und die onMessageReceived Methode überschreibt. Diese Methode ist der Ereignishandler, der aufgerufen wird, wenn FCM die Pushbenachrichtigung an die Anwendung übermittelt.

    // On Firebase onMessageReceived
    val pushNotificationInfo = CallCompositePushNotificationInfo(remoteMessage.data)

    // If pushNotificationInfo.eventType is an incoming call
    val remoteOptions = CallCompositeRemoteOptions(
            pushNotificationInfo,
            communicationTokenCredential,
            displayName
        )
    callComposite.handlePushNotification(
            applicationContext,
            remoteOptions
        )

Registrieren für eingehende Anrufbenachrichtigungen

Um eingehende Anrufbenachrichtigungen nach handlePushNotification, abonnieren IncomingCallEvent und IncomingCallEndEventempfangen .

    private var incomingCallEvent: IncomingCallEvent? = null
    private var incomingCallEndEvent: IncomingCallEndEvent? = null

    class IncomingCallEndEvent : CallCompositeEventHandler<CallCompositeIncomingCallEndEvent> {
        override fun handle(eventArgs: CallCompositeIncomingCallEndEvent?) {
            // Display incoming call UI to accept/decline a call
        }
    }

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

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

    incomingCallEndEvent = IncomingCallEndEvent()
    callComposite.addOnIncomingCallEndEventHandler(incomingCallEndEvent)

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

Behandeln von Anrufen

Um Anrufe zu akzeptieren, tätigen Sie einen Anruf an acceptIncomingCall. Um Anrufe abzulehnen, tätigen Sie einen Anruf an declineIncomingCall.

// Accept call
callComposite.acceptIncomingCall(applicationContext, localOptions)

// Decline call
callComposite.declineIncomingCall()

Andere Teilnehmer anrufen

Um Anrufe mit anderen Teilnehmern zu beginnen, erstellen Sie CallCompositeStartCallOptions mit den unformatierten IDs der Teilnehmer aus CommunicationIdentity und launch.

    val participant = [] // Participant raw IDs
    val startCallOption = CallCompositeStartCallOptions(participant)
    val remoteOptions = CallCompositeRemoteOptions(startCallOption, communicationTokenCredential, displayName)
    callComposite.launch(context, remoteOptions, localOptions)

Integration von TelecomManager-Beispielen

Verwenden Sie zum Integrieren von TelecomManager die in der Open Source-Bibliothek bereitgestellten Beispiele. Verwenden Sie CallComposite APIs für hold, resume, , muteund unmute. Erstellen sie CallComposite mit CallCompositeTelecomIntegration.APPLICATION_IMPLEMENTED_TELECOM_MANAGER der Verwendung TelecomManager in einer Anwendung.

callComposite.hold()
callComposite.resume()
callComposite.mute()
callComposite.unmute()

Weitere Informationen finden Sie in der Open-Source-iOS-UI-Bibliothek und im Beispielanwendungscode.

Pushbenachrichtigungen einrichten

Eine mobile Pushbenachrichtigung ist die Popupbenachrichtigung, die Sie auf dem mobilen Gerät erhalten. Für Anrufe konzentriert sich dieser Artikel auf VoIP-Pushbenachrichtigungen (Voice over Internet Protocol).

In den folgenden Abschnitten erfahren Sie, wie Sie sich für Pushbenachrichtigungen registrieren, sie behandeln und die Registrierung für sie aufheben. Bevor Sie mit diesen Aufgaben beginnen, sind jedoch folgende Schritte erforderlich:

  1. Navigieren Sie in Xcode zur Registerkarte Signing & Capabilities (Signieren und Funktionen). Fügen Sie eine Funktion hinzu, indem Sie + Capability (+ Funktion) und anschließend Push Notifications (Pushbenachrichtigungen) auswählen.
  2. Fügen Sie eine weitere Funktion hinzu, indem Sie + Capability (+ Funktion) und anschließend Background Modes (Hintergrundmodi) auswählen.
  3. Aktivieren Sie unter Background Modes (Hintergrundmodi) die Kontrollkästchen Voice over IP und Remote notifications (Remotebenachrichtigungen) aus.

Registrieren für Pushbenachrichtigungen

Um sich für Pushbenachrichtigungen zu registrieren, muss die Anwendung registerPushNotification() für eine CallComposite-Instanz mit einem Geräteregistrierungstoken aufrufen.

Um aktuelle Einschränkungen zu vermeiden, können Sie mit Azure Event Grid für Pushbenachrichtigungen überspringen registerPushNotification . Weitere Informationen finden Sie unter Verbinden Aufrufen nativer Pushbenachrichtigungen mit Azure Event Grid.

    let deviceToken: Data = pushRegistry?.pushToken(for: PKPushType.voIP)
    let displayName = "DISPLAY_NAME"
    let notificationOptions = CallCompositePushNotificationOptions(
        deviceToken: deviceToken,
        credential: credential,
        displayName: displayName,
        callKitOptions: callKitOptions) // CallKit options
    try await callComposite.registerPushNotification(notificationOptions: notificationOptions)

Behandeln von Pushbenachrichtigungen

Rufen Sie handlePushNotification() für eine CallComposite-Instanz mit Wörterbuchnutzdaten auf, um Pushbenachrichtigungen für eingehende Anrufe zu erhalten.

Bei Verwendung erhalten handlePushNotification()Sie eine CallKit-Benachrichtigung zum Annehmen oder Ablehnen von Anrufen.

    // App is in the background
    let pushNotificationInfo = CallCompositePushNotificationInfo(pushNotificationInfo: dictionaryPayload)
    let cxHandle = CXHandle(type: .generic, value: "\(pushNotificationInfo.callId)")
    let cxProvider = CallCompositeCallKitOption.getDefaultCXProviderConfiguration()
    let remoteInfo = CallCompositeCallKitRemoteInfo(displayName: pushNotificationInfo.fromDisplayName,
                                                    cxHandle: cxHandle)
    let callKitOptions = CallCompositeCallKitOption(cxProvideConfig: cxProvider,
                                                    isCallHoldSupported: true,
                                                    remoteInfo: remoteInfo)
    CallComposite.reportIncomingCall(callKitOptions: callKitOptions,
                                        callNotification: pushNotificationInfo) { result in
        if case .success() = result {
            DispatchQueue.global().async {
                // Handle push notification
                // You don't need to wait for a Communication Services token to handle the push because 
                // Communication Services commonly receives a callback function to get the token
            }
        }
    }

    // App is in the foreground
    let pushNotificationInfo = CallCompositePushNotificationInfo(pushNotificationInfo: dictionaryPayload)
    let displayName = "display name"
    let remoteOptions = RemoteOptions(for: pushNotificationInfo,
                                        credential: credential,
                                        displayName: displayName,
                                        callKitOptions: callKitOptions)
    try await callComposite.handlePushNotification(remoteOptions: remoteOptions)

Registrieren für eingehende Anrufbenachrichtigungen

Um eingehende Anrufbenachrichtigungen nach handlePushNotification, abonnieren IncomingCallEvent und IncomingCallEndEventempfangen .

    let onIncomingCall: (CallCompositeIncomingCallInfo) -> Void = { [] _ in
        // Incoming call
    }
    let onIncomingCallEnded: (CallCompositeIncomingCallEndedInfo) -> Void = { [] _ in
        // Incoming call ended
    }

    callComposite.events.onIncomingCall = onIncomingCall
    callComposite.events.onIncomingCallEnded = onIncomingCallEnded

Andere Teilnehmer anrufen

Um Anrufe mit anderen Teilnehmern zu beginnen, erstellen Sie CallCompositeStartCallOptions mit den unformatierten IDs der Teilnehmer aus CommunicationIdentity und launch.

    let startCallOptions = CallCompositeStartCallOptions(participants: <list of participant IDs>)
    let remoteOptions = RemoteOptions(for: startCallOptions,
                                        credential: credential,
                                        displayName: "DISPLAY_NAME",
                                        callKitOptions: callKitOptions)
    callComposite.launch(remoteOptions: remoteOptions,
                         localOptions: localOptions)

Nächste Schritte