Issue: RxJava and Kotlin Coroutines in Android
I am using both RxJava and Kotlin Coroutines to access data from a Room database. Initially, RxJava worked fine, but after attempting to use Kotlin Coroutines and then reverting back to RxJava, the RxJava code no longer works. The dispose is null and the code within the subscribe block doesn’t execute. Here is my code:

ViewSplashScreenActivity.kt

package com.dane.app.view

import android.annotation.SuppressLint
import android.content.Context
import android.content.Intent
import android.view.LayoutInflater
import android.widget.Toast
import androidx.fragment.app.FragmentActivity
import com.dane.app.LoginActivity
import com.dane.app.MainActivity
import com.dane.app.NoNetworkDialogFragment
import com.dane.app.databinding.ActivitySplashScreenBinding
import com.dane.app.db.DBHandler
import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
import io.reactivex.rxjava3.disposables.CompositeDisposable
import io.reactivex.rxjava3.schedulers.Schedulers

@Suppress("NAME_SHADOWING")
@SuppressLint("CustomSplashScreen")
class ViewSplashScreenActivity(
    private val context: Context,
) {
    val b = ActivitySplashScreenBinding.inflate(LayoutInflater.from(context))

    fun networkIsOff() {
        if (context is FragmentActivity) {
            val noNetworkDialog = NoNetworkDialogFragment()
            noNetworkDialog.show(
                context.supportFragmentManager,
                "NoNetworkDialog"
            )
        } else {
            Toast.makeText(context, "No internet", Toast.LENGTH_SHORT).show()
        }
    }

    fun networkIsOn() {
        val db = DBHandler.getDB(context).userDataDAO().getUserData
        val disposable = CompositeDisposable()

        val dispose = db.observeOn(AndroidSchedulers.mainThread())
            .subscribeOn(Schedulers.io())
            .subscribe({ user2 ->
                user2.forEach { user ->
                    Toast.makeText(context, "run", Toast.LENGTH_SHORT).show()
                    if (user.toString() == "[]") {
                        b.root.postDelayed({
                            val mainIntent = Intent(context, LoginActivity::class.java)
                            context.startActivity(mainIntent)
                        }, 2000)
                    } else {
                        b.root.postDelayed({
                            val mainIntent = Intent(context, MainActivity::class.java)
                            context.startActivity(mainIntent)
                        }, 2000)
                    }
                }
            }) { _ -> }
        
        Toast.makeText(context, dispose.toString(), Toast.LENGTH_SHORT).show()
        disposable.add(dispose)
    }
}

DBHandler.kt

package com.dane.app.db

import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
import androidx.room.TypeConverters
import com.dane.app.db.dao.UserDataDAO
import com.dane.app.db.model.ListConverter
import com.dane.app.db.model.UserData

@Database(
    entities = [UserData::class],
    version = 2
)
@TypeConverters(ListConverter::class)
abstract class DBHandler : RoomDatabase() {
    companion object {
        private var INSTANCE: DBHandler? = null

        fun getDB(context: Context?): DBHandler {
            if (INSTANCE == null) {
                INSTANCE = Room.databaseBuilder(
                    context!!,
                    DBHandler::class.java,
                    "mainDB"
                )
                    .fallbackToDestructiveMigration()
                    .build()
            }
            return INSTANCE!!
        }
    }

    abstract fun userDataDAO(): UserDataDAO
}

UserDataDAO.kt

package com.dane.app.db.dao

import androidx.room.Dao
import androidx.room.Insert
import androidx.room.Query
import com.dane.app.db.model.UserData
import io.reactivex.rxjava3.core.Flowable

@Dao
interface UserDataDAO {
    @Insert
    fun insertUser(user: UserData)

    @get:Query("SELECT * FROM userData")
    val getUserData: Flowable<List<UserData>>
}

UserData.kt

package com.dane.app.db.model

import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.PrimaryKey
import androidx.room.TypeConverters

@Entity(tableName = "userData")
@TypeConverters(ListConverter::class)
data class UserData(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
    @ColumnInfo val signed: Boolean = false,
    @ColumnInfo val part1: Int = 0,
    @ColumnInfo val part2: Int = 0,
    @ColumnInfo val part3: Int = 0,
    @ColumnInfo val part4: Int = 0,
    @ColumnInfo val list1: List<Int>? = null,
    @ColumnInfo val list2: List<Int>? = null,
    @ColumnInfo val list3: List<Int>? = null,
    @ColumnInfo val list4: List<Int>? = null
)

When using Kotlin Coroutines and then switching back to RxJava, my RxJava subscription code no longer executes as expected. The dispose object is null and the subscribe block is never triggered. Any help or suggestions would be appreciated.