@Override
public void cancelDelayed(Class<?> eventClass) {
if (eventClass == null) {
throw new NullPointerException("Event class must not be null");
}
mImpl.cancelDelayed(eventClass, getMainHandlerNotNull());
}
@Override
public void postDelayed(Object event, long delayMillis) {
if (event == null) {
throw new NullPointerException("Event must not be null");
}
Handler handler = getMainHandlerNotNull();
if (handler.getLooper().getThread().isAlive()) {
mImpl.postDelayed(event, delayMillis, handler);
} // otherwise the bus is already stopped
}
public TinyBus(Context context) {
mImpl = new TinyBusImpl();
mImpl.attachContext(context);
mTaskQueue = new TaskQueue();
mMainThread = Thread.currentThread();
final Looper looper = Looper.myLooper();
mMainHandler = looper == null ? null : new Handler(looper);
}
@SuppressWarnings("unchecked")
public <T extends Wireable> T unwire(Class<T> wireClass) {
assertObjectAndWorkerThread(wireClass);
Context context = mImpl.getNotNullContext();
Wireable wireable = getWireable(wireClass);
if (wireable != null) {
if (context instanceof Application || context instanceof Service) {
wireable.onStop();
wireable.onDestroy();
}
mWireables.remove(wireable);
}
return (T) wireable;
}
public TinyBus wire(Wireable wireable) {
assertObjectAndWorkerThread(wireable);
Context context = mImpl.getNotNullContext();
if (mWireables == null) {
mWireables = new ArrayList<Wireable>();
}
mWireables.add(wireable);
wireable.onCreate(this, context.getApplicationContext());
wireable.assertSuperOnCreateCalled();
if (context instanceof Application || context instanceof Service) {
wireable.onStart();
}
// TODO, what to do with already started activity?
return this;
}
void processQueue() {
Task task;
ObjectsMeta meta;
Object obj;
Class<?> objClass;
mProcessing = true;
try {
while ((task = mTaskQueue.poll()) != null) {
obj = task.obj;
objClass = obj.getClass();
switch (task.code) {
case Task.CODE_REGISTER:
{
meta = OBJECTS_METAS.get(objClass);
if (meta == null) {
meta = new ObjectsMeta(obj);
OBJECTS_METAS.put(objClass, meta);
}
meta.registerAtReceivers(obj, mEventSubscribers);
meta.registerAtProducers(obj, mEventProducers);
try {
meta.dispatchEvents(obj, mEventSubscribers, OBJECTS_METAS, mImpl);
meta.dispatchEvents(mEventProducers, obj, OBJECTS_METAS, mImpl);
} catch (Exception e) {
throw handleExceptionOnEventDispatch(e);
}
break;
}
case Task.CODE_UNREGISTER:
{
meta = OBJECTS_METAS.get(objClass);
meta.unregisterFromReceivers(obj, mEventSubscribers);
meta.unregisterFromProducers(obj, mEventProducers);
break;
}
case Task.CODE_POST:
{
final HashSet<Object> receivers = mEventSubscribers.get(objClass);
if (receivers != null) {
Set<SubscriberCallback> subscriberCallback;
try {
for (Object receiver : receivers) {
meta = OBJECTS_METAS.get(receiver.getClass());
subscriberCallback = meta.getEventCallback(objClass);
mImpl.dispatchEvent(subscriberCallback, receiver, obj);
}
} catch (Exception e) {
throw handleExceptionOnEventDispatch(e);
}
}
break;
}
default:
throw new IllegalStateException("unexpected task code: " + task.code);
}
task.recycle();
}
} finally {
mProcessing = false;
}
}
