AsyncTaskLoader在有待处理任务和配置更改时的onLoadFinished方法

Question

我正在尝试使用AsyncTaskLoader在后台加载数据，以响应选择列表项并填充详细视图。虽然它大部分都是有效的，但我仍然有一个问题。如果我选择列表中的第二个项目，然后在第一个选择的项的加载完成之前旋转设备，则onLoadFinished()调用会报告给停止的活动而不是新活动。如果只选择单个项目然后旋转，则此方法正常工作。以下是我正在使用的代码。活动：

public final class DemoActivity extends Activity
        implements NumberListFragment.RowTappedListener,
                   LoaderManager.LoaderCallbacks<String> {

    private static final AtomicInteger activityCounter = new AtomicInteger(0);

    private int myActivityId;

    private ResultFragment resultFragment;

    private Integer selectedNumber;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        myActivityId = activityCounter.incrementAndGet();
        Log.d("DemoActivity", "onCreate for " + myActivityId);

        setContentView(R.layout.demo);

        resultFragment = (ResultFragment) getFragmentManager().findFragmentById(R.id.result_fragment);

        getLoaderManager().initLoader(0, null, this);

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d("DemoActivity", "onDestroy for " + myActivityId);
    }

    @Override
    public void onRowTapped(Integer number) {
        selectedNumber = number;
        resultFragment.setResultText("Fetching details for item " + number + "...");
        getLoaderManager().restartLoader(0, null, this);
    }

    @Override
    public Loader<String> onCreateLoader(int id, Bundle args) {
        return new ResultLoader(this, selectedNumber);
    }

    @Override
    public void onLoadFinished(Loader<String> loader, String data) {
        Log.d("DemoActivity", "onLoadFinished reporting to activity " + myActivityId);
        resultFragment.setResultText(data);
    }

    @Override
    public void onLoaderReset(Loader<String> loader) {

    }

    static final class ResultLoader extends AsyncTaskLoader<String> {

        private static final Random random = new Random();

        private final Integer number;

        private String result;

        ResultLoader(Context context, Integer number) {
            super(context);
            this.number = number;
        }

        @Override
        public String loadInBackground() {
            // Simulate expensive Web call
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            return "Item " + number + " - Price: $" + random.nextInt(500) + ".00, Number in stock: " + random.nextInt(10000);
        }

        @Override
        public void deliverResult(String data) {
            if (isReset()) {
                // An async query came in while the loader is stopped
                return;
            }

            result = data;

            if (isStarted()) {
                super.deliverResult(data);
            }
        }

        @Override
        protected void onStartLoading() {
            if (result != null) {
                deliverResult(result);
            }

            // Only do a load if we have a source to load from
            if (number != null) {
                forceLoad();
            }
        }

        @Override
        protected void onStopLoading() {
            // Attempt to cancel the current load task if possible.
            cancelLoad();
        }

        @Override
        protected void onReset() {
            super.onReset();

            // Ensure the loader is stopped
            onStopLoading();

            result = null;
        }

    }

}

清单片段：

public final class NumberListFragment extends ListFragment {

    interface RowTappedListener {

        void onRowTapped(Integer number);

    }

    private RowTappedListener rowTappedListener;

    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);

        rowTappedListener = (RowTappedListener) activity;
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);

        ArrayAdapter<Integer> adapter = new ArrayAdapter<Integer>(getActivity(),
                                                                  R.layout.simple_list_item_1,
                                                                  Arrays.asList(1, 2, 3, 4, 5, 6));
        setListAdapter(adapter);

    }

    @Override
    public void onListItemClick(ListView l, View v, int position, long id) {
        ArrayAdapter<Integer> adapter = (ArrayAdapter<Integer>) getListAdapter();
        rowTappedListener.onRowTapped(adapter.getItem(position));
    }

}

结果片段：

public final class ResultFragment extends Fragment {

    private TextView resultLabel;

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View root = inflater.inflate(R.layout.result_fragment, container, false);

        resultLabel = (TextView) root.findViewById(R.id.result_label);
        if (savedInstanceState != null) {
            resultLabel.setText(savedInstanceState.getString("labelText", ""));
        }

