Share via

Konfigurera ett-till-en-samtal och push-meddelanden i användargränssnittsbiblioteket

  • Artikel

Användargränssnittsbiblioteket tillhandahåller out-of-the-box-stöd för att göra en-till-en-anrop med hjälp av Azure Communication Services-deltagaridentifierare. För att stödja ett-till-en-samtal tillhandahåller användargränssnittsbiblioteket inkommande samtalsaviseringar. Du kan också använda Azure Communication Services som en Azure Event Grid-händelsekälla för anrop.

I den här artikeln får du lära dig hur du gör en-till-en-anrop på rätt sätt med hjälp av användargränssnittsbiblioteket i ditt program.

Viktigt!

Den här funktionen i Azure Communication Services är för närvarande i förhandsversion.

Förhandsversions-API:er och SDK:er tillhandahålls utan ett serviceavtal. Vi rekommenderar att du inte använder dem för produktionsarbetsbelastningar. Vissa funktioner kanske inte stöds, eller så kan de ha begränsade funktioner.

Mer information finns i Kompletterande användningsvillkor för Förhandsversioner av Microsoft Azure.

Förutsättningar

Konfigurera funktionerna

Mer information finns i Android UI-biblioteket med öppen källkod och exempelprogramkoden.

Konfigurera behörigheter för push-meddelanden

För att konfigurera push-meddelanden behöver du ett Firebase-konto med Firebase Cloud Messaging (FCM) aktiverat. Din FCM-tjänst måste vara ansluten till en Azure Notification Hubs-instans. Mer information finns i Meddelanden om Kommunikationstjänster. Du måste också använda Android Studio version 3.6 eller senare för att skapa ditt program.

För att Android-programmet ska kunna ta emot meddelanden från FCM behöver det en uppsättning behörigheter. AndroidManifest.xml Lägg till följande uppsättning behörigheter efter taggen <manifest ...> eller </application> i filen.

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

Registrera dig för push-meddelanden

För att registrera sig för push-meddelanden måste programmet anropa registerPushNotification() en CallComposite instans med en enhetsregistreringstoken.

Om du vill hämta enhetsregistreringstoken lägger du till Firebase SDK i programmodulens build.gradle instans. Om du vill ta emot meddelanden från Firebase integrerar du Azure Notification Hubs genom att följa anvisningarna i Communication Services-meddelanden.

För att undvika aktuella begränsningar kan du hoppa över registerPushNotification genom att använda Azure Event Grid för push-meddelanden. Mer information finns i Anslut anropa interna push-meddelanden med Azure Event Grid.

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

Hantera push-meddelanden

Om du vill ta emot push-meddelanden för inkommande samtal anropar du handlePushNotification en CallComposite instans med en nyttolast.

Om du vill hämta nyttolasten från FCM börjar du med att skapa en ny tjänst (File>New>Service>Service) som utökar FirebaseMessagingService Firebase SDK-klassen och åsidosätter onMessageReceived metoden. Den här metoden är den händelsehanterare som anropas när FCM levererar push-meddelandet till programmet.

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

Registrera dig för inkommande samtalsaviseringar

Om du vill ta emot inkommande samtalsaviseringar efter handlePushNotificationprenumererar du på IncomingCallEvent och IncomingCallEndEvent.

    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)

Hantera anrop

Om du vill acceptera anrop ringer du ett anrop till acceptIncomingCall. Om du vill avvisa anrop ringer du ett anrop till declineIncomingCall.

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

// Decline call
callComposite.declineIncomingCall()

Ring upp andra deltagare

Om du vill starta samtal med andra deltagare skapar CallCompositeStartCallOptions du med deltagarnas rå-ID från CommunicationIdentity och launch.

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

Integrera TelecomManager-exempel

Om du vill integrera TelecomManager använder du exemplen i biblioteket med öppen källkod. Använd CallComposite API:er för hold, resume, muteoch unmute. Skapa CallComposite med CallCompositeTelecomIntegration.APPLICATION_IMPLEMENTED_TELECOM_MANAGER som ska användas TelecomManager i ett program.

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

Mer information finns i iOS-användargränssnittsbiblioteket med öppen källkod och exempelprogramkoden.

Konfigurera push-meddelanden

Ett mobilt push-meddelande är popup-meddelandet som du får i den mobila enheten. För samtal fokuserar den här artikeln på voIP-push-meddelanden (Voice over Internet Protocol).

I följande avsnitt beskrivs hur du registrerar dig för, hanterar och avregistrerar push-meddelanden. Innan du påbörjar dessa uppgifter måste du slutföra följande krav:

  1. I Xcode går du till Signering och funktioner. Lägg till en funktion genom att välja + Kapacitet och välj sedan Push-meddelanden.
  2. Lägg till ytterligare en funktion genom att välja + Kapacitet och välj sedan Bakgrundslägen.
  3. Under Bakgrundslägen markerar du kryssrutorna Röst över IP och Fjärrmeddelanden .

Registrera dig för push-meddelanden

För att registrera sig för push-meddelanden måste programmet anropa registerPushNotification() en CallComposite instans med en enhetsregistreringstoken.

För att undvika aktuella begränsningar kan du hoppa över registerPushNotification genom att använda Azure Event Grid för push-meddelanden. Mer information finns i Anslut anropa interna push-meddelanden med 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)

Hantera push-meddelanden

Om du vill ta emot push-meddelanden för inkommande samtal anropar handlePushNotification() du en CallComposite instans med en ordlistenyttolast.

När du använder handlePushNotification()får du ett CallKit-meddelande för att acceptera eller avvisa samtal.

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

Registrera dig för inkommande samtalsaviseringar

Om du vill ta emot inkommande samtalsaviseringar efter handlePushNotificationprenumererar du på IncomingCallEvent och IncomingCallEndEvent.

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

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

Ring upp andra deltagare

Om du vill starta samtal med andra deltagare skapar CallCompositeStartCallOptions du med deltagarnas rå-ID från CommunicationIdentity och 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ästa steg