LifecycleMvp 1.2 0.0 Kotlin is MVP architecture implementation with Android Architecture Components and Kotlin language features

Overview

N|Solid

MinSDK 14+

License

Download

Gradle

Add to project level build.gradle

allprojects {
    repositories {
        ...
        maven { url 'https://jitpack.io' }
    }
}

Add dependency to app module level build.gradle

dependencies {
    implementation 'com.github.RobertApikyan:LifecycleMvp:1.1.1'
}

Maven

<repositories>
	<repository>
	<id>jitpack.io</id>
	<url>https://jitpack.io</url>
	</repository>
</repositories>

Add dependency

<dependency>
	<groupId>com.github.RobertApikyan</groupId>
	<artifactId>LifecycleMvp</artifactId>
	<version>1.1.1</version>
</dependency>

LifecycleMvp

It's convenient to write android applications with MVP architecture, because it's simple and lightweight.

LifecycleMvp is implementation of AbstractMvp with Android Arcitecture Components. AbstractMvp framework solves a number of issues related with classic MVP implementation. Read more about AbstractMvp here.

Let's try it on a ColorApp

Here we have a ColorApp. It's main point is to display different colors when the user is tapping on the screen. It has only one activity, and for that activity we gonna create ColorView interface and ColorPresenter class.

Step 1. Creating ColorView and ColorPresenter.
// View
// inherit from LifecycleView
interface ColorView : LifecycleView { 
    fun setNewColor(color: Int) // Set the color value as a view background
}
// Presenter
// inherit from LifecyclePresenter and define View generic type as a ColorView
class ColorPresenter : LifecyclePresenter<ColorView>() { 
    ...
}
Step 2. Implement ColorView interface by ColorActivity
class ColorActivity : AppCompatActivity(), ColorView {
  ...
  fun setNewColor(color:Int){
    mBackgroundView.setBackgroundColor(color)
  }
  ...
}
Step 3. Receive presenter instance in ColorActivity

Here we receiving presenter instance by calling LifecycleMvp.from(this, ::ColorPresenter) where "this"- is ColorView implementation, ::ColorPresenter is Presenter's constructor's reference. Alternatively it can be writen like this LifecycleMvp.from(this) { ColorPresenter() }

...
override fun onCreate(savedInstanceState: Bundle?) {
        ...
        // Receiving presenter instance 
        presenter = LifecycleMvp.from(this, ::ColorPresenter)
        mColorChangeView.setOnClickListener {
           presenter.onColorViewClick()
        }
}
...
The Important think here is that our presenter is lifecycle persistence. After configuration change, such as rotation we gonna receive the same presenter instance.
Step 4. Let's define our ColorPresenter
 class ColorPresenter : LifecyclePresenter<ColorView>() { 
    // Here we hold current display color
    private var currentColor = -1
    
    // This method called when user clicks on mColorBackground
    fun onColorViewClick() {
        // set new color value
        currentColor = ColorGenerator.generateColor()
        // call to change UI color
        onColorChanged()
    }
    
    // This method opens the view scope and send viewAction to view
    private fun onColorChanged() = view {
        setNewColor(currentColor) // UI color will be changed
    }
}

Here new think is view{ } method, which receives lambda(V.() -> Unit) ViewAction as an argument This viewAction will be invoked by LifecycleMvp framework.

Note.

It's impossible to come up with NullPointerException while trying to access view instance at the time when view is detached from presenter and there is no need to make nullability check every time before accessing view instance.

Done. Full example of ColorApp is here

UNDER THE HOOD

Lets understand what is happening when we call view { ... } or viewImmediate { ... } methods. N|Solid

  1. First when we call view { setNewColor(currentColor) } new ViewAction instance is created, and passed to ViewActionDispatcherLiveData.

  2. ViewActionDispatcherLiveData is IViewActionDispatcher(from AbstactMvp) implementation with LiveData from Android arcitecture components. It holds viewActions and dispatch them to ViewActionObserver.

  3. ViewActionObserver receives viewActions and invoke them, with passing the view instance.

  4. After ViewActionObserver invokes viewAction, setNewColor(color:Int) method will be called inside ColorActivity.

view { ... } and viewImmediate { ... }

