前言：

近期在做推送相关，集成了小米推送。小米推送的消息处理有两种模式：预定义和自定义。 预定义就是通过设置一系列参数，来跳转指定的页面，具体见小米推送文档说明。
自定义消息，需要自己处理页面跳转。现在的需求就是，自定义消息处理，收到消息后，点击打开App ,然后根据对应的数据进行页面跳转。由于继承了ReactNative,,具体的页面跳转由ReactNative 处理。以下主要记录 处理打开APP遇到的问题。

需求：

• 1 . 若应用存活，并且位于前台，直接传递消息。
• 2. 若应用存活，应用位于后台，需要调起应用，然后在传递消息。
• 3. 若应用没有存活，先启动应用，然后在传递消息。

注意： 由于集成的是小米推送，除了MIUI 系统，其他厂商的手机无法在应用杀死的情况下接受到推送。

对于需求1 ，无需其他操作，传递数据可以通过给对应的activity 发送广播，若是集成ReactNative 则发送RN事件，让对应页面监听即可。

首先，判断当前应用是否存活，在小米推送配置的Receiver里面，点击消息会进入onNotificationMessageClicked 回调，在该回调里处理。
最常用的方式是通过查看当前包名的进程是否正在运行，或者当前包名的服务是否正在运行。
查看进程是否在运行，代码如下：

 /**
     * 判断应用是否已经启动
     * @param context 一个context
     * @param packageName 要判断应用的包名
     * @return boolean
     */
    public static boolean isAppAlive(Context context, String packageName){
        ActivityManager activityManager =
                (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningAppProcessInfo> processInfos
                = activityManager.getRunningAppProcesses();
        for(int i = 0; i < processInfos.size(); i++){
            if(processInfos.get(i).processName.equals(packageName)){
                Log.i("NotificationLaunch",
                        String.format("the %s is running, isAppAlive return true", packageName));
                return true;
            }
        }
        Log.i("NotificationLaunch",
                String.format("the %s is not running, isAppAlive return false", packageName));
        return false;
    }

查看服务是否在运行，代码如下：

  /**
     * 用来判断服务是否运行.
     *
     * @param mContext
     * @param className  使用.class.getCanoicalName获取
     * @return true 在运行 false 不在运行
     */
    public static boolean isServiceRunning(Context mContext, String className) {
        boolean isRunning = false;
        ActivityManager activityManager = (ActivityManager) mContext
                .getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningServiceInfo> serviceList = activityManager
                .getRunningServices(30);
        if (!(serviceList.size() > 0)) {
            return false;
        }
        for (int i = 0; i < serviceList.size(); i++) {
            if (serviceList.get(i).service.getClassName().equals(className) == true) {
                isRunning = true;
                break;
            }
        }
        return isRunning;
    }

一般情况下，通过上面两个，就能判断系统是否存活。
但是在一些特殊情况下，这两个判断还不够，比如：用户不断点击返回，退出应用，但是进程还没有被系统杀死。再比如：小米系统中，集成了小米推送的应用，即使被杀死，后台还会显示进程存活，只是TaskInfo 栈为空。若是直接打开页面，一些初始化等页面会跳过，导致运行异常。

因此，在进程存活的情况下，需要进一步判断TaskInfo 栈是否为空，来判断进程是否存活。代码如下：

   /**
     * 判断当前应用任务栈是否为空
     *
     *
     * @param context
     */
    public static boolean isTaskEmpty(Context context) {

            /**获取ActivityManager*/
            ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);

            /**获得当前运行的task(任务)*/
            List<ActivityManager.RunningTaskInfo> taskInfoList = activityManager.getRunningTasks(100);
            for (ActivityManager.RunningTaskInfo taskInfo : taskInfoList) {
                Log.d("SystemUtils","num:"+taskInfo.numActivities+"topclassname:"+taskInfo.topActivity.getClassName());
                if (taskInfo.topActivity.getPackageName().equals(context.getPackageName())) {
                    return false;
                }
            }
            return true;
    }

在能确定进程存活的情况下，若是位于前台，则无需其他操作，但是若是位于后台，需要调到前台。因此需要判断应用是否位于前台：

   /**
     * 判断本应用是否已经位于最前端
     *
     * @param context
     * @return 本应用已经位于最前端时，返回 true；否则返回 false
     */
    public static boolean isRunningForeground(Context context) {
        ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningAppProcessInfo> appProcessInfoList = activityManager.getRunningAppProcesses();
        /**枚举进程*/
        for (ActivityManager.RunningAppProcessInfo appProcessInfo : appProcessInfoList) {
            if (appProcessInfo.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
                if (appProcessInfo.processName.equals(context.getApplicationInfo().processName)) {
                    return true;
                }
            }
        }
        return false;
    }

若应用位于后台，则将应用调到前台，代码如下：（需要android.permission.REORDER_TASKS 权限）

   /**
     * 将本应用置顶到最前端
     * 当本应用位于后台时，则将它切换到最前端
     *
     * @param context
     */
    public static void setTopApp(Context context) {
        if (!isRunningForeground(context)) {
            /**获取ActivityManager*/
            ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);

            /**获得当前运行的task(任务)*/
            List<ActivityManager.RunningTaskInfo> taskInfoList = activityManager.getRunningTasks(100);
            for (ActivityManager.RunningTaskInfo taskInfo : taskInfoList) {
                /**找到本应用的 task，并将它切换到前台*/
                if (taskInfo.topActivity.getPackageName().equals(context.getPackageName())) {
                    activityManager.moveTaskToFront(taskInfo.id, 0);
                    break;
                }

            }
        }
    }

若应用没有存活，则重启应用，代码如下：

   /**
     * 重新打开app
     * @param context
     */
    public static void reOpenApp(Context context){
        Intent launchIntent = context.getPackageManager().
                getLaunchIntentForPackage(context.getPackageName());
        launchIntent.setFlags(
                Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
        context.startActivity(launchIntent);
    }

通过上述综合场景，就能顺利的确定每个需求都满足。完成逻辑如下：

   public void handPushMessage(Context context, ReceivePushData receivePushData){
        //逻辑分析：
        //1. 如果进程不存活，直接重新启动应用
        //2. 如果进程存活，分为两种情况：
        //    情况1：进程存活，但Task栈已经空了,此时需要重新启动应用,比如用户点击Back键退出应用，但进程还没有被系统回收
        //    情况2：进程存活，Task 栈不为空，也分两种情况：
        //            1：应用在前台，不做任何处理
        //            2：应用在后台，将应用切换到前台
        if (SystemUtils.isAppAlive(context, context.getPackageName())) {
            Log.i(TAG, "the app process is alive,"+context.getPackageName());
            if (SystemUtils.isTaskEmpty(context)){
                // 任务栈为空，重新启动app
                Log.i(TAG, "the app process is alive, task is empty");
                SystemUtils.reOpenApp(context);
            }else{
                // 任务栈不为空，将后台应用放到前台
                Log.i(TAG, "the app process is alive, task is not empty");
                SystemUtils.setTopApp(context);
            }
        } else {
            // 任务栈为空，重新启动app
            Log.i(TAG, "the app process is dead");
            SystemUtils.reOpenApp(context);
        }
    }