logo indigitall
/Integración indigitall /Push app /Xamarin
EN

 | ES

Integración Xamarin

Guía rápida de integración del SDK de Xamarin.


Tabla de contenidos



¿Qué necesitas para la integración?



Integración


Este artículo muestra el desarrollo mínimo que hay que hacer para comenzar a registrar dispositivos y poder realizar las primeras campañas push.


Nuestro SDK está disponible a través de NuGet.

NuGet es un sistema de gestión de paquetes. Consiste en un cliente de línea de comandos y una base de datos en línea de paquetes públicos y privados.


Importar el plugin


Para añadir nuestro SDK a tu proyecto a través de NuGet tienes que buscar el paquete Com.Indigitall.Xamarin.

Añade este paquete a tu proyecto (PCL, Android e iOS) de la siguiente manera:



Esta integración se ha realizado con el IDE Visual Studio.


Configuración para Android


Puedes verlo en ente vídeo tutorial o leer las instrucciones más abajo:




  1. Para comenzar necesitas un fichero llamado google-services.json. Este fichero lo podrás exportar desde la consola de Firebase. Muevelo a la carpeta raíz de tu proyecto.


  1. Añade los servicios de indigitall en tu AndroidManifest.xml como puedes ver más abajo.


<!-- START indigitall permissions -->
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
<uses-permission android:name="android.permission.VIBRATE" />
<uses-permission android:name="android.permission.WAKE_LOCK" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<!-- END indigitall permissions -->

<application>

  <!-- START indigitall services -->
  <service android:name="com.indigitall.android.services.StatisticService" />
  <service android:name="com.indigitall.android.services.NightService" />
  <receiver android:name="com.indigitall.android.receivers.BootReceiver">
    <intent-filter>
      <action android:name="android.intent.action.BOOT_COMPLETED" />
    </intent-filter>
  </receiver>
  <receiver android:name="com.indigitall.android.receivers.LocationReceiver">
    <intent-filter>
      <action android:name="LocationReceiver.Action.LOCATION_UPDATE" />
    </intent-filter>
  </receiver>
  <service android:name="com.indigitall.android.services.FirebaseMessagingService">
    <intent-filter>
      <action android:name="com.google.firebase.MESSAGING_EVENT" />
    </intent-filter>
  </service>
  <meta-data android:name="indigitall.color" android:resource="@color/colorprimary" />
  <meta-data android:name="indigitall.icon" android:resource="@mipmap/launcher_foreground" />
  <!-- END indigitall services -->

</application>


  1. Añade el siguiente fragmento de código en el método OnCreate desde la que sea tu pantalla principal de la aplicación. Aquí la vamos a llamar MyMainActivity. El fragmento de código debe añadirse antes de llamar al método LoadApplication propio de Xamarin.


protected override void OnCreate(Bundle bundle)
{
    DependencyService.Register<Com.Indigitall.Xamarin.Android.Indigitall>();
    Com.Indigitall.Android.Indigitall.SetDefaultActivity(this, "YOUR ACTIVITY");
    var app = new App();
    Com.Indigitall.Xamarin.Android.Utils.PermissionUtils.RequestLocationPermission(this);
    LoadApplication(app);
}


Configuración para iOS


Puedes verlo en ente vídeo tutorial o leer las instrucciones más abajo:




Para comenzar con la configuración de iOS, asegúrate tener OK estos puntos:



Nota: para que el SDK funcione correctamente el método FinishedLaunching debe ser llamado desde la clase AppDelegate, antes de que se produzca la llamada al método LoadApplication


La clase AppDelegate debería quedar así:


public override bool FinishedLaunching(UIApplication app, NSDictionary options)
{
    Forms.Init();
    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);
    }
    ...
    UNUserNotificationCenter.Current.Delegate = new Com.Indigitall.Xamarin.iOS.UserNotificationCenterDelegate();
    ...
    LoadApplication(new App());

    return base.FinishedLaunching(app, options);
}

[Export("application:didRegisterForRemoteNotificationsWithDeviceToken:")]
override public void RegisteredForRemoteNotifications(UIApplication application, NSData deviceToken)
{
    IndigitallXamarin.Indigitall.SetDeviceToken(deviceToken, (device) =>
    {
        Console.WriteLine("NewUserRegistered: " + device.DeviceID);
    });
}

[Export("application:didReceiveRemoteNotification:fetchCompletionHandler:")]
override public void DidReceiveRemoteNotification(UIApplication application, NSDictionary userInfo, Action<UIBackgroundFetchResult> completionHandler)
{
    IndigitallXamarin.Indigitall.HandleWithNotification(userInfo, null);
}

