public synchronized void register(KeyMatcher matcher, VehicleMessage.Listener listener) { register(matcher, listener, true); }
/** * 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); }
/** * Register to receive asynchronous updates for a specific Measurement type. * * A Measurement is a specific, known VehicleMessage subtype. * * Use this method to register an object implementing the * Measurement.Listener interface to receive real-time updates * whenever a new value is received for the specified measurementType. * * Make sure you unregister your listeners with * VehicleManager.removeListener(...) when your activity or service closes * and no longer requires updates. * * @param measurementType The class of the Measurement * (e.g. VehicleSpeed.class) the listener was listening for * @param listener An listener instance to receive the callback. */ public void addListener(Class<? extends Measurement> measurementType, Measurement.Listener listener) { Log.i(TAG, "Adding listener " + listener + " for " + measurementType); mNotifier.register(measurementType, listener); }
/** * Register to receive asynchronous updates for a specific VehicleMessage * type. * * Use this method to register an object implementing the * VehicleMessage.Listener interface to receive real-time updates * whenever a new value is received for the specified message type. * * Make sure you unregister your listeners with * VehicleManager.removeListener(...) when your activity or service closes * and no longer requires updates. * * @param messageType The class of the VehicleMessage * (e.g. SimpleVehicleMessage.class) the listener is listening for * @param listener An listener instance to receive the callback. */ public void addListener(Class<? extends VehicleMessage> messageType, VehicleMessage.Listener listener) { Log.i(TAG, "Adding listener " + listener + " for " + messageType); mNotifier.register(messageType, listener); }
@Test public void typeListenerDoesntReceiveOtherMessages() throws DataSinkException, UnrecognizedMeasurementTypeException { CanMessage message = new CanMessage(1, 2, new byte[]{1,2,3,4,5,6,7,8}); sink.register(DiagnosticResponse.class, messageListener); assertThat(messageReceived, nullValue()); }
/** * Send a message to the VehicleInterface and register the given listener to * receive the first response matching the message's key. * * This function is non-blocking. * * The listener is unregistered after the first response is received. If you * need to accept multiple responses for the same request, you must manually * register your own listener to control its lifecycle. * * @param message The desired message to send to the vehicle. * @param listener The message listener that should receive a callback when * a response matching the outgoing message's key is received from the * VI. */ public void request(KeyedMessage message, VehicleMessage.Listener listener) { // Register the listener as non-persistent, so it is deleted after // receiving the first response mNotifier.register(ExactKeyMatcher.buildExactMatcher(message.getKey()), listener, false); send(message); }
@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()); }
@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 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 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 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()); }
@Test public void listenerReceivesMeasurement() throws DataSinkException, UnrecognizedMeasurementTypeException { VehicleSpeed speed = new VehicleSpeed(42.0); sink.register(speed.getClass(), speedListener); sink.receive(speed.toVehicleMessage()); sink.clearQueue(); assertThat(speedReceived, notNullValue()); assertEquals(speedReceived, speed); }
@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()); }
@Test public void receiveNonMatchingMeasurementNotPropagated() throws DataSinkException, UnrecognizedMeasurementTypeException { VehicleSpeed speed = new VehicleSpeed(42.0); sink.register(speed.getClass(), speedListener); SteeringWheelAngle angle = new SteeringWheelAngle(10.1); sink.receive(angle.toVehicleMessage()); sink.clearQueue(); assertThat(speedReceived, nullValue()); }
@Test public void receiveNonMatchingNotPropagated() throws DataSinkException { NamedVehicleMessage message = new NamedVehicleMessage("foo"); sink.register(ExactKeyMatcher.buildExactMatcher(message), listener); message = new NamedVehicleMessage("bar"); sink.receive(message); sink.clearQueue(); assertThat(listener.received, nullValue()); }
@Test public void listenerRecievesMessage() 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); }
@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 nonKeyedIgnored() throws DataSinkException { KeyedMessage message = new NamedVehicleMessage("foo"); sink.register(ExactKeyMatcher.buildExactMatcher(message), listener); sink.receive(new VehicleMessage()); }