Snabbstart: Kom igång med användargränssnittsbiblioteket

  • Artikel

Kom igång med Azure Communication Services UI Library för att snabbt integrera kommunikationsupplevelser i dina program. I den här snabbstarten får du lära dig hur du integrerar gränssnittsbibliotekets kompositer i ett program och konfigurerar upplevelsen för dina appanvändare.

Användargränssnittsbiblioteket för Communication Services återger en fullständig kommunikationsupplevelse direkt i ditt program. Den tar hand om att ansluta till samtalet och konfigurerar användarens deltagande i samtalet bakom kulisserna. Som utvecklare behöver du oroa dig för var i appens användarupplevelse du vill att kommunikationsupplevelsen ska starta. Kompositen tar användaren genom att konfigurera sina enheter, ansluta samtalet och delta i det och återge andra deltagare.

Visa den här videon för en översikt:

Kommentar

Detaljerad dokumentation och snabbstarter om webbgränssnittsbiblioteket finns i webbgränssnittsbibliotekets sagobok.

Förutsättningar

Du kan komma åt följande snabbstarter

Hämta Android-exempelprogrammet för den här snabbstarten i användargränssnittsbiblioteket för öppen källkod Azure Communication Services för Android.

Förutsättningar

Konfigurera projektet

Slutför följande avsnitt för att konfigurera snabbstartsprojektet.

Skapa ett nytt Android-projekt

Skapa ett nytt projekt i Android Studio:

  1. I menyn Arkiv väljer du Nytt>nytt projekt.

  2. I Nytt projekt väljer du projektmallen Tom aktivitet .

    Screenshot that shows the New Project dialog in Android Studio with Empty Activity selected.

  3. Välj Nästa.

  4. I Tom aktivitet namnger du projektets UILibraryQuickStart. För språk väljer du Java/Kotlin. Som minsta SDK väljer du API 21: Android 5.0 (Lollipop) eller senare.

  5. Välj Slutför.

    Screenshot that shows new project options and the Finish button selected.

Installera paketen

Slutför följande avsnitt för att installera nödvändiga programpaket.

Lägga till ett beroende

I filen UILibraryQuickStart/app/build.gradle på appnivå (i appmappen) lägger du till följande beroende:

dependencies {
    ...
    implementation 'com.azure.android:azure-communication-ui-calling:+'
    ...
}

Lägga till Maven-lagringsplatser

Två Maven-lagringsplatser krävs för att integrera biblioteket:

  • MavenCentral
  • Azure-paketlagringsplatsen

Så här lägger du till lagringsplatserna:

  1. Kontrollera att följande lagringsplatser läggs till i projektets Gradle-skript. För Android Studio (2020.*) repositories finns i , settings.gradleunder dependencyResolutionManagement(Gradle version 6.8 or greater). För tidigare versioner av Android Studio (4.*) repositories finns på projektnivå build.gradle, under allprojects{}.

    // dependencyResolutionManagement
repositories {
    ...
    mavenCentral()
    maven {
        url "https://pkgs.dev.azure.com/MicrosoftDeviceSDK/DuoSDK-Public/_packaging/Duo-SDK-Feed/maven/v1"
    }
    ...
}

  2. Synkronisera projektet med Gradle-filerna. Om du vill synkronisera projektet går du till arkivmenyn och väljer Synkronisera projekt med Gradle-filer.

Lägg till en knapp i Activity_main.xml

I layoutfilen app/src/main/res/layout/activity_main.xml lägger du till följande kod för att skapa en knapp för att starta den sammansatta filen:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <Button
        android:id="@+id/startButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Launch"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Initiera den sammansatta

Så här initierar du sammansatta:

  1. Gå till MainActivity.

  2. Lägg till följande kod för att initiera dina sammansatta komponenter för anrop. Ersätt "GROUP_CALL_ID" med grupp-ID:t för ditt samtal. Ersätt "DISPLAY_NAME" med ditt namn. Ersätt "USER_ACCESS_TOKEN" med din token.

