Refactor: Replace deprecated realmInstance with withRealmAsync

Replaced the deprecated synchronous `realmInstance` getter with the asynchronous `withRealmAsync` or `withRealm` in `DashboardActivity`, `BaseRecyclerFragment`, and `BaseResourceFragment`. This change moves database access off the main thread, mitigating the risk of ANRs.

- Refactored `DashboardActivity` to use `withRealmAsync` for notification creation.
- Audited and refactored `BaseRecyclerFragment` and `BaseResourceFragment` to eliminate direct `realmInstance` access, favoring `withRealm` within coroutines.
- Added `@Deprecated` annotation to `realmInstance` in `DatabaseService` to guide developers towards safer alternatives.
- Ensured `StrictMode` is enabled to detect disk reads in debug builds.

Author: google-labs-jules[bot]

app/src/main/java/org/ole/planet/myplanet/base/BaseRecyclerFragment.kt

@@ -81,15 +81,18 @@ abstract class BaseRecyclerFragment<LI> : BaseRecyclerParentFragment<Any?>(), On
         tvMessage = v.findViewById(R.id.tv_message)
         selectedItems = mutableListOf()
         list = mutableListOf()
-        mRealm = databaseService.realmInstance
         model = profileDbHandler.userModel
         val adapter = getAdapter()
         recyclerView.adapter = adapter
+
         if (isMyCourseLib && adapter.itemCount != 0 && courseLib == "courses") {
             resources?.let { showDownloadDialog(it) }
         } else if (isMyCourseLib && courseLib == null && !isSurvey) {
             viewLifecycleOwner.lifecycleScope.launch {
-                showDownloadDialog(getLibraryList(mRealm))
+                val libraryList = databaseService.withRealm { realm ->
+                    getLibraryList(realm)
+                }
+                showDownloadDialog(libraryList)
             }
         }
         return v
