Använda push-meddelanden

Översikt över push-meddelanden
Hantera push-meddelanden i ett program
Konfigurera en fjärrmeddelandeleverantör
- Alternativ för fjärrmeddelandeleverantörer
- Certifikat för fjärrmeddelandeleverantören
Administrera push-meddelanden i ett program
- Konfigurera och godkänna push-meddelanden
- Hantera push-meddelanden och meddelandedata

Med push-meddelanden kan fjärrmeddelandeleverantörer skicka meddelanden till program som körs på en mobil enhet. AIR 3.4 har stöd för push-meddelanden för iOS-enheter som använder Apple Push Notification-tjänsten (APN:er).

Obs! Om du vill aktivera push-meddelanden för ett AIR for Android-program ska du använda ett ANE-tillägg, till exempel as3c2dm , utvecklad av Adobe-användaren Piotr Walczyszyn.

I återstoden av detta avsnitt beskrivs hur du aktiverar push-meddelanden i AIR for iOS-program.

Obs! I den här beskrivningen antas att du har ett ID som Apple-utvecklare, känner till arbetsflödet för iOS-utveckling och att du har skapat minst ett program på en iOS-enhet.

Översikt över push-meddelanden

Apple Push Notification-tjänsten (APN:er) används av fjärrmeddelandeleverantörer för att skicka meddelanden till program som körs på iOS-enheter. En APN har stöd för följande meddelandetyper:

Varningar
Bagde-program
Ljud

Fullständig information om APN:er finns på developer.apple.com .

Att använda push-meddelanden i program omfattar flera aspekter:

Klientprogram – Register för push-meddelanden kommunicerar med fjärrmeddelandeleverantörer och erhåller push-meddelanden.
iOS – Hanterar interaktionen mellan klientprogrammet och APN:er.
APN:er – Tillhandahåller ett tokenID under klientregistreringen och skickar meddelanden från fjärrmeddelandeleverantören till iOS.
Fjärrmeddelandeleverantör – Lagrar information för tokenId-klientprogrammet och skickar meddelanden till APN:er.

Arbetsflödet för registrering

Arbetsflödet för registrering av push-meddelanden med en tjänst på serversidan är följande:

Klientprogrammet begär att iOS aktiverar push-meddelanden.
iOS skickar denna begäran till APN:er.
APN-servern returnerar ett token-ID till iOS.
iOS returnerar detta token-ID till klientprogrammet.
Klientprogrammet (med hjälp av en programspecifik metod) levererar detta token-ID till fjärrmeddelandeleverantören, som lagrar detta för att använda det för push-meddelanden.

Arbetsflödet för meddelanden

Arbetsflödet för meddelanden är följande:

Fjärrmeddelandeleverantören skapar ett meddelande och skickar det till APN:er tillsammans med aktuellt token-ID.
APN:er vidarekopplar meddelanden till iOS på enheten.
iOS vidarekopplar meddelanden till programmet.

API för push-meddelanden

I AIR 3.4 introducerades en uppsättning API:er som har stöd för push-meddelanden. Dessa API:er finns i paketet flash.notifications och innehåller följande klasser:

NotificationStyle – Definierar konstanter för meddelandentyperna: ALERT , BADGE och SOUND .C
RemoteNotifier – Prenumerera och avbryta prenumeration på push-meddelanden.
RemoteNotifierSubscribeOptions – Välja vilka meddelandetyper som ska erhållas. Använd egenskapen notificationStyles för att definiera en vektor med strängar som registrerar för flera meddelandetyper.

AIR 3.4 innehåller även flash.events.RemoteNotificationEvent , som skickas av RemoteNotifier enligt följande:

När en programprenumeration skapas och ett nytt token-ID erhålls från APN:er.
När ett nytt fjärrmeddelande tas emot.

Dessutom skickar RemoteNotifier en flash.events.StatusEvent om ett fel upptäcks under prenumerationsprocessen.

Hantera push-meddelanden i ett program

Gör så här för att registrera programmet för push-meddelanden:

Skapa kod som prenumererar på push-meddelanden i programmet.
Aktivera push-meddelanden i programmets XML-fil.
Skapa en provisioneringsprofil och ett certifikat som aktiverar push-tjänster för iOS.

