App A 唤起 App B 并传参,AppB在登录之后的页面，无论哪个页面都有一个弹窗。点击确定按钮，唤起App A （传参）

一 .需求：App A 唤起并传参给 App B ,AppB在登录之后的页面，无论哪个页面都有一个弹窗。点击确定按钮，唤起并传参给App A

二.思路：

a：App B 创建一个Activity S.专门用来接收参数，接收到了并存在本地（唤起的接收参数：根据要跳的Activity,或者根据包名，在启动页的Activity 接收到参数）。

（1）：没有登陆过，跳转引导页（请求域名，然后根据状态跳到对应页面）。

（2）：登录过的话分为两种情况。

（2-1）：App B 是关闭程序状态唤起，同（1）操作。

（2-2）：App B 是后台状态唤起，就直接 finish(). 当前页面 Activity S。 -->上次进入后台什么页面，这次唤起就什么页面。

（2-3）：后台唤起的判断（默认域名是错的地址，并且 public static 状态保存，如果之前没有完全杀死App B，那么这个值还存在）：

!StringUtil.isEmpty(当前域名) && !当前域名.equals("默认的错误域名")

b:App A AppB

（1）启动模式都是 singletask(弹出其他Activity,自己处于栈顶).

（2）都是竖屏 screenorientation="potraint". （如果App A 横屏，App B 根据自己需求决定横竖屏）

（3）传值唤起（采用包名+Activity名）：（三种方式，根据包名，根据包名+activity名，根绝Url配置）

                Intent intent = new Intent(Intent.ACTION_MAIN);
                intent.setComponent(new ComponentName("包名","Activity名"));
                intent.putExtra("参数Key","参数值");
                startActivity(intent);

c:接收参数

（1）未登录情况进去首页，那么在首页数据请求好之后，获取本地存储的状态，来展示弹窗框

（2）后台进入：

a:在基类的BaseActivity 写一个方法可以展示Dialog（项目相同方法最好封装一下，方便改动）,一个内部类来处理，用户点击“确定”按钮的操作，比如：写唤起 App A 并且传参数。注意：在唤起其他App，做个判断，是否这个包名存在，不存在就Toast提示用户，被唤起的App A 没有安装在本机。防止找不到App A，AppB 奔了。

b:添加一个ActivityManager 管理Activity.可以获取堆栈 Activity 的信息。在BaseActivity OnCreate的时候，进栈。在onDestory的时候移除这个Activity.

c:Applicaton 实现接口 ActivityLifecycleCallbacks。在onActivityCrceated 的时候，将activity 转成 BaseActivity，做了容错判断，防止使用引用第三方的项目，执行这个方法，转化失败，笨了。

    @Override
    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
        LogUitl.e("===========================appli=======顺序前后=======onActivityCreated---此处记录最后的activity"+activity.getPackageName()+","+activity.getClass().getSimpleName());
        // 此处记录最后的activity
        try {
            mActivity = (BaseActivity) activity;
        }catch (Exception e){
            mActivity=null;
        }
    }

public static BaseActivity mActivity = null;

    /**
     *公开方法，外部可通过 MyApplication.getInstance().getCurrentActivity() 获取到当前最上层的activity
     */
    public static BaseActivity getCurrentActivity() {
        return mActivity;
    }

d:应用切换到前台：

（1）获取当前最顶部的Activity ,判断是否是 Activity S 。如果是的话，就是App A唤起App B 的操作，然后获取栈的第二个activity.后台进去前台，堆栈的Activity >=2.

(2)获取本地在Activity S 存的数据。如果这个值不是空的，那么进行查询得到数值，再被用户点击的时候唤起App A.

三参考资料：

a:唤起

1.https://blog.csdn.net/margin_0px/article/details/87928709 -- 使用这个 ---取值
2.https://blog.csdn.net/qq_43668086/article/details/87858865 -- 使用这个 ---传值

b:启动模式

1.https://blog.csdn.net/elisonx/article/details/80397519

c:前后端切换

https://blog.csdn.net/qq_37451521/article/details/86479619

d:Activity管理类

https://www.jianshu.com/p/18552ac1fceb

四：部分工具代码--网络找的，地址出处就在三的链接：

a:ActivityManager

package xxxxx;

import android.app.Activity;
import xxxxx;
import java.util.Stack;

/**
 * https://www.jianshu.com/p/18552ac1fceb
 */
public class ActivityManager {
    private static ActivityManager instance;
    private Stack<Activity> activityStack;// activity栈

    // 单例模式
    public static ActivityManager getInstance() {
        if (instance == null) {
            instance = new ActivityManager();
        }
        return instance;
    }