        return root;
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);

        outState.putString("labelText", resultLabel.getText().toString());
    }

    void setResultText(String resultText) {
        resultLabel.setText(resultText);
    }

}

我已经能够使用普通的AsyncTask使其工作，但我正在尝试学习更多关于Loader的知识，因为它们可以自动处理配置更改。

---

编辑：我认为我可能通过查看LoaderManager的源代码找到了问题所在。当在配置更改后调用initLoader时，LoaderInfo对象会将其mCallbacks字段更新为新活动作为LoaderCallbacks的实现，正如我所期望的那样。

public <D> Loader<D> initLoader(int id, Bundle args, LoaderManager.LoaderCallbacks<D> callback) {
    if (mCreatingLoader) {
        throw new IllegalStateException("Called while creating a loader");
    }

    LoaderInfo info = mLoaders.get(id);

    if (DEBUG) Log.v(TAG, "initLoader in " + this + ": args=" + args);

    if (info == null) {
        // Loader doesn't already exist; create.
        info = createAndInstallLoader(id, args,  (LoaderManager.LoaderCallbacks<Object>)callback);
        if (DEBUG) Log.v(TAG, "  Created new loader " + info);
    } else {
        if (DEBUG) Log.v(TAG, "  Re-using existing loader " + info);
        info.mCallbacks = (LoaderManager.LoaderCallbacks<Object>)callback;
    }

    if (info.mHaveData && mStarted) {
        // If the loader has already generated its data, report it now.
        info.callOnLoadFinished(info.mLoader, info.mData);
    }

    return (Loader<D>)info.mLoader;
}

然而，当有一个待处理的加载程序时，主 LoaderInfo 对象也具有一个 mPendingLoader 字段，其中包含对 LoaderCallbacks 的引用，但该对象不会使用 mCallbacks 字段中的新活动进行更新。我希望看到代码像这样：

// This line was already there
info.mCallbacks = (LoaderManager.LoaderCallbacks<Object>)callback;
// This line is not currently there
info.mPendingLoader.mCallbacks = (LoaderManager.LoaderCallbacks<Object>)callback;

似乎是因为这个原因，挂起的加载器在旧的活动实例上调用onLoadFinished。如果我在这个方法中设置断点并使用调试器进行我认为缺少的调用，那么一切都按照我的预期工作。

新的问题是：我发现了一个bug吗，还是这是预期的行为？

- Paul Blessing

---

事实证明，onLoadFinished()确实被调用了 - 只是它报告给旧的活动（在配置更改之前的那个活动），而不是新的活动。问题已经被编辑并且代码已经更新。 - Paul Blessing

为了举例说明，我们可以假设列表中的整数是产品ID，用于服务器调用以返回每个产品的详细信息。这有助于使示例不那么琐碎吗？ - Paul Blessing

问题已更新，其中包括从“LoaderManager”源代码中获得的新信息。代码示例也已更新，以模拟在选择每个产品ID时加载产品详细信息的更真实场景。 - Paul Blessing

我最近写了一篇关于“Loader”的博客文章...也许你会觉得有帮助 :) http://www.androiddesignpatterns.com/2012/08/implementing-loaders.html - Alex Lockwood

在 https://code.google.com/p/android/issues/detail?id=36778 上提交了问题。 - Paul Blessing

Answer 1

在大多数情况下，如果Activity已经被销毁，您应该忽略这样的报告。

public void onLoadFinished(Loader<String> loader, String data) {
    Log.d("DemoActivity", "onLoadFinished reporting to activity " + myActivityId);
    if (isDestroyed()) {
       Log.i("DemoActivity", "Activity already destroyed, report ignored: " + data);
       return;
    }
    resultFragment.setResultText(data);
}

此外，您应该在任何内部类中插入检查isDestroyed()。Runnable-是最常用的情况。

例如：