I följande exempel visas kod för hur du prenumererar på push-meddelanden och hanterar push-meddelandehändelser:

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()); 
                        } 
                        } 
                        }

Aktivera push-meddelanden i programmets XML-fil

Ange följande i taggen Entitlements (under taggen iphone ) för att kunna använda push-meddelanden i programmet:

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

När du ska skicka programmet till App Store, ändrar du ett <string> -element för utveckling till produktion:

      <string>production</string>

Om programmet har stöd för översatta strängar, anger du språket i taggen supportedLanguages under taggen intialWindow enligt exemplet nedan:

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

Skapa en provisioneringsprofil och ett certifikat som aktivera push-tjänster för iOS

Du aktiverar kommunikation för program-APN:er genom att paketera programmet med en provisioneringsprofil och ett certifikat som aktiverar push-tjänster för iOS enligt följande:

Logga in på ditt konto för Apple-utvecklare.
Navigera till Provisioning Portal.
Klicka på fliken Program-ID (App IDs).
Klicka på knappen Nytt program-ID (New App ID).
Ange en beskrivning och källidentifierare (du ska inte använda * i källidentifieraren).
Klicka på Skicka (Submit). På Provisioning Portal skapas ditt program-ID och sidan för program-ID:n visas på nytt.
Klicka på Konfigurera (Configure) (till höger om ditt program-ID). Sidan Konfigurera program-ID (Configure App ID) öppnas.
Markera kryssrutan Aktivera för APN-tjänst (Enable for Apple Push Notification service). Observera att det finns två typer av push SSL-certifikat: ett för utveckling/testning och ett för produktion.
Klicka på knappen Konfigurera (Configure) till höger om Utveckla push-SSL-certifikat (Development Push SSL Certificate). CSR-sidan (Generate Certificate Signing Request) öppnas.
Skapa ett CSR med hjälp av verktyget Keychain Access enligt instruktionerna på sidan.
Skapa SSL-certifikatet.
Hämta och installera SSL-certifikatet.
(Valfritt) Upprepa stegen 9 till 12 för produktions-push-SSL-certifikatet.
Klicka på Klar (Done). Sidan Konfigurera program-ID (Configure App ID) öppnas.
Klicka på Klar (Done). Sidan Program-ID:n (App IDs) öppnas. Lägg märke till den gröna cirkeln intill push-meddelandet för ditt program-ID.
Se till att spara SSL-certifikaten eftersom de används senare för program- och leverantörskommunikation.
Klicka på fliken Provisionering (Provisioning) för att öppna sidan Provisioneringsprofiler (Provisioning Profiles).
Skapa en provisioneringsprofil för ditt nya program-ID och hämta det.
Klicka på fliken Certifikat (Certificates) och hämta ett nytt certifikat för den nya provisioneringsprofilen.

Använda ljud för push-meddelanden

Om du vill aktivera ljudmeddelanden för ditt program paketerar du ljudfilen på samma sätt som du gör med andra resurser, men i samma katalog som SWF- och app-xml-filerna. Till exempel:

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 har stöd för följande ljuddataformat (i aiff-, wav- eller caf-filer):

Linear PCM
MA4 (IMA/ADPCM)
uLaw
aLaw

Använda översatta varningsmeddelanden

Om du vill använda översatta varningsmeddelanden i ditt program ska du paketera dina översatta strängar som lpro-mappar. Gör så här för att skapa varningsmeddelanden på spanska:

Skapa en es.lproj-mapp på samma nivå som app-xml-filen.
Skapa i es.lproj-mappen en textfil med namnet Localizable.Strings.
Öppna filen Localizable.Strings i ett textredigeringsprogram och lägg till meddelandenycklar och motsvarande översatta strängar. Till exempel:
```
"PokeMessageFormat" = "La notificación de alertas en español."
```
Spara filen.
När programmet erhåller ett varningsmeddelande med detta nyckelvärde och enhetsspråket är spanska kommer det översatta textmeddelandet att visas.

Konfigurera en fjärrmeddelandeleverantör

Du behöver en fjärrmeddelandeleverantör för att kunna skicka push-meddelanden till ditt program. Detta serverprogram fungerar som en leverantör som accepterar push-indata och som skickar meddelanden och meddelandedata till APN:er, som i sin tur skickar push-meddelanden till ett klientprogram.