package com.example.uilibraryquickstart

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import com.azure.android.communication.common.CommunicationTokenCredential
import com.azure.android.communication.common.CommunicationTokenRefreshOptions
import com.azure.android.communication.ui.calling.CallComposite
import com.azure.android.communication.ui.calling.CallCompositeBuilder
import com.azure.android.communication.ui.calling.models.CallCompositeGroupCallLocator
import com.azure.android.communication.ui.calling.models.CallCompositeJoinLocator
import com.azure.android.communication.ui.calling.models.CallCompositeRemoteOptions
import java.util.UUID

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        val startButton: Button = findViewById(R.id.startButton)
        startButton.setOnClickListener { l -> startCallComposite() }
    }

    private fun startCallComposite() {
        val communicationTokenRefreshOptions = CommunicationTokenRefreshOptions({ fetchToken() }, true)
        val communicationTokenCredential = CommunicationTokenCredential(communicationTokenRefreshOptions)

        val locator: CallCompositeJoinLocator = CallCompositeGroupCallLocator(UUID.fromString("GROUP_CALL_ID"))
        val remoteOptions = CallCompositeRemoteOptions(locator, communicationTokenCredential, "DISPLAY_NAME")

        val callComposite: CallComposite = CallCompositeBuilder().build()
        callComposite.launch(this, remoteOptions)
    }

    private fun fetchToken(): String? {
        return "USER_ACCESS_TOKEN"
    }
}

Kör koden

Skapa och starta programmet i Android Studio:

  1. Välj Starta.
  2. Godkänn behörigheter och välj sedan inställningar för enhet, mikrofon och video.
  3. Välj Anslut till samtal.

GIF animation that shows an example of how the project runs on an Android device.

Objektmodell

Följande klasser och gränssnitt hanterar några viktiga funktioner i Azure Communication Services Android-användargränssnittet:

Namn Beskrivning
CallComposite Sammansatt komponent som återger en anropsupplevelse med deltagargalleriet och kontroller
CallCompositeBuilder Byggare som bygger CallComposite med alternativ
CallCompositeJoinMeetingLocator CallComposite Skickad start för att starta ett gruppsamtal
CallCompositeTeamsMeetingLinkLocator Skickas till CallComposite start för att ansluta till ett Microsoft Teams-möte
CallCompositeLocalizationOptions Matas in som valfritt i CallCompositeBuilder för att ange språket för den sammansatta

Funktioner för användargränssnittsbibliotek

Hämta koden för att skapa viktiga kommunikationsfunktioner för ditt Android-program.

Skapa CallComposite

Om du vill skapa CallComposite, inuti startCallComposite funktionen initierar du en CallCompositeBuilder instans och en CallComposite instans.

val callComposite: CallComposite = CallCompositeBuilder().build()

Konfigurera autentisering

Om du vill konfigurera autentisering initierar du en CommunicationTokenCredential instans i startCallComposite funktionen. Ersätt "USER_ACCESS_TOKEN" med din åtkomsttoken.

val callComposite: CallComposite = CallCompositeBuilder().build()

val communicationTokenRefreshOptions = CommunicationTokenRefreshOptions(this::fetchToken, true)

val communicationTokenCredential = CommunicationTokenCredential(communicationTokenRefreshOptions)

Konfigurera ett gruppsamtal

Om du vill konfigurera ett gruppanrop initierar du ett CallCompositeGroupCallLocator och anger det till CallCompositeRemoteOptions objektet.

val locator = CallCompositeGroupCallLocator(UUID.fromString("GROUP_CALL_ID"))

val remoteOptions = CallCompositeRemoteOptions(
    locator,
    communicationTokenCredential,            
    "DISPLAY_NAME",
)

Konfigurera ett Teams-möte

Om du vill konfigurera ett Microsoft Teams-möte initierar du ett CallCompositeTeamsMeetingLinkLocator och anger det till CallCompositeRemoteOptions objektet.

val locator = CallCompositeTeamsMeetingLinkLocator("TEAMS_MEETING_LINK")

val remoteOptions = CallCompositeRemoteOptions(
    locator,
    communicationTokenCredential,            
    "DISPLAY_NAME",
)

Konfigurera ett rumssamtal

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.

Om du vill konfigurera ett Azure Communication Services Rooms-anrop initierar du ett CallCompositeRoomLocator, anger det till CallCompositeRemoteOptions -objektet och anger CallCompositeParticipantRole till CallCompositeLocalOptions by setRoleHint(). CallComposite använder rolltips innan du ansluter till anropet. När anropet är anslutet hämtas den aktuella deltagarrollen från Azure Communication Services.

Mer information om Rum, hur du skapar och hanterar en finns i Snabbstart för rum

val locator = CallCompositeRoomLocator("<ROOM_ID>")

val remoteOptions = CallCompositeRemoteOptions(
    locator,
    communicationTokenCredential,            
    "DISPLAY_NAME",
)

val localOptions = CallCompositeLocalOptions().setRoleHint(participantRole)

