Global rendering and logging improvements

semanticer · semanticer · commit 17968ef40165 · 2018-03-12T18:19:04.000+01:00
diff --git a/elmdroid/src/main/java/cz/inventi/elmdroid/ElmArchitecture.kt b/elmdroid/src/main/java/cz/inventi/elmdroid/ElmArchitecture.kt
@@ -21,6 +21,16 @@ interface ComponentRuntime<STATE : State, in MSG : Msg> : DefaultLifecycleObserv
     override fun onDestroy(owner: LifecycleOwner) {
         clear()
     }
+
+    companion object {
+        fun <STATE : State, MSG : Msg, CMD : Cmd> create(component: Component<STATE, MSG, CMD>, lifecycleOwner: LifecycleOwner? = null, logLevel: LogLevel = Elmdroid.defaultLogLevel): ComponentRuntime<STATE, MSG> {
+            val rxRuntime = RxRuntime(component, logLevel)
+            if (lifecycleOwner != null) {
+                rxRuntime.bindTo(lifecycleOwner)
+            }
+            return rxRuntime
+        }
+    }
 }
 
 /** Key class specifying all mayor pars of your elm architecture. */
diff --git a/elmdroid/src/main/java/cz/inventi/elmdroid/ElmViewModel.kt b/elmdroid/src/main/java/cz/inventi/elmdroid/ElmViewModel.kt
@@ -6,7 +6,7 @@ import android.arch.lifecycle.ViewModel
 
 open class ElmViewModel<STATE : State, in MSG : Msg, CMD : Cmd> (component: Component<STATE, MSG, CMD>, logLevel: LogLevel = LogLevel.NONE) :
         ViewModel(),
