Megosztás a következőn keresztül:

Push értesítések engedélyezése

A leküldéses értesítések információkat küldenek az alkalmazásból a felhasználók eszközeire. Leküldéses értesítések használatával megjeleníthet egy párbeszédpanelt, lejátszhat egy hangot, vagy megjelenítheti a bejövő hívásokat az alkalmazás felhasználói felületi rétegében.

Ebből a cikkből megtudhatja, hogyan engedélyezheti a leküldéses értesítéseket az Azure Communication Services-hívásokhoz. A Communication Services integrációkat biztosít az Azure Event Grid és az Azure Notification Hubs szolgáltatással, amelyek lehetővé teszik leküldéses értesítések hozzáadását az alkalmazásokhoz.

A TTL-jogkivonatok áttekintése

A time-to-live (TTL) token egy olyan beállítás, amely meghatározza, hogy egy értesítési token mennyi ideig marad érvényes, mielőtt érvényét veszti. Ez a beállítás olyan alkalmazások esetében hasznos, amelyekben a felhasználói előjegyzés nem igényel napi interakciót, de hosszabb időszakokban kritikus fontosságú marad.

A TTL-konfiguráció lehetővé teszi a leküldéses értesítések életciklusának kezelését. Csökkenti a gyakori jogkivonat-megújítások szükségességét, és segít biztosítani, hogy az alkalmazás és a felhasználók közötti kommunikációs csatorna hosszabb ideig nyitva és megbízható maradjon.

A TTL maximális értéke jelenleg 180 nap (15 552 000 másodperc), a minimális érték pedig 5 perc (300 másodperc). Ezt az értéket megadhatja, és az igényeinek megfelelően módosíthatja. Ha nem ad meg értéket, az alapértelmezett érték 24 óra (86 400 másodperc).

Miután meghívják a regisztrációs értesítés API-t, az eszköz token információit a regisztráló tárolja. A TTL-időtartam lejárta után az eszközvégpont adatai törlődnek. Ha ezek az eszközök nem hívják meg újra a Push Notification API regisztrációját, akkor nem lehet bejövő hívásokat továbbítani az eszközökre.

Ha vissza szeretne vonni egy identitást, kövesse ezt a folyamatot. Az identitás visszavonása után a regisztráló bejegyzését törölni kell.

Feljegyzés

Microsoft Teams-felhasználó esetén a maximális TTL-érték 24 óra (86 400 másodperc). Ezt az értéket nem lehet növelni. Az alkalmazást 24 óránként fel kell ébreszteni a háttérben, és regisztrálni az eszköz tokenjét.

Az alkalmazás felébresztéséhez, az új jogkivonat lekéréséhez és a regisztráció végrehajtásához kövesse az iOS-platform utasításait vagy az Android-platform utasításait.

Előfeltételek

Kövesse a gyorsindítót

Az Azure Communication Services Web Calling SDK-n keresztüli webes leküldéses értesítések előzetes verzióban érhetők el, és az 1.12.0-beta.2+ verzió részeként érhetők el.

Fontos

Az Azure Communication Services ezen funkciója jelenleg előzetes verzióban érhető el. Az előzetes verziójú funkciók nyilvánosan elérhetők, és minden új és meglévő Microsoft-ügyfél használhatja.

Az előzetes verziójú API-k és SDK-k szolgáltatásszintű szerződés nélkül érhetők el. Javasoljuk, hogy éles számítási feladatokhoz ne használja őket. Előfordulhat, hogy bizonyos funkciók nem támogatottak, vagy a képességek korlátozottak lehetnek.

További információ: Microsoft Azure Previewskiegészítő használati feltételei.

Részletes útmutatásért tekintse meg a GitHubon található rövid útmutatót.

  • Firebase-fiók, amelyen engedélyezve van a Firebase Cloud Messaging (FCM) és az FCM szolgáltatás egy Azure Notification Hubs-példányhoz csatlakozik. További információ: Communication Services-értesítések.

  • Az Android Studio 3.6-os vagy újabb verziója az alkalmazás létrehozásához.

  • Engedélyek készlete, amelyek lehetővé teszik, hogy az Android-alkalmazás értesítési üzeneteket fogadjon az FCM-ből. AndroidManifest.xml A fájlban adja hozzá a következő engedélyeket közvetlenül a <manifest ...> címke után </application> vagy alatt:

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

Fontos

