greenrobot/EventBus · error · EventBusException

Only the currently handled event may be aborted

Error message

Only the currently handled event may be aborted

What it means

Thrown by cancelEventDelivery(Object) when postingState.event != event — a reference-identity comparison against the event currently being dispatched on this thread. Cancellation can only abort the one event whose delivery loop is on the thread's PostingThreadState stack; passing a different instance (even an equal() one, e.g. a reconstructed copy or another event of the same class) is rejected because cancelling it would corrupt unrelated dispatch state.

Solutions

1. Always forward the exact instance from the subscriber method parameter to cancelEventDelivery(event)
2. Do not attempt to cancel past events — cancellation only affects subscribers that have not yet received the current event
3. If you need type-based suppression, unsubscribe or filter at post() time instead

Example fix

// before
EventBus.getDefault().cancelEventDelivery(new MessageEvent(id)); // new instance -> throws

// after
@Subscribe(threadMode = ThreadMode.POSTING, priority = 100)
public void onEvent(MessageEvent event) {
    EventBus.getDefault().cancelEventDelivery(event); // same instance being dispatched
}

// cancel must use the exact instance handed to the subscriber
@Subscribe(threadMode = ThreadMode.POSTING)
public void onEvent(MessageEvent event) {
    EventBus.getDefault().cancelEventDelivery(event); // same reference, never a copy
}

When it happens

Trigger: Constructing a new event instance (new MessageEvent(...)) and passing it to cancelEventDelivery instead of the instance received in the subscriber method; keeping the last event in a field and cancelling a previously delivered one; calling cancel for event B from inside the handler for event A.

Common situations: Developers assuming cancelEventDelivery works by event type or equality rather than instance identity; caching events and trying to retroactively cancel an already-delivered event.

Related errors

• Event may not be null
• event handlers may only abort the incoming event
• is a illegal @Subscribe method: must be public, non-static…
• @Subscribe method must have exactly 1 parameter but has
• This method may only be called from inside event handling…

AI-assisted analysis of greenrobot/EventBus@0194926b3b (2026-08-14). Data as JSON: /api/errors/6e292bfe37be86b3. Report an issue: GitHub.

Appendix: source

Thrown at EventBus/src/org/greenrobot/eventbus/EventBus.java:299

        }
    }

    /**
     * Called from a subscriber's event handling method, further event delivery will be canceled. Subsequent
     * subscribers
     * won't receive the event. Events are usually canceled by higher priority subscribers (see
     * {@link Subscribe#priority()}). Canceling is restricted to event handling methods running in posting thread
     * {@link ThreadMode#POSTING}.
     */
    public void cancelEventDelivery(Object event) {
        PostingThreadState postingState = currentPostingThreadState.get();
        if (!postingState.isPosting) {
            throw new EventBusException(
                    "This method may only be called from inside event handling methods on the posting thread");
        } else if (event == null) {
            throw new EventBusException("Event may not be null");
        } else if (postingState.event != event) {
            throw new EventBusException("Only the currently handled event may be aborted");
        } else if (postingState.subscription.subscriberMethod.threadMode != ThreadMode.POSTING) {
            throw new EventBusException(" event handlers may only abort the incoming event");
        }

        postingState.canceled = true;
    }

    /**
     * Posts the given event to the event bus and holds on to the event (because it is sticky). The most recent sticky
     * event of an event's type is kept in memory for future access by subscribers using {@link Subscribe#sticky()}.
     */
    public void postSticky(Object event) {
        synchronized (stickyEvents) {
            stickyEvents.put(event.getClass(), event);
        }
        // Should be posted after it is putted, in case the subscriber wants to remove immediately
        post(event);
    }

View on GitHub (pinned to 0194926b3b)