Emit modalDismissed event when modals are dismissed on Android

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

 	private static final String ComponentDidAppear      = "RNN.ComponentDidAppear";
 	private static final String ComponentDidDisappear   = "RNN.ComponentDidDisappear";
 	private static final String NavigationButtonPressed = "RNN.NavigationButtonPressed";
-	private static final String SearchBarUpdated        = "RNN.SearchBarUpdated";
-	private static final String SearchBarCancelPressed  = "RNN.SearchBarCancelPressed";
+    private static final String ModalDismissed          = "RNN.ModalDismissed";
 
 	private final RCTDeviceEventEmitter emitter;
 
-	EventEmitter(ReactContext reactContext) {
+	public EventEmitter(ReactContext reactContext) {
 		this.emitter = reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
 	}
 
 		emit(BottomTabSelected, event);
 	}
 
-	public void emitCommandCompletedEvent(String commandId, long completionTime) {
+	public void emitCommandCompleted(String commandId, long completionTime) {
 		WritableMap event = Arguments.createMap();
 		event.putString("commandId", commandId);
 		event.putDouble("completionTime", completionTime);
 		emit(CommandCompleted, event);
 	}
 
+    public void emitModalDismissed(String id) {
+        WritableMap event = Arguments.createMap();
+        event.putString("componentId", id);
+        emit(ModalDismissed, event);
+    }
+
 	private void emit(String eventName) {
 		emit(eventName, Arguments.createMap());
 	}

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

 	public void setRoot(String commandId, ReadableMap rawLayoutTree, Promise promise) {
 		final LayoutNode layoutTree = LayoutNodeParser.parse(JSONParser.parse(rawLayoutTree).optJSONObject("root"));
 		handle(() -> {
+            navigator().setEventEmitter(eventEmitter);
             final ViewController viewController = newLayoutFactory().create(layoutTree);
             navigator().setRoot(viewController, new NativeCommandListener(commandId, promise, eventEmitter, now));
         });

lib/android/app/src/main/java/com/reactnativenavigation/utils/NativeCommandListener.java

     @Override
     public void onSuccess(String childId) {
         if (promise != null) promise.resolve(childId);
-        eventEmitter.emitCommandCompletedEvent(commandId, now.now());
+        eventEmitter.emitCommandCompleted(commandId, now.now());
     }
 
     @Override

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/Navigator.java

 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.OptionsPresenter;
 import com.reactnativenavigation.presentation.OverlayManager;
+import com.reactnativenavigation.react.EventEmitter;
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.CompatUtils;
                          fromId +
                          " was not found.");
     }
