Verwenden von Push-Benachrichtigungen

Überblick über Push-Benachrichtigungen
Verwalten von Push-Benachrichtigungen in einer Anwendung
Konfigurieren eines Remotebenachrichtigungsanbieters
- Optionen für Remotebenachrichtigungsanbieter
- Zertifikate für den Remotebenachrichtigungsanbieter
Verarbeiten von Push-Benachrichtigungen in einer Anwendung
- Konfigurieren und Akzeptieren von Push-Benachrichtigungen
- Verarbeiten von Push-Benachrichtigungen und Nutzdaten

Mithilfe von Push-Benachrichtigungen können Anbieter von Remotebenachrichtigungen Benachrichtigungen an Anwendungen senden, die auf einem mobilen Gerät ausgeführt werden. AIR 3.4 unterstützt Push-Benachrichtigungen für iOS-Geräte unter Verwendung des Apple Push Notification service (APNs).

Hinweis: Um Push-Benachrichtigungen für eine AIR for Android-Anwendung zu ermöglichen, verwenden Sie eine native Erweiterung, zum Beispiel as3c2dm , entwickelt vom Adobe-Evangelisten Piotr Walczyszyn.

Im Folgenden wird beschrieben, wie Sie Push-Benachrichtigungen in AIR for iOS-Anwendungen aktivieren.

Hinweis: Hierbei wird davon ausgegangen, dass Sie eine Apple-Entwickler-ID haben, mit dem iOS-Entwicklungsablauf vertraut sind und bereits mindestens eine Anwendung auf einem iOS-Gerät bereitgestellt haben.

Überblick über Push-Benachrichtigungen

Der Apple Push Notification service (APNs) ermöglicht Remotebenachrichtigungsanbietern das Senden von Benachrichtigungen an Anwendungen, die auf iOS-Geräten ausgeführt werden. APNs unterstützt die folgenden Benachrichtigungstypen:

Meldungen
Badges
Sounds

Umfassende Informationen zu APNs finden Sie unter developer.apple.com .

Das Verwenden von Push-Benachrichtigungen in Ihrer Anwendung beinhaltet mehrere Aspekte:

Clientanwendung – Registriert sich für Push-Benachrichtigungen, kommuniziert mit den Remotebenachrichtigungsanbietern und empfängt Push-Benachrichtigungen.
iOS – Verwaltet die Interaktion zwischen der Clientanwendung und APNs.
APNs – Stellt während der Clientregistrierung eine tokenID bereit und übergibt Benachrichtigungen von den Remotebenachrichtigungsanbietern an iOS.
Remotebenachrichtigungsanbieter – Speichert Informationen zur tokenID der Clientanwendung und sendet Benachrichtigungen an APNs.

Arbeitsablauf bei der Registrierung

Der Arbeitsablauf beim Registrieren von Push-Benachrichtigungen bei einem serverseitigen Dienst ist folgender:

Die Clientanwendung fordert bei iOS die Aktivierung von Push-Benachrichtigungen an.
iOS leitet die Anforderung an APNs weiter.
Der APNs-Server gibt eine tokenID an iOS zurück.
iOS gibt die tokenID an die Clientanwendung zurück.
Die Clientanwendung verwendet einen anwendungsspezifischen Mechanismus, um die tokenID dem Remotebenachrichtigungsanbieter bereitzustellen, der die tokenID zur Verwendung für Push-Benachrichtigungen speichert.

Arbeitsablauf für Benachrichtigungen

Der Arbeitsablauf für Benachrichtigungen ist folgender:

Der Remotebenachrichtigungsanbieter generiert eine Benachrichtigung und übergibt die Nutzdaten der Benachrichtigung zusammen mit der tokenID an APNs.
APNs leitet die Benachrichtigung an iOS auf dem Gerät weiter.
iOS übermittelt die Nutzdaten der Benachrichtigung an die Anwendung.

API für Push-Benachrichtigungen

In AIR 3.4 wurde eine Gruppe von APIs eingeführt, die iOS-Push-Benachrichtigungen unterstützen. Diese APIs befinden sich im flash.notifications -Paket und umfassen die folgenden Klassen:

