square/ottoArchived
Otto
Otto is an event-driven communication system designed as an event bus for Android applications. It provides a mechanism to decouple application components by routing events between them without requiring direct dependencies.
The system is state-aware, meaning it can provide the most recent known value to new subscribers immediately upon registration. It operates as a synchronous event dispatcher, ensuring all registered listeners respond to an object before execution continues.
The library includes capabilities for event subscription management and thread execution enforcement to restrict callbacks to specific threads. It utilizes type-based subscriber mapping to organize listeners according to the class of the events they receive.
Features
- Event Bus Systems - Provides an event bus system for decoupled communication between components in Android applications.
- Android Thread Management - Manages the routing of event callbacks to specific threads within the Android runtime to maintain UI stability.
- Callback - Restricts event callbacks to a specific thread to prevent race conditions and ensure thread safety.
- Event - Routes event delivery to a specific execution context to ensure listeners run on a designated thread.
- Component Decoupling Patterns - Implements decoupling patterns to facilitate communication between application components without direct dependencies.
- Event-Based Communication - Implements the architectural pattern of event-based communication to decouple application components.
- Event Propagation Patterns - Follows architectural patterns for pushing state changes synchronously through an event log to downstream listeners.
- Event Subscribers - Groups event listeners into subscribers based on the class of events they are registered to receive.
- Event Type Subscriptions - Allows class instances to register interest in specific event types and receive matching events through method execution.
- Synchronous Event Dispatchers - Executes event handlers within the caller's thread to ensure all listeners respond before execution continues.
- Android Component Architectures - Provides an architectural structure for decoupling Android components using an event-driven communication bus.
- Guava Event Bus Implementations - Implements an event bus based on Guava to decouple application components via event routing.
- State-Aware Event Buses - Implements a state-aware event bus that provides the most recent known value to subscribers upon registration.
- Initial Value Emission - Immediately dispatches the current state value upon the creation of a new event subscription.
- Reflective Event Dispatchers - Uses Java reflection to identify and execute methods annotated as subscribers when events are published.
- Subscription State Synchronization - Provides initial values to new subscribers to ensure they have the latest state immediately upon registration.
- Initial State Injections - Provides the most recent known value to new subscribers immediately upon registration to synchronize application state.
- Event Bus - Provides an enhanced, Guava-based event bus for Android.
