Uso de notificaciones push

Las notificaciones push permiten a proveedores de notificaciones remotas enviar notificaciones a las aplicaciones que se ejecutan en un dispositivo móvil. AIR 3.4 admite notificaciones push para dispositivos iOS a través del Servicio de notificaciones push de Apple (APNs).

Nota: para habilitar las notificaciones push para una aplicación de AIR for Android, utilice una extensión nativa, como as3c2dm , desarrollada por el experto en Adobe Piotr Walczyszyn.

El resto de esta sección describe cómo habilitar las notificaciones push en aplicaciones de AIR for iOS.

Nota: en esta sección se da por hecho que dispone de un ID de desarrollador de Apple, que está familiarizado con el flujo de trabajo de iOS y que ha desarrollado al menos una aplicación en un dispositivo iOS.

Información general sobre notificaciones push

El Servicio de notificaciones push de Apple (APNs) permite a los proveedores de notificaciones remotas enviar notificaciones a aplicaciones que se ejecutan en dispositivos iOS. El APNs admite los siguientes tipos de notificaciones:

  • Alertas

  • Globos

  • Sonidos

Para obtener información detallada sobre el APNs, consulte developer.apple.com .

El uso de notificaciones push en la aplicación implica múltiples aspectos:

  • Aplicación cliente : registra las notificaciones push, se comunica con los proveedores de notificaciones remotas y recibe notificaciones push.

  • iOS : administra la interacción entre la aplicación cliente y el APNs.

  • APNs : proporciona un objeto tokenID durante el registro del cliente y transfiere notificaciones desde los proveedores de notificaciones remotas al iOS.

  • Proveedor de notificaciones remotas : almacenan información de tokenId y aplicaciones cliente y envía instantáneamente las notificaciones al APNs.

Flujo de trabajo de registro

El flujo de trabajo para registrar las notificaciones push con un servicio en el lado del servidor es el siguiente:

  1. La aplicación cliente solicita a iOS la habilitación de notificaciones push.

  2. iOS envía la solicitud al APNs.

  3. El servidor del APNs devuelve un objeto tokenId a iOS.

  4. iOS devuelve el objeto tokenId a la aplicación cliente.

  5. La aplicación cliente (a través de un mecanismo específico de la aplicación) proporciona el objeto tokenId al proveedor de notificaciones remotas y este lo almacena para usarlo en las notificaciones push.

Flujo de trabajo de notificaciones

El flujo de trabajo de notificaciones es el siguiente:

  1. El proveedor de notificaciones remotas genera una notificación y transfiere su carga al APNs junto con el objeto tokenId.

  2. El APNs reenvía la notificación a iOS en el dispositivo.

  3. iOS traslada instantáneamente la carga de la notificación a la aplicación.

API de notificaciones push

AIR 3.4 ya incluía un conjunto de API que admitían las notificaciones push de iOS. Estas API se encuentran en el paquete flash.notifications e incluyen las clases siguientes:

  • NotificationStyle : define constantes para tipos de notificaciones: ALERT , BADGE y SOUND .C

  • RemoteNotifier : permite suscribirse y anular la suscripción de notificaciones push.

  • RemoteNotifierSubscribeOptions : permite seleccionar qué tipos de notificaciones se reciben. Utilice la propiedad notificationStyles para definir un vector de cadenas que registre los distintos tipos de notificaciones.

AIR 3.4 también incluye flash.events.RemoteNotificationEvent , distribuido por RemoteNotifier en los casos siguientes:

  • Cuando se crea correctamente la suscripción en una aplicación y se recibe el objeto tokenId del APNs.

  • Después de recibir una nueva notificación remota.

Además, RemoteNotifier distribuye un evento flash.events.StatusEvent si se produce un error durante el proceso de suscripción.

Administración de notificaciones push en una aplicación

Para registrar su aplicación en el servicio de notificaciones push, debe llevar a cabo los pasos siguientes:

  • Cree el código que le suscriba a las notificaciones push en la aplicación.

  • Habilite las notificaciones push en el archivo XML de la aplicación.

  • Cree un archivo de suministro y un certificado que habilite los servicios push en iOS.

El siguiente código de ejemplo con comentarios realiza la suscripción a notificaciones push y administra los eventos de notificaciones 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()); 
                        } 
                        } 
                        }

