如何在android中设置自定义点击通知

****当应用程序在后台时，推送通知将出现，我想实现一个点击，导航到另一个活动（Mainchat.class，我尝试了挂起缩进和所有，但它仍然启动启动启动活动）****

这是在应用程序为后台时传递我的意图的代码

******MyFirebaseMessagingservice******

public class MyFirebaseMessagingService extends FirebaseMessagingService {

    private static final String TAG = MyFirebaseMessagingService.class.getSimpleName();
    private NotificationUtils notificationUtils;

    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        Log.e(TAG, "From: " + remoteMessage.getFrom());
        Log.e(TAG, "MSSGTYPE: " + remoteMessage.getMessageType());


        if (remoteMessage == null)
            return;

        // Check if message contains a notification payload.
        if (remoteMessage.getNotification() != null) {
            handleNotification(remoteMessage.getNotification().getBody());
        }

        if (remoteMessage.getData() != null) {


            if (remoteMessage.getData().containsKey("token")) {

                String Sender_name = remoteMessage.getData().get("sender");
                String messageBody = remoteMessage.getData().get("body");
                String messageCount = remoteMessage.getData().get("messageCount");
                String senderId = remoteMessage.getData().get("senderId");
                String chatNotification = remoteMessage.getData().get("chatNotification");


                Intent pushNotification = new Intent(Config.MESSAGE_NOTIFICATION);
                pushNotification.putExtra("message", messageBody);
                pushNotification.putExtra("Sender_name", Sender_name);
                pushNotification.putExtra("messageCount ", messageCount);
                pushNotification.putExtra("senderId", senderId);
                pushNotification.putExtra("chatNotification", chatNotification);
                LocalBroadcastManager.getInstance(this).sendBroadcast(pushNotification);
                pushNotification.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
                PendingIntent pendingIntent = PendingIntent.getActivity(this, 0 /* Request code */, pushNotification,
                        PendingIntent.FLAG_ONE_SHOT);

            } else {

                Intent intent = new Intent(Config.PUSH_NOTIFICATION);
                intent.putExtra("message", remoteMessage.getData().get("body"));
                LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
                intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
                PendingIntent pendingIntent = PendingIntent.getActivity(this, 0 /* Request code */, new Intent(this, NewNotification.class),
                        PendingIntent.FLAG_UPDATE_CURRENT);
            }
        }
    }



private void handleNotification(String message) {
        if (!NotificationUtils.isAppIsInBackground(getApplicationContext())) {
            // app is in foreground, broadcast the push message
            Intent pushNotification = new Intent(Config.PUSH_NOTIFICATION);
            pushNotification.putExtra("message", message);
            LocalBroadcastManager.getInstance(this).sendBroadcast(pushNotification);

            // play notification sound
           //Commented by venkatesh

            NotificationUtils notificationUtils = new NotificationUtils(getApplicationContext());
            notificationUtils.playNotificationSound();

        } else {
            // If the app is in background, firebase itself handles the notification
            Log.d(TAG, "Notification");
            handleDataMessage(message);
        }
    }



