Kotlin-Flow如何在Android项目中使用_android kt flow基本使用(1)

于 2024-05-17 05:11:11 发布
阅读量960 收藏 13
点赞数 14
文章标签： 鸿蒙 面试 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84857523/article/details/138986969
版权

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！


img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上鸿蒙开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化的资料的朋友，可以戳这里获取

class TwoLongRunningTasksViewModel(
private val apiHelper: ApiHelper,
private val dbHelper: DatabaseHelper
) : ViewModel() {

private val status = MutableLiveData<Resource<String>>()

fun startLongRunningTask() {
    viewModelScope.launch {
        status.postValue(Resource.loading(null))
        doLongRunningTaskOne()
            .zip(doLongRunningTaskTwo()) { resultOne, resultTwo ->
                return@zip resultOne + resultTwo
            }
            .flowOn(Dispatchers.Default)
            .catch { e ->
                status.postValue(Resource.error(e.toString(), null))
            }
            .collect {
                status.postValue(Resource.success(it))
            }
    }
}

fun getStatus(): LiveData<Resource<String>> {
    return status
}

private fun doLongRunningTaskTwo(): Flow<String> {
    return flow {
        // your code for doing a long running task
        // Added delay to simulate
        delay(5000)
        emit("Two")
    }
}

private fun doLongRunningTaskOne(): Flow<String> {
    return flow {
        // your code for doing a long running task
        // Added delay to simulate
        delay(5000)
        emit("One")
    }
}

}


* **Catch 错误处理**：了解如何使用 Catch 处理 Kotlin Flow 中的错误。
* 活动代码

package com.mindorks.kotlinFlow.learn.errorhandling.catch

import android.os.Bundle
import android.view.View
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProviders
import androidx.recyclerview.widget.DividerItemDecoration
import androidx.recyclerview.widget.LinearLayoutManager
import com.mindorks.kotlinFlow.R
import com.mindorks.kotlinFlow.data.api.ApiHelperImpl
import com.mindorks.kotlinFlow.data.api.RetrofitBuilder
import com.mindorks.kotlinFlow.data.local.DatabaseBuilder
import com.mindorks.kotlinFlow.data.local.DatabaseHelperImpl
import com.mindorks.kotlinFlow.data.model.ApiUser
import com.mindorks.kotlinFlow.learn.base.ApiUserAdapter
import com.mindorks.kotlinFlow.utils.Status
import com.mindorks.kotlinFlow.utils.ViewModelFactory
import kotlinx.android.synthetic.main.activity_recycler_view.*

class CatchActivity : AppCompatActivity() {

private lateinit var viewModel: CatchViewModel
private lateinit var adapter: ApiUserAdapter

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_recycler_view)
    setupUI()
    setupViewModel()
    setupObserver()
}

private fun setupUI() {
    recyclerView.layoutManager = LinearLayoutManager(this)
    adapter =
        ApiUserAdapter(
            arrayListOf()
        )
    recyclerView.addItemDecoration(
        DividerItemDecoration(
            recyclerView.context,
            (recyclerView.layoutManager as LinearLayoutManager).orientation
        )
    )
    recyclerView.adapter = adapter
}

private fun setupObserver() {
    viewModel.getUsers().observe(this, Observer {
        when (it.status) {
            Status.SUCCESS -> {
                progressBar.visibility = View.GONE
                it.data?.let { users -> renderList(users) }
                recyclerView.visibility = View.VISIBLE
            }
            Status.LOADING -> {
                progressBar.visibility = View.VISIBLE
                recyclerView.visibility = View.GONE
            }
            Status.ERROR -> {
                //Handle Error
                progressBar.visibility = View.GONE
                Toast.makeText(this, it.message, Toast.LENGTH_SHORT).show()
            }
        }
    })
}

private fun renderList(users: List<ApiUser>) {
    adapter.addData(users)
    adapter.notifyDataSetChanged()
}

private fun setupViewModel() {
    viewModel = ViewModelProviders.of(
        this,
        ViewModelFactory(
            ApiHelperImpl(RetrofitBuilder.apiService),
            DatabaseHelperImpl(DatabaseBuilder.getInstance(applicationContext))
        )
    ).get(CatchViewModel::class.java)
}

}


* 视图模型代码

package com.mindorks.kotlinFlow.learn.errorhandling.catch

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.mindorks.kotlinFlow.data.api.ApiHelper
import com.mindorks.kotlinFlow.data.local.DatabaseHelper
import com.mindorks.kotlinFlow.data.model.ApiUser
import com.mindorks.kotlinFlow.utils.Resource
import kotlinx.coroutines.flow.catch
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.launch

class CatchViewModel(
private val apiHelper: ApiHelper,
private val dbHelper: DatabaseHelper
) : ViewModel() {

private val users = MutableLiveData<Resource<List<ApiUser>>>()

init {
    fetchUsers()
}

private fun fetchUsers() {
    viewModelScope.launch {
        users.postValue(Resource.loading(null))
        apiHelper.getUsersWithError()
            .catch { e ->
                users.postValue(Resource.error(e.toString(), null))
            }
            .collect {
                users.postValue(Resource.success(it))
            }
    }
}

fun getUsers(): LiveData<Resource<List<ApiUser>>> {
    return users
}

}


* **EmitAll 错误处理**：了解如何使用 emitAll 处理 Kotlin Flow 中的错误。
* 活动代码

