Android developer portal with tools, libraries, and apps

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

A sample app that shows how we can apply unidirectional data flow architecture on Android using Kotlin.

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.

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.

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

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

Clean Architecture with Dagger2 + Retrofit2 + Picasso.

This repo contains demo module which retrieves characters from Star wars API.

An example for Redux architecture on Android.

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

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.

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

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

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.

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

Movie Sample project with new android architecture components.

Android Architecture using Google guides.

This is a SIMPLE MVP-CLEAN KOTLIN sample of Rosie Implementation Architecture!

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

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

A small Android sample demonstrates MVP (Model-View-Presenter) pattern.

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

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

Android kotlin clean architecture rxjava2 + dagger2 + retrofit2 + realm.

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

Android App starter based on Android + MVP + Dagger2 + RxJava2 + Robolectric + Espresso + Mockito + JaCoCo.

This repository contains a detailed sample app that implements MVP architecture using Dagger2, GreenDao, RxJava2, FastAndroidNetworking and PlaceholderView.

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.

A sample Android app using the MVP architecture.

A sample Android app using the MVP architecture, using:

• Dagger2
• mosby
• retrofit2
• 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