Używanie powiadomień w trybie push

Omówienie powiadomień w trybie push
Zarządzanie w aplikacji powiadomieniami w trybie push
Konfigurowanie zdalnego dostawcy powiadomień
- Opcje obsługi zdalnego dostawcy powiadomień
- Certyfikaty zdalnego dostawcy powiadomień
Obsługa w aplikacji powiadomień w trybie push
- Konfigurowanie i przyjmowanie powiadomień w trybie push
- Obsługa powiadomień w trybie push oraz danych, które są w nich przesyłane

Powiadomienia w trybie push są powiadomieniami zdalnie wysyłanymi do aplikacji uruchomionych na urządzeniach przenośnych. Środowisko AIR 3.4 obsługuje powiadomienia w trybie push dla urządzeń z systemem iOS, używając do tego usługi APN (Apple Push Notification).

Uwaga: Aby włączyć powiadomienia w trybie push w środowisku AIR for Android, należy użyć rozszerzenia natywnego, na przykład opracowanego przez specjalistę ds. produktów Adobe Piotra Walczyszyna rozszerzenia as3c2dm .

Pozostała część tej sekcji określa sposób włączania powiadomień push w środowisku AIR for iOS.

Uwaga: W omówieniu przyjęto założenie, że użytkownik ma identyfikator programisty firmy Apple, zna mechanizmy programowania dla systemu iOS i wdrożył przynajmniej jedną aplikację dla urządzeń z systemem iOS.

Omówienie powiadomień w trybie push

Usługa APN (Apple Push Notification) pozwala dostawcom powiadomień zdalnych na przesyłanie powiadomień do aplikacji uruchomionych na urządzeniach z systemem iOS. Usługa APN obsługuje następujące typy powiadomień:

Komunikaty
Ikony
Dźwięki

Pełne informacje o usłudze APN znajdują się w witrynie developer.apple.com .

Używanie w aplikacji powiadomień w trybie push wymaga skonfigurowania kilku elementów:

Aplikacja kliencka rejestruje się do powiadomień w trybie push, komunikuje się ze zdalnymi dostawcami powiadomień i odbiera powiadomienia w trybie push.
System iOS zarządza interakcjami między aplikacją kliencką i usługą APN.
Usługa APN zapewnia identyfikator tokenID podczas rejestracji klienta i przekazuje powiadomienia od zdalnego dostawcy powiadomień do systemu iOS.
Zdalny dostawca powiadomień — przechowuje informację tokenId-client z aplikacji i przesyła powiadomienia do usługi APN.

Obieg pracy podczas rejestracji

Obieg pracy podczas rejestracji powiadomień w trybie push z usługą uruchomioną na serwerze jest następujący:

Aplikacja kliencka przesyła żądanie włączenia powiadomień w trybie push w systemie iOS.
System iOS przesyła żądanie do usługi APN.
Serwer APN zwraca wartość tokenId do systemu iOS.
System iOS zwraca wartość tokenId do aplikacji klienckiej.
Aplikacja kliencka (za pomocą mechanizmu specyficznego dla niej) przekazuje wartość tokenId do zdalnego dostawcy powiadomień, który ją zapisuje na potrzeby obsługi powiadomień w trybie push.

Obieg pracy w zakresie obsługi powiadomień

Obieg pracy w zakresie obsługi powiadomień wygląda następująco:

Zdalny dostawca powiadomień generuje powiadomienie i przesyła jego treść do usługi APN razem z wartością tokenId.
Usługa APN przekazuje powiadomienie do systemu iOS w urządzeniu.
System iOS przesyła zawartość powiadomienia do aplikacji.

Interfejs API powiadomień w trybie push

W środowisku AIR 3.4 został wprowadzony zbiór interfejsów API służących do obsługi powiadomień w trybie push w systemie iOS. Interfejsy te są dostępne w pakiecie flash.notifications i obejmują następujące klasy:

