Android developer portal with tools, libraries, and apps
A basic sample android application to understand MVVM in a very simple way.
Kelm simplifies management of complex app states and asynchronous tasks. Kelm is a Kotlin library based on the Elm Architecture and RxJava.
This is the SampleApp for Android Project Structure.
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.
Android App starter based on Android + MVP + Dagger2 + RxJava2 + Robolectric + Espresso + Mockito + JaCoCo.
Android app built with an MVP approach without RxJava or Dagger.
Sample app showcases the MVP pattern and Uncle Bob Martin's Clean Architecture approach.
An abstract application stack which facilitates:
- Presenter lifecycle management
- Presenter -> Presenter control flow
- Fine grained data scope management
- Presenter lifecycle events
The Shared Memory library allows for the creation of memory regions that may be simultaneously accessed by multiple Android processes or applications. Developed to overcome the Android 1MB IPC limitation, this Shared Memory library allows you to exchange larger amounts of data between your Android applications.
A demo project based on Kotlin, MVVM architecture, coroutines, dagger, koin, and material designs & animations.
Examples of memory leaks and common patterns that cause them in Android development and how to fix/avoid them.
A complete android componentization solution, powered by MVPArms.
Android kotlin clean architecture rxjava2 + dagger2 + retrofit2 + realm.
Newtron Watchdog allows the critical applications you develop for Android to keep running even after an application crash.
Movie Sample project with new android architecture components.
A Framework that simplify developing MVVM Architecture and Material Design in Android with Kotlin language including useful Extensions and Sample Application. This Framework has some tools for Retrofit and OKHttp and Coroutine for calling REST API requests.
Dynamic Localization and Day/Night Theme & Meow Custom Widgets are another features.
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.
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.
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 playground for MVVM style architecture on Android.
A sample Android app using the MVP architecture.
A small Android sample demonstrates MVP (Model-View-Presenter) pattern.
A sample Android app using the MVP architecture, using:
- Dagger2
- mosby
- retrofit2
- RxJava
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
Scoop is a micro framework for building view based modular Android applications.
Clean contacts is a sample repository to illustrate Clean architecture in Android. It has also many other details that hopefully will be useful too.
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.