Haz clic en la acción de notificaciones de FCM de Firebase payload

Por lo que puedo decir, en este punto no es posible establecer click_action en la consola.

Aunque no es una respuesta estricta a cómo obtener el conjunto click_action en la consola, puede usar curl como alternativa:

curl --header "Authorization: key=<YOUR_KEY_GOES_HERE>" --header Content-Type:"application/json" https://fcm.googleapis.com/fcm/send  -d "{\"to\":\"/topics/news\",\"notification\": {\"title\": \"Click Action Message\",\"text\": \"Sample message\",\"click_action\":\"OPEN_ACTIVITY_1\"}}"

Esta es una manera fácil de probar la asignación click_action. Requiere un filtro de intent como el especificado en los documentos de FCM:

<intent-filter>
  <action android:name="OPEN_ACTIVITY_1" />
  <category android:name="android.intent.category.DEFAULT" />
</intent-filter>

Esto también hace uso de temas para establecer la audiencia. Para que esto funcione, necesitará: suscríbase a un tema llamado "noticias".

FirebaseMessaging.getInstance().subscribeToTopic("news");

Aunque se tarda varias horas en ver un tema recién creado en la consola, aún puede enviarle mensajes a través de las api de FCM.

También, tenga en cuenta que esto solo funcionará si la aplicación está en segundo plano. Si está en primer plano tendrá que implementar una extensión de FirebaseMessagingService. En el método onMessageReceived, tendrá que navegar manualmente a su destino click_action:

    @Override
public void onMessageReceived(RemoteMessage remoteMessage) {
    //This will give you the topic string from curl request (/topics/news)
    Log.d(TAG, "From: " + remoteMessage.getFrom());
    //This will give you the Text property in the curl request(Sample Message): 
    Log.d(TAG, "Notification Message Body: " + remoteMessage.getNotification().getBody());
    //This is where you get your click_action 
    Log.d(TAG, "Notification Click Action: " + remoteMessage.getNotification().getClickAction());
    //put code here to navigate based on click_action
}

Como dije, en este momento no puedo encontrar una manera de acceder a las propiedades de la carga útil de notificaciones a través de la consola, pero pensé que este trabajo podría ser útil.

Puedes manejar todas tus acciones en función de tu mensaje en onMessageReceived() en tu servicio extendiendo FirebaseMessagingService. Para ello, debe enviar un mensaje que contenga exclusivamente datos, utilizando por ejemplo Cliente REST avanzado en Chrome. Luego envía un MENSAJE a https://fcm.googleapis.com/fcm/send usando en "Encabezados raw":

Tipo de contenido: aplicación / json Autorización: key = YOUR_PERSONAL_FIREBASE_WEB_API_KEY

Y un mensaje json en el campo "Carga sin procesar".

Advertencia, si hay el campo "notificación" en su json, su mensaje nunca será recibido cuando la aplicación en segundo plano en onMessageReceived(), incluso si hay un campo de datos ! Por ejemplo, al hacer eso, el mensaje funciona solo si la aplicación está en primer plano:

{
    "condition": " 'Symulti' in topics || 'SymultiLite' in topics",
    "priority" : "normal",
    "time_to_live" : 0,
    "notification" : {
        "body" : "new Symulti update !",
        "title" : "new Symulti update !",
        "icon" : "ic_notif_symulti"
    },
    "data" : {
        "id" : 1,
        "text" : "new Symulti update !"
    }
}

Para recibir su mensaje en todos los casos en onMessageReceived(), simplemente elimine el campo "notification" de su json !

Ejemplo:

{
    "condition": " 'Symulti' in topics || 'SymultiLite' in topics",
    "priority" : "normal",
    "time_to_live" : 0,,
    "data" : {
        "id" : 1,
        "text" : "new Symulti update !",
        "link" : "href://www.symulti.com"
    }
}

Y en su FirebaseMessagingService:

public class MyFirebaseMessagingService extends FirebaseMessagingService {

    private static final String TAG = "MyFirebaseMsgService";

    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
      String message = "";
      obj = remoteMessage.getData().get("text");
      if (obj != null) {
        try {
          message = obj.toString();
        } catch (Exception e) {
          message = "";
          e.printStackTrace();
        }
      }

      String link = "";
      obj = remoteMessage.getData().get("link");
      if (obj != null) {
        try {
          link = (String) obj;
        } catch (Exception e) {
          link = "";
          e.printStackTrace();
        }
      }

