应用关闭后恢复Android后备堆栈

Question

在多个会话之间管理/恢复应用程序堆栈的最佳做法是什么？

工作流程的例子:

1. 活动A开始(堆栈:A)
2. 活动B开始(堆栈:AB)
3. 活动C开始(堆栈:ABC)
4. ...
5. 用户使用不同的应用程序(比如GMail应用程序)一段时间
6. ...
7. 用户返回我的应用程序,但后端堆栈已被Android清除.

在第7步,我想恢复活动C,如果用户按下后退按钮2次,它将返回活动B,然后返回活动A.

[编辑]添加详细信息.

在上面的第7步之后,Android中默认情况发生的是:

1. 活动A已启动(堆栈:空,并添加了C)

我希望用户感觉他仍在使用相同的会话:

1. 活动C恢复(堆栈:ABC)
2. 用户按下后退按钮,活动B恢复(堆栈:AB)
3. 用户按下后退按钮,活动A恢复(堆栈:A)

在避免内存泄漏的同时,解决这种情况的好方法是什么？

[第二次编辑]我一直在为所有活动使用commong类UIController制作一个解决方法,并使用LauncherActivity将逻辑委托给UIController.

因为我只需要在ActivityC启动时重建后台堆栈,这个解决方案似乎工作正常:

public class UIController
{
    private boolean _launched = false;

    static private final UIController __instance = new UIController();
    static public UIController getInstance() { return __instance; }

    // Enforces the Singleton Pattern by preventing external access to constructor
    private UIController() { }

    public void onActivityCreated(Activity activity) {
        if (!_launched)
        {
            if ( shouldRebuildStack() )
            {
                // Rebuild Activity stack

                // Npte : actually Android will add ActivityA and ActivityB to the stack
                // but will *NOT* create them right away. Only ActivityC will be 
                // created and resumed.
                // Since they are in the back stack, the other activities will be 
                // created by Android once needed.
                startActivity(activity, ActivityA.class);
                startActivity(activity, ActivityB.class);
                startActivity(activity, ActivityC.class);
            } else {
                // Starts default activity
                startActivity(activity, ActivityA.class);
            }

            _launched = true;
        }
    }

    public void onActivityResumed(Activity activity) {
        memorizeCurrentActivity( activity.getClass().toString() );
    }

    private void memorizeCurrentActivity( String className ) {
        // write className to preferences, disk, etc.
    }

    private boolean shouldRebuildStack() {
        String previousActivity = " [load info from file, preferences, etc.] ";
        return (previousActivity != null && previousActivity.equals("my.package.ActivityC"));
    }

    private void startActivity(Activity caller, Class newActivityClass)
    {
        Intent intent = new Intent(caller, newActivityClass);
        intent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
        caller.startActivity( intent );
    }
}

// This is the default activity in the AndroidManifest.xml
// This prevents ActivityA from starting right away if the UIController
// wants to rebuild the stack.
public class LauncherActivity() {
    protected void onCreate(Bundle data) {
        super.onCreate(data);
        UIController.getInstance().onActivityCreated(this);
        finish();
    }
}

public class ActivityA() {
    protected void onCreate(Bundle data) {
        super.onCreate(data);
        UIController.getInstance().onActivityCreated(this);
    }
    protected void onResume() {
        super.onResume();
        UIController.getInstance().onActivityResumed(this);
    }
}

public class ActivityB() {
    // onCreate() & onResume(), same as ActivityA
}

public class ActivityC() {
    // onCreate() & onResume(), same as ActivityA
}

public class LauncherActivity() {
    protected void onCreate(Bundle data) {
        super.onCreate(data);
        UIController.getInstance().onActivityCreated(this);
        finish();
    }
}

public class ActivityA() {
    protected void onCreate(Bundle data) {
        super.onCreate(data);
        UIController.getInstance().onActivityCreated(this);
    }
    protected void onResume() {
        super.onResume();
        UIController.getInstance().onActivityResumed(this);
    }
}

public class ActivityB() {
    // same as ActivityA
}

public class ActivityC() {
    // same as ActivityA
}

如果有人有更好的解决方案,请随时发布.

Answer 1

听起来你应该将其设置为true并让Android处理活动堆栈.

机器人:alwaysRetainTaskState

如果在任务的根活动中将此属性设置为"true",则不会发生刚刚描述的默认行为.即使经过很长一段时间,任务仍会保留堆栈中的所有活动.