2023. június 20-án a Google bejelentette, hogy elavultnak nyilvánította az üzenetküldést az FCM régi API-k segítségével, és 2024 júniusában kezdi meg a régi FCM API-k megszüntetését. A Google azt javasolja, hogy az örökölt FCM API-król az FCM HTTP v1-re migráljon.

Ha a Communication Services-erőforrás továbbra is az FCM örökölt API-kat használja, kövesse ezt a migrálási útmutatót.

A mobil leküldéses értesítések szempontjai

A mobil push értesítések a mobileszközökön megjelenő pop-up értesítések. A VoIP hívások esetében ez a cikk a hangátvitel Internet Protocol (VoIP) push értesítéseivel foglalkozik.

Feljegyzés

Amikor az alkalmazás leküldéses értesítésekre regisztrál, és kezeli egy Teams-felhasználó bejövő leküldéses értesítéseit, az API-k ugyanazok. A cikkben ismertetett API-k meghívhatók a(z) CommonCallAgent vagy TeamsCallAgent osztályokon is.

Telepítse a SDK-t

Keresse meg a projektszintű build.gradle fájlt, és vegye fel mavenCentral() a buildscript és a allprojects alatt található adattárak listájába.

buildscript {
    repositories {
    ...
        mavenCentral()
    ...
    }
}

allprojects {
    repositories {
    ...
        mavenCentral()
    ...
    }
}

Ezután a modulszintű build.gradle fájlban adja hozzá a következő sorokat a dependencies szakaszhoz:

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

A szükséges objektumok inicializálása

Példány létrehozásához CallAgent meg kell hívnia a createCallAgent metódust egy CallClient példányon. Ez a hívás aszinkron módon egy CallAgent példányobjektumot ad vissza.

A createCallAgent metódus argumentumként veszi fel CommunicationUserCredential a metódust, amely egy hozzáférési jogkivonatot foglal magában.

A DeviceManager eléréséhez először létre kell hoznia egy callAgent példányt. Ezután a CallClient.getDeviceManager módszert használhatja a DeviceManager lekéréséhez.

String userToken = '<user token>';
CallClient callClient = new CallClient();
CommunicationTokenCredential tokenCredential = new CommunicationTokenCredential(userToken);
android.content.Context appContext = this.getApplicationContext(); // From within an activity, for instance
CallAgent callAgent = callClient.createCallAgent(appContext, tokenCredential).get();
DeviceManager deviceManager = callClient.getDeviceManager(appContext).get();

A hívó megjelenítendő nevének beállításához használja az alábbi alternatív módszert:

String userToken = '<user token>';
CallClient callClient = new CallClient();
CommunicationTokenCredential tokenCredential = new CommunicationTokenCredential(userToken);
android.content.Context appContext = this.getApplicationContext(); // From within an activity, for instance
CallAgentOptions callAgentOptions = new CallAgentOptions();
callAgentOptions.setDisplayName("Alice Bob");
DeviceManager deviceManager = callClient.getDeviceManager(appContext).get();
CallAgent callAgent = callClient.createCallAgent(appContext, tokenCredential, callAgentOptions).get();

Leküldéses értesítések regisztrálása

Az alkalmazásnak egy eszközregisztrációs token használatával kell meghívnia a registerPushNotification()-t egy CallAgent példányon, hogy regisztráljon a leküldéses értesítésekre.

Az eszközregisztrációs tokent úgy szerezheti meg, hogy hozzáadja a Firebase SDK-t az alkalmazásmodul build.gradle fájljához az alábbi sorokkal a dependencies szakaszban (ha ezek a sorok még nincsenek ott):

// Add the SDK for Firebase Cloud Messaging
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:20.2.4'

A projektszint fájljában build.gradle adja hozzá a következő sort az dependencies szakaszhoz, ha még nincs ott.

classpath 'com.google.gms:google-services:4.3.3'

Adja hozzá a következő beépülő modult a fájl elejéhez, ha még nincs ott:

apply plugin: 'com.google.gms.google-services'

Az eszköztáron válassza a Szinkronizálás most lehetőséget. Adja hozzá a következő kódrészletet az ügyfélalkalmazás-példányhoz létrehozott Firebase Cloud Messaging SDK által létrehozott eszközregisztrációs jogkivonat lekéréséhez. A token lekéréséhez mindenképp adja hozzá a következő importokat a fő tevékenység fejlécéhez.

