`NavigationStackPlayground` infinitely recomposes

[dfabulich]

The Showcase NavigationStackPlayground infinitely recomposes.

[dfabulich]

git bisect turned up #418 as the culprit.

[dfabulich]

My logging indicates that the problem is here:

skip-ui/Sources/SkipUI/SkipUI/Environment/PreferenceKey.swift

Line 177 in 2f7c8e2

if (state.value as Any?) == nil {

By reading the state at this point, we're effectively declaring a dependency on that state. When child preferences contribute changes to the state, we should recompose the content of the nav entry, but, instead, we're recomposing the nav entry itself, triggering side effects that write the preferences over again, in an infinite loop.

I'm… not exactly sure what to do about this. Ideally, I'd like to fix #300 / #417 in another way, but that's easier said than done, considering that we don't have a repro…

[dfabulich]

I have a repro for #300 now! … but my repro requires Compose Testing skiptools/skipapp-showcase#83

(And, of course, it requires removing SideEffect { saveableStateHolder.removeState(true) } from Main.kt.)

`PreferencePlayground.swift`

PreferencePlayground.swift

// Copyright 2023–2025 Skip
import SwiftUI

struct PreferencePlayground: View {
    @State private var path: [PreferencePlaygroundRoute] = []

    var body: some View {
        NavigationStack(path: $path) {
            PreferencePlaygroundRootView(path: $path)
                .navigationDestination(for: PreferencePlaygroundRoute.self) { route in
                    PreferencePlaygroundDetailView(route: route, path: $path)
                }
        }
        .toolbar {
            PlaygroundSourceLink(file: "PreferencePlayground.swift")
        }
    }
}

private enum PreferencePlaygroundRoute: String, Hashable, CaseIterable {
    case alpha
    case beta
}

/// Non-primitive preference payload so contributed values and collected `Preference<…>` state
/// round-trip through `ComposeStateSaver`'s in-memory key map (not the Bundle directly).
struct PreferencePlaygroundPayload: Equatable {
    var revision: Int
    var tags: [String]
    var attributes: [String: Int]

    static let empty = PreferencePlaygroundPayload(revision: 0, tags: [], attributes: [:])

    static func sample(revision: Int, tag: String) -> PreferencePlaygroundPayload {
        PreferencePlaygroundPayload(
            revision: revision,
            tags: [tag, "layer-\(revision)"],
            attributes: ["count": revision, "hash": tag.hashValue]
        )
    }
}

struct PreferencePlaygroundCustomKey: PreferenceKey {
    static let defaultValue = PreferencePlaygroundPayload.empty

    static func reduce(value: inout PreferencePlaygroundPayload, nextValue: () -> PreferencePlaygroundPayload) {
        value = nextValue()
    }
}

private struct PreferencePlaygroundRootView: View {
    @Binding var path: [PreferencePlaygroundRoute]

    var body: some View {
        VStack(spacing: 16) {
            PreferencePlaygroundCustomKeyDisplayView(label: "Root reader", incrementing: false)
            Divider()
            PreferencePlaygroundCustomKeyDisplayView(label: "Root reader (with contributor)", incrementing: true)
            Divider()
            ForEach(PreferencePlaygroundRoute.allCases, id: \.self) { route in
                NavigationLink(value: route) {
                    Text("Push \(route.rawValue)")
                }
            }
            if !path.isEmpty {
                Text("Path depth: \(path.count)")
                    .font(.caption)
                    .foregroundStyle(.secondary)
            }
        }
        .padding()
        .navigationTitle("Preference")
        .preference(
            key: PreferencePlaygroundCustomKey.self,
            value: PreferencePlaygroundPayload.sample(revision: path.count, tag: "root")
        )
    }
}

private struct PreferencePlaygroundDetailView: View {
    let route: PreferencePlaygroundRoute
    @Binding var path: [PreferencePlaygroundRoute]
    @State private var localRevision = 0

    var body: some View {
        VStack(spacing: 16) {
            Text("Route: \(route.rawValue)")
            PreferencePlaygroundCustomKeyDisplayView(label: "Detail reader", incrementing: true)
            Button("Bump local payload") {
                localRevision += 1
            }
            if path.count > 1 {
                Button("Pop to root") {
                    path.removeAll()
                }
            }
        }
        .padding()
        .navigationTitle("Detail \(route.rawValue)")
        .preference(
            key: PreferencePlaygroundCustomKey.self,
            value: PreferencePlaygroundPayload.sample(revision: localRevision, tag: route.rawValue)
        )
    }
}

struct PreferencePlaygroundCustomKeyDisplayView: View {
    let label: String
    let incrementing: Bool
    @State private var value = PreferencePlaygroundPayload.empty

    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            Text(label)
                .font(.headline)
            Text("revision: \(value.revision)")
            Text("tags: \(value.tags.joined(separator: ", "))")
            Text("attributes: \(formatAttributes(value.attributes))")
                .font(.caption.monospaced())
            if incrementing {
                PreferencePlaygroundCustomKeyIncrementView()
            }
        }
        .frame(maxWidth: .infinity, alignment: .leading)
        .onPreferenceChange(PreferencePlaygroundCustomKey.self) {
            logger.info("Preference changed: revision=\($0.revision) tags=\($0.tags)")
            value = $0
        }
    }

    private func formatAttributes(_ attributes: [String: Int]) -> String {
        attributes.keys.sorted().map { key in
            "\(key)=\(attributes[key] ?? 0)"
        }.joined(separator: ", ")
    }
}

