如何在屏幕旋转期间处理 AsyncTask？

Question

我读了很多关于如何保存实例状态或如何处理屏幕旋转期间被破坏的活动的内容。

似乎有很多可能性，但我还没有弄清楚哪一种最适合检索 AsyncTask 的结果。

我有一些 AsyncTasks 只是再次启动并调用活动的 isFinishing() 方法，如果活动完成，它们将不会更新任何内容。

问题是我有一个任务向 Web 服务发出请求，该请求可能会失败或成功，并且重新启动该任务将导致用户的经济损失。

你会如何解决这个问题？可能的解决方案有哪些优点或缺点？

Answer 1

您可以访问 code.google.com 查看我如何处理 AsyncTask 和方向更改/p/架子。有多种方法可以做到这一点，我在此应用程序中选择的方法是取消任何当前正在运行的任务，保存其状态，并在创建新的 Activity 时使用保存的状态启动一个新任务。这很容易做到，效果很好，而且作为奖励，它可以在用户离开应用程序时停止你的任务。

您还可以使用 onRetainNonConfigurationInstance() 将您的 AsyncTask 传递给新的 Activity（注意不要泄露之前的 Activity）代码>虽然这样。）

Answer 2

这是我见过的关于 Android 的最有趣的问题！事实上，过去几个月我一直在寻找解决方案。还是没有解决。

请小心，仅仅覆盖这些

android:configChanges="keyboardHidden|orientation"

内容是不够的。

考虑当 AsyncTask 运行时用户接到电话的情况。您的请求已被服务器处理，因此 AsyncTask 正在等待响应。此时您的应用程序将进入后台，因为电话应用程序刚刚进入前台。操作系统可能会终止您的活动，因为它位于后台。

Answer 3

我的第一个建议是确保您确实需要在屏幕旋转时重置活动（默认行为）。每次遇到旋转问题时，我都会将此属性添加到 AndroidManifest.xml 中的 标记中，一切都很好。

android:configChanges="keyboardHidden|orientation"

它看起来很奇怪，但它会传递给您的 onConfigurationChanged() 方法，如果您不提供它，它除了重新测量布局之外什么也不做，这似乎是一个完美的解决方案大多数时候处理旋转的适当方法。

Answer 4

为什么不在Android提供的Singleton上始终保留对当前AsyncTask的引用呢？

每当任务启动时，在 PreExecute 或构建器上，您可以定义：

((Application) getApplication()).setCurrentTask(asyncTask);

每当任务完成时，您将其设置为 null。

这样，您始终拥有一个引用，允许您执行适合您的特定逻辑的 onCreate 或 onResume 之类的操作：

this.asyncTaskReference = ((Application) getApplication()).getCurrentTask();

If它是空的，你知道目前没有正在运行的！

:-)

Answer 5

最正确的方法是使用片段来通过旋转保留异步任务的实例。

这是一个非常简单示例的链接，可以轻松地将这种技术集成到您的应用程序中。

https://gist.github.com/daichan4649/2480065

Answer 6

在Pro android 4中。作者提出了一个很好的方法，您应该使用弱引用。

弱引用注释

Answer 7

在我看来，最好通过 onRetainNonConfigurationInstance 来存储 asynctask，将其与当前 Activity 对象解耦，并在方向更改后将其绑定到新的 Activity 对象。 在这里 我发现了一个非常好的示例，说明如何使用 AsyncTask 和 ProgressDialog。

Answer 8

Android：后台处理/带有配置更改的异步操作

要在后台进程期间维护异步操作的状态：
你可以借助碎片。

请参阅以下步骤：

步骤 1：创建一个无标头片段（例如后台任务）并在其中添加一个私有异步任务类。

步骤 2（可选步骤）：如果您想将加载光标放在 Activity 顶部，请使用以下代码：

步骤 3：在主 Activity 中实现步骤 1 中定义的 BackgroundTaskCallbacks 接口

class BackgroundTask extends Fragment {
public BackgroundTask() {

}

// Add a static interface 

static interface BackgroundTaskCallbacks {
    void onPreExecute();

    void onCancelled();

    void onPostExecute();

