标签: otto

我已经Otto在我最新的Android项目中尝试过,它确实简化了对象之间的通信.但是,我不确定Threads与它之间的通信是否存在任何隐藏的问题.

这就是我所做的,创建了一个SingletonBus使用,enum以便可以在任何地方访问总线:

public enum SingletonBus {
    INSTANCE;

    private static String TAG = SingletonBus.class.getSimpleName();

    private Bus bus;

    private boolean paused;

    private final Vector<Object> eventQueueBuffer = new Vector<>();

    private Handler handler = new Handler(Looper.getMainLooper());

    private SingletonBus() {
        this.bus = new Bus(ThreadEnforcer.ANY);
    }

    public <T> void postToSameThread(final T event) {
        bus.post(event);
    }

    public <T> void postToMainThread(final T event) {
        try {
            if(paused) {
                eventQueueBuffer.add(event);
            } else {
                handler.post(new Runnable() {
                    @Override
                    public void run() {
                        try { …

我为Android开发了一些应用程序,并始终指出我需要在其中进行通信的地方

• 片段到活动
• 对片段的活动
• 片段碎片
• 服务碎片
• 等等

在Android 文档中,他们建议使用接口在Activity和Fragment之间进行通信.但我有4个片段,然后我的Activity需要实现4个接口.我的意图是对的？

所以我尝试了奥托,值得尝试一下.但是我认识到,如果你不跟踪公交活动,你会感到非常困惑.

我正在寻找避免这些方法的策略.谷歌或其他主要开发商是如何做到的？

Otto如何处理不同的事件类？可以有不同的事件类吗？

只有听取特定事件类的听众才会收到通知吗？例如下面的示例是否可以工作,只有A类中的监听器被通知？假设EventClassA并且EventClassB不扩展相同的超类.

class A {
    @Subscribe
    public void handleEvent(EventClassA event)
    {
            //
    }
}

class B {
    @Subscribe
    public void handleEvent(EventClassB event)
    {
            //
    }
}

class C {
    public void postEvent() {
        bus.post(new EventClassA());
    }
}

我对使用事件总线并不陌生，但是在以下情况下出现了奇怪的行为：

我有MainActivity，其中有两个片段需要使用Otto从MainActivity启动的SecondActivity中的事件总线来更新其内容。问题是，当SecondActivity启动时，MainActivity暂停，因此，该总线将在其onPause方法内取消注册，并且EventBus从SecondActivity触发其事件时，MainActivity下的两个片段将不会接收到该总线。

顺便说一句，MainActivity有一个订户方法来从AsyncTask线程接收更新，因此它也应该注册和注销事件总线。

这是我的BusProvider课程代码：

public class BusProvider {

   private static final Bus BUS = new Bus(ThreadEnforcer.ANY);

   public static Bus getInstance() {
       return BUS;
   }

   private BusProvider() {
   }
}

这是我的MainActivity事件总线代码：

@Override
protected void onResume() {
    super.onResume();
    bus.register(this);
}

@Override
protected void onPause() {
    super.onPause();
    bus.unregister(this);
}

@Subscribe
public void onAsyncResult(SomeEvent event) {
    // do something
}

这是我的FragmentA和FragmentB事件总线代码：

@Override
protected void onResume() {
    super.onResume();
    bus.register(this);
}

@Override
protected void onPause() { …

我在我的应用程序中使用Otto作为事件总线.我去了square.github.io/otto.它说'发布到总线是一个同步动作,因此当程序执行继续时,保证所有用户都被调用.' 我很好奇为什么它不提供异步发布.如果我们只有同步发布,那么性能是否会成为一个问题？这是否意味着总线事件的接收者应该通过使用其他异步任务或线程来考虑性能问题,以防止阻止一切？

谢谢.

我的BaseActivity具有register（）和unregister（）方法：

public class BaseActivity extends AppCompatActivity{

    ...

    @Override
    protected void onResume() {
        super.onResume();
        // Register ourselves so that we can provide the initial value.
        BusProvider.getInstance().register(this);
    }

    @Override
    protected void onPause() {
        super.onPause();
        // Always unregister when an object no longer should be on the bus.
        BusProvider.getInstance().unregister(this);
    }

    protected void setFragment(Fragment fragment){
        FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();
        transaction.replace(ROOT_CONTAINER_ID, fragment);
        if(!isFinishing()) {
            transaction.commitAllowingStateLoss();
        }
    }


}

我有ChildActivity，它将DoneEvent触发到FrDetails片段，并且工作正常。

public class ChildActivity extends BaseActivity implements View.OnClickListener{

    private ImageView btnDone;

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