jisungbin / composeinvestigator Goto Github PK

Right now we're limiting the invalidation tracking scope to the trace range of the composable, but this doesn't seem to be an effective way to do it. Every composable will have its own group unless we arbitrarily remove the composable group. Alternatively, we can intercept the ComposableLambda. This would have a more precise invalidation tracking scope, but each composable would not be named per group. This would need to be resolved first before adopting this approach.

A composable is divided into the composable function itself and the ComposableSingleton. The latter means to composable lambdas, and this proposal can be applied to the latter.

If this proposal is approved, it will probably solve this problem as well.

Background of Feature Request

Composables are developed as reusable functions, allowing a single composable to be used in multiple places. In the given Kotlin code structure:

@Composable fun House() {
  Content()
}

@Composable fun Door() {
  Content()
}

@Composable fun Content() {
  Text("It's me!")
}

When both House and Door composables recompose, the Content composable is also recomposed. However, the Content composable has no knowledge beyond being recomposed; it doesn't know which parent triggered the recomposition. For effective debugging, it is crucial to know which parent caused the recomposition of the Content composable. Currently, developers have to inspect both House and Door composables to identify the source of unintended recomposition.

Proposed Implementation Approach

The idea is to wrap all composable function calls with a try-finally block to record the call stack. For instance:

@Composable fun House() {
  try {
    // Enter `Content()`
    Content()
  } finally {
    // Exit `Content()` 
  }
}

Extending this approach to wrap all composable function calls in a try-finally block and record the call stack could provide valuable debugging information.

Implementation Considerations

Composable lambdas that do not capture values are managed by the ComposableSingleton class, while lambdas that capture values are wrapped in the ComposableLambda class. Therefore, unintentionally, the ComposableSingleton or ComposableLambda classes may be present in the Compose function call stack. To prevent this, recording the call stack should be performed before the Compose compiler.

Assistance Needed

I attempted to implement this quickly in pull request #78, and while the try-finally concept worked, there were issues. Composables can be defined not only as functions but also as anonymous functions. For example:

@Composable fun Content(content: @Composable () -> Unit) {
  content()
}

@Composable fun ActualContent() {
  Content {
    Text("beep bop boop")
  }
}

The expected call stack for Text("beep bop boop") would be ActaualContent -> Content -> Text. However, in reality, an <anonymous> layer is introduced because Text("beep bop boop") is created from an anonymous composable function.

@Composable fun ActualContent() {
  Content(
    content = @Composable {
      Text("beep bop boop")
    }
  )
}

Replacing <anonymous> with the parameter name content provides a meaningful name, but is this approach always valid?

For now, I'm creating this issue to document my current situation and will continue to develop this way.

It would be nice to have an API to get the ComposableInvalidationTrackTable assigned to the current file, like the currentComposer API in androidx compose. This would make it easier for users and provide more debugging opportunities. If such an API were to be added, how about named it currentComposableInvalidationTracker?

Reproduce Step : Just launch app with this plugin applied.
composeBomVersion = "2023.10.01"
composeCompiler = "1.5.10"

Stacktrace:

java.lang.RuntimeException: Unable to resume activity {com.gangnam.sister.debug/com.kotlin.activity.MainActivity}: java.lang.ClassCastException: androidx.compose.runtime.DerivedSnapshotState cannot be cast to androidx.compose.runtime.snapshots.SnapshotMutableState at android.app.ActivityThread.performResumeActivity(ActivityThread.java:5426) at android.app.ActivityThread.handleResumeActivity(ActivityThread.java:5507) at android.app.servertransaction.ResumeActivityItem.execute(ResumeActivityItem.java:57) at android.app.servertransaction.ActivityTransactionItem.execute(ActivityTransactionItem.java:45) at android.app.servertransaction.TransactionExecutor.executeLifecycleState(TransactionExecutor.java:180) at android.app.servertransaction.TransactionExecutor.execute(TransactionExecutor.java:98) at android.app.ActivityThread$H.handleMessage(ActivityThread.java:2685) at android.os.Handler.dispatchMessage(Handler.java:106) at android.os.Looper.loopOnce(Looper.java:230) at android.os.Looper.loop(Looper.java:319) at android.app.ActivityThread.main(ActivityThread.java:8913) at java.lang.reflect.Method.invoke(Native Method) at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:608) at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:1103) Caused by: java.lang.ClassCastException: androidx.compose.runtime.DerivedSnapshotState cannot be cast to androidx.compose.runtime.snapshots.SnapshotMutableState at land.sungbin.composeinvestigator.runtime.ComposeStateObjectValueGetter.getCurrentValue(StateObjectTracker.kt:234) at land.sungbin.composeinvestigator.runtime.ComposeStateObjectValueGetter.initialize$runtime_release(StateObjectTracker.kt:240) at land.sungbin.composeinvestigator.runtime.StateObjectTrackerKt$registerStateObjectTracking$1$register$2$1.onRemembered(StateObjectTracker.kt:159) at androidx.compose.runtime.CompositionImpl$RememberEventDispatcher.dispatchRememberObservers(Composition.kt:1295) at androidx.compose.runtime.CompositionImpl.applyChangesInLocked(Composition.kt:984) at androidx.compose.runtime.CompositionImpl.applyChanges(Composition.kt:1005) at androidx.compose.runtime.Recomposer.composeInitial$runtime_release(Recomposer.kt:1099) at androidx.compose.runtime.CompositionImpl.composeInitial(Composition.kt:633) at androidx.compose.runtime.CompositionImpl.setContent(Composition.kt:619) at androidx.compose.ui.platform.WrappedComposition$setContent$1.invoke(Wrapper.android.kt:123) at androidx.compose.ui.platform.WrappedComposition$setContent$1.invoke(Wrapper.android.kt:114) at androidx.compose.ui.platform.AndroidComposeView.setOnViewTreeOwnersAvailable(AndroidComposeView.android.kt:1289) at androidx.compose.ui.platform.WrappedComposition.setContent(Wrapper.android.kt:114) at androidx.compose.ui.platform.WrappedComposition.onStateChanged(Wrapper.android.kt:164) at androidx.lifecycle.LifecycleRegistry$ObserverWithState.dispatchEvent(LifecycleRegistry.kt:314) at androidx.lifecycle.LifecycleRegistry.forwardPass(LifecycleRegistry.kt:251) at androidx.lifecycle.LifecycleRegistry.sync(LifecycleRegistry.kt:287) at androidx.lifecycle.LifecycleRegistry.moveToState(LifecycleRegistry.kt:136) at androidx.lifecycle.LifecycleRegistry.handleLifecycleEvent(LifecycleRegistry.kt:119) at androidx.fragment.app.FragmentViewLifecycleOwner.handleLifecycleEvent(FragmentViewLifecycleOwner.java:100) at androidx.fragment.app.Fragment.restoreViewState(Fragment.java:708) at androidx.fragment.app.Fragment.restoreViewState(Fragment.java:3176) at androidx.fragment.app.Fragment.performActivityCreated(Fragment.java:3161) at androidx.fragment.app.FragmentStateManager.activityCreated(FragmentStateManager.java:619) at androidx.fragment.app.FragmentStateManager.moveToExpectedState(FragmentStateManager.java:275) at androidx.fragment.app.FragmentManager.executeOpsTogether(FragmentManager.java:1943) 2024-03-05 13:21:40.287 26853-26853 AndroidRuntime com.gangnam.sister.debug E at androidx.fragment.app.FragmentManager.removeRedundantOperationsAndExecute(FragmentManager.java:1839) at androidx.fragment.app.FragmentManager.execSingleAction(FragmentManager.java:1751) at androidx.fragment.app.BackStackRecord.commitNowAllowingStateLoss(BackStackRecord.java:323) at androidx.fragment.app.FragmentPagerAdapter.finishUpdate(FragmentPagerAdapter.java:249) at androidx.viewpager.widget.ViewPager.populate(ViewPager.java:1244) at androidx.viewpager.widget.ViewPager.populate(ViewPager.java:1092) at androidx.viewpager.widget.ViewPager.setAdapter(ViewPager.java:540) at com.kotlin.activity.MainActivity.initAdapter(MainActivity.kt:601) at com.kotlin.presenter.MainPresenter.onResume(MainPresenter.kt:78) at com.kotlin.activity.MainActivity.onResume(MainActivity.kt:561) at android.app.Instrumentation.callActivityOnResume(Instrumentation.java:1603) at android.app.Activity.performResume(Activity.java:9119) at android.app.ActivityThread.performResumeActivity(ActivityThread.java:5399) ... 13 more

Provide an Android lint that walks through correct API usage and recommends providing userProvideName.

Currently, only the most basic Restartable Groups are supported.

There is a bug where the logger initialization is not synchronous. We probably need to reimplement the logger initialization in a different way to fix this.

Composables with unstable arguments need to be handled differently because of the way IRs are generated.

This issue lists Renovate updates and detected dependencies. Read the Dependency Dashboard docs to learn more.

Open

These updates have all been created already. Click a checkbox below to force a retry/rebase of any.

• Update dependency com.android.tools.build:gradle to v8.3.1
• Update dependency com.pinterest.ktlint:ktlint-cli to v1.2.1
• Update dependency gradle to v8.7
• Click on this checkbox to rebase all open PRs at once

Detected dependencies

• Check this box to trigger a request for Renovate to run again on this repository

(low priority)

In theory, it should already support K2.

Currently, only the arguments of composable functions support change tracking. It is common too to have a State property inside a composable function and to change that state directly to request a recomposition without state hoisting.

I propose "ComposeInvestigator" as a new name, as it looks like the main feature is going to be an invalidation tracker.