Enviar notificaciones Push a tus dispositivos con Firebase

En este post vamos a ver paso a paso cómo enviar notificaciones Push a tus dispositivos con Firebase y Delphi

He supuesto que se ha publicado anteriormente en Google Play una app y se quiere enviar notificaciones a los usuarios que la tengan instalada.

Esta notificación la recibirán tengan abierta o no la app.

El proceso puede ser un poco tedioso al principio, pero una vez que se configure todo, cada vez que se quiera enviar una notificación habría que crear una "nueva campaña" (punto 4) indicando el texto del mensaje a enviar.

Empecemos...

 1) CONFIGURANDO FIREBASE

 Ir a  https://console.firebase.google.com y creamos un nuevo proyecto.

Ponemos un nombre al proyecto y pulsamos sobre el botón "Continuar"

En la siguiente pantalla deshabilitamos Google Analytics y pulsamos el botón "Crear proyecto"

Y si todo ha ido bien nos aparecerá el siguiente mensaje:

 

 

Ahora tenemos que añadir al proyecto una de nuestras apps que esté publicada en Google Play, pulsando sobre el icono de Android

en la caja de texto "Android package name" indicaremos el nombre de nuestra aplicación (com.xxxxxxxxx.xxxxxxxxx), p.ej. com.misoftware.GPSPro y pulsamos el botón "Register app"

En el siguiente paso tenemos que descargar el archivo "google-services.json" haciendo clic sobre "Download google-services.json"

 

 

2) Configurando RAD STUDIO - DELPHI

Después tenemos que abrir nuestra app desde Rad Studio y acceder al menú

Project > Options... > Application > Services y hacer clic sobre el botón "Import" para importar el archivo de configuración (google-services.json)

En mi caso lo hago en la Configuración para Android 64 bits y 32 bits.

 

 y después hay que ir a Project > Options... > Application > Entitlement List y marcar el check "Receive push notifications" también para las configuraciones de android de 64 y 32 bits.

 

3) CONFIGURANDO NUESTRA APP

 

Y con esto último hemos terminado de configurar Delphi y Firebase, ahora tenemos que configurar nuestra app para que pueda mostrar las notificaciones cuando la app está abierta.

En el caso de que la app esté cerrada no habrá que hacer nada ya que las recibirá el dispositivo automáticamente.

 

 -Se añade en el bloque "USES":

System.PushNotification, FMX.PushNotification.Android, System.Notification

 

-Se definen dos variables públicas:

 FDeviceId: string;
 FDeviceToken: string; 

- Creamos un tMemo para almacenar la notificación json.

 

 - Se crea un procedimiento llamado "Firebase" que se ejecutará en el evento OnCreate de la app, junto con otros procedimientos para recibir la notificación cuando se produzca:

PROCEDURE TForm1.Firebase;
VAR
  PushService: TPushService;
  ServiceConnection: TPushServiceConnection;
  Notifications: TArray menorque TPushServiceNotification mayorque;
BEGIN
  PushService := TPushServiceManager.Instance.GetServiceByName(TPushService.TServiceNames.FCM);
  ServiceConnection := TPushServiceConnection.create(PushService);
  ServiceConnection.Active := true;
  ServiceConnection.OnChange := OnServiceConnectionChange;
  ServiceConnection.OnReceiveNotification := OnReceiveNotificationEvent;

  FDeviceId := PushService.DeviceIDValue[TPushService.TDeviceIDNames.DeviceId];
  MemoLog.Lines.Add('DeviceID: ' + FDeviceId);
  MemoLog.Lines.Add('Ready to receive!');


  Notifications := PushService.StartupNotifications;
  IF Length(Notifications) > 0 THEN
  BEGIN
    MemoLog.Lines.Add('-----------------------------------------');
    MemoLog.Lines.Add('DataKey = ' + Notifications[0].DataKey);
    MemoLog.Lines.Add('Json = ' + Notifications[0].Json.ToString);
    MemoLog.Lines.Add('DataObject = ' + Notifications[0].DataObject.ToString);
    MemoLog.Lines.Add('-----------------------------------------');
  END;
