image


indigitall iOS SDK


Índice

  1. Introducción
    1. Obtención del SDK de Indigitall
    2. Obtención del "App Token" de la aplicación
    3. Obtención del “.cer” y “.p12” de APNS
  2. Integración
    1. SDK de Indigitall
    2. Configuración de Capabilities
    3. Configuración de Info.plist
    4. Inclusión del Notification Service Extension
  3. Uso de la librería
    1. Inicialización de la librería
    2. Permiso de envío de notificaciones
    3. Geofences y push geolocalizadas
    4. Sincronización con el registro del dispositivo
    5. Funciones disponibles de la librería
    6. Mensajes push
    7. Servicio de External Apps
    8. Recoger DeviceID
  4. Actualizaciones en la implementación
    1. Cómo actualizar a la versión 3.3 desde versiones anteriores del SDK
    2. Cambio en los permisos de Localización
    3. Cambios en el AppDelegate
    4. Añadir el App Group
    5. Opción de activar y desactivar localización
    6. Añadido bloque de sincronización con el registro
    7. Añadida posibilidad de capturar la descripción de Campaña
  5. F.A.Q
  6. Contacto


1. Introducción

En este documento se muestra toda la información necesaria para realizar la integración del SDK de Indigitall en una aplicación desarrollada para dispositivos con el sistema operativo iOS. En él se muestra todo lo necesario para integrar el SDK en una aplicación ya existente para poder utilizar los servicios que ofrece la plataforma indigitall.

Es importante consultar este manual antes de realizar el desarrollo y seguir todos los pasos que en él se indican para garantizar el correcto funcionamiento de la integración. El documento está dirigido a desarrolladores iOS, por lo que se utilizará un lenguaje técnico y se mostrarán ejemplos de código fuente cuando sea necesario.

1.1 Obtención del SDK de Indigitall

EL SDK se compone de dos partes, el .framework y la extensión de notificación.

El SDK se puede integrar de dos formas diferentes:

Manualmente

Descargar el SDK desde le siguiente enlace: SDK de Indigitall para iOS

CocoaPods

EL SDK está disponible a través de CocoaPods. Para instalarlo, simplemente hay que añadir la siguientes líneas a tu 'Podfile':

source 'https://bitbucket.org/indigitallfuente/indigitall-ios-specs.git'

platform :ios, '8.0'

target 'MyApp' do
    pod 'Indigitall'
end

Si no se encontrara la dependencia ejecutar el comando:

pod install --repo-update

Extensión de notificación

La extensión de notificación se puede descargar en el siguiente enlace: Extensión de Notificación de Indigitall para iOS

Nota:

Será necesario poseer el identificador necesario para que la app, en la que se desea integrar el SDK, pueda realizar la comunicación con el entorno de Indigitall. Para recibir este identificador el desarrollador deberá proporcionar a indigitall los datos necesarios para enviar las notificaciones (certificados .cer y .p12 para notificaciones) obtenidos desde la consola para desarrolladores de Apple.

1.2 Obtención del "App Token" de la aplicación

Cada aplicación registrada en el Panel de Control de Indigitall dispondrá de un identificador único denominado App Token. Este identificador se utilizará para inicializar el SDK y será el responsable de vincular la aplicación con la plataforma de indigitall, de esta forma indicará a qué aplicación pertenecen las notificaciones que lleguen al dispositivo. El App Token de una aplicación puede ser obtenido desde el Panel de Control de indigitall por un usuario administrador en el apartado de “Detalles” de la aplicación.

1.3 Obtención del “.cer” y “.p12” de APNS

Para poder enviar notificaciones push a dispositivos iOS es necesario poseer unos certificados que permiten la comunicación APNS (Apple Push Notification Service). Para ellos tendrá que generar los correspondientes certificados (.cer, .p12 y password si tiene) y enviarlos a indigitall. En el siguiente tutorial se explica cómo conseguir estos certificados.

Obtener certificados “.cer” y “.p12” de APNS.

2. Integración

2.1 SDK de Indigitall

SDK Manual

Incluir el archivo 'Indigitall.framework' en el proyecto. Una vez incluido es necesario además añadir el framework a Embedded Binaries, esto se puede hacer desde la pestaña General del target del proyecto.

 SDK CocoaPods

Una vez incluido las lineas indicadas en el Apartado 1.1 es necesario ejecutar el comando 'pod install' en la carpeta del proyecto desde la terminal. Una vez hecho esto es necesario abrir el 'MyApp'.xcworkspace en lugar del 'MyApp'.xcodeproj

2.2 Configuración de Capabilities

Se deben activar las Capabilities de Push Notifications y de Background Modes, en la cual se seleccionarán Location updates, Background fetch y Remote notifications.

image

También se deberá activar la capability App Groups y seleccionar el grupo que haya creado desde la consola de App. Esta capability deberá quedar configurada de la siguiente manera:

image

2.3 Configuración de Info.plist

El siguiente paso es configurar el archivo Info.plist del proyecto. En él se establecerán las siguientes claves:

<key>NSAppTransportSecurity</key>
    <dict>
        <key>NSAllowsArbitraryLoads</key>
        <false/>
        <key>NSExceptionDomains</key>
        <dict>
            <key>indigitall.net</key>
            <dict>
                <key>NSIncludesSubdomains</key>
                <true/>
                <key>NSTemporaryExceptionAllowsInsecureHTTPLoads</key>
                <true/>
                <key>NSTemporaryExceptionMinimumTLSVersion</key>
                <string>TLSv1.1</string>
            </dict>
        </dict>
    </dict>

2.4 Inclusión del Notification Service Extension

A partir de iOS 10 se mejoran las opciones y el control de las notificaciones. Para poder hacer uso de estas mejoras es necesario incluir un nuevo TARGET en el proyecto llamado Notification Service Extensión.

image

Al añadirlo se deberá configurar algunos datos como el Product Name, Bundle Identifier o Language, estableciendo este último a ObjectiveC.

image

En dicha configuración es necesario que en la sección Deployment Info, el campo Deployment Target este configurado a 10, esto configura cual es la versión minima del S.O. a la que se da soporte:

image

Deberán activarse también la Capability App Group para el Notification Extension Manager y seleccionar el grupo que se haya creado para la app en la consola de Apple "group.net.MyApp".

Tras haber creado el NSE será necesario sustituir los archivos .m y .h que se crean por defecto por los archivos NotificationService.h y NotificationService.m que se encuentran en el archivo .zip que se descargo en el punto 1.1 de la documentación.

Este group también deberá setearse en el código del NSE, concretamente en el archivo NotificationService.m en la siguiente variable:

      NSString *const groupName       = @"group.net.MyApp";

Como punto importante, para incluir esta extensión, deberá utilizar Xcode 8.1 o superior y habrá que configurar la versión del Deployment Target de la extensión a la 10.0 como mínimo, ya que esta extensión sólo se ejecuta para versiones de iOS 10 o superiores.

3. Uso de la librería

Para poder utilizar la librería, ya se haya hecho la integración manual o a través de 'CocoaPods' es necesario hacer un import en la cabecera de aquellas clases desde las cuales se quiera acceder a funcionalidades de la misma.

Objective-c

#import <Indigitall/Indigitall.h>

Swift

Para poder integrar la librería en un proyecto en Swift es necesario crear un archivo de pasarela que permita la compatibilidad con Objective-c:

  1. Si tu app ya tiene un archivo puente:

    • Añadir el siguiente código:

      #import <Indigitall/Indigitall.h>
      #import <UserNotifications/UserNotifications.h>
      #import "NotificationService.h"
  2. Si tu app no tiene un archivo puente:

    • Crear un archivo puente de tipo cabecera .h llamado Objective-Bridge-Swift.h

    • Añadir el siguiente código:

      #import <Indigitall/Indigitall.h>
      #import <UserNotifications/UserNotifications.h>
      #import "NotificationService.h"
    • Linkar el archivo para que actue de puente: Para ello seleccionamos el TARGET de la app y nos vamos a la sección "Build Settings". Una vez aqui nos vamos a "Swift Compiler-General" y ponemos la siguiente configuración:

      image

3.1 Inicialización de la librería

Para inicializar la librería es necesario incluir en el método didFinishLaunching del AppDelegate el siguiente código. Es necesario incluir el 'APP_TOKEN' proporcionado por Indigitall y además indicar si se quiere dar soporte a aplicaciones de terceros. Tras ello se deberá de asignar el delegado a la librería.



 - (BOOL)application:(UIApplication * )application didFinishLaunchingWithOptions:(NSDictionary * )launchOptions {

     [[IndigitallLib sharedInstance] setGroupName: @"group.net.MyApp"];
     [[IndigitallLib sharedInstance] initializeWithAppToken:@"APP_TOKEN" thirdPartyApps:NO];
     [IndigitallLib sharedInstance].delegate = self;

     return YES;
 }
       


  func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {

      IndigitallLib.sharedInstance().setGroupName("group.net.indigitall")
      IndigitallLib.sharedInstance().initialize(withAppToken:"APP_TOKEN", thirdPartyApps:false)
      IndigitallLib.sharedInstance().delegate = self
      return true
  }
      

3.2 Permiso de envío de notificaciones

En el momento de la inicialización si la aplicación aún no ha solicitado el permiso de notificaciones el SDK se encargará de solicitar al usuario ese permiso.