    void doInBackground();
}

private BackgroundTaskCallbacks callbacks;
private PerformAsyncOpeation asyncOperation;
private boolean isRunning;
private final String TAG = BackgroundTask.class.getSimpleName();

/**
 * Start the async operation.
 */
public void start() {
    Log.d(TAG, "********* BACKGROUND TASK START OPERATION ENTER *********");
    if (!isRunning) {
        asyncOperation = new PerformAsyncOpeation();
        asyncOperation.execute();
        isRunning = true;
    }
    Log.d(TAG, "********* BACKGROUND TASK START OPERATION EXIT *********");
}

/**
 * Cancel the background task.
 */
public void cancel() {
    Log.d(TAG, "********* BACKGROUND TASK CANCEL OPERATION ENTER *********");
    if (isRunning) {
        asyncOperation.cancel(false);
        asyncOperation = null;
        isRunning = false;
    }
    Log.d(TAG, "********* BACKGROUND TASK CANCEL OPERATION EXIT *********");
}

/**
 * Returns the current state of the background task.
 */
public boolean isRunning() {
    return isRunning;
}

/**
 * Android passes us a reference to the newly created Activity by calling
 * this method after each configuration change.
 */
public void onAttach(Activity activity) {
    Log.d(TAG, "********* BACKGROUND TASK ON ATTACH ENTER *********");
    super.onAttach(activity);
    if (!(activity instanceof BackgroundTaskCallbacks)) {
        throw new IllegalStateException(
                "Activity must implement the LoginCallbacks interface.");
    }

    // Hold a reference to the parent Activity so we can report back the
    // task's
    // current progress and results.
    callbacks = (BackgroundTaskCallbacks) activity;
    Log.d(TAG, "********* BACKGROUND TASK ON ATTACH EXIT *********");
}

public void onCreate(Bundle savedInstanceState) {
    Log.d(TAG, "********* BACKGROUND TASK ON CREATE ENTER *********");
    super.onCreate(savedInstanceState);
    // Retain this fragment across configuration changes.
    setRetainInstance(true);
    Log.d(TAG, "********* BACKGROUND TASK ON CREATE EXIT *********");
}

public void onDetach() {
    super.onDetach();
    callbacks = null;
}

private class PerformAsyncOpeation extends AsyncTask<Void, Void, Void> {
    protected void onPreExecute() {
        Log.d(TAG,
                "********* BACKGROUND TASK :-> ASYNC OPERATION :- > ON PRE EXECUTE ENTER *********");
        if (callbacks != null) {
            callbacks.onPreExecute();
        }
        isRunning = true;
        Log.d(TAG,
                "********* BACKGROUND TASK :-> ASYNC OPERATION :- > ON PRE EXECUTE EXIT *********");
    }

    protected Void doInBackground(Void... params) {
        Log.d(TAG,
                "********* BACKGROUND TASK :-> ASYNC OPERATION :- > DO IN BACKGROUND ENTER *********");
        if (callbacks != null) {
            callbacks.doInBackground();
        }
        Log.d(TAG,
                "********* BACKGROUND TASK :-> ASYNC OPERATION :- > DO IN BACKGROUND EXIT *********");
        return null;
    }

    protected void onCancelled() {
        Log.d(TAG,
                "********* BACKGROUND TASK :-> ASYNC OPERATION :- > ON CANCEL ENTER *********");
        if (callbacks != null) {
            callbacks.onCancelled();
        }
        isRunning = false;
        Log.d(TAG,
                "********* BACKGROUND TASK :-> ASYNC OPERATION :- > ON CANCEL EXIT *********");
    }

    protected void onPostExecute(Void ignore) {
        Log.d(TAG,
                "********* BACKGROUND TASK :-> ASYNC OPERATION :- > ON POST EXECUTE ENTER *********");
        if (callbacks != null) {
            callbacks.onPostExecute();
        }
        isRunning = false;
        Log.d(TAG,
                "********* BACKGROUND TASK :-> ASYNC OPERATION :- > ON POST EXECUTE EXIT *********");
    }
}

public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);
    setRetainInstance(true);
}

public void onStart() {
    super.onStart();
}

public void onResume() {
    super.onResume();
}

public void onPause() {
    super.onPause();
}

public void onStop() {
    super.onStop();
}

public class ProgressIndicator extends Dialog {

public ProgressIndicator(Context context, int theme) {
    super(context, theme);
}

private ProgressBar progressBar;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    setContentView(R.layout.progress_indicator);
    this.setCancelable(false);
    progressBar = (ProgressBar) findViewById(R.id.progressBar);
    progressBar.getIndeterminateDrawable().setColorFilter(R.color.DarkBlue, android.graphics.PorterDuff.Mode.SCREEN);
}

@Override
public void show() {
    super.show();
}

@Override
public void dismiss() {
    super.dismiss();
}

@Override
public void cancel() {
    super.cancel();
}