private void handleDataMessage(String message) {
        Log.e(TAG, "push json message: " + message);
        String title = "getsummary";

        boolean isBackground = true;
        String imageUrl = "";
        String timestamp = "";


        if (!NotificationUtils.isAppIsInBackground(getApplicationContext())) {
            // app is in foreground, broadcast the push message
            Intent pushNotification = new Intent(Config.PUSH_NOTIFICATION);
            pushNotification.putExtra("message", message);
            LocalBroadcastManager.getInstance(this).sendBroadcast(pushNotification);

            // play notification sound
            NotificationUtils notificationUtils = new NotificationUtils(getApplicationContext());
            notificationUtils.playNotificationSound();
        } else {
            // app is in background, show the notification in notification tray

//            Intent resultIntent = new Intent(getApplicationContext(), MainActivity.class);
//            resultIntent.putExtra("message", message);
//
            Intent resultIntent = new Intent(getApplicationContext(), MainChat.class);
            resultIntent.putExtra("message", message);

            // check for image attachment
            if (TextUtils.isEmpty(imageUrl)) {
                showNotificationMessage(getApplicationContext(), title, message, timestamp, resultIntent);
            } else {
                // image is present, show notification with image
                showNotificationMessageWithBigImage(getApplicationContext(), title, message, timestamp, resultIntent, imageUrl);
            }
        }

    }


    public String getAppLable(Context context) {
        PackageManager packageManager = context.getPackageManager();
        ApplicationInfo applicationInfo = null;
        try {
            applicationInfo = packageManager.getApplicationInfo(context.getApplicationInfo().packageName, 0);
        } catch (final PackageManager.NameNotFoundException e) {
        }
        return (String) (applicationInfo != null ? packageManager.getApplicationLabel(applicationInfo) : "Unknown");
    }

    /**
     * Showing notification with text only
     */
    private void showNotificationMessage(Context context, String title, String message, String timeStamp, Intent intent) {
        notificationUtils = new NotificationUtils(context);
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
        notificationUtils.showNotificationMessage(title, message, timeStamp, intent);
    }

    /**
     * Showing notification with text and image
     */
    private void showNotificationMessageWithBigImage(Context context, String title, String message, String timeStamp, Intent intent, String imageUrl) {
        notificationUtils = new NotificationUtils(context);
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
        notificationUtils.showNotificationMessage(title, message, timeStamp, intent, imageUrl);
    }

这是我的NotificationUttils.clas

public class NotificationUtils {

    private static String TAG = NotificationUtils.class.getSimpleName();
    private Context mContext;

    public NotificationUtils(Context mContext) {
        this.mContext = mContext;
    }

    public void showNotificationMessage(String title, String message, String timeStamp, Intent intent) {
        showNotificationMessage(title, message, timeStamp, intent, null);
    }

    public void showNotificationMessage(final String title, final String message, final String timeStamp, Intent intent, String imageUrl) {
        // Check for empty push message
        if (TextUtils.isEmpty(message))
            return;


        // notification icon
        final int icon = R.mipmap.ic_launcher1;

        intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
        final PendingIntent resultPendingIntent =
                PendingIntent.getActivity(
                        mContext,
                        0,
                        intent,
                        PendingIntent.FLAG_CANCEL_CURRENT
                );

        final NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(
                mContext);

        final Uri alarmSound = Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE
                + "://" + mContext.getPackageName() + "/raw/notification");

