From 638dba770d1a896717ae020079a5e2b8975ea25c Mon Sep 17 00:00:00 2001 From: Vitor Pamplona Date: Tue, 2 Apr 2024 17:49:52 -0400 Subject: [PATCH] Moves the creation of Draft Notes to the IO Thread --- .../amethyst/ui/note/NoteCompose.kt | 12 +-- .../ui/screen/loggedIn/AccountViewModel.kt | 19 +++- .../commons/compose/AsyncCachedState.kt | 88 +++++++++++++++++++ 3 files changed, 106 insertions(+), 13 deletions(-) create mode 100644 commons/src/main/java/com/vitorpamplona/amethyst/commons/compose/AsyncCachedState.kt diff --git a/app/src/main/java/com/vitorpamplona/amethyst/ui/note/NoteCompose.kt b/app/src/main/java/com/vitorpamplona/amethyst/ui/note/NoteCompose.kt index 87c54364a..6d5c42ce8 100644 --- a/app/src/main/java/com/vitorpamplona/amethyst/ui/note/NoteCompose.kt +++ b/app/src/main/java/com/vitorpamplona/amethyst/ui/note/NoteCompose.kt @@ -39,7 +39,6 @@ import androidx.compose.runtime.derivedStateOf import androidx.compose.runtime.getValue import androidx.compose.runtime.livedata.observeAsState import androidx.compose.runtime.mutableStateOf -import androidx.compose.runtime.produceState import androidx.compose.runtime.remember import androidx.compose.runtime.rememberCoroutineScope import androidx.compose.ui.Alignment @@ -54,6 +53,7 @@ import androidx.compose.ui.unit.dp import androidx.lifecycle.distinctUntilChanged import androidx.lifecycle.map import com.vitorpamplona.amethyst.R +import com.vitorpamplona.amethyst.commons.compose.produceCachedStateAsync import com.vitorpamplona.amethyst.model.Channel import com.vitorpamplona.amethyst.model.FeatureSetType import com.vitorpamplona.amethyst.model.Note @@ -724,16 +724,8 @@ fun ObserveDraftEvent( val noteState by note.live().metadata.observeAsState() val noteEvent = noteState?.note?.event as? DraftEvent ?: return - val noteAuthor = noteState?.note?.author ?: return - val innerNote = - produceState(initialValue = accountViewModel.createTempCachedDraftNote(noteEvent, noteAuthor), noteEvent.id) { - if (value == null || value?.event?.id() != noteEvent.id) { - accountViewModel.createTempDraftNote(noteEvent, noteAuthor) { - value = it - } - } - } + val innerNote = produceCachedStateAsync(cache = accountViewModel.draftNoteCache, key = noteEvent) innerNote.value?.let { render(it) diff --git a/app/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/AccountViewModel.kt b/app/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/AccountViewModel.kt index 3ea6d101a..427bc3a91 100644 --- a/app/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/AccountViewModel.kt +++ b/app/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/AccountViewModel.kt @@ -38,6 +38,7 @@ import coil.request.ImageRequest import com.vitorpamplona.amethyst.R import com.vitorpamplona.amethyst.ServiceManager import com.vitorpamplona.amethyst.commons.compose.GenericBaseCache +import com.vitorpamplona.amethyst.commons.compose.GenericBaseCacheAsync import com.vitorpamplona.amethyst.model.Account import com.vitorpamplona.amethyst.model.AccountState import com.vitorpamplona.amethyst.model.AddressableNote @@ -1335,9 +1336,6 @@ class AccountViewModel(val account: Account, val settings: SettingsState) : View onReady: (Note) -> Unit, ) { viewModelScope.launch(Dispatchers.IO) { - noteEvent.cachedDraft(account.signer) { - onReady(createTempDraftNote(it, author)) - } } } @@ -1355,6 +1353,21 @@ class AccountViewModel(val account: Account, val settings: SettingsState) : View return note } + val draftNoteCache = CachedDraftNotes(this) + + class CachedDraftNotes(val accountViewModel: AccountViewModel) : GenericBaseCacheAsync(20) { + override suspend fun compute( + key: DraftEvent, + onReady: (Note?) -> Unit, + ) = withContext(Dispatchers.IO) { + key.cachedDraft(accountViewModel.account.signer) { + val author = LocalCache.getOrCreateUser(key.pubKey) + val note = accountViewModel.createTempDraftNote(it, author) + onReady(note) + } + } + } + val bechLinkCache = CachedLoadedBechLink(this) class CachedLoadedBechLink(val accountViewModel: AccountViewModel) : GenericBaseCache(20) { diff --git a/commons/src/main/java/com/vitorpamplona/amethyst/commons/compose/AsyncCachedState.kt b/commons/src/main/java/com/vitorpamplona/amethyst/commons/compose/AsyncCachedState.kt new file mode 100644 index 000000000..87710c5b0 --- /dev/null +++ b/commons/src/main/java/com/vitorpamplona/amethyst/commons/compose/AsyncCachedState.kt @@ -0,0 +1,88 @@ +/** + * Copyright (c) 2024 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.amethyst.commons.compose + +import android.util.LruCache +import androidx.compose.runtime.Composable +import androidx.compose.runtime.State +import androidx.compose.runtime.produceState + +@Composable +fun produceCachedStateAsync( + cache: AsyncCachedState, + key: K, +): State { + return produceState(initialValue = cache.cached(key), key1 = key) { + cache.update(key) { + value = it + } + } +} + +@Composable +fun produceCachedStateAsync( + cache: AsyncCachedState, + key: String, + updateValue: K, +): State { + return produceState(initialValue = cache.cached(updateValue), key1 = key) { + cache.update(updateValue) { + value = it + } + } +} + +interface AsyncCachedState { + fun cached(k: K): V? + + suspend fun update( + k: K, + onReady: (V?) -> Unit, + ) +} + +abstract class GenericBaseCacheAsync(capacity: Int) : AsyncCachedState { + private val cache = LruCache(capacity) + + override fun cached(k: K): V? { + return cache[k] + } + + override suspend fun update( + k: K, + onReady: (V?) -> Unit, + ) { + cache[k]?.let { onReady(it) } + + compute(k) { + if (it != null) { + cache.put(k, it) + } + + onReady(it) + } + } + + abstract suspend fun compute( + key: K, + onReady: (V?) -> Unit, + ) +}