android: refactoring

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

@@ -1,21 +1,11 @@
 package com.reactnativenavigation;
 
-import android.app.Activity;
 import android.app.Application;
-import android.os.Bundle;
 
 import com.facebook.react.ReactApplication;
-import com.facebook.react.ReactInstanceManager;
 import com.facebook.react.ReactNativeHost;
-import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
-import com.reactnativenavigation.react.NavigationEventEmitter;
+import com.reactnativenavigation.controllers.NavigationActivityLifecycleHandler;
 import com.reactnativenavigation.react.NavigationReactNativeHost;
-import com.reactnativenavigation.react.ReactDevPermission;
-import com.reactnativenavigation.utils.UiThread;
-
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicLong;
 
 public abstract class NavigationApplication extends Application implements ReactApplication {
     public static NavigationApplication instance;
@@ -26,93 +16,7 @@ public abstract class NavigationApplication extends Application implements React
         super.onCreate();
         instance = this;
         host = new NavigationReactNativeHost(this);
-
-        registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
-            private AtomicBoolean creating = new AtomicBoolean(false);
-            private AtomicLong startTime = new AtomicLong(0);
-
-            @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;
-                }
-
-                if (!host.getReactInstanceManager().hasStartedCreatingInitialContext()) {
-                    creating.set(false);
-                    startTime.set(System.currentTimeMillis());
-                    host.getReactInstanceManager().addReactInstanceEventListener(new ReactInstanceManager.ReactInstanceEventListener() {
-                        @Override
-                        public void onReactContextInitialized(final ReactContext context) {
-                            host.getReactInstanceManager().removeReactInstanceEventListener(this);
-
-                            long millisPassed = System.currentTimeMillis() - startTime.get();
-                            long diff = 1000 - millisPassed;
-
-                            UiThread.postDelayed(new Runnable() {
-                                @Override
-                                public void run() {
-                                    new NavigationEventEmitter(context).emitAppLaunched();
-                                }
-                            }, diff);
-                        }
-                    });
-                    host.getReactInstanceManager().createReactContextInBackground();
-                    host.getReactInstanceManager().onHostResume(activity, (DefaultHardwareBackBtnHandler) activity);
-                    return;
-                }
-
-                host.getReactInstanceManager().onHostResume(activity, (DefaultHardwareBackBtnHandler) activity);
-
-                if (creating.compareAndSet(true, false)) {
-                    // this should run only after activity closed and started again, but we already HAVE context
-                    UiThread.postDelayed(new Runnable() {
-                        @Override
-                        public void run() {
-                            new NavigationEventEmitter(host.getReactInstanceManager().getCurrentReactContext()).emitAppLaunched();
-                        }
-                    }, 1000);
-                }
-            }
-
-            @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);
-                }
-            }
-        });
+        registerActivityLifecycleCallbacks(new NavigationActivityLifecycleHandler(host.getReactInstanceManager()));
     }
 
     @Override
@@ -121,4 +25,6 @@ public abstract class NavigationApplication extends Application implements React
     }
 
     public abstract boolean isDebug();
+
+
 }

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

@@ -0,0 +1,126 @@
+package com.reactnativenavigation.controllers;
+
+import android.app.Activity;
+import android.app.Application;
+import android.os.Bundle;
+
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.bridge.ReactContext;
+import com.reactnativenavigation.NavigationActivity;
+import com.reactnativenavigation.react.NavigationEventEmitter;
+import com.reactnativenavigation.react.ReactDevPermission;
+import com.reactnativenavigation.utils.UiThread;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+
+public class NavigationActivityLifecycleHandler implements Application.ActivityLifecycleCallbacks {
+    private final ReactInstanceManager reactInstanceManager;
+    private final AtomicBoolean creating = new AtomicBoolean(false);
+    private final AtomicLong startTime = new AtomicLong(0);
+
+    public NavigationActivityLifecycleHandler(ReactInstanceManager reactInstanceManager) {
+        this.reactInstanceManager = reactInstanceManager;
+    }
+
+    @Override
+    public void onActivityCreated(final Activity activity, Bundle bundle) {
+        if (activity instanceof NavigationActivity) {
+            handleCreated();
+        }
+    }
+
+    @Override
+    public void onActivityStarted(Activity activity) {
+    }
+
+    @Override
+    public void onActivityResumed(Activity activity) {
+        if (activity instanceof NavigationActivity) {
+            handleResumed((NavigationActivity) activity);
+        }
+    }
+
+    @Override
+    public void onActivityPaused(Activity activity) {
+        if (activity instanceof NavigationActivity) {
+            handlePaused((NavigationActivity) 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) {
+            handleDestroyed((NavigationActivity) activity);
+        }
+    }
+
+    private void handleCreated() {
+        creating.set(true);
+    }
+
+    private void handleResumed(NavigationActivity activity) {
+        if (ReactDevPermission.shouldAskPermission()) {
+            ReactDevPermission.askPermission(activity);
+        } else if (shouldCreateContext()) {
+            createContextAndEmitLaunched();
+            reactInstanceManager.onHostResume(activity, activity);
+        } else {
+            reactInstanceManager.onHostResume(activity, activity);
+            if (creating.compareAndSet(true, false)) {
+                // this should run only after activity closed and started again, but we already HAVE context
+                emitAppLaunchedAfterDelay(reactInstanceManager.getCurrentReactContext(), 1000);
+            }
+        }
+    }
+
+    private void createContextAndEmitLaunched() {
+        creating.set(false);
+        startTime.set(System.currentTimeMillis());
+        reactInstanceManager.addReactInstanceEventListener(new ReactInstanceManager.ReactInstanceEventListener() {
+            @Override
+            public void onReactContextInitialized(final ReactContext context) {
+                reactInstanceManager.removeReactInstanceEventListener(this);
+
+                long millisPassed = System.currentTimeMillis() - startTime.get();
+                long diff = 1000 - millisPassed;
+
+                emitAppLaunchedAfterDelay(context, diff);
+            }
+        });
+        reactInstanceManager.createReactContextInBackground();
+    }
+
+    private boolean shouldCreateContext() {
+        return !reactInstanceManager.hasStartedCreatingInitialContext();
+    }
+
+    private void handlePaused(NavigationActivity activity) {
+        if (reactInstanceManager.hasStartedCreatingInitialContext()) {
+            reactInstanceManager.onHostPause(activity);
+        }
+    }
+
+    private void handleDestroyed(NavigationActivity activity) {
+        if (reactInstanceManager.hasStartedCreatingInitialContext()) {
+            reactInstanceManager.onHostDestroy(activity);
+        }
+    }
+
+    private void emitAppLaunchedAfterDelay(final ReactContext context, long delay) {
+        UiThread.postDelayed(new Runnable() {
+            @Override
+            public void run() {
+                new NavigationEventEmitter(context).emitAppLaunched();
+            }
+        }, delay);
+    }
+}