Home work

app/src/main/kotlin/ru/otus/coroutineshomework/ui/login/LoginFragment.kt

@@ -7,6 +7,8 @@ import android.view.ViewGroup
 import androidx.core.view.isVisible
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.viewModels
+import androidx.lifecycle.lifecycleScope
+import kotlinx.coroutines.launch
 import ru.otus.coroutineshomework.databinding.ContentBinding
 import ru.otus.coroutineshomework.databinding.FragmentLoginBinding
 import ru.otus.coroutineshomework.databinding.LoadingBinding
@@ -43,12 +45,14 @@ class LoginFragment : Fragment() {
         setupLogin()
         setupContent()
 
-        loginViewModel.state.observe(viewLifecycleOwner) {
-            when(it) {
-                is LoginViewState.Login -> showLogin(it)
-                LoginViewState.LoggingIn -> showLoggingIn()
-                is LoginViewState.Content -> showContent(it)
-                LoginViewState.LoggingOut -> showLoggingOut()
+        viewLifecycleOwner.lifecycleScope.launch {
+            loginViewModel.state.collect {
+                when(it) {
+                    is LoginViewState.Login -> showLogin(it)
+                    LoginViewState.LoggingIn -> showLoggingIn()
+                    is LoginViewState.Content -> showContent(it)
+                    LoginViewState.LoggingOut -> showLoggingOut()
+                }
             }
         }
     }

app/src/main/kotlin/ru/otus/coroutineshomework/ui/login/LoginViewModel.kt

@@ -1,27 +1,62 @@
 package ru.otus.coroutineshomework.ui.login
 
-import androidx.lifecycle.LiveData
-import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import ru.otus.coroutineshomework.ui.login.data.Credentials
 
 class LoginViewModel : ViewModel() {
 
-    private val _state = MutableLiveData<LoginViewState>(LoginViewState.Login())
-    val state: LiveData<LoginViewState> = _state
+    private val stateFlow = MutableStateFlow<LoginViewState>(LoginViewState.Login())
+    val state: StateFlow<LoginViewState> = stateFlow.asStateFlow()
+
+    private fun loginFlow(name: String, password: String): Flow<LoginViewState> = flow {
+        emit(LoginViewState.LoggingIn)
+
+        val user = withContext(Dispatchers.IO) {
+            LoginApi().login(Credentials(name, password))
+        }
+
+        emit(LoginViewState.Content(user))
+    }.catch { e ->
+        emit(LoginViewState.Login(e as Exception?))
+    }
 
     /**
      * Login to the network
      * @param name user name
      * @param password user password
      */
     fun login(name: String, password: String) {
-        // TODO: Implement login
+        viewModelScope.launch {
+            loginFlow(name,password).collect { state ->
+                stateFlow.value = state
+            }
+        }
     }
 
     /**
      * Logout from the network
      */
-    fun logout() {
-        // TODO: Implement logout
+    private fun logoutFlow(): Flow<LoginViewState> = flow {
+        emit( LoginViewState.LoggingOut)
+        withContext(Dispatchers.IO) {
+           LoginApi().logout()
+        }
+        emit(LoginViewState.Login(null))
+    }
+    fun logout() = viewModelScope.launch {
+        logoutFlow().collect { state ->
+            stateFlow.value = state
+        }
     }
+
 }

app/src/main/kotlin/ru/otus/coroutineshomework/ui/network/NetworkViewModel.kt

@@ -4,8 +4,12 @@ import android.util.Log
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import kotlin.random.Random
 
@@ -17,8 +21,26 @@ class NetworkViewModel : ViewModel() {
     private val _result: MutableLiveData<Long?> = MutableLiveData()
     val result: LiveData<Long?> = _result
 
-    fun startTest(numberOfThreads: Int) {
-        // TODO: Implement the logic
+    fun startTest(numberOfThreads: Int) = viewModelScope.launch {
+        _running.value = true
+
+        val results = List(numberOfThreads) {
+            async { emulateBlockingNetworkRequest() }
+        }.awaitAll()
+
+        val sum = results.filter {
+            it.isSuccess
+        }.mapNotNull {
+            it.getOrNull()
+        }.sum()
+
+        if (sum == 0.toLong()) {
+            _result.value = 0.toLong()
+        } else {
+            _result.value = sum / numberOfThreads
+        }
+
+        _running.value = false
     }
 
     private companion object {

app/src/main/kotlin/ru/otus/coroutineshomework/ui/timer/TimerFragment.kt

@@ -5,10 +5,13 @@ import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import androidx.fragment.app.Fragment
+import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.isActive
+import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.launch
 import ru.otus.coroutineshomework.databinding.FragmentTimerBinding
 import java.util.Locale
@@ -18,12 +21,11 @@ import kotlin.time.Duration.Companion.milliseconds
 
 class TimerFragment : Fragment() {
 
+    private val timerIncrement = 10.milliseconds
     private var _binding: FragmentTimerBinding? = null
     private val binding get() = _binding!!
 
-    private var time: Duration by Delegates.observable(Duration.ZERO) { _, _, newValue ->
-        binding.time.text = newValue.toDisplayString()
-    }
+    private var timeFlow = MutableStateFlow<Duration>(0.milliseconds)
 
     private var started by Delegates.observable(false) { _, _, newValue ->
         setButtonsState(newValue)
@@ -34,6 +36,7 @@ class TimerFragment : Fragment() {
         }
     }
 
+    private var job: Job? = null
     private fun setButtonsState(started: Boolean) {
         with(binding) {
             btnStart.isEnabled = !started
@@ -53,12 +56,21 @@ class TimerFragment : Fragment() {
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         super.onViewCreated(view, savedInstanceState)
         savedInstanceState?.let {
-            time = it.getLong(TIME).milliseconds
+            val initialTime = it.getLong(TIME).milliseconds
+            timeFlow = MutableStateFlow<Duration>(initialTime)
             started = it.getBoolean(STARTED)
         }
         setButtonsState(started)
+
         with(binding) {
-            time.text = this@TimerFragment.time.toDisplayString()
+            viewLifecycleOwner.lifecycleScope.launch(Dispatchers.Main) {
+                repeatOnLifecycle(Lifecycle.State.STARTED) {
+                    timeFlow.collect {
+                        time.text = it.toDisplayString()
+                    }
+                }
+            }
+
             btnStart.setOnClickListener {
                 started = true
             }
@@ -70,16 +82,31 @@ class TimerFragment : Fragment() {
 
     override fun onSaveInstanceState(outState: Bundle) {
         super.onSaveInstanceState(outState)
-        outState.putLong(TIME, time.inWholeMilliseconds)
+        outState.putLong(TIME, timeFlow.value.inWholeMilliseconds)
         outState.putBoolean(STARTED, started)
     }
 
     private fun startTimer() {
-        // TODO: Start timer
+        resetTimer()
+
+        job = viewLifecycleOwner.lifecycleScope.launch(Dispatchers.Main) {
+            while (started) {
+                timeFlow.emit(timeFlow.value + timerIncrement)
+                delay(timerIncrement)
+            }
+        }
     }
 
     private fun stopTimer() {
-        // TODO: Stop timer
+        job?.cancel()
+    }
+
+    private fun resetTimer() {
+        if (job != null) {
+            job?.cancel()
+        }
+
+        timeFlow.value = 0.milliseconds
     }
 
     override fun onDestroyView() {
@@ -91,12 +118,16 @@ class TimerFragment : Fragment() {
         private const val TIME = "time"
         private const val STARTED = "started"
 
-        private fun Duration.toDisplayString(): String = String.format(
-            Locale.getDefault(),
-            "%02d:%02d.%03d",
-            this.inWholeMinutes.toInt(),
-            this.inWholeSeconds.toInt(),
-            this.inWholeMilliseconds.toInt()
-        )
+        private fun Duration.toDisplayString(): String {
+            val minutes = this.inWholeMinutes.toInt()
+            val seconds = (this.inWholeSeconds % 60).toInt()
+            val millis = (this.inWholeMilliseconds % 1000).toInt()
+
+            return String.format(
+                Locale.getDefault(),
+                "%02d:%02d.%03d",
+                minutes, seconds, millis
+            )
+        }
     }
 }