import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.Task;
import com.google.firebase.iid.FirebaseInstanceId;
import com.google.firebase.iid.InstanceIdResult;

Adja hozzá ezt a kódrészletet a jogkivonat lekéréséhez:

FirebaseInstanceId.getInstance().getInstanceId()
    .addOnCompleteListener(new OnCompleteListener<InstanceIdResult>() {
        @Override
        public void onComplete(@NonNull Task<InstanceIdResult> task) {
            if (!task.isSuccessful()) {
                Log.w("PushNotification", "getInstanceId failed", task.getException());
                return;
            }

            // Get the new instance ID token
            String deviceToken = task.getResult().getToken();
            // Log
            Log.d("PushNotification", "Device Registration token retrieved successfully");
        }
    });

Regisztrálja az eszköz regisztrációs tokent a Calling Services SDK-val a bejövő hívások push értesítéseihez.

String deviceRegistrationToken = "<Device Token from previous section>";
try {
    callAgent.registerPushNotification(deviceRegistrationToken).get();
}
catch(Exception e) {
    System.out.println("Something went wrong while registering for Incoming Calls Push Notifications.")
}

Leküldéses értesítések kezelése

A bejövő hívás leküldéses értesítései fogadásához egy hasznos adattal rendelkező példányt handlePushNotification() hívhat CallAgent meg.

A Firebase Cloud Messaging terhelésének beszerzéséhez először hozzon létre egy új szolgáltatást (válassza az Fájl>Új>Szolgáltatás>Szolgáltatás lehetőséget), amely kiterjeszti a FirebaseMessagingService Firebase SDK osztályt, és felülbírálja a onMessageReceived metódust. Ez a metódus az eseménykezelő, amely akkor hívódik meg, amikor a Firebase Cloud Messaging értesítést juttat el az alkalmazásnak.

public class MyFirebaseMessagingService extends FirebaseMessagingService {
    private java.util.Map<String, String> pushNotificationMessageDataFromFCM;

    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        // Check if the message contains a notification payload.
        if (remoteMessage.getNotification() != null) {
            Log.d("PushNotification", "Message Notification Body: " + remoteMessage.getNotification().getBody());
        }
        else {
            pushNotificationMessageDataFromFCM = remoteMessage.getData();
        }
    }
}

Adja hozzá a következő szolgáltatásdefiníciót a AndroidManifest.xml fájlhoz a <application> címkén belül:

<service
    android:name=".MyFirebaseMessagingService"
    android:exported="false">
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT" />
    </intent-filter>
</service>

Miután lekérte a hasznos adatokat, átadhatja azt a Communication Services SDK-nak, hogy egy belső IncomingCallInformation objektumba elemezze. Ez az objektum kezeli a metódus meghívását handlePushNotification egy CallAgent példányon. Hozzon létre egy CallAgent példányt a createCallAgent(...) osztály CallClient metódusának meghívásával.

try {
    IncomingCallInformation notification = IncomingCallInformation.fromMap(pushNotificationMessageDataFromFCM);
    Future handlePushNotificationFuture = callAgent.handlePushNotification(notification).get();
}
catch(Exception e) {
    System.out.println("Something went wrong while handling the Incoming Calls Push Notifications.");
}

Ha a leküldéses értesítési üzenet kezelése sikeres, és az összes eseménykezelő megfelelően van regisztrálva, az alkalmazás cseng.

Push értesítések törlése a regisztrációból

Az alkalmazások bármikor megszüntethetik a leküldéses értesítések regisztrációt. A regisztráció megszüntetéséhez hívja meg a unregisterPushNotification() metódust callAgent:

try {
    callAgent.unregisterPushNotification().get();
}
catch(Exception e) {
    System.out.println("Something went wrong while un-registering for all Incoming Calls Push Notifications.")
}

Bejövő hívásokhoz tartozó belső push értesítések letiltása

A bejövő hívások push-üzenet hasznos terhe kétféleképpen kézbesíthető a hívott félnek:

  • Az FCM használata és az eszköz jogkivonatának regisztrálása a korábban említett API-valregisterPushNotification, CallAgentTeamsCallAgent
  • Az SDK regisztrálása belső szolgáltatással CallAgent vagy TeamsCallAgent létrehozásával a leküldéses hasznos adatok kézbesítéséhez