public class MyActivity extends FragmentActivity implements BackgroundTaskCallbacks,{

private static final String KEY_CURRENT_PROGRESS = "current_progress";

ProgressIndicator progressIndicator = null;

private final static String TAG = MyActivity.class.getSimpleName();

private BackgroundTask task = null;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(//"set your layout here");
    initialize your views and widget here .............



    FragmentManager fm = getSupportFragmentManager();
    task = (BackgroundTask) fm.findFragmentByTag("login");

    // If the Fragment is non-null, then it is currently being
    // retained across a configuration change.
    if (task == null) {
        task = new BackgroundTask();
        fm.beginTransaction().add(task, "login").commit();
    }

    // Restore saved state
    if (savedInstanceState != null) {
        Log.i(TAG, "KEY_CURRENT_PROGRESS_VALUE ON CREATE :: "
                + task.isRunning());
        if (task.isRunning()) {
            progressIndicator = new ProgressIndicator(this,
                    R.style.TransparentDialog);
            if (progressIndicator != null) {
                progressIndicator.show();
            }
        }
    }
}

@Override
protected void onPause() {
    // TODO Auto-generated method stub
    super.onPause();

}

@Override
protected void onSaveInstanceState(Bundle outState) {
    // save the current state of your operation here by saying this 

    super.onSaveInstanceState(outState);
    Log.i(TAG, "KEY_CURRENT_PROGRESS_VALUE ON SAVE INSTANCE :: "
            + task.isRunning());
    outState.putBoolean(KEY_CURRENT_PROGRESS, task.isRunning());
    if (progressIndicator != null) {
        progressIndicator.dismiss();
        progressIndicator.cancel();
    }
    progressIndicator = null;
}


private void performOperation() {

            if (!task.isRunning() && progressIndicator == null) {
                progressIndicator = new ProgressIndicator(this,
                        R.style.TransparentDialog);
                progressIndicator.show();
            }
            if (task.isRunning()) {
                task.cancel();
            } else {
                task.start();
            }
        }


@Override
protected void onDestroy() {
    super.onDestroy();
    if (progressIndicator != null) {
        progressIndicator.dismiss();
        progressIndicator.cancel();
    }
    progressIndicator = null;
}

@Override
public void onPreExecute() {
    Log.i(TAG, "CALLING ON PRE EXECUTE");
}

@Override
public void onCancelled() {
    Log.i(TAG, "CALLING ON CANCELLED");
    if (progressIndicator != null) {
        progressIndicator.dismiss();
        progressIndicator.cancel();

}

public void onPostExecute() {
    Log.i(TAG, "CALLING ON POST EXECUTE");
    if (progressIndicator != null) {
        progressIndicator.dismiss();
        progressIndicator.cancel();
        progressIndicator = null;
    }
}

@Override
public void doInBackground() {
    // put your code here for background operation
}

}

Answer 9

需要考虑的一件事是 AsyncTask 的结果是否只应可供启动该任务的活动使用。如果是，那么Romain Guy的答案是最好的。如果它应该可供应用程序的其他活动使用，那么在 onPostExecute 中，您可以使用 LocalBroadcastManager。

LocalBroadcastManager.getInstance(getContext()).sendBroadcast(new Intent("finished"));

您还需要确保活动正确处理活动暂停时发送广播的情况。

Answer 10

请查看这篇帖子。这篇文章涉及 AsyncTask 执行长时间运行的操作以及在一个示例应用程序中发生屏幕旋转时的内存泄漏。示例应用程序可在 source forge 上获取

Answer 11

我的解决方案。

就我而言，我有一系列具有相同上下文的 AsyncTasks。活动只能访问第一个。要取消任何正在运行的任务，我执行了以下操作：

public final class TaskLoader {

private static AsyncTask task;

     private TaskLoader() {
         throw new UnsupportedOperationException();
     }

     public static void setTask(AsyncTask task) {
         TaskLoader.task = task;
     }

    public static void cancel() {
         TaskLoader.task.cancel(true);
     }
}

任务 doInBackground()：

protected Void doInBackground(Params... params) {
    TaskLoader.setTask(this);
    ....
}

活动 onStop() 或 onPause()：

protected void onStop() {
    super.onStop();
    TaskLoader.cancel();
}

Answer 12

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    final AddTask task = mAddTask;
    if (task != null && task.getStatus() != UserTask.Status.FINISHED) {
        final String bookId = task.getBookId();
        task.cancel(true);

        if (bookId != null) {
            outState.putBoolean(STATE_ADD_IN_PROGRESS, true);
            outState.putString(STATE_ADD_BOOK, bookId);
        }

        mAddTask = null;
    }
}

@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
    if (savedInstanceState.getBoolean(STATE_ADD_IN_PROGRESS)) {
        final String id = savedInstanceState.getString(STATE_ADD_BOOK);
        if (!BooksManager.bookExists(getContentResolver(), id)) {
            mAddTask = (AddTask) new AddTask().execute(id);
        }
    }
}

Answer 13

你还可以添加
android:configChanges="keyboardHidden|orientation|screenSize"

到您的清单示例我希望它有帮助

 <application
    android:name=".AppController"
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:roundIcon="@mipmap/ic_launcher_round"
    android:supportsRtl="true"
    android:configChanges="keyboardHidden|orientation|screenSize"
    android:theme="@style/AppTheme">