Use Wholphin-specific dispatchers (#1583)

## Description
Switches all usages of `kotlinx.coroutines.Dispatchers` to
`WholphinDispatchers`.

`WholphinDispatchers` provides an easier and more reliable mechanism to
use a test dispatcher in unit tests. For regular app usage,
`WholphinDispatchers` just delegates to `Dispatchers`.

There are no user facing changes

### Related issues
None

### Testing
Basic emulator testing & unit tests

## Screenshots
N/A

## AI or LLM usage
None

app/src/main/java/com/github/damontecres/wholphin/services/BackdropService.kt

@@ -18,8 +18,8 @@ import com.github.damontecres.wholphin.data.model.BaseItem
 import com.github.damontecres.wholphin.data.model.DiscoverItem
 import com.github.damontecres.wholphin.preferences.AppPreferences
 import com.github.damontecres.wholphin.preferences.BackdropStyle
+import com.github.damontecres.wholphin.util.WholphinDispatchers
 import dagger.hilt.android.qualifiers.ApplicationContext
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.FlowPreview
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -55,7 +55,7 @@ class BackdropService
          * Update the backdrop to use the specified item
          */
         suspend fun submit(item: BaseItem) =
-            withContext(Dispatchers.IO) {
+            withContext(WholphinDispatchers.IO) {
                 val imageUrl =
                     if (item.type == BaseItemKind.GENRE) {
                         item.imageUrlOverride
@@ -76,7 +76,7 @@ class BackdropService
         suspend fun submit(
             itemId: String,
             imageUrl: String?,
-        ) = withContext(Dispatchers.IO) {
+        ) = withContext(WholphinDispatchers.IO) {
             if (backdropFlow.firstOrNull()?.imageUrl != imageUrl) {
                 _backdropFlow.update {
                     it.copy(
@@ -132,7 +132,7 @@ class BackdropService
         }
 
         suspend fun extractColorsFromBackdrop(imageUrl: String?): ExtractedColors =
-            withContext(Dispatchers.IO) {
+            withContext(WholphinDispatchers.IO) {
                 if (imageUrl.isNullOrBlank()) {
                     return@withContext ExtractedColors.DEFAULT
                 }

app/src/main/java/com/github/damontecres/wholphin/services/DatePlayedService.kt

@@ -9,12 +9,12 @@ import com.github.damontecres.wholphin.preferences.AppPreference
 import com.github.damontecres.wholphin.services.hilt.IoCoroutineScope
 import com.github.damontecres.wholphin.ui.collectLatestIn
 import com.github.damontecres.wholphin.util.GetEpisodesRequestHandler
+import com.github.damontecres.wholphin.util.WholphinDispatchers
 import com.google.common.cache.CacheBuilder
 import dagger.hilt.android.qualifiers.ActivityContext
 import dagger.hilt.android.scopes.ActivityScoped
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Deferred
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
 import kotlinx.coroutines.withContext
 import org.jellyfin.sdk.api.client.ApiClient
@@ -56,7 +56,7 @@ class DatePlayedService
                     adjacentTo = item.id,
                     limit = 1,
                 )
-            return scope.async(Dispatchers.IO) {
+            return scope.async(WholphinDispatchers.IO) {
                 val premiereDate = item.data.premiereDate
                 try {
                     val result =
@@ -92,7 +92,7 @@ class DatePlayedService
          * the previous episode's last played timestamp, and the episode's premiere date
          */
         suspend fun getLastPlayed(item: BaseItem): LocalDateTime? =
-            withContext(Dispatchers.IO) {
+            withContext(WholphinDispatchers.IO) {
                 val seriesId = item.data.seriesId
                 return@withContext if (seriesId != null) {
                     datePlayedCache

app/src/main/java/com/github/damontecres/wholphin/services/DeviceProfileService.kt

@@ -3,10 +3,10 @@ package com.github.damontecres.wholphin.services
 import android.content.Context
 import com.github.damontecres.wholphin.preferences.AssPlaybackMode
 import com.github.damontecres.wholphin.preferences.PlaybackPreferences
+import com.github.damontecres.wholphin.util.WholphinDispatchers
 import com.github.damontecres.wholphin.util.profile.MediaCodecCapabilitiesTest
 import com.github.damontecres.wholphin.util.profile.createDeviceProfile
 import dagger.hilt.android.qualifiers.ApplicationContext
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
@@ -37,7 +37,7 @@ class DeviceProfileService
             prefs: PlaybackPreferences,
             serverVersion: ServerVersion?,
         ): DeviceProfile =
-            withContext(Dispatchers.Default) {
+            withContext(WholphinDispatchers.Default) {
                 mutex.withLock {
                     val newConfig =
                         DeviceProfileConfiguration(

app/src/main/java/com/github/damontecres/wholphin/services/LatestNextUpService.kt

@@ -8,8 +8,8 @@ package com.github.damontecres.wholphin.services
 import com.github.damontecres.wholphin.data.model.BaseItem
 import com.github.damontecres.wholphin.ui.SlimItemFields
 import com.github.damontecres.wholphin.util.LocalDateTimeSerializer
+import com.github.damontecres.wholphin.util.WholphinDispatchers
 import com.github.damontecres.wholphin.util.supportItemKinds
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.sync.Semaphore
@@ -143,14 +143,14 @@ class LatestNextUpService
             resume: List<BaseItem>,
             nextUp: List<BaseItem>,
         ): List<BaseItem> =
-            withContext(Dispatchers.IO) {
+            withContext(WholphinDispatchers.IO) {
                 val start = System.currentTimeMillis()
                 val semaphore = Semaphore(3)
                 val deferred =
                     nextUp
                         .filter { it.data.seriesId != null }
                         .map { item ->
-                            async(Dispatchers.IO) {
+                            async(WholphinDispatchers.IO) {
                                 try {
                                     semaphore.withPermit {
                                         datePlayedService.getLastPlayed(item)

app/src/main/java/com/github/damontecres/wholphin/services/LatestNextUpWorker.kt

@@ -16,12 +16,12 @@ import androidx.work.workDataOf
 import com.github.damontecres.wholphin.data.ServerRepository
 import com.github.damontecres.wholphin.ui.collectLatestIn
 import com.github.damontecres.wholphin.util.ExceptionHandler
+import com.github.damontecres.wholphin.util.WholphinDispatchers
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import dagger.hilt.android.qualifiers.ActivityContext
 import dagger.hilt.android.scopes.ActivityScoped
 import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import org.jellyfin.sdk.api.client.ApiClient
 import org.jellyfin.sdk.model.serializer.toUUIDOrNull
@@ -92,7 +92,7 @@ class LatestNextUpSchedulerService
                 )
 
         // Exposed for testing
-        internal var dispatcher: CoroutineDispatcher = Dispatchers.IO
+        internal var dispatcher: CoroutineDispatcher = WholphinDispatchers.IO
 
         init {
             serverRepository.current.collectLatestIn(activity.lifecycleScope) { user ->

app/src/main/java/com/github/damontecres/wholphin/services/MusicService.kt

@@ -24,10 +24,10 @@ import com.github.damontecres.wholphin.util.BlockingList
 import com.github.damontecres.wholphin.util.LoadingState
 import com.github.damontecres.wholphin.util.PlaybackItemState
 import com.github.damontecres.wholphin.util.TrackActivityPlaybackListener
+import com.github.damontecres.wholphin.util.WholphinDispatchers
 import com.github.damontecres.wholphin.util.profile.supportedAudioCodecs
 import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -177,9 +177,9 @@ class MusicService
             items: BlockingList<BaseItem?>,
             startIndex: Int,
             shuffled: Boolean,
-        ) = withContext(Dispatchers.IO) {
+        ) = withContext(WholphinDispatchers.IO) {
             Timber.d("setQueue: %s items, startIndex=%s, shuffled=%s", items.size, startIndex, shuffled)
-            withContext(Dispatchers.Main) {
+            withContext(WholphinDispatchers.Main) {
                 player.setMediaItems(emptyList())
                 player.shuffleModeEnabled = shuffled
             }
@@ -199,7 +199,7 @@ class MusicService
                 items
                     .filter { it.type == BaseItemKind.AUDIO }
                     .map(::convert)
-            withContext(Dispatchers.Main) {
+            withContext(WholphinDispatchers.Main) {
                 player.setMediaItems(mediaItems)
                 player.shuffleModeEnabled = shuffled
                 updateQueueSize()
@@ -216,7 +216,7 @@ class MusicService
         ) {
             if (item.type == BaseItemKind.AUDIO) {
                 val mediaItem = convert(item)
-                withContext(Dispatchers.Main) {
+                withContext(WholphinDispatchers.Main) {
                     if (index != null) {
                         player.addMediaItem(index, mediaItem)
                     } else {
@@ -293,7 +293,7 @@ class MusicService
          */
         private suspend fun updateQueueSize() {
 //            val ids =
-//                withContext(Dispatchers.Default) {
+//                withContext(WholphinDispatchers.Default) {
 //                    (0..<player.mediaItemCount).map { player.getMediaItemAt(it).mediaId.toUUID() }
 //                }
             val timeline = onMain { player.currentTimeline }
@@ -304,7 +304,7 @@ class MusicService
                         timeline.getWindow(it, window)
                         window.mediaItem.mediaId.toUUID()
                     }.toSet()
-            withContext(Dispatchers.Main) {
+            withContext(WholphinDispatchers.Main) {
                 _state.update {
                     it.copy(
                         queueVersion = it.queueVersion + 1,
@@ -321,7 +321,7 @@ class MusicService
         suspend fun moveQueue(
             index: Int,
             direction: MoveDirection,
-        ) = withContext(Dispatchers.Main) {
+        ) = withContext(WholphinDispatchers.Main) {
             player.moveMediaItem(index, if (direction == MoveDirection.UP) index - 1 else index + 1)
             updateQueueSize()
         }
@@ -332,7 +332,7 @@ class MusicService
         suspend fun moveQueue(
             index: Int,
             newIndex: Int,
-        ) = withContext(Dispatchers.Main) {
+        ) = withContext(WholphinDispatchers.Main) {
             player.moveMediaItem(index, newIndex)
             updateQueueSize()
         }
@@ -385,7 +385,7 @@ class MusicService
                 .subscribe<PlaystateMessage>()
                 .onEach { message ->
                     message.data?.let {
-                        withContext(Dispatchers.Main) {
+                        withContext(WholphinDispatchers.Main) {
                             when (it.command) {
                                 PlaystateCommand.STOP -> {
                                     stop()

app/src/main/java/com/github/damontecres/wholphin/services/NavDrawerService.kt

@@ -13,11 +13,11 @@ import com.github.damontecres.wholphin.ui.nav.Destination
 import com.github.damontecres.wholphin.ui.nav.NavDrawerItem
 import com.github.damontecres.wholphin.ui.nav.ServerNavDrawerItem
 import com.github.damontecres.wholphin.ui.showToast
+import com.github.damontecres.wholphin.util.WholphinDispatchers
 import com.github.damontecres.wholphin.util.supportedCollectionTypes
 import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -209,7 +209,7 @@ class NavDrawerService
             val allItems = builtins + libraries
 
             val navDrawerPins =
-                withContext(Dispatchers.IO) {
+                withContext(WholphinDispatchers.IO) {
                     serverPreferencesDao.getNavDrawerPinnedItems(user).associateBy { it.itemId }
                 }
 

app/src/main/java/com/github/damontecres/wholphin/services/PlayerFactory.kt

@@ -29,6 +29,7 @@ import com.github.damontecres.wholphin.preferences.MediaExtensionStatus
 import com.github.damontecres.wholphin.preferences.PlaybackPreferences
 import com.github.damontecres.wholphin.preferences.PlayerBackend
 import com.github.damontecres.wholphin.services.hilt.AuthOkHttpClient
+import com.github.damontecres.wholphin.util.WholphinDispatchers
 import com.github.damontecres.wholphin.util.mpv.MpvPlayer
 import dagger.hilt.android.qualifiers.ApplicationContext
 import io.github.peerless2012.ass.media.AssHandler
@@ -36,7 +37,6 @@ import io.github.peerless2012.ass.media.factory.AssRenderersFactory
 import io.github.peerless2012.ass.media.kt.withAssMkvSupport
 import io.github.peerless2012.ass.media.parser.AssSubtitleParserFactory
 import io.github.peerless2012.ass.media.type.AssRenderType
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
 import timber.log.Timber
@@ -62,7 +62,7 @@ class PlayerFactory
             backend: PlayerBackend,
             prefs: PlaybackPreferences,
         ): PlayerCreation {
-            withContext(Dispatchers.Main) {
+            withContext(WholphinDispatchers.Main) {
                 if (currentPlayer?.isReleased == false) {
                     Timber.w("Player was not released before trying to create a new one!")
                     currentPlayer?.release()
@@ -138,7 +138,7 @@ class PlayerFactory
                             .build()
                             .apply {
                                 assHandler?.init(this)
-                                withContext(Dispatchers.Main) {
+                                withContext(WholphinDispatchers.Main) {
                                     setAudioAttributes(
                                         AudioAttributes
                                             .Builder()

app/src/main/java/com/github/damontecres/wholphin/services/RefreshRateService.kt

@@ -8,9 +8,9 @@ import android.os.Looper
 import android.view.Display
 import com.github.damontecres.wholphin.MainActivity
 import com.github.damontecres.wholphin.ui.showToast
+import com.github.damontecres.wholphin.util.WholphinDispatchers
 import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.CompletableDeferred
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeoutOrNull
@@ -38,7 +38,7 @@ class RefreshRateService
             stream: MediaStream,
             switchRefreshRate: Boolean,
             switchResolution: Boolean,
-        ) = withContext(Dispatchers.IO) {
+        ) = withContext(WholphinDispatchers.IO) {
             if (!switchRefreshRate && !switchResolution) {
                 Timber.v("Not switching either refresh rate nor resolution")
                 return@withContext

app/src/main/java/com/github/damontecres/wholphin/services/RememberedTabService.kt

@@ -3,7 +3,7 @@ package com.github.damontecres.wholphin.services
 import com.github.damontecres.wholphin.data.RememberedTabDao
 import com.github.damontecres.wholphin.data.ServerRepository
 import com.github.damontecres.wholphin.data.model.RememberedTab
-import kotlinx.coroutines.Dispatchers
+import com.github.damontecres.wholphin.util.WholphinDispatchers
 import kotlinx.coroutines.withContext
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -16,7 +16,7 @@ class RememberedTabService
         private val rememberedTabDao: RememberedTabDao,
     ) {
         suspend fun getRememberedTab(itemId: String): Int? =
-            withContext(Dispatchers.IO) {
+            withContext(WholphinDispatchers.IO) {
                 serverRepository.currentUser?.rowId?.let { userId ->
                     rememberedTabDao.getRememberedTab(userId, itemId)?.index
                 }
@@ -26,7 +26,7 @@ class RememberedTabService
             itemId: String,
             tabIndex: Int,
         ): Unit =
-            withContext(Dispatchers.IO) {
+            withContext(WholphinDispatchers.IO) {
                 serverRepository.currentUser?.rowId?.let { userId ->
                     rememberedTabDao.save(RememberedTab(userId, itemId, tabIndex))
                 }

app/src/main/java/com/github/damontecres/wholphin/services/ScreensaverService.kt

@@ -10,10 +10,10 @@ import com.github.damontecres.wholphin.ui.launchDefault
 import com.github.damontecres.wholphin.util.ApiRequestPager
 import com.github.damontecres.wholphin.util.ExceptionHandler
 import com.github.damontecres.wholphin.util.GetItemsRequestHandler
+import com.github.damontecres.wholphin.util.WholphinDispatchers
 import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
@@ -224,7 +224,7 @@ class ScreensaverService
                         if (index > pager.lastIndex) index = 0
                     }
                 }
-            }.flowOn(Dispatchers.Default).cancellable()
+            }.flowOn(WholphinDispatchers.Default).cancellable()
 
         private suspend fun createPager(): ApiRequestPager<GetItemsRequest> {
             val prefs =

app/src/main/java/com/github/damontecres/wholphin/services/SuggestionsCache.kt

@@ -4,11 +4,11 @@ package com.github.damontecres.wholphin.services
 
 import android.content.Context
 import com.github.damontecres.wholphin.ui.toServerString
+import com.github.damontecres.wholphin.util.WholphinDispatchers
 import com.mayakapps.kache.InMemoryKache
 import com.mayakapps.kache.ObjectKache
 import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.serialization.ExperimentalSerializationApi
@@ -43,7 +43,7 @@ class SuggestionsCache
 
         private val memoryCache =
             InMemoryKache<String, CachedSuggestions>(maxSize = 8) {
-                creationScope = CoroutineScope(Dispatchers.IO)
+                creationScope = CoroutineScope(WholphinDispatchers.IO)
             }
 
         private fun cacheKey(

app/src/main/java/com/github/damontecres/wholphin/services/SuggestionsWorker.kt

@@ -9,9 +9,9 @@ import com.github.damontecres.wholphin.data.ServerRepository
 import com.github.damontecres.wholphin.preferences.AppPreference
 import com.github.damontecres.wholphin.preferences.AppPreferences
 import com.github.damontecres.wholphin.util.GetItemsRequestHandler
+import com.github.damontecres.wholphin.util.WholphinDispatchers
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.coroutineScope
@@ -81,7 +81,7 @@ class SuggestionsWorker
                         .takeIf { it > 0 }
                         ?: AppPreference.HomePageItems.defaultValue.toInt()
 
-                val context = Dispatchers.IO.limitedParallelism(2, "fetchSuggestions")
+                val context = WholphinDispatchers.IO.limitedParallelism(2, "fetchSuggestions")
                 if (requestedParentId != null && requestedItemKind != null) {
                     Timber.d(
                         "Fetching on-demand suggestions for parent=%s kind=%s",
@@ -128,7 +128,7 @@ class SuggestionsWorker
                     supervisorScope {
                         supportedViews
                             .map { view ->
-                                async(Dispatchers.IO) {
+                                async(WholphinDispatchers.IO) {
                                     runCatching {
                                         Timber.v("Fetching suggestions for parent=%s kind=%s", view.id, view.itemKind)
                                         fetchAndCacheSuggestions(
@@ -293,7 +293,7 @@ class SuggestionsWorker
                             limit = freshLimit,
                         )
                     }
-                withContext(Dispatchers.Default) {
+                withContext(WholphinDispatchers.Default) {
                     val contextual = contextualDeferred.await()
                     val random = randomDeferred.await()
                     val fresh = freshDeferred.await()

app/src/main/java/com/github/damontecres/wholphin/services/ThemeSongPlayer.kt

@@ -14,10 +14,10 @@ import com.github.damontecres.wholphin.preferences.ThemeSongVolume
 import com.github.damontecres.wholphin.services.hilt.AuthOkHttpClient
 import com.github.damontecres.wholphin.services.hilt.IoCoroutineScope
 import com.github.damontecres.wholphin.ui.launchIO
+import com.github.damontecres.wholphin.util.WholphinDispatchers
 import com.github.damontecres.wholphin.util.profile.Codec
 import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.cancelAndJoin
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -102,7 +102,7 @@ class ThemeSongPlayer
                                                 Codec.Audio.FLAC,
                                             ),
                                     )
-                                withContext(Dispatchers.Main) {
+                                withContext(WholphinDispatchers.Main) {
                                     player.apply {
                                         stop()
                                         volume = volumeLevel
@@ -127,7 +127,7 @@ class ThemeSongPlayer
             scope.launch {
                 mutex.withLock {
                     state.value.job?.cancelAndJoin()
-                    withContext(Dispatchers.Main) {
+                    withContext(WholphinDispatchers.Main) {
                         Timber.v("Stopping theme song")
                         player.stop()
                     }

app/src/main/java/com/github/damontecres/wholphin/services/UpdateChecker.kt

@@ -21,8 +21,8 @@ import com.github.damontecres.wholphin.services.hilt.StandardOkHttpClient
 import com.github.damontecres.wholphin.ui.isNotNullOrBlank
 import com.github.damontecres.wholphin.ui.showToast
 import com.github.damontecres.wholphin.util.Version
+import com.github.damontecres.wholphin.util.WholphinDispatchers
 import dagger.hilt.android.qualifiers.ApplicationContext
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
@@ -131,7 +131,7 @@ class UpdateChecker
         suspend fun getRelease(version: Version): Release? {
             val url =
                 "https://api.github.com/repos/damontecres/Wholphin/releases/tags/v${version.major}.${version.minor}.${version.patch}"
-            return withContext(Dispatchers.IO) {
+            return withContext(WholphinDispatchers.IO) {
                 val request =
                     Request
                         .Builder()
@@ -146,7 +146,7 @@ class UpdateChecker
          * Get the latest released version
          */
         suspend fun getLatestRelease(updateUrl: String): Release? =
-            withContext(Dispatchers.IO) {
+            withContext(WholphinDispatchers.IO) {
                 val request =
                     Request
                         .Builder()
@@ -199,7 +199,7 @@ class UpdateChecker
             release: Release,
             callback: DownloadCallback,
         ) {
-            withContext(Dispatchers.IO) {
+            withContext(WholphinDispatchers.IO) {
                 cleanup()
                 val request =
                     Request
@@ -210,7 +210,7 @@ class UpdateChecker
                 okHttpClient.newCall(request).execute().use {
                     if (it.isSuccessful && it.body != null) {
                         Timber.v("Request successful for ${release.downloadUrl}")
-                        withContext(Dispatchers.Main) {
+                        withContext(WholphinDispatchers.Main) {
                             callback.contentLength(it.body.contentLength())
                         }
                         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
@@ -396,7 +396,7 @@ suspend fun copyTo(
     while (bytes >= 0) {
         out.write(buffer, 0, bytes)
         bytesCopied += bytes
-        withContext(Dispatchers.Main) {
+        withContext(WholphinDispatchers.Main) {
             callback.bytesDownloaded(bytesCopied)
         }
         bytes = input.read(buffer)

app/src/main/java/com/github/damontecres/wholphin/services/UserSwitchListener.kt

@@ -12,9 +12,9 @@ import com.github.damontecres.wholphin.data.model.JellyfinUser
 import com.github.damontecres.wholphin.data.model.SeerrAuthMethod
 import com.github.damontecres.wholphin.ui.launchDefault
 import com.github.damontecres.wholphin.ui.launchIO
+import com.github.damontecres.wholphin.util.WholphinDispatchers
 import dagger.hilt.android.qualifiers.ActivityContext
 import dagger.hilt.android.scopes.ActivityScoped
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.supervisorScope
 import kotlinx.coroutines.withContext
@@ -56,7 +56,7 @@ class UserSwitchListener
                     user.uiLanguage?.let { LocaleListCompat.forLanguageTags(it) }
                         ?: LocaleListCompat.getEmptyLocaleList()
                 Timber.i("Switching locale to %s", localeList)
-                withContext(Dispatchers.Main) {
+                withContext(WholphinDispatchers.Main) {
                     AppCompatDelegate.setApplicationLocales(localeList)
                 }
 

app/src/main/java/com/github/damontecres/wholphin/services/hilt/AppModule.kt

@@ -7,6 +7,7 @@ import com.github.damontecres.wholphin.R
 import com.github.damontecres.wholphin.data.ServerRepository
 import com.github.damontecres.wholphin.services.SeerrApi
 import com.github.damontecres.wholphin.util.CoroutineContextApiClientFactory
+import com.github.damontecres.wholphin.util.WholphinDispatchers
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@@ -14,7 +15,6 @@ import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import okhttp3.OkHttpClient
 import org.jellyfin.sdk.Jellyfin
@@ -42,21 +42,21 @@ annotation class AuthOkHttpClient
 annotation class StandardOkHttpClient
 
 /**
- * A [CoroutineScope] with [Dispatchers.IO]
+ * A [CoroutineScope] with [WholphinDispatchers.IO]
  */
 @Qualifier
 @Retention(AnnotationRetention.BINARY)
 annotation class IoCoroutineScope
 
 /**
- * A [CoroutineScope] with [Dispatchers.Default]
+ * A [CoroutineScope] with [WholphinDispatchers.Default]
  */
 @Qualifier
 @Retention(AnnotationRetention.BINARY)
 annotation class DefaultCoroutineScope
 
 /**
- * [Dispatchers.IO]
+ * [WholphinDispatchers.IO]
  *
  * @see IoCoroutineScope
  */
@@ -65,7 +65,7 @@ annotation class DefaultCoroutineScope
 annotation class IoDispatcher
 
 /**
- * [Dispatchers.Default]
+ * [WholphinDispatchers.Default]
  *
  * @see DefaultCoroutineScope
  */
@@ -156,7 +156,7 @@ object AppModule {
     @Provides
     @Singleton
     @IoDispatcher
-    fun ioDispatcher(): CoroutineDispatcher = Dispatchers.IO
+    fun ioDispatcher(): CoroutineDispatcher = WholphinDispatchers.IO
 
     @Provides
     @Singleton
@@ -168,7 +168,7 @@ object AppModule {
     @Provides
     @Singleton
     @DefaultDispatcher
-    fun defaultDispatcher(): CoroutineDispatcher = Dispatchers.Default
+    fun defaultDispatcher(): CoroutineDispatcher = WholphinDispatchers.Default
 
     @Provides
     @Singleton

app/src/main/java/com/github/damontecres/wholphin/services/hilt/DatabaseModule.kt

@@ -44,7 +44,7 @@ object DatabaseModule {
             ).addMigrations(Migrations.Migrate2to3)
 //            .setQueryCallback({ sqlQuery, args ->
 //                Timber.v("sqlQuery=$sqlQuery, args=$args")
-//            }, Dispatchers.IO.asExecutor())
+//            }, WholphinDispatchers.IO.asExecutor())
             .build()
 
     @Provides