();
144 | for (Method m : e.getValue()) {
145 | handlers.add(new EventHandler(listener, m));
146 | }
147 | handlersInMethod.put(e.getKey(), handlers);
148 | }
149 | }
150 |
151 | return handlersInMethod;
152 | }
153 |
154 | private AnnotatedHandlerFinder() {
155 | // No instances.
156 | }
157 |
158 | }
159 |
--------------------------------------------------------------------------------
/src/com/squareup/otto/Bus.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2012 Square, Inc.
3 | * Copyright (C) 2007 The Guava Authors
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the "License");
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | */
17 |
18 | package com.squareup.otto;
19 |
20 | import java.lang.reflect.InvocationTargetException;
21 | import java.util.Collection;
22 | import java.util.HashMap;
23 | import java.util.HashSet;
24 | import java.util.LinkedList;
25 | import java.util.List;
26 | import java.util.Map;
27 | import java.util.Set;
28 | import java.util.concurrent.ConcurrentHashMap;
29 | import java.util.concurrent.ConcurrentLinkedQueue;
30 | import java.util.concurrent.ConcurrentMap;
31 | import java.util.concurrent.CopyOnWriteArraySet;
32 |
33 |
34 | /**
35 | * Dispatches events to listeners, and provides ways for listeners to register themselves.
36 | *
37 | * The Bus allows publish-subscribe-style communication between components without requiring the components to
38 | * explicitly register with one another (and thus be aware of each other). It is designed exclusively to replace
39 | * traditional Android in-process event distribution using explicit registration or listeners. It is not a
40 | * general-purpose publish-subscribe system, nor is it intended for interprocess communication.
41 | *
42 | *
Receiving Events
43 | * To receive events, an object should:
44 | *
45 | * - Expose a public method, known as the event handler, which accepts a single argument of the type of event
46 | * desired;
47 | * - Mark it with a {@link com.squareup.otto.Subscribe} annotation;
48 | * - Pass itself to an Bus instance's {@link #register(Object)} method.
49 | *
50 | *
51 | *
52 | * Posting Events
53 | * To post an event, simply provide the event object to the {@link #post(Object)} method. The Bus instance will
54 | * determine the type of event and route it to all registered listeners.
55 | *
56 | * Events are routed based on their type — an event will be delivered to any handler for any type to which the
57 | * event is assignable. This includes implemented interfaces, all superclasses, and all interfaces implemented
58 | * by superclasses.
59 | *
60 | *
When {@code post} is called, all registered handlers for an event are run in sequence, so handlers should be
61 | * reasonably quick. If an event may trigger an extended process (such as a database load), spawn a thread or queue it
62 | * for later.
63 | *
64 | *
Handler Methods
65 | * Event handler methods must accept only one argument: the event.
66 | *
67 | * Handlers should not, in general, throw. If they do, the Bus will wrap the exception and
68 | * re-throw it.
69 | *
70 | *
The Bus by default enforces that all interactions occur on the main thread. You can provide an alternate
71 | * enforcement by passing a {@link ThreadEnforcer} to the constructor.
72 | *
73 | *
Producer Methods
74 | * Producer methods should accept no arguments and return their event type. When a subscriber is registered for a type
75 | * that a producer is also already registered for, the subscriber will be called with the return value from the
76 | * producer.
77 | *
78 | * Dead Events
79 | * If an event is posted, but no registered handlers can accept it, it is considered "dead." To give the system a
80 | * second chance to handle dead events, they are wrapped in an instance of {@link com.squareup.otto.DeadEvent} and
81 | * reposted.
82 | *
83 | * This class is safe for concurrent use.
84 | *
85 | * @author Cliff Biffle
86 | * @author Jake Wharton
87 | */
88 | public class Bus {
89 | public static final String DEFAULT_IDENTIFIER = "default";
90 |
91 | /** All registered event handlers, indexed by event type. */
92 | private final ConcurrentMap, Set> handlersByType =
93 | new ConcurrentHashMap, Set>();
94 |
95 | /** All registered event producers, index by event type. */
96 | private final ConcurrentMap, EventProducer> producersByType =
97 | new ConcurrentHashMap, EventProducer>();
98 |
99 | /** Identifier used to differentiate the event bus instance. */
100 | private final String identifier;
101 |
102 | /** Thread enforcer for register, unregister, and posting events. */
103 | private final ThreadEnforcer enforcer;
104 |
105 | /** Used to find handler methods in register and unregister. */
106 | private final HandlerFinder handlerFinder;
107 |
108 | /** Queues of events for the current thread to dispatch. */
109 | private final ThreadLocal> eventsToDispatch =
110 | new ThreadLocal>() {
111 | @Override protected ConcurrentLinkedQueue initialValue() {
112 | return new ConcurrentLinkedQueue();
113 | }
114 | };
115 |
116 | /** True if the current thread is currently dispatching an event. */
117 | private final ThreadLocal isDispatching = new ThreadLocal() {
118 | @Override protected Boolean initialValue() {
119 | return false;
120 | }
121 | };
122 |
123 | /** Creates a new Bus named "default" that enforces actions on the main thread. */
124 | public Bus() {
125 | this(DEFAULT_IDENTIFIER);
126 | }
127 |
128 | /**
129 | * Creates a new Bus with the given {@code identifier} that enforces actions on the main thread.
130 | *
131 | * @param identifier a brief name for this bus, for debugging purposes. Should be a valid Java identifier.
132 | */
133 | public Bus(String identifier) {
134 | this(ThreadEnforcer.MAIN, identifier);
135 | }
136 |
137 | /**
138 | * Creates a new Bus named "default" with the given {@code enforcer} for actions.
139 | *
140 | * @param enforcer Thread enforcer for register, unregister, and post actions.
141 | */
142 | public Bus(ThreadEnforcer enforcer) {
143 | this(enforcer, DEFAULT_IDENTIFIER);
144 | }
145 |
146 | /**
147 | * Creates a new Bus with the given {@code enforcer} for actions and the given {@code identifier}.
148 | *
149 | * @param enforcer Thread enforcer for register, unregister, and post actions.
150 | * @param identifier A brief name for this bus, for debugging purposes. Should be a valid Java identifier.
151 | */
152 | public Bus(ThreadEnforcer enforcer, String identifier) {
153 | this(enforcer, identifier, HandlerFinder.ANNOTATED);
154 | }
155 |
156 | /**
157 | * Test constructor which allows replacing the default {@code HandlerFinder}.
158 | *
159 | * @param enforcer Thread enforcer for register, unregister, and post actions.
160 | * @param identifier A brief name for this bus, for debugging purposes. Should be a valid Java identifier.
161 | * @param handlerFinder Used to discover event handlers and producers when registering/unregistering an object.
162 | */
163 | Bus(ThreadEnforcer enforcer, String identifier, HandlerFinder handlerFinder) {
164 | this.enforcer = enforcer;
165 | this.identifier = identifier;
166 | this.handlerFinder = handlerFinder;
167 | }
168 |
169 | @Override public String toString() {
170 | return "[Bus \"" + identifier + "\"]";
171 | }
172 |
173 | /**
174 | * Registers all handler methods on {@code object} to receive events and producer methods to provide events.
175 | *
176 | * If any subscribers are registering for types which already have a producer they will be called immediately
177 | * with the result of calling that producer.
178 | *
179 | * If any producers are registering for types which already have subscribers, each subscriber will be called with
180 | * the value from the result of calling the producer.
181 | *
182 | * @param object object whose handler methods should be registered.
183 | */
184 | public void register(Object object) {
185 | enforcer.enforce(this);
186 |
187 | Map, EventProducer> foundProducers = handlerFinder.findAllProducers(object);
188 | for (Class type : foundProducers.keySet()) {
189 |
190 | final EventProducer producer = foundProducers.get(type);
191 | EventProducer previousProducer = producersByType.putIfAbsent(type, producer);
192 | //checking if the previous producer existed
193 | if (previousProducer != null) {
194 | throw new IllegalArgumentException("Producer method for type " + type + " already registered.");
195 | }
196 | Set handlers = handlersByType.get(type);
197 | if (handlers != null && !handlers.isEmpty()) {
198 | for (EventHandler handler : handlers) {
199 | dispatchProducerResultToHandler(handler, producer);
200 | }
201 | }
202 | }
203 |
204 | Map, Set> foundHandlersMap = handlerFinder.findAllSubscribers(object);
205 | for (Class type : foundHandlersMap.keySet()) {
206 | Set handlers = handlersByType.get(type);
207 | if (handlers == null) {
208 | //concurrent put if absent
209 | Set handlersCreation = new CopyOnWriteArraySet();
210 | handlers = handlersByType.putIfAbsent(type, handlersCreation);
211 | if (handlers == null) {
212 | handlers = handlersCreation;
213 | }
214 | }
215 | final Set foundHandlers = foundHandlersMap.get(type);
216 | handlers.addAll(foundHandlers);
217 | }
218 |
219 | for (Map.Entry, Set> entry : foundHandlersMap.entrySet()) {
220 | Class type = entry.getKey();
221 | EventProducer producer = producersByType.get(type);
222 | if (producer != null && producer.isValid()) {
223 | Set foundHandlers = entry.getValue();
224 | for (EventHandler foundHandler : foundHandlers) {
225 | if (!producer.isValid()) {
226 | break;
227 | }
228 | if (foundHandler.isValid()) {
229 | dispatchProducerResultToHandler(foundHandler, producer);
230 | }
231 | }
232 | }
233 | }
234 | }
235 |
236 | private void dispatchProducerResultToHandler(EventHandler handler, EventProducer producer) {
237 | Object event = null;
238 | try {
239 | event = producer.produceEvent();
240 | } catch (InvocationTargetException e) {
241 | throw new RuntimeException("Producer " + producer + " threw an exception.", e);
242 | }
243 | if (event == null) {
244 | return;
245 | }
246 | dispatch(event, handler);
247 | }
248 |
249 | /**
250 | * Unregisters all producer and handler methods on a registered {@code object}.
251 | *
252 | * @param object object whose producer and handler methods should be unregistered.
253 | * @throws IllegalArgumentException if the object was not previously registered.
254 | */
255 | public void unregister(Object object) {
256 | enforcer.enforce(this);
257 |
258 | Map, EventProducer> producersInListener = handlerFinder.findAllProducers(object);
259 | for (Map.Entry, EventProducer> entry : producersInListener.entrySet()) {
260 | final Class key = entry.getKey();
261 | EventProducer producer = getProducerForEventType(key);
262 | EventProducer value = entry.getValue();
263 |
264 | if (value == null || !value.equals(producer)) {
265 | throw new IllegalArgumentException(
266 | "Missing event producer for an annotated method. Is " + object.getClass()
267 | + " registered?");
268 | }
269 | producersByType.remove(key).invalidate();
270 | }
271 |
272 | Map, Set> handlersInListener = handlerFinder.findAllSubscribers(object);
273 | for (Map.Entry, Set> entry : handlersInListener.entrySet()) {
274 | Set currentHandlers = getHandlersForEventType(entry.getKey());
275 | Collection eventMethodsInListener = entry.getValue();
276 |
277 | if (currentHandlers == null || !currentHandlers.containsAll(eventMethodsInListener)) {
278 | throw new IllegalArgumentException(
279 | "Missing event handler for an annotated method. Is " + object.getClass()
280 | + " registered?");
281 | }
282 |
283 | for (EventHandler handler : currentHandlers) {
284 | if (eventMethodsInListener.contains(handler)) {
285 | handler.invalidate();
286 | }
287 | }
288 | currentHandlers.removeAll(eventMethodsInListener);
289 | }
290 | }
291 |
292 | /**
293 | * Posts an event to all registered handlers. This method will return successfully after the event has been posted to
294 | * all handlers, and regardless of any exceptions thrown by handlers.
295 | *
296 | * If no handlers have been subscribed for {@code event}'s class, and {@code event} is not already a
297 | * {@link DeadEvent}, it will be wrapped in a DeadEvent and reposted.
298 | *
299 | * @param event event to post.
300 | */
301 | public void post(Object event) {
302 | enforcer.enforce(this);
303 |
304 | Set> dispatchTypes = flattenHierarchy(event.getClass());
305 |
306 | boolean dispatched = false;
307 | for (Class eventType : dispatchTypes) {
308 | Set wrappers = getHandlersForEventType(eventType);
309 |
310 | if (wrappers != null && !wrappers.isEmpty()) {
311 | dispatched = true;
312 | for (EventHandler wrapper : wrappers) {
313 | enqueueEvent(event, wrapper);
314 | }
315 | }
316 | }
317 |
318 | if (!dispatched && !(event instanceof DeadEvent)) {
319 | post(new DeadEvent(this, event));
320 | }
321 |
322 | dispatchQueuedEvents();
323 | }
324 |
325 | /**
326 | * Queue the {@code event} for dispatch during {@link #dispatchQueuedEvents()}. Events are queued in-order of
327 | * occurrence so they can be dispatched in the same order.
328 | */
329 | protected void enqueueEvent(Object event, EventHandler handler) {
330 | eventsToDispatch.get().offer(new EventWithHandler(event, handler));
331 | }
332 |
333 | /**
334 | * Drain the queue of events to be dispatched. As the queue is being drained, new events may be posted to the end of
335 | * the queue.
336 | */
337 | protected void dispatchQueuedEvents() {
338 | // don't dispatch if we're already dispatching, that would allow reentrancy and out-of-order events. Instead, leave
339 | // the events to be dispatched after the in-progress dispatch is complete.
340 | if (isDispatching.get()) {
341 | return;
342 | }
343 |
344 | isDispatching.set(true);
345 | try {
346 | while (true) {
347 | EventWithHandler eventWithHandler = eventsToDispatch.get().poll();
348 | if (eventWithHandler == null) {
349 | break;
350 | }
351 |
352 | if (eventWithHandler.handler.isValid()) {
353 | dispatch(eventWithHandler.event, eventWithHandler.handler);
354 | }
355 | }
356 | } finally {
357 | isDispatching.set(false);
358 | }
359 | }
360 |
361 | /**
362 | * Dispatches {@code event} to the handler in {@code wrapper}. This method is an appropriate override point for
363 | * subclasses that wish to make event delivery asynchronous.
364 | *
365 | * @param event event to dispatch.
366 | * @param wrapper wrapper that will call the handler.
367 | */
368 | protected void dispatch(Object event, EventHandler wrapper) {
369 | try {
370 | wrapper.handleEvent(event);
371 | } catch (InvocationTargetException e) {
372 | throw new RuntimeException(
373 | "Could not dispatch event: " + event.getClass() + " to handler " + wrapper, e);
374 | }
375 | }
376 |
377 | /**
378 | * Retrieves a mutable set of the currently registered producers for {@code type}. If no producers are currently
379 | * registered for {@code type}, this method will return {@code null}.
380 | *
381 | * @param type type of producers to retrieve.
382 | * @return currently registered producer, or {@code null}.
383 | */
384 | EventProducer getProducerForEventType(Class type) {
385 | return producersByType.get(type);
386 | }
387 |
388 | /**
389 | * Retrieves a mutable set of the currently registered handlers for {@code type}. If no handlers are currently
390 | * registered for {@code type}, this method may either return {@code null} or an empty set.
391 | *
392 | * @param type type of handlers to retrieve.
393 | * @return currently registered handlers, or {@code null}.
394 | */
395 | Set getHandlersForEventType(Class type) {
396 | return handlersByType.get(type);
397 | }
398 |
399 | /**
400 | * Flattens a class's type hierarchy into a set of Class objects. The set will include all superclasses
401 | * (transitively), and all interfaces implemented by these superclasses.
402 | *
403 | * @param concreteClass class whose type hierarchy will be retrieved.
404 | * @return {@code clazz}'s complete type hierarchy, flattened and uniqued.
405 | */
406 | Set> flattenHierarchy(Class concreteClass) {
407 | Set> classes = flattenHierarchyCache.get(concreteClass);
408 | if (classes == null) {
409 | classes = getClassesFor(concreteClass);
410 | flattenHierarchyCache.put(concreteClass, classes);
411 | }
412 |
413 | return classes;
414 | }
415 |
416 | private Set> getClassesFor(Class concreteClass) {
417 | List> parents = new LinkedList>();
418 | Set> classes = new HashSet>();
419 |
420 | parents.add(concreteClass);
421 |
422 | while (!parents.isEmpty()) {
423 | Class clazz = parents.remove(0);
424 | classes.add(clazz);
425 |
426 | Class parent = clazz.getSuperclass();
427 | if (parent != null) {
428 | parents.add(parent);
429 | }
430 | }
431 | return classes;
432 | }
433 |
434 | private final Map, Set>> flattenHierarchyCache =
435 | new HashMap, Set>>();
436 |
437 | /** Simple struct representing an event and its handler. */
438 | static class EventWithHandler {
439 | final Object event;
440 | final EventHandler handler;
441 |
442 | public EventWithHandler(Object event, EventHandler handler) {
443 | this.event = event;
444 | this.handler = handler;
445 | }
446 | }
447 | }
448 |
--------------------------------------------------------------------------------
/src/com/squareup/otto/BusProvider.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2012 Square, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.squareup.otto;
18 |
19 | import com.squareup.otto.Bus;
20 |
21 | /**
22 | * Maintains a singleton instance for obtaining the bus. Ideally this would be replaced with a more efficient means
23 | * such as through injection directly into interested classes.
24 | */
25 | public final class BusProvider {
26 | private static final Bus BUS = new Bus();
27 |
28 | public static Bus getInstance() {
29 | return BUS;
30 | }
31 |
32 | private BusProvider() {
33 | // No instances.
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/src/com/squareup/otto/DeadEvent.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2007 The Guava Authors
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.squareup.otto;
18 |
19 | /**
20 | * Wraps an event that was posted, but which had no subscribers and thus could not be delivered.
21 | *
22 | * Subscribing a DeadEvent handler is useful for debugging or logging, as it can detect misconfigurations in a
23 | * system's event distribution.
24 | *
25 | * @author Cliff Biffle
26 | */
27 | public class DeadEvent {
28 |
29 | public final Object source;
30 | public final Object event;
31 |
32 | /**
33 | * Creates a new DeadEvent.
34 | *
35 | * @param source object broadcasting the DeadEvent (generally the {@link Bus}).
36 | * @param event the event that could not be delivered.
37 | */
38 | public DeadEvent(Object source, Object event) {
39 | this.source = source;
40 | this.event = event;
41 | }
42 |
43 | }
44 |
--------------------------------------------------------------------------------
/src/com/squareup/otto/EventHandler.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2012 Square, Inc.
3 | * Copyright (C) 2007 The Guava Authors
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the "License");
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | */
17 |
18 | package com.squareup.otto;
19 |
20 | import java.lang.reflect.InvocationTargetException;
21 | import java.lang.reflect.Method;
22 |
23 | /**
24 | * Wraps a single-argument 'handler' method on a specific object.
25 | *
26 | *
This class only verifies the suitability of the method and event type if something fails. Callers are expected t
27 | * verify their uses of this class.
28 | *
29 | *
Two EventHandlers are equivalent when they refer to the same method on the same object (not class). This
30 | * property is used to ensure that no handler method is registered more than once.
31 | *
32 | * @author Cliff Biffle
33 | */
34 | class EventHandler {
35 |
36 | /** Object sporting the handler method. */
37 | private final Object target;
38 | /** Handler method. */
39 | private final Method method;
40 | /** Object hash code. */
41 | private final int hashCode;
42 | /** Should this handler receive events? */
43 | private boolean valid = true;
44 |
45 | EventHandler(Object target, Method method) {
46 | if (target == null) {
47 | throw new NullPointerException("EventHandler target cannot be null.");
48 | }
49 | if (method == null) {
50 | throw new NullPointerException("EventHandler method cannot be null.");
51 | }
52 |
53 | this.target = target;
54 | this.method = method;
55 | method.setAccessible(true);
56 |
57 | // Compute hash code eagerly since we know it will be used frequently and we cannot estimate the runtime of the
58 | // target's hashCode call.
59 | final int prime = 31;
60 | hashCode = (prime + method.hashCode()) * prime + target.hashCode();
61 | }
62 |
63 | public boolean isValid() {
64 | return valid;
65 | }
66 |
67 | /**
68 | * If invalidated, will subsequently refuse to handle events.
69 | *
70 | * Should be called when the wrapped object is unregistered from the Bus.
71 | */
72 | public void invalidate() {
73 | valid = false;
74 | }
75 |
76 | /**
77 | * Invokes the wrapped handler method to handle {@code event}.
78 | *
79 | * @param event event to handle
80 | * @Throws java.lang.IllegalStateException if previously invalidated.
81 | * @throws java.lang.reflect.InvocationTargetException if the wrapped method throws any {@link Throwable} that is not
82 | * an {@link Error} ({@code Error}s are propagated as-is).
83 | */
84 | public void handleEvent(Object event) throws InvocationTargetException {
85 | if (!valid) {
86 | throw new IllegalStateException(toString() + " has been invalidated and can no longer handle events.");
87 | }
88 | try {
89 | method.invoke(target, new Object[] {event});
90 | } catch (IllegalAccessException e) {
91 | throw new AssertionError(e);
92 | } catch (InvocationTargetException e) {
93 | if (e.getCause() instanceof Error) {
94 | throw (Error) e.getCause();
95 | }
96 | throw e;
97 | }
98 | }
99 |
100 | @Override public String toString() {
101 | return "[EventHandler " + method + "]";
102 | }
103 |
104 | @Override public int hashCode() {
105 | return hashCode;
106 | }
107 |
108 | @Override public boolean equals(Object obj) {
109 | if (this == obj) {
110 | return true;
111 | }
112 |
113 | if (obj == null) {
114 | return false;
115 | }
116 |
117 | if (getClass() != obj.getClass()) {
118 | return false;
119 | }
120 |
121 | final EventHandler other = (EventHandler) obj;
122 |
123 | return method.equals(other.method) && target == other.target;
124 | }
125 |
126 | }
127 |
--------------------------------------------------------------------------------
/src/com/squareup/otto/EventProducer.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2012 Square, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.squareup.otto;
18 |
19 | import java.lang.reflect.InvocationTargetException;
20 | import java.lang.reflect.Method;
21 |
22 | /**
23 | * Wraps a 'producer' method on a specific object.
24 | *
25 | *
This class only verifies the suitability of the method and event type if something fails. Callers are expected
26 | * to verify their uses of this class.
27 | *
28 | * @author Jake Wharton
29 | */
30 | class EventProducer {
31 |
32 | /** Object sporting the producer method. */
33 | private final Object target;
34 | /** Producer method. */
35 | private final Method method;
36 | /** Object hash code. */
37 | private final int hashCode;
38 | /** Should this producer produce events? */
39 | private boolean valid = true;
40 |
41 | EventProducer(Object target, Method method) {
42 | if (target == null) {
43 | throw new NullPointerException("EventProducer target cannot be null.");
44 | }
45 | if (method == null) {
46 | throw new NullPointerException("EventProducer method cannot be null.");
47 | }
48 |
49 | this.target = target;
50 | this.method = method;
51 | method.setAccessible(true);
52 |
53 | // Compute hash code eagerly since we know it will be used frequently and we cannot estimate the runtime of the
54 | // target's hashCode call.
55 | final int prime = 31;
56 | hashCode = (prime + method.hashCode()) * prime + target.hashCode();
57 | }
58 |
59 | public boolean isValid() {
60 | return valid;
61 | }
62 |
63 | /**
64 | * If invalidated, will subsequently refuse to produce events.
65 | *
66 | * Should be called when the wrapped object is unregistered from the Bus.
67 | */
68 | public void invalidate() {
69 | valid = false;
70 | }
71 |
72 | /**
73 | * Invokes the wrapped producer method.
74 | *
75 | * @throws java.lang.IllegalStateException if previously invalidated.
76 | * @throws java.lang.reflect.InvocationTargetException if the wrapped method throws any {@link Throwable} that is not
77 | * an {@link Error} ({@code Error}s are propagated as-is).
78 | */
79 | public Object produceEvent() throws InvocationTargetException {
80 | if (!valid) {
81 | throw new IllegalStateException(toString() + " has been invalidated and can no longer produce events.");
82 | }
83 | try {
84 | return method.invoke(target);
85 | } catch (IllegalAccessException e) {
86 | throw new AssertionError(e);
87 | } catch (InvocationTargetException e) {
88 | if (e.getCause() instanceof Error) {
89 | throw (Error) e.getCause();
90 | }
91 | throw e;
92 | }
93 | }
94 |
95 | @Override public String toString() {
96 | return "[EventProducer " + method + "]";
97 | }
98 |
99 | @Override public int hashCode() {
100 | return hashCode;
101 | }
102 |
103 | @Override public boolean equals(Object obj) {
104 | if (this == obj) {
105 | return true;
106 | }
107 |
108 | if (obj == null) {
109 | return false;
110 | }
111 |
112 | if (getClass() != obj.getClass()) {
113 | return false;
114 | }
115 |
116 | final EventProducer other = (EventProducer) obj;
117 |
118 | return method.equals(other.method) && target == other.target;
119 | }
120 |
121 | }
122 |
--------------------------------------------------------------------------------
/src/com/squareup/otto/HandlerFinder.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2012 Square, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.squareup.otto;
18 |
19 | import java.util.Map;
20 | import java.util.Set;
21 |
22 | /** Finds producer and subscriber methods. */
23 | interface HandlerFinder {
24 |
25 | Map, EventProducer> findAllProducers(Object listener);
26 |
27 | Map, Set> findAllSubscribers(Object listener);
28 |
29 |
30 | HandlerFinder ANNOTATED = new HandlerFinder() {
31 | @Override
32 | public Map, EventProducer> findAllProducers(Object listener) {
33 | return AnnotatedHandlerFinder.findAllProducers(listener);
34 | }
35 |
36 | @Override
37 | public Map, Set> findAllSubscribers(Object listener) {
38 | return AnnotatedHandlerFinder.findAllSubscribers(listener);
39 | }
40 | };
41 | }
42 |
--------------------------------------------------------------------------------
/src/com/squareup/otto/Produce.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2012 Square, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.squareup.otto;
18 |
19 | import java.lang.annotation.ElementType;
20 | import java.lang.annotation.Retention;
21 | import java.lang.annotation.RetentionPolicy;
22 | import java.lang.annotation.Target;
23 |
24 | /**
25 | * Marks a method as an instance producer, as used by {@link AnnotatedHandlerFinder} and {@link Bus}.
26 | *
27 | * Otto infers the instance type from the annotated method's return type. Producer methods may return null when there is
28 | * no appropriate value to share. The calling {@link Bus} ignores such returns and posts nothing.
29 | *
30 | * @author Jake Wharton
31 | */
32 | @Retention(RetentionPolicy.RUNTIME)
33 | @Target(ElementType.METHOD)
34 | public @interface Produce {
35 | }
36 |
--------------------------------------------------------------------------------
/src/com/squareup/otto/Subscribe.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2007 The Guava Authors
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.squareup.otto;
18 |
19 | import java.lang.annotation.ElementType;
20 | import java.lang.annotation.Retention;
21 | import java.lang.annotation.RetentionPolicy;
22 | import java.lang.annotation.Target;
23 |
24 | /**
25 | * Marks a method as an event handler, as used by {@link AnnotatedHandlerFinder} and {@link Bus}.
26 | *
27 | *
The method's first (and only) parameter defines the event type.
28 | *
If this annotation is applied to methods with zero parameters or more than one parameter, the object containing
29 | * the method will not be able to register for event delivery from the {@link Bus}. Otto fails fast by throwing
30 | * runtime exceptions in these cases.
31 | *
32 | * @author Cliff Biffle
33 | */
34 | @Retention(RetentionPolicy.RUNTIME)
35 | @Target(ElementType.METHOD)
36 | public @interface Subscribe {
37 | }
38 |
--------------------------------------------------------------------------------
/src/com/squareup/otto/ThreadEnforcer.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2012 Square, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.squareup.otto;
18 |
19 | import android.os.Looper;
20 |
21 | /**
22 | * Enforces a thread confinement policy for methods on a particular event bus.
23 | *
24 | * @author Jake Wharton
25 | */
26 | public interface ThreadEnforcer {
27 |
28 | /**
29 | * Enforce a valid thread for the given {@code bus}. Implementations may throw any runtime exception.
30 | *
31 | * @param bus Event bus instance on which an action is being performed.
32 | */
33 | void enforce(Bus bus);
34 |
35 |
36 | /** A {@link ThreadEnforcer} that does no verification or enforcement for any action. */
37 | ThreadEnforcer NONE = new ThreadEnforcer() {
38 | @Override public void enforce(Bus bus) {
39 | // Allow any thread.
40 | }
41 | };
42 |
43 | /** A {@link ThreadEnforcer} that confines {@link Bus} methods to the main thread. */
44 | ThreadEnforcer MAIN = new ThreadEnforcer() {
45 | @Override public void enforce(Bus bus) {
46 | if (Looper.myLooper() != Looper.getMainLooper()) {
47 | throw new IllegalStateException("Event bus " + bus + " accessed from non-main thread " + Looper.myLooper());
48 | }
49 | }
50 | };
51 |
52 | }
53 |
--------------------------------------------------------------------------------