Pet project using Clean Architecture + MVVM + Reactive Extensions + Android Architecture Components. The data is fetched from LondonTheatreDirect API.
Uses concepts of the notorious Uncle Bob's architecture called Clean Architecture. The software produced by this architecture is going to be:
The overriding rule of this architecture says that the source code dependencies always point inwards. The outer tiers can only dependent of inner tiers. Therefore, the inner tiers know nothing about the outer tiers. The more further you go through the concentric circles, the higher level the software becomes. Which means that the level of abstraction increases.
They are the operations of the application and may contain specific business rules. This layer is isolated from database, UI, or any of the common frameworks. All use case classes extends UseCase abstract class that sets up the schedulers of Reactive Extensions.
It is a set of adapters that convert data from the format most convenient for the use cases and entities, to the format most convenient for some external agency such as the UI or Database. It is this layer that will wholly contain the ViewModels of MVVM architectural pattern. The models are likely just data structures that are passed from the view to the use cases, and vice versa. Similarly, data is converted, in this layer, from the form most convenient for entities and use cases, into the form most convenient for whatever persistence framework is being used.
The outermost layer is composed of frameworks and tools such as the Database and the Android Framework. The Repository pattern is used to encapsulate the details about caching mechanism.
In order to not violate the Dependency Rule, the Dependency Inversion principle must be used whenever complex data needs to be passed across a boundary to an inward layer. Instead of expecting and directly referencing a low-level component (e.g. as a function parameter), the high-level layer provides and references an interface that must be implemented and inherited from by the caller. This way, the conventional dependency relationship is inverted and the high-level layer is decoupled from the low-level component.
To make the application more testable and avoid having to deal with object instantiations in many points, the Dependency Injection technique is used.
Dependency injection is one form of the broader technique of inversion of control. As with other forms of inversion of control, dependency injection supports the dependency inversion principle.
Dagger is the tool used for managing and injection of our dependencies.
The LondonTheatreDirect API groups the data into:
Since the data is basically static, a Repository with database caching is used by Gateway.
Due the data volatility, it is used a Repository that caches in memory.
Contributions are always welcome!
Issues: Fell free to open a new issue. Follow the ISSUE_TEMPLATE.MD
Follow the "fork-and-pull" Git workflow.
Prevent code-style related changes. Format the code before commiting.
Copyright 2018 André Mion Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.