NotificationStyle - Definiert Konstanten für Benachrichtigungstypen: ALERT , BADGE und SOUND .
RemoteNotifier - Ermöglicht das Abonnieren bzw. Kündigen von Push-Benachrichtigungen.
RemoteNotifierSubscribeOptions - Ermöglicht die Auswahl der zu empfangenden Benachrichtigungstypen. Verwenden Sie die notificationStyles -Eigenschaft, um einen Vektor von Strings zu definieren, die sich für mehrere Benachrichtigungstypen registrieren.

AIR 3.4 enthält auch flash.events.RemoteNotificationEvent , das von RemoteNotifier abgesetzt wird:

Wenn das Abonnement einer Anwendung erfolgreich erstellt und eine neue tokenID von APNs empfangen wurde.
Wenn eine neue Remotebenachrichtigung empfangen wird.

Zusätzlich setzt RemoteNotifier ein flash.events.StatusEvent ab, wenn beim Abonnieren ein Fehler aufgetreten ist.

Verwalten von Push-Benachrichtigungen in einer Anwendung

Führen Sie die folgenden Schritte aus, um Ihre Anwendung für Push-Benachrichtigungen zu registrieren:

Erstellen Sie in Ihrer Anwendung Code, der Push-Benachrichtigungen abonniert.
Aktivieren Sie Push-Benachrichtigungen in der XML-Datei der Anwendung.
Erstellen Sie ein Provisioning-Profil und -Zertifikat, das iOS Push Services aktiviert.

Im folgenden Codebeispiel mit Anmerkungen wird eine Push-Benachrichtigung abonniert und Push-Benachrichtigungsereignisse werden verarbeitet:

package 
                        { 
                        import flash.display.Sprite; 
                        import flash.display.StageAlign; 
                        import flash.display.StageScaleMode; 
                        import flash.events.*; 
                        import flash.events.Event; 
                        import flash.events.IOErrorEvent; 
                        import flash.events.MouseEvent; 
                        import flash.net.*; 
                        import flash.text.TextField; 
                        import flash.text.TextFormat; 
                        import flash.ui.Multitouch; 
                        import flash.ui.MultitouchInputMode; 
                        // Required packages for push notifications 
                        import flash.notifications.NotificationStyle; 
                        import flash.notifications.RemoteNotifier; 
                        import flash.notifications.RemoteNotifierSubscribeOptions; 
                        import flash.events.RemoteNotificationEvent; 
                        import flash.events.StatusEvent; 
                        [SWF(width="1280", height="752", frameRate="60")] 

                        public class TestPushNotifications extends Sprite 
                        { 
                        private var notiStyles:Vector.<String> = new Vector.<String>;; 
                        private var tt:TextField = new TextField(); 
                        private var tf:TextFormat = new TextFormat(); 
                        // Contains the notification styles that your app wants to receive 
                        private var preferredStyles:Vector.<String> = new Vector.<String>(); 
                        private var subscribeOptions:RemoteNotifierSubscribeOptions = new RemoteNotifierSubscribeOptions(); 
                        private var remoteNot:RemoteNotifier = new RemoteNotifier(); 

                        private var subsButton:CustomButton = new CustomButton("Subscribe"); 
                        private var unSubsButton:CustomButton = new CustomButton("UnSubscribe"); 
                        private var clearButton:CustomButton = new CustomButton("clearText"); 

                        private var urlreq:URLRequest; 
                        private var urlLoad:URLLoader = new URLLoader(); 
                        private var urlString:String; 

                        public function TestPushNotifications() 
                        { 
                        super(); 

                        Multitouch.inputMode = MultitouchInputMode.TOUCH_POINT; 
                        stage.align = StageAlign.TOP_LEFT; 
                        stage.scaleMode = StageScaleMode.NO_SCALE; 

                        tf.size = 20; 
                        tf.bold = true; 


                        tt.x=0; 
                        tt.y =150; 
                        tt.height = stage.stageHeight; 
                        tt.width = stage.stageWidth; 
                        tt.border = true; 
                        tt.defaultTextFormat = tf; 

                        addChild(tt); 

                        subsButton.x = 150; 
                        subsButton.y=10; 
                        subsButton.addEventListener(MouseEvent.CLICK,subsButtonHandler); 
                        stage.addChild(subsButton); 

                        unSubsButton.x = 300; 
                        unSubsButton.y=10; 
                        unSubsButton.addEventListener(MouseEvent.CLICK,unSubsButtonHandler); 
                        stage.addChild(unSubsButton); 

                        clearButton.x = 450; 
                        clearButton.y=10; 
                        clearButton.addEventListener(MouseEvent.CLICK,clearButtonHandler); 
                        stage.addChild(clearButton); 

                        // 
                        tt.text += "\n SupportedNotification Styles: " + RemoteNotifier.supportedNotificationStyles.toString() + "\n"; 

                        tt.text += "\n Before Preferred notificationStyles: " + subscribeOptions.notificationStyles.toString() + "\n"; 

                        // Subscribe to all three styles of push notifications: 
                        // ALERT, BADGE, and SOUND. 
                        preferredStyles.push(NotificationStyle.ALERT ,NotificationStyle.BADGE,NotificationStyle.SOUND ); 

                        subscribeOptions.notificationStyles= preferredStyles; 

                        tt.text += "\n After Preferred notificationStyles:" + subscribeOptions.notificationStyles.toString() + "\n"; 


                        remoteNot.addEventListener(RemoteNotificationEvent.TOKEN,tokenHandler); 
                        remoteNot.addEventListener(RemoteNotificationEvent.NOTIFICATION,notificationHandler); 
                        remoteNot.addEventListener(StatusEvent.STATUS,statusHandler); 

                        this.stage.addEventListener(Event.ACTIVATE,activateHandler); 


                        } 
                        // Apple recommends that each time an app activates, it subscribe for 
                        // push notifications. 
                        public function activateHandler(e:Event):void{ 
                        // Before subscribing to push notifications, ensure the device supports it. 
                        // supportedNotificationStyles returns the types of notifications 
                        // that the OS platform supports 
                        if(RemoteNotifier.supportedNotificationStyles.toString() != "") 
                        {     
                        remoteNot.subscribe(subscribeOptions); 
                        } 
                        else{ 
                        tt.appendText("\n Remote Notifications not supported on this Platform !"); 
                        } 
                        } 
                        public function subsButtonHandler(e:MouseEvent):void{ 
                        remoteNot.subscribe(subscribeOptions); 
                        } 
                        // Optionally unsubscribe from push notfications at runtime. 
                        public function unSubsButtonHandler(e:MouseEvent):void{ 
                        remoteNot.unsubscribe(); 
                        tt.text +="\n UNSUBSCRIBED"; 
                        } 

                        public function clearButtonHandler(e:MouseEvent):void{ 
                        tt.text = " "; 
                        } 
                        // Receive notification payload data and use it in your app 
                        public function notificationHandler(e:RemoteNotificationEvent):void{ 
                        tt.appendText("\nRemoteNotificationEvent type: " + e.type + 
                        "\nbubbles: "+ e.bubbles + "\ncancelable " +e.cancelable); 

                        for (var x:String in e.data) { 
                        tt.text += "\n"+ x + ":  " + e.data[x]; 
                        } 
                        } 
                        // If the subscribe() request succeeds, a RemoteNotificationEvent of 
                        // type TOKEN is received, from which you retrieve e.tokenId, 
                        // which you use to register with the server provider (urbanairship, in 
                        // this example. 
                        public function tokenHandler(e:RemoteNotificationEvent):void 
                        { 
                        tt.appendText("\nRemoteNotificationEvent type: "+e.type +"\nBubbles: "+ e.bubbles + "\ncancelable " +e.cancelable +"\ntokenID:\n"+ e.tokenId +"\n"); 

                        urlString = new String("https://go.urbanairship.com/api/device_tokens/" + 
                        e.tokenId); 
                        urlreq = new URLRequest(urlString); 

                        urlreq.authenticate = true; 
                        urlreq.method = URLRequestMethod.PUT; 

                        URLRequestDefaults.setLoginCredentialsForHost 
                        ("go.urbanairship.com", 
                        "1ssB2iV_RL6_UBLiYMQVfg","t-kZlzXGQ6-yU8T3iHiSyQ"); 

                        urlLoad.load(urlreq); 
                        urlLoad.addEventListener(IOErrorEvent.IO_ERROR,iohandler); 
                        urlLoad.addEventListener(Event.COMPLETE,compHandler); 
                        urlLoad.addEventListener(HTTPStatusEvent.HTTP_STATUS,httpHandler); 

                        } 

                        private function iohandler(e:IOErrorEvent):void 
                        { 
                        tt.appendText("\n In IOError handler" + e.errorID +" " +e.type); 

                        } 
                        private function compHandler(e:Event):void{ 
                        tt.appendText("\n In Complete handler,"+"status: " +e.type + "\n"); 
                        } 

                        private function httpHandler(e:HTTPStatusEvent):void{ 
                        tt.appendText("\n in httpstatus handler,"+ "Status: " + e.status); 
                        } 

                        // If the subscription request fails, StatusEvent is dispatched with 
                        // error level and code. 
                        public function statusHandler(e:StatusEvent):void{ 
                        tt.appendText("\n statusHandler"); 
                        tt.appendText("event Level" + e.level +"\nevent code " + 
                        e.code + "\ne.currentTarget: " + e.currentTarget.toString()); 
                        } 
                        } 
                        }