When viewAction is created via view { ... } method, ViewActionDispatcherLiveData will cache the viewActions if view is detached, and send them when view will become attached again. If viewAction is created via viewImmediate{ ... } method, it will be send it only if view is attached, otherwise viewAction will be lost. This method can be used only after presenter's onCreate() lifecycle method call. This method is calling by AbstactMvp framework (Later more detail about LifecyclePresenter lifecycle). This methods can be called from worker thread, but the execution of viewAction will be automatically switched to the main thread.

It's comfortable to use view { ... } and viewImmediate { ... } methods with different type of expressions in kotlin language such as if or when.

// this methods are defined inside presenter
...
// using view { ... } with IF
fun onComplete(items:List<Item>) {
    if(items.isEmpty()) view {
        showEmptyResult()
    } else view {
        showItems(items)
    }
}
// using view { ... } with WHEN
fun onComplete(genre:FilmGenres) = when (genre) {
            FilmGenres.HORROR -> view { 
                showHorrors()
            }
            FilmGenres.COMEDY -> view { 
                showComedy()
            }
            FilmGenres.ROMANCE -> view {
                showRomance()
            }
        }
...

LifecyclePresenter's Lifecycle

LifecyclePresenter's has five lifecycle methods.

  1. First one is onCreate(), which is the initial stating point for presenter. As we know this method is called by AbstactMvp framework, when presenter instance is created, since LifecyclePresenter is Activity lifecycle persistence, it will be called only once. onCreate() is called when AbstactMvp framework finish binding all components together. (more about AbstractMvp components here). Only onCreate() method is related with presenter's lifecycle, upcoming methods are bounded with viewController lifecycle.

  2. onViewAttach() This method is called with ViewController's onCreate()

  3. onViewStart() This method is called with ViewController's onStart()

  4. onViewStop() This method is called with ViewController's onStop()

  5. onViewDetach() This method is called with ViewController's onDestroy()

LifecycleMvpFactory Class

AbstactMvp framework uses Mvp.Factory<V,P> factory, in order to get all components instances. LifecycleMvpFactory implement Mvp.Factory<V,P> interface and provides all necessary lifecycle components. If you need to change some component implementation you can inherit from LifecycleMvpFactory class and override component provider method that you want to change.

Summary

LifecycleMvp library is AbstractMvp implementation with LiveData, ViewModels and Lifecycle from Android Architecture Components.

View Robert Apikyan profile on LinkedIn

License

Copyright 2018 Robert Apikyan

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
You might also like...
A minimal notes application in Jetpack Compose with MVVM architecture. Built with components like DataStore, Coroutines, ViewModel, LiveData, Room, Navigation-Compose, Coil, koin etc.
A minimal notes application in Jetpack Compose with MVVM architecture. Built with components like DataStore, Coroutines, ViewModel, LiveData, Room, Navigation-Compose, Coil, koin etc.

Paper - A Minimal Notes App A minimal notes application in Jetpack Compose with MVVM architecture. Built with components like DataStore, Coroutines, V

Create an application with Kotlin/JVM and Kotlin/JS, and explore features around code sharing, serialization, server- and client
Create an application with Kotlin/JVM and Kotlin/JS, and explore features around code sharing, serialization, server- and client

Practical Kotlin Multiplatform on the Web 본 저장소는 코틀린 멀티플랫폼 기반 웹 프로그래밍 워크숍(강좌)을 위해 작성된 템플릿 프로젝트가 있는 곳입니다. 워크숍 과정에서 코틀린 멀티플랫폼을 기반으로 프론트엔드(front-end)는 Ko

Create an application with Kotlin/JVM and Kotlin/JS, and explore features around code sharing, serialization, server- and client
Create an application with Kotlin/JVM and Kotlin/JS, and explore features around code sharing, serialization, server- and client

Building a Full Stack Web App with Kotlin Multiplatform 본 저장소는 INFCON 2022에서 코틀린 멀티플랫폼 기반 웹 프로그래밍 핸즈온랩을 위해 작성된 템플릿 프로젝트가 있는 곳입니다. 핸즈온 과정에서 코틀린 멀티플랫폼을

This library provides common speech features for ASR including MFCCs and filterbank energies for Android and iOS.

Kotlin Speech Features Quick Links 📒 Introduction This library is a complete port of python_speech_features in pure Kotlin available for Android and

A furry-themed assembly language and interpreter written in Kotlin.
A furry-themed assembly language and interpreter written in Kotlin.

