fix tab not being refresh after login

Tlaster · Tlaster · commit 2e8b089a42b6 · 2025-09-18T20:10:26.000+09:00
diff --git a/compose-ui/src/commonMain/kotlin/dev/dimension/flare/ui/presenter/HomeTabsPresenter.kt b/compose-ui/src/commonMain/kotlin/dev/dimension/flare/ui/presenter/HomeTabsPresenter.kt
@@ -21,9 +21,7 @@ import dev.dimension.flare.ui.presenter.home.NotificationBadgePresenter
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.persistentListOf
 import kotlinx.collections.immutable.toImmutableList
-import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.distinctUntilChangedBy
 import org.koin.core.component.KoinComponent
 import org.koin.core.component.inject
@@ -58,56 +56,56 @@ public class HomeTabsPresenter :
 
     private val settingsRepository by inject<SettingsRepository>()
     private val accountRepository by inject<AccountRepository>()
-    private val activeAccountFlow by lazy {
-        combine(
-            activeAccountFlow(accountRepository),
-            settingsRepository.tabSettings.distinctUntilChangedBy { it.secondaryItems },
-        ) { account, tabsState ->
-            println("Active account changed: $account, tabsState: $tabsState")
-            val secondary =
-                tabsState.secondaryItems ?: TimelineTabItem.defaultSecondary(account)
-            State.HomeTabState(
-                primary =
-                    TimelineTabItem.default
-                        .map {
-                            HomeTabItem(it)
-                        }.toImmutableList(),
-                secondary =
-                    secondary
-                        .map {
-                            HomeTabItem(it)
-                        }.toImmutableList(),
-                extraProfileRoute =
-                    HomeTabItem(
-                        tabItem =
-                            ProfileTabItem(
-                                accountKey = account.accountKey,
-                                userKey = account.accountKey,
+    private val tabsFlow by lazy {
+        activeAccountFlow(accountRepository)
+            .combine(
+                settingsRepository.tabSettings.distinctUntilChangedBy { it.secondaryItems },
+            ) { account, tabsState ->
+                println("Active account changed: $account, tabsState: $tabsState")
+                if (account == null) {
+                    State.HomeTabState(
+                        primary =
+                            TimelineTabItem.guest
+                                .map {
+                                    HomeTabItem(it)
+                                }.toImmutableList(),
+                        secondary = persistentListOf(),
+                        extraProfileRoute = null,
+                        secondaryIconOnly = true,
+                    )
+                } else {
+                    val secondary =
+                        tabsState.secondaryItems ?: TimelineTabItem.defaultSecondary(account)
+                    State.HomeTabState(
+                        primary =
+                            TimelineTabItem.default
+                                .map {
+                                    HomeTabItem(it)
+                                }.toImmutableList(),
+                        secondary =
+                            secondary
+                                .map {
+                                    HomeTabItem(it)
+                                }.toImmutableList(),
+                        extraProfileRoute =
+                            HomeTabItem(
+                                tabItem =
+                                    ProfileTabItem(
+                                        accountKey = account.accountKey,
+                                        userKey = account.accountKey,
+                                    ),
                             ),
-                    ),
-                secondaryIconOnly = tabsState.secondaryItems == null,
-            )
-        }.catch {
-            emit(
-                State.HomeTabState(
-                    primary =
-                        TimelineTabItem.guest
-                            .map {
-                                HomeTabItem(it)
-                            }.toImmutableList(),
-                    secondary = persistentListOf(),
-                    extraProfileRoute = null,
-                    secondaryIconOnly = true,
-                ),
-            )
-        }.distinctUntilChanged()
+                        secondaryIconOnly = tabsState.secondaryItems == null,
+                    )
+                }
+            }
     }
 
     @Composable
     override fun body(): State {
         val tabs =
-            remember(activeAccountFlow) {
-                activeAccountFlow
+            remember(tabsFlow) {
+                tabsFlow
             }.collectAsUiState().value.map {
                 it.copy(
                     primary =
diff --git a/compose-ui/src/commonMain/kotlin/dev/dimension/flare/ui/presenter/HomeTimelineWithTabsPresenter.kt b/compose-ui/src/commonMain/kotlin/dev/dimension/flare/ui/presenter/HomeTimelineWithTabsPresenter.kt
@@ -19,7 +19,6 @@ import dev.dimension.flare.ui.presenter.home.UserState
 import dev.dimension.flare.ui.presenter.settings.AccountEventPresenter
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.toImmutableList
-import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.distinctUntilChangedBy
 import kotlinx.coroutines.flow.map
 import org.koin.core.component.KoinComponent
@@ -35,6 +34,10 @@ public class HomeTimelineWithTabsPresenter(
         public val tabState: UiState<ImmutableList<TimelineTabItem>>
     }
 
+    init {
+        println("HomeTimelineWithTabsPresenter: accountType=$accountType")
+    }
+
     private val tabsState by lazy {
         settingsRepository.tabSettings
             .distinctUntilChangedBy { it.mainTabs + it.enableMixedTimeline }
@@ -62,8 +65,7 @@ public class HomeTimelineWithTabsPresenter(
                         )
                     }
                 }
-            }.distinctUntilChanged()
-            .map {
+            }.map {
                 it.toImmutableList()
             }
     }
@@ -143,10 +145,8 @@ public class HomeTimelineWithTabsPresenter(
 //                    }.toImmutableList()
 //            }
 
-        return remember(accountState, tabs) {
-            object : State, UserState by accountState {
-                override val tabState = tabs
-            }
+        return object : State, UserState by accountState {
+            override val tabState = tabs
         }
     }
 }
diff --git a/desktopApp/src/main/kotlin/dev/dimension/flare/App.kt b/desktopApp/src/main/kotlin/dev/dimension/flare/App.kt
@@ -83,7 +83,6 @@ import io.github.composefluent.component.Icon
 import io.github.composefluent.component.NavigationDefaults
 import io.github.composefluent.component.SubtleButton
 import io.github.composefluent.component.Text
-import io.ktor.http.Url
 import kotlinx.coroutines.launch
 import moe.tlaster.precompose.molecule.producePresenter
 import org.apache.commons.lang3.SystemUtils
@@ -98,7 +97,7 @@ internal fun WindowScope.FlareApp(onWindowRoute: (Route.WindowRoute) -> Unit) {
         val stackManager =
             rememberStackManager(
                 startRoute = getRoute(tabs.primary.first().tabItem),
-                key = tabs.all.size,
+                key = tabs.all.joinToString { it.tabItem.key },
                 topLevelRoutes = tabs.all.map { getRoute(it.tabItem) },
             )
 
@@ -425,8 +424,6 @@ private class ProxyUriHandler(
 ) : UriHandler {
     override fun openUri(uri: String) {
         if (uri.startsWith("flare://")) {
-            val data = Url(uri)
-
             Route.parse(uri)?.let {
                 if (it is Route.WindowRoute) {
                     onWindowRoute.invoke(it)
diff --git a/shared/src/commonMain/kotlin/dev/dimension/flare/data/repository/AccountRepository.kt b/shared/src/commonMain/kotlin/dev/dimension/flare/data/repository/AccountRepository.kt
@@ -222,11 +222,11 @@ internal fun accountServiceFlow(
         }
     }
 
-public fun activeAccountFlow(repository: AccountRepository): Flow<UiAccount> =
+public fun activeAccountFlow(repository: AccountRepository): Flow<UiAccount?> =
     repository
         .activeAccount
-        .map { it.takeSuccess() ?: throw NoActiveAccountException }
-        .distinctUntilChangedBy { it.accountKey }
+        .map { it.takeSuccess() }
+        .distinctUntilChangedBy { it?.accountKey }
 
 @Composable
 internal fun allAccountsPresenter(repository: AccountRepository): State<UiState<ImmutableList<UiAccount>>> =

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,6 @@ import dev.dimension.flare.ui.presenter.home.UserState`
`19`	`19`	`import dev.dimension.flare.ui.presenter.settings.AccountEventPresenter`
`20`	`20`	`import kotlinx.collections.immutable.ImmutableList`
`21`	`21`	`import kotlinx.collections.immutable.toImmutableList`
`22`		`-import kotlinx.coroutines.flow.distinctUntilChanged`
`23`	`22`	`import kotlinx.coroutines.flow.distinctUntilChangedBy`
`24`	`23`	`import kotlinx.coroutines.flow.map`
`25`	`24`	`import org.koin.core.component.KoinComponent`
`@@ -35,6 +34,10 @@ public class HomeTimelineWithTabsPresenter(`
`35`	`34`	`public val tabState: UiState<ImmutableList<TimelineTabItem>>`
`36`	`35`	`}`
`37`	`36`
	`37`	`+ init {`
	`38`	`+ println("HomeTimelineWithTabsPresenter: accountType=$accountType")`
	`39`	`+ }`
	`40`	`+`
`38`	`41`	`private val tabsState by lazy {`
`39`	`42`	`settingsRepository.tabSettings`
`40`	`43`	`.distinctUntilChangedBy { it.mainTabs + it.enableMixedTimeline }`
`@@ -62,8 +65,7 @@ public class HomeTimelineWithTabsPresenter(`
`62`	`65`	`)`
`63`	`66`	`}`
`64`	`67`	`}`
`65`		`- }.distinctUntilChanged()`
`66`		`- .map {`
	`68`	`+ }.map {`
`67`	`69`	`it.toImmutableList()`
`68`	`70`	`}`
`69`	`71`	`}`
`@@ -143,10 +145,8 @@ public class HomeTimelineWithTabsPresenter(`
`143`	`145`	`// }.toImmutableList()`
`144`	`146`	`// }`
`145`	`147`
`146`		`- return remember(accountState, tabs) {`
`147`		`- object : State, UserState by accountState {`
`148`		`- override val tabState = tabs`
`149`		`- }`
	`148`	`+ return object : State, UserState by accountState {`
	`149`	`+ override val tabState = tabs`
`150`	`150`	`}`
`151`	`151`	`}`
`152`	`152`	`}`
Original file line number	Diff line number	Diff line change
`@@ -222,11 +222,11 @@ internal fun accountServiceFlow(`
`222`	`222`	`}`
`223`	`223`	`}`
`224`	`224`
`225`		`-public fun activeAccountFlow(repository: AccountRepository): Flow<UiAccount> =`
	`225`	`+public fun activeAccountFlow(repository: AccountRepository): Flow<UiAccount?> =`
`226`	`226`	`repository`
`227`	`227`	`.activeAccount`
`228`		`- .map { it.takeSuccess() ?: throw NoActiveAccountException }`
`229`		`- .distinctUntilChangedBy { it.accountKey }`
	`228`	`+ .map { it.takeSuccess() }`
	`229`	`+ .distinctUntilChangedBy { it?.accountKey }`
`230`	`230`
`231`	`231`	`@Composable`
`232`	`232`	`internal fun allAccountsPresenter(repository: AccountRepository): State<UiState<ImmutableList<UiAccount>>> =`