      Intent intent;
      PendingIntent pendingIntent;
      if (link.equals("")) { // Simply run your activity
        intent = new Intent(this, MainActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
      } else { // open a link
        String url = "";
        if (!link.equals("")) {
          intent = new Intent(Intent.ACTION_VIEW);
          intent.setData(Uri.parse(link));
          intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        }
      }
      pendingIntent = PendingIntent.getActivity(this, 0 /* Request code */, intent,
          PendingIntent.FLAG_ONE_SHOT);


      NotificationCompat.Builder notificationBuilder = null;

      try {
        notificationBuilder = new NotificationCompat.Builder(this)
            .setSmallIcon(R.drawable.ic_notif_symulti)          // don't need to pass icon with your message if it's already in your app !
            .setContentTitle(URLDecoder.decode(getString(R.string.app_name), "UTF-8"))
            .setContentText(URLDecoder.decode(message, "UTF-8"))
            .setAutoCancel(true)
            .setSound(RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION))
            .setContentIntent(pendingIntent);
        } catch (UnsupportedEncodingException e) {
          e.printStackTrace();
        }

        if (notificationBuilder != null) {
          NotificationManager notificationManager =
              (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
          notificationManager.notify(id, notificationBuilder.build());
        } else {
          Log.d(TAG, "error NotificationManager");
        }
      }
    }
}

Disfrute !

Esto entra en la categoría de solución alternativa, que también contiene información adicional:

Dado que las notificaciones se manejan de manera diferente dependiendo del estado de la aplicación (primer plano/segundo plano/no iniciado), he visto la mejor manera de implementar una clase auxiliar donde se inicia la actividad seleccionada en función de los datos personalizados enviados en el mensaje de notificación.

• cuando la aplicación está en primer plano use la clase helper en onMessageReceived
• cuando la aplicación está en segundo plano la clase helper para manejar la intent en el onNewIntent de la actividad principal (verifique datos personalizados específicos)
• cuando la aplicación no se está ejecutando, use la clase helper para manejar la intent en el onCreate de la actividad principal (llame a getIntent para la intent).

De esta manera no necesita el filtro click_action o intent específico para él. También escribe el código solo una vez y puede iniciar cualquier actividad razonablemente fácilmente.

Así que los datos personalizados mínimos se verían algo como esto:

Key: run_activity
Value: com.mypackage.myactivity

Y el código para manejarlo:

if (intent.hasExtra("run_activity")) {
    handleFirebaseNotificationIntent(intent);
}


private void handleFirebaseNotificationIntent(Intent intent){
    String className = intent.getStringExtra("run_activity");
    startSelectedActivity(className, intent.getExtras());
}

private void startSelectedActivity(String className, Bundle extras){
    Class cls;
    try {
        cls = Class.forName(className);
    }catch(ClassNotFoundException e){
        ...
    }
    Intent i = new Intent(context, cls);

    if (i != null) {
        i.putExtras(extras);
        this.startActivity(i);
    } 
}

Que es el código para los dos últimos casos, startSelectedActivity se llamaría también desde onMessageReceived (primer caso).

La limitación es que todos los datos en los intent extras son cadenas, por lo que es posible que deba manejarlos de alguna manera en la actividad en sí. Además, esto se simplifica, probablemente no sepa qué cambiar la Actividad / Vista en una aplicación que está en primer plano sin avisar a su usuario.

Bueno, esto está claro desde firebase docs que su onMessageReceived no funcionará cuando la aplicación está en segundo plano.

Cuando su aplicación está en segundo plano y haga clic en su notificación, se iniciará su lanzador predeterminado. Para iniciar la actividad deseada, debe especificar click_action en su carga útil de notificación.

$noti = array
    (
    'icon' => 'new',
    'title' => 'title',
    'body' => 'new msg',
    'click_action' => 'your activity name comes here'
); 

Y en su archivo android.manifest

Agregue el siguiente código donde registró su actividad

     <activity
                android:name="your activity name">
                <intent-filter>
                    <action android:name="your activity name" />
                   <category android:name="android.intent.category.DEFAULT"/>
               </intent-filter>
   </activity>

Si tu app está en segundo plano, Firebase no activará onMessageReceived(). onMessageReceived () se llama cuando app está en primer plano . Cuando app está en segundo plano, el método onMessageReceived() será llamado solo si el cuerpo de https://fcm.googleapis.com/fcm/send contiene solo carga útil de datos.Aquí, acabo de crear un método para crear notificaciones personalizadas con la intención de tener tu actividad requerida . y llamó a este método en onMessageRecevied ().