Habilite las notificaciones push en el archivo XML de la aplicación

Para usar notificaciones push en la aplicación, incluya lo siguiente en la etiqueta Entitlements (debajo de la etiqueta iphone ):

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

Cuando esté listo para publicar la aplicación en el App Store, un elemento <string> para desarrollar en producción:

      <string>production</string>

Si la aplicación admite cadenas localizadas, especifique los idiomas en la etiqueta supportedLanguages , debajo de la etiqueta intialWindow , tal y como se indica en el siguiente ejemplo:

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

Cree un archivo de suministro y un certificado que habilite los servicios push en iOS

Para permitir la comunicación entre la aplicación y el APNs, debe empaquetar la aplicación con un archivo de suministro y un certificado para habilitar los servicios push en iOS del modo siguiente:

  1. Inicie sesión en su cuenta de desarrollador de Apple.

  2. Vaya a Provisioning Portal.

  3. Haga clic en la ficha App IDs.

  4. Haga clic en el botón New App ID.

  5. Especifique una descripción y un identificador de paquete (no puede utilizar * en el identificador).

  6. Haga clic en Submit. El portal de suministro generará su identificador y volverá a mostrar la página de identificadores de aplicaciones.

  7. Haga clic en Configure (a la derecha del identificador de la aplicación). Aparecerá la página Configure App ID.

  8. Marque la casilla de verificación Enable for Apple Push Notification. Tenga en cuenta que existen dos tipos de certificados SSL push: uno para desarrollo/pruebas y otro para producción.

  9. Haga clic en el botón Configure situado a la derecha del certificado SSL push de desarrollo. Aparecerá la página Generate Certificate Signing Request (CSR).

  10. Genere un CSR con la utilidad Acceso a Llaveros, tal como se indica en la página.

  11. Genere el certificado SSL.

  12. Descargue el certificado SSL e instálelo.

  13. (Opcional) Repita los pasos del 9 al 12 para generar el certificado SSL push de producción.

  14. Haga clic en Done. Aparecerá la página Configure App ID.

  15. Haga clic en Done. Aparecerá la página App IDs. Observe el círculo de color verde junto a la notificación push del identificador de su aplicación.

  16. Es muy importante guardar los certificados SSL, ya que se utilizarán más adelante para la comunicación entre la aplicación y el proveedor.

  17. Haga clic en la ficha Provisioning para visualizar la página Provisioning Profiles.

  18. Cree un archivo de suministro para el nuevo identificador de la aplicación y descárguelo.

  19. Haga clic en la ficha Certificates y descargue un nuevo certificado para el nuevo archivo de suministro.

Uso de sonidos para las notificaciones push

Para habilitar notificaciones con sonido para la aplicación, empaquete los archivos de sonido del mismo modo que haría con cualquier otro activo, pero en el mismo directorio que los archivos SWF y app-xml. Por ejemplo:

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 admite los siguientes formatos de datos de sonido (en archivos aiff, wav o caf):

  • PCM lineal

  • MA4 (IMA/ADPCM)

  • uLaw

  • aLaw

Uso de notificaciones de alerta localizadas

Para usar notificaciones de alerta localizadas en la aplicación, empaquete las cadenas localizadas en forma de carpetas lproj. Por ejemplo, si quiere admitir alertas en español, haga lo siguiente:

  1. Cree una carpeta es.lproj en el proyecto al mismo nivel que el archivo app-xml.

  2. Dentro de la carpeta es.lproj, cree un archivo de texto llamado Localizable.Strings.

  3. Abra el archivo Localizable.Strings en un editor de texto y añada claves de mensaje y las cadenas localizadas correspondientes. Por ejemplo:

    "PokeMessageFormat" = "La notificación de alertas en español."
  4. Guarde el archivo.

  5. Cuando la aplicación reciba una notificación de alerta con este valor clave y si el idioma del dispositivo es el español, se visualizará el texto de la alerta traducido.

Configuración de un proveedor de notificaciones remotas

Necesitará un proveedor de notificaciones remotas para enviar notificaciones push a la aplicación. Esta aplicación de servidor actúa como proveedor, acepta entradas push y transfiere la notificación y los datos al APNs que, por su lado, envía la notificación push a una aplicación cliente.