Aktivieren von Push-Benachrichtigungen in der XML-Datei der Anwendung

Um Push-Benachrichtigungen in Ihrer Anwendung zu verwenden, geben Sie im Entitlements -Tag (unter dem iphone -Tag) Folgendes an:

<iphone> 
                            ... 
                               <Entitlements> 
                                  <![CDATA[ 
                                     <key>aps-environment</key> 
                                     <string>development</string> 
                                  ]]> 
                               </Entitlements> 
                            </iphone>

Wenn Sie bereit sind, die Anwendung in den App Store zu stellen, ein <string> -Element für den Übergang von der Entwicklung zur Produktion:

      <string>production</string>

Falls Ihre Anwendung lokalisierte Strings unterstützt, geben Sie im supportedLanguages -Tag unter dem intialWindow -Tag die Sprachen an wie im folgenden Beispiel gezeigt:

<supportedLanguages>en de cs es fr it ja ko nl pl pt</supportedLanguages>

Erstellen eines Provisioning-Profils und -Zertifikats, das iOS Push Services aktiviert

Um die Kommunikation zwischen Anwendung und APNs zu ermöglichen, müssen Sie die Anwendung mit einem Provisioning-Profil und -Zertifikat verpacken, das iOS Push Services aktiviert:

Melden Sie sich bei Ihrem Apple-Entwicklerkonto an.
Navigieren Sie zum Provisioning Portal.
Klicken Sie auf das Register „App IDs“.
Klicken Sie auf die Schaltfläche „New App ID“.
Geben Sie eine Beschreibung und einen Bundle-Bezeichner ein (der Bundle-Bezeichner darf kein * enthalten).
Klicken Sie auf „Submit“. Das Provisioning Portal generiert Ihre App-ID und zeigt wieder die Seite „App IDs“ an.
Klicken Sie rechts neben Ihrer App-ID auf „Configure“. Die Seite „Configure App ID“ wird angezeigt.
Markieren Sie das Kontrollkästchen „Enable for Apple Push Notification service“. Beachten Sie, dass es zwei Arten von Push-SSL-Zertifikaten gibt: eines für Entwicklung/Testen und eines für die Produktion.
Klicken Sie rechts neben „Development Push SSL Certificate“ auf die Schaltfläche „Configure“. Die Seite „Generate Certificate Signing Request (CSR)“ wird angezeigt.
Generieren Sie einen CSR, indem Sie wie auf der Seite beschreiben das Schlüsselbund-Utility verwenden.
Generieren Sie das SSL-Zertifikat.
Laden Sie das SSL-Zertifikat herunter und installieren Sie es.
(Optional) Wiederholen Sie die Schritte 9 bis 12 für das Push-SSL-Zertifikat für die Produktion.
Klicken Sie auf „Done“. Die Seite „Configure App ID“ wird angezeigt.
Klicken Sie auf „Done“. Die Seite „App IDs“ wird angezeigt. Beachten Sie den grünen Kreis neben „Push Notification“ für Ihre App-ID.
Vergessen Sie nicht, Ihre SSL-Zertifikate zu speichern. Sie werden später für die Kommunikation von Anwendung und Anbieter verwendet.
Klicken Sie auf das Register „Provisioning“, um die Seite „Provisioning Profiles“ anzuzeigen.
Erstellen Sie ein Provisioning-Profil für Ihre neue App-ID und laden Sie es herunter.
Klicken Sie auf das Register „Certificates“ und laden Sie ein neues Zertifikat für das neue Provisioning-Profil herunter.

Verwenden von Sound für Benachrichtigungen

Um Soundbenachrichtigungen für Ihre Anwendung zu aktivieren, bündeln Sie die Sounddatei wie jedes andere Element, jedoch im selben Verzeichnis wie SWF- und app-xml-Dateien. Zum Beispiel:

Build/adt -package -target ipa-app-store -provisioning-profile _-_.mobileprovision -storetype pkcs12 -keystore _-_.p12 test.ipa test-app.xml test.swf sound.caf sound1.caf

Apple unterstützt die folgenden Formate für Sounddateien (in AIFF-, WAV- oder CAF-Dateien):

Linear PCM
MA4 (IMA/ADPCM)
uLaw
aLaw

Verwenden von lokalisierten Meldungen

Um lokalisierte Meldungen als Benachrichtigungen zu verwenden, bündeln Sie die lokalisierten Strings in lproj-Ordnern. Sie könnten zum Beispiel Meldungen in spanischer Sprache unterstützen:

Erstellen Sie den Ordner „es.lproj“ auf derselben Ebene wie die app-xml-Datei innerhalb des Projekts.
Erstellen Sie im Ordner „es.lproj“ eine Textdatei mit dem Namen „Localizable.Strings“.
Öffnen Sie die Datei „Localizable.Strings“ in einem Text-Editor und fügen Sie Sprachschlüssel sowie die entsprechenden übersetzten Strings hinzu. Zum Beispiel:
```
"PokeMessageFormat" = "La notificación de alertas en español."
```
Speichern Sie die Datei.
Wenn die Anwendung eine Meldung mit diesem Schlüsselwert erhält und die Gerätesprache Spanisch ist, wird die übersetzte Meldung in spanischer Sprache angezeigt.

Konfigurieren eines Remotebenachrichtigungsanbieters

Sie brauchen einen Remotebenachrichtigungsanbieter, um Push-Benachrichtigungen an Ihre Anwendung zu senden. Diese Serveranwendung fungiert als Anbieter, empfängt Ihre Push-Eingabe und übergibt die Benachrichtigung und die Benachrichtigungsdaten an APNs, der die Push-Benachrichtigung dann an eine Clientanwendung sendet.

Ausführliche Informationen zum Senden von Benachrichtigungen von einem Remotebenachrichtigungsanbieter finden Sie unter Provider Communication with Apple Push Notification Service in der Apple Developer Library.

Optionen für Remotebenachrichtigungsanbieter

Zu den Optionen für einen Remotebenachrichtigungsanbieter gehören die folgenden:

Erstellen Sie Ihren eigenen Anbieter basierend auf dem APNS-php-Open-Source-Server. Sie können einen PHP-Server mit http://code.google.com/p/apns-php/ einrichten. Mit diesem Google Code-Projekt können Sie eine Oberfläche entwerfen, die Ihren Anforderungen entspricht.

Verwenden Sie einen Serviceanbieter. Zum Beispiel bietet http://urbanairship.com/ einen einsatzbereiten APNs-Anbieter an. Nachdem Sie sich bei diesem Dienst registriert haben, stellen Sie Ihr Gerätetoken mit ähnlichem Code wie dem folgenden bereit:

private var urlreq:URLRequest; 
                                    private var urlLoad:URLLoader = new URLLoader(); 
                                    private var urlString:String; 

                                    //When subscription is successful then only call the following code 
                                    urlString = new String("https://go.urbanairship.com/api/device_tokens/" + e.tokenId); 
                                    urlreq = new URLRequest(urlString); 

                                    urlreq.authenticate = true; 
                                    urlreq.method = URLRequestMethod.PUT; 
                                    URLRequestDefaults.setLoginCredentialsForHost("go.urbanairship.com", 
                                       "Application Key","Application Secret"); 
                                    urlLoad.load(urlreq); 
                                    urlLoad.addEventListener(IOErrorEvent.IO_ERROR,iohandler); 
                                    urlLoad.addEventListener(Event.COMPLETE,compHandler); 
                                    urlLoad.addEventListener(HTTPStatusEvent.HTTP_STATUS,httpHandler); 

                                    private function iohandler(e:IOErrorEvent):void{ 
                                       trace("\n In IOError handler" + e.errorID +" " +e.type); 
                                    } 

                                    private function compHandler(e:Event):void{ 
                                       trace("\n In Complete handler,"+"status: " +e.type + "\n"); 
                                    } 

                                    private function httpHandler(e:HTTPStatusEvent):void{ 
                                       tt.appendText("\n in httpstatus handler,"+ "Status: " + e.status); 
                                    }

Sie können mithilfe von Urban Airship-Tools dann Testbenachrichtigungen senden.