package com.mindorks.kotlinFlow.learn.errorhandling.emitall

import android.os.Bundle
import android.view.View
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProviders
import androidx.recyclerview.widget.DividerItemDecoration
import androidx.recyclerview.widget.LinearLayoutManager
import com.mindorks.kotlinFlow.R
import com.mindorks.kotlinFlow.data.api.ApiHelperImpl
import com.mindorks.kotlinFlow.data.api.RetrofitBuilder
import com.mindorks.kotlinFlow.data.local.DatabaseBuilder
import com.mindorks.kotlinFlow.data.local.DatabaseHelperImpl
import com.mindorks.kotlinFlow.data.model.ApiUser
import com.mindorks.kotlinFlow.learn.base.ApiUserAdapter
import com.mindorks.kotlinFlow.utils.Status
import com.mindorks.kotlinFlow.utils.ViewModelFactory
import kotlinx.android.synthetic.main.activity_recycler_view.*

class EmitAllActivity : AppCompatActivity() {

private lateinit var viewModel: EmitAllViewModel
private lateinit var adapter: ApiUserAdapter

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_recycler_view)
    setupUI()
    setupViewModel()
    setupObserver()
}

private fun setupUI() {
    recyclerView.layoutManager = LinearLayoutManager(this)
    adapter =
        ApiUserAdapter(
            arrayListOf()
        )
    recyclerView.addItemDecoration(
        DividerItemDecoration(
            recyclerView.context,
            (recyclerView.layoutManager as LinearLayoutManager).orientation
        )
    )
    recyclerView.adapter = adapter
}

private fun setupObserver() {
    viewModel.getUsers().observe(this, Observer {
        when (it.status) {
            Status.SUCCESS -> {
                progressBar.visibility = View.GONE
                it.data?.let { users -> renderList(users) }
                recyclerView.visibility = View.VISIBLE
            }
            Status.LOADING -> {
                progressBar.visibility = View.VISIBLE
                recyclerView.visibility = View.GONE
            }
            Status.ERROR -> {
                //Handle Error
                progressBar.visibility = View.GONE
                Toast.makeText(this, it.message, Toast.LENGTH_SHORT).show()
            }
        }
    })
}

private fun renderList(users: List<ApiUser>) {
    adapter.addData(users)
    adapter.notifyDataSetChanged()
}

private fun setupViewModel() {
    viewModel = ViewModelProviders.of(
        this,
        ViewModelFactory(
            ApiHelperImpl(RetrofitBuilder.apiService),
            DatabaseHelperImpl(DatabaseBuilder.getInstance(applicationContext))
        )
    ).get(EmitAllViewModel::class.java)
}

}


* 视图模型代码

package com.mindorks.kotlinFlow.learn.errorhandling.emitall

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.mindorks.kotlinFlow.data.api.ApiHelper
import com.mindorks.kotlinFlow.data.local.DatabaseHelper
import com.mindorks.kotlinFlow.data.model.ApiUser
import com.mindorks.kotlinFlow.utils.Resource
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.launch

class EmitAllViewModel(
private val apiHelper: ApiHelper,
private val dbHelper: DatabaseHelper
) : ViewModel() {

private val users = MutableLiveData<Resource<List<ApiUser>>>()

init {
    fetchUsers()
}

private fun fetchUsers() {
    viewModelScope.launch {
        users.postValue(Resource.loading(null))
        apiHelper.getUsers()
            .zip(
                apiHelper.getUsersWithError()
                    .catch { emitAll(flowOf(emptyList())) }) { usersFromApi, moreUsersFromApi ->
                val allUsersFromApi = mutableListOf<ApiUser>()
                allUsersFromApi.addAll(usersFromApi)
                allUsersFromApi.addAll(moreUsersFromApi)
                return@zip allUsersFromApi
            }
            .flowOn(Dispatchers.Default)
            .catch { e ->
                users.postValue(Resource.error(e.toString(), null))
            }
            .collect {
                users.postValue(Resource.success(it))
            }
    }
}

fun getUsers(): LiveData<Resource<List<ApiUser>>> {
    return users
}

}


* **完成：**
* 活动代码

package com.mindorks.kotlinFlow.learn.completion

import android.os.Bundle
import android.view.View
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProviders
import com.mindorks.kotlinFlow.R
import com.mindorks.kotlinFlow.data.api.ApiHelperImpl
import com.mindorks.kotlinFlow.data.api.RetrofitBuilder
import com.mindorks.kotlinFlow.data.local.DatabaseBuilder
import com.mindorks.kotlinFlow.data.local.DatabaseHelperImpl
import com.mindorks.kotlinFlow.learn.base.ApiUserAdapter
import com.mindorks.kotlinFlow.utils.Status
import com.mindorks.kotlinFlow.utils.ViewModelFactory
import kotlinx.android.synthetic.main.activity_long_running_task.*
import kotlinx.android.synthetic.main.activity_recycler_view.progressBar

class CompletionActivity : AppCompatActivity() {

private lateinit var viewModel: CompletionViewModel
private lateinit var adapter: ApiUserAdapter

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_completion)
    setupViewModel()
    setupObserver()
}