A setDisableInternalPushForIncomingCall tulajdonság használatával CallAgentOptions-ben vagy TeamsCallAgentOptions-ben utasíthatja az SDK-t, hogy tiltsa le a push hasznos adatok kézbesítését a belső push szolgáltatáson keresztül.

CallAgentOptions callAgentOptions = new CallAgentOptions();
callAgentOptions.setDisableInternalPushForIncomingCall(true);

iOS mobil értesítések leküldésének bevezetése

A mobil push értesítések a mobileszközökön megjelenő pop-up értesítések. A VoIP hívások esetében ez a cikk a hangátvitel Internet Protocol (VoIP) push értesítéseivel foglalkozik. Az iOS-alkalmazás CallKit-integrációjáról az Integrálás a CallKittel című témakörben olvashat.

Feljegyzés

Amikor az alkalmazás leküldéses értesítésekre regisztrál, és kezeli egy Teams-felhasználó bejövő leküldéses értesítéseit, az API-k ugyanazok. A cikkben ismertetett API-k meghívhatók a(z) CommonCallAgent vagy TeamsCallAgent osztályokon is.

A rendszer beállítása

A rendszer beállításához kövesse az alábbi lépéseket.

Az Xcode-projekt létrehozása

Az Xcode-ban hozzon létre egy új iOS-projektet, és válassza ki az egynézetes alkalmazássablont . Ez a cikk a SwiftUI-keretrendszert használja, ezért a Nyelvet Swiftrekell állítania, az interfészt pedig SwiftUI-ra.

Ebben a cikkben nem fogsz teszteket létrehozni. Nyugodtan távolítsa el a Tesztet belefoglal jelölőnégyzetet.

Képernyőkép a projekt Xcode-on belüli létrehozására szolgáló ablakról.

A csomag és a függőségek telepítése a CocoaPods használatával

  1. Hozzon létre egy Podfile-t az alkalmazáshoz, például:

    platform :ios, '13.0'
use_frameworks!
target 'AzureCommunicationCallingSample' do
    pod 'AzureCommunicationCalling', '~> 1.0.0'
end

  2. Futtassa az pod install parancsot.

  3. Nyisd meg .xcworkspace az Xcode használatával.

Hozzáférés kérése a mikrofonhoz

Az eszköz mikrofonjának eléréséhez frissítenie kell az alkalmazás információs tulajdonságlistáját a használatával NSMicrophoneUsageDescription. Állítsa a társított értéket egy karakterláncra, amely szerepel abban a párbeszédpanelen, amelyet a rendszer a felhasználótól való hozzáférés kéréséhez használ.

Kattintson a projektfa Info.plist bejegyzésére jobb gombbal, majd válassza a Megnyitásként>Forráskód lehetőséget. Adja hozzá a következő sorokat a legfelső szintű <dict> szakaszhoz, majd mentse a fájlt.

<key>NSMicrophoneUsageDescription</key>
<string>Need microphone access for VOIP calling.</string>

Az alkalmazás-keretrendszer beállítása

Nyissa meg a projekt fájlját ContentView.swift . Adjon hozzá egy deklarációt import a fájl tetejére a AzureCommunicationCalling tár importálásához. Ezenkívül importálja AVFoundation. Szüksége van rá a kódban található hangengedély-kérelmekhez.

import AzureCommunicationCalling
import AVFoundation

A CallAgent inicializálása

Egy CallAgent példány létrehozásához a CallClient, olyan callClient.createCallAgent metódust kell használnia, amely aszinkron módon ad vissza egy CallAgent objektumot az inicializálás után.

Hívásügyfél létrehozásához adjon át egy objektumot CommunicationTokenCredential :

import AzureCommunication

let tokenString = "token_string"
var userCredential: CommunicationTokenCredential?
do {
    let options = CommunicationTokenRefreshOptions(initialToken: token, refreshProactively: true, tokenRefresher: self.fetchTokenSync)
    userCredential = try CommunicationTokenCredential(withOptions: options)
} catch {
    updates("Couldn't created Credential object", false)
    initializationDispatchGroup!.leave()
    return
}

// tokenProvider needs to be implemented by Contoso, which fetches a new token
public func fetchTokenSync(then onCompletion: TokenRefreshOnCompletion) {
    let newToken = self.tokenProvider!.fetchNewToken()
    onCompletion(newToken, nil)
}

Adja át a CommunicationTokenCredential létrehozott objektumot CallClient, és állítsa be a megjelenítendő nevet:

self.callClient = CallClient()
let callAgentOptions = CallAgentOptions()
options.displayName = " iOS Azure Communication Services User"

self.callClient!.createCallAgent(userCredential: userCredential!,
    options: callAgentOptions) { (callAgent, error) in
        if error == nil {
            print("Create agent succeeded")
            self.callAgent = callAgent
        } else {
            print("Create agent failed")
        }
})

Push értesítések beállítása

Mielőtt megkezdené a leküldéses értesítések regisztrálásával, kezelésével és regisztrációjának törlésével kapcsolatos feladatokat, végezze el ezt a beállítási feladatot:

  1. Az Xcode-ban lépjen az Aláírás és képességek elemre. Adjon hozzá egy funkciót a + Funkció kiválasztásával, majd válassza a Push értesítések opciót.
  2. Adjon hozzá egy másik képességet a + Képesség lehetőség kiválasztásával, majd válassza a Háttérmódok lehetőséget.
  3. A Háttérmódok területen jelölje be a Voice over IP és a Remote notifications jelölőnégyzetet.

Képernyőkép az Xcode képességeinek hozzáadásáról.

Leküldéses értesítések regisztrálása

Leküldéses értesítésekre való regisztrációhoz használja a registerPushNotification() példány CallAgent hívását egy eszközregisztrációs token segítségével.

A leküldéses értesítések regisztrációjának a sikeres inicializálás után kell történnie. Ha az callAgent objektum megsemmisül, a rendszer meghívja, logout amely automatikusan megszünteti a leküldéses értesítések regisztrációját.

let deviceToken: Data = pushRegistry?.pushToken(for: PKPushType.voIP)
callAgent.registerPushNotifications(deviceToken: deviceToken!) { (error) in
    if(error == nil) {
        print("Successfully registered to push notification.")
    } else {
        print("Failed to register push notification.")
    }
}

Leküldéses értesítések kezelése

Ha leküldéses értesítéseket szeretne kapni a bejövő hívásokról, hívja meg a handlePushNotification() példányon a CallAgent függvényt egy szótár típusú adathalmazzal.

let callNotification = PushNotificationInfo.fromDictionary(pushPayload.dictionaryPayload)

callAgent.handlePush(notification: callNotification) { (error) in
    if (error == nil) {
        print("Handling of push notification was successful")
    } else {
        print("Handling of push notification failed")
    }
}

Push értesítések törlése a regisztrációból

Az alkalmazások bármikor megszüntethetik a leküldéses értesítések regisztrációt. A regisztráció megszüntetéséhez hívja meg a unregisterPushNotification metódust a CallAgent-on.

Feljegyzés

Az alkalmazások nem lesznek automatikusan törölve a push értesítésekről kijelentkezéskor.

callAgent.unregisterPushNotification { (error) in
    if (error == nil) {
        print("Unregister of push notification was successful")
    } else {
       print("Unregister of push notification failed, please try again")
    }
}

Bejövő hívásokhoz tartozó belső push értesítések letiltása

A bejövő hívások push-üzenet hasznos terhe kétféleképpen kézbesíthető a hívott félnek:

  • Az Apple Push Notification szolgáltatás (APNS) használata és az eszköz token regisztrálása a korábban említett API-val registerPushNotificationCallAgent vagy TeamsCallAgent
  • Az SDK regisztrálása belső szolgáltatással CallAgent vagy TeamsCallAgent létrehozásával a leküldéses hasznos adatok kézbesítéséhez

A tulajdonság disableInternalPushForIncomingCall használatával a(z) CallAgentOptions vagy TeamsCallAgentOptions kontextusában, utasíthatja az SDK-t, hogy tiltsa le a leküldéses hasznos adatok kézbesítését a belső leküldéses szolgáltatáson keresztül:

let options = CallAgentOptions()
options.disableInternalPushForIncomingCall = true

Windows push értesítések bevezetése

A mobil push értesítések a mobileszközökön megjelenő pop-up értesítések. A VoIP hívások esetében ez a cikk a hangátvitel Internet Protocol (VoIP) push értesítéseivel foglalkozik.

A push értesítések a Windows platformon a Windows Push Notification Service (WNS) segítségével érkeznek.

Feljegyzés