val callComposite = CallCompositeBuilder().build()
callComposite.launch(context, remoteOptions, localOptions)

Starta den sammansatta

Om du vill starta anropsgränssnittet anropar launch du instansen CallCompositestartCallComposite i funktionen.

callComposite.launch(context, remoteOptions)

Prenumerera på CallComposite-felhändelser

Om du vill ta emot felhändelser anropar du setOnErrorHandler med CallComposite.

Följande errorCode värden kan skickas till felhanteraren:

  • CallCompositeErrorCode.CALL_JOIN_FAILED
  • CallCompositeErrorCode.CALL_END_FAILED
  • CallCompositeErrorCode.TOKEN_EXPIRED
  • CallCompositeErrorCode.CAMERA_FAILURE
  • CallCompositeErrorCode.MICROPHONE_PERMISSION_NOT_GRANTED
  • CallCompositeErrorCode.NETWORK_CONNECTION_NOT_AVAILABLE

I följande exempel visas en felhändelse för en misslyckad sammansatt händelse.

callComposite.addOnErrorEventHandler { callCompositeErrorEvent ->
    println(callCompositeErrorEvent.errorCode)
}

Använda en temakonfiguration

Om du vill ändra den primära färgen för kompositen skapar du ett nytt temaformat i src/main/res/values/themes.xml och src/main/res/values-night/themes.xml med hjälp AzureCommunicationUICalling.Theme av som överordnat tema. Använd temat genom att mata in tema-ID:t i CallCompositeBuilder:

<style name="MyCompany.CallComposite" parent="AzureCommunicationUICalling.Theme">
    <item name="azure_communication_ui_calling_primary_color">#27AC22</item>
    <item name="azure_communication_ui_calling_primary_color_tint10">#5EC65A</item>
    <item name="azure_communication_ui_calling_primary_color_tint20">#A7E3A5</item>
    <item name="azure_communication_ui_calling_primary_color_tint30">#CEF0CD</item>
</style>

val callComposite: CallComposite =
        CallCompositeBuilder()
            .theme(R.style.MyCompany_CallComposite)
            .build()

Tillämpa en lokaliseringskonfiguration

Om du vill ändra språket för det sammansatta språket använder du CallCompositeSupportedLocale för att skapa CallCompositeLocalizationOptions med Locale. Använd språket genom att mata in lokaliseringskonfigurationen i CallCompositeBuilder. Som standard använder alla textetiketter engelska (en) strängar. Du kan använda CallCompositeLocalizationOptions för att ange ett annat värde för language. Som standard innehåller användargränssnittsbiblioteket en uppsättning language värden som du kan använda med UI-komponenter. CallCompositeSupportedLocale tillhandahåller de nationella inställningar som stöds. Om du till exempel vill komma åt det engelska språket kan du använda CallCompositeSupportedLocale.EN. CallCompositeSupportedLocale.getSupportedLocales() innehåller en lista över nationella objekt för språk som stöds.

import com.azure.android.communication.ui.calling.models.CallCompositeLocalizationOptions
import com.azure.android.communication.ui.calling.models.CallCompositeSupportedLocale

// CallCompositeSupportedLocale provides list of supported locale
val callComposite: CallComposite =
            CallCompositeBuilder().localization(
                CallCompositeLocalizationOptions(CallCompositeSupportedLocale.EN)
            ).build()

Prenumerera på callComposite call state changed event

Om du vill ta emot ändrade händelser för samtalstillstånd anropar du addOnCallStateChangedEventHandler med CallComposite.

I följande exempel visas en händelse för ett ändrat anropstillstånd.

callComposite.addOnCallStateChangedEventHandler { callStateChangedEvent ->
    println(callStateChangedEvent.code)
}

Stäng CallComposite och prenumerera på en avvisad händelse

Om du vill ta emot avvisande anropar du addOnDismissedEventHandler med CallComposite. Om du vill stänga CallComposite anropar du dismiss.

I följande exempel visas en händelse för ett ändrat anropstillstånd.

callComposite.addOnDismissedEventHandler { callCompositeDismissedEvent ->
    println(callCompositeDismissedEvent.errorCode)
}

callComposite.dismiss()

Fler funktioner

Listan över användningsfall innehåller detaljerad information om fler funktioner.

Lägga till meddelanden i din mobilapp

Azure Communication Services integreras med Azure Event Grid och Azure Notification Hubs så att du kan lägga till push-meddelanden i dina appar i Azure. Du kan använda push-meddelanden för att skicka information från ditt program till användarnas mobila enheter. Ett push-meddelande kan visa en dialogruta, spela upp ett ljud eller visa ett inkommande samtalsgränssnitt.

