Android implementation of Navigation.setDefaultOptions (#2299)

Usage
```js
Navigation.setDefaultOptions({
      topBar: {
        backgroundColor: 'red'
      }
    });
```

lib/android/app/src/main/java/com/reactnativenavigation/parse/BottomTabsOptions.java

 package com.reactnativenavigation.parse;
 
 
+import com.reactnativenavigation.parse.NavigationOptions.BooleanOptions;
+
 import org.json.JSONObject;
 
 public class BottomTabsOptions implements DEFAULT_VALUES {
 		options.currentTabId = json.optString("currentTabId", NO_VALUE);
 		options.currentTabIndex = json.optInt("currentTabIndex", NO_INT_VALUE);
 		options.tabBadge = json.optInt("tabBadge", NO_INT_VALUE);
-		options.hidden = NavigationOptions.BooleanOptions.parse(json.optString("hidden"));
-		options.animateHide = NavigationOptions.BooleanOptions.parse(json.optString("animateHide"));
+		options.hidden = BooleanOptions.parse(json.optString("hidden"));
+		options.animateHide = BooleanOptions.parse(json.optString("animateHide"));
 
 		return options;
 	}
 
 	public int tabBadge = NO_INT_VALUE;
-	public NavigationOptions.BooleanOptions hidden = NavigationOptions.BooleanOptions.False;
-	public NavigationOptions.BooleanOptions animateHide = NavigationOptions.BooleanOptions.False;
+	public BooleanOptions hidden = BooleanOptions.False;
+	public BooleanOptions animateHide = BooleanOptions.False;
 	public int currentTabIndex = NO_INT_VALUE;
 	public String currentTabId = NO_VALUE;
 
 			currentTabId = other.currentTabId;
 		}
 		if (NO_INT_VALUE != other.currentTabIndex) {
-			currentTabId = other.currentTabId;
+            currentTabIndex = other.currentTabIndex;
 		}
 		if (NO_INT_VALUE != other.tabBadge) {
 			tabBadge = other.tabBadge;
 		}
