android: fixing app lifecycle

android/app/src/main/java/com/reactnativenavigation/NavigationActivity.java

@@ -5,51 +5,16 @@ import android.support.annotation.Nullable;
 import android.support.v7.app.AppCompatActivity;
 import android.view.View;
 
-import com.facebook.react.ReactInstanceManager;
-import com.facebook.react.ReactNativeHost;
-import com.facebook.react.ReactPackage;
-import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
-import com.facebook.react.shell.MainReactPackage;
-import com.reactnativenavigation.react.NavigationEventEmitter;
-import com.reactnativenavigation.react.NavigationPackage;
-import com.reactnativenavigation.react.ReactDevPermission;
 import com.reactnativenavigation.views.NavigationSplashView;
 
-import java.util.Arrays;
-import java.util.List;
-
 public class NavigationActivity extends AppCompatActivity implements DefaultHardwareBackBtnHandler {
-    private ReactNativeHost host;
     private View contentView;
 
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(new NavigationSplashView(this));
-
-        host = new ReactNativeHost(getApplication()) {
-            @Override
-            protected boolean getUseDeveloperSupport() {
-                return NavigationApplication.instance.isDebug();
-            }
-
-            @Override
-            protected List<ReactPackage> getPackages() {
-                return Arrays.asList(
-                        new MainReactPackage(),
-                        new NavigationPackage(NavigationActivity.this)
-                );
-            }
-        };
-
-        host.getReactInstanceManager().addReactInstanceEventListener(new ReactInstanceManager.ReactInstanceEventListener() {
-            @Override
-            public void onReactContextInitialized(ReactContext context) {
-                // TODO should we implement this line also if context already exists onCreate?
-                new NavigationEventEmitter(context).emitAppLaunched();
-            }
-        });
     }
 
     @Override
@@ -63,42 +28,8 @@ public class NavigationActivity extends AppCompatActivity implements DefaultHard
         return contentView;
     }
 
-    @Override
-    protected void onResume() {
-        super.onResume();
-        if (ReactDevPermission.shouldAskPermission()) {
-            ReactDevPermission.askPermission(this);
-        } else {
-            if (!host.getReactInstanceManager().hasStartedCreatingInitialContext()) {
-                host.getReactInstanceManager().createReactContextInBackground();
-            }
-            host.getReactInstanceManager().onHostResume(this, this);
-        }
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        if (host.getReactInstanceManager().hasStartedCreatingInitialContext()) {
-            host.getReactInstanceManager().onHostPause(this);
-        }
-    }
-
-    @Override
-    protected void onDestroy() {
-        super.onDestroy();
-        if (host.getReactInstanceManager().hasStartedCreatingInitialContext()) {
-            host.getReactInstanceManager().onHostDestroy(this);
-        }
-        host.clear();
-    }
-
     @Override
     public void invokeDefaultOnBackPressed() {
         onBackPressed();
     }
-
-    public ReactNativeHost getHost() {
-        return host;
-    }
 }

android/app/src/main/java/com/reactnativenavigation/NavigationApplication.java

@@ -1,26 +1,120 @@
 package com.reactnativenavigation;
 
+import android.app.Activity;
 import android.app.Application;
-import android.os.Handler;
-import android.os.Looper;
+import android.os.Bundle;
 
