Question

我对装载机有一个奇怪的问题。目前我不确定这是否是我的代码中的错误或我误解了加载器。

该应用

问题出现在对话中（想象类似于Whatsapp的东西）。我使用的加载器是基于AsyncTaskLoader example实现的。我正在使用支持库。

在OnCreate中，我启动一个加载程序来检索缓存的邮件。
当CachedMessageLoader完成时，它会启动RefreshLoader以检索（在线）最新消息。
每个加载器类型作为不同的ID（例如，离线：1在线：2）

这非常有效，但有以下例外。

问题

当我打开另一个片段（并将事务添加到backstack）然后使用Back-Key返回conversationFragment时，再次调用{em>两个的结果来调用onLoadFinished之前。在片段有机会再次启动加载器之前发生此调用...

我之前获得的“旧”结果的传递导致重复的消息。

问题

为什么会再次提供这些结果？
我是否错误地使用这些装载机？
我可以“使结果无效”以确保我只将它们送到一次或者我必须自己消除重复吗？

堆栈跟踪跟踪

MyFragment.onLoadFinished(Loader, Result) line: 369 
MyFragment.onLoadFinished(Loader, Object) line: 1   
LoaderManagerImpl$LoaderInfo.callOnLoadFinished(Loader, Object) line: 427   
LoaderManagerImpl$LoaderInfo.reportStart() line: 307    
LoaderManagerImpl.doReportStart() line: 768 
MyFragment(Fragment).performStart() line: 1511  
FragmentManagerImpl.moveToState(Fragment, int, int, int, boolean) line: 957 
FragmentManagerImpl.moveToState(int, int, int, boolean) line: 1104  
BackStackRecord.popFromBackStack(boolean) line: 764 
...

更新1 这里提到的加载器是由对话片段启动的：

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setHasOptionsMenu(true);
    Bundle args = getArguments();
    m_profileId = args.getString(ArgumentConstants.ARG_USERID);
    m_adapter = new MessageAdapter(this);

    if (savedInstanceState != null) {
        restoreInstanceState(savedInstanceState);
    }
    if (m_adapter.isEmpty()) {
        Bundle bundle = new Bundle();
        bundle.putString(ArgumentConstants.ARG_USERID, m_profileId);
        getLoaderManager().restartLoader(R.id.loader_message_initial, bundle, this);
    } else {
        // Omitted: Some arguments passed in Bundle
        Bundle b = new Bundle(). 
        getLoaderManager().restartLoader(R.id.loader_message_refresh, b, this);
    }
}

@Override
public void onResume() {
    super.onResume();
    // Omitted: setting up UI state / initiating other loaders that work fine
}

@Override
public AbstractMessageLoader onCreateLoader(final int type, final Bundle bundle) {
    final SherlockFragmentActivity context = getSherlockActivity();
    context.setProgressBarIndeterminateVisibility(true);
    switch (type) {
        case R.id.loader_message_empty:
            return new EmptyOnlineLoader(context, bundle);
        case R.id.loader_message_initial:
            return new InitialDBMessageLoader(context, bundle);
        case R.id.loader_message_moreoldDB:
            return new OlderMessageDBLoader(context, bundle);
        case R.id.loader_message_moreoldOnline:
            return new OlderMessageOnlineLoader(context, bundle);
        case R.id.loader_message_send:
            sendPreActions();
            return new SendMessageLoader(context, bundle);
        case R.id.loader_message_refresh:
            return new RefreshMessageLoader(context, bundle);
        default:
            throw new UnsupportedOperationException("Unknown loader");
    }
}

@Override
public void onLoadFinished(Loader<Holder<MessageResult>> loader, Holder<MessageResult> holder) {
    if (getSherlockActivity() != null) {
        getSherlockActivity().setProgressBarIndeterminateVisibility(false);
    }
    // Omitted: Error handling of result (can contain exception)
    List<PrivateMessage> unreadMessages = res.getUnreadMessages();
    switch (type) {
        case R.id.loader_message_moreoldDB: {
            // Omitted error handling (no data)
            if (unreadMessages.isEmpty()) {
                m_hasNoMoreCached = true;
                // Launch an online loader
                Bundle b = new Bundle();
                // Arguments omitted
                getLoaderManager().restartLoader(R.id.loader_message_moreoldOnline, b, ConversationFragment.this);
            }
            // Omitted: Inserting results into adapter
        }
        case R.id.loader_message_empty: { // Online load when nothing in DB
            // Omitted: error/result handling handling
            break;
        }
        case R.id.loader_message_initial: { // Latest from DB, when opening
            // Omitted: Error/result handling

            // If we found nothing, request online
            if (unreadMessages.isEmpty()) {
                 Bundle b = new Bundle();
                 // Omitted: arguments
                 getLoaderManager().restartLoader(R.id.loader_message_empty, b, this);
             } else {
                // Just get new stuff
                Bundle b = new Bundle();
               // Omitted: Arguments
               getLoaderManager().restartLoader(R.id.loader_message_refresh, b, this);
            }
            break;
        }
        // Omitted: Loaders that do not start other loaders, but only add returned data to the adapter
        default:
            throw new IllegalArgumentException("Unknown loader type " + type);
    }
    // Omitted: Refreshing UI elements
}

@Override
public void onLoaderReset(Loader<Holder<MessageResult>> arg0) { }

更新2 我的MainActivity（最终托管所有片段）子类SherlockFragmentActivity并基本上启动这样的片段：

    Fragment f = new ConversationFragment(); // Setup omitted
    f.setRetainInstance(false);
    // Omitted: Code related to navigation drawer
    FragmentManager fragmentManager = getSupportFragmentManager();
    fragmentManager.beginTransaction().replace(R.id.fragment_container_frame, f).commit();

会话片段启动“显示配置文件”片段，如下所示：

DisplayProfileFragment f = new DisplayProfileFragment();
// Arguments omitted
FragmentManager manager = getSherlockActivity().getSupportFragmentManager();
FragmentTransaction transaction = manager.beginTransaction();
transaction.replace(R.id.fragment_container_frame, f).addToBackStack(null).commit();

Answer 1

还有其他类似问题，例如Android: LoaderCallbacks.OnLoadFinished called twice但是加载程序管理器挂钩的行为就是它们的本质。您可以在获得第一组结果后销毁加载器

public abstract void destroyLoader (int id)

或者你可以处理onLoaderReset并将你的UI数据更紧密地绑定到加载器数据

public abstract void onLoaderReset (Loader<D> loader)

在重置先前创建的加载程序时调用，因此使其数据不可用。应用程序应该在这一点上删除它对Loader数据的任何引用。

就个人而言，我会使用ContentProvider和CursorLoader（每行数据都需要一个唯一的_ID，但对于不应该有问题的消息）。

Answer 2

在onResume（）中使用此操作

 @Override
public void onResume() {
    super.onResume();
    getLoaderManager().initLoader(0, null, this);
}

我从中解决了我的问题 this is same type Q

为什么在片段恢复后再次调用onLoadFinished？

2 个答案: