How to replace AsyncTask and AsyncTaskLoader with their Rx equivalents?

Question

Background

Some articles claim that Rx can replace AsyncTask and AsyncTaskLoader. Seeing that Rx usually makes code shorter, I tried to dive into various samples and ideas of how it works.

The problem

All of the samples and articles I've found, including Github repos, don't seem to really replace AsyncTask and AsyncTaskLoader well:

1. Can't find how to cancel a task or multiple ones (including interrupting a thread). This is especially important for AsyncTask, which is usually used for RecyclerView and ListView. This can also be done on AsyncTaskLoader, but requires a bit more work than just call "cancel". For AsyncTask, it also provides publishing of a progress, and that's another thing I can't find an example of in Rx.

2. Can't find how to avoid unsubscribing manually while avoiding memory leaks, which quite ruins the whole point of using Rx, as it's supposed to be shorter. In some samples, there are even more callbacks than normal code has.

What I've tried

Here are some links I've read about Rx:

• https://stablekernel.com/replace-asynctask-and-asynctaskloader-with-rx-observable-rxjava-android-patterns/ - this actually provides a cool way to handle AsyncTaskLoader, as it caches the result. However, the samples don't work at all (including building them), as they are very old.

• https://code.tutsplus.com/tutorials/getting-started-with-rxjava-20-for-android--cms-28345 , https://code.tutsplus.com/tutorials/reactive-programming-operators-in-rxjava-20--cms-28396 , https://code.tutsplus.com/tutorials/rxjava-for-android-apps-introducing-rxbinding-and-rxlifecycle--cms-28565 - all those talk mostly about RxJava, and not about replacement of AsyncTask or AsyncTaskLoader.

• https://github.com/L4Digital/RxLoader - requires unsubscribing, even though it doesn't say it needs it.

The question

How can I use Rx as replacement for AsyncTask and AsyncTaskLoader?

For example, how would I replace this tiny AsyncTaskLoader sample code with Rx equivalent:

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        supportLoaderManager.initLoader(1, Bundle.EMPTY, object : LoaderCallbacks<Int> {
            override fun onCreateLoader(id: Int, args: Bundle): Loader<Int> {
                Log.d("AppLog", "onCreateLoader")
                return MyLoader(this@MainActivity)
            }

            override fun onLoadFinished(loader: Loader<Int>, data: Int?) {
                Log.d("AppLog", "done:" + data!!)
            }

            override fun onLoaderReset(loader: Loader<Int>) {}
        })
    }

    private class MyLoader(context: Context) : AsyncTaskLoader<Int>(context) {

        override fun onStartLoading() {
            super.onStartLoading()
            forceLoad()
        }

        override fun loadInBackground(): Int {
            Log.d("AppLog", "loadInBackground")
            try {
                Thread.sleep(10000)
            } catch (e: InterruptedException) {
                e.printStackTrace()
            }
            return 123
        }
    }
}

For AsyncTask, usually we set it per ViewHolder, as a field there, and we cancel it upon onBindViewHolder, and when activity/fragment gets destroyed (go over all those that still pending or running).

Something like this (sample made as short as possible, of course it should be changed depending on needs) :

class AsyncTaskActivity : AppCompatActivity() {
    internal val mTasks = HashSet<AsyncTask<Void, Int, Void>>()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_async_task)
        val recyclerView = findViewById<RecyclerView>(R.id.recyclerView)
        recyclerView.layoutManager = LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false)
        recyclerView.adapter = object : Adapter<MyViewHolder>() {
            override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): MyViewHolder {
                return MyViewHolder(LayoutInflater.from(this@AsyncTaskActivity).inflate(android.R.layout.simple_list_item_1, parent, false))
            }

            @SuppressLint("StaticFieldLeak")
            override fun onBindViewHolder(holder: MyViewHolder, position: Int) {
                holder.tv.text = "loading..."
                if (holder.task != null) {
                    holder.task!!.cancel(true)
                    mTasks.remove(holder.task!!)
                }
                holder.task = object : AsyncTask<Void, Int, Void>() {
                    override fun doInBackground(vararg voids: Void): Void? {
                        for (i in 0..100)
                            try {
                                Thread.sleep(5)
                                publishProgress(i)
                            } catch (e: InterruptedException) {
                                e.printStackTrace()
                            }

                        return null
                    }

                    override fun onProgressUpdate(vararg values: Int?) {
                        super.onProgressUpdate(*values)
                        holder.tv.text = "progress:" + values[0]
                    }

                    override fun onPostExecute(aVoid: Void?) {
                        super.onPostExecute(aVoid)
                        mTasks.remove(holder.task)
                        holder.tv.text = "done:" + position
                        holder.task = null
                    }
                }.execute()
            }

            override fun getItemCount(): Int {
                return 1000
            }
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        for (task in mTasks)
            task.cancel(true)
    }

    private class MyViewHolder(itemView: View) : ViewHolder(itemView) {
        internal var tv: TextView
        internal var task: AsyncTask<Void, Int, Void>? = null

        init {
            tv = itemView.findViewById(android.R.id.text1)
        }
    }
}

Answer 1

Let me tell you in advance that my experience in RxJava isn't as some would call it advance. I just know enough to replace AsyncTask using RxJava + RxAndroid. For example, let's convert your AsyncTask code to RxJava2 equivalent using Observable, which is arguably the most popular stream type.

Observable
    .create <Int> { emitter ->
        try { 
            for (i in 0..100) {
                Thread.sleep(5) 
                emitter.onNext(i) 
            }
        } catch (e: InterruptedException) {
            emitter.onError(e)
        }
        emitter.onComplete()
    ‎}
    ‎.subscribeOn(Schedulers.io())
    ‎.observeOn(AndroidSchedulers.mainThread())
    ‎.subscribe({ i ->
    ‎    holder.tv.text = "progress:" + i
     }, { e ->
     ‎   e.printStackTrace()
     ‎}, {
     ‎   holder.tv.text = "done:" + position
     ‎})

Now let's go through the code line-by-line:

1. create lets you customize emitter behavior. Note that this isn't the only method to create the streams, there are also just, fromArray, fromList, defer, etc. We can discuss more of that if you are still interested.
2. subscribeOn(Schedulers.io()) tells RxJava that #1 will be executed in I/O thread. If this is a background operation, Schedulers.newThread() also works (at least to my knowledge it does).
3. observeOn(AndroidSchedulers.mainThread()) tells RxJava that #4 will be executed in Android's main thread. This is also where RxAndroid fills the gap since RxJava doesn't have any reference of Android.
4. subscribe()
   • onNext(i : Int) - equivalent to publishProgress(). In newer RxJava, emitted value cannot be null.
   • onError(e : Throwable) - error handling that is long glorified by RxJava's programmers. In newer RxJava, onError() must be provided, doesn't matter if it's empty.
   • onComplete() - equivalent to onPostExecute().

Again, there might be a lot of misinformation with my answer. I expect someone with better understanding to correct it or provide better answer that this one.

Answer 2

It seems there is no way to implement AsyncTask functionality with RxJava in shorter or more simple form. With RxJava you simplify task chaining, so if you have only one task AsyncTask can be better solution, but when you have several consecutive tasks to do - RxJava's interface is more convenient. So instead of, for example, program onCancelled for each task you should rather implement some common logic.