private fun setupObserver() {
    viewModel.getStatus().observe(this, Observer {
        when (it.status) {
            Status.SUCCESS -> {
                progressBar.visibility = View.GONE
                textView.text = it.data
                textView.visibility = View.VISIBLE
            }
            Status.LOADING -> {
                progressBar.visibility = View.VISIBLE
                textView.visibility = View.GONE
            }
            Status.ERROR -> {
                //Handle Error
                progressBar.visibility = View.GONE
                Toast.makeText(this, it.message, Toast.LENGTH_SHORT).show()
            }
        }
    })
}

private fun setupViewModel() {
    viewModel = ViewModelProviders.of(
        this,
        ViewModelFactory(
            ApiHelperImpl(RetrofitBuilder.apiService),
            DatabaseHelperImpl(DatabaseBuilder.getInstance(applicationContext))
        )
    ).get(CompletionViewModel::class.java)
}

}


* 视图模型代码

package com.mindorks.kotlinFlow.learn.completion

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.mindorks.kotlinFlow.data.api.ApiHelper
import com.mindorks.kotlinFlow.data.local.DatabaseHelper
import com.mindorks.kotlinFlow.utils.Resource
import kotlinx.coroutines.flow.catch
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.onCompletion
import kotlinx.coroutines.launch

class CompletionViewModel(
private val apiHelper: ApiHelper,
private val dbHelper: DatabaseHelper
) : ViewModel() {

private val status = MutableLiveData<Resource<String>>()

init{
    fetchUsers()
}
private fun fetchUsers() {
    viewModelScope.launch {
        status.postValue(Resource.loading(null))
        apiHelper.getUsers()
            .catch { e ->
                status.postValue(Resource.error(e.toString(), null))
            }
            .onCompletion {
                status.postValue(Resource.success("Task Completed"))
            }
            .collect {
            }
    }
}

fun getStatus(): LiveData<Resource<String>> {
    return status
}

}


* **减少：**
* 活动代码

package com.mindorks.kotlinFlow.learn.reduce

import android.os.Bundle
import android.view.View
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProviders
import com.mindorks.kotlinFlow.R
import com.mindorks.kotlinFlow.data.api.ApiHelperImpl
import com.mindorks.kotlinFlow.data.api.RetrofitBuilder
import com.mindorks.kotlinFlow.data.local.DatabaseBuilder
import com.mindorks.kotlinFlow.data.local.DatabaseHelperImpl
import com.mindorks.kotlinFlow.utils.Status
import com.mindorks.kotlinFlow.utils.ViewModelFactory
import kotlinx.android.synthetic.main.activity_long_running_task.*

class ReduceActivity : AppCompatActivity() {

private lateinit var viewModel: ReduceViewModel

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_long_running_task)
    setupViewModel()
    setupLongRunningTask()
}

private fun setupLongRunningTask() {
    viewModel.getStatus().observe(this, Observer {
        when (it.status) {
            Status.SUCCESS -> {
                progressBar.visibility = View.GONE
                textView.text = it.data
                textView.visibility = View.VISIBLE
            }
            Status.LOADING -> {
                progressBar.visibility = View.VISIBLE
                textView.visibility = View.GONE
            }
            Status.ERROR -> {
                //Handle Error
                progressBar.visibility = View.GONE
                Toast.makeText(this, it.message, Toast.LENGTH_SHORT).show()
            }
        }
    })
    viewModel.startReduceTask()
}

private fun setupViewModel() {
    viewModel = ViewModelProviders.of(
        this,
        ViewModelFactory(
            ApiHelperImpl(RetrofitBuilder.apiService),
            DatabaseHelperImpl(DatabaseBuilder.getInstance(applicationContext))
        )
    ).get(ReduceViewModel::class.java)
}

}


* 视图模型代码

package com.mindorks.kotlinFlow.learn.reduce

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.mindorks.kotlinFlow.data.api.ApiHelper
import com.mindorks.kotlinFlow.data.local.DatabaseHelper
import com.mindorks.kotlinFlow.utils.Resource
import kotlinx.coroutines.flow.asFlow
import kotlinx.coroutines.flow.reduce
import kotlinx.coroutines.launch

class ReduceViewModel(
val apiHelper: ApiHelper,
dbHelper: DatabaseHelper
) : ViewModel() {

private val status = MutableLiveData<Resource<String>>()

fun startReduceTask() {
    viewModelScope.launch {
        status.postValue(Resource.loading(null))
        val result = (1..5).asFlow()
            .reduce { a, b -> a + b }

        status.postValue(Resource.success(result.toString()))
    }
}

fun getStatus(): LiveData<Resource<String>> {
    return status
}

}


* **地图：**
* 活动代码

package com.mindorks.kotlinFlow.learn.map

import android.os.Bundle
import android.view.View
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProviders
import androidx.recyclerview.widget.DividerItemDecoration
import androidx.recyclerview.widget.LinearLayoutManager
import com.mindorks.kotlinFlow.R
import com.mindorks.kotlinFlow.data.api.ApiHelperImpl
import com.mindorks.kotlinFlow.data.api.RetrofitBuilder
import com.mindorks.kotlinFlow.data.local.DatabaseBuilder
import com.mindorks.kotlinFlow.data.local.DatabaseHelperImpl
import com.mindorks.kotlinFlow.data.local.entity.User
import com.mindorks.kotlinFlow.learn.base.UserAdapter
import com.mindorks.kotlinFlow.utils.Status
import com.mindorks.kotlinFlow.utils.ViewModelFactory
import kotlinx.android.synthetic.main.activity_recycler_view.*