NotificationStyle definiuje stałe wartości dla poszczególnych typów powiadomień: ALERT , BADGE i SOUND .C
RemoteNotifier pozwala na subskrypcję powiadomień w trybie push oraz rezygnację z nich.
RemoteNotifierSubscribeOptions pozwala wybrać typ powiadomień do odebrania. Za pomocą właściwości notificationStyles można zarejestrować wektor ciągów rejestrujących wiele typów powiadomień.

Środowisko AIR 3.4 zawiera także zdarzenie flash.events.RemoteNotificationEvent wywoływane przez klasę RemoteNotifier w następujący sposób:

Gdy aplikacja pomyślnie zasubskrybuje powiadomienia, usługa APN tworzy nową wartość tokenId i przesyła ją do aplikacji.
Po odebraniu nowego powiadomienia zdalnego.

Jeśli w trakcie procesu subskrypcji wystąpi błąd, klasa RemoteNotifier wywoła zdarzenie flash.events.StatusEvent .

Zarządzanie w aplikacji powiadomieniami w trybie push

Aby zarejestrować w aplikacji powiadomienia w trybie push, należy wykonać następujące kroki:

Utwórz kod, który wykona subskrypcję powiadomień w trybie push w aplikacji.
Włącz powiadomienia w trybie push w pliku XML aplikacji.
Utwórz profil informacyjny oraz certyfikat umożliwiające włączenie usługi powiadomień w trybie push w systemie iOS.

Przedstawiony poniżej przykładowy kod z odpowiednimi komentarzami pozwala zasubskrybować powiadomienia w trybie push i obsługuje zdarzenia, które są z nimi związane:

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

Włączanie powiadomień w trybie push w pliku XML aplikacji

Aby użyć w aplikacji powiadomień w trybie push, należy w znaczniku Entitlements wprowadzić następujące informacje (w znaczniku iphone ).

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

Gdy aplikacja jest już gotowa do przesłania do sklepu App Store, należy zmienić zawartość ciągu <string> z „development” na „production”.

      <string>production</string>

Jeśli aplikacja obsługuje zlokalizowane ciągi, należy podać języki w znaczniku supportedLanguages , pod znacznikiem intialWindow , tak jak w poniższym przykładzie.

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

Tworzenie profilu informacyjnego oraz certyfikatu umożliwiającego włączenie usługi obsługującej powiadomienia w trybie push w systemie iOS

Aby umożliwić komunikację między aplikacją i usługą APN, należy spakować aplikację razem z profilem i certyfikatem informacji, zgodnie z poniższym opisem. Pozwoli to na włączenie usługi powiadomień w trybie push w systemie iOS.

Zaloguj się na konto programisty firmy Apple.
Przejdź do witryny Provisioning Portal (Portal informacji).
Kliknij zakładkę App IDs (Identyfikatory aplikacji).
Kliknij przycisk New App ID (Nowy identyfikator aplikacji).
Wprowadź opis i identyfikator paczki pakietu. (W identyfikatorze nie należy używać znaku *).
Kliknij przycisk Submit (Wyślij). Witryna Provisioning Portal (Portal informacji) wygeneruje identyfikator App ID i wyświetli ponownie stronę identyfikatorów.
Kliknij przycisk Configure (Konfiguruj) umieszczony obok otrzymanego identyfikatora App ID. Pojawi się strona Configure App ID (Konfiguracja identyfikatora aplikacji)
Zaznacz pole wyboru Enable for Apple Push Notification service (Włącz w powiadomieniach Apple w trybie push) Uwaga: Dostępne są dwa rodzaje certyfikatów SSL do obsługi powiadomień w trybie push — jeden do programowania i testowania oraz drugi do użytku produkcyjnego.
Kliknij przycisk Configure (Konfiguruj) umieszczony obok nazwy Development Push SSL Certificate (Certyfikat SSL trybu push do programowania). Zostanie wyświetlona strona generowania żądania podpisania certyfikatu (Certificate Signing Request, CSR).
Zgodnie z informacjami podanymi na tej stronie wygeneruj żądanie CSR, używając narzędzia Dostęp do pęku kluczy.
Wygeneruj certyfikat SSL.
Pobierz i zainstaluj certyfikat SSL.
(Opcjonalnie) Powtórz kroki od 9 do 12 dla certyfikatu SSL przeznaczonego do obsługi powiadomień w trybie push w użytku produkcyjnym.
Kliknij polecenie Done (Gotowe). Pojawi się strona Configure App ID (Konfiguracja identyfikatora aplikacji)
Kliknij polecenie Done (Gotowe). Pojawi się strona App IDs (Identyfikatory aplikacji). Zwróć uwagę na zielony okrąg obok nazwy Push Notifications (Powiadomienia w trybie push) umieszczony przy otrzymanym identyfikatorze App ID.
Zapisuj otrzymywane certyfikaty SSL. Są one później używane do komunikacji między aplikacją i dostawcą.
Kliknij kartę Provisioning (Informacje). Zostanie wyświetlona strona Provisioning Profiles (Profile informacji).
Utwórz profil informacyjny dla nowego identyfikatora App ID i pobierz go.
Kliknij kartę Certificates (Certyfikaty) i pobierz nowy certyfikat dla nowego profilu informacyjnego.

