public <E> EventHandler<E> newEventHandler(int id, Object[] params) { return new EventHandler<>(mComponentScope, id, params); }
@Override public void dispatchEvent(E event) { mEventHandler1.dispatchEvent(event); mEventHandler2.dispatchEvent(event); }
@Test public void testIsEquivalentToWithOneNullParams() { EventHandler eventHandler1 = new EventHandler(mHasEventDispatcher, 1); EventHandler eventHandler2 = new EventHandler(mHasEventDispatcher, 1, new Object[0]); assertThat(eventHandler1.isEquivalentTo(eventHandler2)).isFalse(); assertThat(eventHandler2.isEquivalentTo(eventHandler1)).isFalse(); }
@Override public boolean isEquivalentTo(@Nullable EventHandler other) { if (this == other) { return true; } if (other == null) { return false; } if (other.getClass() != getClass()) { return false; } DelegatingEventHandler otherDelegating = (DelegatingEventHandler) other; return mEventHandler1.isEquivalentTo(otherDelegating.mEventHandler1) && mEventHandler2.isEquivalentTo(otherDelegating.mEventHandler2); } }
@Test public void testIsEquivalentToNormalEventHandler() { EventHandler<Object> eventHandler1 = new DelegatingEventHandler<>(mEventHandler1, mEventHandler2); assertThat(eventHandler1.isEquivalentTo(mEventHandler1)).isFalse(); assertThat(mEventHandler1.isEquivalentTo(eventHandler1)).isFalse(); }
EventHandler newEventHandler(int id) { return new EventHandler(mComponentScope, id); }
@Test public void testIsEquivalentToWithBothNullParams() { EventHandler eventHandler1 = new EventHandler(mHasEventDispatcher, 1); EventHandler eventHandler2 = new EventHandler(mHasEventDispatcher, 1); assertThat(eventHandler1.isEquivalentTo(eventHandler2)).isTrue(); assertThat(eventHandler2.isEquivalentTo(eventHandler1)).isTrue(); }
@Override public @Nullable Object dispatchOnEvent(EventHandler eventHandler, Object eventState) { if (ComponentsConfiguration.enableOnErrorHandling && eventHandler.id == ERROR_EVENT_HANDLER_ID) { ((Component) this).getErrorHandler().dispatchEvent(((ErrorEvent) eventState)); } // Don't do anything by default, unless we're handling an error. return null; }
case Comparable.EVENT_HANDLER_IN_PARAMETERIZED_TYPE: if (val1 != null ? !((EventHandler) val1).isEquivalentTo((EventHandler) val2) : val2 != null) { return false;
@Override public <E> EventHandler<E> newEventHandler(int id, Object[] params) { final Section section = mScope.get(); if (section == null) { throw new IllegalStateException("Called newEventHandler on a released Section"); } return new EventHandler<>(section, id, params); }
@Test public void testIsEquivalentToFirstParamCanBeDifferent() { EventHandler eventHandler1 = new EventHandler(mHasEventDispatcher, 1, new Object[] {1, 2, 3}); EventHandler eventHandler2 = new EventHandler(mHasEventDispatcher, 1, new Object[] {2, 2, 3}); assertThat(eventHandler1.isEquivalentTo(eventHandler2)).isTrue(); assertThat(eventHandler2.isEquivalentTo(eventHandler1)).isTrue(); } }
@Override public void run() { if (mReMeasureEventEventHandler != null) { mReMeasureEventEventHandler.dispatchEvent(new ReMeasureEvent()); } } };
@Test public void testIsEquivalentToWithSameUnderlyingHandlers() { EventHandler<Object> eventHandler1 = new DelegatingEventHandler<>(mEventHandler1, mEventHandler2); EventHandler<Object> eventHandler2 = new DelegatingEventHandler<>(mEventHandler1, mEventHandler2); assertThat(eventHandler1.isEquivalentTo(eventHandler2)).isTrue(); assertThat(eventHandler2.isEquivalentTo(eventHandler1)).isTrue(); }
protected static <E> EventHandler<E> newEventHandler( Section c, int id, Object[] params) { final EventHandler eventHandler = new EventHandler<E>(c, id, params); recordEventHandler(c, eventHandler); return eventHandler; }
@Test public void testIsEquivalentToWithDifferentIds() { EventHandler eventHandler1 = new EventHandler(mHasEventDispatcher, 1); EventHandler eventHandler2 = new EventHandler(mHasEventDispatcher, 2); assertThat(eventHandler1.isEquivalentTo(eventHandler2)).isFalse(); assertThat(eventHandler2.isEquivalentTo(eventHandler1)).isFalse(); }
public static void dispatchLoadingEvent( SectionContext context, boolean isEmpty, LoadingEvent.LoadingState loadingState, @Nullable Throwable t) { final EventHandler<LoadingEvent> loadingEventHandler = getLoadingEventHandler(context); if (loadingEventHandler != null) { LoadingEvent loadingEvent = new LoadingEvent(); loadingEvent.isEmpty = isEmpty; loadingEvent.loadingState = loadingState; loadingEvent.t = t; loadingEventHandler.dispatchEvent(loadingEvent); } }
@Test public void testIsEquivalentToWithDifferentUnderlyingHandlers() { EventHandler<Object> eventHandler1 = new DelegatingEventHandler<>(mEventHandler1, mEventHandler2); EventHandler<Object> eventHandler2 = new DelegatingEventHandler<>(mEventHandler2, mEventHandler1); assertThat(eventHandler1.isEquivalentTo(eventHandler2)).isFalse(); assertThat(eventHandler2.isEquivalentTo(eventHandler1)).isFalse(); } }
return new EventHandler<>( new HasEventDispatcher() { @Override
@Test public void testIsEquivalentToWithDifferentParams() { EventHandler eventHandler1 = new EventHandler(mHasEventDispatcher, 1, new Object[] {1, 2, 3}); EventHandler eventHandler2 = new EventHandler(mHasEventDispatcher, 1, new Object[] {1, 3, 3}); assertThat(eventHandler1.isEquivalentTo(eventHandler2)).isFalse(); assertThat(eventHandler2.isEquivalentTo(eventHandler1)).isFalse(); }
static void dispatchOnFullImpression( EventHandler<FullImpressionVisibleEvent> fullImpressionHandler) { assertMainThread(); if (sFullImpressionVisibleEvent == null) { sFullImpressionVisibleEvent = new FullImpressionVisibleEvent(); } fullImpressionHandler.dispatchEvent(sFullImpressionVisibleEvent); }