Android developer portal with tools, libraries, and apps

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.

An extremely lightweight collection of classes for implementing a state based decoupled architecture for Android applications.

A major benefit of this is that it also keeps asynchronous code away from the Android lifecycle.

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.

GraphFlow is a lightweight library for designing 'logic based' UI flows.

You create a graph of nodes logically connected where each node represents a UI renderable object (fragment/view/whatever you prefer).

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.

ngAndroid is bringing angularjs type directives to android xml attributes.

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.

Android Starter is a starter project which implements MVP Pattern. It includes libraries:

• RxJava2
• RxAndroid
• Dagger2
• Butterknife
• Crashlytics
• Timber
• GreenDao
• Realm
• Retrofit
• OkHttp
• Gson
• Picasso

This demo aims shows practical way of clean architecture, MVP.

It's a simple MVP implementation. With this library every developer can integration pattern MVP in him project. To add presenter to Activity or Fragment, the developer need write only one row - setPreseter(ExamplePresenter.class);

This library does support MVP pattern for Activities, Fragments and RecyclerViewAdapter.

Unify activity and fragment life cycle for MVVM architecture.

Binds Android Activity lifecycle callbacks to Activity fields annotated with @AirCycle.

Fields annotated with @AirCycle that are defined in an Activity will receive lifecycle callbacks of the enclosing Activity. The Activity does NOT need to implement any interface or extend any specific base class.

The field itself also does NOT need to implement any interface or extend any specific base class.

The binding class is generated in compile time using Java annotation processing, NO reflection is used at runtime. Since all classes are generated in compile time, it can safely be used with ProGuard.

Inspired by SoundCloud's LightCycle library. Compared to LightCycle, AirCycle supports passing of Activity lifecycle callbacks without the need to extend from a specific base Activity. Additionally, the listener classes are completely flexible, without the need to extend from any class or interface. This enables more flexibility when developing and further promotes composition over inheritance.

Abstract, easy, quick, flexible and extendable Rapid Android development.

A minimalist, View-based application framework for Android.

Got idea from Android Clean Architecture, this is a very simple Android app which describes how we can design a clean and clear architecture for an Android App.

Base skeleton structure to start every new project, based on the design patters suggested by Robert C. Martin (aka Uncle Bob) on his clean architecture.

A multi-purpose Groovy library containing view injection and threading for Android using annotations. It's based on both ButterKnife and AndroidAnnotations.

Get your Android applications off the ground and running fast with this archetype. This bootstrap should contain everything you need to get going but not so much you have to spend time stripping things out. If you find your self deleting something frequently then it should probably be removed. This application is highly based off of Jake Wharton's u2020 and has a debug drawer ready and waiting for more awesomeness.

A project which showcases usage of AndroidAnnotations among other open source libraries.

A project which showcases usage of Dagger, RxJava and Retrolambda among other open source libraries.

Dagger2Scopes is a sample Android app to implement usual Dagger 1 multiple scoping logic with the brand new Dagger 2 Google lib. In this sample you will be able to find the following features:

• Multiple scopes with Dagger 2 (Components and subcomponents).
• An approach to Clean Architecture.
• An approach to MVP pattern.

Kick-starts Android application development.

Areas covered by ignition encompass:

• UI components such as widgets, adapters, dialogs, and more
• An HTTP wrapper library that allows you to write simple yet robust networking code
• A class to load remote images off the web and cache them
• A simple yet effective caching framework (caches to memory and disk, anything from HTTP responses to entire object trees)
• Several helper classes for easier API level backwards compatibility, Intents, diagnostics, and more
• A friendlier and more robust implementation of AsyncTask

ViewModel Lifecycle allows you to track and observe Jetpack ViewModel's lifecycle changes.