Amikor az alkalmazás leküldéses értesítésekre regisztrál, és kezeli az egyéni Teams-végpontok (CTE) leküldéses értesítéseit, az API-k ugyanazok. A cikkben ismertetett API-k egy CommonCallAgent vagy egy TeamsCallAgent osztály esetén is meghívhatók CTE-k esetében.

A rendszer beállítása

A rendszer beállításához kövesse az alábbi lépéseket.

A Visual Studio-projekt létrehozása

Egy Univerzális Windows-platform-alkalmazás esetében a Visual Studio 2022-ben hozzon létre egy új Üres alkalmazás (Univerzális Windows) projektet. Miután megadta a projekt nevét, nyugodtan válasszon bármelyik Windows SDK-t a 10.0.17763.0-s verziónál később.

WinUI 3-alkalmazások esetén hozzon létre egy új projektet az Üres alkalmazás, csomagolt (WinUI 3 in Desktop) sablonnal egy egyoldalas WinUI 3-alkalmazás beállításához. Windows-alkalmazás SDK 1.3-es vagy újabb verzió szükséges.

Telepítse a csomagot és a függőségeket a NuGet Csomagkezelő

A hívó SDK API-k és kódtárak nyilvánosan elérhetők NuGet-csomagon keresztül.

A Hívó SDK NuGet-csomag megkeresése, letöltése és telepítése:

  1. Nyissa meg a NuGet-Csomagkezelő az Tools
  2. Válassza a Tallózás lehetőséget, majd írja be az Azure.Communication.Calling.WindowsClient kifejezést a keresőmezőbe.
  3. Győződjön meg arról, hogy az Előzetes verziók belefoglalása jelölőnégyzet be van jelölve.
  4. Válassza ki az Azure.Communication.Calling.WindowsClient csomagot, majd válassza az Azure.Communication.Calling.WindowsClient1.4.0-beta.1 vagy egy újabb verziót.
  5. Jelölje be az Azure Communication Services-projektnek megfelelő jelölőnégyzetet a jobb oldali panelen.
  6. Válassza a Telepítés lehetőséget.

Push értesítések beállítása

Mielőtt megkezdené a windowsos értesítések regisztrálásával, kezelésével és megjelenítésével kapcsolatos feladatokat a bejövő hívások fogadásához vagy elutasításához, végezze el ezt a beállítási feladatot:

  1. Kövesse az oktatóanyagot: Értesítések küldése Univerzális Windows-platform alkalmazásoknak az Azure Notification Hubs használatával. Miután követte az oktatóanyagot, a következőket kell követnie:

    • Egy olyan alkalmazás, amely tartalmazza a csomagokat és WindowsAzure.Messaging.Managed a Microsoft.Toolkit.Uwp.Notifications csomagokat.
    • A jelen cikkben említett Azure Notifications Hub központ neve <AZURE_PNH_HUB_NAME> és az Azure Notifications Hub kapcsolati karakterlánca <AZURE_PNH_HUB_CONNECTION_STRING>.

  2. Ha minden alkalmazás inicializálásához regisztrálni szeretne egy WNS-csatornára, mindenképpen adja hozzá az inicializálási kódot a App.xaml.cs fájlhoz:

    // App.xaml.cs

protected override async void OnLaunched(LaunchActivatedEventArgs e)
{
    await InitNotificationsAsync();

    ...
}

private async Task InitNotificationsAsync()
{
    if (AZURE_PNH_HUB_NAME != "<AZURE_PNH_HUB_NAME>" && AZURE_PNH_HUB_CONNECTION_STRING != "<AZURE_PNH_HUB_CONNECTION_STRING>")
    {
        var channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();
        channel.PushNotificationReceived += Channel_PushNotificationReceived;

        var hub = new NotificationHub(AZURE_PNH_HUB_NAME, AZURE_PNH_HUB_CONNECTION_STRING);
        var result = await hub.RegisterNativeAsync(channel.Uri);

        if (result.ChannelUri != null)
        {
            PNHChannelUri = new Uri(result.ChannelUri);
        }
        else
        {
            Debug.WriteLine("Cannot register WNS channel");
        }
    }
}

  3. Regisztrálja az eseménykezelőt, amely akkor aktiválódik, amikor új push értesítési üzenet érkezik: App.xaml.cs

    // App.xaml.cs