Używanie dźwięku dla powiadomień w trybie push

Aby włączyć w aplikacji powiadomienia dźwiękowe, pliki dźwiękowe należy dołączyć tak samo jak inne zasoby, jednak muszą się one znajdować w tym samym katalogu co pliki SWF i app-xml. Na przykład:

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

Firma Apple obsługuje następujące formaty danych dźwiękowych (w plikach AIFF, WAV lub CAF):

Linear PCM
MA4 (IMA/ADPCM)
uLaw
aLaw

Używanie zlokalizowanych powiadomień z komunikatami

Aby użyć w aplikacji zlokalizowanych powiadomień z komunikatami, zlokalizowane ciągi należy dołączyć w postaci folderów lproj. Aby na przykład wprowadzić obsługę komunikatów w języku hiszpańskim, należy wykonać następujące czynności:

Utwórz w projekcie folder es.lproj na tym samym poziomie, na którym znajduje się plik app-xml.
W folderze es.lproj utwórz plik tekstowy o nazwie Localizable.Strings.
Otwórz plik Localizable.Strings w edytorze tekstowym i wpisz w nim klucze komunikatów oraz odpowiednie zlokalizowane ciągi. Na przykład:
```
"PokeMessageFormat" = "La notificación de alertas en español."
```
Zapisz plik.
Gdy aplikacja otrzyma powiadomienie z komunikatem o danej wartości klucza, a językiem urządzenia jest hiszpański, pojawi się zlokalizowany tekst komunikatu.

Konfigurowanie zdalnego dostawcy powiadomień

Do przesyłania do aplikacji powiadomień w trybie push potrzebny jest zdalny dostawca powiadomień. Aplikacja serwera działa jako dostawca, odbierając informacje przesyłane w trybie push oraz przekazując powiadomienia i ich dane do usługi APN. Ta usługa przesyła do aplikacji klienckiej powiadomienie w trybie push.

Szczegółowe informacje o powiadomieniach w trybie push od zdalnego dostawcy powiadomień znajdują się w dokumencie Komunikacja dostawcy z usługą powiadomień w trybie push firmy Apple w bibliotece dokumentacji dla programistów firmy Apple.

Opcje obsługi zdalnego dostawcy powiadomień

Dostępne są następujące opcje obsługi zdalnego dostawcy powiadomień:

Można utworzyć własnego dostawcę opartego na serwerze open source APNS-php. Serwer PHP można skonfigurować, używając projektu http://code.google.com/p/apns-php/ . Ten należący do usługi Google Code projekt pozwala na utworzenie interfejsu pasującego do określonych wymagań.