class MapActivity : AppCompatActivity() {

private lateinit var viewModel: MapViewModel
private lateinit var adapter: UserAdapter

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_recycler_view)
    setupUI()
    setupViewModel()
    setupObserver()
}

private fun setupUI() {
    recyclerView.layoutManager = LinearLayoutManager(this)
    adapter =
        UserAdapter(
            arrayListOf()
        )
    recyclerView.addItemDecoration(
        DividerItemDecoration(
            recyclerView.context,
            (recyclerView.layoutManager as LinearLayoutManager).orientation
        )
    )
    recyclerView.adapter = adapter
}

private fun setupObserver() {
    viewModel.getUsers().observe(this, Observer {
        when (it.status) {
            Status.SUCCESS -> {
                progressBar.visibility = View.GONE
                it.data?.let { users -> renderList(users) }
                recyclerView.visibility = View.VISIBLE
            }
            Status.LOADING -> {
                progressBar.visibility = View.VISIBLE
                recyclerView.visibility = View.GONE
            }
            Status.ERROR -> {
                //Handle Error
                progressBar.visibility = View.GONE
                Toast.makeText(this, it.message, Toast.LENGTH_SHORT).show()
            }
        }
    })
}

private fun renderList(users: List<User>) {
    adapter.addData(users)
    adapter.notifyDataSetChanged()
}

private fun setupViewModel() {
    viewModel = ViewModelProviders.of(
        this,
        ViewModelFactory(
            ApiHelperImpl(RetrofitBuilder.apiService),
            DatabaseHelperImpl(DatabaseBuilder.getInstance(applicationContext))
        )
    ).get(MapViewModel::class.java)
}

}


* 视图模型代码

package com.mindorks.kotlinFlow.learn.map

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.mindorks.kotlinFlow.data.api.ApiHelper
import com.mindorks.kotlinFlow.data.local.DatabaseHelper
import com.mindorks.kotlinFlow.data.local.entity.User
import com.mindorks.kotlinFlow.utils.Resource
import kotlinx.coroutines.flow.catch
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.launch

class MapViewModel(
val apiHelper: ApiHelper,
dbHelper: DatabaseHelper
) : ViewModel() {

private val users = MutableLiveData<Resource<List<User>>>()

init {
    fetchUsers()
}

private fun fetchUsers() {
    viewModelScope.launch {
        users.postValue(Resource.loading(null))
        apiHelper.getUsers()
            .map { apiUserList ->
                val userList = mutableListOf<User>()
                for (apiUser in apiUserList) {
                    val user = User(
                        apiUser.id,
                        apiUser.name,
                        apiUser.email,
                        apiUser.avatar
                    )
                    userList.add(user)
                }
                userList
            }
            .catch { e ->
                users.postValue(Resource.error(e.toString(), null))
            }
            .collect {
                users.postValue(Resource.success(it))
            }
    }
}

fun getUsers(): LiveData<Resource<List<User>>> {
    return users
}

}


* **筛选：**
* 活动代码

package com.mindorks.kotlinFlow.learn.filter

import android.os.Bundle
import android.view.View
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProviders
import com.mindorks.kotlinFlow.R
import com.mindorks.kotlinFlow.data.api.ApiHelperImpl
import com.mindorks.kotlinFlow.data.api.RetrofitBuilder
import com.mindorks.kotlinFlow.data.local.DatabaseBuilder
import com.mindorks.kotlinFlow.data.local.DatabaseHelperImpl
import com.mindorks.kotlinFlow.utils.Status
import com.mindorks.kotlinFlow.utils.ViewModelFactory
import kotlinx.android.synthetic.main.activity_long_running_task.*
import kotlinx.android.synthetic.main.activity_recycler_view.progressBar

class FilterActivity : AppCompatActivity() {

private lateinit var viewModel: FilterViewModel

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_long_running_task)
    setupViewModel()
    setupLongRunningTask()
}

private fun setupLongRunningTask() {
    viewModel.getStatus().observe(this, Observer {
        when (it.status) {
            Status.SUCCESS -> {
                progressBar.visibility = View.GONE
                textView.text = it.data
                textView.visibility = View.VISIBLE
            }
            Status.LOADING -> {
                progressBar.visibility = View.VISIBLE
                textView.visibility = View.GONE
            }
            Status.ERROR -> {
                //Handle Error
                progressBar.visibility = View.GONE
                Toast.makeText(this, it.message, Toast.LENGTH_SHORT).show()
            }
        }
    })
    viewModel.startFilterTask()
}

private fun setupViewModel() {
    viewModel = ViewModelProviders.of(
        this,
        ViewModelFactory(
            ApiHelperImpl(RetrofitBuilder.apiService),
            DatabaseHelperImpl(DatabaseBuilder.getInstance(applicationContext))
        )
    ).get(FilterViewModel::class.java)
}

}


* 视图模型代码

package com.mindorks.kotlinFlow.learn.filter

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.mindorks.kotlinFlow.data.api.ApiHelper
import com.mindorks.kotlinFlow.data.local.DatabaseHelper
import com.mindorks.kotlinFlow.utils.Resource
import kotlinx.coroutines.flow.asFlow
import kotlinx.coroutines.flow.filter
import kotlinx.coroutines.flow.toList
import kotlinx.coroutines.launch