En PostMan:

Uri: https://fcm.googleapis.com/fcm/send

Header: Authorization: key = ur key

Cuerpo --->>

{  "data" : {
      "Nick" : "Mario",
      "Room" : "PoSDenmark",

    },

  "to" : "xxxxxxxxx"

}

En su solicitud.

class MyFirebaseMessagingService  extends FirebaseMessagingService {

 public void onMessageReceived(RemoteMessage remoteMessage) {
       if (remoteMessage.getData().size() > 0) {
           sendNotification("ur message body") ;
        }
    }
private void sendNotification(String messageBody) {
        Intent intent = new Intent(this, Main2Activity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0 /* Request code */, intent,
                PendingIntent.FLAG_ONE_SHOT);

        Uri defaultSoundUri= RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
        NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this)
                .setSmallIcon(R.drawable.ic_stat_ic_notification)
                .setContentTitle("FCM Message")
                .setContentText(messageBody)
                .setAutoCancel(true)
                .setSound(defaultSoundUri)
                .setContentIntent(pendingIntent);

        NotificationManager notificationManager =
                (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);

        notificationManager.notify(0 /* ID of notification */, notificationBuilder.build());
    }

 }

Cuando la carga útil de datos llega al móvil,se llamará al método onMessageReceived ().. dentro de ese método ,acabo de hacer una notificación personalizada. esto funcionará incluso si la aplicación ur está en segundo plano o en primer plano.

Actualización:

Así que solo para verificar, actualmente no es posible establecer el parámetro click_action a través de la consola Firebase.

Así que he estado tratando de hacer esto en la consola de notificaciones de Firebase sin suerte. Dado que parece que no puedo encontrar ningún lugar para colocar el valor click_action en la consola, lo que hice principalmente para probar esto es agregar un par clave/valor personalizado en la Notificación (Opciones avanzadas > Datos personalizados):

Key: click_action
Value: <your_preferred_value>

Luego intentó llamar Mensaje remoto.getNotification ().getClickAction () en onMessageReceived() para ver si estaba recuperando el valor correcto, pero siempre devuelve null. Así que a continuación intenté llamar a RemoteMessage.getData().get () y fue capaz de recuperar el valor que agregué.

NOTA: No estoy completamente seguro de si eso está bien para ser utilizado como una solución alternativa, o si está en contra de las mejores prácticas. Sugeriría usar su propio servidor de aplicaciones, pero su publicación es específica de Firebase Consola.

El comportamiento de la aplicación cliente y la notificación depende de cómo la programes. Dicho esto, creo que puede usar lo anterior como una solución alternativa, utilizando el valor recuperado de getData(), y luego hacer que la Notificación llame esto o aquello. Espero que esto ayude de alguna manera. ¡Salud! : D

Ahora es posible establecer click_action en Firebase Console. Simplemente vaya a notificaciones-enviar mensaje-opción avanzada y allí tendrá dos campos para clave y valor. En el primer campo pones click_action y en el segundo pones algo de texto que representa el valor de esa acción. Y agregas intent-filter en tu Manifiesto y le das el mismo valor que escribiste en la consola. Y eso es simulación de click_action real.

Estoy buscando esta Base de fuego es, el desarrollo de google cloud messaging notificación push fundamental así que podemos usar el tutorial de gcm, la función y la implementación en firebase , uso de la función de notificación push de gcm para resolver este problema de click_action uso la función gcm * *

'notificationclick'

** trate de guardar la url click_action en la variable url esto es en servidor-trabajador.js

var url =  "";

messaging.setBackgroundMessageHandler(function(payload) {

  console.log('[firebase-messaging-sw.js] Received background message ', payload);
  // Customize notification here
  url = payload.data.click_action;

  const notificationTitle = payload.data.title;
  const notificationOptions = {
    body: payload.data.body , 
    icon: 'firebase-logo.png'
  };

  return self.registration.showNotification(notificationTitle,
      notificationOptions);

});


   //i got this in google cloud messaging push notification


self.addEventListener('notificationclick', function (event) {
  event.notification.close();

  var clickResponsePromise = Promise.resolve();
    clickResponsePromise = clients.openWindow(url);

  event.waitUntil(Promise.all([clickResponsePromise, self.analytics.trackEvent('notification-click')]));
});