Android developer portal with tools, libraries, and apps

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 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

Clean contacts is a sample repository to illustrate Clean architecture in Android. It has also many other details that hopefully will be useful too.

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.

This is an ambitious example project of what can be done with RxJava to create an app based on streams of data.

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 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.

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.

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.

An example of CleanArchitecture on Kotlin.

Android app to demonstrate MVP Android Architecture using Dagger and SOLID principles.

Simple project demonstrating the MVP architecture with Kotlin, Dagger2 and Unit Tests to help developers build better apps.

This example describes how use Espresso in Android-Kotlin using MVP, Dagger2, Retrofit.

A showcase of RxJava and Model View Presenter, plus a number of other popular libraries for android development, including AutoValue, Retrofit, Moshi, and ButterKnife. Unit tests covering any business logic and Robolectric tests verifying the ui.

Android Architecture Components (AAC) is a new collection of libraries that contains the lifecycle-aware components. It can solve problems with configuration changes, supports data persistence, reduces boilerplate code, helps to prevent memory leaks and simplifies async data loading into your UI. I can’t say that it brings absolutely new approaches for solving these issues, but, finally, we have a formal, single and official direction.

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.

Android Architecture using Google guides.

An Implementation of the Actor-Model in pure Android components, also supports inter-process communication between Actors.

This application is example of Android Architecture Components which implements MVVM Pattern.

Sample app to demonstrate MVP (Model - View - Presenter) architecture in android.

Android Kotlin Starter is a starter project which implements MVP Pattern.

Kloud is a Kotlin implementation of a new architecture idea that I named cloud, it's based on system communication without any type of instance reference or static properties, in a robust, simple and reactive way.

MvpCleanArchitecture is a sample project using Clean architecture and MVP.

The Android SDK has changed much since its first version. Every new version comes with many new APIs. However, there is no perfect API, some do too much under the hood, others couple your classes to the context, others have more lifecycle events than you have years in your life.

This sample project shows how to apply MVP and Clean architecture on an Android app.