struct PreferencePlaygroundCustomKeyIncrementView: View {
    @State private var count = 0

    var body: some View {
        Button("Increment contributor") {
            count += 1
        }
        .preference(
            key: PreferencePlaygroundCustomKey.self,
            value: PreferencePlaygroundPayload.sample(revision: count, tag: "increment")
        )
    }
}

`PreferencePlaygroundSaveableStateInstrumentedTest.kt`

PreferencePlaygroundSaveableStateInstrumentedTest.kt

package showcase.module

import android.content.Context
import android.content.res.Configuration
import android.os.Bundle
import android.os.SystemClock
import android.util.Log
import androidx.compose.ui.test.hasAnyAncestor
import androidx.compose.ui.test.hasClickAction
import androidx.compose.ui.test.hasContentDescription
import androidx.compose.ui.test.hasTestTag
import androidx.compose.ui.test.hasText
import androidx.compose.ui.test.junit4.createAndroidComposeRule
import androidx.compose.ui.test.onNodeWithTag
import androidx.compose.ui.test.onNodeWithText
import androidx.compose.ui.test.performClick
import androidx.compose.ui.test.performTextReplacement
import androidx.lifecycle.Lifecycle
import androidx.test.espresso.IdlingPolicies
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.uiautomator.By
import androidx.test.uiautomator.UiDevice
import androidx.test.uiautomator.Until
import java.util.concurrent.TimeUnit
import org.junit.BeforeClass
import org.junit.Rule
import org.junit.Test
import org.junit.rules.RuleChain
import org.junit.rules.TestWatcher
import org.junit.runner.Description
import org.junit.runner.RunWith

/**
 * Exercises skip-ui #300 / #417: NPE when `rememberSaveable` restores a `Preference<…>` whose
 * `ComposeStateSaver` in-memory map was lost across Activity recreation.
 *
 * **With** `SideEffect { saveableStateHolder.removeState(true) }` in [Main.kt] (Showcase default),
 * these tests should **pass**: recreate does not crash, though deep navigation is not restored
 * from the Activity bundle (that is intentional — see Marc's note on
 * [skip-ui#418](https://github.com/skiptools/skip-ui/pull/418)).
 *
 * **Without** `removeState`, `recreate()` after building preference/nav state should reproduce the
 * `Preference.getReduced()` NPE (PresentationRoot / NavigationStack).
 */
@RunWith(AndroidJUnit4::class)
class PreferencePlaygroundSaveableStateInstrumentedTest {

    companion object {
        private const val IDLE_TIMEOUT_SECONDS = 15L
        private const val LOG_TAG = "PrefSaveableTest"

        @JvmStatic
        @BeforeClass
        fun configureTestEnvironment() {
            IdlingPolicies.setMasterPolicyTimeout(IDLE_TIMEOUT_SECONDS, TimeUnit.SECONDS)
            IdlingPolicies.setIdlingResourceTimeout(IDLE_TIMEOUT_SECONDS, TimeUnit.SECONDS)
            UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
                .executeShellCommand("settings put global always_finish_activities 0")
        }
    }

    private val composeTestRule = createAndroidComposeRule<MainActivity>()

