question: how to listen to the scope ref before navigation and dispose after pop

[YousefAK009]

how to listen to the scope ref before navigation and dispose after pop?

like listenManul in riverpod

[zupat]

I'm not sure if this is possible as widgets have to be mounted to watch a ScopedRef. Riverpod doesn't use InheritedWidget so it doesn't have this limitation.

Post the code snippet of what you're trying to achieve.
Adding the riverpod equivalent would also be helpful.

[YousefAK009]

i am trying to do

final controller = controllerRef.of(context);
controller.doSomthing();

// details page is listening to controllerRef.of(context); 
// and mutate some state inside it
await Navigator.of(context).pushNamed('/details'); 

// How to free the resource?
// I want every time navigate to the details page to have a new state of controller

in riverpod

final sub = ref.listenManul(controllerProvider, (_,__) { } );
sub.read().doSomthing();

// details page is listening to  ref.watch(controllerProvider);
// and mutate some state inside it
await Navigator.of(context).pushNamed('/details'); 

//After pop from details, it is simply called cancel
// or even if I am inside the details page and navigate using replace the listening also closed

sub.cancel();

[zupat]

So controller.doSomething() shouldn't affect the instance that detailpage gets?

If that's the case, wrapping the DetailPage in a LiteRefScope should work. It will get a fresh instance everytime.

[YousefAK009]

So controller.doSomething() shouldn't affect the instance that detailpage gets?

it should affect the instance in the details page, the listenManul is watching the controller so anything that comes later and reads the controller will get the last thing that is watched

If that's the case, wrapping the DetailPage in a LiteRefScope should work. It will get a fresh instance everytime.

yes I know, but there are many situations it's not suitable to do that, like navigation by name, and you want at the same time to call the controller to do some stuff

[zupat]

I see, the issue is that it will not be disposed until all widgets are unmounted.

I will create a read method that doesn't register the current context as a listener. I think that should address your use case.

[YousefAK009]

I see, the issue is that it will not be disposed until all widgets are unmounted.

I will create a read method that doesn't register the current context as a listener. I think that should address your use case.

I think it will not solve the issue because when I read the ref it will return an instance for it, so when I navigate and use of to register the ref it will return another instance.

edit:
the idea of manual listening is making temporary scope, and dispose it in two situations:
1- in manual canceling
2- when the current context is disposed and there are no listeners

[zupat]

No, it should return the same instance, unless you wrap the new page in a scope.

[zupat]

Here's what I'm thinking:

TextButton(
   child: Text('go to details page'),
   onPressed: () async {
     // read doesn't count this widget as a dependency
     final controller = controllerRef.read(context);
     controller.doSomthing();

     // details page is listening to controllerRef.of(context);
     // and mutate some state inside it
     // controller will be disposed when details page is unmounted
     await Navigator.of(context).pushNamed('/details');
   },
 ),

lmk if I understand the issue correctly

[YousefAK009]

Here's what I'm thinking:

TextButton(
   child: Text('go to details page'),
   onPressed: () async {
     // read doesn't count this widget as a dependency
     final controller = controllerRef.read(context);
     controller.doSomthing();

     // details page is listening to controllerRef.of(context);
     // and mutate some state inside it
     // controller will be disposed when details page is unmounted
     await Navigator.of(context).pushNamed('/details');
   },
 ),

lmk if I understand the issue correctly

yes, you are correct.
and it should controllerRef.of(context) get the same state of controllerRef.read(context)

so take this senaroi:

TextButton(
   child: Text('go to details page'),
   onPressed: () async {
     final controllerSub = controllerRef.sub(context);
     final controller = controllerSub.read(); 
     
     final result = await  controller.fetchPosts();
     if(!result) {
          // show error message
          return;
     }
    
     // details page is listening to controllerRef.of(context);
     // and retrieve all posts
     await Navigator.of(context).pushNamed('/details');
     
     controllerSub.close();
   },
 ),

when the controller should be disposed?

1- when controllerSub is closed manually and there are no listeners
2- when the context of controllerSub is unmounted and there are no listeners