class FilterViewModel(
apiHelper: ApiHelper,
dbHelper: DatabaseHelper
) : ViewModel() {
private val status = MutableLiveData<Resource>()

fun startFilterTask() {
    viewModelScope.launch {
        status.postValue(Resource.loading(null))
        val result = mutableListOf<Int>()
        (1..5).asFlow()
            .filter {
                it % 2 == 0
            }
            .toList(result)

        status.postValue(Resource.success(result.toString()))
    }
}

fun getStatus(): LiveData<Resource<String>> {
    return status
}

}


* **搜索功能**：使用 Kotlin Flow Operators 实现搜索 - Debounce、Filter、DistinctUntilChanged、FlatMapLatest。


	+ 活动代码

package com.mindorks.kotlinFlow.learn.search

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import com.mindorks.kotlinFlow.R
import com.mindorks.kotlinFlow.utils.getQueryTextChangeStateFlow
import kotlinx.android.synthetic.main.activity_search.*
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import kotlin.coroutines.CoroutineContext

class SearchActivity : AppCompatActivity(), CoroutineScope {

override val coroutineContext: CoroutineContext
    get() = Dispatchers.Main + job

private lateinit var job: Job

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_search)
    job = Job()
    setUpSearchStateFlow()
}

override fun onDestroy() {
    job.cancel()
    super.onDestroy()
}

private fun setUpSearchStateFlow() {
    launch {
        searchView.getQueryTextChangeStateFlow()
            .debounce(300)
            .filter { query ->
                if (query.isEmpty()) {
                    textViewResult.text = ""
                    return@filter false
                } else {
                    return@filter true
                }
            }
            .distinctUntilChanged()
            .flatMapLatest { query ->
                dataFromNetwork(query)
                    .catch {
                        emitAll(flowOf(""))
                    }
            }
            .flowOn(Dispatchers.Default)
            .collect { result ->
                textViewResult.text = result
            }
    }
}

/**
 * Simulation of network data
 */
private fun dataFromNetwork(query: String): Flow<String> {
    return flow {
        delay(2000)
        emit(query)
    }
}

}


* **重试：**
* 活动代码

package com.mindorks.kotlinFlow.learn.retry

import android.os.Bundle
import android.view.View
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProviders
import com.mindorks.kotlinFlow.R
import com.mindorks.kotlinFlow.data.api.ApiHelperImpl
import com.mindorks.kotlinFlow.data.api.RetrofitBuilder
import com.mindorks.kotlinFlow.data.local.DatabaseBuilder
import com.mindorks.kotlinFlow.data.local.DatabaseHelperImpl
import com.mindorks.kotlinFlow.utils.Status
import com.mindorks.kotlinFlow.utils.ViewModelFactory
import kotlinx.android.synthetic.main.activity_retry.*

class RetryActivity : AppCompatActivity() {

private lateinit var viewModel: RetryViewModel

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_retry)
    setupViewModel()
    setupLongRunningTask()
}

private fun setupLongRunningTask() {
    viewModel.getStatus().observe(this, Observer {
        when (it.status) {
            Status.SUCCESS -> {
                progressBar.visibility = View.GONE
                textView.text = it.data
                textView.visibility = View.VISIBLE
            }
            Status.LOADING -> {
                progressBar.visibility = View.VISIBLE
                textView.visibility = View.GONE
            }
            Status.ERROR -> {
                //Handle Error
                progressBar.visibility = View.GONE
                Toast.makeText(this, it.message, Toast.LENGTH_SHORT).show()
            }
        }
    })
    viewModel.startTask()
}

private fun setupViewModel() {
    viewModel = ViewModelProviders.of(
        this,
        ViewModelFactory(
            ApiHelperImpl(RetrofitBuilder.apiService),
            DatabaseHelperImpl(DatabaseBuilder.getInstance(applicationContext))
        )
    ).get(RetryViewModel::class.java)
}

}


* 视图模型代码

package com.mindorks.kotlinFlow.learn.retry

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.mindorks.kotlinFlow.data.api.ApiHelper
import com.mindorks.kotlinFlow.data.local.DatabaseHelper
import com.mindorks.kotlinFlow.utils.Resource
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.launch
import java.io.IOException

class RetryViewModel(
val apiHelper: ApiHelper,
dbHelper: DatabaseHelper
) : ViewModel() {

private val status = MutableLiveData<Resource<String>>()

fun startTask() {
    viewModelScope.launch {
        status.postValue(Resource.loading(null))
        // do a long running task
        doLongRunningTask()
            .flowOn(Dispatchers.Default)
            .retry(retries = 3) { cause ->
                if (cause is IOException) {
                    delay(2000)
                    return@retry true
                } else {
                    return@retry false
                }
            }
            .catch {
                status.postValue(Resource.error("Something Went Wrong", null))
            }
            .collect {
                status.postValue(Resource.success("Task Completed"))
            }
    }
}

fun getStatus(): LiveData<Resource<String>> {
    return status
}

private fun doLongRunningTask(): Flow<Int> {
    return flow {
        // your code for doing a long running task
        // Added delay, random number, and exception to simulate

        delay(2000)

        val randomNumber = (0..2).random()

        if (randomNumber == 0) {
            throw IOException()
        } else if (randomNumber == 1) {
            throw IndexOutOfBoundsException()
        }

        delay(2000)
        emit(0)
    }
}

}


* **重试时间：**
* 活动代码

