Merge branch 'feature/flowmvvm' into lusa/safecollect

Author: johsoe

app/src/main/java/com/monstarlab/extensions/ActivityViewBindingDelegate.kt

@@ -0,0 +1,44 @@
+package com.monstarlab.extensions
+
+import android.view.LayoutInflater
+import androidx.appcompat.app.AppCompatActivity
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleObserver
+import androidx.lifecycle.OnLifecycleEvent
+import androidx.viewbinding.ViewBinding
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
+
+class ActivityViewBindingDelegate<T : ViewBinding>(
+    private val activity: AppCompatActivity,
+    private val viewBinder: (LayoutInflater) -> T,
+    private val beforeSetContent: () -> Unit = {}
+) : ReadOnlyProperty<AppCompatActivity, T>, LifecycleObserver {
+
+    private var activityBinding: T? = null
+
+    init {
+        activity.lifecycle.addObserver(this)
+    }
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
+    fun createBinding() {
+        initialize()
+        beforeSetContent()
+        activity.setContentView(activityBinding?.root)
+        activity.lifecycle.removeObserver(this)
+    }
+
+    private fun initialize() {
+        if (activityBinding == null) {
+            activityBinding = viewBinder(activity.layoutInflater)
+        }
+    }
+
+    override fun getValue(thisRef: AppCompatActivity, property: KProperty<*>): T {
+        ensureMainThread()
+
+        initialize()
+        return activityBinding!!
+    }
+}

app/src/main/java/com/monstarlab/extensions/FlowExtensions.kt

@@ -0,0 +1,40 @@
+package com.monstarlab.extensions
+
+import androidx.fragment.app.Fragment
+import androidx.lifecycle.LifecycleCoroutineScope
+import androidx.lifecycle.lifecycleScope
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.launch
+
+fun <T1, T2> CoroutineScope.combineFlows(flow1: Flow<T1>, flow2: Flow<T2>, collectBlock: (suspend (T1, T2) -> Unit)) {
+    launch {
+        flow1.combine(flow2) { v1, v2 ->
+            collectBlock.invoke(v1, v2)
+        }.collect {
+            // Empty collect block to trigger ^
+        }
+    }
+}
+
+fun <T1, T2, T3> CoroutineScope.combineFlows(flow1: Flow<T1>, flow2: Flow<T2>, flow3: Flow<T3>, collectBlock: (suspend (T1, T2, T3) -> Unit)) {
+    launch {
+        combine(flow1, flow2, flow3) { v1, v2, v3 ->
+            collectBlock.invoke(v1, v2, v3)
+        }.collect {
+            // Empty collect block to trigger ^
+        }
+    }
+}
+
+fun <T1, T2, T3, T4> CoroutineScope.combineFlows(flow1: Flow<T1>, flow2: Flow<T2>, flow3: Flow<T3>, flow4: Flow<T4>, collectBlock: (suspend (T1, T2, T3, T4) -> Unit)) {
+    launch {
+        combine(flow1, flow2, flow3, flow4) { v1, v2, v3, v4 ->
+            collectBlock.invoke(v1, v2, v3, v4)
+        }.collect {
+            // Empty collect block to trigger ^
+        }
+    }
+}

app/src/main/java/com/monstarlab/extensions/FragmentViewBindingDelegate.kt

@@ -0,0 +1,57 @@
+package com.monstarlab.extensions
+
+import android.view.View
+import androidx.fragment.app.Fragment
+import androidx.lifecycle.*
+import androidx.viewbinding.ViewBinding
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
+
+class FragmentViewBindingDelegate<T : ViewBinding>(
+    private val fragment: Fragment,
+    private val viewBinder: (View) -> T,
+    private val disposeEvents: T.() -> Unit = {}
+) : ReadOnlyProperty<Fragment, T>, LifecycleObserver {
+
+    private inline fun Fragment.observeLifecycleOwnerThroughLifecycleCreation(crossinline viewOwner: LifecycleOwner.() -> Unit) {
+        lifecycle.addObserver(object : DefaultLifecycleObserver {
+            override fun onCreate(owner: LifecycleOwner) {
+                viewLifecycleOwnerLiveData.observe(
+                    this@observeLifecycleOwnerThroughLifecycleCreation,
+                    Observer { viewLifecycleOwner ->
+                        viewLifecycleOwner.viewOwner()
+                    })
+            }
+        })
+    }
+
+    private var fragmentBinding: T? = null
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
+    fun disposeBinding() {
+        fragmentBinding?.disposeEvents()
+        fragmentBinding = null
+    }
+
+    init {
+        fragment.observeLifecycleOwnerThroughLifecycleCreation {
+            lifecycle.addObserver(this@FragmentViewBindingDelegate)
+        }
+    }
+
+    override fun getValue(thisRef: Fragment, property: KProperty<*>): T {
+
+        ensureMainThread()
+
+        val binding = fragmentBinding
+        if (binding != null) {
+            return binding
+        }
+
+        val lifecycle = fragment.viewLifecycleOwner.lifecycle
+        if (!lifecycle.currentState.isAtLeast(Lifecycle.State.INITIALIZED)) {
+            throw IllegalStateException("Fragment views are destroyed.")
+        }
+        return viewBinder(thisRef.requireView()).also { fragmentBinding = it }
+    }
+}