Para el correcto funcionamiento de las notificaciones hay que incluir el siguiente código en el AppDelegate:



       #import <UserNotifications/UserNotifications.h>
       @import Indigitall;

       @interface AppDelegate () <UNUserNotificationCenterDelegate,IndigitallDelegate>

       @end

       @implementation AppDelegate

       // MARK: - Push Notifications
       - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {

          //Ask for location permission
          CLLocationManager *locationManager = [CLLocationManager new];
          if ([locationManager respondsToSelector:@selector (requestAlwaysAuthorization)]) {
              [locationManager requestAlwaysAuthorization];
          }

          UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
          center.delegate = self;

       }

       - (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
          [[IndigitallLib sharedInstance] didRegisterForRemoteNotificationsWithDeviceToken:deviceToken];
       }

       - (void)application:(UIApplication *)application didFailToRegisterForRemoteNotificationsWithError:(NSError *)error {
          [[IndigitallLib sharedInstance] didFailToRegisterForRemoteNotificationsWithError:error];
       }

       - (void)application:(UIApplication *)application handleActionWithIdentifier: (NSString *)identifier forRemoteNotification:(NSDictionary *)notification completionHandler:(void(^)())completionHandler {
          // Comprobamos si la notificación es de Indigitall
          INPushNotification *indigitallPush = [[INPushNotification alloc] initWithDictionary: notification];
          if (indigitallPush) {
              [[IndigitallLib sharedInstance] handleActionWithIdentifier:identifier forRemoteNotification:notification completionHandler:completionHandler];
          }else {
              // Esta notificación no es de Indigitall
          }
       }

       - (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo {

          // Comprobamos si la notificación es de Indigitall
          INPushNotification *indigitallPush = [[INPushNotification alloc] initWithDictionary: userInfo];
          if (indigitallPush) {
              [[IndigitallLib sharedInstance] didReceiveRemoteNotification:notification];
          }else {
              // Esta notificación no es de Indigitall
          }
       }

       -(void) application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {

          // Comprobamos si la notificación es de Indigitall
          INPushNotification *indigitallPush = [[INPushNotification alloc] initWithDictionary: notification];
          if (indigitallPush) {
              [[IndigitallLib sharedInstance] didReceiveRemoteNotification:notification];
          }else {
            // Esta notificación no es de Indigitall
          }
          completionHandler( UIBackgroundFetchResultNewData );
       }

       - (void)userNotificationCenter:(UNUserNotificationCenter *)center willPresentNotification:(UNNotification *)notification withCompletionHandler:(void (^)(UNNotificationPresentationOptions options))completionHandler {
          NSLog( @"Gestionar la notificación en primer plano" );

          // Comprobamos si la notificación es de Indigitall
          INPushNotification *indigitallPush = [[INPushNotification alloc] initWithDictionary: notification.request.content.userInfo];
          if (indigitallPush) {
              [[IndigitallLib sharedInstance] didReceiveRemoteNotification:notification];
          }else {
              // Esta notificación no es de Indigitall
          }
       }

       - (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void (^)())completionHandler {
          NSLog( @"Handle push from background or closed" );
          INPushNotification *indigitallPush = [[INPushNotification alloc] initWithDictionary: response.notification.request.content.userInfo];
          if (indigitallPush) {
              [[IndigitallLib sharedInstance] handleActionWithIdentifier:response.actionIdentifier forRemoteNotification:response.notification.request.content.userInfo completionHandler:completionHandler];
          }else {
            // Esta notificación no es de Indigitall
          }
       }

       -(void)manageINPushNotification:(INPushNotification *)notification{

          //Programar funcionalidad

       }

       


    import UIKit

    @UIApplicationMain
    class AppDelegate: UIResponder, UIApplicationDelegate, IndigitallDelegate, UNUserNotificationCenterDelegate {

       var window: UIWindow?

       func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {

           IndigitallLib.sharedInstance().setGroupName("group.net.indigitall")
           IndigitallLib.sharedInstance().initialize(withAppToken:"APP_TOKEN", thirdPartyApps:false)
           IndigitallLib.sharedInstance().delegate = self
           return true
       }

       func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
           IndigitallLib.sharedInstance().didRegisterForRemoteNotifications(withDeviceToken: deviceToken)
       }

       func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: Error) {
           IndigitallLib.sharedInstance().didFailToRegisterForRemoteNotificationsWithError(error)
       }

       func application(_ application: UIApplication, handleActionWithIdentifier identifier: String?, forRemoteNotification userInfo: [AnyHashable : Any], completionHandler: @escaping () -> Void) {
           if (INPushNotification.init(dictionary: userInfo) != nil) {
               IndigitallLib.sharedInstance().handleAction(withIdentifier: identifier, forRemoteNotification: userInfo, completionHandler: completionHandler)
           }else {
               // Esta notificación no es de Indigitall
           }
       }

       func application(_ application: UIApplication, handleActionWithIdentifier identifier: String?, forRemoteNotification userInfo: [AnyHashable : Any], withResponseInfo responseInfo: [AnyHashable : Any], completionHandler: @escaping () -> Void) {
           if (INPushNotification.init(dictionary: userInfo) != nil) {
               IndigitallLib.sharedInstance().handleAction(withIdentifier: identifier, forRemoteNotification: userInfo, completionHandler: completionHandler)
           }else {
               // Esta notificación no es de Indigitall
           }
       }

       func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
           if (INPushNotification.init(dictionary: userInfo) != nil) {
               IndigitallLib.sharedInstance().didReceiveRemoteNotification(userInfo)
           }else {
               // Esta notificación no es de Indigitall
           }
           completionHandler(UIBackgroundFetchResult.newData)
       }

       func userNotificationCenter (_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void){
           print("Gestionar la notificación en primer plano")
           if ((INPushNotification.init(dictionary: notification.request.content.userInfo)) != nil){
               IndigitallLib.sharedInstance().didReceiveRemoteNotification(notification.request.content.userInfo)
           }else {
               // Esta notificación no es de Indigitall
           }
       }

       func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
            print("Handle push from background or closed")
           if((INPushNotification.init(dictionary: response.notification.request.content.userInfo)) != nil){
               IndigitallLib.sharedInstance().handleAction(withIdentifier: response.actionIdentifier, forRemoteNotification: response.notification.request.content.userInfo, completionHandler: completionHandler)
           }else {
               // Esta notificación no es de Indigitall
           }
       }

       func manage(_ notification: INPushNotification!) {
           // Programar funcionalidad

       }

          

