如何使用Rxjava做long 运行后台任务

Question

我正在使用 rxjava 将一些任务上传到服务器，每当任务启动片段或 activity 被销毁时，我将处理订阅以避免内存泄漏，但我想要的是即使在 fragment/activity destroyed 我需要在后台继续任务运行，有什么办法可以实现吗？

例子

doSomeLongRunningBgTaks()
     .subscribe()
     .addTo(compositeDisposal)

override onDestroy(){
  compositeDisposal.clear()
}

Is it mandatory to dispose the subscription all time ? if not when to use dispose ?

Answer 1

你可以这样使用：

webService.doSomething(someData)
      .observeOn(AndroidSchedulers.mainThread())
      .subscribe(
          result -> resultText.setText("It worked!"),
          e -> handleError(e));

Answer 2

首先，您必须了解AndroidOS现代版本的后台任务限制。关于它的全部内容 [a link] (https://developer.android.com/about/versions/oreo/background) 简而言之，如果您的应用不可见或您的应用没有运行ning 前台服务，则无法保证您的后台工作已完成。

其次，在你的情况下，你需要有一些实体，它不依赖于你的片段或 activity 的任何生命周期，并且能够运行后台工作。有几种可能的解决方案

1)Android服务方式

创建一个 Intent 服务。这是一个简单的服务，已经实现了具有内部队列的块。每当客户端尝试通过此类服务执行作业时，服务都会在后台队列中执行此类任务。因此，如果您执行两次，服务将在执行第二个任务之前完成第一个任务。

进口android.app.IntentService 导入 android.content.Intent

class MyIntentService : IntentService("My intent service") {

  // This method already in another thread (not UI thread)
  override fun onHandleIntent(intent: Intent?) {
    doLongRunningBackgroundJob()
  }
}

P.S。不要忘记在清单文件中注册此类服务。

2) Android 处理方式

您可以创建一个带有内部 android 处理程序的 class 和准备好的后台循环程序。例如：

import android.os.Handler
import android.os.HandlerThread

class MyBackgroundWorker {

  private val handler = initHandler()

  private fun initHandler(): Handler {
    val handlerThread = HandlerThread("My background thread")
    handlerThread.start()
    return Handler(handlerThread.looper)
  }

  fun executeJobInBackground(job: Runnable) {
    handler.post(job)
  }
}

3) 纯java方式

你可以创建一个纯线程的实例，但更推荐使用executors Java框架。对于线程方法：

class MyBackgroundWorker {

  fun executeJobInBackground(job: Runnable) {
    Thread(job).start()
  }
}

对于执行者方法：

import java.util.concurrent.Executors

class MyBackgroundWorker {

  private val executor = Executors.newSingleThreadExecutor()

  fun executeJobInBackground(job: Runnable) {
    executor.execute(job)
  }
}

P.S。不要忘记使用 DI 方法提供依赖项。

Answer 3

So Why you need Disposable ?

因此，如果您有如下所示的可观察对象：

Observable.just("Hello world!")
     .delay(1, TimeUnit.SECONDS)
     .subscribeWith(new DisposableObserver<String>() {
         @Override public void onStart() {
             System.out.println("Start!");
         }
         @Override public void onNext(String t) {
             System.out.println(t);
         }
         @Override public void onError(Throwable t) {
             t.printStackTrace();
         }
         @Override public void onComplete() {
             System.out.println("Done!");
         }
     });

现在，如果您想停止此任务，则只能通过 dispose() 处理它。

有时如果用户想要处理任何任务，例如：如果用户从屏幕导航或用户按下后退按钮，那么我们必须终止 Web 请求或取消任何任务，此时使用 Disposable。

What if you have to perform any task in background and not kill if fragment is destroyed ?

你可以简单地只写 subscribe() 方法而忘记了任务。

doSomeLongRunningBgTaks()
     .subscribe()

也许它会对你有所帮助。谢谢

如何使用Rxjava做long 运行后台任务

How to use Rxjava for long running background task

android

rx-java

rx-java2

rx-kotlin2