private void Channel_PushNotificationReceived(PushNotificationChannel sender, PushNotificationReceivedEventArgs args)
{
    switch (args.NotificationType)
    {
      case PushNotificationType.Toast:
      case PushNotificationType.Tile:
      case PushNotificationType.TileFlyout:
      case PushNotificationType.Badge:
          break;
      case PushNotificationType.Raw:
          var frame = (Frame)Window.Current.Content;
          if (frame.Content is MainPage)
          {
              var mainPage = frame.Content as MainPage;
              await mainPage.HandlePushNotificationIncomingCallAsync(args.RawNotification.Content);
          }
          break;
    }
}

Leküldéses értesítések regisztrálása

Push értesítésekre való regisztrációhoz az alkalmazás inicializálásakor szerezzen be egy WNS regisztrációs csatornát, majd hívja meg a RegisterForPushNotificationAsync() függvényt a CallAgent példányon.

A leküldéses értesítések regisztrációjának a sikeres inicializálás után kell történnie.

// MainPage.xaml.cs

this.callAgent = await this.callClient.CreateCallAgentAsync(tokenCredential, callAgentOptions);
                
if ((Application.Current as App).PNHChannelUri != null)
{
    await this.callAgent.RegisterForPushNotificationAsync((Application.Current as App).PNHChannelUri.ToString());
}

this.callAgent.CallsUpdated += OnCallsUpdatedAsync;
this.callAgent.IncomingCallReceived += OnIncomingCallAsync;

Leküldéses értesítések kezelése

Ha leküldéses értesítéseket szeretne kapni a bejövő hívásokról, hívja meg a handlePushNotification() példányon a CallAgent függvényt egy szótár típusú adathalmazzal.

// MainPage.xaml.cs

public async Task HandlePushNotificationIncomingCallAsync(string notificationContent)
{
    if (this.callAgent != null)
    {
        PushNotificationDetails pnDetails = PushNotificationDetails.Parse(notificationContent);
        await callAgent.HandlePushNotificationAsync(pnDetails);
    }
}

Ez a hívás elindít egy bejövő hívási eseményt CallAgent , amelyen megjelenik a bejövő hívásértesítés:

// MainPage.xaml.cs

private async void OnIncomingCallAsync(object sender, IncomingCallReceivedEventArgs args)
{
    incomingCall = args.IncomingCall;
    (Application.Current as App).ShowIncomingCallNotification(incomingCall);
}

// App.xaml.cs

public void ShowIncomingCallNotification(IncomingCall incomingCall)
{
    string incomingCallType = incomingCall.IsVideoEnabled ? "Video" : "Audio";
    string caller = incomingCall.CallerDetails.DisplayName != "" ? incomingCall.CallerDetails.DisplayName : incomingCall.CallerDetails.Identifier.RawId;
    new ToastContentBuilder()
    .SetToastScenario(ToastScenario.IncomingCall)
    .AddText(caller + " is calling you.")
    .AddText("New Incoming " + incomingCallType + " Call")
      .AddButton(new ToastButton()
          .SetContent("Decline")
          .AddArgument("action", "decline"))
      .AddButton(new ToastButton()
          .SetContent("Accept")
          .AddArgument("action", "accept"))
      .Show();
}

Adja hozzá a kódot, amely kezeli a gomb lenyomását az értesítéshez a OnActivated metódusban.

// App.xaml.cs

protected override async void OnActivated(IActivatedEventArgs e)
{   
    // Handle notification activation
    if (e is ToastNotificationActivatedEventArgs toastActivationArgs)
    {
      ToastArguments args = ToastArguments.Parse(toastActivationArgs.Argument);
      string action = args?.Get("action");
    
      if (!string.IsNullOrEmpty(action))
      {
          var frame = Window.Current.Content as Frame;
          if (frame.Content is MainPage)
          {
              var mainPage = frame.Content as MainPage;
              await mainPage.AnswerIncomingCall(action);
          }
      }
    }
}

// MainPage.xaml.cs

public async Task AnswerIncomingCall(string action)
{
    if (action == "accept")
    {
      var acceptCallOptions = new AcceptCallOptions()
      {
          IncomingVideoOptions = new IncomingVideoOptions()
          {
              StreamKind = VideoStreamKind.RemoteIncoming
          }
      };
    
      call = await incomingCall?.AcceptAsync(acceptCallOptions);
      call.StateChanged += OnStateChangedAsync;
      call.RemoteParticipantsUpdated += OnRemoteParticipantsUpdatedAsync;
    }
    else if (action == "decline")
    {
      await incomingCall?.RejectAsync();
    }
}