Support headlessJs (#1444)

Currently startApp is called from global context which results in the
app being launched when headlessJs tasks run in the background.
In order to support this use case, while not breaking existing users,
this commit adds two mechanisms which should help users detrmine if
the native Activity is running and startApp can be called safely.

1. RNN.appLaunched event is emitted is SplashActivity starts and react
   context has already been created. This is the use case of openeing
   the app while headless js task was started or has just finished and
   react context is in a "pasued" state.

2. Navigation.isAppLaunched() convenience method has been added.
   It returns a promise which when resolved, indicates if the app
   is launched and we should show the ui or not.

Usage

import {Navigation, NativeEventsReceiver} from 'react-native-navigation';

Promise.resolve(Navigation.isAppLaunched())
  .then(appLaunched => {
    if (appLaunched) {
      startApp();
    } else {
      new NativeEventsReceiver().appLaunched(startApp);
    }
  });

function startApp() {
  Navigation.startTabBasedApp({ ... });
}

android/app/src/main/java/com/reactnativenavigation/bridge/EventEmitter.java

         }
         reactGateway.getReactEventEmitter().sendEvent(eventId, Arguments.createMap());
     }
+
+    public void sendAppLaunchedEvent() {
+        if (!NavigationApplication.instance.isReactContextInitialized()) {
+            return;
+        }
+        reactGateway.getReactEventEmitter().sendEvent("RNN.appLaunched", Arguments.createMap());
+    }
 }

android/app/src/main/java/com/reactnativenavigation/bridge/NavigationReactModule.java

     public void getOrientation(Promise promise) {
         NavigationCommandsHandler.getOrientation(promise);
     }
+
+    @ReactMethod
+    public void isAppLaunched(Promise promise) {
+        NavigationCommandsHandler.isAppLaunched(promise);
+    }
 }

android/app/src/main/java/com/reactnativenavigation/controllers/NavigationCommandsHandler.java

         }
         promise.resolve(OrientationHelper.getOrientation(currentActivity));
     }
+
+    public static void isAppLaunched(Promise promise) {
+        final boolean isAppLaunched = SplashActivity.isResumed || NavigationActivity.currentActivity != null;
+        promise.resolve(isAppLaunched);
+    }
 }

android/app/src/main/java/com/reactnativenavigation/controllers/SplashActivity.java

 import com.reactnativenavigation.react.ReactDevPermission;
 
 public abstract class SplashActivity extends AppCompatActivity {
+    public static boolean isResumed = false;
 
     @Override
     protected void onCreate(@Nullable Bundle savedInstanceState) {
     @Override
     protected void onResume() {
         super.onResume();
+        isResumed = true;
 
         if (NavigationApplication.instance.getReactGateway().hasStartedCreatingContext()) {
+            NavigationApplication.instance.getEventEmitter().sendAppLaunchedEvent();
+            overridePendingTransition(0, 0);
             finish();
             return;
         }
         NavigationApplication.instance.startReactContextOnceInBackgroundAndExecuteJS();
     }
 
+    @Override
+    protected void onPause() {
+        super.onPause();
+        isResumed = false;
+    }
+
     private void setSplashLayout() {
         final int splashLayout = getSplashLayout();
         if (splashLayout > 0) {

src/NativeEventsReceiver.js

+import {
+  NativeAppEventEmitter,
+  DeviceEventEmitter,
+  Platform
+} from 'react-native';
+export default class NativeEventsReceiver {
+  constructor() {
+    this.emitter = Platform.OS === 'android' ? DeviceEventEmitter : NativeAppEventEmitter;
+  }
+
+  appLaunched(callback) {
+    this.emitter.addListener('RNN.appLaunched', callback);
+  }
+}

src/Navigation.js

   }
 }
 
+async function isAppLaunched() {
+  return await platformSpecific.isAppLaunched();
+}
+
 export default {
   getRegisteredScreen,
   registerComponent,
   startSingleScreenApp: startSingleScreenApp,
   setEventHandler: setEventHandler,
   clearEventHandler: clearEventHandler,
-  handleDeepLink: handleDeepLink
+  handleDeepLink: handleDeepLink,
+  isAppLaunched: isAppLaunched
 };

src/deprecated/indexDeprecated.android.js

 import Navigation from './../Navigation';
 import SharedElementTransition from './../views/sharedElementTransition';
+import NativeEventsReceiver from './../NativeEventsReceiver';
 
 module.exports = {
   Navigation,
-  SharedElementTransition
+  SharedElementTransition,
+  NativeEventsReceiver
 };
-

src/deprecated/indexDeprecated.ios.js

 import Navigation from './../Navigation';
 import {NavigationToolBarIOS} from './controllers';
 import SharedElementTransition from '../views/sharedElementTransition';
+import NativeEventsReceiver from './../NativeEventsReceiver';
 
 module.exports = {
   Navigation,
   NavigationToolBarIOS,
-  SharedElementTransition
+  SharedElementTransition,
+  NativeEventsReceiver
 };

src/deprecated/platformSpecificDeprecated.android.js

   newPlatformSpecific.dismissContextualMenu();
 }
 
+async function isAppLaunched() {
+  return await newPlatformSpecific.isAppLaunched();
+}
+
 export default {
   startTabBasedApp,
   startSingleScreenApp,
   showSnackbar,
   dismissSnackbar,
   showContextualMenu,
-  dismissContextualMenu
+  dismissContextualMenu,
+  isAppLaunched
 };

src/platformSpecific.android.js

   NativeReactModule.setScreenStyle(screenInstanceId, style);
 }
 
+async function isAppLaunched() {
+  return await NativeReactModule.isAppLaunched();
+}
+
 module.exports = {
   startApp,
   push,
   dismissSnackbar,
   showContextualMenu,
   dismissContextualMenu,
-  setScreenStyle
+  setScreenStyle,
+  isAppLaunched
 };