// UI thread
final Handler handler = new Handler();
Executor someExecutorService = ... ;
someExecutorService.execute(new Runnable() {
    public void run() {
        // some heavy operations
        ...
        // notification to UI thread
        handler.post(new Runnable() {
            // this runnable can link to 'dead' activity or any outer instance
            if (isDestroyed()) {
                return;
            }

            // we are alive
            onSomeHeavyOperationFinished();
        });
    }
});

但是在这种情况下，最好的方法是避免将Activity的强引用传递给其他线程（如AsynkTask、Loader、Executor等）。

最可靠的解决方案如下：

// BackgroundExecutor.java
public class BackgroundExecutor {
    private static final Executor instance = Executors.newSingleThreadExecutor();

    public static void execute(Runnable command) {
        instance.execute(command);
    }
}

// MyActivity.java
public class MyActivity extends Activity {
    // Some callback method from any button you want
    public void onSomeButtonClicked() {
        // Show toast or progress bar if needed

        // Start your heavy operation
        BackgroundExecutor.execute(new SomeHeavyOperation(this));
    }

    public void onSomeHeavyOperationFinished() {
        if (isDestroyed()) {
            return;
        }

        // Hide progress bar, update UI
    }
}

// SomeHeavyOperation.java
public class SomeHeavyOperation implements Runnable {
    private final WeakReference<MyActivity> ref;

    public SomeHeavyOperation(MyActivity owner) {
        // Unlike inner class we do not store strong reference to Activity here
        this.ref = new WeakReference<MyActivity>(owner);
    }

    public void run() {
        // Perform your heavy operation
        // ...
        // Done!

        // It's time to notify Activity
        final MyActivity owner = ref.get();
        // Already died reference
        if (owner == null) return;

        // Perform notification in UI thread
        owner.runOnUiThread(new Runnable() {
            public void run() {
                owner.onSomeHeavyOperationFinished();
            }
        });
    }
}

- Oleksii K.

Answer 2

一个可能的解决方案是在自定义单例对象中启动AsyncTask，并在Activity中访问onFinished()结果。每次旋转屏幕、暂停或恢复时，都会使用/访问最新的结果。如果您的单例对象仍然没有结果，那么您就知道它仍在忙碌中，或者您可以重新启动任务。

另一种方法是使用类似Otto的服务总线，或者使用Service。

- josomers

Answer 3

也许不是最好的解决方案，但... 这段代码每次都重新启动加载器，这是不好的，但是它是唯一有效的解决办法 - 如果你想使用加载器的话。

Loader l = getLoaderManager().getLoader(MY_LOADER);
if (l != null) {
    getLoaderManager().restartLoader(MY_LOADER, null, this);
} else {
    getLoaderManager().initLoader(MY_LOADER, null, this);
}

顺便说一下，我正在使用CursorLoader...

- Gordon Freeman

Answer 4

好的，我正在努力理解这个问题，如果我有任何误解，请原谅。但是当设备旋转时，您会丢失对某些内容的引用。

尝试一下...

是否添加

android:configChanges="orientation|keyboardHidden|screenSize"

在您的清单中为该活动修复错误？或者防止onLoadFinished()说活动停止？

- StrikeForceZero

---

这可能是一个解决方法，但很可能是Android中的真正错误。 - Steve Pomeroy

@StevePomeroy 不一定，当设备旋转时，活动会被重新创建，从而重新初始化任何对象或其他变量的引用。这可以通过将其传递给活动本身来防止系统重新创建活动，使其能够处理/覆盖方向更改。如果设备进入横向模式，则某些布局元素可能会被重新调整大小或重新定位。 - StrikeForceZero

@StevePomeroy 你的异步加载器永远不会真正完成，因为它在活动销毁和重建时被处理掉了。 - StrikeForceZero

请查看上面列出的错误（https://code.google.com/p/android/issues/detail?id=36778）并尝试运行示例代码。该行为非常不寻常，肯定不是所期望的（除非它本来就是意图不起作用）。 - Steve Pomeroy

另外，你是对的 - 自己处理配置更改是解决问题的一种方式。但是如果Android因某些未被配置更改调用处理的原因而清理了你的活动，该怎么办？仍然很重要修复出现的错误，当你没有自己处理配置更改时。 - Steve Pomeroy