Mer information om push-meddelanden från en fjärrmeddelandeleverantör finns i Provider Communication with Apple Push Notification Service i Apple Developer Library.

Alternativ för fjärrmeddelandeleverantörer

Följande alternativ finns för en fjärrmeddelandeleverantör:

Skapa en egen leverantör baserad på APNS-php öppen källserver. Du ställer in en PHP-server med hjälp av http://code.google.com/p/apns-php/ . Med detta Google Code-projekt kan du skapa ett gränssnitt som matchar dina specifika krav.

Använd en tjänsteleverantör. På http://urbanairship.com/ finns ett exempel på en färdig APN-leverantör. Sedan du registrerat tjänsten fortsätter du med att tillhandahålla din enhets-token med hjälp av en kod enligt följande:

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); 
                                    }

Du kan sedan skicka testmeddelanden med verktyget Urban Airship.

Certifikat för fjärrmeddelandeleverantören

Du måste kopiera SSL-certifikatet och den privata nyckeln (skapad tidigare) till rätt plats på fjärrmeddelandeleverantörens server. Du kombinerar vanligtvis dessa båda filer till en .pem -fil. Gör så här:

Öppna ett terminalfönster.

Skapa en .pem -fil från SSL-certifikatet genom att skriva följande kommando:

openssl x509 -in aps_developer_identity.cer -inform der -out TestPushDev.pem

Skapa en .pem-fil av den privata nyckelfilen ( .p12 ) genom att skriva följande kommando:
```
openssl pkcs12 -nocerts -out TestPushPrivateKey.pem -in certificates.p12
```
Kombinera de båda .pem-filerna till en fil genom att skriva följande kommando:
```
cat TestPushDev.pem TestPushPrivateKey.pem > FinalTestPush.pem
```
Lägg till den kombinerade .pem -filen hos serverleverantören när du skapar push-programmet på serversidan.

Mer information finns på Installing the SSL Certificate and Key on the Server i Apple Local and Push Notification Programming Guide.

Administrera push-meddelanden i ett program

Så här administrerar du push-meddelanden i ett program:

Global användarkonfiguration och godkännande av push-meddelanden
Få användargodkännande av enskilda push-meddeladen
Hantera push-meddelanden och meddelandedata

Konfigurera och godkänna push-meddelanden

Första gången en användare startar ett program aktiverat för push-meddelanden, visas i iOS en dialogruta appname Vill du skicka push-meddelanden (Would Like to Send You Push Notifications) med knapparna Tillåt inte (Don’t Allow) och OK. Om användaren väljer OK kan programmet ta emot alla stilar för meddelanden som omfattas av prenumerationen. Om du väljer Tillåt inte (Don’t Allow) tas inga meddelanden emot.

Obs! Användarna kan även välja Inställningar (Settings) > Meddelanden (Notifications) för att kontrollera specifika meddelandetyper som de kan erhålla för varje push-aktiverat program.

Apple rekommenderar att varje gång som ett program aktiveras ska det prenumerera på push-meddeladen. När programmet anropar RemoteNotifier.subscribe() , erhålls en RemoteNotificationEvent -händelse av typen token , som innehåller ett 32-byte stort unikt numeriskt token-ID som unikt identifierar programmet på enheten.

När enheten erhåller ett push-meddelande visas ett poup-fönster med knapparna Stäng (Close) och Starta (Launch). Om användarna pekar på Stäng (Close) händer inget, men om användaren pekar på Starta (Launch), öppnar iOS programmet och det erhåller en flash.events.RemoteNotificationEvent -händelse av typen notification . Se nedan.

Hantera push-meddelanden och meddelandedata

När fjärrmeddelandeleverantören skickar ett meddelande till en enhet (med aktuellt tokenID), kommer programmet att erhålla händelsen flash.events.RemoteNotificationEvent med typen notification , oberoende av om programmet körs eller inte. Vid den här tidpunkten utför programmet en programspecifik meddelandebearbetning. Om programmet hanterar meddelande data öppnar du det genom den JSON-formaterade egenskapen RemoteNotificationEvent.data .