Android LoaderCallbacks.onLoadFinished with Fragment transaction:是否正确？

有人能告诉我我是否理解正确吗？我所做的似乎是有效的，但它似乎比许多装载机示例更为复杂。。。我不知道我是否有过复杂的事情。我有一个使用多个AsyncTaskLoader的活动。因此，我为LoaderCallback实现内部类，而不是让活动实现LoaderCallback接口。我了解到匿名内部类可能泄漏活动，因此我不得不将其创建为静态类，并对活动进行弱引用。onLoadFinished需要执行一个片段事务，因此我需要一个处理程序。同样，内部类活动泄漏问题，因此处理程序是一个静态类。此外，我了解到可以在暂停活动时调用handleMessage，因此我需要在处理程序中实现pause和resume方法。这真的是必要的吗

 //here are the relavent bits from my activity
private static class SessionListener implements LoaderManager.LoaderCallbacks<SessionStatus> {
    private final WeakReference<MainActivity> mTarget;

    private SessionListener(MainActivity target) {
        this.mTarget = new WeakReference<>(target);
    }

    @Override
    public Loader<SessionStatus> onCreateLoader(int id, Bundle args) {
        return  new SessionCheckLoader(mTarget.get(), args);
    }

    @Override
    public void onLoadFinished(Loader<SessionStatus> arg0, SessionStatus arg1) {
        MainActivity target = mTarget.get();

        if (arg1 == MainActivity.SessionStatus.CLOSED && target != null) {
            target.mHandler.sendEmptyMessage(MSG_SHOW_CLOSED_DIALOG);
        }
    }

    @Override
    public void onLoaderReset(Loader<SessionStatus> arg0) {


    }
};

//the handler with pause/resume
 private static class HandlerClass extends Handler {
    private final WeakReference<MainActivity> mTarget;

    public HandlerClass(MainActivity context) {
        mTarget = new WeakReference<>(context);
    }
    Stack<Message> s = new Stack<>();
    boolean is_paused = false;

    public synchronized void pause() {
        is_paused = true;
    }

    public synchronized void resume()  {
        is_paused = false;
        while (! s.empty())
        {
            sendMessageAtFrontOfQueue(s.pop());
        }
    }
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        if (is_paused) {
            s.push(Message.obtain(msg));
            return;
        }
        MainActivity target = mTarget.get();
        if (target != null) {
            if (msg.what == MSG_SHOW_CLOSED_DIALOG) {
                target.sessionDialog();
            }else if (msg.what == MSG_POP_STACK) {
                target.getSupportFragmentManager().popBackStack(null, 0);
            }
        }
    }
}

 private LoaderManager.LoaderCallbacks<SessionStatus> sessionCheckListener = new SessionListener(this);
private HandlerClass mHandler = new HandlerClass(this);

@Override
protected void onPause() {
    super.onPause();
    mHandler.pause();
}

@Override
protected void onPostResume() {
    super.onPostResume();
    mHandler.resume();
}

//以下是我活动中的相关信息
私有静态类SessionListener实现LoaderManager.LoaderCallbacks{
私有最终WeakReference mTarget；
专用会话侦听器（主活动目标）{
this.mTarget=新的WeakReference（目标）；
}
@凌驾
公共加载器onCreateLoader（int-id，Bundle-args）{
返回新的SessionCheckLoader（mTarget.get（），args）；
}
@凌驾
public void onLoadFinished（加载程序arg0，会话状态arg1）{
MainActivity target=mTarget.get（）；
如果（arg1==MainActivity.SessionStatus.CLOSED&&target！=null）{
target.mHandler.sendEmptyMessage（消息显示\关闭\对话框）；
}
}
@凌驾
公共void onLoaderReset（加载程序arg0）{
}
};
//具有暂停/恢复的处理程序
私有静态类HandlerClass扩展处理程序{
私有最终WeakReference mTarget；
公共HandlerClass（MainActivity上下文）{
mTarget=新的WeakReference（上下文）；
}
堆栈s=新堆栈（）；
布尔值为_=false；
公共同步的无效暂停（）{
是否暂停=真；
}
公共同步无效恢复（）{
is_=false；
而（！s.empty（））
{
sendMessageAtFrontOfQueue（s.pop（））；
}
}
@凌驾
公共无效handleMessage（消息消息消息）{
超级handleMessage（msg）；
如果（是否已暂停）{
s、 推送（Message.get（msg））；
回来
}
MainActivity target=mTarget.get（）；
如果（目标！=null）{
如果（msg.what==msg\u显示\u关闭\u对话框）{
target.sessionDialog（）；
}else if（msg.what==msg\u POP\u堆栈）{
target.getSupportFragmentManager（）.popBackStack（null，0）；
}
}
}
}
私有LoaderManager.LoaderCallbacks sessionCheckListener=新SessionListener（此）；
私有HandlerClass mHandler=新HandlerClass（本）；
@凌驾
受保护的void onPause（）{
super.onPause（）；
暂停（）；
}
@凌驾
PostResume（）上的受保护无效{
super.onPostResume（）；
mHandler.resume（）；
}

您仍然可以在

活动中实现回调。调用
initLoader（）
时，为每个
Loader
提供一个唯一的id。在每个回调中的
switch
语句中使用
Loader.getId（）
，以确定它是哪个
Loader
。
我已经查找了一个按照您所说的方式完成的示例，其中Loader具有不同的返回类型。我发现ppl说要实现不同的类。不过，我仍然希望看到这样一个示例。尝试使
活动
实现
装入器回调
，然后将其转换为
开关盒
中相应的装入器类型。我将尝试一下。那么，处理器部分正确吗？是否真的需要暂停/恢复？我想我很困惑，因为按照我的理解，处理程序是必需的，因为您不能从onLoadFinished方法提交片段事务，但是，在提交片段事务时，似乎也可以在不合适的时间调用处理程序？onLoadFinished保证在开始/停止之间调用，所以我认为您可以使用事务。你不必为暂停/恢复而烦恼。在可能的情况下，将加载程序放在相关片段而不是活动中，并使用主机活动接口模式在片段和主机活动之间进行通信。这将有助于将每个活动/片段限制为一个加载器，并大大简化代码。但它在javadoc for onLoadFinished中说：注意，在调用时通常不允许应用程序提交片段事务，因为这可能发生在活动状态保存后。