Udostępnij za pośrednictwem

Konfigurowanie połączeń typu jeden do jednego i powiadomień wypychanych w bibliotece interfejsu użytkownika

  • Artykuł

Biblioteka interfejsu użytkownika zapewnia wbudowaną obsługę wykonywania wywołań jeden do jednego przy użyciu identyfikatorów uczestników usług Azure Communication Services. Aby obsługiwać wywołania typu jeden do jednego, biblioteka interfejsu użytkownika udostępnia przychodzące powiadomienia o wywołaniach. Usługi Azure Communication Services można również używać jako źródła zdarzeń usługi Azure Event Grid do wywołań.

Z tego artykułu dowiesz się, jak poprawnie wykonywać wywołania jeden do jednego przy użyciu biblioteki interfejsu użytkownika w aplikacji.

Wymagania wstępne

Konfigurowanie funkcji

Aby uzyskać więcej informacji, zobacz bibliotekę interfejsu użytkownika systemu Android typu open source i przykładowy kod aplikacji.

Konfigurowanie uprawnień dla powiadomień wypychanych

Aby skonfigurować powiadomienia wypychane, musisz mieć konto firebase z włączoną usługą Firebase Cloud Messaging (FCM). Usługa FCM musi być połączona z wystąpieniem usługi Azure Notification Hubs. Aby uzyskać więcej informacji, zobacz Powiadomienia usług komunikacyjnych. Aby skompilować aplikację, musisz również użyć programu Android Studio w wersji 3.6 lub nowszej.

Aby aplikacja systemu Android odbierała komunikaty powiadomień z usługi FCM, musi mieć zestaw uprawnień. AndroidManifest.xml W pliku dodaj następujący zestaw uprawnień po tagu <manifest ...> or</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" />

Dodawanie powiadomień przychodzących do aplikacji mobilnej

Usługi Azure Communication Services integrują się z usługami Azure Event Grid i Azure Notification Hubs, dzięki czemu można dodawać powiadomienia wypychane do aplikacji na platformie Azure.

Rejestrowanie/wyrejestrowywanie powiadomień wypychanych centrum powiadomień

Aby zarejestrować się w celu otrzymywania powiadomień wypychanych, aplikacja musi wywołać registerPushNotification() CallComposite wystąpienie przy użyciu tokenu rejestracji urządzenia.

Aby uzyskać token rejestracji urządzenia, dodaj zestaw Firebase SDK do wystąpienia modułu build.gradle aplikacji. Aby otrzymywać powiadomienia z programu Firebase, zintegruj usługę Azure Notification Hubs, postępując zgodnie z instrukcjami w obszarze Powiadomienia usług Komunikacyjnych.

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

Obsługa powiadomień wypychanych odebranych z usługi Event Grid lub centrum powiadomień

Aby odbierać powiadomienia wypychane dla połączeń przychodzących, wywołaj handlePushNotification CallComposite wystąpienie z ładunkiem.

Aby pobrać ładunek z usługi FCM, zacznij od utworzenia nowej usługi (usługi File>New>Service),> która rozszerza FirebaseMessagingService klasę zestawu SDK programu Firebase i zastępuje metodę .onMessageReceived Ta metoda to procedura obsługi zdarzeń wywoływana, gdy usługa FCM dostarcza powiadomienie wypychane do aplikacji.

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

Rejestrowanie w celu otrzymywania powiadomień o połączeniach przychodzących

Aby otrzymywać powiadomienia o połączeniach przychodzących po handlePushNotification, zasubskrybuj CallCompositeIncomingCallEvent i CallCompositeIncomingCallCancelledEvent. CallCompositeIncomingCallEvent zawiera identyfikator wywołania przychodzącego i informacje o obiekcie wywołującym. CallCompositeIncomingCallCancelledEvent zawiera identyfikator callId i kod anulowania wywołań w usługach Azure Communication Services.

    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)

Obsługa wywołań

Aby akceptować połączenia, wykonaj wywołanie metody accept. Aby odrzucić wywołania, wykonaj wywołanie metody reject.

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

// Decline call
callComposite.reject(incomingCallId)

Wybieranie innych uczestników

Aby rozpocząć połączenia z innymi uczestnikami, utwórz CallCompositeStartCallOptions z nieprzetworzonymi identyfikatorami uczestników z CommunicationIdentity i launch.

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

Aby uzyskać więcej informacji, zobacz bibliotekę interfejsu użytkownika systemu iOS typu open source i przykładowy kod aplikacji.