Zertifikate für den Remotebenachrichtigungsanbieter

Sie müssen das SSL-Zertifikat und den (zuvor generierten) privaten Schlüssel an den richtigen Speicherort auf dem Server des Remotebenachrichtigungsanbieter kopieren. Normalerweise werden diese beiden Dateien in einer einzelnen .pem -Datei kombiniert. Gehen Sie dazu folgendermaßen vor:

Öffnen Sie ein Terminalfenster.
Erstellen Sie eine .pem -Datei aus dem SSL-Zertifikat, indem Sie den folgenden Befehl eingeben:
```
openssl x509 -in aps_developer_identity.cer -inform der -out TestPushDev.pem
```
Erstellen Sie eine .pem-Datei aus der Datei mit dem privaten Schlüssel ( .p12 ), indem Sie den folgenden Befehl eingeben:
```
openssl pkcs12 -nocerts -out TestPushPrivateKey.pem -in certificates.p12
```
Kombinieren Sie die beiden .pem-Dateien zu einer einzigen, indem Sie den folgenden Befehl eingeben:
```
cat TestPushDev.pem TestPushPrivateKey.pem > FinalTestPush.pem
```
Stellen Sie die kombinierte .pem -Datei für den Serveranbieter bereit, wenn Sie Ihre serverseitige Push-Anwendung erstellen.

Weitere Informationen finden Sie unter Installing the SSL Certificate and Key on the Server im Apple Local and Push Notification Programming Guide.

Verarbeiten von Push-Benachrichtigungen in einer Anwendung

Zum Umgang mit Push-Benachrichtigungen in einer Anwendung gehört Folgendes:

Globale Benutzerkonfiguration und -akzeptanz von Push-Benachrichtigungen
Benutzerakzeptanz einzelner Push- Benachrichtigungen
Verarbeiten von Push-Benachrichtigungen und Benachrichtigungsnutzdaten

Konfigurieren und Akzeptieren von Push-Benachrichtigungen

Wenn ein Benutzer zum ersten Mal eine Anwendung aufruft, die Push-Benachrichtigungen verwenden kann, zeigt iOS ein Dialogfeld appname Would Like to Send You Push Notifications (Anwendung möchte Ihnen Push-Benachrichtigungen senden) mit Schaltfläche zum Ablehnen („Don’t Allow“) und Zustimmen („OK“) an. Wenn der Benutzer „OK“ wählt, kann die Anwendung alle Arten von Benachrichtigungen empfangen, die sie abonniert hat. Wenn der Benutzer nicht einverstanden ist und „Don't Allow“ wählt, werden keine Benachrichtigungen empfangen.

Hinweis: Benutzer können auch „Settings > Notifications“ (Einstellungen > Benachrichtigungen) wählen, um bestimmte Benachrichtigungstypen auszuwählen, die für die einzelnen Anwendungen empfangen werden können.

Apple empfiehlt, Push-Benachrichtigungen jedes Mal zu abonnieren, wenn eine Anwendung aktiviert wird. Wenn Ihre Anwendung RemoteNotifier.subscribe() aufruft, empfängt sie ein RemoteNotificationEvent des Typs token , das eine eindeutige numerische 32-Byte-Tokenkennung enthält, mit der diese Anwendung auf diesem Gerät eindeutig identifiziert wird.

Wenn das Gerät eine Push-Benachrichtigung empfängt, wird ein Popup mit Schaltflächen zum Schließen (Close) und Starten (Launch) angezeigt. Wenn der Benutzer „Close“ wählt, passiert nichts; wenn der Benutzer „Launch“ wählt, ruft iOS die Anwendung auf und die Anwendung erhält ein flash.events.RemoteNotificationEvent des Typs notification , wie unten beschrieben.

Verarbeiten von Push-Benachrichtigungen und Nutzdaten

Wenn der Remotebenachrichtigungsanbieter eine Benachrichtigung an ein Gerät sendet (unter Verwendung der tokenID), empfängt Ihre Anwendung ein flash.events.RemoteNotificationEvent des Typs notification , unabhängig davon, ob die Anwendung ausgeführt wird oder nicht. An diesem Punkt führt Ihre Anwendung die anwendungsspezifische Verarbeitung von Benachrichtigungen aus. Wenn Ihre Anwendung Benachrichtigungsdaten verarbeitet, können Sie mit der RemoteNotificationEvent.data -Eigenschaft darauf zugreifen.