Merge branch 'master' into refactor-team-resource-dto-8518796163138516645

Author: dogi

CLAUDE.md

@@ -237,15 +237,15 @@ Activities, Chat, Configurations, Courses, Events, Feedback, Life, Notifications
 - `SharedPreferencesModule.kt` - Provides SharedPreferences
 
 **Entry Points for Workers (11 entry point files):**
-- `AutoSyncEntryPoint`, `ApiClientEntryPoint`, `ApiInterfaceEntryPoint`
+- `NetworkDependenciesEntryPoint`, `NetworkDependenciesEntryPoint`, `NetworkDependenciesEntryPoint`
 - `ApplicationScopeEntryPoint`, `BroadcastServiceEntryPoint`, `DatabaseServiceEntryPoint`
 - `RepositoryEntryPoint`, `RetryQueueEntryPoint`, `ServiceEntryPoint`
-- `TeamsRepositoryEntryPoint`, `WorkerDependenciesEntryPoint`
+- `RepositoryDependenciesEntryPoint`, `CoreDependenciesEntryPoint`
 
 ```kotlin
 @EntryPoint
 @InstallIn(SingletonComponent::class)
-interface AutoSyncEntryPoint {
+interface NetworkDependenciesEntryPoint {
     fun apiInterface(): ApiInterface
     fun sharedPreferences(): SharedPreferences
 }
@@ -543,7 +543,7 @@ class AutoSyncWorker(
     override suspend fun doWork(): Result {
         val entryPoint = EntryPointAccessors.fromApplication(
             applicationContext,
-            AutoSyncEntryPoint::class.java
+            NetworkDependenciesEntryPoint::class.java
         )
         val apiInterface = entryPoint.apiInterface()
         // ... use injected dependencies

app/src/androidTest/java/org/ole/planet/myplanet/model/RealmUserTest.kt

@@ -1,22 +1,35 @@
 package org.ole.planet.myplanet.model
 
+import android.content.SharedPreferences
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.platform.app.InstrumentationRegistry
+import dagger.Lazy
+import io.mockk.mockk
 import io.realm.Realm
 import io.realm.RealmConfiguration
-import java.util.concurrent.CountDownLatch
-import java.util.concurrent.TimeUnit
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
 import org.junit.After
 import org.junit.Assert.assertEquals
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
+import org.ole.planet.myplanet.data.DatabaseService
+import org.ole.planet.myplanet.data.api.ApiInterface
+import org.ole.planet.myplanet.repository.ConfigurationsRepository
+import org.ole.planet.myplanet.repository.UserRepositoryImpl
+import org.ole.planet.myplanet.services.SharedPrefManager
+import org.ole.planet.myplanet.services.UploadToShelfService
+import org.ole.planet.myplanet.utils.DispatcherProvider
 
 @RunWith(AndroidJUnit4::class)
 class RealmUserTest {
 
     private lateinit var realmConfiguration: RealmConfiguration
+    private lateinit var userRepository: UserRepositoryImpl
+    private lateinit var databaseService: DatabaseService
 
     @Before
     fun setUp() {
@@ -31,6 +44,45 @@ class RealmUserTest {
                 .build()
             Realm.setDefaultConfiguration(realmConfiguration)
         }
+
+        databaseService = object : DatabaseService {
+            override val realm: Realm
+                get() = Realm.getInstance(realmConfiguration)
+
+            override fun executeTransaction(transaction: Realm.Transaction) {
+                realm.executeTransaction(transaction)
+            }
+
+            override fun executeTransactionAsync(
+                transaction: Realm.Transaction,
+                onSuccess: Realm.Transaction.OnSuccess,
+                onError: Realm.Transaction.OnError
+            ) {
+                realm.executeTransactionAsync(transaction, onSuccess, onError)
+            }
+        }
+
+        val mockSettings = mockk<SharedPreferences>(relaxed = true)
+        val mockSharedPrefManager = mockk<SharedPrefManager>(relaxed = true)
+        val mockApiInterface = mockk<ApiInterface>(relaxed = true)
+        val mockUploadToShelfService = mockk<Lazy<UploadToShelfService>>(relaxed = true)
+        val mockContext = ApplicationProvider.getApplicationContext<android.content.Context>()
+        val mockConfigurationsRepository = mockk<ConfigurationsRepository>(relaxed = true)
+        val mockAppScope = CoroutineScope(Dispatchers.Unconfined)
+        val mockDispatcherProvider = mockk<DispatcherProvider>(relaxed = true)
+
+        userRepository = UserRepositoryImpl(
+            databaseService,
+            Dispatchers.Unconfined,
+            mockSettings,
+            mockSharedPrefManager,
+            mockApiInterface,
+            mockUploadToShelfService,
+            mockContext,
+            mockConfigurationsRepository,
+            mockAppScope,
+            mockDispatcherProvider
+        )
     }
 
     @After
@@ -43,8 +95,7 @@ class RealmUserTest {
     }
 
     @Test
-    fun cleanupDuplicateUsers_removesGuestWhenCouchDbUserExists() {
-        val latch = CountDownLatch(1)
+    fun cleanupDuplicateUsers_removesGuestWhenCouchDbUserExists() = runBlocking {
         InstrumentationRegistry.getInstrumentation().runOnMainSync {
             val realm = Realm.getInstance(realmConfiguration)
             realm.executeTransaction { r ->
@@ -57,14 +108,10 @@ class RealmUserTest {
                     name = "testuser"
                 }
             }
-
-            RealmUser.cleanupDuplicateUsers(realm) {
-                latch.countDown()
-                realm.close() // Close the realm after async transaction finishes
-            }
+            realm.close()
         }
 
-        latch.await(5, TimeUnit.SECONDS)
+        userRepository.cleanupDuplicateUsers()
 
         InstrumentationRegistry.getInstrumentation().runOnMainSync {
             val verifyRealm = Realm.getInstance(realmConfiguration)
@@ -76,8 +123,7 @@ class RealmUserTest {
     }
 
     @Test
-    fun cleanupDuplicateUsers_keepsCouchDbUserWhenGuestExists() {
-        val latch = CountDownLatch(1)
+    fun cleanupDuplicateUsers_keepsCouchDbUserWhenGuestExists() = runBlocking {
         InstrumentationRegistry.getInstrumentation().runOnMainSync {
             val realm = Realm.getInstance(realmConfiguration)
             realm.executeTransaction { r ->
@@ -90,14 +136,10 @@ class RealmUserTest {
                     name = "testuser"
                 }
             }
-
-            RealmUser.cleanupDuplicateUsers(realm) {
-                latch.countDown()
-                realm.close()
-            }
+            realm.close()
         }
 
-        latch.await(5, TimeUnit.SECONDS)
+        userRepository.cleanupDuplicateUsers()
 
         InstrumentationRegistry.getInstrumentation().runOnMainSync {
             val verifyRealm = Realm.getInstance(realmConfiguration)
@@ -109,8 +151,7 @@ class RealmUserTest {
     }
 
     @Test
-    fun cleanupDuplicateUsers_keepsAllUsersWhenNoDuplicates() {
-        val latch = CountDownLatch(1)
+    fun cleanupDuplicateUsers_keepsAllUsersWhenNoDuplicates() = runBlocking {
         InstrumentationRegistry.getInstrumentation().runOnMainSync {
             val realm = Realm.getInstance(realmConfiguration)
             realm.executeTransaction { r ->
@@ -123,14 +164,10 @@ class RealmUserTest {
                     name = "testuser2"
                 }
             }
-
-            RealmUser.cleanupDuplicateUsers(realm) {
-                latch.countDown()
-                realm.close()
-            }
+            realm.close()
         }
 
-        latch.await(5, TimeUnit.SECONDS)
+        userRepository.cleanupDuplicateUsers()
 
         InstrumentationRegistry.getInstrumentation().runOnMainSync {
             val verifyRealm = Realm.getInstance(realmConfiguration)

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

@@ -35,13 +35,9 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import org.ole.planet.myplanet.callback.OnTeamPageListener
 import org.ole.planet.myplanet.data.DatabaseService
-import org.ole.planet.myplanet.di.ApiClientEntryPoint
-import org.ole.planet.myplanet.di.ApplicationScopeEntryPoint
-import org.ole.planet.myplanet.di.AutoSyncEntryPoint
+import org.ole.planet.myplanet.di.CoreDependenciesEntryPoint
 import org.ole.planet.myplanet.di.DefaultPreferences
-import org.ole.planet.myplanet.di.RetryQueueEntryPoint
-import org.ole.planet.myplanet.di.ServerUrlMapperEntryPoint
-import org.ole.planet.myplanet.di.WorkerDependenciesEntryPoint
+import org.ole.planet.myplanet.di.NetworkDependenciesEntryPoint
 import org.ole.planet.myplanet.model.RealmApkLog
 import org.ole.planet.myplanet.repository.ResourcesRepository
 import org.ole.planet.myplanet.services.AutoSyncWorker
@@ -54,7 +50,9 @@ import org.ole.planet.myplanet.services.retry.RetryQueueWorker
 import org.ole.planet.myplanet.utils.ANRWatchdog
 import org.ole.planet.myplanet.utils.DispatcherProvider
 import org.ole.planet.myplanet.utils.DownloadUtils.downloadAllFiles
+import org.ole.planet.myplanet.utils.FileUtils
 import org.ole.planet.myplanet.utils.LocaleUtils
+import org.ole.planet.myplanet.utils.MarkdownUtils
 import org.ole.planet.myplanet.utils.NetworkUtils.isNetworkConnectedFlow
 import org.ole.planet.myplanet.utils.NetworkUtils.startListenNetworkState
 import org.ole.planet.myplanet.utils.NetworkUtils.stopListenNetworkState
@@ -117,10 +115,10 @@ class MainApplication : Application(), Application.ActivityLifecycleCallbacks, W
             applicationScope.launch {
                 val entryPoint = EntryPointAccessors.fromApplication(
                     context,
-                    WorkerDependenciesEntryPoint::class.java
+                    CoreDependenciesEntryPoint::class.java
                 )
                 val userSessionManager = entryPoint.userSessionManager()
-                val spm = EntryPointAccessors.fromApplication(context, AutoSyncEntryPoint::class.java).sharedPrefManager()
+                val spm = EntryPointAccessors.fromApplication(context, CoreDependenciesEntryPoint::class.java).sharedPrefManager()
                 try {
                     val databaseService = (context.applicationContext as MainApplication).databaseService
                     val model = userSessionManager.getUserModel()
@@ -155,7 +153,7 @@ class MainApplication : Application(), Application.ActivityLifecycleCallbacks, W
             urlString: String,
             ioDispatcher: kotlinx.coroutines.CoroutineDispatcher = kotlinx.coroutines.Dispatchers.IO
         ): Boolean {
-            val entryPoint = EntryPointAccessors.fromApplication(context, ServerUrlMapperEntryPoint::class.java)
+            val entryPoint = EntryPointAccessors.fromApplication(context, CoreDependenciesEntryPoint::class.java)
             val serverUrlMapper = entryPoint.serverUrlMapper()
             val mapping = serverUrlMapper.processUrl(urlString)
             val urlsToTry = mutableListOf(urlString)
@@ -224,7 +222,9 @@ class MainApplication : Application(), Application.ActivityLifecycleCallbacks, W
 
     private fun performDeferredInitialization() {
         applicationScope.launch(Dispatchers.IO) {
+            FileUtils.warmUp(this@MainApplication)
             SecurePrefs.warmUp(this@MainApplication)
+            MarkdownUtils.warmUp(this@MainApplication)
         }
         applicationScope.launch {
             initApp()
@@ -245,7 +245,7 @@ class MainApplication : Application(), Application.ActivityLifecycleCallbacks, W
     private fun setupCriticalProperties() {
         applicationScope = EntryPointAccessors.fromApplication(
             this,
-            ApplicationScopeEntryPoint::class.java
+            CoreDependenciesEntryPoint::class.java
         ).applicationScope()
     }
 
@@ -261,7 +261,7 @@ class MainApplication : Application(), Application.ActivityLifecycleCallbacks, W
         withContext(dispatcherProvider.io) {
             EntryPointAccessors.fromApplication(
                 this@MainApplication,
-                ApiClientEntryPoint::class.java
+                NetworkDependenciesEntryPoint::class.java
             ).apiClient()
             apiClientInitialized.complete(Unit)
         }
@@ -320,7 +320,7 @@ class MainApplication : Application(), Application.ActivityLifecycleCallbacks, W
             try {
                 val entryPoint = EntryPointAccessors.fromApplication(
                     this@MainApplication,
-                    RetryQueueEntryPoint::class.java
+                    NetworkDependenciesEntryPoint::class.java
                 )
                 entryPoint.retryQueue().recoverStuckOperations()
             } catch (e: Exception) {

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

@@ -297,9 +297,10 @@ abstract class BaseResourceFragment : Fragment() {
     fun createListView(dbMyLibrary: List<RealmMyLibrary?>, alertDialog: AlertDialog) {
         lv = convertView?.findViewById(R.id.alertDialog_listView)
         val names = dbMyLibrary.map { it?.title ?: "" }
-        val adapter = CheckboxAdapter(names) {
+        val adapter = CheckboxAdapter {
             alertDialog.getButton(AlertDialog.BUTTON_POSITIVE).isEnabled = ((lv?.adapter as? CheckboxAdapter)?.selectedItemsList?.size ?: 0) > 0
         }
+        adapter.submitList(names)
         lv?.layoutManager = LinearLayoutManager(requireActivity().baseContext)
         lv?.adapter = adapter
     }

app/src/main/java/org/ole/planet/myplanet/di/ApiClientEntryPoint.kt

@@ -0,0 +1,20 @@
+package org.ole.planet.myplanet.di
+
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import kotlinx.coroutines.CoroutineScope
+import org.ole.planet.myplanet.data.DatabaseService
+import org.ole.planet.myplanet.services.SharedPrefManager
+import org.ole.planet.myplanet.services.UserSessionManager
+import org.ole.planet.myplanet.services.sync.ServerUrlMapper
+
+@EntryPoint
+@InstallIn(SingletonComponent::class)
+interface CoreDependenciesEntryPoint {
+    @ApplicationScope fun applicationScope(): CoroutineScope
+    fun sharedPrefManager(): SharedPrefManager
+    fun databaseService(): DatabaseService
+    fun userSessionManager(): UserSessionManager
+    fun serverUrlMapper(): ServerUrlMapper
+}

app/src/main/java/org/ole/planet/myplanet/di/ApiInterfaceEntryPoint.kt

@@ -29,8 +29,8 @@ object DatabaseModule {
     @Singleton
     @RealmDispatcher
     fun provideRealmDispatcher(): CoroutineDispatcher {
-        val handlerThread = HandlerThread("RealmQueryThread")
-        handlerThread.start()
+        // Realm async queries and change listeners require a thread with a Looper.
+        val handlerThread = HandlerThread("RealmQueryThread").also { it.start() }
         return Handler(handlerThread.looper).asCoroutineDispatcher()
     }