时间戳

首页 > 解决方案 > 如何处理以前的请求并停止观察以前的 LiveData

android - 如何处理以前的请求并停止观察以前的 LiveData

问题描述

我正在尝试实现一个应用程序，其中我有一个 searchView，当用户搜索某些东西时，应用程序将调用一个返回可观察数据的改造请求。在 myRepository 中，我将 observable 转换为 flowable，在 myViewModel 中，我将 flowable 转换为我在 myActivity 中观察到的 LiveData。

但问题是，如果用户搜索不止一次并且非常快（在获得以前的结果之前），那么我想取消以前的请求并且也不想观察以前的数据。

所以我使用的代码如下：

主要活动

class MainActivity  : DaggerAppCompatActivity() {

 override fun onCreate(savedInstanceState: Bundle?) {
        observeRepos()
 }

 fun getReposFromServer(filter_search :String )    {
        mainViewModel.getReposFromServer(filter_search)    }

 private fun observeRepos() {
        mainViewModel.observeReposFromServer().observe(this, Observer { repos ->

            txtVwCount.setText("total item count is: "+repos?.total_count.toString())

        })

        mainViewModel.observeItemList().observe(this, Observer {

            if(!it.isNullOrEmpty())
                if(it.size>0) {
                    mAdapter.setReposInAdapter(it)
                    progressBar.visibility = View.GONE
                }
        })
    }


override fun onCreateOptionsMenu(menu: Menu?): Boolean {
        .....
        ......
         searchView.setOnQueryTextListener(object: SearchView.OnQueryTextListener{

          override fun onQueryTextSubmit(query: String?): Boolean {
                query?.let {
                            if(it.trim().length>0) {
                                clearOldCalls()
                                getReposFromServer(it,"","")      }
                            }
                        return false
            }

            override fun onQueryTextChange(newText: String?): Boolean {
                     return false;          }

        })
        return true
    }


fun clearOldCalls()   {
        mainViewModel.clearRetrofitCall()
        mAdapter.clearListInAdapter() //in my adapter I just make the list empty by assigning a new list to it
    }

}

主视图模型：

class MainViewModel @Inject constructor() : ViewModel() {
    var liveGitResult = MediatorLiveData<GitResult>()
    val liveItemList =  MediatorLiveData<MutableList<ItemList>>()

     @set:Inject
    lateinit var mainRepository: MainRepository

    fun getReposFromServer(filter_search: String)    {
          val resultFromApiCall_flowable : Flowable<GitResult> =  mainRepository.fetchToDosFromServer(filter_search)
         lateinit var source: LiveData<GitResult>

         resultFromApiCall_flowable.let { 
                 source = LiveDataReactiveStreams.fromPublisher(it)

                  liveGitResult.addSource(source) { todos ->
                       liveGitResult.setValue(todos)
                       liveGitResult.removeSource(source)   }

            }

         var itemList_observable = resultFromApiCall_flowable.map {//it = gitResult
                    gitResult ->
                        var lst = mutableListOf<ItemList>()
                        gitResult.items.forEach {
                                                    lst.add(it)   }

                     lst
            }

        itemList_observable?.let{
                        var liveItemList  = LiveDataReactiveStreams.fromPublisher(itemList_observable)

                        this.liveItemList.addSource(liveItemList){ itemList ->
                        this.liveItemList.setValue(itemList)
                        this.liveItemList.removeSource(liveItemList)    }
            }


     fun observeReposFromServer(): LiveData<GitResult> {
        return liveGitResult
    }

    fun observeItemList(): LiveData<MutableList<ItemList>> {

        return liveItemList
    }

    fun clearRetrofitCall()
    {
        liveGitResult.value =null
        liveItemList.value = null
        mainRepository.clearDisposables()
    }

}

主要存储库：

class MainRepository @Inject constructor(mainApi: MainApi) {

    private val mainApi: MainApi
    private val disposables: CompositeDisposable = CompositeDisposable()


    init {
        this.mainApi = mainApi
    }

    fun fetchToDosFromServer(filter_search: String) : Observable<GitResult> {
 lateinit var  returnedData : Observable<GitResult>

      //mainApi.getAllRepo(filter_search) is a retrofit call which returns a   Flowable<GitResult>
             returnedData =    mainApi.getAllRepo(filter_search).subscribeOn( Schedulers.io())
                                                             .onErrorReturn(Function {throwable ->
                                                                Log.e( LOG_TAG, "Something went wrong" )
                                                                 null
                                                             })


              returnedData.subscribeOn(Schedulers.io())
                          .observeOn( AndroidSchedulers.mainThread())
                          .subscribe(object :Observer<GitResult>{
                                                override fun onSubscribe(d: Disposable) {
                                                    disposables.add(d)  }

                                                override fun onComplete() { }

                                                override fun onNext(t: GitResult) { }

                                                override fun onError(e: Throwable) { }

                                            })

            return returnedData.toFlowable(BackpressureStrategy.BUFFER);

    }


     fun clearDisposables(){
        if(disposables!=null){
            if(!disposables.isDisposed)
                disposables.clear()
                disposables.dispose()
            }
    }

}

现在，如果我在获得上一个结果之前运行该应用程序并快速搜索多次 - 那么它的行为很奇怪..

那么，我在哪里做错了？

还有如何returnedData 在单个语句中编写代码，而不是在我正在做的 2 个语句中编写代码（一个用于调用 api，另一个用于覆盖订阅方法）。

标签： androidrx-java2android-livedata

解决方案

当用户创建另一个请求而前一个请求仍在进行中时，要取消以前的改造请求，您可以使用 kotlin 的协程来实现这一点。

您可以使用调用您的 api 请求的挂起函数启动协程，并保留在启动协程时返回的“作业”对象的引用，并且当您的用户在前一个请求正在进行时发送另一个搜索请求时，您可以简单地检查使用'job.isActive'，如果之前的改造请求正在进行中并且如果它处于活动状态，那么你可以调用'job.cancel（）'来停止观察之前的liveData并开始一个新的工作。

class MainViewModel @Inject constructor() : ViewModel() {
// Job instance
private var job = Job()

fun requestApiForResponse(val searchQuery:String){
 if(job?.isActive) // check if any previous job is running , if true then cancel that 
   job?.cancel()
 job = GlobalScope.launch(Dispatchers.IO){
   //call your retrofit Request here
 }
}

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

使用 liveData 和协程检查这个 github 的存储库搜索功能

推荐阅读