app/src/main/java/com/monstarlab/extensions/GlobalViewBindingDelegate.kt

@@ -0,0 +1,14 @@
+package com.monstarlab.extensions
+
+import android.view.View
+import androidx.viewbinding.ViewBinding
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
+
+class GlobalViewBindingDelegate<T : ViewBinding>(val viewBinder: (View) -> T) :
+    ReadOnlyProperty<View, T> {
+
+    override fun getValue(thisRef: View, property: KProperty<*>): T {
+        return viewBinder(thisRef)
+    }
+}

app/src/main/java/com/monstarlab/extensions/ViewBindingExtensions.kt

@@ -0,0 +1,35 @@
+package com.monstarlab.extensions
+
+import android.app.Activity
+import android.os.Looper
+import android.view.LayoutInflater
+import android.view.View
+import androidx.appcompat.app.AppCompatActivity
+import androidx.fragment.app.Fragment
+import androidx.viewbinding.ViewBinding
+
+inline fun <T : ViewBinding> Activity.viewBinder(crossinline bindingInflater: (LayoutInflater) -> T) =
+    lazy(LazyThreadSafetyMode.NONE) {
+        bindingInflater.invoke(layoutInflater)
+    }
+
+fun <T : ViewBinding> AppCompatActivity.viewBinding(
+    bindingInflater: (LayoutInflater) -> T,
+    beforeSetContent: () -> Unit = {}
+) =
+    ActivityViewBindingDelegate(this, bindingInflater, beforeSetContent)
+
+fun <T : ViewBinding> Fragment.viewBinding(
+    viewBindingFactory: (View) -> T,
+    disposeEvents: T.() -> Unit = {}
+) =
+    FragmentViewBindingDelegate(this, viewBindingFactory, disposeEvents)
+
+fun <T : ViewBinding> globalViewBinding(viewBindingFactory: (View) -> T) =
+    GlobalViewBindingDelegate(viewBindingFactory)
+
+internal fun ensureMainThread() {
+    if (Looper.myLooper() != Looper.getMainLooper()) {
+        throw IllegalThreadStateException("View can be accessed only on the main thread.")
+    }
+}

app/src/main/java/com/monstarlab/extensions/ViewExtensions.kt