package com.mindorks.kotlinFlow.learn.retrywhen

import android.os.Bundle
import android.view.View
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProviders
import com.mindorks.kotlinFlow.R
import com.mindorks.kotlinFlow.data.api.ApiHelperImpl
import com.mindorks.kotlinFlow.data.api.RetrofitBuilder
import com.mindorks.kotlinFlow.data.local.DatabaseBuilder
import com.mindorks.kotlinFlow.data.local.DatabaseHelperImpl
import com.mindorks.kotlinFlow.utils.Status
import com.mindorks.kotlinFlow.utils.ViewModelFactory
import kotlinx.android.synthetic.main.activity_retry.*

class RetryWhenActivity : AppCompatActivity() {

private lateinit var viewModel: RetryWhenViewModel

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_retry)
    setupViewModel()
    setupLongRunningTask()
}

private fun setupLongRunningTask() {
    viewModel.getStatus().observe(this, Observer {
        when (it.status) {
            Status.SUCCESS -> {
                progressBar.visibility = View.GONE
                textView.text = it.data
                textView.visibility = View.VISIBLE
            }
            Status.LOADING -> {
                progressBar.visibility = View.VISIBLE
                textView.visibility = View.GONE
            }
            Status.ERROR -> {
                //Handle Error
                progressBar.visibility = View.GONE
                Toast.makeText(this, it.message, Toast.LENGTH_SHORT).show()
            }
        }
    })
    viewModel.startTask()
}

private fun setupViewModel() {
    viewModel = ViewModelProviders.of(
        this,
        ViewModelFactory(
            ApiHelperImpl(RetrofitBuilder.apiService),
            DatabaseHelperImpl(DatabaseBuilder.getInstance(applicationContext))
        )
    ).get(RetryWhenViewModel::class.java)
}

}


* 视图模型代码

package com.mindorks.kotlinFlow.learn.retrywhen

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.mindorks.kotlinFlow.data.api.ApiHelper
import com.mindorks.kotlinFlow.data.local.DatabaseHelper
import com.mindorks.kotlinFlow.utils.Resource
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.launch
import java.io.IOException

class RetryWhenViewModel(
val apiHelper: ApiHelper,
dbHelper: DatabaseHelper
) : ViewModel() {

private val status = MutableLiveData<Resource<String>>()

fun startTask() {
    viewModelScope.launch {
        status.postValue(Resource.loading(null))
        // do a long running task
        doLongRunningTask()
            .flowOn(Dispatchers.Default)
            .retryWhen { cause, attempt ->
                if (cause is IOException && attempt < 3) {
                    delay(2000)
                    return@retryWhen true
                } else {
                    return@retryWhen false
                }
            }
            .catch {
                status.postValue(Resource.error("Something Went Wrong", null))
            }
            .collect {
                status.postValue(Resource.success("Task Completed"))
            }
    }
}

fun getStatus(): LiveData<Resource<String>> {
    return status
}

private fun doLongRunningTask(): Flow<Int> {
    return flow {
        // your code for doing a long running task
        // Added delay, random number, and exception to simulate

        delay(2000)

        val randomNumber = (0..2).random()

        if (randomNumber == 0) {
            throw IOException()
        } else if (randomNumber == 1) {
            throw IndexOutOfBoundsException()
        }

        delay(2000)
        emit(0)
    }
}

}


* **使用指数退避重试：**
* 活动代码

package com.mindorks.kotlinFlow.learn.retryexponentialbackoff

import android.os.Bundle
import android.view.View
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProviders
import com.mindorks.kotlinFlow.R
import com.mindorks.kotlinFlow.data.api.ApiHelperImpl
import com.mindorks.kotlinFlow.data.api.RetrofitBuilder
import com.mindorks.kotlinFlow.data.local.DatabaseBuilder
import com.mindorks.kotlinFlow.data.local.DatabaseHelperImpl
import com.mindorks.kotlinFlow.utils.Status
import com.mindorks.kotlinFlow.utils.ViewModelFactory
import kotlinx.android.synthetic.main.activity_retry.*

class RetryExponentialBackoffActivity : AppCompatActivity() {

private lateinit var viewModel: RetryExponentialBackoffModel

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_retry)
    setupViewModel()
    setupLongRunningTask()
}

private fun setupLongRunningTask() {
    viewModel.getStatus().observe(this, Observer {
        when (it.status) {
            Status.SUCCESS -> {
                progressBar.visibility = View.GONE
                textView.text = it.data
                textView.visibility = View.VISIBLE
            }
            Status.LOADING -> {
                progressBar.visibility = View.VISIBLE
                textView.visibility = View.GONE
            }
            Status.ERROR -> {
                //Handle Error
                progressBar.visibility = View.GONE
                Toast.makeText(this, it.message, Toast.LENGTH_SHORT).show()
            }
        }
    })
    viewModel.startTask()
}

private fun setupViewModel() {
    viewModel = ViewModelProviders.of(
        this,
        ViewModelFactory(
            ApiHelperImpl(RetrofitBuilder.apiService),
            DatabaseHelperImpl(DatabaseBuilder.getInstance(applicationContext))
        )
    ).get(RetryExponentialBackoffModel::class.java)
}

}


* 视图模型代码