    private val semanticsTreeLogger by lazy {
        ComposeSemanticsTreeLogger(composeTestRule, LOG_TAG, "PrefSaveableTree")
    }

    @get:Rule
    val ruleChain: RuleChain = RuleChain.outerRule(object : TestWatcher() {
        override fun starting(description: Description) {
            InstrumentationRegistry.getInstrumentation().targetContext
                .getSharedPreferences("defaults", Context.MODE_PRIVATE)
                .edit()
                .putString("tab", "showcase")
                .remove("searchText")
                .commit()
        }

        override fun failed(e: Throwable?, description: Description) {
            Log.e(LOG_TAG, "Failed ${description.methodName}", e)
            logTree("failed_${description.methodName}")
        }
    }).around(composeTestRule)

    @Test
    fun preferencePlayground_activityRecreate_doesNotNPE() {
        openPreferencePlayground()
        buildHeavyPreferenceAndNavState()

        logTree("before_recreate")
        recreateActivityWithSavedState()
        logTree("after_recreate")

        assertShowcaseRootAfterRecreate()
        openPreferencePlayground()
        assertPreferencePlaygroundRoot()
        composeTestRule.onNodeWithText("Increment contributor").performClick()
        composeTestRule.waitForIdle()
        logTree("after_post_recreate_interaction")
    }

    @Test
    fun preferencePlayground_fontScaleRecreateAndTabSwitch_doesNotNPE() {
        openPreferencePlayground()
        buildHeavyPreferenceAndNavState()
        popBackToShowcaseList()

        tapTab(ABOUT_TAB)
        applyFontScale(2.0f)
        recreateActivityWithSavedState()
        applyFontScale(0.85f)
        recreateActivityWithSavedState()

        tapTab(SHOWCASE_TAB)
        assertShowcaseRootAfterRecreate()
        openPreferencePlayground()
        assertPreferencePlaygroundRoot()
        logTree("after_tab_switch_cycle")
    }

    @Test
    fun preferencePlayground_repeatedRecreateCycles_doesNotNPE() {
        openPreferencePlayground()
        buildHeavyPreferenceAndNavState()

        repeat(4) { cycle ->
            logTree("recreate_cycle_$cycle")
            composeTestRule.onNodeWithText("Increment contributor").performClick()
            composeTestRule.waitForIdle()
            recreateActivityWithSavedState()
            assertShowcaseRootAfterRecreate()
            openPreferencePlayground()
            assertPreferencePlaygroundRoot()
        }
    }

    private fun buildHeavyPreferenceAndNavState() {
        repeat(3) {
            composeTestRule.onNodeWithText("Increment contributor").performClick()
            composeTestRule.waitForIdle()
        }
        composeTestRule.onNodeWithText("Push alpha").performClick()
        composeTestRule.waitForIdle()
        repeat(2) {
            composeTestRule.onNodeWithText("Bump local payload").performClick()
            composeTestRule.waitForIdle()
        }
        navigateBackViaToolbar()
        composeTestRule.onNodeWithText("Push beta").performClick()
        composeTestRule.waitForIdle()
        composeTestRule.onNodeWithText("Bump local payload").performClick()
        composeTestRule.waitForIdle()
        composeTestRule.onNodeWithText("Route: beta", substring = true).assertExists()
        logTree("heavy_state_built")
    }

    private fun navigateBackViaToolbar() {
        val device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
        try {
            composeTestRule.onNode(hasContentDescription(NAV_BACK_CONTENT_DESC)).performClick()
        } catch (_: Throwable) {
            device.pressBack()
        }
        SystemClock.sleep(250)
        composeTestRule.waitForIdle()
    }

    /** After recreate, Showcase list should be reachable (not a process crash). */
    private fun assertShowcaseRootAfterRecreate() {
        composeTestRule.onNodeWithTag(SEARCH_FIELD_TEST_TAG, useUnmergedTree = true).assertExists()
        logTree("showcase_root_after_recreate")
    }

    /** Root of Preference playground (not a pushed detail). */
    private fun assertPreferencePlaygroundRoot() {
        composeTestRule.onNodeWithText("Push alpha").assertExists()
        composeTestRule.onNodeWithText("Increment contributor").assertExists()
    }