3.3 Geofences y push geolocalizadas

Para el uso de Geofences y push geolocalizadas es necesario que la aplicación tenga el permiso de localización aprovado por el usuario ( Cuando la aplicación está en uso o siempre).

Para que el SDK pueda tener acceso a la localización es necesario incluir las siguientes tres claves en el archivo 'Info.plist'

<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
<string>¿Podemos usar tu localización siempre?</string>
<key>NSLocationAlwaysUsageDescription</key>
<string>¿Podemos usar tu localización siempre?</string>
<key>NSLocationWhenInUseUsageDescription</key>
<string>¿Podemos usar tu localización cuando usas la app?</string>

El mensaje que se mostrará al usuario asociado a las claves NSLocationAlwaysAndWhenInUseUsageDescription, NSLocationAlwaysUsageDescription​ y NSLocationWhenInUseUsageDescription puede personalizarse.

Para solicitar el permiso al usuario la aplicación debe ejecutar uno de los siguientes métodos en el momento que se quiera solicitar el permiso de localización al usuario ya que el SDK no lo pedirá por su cuenta.



       #import <CoreLocation/CoreLocation.h>

       //Ask allways location permission
       CLLocationManager *locationManager = [CLLocationManager new];
       if ([locationManager respondsToSelector:@selector (requestAlwaysAuthorization)]) {
           [locationManager requestAlwaysAuthorization];
       }

       //Ask when in use location permission
       CLLocationManager *locationManager = [CLLocationManager new];
       if ([locationManager respondsToSelector:@selector(requestWhenInUseAuthorization)]) {
               [locationManager requestWhenInUseAuthorization];
           }

       


       import CoreLocation

       //Ask for location permission
       let locationManager = CLLocationManager()
       if(CLLocationManager.authorizationStatus() == .authorizedAlways){
           locationManager.requestAlwaysAuthorization()
       }

       //Ask when in use location permission
       let locationManager = CLLocationManager()
       if(CLLocationManager.authorizationStatus() == .authorizedWhenInUse){
           locationManager.requestWhenInUseAuthorization()
       }

      

3.4 Sincronización con el registro del dispositivo

