setRoot instead of startApp, events registry

ios/RNNBridgeModule.m

 	return dispatch_get_main_queue();
 }
 
-RCT_EXPORT_METHOD(startApp:(NSDictionary*)layout)
+RCT_EXPORT_METHOD(setRoot:(NSDictionary*)layout)
 {
 	UIApplication.sharedApplication.delegate.window.rootViewController = [[RNNControllerFactory new] createRootViewController:layout];
 	[UIApplication.sharedApplication.delegate.window makeKeyAndVisible];

playground/e2e/app.test.js

     expect(elementByLabel('This is a tab screen')).toBeVisible();
   });
 
-  it('switch to tabs with side menus', () => {
+  xit('switch to tabs with side menus', () => {
     elementByLabel('Switch to tab based app with side menus').tap();
     // expect(elementByLabel('This is a tab screen')).toBeVisible();
   });

playground/src/app.js

 export function start() {
   registerContainers();
 
-  Navigation.onAppLaunched(() => {
-    Navigation.startApp({
+  Navigation.events().onAppLaunched(() => {
+    Navigation.setRoot({
       container: {
         name: 'com.example.WelcomeScreen'
       }

playground/src/containers/WelcomeScreen.js

   }
 
   onClickSwitchToTabs() {
-    Navigation.startApp({
+    Navigation.setRoot({
       tabs: [
         {
           container: {
   }
 
   onClickSwitchToTabsWithSideMenus() {
-    Navigation.startApp({
+    Navigation.setRoot({
       tabs: [
         {
           container: {

src/Navigation.js

     this.containerRegistry.registerContainer(containerName, getContainerFunc);
   }
 
-  startApp(params) {
-    this.commands.startApp(params);
+  setRoot(params) {
+    this.commands.setRoot(params);
   }
 
-  onAppLaunched(fn) {
-    this.nativeEventsReceiver.onAppLaunched(fn);
+  events() {
+    return this.nativeEventsReceiver;
   }
 }
 

src/Navigation.test.js

     expect(Navigation.containerRegistry.registerContainer).toHaveBeenCalledWith('name', fn);
   });
 
-  it('startApp delegates to Commands', () => {
+  it('setRoot delegates to Commands', () => {
     const params = {};
-    Navigation.startApp(params);
-    expect(Navigation.commands.startApp).toHaveBeenCalledTimes(1);
-    expect(Navigation.commands.startApp).toHaveBeenCalledWith(params);
+    Navigation.setRoot(params);
+    expect(Navigation.commands.setRoot).toHaveBeenCalledTimes(1);
+    expect(Navigation.commands.setRoot).toHaveBeenCalledWith(params);
   });
 
-  it('onAppLaunched delegates to NativeEventsReceiver', () => {
-    const fn = jest.fn();
-    Navigation.onAppLaunched(fn);
-    expect(Navigation.nativeEventsReceiver.onAppLaunched).toHaveBeenCalledTimes(1);
-    expect(Navigation.nativeEventsReceiver.onAppLaunched).toHaveBeenCalledWith(fn);
+  it('events return the events registry', () => {
+    expect(Navigation.events()).toBeDefined();
+    expect(Navigation.events().onAppLaunched).toBeInstanceOf(Function);
   });
 });

src/adapters/NativeCommandsSender.js

     this.nativeCommandsModule = NativeModules.RNNBridgeModule;
   }
 
-  startApp(layoutTree) {
-    this.nativeCommandsModule.startApp(layoutTree);
+  setRoot(layoutTree) {
+    this.nativeCommandsModule.setRoot(layoutTree);
   }
 }

src/adapters/NativeCommandsSender.test.js

 
   beforeEach(() => {
     mockNativeModule = {
-      startApp: jest.fn()
+      setRoot: jest.fn()
     };
     require('react-native').NativeModules.RNNBridgeModule = mockNativeModule;
     const NativeCommandsSender = require('./NativeCommandsSender').default;
   });
 
   it('delegates to native', () => {
-    uut.startApp();
-    expect(mockNativeModule.startApp).toHaveBeenCalledTimes(1);
+    uut.setRoot();
+    expect(mockNativeModule.setRoot).toHaveBeenCalledTimes(1);
   });
 });

src/commands/Commands.js

     this.layoutTreeParser = new LayoutTreeParser(uniqueIdProvider);
   }
 
-  startApp(simpleApi) {
-    this.nativeCommandsSender.startApp(this.layoutTreeParser.parseFromSimpleJSON(simpleApi));
+  setRoot(simpleApi) {
+    this.nativeCommandsSender.setRoot(this.layoutTreeParser.parseFromSimpleJSON(simpleApi));
   }
 }

src/commands/Commands.test.js

 describe('Commands', () => {
   let uut;
   const mockCommandsSender = {
-    startApp: jest.fn()
+    setRoot: jest.fn()
   };
   const mockIdProvider = {
     generate: (prefix) => `${prefix}UNIQUE_ID`
     uut = new Commands(mockCommandsSender, mockIdProvider);
   });
 
-  describe('startApp', () => {
-    it('sends startApp to native after parsing into layoutTree', () => {
-      uut.startApp({
+  describe('setRoot', () => {
+    it('sends setRoot to native after parsing into layoutTree', () => {
+      uut.setRoot({
         container: {
           name: 'com.example.MyScreen'
         }
       });
-      expect(mockCommandsSender.startApp).toHaveBeenCalledTimes(1);
-      expect(mockCommandsSender.startApp).toHaveBeenCalledWith({
+      expect(mockCommandsSender.setRoot).toHaveBeenCalledTimes(1);
+      expect(mockCommandsSender.setRoot).toHaveBeenCalledWith({
         type: 'ContainerStack',
         id: 'ContainerStackUNIQUE_ID',
         children: [