Android developer portal with tools, libraries, and apps

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.

A sample Android app using the MVP architecture, using:

• Dagger2
• mosby
• retrofit2
• RxJava

An example project for creating machine learning model for MNIST to detect hand written digits.

Separating data and state handling from Fragments or Activities without lots of boilerplate-code. Reducing them to simple dumb views.

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

Anvil is a tiny library to simplify android UI development. The name stands for "android virtual layout". Virtual layout is an Android analogy of the virtual DOM in the web.

A complete android componentization solution, powered by MVPArms.

Android app built with an MVP approach without RxJava or Dagger.

Examples of memory leaks and common patterns that cause them in Android development and how to fix/avoid them.

Android DI, DDD, Specification Pattern, Repository Pattern, IoC.

BARACUS is the BAReknuckle Android Context USher, a tiny framework for android development enabling you to have dependency injection, dynamic context handling and database object relational mapping.

Features:

• Dynamic context creation and destruction
• Type based dependency injection plus documentation annotation
• Object relational mapper
• Dao-Approach for mapping and lazy loading / lazy references
• Modification awareness for components - listen for data changes
• Automatic database version and migration management
• Hot-Backup of Sqlite
• Declarative form validation and automatic error routing

Base is a lightweight library that gives you a clean architecture foundation for your Android MVP's.

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.

Sample app showcases the MVP pattern and Uncle Bob Martin's Clean Architecture approach.

CatanArchitecture is a sample repository to illustrate Hexagonal architecture in Android.

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

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.

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

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 Rx Kotlin Architecture sample on GitHub Api.

A small, yet full-featured framework that allows building View-based Android applications. Conductor provides a light-weight wrapper around standard Android Views that does just about everything you'd want.

Simple lifecycle for your MVWhatever on Android. No kidding.

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.

Demo Application to understand the architecture of MVVM App with Unit tests.

A carefully crafted Android framework that includes: DI, ORM, EventBus, JSON (de)serialization feature, improved AsyncTask & IntentService, Logger, RESTClient, ImageFetcher, and a lot of utils.

Droidux is "predictable state container" implementation, inspired by Redux.

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.

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.

Sample project created to reinforce some of the main concepts described in the tech talk "Effective Android UI".