Hey, I have a problem with `RememberObserver`: I have a class, let me call it `MyState` , which impl...

# compose

[fengdai]

Hey, I have a problem with `RememberObserver`:
I have a class, let me call it MyState , which implements the RememberObserver interface. I do cleanup stuff in onForgotten and onAbandoned.
I use remember to remember the MyState instance:

val state = remember { MyState() }

And I configure my activity to handle configuration changes automatically in this way in my AndroidManifest.xml:

android:configChanges="colorMode|density|fontScale|keyboard|keyboardHidden|layoutDirection|locale|mcc|mnc|navigation|orientation|screenLayout|screenSize|smallestScreenSize|touchscreen|uiMode"

So the instance will be kept across configuration changes.
When I changed the activity’s orientation, state was kept, just as I expected. What I didn’t expect is that the MyState ’s onForgotten method was called. This behavior left my remembered MyState instance in a wrong state.
Is it a bug?

[fengdai]

This seems only happen when the state is used in conditional flows, like this:

val state = remember { MyState() }
if (!isLandscape) {
  Normal(state)
} else {
  Landscape(state)
}

[fengdai]

99% sure it’s a bug 😂

[fengdai]

This is my real world MyState :
https://github.com/fengdai/compose-media/blob/de29aa1d84d991beb99b55a4322ed004d08b[…]a/src/main/java/com/github/fengdai/compose/media/PlayerState.kt
And this sample can reproduce the issue:
https://github.com/fengdai/compose-media/blob/de29aa1d84d991beb99b55a4322ed004d08b[…]/src/main/java/com/github/fengdai/compose/media/sample/Basic.kt

[Zach Klippenstein (he/him) [MOD]]

I think you might be running into the situation described in the docs:

Compose may implicitly remember an object if doing so is required to restart the composition later, such as for composable function parameters.

If a single instance is remembered in more than one location in the same composition, its onRemembered and onForgotten will be called for each location in the composition.

A RememberObserver reference that is propagated to multiple parts of a composition might remain present in the composition for longer than expected if it is remembered (explicitly or implicitly) elsewhere, and a RememberObserver that appears more once can have its callback methods called multiple times in no meaningful order and on multiple threads.

[fengdai]

I can’t figure out which part of the docs described my case.

[fengdai]

I found a key function usage in the conditional branch is also relevant:

val state = remember { MyState() }
if (!isLandscape) {
  key(state) {
    // do something
  }
  Normal(state)
} else {
  Landscape(state)
}

[fengdai]

I made a simplest sample to reproduce this:
https://github.com/fengdai/rememberobserver-issue-sample

[fengdai]

Run the sample app, the UI is like the 1st screenshot. Rotate the screen, then rotate back. The bug will occur as the 2nd screenshot presents.

[natario1]

You might be able to workaround this by using a separate line, remember(state) { ActualObserver(state) }

[Zach Klippenstein (he/him) [MOD]]

Presumably Normal and Landscape are composable functions? So you're “passing a RememberObserver as a composable function parameter”. The runtime will implicitly remember those values to enable skipping, and when you remove one of them from the composition it will get an onForgotten call.

[fengdai]

Yes, they are composable functions. But, why it doesn’t get an onRemembered call when it is implicitly remembered again?

[Zach Klippenstein (he/him) [MOD]]

You don't have to tag people who are already in threads

[Zach Klippenstein (he/him) [MOD]]

Idk why not. @Leland Richardson [G] can probably explain what I missed

[Leland Richardson [G]]

can you track the number of times onRemembered / onForgotten get called? i think what is probably happening is key(state) is causing onForgotten to get called but not onRemembered, which would be a bug

[Leland Richardson [G]]

we don’t guarantee that onRemembered/onForgotten only get called once, but i believe we do guarantee that they should get called symmetrically, which this would indicate that they’re not i think

[Leland Richardson [G]]

if you add the counts and you increment/decrement and the bug still occurs, that would be useful to know

[Leland Richardson [G]]

basically this:

class MyState : RememberObserver {
    val isAvailable get() = remembered - forgotten > 0

    private var remembered = 0
    private var forgotten = 0

    override fun onRemembered() {
        remembered++
    }

    override fun onAbandoned() {
        remembered--
    }

    override fun onForgotten() {
        remembered--
    }
}

[fengdai]

I did, and isAvailable still will be false after two screen rotations.

[Leland Richardson [G]]

what are the counts for one screen rotation?

[fengdai]

First rotation:

remembered: 1
forgotten: 0

And second rotation:

remembered: 0
forgotten: 0

[Leland Richardson [G]]

hmm. interesting. i was expecting 2/1. not 1/0.

[natario1]

Note that if the snippet was pasted as is, forgotten will always be 0. So it’s probably 2/1 resulting in 1

[Leland Richardson [G]]

eh, good point. i had a bug in there 😛

[Leland Richardson [G]]

2/1 would make more sense to me, but still a bug

[fengdai]

Yes, I copied and pasted it. 😂

[Leland Richardson [G]]

created https://issuetracker.google.com/234084017

[Leland Richardson [G]]

2/1 with forgotten-- instead of remembered--?

[fengdai]

I’ve made a simplest sample to reproduce this issue:
https://github.com/fengdai/rememberobserver-issue-sample
I think you can update the link to point to it.

[Leland Richardson [G]]

done. thanks