-        ComponentRuntime<STATE, MSG> by RuntimeFactory.create(component, logLevel = logLevel) {
+        ComponentRuntime<STATE, MSG> by ComponentRuntime.create(component, logLevel = logLevel) {
 
     override fun onCleared() {
         super.onCleared()
@@ -18,7 +18,7 @@ abstract class ElmBaseViewModel<STATE : State, MSG : Msg, CMD : Cmd>(logLevel: L
         Component<STATE, MSG, CMD>,
         ComponentRuntime<STATE, MSG> {
 
-    private val runtime = RuntimeFactory.create(this, logLevel = logLevel)
+    private val runtime = ComponentRuntime.create(this, logLevel = logLevel)
 
     override fun state(): LiveData<STATE> = runtime.state()
 
@@ -31,7 +31,7 @@ abstract class ElmSimpleBaseViewModel<STATE : State, MSG : Msg>(logLevel: LogLev
         SimpleComponent<STATE, MSG>,
         ComponentRuntime<STATE, MSG> {
 
-    private val runtime = RuntimeFactory.create(this, logLevel = logLevel)
+    private val runtime = ComponentRuntime.create(this, logLevel = logLevel)
 
     override fun state(): LiveData<STATE> = runtime.state()
 
diff --git a/elmdroid/src/main/java/cz/inventi/elmdroid/Elmdroid.kt b/elmdroid/src/main/java/cz/inventi/elmdroid/Elmdroid.kt
@@ -0,0 +1,5 @@
+package cz.inventi.elmdroid
+
+object Elmdroid {
+    var defaultLogLevel = LogLevel.NONE
+}
diff --git a/elmdroid/src/main/java/cz/inventi/elmdroid/RuntimeFactory.kt b/elmdroid/src/main/java/cz/inventi/elmdroid/RuntimeFactory.kt
diff --git a/elmdroid/src/main/java/cz/inventi/elmdroid/RxRuntime.kt b/elmdroid/src/main/java/cz/inventi/elmdroid/RxRuntime.kt
@@ -2,7 +2,6 @@ package cz.inventi.elmdroid
 
 import android.arch.lifecycle.LiveData
 import android.arch.lifecycle.MutableLiveData
-import android.util.Log
 import com.jakewharton.rxrelay2.BehaviorRelay
 import io.reactivex.Observable
 import io.reactivex.ObservableTransformer
@@ -44,7 +43,7 @@ internal class RxRuntime<STATE : State, in MSG : Msg, CMD : Cmd> (component: Com
             val subObs: Observable<MSG> = createSubObs(sub, sharedStateRelay)
             val subDisposable = subObs
                 .subscribeNewObserveMain()
-                .doOnSubscribe { log(LogLevel.FULL,"Subscribed sub: $sub") }
+                .doOnSubscribe { log(logLevel, LogLevel.FULL, TAG,"Subscribed sub: $sub") }
                 .subscribe { msg -> dispatch(msg) }
             compositeDisposable.add(subDisposable)
         }
@@ -54,26 +53,26 @@ internal class RxRuntime<STATE : State, in MSG : Msg, CMD : Cmd> (component: Com
 
     override fun clear() {
         compositeDisposable.clear()
-        log(LogLevel.BASIC, "Runtime cleared")
+        log(logLevel, LogLevel.BASIC, TAG, "Runtime cleared")
     }
 
     override fun dispatch(msg: MSG) {
         msgRelay.accept(msg)
-        log(LogLevel.BASIC,"Msg dispatched: $msg")
+        log(logLevel, LogLevel.BASIC, TAG,"Msg dispatched: $msg")
     }
 
     private fun updateStateValue(stateVal: STATE) {
         state.value = stateVal
         stateRelay.accept(stateVal)
-        log(LogLevel.BASIC, "State updated to: $stateVal")
+        log(logLevel, LogLevel.BASIC, TAG, "State updated to: $stateVal")
     }
 
     private fun cmdToMsg(component: Component<STATE, MSG, CMD>): ObservableTransformer<Pair<STATE, CMD?>, MSG> {
         return ObservableTransformer { obs ->
             obs.filter{ (_, maybeCmd) -> maybeCmd != null }
                 .map { (_, cmd) -> cmd }
                 .observeOn(Schedulers.newThread())
-                .doOnNext { cmd -> log(LogLevel.BASIC, "Calling cmd: $cmd") }
+                .doOnNext { cmd -> log(logLevel, LogLevel.BASIC, TAG, "Calling cmd: $cmd") }
                 .flatMap { cmd -> component.call(cmd).toObservable()}
                 .observeOn(AndroidSchedulers.mainThread())
         }
@@ -88,18 +87,15 @@ internal class RxRuntime<STATE : State, in MSG : Msg, CMD : Cmd> (component: Com
             is StatefulSub<STATE, MSG> -> {
                 sharedStateRelay
                     .distinctUntilChanged { s1, s2 -> !sub.isDistinct(s1, s2) }
-                    .doOnNext{ state -> log(LogLevel.FULL, "New state $state for StatefulSub $sub to handle")}
+                    .doOnNext{ state -> log(logLevel, LogLevel.FULL, TAG,  "New state $state for StatefulSub $sub to handle")}
                     .switchMap { state -> sub(state) }
             }
         }
     }
 
-    private fun log(
-        minLogLevel: LogLevel,
-        logMsg: String
-    ) {
-        if (minLogLevel.logLevelIndex <= logLevel.logLevelIndex) {
-            Log.d("ComponentRuntime", logMsg)
-        }
+    companion object {
+        const val TAG = "ComponentRuntime"
     }
+
+
 }
diff --git a/elmdroid/src/main/java/cz/inventi/elmdroid/Utils.kt b/elmdroid/src/main/java/cz/inventi/elmdroid/Utils.kt
@@ -1,9 +1,21 @@
 package cz.inventi.elmdroid
 
+import android.util.Log
 import io.reactivex.Observable
 import io.reactivex.android.schedulers.AndroidSchedulers
 import io.reactivex.schedulers.Schedulers
 
 internal fun <T> Observable<T>.subscribeNewObserveMain(): Observable<T> {
     return this.subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread())
 }
+
+internal fun log(
+        logLevel: LogLevel,
+        minLogLevel: LogLevel,
+        tag: String,
+        logMsg: String
+) {
+    if (minLogLevel.logLevelIndex <= logLevel.logLevelIndex) {
+        Log.d(tag, logMsg)
+    }
+}
diff --git a/elmdroid/src/main/java/cz/inventi/elmdroid/ViewRenderer.kt b/elmdroid/src/main/java/cz/inventi/elmdroid/ViewRenderer.kt
@@ -10,7 +10,7 @@ interface ViewRenderer<in V : LifecycleOwner, S: State> : Observer<S>, DefaultLi
     infix fun <S, T> Triple<S, S?, (S) -> T>.into(apply: (T) -> Unit): S
 }
 
-abstract class BaseViewRenderer<in V : LifecycleOwner, S: State> (private var view: V?) : ViewRenderer<V, S> {
+abstract class BaseViewRenderer<in V : LifecycleOwner, S: State> (private var view: V?, private val logLevel: LogLevel = Elmdroid.defaultLogLevel) : ViewRenderer<V, S> {
 
     private var previouslyRenderedState: S? = null
 
@@ -29,19 +29,27 @@ abstract class BaseViewRenderer<in V : LifecycleOwner, S: State> (private var vi
 
     override fun onDestroy(owner: LifecycleOwner) {
         view = null
+        log(logLevel, LogLevel.BASIC, TAG, "onDestroy: view deleted" )
     }
 
     override fun onStop(owner: LifecycleOwner) {
         previouslyRenderedState = null
+        log(logLevel, LogLevel.BASIC, TAG, "onStop: previouslyRenderedState deleted" )
     }
 
     override infix fun <T> S.from(getter: (S) -> T): Triple<S, S?, (S) -> T> = Triple(this, previouslyRenderedState, getter)
     override infix fun <S, T> Triple<S, S?, (S) -> T>.into(apply: (T) -> Unit): S {
         val (state, prevState, getter) = this
         val newValue = getter(state)
-        if (prevState == null || getter(prevState) != newValue) {
+        val oldValue = prevState?.let { getter(prevState) }
+        if (oldValue == null || oldValue != newValue) {
             apply(newValue)
+            log(logLevel, LogLevel.FULL, TAG, "New value applied. From $oldValue => $newValue" )
         }
         return state
     }
+
+    companion object {
+        const val TAG = "ViewRenderer"
+    }
 }
diff --git a/elmdroid/src/test/java/cz/inventi/elmdroid/ComponentRuntimeTest.kt b/elmdroid/src/test/java/cz/inventi/elmdroid/ComponentRuntimeTest.kt
@@ -38,7 +38,7 @@ class ComponentRuntimeTest {
         MockitoAnnotations.initMocks(this)
         `when`(component.initState()).thenReturn(TestState(3, "init"))
         lifecycleOwner = TestLifecycleOwner()
-        runtime = Mockito.spy(RuntimeFactory.create(component))
+        runtime = Mockito.spy(ComponentRuntime.create(component))
         runtime.bindTo(lifecycleOwner)
     }
 
diff --git a/sample/build.gradle b/sample/build.gradle
@@ -33,7 +33,7 @@ dependencies {
 
     // arch
     implementation deps.lifecycle.viewmodel
-    implementation deps.lifecycle.livedata
+    implementation deps.lifecycle.extensions
     implementation deps.lifecycle.java8
 
     // rx
diff --git a/sample/src/main/java/com/example/elmdroid/ElmApp.kt b/sample/src/main/java/com/example/elmdroid/ElmApp.kt
@@ -1,13 +1,13 @@
 package com.example.elmdroid
 
 import android.app.Application
+import cz.inventi.elmdroid.Elmdroid
 import cz.inventi.elmdroid.LogLevel
-import cz.inventi.elmdroid.RuntimeFactory
 
 
 class ElmApp : Application() {
     override fun onCreate() {
         super.onCreate()
-        RuntimeFactory.defaultLogLevel = if (BuildConfig.DEBUG)  LogLevel.FULL else LogLevel.NONE
+        Elmdroid.defaultLogLevel = if (BuildConfig.DEBUG) LogLevel.FULL else LogLevel.NONE
     }
 }
diff --git a/sample/src/main/java/com/example/elmdroid/counter/CounterActivity.kt b/sample/src/main/java/com/example/elmdroid/counter/CounterActivity.kt
@@ -5,7 +5,6 @@ import android.os.Bundle
 import android.support.v7.app.AppCompatActivity
 import com.example.elmdroid.R
 import cz.inventi.elmdroid.ComponentRuntime
-import cz.inventi.elmdroid.RuntimeFactory
 import kotlinx.android.synthetic.main.activity_counter.*
 
 class CounterActivity : AppCompatActivity() {
@@ -17,7 +16,7 @@ class CounterActivity : AppCompatActivity() {
         setContentView(R.layout.activity_counter)
         supportActionBar?.title = getString(R.string.basic_counter)
 
-        runtime = RuntimeFactory.create(CounterComponent(), this)
+        runtime = ComponentRuntime.create(CounterComponent(), this)
 
         runtime.state().observe(this, Observer {
             it?.let { counter.text = "${it.counter}" }
diff --git a/sample/src/main/java/com/example/elmdroid/login/presentation/LoginActivity.kt b/sample/src/main/java/com/example/elmdroid/login/presentation/LoginActivity.kt
@@ -6,7 +6,6 @@ import android.widget.*
 import com.example.elmdroid.R
 import com.example.elmdroid.common.setOnTextChangeListener
 import cz.inventi.elmdroid.ComponentRuntime
-import cz.inventi.elmdroid.RuntimeFactory
 import kotlinx.android.synthetic.main.activity_login.*
 
 class LoginActivity : AppCompatActivity(), LoginView  {
@@ -19,7 +18,7 @@ class LoginActivity : AppCompatActivity(), LoginView  {
 
         supportActionBar?.title = getString(R.string.complex_login)
 
-        runtime = RuntimeFactory.create(LoginComponent(), this)
+        runtime = ComponentRuntime.create(LoginComponent(), this)
 
         // observe state
         runtime.state().observe(this, LoginRenderer(this))
diff --git a/sample/src/main/java/com/example/elmdroid/login/presentation/LoginComponent.kt b/sample/src/main/java/com/example/elmdroid/login/presentation/LoginComponent.kt
@@ -13,10 +13,10 @@ class LoginComponent : Component<LoginState, LoginMsg, LoginCmd> {
     override fun initState(): LoginState = LoginState("", "", false, false, "", "", 0)
 
     override fun update(msg: LoginMsg, prevState: LoginState): Pair<LoginState, LoginCmd?> = when(msg) {
-        is EmailChanged ->      prevState.copy(email = msg.email, msgText = "").updateLogin().noCmd()
-        is PasswordChanged ->   prevState.copy(password = msg.password, msgText = "").updateLogin().noCmd()
+        is EmailChanged ->      prevState.copy(email = msg.email, msgText = "").updateLoginEnabled().noCmd()
+        is PasswordChanged ->   prevState.copy(password = msg.password, msgText = "").updateLoginEnabled().noCmd()
         LoginClicked ->      prevState.copy(loadingVisible = true, loginEnabled = false, msgText = "") withCmd LoginAction(prevState.email, prevState.password)
-        is LoginSuccess ->      prevState.copy(loadingVisible = false, msgText = "Login Successful, welcome ${msg.username}", email = "", password = "").updateLogin().noCmd()
+        is LoginSuccess ->      prevState.copy(loadingVisible = false, msgText = "Login Successful, welcome ${msg.username}", email = "", password = "").updateLoginEnabled().noCmd()
         is LoggedUserChanged -> prevState.copy(loggedUsername = msg.username, loggedTimer = 0).noCmd()
         Tick ->                 prevState.copy(loggedTimer = (prevState.loggedTimer + 1)).noCmd()
     }
@@ -27,7 +27,7 @@ class LoginComponent : Component<LoginState, LoginMsg, LoginCmd> {
 
     override fun subscriptions(): List<Sub<LoginState, LoginMsg>> = listOf(UserSubscription(), CounterSubscription())
 
-    private fun LoginState.updateLogin() = this.copy(loginEnabled = (email.isNotBlank() && password.isNotBlank()))
+    private fun LoginState.updateLoginEnabled() = this.copy(loginEnabled = (email.isNotBlank() && password.isNotBlank()))
 }
 
 
diff --git a/sample/src/main/java/com/example/elmdroid/login/presentation/LoginRenderer.kt b/sample/src/main/java/com/example/elmdroid/login/presentation/LoginRenderer.kt
@@ -11,7 +11,7 @@ class LoginRenderer(view: LoginView?) : BaseViewRenderer<LoginView, LoginState>(
         state from { it.loggedUsername } into {
             loggedUser().text = it
         } from { it.loginEnabled } into {
-            loginButton().isEnabled
+            loginButton().isEnabled = it
         } from { it.loadingVisible } into {
             if (it){
                 email().isEnabled = false
@@ -22,6 +22,10 @@ class LoginRenderer(view: LoginView?) : BaseViewRenderer<LoginView, LoginState>(
                 password().isEnabled = true
                 progressBar().visibility = View.GONE
             }
+        } from { it.email } into {
+            if (it.isEmpty()) email().setText("")
+        } from { it.password} into {
+            if (it.isEmpty()) password().setText("")
         } from { it.msgText } into {
             if (it.isNotBlank()) {
                 showUserMsg(state.msgText)
diff --git a/sample/src/main/java/com/example/elmdroid/login/presentation/LoginVMActivity.kt b/sample/src/main/java/com/example/elmdroid/login/presentation/LoginVMActivity.kt
@@ -1,6 +1,6 @@
 package com.example.elmdroid.login.presentation
 
-import android.arch.lifecycle.ViewModelProvider
+import android.arch.lifecycle.ViewModelProviders
 import android.os.Bundle
 import android.support.v7.app.AppCompatActivity
 import android.widget.*
@@ -19,7 +19,7 @@ class LoginVMActivity : AppCompatActivity(), LoginView {
 
         supportActionBar?.title = getString(R.string.complex_login_with_viewmodel)
 
-        viewModel = ViewModelProvider.AndroidViewModelFactory.getInstance(application).create(LoginViewModel::class.java)
+        viewModel = ViewModelProviders.of(this).get(LoginViewModel::class.java)
 
         // observe state
         viewModel.state().observe(this, LoginRenderer(this))
diff --git a/sample/src/main/java/com/example/elmdroid/login/presentation/LoginView.kt b/sample/src/main/java/com/example/elmdroid/login/presentation/LoginView.kt
@@ -6,9 +6,6 @@ import android.widget.EditText
 import android.widget.ProgressBar
 import android.widget.TextView
 
-/**
- * Created by tomas.valenta on 11/21/2017.
- */
 interface LoginView : LifecycleOwner {
     fun email(): EditText
     fun password(): EditText
diff --git a/sample/src/test/java/com/example/elmdroid/counter/CounterComponentTest.kt b/sample/src/test/java/com/example/elmdroid/counter/CounterComponentTest.kt
@@ -5,7 +5,6 @@ import android.arch.lifecycle.Observer
 import com.example.elmdroid.utils.RxImmediateSchedulerRule
 import com.example.elmdroid.utils.verifyStates
 import cz.inventi.elmdroid.ComponentRuntime
-import cz.inventi.elmdroid.RuntimeFactory
 import org.junit.Before
 import org.junit.ClassRule
 import org.junit.Rule
@@ -37,7 +36,7 @@ class CounterComponentTest {
     fun setup(){
         MockitoAnnotations.initMocks(this)
         component = CounterComponent()
-        runtime = RuntimeFactory.create(component)
+        runtime = ComponentRuntime.create(component)
     }
 
     @Test
diff --git a/sample/src/test/java/com/example/elmdroid/login/LoginComponentTest.kt b/sample/src/test/java/com/example/elmdroid/login/LoginComponentTest.kt
diff --git a/versions.gradle b/versions.gradle

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ interface ViewRenderer<in V : LifecycleOwner, S: State> : Observer<S>, DefaultLi`
`10`	`10`	`infix fun <S, T> Triple<S, S?, (S) -> T>.into(apply: (T) -> Unit): S`
`11`	`11`	`}`
`12`	`12`
`13`		`-abstract class BaseViewRenderer<in V : LifecycleOwner, S: State> (private var view: V?) : ViewRenderer<V, S> {`
	`13`	`+abstract class BaseViewRenderer<in V : LifecycleOwner, S: State> (private var view: V?, private val logLevel: LogLevel = Elmdroid.defaultLogLevel) : ViewRenderer<V, S> {`
`14`	`14`
`15`	`15`	`private var previouslyRenderedState: S? = null`
`16`	`16`
`@@ -29,19 +29,27 @@ abstract class BaseViewRenderer<in V : LifecycleOwner, S: State> (private var vi`
`29`	`29`
`30`	`30`	`override fun onDestroy(owner: LifecycleOwner) {`
`31`	`31`	`view = null`
	`32`	`+ log(logLevel, LogLevel.BASIC, TAG, "onDestroy: view deleted" )`
`32`	`33`	`}`
`33`	`34`
`34`	`35`	`override fun onStop(owner: LifecycleOwner) {`
`35`	`36`	`previouslyRenderedState = null`
	`37`	`+ log(logLevel, LogLevel.BASIC, TAG, "onStop: previouslyRenderedState deleted" )`
`36`	`38`	`}`
`37`	`39`
`38`	`40`	`override infix fun <T> S.from(getter: (S) -> T): Triple<S, S?, (S) -> T> = Triple(this, previouslyRenderedState, getter)`
`39`	`41`	`override infix fun <S, T> Triple<S, S?, (S) -> T>.into(apply: (T) -> Unit): S {`
`40`	`42`	`val (state, prevState, getter) = this`
`41`	`43`	`val newValue = getter(state)`
`42`		`- if (prevState == null \|\| getter(prevState) != newValue) {`
	`44`	`+ val oldValue = prevState?.let { getter(prevState) }`
	`45`	`+ if (oldValue == null \|\| oldValue != newValue) {`
`43`	`46`	`apply(newValue)`
	`47`	`+ log(logLevel, LogLevel.FULL, TAG, "New value applied. From $oldValue => $newValue" )`
`44`	`48`	`}`
`45`	`49`	`return state`
`46`	`50`	`}`
	`51`	`+`
	`52`	`+ companion object {`
	`53`	`+ const val TAG = "ViewRenderer"`
	`54`	`+ }`
`47`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ class ComponentRuntimeTest {`
`38`	`38`	`MockitoAnnotations.initMocks(this)`
`39`	`39`	`when`(component.initState()).thenReturn(TestState(3, "init"))
`40`	`40`	`lifecycleOwner = TestLifecycleOwner()`
`41`		`- runtime = Mockito.spy(RuntimeFactory.create(component))`
	`41`	`+ runtime = Mockito.spy(ComponentRuntime.create(component))`
`42`	`42`	`runtime.bindTo(lifecycleOwner)`
`43`	`43`	`}`
`44`	`44`
Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,13 @@`
`1`	`1`	`package com.example.elmdroid`
`2`	`2`
`3`	`3`	`import android.app.Application`
	`4`	`+import cz.inventi.elmdroid.Elmdroid`
`4`	`5`	`import cz.inventi.elmdroid.LogLevel`
`5`		`-import cz.inventi.elmdroid.RuntimeFactory`
`6`	`6`
`7`	`7`
`8`	`8`	`class ElmApp : Application() {`
`9`	`9`	`override fun onCreate() {`
`10`	`10`	`super.onCreate()`
`11`		`- RuntimeFactory.defaultLogLevel = if (BuildConfig.DEBUG) LogLevel.FULL else LogLevel.NONE`
	`11`	`+ Elmdroid.defaultLogLevel = if (BuildConfig.DEBUG) LogLevel.FULL else LogLevel.NONE`
`12`	`12`	`}`
`13`	`13`	`}`