[Export("application:handleActionWithIdentifier:forRemoteNotification:withResponseInfo:completionHandler:")]
override public void HandleAction(UIApplication application, string actionIdentifier, NSDictionary remoteNotificationInfo, NSDictionary responseInfo, Action completionHandler)
{
    IndigitallXamarin.Indigitall.HandleWithNotification(remoteNotificationInfo, actionIdentifier);
}


Notification Service Extension


Desde la salida de iOS 10, las apps pueden gestionar notificaciones push enriquecidas, es decir, con imágen, gif, vídeo, botones, etc.

Para poder hacer uso de estas funcionalidades, tu app necesita implementar el Notification Service Extension.


  1. Añade un nuevo proyecto Notification Service Extension a tu solución
  2. Añade la dependencia Com.Indigitall.Xamarin.NSE de NuGet
  3. Referencia la extensión objetivo en tu proyecto iOS
  4. Una vez que hayas creado la extensión, se crea un nuevo fichero dentro del proyecto. Es el NotificationService. Reemplaza su contenido por las siguientes líneas:


using System;
using Foundation;
using Com.Indigitall.Xamarin.iOS;

namespace Notification
{
    [Register("NotificationService")]
    public class NotificationService : NotificationServiceExtension
    {
        protected NotificationService(IntPtr handle) : base(handle) {}
    }
}


Inicialización del SDK


Puedes verlo en ente vídeo tutorial o leer las instrucciones más abajo:




Inicializa el SDK con la llamada al metodo Indigital.init.

Primero hay que llamar a la interfaz IIndigitall dentro de tu clase MainPage, como vemos a continuación:


IIndigitall indigitall = DependencyService.Get<IIndigitall>();
if (indigitall != null)
{
    indigitall.Init("<YOUR_APP_KEY>", "<YOUR_SENDER_ID>");
}



Consola de Firebase Consola de Firebase



Inicialización avanzada del SDK


Nuestro SDK ofrece diversos callbacks que te ayudan tener mayor control del flujo de ejecución y a implementar comportamientos personalizados.


var indigitall = DependencyService.Get<IIndigitall>();
if (indigitall != null)
{
    indigitall.Init("YOUR APPKEY", "YOUR SENDER ID", true, (permissions, device)=>
    {
        //Cada vez que inicializa la sdk. AQui podéis coger el deviceID
        Console.WriteLine("device: " + device.deviceId);
    },(device)=>
    {
        Console.WriteLine("Newdevice: " + device.deviceId);
    },(errorCode,errorMessage)=>
    {
        Console.WriteLine("errorCode: " + errorCode+" Message: "+ errorMessage);
    });

Get Device

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.DeviceGet((device) =>
{
    if (device != null)
    {
        Console.WriteLine("Device: " + device.deviceId);
    }
}, null);


Activar las notificaciones geolocalizadas


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)


Location path on console

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.


Configuración localización para Android


Añade los permisos de localización incluyendo esta línea en el archivo AndroidManifest.xml:


<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />


Añade el siguiente código en el onCreate del MainActivity.cs y el método con la llamada OnRequestPermissionsResult para registrar la localización.

{
    DependencyService.Register<Com.Indigitall.Xamarin.Android.Indigitall>();
    //Com.Indigitall.Android.Indigitall.SetDefaultActivity(this, Java.Lang.Class.FromType(typeof(MyMainActivity)).Name);
    Com.Indigitall.Android.Indigitall.SetDefaultActivity(this, "YOUR ACTIVITY");
    ...
    var app = new App();
    ...
    Com.Indigitall.Xamarin.Android.Utils.PermissionUtils.RequestLocationPermission(this);
    ...
    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);

    }

Configuración localización para iOS


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 >.

Opciones que debes tener en cuenta


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 true cuando se inicialice el SDK. Esto se hace mediante el siguiente extracto de código:


//Al inicializar indigitall
indigitall.Init("<YOUR-APP-KEY>", "<YOUR-SENDER-ID>", true );


Validar la integración


Para comprobar que la integración se ha realizado correctamente realiza lo siguiente:


  1. Desde Visual Studio, ve a la pestaña de log y busca la llamada PUT /device conteniendo los parámetros appKey, deviceId y pushToken y que devuelva HTTP 200.




  1. Envia una notificación desde la consola de indigitall. Es posible que en la consola el contador de dispositivos aparezca a 0. No te preocupes, puede tardar unos minutos en actualizarse, pero no hace falta que esperes, la push debería llegar igualmente.




Siguientes pasos