Utilisation des notifications Push

Présentation des notifications Push
Gestion des notifications Push dans une application
Configuration d’un fournisseur de notifications à distance
- Options du fournisseur de notifications à distance
- Certificats pour le fournisseur de notifications à distance
Gestion des notifications Push dans une application
- Configuration et acceptation des notifications Push
- Gestion des notifications Push et des données de charge utile

Grâce aux notifications Push, les fournisseurs de notifications à distance peuvent envoyer des notifications aux applications qui s’exécutent sur des périphériques mobiles. AIR 3.4 prend en charge les notifications pour les périphériques iOS qui font appel au service Apple Push Notification (APN).

Remarque : pour activer les notifications Push dans une application AIR for Android, utilisez une extension native, telle que as3c2dm , développée par l’expert Adobe Piotr Walczyszyn.

Le reste de cette section décrit comment activer les notifications Push dans les applications AIR for iOS.

Remarque : nous supposons que vous disposez d’un ID de développement Apple, que vous connaissez le processus de développement iOS et que vous avez déployé au moins une application sur un périphérique iOS.

Présentation des notifications Push

Le service Apple Push Notification (APN) permet aux fournisseurs de notifications à distance d’envoyer des notifications aux applications qui s’exécutent sur des périphériques iOS. Le service APN prend en charge les types de notification suivants :

Alertes
Badges
Sons

Pour obtenir des informations complètes sur le service APN, consulter le site developer.apple.com .

L’utilisation des notifications Push dans votre application implique plusieurs aspects :

Application cliente : souscrit aux notifications Push, communique avec les fournisseurs de notifications à distance et reçoit des notifications Push.
iOS : gère l’interaction entre l’application cliente et le service APN.
Service APN : fournit un ID de jeton lors de la souscription du client et transmet les notifications des fournisseurs de notifications à distance au périphérique iOS.
Fournisseur de notifications à distance : stocke les informations de l’application cliente (fournie par l’ID de jeton) et envoie des notifications Push au service APN.

Procédure de souscription

La procédure de souscription aux notifications Push avec un service côté serveur est la suivante :

L’application cliente demande au périphérique iOS d’activer les notifications Push.
iOS transfère la demande au service APN.
Le serveur du service APN renvoie un ID de jeton au périphérique iOS.
iOS renvoie cet ID de jeton à l’application cliente.
A l’aide d’un mécanisme qui lui est propre, l’application cliente transmet l’ID de jeton au fournisseur de notifications à distance, qui enregistre ce dernier pour procéder à l’envoi de notifications Push.

Procédure de notification

La procédure de notification est la suivante :

Le fournisseur de notifications à distance génère une notification et transmet la charge utile de la notification au service APN, accompagnée de l’ID de jeton.
Le service APN transfère la notification au système iOS sur le périphérique.
iOS envoie la charge utile de la notification à l’application.

API pour les notifications Push

AIR 3.4 intègre plusieurs API qui prennent en charge les notifications Push sur iOS. Ces API se trouvent dans le package flash.notifications et incluent les classes suivantes :

NotificationStyle : définit les constantes pour les types de notification ALERT , BADGE et SOUND .C
RemoteNotifier : permet de souscrire et d’annuler la souscription aux notifications Push.
RemoteNotifierSubscribeOptions : permet de sélectionner les types de notifications à recevoir. Utilisez la propriété notificationStyles pour définir un vecteur de chaînes souscrivant à divers types de notifications.

AIR 3.4 inclut également l’événement flash.events.RemoteNotificationEvent , distribué par RemoteNotifier dans les cas suivants :

Lorsque la souscription d’une application aboutit et après la réception d’un nouvel ID de jeton envoyé par le service APN ;
A la réception d’une nouvelle notification à distance.

Par ailleurs, RemoteNotifier distribue l’événement flash.events.StatusEvent s’il rencontre une erreur lors du processus de souscription.

Gestion des notifications Push dans une application

Pour souscrire aux notifications Push, vous devez :

créer un code qui souscrit aux notifications Push dans votre application ;
activer les notifications Push dans le fichier XML de l’application ;
créer un profil et un certificat d’attribution de privilèges d’accès pour activer les services Push sur iOS.

L’exemple de code annoté suivant souscrit aux notifications Push et gère les événements de notification Push :

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