A furry-themed assembly language and interpreter written in Kotlin. Inspired by Furcode, the Synacor challenge, and JVM bytecode. I spent multiple hou

Kotlin DALL·E 2 is a new AI system that can create realistic images and art from a description in natural language.
Kotlin DALL·E 2 is a new AI system that can create realistic images and art from a description in natural language.

OpenAI Dall•E AI Kotlin Mobile App OpenAI Dall•E Application Build With Kotlin MVVM (Model - View - ViewModel) Clean Architecture, Beautiful Design UI

Provides Kotlin libs and some features for building Kotlin plugins
Provides Kotlin libs and some features for building Kotlin plugins

Kotlin Plugin Provides Kotlin libs and some features for building awesome Kotlin plugins. Can be used instead of CreeperFace's KotlinLib (don't use to

An example for who are all going to start learning Kotlin programming language to develop Android application.

Kotlin Example Here is an example for who are all going to start learning Kotlin programming language to develop Android application. First check this

🍼Debug Bottle is an Android runtime debug / develop tools written using kotlin language.
🍼Debug Bottle is an Android runtime debug / develop tools written using kotlin language.

🇨🇳 中文 / 🇯🇵 日本語 / 🇬🇧 English 🍼 Debug Bottle An Android debug / develop tools written using Kotlin language. All the features in Debug bottle are

Releases(1.1.2-experimental)
Owner
Robert
Robert
Example Multi module architecture Android project using MVVM, Dynamic Features, Dagger-Hilt, Coroutines and Navigation Components

ModularDynamicFeatureHilt An Android template project following a multi module approach with clean architecture. It has been built following Clean Arc

Mbuodile Obiosio 25 Nov 23, 2022
Lambda-snake.kt - Snake Game Implementation for Web using Kotlin programming language compiled for Javascript

Projeto da disciplina de Linguagem de Programação Funcional 2021.1 (jan/2022) ??

Alex Candido 3 Jan 10, 2022
FaceTimeClone app that implements Coroutines , mvvm architecture , clean architecture , navigation component , hilt , etc.... using kotlin language

This repository contains a FaceTimeClone app that implements Coroutines , mvvm architecture , clean architecture , navigation component , hilt , etc.... using kotlin language

null 17 Dec 13, 2022
A fork of our clean architecture boilerplate, this time using the Android Architecture Components

Android Clean Architecture Components Boilerplate Note: This is a fork of our original Clean Architecture Boilerplate, except in this repo we have swi

Buffer 1.3k Jan 3, 2023
Bego Chat is chat application in Kotlin and Firebase with the following features: last seen , user status like typing ,online and last seen with MVVM pattern and clean architecture

Compose ChatApp(Bego Chat) Bego Chat is Compose chat application in Kotlin and Firebase with the following features: sending all file types and abilit

Ahmed EL Bagory 5 Dec 20, 2022
ATH Sample is a sample Authentication and Authorization Application with Kotlin Language and MVVM architecture.

ATH Sample ATH Sample is a sample Authentication and Authorization Application with Kotlin Language and MVVM architecture. Overview ATH Sample is a sa

AbolfaZl RezaEi 4 Jun 8, 2021
📚 Sample Android Components Architecture on a modular word focused on the scalability, testability and maintainability written in Kotlin, following best practices using Jetpack.

Android Components Architecture in a Modular Word Android Components Architecture in a Modular Word is a sample project that presents modern, 2020 app

Madalin Valceleanu 2.3k Jan 4, 2023
Multi module architecture Android template project using MVVM, Dagger-Hilt, and Navigation Components

ModularAppTemplate An Android template project following a multi module approach with clean architecture. It has been built following Clean Architectu

Mbuodile Obiosio 7 May 23, 2022
Built with Jetpack compose, multi modules MVVM clean architecture, coroutines + flow, dependency injection, jetpack navigation and other jetpack components

RickAndMortyCompose - Work in progress A simple app using Jetpack compose, clean architecture, multi modules, coroutines + flows, dependency injection

Daniel Waiguru 9 Jul 13, 2022
To illustrate the clean architecture and modularisation with other components.

CleanNews A news app that provides data from mediastack API using clean architecture, kotlin coroutines, architectural pattern (MVI) with Mavericks. .

Yves Kalume 4 Feb 13, 2022