如果在一个方法里销毁一个activity

Question

public void start()
{
         Intent v1 = new Intent(context, MyActivity.class);
         v1.putExtra("bid", 123456);
         activity.startActivity(v1);
}我现在,在一个Activity的一个start()方法里启动了另一个Activity.
但是用startActivity这种方式启动以后,获取不到MyActivity的对象,就无法销毁他.
请问有什么办法能销毁他.

Answer 1

我无法直接在MyActivity写代码.所以只能在MyActivity类以外的地方销毁它

Answer 2

你用EventBus发送一条消息，在MyActivity里实现接受这条消息销毁自己的代码

Answer 3

你可以新建一个ActivityManager 然后把你要销毁的activity加进去 然后finish
添加是在你的activity的Create()方法中   调用 ActivityManager.getInstance().addActivity(this);public class ActivityManager {
    private List<Activity> activities = null;
    private static ActivityManager instance = new ActivityManager();    private ActivityManager() {
        activities = new LinkedList<Activity>();
    }    /**
     * 单例模式中获取唯一的MyApplication实例     *     * @return
     */
    public static ActivityManager getInstance() {
        return instance;
    }    // 添加Activity到容器中
    public void addActivity(Activity activity) {
        if (activities != null && activities.size() > 0) {
            if (!activities.contains(activity)) {
                activities.add(activity);
            }
        } else {
            activities.add(activity);
        }
    }    // 遍历所有Activity并finish
    public void finishActivity() {
        if (activities != null && activities.size() > 0) {
            for (Activity activity : activities) {
                if (!activity.isFinishing()) {
                    activity.finish();
                }
            }
        }
        activities.clear();
    }    /**
     * 获得当前显示的Activity
     *
     * @return
     */
    public String getRunningActivityName() {
        if (null != activities && activities.size() > 0) {
            return activities.get(activities.size() - 1).toString();
        }
        return null;
    }   //获得当前正在显示的activity
    public Activity getRunningActivity() {
        if (null != activities && activities.size() > 0) {
            return activities.get(activities.size() - 1);
        }
        return null;
    }    public void finishActivityByName(String name){
        if (activities != null && activities.size() > 0) {
           for (Activity activity : activities){
               if(null != activity){
                   String activityName = activity.toString();
                   if(activityName.contains(name) && !activity.isFinishing()){
                       activity.finish();
                   }
               }
           }
        }
    }
}

Answer 4

无法直接在MyActivity写代码？MyActivity是其他应用的Activity？

Answer 5

思想就是自己重写一下Application类，在onCreate方法中注册activity生命周期方法的回调方法，在onActivityCreated方法中判断是否是目标activity，是的话给该activity注册一个广播接收器，收到你的广播后做一些处理（如销毁activity）。当然，在onActivityDestroyed记得要解注册广播接收器。public class app extends Application {
    private BroadcastReceiver receiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            // 收到广播后做一些处理，比如销毁activity
            ((Activity)context).finish();
        }
    };
    @Override
    public void onCreate() {
        super.onCreate();
        registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
            @Override
            public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
                System.out.println(activity.getComponentName().getClassName() + "app.onActivityCreated");
                // 在这里判断是不是目标activity，如果是目标activity的话，可以给activity注册一个广播接收器，在收到广播后finish掉自己
                if (activity.getComponentName().equals("")) {
                    IntentFilter filter = new IntentFilter();
                    filter.addAction("custom action");
                    activity.registerReceiver(receiver, filter);
                }
            }            @Override
            public void onActivityStarted(Activity activity) {
            }            @Override
            public void onActivityResumed(Activity activity) {
            }            @Override
            public void onActivityPaused(Activity activity) {
            }            @Override
            public void onActivityStopped(Activity activity) {
            }            @Override
            public void onActivitySaveInstanceState(Activity activity, Bundle outState) {            }            @Override
            public void onActivityDestroyed(Activity activity) {
                System.out.println(activity.getComponentName().getClassName() + "app.onActivityDestroyed");
                // 在这里判断是不是目标activity，如果是目标activity的话，activity解注册广播接收器
                if (activity.getComponentName().equals("myActivity")) {
                    activity.unregisterReceiver(receiver);
                }
            }
        });
    }
}

Answer 6

写一个类 用于存放需要销毁的Activity  跳转去其他页面就调用 跟3

Answer 7

写一个类存放需要销毁的activity 跳转其他页面的时候就销毁就好 (参考3楼的)  还有就是写回调 或者 用RX也可以 

Answer 8

还想到一种方法，如果需要销毁目标activity，将启动目标activity的activity的启动模式设置成singleTop模式，然后发送一个Intent重新启动之前的activity，由于堆栈中已经有一个之前activity的实例了，系统会将其之上的activity都弹出栈，目标activity在其之上，会被系统销毁，这样就回到之前的activity了。

Answer 9

你是要销毁当前activity吗，直接在startActivity时，顺便用this.finsh()掉不就行了？

Answer 10

解决方案https://blog.csdn.net/bubujintian/article/details/83508855

Answer 11

活动A启动活动B后，当前活动就是B了，活动A没办法知道活动B在干什么，唯一的通信方式是用startActivityForResult(),在活动B销毁时返回状态，不然A都不知道B在干什么，哪能随便又把它销毁，没有意义。