Para evitar posibles conflictos con el registro del dispositivo, como realizar acciones que requieran el deviceId del dispositivo (que se genera durante el registro), Indigitall provee de la función didRegisterForRemoteNotificationsWithDeviceToken a la que se le puede pasar un handler que permite saber cuando dicho registro se ha completado.



    - (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken{

        [[IndigitallLib sharedInstance] didRegisterForRemoteNotificationsWithDeviceToken:deviceToken completionHandler:^(BOOL registerSuccess, NSError *error){
            if(error){
                NSLog(@"ERROR: %@d " , error.localizedDescription);

            }else{
              if(registerSuccess){
                 NSLog(@"OnReady to receive push!!");
               }
            }

            }];
        }
       


       func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {

           IndigitallLib.sharedInstance().didRegisterForRemoteNotifications(withDeviceToken: deviceToken, handler:{(registerSuccess, error) in

               if (error) {
                    print("ERROR: %@d " , error.localizedDescription);
               }else {
                 if(registerSuccess){
                   print("OnReady to receive push!!");
                 }
               }
           })
       }

      

3.5 Funciones disponibles de la librería

Indigitall provee de una serie de métodos para las aplicaciones que hagan uso de la librería. Estos métodos ofrecen funcionalidades que van desde poder suscribirse y manejar Tags hasta operaciones para habilitar o deshabilitar el dispositivo.

Existen varias propiedades con información sobre el SDK y sobre el dispositivo.



       NSString *deviceId = [IndigitallLib getDeviceID];
       NSString *lVersion = [IndigitallLib getIndigitallSDKVersion];

       


       var deviceId = IndigitallLib.getDeviceID()
       var lVersion = IndigitallLib.getIndigitallSDKVersion()

      

Los propiedades:

  • deviceId: Es el identificador del dispositivo.
  • lVersion: Es la versión del SDK.

Métodos para gestionar la RECEPCIÓN DE NOTIFICACIONES

Los métodos disponibles para el control del dispositivo son los siguientes:



       // Permite activar la recepción de notificaciones en el dispositivo
       - (IBAction)enableDevice:(id)sender {
           [[IndigitallLib sharedInstance] enableDeviceWithHandler:^(NSError *error) {
               if (error == nil) {
                   NSLog(@"Dispositivo activado correctamente");
               }else {
                   NSLog(@"Se ha producido un error activado el dispositivo");
               }
           }];
       }
       //Permite desactivar la recepción de notificaciones en el dispositivo.
       - (IBAction)disableDevice:(id)sender {
           [[IndigitallLib sharedInstance] disableDeviceWithHandler:^(NSError *error) {
               if (error == nil) {
                   NSLog(@"Dispositivo desactivado correctamente");
               }else {
                   NSLog(@"Se ha producido un error desactivando el dispositivo");
               }
           }];
       }
       //Permite comprobar si la recepción de notificaciones esta activada o desactivada en el dispositivo
       - (IBAction)checkStatus:(id)sender {
           [[IndigitallLib sharedInstance] checkDeviceStatusWithHandler:^(BOOL enabled, NSError *error) {
               if (error == nil) {
                   if (enabled) {
                       NSLog(@"El dispositivo está activado");
                   }else {
                       NSLog(@"El dispositivo está desactivado");
                   }

               }else {
                   NSLog(@"Error: %@", error.localizedDescription);
               }
           }];
       }

       


    //Permite activar la recepción de notificaciones en el dispositivo.
        func enableDevice(sender:Any){
            IndigitallLib.sharedInstance().enableDevice(handler:{ (error) in
                if (error == nil) {
                    print("Dispositivo activado correctamente");
                }else {
                    print("Se ha producido un error activado el dispositivo");
                }
            })
        }

    //Permite desactivar la recepción de notificaciones en el dispositivo.
      func disableDevice(sender:Any){
          IndigitallLib.sharedInstance().disableDevice (handler:{(error) in
              if(error == nil){
                  print("Dispositivo desactivado correctamente")
              }else{
                  print("Se ha producido un error desactivando el dispositivo")
              }
          })
      }

    //Permite comprobar si la recepción de notificaciones esta activada
    o desactivada en el dispositivo
      func checkstatus (sender:Any){
          IndigitallLib.sharedInstance().checkDeviceStatus(handler: {(enabled, error) in
              if(error == nil){
                  if(enabled){
                      print("El dispositivo está activado")
                  }else{
                      print("El dispositivo está desactivado")
                  }
              }else{
                  print("Error: %@", error?.localizedDescription ?? "Unknown error")
              }
          })
      }

      

Métodos para la LOCALIZACIÓN

Los siguientes métodos permiten el control de la localización en el dispositivo. Es necesario haber inicializado la libreria para poder hacer uso de ellos:



       //Permite comprobar si el envío de la localización esta activado o desactivado en el dispositivo.
       - (BOOL) checkLocationStatus{
          return [[IndigitallLib sharedInstance] checklocationStatus];
       }

       //Permite activar el envío de localización en el dispositivo.
       - (void) enableLocation{
         [[IndigitallLib sharedInstance] enableLocation];
       }
       //Permite desactivar el envío de localización en el dispositivo.
       - (void) disableLocation{
         [[IndigitallLib sharedInstance] disableLocation];
       }

       


       //Permite comprobar si el envío de la localización esta activado o desactivado en el dispositivo.
       func checkLocationStatus() -> Bool{
           return IndigitallLib.sharedInstance().checkLocationStatus()
       }

       //Permite activar el envío de localización en el dispositivo.
       func enableLocation (){
           IndigitallLib.sharedInstance().enableLocation()
       }

       //Permite desactivar el envío de localización en el dispositivo.
       func disableLocation(){
           IndigitallLib.sharedInstance().disableLocation()
       }

      

Métodos para TAGS

Los Tags han de estar previamente creados en el panel para poder listarlos, suscribirse o desuscribirse de ellos.



       //Permite listar todos los tags que esten definidos en el panel.
       - (void) loadTags {
           [[IndigitallLib sharedInstance] tagsListWithHandler:^(NSArray *tags, NSError *error) {
               if (error == nil) {
                   tagsList = tags;
                   [self loadSubscribedTags];
               }else {
                   NSLog(@"Error al obtener todos los tags");
               }
           }];
       }
       //Permite obtener los tags a los que esta subscrito el dispositivo.
       - (void) loadSubscribedTags {
           [[IndigitallLib sharedInstance] tagsSubscriptionsWithHandler:^(NSArray *tags, NSError *error) {
               if (error == nil) {
                   for (INTag *tag in tags) {
                       for (INTag *currentTag in tagsList) {
                           if ([tag.tagId isEqualToString: currentTag.tagId]) {
                               currentTag.selected = YES;
                           }
                       }
                   }
                   [self.tableView reloadData];
               }else {
                   NSLog(@"Error al obtener los tags subscritos");
               }
           }];
       }
       //Permite subscribir o desubscribir al dispositivo de un tag.
       - (void) tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath {

           INTag *tag = [tagsList objectAtIndex:indexPath.row];
           if (tag.selected) {
               [[IndigitallLib sharedInstance] tagsUnsubscribeFromTags:[[NSArray alloc] initWithObjects:tag.tagId, nil] completionHandler:^(NSError *error) {
                   if (error == nil) {
                       tag.selected = NO;
                       [self.tableView reloadData];
                   }else {
                       NSLog(@"Error al desubscribir el tag");
                   }
               }];

           }else {
               [[IndigitallLib sharedInstance] tagsSubscribeToTags:[[NSArray alloc] initWithObjects:tag.tagId, nil]  completionHandler:^(NSError *error) {
                   if (error == nil) {
                       tag.selected = YES;
                       [self.tableView reloadData];
                   }else {
                       NSLog(@"Error al subscribir el tag");
                   }
               }];
           }
       }

       


   //Permite listar todos los tags que esten definidos en el panel.
      func loadTags(){
         IndigitallLib.sharedInstance().tagsList( handler:{(tags, error) in
             if (error == nil) {
                 print("Tags del panel obtenidos con éxito.")
             }else {
                 print("Error al obtener todos los tags")
             }
         })
      }

   //Permite obtener los tags a los que esta subscrito el dispositivo.
      func loadSubscribedTags(){
         IndigitallLib.sharedInstance().tagsSubscriptions (handler:{(tags, error) in
             if (error == nil) {
                 print("Tags del dispositivo obtenidos con éxito")
             }else{
                 print("Error al obtener los tags subscritos")
             }
         })

     }

  //Permite subscribir al dispositivo a un tag.
    func subscribe(tags: NSArray){
        IndigitallLib.sharedInstance().tagsSubscribe(toTags: tags as! [Any], completionHandler:{(error) in
            if (error == nil) {
                print("Dispositivo suscrito con éxito.")

            }else {
                print("Error al suscribir el tag")
            }
        })
    }

  //Permite desubscribir al dispositivo a un tag.
    func unsubscribe(tags: NSArray){
        IndigitallLib.sharedInstance().tagsUnsubscribe(fromTags: tags as! [Any],completionHandler:{(error) in
            if (error == nil) {
                print("Dispositivo desuscrito con éxito.")

            }else {
                print("Error al desuscribir el tag")
            }
        })
    }
      

3.6 Mensajes push

Una vez que hemos realizado todo el proceso de registro e inicialización, la aplicación se encuentra en disposición de recibir los mensajes push, la librería se encargará de tratar los mensajes y mostrar las notificaciones adecuadas. La aplicación tendrá la posibilidad de recoger los datos de los mensajes push cuando se envíen notificaciones de tipo “Abrir App”.

Si el objeto de tipo INPushNotification existe y la notificación proviene de Indigitall las propiedades del mensaje son:

NSNumber *type; //Tipo de notification
NSNumber *subtype; //Subtype de notificacion
NSString *message_id; //Identificador del mensaje
NSString *appToken; //App Token de la applicación
NSString *title; //Titulo de la notificación
NSString *body; // Cuerpo de la notificación
NSString *iconURL; // Icono de la notificación
NSString *imageURL; //Imagen de la notificación
NSString *data;// Datos enviados en la notificacion
NString *descCampaign; //Campaña asociada a la push
NSString *action;// Accion asociada a la push
BOOL destructive;//Flag que indica que la push ha sido descartada
NSArray *tagsToSubscribe; //Tags aplicados al crear el mensaje
NSArray *buttons; //Botones de la notificación
BOOL launch;//Flag que indica que la push ha sido mostrada
NSString *urlButton1; //Url asociada al botón 1
NSString *urlButton2; //Url asociada al botón 2

La forma de recoger estos datos es en el AppDelegate en los diferentes métodos en los que reciben las notificaciones:



   INPushNotification *indigitallPush = [[INPushNotification alloc] initWithDictionary: notification];

       


    var indigitallPush = INPushNotification.init(dictionary:notification)

      

3.7 Servicio de External Apps

El servicio de external Apps permite enviar notificaciones en función de si el usuario tiene o no instalada una determinada aplicación. Para ello es necesario que queden definidas en el panel las aplicaciones que se desean comprobar.

Para poder usar el servicio de externalApps es necesario seguir los siguientes pasos:

  • Al inicializar la librería debemos poner el campo thirdPartyApps a YES. La inicialización, por tanto, quedaría de la siguiente manera:


 - (BOOL)application:(UIApplication * )application didFinishLaunchingWithOptions:(NSDictionary * )launchOptions {

     [[IndigitallLib sharedInstance] setGroupName: @"group.net.MyApp"];
     [[IndigitallLib sharedInstance] initializeWithAppToken:@"APP_TOKEN" thirdPartyApps:YES];
     [IndigitallLib sharedInstance].delegate = self;

     return YES;
 }
       


  func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {

      IndigitallLib.sharedInstance().setGroupName("group.net.indigitall")
      IndigitallLib.sharedInstance().initialize(withAppToken:"APP_TOKEN", thirdPartyApps:true)
      IndigitallLib.sharedInstance().delegate = self
      return true
  }
      
  • En el fichero *-Info.plist:Añadir una clave nueva clave LSApplicationQueriesSchemes de tipo Array con los Strings de las app que se quieran chequear en el servicio. Con el array indicamos cuales serán las aplicaciones que deseamos que el usuario tenga instaladas para realizar el envío de pushes. Los strings que queremos

    El archivo *Info.plist quedaría de la siguiente manera si por ejemplo quisieramos chequear como externalApps Facebook:

    ...
    <key>LSApplicationQueriesSchemes</key>
    <array>
        <string>fb</string>
    </array>
    ...
  • Tener definido en el panel la URL scheme de la aplicación que se desea chequear.

3.8 Recoger DeviceID

Cuando hablamos de DeviceID, nos referimos al identificador único que la librería de indigitall genera para identificar los dispositivos y poder enviarles mensajes push. Este ejemplo indica cómo recoger este dato para poder trabajar con él.



       NSString * deviceID = [IndigitallLib getDeviceID];
       [self sendToYourBackend:deviceID];

       


       var deviceID = IndigitallLib.getDeviceID()
       self.sendToYourBackend(deviceID)

      

4 Actualizaciones en la implementación

4.1 Cómo actualizar a la versión 3.3 desde versiones anteriores del SDK

Para llevar a cabo la actualización a la versión 3.3 del SDK:

4.2 Cambio en los permisos de Localización

Para dar soporte a las pushes geolocalizadas en iOS11 es necesario añadir una etiqueta "Privacy - Location Always and When In Use Usage Description" en el fichero *-Info.plist. De forma que el archivo anterior queda configurado como se muestra en el punto 3.3 de la documentación: Geofences y push geolocalizadas

4.3 Cambios en el AppDelegate

Para poder recibir notificaciones con la aplicación en primer plano es necesario realizar una serie de cambios en el archivo AppDelegate.m:

  • Hacer que el AppDelegate implemente el delegado de indigitall, IndigitallDelegate:


    AppDelegate () <UNUserNotificationCenterDelegate, IndigitallDelegat>

       


    class AppDelegate: UIResponder, UIApplicationDelegate, IndigitallDelegate, UNUserNotificationCenterDelegate {

      
  • Asignar el IndigitallDelegate después de la inicialización de la librería:


   - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{
        ...
        [[IndigitallLib sharedInstance] initializeWithAppToken:@"APP_TOKEN" thirdPartyApps:NO];
        [IndigitallLib sharedInstance].delegate = self;
        ...
     }

     


   func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {

      ...
       IndigitallLib.sharedInstance().initialize(withAppToken:"APP_TOKEN", thirdPartyApps:false)
       IndigitallLib.sharedInstance().delegate = self
       ...
   }

    
  • Añadir el método que gestiona las notificaciones, en este método se debe sobreescribir con la acción que debe realizarse cuando se recibe la notificación de tipo 'Abrir App'.


       -(void)manageINPushNotification:(INPushNotification *)notification{

           //Do something

       }

       


       func manage(_ notification: INPushNotification!) {

         //Do something

       }

      

4.4 Añadir el App Group

En esta versión se han introducido una serie de cambios para poder realizar un mejor seguimiento de la recepción y envío de pushes y en consecuencia de las estadísticas. Estos cambios afectan a la configuración del NSE y a las Capabilities de la app:

  1. Cambios en las Capabilities de la app:

    • Crear un App Group para la aplicación desde la consola de Apple del tipo "group.net.MyApp".

    • Activar "App Group" en las Capabilities de la app y seleccionar el group creado en el paso anterior.

    Nota: Las Capabilities de la app deben quedar configuradas como se indica en el punto 2.2 de la documentación: Configuración de Capabilities

  2. Cambios en el NSE:

    • Añadir en las Capabilites del NSE el App Group creado previamente en la consola de Apple y que se añadio también a las Capabilities de la app.

    • Setear el group en la variable groupName del archivo NotificationService.m

    Nota: De tal manera que la configuración del NSE debe quedar como se indica en el punto 2.4 de la documentación: Inclusión del Notification Service Extension

  3. Cambios en la inicialización de la librería:

    • Es necesario setear el App group mediante el método setGroupName antes de inicializar la librería como se indica a continuación:


       - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {

           [[IndigitallLib sharedInstance] setGroupName: @"group.net.MyApp"];
           ...

           return YES;
       }

       


       func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {

        IndigitallLib.sharedInstance().setGroupName("group.net.indigitall")
        ...

        return true;
        }

      

Debido a esto, la inicialización de la librería debe realizarse como se indica en el punto 3.1 de la documentación: Inicialización de la librería

4.5 Opción de activar y desactivar localización

En esta versión se ha añadido la opción de activar/desactivar el envío de localización del dispositivo. Para ello se han creado tres métodos:

  • Para comprobar el estado de la localización:


         (BOOL) checkLocationStatus()

       


          func checkLocationStatus()-> Bool

      
  • Para activar la localización:


        (void) enableLocation()

       


        func enableLocation()

      
  • Para desactivar la localización:


         (void) disableLocation()

       


        func disableLocation()

      

NOTA IMPORTANTE: Para poder hacer uso de estos tres métodos es necesario haber inicializado la librería previamente.

Toda la información relativa a éstos tres métodos esta reflejada en el punto 3.4 de la documentación: Funciones disponibles de la librería

4.6 Añadido bloque de sincronización con el registro

Se ha añadido un método en la librería que permite un handler como parámetro de entrada. Este handler salta cuando el dispositivo ha finalizado el registro en nuestro sistema, proporcionando un punto seguro a partir del cual el usuario puede hacer peticiones.

Para ver como implementar esta funcinalidad, debe consultar el punto 3.4 de la documentación: Sincronización con el registro del dispositivo

4.7 Añadida posibilidad de capturar la descripción de Campaña

Se ha añadido la posibilidad de capturar la descripción de Campaña que se envía en el push. A continuación podemos ver un ejemplo de como capturar este dato, desde la función del AppDelegate que gestiona las notificaciones de tipo Abrir ApP:


         -(void)manageINPushNotification:(INPushNotification *)notification{

           NSString* descCampaign = notification.descCampaign;
        }

         

        func manage(_ notification: INPushNotification!) {

          NSString* descCampaign = notification.descCampaign;
        }
        

Todos los datos de la push vienen especificados en el punto 3.6 de la documentación: Mensajes push

5. F.A.Q

  • Q: No llegan las notificaciones ¿Qué puedo hacer? A: Busque en logs el siguiente mensaje “Device Token: {identificador}”. Si este mensaje llega es porque el registro de notificaciones se está efectuando correctamente. Si aún así no recibe notificaciones, revise su “App Token” y compruebe que sean correctos. Revise también que los certificados enviados al equipo de indigitall sean correctos.

  • Q: ¿A qué versiones de iOS da soporte indigitall? A: La librería de indigitall se compila con deploymentTarget 8, por tanto la versión mínima a la que da soporte es la iOS 8, aunque no recibirá fotos en versiones inferiores a iOS 10 y no recibirá interactivas en versiones inferiores a iOS 8.

  • Q: La imagen me llega pequeña, ¿hay forma de arreglar esto?
  • A: Las notificaciones con foto en iOS 10 se muestran como un cuadrado pequeño abajo a la derecha en dispositivos anteriores a iPhone 6. En cambio para iPhone 6 y posteriores la imagen puede verse en grande dándole a la opción “Ver” o con una pulsación profunda si el dispositivo dispone de 3D Touch.

  • Q: No me llegan las notificaciones Geolocalizadas ¿cómo puedo arreglarlo?
  • A: Revise que tiene habilitada la geolocalización en el dispositivo y los permisos concedidos. Abra la app y busque los logs correspondientes a “INDIGITALL_LOCATION”, en ellos podrá ver cómo cambia la localización y si esta es significativa. Hablamos de cambios significativos en la localización cuando el dispositivo se mueve más de 500 m (Apple estipula que esta es una distancia significativa) de la última posición conocida.

  • Q: ¿Es obligatorio que pida permisos de localización a mis usuarios??
  • A: El permiso de localización es opcional, puedo no solicitar permiso de localización. En estos casos se pierden algunas funcionalidades relacionadas con estos permisos, como pueden ser las notificaciones Geolocalizadas y Geofencing o las notificaciones de tipo Click to Call.

  • Q: Mis notificaciones no se posicionan las primeras ¿Cómo hago que esto ocurra?
  • A: Las notificaciones de iOS son gestionadas por el Sistema Operativo y no se puede establecer una prioridad para ellas. De esta forma, la notificación que llegue última será la que aparezca más arriba en el listado de notificaciones.

  • Q: ¿Cómo hago pruebas en desarrollo sin afectar a los usuarios de producción?
  • A: Los “App Token” de la aplicación de desarrollo y la de producción son distintos, esto es así para evitar que puedan llegarle a usuarios de producción notificaciones creadas en desarrollo. Por este motivo las pruebas en desarrollo no conllevan ningún riesgo. Aun así, siempre puede filtrar en el panel de indigitall por DeviceID creando y subiendo un .csv que contenga los identificadores de los dispositivos a los que quiere que llegue la notificación.

  • Q: ¿Cómo hago pruebas en producción sin afectar a los usuarios?
  • A: Las pruebas en producción son muy sensibles, ya que cometer un fallo aquí puede hacer que nuestra notificación llegue a usuarios reales. Por este motivo aconsejamos que a la hora de hacer pruebas en producción se hagan envíos geolocalizados o que se filtre por DeviceID como se explica en el caso anterior.

6. Contacto

En indigitall estamos encantados de ayudarle con cualquier duda o problema que le surja al integrar nuestra solución. Para contactar con nosotros puede escribirnos a soporte@indigitall.net​. Nos pondremos en contacto con usted lo antes posible.