Para obtener información detallada sobre las notificaciones push desde un proveedor de notificaciones remotas, consulte Comunicación del proveedor con el Servicio de notificaciones push de Apple en la biblioteca de desarrolladores de Apple.

Opciones del proveedor de notificaciones remotas

Las opciones del proveedor de notificaciones remotas le permiten hacer lo siguiente:

  • Cree su propio proveedor a partir del servidor open-source APNS-php. Puede configurar un servidor PHP con http://code.google.com/p/apns-php/ . Este proyecto de Google Code permite diseñar una interfaz que se ajuste a sus requisitos concretos.

  • Utilice un proveedor de servicios. Por ejemplo, http://urbanairship.com/ ofrece proveedores APNs listos para usar. Tras registrarse en este servicio, deberá empezar por proporcionar su símbolo de dispositivo con un código similar al siguiente:

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

    Seguidamente, puede enviar las notificaciones de prueba con las herramientas de Urban Airship.

Certificados para el proveedor de notificaciones remotas

Debe copiar el certificado SSL y la clave privada (generada previamente) en la ubicación adecuada del servidor del proveedor de notificaciones remotas. Lo habitual es combinar estos dos archivos en un único archivo .pem . Para ello, haga lo siguiente:

  1. Abra una ventana de Terminal.

  2. Cree un archivo .pem desde el certificado SSL escribiendo el siguiente comando:

    openssl x509 -in aps_developer_identity.cer -inform der -out TestPushDev.pem
  3. Cree un archivo .pem desde el archivo de clave privada ( .p12 ) escribiendo el siguiente comando:

    openssl pkcs12 -nocerts -out TestPushPrivateKey.pem -in certificates.p12
  4. Combine los dos archivos .pem en uno solo escribiendo el siguiente comando:

    cat TestPushDev.pem TestPushPrivateKey.pem > FinalTestPush.pem
  5. Proporcione el archivo .pem combinado al proveedor del servidor cuando vaya a crear la aplicación push en el lado del servidor.

Para obtener más información, consulte Instalación del certificado SSL y la clave en el servidor en el manual Apple Local and Push Notification Programming Guide.

Manejo de notificaciones push en una aplicación

Manejar las notificaciones push en una aplicación implica lo siguiente:

  • Configuración y aceptación global de notificaciones push por parte del usuario

  • Aceptación de notificaciones push individuales por parte del usuario

  • Control de notificaciones push y datos de carga de notificaciones

Configuración y aceptación de notificaciones push

La primera vez que un usuario inicia una aplicación habilitada con notificaciones push, iOS muestra un diálogo de appname Would Like to Send You Push Notifications con los botones No permitir y Aceptar. Si el usuario selecciona Aceptar, la aplicación puede recibir todo tipo de notificaciones a las que se haya suscrito. Si el usuario selecciona No permitir, no recibirá ninguna notificación.

Nota: los usuarios pueden ir a Ajustes > Notificaciones para controlar los tipos específicos de notificaciones que pueden recibir en cada aplicación habilitada con notificaciones push.

Apple recomienda que cada vez que se active una aplicación, debe suscribirse a notificaciones push. Cuando la aplicación llama a RemoteNotifier.subscribe() , recibe un evento RemoteNotificationEvent de tipo token que contiene un objeto tokenId numérico único de 32 bytes para identificar de forma exclusiva la aplicación en dicho dispositivo.

Cuando el dispositivo recibe una notificación push, muestra un mensaje emergente con los botones Cerrar y Abrir. Si el usuario toque Cerrar, no sucede nada; si el usuario toque Abrir, iOS invoca la aplicación y esta recibe un evento flash.events.RemoteNotificationEvent de tipo notification , tal como se describe más abajo.

Control de notificaciones push y datos de carga

Cuando el proveedor de notificaciones remotas envía una notificación a un dispositivo (con el objeto tokenID), la aplicación recibe un evento flash.events.RemoteNotificationEvent de tipo notification , se esté ejecutando o no la aplicación. En este punto, la aplicación lleva a cabo el procesamiento de notificaciones específicas de la aplicación. Si al aplicación gestiona datos de notificaciones, podrá acceder a ellos a través de la propiedad RemoteNotificationEvent.data con formato JSON.