public synchronized void register(KeyMatcher matcher, VehicleMessage.Listener listener) { register(matcher, listener, true); }
/** * Unregister a previously registered key matcher listener. * * @param matcher The KeyMatcher this listener was previously registered * to receive matches from. * @param listener The listener to remove. */ public void removeListener(KeyMatcher matcher, VehicleMessage.Listener listener) { mNotifier.unregister(matcher, listener); }
@Override public String toString() { return MoreObjects.toStringHelper(this) .add("numMessageListeners", mMessageListeners.size()) .add("numMessageTypeListeners", mMessageTypeListeners.size()) .add("numPersistentMessageListeners", getNumPersistentListeners()) .add("numMeasurementTypeListeners", mMeasurementTypeListeners.size()) .toString(); }
@Test public void removeMessageTypeListener() throws DataSinkException { CanMessage message = new CanMessage(1, 2, new byte[]{1,2,3,4,5,6,7,8}); sink.register(message.getClass(), messageListener); sink.unregister(message.getClass(), messageListener); sink.receive(message); sink.clearQueue(); assertThat(messageReceived, nullValue()); }
@Test public void listenerRecievesMessageContinually() throws DataSinkException { NamedVehicleMessage message = new NamedVehicleMessage("foo"); sink.register(ExactKeyMatcher.buildExactMatcher(message), listener); sink.receive(message); sink.clearQueue(); assertThat(listener.received, notNullValue()); assertEquals(listener.received, message); listener.received = null; sink.receive(message); assertThat(listener.received, nullValue()); }
pruneListeners(matcher); propagateMeasurementFromMessage(message.asSimpleMessage());
public synchronized void unregister(KeyMatcher matcher, VehicleMessage.Listener listener) { MessageListenerGroup group = mMessageListeners.get(matcher); if (group != null) { group.removePersistent(listener); pruneListeners(matcher); } }
@Test public void toStringNotNull() { assertThat(sink.toString(), notNullValue()); }
@After public void tearDown() { sink.stop(); }
@Before public void setUp() { sink = new MessageListenerSink(); }
@Test public void receiveUnrecognizedSimpleMessage() throws DataSinkException, UnrecognizedMeasurementTypeException { SimpleVehicleMessage message = new SimpleVehicleMessage("foo", "bar"); sink.receive(message); }
@Test public void removeMeasurementListenerByClass() throws UnrecognizedMeasurementTypeException, DataSinkException { VehicleSpeed speed = new VehicleSpeed(42.0); sink.register(speed.getClass(), speedListener); sink.unregister(speed.getClass(), speedListener); sink.receive(speed.toVehicleMessage()); sink.clearQueue(); assertThat(speedReceived, nullValue()); }
@Test public void receiveCanMessageByClass() throws DataSinkException, UnrecognizedMeasurementTypeException { CanMessage message = new CanMessage(1, 2, new byte[]{1,2,3,4,5,6,7,8}); sink.register(message.getClass(), messageListener); sink.receive(message); sink.clearQueue(); assertThat(messageReceived, notNullValue()); assertEquals(messageReceived, message); }
@Test public void removeMeasurementListener() throws UnrecognizedMeasurementTypeException, DataSinkException { VehicleSpeed speed = new VehicleSpeed(42.0); sink.register(speed.getClass(), speedListener); sink.unregister(speed.getClass(), speedListener); sink.receive(speed.toVehicleMessage()); sink.clearQueue(); assertThat(speedReceived, nullValue()); }
@Test public void nonpersistentRemovedAfterOne() throws DataSinkException { NamedVehicleMessage message = new NamedVehicleMessage("foo"); sink.register(ExactKeyMatcher.buildExactMatcher(message), listener, false); sink.receive(message); sink.clearQueue(); assertThat(listener.received, notNullValue()); assertEquals(listener.received, message); listener.received = null; sink.receive(message); assertThat(listener.received, nullValue()); }
/** * Register to receive a callback when a message with key matching the given * KeyMatcher is received. * * This function can be used to set up a wildcard listener, or one that * receives a wider range of responses than just a 1 to 1 match of keys. * * @param matcher A KeyMatcher implement the desired filtering logic. * @param listener An listener instance to receive the callback. */ public void addListener(KeyMatcher matcher, VehicleMessage.Listener listener) { Log.i(TAG, "Adding listener " + listener + " to " + matcher); mNotifier.register(matcher, listener); }
/** * Unregister a previously registered message type listener. * * @param messageType The class of the VehicleMessage this listener was * registered to receive. A listener can be registered to receive * multiple message types, which is why this must be specified when * removing a listener. * @param listener The listener to remove. */ public void removeListener(Class<? extends VehicleMessage> messageType, VehicleMessage.Listener listener) { mNotifier.unregister(messageType, listener); }
@Test public void removeMessageListener() throws UnrecognizedMeasurementTypeException, DataSinkException { NamedVehicleMessage message = new NamedVehicleMessage("foo"); sink.register(ExactKeyMatcher.buildExactMatcher(message), listener); sink.unregister(ExactKeyMatcher.buildExactMatcher(message), listener); sink.receive(message); sink.clearQueue(); assertThat(listener.received, nullValue()); }
@Test public void messageAndMeasurementListenersBothReceive() throws DataSinkException, UnrecognizedMeasurementTypeException { VehicleSpeed speed = new VehicleSpeed(42.0); VehicleMessage message = speed.toVehicleMessage(); sink.register(ExactKeyMatcher.buildExactMatcher((KeyedMessage) message), listener); sink.register(speed.getClass(), speedListener); sink.receive(speed.toVehicleMessage()); sink.clearQueue(); assertThat(speedReceived, notNullValue()); assertThat(listener.received, notNullValue()); }