Hämta exempelprogrammet för iOS för den här snabbstarten i öppen källkod Azure Communication Services UI Library för iOS.

Förutsättningar

Konfigurera projektet

Slutför följande avsnitt för att konfigurera snabbstartsprojektet.

Skapa ett nytt Xcode-projekt

Skapa ett nytt projekt i Xcode:

  1. I menyn Arkiv väljer du Nytt>projekt.

  2. I Välj en mall för ditt nya projekt väljer du iOS-plattformen och väljer programmallen App . Snabbstarten använder UIKit-storyboards. Snabbstarten skapar inte tester, så du kan avmarkera kryssrutan Inkludera tester .

    Screenshot that shows the Xcode new project dialog, with iOS and the App template selected.

  3. I Välj alternativ för det nya projektet anger du UILibraryQuickStart som produktnamn. För gränssnittet väljer du Storyboard.

    Screenshot that shows setting new project options in Xcode.

Installera paketet och beroenden

  1. (Valfritt) För MacBook med M1 installerar och aktiverar du Rosetta i Xcode.

  2. I projektrotkatalogen kör du pod init för att skapa en Podfile. Om du får ett fel uppdaterar du CocoaPods till den aktuella versionen.

  3. Lägg till följande kod i poddfilen. Ersätt UILibraryQuickStart med projektnamnet.

    platform :ios, '15.0'

target 'UILibraryQuickStart' do
    use_frameworks!
    pod 'AzureCommunicationUICalling'
end

  4. Kör pod install --repo-update.

  5. Öppna den genererade .xcworkspace-filen i Xcode.

Begär åtkomst till enhetens maskinvara

Om du vill komma åt enhetens maskinvara, inklusive mikrofonen och kameran, uppdaterar du appens egenskapslista för information. Ange det associerade värdet till en sträng som ingår i dialogrutan som systemet använder för att begära åtkomst från användaren.

  1. Högerklicka på posten i Info.plist projektträdet och välj Öppna som>källkod. Lägg till följande rader i avsnittet på den översta nivån <dict> och spara sedan filen.

    <key>NSCameraUsageDescription</key>
<string></string>
<key>NSMicrophoneUsageDescription</key>
<string></string>

    Här är ett exempel på källkoden Info.plist i en Xcode-fil:

    Screenshot that shows an example of the info plist source code in an Xcode file.

  2. Om du vill kontrollera att begäranden om enhetsbehörighet har lagts till korrekt väljer du Öppna som>egenskapslista. Kontrollera att informationsegenskapslistan ser ut ungefär som i följande exempel:

    Screenshot that shows the camera and microphone device privacy in Xcode.

Inaktivera bitkod

I Xcode-projektet under Skapa Inställningar anger du alternativet Aktivera bitkod till Nej. Om du vill hitta inställningen ändrar du filtret från Basic till Alla eller använder sökfältet.

Screenshot that shows the Build Settings option to turn off Bitcode.

Initiera den sammansatta

Så här initierar du sammansatta:

  1. Gå till ViewController.

  2. Lägg till följande kod för att initiera dina sammansatta komponenter för ett anrop. Ersätt <GROUP_CALL_ID> med antingen grupp-ID:t för ditt samtal eller med UUID() för att generera ett grupp-ID för anropet. Ersätt <DISPLAY_NAME> med ditt namn. (Stränglängdsgränsen för <DISPLAY_NAME> är 256 tecken.) Ersätt <USER_ACCESS_TOKEN> med din åtkomsttoken.

    import UIKit
import AzureCommunicationCalling
import AzureCommunicationUICalling

class ViewController: UIViewController {

    private var callComposite: CallComposite?

