Android developer portal with tools, libraries, and apps

Utility to trigger action on Android lifecycle events. Contains implementation based on Android Architecture Components and own implementation with extended set of events for Activity and Fragment.

java lifebus.on(Lifecycle.Event.ON_STOP, () -> { holdMe.release(); });

This is an android framework for build complex application with different architectures (MVC ready/MVP/MVVM/MVI etc.). It's created on top of MVC pattern with powerful event system, dependency injection and property delegation, also it supports multi-core instances and animation changes between views.

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

Movie Sample project with new android architecture components.

A comprehensive library designed specifically for the Android Mode in Processing.

A playground for MVVM style architecture on Android.

Adds listeners for Activity and Fragment.

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.

An easy, powerful, and flexible MVP/MVI library for Android apps. It uses the same principles as Mosby (Model-View-Intent) but made easier and it has a built-in mechanism to save and restore your view state.

A complete android componentization solution, powered by MVPArms.

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.

ViewStateStore wraps a LiveData for deliver ViewStates to the UI.

Supported ViewState types are:

• Success: holds the real data
• Error: holds and error ( which could be a custom class ) with its Throwable and an optional customMessageRes.
• Loading
• None (default initial value)

It also supports Android's Paging.

A Reactive Android MVP Framework which is Slick to use, Inspired by MVI and Elm Architecture.

Inversion simplifies the ServiceLoader usage to retrieve all the implementations of a certain interface. Using Inversion it's easy to use the dependency inversion in a multi module project.

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.

Rosie is an Android framework to create applications following the Clean Architecture.

Rosie divides your application in three layers, view, domain and repository. For each layer, Rosie provides plenty of classes that will make defining and separating these concerns much easier.

An architecture for Android as a replacement of MVC.

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.

Scoop is a micro framework for building view based modular Android applications.

Easy and intuitive architecture pattern library for Android by Naver Corp.

Krate is a predictable state container for Kotlin and RxJava. It brings order to the chaos by taking care of the data flow in your app. Krate is heavily inspired by This talk by Jake Wharton but also Flux and Redux.

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