    private fun recreateActivityWithSavedState() {
        val instrumentation = InstrumentationRegistry.getInstrumentation()
        val scenario = composeTestRule.activityRule.scenario
        scenario.onActivity { activity ->
            instrumentation.callActivityOnSaveInstanceState(activity, Bundle())
        }
        scenario.recreate()
        scenario.moveToState(Lifecycle.State.RESUMED)
        composeTestRule.waitForIdle()
        SystemClock.sleep(400)
        composeTestRule.waitForIdle()
    }

    private fun applyFontScale(scale: Float) {
        composeTestRule.activityRule.scenario.onActivity { activity ->
            val config = Configuration(activity.resources.configuration)
            config.fontScale = scale
            activity.onConfigurationChanged(config)
        }
        composeTestRule.waitForIdle()
    }

    private fun openPreferencePlayground() {
        logTree("open_preference_start")
        popBackToShowcaseList()

        val device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
        val pkg = composeTestRule.activity.packageName
        device.wait(Until.hasObject(By.pkg(pkg).depth(0)), 5_000)
        logTree("open_preference_after_device_wait")

        clickNodeLogged("open_showcase_tab") {
            composeTestRule.onNode(
                hasText(SHOWCASE_TAB, substring = false) and
                    hasClickAction() and
                    hasAnyAncestor(hasTestTag(TAB_BAR_TEST_TAG)),
            ).performClick()
        }
        waitForIdleLogged("open_preference_after_showcase_tab")

        if (clickPreferencesRowIfVisible()) {
            waitForIdleLogged("open_preference_after_row_click_direct")
            logTree("open_preference_end")
            return
        }

        clickNodeLogged("focus_search_field") {
            val searchField = composeTestRule.onNodeWithTag(SEARCH_FIELD_TEST_TAG, useUnmergedTree = true)
            searchField.performClick()
            searchField.performTextReplacement(PLAYGROUND_SEARCH_TEXT)
        }
        waitForIdleLogged("open_preference_after_search_input")

        clickNodeLogged("open_preferences_row") {
            composeTestRule.onNode(
                hasText(PLAYGROUND_ROW_TITLE) and hasTestTag(SEARCH_FIELD_TEST_TAG).not(),
            ).performClick()
        }
        waitForIdleLogged("open_preference_after_row_click")
        logTree("open_preference_end")
    }

    private fun clickPreferencesRowIfVisible(): Boolean {
        return try {
            composeTestRule.onNode(
                hasText(PLAYGROUND_ROW_TITLE) and hasTestTag(SEARCH_FIELD_TEST_TAG).not(),
            ).performClick()
            true
        } catch (_: Throwable) {
            false
        }
    }

    private fun popBackToShowcaseList() {
        logTree("pop_back_to_showcase_before")
        try {
            composeTestRule.onNodeWithText("Pop").performClick()
            waitForIdleLogged("pop_back_to_showcase_after_pop")
        } catch (_: Throwable) {
            logTree("pop_back_to_showcase_no_pop_needed")
        }
        logTree("pop_back_to_showcase_after")
    }

    private fun tapTab(label: String) {
        clickNodeLogged("tap_tab_$label") {
            composeTestRule.onNode(
                hasText(label, substring = false) and
                    hasClickAction() and
                    hasAnyAncestor(hasTestTag(TAB_BAR_TEST_TAG)),
            ).performClick()
        }
        waitForIdleLogged("after_tab_$label")
    }

    private fun waitForIdleLogged(stage: String) {
        try {
            composeTestRule.waitForIdle()
        } catch (t: Throwable) {
            logTree("waitForIdleFailed_$stage")
            throw t
        }
    }

    private fun clickNodeLogged(stage: String, action: () -> Unit) {
        logTree("beforeClick_$stage")
        try {
            action()
        } catch (t: Throwable) {
            logTree("clickFailed_$stage")
            throw t
        }
        logTree("afterClick_$stage")
    }

    private fun logTree(stage: String) {
        semanticsTreeLogger.logTree(stage)
    }
}

private const val TAB_BAR_TEST_TAG = "skip_ui_automation_tab_bar"
private const val SEARCH_FIELD_TEST_TAG = "skip_ui_automation_search_field"

private const val SHOWCASE_TAB = "Showcase"
private const val ABOUT_TAB = "About"
private const val PLAYGROUND_ROW_TITLE = "Preferences"
private const val PLAYGROUND_SEARCH_TEXT = "Preference"
private const val NAV_BACK_CONTENT_DESC = "Back"