Konfigurowanie powiadomień wypychanych

Powiadomienie push dla urządzeń przenośnych to wyskakujące powiadomienie, które otrzymasz na urządzeniu przenośnym. Ten artykuł koncentruje się na powiadomieniach wypychanych za pośrednictwem protokołu Internet Protocol (VoIP).

W poniższych sekcjach opisano sposób rejestrowania, obsługi i wyrejestrowania powiadomień wypychanych. Przed rozpoczęciem tych zadań wykonaj następujące wymagania wstępne:

  1. W programie Xcode przejdź do pozycji Podpisywanie i możliwości. Dodaj możliwość, wybierając pozycję + Możliwości, a następnie wybierz pozycję Powiadomienia wypychane.
  2. Dodaj kolejną możliwość, wybierając pozycję + Możliwości, a następnie wybierz pozycję Tryby w tle.
  3. W obszarze Tryby tła zaznacz pola wyboru Voice over IP i Remote notifications (Głos za pośrednictwem adresu IP i powiadomień zdalnych ).

Dodawanie powiadomień przychodzących do aplikacji mobilnej

Usługi Azure Communication Services integrują się z usługami Azure Event Grid i Azure Notification Hubs, dzięki czemu można dodawać powiadomienia wypychane do aplikacji na platformie Azure.

Rejestrowanie/wyrejestrowywanie powiadomień wypychanych centrum powiadomień

Aby zarejestrować się w celu otrzymywania powiadomień wypychanych, aplikacja musi wywołać registerPushNotifications() CallComposite wystąpienie przy użyciu tokenu rejestracji urządzenia.

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

Obsługa powiadomień wypychanych odebranych z usługi Event Grid lub centrum powiadomień

Aby odbierać powiadomienia wypychane dla wywołań przychodzących, wywołaj handlePushNotification() CallComposite wystąpienie z ładunkiem słownika.

Gdy używasz handlePushNotification() i opcje CallKit są ustawione, otrzymasz powiadomienie CallKit o akceptowaniu lub odrzucaniu wywołań.

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

Rejestrowanie w celu otrzymywania powiadomień o wywołaniu przychodzącym przy wypychaniu dojścia

Aby otrzymywać powiadomienia o połączeniach przychodzących po handlePushNotification, zasubskrybuj onIncomingCall i onIncomingCallCancelled. IncomingCall zawiera identyfikator wywołania przychodzącego i informacje o obiekcie wywołującym. IncomingCallCancelled zawiera identyfikator callId i kod anulowania wywołań w usługach Azure Communication Services.

    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

Wyłączanie wewnętrznego wypychania dla połączeń przychodzących

Aby otrzymywać powiadomienia wypychane tylko z EventGrid elementu i APNS ustawić wartość disableInternalPushForIncomingCall true w elem CallCompositeOptions. Jeśli disableInternalPushForIncomingCall ma wartość true, zdarzenie powiadomienia wypychanego z biblioteki interfejsu użytkownika odebrane tylko wtedy, gdy handlePushNotification zostanie wywołane. Opcja disableInternalPushForIncomingCall ułatwia zatrzymanie odbierania powiadomień z CallComposite trybu pierwszego planu. To ustawienie nie kontroluje ustawień i NotificationHub nie jest to ustawienieEventGrid.

    let options = CallCompositeOptions(disableInternalPushForIncomingCall: true)

Uruchamianie złożonego wywołania przychodzącego zaakceptowanego z wywołania zestawu CallKit zestawu SDK

Usługa Azure Communication Services wywołująca zestaw SDK systemu iOS obsługuje integrację z zestawem CallKit. Tę integrację można włączyć w bibliotece interfejsu użytkownika, konfigurując wystąpienie programu CallCompositeCallKitOption. Aby uzyskać więcej informacji, zobacz Integracja z zestawem CallKit.

onIncomingCallAcceptedFromCallKit Subskrybuj, jeśli zestaw CallKit z wywoływania zestawu SDK jest włączony. Po zaakceptowaniu połączenia uruchom polecenie callComposite z identyfikatorem połączenia.

    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)

Obsługa wywołań za pomocą funkcji CallComposite

Aby akceptować połączenia, wykonaj wywołanie metody accept. Aby odrzucić wywołania, wykonaj wywołanie metody reject.

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

// Decline call
callComposite.reject(incomingCallId)

Wybieranie innych uczestników

Aby rozpocząć połączenia z innymi uczestnikami, uruchom polecenie callComposite z listą uczestników .CommunicationIdentifier

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

Następne kroki