    // 把一个activity压入栈中
    public void pushOneActivity(Activity actvity) {
        if (activityStack == null) {
            activityStack = new Stack<Activity>();
        }
        activityStack.add(actvity);
    }

    // 获取栈顶的activity，先进后出原则
    public Activity getLastActivity() {
//        activityStack.remove(activityStack.size()-1);
        activityStack.get(activityStack.size()-1);
        return activityStack.lastElement();
    }

//    public Activity getLastTowActivity() {
//        return activityStack.get(activityStack.size()-1);
//    }

    // 移除一个activity
    public void popOneActivity(Activity activity) {
        if (activityStack != null && activityStack.size() > 0) {
            if (activity != null) {
                activity.finish();
                activityStack.remove(activity);
                activity = null;
            }
        }
    }

    // 退出所有activity
    public void finishAllActivity() {
        if (activityStack != null) {
            while (activityStack.size() > 0) {
                Activity activity = getLastActivity();
                if (activity == null)
                    break;
                popOneActivity(activity);
            }
        }
    }

    /**
     * 堆栈循环得到对应activity名称
     * @return
     */
    public int aaa(){
        if (activityStack != null) {
            for(int i=0;i<activityStack.size();i++){
                activityStack.get(i).getClass().getSimpleName();
                LogUitl.e("======================到前台=============appli=======顺序前后=======aaa====="+i+","+activityStack.get(i).getClass().getSimpleName());
            }
        }
        return activityStack.size();
    }

    /**
     * 栈顶第二个
     * @return
     */
    public Activity getLastTow(){
        if (activityStack != null && activityStack.size()>1) {
            return  activityStack.get(activityStack.size()-2);
        }
        return null;
    }

//    public String getLastTowSimeName(){
//        if (activityStack != null && activityStack.size()>2) {
//            return  activityStack.get(activityStack.size()-2).getClass().getSimpleName();
//        }
//        return "";
//    }
//
//    public boolean ifHaveActivity(Activity actvity){
//        if (activityStack != null && activityStack.contains(actvity)) {
//            return true;
//        }
//        return false;
//    }
//
//    public boolean iFHaveActivity(String compareName){
//        if (activityStack != null && !StringUtil.isEmpty(compareName)) {
//            for(int i=0;i<activityStack.size();i++){
//                if(compareName.equals(activityStack.get(i).getClass().getSimpleName().trim())){
//                    return true;
//                }
//            }
//        }
//        return false;
//    }

}

b：AppFrontBackHelper

package xxxx.util;

import android.app.Activity;
import android.app.Application;
import android.os.Bundle;

/**
 * 前后端切换
 * https://blog.csdn.net/qq_37451521/article/details/86479619
 */
public class AppFrontBackHelper {
    private OnAppStatusListener mOnAppStatusListener;

    public AppFrontBackHelper() {

    }

    /**
     * 注册状态监听，仅在Application中使用
     * @param application
     * @param listener
     */
    public void register(Application application, OnAppStatusListener listener){
        mOnAppStatusListener = listener;
        application.registerActivityLifecycleCallbacks(activityLifecycleCallbacks);
    }

    public void unRegister(Application application){
        application.unregisterActivityLifecycleCallbacks(activityLifecycleCallbacks);
    }

    private Application.ActivityLifecycleCallbacks activityLifecycleCallbacks = new Application.ActivityLifecycleCallbacks() {
        //打开的Activity数量统计
        private int activityStartCount = 0;

        @Override
        public void onActivityCreated(Activity activity, Bundle savedInstanceState) {

        }

        @Override
        public void onActivityStarted(Activity activity) {
            activityStartCount++;
            //数值从0变到1说明是从后台切到前台
            if (activityStartCount == 1){
                //从后台切到前台
                if(mOnAppStatusListener != null){
                    mOnAppStatusListener.onFront();
                }
            }
        }

        @Override
        public void onActivityResumed(Activity activity) {

        }

        @Override
        public void onActivityPaused(Activity activity) {

        }

        @Override
        public void onActivityStopped(Activity activity) {
            activityStartCount--;
            //数值从1到0说明是从前台切到后台
            if (activityStartCount == 0){
                //从前台切到后台
                if(mOnAppStatusListener != null){
                    mOnAppStatusListener.onBack();
                }
            }
        }

        @Override
        public void onActivitySaveInstanceState(Activity activity, Bundle outState) {

        }

        @Override
        public void onActivityDestroyed(Activity activity) {

        }
    };

    public interface OnAppStatusListener{
        void onFront();
        void onBack();
    }
}

来源：CSDN

作者：凝魄

链接：https://blog.csdn.net/fangjingjingll/article/details/104695622

标签

activity启动模式

软件

app