Activation des notifications Push dans le fichier XML de l’application

Pour utiliser les notifications Push dans votre application, fournissez les informations suivantes dans la balise Entitlements (sous la balise iphone ) :

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

Lorsque vous êtes prêt à soumettre l’application à l’App Store, un élément <string> pour le développement à la production :

      <string>production</string>

Si votre application prend en charge les chaînes localisées, spécifiez les langues dans la balise supportedLanguages , sous la balise intialWindow , comme dans l’exemple suivant :

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

Création d’un profil et d’un certificat d’attribution de privilèges d’accès pour activer les services Push sur iOS

Pour permettre la communication entre le service APN et l’application, vous devez mettre en package l’application avec un profil et un certificat d’attribution de privilèges d’accès permettant d’activer les services Push sur iOS. Pour cela, procédez comme suit :

Connectez-vous à votre compte de développement Apple.
Accédez au portail de configuration.
Cliquez sur l’onglet App IDs.
Cliquez sur le bouton New App ID.
Entrez une description et un identificateur d’offres groupées (vous ne devez pas utiliser le signe * dans cet identificateur).
Cliquez sur Submit. Le portail de configuration génère votre ID d’application et vous êtes redirigé vers la page App IDs.
Cliquez sur Configure (en regard de votre ID d’application). La page Configure App ID s’affiche.
Cochez la case Enable for Apple Push Notification service. Notez qu’il existe deux types de certificats SSL Push : un pour le développement et le test, un autre pour la production.
Cliquez sur le bouton Configure situé en regard de Development Push SSL Certificate. La page Generate Certificate Signing Request (CSR) s’affiche.
Générez une demande de signature de certificat (CSR) à l’aide de l’utilitaire Keychain Access, comme indiqué sur cette page.
Générez le certificat SSL.
Téléchargez et installez le certificat SSL.
(Facultatif) Répétez les étapes 9 à 12 pour le certificat SSL Push de production.
Cliquez sur Done. La page Configure App ID s’affiche.
Cliquez sur Done. La page App IDs s’affiche. Notez le cercle vert en regard de la notification Push correspondant à votre ID d’application.
Veillez à enregistrer vos certificats SSL, car ils seront utilisés ultérieurement pour communiquer avec l’application et le fournisseur.
Cliquez sur l’onglet Provisioning pour afficher la page Provisioning Profiles.
Créez un profil d’attribution de privilèges d’accès pour votre nouvel ID d’application et téléchargez-le.
Cliquez sur l’onglet Certificates et téléchargez un nouveau certificat pour le nouveau profil d’attribution de privilèges d’accès.

Utilisation de sons pour les notifications Push

Pour activer les notifications sonores dans votre application, regroupez les fichiers son comme vous le feriez pour tout autre actif, mais dans le même répertoire que les fichiers SWF et app-xml. Exemple :

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 prend en charge les formats de données audio suivants (dans les fichiers aiff, wav et caf) :

PCM linéaire
MA4 (IMA/ADPCM)
uLaw
aLaw

Utilisation de notifications d’alerte localisées

Pour utiliser des notifications d’alerte localisées dans votre application, regroupez les chaînes localisées dans des dossiers lproj. Par exemple, si vous souhaitez créer des alertes en espagnol, procédez comme suit :

Créez un dossier es.lproj dans le projet, au même niveau que le fichier app-xml.
Au sein du dossier es.lproj, créez un fichier texte appelé Localizable.Strings.
Ouvrez le fichier Localizable.Strings dans un éditeur de texte et ajoutez les clés du message et les chaînes localisées correspondantes. Exemple :
```
"PokeMessageFormat" = "La notificación de alertas en español."
```
Enregistrez le fichier.
Lorsque l’application reçoit une notification d’alerte avec cette valeur de clé et que la langue du périphérique est l’espagnol, le texte d’alerte traduit s’affiche.

Configuration d’un fournisseur de notifications à distance

Vous devez disposer d’un fournisseur de notifications à distance pour envoyer des notifications Push à votre application. Cette application serveur agit comme un fournisseur ; elle accepte votre demande de réception de notifications Push et transmet les notifications et les données de notification au service APN qui, à son tour, envoie les notifications Push à l’application cliente.

