guía avanzada para configurar el SDK de iOS
En esta sección encontrarás una serie de funcionalidades más avanzadas y que requieren de un desarrollo más complejo. Aconsejamos que sea un desarrollador el encargado de esta configuración.
El SDK de indigitall puede gestionar la localización del usuario. Esto te permite usar los filtros de localización en la pantalla de enviar campaña push (Campañas>Push>Nueva campaña push>Filtros>Filtros geográficos)
Una vez hayamos habilitado esta funcionalidad, el usuario final tendrá que dar su consentimiento al permiso de localización y habilitar los servicios de localización de su smartphone, para que la aplicación obtenga la ubicación exacta del usuario.
Añade las siguientes claves en el archivo Info.plist de la aplicación.
<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
<string>Can we always use your location?</string>
<key>NSLocationAlwaysUsageDescription</key>
<string>Can we always use your location?</string>
<key>NSLocationWhenInUseUsageDescription</key>
<string>Can we use your location when using the apps?</string>
Las claves NSLocationAlwaysUsageDescription, NSLocationWhenInUseUsageDescription y NSLocationAlwaysAndWhenInUseUsageDescription se pueden personalizar editando el contenido de la etiqueta
Hay dos modos de gestionar los permisos de localización:
A continuación te explicamos cómo configurar los permisos de localización en modo automático.
Hay que añadir el parámetro locationPermissionMode cuando se inicialice el SDK. Esto se hace mediante el siguiente extracto de código:
let config = INConfig(appKey: "<YOUR-APP-KEY>")
config.locationPermissionMode = .automatic
Indigitall.initialize(with: config, onIndigitallInitialized: nil, onErrorInitialized: nil);INConfig *config;
config.appKey = @"<YOUR-APP-KEY>";
config.locationPermissionMode = PermissionModeAutomatic;
[Indigitall initializeWithConfig:config onIndigitallInitialized:nil onErrorInitialized:nil];Puedes asociar tu propio ID a cada dispositivo. De esta forma te será más sencillo e intuitivo trabajar con nuestra herramienta. Por ejemplo:
Para realizar esta asociación entre tu ID personalizado (externalId), y el identificador que maneja indigitall (deviceId), hay que invocar el método setExternalCode:
//Recuerda poner aquí tu código externo
Indigitall.setExternalCode("", onSuccess: { (device) in
//DO SOMETHING
}) { (error) in
//LOG ERROR
}//Recuerda poner aquí tu código externo
[IndigitallObjc setExternalCodeWithCode:@"YOUR_EXTERNAL_ID"
success:^(INDevice *device) {
//DO SOMETHING
} failed:^(INError* error){
//LOG ERROR
}];No te preocupes por nada. Tus IDs se cifran de forma irreversible en el propio teléfono y se mandan de forma segura a nuestros servidores. Ni siquiera el equipo de indigitall puede conocer esta información.
Si se requiere recoger la información de la WiFi del usuario, además de la configuración del panel de Indigitall, deberás añadir en las opciones del proyecto, en Signing & Capabilities la opción Access WiFi Information:
Y añadir el parámetro wifiFilterEnabled cuando se inicialice el SDK:
let config = INConfig(appKey: "<YOUR-APP-KEY>")
config.wifiFilterEnabled = true
Indigitall.initialize(with: config, onIndigitallInitialized: nil, onErrorInitialized: nil);INConfig *config;
config.appKey = @"<YOUR-APP-KEY>";
config.wifiFilterEnabled = true
[Indigitall initializeWithConfig:config onIndigitallInitialized:nil onErrorInitialized:nil];El permiso de localización debe ser aceptado por el usuario
Nuestro SDK ofrece diversos callbacks que te ayudan tener mayor control del flujo de ejecución y a implementar comportamientos personalizados.
Para suscribirte a estos callbacks tienes que:
Indigitall.initialize(withAppKey: "<YOUR_APP_KEY>", onIndigitallInitialized: { (permissions, device) in
//DO SOMETHING
}) { (error) in
//LOG ERROR
}[Indigitall initializeWithAppKey:@"<YOUR_APP_KEY>" onIndigitallInitialized:^(NSArray<INPermissions *> * _Nonnull permissions, INDevice * _Nonnull device) {
//DO SOMETHING
} onErrorInitialized:^(INError * _Nonnull onError) {
//LOG ERROR
}];Si eres CLIENTE ENTERPRISE tienes que añadir este parámetro en la configuración para que la SDK apunte al entorno correcto:
let config = INConfig(appKey: "<YOUR-APP-KEY>")
config.domain = "YOUR_DEVICE_API_DOMAIN"
config.domainInApp = "YOUR_INAPP_API_DOMAIN"
config.domainInbox = "YOUR_INBOX_API_DOMAIN"
Indigitall.initialize(with: config, onIndigitallInitialized: nil, onErrorInitialized: nil);INConfig *config = [[INConfig alloc]initWithAppKey:@"<YOUR-APP-KEY>"];
config.domain = "YOUR_DEVICE_API_DOMAIN"
config.domainInApp = "YOUR_INAPP_API_DOMAIN"
config.domainInbox = "YOUR_INBOX_API_DOMAIN"
[Indigitall initializeWithConfig:config onIndigitallInitialized:nil onErrorInitialized:nil];El método onIndigitallInitialized se ejecutará cuando el SDK termine de inicializarse y el dispositivo esté preparado para recibir notificaciones de indigitall.
Recibe como parámetro:
A continuación te mostramos un elemento que imprime logs sobre el estado de los permisos y la información del dispositivo.
Indigitall.initialize(appKey: "<YOUR_APP_KEY>",
onIndigitallInitialized: { (permission, device) in
print("onIndigitallInitialized Push \(permissions[0].permissionType) permission: \(permissions[0].permissionStatus)")
print("onIndigitallInitialized Location \(permissions[0].permissionType) permission: \(permissions[1].permissionStatus)")
print("onIndigitallInitialized DEVICE: \(device.deviceID )")
}, onErrorInitialized: { (error) in
//LOG ERROR
}[Indigitall initializeWithAppKey:@"<YOUR_APP_KEY>" onIndigitallInitialized:^(NSArray<INPermissions *> * _Nonnull permissions, INDevice * _Nonnull device) {
NSLog(@"onIndigitallInitialized Device: %@",device.deviceID);
NSLog(@"onIndigitallInitialized Permission push: %u : %u", permissions[0].permissionType, permissions[0].permissionStatus );
NSLog(@"onIndigitallInitialized Permission location: %u: %u",permissions[1].permissionType, permissions[1].permissionType)
} onErrorInitialized:^(INError * _Nonnull onError) {
//LOG ERROR
}];El método onNewUserRegistered se ejecutará cuando el dispositivo se le ha asignado el push token para recibir notificaciones, es decir, en la primera ejecución de la app tras ser instalada y al haber aceptado permisos. Éste va definido en el AppDelegate como callback de la llamada al setDeviceToken descrito anteriormente
Recibe como parámetro el objeto Device con la información asociada al dispositivo.
Indigitall.setDeviceToken(deviceToken) { (token) in
print("NewUserRegistered: \(token)")
}[Indigitall setDeviceToken:deviceToken onNewUserRegistered:^(INDevice * _Nonnull device) {
NSLog(@"Device: %@",device);
}];El método onErrorInitialized se ejecutará sólo si se produce un error durante la incialización del SDK.
Recibe como parámetro la descripción del error.
Indigitall.initialize(appKey: "<YOUR_APP_KEY>",
onIndigitallInitialized: { (permission, device) in
//DO SOMETHING
}, onErrorInitialized: { (error) in
print("ERROR: \(error.message)")
}[Indigitall initializeWithAppKey:@"<YOUR_APP_KEY>" onIndigitallInitialized:^(NSArray<INPermissions *> * _Nonnull permissions, INDevice * _Nonnull device) {
//DO SOMETHING
} onErrorInitialized:^(INError * _Nonnull onError) {
NSLog(@"Error Initialized: %@",onError);
}];Puedes usar el método getDevice para obtener la información que ha registrado el SDK en referencia al dispositivo.
El callback de este método recibirá como parámetro el objeto device que contiene toda la información asociada al dispositivo.
Indigitall.getDeviceWith(onSuccess: { (device) in
print("Device: \(device.deviceID ?? "")\nStatus: \(device.enabled ?? false)")
}, onError: { (error) in
print("Error: \(error.message)")
})[Indigitall getDeviceWithOnSuccess:^(INDevice * _Nonnull device) {
NSLog(@"DEVICE: %@ \nStatus: %d", device.deviceID, device.enabled);
} onError:^(INError * _Nonnull error) {
NSLog(@"ERROR: %@", error.message);
}];Puedes elegir deshabilitar el dispositivo para bloquear la recepción de notificaciones. Es un método muy útil para:
Para ello, dispones de los métodos enableDevice y disableDevice.
El callback de estos métodos recibirá como parámetro el objeto device que contiene toda la información asociada al dispositivo.
Indigitall.enableDeviceWith(onSuccess: { (device) in
print("Device: \(device.deviceID ?? "")\nStatus: \(device.enabled ?? false)")
}, onError: { (error) in
print("Error: \(error.message)")
})
Indigitall.disableDeviceWith(onSuccess: { (device) in
print("Device: \(device.deviceID ?? "")\nStatus: \(device.enabled ?? false)")
}) { (error) in
print("Error: \(error.message)")
}[Indigitall enableDeviceWithOnSuccess:^(INDevice * _Nonnull device) {
NSLog(@"Device: %@ \nStatus: %d",device.deviceID,device.enabled);
} onError:^(INError * _Nonnull error) {
NSLog(@"ERROR: %@", error.message);
}];
[Indigitall disableDeviceWithOnSuccess:^(INDevice * _Nonnull device) {
NSLog(@"Device: %@ \nStatus: %d",device.deviceID,device.enabled);
} onError:^(INError * _Nonnull error) {
NSLog(@"ERROR: %@", error.message);
}];Nuestro SDK te permite clasificar a los usuarios en diferentes grupos personalizables. Esto es muy útil para:
Recuerda que primero debes definir los grupos con los que quieres trabajar en la consola de indigitall (Herramientas > Grupos de interés). Consulta nuestro manual de usuario para más info.
Usa el método topicsList para obtener la lista de grupos que están configurados en tu proyecto de indigitall. El callback de este método recibe como parámetro un array de INTopics, que contiene la información de todos los grupos disponibles, además de un flag que indica si el usuario está incluido en alguno de ellos.
Indigitall.topicsListWith(onSuccess: { (topics) in
print("TOPICS: \(topics)")
}) { (error) in
print("Error: \(error.message)")
}[Indigitall topicsListWithOnSuccess:^(NSArray<INTopic *> * _Nonnull topics) {
NSLog(@"TOPICS: %@",topics);
} onError:^(INError * _Nonnull error) {
NSLog(@"ERROR: %@", error.message);
}];Para gestionar la suscripción del dispositivo a uno o varios grupos, existen dos métodos: subscribe y unsubscribe.
Opcionalmente ambos reciben un objeto TopicsCallback como tercer parámetro, que devolverá el listado de todos los Topic del proyecto.
Indigitall.topicsSubscribe(withTopic: [Topic.code, Topic.code], onSuccess: { (topics) in
self?.topics = topics
}) { (error) in
print(error.message)
}
Indigitall.topicsUnSubscribe(withTopic: [Topic.code, Topic.code], onSuccess: { (topics) in
self?.topics = topics
}) { (error) in
print(error.message)
}[Indigitall topicsSubscribeWithTopic:@[Topic[0], Topic[1]] onSuccess:^(NSArray<INTopic *> * _Nonnull topics) {
topics = topics.self;
} onError:^(INError * _Nonnull error) {
NSLog(@"ERROR: %@", error.message);
}];
[Indigitall topicsUnSubscribeWithTopic:@[Topic[0], Topic[1]] onSuccess:^(NSArray<INTopic *> * _Nonnull topics) {
topics = topics.self;
} onError:^(INError * _Nonnull error) {
NSLog(@"ERROR: %@", error.message);
}];Tu app puede mandar información a los servidores de indigitall para identificar las acciones y eventos que suceden en ella. Esto te permite automatizar acciones de retargeting.
Para registrar estos eventos hay que llamar al método sendCustomEvent, pasando como parámetro un ID descriptivo (puedes inventarte el que más te guste) y añadir los datos que necesites.
Indigitall.sendCustomEvent("YOUR_CUSTOM_EVENT", customData: []) {
//Do something in success function
} onError: { (error) in
//ERROR DO SOMETHING
}
[Indigitall sendCustomEvent:@"YOUR_CUSTOM_EVENT" customData:@[] onSuccess:^{
// Do something in success function
} onError:^(INError * _Nonnull error) {
//ERROR DO SOMETHING
}];Si quieres integrar los mensajes In-App en tu aplicación, puedes hacerlo con varios formatos complementarios:
A continuación te contamos como instanciar uno o varios mensajes In-App en formato banner.
Recuerda que primero deberías tenerlos definidos en la consola de indigitall. Consulta nuestro manual de usuario para más info.
Crea una vista de UIView en tu storyboard. El tamaño debe coincidir con el que hayas definido en la consola de indigitall (Herramientas > Esquemas In-App/In-Web). Recuerda traducir las unidades de PX a iOS points.
@IBOutlet weak var myBanner: UIView!@property (weak, nonatomic) IBOutlet UIView *myBanner;Instancia los mensajes In-App usando el método showInApp.
Indigitall.show(inApp: "myBanner_CODE", view: myBanner, success: { (inAppView) in
//DO SOMETHING
}, failed: { (error) in
// LOG ERROR
}, didTouch: {
print("Did touch")
}, onShowTimeFinished: { (inApp, showTime) in
//DO SOMETHING
})[Indigitall showInApp:"" view:<#(nonnull UIView *)#> success:^(INInApp * _Nonnull) {
// DO SOMETHING
} failed:^(INError * _Nonnull error) {
// LOG ERROR
} didTouch:^{
// DO SOMETHING
} oShowTimeFinished:^(INInApp *inApp, int showTime){
// DO SOMETHING
}];Crea varias vistas de UIView en tu storyboard. El tamaño debe coincidir con el que hayas definido en la consola de indigitall (Herramientas > Esquemas In-App/In-Web). Recuerda traducir las unidades de PX a iOS points.
@IBOutlet weak var viewBanner: UIView!
@IBOutlet weak var viewBannerTwo: UIView!
@IBOutlet weak var viewBannerThree: UIView!
...
@property (weak, nonatomic) IBOutlet UIView *viewBanner;
@property (weak, nonatomic) IBOutlet UIView *viewBannerTwo;
@property (weak, nonatomic) IBOutlet UIView *viewBannerThree;
...Crea un array de las vistas y de los códigos de los inApp que defines en la consola e instancia los mensajes In-App usando el método showMultipleInApp.
var viewList = [UIView]()
viewList.append(viewBanner)
viewList.append(viewBannerTwo)
viewList.append(viewBannerThree)
var webViewCodes = [String]()
webViewCodes.append("myInApp_code_banner")
webViewCodes.append("myInApp_code_banner_two")
webViewCodes.append("myInApp_code_banner_three")
Indigitall.showMultiple(inApp: webViewCodes, listView: viewList, success: { (inApp, view) in
//DO SOMETHING
}, failed: { (error) in
// LOG ERROR
}, didTouch: { (inApp, view) in
//DO SOMETHING
}, didDismissed: { (inApp, view) in
//DO SOMETHING
}, onShowTimeFinished: {(inApp, view, showTime) in
// DO SOMETHING
})
NSMutableArray <UIView *> *viewList;
[viewList addObject:yourCustomView];
[viewList addObject:yourCustomViewTwo];
[viewList addObject:yourCustomViewThree];
NSMutableArray <NSString *> *webViewCodes;
[webViewCodes addObject:@"myInApp_code_banner"];
[webViewCodes addObject:@"myInApp_code_banner_two"];
[webViewCodes addObject:@"myInApp_code_banner_three"];
[Indigitall showMultipleInApp:webViewCodes listView:viewList success:^(INInApp * _Nonnull, UIView *view) {
//DO SOMETHING
} failed:^(INError * _Nonnull error) {
// LOG ERROR
} didTouch:^(INInApp *inApp, UIView *view){
//DO SOMETHING
} didDismissed:^(INInApp *inApp, UIView *view){
//DO SOMETHING
} onShowTimeFinished:^(INInApp *inApp, UIView *view, int showTime){
// DO SOMETHING
}];A continuación te contamos como instanciar un mensaje In-App en formato popup.
Recuerda que primero deberías tenerlo definido en la consola de indigitall. Consulta nuestro manual de usuario para más info.
Crea una vista de WebView en tus layouts. El tamaño debe coincidir con el que hayas definido en la consola de indigitall (Herramientas > Esquemas In-App/In-Web). Recuerda traducir las unidades de PX a iOS points.
Indigitall.showPopup("myInApp_code_popup", didAppear: {
// DO SOMETHING
}, didCancel: {
// DO SOMETHING
}, didClicked: {
// DO SOMETHING
}, didDismissed: {
// DO SOMETHING
},onShowTimeFinished: {(inApp, showTime) in
// DO SOMETHING
}) { (error) in
// LOG ERROR
}[Indigitall showPopup:@"myInApp_code_popup-Inapp" didAppear:^{
// DO SOMETHING
} didCancel:^{
// DO SOMETHING
} didClicked:^{
// DO SOMETHING
} didDismissed:^{
// DO SOMETHING
} onShowTimeFinished:^(INInApp *inApp, int showTime){
// DO SOMETHING
} failed:^(INError * _Nonnull error) {
// LOG ERROR
}];Si quieres personalizar el icono de cerrar el Popup, puedes hacerlo con el siguiente método al que le podrás pasar un UIButton personalizado, si quisieras usar nuestro icono, bastaría con pasar un null. El parámetro closeIconDisabled es por si no quieres mostrar ningún icono, definiendo éste a true para ocultarlo o false para mostrarlo.
let closeButton = UIButton()
.
.//set UIButton params
.
Indigitall.showPopup("Interstitial", closeIcon: closeButton, closeIconDisabled: false, didAppear: {
print("Did appear")
}, didCancel: {
print("Did cancel")
}, didClicked: {
print("Did Clicked")
}, didDismissed: {
print("Did Dismissed")
}, onShowTimeFinished: {(inApp, showTime) in
print("Did onShowTimeFinished")
}) { (error) in
print("ERROR: \(error.message)")
}
[Indigitall showPopup:@"myInApp_code_popup-Inapp", closeIcon: closeButton, closeIconDisabled: false, didAppear:^{
// DO SOMETHING
} didCancel:^{
// DO SOMETHING
} didClicked:^{
// DO SOMETHING
} didDismissed:^{
// DO SOMETHING
} onShowTimeFinished:^(INInApp *inApp, int showTime){
// DO SOMETHING
} failed:^(INError * _Nonnull error) {
// LOG ERROR
}];En el caso de que quisieras obtener el objeto push de tipo json para realizar comprobaciones o acciones que tu aplicación requiera, te dejamos este código que ayudará a su obtención:
@available(iOS 10.0, *)
func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
Indigitall.handle(with: response ,withCompletionHandler: { (push, action) in
print("Push object:", push)
print("Push action app:", action.app)
})
}
//@DEPRECATED
func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
print("Push notification received: \(userInfo)")
let data = userInfo["data"]
let push = INPush(data as! NSMutableDictionary)
print("Push object : \(push)")
- (void) userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void (^)(void))completionHandler{
[Indigitall handleWithResponse:response withCompletionHandler:^(INPush * _Nonnull push, INPushAction * _Nonnull action) {
NSLog(@"Push object: %@", push);
NSLog(@"Push object app: %@", action.app);
}];
}
//@DEPRECATED
- (void) application:(UIApplication *)application didReceiveRemoteNotification:(nonnull NSDictionary *)userInfo fetchCompletionHandler:(nonnull void (^)(UIBackgroundFetchResult))completionHandler{
NSLog(@"Push notification received: %@", userInfo);
NSMutableDictionary *data = userInfo[@"data"];
INPush *push = [[INPush alloc]init:data];
NSLog(@"Push object: %@",push);
}Si se decide por tratar la acción de la Push de manera independiente sin pasar por nuestra SDK, una vez recogida la push como explicamos en el apartado anterior, en el método userNotificationCenter:didReceive del propio AppDelegate, para poder registrar las estadísticas hay que añadir el siguiente método:
Indigitall.registerStatistics(response)[Indigitall registesStatistics: response];En esta sección encontrarás una serie de funcionalidades más avanzadas y que requieren de un desarrollo más complejo. Aconsejamos que sea un desarrollador el encargado de esta configuración.
Para poder obtener las notificaciones del Inbox de Indigitall, el usuario debe identificarse. Primero hay que inicializar la SDK de Indigitall para que genere nuestro identificador (deviceId) y poder asociarlo al ID personalizado que asocies a dispositivo, similar a como se explica aquí.
Para realizar las tareas de registro, se usan estos dos métodos:
//Identificación de usuario
Indigitall.logIn(withId: "YOUR_ID", onSuccess: { (device) in
//DO SOMETHING
}) { (error) in
//LOG ERROR
}
//Desconexión
Indigitall.logOut(success: { (device) in
//DO SOMETHING
}, onError: { (error) in
//LOG ERROR
})
//Identificación de usuario
[Indigitall logInWithId:"YOUR_ID" onSuccess:^(INDevice * _Nonnull device) {
//DO SOMETHING
} onError:^(INError * _Nonnull error) {
//LOG ERROR
}];
//Desconexión
[Indigitall logOutWithSuccess:^(INDevice * _Nonnull device) {
//DO SOMETHING
} onError:^(INError * _Nonnull error) {
//LOG ERROR
}];En esta sección verás cómo se genera un token de validación para una aplicación que tenga configurado una autentificación con webhook. Para generar dicho token, se necesita añadir el JSON con la configuración.
El token tiene una fecha predeterminada de caducidad, una vez caducado en nuestro sistema, se lanzará un evento de tipo 'Protocol', que indicará dicha caducidad y tendrá que devolvernos el JSON de configuración. Para recoger el evento, hay que implementarlo en la clase correspondiente, y sobreescribir el siguiente método:
class YOURCLASS: GetAuthConfig
func getAuthConfig() -> [AnyHashable : Any] {
...
return YOUR_JSON
}
@interface YOURCLASS: NSObject<GetAuthConfig>
- (NSDictionary *) getAuthConfig;
Una vez hecho el registro del dispositivo correctamente, se puede empezar a realizar las peticiones del Inbox. Hay que tener en cuenta las siguientes características del Inbox, que opcionalmente son configurables.
Las notificaciones del Inbox tendrán los siguiente estados de la clase InboxStatus:
Las notificaciones también vendrán con un estado leído o 'read', para ayudar a diferenciar dichos estados.
Cada notificación vendrá asignada con un sendingId entero y único, para poder diferenciarlos y usarlos para algunas de las funcionalidades.
Como se ha explicado anteriormente, para obtener las notificaciones se usa el siguiente método:
Inbox.getInboxWithSuccess({ (inbox) in
//DO SOMETHING
}) { (error) in
//LOG ERROR
}
[Inbox getInboxWithSuccess:^(INInbox * _Nonnull inbox) {
//DO SOMETHING
} onError:^(INError * _Nonnull error) {
//LOG ERROR
}];
Una vez obtenida la instancia Inbox, la usaremos para pedir la siguiente página, que se realizada con el siguiente método, en el caso de que no haya más páginas te lo indicará en el error con el códigoo 410:
inbox.getNextPage(success: { (inbox, newNotifications) in
//DO SOMETHING
}) { (error) in
if (error.statusCode == 410){
//LOG NO HAY MÁS PÁGINAS
}else{
//LOG ERROR
}
}[inbox getNextPageWithSuccess:^(INInbox * _Nonnull inbox, NSArray<INInboxNotification *>* newNotifications) {
//DO SOMETHING
} onError:^(INError * _Nonnull error) {
if (error.statusCode == 410){
//LOG NO HAY MÁS PÁGINAS
}
//LOG ERROR
}];Ten en cuenta que el callback del Inbox a parte de devolver el Inbox actualizado, devuelve un array que se llama newNotifications, en el que se irán las nuevas notificaciones que añadir al Inbox, para que, en caso de ser necesario, poder utilizar dicho array para moverte entre las páginas sin depender de las llamadas al Inbox.
Para obtener la información de una notificación en particular, hay que hacer la siguiente llamada con el sendingId de cada notificación:
inbox.getInfoFromNotification(withSendingId: SENDING_ID, onSuccess: { (inboxnotification) in
//DO SOMETHING
}) { (error) in
//LOG ERROR
}[inbox getInfoFromNotificationWithSendingId:SENDING_ID onSuccess:^(INInboxNotification * _Nonnull inboxNotification) {
//DO SOMETHING
} onError:^(INError * _Nonnull error) {
//LOG ERROR
}];Para editar el estado de una o más notificaciones a la vez, se realiza con el siguiente método en el que se deben indicar los sendingIds de las notificaciones a editar y el estado al que se quiere cambiar:
//Modificar una notificación
inbox.modifyStatusFromNotification(withSendingId: SENDING_ID, status: STATUS, onSuccess: { (inboxnotification) in
//DO SOMETHING
}) { (error) in
//LOG ERROR
}
//Modificar masivamente
inbox.massiveEditNotifications(withSendingIdsList: [SENDING_IDS], status: STATUS, onSuccess: {
//DO SOMETHING
}) { (error) in
//LOG ERROR
}//Modificar una notificación
[inbox modifyStatusFromNotificationWithSendingId:SENDING_ID status:STATUS onSuccess:^(INInboxNotification * _Nonnull inboxNotification) {
//DO SOMETHING
} onError:^(INError * _Nonnull error) {
//LOG ERROR
}];
//Modificar masivamente
[inbox massiveEditNotificationsWithSendingIdsList:[SENDING_IDS] status:STATUS onSuccess:^{
//DO SOMETHING
} onError:^(INError * _Nonnull error) {
//LOG ERROR
}];Para saber el número de notificaciones que hay en el Inbox según su estado, se reliza este método:
Inbox.getMessagesCount(success: { (counter) in
//DO SOMETHING
}) { (error) in
//LOG ERROR
}
[Inbox getMessagesCountWithSuccess:^(INInboxCounters * _Nonnull counters) {
//DO SOMETHING
} onError:^(INError * _Nonnull error) {
//LOG ERROR
}];