-public abstract class NavigationApplication extends Application {
+import com.facebook.react.ReactApplication;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactNativeHost;
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.facebook.react.shell.MainReactPackage;
+import com.reactnativenavigation.react.NavigationEventEmitter;
+import com.reactnativenavigation.react.NavigationPackage;
+import com.reactnativenavigation.react.ReactDevPermission;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public abstract class NavigationApplication extends Application implements ReactApplication {
     public static NavigationApplication instance;
-    private Handler handler;
+    private ReactNativeHost host;
 
     @Override
     public void onCreate() {
         super.onCreate();
         instance = this;
-        handler = new Handler(Looper.getMainLooper());
-    }
+        host = new ReactNativeHost(this) {
+            @Override
+            protected boolean getUseDeveloperSupport() {
+                return isDebug();
+            }
+
+            @Override
+            protected List<ReactPackage> getPackages() {
+                return Arrays.asList(
+                        new MainReactPackage(),
+                        new NavigationPackage()
+                );
+            }
+        };
+
+        registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
+            private AtomicBoolean creating = new AtomicBoolean(true);
+
+            @Override
+            public void onActivityCreated(final Activity activity, Bundle bundle) {
+                if (!(activity instanceof NavigationActivity)) return;
+                creating.set(true);
+            }
+
+            @Override
+            public void onActivityStarted(Activity activity) {
+            }
+
+            @Override
+            public void onActivityResumed(Activity activity) {
+                if (!(activity instanceof NavigationActivity)) return;
+
+                if (ReactDevPermission.shouldAskPermission()) {
+                    ReactDevPermission.askPermission(activity);
+                    return;
+                }
 
-    public void runOnUiThread(Runnable runnable) {
-        handler.post(runnable);
+                if (!host.getReactInstanceManager().hasStartedCreatingInitialContext()) {
+                    host.getReactInstanceManager().addReactInstanceEventListener(new ReactInstanceManager.ReactInstanceEventListener() {
+                        @Override
+                        public void onReactContextInitialized(ReactContext context) {
+                            host.getReactInstanceManager().removeReactInstanceEventListener(this);
+                            new NavigationEventEmitter(context).emitAppLaunched();
+                        }
+                    });
+                    host.getReactInstanceManager().createReactContextInBackground();
+                    host.getReactInstanceManager().onHostResume(activity, (DefaultHardwareBackBtnHandler) activity);
+                    return;
+                }
+
+                host.getReactInstanceManager().onHostResume(activity, (DefaultHardwareBackBtnHandler) activity);
+
+                if (creating.compareAndSet(true, false)) {
+                    new NavigationEventEmitter(host.getReactInstanceManager().getCurrentReactContext()).emitAppLaunched();
+                }
+            }
+
+            @Override
+            public void onActivityPaused(Activity activity) {
+                if (!(activity instanceof NavigationActivity)) return;
+
+                if (host.getReactInstanceManager().hasStartedCreatingInitialContext()) {
+                    host.getReactInstanceManager().onHostPause(activity);
+                }
+            }
+
+            @Override
+            public void onActivityStopped(Activity activity) {
+            }
+
+            @Override
+            public void onActivitySaveInstanceState(Activity activity, Bundle bundle) {
+            }
+
+            @Override
+            public void onActivityDestroyed(Activity activity) {
+                if (!(activity instanceof NavigationActivity)) return;
+
+                if (host.getReactInstanceManager().hasStartedCreatingInitialContext()) {
+                    host.getReactInstanceManager().onHostDestroy(activity);
+                }
+            }
+        });
     }
 