@@ -12,7 +12,7 @@ import kotlinx.coroutines.launch
 
 fun <T> Fragment.collectFlow(targetFlow: Flow<T>, collectBlock: ((T) -> Unit)) {
     safeViewCollect {
-        viewLifecycleOwner.lifecycleScope.launch {
+        viewLifecycleOwner.lifecycleScope.launchWhenCreated {
             targetFlow.collect {
                 collectBlock.invoke(it)
             }
@@ -33,7 +33,7 @@ private inline fun Fragment.safeViewCollect(crossinline viewOwner: LifecycleOwne
 }
 
 fun <T1, T2> Fragment.combineFlows(flow1: Flow<T1>, flow2: Flow<T2>, collectBlock: ((T1, T2) -> Unit)) {
-    viewLifecycleOwner.lifecycleScope.launch {
+    viewLifecycleOwner.lifecycleScope.launchWhenCreated {
         flow1.combine(flow2) { v1, v2 ->
             collectBlock.invoke(v1, v2)
         }.collect {
@@ -43,7 +43,7 @@ fun <T1, T2> Fragment.combineFlows(flow1: Flow<T1>, flow2: Flow<T2>, collectBloc
 }
 
 fun <T1, T2, T3> Fragment.combineFlows(flow1: Flow<T1>, flow2: Flow<T2>, flow3: Flow<T3>,  collectBlock: ((T1, T2, T3) -> Unit)) {
-    viewLifecycleOwner.lifecycleScope.launch {
+    viewLifecycleOwner.lifecycleScope.launchWhenCreated {
         combine(flow1, flow2, flow3) { v1, v2, v3 ->
             collectBlock.invoke(v1, v2, v3)
         }.collect {
@@ -53,7 +53,7 @@ fun <T1, T2, T3> Fragment.combineFlows(flow1: Flow<T1>, flow2: Flow<T2>, flow3:
 }
 
 fun <T1, T2, T3, T4> Fragment.combineFlows(flow1: Flow<T1>, flow2: Flow<T2>, flow3: Flow<T3>, flow4: Flow<T4>, collectBlock: ((T1, T2, T3, T4) -> Unit)) {
-    viewLifecycleOwner.lifecycleScope.launch {
+    viewLifecycleOwner.lifecycleScope.launchWhenCreated {
         combine(flow1, flow2, flow3, flow4) { v1, v2, v3, v4 ->
             collectBlock.invoke(v1, v2, v3, v4)
         }.collect {
@@ -63,7 +63,7 @@ fun <T1, T2, T3, T4> Fragment.combineFlows(flow1: Flow<T1>, flow2: Flow<T2>, flo
 }
 
 fun <T1, T2> Fragment.zipFlows(flow1: Flow<T1>, flow2: Flow<T2>,  collectBlock: ((T1, T2) -> Unit)) {
-    viewLifecycleOwner.lifecycleScope.launch {
+    viewLifecycleOwner.lifecycleScope.launchWhenCreated {
         flow1.zip(flow2) { v1, v2 ->
             collectBlock.invoke(v1, v2)
         }.collect {

app/src/main/java/com/monstarlab/features/sample/SampleFragment.kt

@@ -1,36 +1,20 @@
 package com.monstarlab.features.sample
 
 import android.os.Bundle
-import android.view.LayoutInflater
 import android.view.View
-import android.view.ViewGroup
-import androidx.fragment.app.Fragment
 import com.monstarlab.R
 import com.monstarlab.base.BaseFragment
 import com.monstarlab.databinding.FragmentSampleBinding
 import com.monstarlab.extensions.collectFlow
+import com.monstarlab.extensions.viewBinding
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.flow.combine
 
-class SampleFragment: BaseFragment(R.layout.fragment_sample) {
+class SampleFragment : BaseFragment(R.layout.fragment_sample) {
 
-    val viewModel by viewModel<SampleViewModel>()
+    private val viewModel by viewModel<SampleViewModel>()
 
-    private var _binding: FragmentSampleBinding? = null
-    private val binding get() = _binding!!
-
-    override fun onCreateView(
-        inflater: LayoutInflater,
-        container: ViewGroup?,
-        savedInstanceState: Bundle?
-    ): View? {
-        _binding = FragmentSampleBinding.inflate(inflater, container, false)
-        val view = binding.root
-        return view
-    }
-
-    override fun onDestroyView() {
-        super.onDestroyView()
-        _binding = null
-    }
+    private val binding by viewBinding(FragmentSampleBinding::bind)
 
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         super.onViewCreated(view, savedInstanceState)
@@ -39,8 +23,14 @@ class SampleFragment: BaseFragment(R.layout.fragment_sample) {
             binding.valueTextView.text = "Clicked $clicks times"
         }
 
+        collectFlow(viewModel.textFlow) { newText ->
+            binding.asyncTextView.text = newText
+        }
+
         binding.theButton.setOnClickListener {
             viewModel.clickedButton()
         }
+
+        viewModel.fetchString()
     }
 }

app/src/main/java/com/monstarlab/features/sample/SampleViewModel.kt

@@ -1,17 +1,42 @@
 package com.monstarlab.features.sample
 
 import androidx.lifecycle.ViewModel
-import kotlinx.coroutines.flow.MutableStateFlow
+import androidx.lifecycle.viewModelScope
+import com.monstarlab.extensions.combineFlows
+import com.monstarlab.mock.MockFlows
+import com.monstarlab.mock.MockSuspends
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import javax.inject.Inject
 
 class SampleViewModel @Inject constructor(
 
 ): ViewModel() {
 
     val clickFlow: MutableStateFlow<Int> = MutableStateFlow(0)
+    val textFlow: MutableStateFlow<String> = MutableStateFlow("Nothing yet")
 
     fun clickedButton() {
         clickFlow.value++
     }
 
+    fun fetchString() {
+        viewModelScope.combineFlows(MockFlows.mockString(), MockFlows.mockFlag()) { text, flag ->
+            textFlow.value = "text: $text - flag: $flag"
+        }
+
+
+        MockFlows.mockString()
+                .onEach { result -> textFlow.value = result }
+                .catch { _ -> /* Do something with the exception */ }
+                .launchIn(viewModelScope)
+
+        viewModelScope.launch {
+            val result = withContext(Dispatchers.IO) { MockSuspends.fetchString() }
+            textFlow.value = result
+        }
+    }
+
 }

app/src/main/java/com/monstarlab/mock/MockFlows.kt

@@ -0,0 +1,21 @@
+package com.monstarlab.mock
+
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+
+object MockFlows {
+
+    fun mockString(): Flow<String> = flow {
+        delay(2000)
+        emit("Hello world from Flow")
+    }
+
+    fun mockFlag(): Flow<Boolean> = flow {
+        delay(1000)
+        emit(false)
+        delay(2000)
+        emit(true)
+    }
+
+}

app/src/main/java/com/monstarlab/mock/MockSuspends.kt

@@ -0,0 +1,12 @@
+package com.monstarlab.mock
+
+import kotlinx.coroutines.delay
+
+object MockSuspends {
+
+    suspend fun fetchString(): String {
+        delay(5000)
+        return "Hello world from suspend"
+    }
+
+}