Destroyable.destroy() is called before node's View is disposed

[dimsuz]

If I have a Node with this View implementation:

fun View(modifier: Modifier) {
  DisposableEffect(Unit) {
    onDispose {
      Log.d("Appyx", "Node view disposed")
    }
  }
}

and then have a ParentNode which contains this node above as one of its children and this ParentNode implementation also has a Destroyable plugin:

class DestroyAware : Destroable {
  override fun destroy() {
      Log.d("Appyx", "Node destroyed")
  }
}

I observe that logs have this:

Node destroyed
Node view disposed

which is a bit counterintuitive to me, as I perceive Node as something more "global" than its View which gets "attached/detached" to/from the node.

Is this an expected behavior?

I suspect that in future this can potentially cause bugs, e.g. someone will store some resource in Node and will reference it in View after node gets destroyed.

[KovalevAndrey]

Hi @dimsuz Node is moved to STOPPED state when it's pushed off the screen. At the same time its View leaves composition (DisposableEffect will be called). When Node is removed from the parent's children list, for instance, you pressed BackStack.pop() it's moved to DESTROYED state and then it will be garbage collected.

Note, that sometimes you don't want to keep in memory off-screen Node so you can set childKeepMode as SUSPEND in your ParentNode and off-screen Nodes state will be saved and restored when they become on-screen again.

More info about lifecycle behaviour can be found here

[dimsuz]

Yes, but what I observe is that node is moved to the DESTROYED state before DisposableEffect gets called, is this normal? I guess it is, the reference to the node will be kept as long as node's View is alive most likely.

It's just that I've seen code where people tend to assume that "if View is alive then parent node can't be in the DESTROYED state", which will not be the case here.

[KovalevAndrey]

@dimsuz yes, at the moment the order is not preserved. This is what happens:

1. ParentNode has a Backstack with active ChildNode
2. You pop Backstack and transition is started
3. When transition is finished ParentNode will
   a) Update ChildNode lifecyce state to DESROYED
   b) Remove ChildNode from the child list
4. At the same time ChildNode is no longer visible therefore its View leaves composition and DisposableEffect is called. But it will happen only on the next frame when recomposition happens.

[dimsuz]

I see! Thanks, good to know! I suspected that this has to do with transitions which require View to leave some more, until they're finished.

[KovalevAndrey]

@dimsuz Node is moved into onStop and onDestroy(if removed) only when transition is finished. This behaviour happens only due to the fact that DisposableEffect effect only called when view has left the composition and that happens only the frame after

[dimsuz]

I have another kinda parallel question about onDestroy, will ask here too.

I'm building a tree of several navigation flows which looks like this:

           ┌───────────┐
           │           │
           │  AppFlow  │
           │           │
           └───┬──┬────┘
               │  │
               │  │
┌────────────┐ │  │     ┌───────────┐
│            │ │  └─────┤           │
│ MainFlow   ├─┘        │ LoginFlow │
│            │          │           │
└────┬───────┘          └─────┬─────┘
     │                        │
 ┌───┴─┐                      │    ┌─────────────────┐
 │     │                      │    │                 │
 │ M1  │                      └────┤ PermissionsFlow │
 │     │                           │                 │
 └─────┘                           └────────┬────────┘
                                            │
                                            │
                                            │   ┌────┐
                                            │   │    │
                                            └───┤ P1 │
                                                │    │
                                                └────┘

Each *Flow here is a ParentNode with a Backstack model.

I have these steps:

1. P1 is the currently active node
2. It somehow broadcasts the "reset to Main" "event" to the AppFlow node. For example using MutableSharedFlow or through some callbacks (whether it is OK to send events like this is another topic, lets allow it for now :))
3. AppFlow node receives this event and does this:

class AppFlow(private val backStack = ...) : ParentNode {
  fun onEvent() {
    backStack.newRoot(AppFlowNavTarget.MainFlow)
  }
}

4. This correctly makes M1 node active.

But it doesn't call onDestroy on any of righthand-side nodes.
I would expect that PermissionsFlow, LoginFlow nodes get onDestroy event in their NodeLifecycleAware plugins but they do not.
They get only onStop and so they get kept in memory.

I can see that BackStack.NewRoot impl does call currentNode.transitionTo(targetState = DESTROYED), but somehow this results only in onStop being called in lifecycleListener of those nodes.

Is this an expected behavior?

[KovalevAndrey]

@dimsuz good catch, I've opened an issue #293

[KovalevAndrey]

@dimsuz actually after further investigation it looks like newRoot works correctly.

1. Check out latest 1.x branch
2. Lauch samples.sanbox
3. Open explicit navigation
4. Attach child two
5. Attach grand child two
6. Press navigate to child one - this calls newRoot(ChildOne) on the RootNode backstack.
7. Check that all Node receive onDestroy callback

Screen.Recording.2022-12-02.at.14.31.18.mp4

[dimsuz]

Do you think it was fixed in 1.x branch? If there's a SNAPSHOT for it somewhere on MavenCentral I can try to run my "project" on 1.x version to confirm.

I do not use explicit navigation though (I mean attachChild), not sure if this could be a factor in reproducing or not reproducing this issue

[dimsuz]

I am currently using 1.0.1.

[dimsuz]

Ah, found info on SNAPSHOT versions in the README will try.