+
+    public void setEventEmitter(EventEmitter eventEmitter) {
+        modalStack.setEventEmitter(eventEmitter);
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/modal/ModalPresenter.java

 import com.reactnativenavigation.anim.ModalAnimator;
 import com.reactnativenavigation.parse.ModalPresentationStyle;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.react.EventEmitter;
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 
     private ViewGroup content;
     private ModalAnimator animator;
     private Options defaultOptions = new Options();
+    private EventEmitter eventEmitter;
 
     ModalPresenter(ModalAnimator animator) {
         this.animator = animator;
 
     private void onDismissEnd(ViewController toDismiss, CommandListener listener) {
         toDismiss.destroy();
+        eventEmitter.emitModalDismissed(toDismiss.getId());
         listener.onSuccess(toDismiss.getId());
     }
+
+    public void setEventEmitter(EventEmitter eventEmitter) {
+        this.eventEmitter = eventEmitter;
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/modal/ModalStack.java

 
 import com.reactnativenavigation.anim.ModalAnimator;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.react.EventEmitter;
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 
         }
         return null;
     }
+
+    public void setEventEmitter(EventEmitter eventEmitter) {
+        presenter.setEventEmitter(eventEmitter);
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/utils/NativeCommandListenerTest.java

     @Test
     public void onSuccess_emitsNavigationEvent() {
         uut.onSuccess(CHILD_ID);
-        verify(eventEmitter, times(1)).emitCommandCompletedEvent(COMMAND_ID, NOW);
+        verify(eventEmitter, times(1)).emitCommandCompleted(COMMAND_ID, NOW);
     }
 
     @Test

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

         activityController = newActivityController(TestActivity.class);
         activity = activityController.create().get();
         modalStack = spy(new ModalStack(activity));
+        modalStack.setEventEmitter(Mockito.mock(EventEmitter.class));
         uut = new Navigator(activity, childRegistry, modalStack, overlayManager);
         activity.setNavigator(uut);
 

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/modal/ModalPresenterTest.java

 import com.reactnativenavigation.parse.ModalPresentationStyle;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.react.EventEmitter;
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.viewcontrollers.ChildController;
 import org.json.JSONException;
 import org.json.JSONObject;
 import org.junit.Test;
+import org.mockito.Mockito;
 
 import static org.assertj.core.api.Java6Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
         uut.setContentLayout(contentLayout);
         modal1 = spy(new SimpleViewController(activity, childRegistry, MODAL_ID_1, new Options()));
         modal2 = spy(new SimpleViewController(activity, childRegistry, MODAL_ID_2, new Options()));
+        uut.setEventEmitter(Mockito.mock(EventEmitter.class));
     }
 
     @Test

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/modal/ModalStackTest.java

 import com.reactnativenavigation.anim.ModalAnimator;
 import com.reactnativenavigation.mocks.SimpleViewController;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.react.EventEmitter;
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 
 import org.junit.Test;
+import org.mockito.Mockito;
 
 import java.util.EmptyStackException;
 
         presenter = spy(new ModalPresenter(animator));
         uut = new ModalStack(presenter);
         uut.setContentLayout(activityContentView);
+        uut.setEventEmitter(Mockito.mock(EventEmitter.class));
         modal1 = spy(new SimpleViewController(activity, childRegistry, MODAL_ID_1, new Options()));
         modal2 = spy(new SimpleViewController(activity, childRegistry, MODAL_ID_2, new Options()));
         modal3 = spy(new SimpleViewController(activity, childRegistry, MODAL_ID_3, new Options()));

lib/src/adapters/NativeEventsReceiver.ts

   ComponentDidDisappearEvent,
   NavigationButtonPressedEvent,
   SearchBarUpdatedEvent,
-  SearchBarCancelPressedEvent
+  SearchBarCancelPressedEvent,
+  ModalDismissedEvent
 } from '../interfaces/ComponentEvents';
 import { CommandCompletedEvent, BottomTabSelectedEvent } from '../interfaces/Events';
 
     return this.emitter.addListener('RNN.NavigationButtonPressed', callback);
   }
 
+  public registerModalDismissedListener(callback: (event: ModalDismissedEvent) => void): EventSubscription {
+    return this.emitter.addListener('RNN.ModalDismissed', callback);
+  }
+
   public registerSearchBarUpdatedListener(callback: (event: SearchBarUpdatedEvent) => void): EventSubscription {
     return this.emitter.addListener('RNN.SearchBarUpdated', callback);
   }

lib/src/events/ComponentEventsObserver.test.tsx

   const navigationButtonPressedFn = jest.fn();
   const searchBarUpdatedFn = jest.fn();
   const searchBarCancelPressedFn = jest.fn();
+  const modalDismissedFn = jest.fn();
   let subscription;
 
   class SimpleScreen extends React.Component<any, any> {
       navigationButtonPressedFn(event);
     }
 
+    modalDismissed(event) {
+      modalDismissedFn(event);
+    }
+
     searchBarUpdated(event) {
       searchBarUpdatedFn(event);
     }
     expect(navigationButtonPressedFn).toHaveBeenCalledTimes(1);
     expect(navigationButtonPressedFn).toHaveBeenCalledWith({ buttonId: 'myButtonId', componentId: 'myCompId' });
 
+    uut.notifyModalDismissed({ componentId: 'myCompId' });
+    expect(modalDismissedFn).toHaveBeenCalledTimes(1);
+    expect(modalDismissedFn).toHaveBeenLastCalledWith({ componentId: 'myCompId' })
+
     uut.notifySearchBarUpdated({ componentId: 'myCompId', text: 'theText', isFocused: true });
     expect(searchBarUpdatedFn).toHaveBeenCalledTimes(1);
     expect(searchBarUpdatedFn).toHaveBeenCalledWith({ componentId: 'myCompId', text: 'theText', isFocused: true });

lib/src/events/ComponentEventsObserver.ts

   NavigationButtonPressedEvent,
   SearchBarUpdatedEvent,
   SearchBarCancelPressedEvent,
-  ComponentEvent
+  ComponentEvent,
+  ModalDismissedEvent
 } from '../interfaces/ComponentEvents';
 import { NativeEventsReceiver } from '../adapters/NativeEventsReceiver';
 
     this.notifyComponentDidAppear = this.notifyComponentDidAppear.bind(this);
     this.notifyComponentDidDisappear = this.notifyComponentDidDisappear.bind(this);
     this.notifyNavigationButtonPressed = this.notifyNavigationButtonPressed.bind(this);
