极光推送-点击通知栏跳到指定页面

在MyReceiver接收器里面，添加以下代码：

if (JPushInterface.ACTION_NOTIFICATION_OPENED.equals(intent.getAction())) {
            Log.d(TAG, "[MyReceiver] 用户点击打开了通知");
           //打开自定义的Activity
           Intent i = new Intent(context, ArticleActivity.class);
           i.putExtras(bundle);
           i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
           context.startActivity(i);
        }  

由于是在广播接收器里面启动Activity，所以要添加Flag：FLAG_ACTIVITY_NEW_TASK，表示新创建一个task来存放启动的Activity。那为什么就要设置这么一个Flag呢，不能引用原来的task吗，答案是确实不能。普通情况下，要有前一个Activity的Context才能启动另外一个Activity。startActivity()源码中有这么一个描述：

 *   Note that if this method is being called from outside of an 
 *   {@link android.app.Activity} Context, then the Intent must include 
 *   the {@link Intent#FLAG_ACTIVITY_NEW_TASK} launch flag.  This is because, 
 *   without being started from an existing Activity, there is no existing 
 *   task in which to place the new activity and thus it needs to be placed 
 *   in its own separate task.

设置该Flag的效果与模式设置为SingleTask的效果是一样。

如果要跳转到该Activity时，并清除掉之前的Activity，那么就可以将跳转到的Activity启动模式设置为singleTask。

<!--主页面-->
<activity android:name=".activity.MainActivity"
    android:launchMode="singleTask"/>  

-------20170414更新---------

最近发现了一个问题，就是如果我们的应用已经退出了，但极光推送的服务还在运行，这时候推了一条通知过来，这时我们是否应该要判断一下应用是否还在运行？因为你如果不去判断的话，比如此时应该退出了，但你点击通知，直接打开文章详情Activity，就会比原来流程少了启动页->主页（->文章详情），你肯定会在启动页或主页做一些初始化的，这时直接跳过初始化肯定会有问题的。所以我们要做应用是否还在运行的判断，看到网上有一些是用进程（5.0以上）和任务栈（5.0以下）去判断，我觉得没必要这样，因为利用进程去判断时，明明应用已经退出，但进程还在，会导致误判。我们可以换另外一种思路来判断应用是否正在运行：去判断任务栈中存在的Activity个数，如果Activity数都为0了，那应用肯定退出了，不再运行了。而判断Activity数可以自己创建一个类去管理Activity，代码如下：

package com.wesdom.realstuffshop.utils;

import android.app.Activity;

import java.util.ArrayList;
import java.util.List;

/**
 * Activity管理器
 * Created by sen young on 2017/5/18 11:25.
 * 邮箱:595327086@qq.com.
 */

public class MyActivityManager {

    private static List<Activity> activityList = new ArrayList<Activity>();
    private static MyActivityManager instance;

    public static MyActivityManager getInstance() {
        if (instance == null) {
            instance = new MyActivityManager();
        }
        return instance;
    }

    /**
     * 添加 Activity 到列表
     *
     * @param activity activity
     */
    public static void addActivity(Activity activity) {
        if (activityList == null) {
            activityList = new ArrayList<Activity>();
        }
        activityList.add(activity);
    }

    /**
     * 获取界面数量
     *
     * @return activity size
     */
    public static int getActivitySize() {
        if (activityList != null) {
            return activityList.size();
        }
        return 0;
    }

    /**
     * 获取当前 Activity - 堆栈中最后一个压入的
     *
     * @return current Activity
     */
    public static Activity getCurrentActivity() {
        if (activityList != null && activityList.size() > 0) {
            Activity activity = activityList.get(activityList.size() - 1);
            return activity;
        }
        return null;
    }

    /**
     * 获取指定类名的 Activity
     *
     * @param cls 指定的类
     * @return Activity
     */
    public static Activity getActivity(Class<?> cls) {
        if (activityList == null) {
            return null;
        }
        for (Activity activity : activityList) {
            if (activity.getClass().equals(cls)) {
                return activity;
            }
        }
        return null;
    }

    /**
     * 结束指定的 Activity
     *
     * @param activity Activity
     */
    public static void removeActivity(Activity activity) {
        if (activity != null) {
            activityList.remove(activity);
        }
    }

    /**
     * 结束指定类名的 Activity
     *
     * @param cls 指定的类
     */
    public static void removeActivity(Class<?> cls) {
        if (activityList == null) {
            return;
        }
        for (Activity activity : activityList) {
            if (activity.getClass().equals(cls)) {
                activityList.remove(activity);
            }
        }
    }

    /**
     * 结束所有Activity
     */
    public static void finishAllActivity() {
        if (activityList == null) {
            return;
        }
        int size = activityList.size();
        for (int i = 0; i < size; i++) {
            if (null != activityList.get(i)) {
                activityList.get(i).finish();
            }
        }
        activityList.clear();
    }

    /**
     * 结束其他所有的Activity
     *
     * @param activity 不需要销毁的Activity
     */
    public static void finishOtherAllActivity(Activity activity) {
        if (activityList == null) {
            return;
        }
        for (int i = 0, size = activityList.size(); i < size; i++) {
            if (activity != activityList.get(i)) {
                activityList.get(i).finish();
                activityList.remove(i);
            }
        }
    }

}

使用这个类有两种方法：

（1），在BaseActivity的生命周期中调用

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    MyActivityManager.addActivity(this);
｝

@Override
protected void onDestroy() {
    MyActivityManager.removeActivity(this);
}

（2），通过实现Application.ActivityLifecycleCallbacks里面的两个方法，并在MyApplication中去注册这个回调

a,在自己的MyApplication中添加回调：

registerActivityLifecycleCallbacks(this);

b,实现的相关方法中添加以下代码：

    @Override
    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
        MyActivityManager.addActivity(activity);
    }

    @Override
    public void onActivityDestroyed(Activity activity) {
        MyActivityManager.removeActivity(activity);
    }

这样，我们新启动或销毁Activity就会自己调用实现的方法。