Activité ouverte sur firebase notification reçue en premier plan

(kotlin)
utilisez ce code à l'intérieur de onMessageReceived si vous voulez vérifier est l'application de premier plan ou d'arrière-plan

    var foreground = false

    try {
        foreground = ForegroundCheckTask().execute(this).get()
    } catch (e: InterruptedException) {
        e.printStackTrace()
    } catch (e: ExecutionException) {
        e.printStackTrace()
    }

puis utilisez le "premier plan", variable pour faire l'action que vous avez besoin

 if (foregroud) { //app in foreground
            intent = Intent(this, ChatAdminActivity::class.java)
            intent.putExtra("intent_backchat", 1)
            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_CLEAR_TASK)
            pendingIntent = PendingIntent.getActivity(this, Integer.valueOf(random) /* Request code */, intent, PendingIntent.FLAG_UPDATE_CURRENT)
            startActivity(intent)      //to directly open activity if app is foreground
        } else { //app in background
            intent = Intent(this, ChatAdminActivity::class.java)
            intent.putExtra("intent_backchat", 1)
            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_CLEAR_TASK or Intent.FLAG_ACTIVITY_NEW_TASK)
            pendingIntent = PendingIntent.getActivity(this, Integer.valueOf(random) /* Request code */, intent, PendingIntent.FLAG_UPDATE_CURRENT)
        }
.....

espère que son aidant..

et vous pouvez voir mon FCMService code

OriginalL'auteur firecatmusic

public class MyFirebaseMessagingService extends FirebaseMessagingService {
 private static final String TAG = "FCM Service";
 @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        //TODO: Handle FCM messages here.
        //If the application is in the foreground handle both data and notification messages here.
        //Also if you intend on generating your own notifications as a result of a received FCM
        //message, here is where that should be initiated.
//    IntentFilter filter = new IntentFilter("OPEN_NEW_ACTIVITY");
//       registerReceiver(new BroadcastNotification(),filter);
//    showNotification(remoteMessage.getNotification().getBody());

        Log.d(TAG, "From: " + remoteMessage.getFrom());
        Log.d(TAG, "Notification Message Body: " + remoteMessage.getNotification().getBody());
     Log.e("Myname","shdjhfghgh");
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Intent in= new Intent(this,MainActivity.class);
        in.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        startActivity(in);
    }
}

OriginalL'auteur Devraj Jha

Selon la La page de Google sur les Émissions:

Si vous n'avez pas besoin d'envoyer les émissions de composants à l'extérieur de votre application, puis d'envoyer et de recevoir des émissions locales avec le LocalBroadcastManager qui est disponible dans la Bibliothèque de prise en charge. Le LocalBroadcastManager est beaucoup plus efficace (pas de communication interprocessus nécessaire) et vous permet d'éviter de penser à toutes les questions de sécurité liées à d'autres applications d'être en mesure de recevoir ou d'envoyer vos émissions. Des Émissions locales peut être utilisé comme un objectif général de pub/sub bus d'événement dans votre application, sans les frais généraux de l'ensemble du système de radiodiffusion.

Donc, préfèrent utiliser LocalBroadcastManager au lieu de BroadcastReceiver.

Dans le FirebaseMessagingService classe, vous recevez la notification de la FCM (Firebase Messagerie en Nuage) et les utiliser:

LocalBroadcastManager.getInstance(this).sendBroadcast(intent);

pour envoyer un message à l'MainActivity:

public class AppFirebaseMessagingService extends FirebaseMessagingService {
@Override
public void onMessageReceived(RemoteMessage remoteMessage) {
try {
String messageFrom = remoteMessage.getFrom();
String messageBody = (remoteMessage.getNotification() != null ? remoteMessage.getNotification().getBody() : null);
Map<String, String> messageData = remoteMessage.getData();
NotificationInfo notificationInfo = new NotificationInfo(messageData.get(message));
notifyMainActivity(notificationInfo);
showNotification(notificationInfo);
}
private void notifyMainActivity(NotificationInfo notificationInfo) {
Intent intent = new Intent();
intent.setAction(Constants.BROADCAST_MESSAGE_NOTIFICATION_RECEIVED);
intent.putExtra(Constants.PARAM_NOTIFICATION_INFO, notificationInfo);
LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
}
private void showNotification(NotificationInfo notificationInfo) {
Intent intentNotificationClicked = new Intent(this, MainActivity.class);
intentNotificationClicked.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
intentNotificationClicked.putExtra(Constants.PARAM_NOTIFICATION_INFO, notificationInfo);
PendingIntent resultIntentNotificationClicked = PendingIntent.getActivity(this, 0, intentNotificationClicked, PendingIntent.FLAG_ONE_SHOT);
String title = "MY APPLICATION";
String message = notificationInfo.message;
Uri notificationSoundURI = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
NotificationCompat.Builder mNotificationBuilder = new NotificationCompat.Builder(this)
.setSmallIcon(R.drawable.ic_notification_icon)
.setContentTitle(title)
.setContentText(message)
.setAutoCancel(true)
.setSound(notificationSoundURI)
.setContentIntent(resultIntentNotificationClicked);
NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
int notificationID = Integer.parseInt(new SimpleDateFormat("HHmmssSSS").format(new Date()));
notificationManager.notify(notificationID, mNotificationBuilder.build());
}
}

Et dans MainActivity vous créez le BroadcastReceiver à recevoir le message:

public class MainActivity extends AppCompatActivity {
private NotificationBroadcastReceiver mNotificationBroadcastReceiver = null;
private IntentFilter mIntentFilter = null;
@Override
public void onCreate(Bundle savedInstanceState) {
this.mNotificationBroadcastReceiver = new NotificationBroadcastReceiver(this);
this.mIntentFilter = new IntentFilter(Constants.BROADCAST_MESSAGE_NOTIFICATION_RECEIVED);
}
@Override
protected void onResume() {
super.onResume();
LocalBroadcastManager.getInstance(this).registerReceiver(this.mNotificationBroadcastReceiver, this.mIntentFilter);
}
@Override
protected void onPause() {
if (this.mNotificationBroadcastReceiver != null) {
unregisterReceiver(mNotificationBroadcastReceiver);
this.mNotificationBroadcastReceiver = null;
}
super.onPause();
}
private class NotificationBroadcastReceiver extends BroadcastReceiver {
WeakReference<MainActivity> mMainActivity;
public NotificationBroadcastReceiver(MainActivity mainActivity) {
this.mMainActivity = new WeakReference<>(mainActivity);
}
@Override
public void onReceive(Context context, Intent intent) {
MainActivity mainActivity = mMainActivity.get();
if (mainActivity != null) {
Bundle extras = intent.getExtras();
if (extras != null && extras.containsKey(Constants.PARAM_NOTIFICATION_INFO)) {
NotificationInfo notificationInfo = (NotificationInfo) extras.getSerializable(Constants.PARAM_NOTIFICATION_INFO);
mainActivity.notificationReceived(notificationInfo);
}
}
}
}
public void notificationReceived(@NonNull final NotificationInfo notificationInfo)
{
//handle the notification in MainActivity
}
}

Ci-dessous les classes référencées dans le code:

public class Constants {
public static final String NOTIFICATION_BROADCAST_RECEIVER_MESSAGE_RECEIVED = "com.mycompany.myapp.NOTIFICATION_RECEIVED";
public static final String PARAM_NOTIFICATION_INFO = "NotificationContent";
}
public class NotificationInfo implements Serializable {
public String message;
public NotificationInfo() { }
public NotificationInfo(String message) { this.message = message; }
}

Que c'est!

OriginalL'auteur educoutinho

Si vous souhaitez définir uniquement de votre notification, Vous pouvez modifier ce(Clinet exemple),

@Override
public void onMessageReceived(RemoteMessage remoteMessage) {
//Check if message contains a data payload.
if (remoteMessage.getData().size() > 0) {
Log.d(TAG, "Message data payload: " + remoteMessage.getData());
sendNotification( remoteMessage.getData());          
}       
}  

Et serveur envoyer un message comme ceci(exemple), seules les données( pas de notification)

var message = { //this may vary according to the message type (single recipient, multicast, topic, et cetera)
to: token,     
priority: 'high',
content_available: true,    
data: {  
//you can send only notification or only data(or include both)
message: 'news'
}};

Ref)

Il y a deux types de messages dans la FCM:

- affichage de messages: Ces messages déclencher la onMessageReceived() rappel uniquement lorsque votre application est au premier plan

- données-messages: Ces messages déclencher la onMessageReceived() de rappel, même si votre application est en arrière-plan

Les deux types de messages de la FCM

OriginalL'auteur amuyu