guía avanzada para configurar el SDK de Xamarin
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 los permisos de localización incluyendo esta línea en el archivo AndroidManifest.xml dentro de la carpeta Properties del proyecto de android:
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />Hay que añadir el parámetro RequestLocationPermission cuando se inicialice el SDK en el caso de usar Xamarin.Forms y marcar con el flag de requestPermissionLocation, en el caso de usar Xamarin Classics sólamente hay que añadir el flag de requestPermissionLocation. Esto se hace mediante el siguiente extracto de código:
//Xamarin.Forms
//Cuando quieres inicializar indigitall en el proyecto iOS
global::Xamarin.Forms.Forms.Init(this, bundle);
DependencyService.Register<Com.Indigitall.Xamarin.Android.Indigitall>();
Com.Indigitall.Xamarin.Android.Utils.PermissionUtils.RequestLocationPermission(this);
// otra forma de pdefinir el setdefault: this.ComponentName.ClassName
var app = new App();
LoadApplication(app);
...
public override void OnRequestPermissionsResult(int requestCode, string[] permissions, [GeneratedEnum] Permission[] grantResults)
{
base.OnRequestPermissionsResult(requestCode, permissions, grantResults);
Com.Indigitall.Xamarin.Android.Utils.PermissionUtils.OnRequestPermissionResult(this, requestCode, permissions, grantResults);
}
------------
//Inicializar el proyecto
var indigitall = DependencyService.Get<IIndigitall>();
if (indigitall != null)
{
indigitall.Init("YOUR_APPKEY", "YOUR_SENDERID", true);
}
------------
//Xamarin Classics
Com.Indigitall.Xamarin.Android.Indigitall indigitall = new Com.Indigitall.Xamarin.Android.Indigitall();
indigitall.Init("YOUR_APPKEY", "YOUR_SENDERID", true);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>
<key>UIBackgroundModes</key>
<array>
<string>location</string>
<string>remote-notification</string>
</array>
Las claves NSLocationAlwaysUsageDescription, NSLocationWhenInUseUsageDescription y NSLocationAlwaysAndWhenInUseUsageDescription se pueden personalizar editando el contenido de la etiqueta < string >.
Añade el siguiente código en el AppDelegate dentro del método FinishedLaunching
DependencyService.Register<Com.Indigitall.Xamarin.iOS.Indigitall>();
if (UIDevice.CurrentDevice.CheckSystemVersion(10, 0))
{
// iOS 10 or later
var authOptions = UNAuthorizationOptions.Alert | UNAuthorizationOptions.Badge | UNAuthorizationOptions.Sound;
UNUserNotificationCenter.Current.RequestAuthorization(authOptions, (granted, error) =>
{
if (granted)
{
InvokeOnMainThread(() =>
{
UIApplication.SharedApplication.RegisterForRemoteNotifications();
});
}
});
// For iOS 10 display notification (sent via APNS)
UNUserNotificationCenter.Current.Delegate = new Com.Indigitall.Xamarin.iOS.UserNotificationCenterDelegate();
}
else
{
// iOS 9 or before
var allNotificationTypes = UIUserNotificationType.Alert | UIUserNotificationType.Badge | UIUserNotificationType.Sound;
var settings = UIUserNotificationSettings.GetSettingsForTypes(allNotificationTypes, null);
UIApplication.SharedApplication.RegisterUserNotificationSettings(settings);
}
La Activity por defecto es la pantalla inicial de tu app que se lanza cuando un usuario pulsa en una notificación que no lleva deeplink. También es el punto donde debes inicializar el SDK. Se establece mediante el parámetro DefaultActivity:
//Cuando quieres iniciar indigitall
Com.Indigitall.Android.Indigitall.SetDefaultActivity(this, Java.Lang.Class.FromType(typeof("YOUR_ACTIVITY")).Name);
//o también
Com.Indigitall.Xamarin.Models.IConfiguration config = new Com.Indigitall.Xamarin.Models.IConfiguration();
config.appKey = "<YOUR-APP-KEY>";
config.senderId = "<YOUR-SENDER-ID>";
config.defaultActivity = Java.Lang.Class.FromType(typeof(MainActivity)).Name;
indigitall.Init(config)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("YOUR_EXTERNAL_CODE", (device) =>
{
//Log device
}, (code, message) =>
{
Console.WriteLine("SetExternalCode.iOS error code:" + code + " message: " + message);
});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 el parámetro wifiFilterEnabled cuando se inicialice el SDK:
indigitall.Init("YOUR APPKEY", "YOUR SENDER ID", requestLocation: true, wifiFilterEnabled: true)
//o también
Com.Indigitall.Xamarin.Models.IConfiguration config = new Com.Indigitall.Xamarin.Models.IConfiguration();
config.appKey = "<YOUR-APP-KEY>";
config.senderId = "<YOUR-SENDER-ID>";
config.requestLocation = true;
config.wifiFilterEnabled = true;
config.layoutBasic = Com.Indigitall.Xamarin.Models.Layoutbasic.Custom;
indigitall.Init(config)El permiso de localización debe ser aceptado por el usuario
Para poder obtener la información de la wifi en adroid se necesitan los siguientes permisos y servicios declarados en el manifest:
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION"/>
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
// ANDROID 12 WIFI
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
//Servicio WiFi
<service
android:name="com.indigitall.android.services.WifiStatusService"
android:permission="android.permission.BIND_JOB_SERVICE" >
</service>
<receiver android:name="com.indigitall.android.receivers.WifiWakeLockReceiver">
<intent-filter>
<action android:name="AlarmReceiver.Action.NETWORK_ALARM" />
</intent-filter>
</receiver>Así mismo, deberás añadir en las opciones del proyecto en Xcode, en Signing & Capabilities la opción Access WiFi Information:
Si por alguna razón no se desea mostrar la push como la muestra android nativo, dejamos esta opción para mostrar la push con nuestro layout custom. Para ello añade el siguiente código en la llamada al init:
indigitall.Init("YOUR APPKEY", "YOUR SENDER ID", requestLocation: true, wifiFilterEnabled: true, customBasic: "custom")
//o también
Com.Indigitall.Xamarin.Models.IConfiguration config = new Com.Indigitall.Xamarin.Models.IConfiguration();
config.appKey = "<YOUR-APP-KEY>";
config.senderId = "<YOUR-SENDER-ID>";
config.logDebug = false;
config.layoutBasic = Com.Indigitall.Xamarin.Models.Layoutbasic.Custom;
indigitall.Init(config);
Si eres CLIENTE ENTERPRISE tienes que añadir este parámetro en la configuración para que la SDK apunte al entorno correcto:
//Cuando quieres iniciar indigitall
Com.Indigitall.Xamarin.Models.IConfiguration config = new Com.Indigitall.Xamarin.Models.IConfiguration();
config.appKey = "<YOUR-APP-KEY>";
config.senderId = "<YOUR-SENDER-ID>";
config.urlDeviceApi = "YOUR_DEVICE_API_DOMAIN";
config.urlInAppApi = "YOUR_INAPP_API_DOMAIN";
indigitall.Init(config);
Nuestro SDK ofrece diversos callbacks que te ayudan tener mayor control del flujo de ejecución y a implementar comportamientos personalizados.
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 ejemplo que imprime logs sobre el estado de los permisos y la información del dispositivo.
var indigitall = DependencyService.Get<IIndigitall>();
if (indigitall != null)
{
indigitall.Init("YOUR APPKEY", "YOUR SENDER ID", true, (permissions, device)=>
{
Console.WriteLine("device: " + device.deviceId);
Console.WriteLine("device: " + permissions);
},(device)=>
{
//DO SOMETHING
},(errorCode,errorMessage)=>
{
//DO SOMETHING
});
//o también
Com.Indigitall.Xamarin.Models.IConfiguration config = new Com.Indigitall.Xamarin.Models.IConfiguration();
config.appKey = "<YOUR-APP-KEY>";
config.senderId = "<YOUR-SENDER-ID>";
indigitall.Init(config, (permissions, device) =>
{
Console.WriteLine("device: " + device.deviceId);
Console.WriteLine("device: " + permissions);
}, (device) =>
{
//DO SOMETHING
}, (errorCode,errorMessage) =>
{
//DO SOMETHING
});
/>
### 2.2. Nuevo dispositivo registrado
<br />
El método **onNewUserRegistered** se ejecutará cuando el dispositivo ha sido registrado por primera vez, es decir, en la primera ejecución de la app tras ser instalada.
<br />
Recibe como parámetro el objeto _Device_ con la información asociada al dispositivo.
<br />
```javascript
var indigitall = DependencyService.Get<IIndigitall>();
if (indigitall != null)
{
indigitall.Init("YOUR APPKEY", "YOUR SENDER ID", true, (permissions, device)=>
{
//DO SOMETHING
},(device)=>
{
Console.WriteLine("device: " + device.deviceId);
},(errorCode,errorMessage)=>
{
//DO SOMETHING
});El método onErrorInitialized se ejecutará sólo si se produce un error durante la inicialización del SDK.
Recibe como parámetro la descripción del error.
var indigitall = DependencyService.Get<IIndigitall>();
if (indigitall != null)
{
indigitall.Init("YOUR APPKEY", "YOUR SENDER ID", true, (permissions, device)=>
{
//DO SOMETHING
},(device)=>
{
//DO SOMETHING
},(errorCode,errorMessage)=>
{
Console.WriteLine("ErrorCode: " + errorCode+" Message: "+ errorMessage);
});Puedes usar el método deviceGet para obtener la información que ha registrado el SDK en referencia al dispositivo.
El callback recibirá como parámetro el objeto device que contiene toda la información asociada al dispositivo.
indigitall.DeviceGet((device) =>
{
if (device != null)
{
Console.WriteLine("Device: " + device.deviceId);
}
},(errorCode,errorMessage)=>
{
Console.WriteLine("ErrorCode: " + errorCode+" Message: "+ errorMessage);
});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 deviceEnable y deviceDisable.
El callback recibirá como parámetro el objeto device que contiene toda la información asociada al dispositivo.
indigitall.DeviceEnable((device)=>{
Console.WriteLine("Device: " + device.deviceId);
},(errorCode,errorMessage)=>
{
Console.WriteLine("ErrorCode: " + errorCode+" Message: "+ errorMessage);
});
indigitall.DeviceDisable((device)=>{
Console.WriteLine("Device: " + device.deviceId);
},(errorCode,errorMessage)=>
{
Console.WriteLine("ErrorCode: " + errorCode+" Message: "+ errorMessage);
});
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 Topics, 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.TopicsList((topic) =>
{
//DO SOMETHING
}, (errorCode, messageError) =>
{
//Log error
});Para gestionar la suscripción del dispositivo a uno o varios grupos, existen dos métodos: topicsSubscribe y topicsUnsubscribe.
Opcionalmente ambos reciben un objeto TopicsCallback como tercer parámetro, que devolverá el listado de todos los Topic del proyecto.
//topics typeof string[]
indigitall.TopicsSubscribe(topics, (topic) =>
{
//DO SOMETHING
}, (errorCode, messageError) =>
{
//Log error
});
indigitall.TopicsUnsubscribe(topics }, (topic) =>
{
//DO SOMETHING
}, (errorCode, messageError) =>
{
//Log error
}); 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.
Los datos debes añadirlos en un array del modelo INHashMap como el del ejemplo que se indica a continuación.
Com.Indigitall.Xamarin.Models.INHashMap[] iNHashMap = new Com.Indigitall.Xamarin.Models.INHashMap[2];
iNHashMap[0] = new Com.Indigitall.Xamarin.Models.INHashMap("key1", "value1");
iNHashMap[1] = new Com.Indigitall.Xamarin.Models.INHashMap("key2", "value2");
indigitall.SendCustomEvent("YOUR_CUSTOM_EVENT", iNHashMap, () =>
{
// Do something in success function
}, (ErrorDescription) =>
{
//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.
Definir un hybridWeview en el archivo .xml. 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 _pulgadas.
//160 unidades es 1 pulgada. 64 unidades es 1 cm
<local:HybridWebView x:Name="hybridWebView" InAppId="Billboard" WidthRequest="x" HeightRequest="y"/>Instancia los mensajes In-App usando el método ShowInApp.
indigitall.ShowInApp(webViewHybrid, "INAPP_CODE", (inAppId, webview) =>
{
//DO SOMETHING
},(inAppId, webview, errorMessage)=>
{
//LOG ERROR
}, (inAppCode, webView, showTime) =>
{
//onShowTimeFinished
});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 DP.
<android.webkit.WebView
android:id="@+id/myBanner"
android:layout_width="230dp"
android:layout_height="33.33dp"
/>
<android.webkit.WebView
android:id="@+id/otherBanner"
android:layout_width="250dp"
android:layout_height="36dp"
/>Instancia los mensajes In-App usando el método showInApp.
var myBanner = FindViewById<Android.Webkit.WebView>(Resource.Id.myBanner);
var otherBanner = FindViewById<Android.Webkit.WebView>(Resource.Id.otherBanner);
var views = new List<Android.Webkit.WebView>();
views.Add(myBanner);
views.Add(otherBanner);
var codes = new List<>();
codes.Add("myBanner_CODE");
codes.Add("otherBanner_CODE");
Indigitall.showInApp(getContext(), codes, views, new ShowInAppCallback() {
@Override
public void onLoad(String inAppCode, WebView webView) {
Log.d("InApp loaded: ", inAppCode);
}
@Override
public void onFail(String inAppCode, WebView webView, String message) {}
@Override
public void onShowTimeFinished(String inAppCode, WebView webView, int showTime) {
super.onShowTimeFinished(inAppCode,webView);
Log.d("InApp onShowTimeFinished " + inAppCode);
}
});Crea una vista de WebView en el 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.
Instancia los mensajes In-App usando el método, tanto si quieres mostrar un inapp como varios de ellos.
IndigitallXamarin.Indigitall.ShowInApp(uiWebviewIos, "Billboard", (inAppId, webView) =>
{
// DO SOMETHING
}, (inAppId, webView, message) =>
{
//Error DO SOMETHING
},()=>{
//didTouch: DO SOMETHING
}, (inApp, showTime) =>{
//OnShowTimeFinished: DO SOMETHING
});
var views = new List<UIView>();
views.Add(myBanner);
views.Add(otherBanner);
var codes = new List<>();
codes.Add("myBanner_CODE");
codes.Add("otherBanner_CODE");
IndigitallXamarin.Indigitall.ShowMultipleInApp(views, codes, (inAppId, webView) =>
{
// DO SOMETHING
}, (inAppId, webView, message) =>
{
//Error DO SOMETHING
}, (inApp, webView) =>{
//Didtouch: DO SOMETHING
}, (inApp, webView, showtime) =>{
//OnShowTimeFinished: 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.
Instancia los mensajes In-App del hybridWebView usando el método ShowPopUp.
indigitall.ShowPopUp(view, "INAPP_CODE", (inAppId, webview) =>
{
//DO SOMETHING
},(inAppId, webview, errorMessage)=>
{
//LOG ERROR
}, () =>
{
Console.WriteLine("DidClick");
}, () =>
{
Console.WriteLine("DidClose");
}, () =>
{
Console.WriteLine("DidDismissed");
});
//En el caso de que quieras personalizar el icono de cerrar del Popup,
//puedes usar el siguiente método, en el que añades un UIButton personalizado, o usar la variable **closeIconDisabled** para no mostrar ninguno:
indigitall.ShowPopUp(view, "INAPP_CODE", myIcon, false, (inAppId, webview) =>
{
//DO SOMETHING
},(inAppId, webview, errorMessage)=>
{
//LOG ERROR
}, () =>
{
Console.WriteLine("DidClick");
}, () =>
{
Console.WriteLine("DidClose");
}, () =>
{
Console.WriteLine("DidDismissed");
}, (inAppCode, showTime)=>{
Console.WriteLine("OnShowTimeFinished");
}); 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 DP.
var view = findViewById(R.id.myPopup)
Indigitall.ShowPopUp(view, getContext(), "myPopup_CODE", new ShowInAppCallback() {
@Override
public void onLoad(String inAppCode, WebView webView) {
Log.d("In-App loaded: ", inAppCode);
}
@Override
public void onFail(String inAppCode, WebView webView, String message) {}
@Override
public void onShowTimeFinished(String inAppCode, WebView webView, int showTime) {}
});
//En el caso de que quieras personalizar el icono de cerrar del Popup, puedes
//usar el siguiente método, en el que añades un UIButton personalizado, o usar la variable **closeIconDisabled** para no mostrar ninguno:
Indigitall.ShowPopUp(view, getContext(), "myPopup_CODE", myIcon, false, new ShowInAppCallback() {
@Override
public void onLoad(String inAppCode, WebView webView) {
Log.d("In-App loaded: ", inAppCode);
}
@Override
public void onFail(String inAppCode, WebView webView, String message) {}
@Override
public void onShowTimeFinished(String inAppCode, WebView webView, int showTime) {}
});Crea una vista de WebView en el 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.
IndigitallXamarin.Indigitall.ShowPopup("myPopup_CODE", () =>
{
// DO SOMETHING didAppear
}, () =>
{
// DO SOMETHING didCancel
}, () =>
{
// DO SOMETHING didClicked
}, () =>
{
// DO SOMETHING didDismissed
}, (inApp, showTime) =>
{
// DO SOMETHING onShowTimeFinished
},(error)=> {
//Log Error
});
//En el caso de que quieras personalizar el icono de cerrar del Popup,
//puedes usar el siguiente método, en el que añades un UIButton personalizado, o usar la variable **closeIconDisabled** para no mostrar ninguno:
IndigitallXamarin.Indigitall.ShowPopup("myPopup_CODE", myIcon, false, () =>
{
// DO SOMETHING didAppear
}, () =>
{
// DO SOMETHING didCancel
}, () =>
{
// DO SOMETHING didClicked
}, () =>
{
// DO SOMETHING didDismissed
}, (inApp, showTime) =>
{
// DO SOMETHING onShowTimeFinished
},(error)=> {
//Log Error
});
En el caso de que quisieras obtener el objeto push de tipo json para realizar comprobaciones y/o cuando el usuario haga click en la notificación y sea con la acción de abrir app te dejamos este código que ayudará a su obtención:
En el caso de Android deberemos añadir este código en el MainActivity y parsearlo como objeto push para obtener la información:
var pushExtra = Com.Indigitall.Android.Models.Push.ExtraPush;
if (Intent != null && Intent.GetStringExtra(pushExtra) != null)
{
Com.Indigitall.Android.Models.Push push = new Com.Indigitall.Android.Models.Push(Intent.GetStringExtra(pushExtra));
Console.WriteLine("Push object: ", push);
}En el caso de iOS deberemos añadir este código en el AppDelegate de la aplicación, tanto en el método DidReceiveRemoteNotification para la acción principal, como para el método HandleAction para la acción de los botones:
//class extends UNUserNotificationCenterDelegate
[Export("userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler:")]
public override void DidReceiveNotificationResponse(UserNotifications.UNUserNotificationCenter center, UserNotifications.UNNotificationResponse response, Action completionHandler)
{
IndigitallXamarin.Indigitall.HandleWithResponse(response, (push, action) =>
{
Console.WriteLine("DidReceiveNotificationResponse push: " + push);
Console.WriteLine("DidReceiveNotificationResponse action: " + action.App);
});
}
//DidReceiveRemoteNotification
Com.Indigitall.Xamarin.iOS.Indigitall.HandleActionPush(userInfo, null, (push, action) => {
Console.WriteLine("DidReceiveRemoteNotification push: " + push);
Console.WriteLine("DidReceiveRemoteNotification action: " + action.app);
});
//HandleAction
Com.Indigitall.Xamarin.iOS.Indigitall.HandleActionPush(remoteNotificationInfo, actionIdentifier, (push, action) => {
Console.WriteLine("HandleAction push: " + push);
Console.WriteLine("HandleAction action: " + action.app);
});Si se decide por tratar la acción de la Push de manera independiente sin pasar por nuestra SDK, para poder registrar las estadísticas hay que hacer lo siguiente según la plataforma.
En el caso de Android, se recoge el intent de la acción en vuestra activity dónde se debe llamar al método ServiceUtils.RegisterStatistics. Para este caso se puede, por ejemplo, crear una clase que extienda de nuestro PushNotification para generar el intent con los siguientes extras:
public class PushNotification : Com.Indigitall.Android.Models.PushNotification
{
Push push;
Context context;
public PushNotification(Push push): base(push)
{
this.push = push;
}
public override void ShowNotification(Context context)
{
this.context = context;
base.ShowNotification(context);
}
protected override PendingIntent GetIntent(PushAction action, int clickedButton){
Intent intent = action.GetIntent(context);
Intent indigitallIntent;
indigitallIntent = new Intent(context, typeof(MainActivity));
indigitallIntent.SetFlags(ActivityFlags.NewTask);
indigitallIntent.PutExtra(Com.Indigitall.Android.Services.StatisticService.ExtraAppKey, Com.Indigitall.Android.Commons.Utils.PreferenceUtils.GetAppKey(context));
indigitallIntent.PutExtra(Com.Indigitall.Android.Services.StatisticService.ExtraPushId, push.Id);
indigitallIntent.PutExtra(Com.Indigitall.Android.Services.StatisticService.ExtraClickedButton, clickedButton);
indigitallIntent.PutExtra(Com.Indigitall.Android.Services.StatisticService.ExtraIntentAction, intent);
indigitallIntent.PutExtra(Push.ExtraPush, push.ToString());
if (action.GetTopics() != null && action.GetTopics().Length > 0)
{
indigitallIntent.PutExtra(Com.Indigitall.Android.Services.StatisticService.ExtraActionTopics, action.TopicsToString());
}
TaskStackBuilder stackBuilder = TaskStackBuilder.Create(context);
stackBuilder.AddNextIntentWithParentStack(indigitallIntent);
return stackBuilder.GetPendingIntent((push.Id * 10) + clickedButton,
PendingIntentFlags.OneShot);
}Una vez recogida la push como explicamos en el apartado anterior, se debe llamar al siguiente método para el registro de estadísticas:
Com.Indigitall.Android.Utils.ServiceUtils.RegisterStatistics(context, indigitallIntent);En el caso de iOS en el método userNotificationCenter:didReceive del propio AppDelegate, para poder registrar las estadísticas hay que añadir el siguiente método:
IndigitallXamarin.Indigitall.RegisterStatistics(response);