Pour obtenir des informations détaillées sur l’envoi de notifications à partir d’un fournisseur de notifications à distance, voir l’article Provider Communication with Apple Push Notification Service dans Apple Developer Library (disponible en anglais uniquement).

Options du fournisseur de notifications à distance

Les options d’un fournisseur de notifications à distance sont les suivantes :

Créer votre propre fournisseur en fonction du serveur Open Source APNS-php. Vous pouvez configurer un serveur PHP en suivant les instructions de la page http://code.google.com/p/apns-php/ . Ce projet de code Google permet de créer une interface adaptée à vos besoins spécifiques.

Utiliser un fournisseur de services. Par exemple, http://urbanairship.com/ offre un fournisseur de service APN prêt à l’emploi. Après avoir souscrit ce service, vous devez commencer par fournir votre jeton de périphérique à l’aide d’un code similaire au suivant :

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

Vous pouvez envoyer des notifications de test à l’aide des outils Urban Airship.

Certificats pour le fournisseur de notifications à distance

Vous devez copier le certificat SSL et la clé privée (générée antérieurement) à l’emplacement approprié sur le serveur du fournisseur de notifications à distance. En règle générale, vous devez combiner ces deux fichiers dans un fichier .pem unique. Pour cela, procédez comme suit :

Ouvrez une fenêtre de terminal.
Créez un fichier .pem à partir du certificat SSL en saisissant la commande suivante :
```
openssl x509 -in aps_developer_identity.cer -inform der -out TestPushDev.pem
```
Créez un fichier .pem à partir du fichier de clé privée ( .p12 ) en saisissant la commande suivante :
```
openssl pkcs12 -nocerts -out TestPushPrivateKey.pem -in certificates.p12
```
Combinez ces deux fichiers .pem au sein d’un fichier unique en saisissant la commande suivante :
```
cat TestPushDev.pem TestPushPrivateKey.pem > FinalTestPush.pem
```
Fournissez le fichier .pem combiné au serveur du fournisseur lorsque vous créez votre application d’envoi côté serveur.

Pour plus d’informations, voir la rubrique Installing the SSL Certificate and Key on the Server du document Apple Local and Push Notification Programming Guide (disponible en anglais uniquement).

Gestion des notifications Push dans une application

La gestion des notifications Push dans une application implique les aspects suivants :

Configuration et acceptation des notifications Push de la part de l’utilisateur global
Acceptation des notifications Push individuelles de la part de l’utilisateur
Gestion des notifications Push et des données de charge utile des notifications

Configuration et acceptation des notifications Push

La première fois qu’un utilisateur lance une application prenant en charge les notifications Push, iOS affiche la boîte de dialogue appname Would Like to Send You Push Notifications accompagnée des boutons Don’t Allow et OK. Si l’utilisateur sélectionne OK, l’application peut recevoir tous les styles de notifications auxquels elle a souscrit. Si l’utilisateur sélectionne Don’t Allow, l’application ne reçoit aucune notification.

Remarque : les utilisateurs peuvent accéder à Réglages > Notifications pour contrôler les types de notifications spécifiques qu’ils peuvent recevoir pour chaque application prenant en charge les notifications Push.

Selon les recommandations d’Apple, chaque fois qu’une application est activée elle doit souscrire aux notifications Push. Lorsqu’une application appelle RemoteNotifier.subscribe() , elle reçoit un événement RemoteNotificationEvent de type token , qui contient un ID de jeton numérique unique de 32 octets permettant d’identifier de façon unique l’application sur ce périphérique.

Lorsque le périphérique reçoit une notification Push, il affiche une fenêtre contextuelle contenant les boutons Fermer et Lancer. Si l’utilisateur appuie sur Fermer, rien ne se passe ; si l’utilisateur appuie sur Lancer, iOS invoque l’application, qui reçoit un événement flash.events.RemoteNotificationEvent de type notification , tel que décrit ci-dessous.

Gestion des notifications Push et des données de charge utile

Lorsque le fournisseur de notifications à distance envoie une notification à un périphérique (à l’aide de l’ID de jeton), votre application reçoit un événement flash.events.RemoteNotificationEvent de type notification , que l’application soit en cours d’exécution ou pas. A ce stade, votre application effectue un traitement des notifications propre à l’application. Si votre application gère les données de notification, vous pouvez y accéder via la propriété RemoteNotificationEvent.data au format JSON.