+    this.notifyModalDismissed = this.notifyModalDismissed.bind(this);
     this.notifySearchBarUpdated = this.notifySearchBarUpdated.bind(this);
     this.notifySearchBarCancelPressed = this.notifySearchBarCancelPressed.bind(this);
   }
     this.nativeEventsReceiver.registerComponentDidAppearListener(this.notifyComponentDidAppear);
     this.nativeEventsReceiver.registerComponentDidDisappearListener(this.notifyComponentDidDisappear);
     this.nativeEventsReceiver.registerNavigationButtonPressedListener(this.notifyNavigationButtonPressed);
+    this.nativeEventsReceiver.registerModalDismissedListener(this.notifyModalDismissed);
     this.nativeEventsReceiver.registerSearchBarUpdatedListener(this.notifySearchBarUpdated);
     this.nativeEventsReceiver.registerSearchBarCancelPressedListener(this.notifySearchBarCancelPressed);
   }
     this.triggerOnAllListenersByComponentId(event, 'navigationButtonPressed');
   }
 
+  notifyModalDismissed(event: ModalDismissedEvent) {
+    this.triggerOnAllListenersByComponentId(event, 'modalDismissed');
+  }
+
   notifySearchBarUpdated(event: SearchBarUpdatedEvent) {
     this.triggerOnAllListenersByComponentId(event, 'searchBarUpdated');
   }

lib/src/events/EventsRegistry.test.tsx

     expect(mockNativeEventsReceiver.registerNavigationButtonPressedListener).toHaveBeenCalledWith(cb);
   });
 
+  it('delegates modalDismissed to nativeEventsReceiver', () => {
+    const cb = jest.fn();
+    uut.registerModalDismissedListener(cb);
+    expect(mockNativeEventsReceiver.registerModalDismissedListener).toHaveBeenCalledTimes(1);
+    expect(mockNativeEventsReceiver.registerModalDismissedListener).toHaveBeenCalledWith(cb);
+  });
+
   it('delegates searchBarUpdated to nativeEventsReceiver', () => {
     const cb = jest.fn();
     uut.registerSearchBarUpdatedListener(cb);

lib/src/events/EventsRegistry.ts

   ComponentDidDisappearEvent,
   NavigationButtonPressedEvent,
   SearchBarUpdatedEvent,
-  SearchBarCancelPressedEvent
+  SearchBarCancelPressedEvent,
+  ModalDismissedEvent
 } from '../interfaces/ComponentEvents';
 import { CommandCompletedEvent, BottomTabSelectedEvent } from '../interfaces/Events';
 
     return this.nativeEventsReceiver.registerNavigationButtonPressedListener(callback);
   }
 
+  public registerModalDismissedListener(callback: (event: ModalDismissedEvent) => void): EventSubscription {
+    return this.nativeEventsReceiver.registerModalDismissedListener(callback);
+  }
+
   public registerSearchBarUpdatedListener(callback: (event: SearchBarUpdatedEvent) => void): EventSubscription {
     return this.nativeEventsReceiver.registerSearchBarUpdatedListener(callback);
   }

lib/src/interfaces/ComponentEvents.ts

   buttonId: string;
 }
 
+export interface ModalDismissedEvent extends ComponentEvent {
+  componentId: string;
+}
+
 export interface SearchBarUpdatedEvent extends ComponentEvent {
   text: string;
   isFocused: boolean;

playground/src/screens/StaticLifecycleOverlay.js

         events: [...this.state.events, { event: 'navigationButtonPressed', buttonId, componentId }]
       });
     }));
+    this.listeners.push(Navigation.events().registerModalDismissedListener(({ componentId }) => {
+      this.setState({
+        events: [...this.state.events, { event: 'modalDismissed', componentId }]
+      });
+    }));
   }
 
   componentWillUnmount() {
       return <Text style={styles.h2}>{`${event.commandId}`}</Text>;
     } else if (event.componentName) {
       return <Text style={styles.h2}>{`${event.event} | ${event.componentName}`}</Text>;
-    } else {
+    } else if (event.buttonId) {
       return <Text style={styles.h2}>{`${event.event} | ${event.buttonId}`}</Text>;
+    } else {
+      return <Text style={styles.h2}>{`${event.event} | ${event.componentId}`}</Text>;
     }
   }