-		if (other.hidden != NavigationOptions.BooleanOptions.NoValue) {
+		if (other.hidden != BooleanOptions.NoValue) {
 			hidden = other.hidden;
 		}
-		if (other.animateHide != NavigationOptions.BooleanOptions.NoValue) {
+		if (other.animateHide != BooleanOptions.NoValue) {
 			animateHide = other.animateHide;
 		}
 	}
+
+    void mergeWithDefault(final BottomTabsOptions defaultOptions) {
+        if (NO_VALUE.equals(currentTabId)) {
+            currentTabId = defaultOptions.currentTabId;
+        }
+        if (NO_INT_VALUE == currentTabIndex) {
+            currentTabIndex = defaultOptions.currentTabIndex;
+        }
+        if (NO_INT_VALUE == tabBadge) {
+            tabBadge = defaultOptions.tabBadge;
+        }
+        if (hidden == BooleanOptions.NoValue) {
+            hidden = defaultOptions.hidden;
+        }
+        if (animateHide == BooleanOptions.NoValue) {
+            animateHide = defaultOptions.animateHide;
+        }
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/parse/LayoutFactory.java

 
 	private final Activity activity;
 	private final ReactInstanceManager reactInstanceManager;
+    private NavigationOptions defaultOptions;
 
-	public LayoutFactory(Activity activity, final ReactInstanceManager reactInstanceManager) {
+    public LayoutFactory(Activity activity, final ReactInstanceManager reactInstanceManager, NavigationOptions defaultOptions) {
 		this.activity = activity;
 		this.reactInstanceManager = reactInstanceManager;
-	}
+        this.defaultOptions = defaultOptions;
+    }
 
 	public ViewController create(final LayoutNode node) {
 		switch (node.type) {
 	private ViewController createContainer(LayoutNode node) {
 		String id = node.id;
 		String name = node.data.optString("name");
-		NavigationOptions navigationOptions = NavigationOptions.parse(node.data.optJSONObject("navigationOptions"));
+		NavigationOptions navigationOptions = NavigationOptions.parse(node.data.optJSONObject("navigationOptions"), defaultOptions);
 		return new ContainerViewController(activity, id, name,
 				new TopbarContainerViewCreator(new ReactContainerViewCreator(reactInstanceManager)), navigationOptions);
 	}

lib/android/app/src/main/java/com/reactnativenavigation/parse/NavigationOptions.java

 package com.reactnativenavigation.parse;
 
-import android.graphics.Color;
-import android.support.annotation.ColorInt;
 import android.support.annotation.NonNull;
 
 import org.json.JSONObject;
 
 public class NavigationOptions implements DEFAULT_VALUES {
 
-	public enum BooleanOptions {
+    public enum BooleanOptions {
 		True,
 		False,
 		NoValue;
 		}
 	}
 
+    @NonNull
+    public static NavigationOptions parse(JSONObject json) {
+        return parse(json, new NavigationOptions());
+    }
+
 	@NonNull
-	public static NavigationOptions parse(JSONObject json) {
+	public static NavigationOptions parse(JSONObject json, @NonNull NavigationOptions defaultOptions) {
 		NavigationOptions result = new NavigationOptions();
 		if (json == null) return result;
 
 		result.topBarOptions = TopBarOptions.parse(json.optJSONObject("topBar"));
 		result.bottomTabsOptions = BottomTabsOptions.parse(json.optJSONObject("tabBar"));
 
-		return result;
+		return result.withDefaultOptions(defaultOptions);
 	}
 
 	public TopBarOptions topBarOptions = new TopBarOptions();
 	public BottomTabsOptions bottomTabsOptions = new BottomTabsOptions();
 
 	public void mergeWith(final NavigationOptions other) {
-		topBarOptions.mergeWith(other.topBarOptions);
+        topBarOptions.mergeWith(other.topBarOptions);
 		bottomTabsOptions.mergeWith(other.bottomTabsOptions);
 	}
+
+    NavigationOptions withDefaultOptions(final NavigationOptions other) {
+        topBarOptions.mergeWithDefault(other.topBarOptions);
+        bottomTabsOptions.mergeWithDefault(other.bottomTabsOptions);
+        return this;
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/parse/TopBarOptions.java

 			animateHide = other.animateHide;
 		}
 	}
+
+    void mergeWithDefault(TopBarOptions defaultOptions) {
+        if (NO_VALUE.equals(title))
+            title = defaultOptions.title;
+        if (backgroundColor == NO_COLOR_VALUE)
+            backgroundColor = defaultOptions.backgroundColor;
+        if (textColor == NO_COLOR_VALUE)
+            textColor = defaultOptions.textColor;
+        if (textFontSize == NO_FLOAT_VALUE)
+            textFontSize = defaultOptions.textFontSize;
+        if (NO_VALUE.equals(textFontFamily))
+            textFontFamily = defaultOptions.textFontFamily;
+        if (hidden == NavigationOptions.BooleanOptions.NoValue)
+            hidden = defaultOptions.hidden;
+        if (animateHide == NavigationOptions.BooleanOptions.NoValue)
+            animateHide = defaultOptions.animateHide;
+    }
 }

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

 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
 import com.reactnativenavigation.NavigationActivity;
+import com.reactnativenavigation.parse.JSONParser;
 import com.reactnativenavigation.parse.LayoutFactory;
 import com.reactnativenavigation.parse.LayoutNode;
-import com.reactnativenavigation.parse.NavigationOptions;
-import com.reactnativenavigation.parse.JSONParser;
 import com.reactnativenavigation.parse.LayoutNodeParser;
+import com.reactnativenavigation.parse.NavigationOptions;
 import com.reactnativenavigation.parse.OverlayOptions;
 import com.reactnativenavigation.utils.UiThread;
-import com.reactnativenavigation.viewcontrollers.ContainerViewController;
 import com.reactnativenavigation.viewcontrollers.Navigator;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.viewcontrollers.overlay.OverlayFactory;
 
-import org.json.JSONObject;
-
 public class NavigationModule extends ReactContextBaseJavaModule {
 	private static final String NAME = "RNNBridgeModule";
 	private final ReactInstanceManager reactInstanceManager;
 		});
 	}
 
+	@ReactMethod
+	public void setDefaultOptions(final ReadableMap options) {
+        final NavigationOptions defaultOptions = NavigationOptions.parse(JSONParser.parse(options));
+        handle(new Runnable() {
+            @Override
+            public void run() {
+                navigator().setDefaultOptions(defaultOptions);
+            }
+        });
+    }
+
 	@ReactMethod
 	public void setOptions(final String onContainerId, final ReadableMap options) {
 		final NavigationOptions navOptions = NavigationOptions.parse(JSONParser.parse(options));
 
 	@NonNull
 	private LayoutFactory newLayoutFactory() {
-		return new LayoutFactory(activity(), reactInstanceManager);
+		return new LayoutFactory(activity(), reactInstanceManager, navigator().getDefaultOptions());
 	}
 
 	private void handle(Runnable task) {

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/Navigator.java

 import com.reactnativenavigation.presentation.OverlayPresenter;
 import com.reactnativenavigation.utils.CompatUtils;
 
-import org.json.JSONObject;
-
 import java.util.Collection;
 import java.util.Collections;
 
 	private final ModalStack modalStack = new ModalStack();
 	private ViewController root;
 	private OverlayPresenter overlayPresenter;
+    private NavigationOptions defaultOptions = new NavigationOptions();
 
-	public Navigator(final Activity activity) {
+    public Navigator(final Activity activity) {
 		super(activity, "navigator" + CompatUtils.generateViewId());
 	}
 
 		}
 	}
 
+    public void setDefaultOptions(NavigationOptions defaultOptions) {
+        this.defaultOptions = defaultOptions;
+    }
+
+    public NavigationOptions getDefaultOptions() {
+        return defaultOptions;
+    }
+
 	public void setOptions(final String containerId, NavigationOptions options) {
 		ViewController target = findControllerById(containerId);
 		if (target instanceof NavigationOptionsListener) {

lib/android/app/src/test/java/com/reactnativenavigation/parse/NavigationOptionsTest.java

 package com.reactnativenavigation.parse;
 
+import android.support.annotation.NonNull;
+
 import com.reactnativenavigation.BaseTest;
 
+import org.json.JSONException;
 import org.json.JSONObject;
 import org.junit.Test;
 
 
 public class NavigationOptionsTest extends BaseTest {
 
-	@Test
+    private static final String TITLE = "the title";
+    private static final int TOP_BAR_BACKGROUND_COLOR = 0xff123456;
+    private static final int TOP_BAR_TEXT_COLOR = 0xff123456;
+    private static final int TOP_BAR_FONT_SIZE = 18;
+    private static final String TOP_BAR_FONT_FAMILY = "HelveticaNeue-CondensedBold";
+    private static final NavigationOptions.BooleanOptions TOP_BAR_HIDDEN = True;
+    private static final NavigationOptions.BooleanOptions BOTTOM_TABS_ANIMATE_HIDE = True;
+    private static final NavigationOptions.BooleanOptions BOTTOM_TABS_HIDDEN = True;
+    private static final int BOTTOM_TABS_BADGE = 3;
+    private static final String BOTTOM_TABS_CURRENT_TAB_ID = "ContainerId";
+    private static final int BOTTOM_TABS_CURRENT_TAB_INDEX = 1;
+
+    @Test
 	public void parsesNullAsDefaultEmptyOptions() throws Exception {
 		assertThat(NavigationOptions.parse(null)).isNotNull();
 	}
 
 	@Test
 	public void parsesJson() throws Exception {
-		JSONObject json = new JSONObject();
-		JSONObject topBarJson = new JSONObject();
+		JSONObject json = new JSONObject()
+                .put("topBar", createTopBar())
+                .put("tabBar", createTabBar());
+		NavigationOptions result = NavigationOptions.parse(json);
+        assertResult(result);
+	}
 
-		topBarJson.put("title", "the title");
-		topBarJson.put("backgroundColor", 0xff123456);
-		topBarJson.put("textColor", 0xff123456);
-		topBarJson.put("textFontSize", 18);
-		topBarJson.put("textFontFamily", "HelveticaNeue-CondensedBold");
-		topBarJson.put("hidden", true);
+    private void assertResult(NavigationOptions result) {
+        assertThat(result.topBarOptions.title).isEqualTo(TITLE);
+        assertThat(result.topBarOptions.backgroundColor).isEqualTo(TOP_BAR_BACKGROUND_COLOR);
+        assertThat(result.topBarOptions.textColor).isEqualTo(TOP_BAR_TEXT_COLOR);
+        assertThat(result.topBarOptions.textFontSize).isEqualTo(TOP_BAR_FONT_SIZE);
+        assertThat(result.topBarOptions.textFontFamily).isEqualTo(TOP_BAR_FONT_FAMILY);
+        assertThat(result.topBarOptions.hidden).isEqualTo(TOP_BAR_HIDDEN);
+        assertThat(result.bottomTabsOptions.animateHide).isEqualTo(BOTTOM_TABS_ANIMATE_HIDE);
+        assertThat(result.bottomTabsOptions.hidden).isEqualTo(BOTTOM_TABS_HIDDEN);
+        assertThat(result.bottomTabsOptions.tabBadge).isEqualTo(BOTTOM_TABS_BADGE);
+        assertThat(result.bottomTabsOptions.currentTabId).isEqualTo(BOTTOM_TABS_CURRENT_TAB_ID);
+        assertThat(result.bottomTabsOptions.currentTabIndex).isEqualTo(BOTTOM_TABS_CURRENT_TAB_INDEX);
+    }
 
-		json.put("topBar", topBarJson);
+    @NonNull
+    private JSONObject createTabBar() throws JSONException {
+        return new JSONObject()
+            .put("currentTabId", BOTTOM_TABS_CURRENT_TAB_ID)
+            .put("currentTabIndex", BOTTOM_TABS_CURRENT_TAB_INDEX)
+            .put("hidden", BOTTOM_TABS_HIDDEN)
+            .put("animateHide", BOTTOM_TABS_ANIMATE_HIDE)
+            .put("tabBadge", BOTTOM_TABS_BADGE);
+    }
 
-		JSONObject tabBarJson = new JSONObject();
-		tabBarJson.put("currentTabId", "ContainerId");
-		tabBarJson.put("currentTabIndex", 1);
-		tabBarJson.put("hidden", true);
-		tabBarJson.put("animateHide", true);
-		tabBarJson.put("tabBadge", 3);
+    @NonNull
+    private JSONObject createTopBar() throws JSONException {
+        return new JSONObject()
+            .put("title", TITLE)
+            .put("backgroundColor", TOP_BAR_BACKGROUND_COLOR)
+            .put("textColor", TOP_BAR_TEXT_COLOR)
+            .put("textFontSize", TOP_BAR_FONT_SIZE)
+            .put("textFontFamily", TOP_BAR_FONT_FAMILY)
+            .put("hidden", TOP_BAR_HIDDEN);
+    }
 
-		json.put("tabBar", tabBarJson);
+    @NonNull
+    private JSONObject createOtherTopBar() throws JSONException {
+        return new JSONObject()
+                .put("title", TITLE)
+                .put("backgroundColor", TOP_BAR_BACKGROUND_COLOR)
+                .put("textColor", TOP_BAR_TEXT_COLOR)
+                .put("textFontSize", TOP_BAR_FONT_SIZE)
+                .put("textFontFamily", TOP_BAR_FONT_FAMILY)
+                .put("hidden", TOP_BAR_HIDDEN);
+    }
 
-		NavigationOptions result = NavigationOptions.parse(json);
-		assertThat(result.topBarOptions.title).isEqualTo("the title");
-		assertThat(result.topBarOptions.backgroundColor).isEqualTo(0xff123456);
-		assertThat(result.topBarOptions.textColor).isEqualTo(0xff123456);
-		assertThat(result.topBarOptions.textFontSize).isEqualTo(18);
-		assertThat(result.topBarOptions.textFontFamily).isEqualTo("HelveticaNeue-CondensedBold");
-		assertThat(result.topBarOptions.hidden).isEqualTo(True);
-		assertThat(result.bottomTabsOptions.animateHide).isEqualTo(True);
-		assertThat(result.bottomTabsOptions.hidden).isEqualTo(True);
-		assertThat(result.bottomTabsOptions.tabBadge).isEqualTo(3);
-		assertThat(result.bottomTabsOptions.currentTabId).isEqualTo("ContainerId");
-		assertThat(result.bottomTabsOptions.currentTabIndex).isEqualTo(1);
-	}
+    @NonNull
+    private JSONObject createOtherTabBar() throws JSONException {
+        return new JSONObject()
+                .put("currentTabId", BOTTOM_TABS_CURRENT_TAB_ID)
+                .put("currentTabIndex", BOTTOM_TABS_CURRENT_TAB_INDEX)
+                .put("hidden", BOTTOM_TABS_HIDDEN)
+                .put("animateHide", BOTTOM_TABS_ANIMATE_HIDE)
+                .put("tabBadge", BOTTOM_TABS_BADGE);
+    }
+
+    @Test
+    public void mergeDefaultOptions() throws Exception {
+        JSONObject json = new JSONObject();
+        json.put("topBar", createTopBar());
+        json.put("tabBar", createTabBar());
+        NavigationOptions defaultOptions = NavigationOptions.parse(json);
+        NavigationOptions options = new NavigationOptions();
+
+        options.mergeWith(defaultOptions);
+        assertResult(options);
+    }
+
+    @Test
+    public void mergedDefaultOptionsDontOverrideGivenOptions() throws Exception {
+        JSONObject defaultJson = new JSONObject()
+            .put("topBar", createOtherTopBar())
+            .put("tabBar", createOtherTabBar());
+        NavigationOptions defaultOptions = NavigationOptions.parse(defaultJson);
+
+        JSONObject json = new JSONObject()
+                .put("topBar", createTopBar())
+                .put("tabBar", createTabBar());
+        NavigationOptions options = NavigationOptions.parse(json);
+        options.withDefaultOptions(defaultOptions);
+        assertResult(options);
+    }
 
 	@Test
 	public void defaultEmptyOptions() throws Exception {

lib/src/Navigation.js

     return this.commands.setRoot(params);
   }
 
+  setDefaultOptions(options) {
+    this.commands.setDefaultOptions(options);
+  }
+
   setOptions(containerId, options) {
     this.commands.setOptions(containerId, options);
   }

lib/src/adapters/NativeCommandsSender.js

     return this.nativeCommandsModule.setRoot(layoutTree);
   }
 
+  setDefaultOptions(options) {
+    this.nativeCommandsModule.setDefaultOptions(options);
+  }
+
   setOptions(containerId, options) {
     this.nativeCommandsModule.setOptions(containerId, options);
   }

lib/src/commands/Commands.js

     return this.nativeCommandsSender.setRoot(layout);
   }
 
+  setDefaultOptions(options) {
+    const input = _.cloneDeep(options);
+    OptionsProcessor.processOptions(input);
+    this.nativeCommandsSender.setDefaultOptions(input);
+  }
+
   setOptions(containerId, options) {
     const input = _.cloneDeep(options);
     OptionsProcessor.processOptions(input);

lib/src/commands/Commands.test.js

     });
   });
 
+  describe('setDefaultOptions', () => {
+    it('deep clones input to avoid mutation errors', () => {
+      const obj = { title: 'test' };
+      uut.setDefaultOptions(obj);
+      expect(mockCommandsSender.setDefaultOptions.mock.calls[0][0]).not.toBe(obj);
+    });
+  });
+
   describe('showModal', () => {
     it('sends command to native after parsing into a correct layout tree', () => {
       uut.showModal({