        if (!TextUtils.isEmpty(imageUrl)) {

            if (imageUrl != null && imageUrl.length() > 4 && Patterns.WEB_URL.matcher(imageUrl).matches()) {

                Bitmap bitmap = getBitmapFromURL(imageUrl);

                if (bitmap != null) {
                    showBigNotification(bitmap, mBuilder, icon, title, message, timeStamp, resultPendingIntent, alarmSound);
                } else {
                    showSmallNotification(mBuilder, icon, title, message, timeStamp, resultPendingIntent, alarmSound);
                }
            }
        } else {
            showSmallNotification(mBuilder, icon, title, message, timeStamp, resultPendingIntent, alarmSound);
            playNotificationSound();
        }
    }


    private void showSmallNotification(NotificationCompat.Builder mBuilder, int icon, String title, String message, String timeStamp, PendingIntent resultPendingIntent, Uri alarmSound) {

        NotificationCompat.InboxStyle inboxStyle = new NotificationCompat.InboxStyle();

        inboxStyle.addLine(message);

        Notification notification;
        notification = mBuilder.setSmallIcon(icon).setTicker(title).setWhen(0)
                .setAutoCancel(true)
                .setContentTitle(title)
                .setContentIntent(resultPendingIntent)
                .setSound(alarmSound)
                .setStyle(inboxStyle)
                .setWhen(getTimeMilliSec(timeStamp))
                .setSmallIcon(R.mipmap.ic_launcher1)
                .setLargeIcon(BitmapFactory.decodeResource(mContext.getResources(), icon))
                .setContentText(message)
                .build();

        NotificationManager notificationManager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
        notificationManager.notify(Config.NOTIFICATION_ID, notification);
    }

    private void showBigNotification(Bitmap bitmap, NotificationCompat.Builder mBuilder, int icon, String title, String message, String timeStamp, PendingIntent resultPendingIntent, Uri alarmSound) {
        NotificationCompat.BigPictureStyle bigPictureStyle = new NotificationCompat.BigPictureStyle();
        bigPictureStyle.setBigContentTitle(title);
        bigPictureStyle.setSummaryText(Html.fromHtml(message).toString());
        bigPictureStyle.bigPicture(bitmap);
        Notification notification;
        notification = mBuilder.setSmallIcon(icon).setTicker(title).setWhen(0)
                .setAutoCancel(true)
                .setContentTitle(title)
                .setContentIntent(resultPendingIntent)
                .setSound(alarmSound)
                .setStyle(bigPictureStyle)
                .setWhen(getTimeMilliSec(timeStamp))
                .setSmallIcon(R.mipmap.ic_launcher1)
                .setLargeIcon(BitmapFactory.decodeResource(mContext.getResources(), icon))
                .setContentText(message)
                .build();

        NotificationManager notificationManager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
        notificationManager.notify(Config.NOTIFICATION_ID_BIG_IMAGE, notification);
    }

    /**
     * Downloading push notification image before displaying it in
     * the notification tray
     */
    public Bitmap getBitmapFromURL(String strURL) {
        try {
            URL url = new URL(strURL);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setDoInput(true);
            connection.connect();
            InputStream input = connection.getInputStream();
            Bitmap myBitmap = BitmapFactory.decodeStream(input);
            return myBitmap;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    // Playing notification sound
    public void playNotificationSound() {
        try {
            Uri alarmSound = Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE
                    + "://" + mContext.getPackageName() + "/raw/notification");
            Ringtone r = RingtoneManager.getRingtone(mContext, alarmSound);
            r.play();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Method checks if the app is in background or not
     */
    public static boolean isAppIsInBackground(Context context) {
        ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningAppProcessInfo> runningProcesses = am.getRunningAppProcesses();
        for (ActivityManager.RunningAppProcessInfo processInfo : runningProcesses) {
            if (processInfo.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
                for (String activeProcess : processInfo.pkgList) {
                    if (activeProcess.equals(context.getPackageName())) {
                        //If your app is the process in foreground, then it's not in running in background
                        return false;
                    }
                }
            }
        }


        return true;
    }


    // Clears notification tray messages
    public static void clearNotifications(Context context) {
        NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
        notificationManager.cancelAll();
    }

    public static long getTimeMilliSec(String timeStamp) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.ENGLISH);
        try {
            Date date = format.parse(timeStamp);
            return date.getTime();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return 0;
    }

}

公共类通知utils{
私有静态字符串标记=NotificationUtils.class.getSimpleName（）；
私有上下文；
公共通知UTILS（上下文mContext）{
this.mContext=mContext；
}
public void showNotificationMessage（字符串标题、字符串消息、字符串时间戳、意图）{
showNotificationMessage（标题、消息、时间戳、意图、空）；
}
public void showNotificationMessage（最终字符串标题、最终字符串消息、最终字符串时间戳、意图、字符串图像URL）{
//检查空推送消息
if（TextUtils.isEmpty（message））
返回；
//通知图标
最终int图标=R.mipmap.ic_1；
intent.setFlags（intent.FLAG_ACTIVITY_CLEAR_TOP | intent.FLAG_ACTIVITY_SINGLE_TOP）；
最终挂起内容结果挂起内容=
pendingent.getActivity(
McContext，
0,
意图
PendingEvent.FLAG_取消_当前
);
最终NotificationCompat.Builder mBuilder=新NotificationCompat.Builder(
mContext）；
最终Uri alarmSound=Uri.parse（ContentResolver.SCHEME\u ANDROID\u资源
+“：/”+mContext.getPackageName（）+“/raw/notification”）；
如果（！TextUtils.isEmpty（imageUrl））{
if（imageUrl！=null&&imageUrl.length（）>4&&Patterns.WEB\u URL.matcher（imageUrl.matches（））{
位图位图=getBitmapFromURL（imageUrl）；
if（位图！=null）{
showBigNotification（位图、mBuilder、图标、标题、消息、时间戳、结果结束内容、alarmSound）；
}否则{
showSmallNotification（mBuilder、图标、标题、消息、时间戳、ResultPendingContent、alarmSound）；
}
}
}否则{
showSmallNotification（mBuilder、图标、标题、消息、时间戳、ResultPendingContent、alarmSound）；
播放通知声音（）；
}
}
私有void showSmallNotification（NotificationCompat.Builder mBuilder、int图标、字符串标题、字符串消息、字符串时间戳、PendingEvent ResultPendingEvent、Uri alarmSound）{
NotificationCompat.InboxStyle InboxStyle=新NotificationCompat.InboxStyle（）；
inboxStyle.addLine（消息）；
通知；
通知=mBuilder.setSmallIcon（icon）.setTicker（title）.setWhen（0）
.setAutoCancel（真）
.setContentTitle（标题）
.setContentIntent（结果结束内容）
.setSound（警报声）
.setStyle（收件箱样式）
.setWhen（GetTimeMillissec（时间戳））
.setSmallIcon（R.mipmap.ic_启动器1）
.setLargeIcon（位图工厂.decodeResource（mContext.getResources（），图标））
.setContentText（消息）
.build（）；
NotificationManager NotificationManager=（NotificationManager）mContext.getSystemService（Context.NOTIFICATION\u服务）；
notificationManager.notify（Config.NOTIFICATION\u ID，NOTIFICATION）；
}
私有void showBigNotification（位图位图、NotificationCompat.Builder mBuilder、int图标、字符串标题、字符串消息、字符串时间戳、PendingEvent ResultPendingEvent、Uri alarmSound）{
NotificationCompat.BigPictureStyle BigPictureStyle=新NotificationCompat.BigPictureStyle（）；
bigPictureStyle.setBigContentTitle（标题）；
bigPictureStyle.setSummaryText（Html.fromHtml（message.toString（））；
bigPictureStyle.bigPicture（位图）；
通知；
通知=mBuilder.setSmallIcon（icon）.setTicker（title）.setWhen（0）
.setAutoCancel（真）
.setContentTitle（标题）
.setContentIntent（结果结束内容）
.setSound（警报声）
.setStyle（大图片样式）
.setWhen（GetTimeMillissec（时间戳））
.setSmallIcon（R.mipmap.ic_启动器1）
.setLargeIcon（位图工厂.decodeResource（mContext.getResources（），图标））
.setContentText（消息）
.build（）；
NotificationManager NotificationManager=（NotificationManager）mContext.getSystemService（Context.NOTIFICATION\u服务）；
notificationManager.notify（Config.NOTIFICATION\u ID\u BIG\u IMAGE，NOTIFICATION）；
}
/**
*在中显示推送通知图像之前下载该图像
*通知盘
*/
公共位图getBitmapFromURL（字符串strURL）{
试一试{
URL=新URL（strURL）；
HttpURLConnection connection=（HttpURLConnection）url.openConnection（）；
connection.setDoInput（true）；
connection.connect（）；
InputStream输入=连接。getInputStream（）；
位图myBitmap=BitmapFactory.decodeStream（输入）；
返回我的位图；
}捕获（IOE异常）{
e、 printStackTrace（）；
返回null；
}
}
//播放通知音
公共无效播放通知声音（）{
试一试{
Uri alarmSound=Uri.parse（ContentResolver.SCHEME\u ANDROID\u资源
+“：/”+mContext.getPackageName（）+“/raw/notification”）；
Ringtone r=RingtoneManager.getRingtone（mContext，alarmSound）；
r、 play（）；
}捕获（例外e）{
e、 printStackTrace（）；
}