END;

PROCEDURE TForm1.OnServiceConnectionChange(Sender: TObject; PushChanges: TPushService.TChanges);
VAR
  PushService: TPushService;
BEGIN
  PushService := TPushServiceManager.Instance.GetServiceByName(TPushService.TServiceNames.FCM);
  IF TPushService.TChange.DeviceToken IN PushChanges THEN
  BEGIN
    FDeviceToken := PushService.DeviceTokenValue[TPushService.TDeviceTokenNames.DeviceToken];
    MemoLog.Lines.Add('Firebase Token: ' + FDeviceToken);
    Log.d('Firebase device token: token=' + FDeviceToken);
  END;
  IF (TPushService.TChange.Status IN PushChanges) AND (PushService.Status = TPushService.TStatus.StartupError) THEN
    MemoLog.Lines.Add('Error: ' + PushService.StartupError);
END;

PROCEDURE TForm1.OnReceiveNotificationEvent(Sender: TObject; CONST ServiceNotification: TPushServiceNotification);
VAR
  MessageText: STRING;
BEGIN
  MemoLog.Lines.Add('-----------------------------------------');
  MemoLog.Lines.Add('DataKey = ' + ServiceNotification.DataKey);
  MemoLog.Lines.Add('Json = ' + ServiceNotification.Json.ToString);
  MemoLog.Lines.Add('DataObject = ' + ServiceNotification.DataObject.ToString);
  MemoLog.Lines.Add('---------------------------------------');
  MessageText := ServiceNotification.DataObject.GetValue('gcm.notification.body').Value;

  Memo1.Lines.Add(DatetimeToStr(now) + ' Message = ' + MessageText);
  MuestraNotificacion(MessageText, 0);
END;

PROCEDURE TForm1.MuestraNotificacion(MessageText: STRING; NotificationNumber: integer);
VAR
  NotificationCenter: TNotificationCenter;
  Notification: TNotification;
BEGIN
  NotificationCenter := TNotificationCenter.create(NIL);
  TRY
    Notification := NotificationCenter.CreateNotification;
    TRY
      Notification.Name := MessageText;
      Notification.AlertBody := MessageText;
      Notification.Title := MessageText;
      Notification.EnableSound := False;
      Notification.Number := NotificationNumber;
      NotificationCenter.ApplicationIconBadgeNumber := NotificationNumber;
      NotificationCenter.PresentNotification(Notification);
    FINALLY
      Notification.DisposeOf;
    END;
  FINALLY
    NotificationCenter.Free;
    NotificationCenter.DisposeOf;
  END;
END;

4) ENVIANDO LAS NOTIFICACIONES

Abrimos https://console.firebase.google.com

y se seleccionamos nuestro proyecto.

Accedemos a "Cloud Messaging" o a "Messaging" en la barra lateral izquierda

y creamos una nueva campaña, pulsando "Crear la primera campaña"

Nos pedirá que tipo de notificación queremos enviar y marcaremos sobre "Mensajes de Firebase Notifications" y después sobre el botón CREAR

En la pantalla siguiente escribimos un título: "Mi primera notificación" y el texto de la notificación y pulsamos SIGUIENTE

En la segmentación de usuarios hay que indicar el nombre de la app que hemos añadido al proyecto, para que la notificación la reciban todos los usuarios que tienen instalada en su dispositivo dicha app.

y en el punto siguiente seleccionamos la opción de enviar AHORA.

Después pulsamos el botón REVISAR y en la ventana siguiente pulsamos sobre PUBLICAR

y con eso tendremos nuestra primera notificación enviada a los usuarios que tengan instalada la app en su dispositivo.

 

Muy importante: No esperen que la notificación se reciba inmediatamente en el dispositivo, tarda un poco, en las pruebas que he hecho se recibe como máximo entre 2 y 10 minutos, aunque dependerá del número de usuarios que tengan instalada la app.