Android developer portal with tools, libraries, and apps
An Android project with MVP pattern which adapts with new Android architecture components introduced in Google IO 2017. It provides lifecycle-aware Presenter with support of LifeCycle and local data source handled by Room (an abstraction layer over SQLite).
This demo project uses StackExchange API as a remote data source. Also, it covers basic and general tasks which most Android apps deal with.
A small Android sample demonstrates MVP (Model-View-Presenter) pattern.
A sample Android application, written in Kotlin, to demonstrate how to build screens as fully independent modules.
Use cases:
- Screen 1: type a user
- Screen 2: load and display GitHub repos for this user
A sample Android application to demonstrate how to build screens as fully independent modules.
Goals
- Use native Android SDK as much as possible (Fragment, ViewModel)
- Support configuration changes
Android project to experiment the VIPER approach.
Motivations
- Tend toward the VIPER approach
- Make it easier to test the application
- Simplify the set up of asynchronous job with RxJava
A sample Android application to demonstrate how to build screens as fully independent modules.
It relies on a Finite State Machine (EasyFlow), to handle screens as states and trigger/consume events. Events allow the application to handle navigation between screens. The global context of the FSM is used to pass arguments as a Bundle. It also shows how to use dependency injection (via Dagger 2 for example) in modules.
This way:
- modules are fully independent
- modules declare the dependencies they need
- modules declare the states they correspond to
- modules declare the events that can be triggered
- the hosting application sets up the states it uses (i.e., "screens")
- the hosting application sets up how to navigation between states (with events)
- the hosting application sets up the dependency injection mechanism
A sample Android app using the MVP architecture, using:
- Dagger2
- mosby
- retrofit2
- RxJava
A sample Android app using the MVP architecture.
Clean MVP Architecture with RxJava + Dagger2 + Retrofit2 + Mockito + Fresco + EasiestGenericRecyclerAdapter using Kotlin. Includes Unit Tests(Kotlin Tests)!
Main purpose of this repo is dealing unit testing problems and find easy ways to handle them.
Clean contacts is a sample repository to illustrate Clean architecture in Android. It has also many other details that hopefully will be useful too.
A demo project based on MVVM clean architecture and material design & animations.
A demo project for the health care todo list based on Kotlin MVVM architecture and material design & animations.
This is an Android Clean Architecture base project using 100% Kotlin including Unit tests!
You could use it as the base project when you create a new Android project. This architecture optimized the Clean Architecture and MVP for the Android Kotlin project. When using this architecture, you could isolate the UI, business logic and data sources, and also making the unit test easier.
Benefits:
- Makes your new project clean
- Isolates UI, business logic and data sources responsibilities
- Testable
- Avoids multi-threading problems
A sample app that shows how we can apply unidirectional data flow architecture on Android using Kotlin.
A showcase of Flux architecture patterns for Android apps.
A sample project based on the new Android Component Architecture.
Lifecycle, LiveData, MVVM, ViewModels, DataBinding, Dagger
Android DI, DDD, Specification Pattern, Repository Pattern, IoC.
This is an ambitious example project of what can be done with RxJava to create an app based on streams of data.
Clean Arch is a derivative of a model-view-presenter (MVP) architectural pattern. This paradigm is made in maximizing maintenable code. So, the essentials are already bundled in one package. Its pattern is greeting like MVP, but I try refactor to apply clean code principle. For the lifecycle, I try to make a little different (not as a whole), both Activity and Fragment.
A simple implementation of android app based Android new architecture components (ViewModel, LiveDate, RoomDAO) with Dagger2 & Retrofit2. Written in Kotlin.
Starter boilerplate projects for Android, with Components Architecture implemented, written completely in Kotlin. Variations include Rx, Realm & Dagger usage.
This is simple example of pure MVVM (Model VIew View-Model) android architecture example using Data Binding, ViewModel and many more features.
Examples of application architecture implements in Android. Contains MVC, MVVM, Redux.
This project is the evolution of our way to understand code quality based on Clean Architecture.
In this repo you'll find an example app to show our way to architect android projects.
Android app to demonstrate MVP Android Architecture using Dagger and SOLID principles.
This example describes how use Espresso in Android-Kotlin using MVP, Dagger2, Retrofit.
Simple project demonstrating the MVP architecture with Kotlin, Dagger2 and Unit Tests to help developers build better apps.
An example of CleanArchitecture on Kotlin.
Repository that showcases 3 different Android app architectures, all with Java and Kotlin versions: "Standard Android", MVP and MVVM. The exact same app is built 6 times following the different patterns.