changed API, better naming

lib/src/adapters/NativeEventsReceiver.ts

     this.emitter = new NativeEventEmitter(NativeModules.RNNEventEmitter);
   }
 
-  registerAppLaunched(callback: () => void): EventSubscription {
-    return this.emitter.addListener('RNN.appLaunched', callback);
+  registerOnAppLaunched(callback: () => void): EventSubscription {
+    return this.emitter.addListener('RNN.onAppLaunched', callback);
   }
 
   registerComponentDidAppear(callback: (componendId: string, componentName: string) => void): EventSubscription {
     return this.emitter.addListener('RNN.componentDidDisappear', callback);
   }
 
-  registerInteraction(callback: (name: string) => void): EventSubscription {
-    return this.emitter.addListener('RNN.interaction', callback);
+  registerOnNavigationInteraction(callback: (name: string) => void): EventSubscription {
+    return this.emitter.addListener('RNN.onNavigationInteraction', callback);
   }
 }

lib/src/components/ComponentWrapper.test.tsx

   });
 
   describe('component lifecycle', () => {
-    const didAppearCallback = jest.fn();
-    const didDisappearCallback = jest.fn();
-    const onNavigationButtonPressedCallback = jest.fn();
+    const componentDidAppearCallback = jest.fn();
+    const componentDidDisappearCallback = jest.fn();
+    const onNavigationInteractionCallback = jest.fn();
 
     class MyLifecycleComponent extends MyComponent {
-      didAppear() {
-        didAppearCallback();
+      componentDidAppear() {
+        componentDidAppearCallback();
       }
 
-      didDisappear() {
-        didDisappearCallback();
+      componentDidDisappear() {
+        componentDidDisappearCallback();
       }
 
-      onNavigationButtonPressed() {
-        onNavigationButtonPressedCallback();
+      onNavigationInteraction() {
+        onNavigationInteractionCallback();
       }
     }
 
-    it('didAppear, didDisappear and onNavigationButtonPressed are optional', () => {
+    it('componentDidAppear, componentDidDisappear and onNavigationInteraction are optional', () => {
       const NavigationComponent = ComponentWrapper.wrap(componentName, MyComponent, store);
       const tree = renderer.create(<NavigationComponent componentId={'component1'} />);
-      expect(() => tree.getInstance()!.didAppear()).not.toThrow();
-      expect(() => tree.getInstance()!.didDisappear()).not.toThrow();
-      expect(() => tree.getInstance()!.onNavigationButtonPressed()).not.toThrow();
+      expect(() => tree.getInstance()!.componentDidAppear()).not.toThrow();
+      expect(() => tree.getInstance()!.componentDidDisappear()).not.toThrow();
+      expect(() => tree.getInstance()!.onNavigationInteraction()).not.toThrow();
     });
 
-    it('calls didAppear on OriginalComponent', () => {
+    it('calls componentDidAppear on OriginalComponent', () => {
       const NavigationComponent = ComponentWrapper.wrap(componentName, MyLifecycleComponent, store);
       const tree = renderer.create(<NavigationComponent componentId={'component1'} />);
-      expect(didAppearCallback).toHaveBeenCalledTimes(0);
-      tree.getInstance()!.didAppear();
-      expect(didAppearCallback).toHaveBeenCalledTimes(1);
+      expect(componentDidAppearCallback).toHaveBeenCalledTimes(0);
+      tree.getInstance()!.componentDidAppear();
+      expect(componentDidAppearCallback).toHaveBeenCalledTimes(1);
     });
 
-    it('calls didDisappear on OriginalComponent', () => {
+    it('calls componentDidDisappear on OriginalComponent', () => {
       const NavigationComponent = ComponentWrapper.wrap(componentName, MyLifecycleComponent, store);
       const tree = renderer.create(<NavigationComponent componentId={'component1'} />);
-      expect(didDisappearCallback).toHaveBeenCalledTimes(0);
-      tree.getInstance()!.didDisappear();
-      expect(didDisappearCallback).toHaveBeenCalledTimes(1);
+      expect(componentDidDisappearCallback).toHaveBeenCalledTimes(0);
+      tree.getInstance()!.componentDidDisappear();
+      expect(componentDidDisappearCallback).toHaveBeenCalledTimes(1);
     });
 
-    it('calls onNavigationButtonPressed on OriginalComponent', () => {
+    it('calls onNavigationInteraction on OriginalComponent', () => {
       const NavigationComponent = ComponentWrapper.wrap(componentName, MyLifecycleComponent, store);
       const tree = renderer.create(<NavigationComponent componentId={'component1'} />);
-      expect(onNavigationButtonPressedCallback).toHaveBeenCalledTimes(0);
-      tree.getInstance()!.onNavigationButtonPressed();
-      expect(onNavigationButtonPressedCallback).toHaveBeenCalledTimes(1);
+      expect(onNavigationInteractionCallback).toHaveBeenCalledTimes(0);
+      tree.getInstance()!.onNavigationInteraction();
+      expect(onNavigationInteractionCallback).toHaveBeenCalledTimes(1);
     });
   });
 });

lib/src/components/ComponentWrapper.tsx

         store.cleanId(this.state.componentId);
       }
 
-      didAppear() {
-        if (this.originalComponentRef.didAppear) {
-          this.originalComponentRef.didAppear();
+      componentDidAppear() {
+        if (this.originalComponentRef.componentDidAppear) {
+          this.originalComponentRef.componentDidAppear();
         }
       }
 
-      didDisappear() {
-        if (this.originalComponentRef.didDisappear) {
-          this.originalComponentRef.didDisappear();
+      componentDidDisappear() {
+        if (this.originalComponentRef.componentDidDisappear) {
+          this.originalComponentRef.componentDidDisappear();
         }
       }
 
-      onNavigationButtonPressed(buttonId) {
-        if (this.originalComponentRef.onNavigationButtonPressed) {
-          this.originalComponentRef.onNavigationButtonPressed(buttonId);
+      onNavigationInteraction(buttonId) {
+        if (this.originalComponentRef.onNavigationInteraction) {
+          this.originalComponentRef.onNavigationInteraction(buttonId);
         }
       }
 
         return (
           <OriginalComponentClass
             ref={this._saveComponentRef}
-            { ...this.state.allProps }
+            {...this.state.allProps}
             componentId={this.state.componentId}
             key={this.state.componentId}
           />

lib/src/events/EventsRegistry.test.ts

   it('exposes appLaunch event', () => {
     const subscription = {};
     const cb = jest.fn();
-    mockNativeEventsReceiver.registerAppLaunched.mockReturnValueOnce(subscription);
+    mockNativeEventsReceiver.registerOnAppLaunched.mockReturnValueOnce(subscription);
 
-    const result = uut.appLaunched(cb);
+    const result = uut.onAppLaunched(cb);
 
     expect(result).toBe(subscription);
-    expect(mockNativeEventsReceiver.registerAppLaunched).toHaveBeenCalledTimes(1);
-    expect(mockNativeEventsReceiver.registerAppLaunched).toHaveBeenCalledWith(cb);
+    expect(mockNativeEventsReceiver.registerOnAppLaunched).toHaveBeenCalledTimes(1);
+    expect(mockNativeEventsReceiver.registerOnAppLaunched).toHaveBeenCalledWith(cb);
   });
 
   it('exposes componentDidAppear event', () => {
   it('exposes interaction event', () => {
     const subscription = {};
     const cb = jest.fn();
-    mockNativeEventsReceiver.registerInteraction.mockReturnValueOnce(subscription);
+    mockNativeEventsReceiver.registerOnNavigationInteraction.mockReturnValueOnce(subscription);
 
-    const result = uut.interaction(cb);
+    const result = uut.onNavigationInteraction(cb);
 
     expect(result).toBe(subscription);
-    expect(mockNativeEventsReceiver.registerInteraction).toHaveBeenCalledTimes(1);
-    expect(mockNativeEventsReceiver.registerInteraction).toHaveBeenCalledWith(cb);
+    expect(mockNativeEventsReceiver.registerOnNavigationInteraction).toHaveBeenCalledTimes(1);
+    expect(mockNativeEventsReceiver.registerOnNavigationInteraction).toHaveBeenCalledWith(cb);
   });
 });

lib/src/events/EventsRegistry.ts

     this.nativeEventsReceiver = nativeEventsReceiver;
   }
 
-  public appLaunched(callback: () => void): EventSubscription {
-    return this.nativeEventsReceiver.registerAppLaunched(callback);
+  public onAppLaunched(callback: () => void): EventSubscription {
+    return this.nativeEventsReceiver.registerOnAppLaunched(callback);
   }
 
   public componentDidAppear(callback: (componendId: string, componentName: string) => void): EventSubscription {
     return this.nativeEventsReceiver.registerComponentDidDisappear(callback);
   }
 
-  public interaction(callback: (name: string) => void): EventSubscription {
-    return this.nativeEventsReceiver.registerInteraction(callback);
+  public onNavigationInteraction(callback: (name: string) => void): EventSubscription {
+    return this.nativeEventsReceiver.registerOnNavigationInteraction(callback);
   }
 }