@@ -107,7 +110,7 @@ abstract class BaseRecyclerFragment<LI> : BaseRecyclerParentFragment<Any?>(), On
     }
 
     fun addToMyList() {
-        if (!isRealmInitialized() || isAddInProgress) return
+        if (isAddInProgress) return
 
         val itemsToAdd = selectedItems?.toList() ?: emptyList()
         if (itemsToAdd.isEmpty()) return
@@ -181,26 +184,23 @@ abstract class BaseRecyclerFragment<LI> : BaseRecyclerParentFragment<Any?>(), On
     }
 
     fun deleteSelected(deleteProgress: Boolean) {
-        selectedItems?.forEach { item ->
+        viewLifecycleOwner.lifecycleScope.launch {
             try {
-                if (!mRealm.isInTransaction) {
-                    mRealm.beginTransaction()
-                }
-                val `object` = item as RealmObject
-                deleteCourseProgress(deleteProgress, `object`)
-                removeFromShelf(`object`)
-                if (mRealm.isInTransaction) {
-                    mRealm.commitTransaction()
+                databaseService.withRealm { realm ->
+                    realm.executeTransaction {
+                        selectedItems?.forEach { item ->
+                            val `object` = item as RealmObject
+                            deleteCourseProgress(deleteProgress, `object`)
+                            removeFromShelf(`object`)
+                        }
+                    }
                 }
+                recyclerView.adapter = getAdapter()
+                showNoData(tvMessage, getAdapter().itemCount, "")
             } catch (e: Exception) {
-                if (mRealm.isInTransaction) {
-                    mRealm.cancelTransaction()
-                }
-                throw e
+                e.printStackTrace()
             }
         }
-        recyclerView.adapter = getAdapter()
-        showNoData(tvMessage, getAdapter().itemCount, "")
     }
 
     fun countSelected(): Int {
@@ -209,31 +209,42 @@ abstract class BaseRecyclerFragment<LI> : BaseRecyclerParentFragment<Any?>(), On
 
     private fun deleteCourseProgress(deleteProgress: Boolean, `object`: RealmObject) {
         if (deleteProgress && `object` is RealmMyCourse) {
-            mRealm.where(RealmCourseProgress::class.java).equalTo("courseId", `object`.courseId).findAll().deleteAllFromRealm()
-            val examList: List<RealmStepExam> = mRealm.where(RealmStepExam::class.java).equalTo("courseId", `object`.courseId).findAll()
-            for (exam in examList) {
-                mRealm.where(RealmSubmission::class.java).equalTo("parentId", exam.id)
-                    .notEqualTo("type", "survey").equalTo("uploaded", false).findAll()
-                    .deleteAllFromRealm()
+            databaseService.withRealm { realm ->
+                realm.where(RealmCourseProgress::class.java).equalTo("courseId", `object`.courseId)
+                    .findAll().deleteAllFromRealm()
+                val examList: List<RealmStepExam> =
+                    realm.where(RealmStepExam::class.java).equalTo("courseId", `object`.courseId)
+                        .findAll()
+                for (exam in examList) {
+                    realm.where(RealmSubmission::class.java).equalTo("parentId", exam.id)
+                        .notEqualTo("type", "survey").equalTo("uploaded", false).findAll()
+                        .deleteAllFromRealm()
+                }
             }
         }
     }
 
-    private fun checkAndAddToList(course: RealmMyCourse?, courses: MutableList<RealmMyCourse>, tags: List<RealmTag>) {
+    private fun checkAndAddToList(
+        realm: Realm,
+        course: RealmMyCourse?,
+        courses: MutableList<RealmMyCourse>,
+        tags: List<RealmTag>
+    ) {
         for (tg in tags) {
-            val count = mRealm.where(RealmTag::class.java).equalTo("db", "courses").equalTo("tagId", tg.id)
+            val count = realm.where(RealmTag::class.java).equalTo("db", "courses")
+                .equalTo("tagId", tg.id)
                 .equalTo("linkId", course?.courseId).count()
             if (count > 0 && !courses.contains(course)) {
                 course?.let { courses.add(it) }
             }
         }
     }
 
-    private fun <LI : RealmModel> getData(s: String, c: Class<LI>): List<LI> {
-        if (s.isEmpty()) return mRealm.where(c).findAll()
+    private fun <LI : RealmModel> getData(realm: Realm, s: String, c: Class<LI>): List<LI> {
+        if (s.isEmpty()) return realm.where(c).findAll()
 
         val queryParts = s.split(" ").filterNot { it.isEmpty() }
-        val data: RealmResults<LI> = mRealm.where(c).findAll()
+        val data: RealmResults<LI> = realm.where(c).findAll()
         val normalizedQuery = normalizeText(s)
         val startsWithQuery = mutableListOf<LI>()
         val containsQuery = mutableListOf<LI>()
@@ -258,25 +269,26 @@ abstract class BaseRecyclerFragment<LI> : BaseRecyclerParentFragment<Any?>(), On
     }
 
     fun filterLibraryByTag(s: String, tags: List<RealmTag>): List<RealmMyLibrary> {
-        val normalizedSearchTerm = normalizeText(s)
-        var list = getData(s, RealmMyLibrary::class.java)
-        list = if (isMyCourseLib) {
-            getMyLibraryByUserId(model?.id, list)
-        } else {
-            getOurLibrary(model?.id, list)
-        }
+        return databaseService.withRealm { realm ->
+            val normalizedSearchTerm = normalizeText(s)
+            var list = getData(realm, s, RealmMyLibrary::class.java)
+            list = if (isMyCourseLib) {
+                getMyLibraryByUserId(model?.id, list)
+            } else {
+                getOurLibrary(model?.id, list)
+            }
 
-        val libraries = if (tags.isNotEmpty()) {
-            val filteredLibraries = mutableListOf<RealmMyLibrary>()
-            for (library in list) {
-                filter(tags, library, filteredLibraries)
+            val libraries = if (tags.isNotEmpty()) {
+                val filteredLibraries = mutableListOf<RealmMyLibrary>()
+                for (library in list) {
+                    filter(realm, tags, library, filteredLibraries)
+                }
+                filteredLibraries
+            } else {
+                list
             }
-            filteredLibraries
-        } else {
-            list
+            libraries
         }
-
-        return libraries
     }
 
     fun normalizeText(str: String): String {
@@ -285,32 +297,39 @@ abstract class BaseRecyclerFragment<LI> : BaseRecyclerParentFragment<Any?>(), On
     }
 
     fun filterCourseByTag(s: String, tags: List<RealmTag>): List<RealmMyCourse> {
-        if (tags.isEmpty() && s.isEmpty()) {
-            return applyCourseFilter(filterRealmMyCourseList(getList(RealmMyCourse::class.java)))
-        }
-        var list = getData(s, RealmMyCourse::class.java)
-        list = if (isMyCourseLib) {
-            getMyCourseByUserId(model?.id, list)
-        } else {
-            getAllCourses(model?.id, list)
-        }
-        if (tags.isEmpty()) {
-            return list
-        }
-        val courses = RealmList<RealmMyCourse>()
-        list.forEach { course ->
-            checkAndAddToList(course, courses, tags)
+        return databaseService.withRealm { realm ->
+            if (tags.isEmpty() && s.isEmpty()) {
+                return@withRealm applyCourseFilter(filterRealmMyCourseList(getList(RealmMyCourse::class.java)))
+            }
+            var list = getData(realm, s, RealmMyCourse::class.java)
+            list = if (isMyCourseLib) {
+                getMyCourseByUserId(model?.id, list)
+            } else {
+                getAllCourses(model?.id, list)
+            }
+            if (tags.isEmpty()) {
+                return@withRealm list
+            }
+            val courses = RealmList<RealmMyCourse>()
+            list.forEach { course ->
+                checkAndAddToList(realm, course, courses, tags)
+            }
+            applyCourseFilter(courses)
         }
-        return applyCourseFilter(courses)
     }
 
     private fun filterRealmMyCourseList(items: List<Any?>): List<RealmMyCourse> {
         return items.filterIsInstance<RealmMyCourse>()
     }
 
-    private fun filter(tags: List<RealmTag>, library: RealmMyLibrary?, libraries: MutableList<RealmMyLibrary>) {
+    private fun filter(
+        realm: Realm,
+        tags: List<RealmTag>,
+        library: RealmMyLibrary?,
+        libraries: MutableList<RealmMyLibrary>
+    ) {
         for (tg in tags) {
-            val count = mRealm.where(RealmTag::class.java).equalTo("db", "resources")
+            val count = realm.where(RealmTag::class.java).equalTo("db", "resources")
                 .equalTo("tagId", tg.id).equalTo("linkId", library?.id).count()
             if (count > 0 && !libraries.contains(library)) {
                 library?.let { libraries.add(it) }
@@ -348,32 +367,6 @@ abstract class BaseRecyclerFragment<LI> : BaseRecyclerParentFragment<Any?>(), On
         return sub && lev && lan && med
     }
 
-    override fun onDestroy() {
-        cleanupRealm()
-        super.onDestroy()
-    }
-
-    private fun cleanupRealm() {
-        if (isRealmInitialized()) {
-            try {
-                mRealm.removeAllChangeListeners()
-
-                if (mRealm.isInTransaction) {
-                    try {
-                        mRealm.commitTransaction()
-                    } catch (e: Exception) {
-                        mRealm.cancelTransaction()
-                    }
-                }
-            } catch (e: Exception) {
-                e.printStackTrace()
-            } finally {
-                if (!mRealm.isClosed) {
-                    mRealm.close()
-                }
-            }
-        }
-    }
 
     override fun onDetach() {
         super.onDetach()