package com.mindorks.kotlinFlow.learn.retryexponentialbackoff

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.mindorks.kotlinFlow.data.api.ApiHelper
import com.mindorks.kotlinFlow.data.local.DatabaseHelper
import com.mindorks.kotlinFlow.utils.Resource
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.launch
import java.io.IOException

class RetryExponentialBackoffModel(
val apiHelper: ApiHelper,
dbHelper: DatabaseHelper
) : ViewModel() {

private val status = MutableLiveData<Resource<String>>()

fun startTask() {
    viewModelScope.launch {
        status.postValue(Resource.loading(null))
        // do a long running task
        var currentDelay = 1000L
        val delayFactor = 2
        doLongRunningTask()
            .flowOn(Dispatchers.Default)
            .retry(retries = 3) { cause ->
                if (cause is IOException) {
                    delay(currentDelay)
                    currentDelay = (currentDelay * delayFactor)
                    return@retry true
                } else {
                    return@retry false
                }
            }
            .catch {
                status.postValue(Resource.error("Something Went Wrong", null))
            }
            .collect {
                status.postValue(Resource.success("Task Completed"))
            }
    }
}

fun getStatus(): LiveData<Resource<String>> {
    return status
}

private fun doLongRunningTask(): Flow<Int> {
    return flow {
        // your code for doing a long running task
        // Added delay, random number, and exception to simulate

        delay(2000)

        val randomNumber = (0..2).random()

        if (randomNumber == 0) {
            throw IOException()
        } else if (randomNumber == 1) {
            throw IndexOutOfBoundsException()
        }

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

delay(currentDelay)
currentDelay = (currentDelay * delayFactor)
return@retry true
} else {
return@retry false
}
}
.catch {
status.postValue(Resource.error(“Something Went Wrong”, null))
}
.collect {
status.postValue(Resource.success(“Task Completed”))
}
}
}

fun getStatus(): LiveData<Resource<String>> {
    return status
}