Można użyć dostawcy usług. Na przykład witryna http://urbanairship.com/ oferuje gotowego dostawcę APN. Po zarejestrowaniu usługi można ją uruchomić, podając token urządzenia za pomocą kodu podobnego do poniższego.

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

Następnie można przetestować obsługę powiadomień, używając narzędzi Urban Airship.

Certyfikaty zdalnego dostawcy powiadomień

Wygenerowany wcześniej certyfikat SSL i klucz prywatny należy skopiować do odpowiedniego miejsca na serwerze zdalnego dostawcy powiadomień. Te dwa pliki można przeważnie połączyć w jednym pliku PEM . Aby to zrobić, wykonaj następujące czynności:

Otwórz okno terminalu.

Utwórz plik PEM z certyfikatu SSL, wpisując następujące polecenie:

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

Utwórz plik PEM z pliku klucza prywatnego ( .p12 ), wpisując następujące polecenie:
```
openssl pkcs12 -nocerts -out TestPushPrivateKey.pem -in certificates.p12
```
Połącz dwa uzyskane pliki PEM w jeden, wpisując następujące polecenie:
```
cat TestPushDev.pem TestPushPrivateKey.pem > FinalTestPush.pem
```
Podaj utworzony plik PEM podczas tworzenia aplikacji obsługującej powiadomienia w trybie push po stronie serwera.

Więcej informacji znajduje się w artykule Instalowanie certyfikatu i klucza SSL na serwerze dostępnym w dokumencie Podręcznik firmy Apple: Programowanie powiadomień lokalnych i w trybie push.

Obsługa w aplikacji powiadomień w trybie push

Obsługa w aplikacji powiadomień w trybie push obejmuje następujące czynności:

Globalna konfiguracja użytkownika i przyjmowanie powiadomień w trybie push
Przyjmowanie przez użytkownika poszczególnych powiadomień w trybie push
Obsługa powiadomień w trybie push oraz danych, które są w nich przesyłane

Konfigurowanie i przyjmowanie powiadomień w trybie push

Gdy użytkownik pierwszy raz uruchomi aplikację obsługującą powiadomienia w trybie push, system iOS wyświetli komunikat „ appname ” chce wysyłać Ci powiadomienia Push . Dostępne są wówczas dwa przyciski: Nie pozwalaj i OK. Jeśli użytkownik wybierze przycisk OK, aplikacja będzie mogła odbierać wszystkie rodzaje powiadomień, które subskrybuje. Jeśli użytkownik wybierze polecenie Nie pozwalaj, nie będą przesyłane żadne powiadomienia.

Uwaga: Rodzaje powiadomień, które aplikacja może otrzymywać, można także skonfigurować, wybierając polecenie Ustawienia > Powiadomienia.

Firma Apple zaleca, aby aplikacja zawsze subskrybowała powiadomienia podczas uaktywniania. Wywołanie przez aplikację metody RemoteNotifier.subscribe() powoduje otrzymanie parametru RemoteNotificationEvent typu token z 32-bajtową niepowtarzalną wartością liczbową tokenId, która pozwala na jednoznaczną identyfikację aplikacji na danym urządzeniu.

Gdy urządzenie odbierze powiadomienie w trybie push, wyświetli okno podręczne z przyciskami Zamknij i Uruchom. Gdy użytkownik dotknie przycisku Zamknij, system iOS wywoła aplikację, która odbierze zdarzenie flash.events.RemoteNotificationEvent opisanego poniżej typu notification .

Obsługa powiadomień w trybie push oraz danych, które są w nich przesyłane

Gdy zdalny dostawca powiadomień przesyła powiadomienie do urządzenia (za pomocą wartości tokenID), aplikacja odbiera zdarzenie flash.events.RemoteNotificationEvent typu notification niezależnie od tego, czy jest uruchomiona. Następnie wykonywane są wewnętrzne procesy aplikacji związane z obsługą powiadomienia. Jeśli aplikacja obsługuje dane powiadomień, można uzyskać do nich dostęp za pomocą właściwości RemoteNotificationEvent.data w formacie JSON.