-    public void runOnUiThreadDelayed(Runnable runnable, long delayMillis) {
-        handler.postDelayed(runnable, delayMillis);
+    @Override
+    public ReactNativeHost getReactNativeHost() {
+        return host;
     }
 
     public abstract boolean isDebug();

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

@@ -16,6 +16,7 @@ import com.reactnativenavigation.layout.LayoutFactory;
 import com.reactnativenavigation.layout.LayoutNode;
 import com.reactnativenavigation.layout.StackLayout;
 import com.reactnativenavigation.layout.bottomtabs.BottomTabsCreator;
+import com.reactnativenavigation.utils.UiThread;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -23,11 +24,9 @@ import java.util.Map;
 
 public class NavigationModule extends ReactContextBaseJavaModule {
     private static final String NAME = "RNNBridgeModule";
-    private final NavigationActivity activity;
 
-    public NavigationModule(ReactApplicationContext context, NavigationActivity activity) {
-        super(context);
-        this.activity = activity;
+    public NavigationModule(ReactApplicationContext reactContext) {
+        super(reactContext);
     }
 
     @Override
@@ -37,66 +36,63 @@ public class NavigationModule extends ReactContextBaseJavaModule {
 
     @ReactMethod
     public void setRoot(final ReadableMap layoutTree) {
-        NavigationApplication.instance.runOnUiThread(new Runnable() {
+        if (getCurrentActivity() == null) return;
+
+        UiThread.post(new Runnable() {
             @Override
             public void run() {
-                getActivity().runOnUiThread(new Runnable() {
-                    @Override
-                    public void run() {
-                        LayoutFactory factory =
-                                new LayoutFactory(getActivity(), new LayoutFactory.ReactRootViewCreator() {
-                                    @Override
-                                    public View create(String id, String name) {
-                                        ReactRootView rootView = new ReactRootView(getActivity());
-                                        Bundle opts = new Bundle();
-                                        opts.putString("id", id);
-                                        rootView.startReactApplication(getActivity().getHost().getReactInstanceManager(), name, opts);
-                                        return rootView;
-                                    }
-                                }, new BottomTabsCreator());
-
-                        final LayoutNode layoutTreeRoot = readableMapToLayoutNode(layoutTree);
-                        final View rootView = factory.create(layoutTreeRoot);
-                        getActivity().setContentView(rootView);
-                    }
-                });
+                LayoutFactory factory =
+                        new LayoutFactory(getCurrentActivity(), new LayoutFactory.ReactRootViewCreator() {
+                            @Override
+                            public View create(String id, String name) {
+                                ReactRootView rootView = new ReactRootView(getCurrentActivity());
+                                Bundle opts = new Bundle();
+                                opts.putString("id", id);
+                                rootView.startReactApplication(NavigationApplication.instance.getReactNativeHost().getReactInstanceManager(), name, opts);
+                                return rootView;
+                            }
+                        }, new BottomTabsCreator());
+
+                final LayoutNode layoutTreeRoot = readableMapToLayoutNode(layoutTree);
+                final View rootView = factory.create(layoutTreeRoot);
+                getCurrentActivity().setContentView(rootView);
             }
         });
     }
 
-    private NavigationActivity getActivity() {
-        return activity;
-    }
-
     @ReactMethod
     public void push(String onContainerId, final ReadableMap layout) {
-        getActivity().runOnUiThread(new Runnable() {
+        if (getCurrentActivity() == null) return;
+
+        UiThread.post(new Runnable() {
             @Override
             public void run() {
                 LayoutFactory factory =
-                        new LayoutFactory(getActivity(), new LayoutFactory.ReactRootViewCreator() {
+                        new LayoutFactory(getCurrentActivity(), new LayoutFactory.ReactRootViewCreator() {
                             @Override
                             public View create(String id, String name) {
-                                ReactRootView rootView = new ReactRootView(getActivity());
+                                ReactRootView rootView = new ReactRootView(getCurrentActivity());
                                 Bundle opts = new Bundle();
                                 opts.putString("id", id);
-                                rootView.startReactApplication(getActivity().getHost().getReactInstanceManager(), name, opts);
+                                rootView.startReactApplication(NavigationApplication.instance.getReactNativeHost().getReactInstanceManager(), name, opts);
                                 return rootView;
                             }
                         }, new BottomTabsCreator());
                 final LayoutNode layoutNode = readableMapToLayoutNode(layout);
                 final View rootView = factory.create(layoutNode);
-                ((StackLayout) getActivity().getContentView()).push(rootView);
+                ((StackLayout) ((NavigationActivity) getCurrentActivity()).getContentView()).push(rootView);
             }
         });
     }
 
     @ReactMethod
     public void pop(String onContainerId) {
-        getActivity().runOnUiThread(new Runnable() {
+        if (getCurrentActivity() == null) return;
+
+        UiThread.post(new Runnable() {
             @Override
             public void run() {
-                ((StackLayout) getActivity().getContentView()).pop();
+                ((StackLayout) ((NavigationActivity) getCurrentActivity()).getContentView()).pop();
             }
         });
     }
@@ -132,5 +128,4 @@ public class NavigationModule extends ReactContextBaseJavaModule {
         }
         return map;
     }
-
 }

android/app/src/main/java/com/reactnativenavigation/react/NavigationPackage.java

@@ -5,7 +5,6 @@ import com.facebook.react.bridge.JavaScriptModule;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.uimanager.ViewManager;
-import com.reactnativenavigation.NavigationActivity;
 
 import java.util.Arrays;
 import java.util.Collections;
@@ -13,16 +12,10 @@ import java.util.List;
 
 public class NavigationPackage implements ReactPackage {
 
-    private final NavigationActivity activity;
-
-    public NavigationPackage(NavigationActivity activity) {
-        this.activity = activity;
-    }
-
     @Override
     public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
         return Arrays.<NativeModule>asList(
-                new NavigationModule(reactContext, activity)
+                new NavigationModule(reactContext)
         );
     }
 

android/app/src/main/java/com/reactnativenavigation/utils/UiThread.java

@@ -0,0 +1,16 @@
+package com.reactnativenavigation.utils;
+
+import android.os.Handler;
+import android.os.Looper;
+
+public class UiThread {
+    private static final Handler handler = new Handler(Looper.getMainLooper());
+
+    public static void post(Runnable runnable) {
+        handler.post(runnable);
+    }
+
+    public static void postDelayed(Runnable runnable, long millis) {
+        handler.postDelayed(runnable, millis);
+    }
+}

playground/android/app/src/androidTest/java/com/reactnativenavigation/playground/ApplicationLifecycleTest.java

@@ -11,6 +11,8 @@ import android.support.test.uiautomator.UiSelector;
 
 import com.reactnativenavigation.views.NavigationSplashView;
 
+import org.junit.After;
+import org.junit.Before;
 import org.junit.FixMethodOrder;
 import org.junit.Rule;
 import org.junit.Test;
@@ -30,26 +32,19 @@ import static org.assertj.core.api.Java6Assertions.assertThat;
 @FixMethodOrder(value = MethodSorters.NAME_ASCENDING)
 public class ApplicationLifecycleTest {
 
-    private ReactIdlingResource reactIdlingResource;
+    private ReactIdlingResource reactIdlingResource = new ReactIdlingResource();
 
     @Rule
-    public ActivityTestRule<MainActivity> rule = new ActivityTestRule<MainActivity>(MainActivity.class, false, false) {
-        @Override
-        protected void afterActivityLaunched() {
-            super.afterActivityLaunched();
-            reactIdlingResource = new ReactIdlingResource(getActivity());
-            Espresso.registerIdlingResources(reactIdlingResource);
-        }
+    public ActivityTestRule<MainActivity> rule = new ActivityTestRule<>(MainActivity.class, false, false);
 
-        @Override
-        protected void afterActivityFinished() {
-            super.afterActivityFinished();
-            Espresso.unregisterIdlingResources(reactIdlingResource);
-        }
-    };
+    @Before
+    public void beforeEach() {
+        Espresso.registerIdlingResources(reactIdlingResource);
+    }
 
-    private void launchActivity() {
-        rule.launchActivity(null);
+    @After
+    public void afterEach() {
+        Espresso.unregisterIdlingResources(reactIdlingResource);
     }
 
     private UiDevice uiDevice() {
@@ -67,23 +62,16 @@ public class ApplicationLifecycleTest {
     }
 
     @Test
-    public void _1_acceptsOverlayPermissions_ShowsWelcomeScreen() throws Exception {
-        launchActivity();
-        acceptOverlayPermissionIfNeeded();
-        onView(withText("React Native Navigation!")).check(matches(isDisplayed()));
-    }
-
-    @Test
-    public void _2_showsSplashOnStartup() throws Exception {
-        launchActivity();
+    public void _1_ShowSplash_AcceptsOverlayPermissions_ShowsWelcomeScreen() throws Exception {
+        rule.launchActivity(null);
         assertThat(rule.getActivity().getContentView()).isNotNull().isInstanceOf(NavigationSplashView.class);
         acceptOverlayPermissionIfNeeded();
+        onView(withText("React Native Navigation!")).check(matches(isDisplayed()));
     }
 
     @Test
-    public void _3_relaunchFromBackground() throws Exception {
-        launchActivity();
-        acceptOverlayPermissionIfNeeded();
+    public void _2_relaunchFromBackground() throws Exception {
+        rule.launchActivity(null);
         onView(withText("React Native Navigation!")).check(matches(isDisplayed()));
 
         uiDevice().pressHome();
@@ -92,6 +80,14 @@ public class ApplicationLifecycleTest {
 
         onView(withText("React Native Navigation!")).check(matches(isDisplayed()));
     }
+
+//    @Test
+//    public void _3_relaunchAfterClose() throws Exception {
+//        launchActivity();
+//        uiDevice().pressBack();
+//        launchActivity();
+//        onView(withText("React Native Navigation!")).check(matches(isDisplayed()));
+//    }
 }
 //    xdescribe('android application lifecycle', () => {
 ////launch, pause, and resume

playground/android/app/src/androidTest/java/com/reactnativenavigation/playground/ReactIdlingResource.java

@@ -4,24 +4,22 @@ import android.support.test.espresso.IdlingResource;
 
 import com.facebook.react.ReactNativeHost;
 import com.facebook.react.bridge.NotThreadSafeBridgeIdleDebugListener;
-import com.reactnativenavigation.NavigationActivity;
 import com.reactnativenavigation.NavigationApplication;
+import com.reactnativenavigation.utils.UiThread;
 
 import java.util.concurrent.atomic.AtomicBoolean;
 
 class ReactIdlingResource implements IdlingResource, NotThreadSafeBridgeIdleDebugListener {
-    private final NavigationActivity activity;
     private ResourceCallback callback;
     private AtomicBoolean registered = new AtomicBoolean(false);
     private AtomicBoolean bridgeIdle = new AtomicBoolean(false);
 
-    ReactIdlingResource(NavigationActivity activity) {
-        this.activity = activity;
-        NavigationApplication.instance.runOnUiThreadDelayed(new Runnable() {
+    ReactIdlingResource() {
+        UiThread.postDelayed(new Runnable() {
             @Override
             public void run() {
                 if (!isIdleNow()) {
-                    NavigationApplication.instance.runOnUiThreadDelayed(this, 10);
+                    UiThread.postDelayed(this, 10);
                 }
             }
         }, 10);
@@ -35,7 +33,7 @@ class ReactIdlingResource implements IdlingResource, NotThreadSafeBridgeIdleDebu
 
     @Override
     public boolean isIdleNow() {
-        ReactNativeHost host = activity.getHost();
+        ReactNativeHost host = NavigationApplication.instance.getReactNativeHost();
         boolean hasContext = host != null
                 && host.getReactInstanceManager() != null
                 && host.getReactInstanceManager().getCurrentReactContext() != null;
@@ -48,7 +46,7 @@ class ReactIdlingResource implements IdlingResource, NotThreadSafeBridgeIdleDebu
         }
 
         boolean idle = bridgeIdle.get();
-        if (idle) {
+        if (idle && callback != null) {
             callback.onTransitionToIdle();
         }
         return idle;