update realm in build gradle and start models migration (fixes #4773)

app/build.gradle

@@ -3,7 +3,7 @@ apply plugin: 'kotlin-android'
 apply plugin: 'kotlin-kapt'
 apply plugin: 'kotlinx-serialization'
 apply plugin: 'dagger.hilt.android.plugin'
-apply plugin: 'realm-android'
+
 android {
     compileSdk 35
     defaultConfig {
@@ -233,9 +233,7 @@ dependencies {
     implementation(platform("org.jetbrains.kotlin:kotlin-bom:2.1.0"))
 
     implementation 'com.github.chrisbanes:PhotoView:2.3.0'
-}
-realm {
-    syncEnabled = true
+    implementation "io.realm.kotlin:library-base:1.11.0"
 }
 kapt{
     correctErrorTypes  true

app/src/main/java/org/ole/planet/myplanet/MainApplication.kt

@@ -14,17 +14,15 @@ import androidx.preference.PreferenceManager
 import androidx.work.ExistingPeriodicWorkPolicy
 import androidx.work.PeriodicWorkRequest
 import androidx.work.WorkManager
-import io.realm.Realm
+import io.realm.kotlin.Realm
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withContext
-import org.ole.planet.myplanet.MainApplication
 import org.ole.planet.myplanet.base.BaseResourceFragment.Companion.backgroundDownload
 import org.ole.planet.myplanet.base.BaseResourceFragment.Companion.getAllLibraryList
 import org.ole.planet.myplanet.callback.TeamPageListener
@@ -75,29 +73,27 @@ class MainApplication : Application(), Application.ActivityLifecycleCallbacks {
         val applicationScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
         lateinit var defaultPref: SharedPreferences
 
-        fun createLog(type: String) {
-            runBlocking {
-                withContext(Dispatchers.IO) {
-                    val realm = Realm.getDefaultInstance()
-                    try {
-                        realm.executeTransaction { r ->
-                            val log = r.createObject(RealmApkLog::class.java, "${UUID.randomUUID()}")
+        suspend fun createLog(type: String) {
+            withContext(Dispatchers.IO) {
+                try {
+                    mRealm.write {
+                        val log = RealmApkLog().apply {
+                            id = UUID.randomUUID().toString()
                             val model = UserProfileDbHandler(context).userModel
                             if (model != null) {
-                                log.parentCode = model.parentCode
-                                log.createdOn = model.planetCode
-                                log.userId = model.id
+                                parentCode = model.parentCode
+                                createdOn = model.planetCode
+                                userId = model.id
                             }
-                            log.time = "${Date().time}"
-                            log.page = ""
-                            log.version = getVersionName(context)
-                            log.type = type
+                            time = Date().time.toString()
+                            page = ""
+                            version = getVersionName(context)
+                            this.type = type
                         }
-                    } catch (e: Exception) {
-                        e.printStackTrace()
-                    } finally {
-                        realm.close()
+                        copyToRealm(log)
                     }
+                } catch (e: Exception) {
+                    e.printStackTrace()
                 }
             }
         }
@@ -153,24 +149,22 @@ class MainApplication : Application(), Application.ActivityLifecycleCallbacks {
             e.printStackTrace()
             applicationScope.launch(Dispatchers.IO) {
                 try {
-                    val realm = Realm.getDefaultInstance()
-                    try {
-                        realm.executeTransaction { r ->
-                            val log = r.createObject(RealmApkLog::class.java, "${UUID.randomUUID()}")
+                    mRealm.write {
+                        val log = RealmApkLog().apply {
+                            id = UUID.randomUUID().toString()
                             val model = UserProfileDbHandler(context).userModel
                             if (model != null) {
-                                log.parentCode = model.parentCode
-                                log.createdOn = model.planetCode
-                                log.userId = model.id
+                                parentCode = model.parentCode
+                                createdOn = model.planetCode
+                                userId = model.id
                             }
-                            log.time = "${Date().time}"
-                            log.page = ""
-                            log.version = getVersionName(context)
-                            log.type = RealmApkLog.ERROR_TYPE_CRASH
-                            log.setError(e)
+                            time = Date().time.toString()
+                            page = ""
+                            version = getVersionName(context)
+                            type = RealmApkLog.ERROR_TYPE_CRASH
+                            setError(e)
                         }
-                    } finally {
-                        realm.close()
+                        copyToRealm(log)
                     }
                 } catch (ex: Exception) {
                     ex.printStackTrace()
@@ -195,7 +189,7 @@ class MainApplication : Application(), Application.ActivityLifecycleCallbacks {
         startListenNetworkState()
 
         preferences = getSharedPreferences(PREFS_NAME, MODE_PRIVATE)
-        service = DatabaseService(context)
+        service = DatabaseService()
         mRealm = service.realmInstance
         defaultPref = PreferenceManager.getDefaultSharedPreferences(this)
 
@@ -213,7 +207,9 @@ class MainApplication : Application(), Application.ActivityLifecycleCallbacks {
         scheduleTaskNotificationWork()
 
         Thread.setDefaultUncaughtExceptionHandler { _: Thread?, e: Throwable ->
-            handleUncaughtException(e)
+            applicationScope.launch {
+                handleUncaughtException(e)
+            }
         }
         registerActivityLifecycleCallbacks(this)
         onAppStarted()
@@ -334,6 +330,7 @@ class MainApplication : Application(), Application.ActivityLifecycleCallbacks {
     override fun onTerminate() {
         super.onTerminate()
         onAppClosed()
+        mRealm.close()
         applicationScope.cancel()
     }
 }

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

@@ -15,14 +15,15 @@ import android.view.ViewGroup
 import android.widget.ArrayAdapter
 import android.widget.Button
 import android.widget.TextView
-import android.widget.Toast
 import androidx.activity.result.ActivityResultLauncher
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AlertDialog
 import androidx.appcompat.view.ContextThemeWrapper
 import androidx.appcompat.widget.AppCompatRatingBar
 import androidx.core.content.FileProvider
+import androidx.lifecycle.lifecycleScope
 import com.google.gson.JsonObject
+import kotlinx.coroutines.launch
 import org.ole.planet.myplanet.MainApplication
 import org.ole.planet.myplanet.R
 import org.ole.planet.myplanet.base.PermissionActivity.Companion.hasInstallPermission
@@ -106,35 +107,33 @@ abstract class BaseContainerFragment : BaseResourceFragment() {
     }
     private fun openIntent(items: RealmMyLibrary, typeClass: Class<*>?) {
         val fileOpenIntent = Intent(activity, typeClass)
-        if (items.resourceLocalAddress?.contains("ole/audio") == true || items.resourceLocalAddress?.contains("ole/video") == true) {
+        if (items.resourceLocalAddress.contains("ole/audio") == true || items.resourceLocalAddress.contains("ole/video") == true) {
             fileOpenIntent.putExtra("TOUCHED_FILE", items.resourceLocalAddress)
             fileOpenIntent.putExtra("RESOURCE_TITLE", items.title)
         } else {
-            fileOpenIntent.putExtra("TOUCHED_FILE", items.id + "/" + items.resourceLocalAddress)
+            fileOpenIntent.putExtra("TOUCHED_FILE", "${items.id}/${items.resourceLocalAddress}")
             fileOpenIntent.putExtra("RESOURCE_TITLE", items.title)
         }
         startActivity(fileOpenIntent)
     }
     private fun openPdf(item: RealmMyLibrary) {
         val fileOpenIntent = Intent(activity, PDFReaderActivity::class.java)
-        fileOpenIntent.putExtra("TOUCHED_FILE", item.id + "/" + item.resourceLocalAddress)
+        fileOpenIntent.putExtra("TOUCHED_FILE", "${item.id}/${item.resourceLocalAddress}")
         fileOpenIntent.putExtra("resourceId", item.id)
         startActivity(fileOpenIntent)
     }
 
     fun openResource(items: RealmMyLibrary) {
-        val matchingItems = mRealm.where(RealmMyLibrary::class.java)
-            .equalTo("resourceLocalAddress", items.resourceLocalAddress)
-            .findAll()
+        val matchingItems = MainApplication.mRealm.query<RealmMyLibrary>(RealmMyLibrary::class, "resourceLocalAddress == $0", items.resourceLocalAddress).find()
         val anyOffline = matchingItems.any { it.isResourceOffline() }
         if (anyOffline) {
-            val offlineItem = matchingItems.first { it.isResourceOffline()}
+            val offlineItem = matchingItems.first { it.isResourceOffline() }
             openFileType(offlineItem, "offline")
         } else {
             if (items.isResourceOffline()) {
                 openFileType(items, "offline")
             } else if (FileUtils.getFileExtension(items.resourceLocalAddress) == "mp4") {
-                openFileType(items,  "online")
+                openFileType(items, "online")
             } else {
                 val arrayList = ArrayList<String>()
                 arrayList.add(Utilities.getUrl(items))
@@ -145,38 +144,41 @@ abstract class BaseContainerFragment : BaseResourceFragment() {
     }
 
     private fun checkFileExtension(items: RealmMyLibrary) {
-        val filenameArray = items.resourceLocalAddress?.split("\\.".toRegex())?.toTypedArray()
-        val extension = filenameArray?.get(filenameArray.size - 1)
+        val filenameArray = items.resourceLocalAddress.split("\\.".toRegex()).toTypedArray()
+        val extension = filenameArray[filenameArray.size - 1]
         val mimetype = Utilities.getMimeType(items.resourceLocalAddress)
 
-        if (mimetype != null) {
-            if (mimetype.contains("image")) {
-                openIntent(items, ImageViewerActivity::class.java)
-            } else if (mimetype.contains("pdf")) {
-                openPdf(items)
-            } else if (mimetype.contains("audio")) {
-                openIntent(items, AudioPlayerActivity::class.java)
-            } else {
-                checkMoreFileExtensions(extension, items)
+        lifecycleScope.launch {
+            if (mimetype != null) {
+                if (mimetype.contains("image")) {
+                    openIntent(items, ImageViewerActivity::class.java)
+                } else if (mimetype.contains("pdf")) {
+                    openPdf(items)
+                } else if (mimetype.contains("audio")) {
+                    openIntent(items, AudioPlayerActivity::class.java)
+                } else {
+                    checkMoreFileExtensions(extension, items)
+                }
             }
         }
     }
 
     private fun checkMoreFileExtensions(extension: String?, items: RealmMyLibrary) {
-        when (extension) {
-            "txt" -> {
-                openIntent(items, TextFileViewerActivity::class.java)
-            }
-            "md" -> {
-                openIntent(items, MarkdownViewerActivity::class.java)
-            }
-            "csv" -> {
-                openIntent(items, CSVViewerActivity::class.java)
-            }
-            "apk" -> {
-                installApk(items)
+        lifecycleScope.launch {
+            when (extension) {
+                "txt" -> {
+                    openIntent(items, TextFileViewerActivity::class.java)
+                }
+                "md" -> {
+                    openIntent(items, MarkdownViewerActivity::class.java)
+                }
+                "csv" -> {
+                    openIntent(items, CSVViewerActivity::class.java)
+                }
+                "apk" -> {
+                    installApk(items)
+                }
             }
-            else -> Toast.makeText(activity, getString(R.string.this_file_type_is_currently_unsupported), Toast.LENGTH_LONG).show()
         }
     }
 
@@ -188,14 +190,14 @@ abstract class BaseContainerFragment : BaseResourceFragment() {
                 throw RuntimeException("Failed to create directory: " + directory.absolutePath)
             }
         }
-        val apkFile = items.resourceLocalAddress?.let { File(directory, it) }
-        if (apkFile != null) {
+        val apkFile = File(directory, items.resourceLocalAddress)
+        if (true) {
             if (!apkFile.exists()) {
                 Utilities.toast(activity,"APK file not found")
                 return
             }
         }
-        val uri = apkFile?.let {
+        val uri = apkFile.let {
             FileProvider.getUriForFile(MainApplication.context, "${MainApplication.context.packageName}.fileprovider", it)
         }
         val intent = Intent(Intent.ACTION_VIEW).apply {
@@ -241,7 +243,7 @@ abstract class BaseContainerFragment : BaseResourceFragment() {
             bundle.putString("videoURL", "" + Utilities.getUrl(items))
             bundle.putString("Auth", "" + auth)
         } else if (videoType == "offline") {
-            if (items.resourceRemoteAddress == null && items.resourceLocalAddress != null) {
+            if (false) {
                 bundle.putString("videoURL", items.resourceLocalAddress)
             } else {
                 bundle.putString("videoURL", "" + Uri.fromFile(File("" + FileUtils.getSDPathFromUrl(items.resourceRemoteAddress))))