private fun doLongRunningTask(): Flow<Int> {
    return flow {
        // your code for doing a long running task
        // Added delay, random number, and exception to simulate

        delay(2000)

        val randomNumber = (0..2).random()

        if (randomNumber == 0) {
            throw IOException()
        } else if (randomNumber == 1) {
            throw IndexOutOfBoundsException()
        }

[外链图片转存中…(img-9zPP9m9g-1715893850994)]
[外链图片转存中…(img-uR9HvFwo-1715893850994)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_84857523
关注
  • 14
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ROS官方教程[翻译]---message_filter的使用
qq_41861406的博客
05-23 3271
转载：https://blog.csdn.net/chishuideyu/article/details/77479758 1 综述 message_filters是一个用于roscpp和rospy的实用程序库。 它集合了许多的常用的消息“过滤”算法。 消息过滤器message_filters类似一个消息缓存，当消息到达消息过滤器的时候，可能并不会立即输出，而是在稍后的时间点里满足一定条件下输出。 举个例子，比如时间同步器，它接收来自多个源的不同类型的消息，并且仅当它们在具有相同时间戳的每个源上接收到消息时
mysql省市区邮政编码和区号级联sql文件
wyyl1的专栏
05-12 3万+
文章主要内容来源于csdn的lookbbs的资源，是他提供的sql语句，我只是删除了原语句中的“ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=3145“因为这句有可能导致部分生成时编码错误。  DROP TABLE IF EXISTS `areas`;CREATE TABLE `areas` (  `id` int(11) NO
MobaXterm详细使用教程
热门推荐
xuanying_china的专栏
09-03 26万+
这一篇MobaXterm详细使用教程，我们来介绍一下如何设置并用MobaXterm来连接Linux服务器。 MobaXterm 又名 MobaXVT，是一款增强型终端、X 服务器和 Unix 命令集(GNU/ Cygwin)工具箱。 MobaXterm 可以开启多个终端视窗，以最新的 X 服务器为基础的X.Org，可以轻松地来试用 Unix/Linux 上的 GNU Unix 命令。这样一来，我们可以不用安装虚拟机来试用虚拟环境，然后只要通过 MobaXterm 就可以使用大多数的 linux 命令。.
ros多传感器时间同步(message_filters)
hongge_smile的博客
05-25 5699
message_filters是一个用于roscpp和rospy的实用程序库。 它集合了许多的常用的消息“过滤”算法。消息过滤器message_filters类似一个消息缓存，当消息到达消息过滤器的时候，可能并不会立即输出，而是在稍后的时间点里满足一定条件下输出。 举个例子，比如时间同步器，它接收来自多个源的不同类型的消息，并且仅当它们在具有相同时间戳的每个源上接收到消息时才输出它们，也就是起到了一个消息同步输出的效果。 下面同步雷达和图像的数据.代码如下: // msg_filter.cpp #incl
kotlin-flow-android-demo：使用Kotlin Flow演示Android应用
02-17
本项目"**kotlin-flow-android-demo**"是一个实践示例，展示了如何在Android应用中有效地使用Kotlin Flow。 Kotlin Flow的核心概念是它是一个生成器，可以在需要时生成值，而不是一次性全部生成。这种设计模式使得...
stateflow-demo:样例android应用程序演示了Kotlin Coroutines StateFlow的使用
04-25
StateFlow-演示什么是StateFlow ？ 这是一个向其收集器发出更新的流。 可以通过从流中收集值来观察值。执行ViewModel.kt ： class MainViewModel : ViewModel () { privateval _countState = MutableStateFlow ( 0 )...
uniflow-kt：Uniflow:unicorn:-适用于Android和Kotlin的简单Unidirectionnel数据流，使用Kotlin协程并向函数式编程开放
02-03
**正文** `uniflow-kt` 是一个专门为Android平台和Kotlin语言设计的轻量级框架，它引入了单向数据流的概念，以简化应用的状态管理。...在实际项目中使用`uniflow-kt`，可以极大地提升开发效率和代码质量。
init:Kotlin + Flow实现的Android应用初始化任务启动库
03-11
Kotlin + Flow实现的Android应用初始化任务启动库。 支持奖学金，按模块加载任务 可指定工作进程名称，main表示仅在主进程运行，all表示在所有进程运行，替换值all 可指定任务仅在工作线程执行 可指定任务仅在调试...
Android-flow-playground:squareflow 的游乐场
07-13
在"Android-flow-playground-master"这个压缩包中，你将找到项目源码，包括`.kt`文件，这些文件包含了用Kotlin编写的`squareflow`示例代码。通过阅读和运行这些代码，你可以学习到如何在实际项目中应用`squareflow`...
res2net50_v1b_26w_4s.pdparams
05-02
res2net50_v1b_26w_4s
vegan
03-30
纯素
Anaconda3最新版2022版的下载安装配置及使用教程(建议收藏，持续更新..)
神兽汤姆猫的博客
10-19 1万+
Anaconda，中文大蟒蛇是一个开源的发行版本，其包含了、Python等180多个科学包及其依赖项。Anaconda集成了我们几乎常用的包，用于快速安装，运行和升级及其依赖项在计算机便捷的创建，和保存，加载切换环境。同时conda也是一个环境管理器。
paddleocr部署训练全流程
weixin_47978722的博客
04-04 7395
paddleocr部署训练全流程 1.GPU及环境配置 GPU：GTX1050TI 环境：win11+anaconda paddleocr版本：PaddleOCR-release-2.4 2.paddle安装 2.1快速开始安装方法（为后续使用标注工具做准备） 能够快速的使用paddleocr 创建conda虚拟环境 conda create -n paddle_quickstart python=3.8 接下来按照下述参考链接安装paddleocr 参考：https://gitee.com/paddle
Ros message_filters （消息滤波器）介绍与使用-待完善
Joweay的博客
09-28 2420
本文对ros message_filters 滤波器基本介绍，包括message_filters包的功能，通用使用方法，以及Subscriber 滤波的使用方法。 1.Ros message_filters 总览： message filters 即包含一系列算法，这些算法对输入数据满足一定条件才进行输出。如：时间同步器，从不同传感器获取数据，但只输出同一时间戳的所有传感器数据。 2.Filter Pattern(滤波方法) 在message filters 中所有的...
鸿蒙HarmonyOS教程-开发准备和HelloWorld【入门篇】_devecostudio stage fa
最新发布
2401_84185397的博客
04-16 1181
点击DevEco Studio右上角的No Devices > Device Manager，或者点击菜单Tools > Device Manager。等）以及一份在Github上持续爆火霸榜的《纯血版华为鸿蒙 (Harmony OS)开发手册》（共计890页），希望对大家有所帮助。最后，为了能让大家更好的去学习提升鸿蒙 (Harmony OS) 开发技术，小编连夜整理了一份30个G。一路Next，等待模拟器文件(1G左右)下载完成后，模拟器既完成创建。，这里不再赘述，使用默认选项，一路Next即可。
HarmonyOS开发（DevEco Studio）
qq_62156548的博客
06-14 3368
HarmonyOS开发 简单操作的前端开发
opensuse 安装docker
u010279658的博客
06-12 453
直接用zypper in docker 参考：http://www.dockerinfo.net/docker%E5%AE%89%E8%A3%85-opensuse
ROS学习笔记之——message filters的应用
gwpscut的博客
10-06 2294
message_filters用于对齐多种传感信息的时间戳，对齐时间戳有两种方式，一种是时间戳完全对齐 ：ExactTime Policy，另一种是时间戳相近：ApproximateTime Policy ｍessage_filters作用是： 同时订阅并发布话题 时间同步 接下来看看esvo里面的时间同步处理 先看看esvo_mapping.h文件 message_filters::Subscriber<sensor_msgs::Image> TS_left_sub_, TS_r.
kotlin，在android studio中怎么添加kotlin-android-extensions插件
05-13
要在 Android Studio 中添加 `kotlin-android-extensions` 插件，请按照以下步骤： 1. 在你的项目的 `build.gradle` 文件中，添加以下依赖： ```groovy dependencies { // ... implementation "org.jetbrains.kotlin:kotlin-android-extensions:$kotlin_version" } ``` 其中 `$kotlin_version` 是你使用的 Kotlin 版本号。 2. 在你的模块的 `build.gradle` 文件中，应用 `kotlin-android-extensions` 插件： ```groovy apply plugin: 'kotlin-android-extensions' ``` 3. 重新构建你的项目。 现在，你可以在布局文件中使用 `findViewById()` 方法来获取 View 对象，而不需要手动声明和初始化变量。 注意：尽管 `kotlin-android-extensions` 插件非常方便，但它并不推荐在大型项目中使用，因为它容易导致命名冲突和代码混乱。对于大型项目，建议使用 `findViewById()` 或者 Data Binding 等更加健壮的方案。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值