    override func viewDidLoad() {
        super.viewDidLoad()

        let button = UIButton(frame: CGRect(x: 100, y: 100, width: 200, height: 50))
        button.contentEdgeInsets = UIEdgeInsets(top: 10.0, left: 20.0, bottom: 10.0, right: 20.0)
        button.layer.cornerRadius = 10
        button.backgroundColor = .systemBlue
        button.setTitle("Start Experience", for: .normal)
        button.addTarget(self, action: #selector(startCallComposite), for: .touchUpInside)

        button.translatesAutoresizingMaskIntoConstraints = false
        self.view.addSubview(button)
        button.centerXAnchor.constraint(equalTo: view.centerXAnchor).isActive = true
        button.centerYAnchor.constraint(equalTo: view.centerYAnchor).isActive = true
    }

    @objc private func startCallComposite() {
        let callCompositeOptions = CallCompositeOptions()

        callComposite = CallComposite(withOptions: callCompositeOptions)

        let communicationTokenCredential = try! CommunicationTokenCredential(token: "<USER_ACCESS_TOKEN>")

        let remoteOptions = RemoteOptions(for: .groupCall(groupId: UUID(uuidString: "<GROUP_CALL_ID>")!),
                                          credential: communicationTokenCredential,
                                          displayName: "<DISPLAY_NAME>")
        callComposite?.launch(remoteOptions: remoteOptions)
    }
}

Kör koden

Om du vill skapa och köra din app i iOS-simulatorn väljer du Produktkörning> eller använder kortkommandot (⌘-R). Prova sedan samtalsupplevelsen i simulatorn:

  1. Välj Startupplevelse.

  2. Acceptera ljudbehörigheter och välj sedan inställningar för enhet, mikrofon och video.

  3. Välj Starta anrop.

GIF animation that demonstrates the final look and feel of the quickstart iOS app.

Objektmodell

Följande klasser och gränssnitt hanterar några viktiga funktioner i Azure Communication Services UI-klientbiblioteket:

Namn Beskrivning
CallComposite Komponent som återger en anropsupplevelse som har ett deltagargalleri och kontroller
CallCompositeOptions Inställningar för alternativ som teman och händelsehantering
RemoteOptions Fjärralternativ för att skicka till Azure Communication Services för att ansluta till ett gruppsamtal eller ett Teams-möte.
TemaAlternativ Anpassningsalternativ för det sammansatta temat
LokaliseringAlternativ Språkalternativ för den sammansatta

Funktioner för användargränssnittsbibliotek

Hämta koden för att skapa viktiga kommunikationsfunktioner för ditt iOS-program.

Skapa CallComposite

Om du vill skapa CallComposite, inuti startCallComposite funktionen initierar du en CallCompositeOptions instans och en CallComposite instans:

@objc private func startCallComposite() {
    let callCompositeOptions = CallCompositeOptions()

    callComposite = CallComposite(withOptions: callCompositeOptions)
}

Konfigurera autentisering

Om du vill konfigurera autentisering initierar du en CommunicationTokenCredential instans i startCallComposite funktionen. Ersätt <USER_ACCESS_TOKEN> med din åtkomsttoken.

let communicationTokenCredential = try! CommunicationTokenCredential(token: "<USER_ACCESS_TOKEN>")

Om du inte redan har en åtkomsttoken skapar du en åtkomsttoken för Azure Communication Services.

Konfigurera ett gruppsamtal

Om du vill konfigurera ett gruppanrop initierar du en RemoteOptions instans för positioneraren .groupCall i startCallComposite funktionen. Ersätt <GROUP_CALL_ID> med grupp-ID:t för ditt samtal. Ersätt <DISPLAY_NAME> med ditt namn.

// let uuid = UUID() to create a new call
let uuid = UUID(uuidString: "<GROUP_CALL_ID>")!
let remoteOptions = RemoteOptions(for: .groupCall(groupId: uuid),
                                  credential: communicationTokenCredential,
                                  displayName: "<DISPLAY_NAME>")

Mer information om hur du använder ett grupp-ID för anrop finns i Hantera anrop.

Konfigurera ett Teams-möte

Om du vill konfigurera ett Microsoft Teams-möte initierar du en RemoteOptions instans för positioneraren .teamsMeeting i startCallComposite funktionen. Ersätt <TEAMS_MEETING_LINK> med teams-möteslänken för ditt samtal. Ersätt <DISPLAY_NAME> med ditt namn.

let remoteOptions = RemoteOptions(for: .teamsMeeting(teamsLink: "<TEAMS_MEETING_LINK>"),
                                  credential: communicationTokenCredential,
                                  displayName: "<DISPLAY_NAME>")

Du kan hämta en Microsoft Teams-möteslänk med hjälp av Graph-API:er. Den här processen beskrivs i Graph-dokumentationen.

Communication Services Call SDK accepterar en fullständig Microsoft Teams-möteslänk. Den här länken returneras som en del av resursen onlineMeeting under egenskapen joinWebUrl. Du kan också hämta nödvändig mötesinformation från URL:en för att ansluta till mötet i själva Teams-mötesbjudan.

Konfigurera ett rumssamtal

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.

Om du vill konfigurera ett Azure Communication Services Rooms-anrop initierar du en RemoteOptions instans för positioneraren .roomCall i startCallComposite funktionen. Ersätt <ROOM_ID> med rums-ID:t för ditt samtal. Initiera en LocalOptions instans med roleHint.

Ersätt <DISPLAY_NAME> med ditt namn.

CallComposite använder rolltips innan du ansluter till anropet. När anropet är anslutet hämtas den aktuella deltagarrollen från Azure Communication Services.

Mer information om Rum, hur du skapar och hanterar en finns i Snabbstart för rum

let remoteOptions = RemoteOptions(for: .roomCall(roomId: "<ROOM_ID>"),
                                  credential: communicationTokenCredential,
                                  displayName: "<DISPLAY_NAME>")
let localOptions = LocalOptions(roleHint: participantRole)

let callComposite = CallComposite()
callComposite.launch(remoteOptions: remoteOptions, localOptions: localOptions)

Starta den sammansatta

startCallComposite I funktionen anropar du launch instansenCallComposite:

callComposite?.launch(remoteOptions: remoteOptions)

Prenumerera på händelser

Du kan implementera stängningar för att agera på sammansatta händelser. Följande errorCodes kan skickas till felhanteraren:

  • callJoin
  • callEnd
  • cameraFailure
  • tokenExpired
  • microphonePermissionNotGranted
  • networkConnectionNotAvailable

I följande exempel visas en felhändelse för en misslyckad sammansatt händelse:

callComposite?.events.onError = { error in
    print("CallComposite failed with error:\(error)")
}

Använda temaalternativ

Om du vill anpassa kommunikationsupplevelsen i ditt program skapar du anpassade temaalternativ som implementerar ThemeOptions protokollet. Inkludera en instans av den nya klassen i CallCompositeOptions:

class CustomThemeOptions: ThemeOptions {
   var primaryColor: UIColor {
       return UIColor.red
   }
}

let callCompositeOptions = CallCompositeOptions(theme: CustomThemeOptions())

Mer information om hur teman fungerar finns i temaguiden.

Använd lokaliseringsalternativ

Om du vill ändra språket i kompositen skapar du anpassade lokaliseringsalternativ och inkluderar dem i CallCompositeOptions. Som standard använder alla textetiketter engelska (SupportedLocale.en) strängar. Du kan använda LocalizationOptions för att ange ett annat värde för locale. Som standard innehåller användargränssnittsbiblioteket en uppsättning locale värden som du kan använda med UI-komponenterna. SupportedLocale.values innehåller en lista över alla språk som stöds.

I följande exempel lokaliseras kompositen till franska (fr):

// Option1: Use IntelliSense to get locales UI Library supports.
let localizationOptions = LocalizationOptions(locale: SupportedLocale.frFR)

// Option2: If UI Library doesn't support the locale you set, the Swift Locale struct defaults to English.
let localizationOptions = LocalizationOptions(locale: Locale(identifier: "fr-FR"))

let callCompositeOptions = CallCompositeOptions(localization: localizationOptions)

Mer information om lokalisering och en lista över språk som stöds finns i lokaliseringsguiden.

Prenumerera på callComposite call state changed event

Du kan implementera stängningar för att agera på sammansatta händelser. Samtalstillstånden skickas till anropstillståndets ändrade hanterare.

I följande exempel visas en händelse för ett ändrat anropstillstånd.

callComposite?.events.onCallStateChanged = { callStateEvent in
   print("CallComposite call state changed:\(callStateEvent.requestString)")
}

Stäng CallComposite och prenumerera på en avvisad händelse

Om du vill stänga CallComposite anropar du dismiss. Följande avvisande händelse skickas på anrop sammansatt avvisas:

callComposite?.events.onDismissed = { dismissed in
   print("CallComposite dismissed:\(dismissed.errorCode)")
}

callComposite.dismiss()

Lägga till meddelanden i din mobilapp

Azure Communication Services integreras med Azure Event Grid och Azure Notification Hubs så att du kan lägga till push-meddelanden i dina appar i Azure. Du kan använda push-meddelanden för att skicka information från ditt program till användarnas mobila enheter. Ett push-meddelande kan visa en dialogruta, spela upp ett ljud eller visa ett inkommande samtalsgränssnitt.

Rensa resurser

Om du vill rensa och ta bort en Communication Services-prenumeration kan du ta bort resursen eller resursgruppen.

Om du tar bort resursgruppen tas även alla andra resurser som är associerade med den bort.

Läs mer om att rensa resurser.