Add screenPopped event (#5748)

Called each time a screen is popped, either due to `Navigation.pop` or pop gesture.
closes #3941 

Navigation.events().registerScreenPoppedListener(({ componentId }) => {

});

docs/docs/events.md

 modalDismissedListener.remove();
 ```
 
+## registerScreenPoppedListener
+Invoked when screen is popped.
+
+```js
+// Subscribe
+const screenPoppedListener = Navigation.events().registerScreenPoppedListener(({ componentId }) => {
+
+});
+...
+// Unsubscribe
+screenPoppedListener.remove();
+```
+
 |       Parameter         | Description |
 |:--------------------:|:-----|
 |**componentId** | Id of the modal|

lib/android/app/src/main/java/com/reactnativenavigation/parse/LayoutFactory.java

     }
 
 	private ViewController createStack(LayoutNode node) {
-        return new StackControllerBuilder(activity)
+        return new StackControllerBuilder(activity, eventEmitter)
                 .setChildren(createChildren(node.children))
                 .setChildRegistry(childRegistry)
                 .setTopBarController(new TopBarController())

lib/android/app/src/main/java/com/reactnativenavigation/react/EventEmitter.java

     private static final String ComponentDidDisappear = "RNN.ComponentDidDisappear";
     private static final String NavigationButtonPressed = "RNN.NavigationButtonPressed";
     private static final String ModalDismissed = "RNN.ModalDismissed";
+    private static final String ScreenPopped = "RNN.ScreenPopped";
     @Nullable
     private ReactContext reactContext;
 
         emit(ModalDismissed, event);
     }
 
+    public void emitScreenPoppedEvent(String componentId) {
+        WritableMap event = Arguments.createMap();
+        event.putString("componentId", componentId);
+        emit(ScreenPopped, event);
+    }
+
     private void emit(String eventName) {
         emit(eventName, Arguments.createMap());
     }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/stack/StackController.java

 import com.reactnativenavigation.presentation.Presenter;
 import com.reactnativenavigation.presentation.StackPresenter;
 import com.reactnativenavigation.react.Constants;
+import com.reactnativenavigation.react.EventEmitter;
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.CompatUtils;
 
     private IdStack<ViewController> stack = new IdStack<>();
     private final NavigationAnimator animator;
+    private final EventEmitter eventEmitter;
     private TopBarController topBarController;
     private BackButtonHelper backButtonHelper;
     private final StackPresenter presenter;
 
-    public StackController(Activity activity, List<ViewController> children, ChildControllersRegistry childRegistry, TopBarController topBarController, NavigationAnimator animator, String id, Options initialOptions, BackButtonHelper backButtonHelper, StackPresenter stackPresenter, Presenter presenter) {
+    public StackController(Activity activity, List<ViewController> children, ChildControllersRegistry childRegistry, EventEmitter eventEmitter, TopBarController topBarController, NavigationAnimator animator, String id, Options initialOptions, BackButtonHelper backButtonHelper, StackPresenter stackPresenter, Presenter presenter) {
         super(activity, childRegistry, id, presenter, initialOptions);
+        this.eventEmitter = eventEmitter;
         this.topBarController = topBarController;
         this.animator = animator;
         this.backButtonHelper = backButtonHelper;
     private void finishPopping(ViewController disappearing, CommandListener listener) {
         disappearing.destroy();
         listener.onSuccess(disappearing.getId());
+        eventEmitter.emitScreenPoppedEvent(disappearing.getId());
     }
 
     public void popTo(ViewController viewController, Options mergeOptions, CommandListener listener) {

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/stack/StackControllerBuilder.java

 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.Presenter;
 import com.reactnativenavigation.presentation.StackPresenter;
+import com.reactnativenavigation.react.EventEmitter;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
     private Presenter presenter;
     private StackPresenter stackPresenter;
     private List<ViewController> children = new ArrayList<>();
+    private EventEmitter eventEmitter;
 
-    public StackControllerBuilder(Activity activity) {
+    public StackControllerBuilder(Activity activity, EventEmitter eventEmitter) {
         this.activity = activity;
+        this.eventEmitter = eventEmitter;
         presenter = new Presenter(activity, new Options());
         animator = new NavigationAnimator(activity, new ElementTransitionManager());
     }
 
+    public StackControllerBuilder setEventEmitter(EventEmitter eventEmitter) {
+        this.eventEmitter = eventEmitter;
+        return this;
+    }
+
     public StackControllerBuilder setChildren(ViewController... children) {
         return setChildren(Arrays.asList(children));
     }
         return new StackController(activity,
                 children,
                 childRegistry,
+                eventEmitter,
                 topBarController,
                 animator,
                 id,

lib/android/app/src/test/java/com/reactnativenavigation/TestUtils.java

 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.presentation.RenderChecker;
 import com.reactnativenavigation.presentation.StackPresenter;
+import com.reactnativenavigation.react.EventEmitter;
 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.UiUtils;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
                 return topBar;
             }
         };
-        return new StackControllerBuilder(activity)
+        return new StackControllerBuilder(activity, Mockito.mock(EventEmitter.class))
                 .setId("stack")
                 .setChildRegistry(new ChildControllersRegistry())
                 .setTopBarController(topBarController)

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/OptionsApplyingTest.java

 import com.reactnativenavigation.TestUtils;
 import com.reactnativenavigation.mocks.TestComponentLayout;
 import com.reactnativenavigation.mocks.TestReactView;
-import com.reactnativenavigation.mocks.TitleBarReactViewCreatorMock;
-import com.reactnativenavigation.mocks.TopBarBackgroundViewCreatorMock;
-import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Colour;
 import com.reactnativenavigation.parse.params.Text;
 import com.reactnativenavigation.presentation.ComponentPresenter;
 import com.reactnativenavigation.presentation.Presenter;
-import com.reactnativenavigation.presentation.RenderChecker;
-import com.reactnativenavigation.presentation.StackPresenter;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
-import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.viewcontrollers.stack.StackController;
-import com.reactnativenavigation.viewcontrollers.stack.StackControllerBuilder;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.StackLayout;
 import com.reactnativenavigation.views.topbar.TopBar;
     @Test
     public void initialOptionsAppliedOnAppear() {
         uut.options.topBar.title.text = new Text("the title");
-        StackController stackController =
-                new StackControllerBuilder(activity)
-                        .setTopBarController(new TopBarController())
-                        .setId("stackId")
-                        .setInitialOptions(new Options())
-                        .setStackPresenter(new StackPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarButtonCreatorMock(), new ImageLoader(), new RenderChecker(), new Options()))
-                        .build();
+        StackController stackController = TestUtils.newStackController(activity).build();
         stackController.ensureViewIsCreated();
         stackController.push(uut, new CommandListenerAdapter());
         assertThat(stackController.getTopBar().getTitle()).isEmpty();

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/stack/StackControllerTest.java

 import com.reactnativenavigation.parse.params.Text;
 import com.reactnativenavigation.presentation.RenderChecker;
 import com.reactnativenavigation.presentation.StackPresenter;
+import com.reactnativenavigation.react.EventEmitter;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
-import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.StatusBarUtils;
 import com.reactnativenavigation.utils.TitleBarHelper;
 import com.reactnativenavigation.utils.UiUtils;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
 @LooperMode(LooperMode.Mode.PAUSED)
     private TopBarController topBarController;
     private StackPresenter presenter;
     private BackButtonHelper backButtonHelper;
+    private EventEmitter eventEmitter;
 
     @Override
     public void beforeEach() {
         super.beforeEach();
+        eventEmitter = Mockito.mock(EventEmitter.class);
         backButtonHelper = spy(new BackButtonHelper());
         activity = newActivity();
         StatusBarUtils.saveStatusBarHeight(63);
     @Test
     public void pop_layoutHandlesChildWillDisappear() {
         TopBarController topBarController = new TopBarController();
-        uut = new StackControllerBuilder(activity)
-                        .setTopBarController(topBarController)
-                        .setId("uut")
-                        .setInitialOptions(new Options())
-                        .setStackPresenter(new StackPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarButtonCreatorMock(), new ImageLoader(), new RenderChecker(), new Options()))
-                        .build();
+        uut = TestUtils.newStackController(activity)
+                .setTopBarController(topBarController)
+                .setId("uut")
+                .build();
         uut.ensureViewIsCreated();
         uut.push(child1, new CommandListenerAdapter());
         uut.push(child2, new CommandListenerAdapter() {
         });
     }
 
+    @Test
+    public void pop_popEventIsEmitted() {
+        disablePushAnimation(child1, child2);
+        disablePopAnimation(child2);
+        uut.push(child1, new CommandListenerAdapter());
+        uut.push(child2, new CommandListenerAdapter());
+
+        uut.pop(Options.EMPTY, new CommandListenerAdapter());
+        verify(eventEmitter).emitScreenPoppedEvent(child2.getId());
+    }
+
+    @Test
+    public void popToRoot_popEventIsEmitted() {
+        disablePushAnimation(child1, child2, child3);
+        disablePopAnimation(child2, child3);
+        uut.push(child1, new CommandListenerAdapter());
+        uut.push(child2, new CommandListenerAdapter());
+        uut.push(child3, new CommandListenerAdapter());
+
+        uut.pop(Options.EMPTY, new CommandListenerAdapter());
+        verify(eventEmitter).emitScreenPoppedEvent(child3.getId());
+        verifyNoMoreInteractions(eventEmitter);
+    }
+
     @Test
     public void stackOperations() {
         assertThat(uut.peek()).isNull();
 
     @Test
     public void mergeChildOptions_updatesViewWithNewOptions() {
-        StackController uut = spy(new StackControllerBuilder(activity)
-                        .setTopBarController(new TopBarController())
-                        .setId("stack")
-                        .setInitialOptions(new Options())
-                        .setStackPresenter(new StackPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TitleBarReactViewCreatorMock(), ImageLoaderMock.mock(), new RenderChecker(), Options.EMPTY))
-                        .build());
+        StackController uut = spy(TestUtils.newStackController(activity)
+                .setId("stack")
+                .build());
         Options optionsToMerge = new Options();
         ViewController vc = mock(ViewController.class);
         uut.mergeChildOptions(optionsToMerge, vc);
 
     @Test
     public void mergeChildOptions_updatesParentControllerWithNewOptions() {
-        StackController uut = new StackControllerBuilder(activity)
-                        .setTopBarController(new TopBarController())
+        StackController uut = TestUtils.newStackController(activity)
                         .setId("stack")
-                        .setInitialOptions(new Options())
-                        .setStackPresenter(new StackPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TitleBarReactViewCreatorMock(), ImageLoaderMock.mock(), new RenderChecker(), Options.EMPTY))
                         .build();
         ParentController parentController = Mockito.mock(ParentController.class);
         uut.setParentController(parentController);
     private StackControllerBuilder createStackBuilder(String id, List<ViewController> children) {
         createTopBarController();
         return TestUtils.newStackController(activity)
+                .setEventEmitter(eventEmitter)
                 .setChildren(children)
                 .setId(id)
                 .setTopBarController(topBarController)

lib/ios/RNNCommandsHandler.m

 	UINavigationController *nvc = vc.navigationController;
 	
 	if ([nvc topViewController] == vc) {
-		if (vc.resolveOptionsWithDefault.animations.pop) {
+		if (vc.resolveOptions.animations.pop.hasCustomAnimation) {
 			nvc.delegate = vc;
-		} else {
-			nvc.delegate = nil;
 		}
 	} else {
 		NSMutableArray * vcs = nvc.viewControllers.mutableCopy;

lib/ios/RNNComponentViewController.m

 	
 	self.animator = [[RNNAnimator alloc] initWithTransitionOptions:self.resolveOptions.customTransition];
 	
-	self.navigationController.delegate = self;
-	
 	return self;
 }
 

lib/ios/RNNEventEmitter.h

-
 #import <Foundation/Foundation.h>
 
 #import <React/RCTEventEmitter.h>
 
 - (void)sendModalsDismissedEvent:(NSString *)componentId numberOfModalsDismissed:(NSNumber *)modalsDismissed;
 
+- (void)sendScreenPoppedEvent:(NSString *)componentId;
+
 
 @end

lib/ios/RNNEventEmitter.m

 #import "RNNUtils.h"
 
 @implementation RNNEventEmitter {
-	NSInteger _appLaunchedListenerCount;
-	BOOL _appLaunchedEventDeferred;
+    NSInteger _appLaunchedListenerCount;
+    BOOL _appLaunchedEventDeferred;
 }
 
 RCT_EXPORT_MODULE();
 static NSString* const SearchBarUpdated 		= @"RNN.SearchBarUpdated";
 static NSString* const SearchBarCancelPressed 	= @"RNN.SearchBarCancelPressed";
 static NSString* const PreviewCompleted         = @"RNN.PreviewCompleted";
-
--(NSArray<NSString *> *)supportedEvents {
-	return @[AppLaunched,
-			 CommandCompleted,
-			 BottomTabSelected,
-			 ComponentDidAppear,
-			 ComponentDidDisappear,
-			 NavigationButtonPressed,
-			 ModalDismissed,
-			 SearchBarUpdated,
-			 SearchBarCancelPressed,
-			 PreviewCompleted];
+static NSString* const ScreenPopped             = @"RNN.ScreenPopped";
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[AppLaunched,
+             CommandCompleted,
+             BottomTabSelected,
+             ComponentDidAppear,
+             ComponentDidDisappear,
+             NavigationButtonPressed,
+             ModalDismissed,
+             SearchBarUpdated,
+             SearchBarCancelPressed,
+             PreviewCompleted,
+             ScreenPopped];
 }
 
 # pragma mark public
 
--(void)sendOnAppLaunched {
-	if (_appLaunchedListenerCount > 0) {
-		[self send:AppLaunched body:nil];
-	} else {
-		_appLaunchedEventDeferred = TRUE;
-	}
+- (void)sendOnAppLaunched {
+    if (_appLaunchedListenerCount > 0) {
+        [self send:AppLaunched body:nil];
+    } else {
+        _appLaunchedEventDeferred = TRUE;
+    }
 }
 
--(void)sendComponentDidAppear:(NSString *)componentId componentName:(NSString *)componentName {
-	[self send:ComponentDidAppear body:@{
-										 @"componentId":componentId,
-										 @"componentName": componentName
-										 }];
+- (void)sendComponentDidAppear:(NSString *)componentId componentName:(NSString *)componentName {
+    [self send:ComponentDidAppear body:@{
+        @"componentId":componentId,
+        @"componentName": componentName
+    }];
 }
 
--(void)sendComponentDidDisappear:(NSString *)componentId componentName:(NSString *)componentName{
-	[self send:ComponentDidDisappear body:@{
-											@"componentId":componentId,
-											@"componentName": componentName
-											}];
+- (void)sendComponentDidDisappear:(NSString *)componentId componentName:(NSString *)componentName{
+    [self send:ComponentDidDisappear body:@{
+        @"componentId":componentId,
+        @"componentName": componentName
+    }];
 }
 
--(void)sendOnNavigationButtonPressed:(NSString *)componentId buttonId:(NSString*)buttonId {
-	[self send:NavigationButtonPressed body:@{
-											  @"componentId": componentId,
-											  @"buttonId": buttonId
-											  }];
+- (void)sendOnNavigationButtonPressed:(NSString *)componentId buttonId:(NSString*)buttonId {
+    [self send:NavigationButtonPressed body:@{
+        @"componentId": componentId,
+        @"buttonId": buttonId
+    }];
 }
 
--(void)sendBottomTabSelected:(NSNumber *)selectedTabIndex unselected:(NSNumber*)unselectedTabIndex {
-	[self send:BottomTabSelected body:@{
-									  @"selectedTabIndex": selectedTabIndex,
-									  @"unselectedTabIndex": unselectedTabIndex
-									  }];
+- (void)sendBottomTabSelected:(NSNumber *)selectedTabIndex unselected:(NSNumber*)unselectedTabIndex {
+    [self send:BottomTabSelected body:@{
+        @"selectedTabIndex": selectedTabIndex,
+        @"unselectedTabIndex": unselectedTabIndex
+    }];
 }
 
--(void)sendOnNavigationCommandCompletion:(NSString *)commandName commandId:(NSString *)commandId params:(NSDictionary*)params {
-	[self send:CommandCompleted body:@{
-									   @"commandId":commandId,
-									   @"commandName":commandName,
-									   @"params": params,
-									   @"completionTime": [RNNUtils getCurrentTimestamp]
-									   }];
+- (void)sendOnNavigationCommandCompletion:(NSString *)commandName commandId:(NSString *)commandId params:(NSDictionary*)params {
+    [self send:CommandCompleted body:@{
+        @"commandId":commandId,
+        @"commandName":commandName,
+        @"params": params,
+        @"completionTime": [RNNUtils getCurrentTimestamp]
+    }];
 }
 
--(void)sendOnSearchBarUpdated:(NSString *)componentId
-						 text:(NSString*)text
-					isFocused:(BOOL)isFocused {
-	[self send:SearchBarUpdated body:@{
-									   @"componentId": componentId,
-									   @"text": text,
-									   @"isFocused": @(isFocused)
-									   }];
+- (void)sendOnSearchBarUpdated:(NSString *)componentId
+                          text:(NSString*)text
+                     isFocused:(BOOL)isFocused {
+    [self send:SearchBarUpdated body:@{
+        @"componentId": componentId,
+        @"text": text,
+        @"isFocused": @(isFocused)
+    }];
 }
 
 - (void)sendOnSearchBarCancelPressed:(NSString *)componentId {
-	[self send:SearchBarCancelPressed body:@{
-											@"componentId": componentId
-											}];
+    [self send:SearchBarCancelPressed body:@{
+        @"componentId": componentId
+    }];
 }
 
 - (void)sendOnPreviewCompleted:(NSString *)componentId previewComponentId:(NSString *)previewComponentId {
-	[self send:PreviewCompleted body:@{
-											 @"componentId": componentId,
-											 @"previewComponentId": previewComponentId
-                       }];
+    [self send:PreviewCompleted body:@{
+        @"componentId": componentId,
+        @"previewComponentId": previewComponentId
+    }];
 }
 
 - (void)sendModalsDismissedEvent:(NSString *)componentId numberOfModalsDismissed:(NSNumber *)modalsDismissed {
-	[self send:ModalDismissed body:@{
-											 @"componentId": componentId,
-											 @"modalsDismissed": modalsDismissed
-											 }];
+    [self send:ModalDismissed body:@{
+        @"componentId": componentId,
+        @"modalsDismissed": modalsDismissed
+    }];
+}
+
+- (void)sendScreenPoppedEvent:(NSString *)componentId {
+    [self send:ScreenPopped body:@{
+        @"componentId": componentId
+    }];
 }
 
 - (void)addListener:(NSString *)eventName {
-	[super addListener:eventName];
-	if ([eventName isEqualToString:AppLaunched]) {
-		_appLaunchedListenerCount++;
-		if (_appLaunchedEventDeferred) {
-			_appLaunchedEventDeferred = FALSE;
-			[self sendOnAppLaunched];
-		}
-	}
+    [super addListener:eventName];
+    if ([eventName isEqualToString:AppLaunched]) {
+        _appLaunchedListenerCount++;
+        if (_appLaunchedEventDeferred) {
+            _appLaunchedEventDeferred = FALSE;
+            [self sendOnAppLaunched];
+        }
+    }
 }
 
 # pragma mark private
 
--(void)send:(NSString *)eventName body:(id)body {
-	if (self.bridge == nil) {
-		return;
-	}
-	[self sendEventWithName:eventName body:body];
+- (void)send:(NSString *)eventName body:(id)body {
+    if (self.bridge == nil) {
+        return;
+    }
+    [self sendEventWithName:eventName body:body];
 }
 
 @end

lib/ios/RNNNavigationStackManager.m

 
 	if (animationDelegate) {
 		nvc.delegate = animationDelegate;
-	} else {
-		nvc.delegate = nil;
 	}
 	
 	[self performAnimationBlock:^{

lib/ios/RNNStackController.m

 #import "RNNStackController.h"
 #import "RNNComponentViewController.h"
 
-@implementation RNNStackController
+@implementation RNNStackController {
+    UIViewController* _presentedViewController;
+}
+
+- (instancetype)init {
+    self = [super init];
+    self.delegate = self;
+    return self;
+}
 
--(void)setDefaultOptions:(RNNNavigationOptions *)defaultOptions {
+- (void)setDefaultOptions:(RNNNavigationOptions *)defaultOptions {
 	[super setDefaultOptions:defaultOptions];
 	[self.presenter setDefaultOptions:defaultOptions];
 }
 }
 
 - (UIViewController *)popViewControllerAnimated:(BOOL)animated {
-	if (self.viewControllers.count > 1) {
-		UIViewController *controller = self.viewControllers[self.viewControllers.count - 2];
-		if ([controller isKindOfClass:[RNNComponentViewController class]]) {
-			RNNComponentViewController *rnnController = (RNNComponentViewController *)controller;
-			[self.presenter applyOptionsBeforePopping:rnnController.resolveOptions];
-		}
-	}
-	
+    [self prepareForPop];
 	return [super popViewControllerAnimated:animated];
 }
 
+- (void)navigationController:(UINavigationController *)navigationController didShowViewController:(UIViewController *)viewController animated:(BOOL)animated {
+    if ([self.viewControllers indexOfObject:_presentedViewController] < 0) {
+        [self sendScreenPoppedEvent:_presentedViewController];
+    }
+    
+    _presentedViewController = viewController;
+}
+
+- (void)sendScreenPoppedEvent:(UIViewController *)poppedScreen {
+    [self.eventEmitter sendScreenPoppedEvent:poppedScreen.layoutInfo.componentId];
+}
+
+- (void)prepareForPop {
+    if (self.viewControllers.count > 1) {
+        UIViewController *controller = self.viewControllers[self.viewControllers.count - 2];
+        if ([controller isKindOfClass:[RNNComponentViewController class]]) {
+            RNNComponentViewController *rnnController = (RNNComponentViewController *)controller;
+            [self.presenter applyOptionsBeforePopping:rnnController.resolveOptions];
+        }
+    }
+}
+
 - (UIViewController *)childViewControllerForStatusBarStyle {
 	return self.topViewController;
 }

lib/src/adapters/NativeEventsReceiver.ts

   SearchBarUpdatedEvent,
   SearchBarCancelPressedEvent,
   PreviewCompletedEvent,
-  ModalDismissedEvent
+  ModalDismissedEvent,
+  ScreenPoppedEvent
 } from '../interfaces/ComponentEvents';
 import { CommandCompletedEvent, BottomTabSelectedEvent } from '../interfaces/Events';
 
   public registerBottomTabSelectedListener(callback: (data: BottomTabSelectedEvent) => void): EmitterSubscription {
     return this.emitter.addListener('RNN.BottomTabSelected', callback);
   }
+
+  public registerScreenPoppedListener(callback: (event: ScreenPoppedEvent) => void): EmitterSubscription {
+    return this.emitter.addListener('RNN.ScreenPopped', callback);
+  }
 }

lib/src/events/ComponentEventsObserver.test.tsx

   const searchBarCancelPressedFn = jest.fn();
   const previewCompletedFn = jest.fn();
   const modalDismissedFn = jest.fn();
+  const screenPoppedFn = jest.fn();
   let subscription: EventSubscription;
   let uut: ComponentEventsObserver;
 
       previewCompletedFn(event);
     }
 
+    screenPopped(event: any) {
+      screenPoppedFn(event);
+    }
+
     render() {
       return 'Hello';
     }
       previewCompletedFn(event);
     }
 
+    screenPopped(event: any) {
+      screenPoppedFn(event);
+    }
+
     render() {
       return 'Hello';
     }
     expect(previewCompletedFn).toHaveBeenCalledTimes(1);
     expect(previewCompletedFn).toHaveBeenCalledWith({ componentId: 'myCompId' });
 
+    uut.notifyScreenPopped({ componentId: 'myCompId' });
+    expect(screenPoppedFn).toHaveBeenCalledTimes(1);
+    expect(screenPoppedFn).toHaveBeenLastCalledWith({ componentId: 'myCompId' })
+
     tree.unmount();
     expect(willUnmountFn).toHaveBeenCalledTimes(1);
   });

lib/src/events/ComponentEventsObserver.ts

   SearchBarCancelPressedEvent,
   ComponentEvent,
   PreviewCompletedEvent,
-  ModalDismissedEvent
+  ModalDismissedEvent,
+  ScreenPoppedEvent
 } from '../interfaces/ComponentEvents';
 import { NativeEventsReceiver } from '../adapters/NativeEventsReceiver';
 import { Store } from '../components/Store';
     this.notifySearchBarUpdated = this.notifySearchBarUpdated.bind(this);
     this.notifySearchBarCancelPressed = this.notifySearchBarCancelPressed.bind(this);
     this.notifyPreviewCompleted = this.notifyPreviewCompleted.bind(this);
+    this.notifyScreenPopped = this.notifyScreenPopped.bind(this);
   }
 
   public registerOnceForAllComponentEvents() {
     this.nativeEventsReceiver.registerSearchBarUpdatedListener(this.notifySearchBarUpdated);
     this.nativeEventsReceiver.registerSearchBarCancelPressedListener(this.notifySearchBarCancelPressed);
     this.nativeEventsReceiver.registerPreviewCompletedListener(this.notifyPreviewCompleted);
+    this.nativeEventsReceiver.registerScreenPoppedListener(this.notifyPreviewCompleted);
   }
 
   public bindComponent(component: React.Component<any>, componentId?: string): EventSubscription {
     this.triggerOnAllListenersByComponentId(event, 'previewCompleted');
   }
 
+  notifyScreenPopped(event: ScreenPoppedEvent) {
+    this.triggerOnAllListenersByComponentId(event, 'screenPopped');
+  }
+
   private triggerOnAllListenersByComponentId(event: ComponentEvent, method: string) {
     forEach(this.listeners[event.componentId], (component) => {
       if (component && component[method]) {

lib/src/events/EventsRegistry.test.tsx

     mockScreenEventsRegistry.bindComponent.mockReturnValueOnce(subscription);
     expect(uut.bindComponent({} as React.Component<any>)).toEqual(subscription);
   });
+
+  it('delegates screenPopped to nativeEventsReceiver', () => {
+    const cb = jest.fn();
+    uut.registerScreenPoppedListener(cb);
+    expect(mockNativeEventsReceiver.registerScreenPoppedListener).toHaveBeenCalledTimes(1);
+    expect(mockNativeEventsReceiver.registerScreenPoppedListener).toHaveBeenCalledWith(cb);
+  });
 });

lib/src/events/EventsRegistry.ts

   SearchBarUpdatedEvent,
   SearchBarCancelPressedEvent,
   PreviewCompletedEvent,
-  ModalDismissedEvent
+  ModalDismissedEvent,
+  ScreenPoppedEvent
 } from '../interfaces/ComponentEvents';
 import { CommandCompletedEvent, BottomTabSelectedEvent } from '../interfaces/Events';
 
   public bindComponent(component: React.Component<any>, componentId?: string): EventSubscription {
     return this.componentEventsObserver.bindComponent(component, componentId);
   }
+
+  public registerScreenPoppedListener(callback: (event: ScreenPoppedEvent) => void): EmitterSubscription {
+    return this.nativeEventsReceiver.registerScreenPoppedListener(callback);
+  }
+
 }

lib/src/interfaces/ComponentEvents.ts

   componentName?: string;
   previewComponentId?: string;
 }
+
+export interface ScreenPoppedEvent extends ComponentEvent {
+  componentId: string;
+}

playground/ios/NavigationTests/RNNNavigationControllerTest.m

 	UIViewController* _vc3;
 	RNNNavigationOptions* _options;
 	RNNTestRootViewCreator* _creator;
+	RNNEventEmitter* _eventEmitter;
 }
 
 - (void)setUp {
     [super setUp];
+	_eventEmitter = [OCMockObject niceMockForClass:[RNNEventEmitter class]];
 	_creator = [[RNNTestRootViewCreator alloc] init];
 	_vc1 = [[RNNComponentViewController alloc] initWithLayoutInfo:nil rootViewCreator:nil eventEmitter:nil presenter:[OCMockObject partialMockForObject:[[RNNComponentPresenter alloc] init]] options:[[RNNNavigationOptions alloc] initEmptyOptions] defaultOptions:[[RNNNavigationOptions alloc] initEmptyOptions]];
 	_vc2 = [[RNNComponentViewController alloc] initWithLayoutInfo:nil rootViewCreator:nil eventEmitter:nil presenter:[[RNNComponentPresenter alloc] init] options:[[RNNNavigationOptions alloc] initEmptyOptions] defaultOptions:[[RNNNavigationOptions alloc] initEmptyOptions]];
 	_vc2Mock = [OCMockObject partialMockForObject:_vc2];
 	_vc3 = [UIViewController new];
 	_options = [OCMockObject partialMockForObject:[[RNNNavigationOptions alloc] initEmptyOptions]];
-	self.uut = [[RNNStackController alloc] initWithLayoutInfo:nil creator:_creator options:_options defaultOptions:nil presenter:[OCMockObject partialMockForObject:[[RNNStackPresenter alloc] init]] eventEmitter:nil childViewControllers:@[_vc1, _vc2]];
+	self.uut = [[RNNStackController alloc] initWithLayoutInfo:nil creator:_creator options:_options defaultOptions:nil presenter:[OCMockObject partialMockForObject:[[RNNStackPresenter alloc] init]] eventEmitter:_eventEmitter childViewControllers:@[_vc1, _vc2]];
 }
 
 - (void)testInitWithLayoutInfo_shouldBindPresenter {
 	[uut setViewControllers:@[_vc1, _vc2]];
 	
 	[[(id)uut.presenter expect] applyOptionsBeforePopping:[OCMArg any]];
-	
 	[uut popViewControllerAnimated:NO];
-	
 	[(id)uut.presenter verify];
 }
 
+- (void)testPopViewController_ShouldEmitScreenPoppedEvent {
+	RNNStackController* uut = [RNNStackController new];
+	[uut setViewControllers:@[_vc1, _vc2]];
+	
+	[[(id)uut.eventEmitter expect] sendScreenPoppedEvent:_vc2.layoutInfo.componentId];
+	[uut popViewControllerAnimated:NO];
+	[(id)uut.eventEmitter verify];
+}
+
 - (void)testOverrideOptionsShouldOverrideOptionsState {
 	RNNNavigationOptions* overrideOptions = [[RNNNavigationOptions alloc] initEmptyOptions];
 	[(RNNNavigationOptions*)[(id)self.uut.options expect] overrideOptions:overrideOptions];