JSONObject

lib/android/app/src/main/java/com/reactnativenavigation/controllers/CommandsHandler.java

 import com.reactnativenavigation.layout.parse.LayoutNode;
 import com.reactnativenavigation.utils.UiThread;
 
-import java.util.Map;
+import org.json.JSONObject;
 
 public class CommandsHandler {
 
-	public void setRoot(final NavigationActivity activity, final Map<String, Object> layoutTree) {
+	public void setRoot(final NavigationActivity activity, final JSONObject layoutTree) {
 		LayoutFactory factory =
 				new LayoutFactory(activity, new LayoutFactory.ReactRootViewCreator() {
 					@Override
 		activity.setContentView(rootView);
 	}
 
-	public void push(final NavigationActivity activity, String onContainerId, final Map<String, Object> layoutTree) {
+	public void push(final NavigationActivity activity, String onContainerId, JSONObject layoutTree) {
 		LayoutFactory factory =
 				new LayoutFactory(activity, new LayoutFactory.ReactRootViewCreator() {
 					@Override

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

 	}
 
 	private View createContainerView(LayoutNode node) {
-		final String name = (String) node.data.get("name");
+		final String name = node.data.optString("name");
 		Container container = new Container(activity, reactRootViewCreator, node.id, name);
 		container.setId(CompatUtils.generateViewId());
 		return container;

lib/android/app/src/main/java/com/reactnativenavigation/layout/parse/LayoutNode.java

 package com.reactnativenavigation.layout.parse;
 
+import org.json.JSONArray;
+import org.json.JSONObject;
+
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 
 public class LayoutNode {
 	public enum Type {
 
 	public final String id;
 	public final Type type;
-	public final Map<String, Object> data;
-
+	public final JSONObject data;
 	public final List<LayoutNode> children;
 
 	public LayoutNode(String id, Type type) {
-		this(id, type, new HashMap<String, Object>(), new ArrayList<LayoutNode>());
+		this(id, type, new JSONObject(), new ArrayList<LayoutNode>());
 	}
 
-	public LayoutNode(String id, Type type, Map<String, Object> data, List<LayoutNode> children) {
+	public LayoutNode(String id, Type type, JSONObject data, List<LayoutNode> children) {
 		this.id = id;
 		this.type = type;
 		this.data = data;
 	}
 
 	@SuppressWarnings("unchecked")
-	public static LayoutNode fromTree(Map<String, Object> layoutTree) {
-		String id = (String) layoutTree.get("id");
-		LayoutNode.Type type = LayoutNode.Type.fromString((String) layoutTree.get("type"));
+	public static LayoutNode fromTree(JSONObject layoutTree) {
+		String id = layoutTree.optString("id");
+		LayoutNode.Type type = LayoutNode.Type.fromString(layoutTree.optString("type"));
 
-		Map<String, Object> data;
-		if (layoutTree.containsKey("data")) {
-			data = (Map<String, Object>) layoutTree.get("data");
+		JSONObject data;
+		if (layoutTree.has("data")) {
+			data = layoutTree.optJSONObject("data");
 		} else {
-			data = new HashMap<>();
+			data = new JSONObject();
 		}
 
 		List<LayoutNode> children = new ArrayList<>();
-		if (layoutTree.containsKey("children")) {
-			List<Object> rawChildren = (List<Object>) layoutTree.get("children");
-			for (Object rawChild : rawChildren) {
-				children.add(LayoutNode.fromTree((Map<String, Object>) rawChild));
+		if (layoutTree.has("children")) {
+			JSONArray rawChildren = layoutTree.optJSONArray("children");
+			for (int i = 0; i < rawChildren.length(); i++) {
+				children.add(LayoutNode.fromTree(rawChildren.optJSONObject(i)));
 			}
 		}
 

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

 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
 
 public class ArgsParser {
-	public static Map<String, Object> parse(ReadableMap map) {
-		Map<String, Object> result = new HashMap<>();
-		ReadableMapKeySetIterator it = map.keySetIterator();
-		while (it.hasNextKey()) {
-			String key = it.nextKey();
-			switch (map.getType(key)) {
-				case String:
-					result.put(key, map.getString(key));
-					break;
-				case Number:
-					result.put(key, parseNumber(map, key));
-					break;
-				case Boolean:
-					result.put(key, map.getBoolean(key));
-					break;
-				case Array:
-					result.put(key, parseArray(map.getArray(key)));
-					break;
-				case Map:
-					result.put(key, parse(map.getMap(key)));
-					break;
-				default:
-					break;
+	public static JSONObject parse(ReadableMap map) {
+		try {
+			ReadableMapKeySetIterator it = map.keySetIterator();
+			JSONObject result = new JSONObject();
+			while (it.hasNextKey()) {
+				String key = it.nextKey();
+				switch (map.getType(key)) {
+					case String:
+						result.put(key, map.getString(key));
+						break;
+					case Number:
+						result.put(key, parseNumber(map, key));
+						break;
+					case Boolean:
+						result.put(key, map.getBoolean(key));
+						break;
+					case Array:
+						result.put(key, parse(map.getArray(key)));
+						break;
+					case Map:
+						result.put(key, parse(map.getMap(key)));
+						break;
+					default:
+						break;
+				}
 			}
+			return result;
+		} catch (JSONException e) {
+			throw new RuntimeException(e);
 		}
-		return result;
 	}
 
-	public static List<Object> parseArray(ReadableArray arr) {
-		List<Object> result = new ArrayList<>();
+	public static JSONArray parse(ReadableArray arr) {
+		JSONArray result = new JSONArray();
 		for (int i = 0; i < arr.size(); i++) {
 			switch (arr.getType(i)) {
 				case String:
-					result.add(arr.getString(i));
+					result.put(arr.getString(i));
 					break;
 				case Number:
-					result.add(parseNumber(arr, i));
+					result.put(parseNumber(arr, i));
 					break;
 				case Boolean:
-					result.add(arr.getBoolean(i));
+					result.put(arr.getBoolean(i));
 					break;
 				case Array:
-					result.add(parseArray(arr.getArray(i)));
+					result.put(parse(arr.getArray(i)));
 					break;
 				case Map:
-					result.add(parse(arr.getMap(i)));
+					result.put(parse(arr.getMap(i)));
 					break;
 				default:
 					break;

lib/android/app/src/test/java/com/reactnativenavigation/layout/LayoutFactoryTest.java

 import com.reactnativenavigation.layout.bottomtabs.BottomTabsLayout;
 import com.reactnativenavigation.layout.parse.LayoutNode;
 
+import org.json.JSONException;
+import org.json.JSONObject;
 import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;
 
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
 
 import static org.assertj.core.api.Java6Assertions.assertThat;
 	}
 
 	@Test
-	public void pushScreenToFirstBottomTab() {
+	public void pushScreenToFirstBottomTab() throws Exception {
 		BottomTabs bottomTabsMock = mock(BottomTabs.class);
 		when(bottomTabsMock.size()).thenReturn(0, 1);
 
 	}
 
 	@Test
-	public void popScreenFromFirstBottomTab() {
+	public void popScreenFromFirstBottomTab() throws Exception {
 		BottomTabs bottomTabsMock = mock(BottomTabs.class);
 		when(bottomTabsMock.size()).thenReturn(0, 1);
 
 		assertThat(result.getChildAt(0)).isEqualTo(mockView);
 	}
 
-	private void pushContainer(ContainerStackLayout containerStackLayout, String screenId, String reactRootViewKey, View rootView) {
+	private void pushContainer(ContainerStackLayout containerStackLayout, String screenId, String reactRootViewKey, View rootView) throws Exception {
 		when(reactRootViewCreator.create(eq(screenId), eq(reactRootViewKey))).thenReturn(rootView);
 		View pushedContainer = createLayoutFactory().create(createContainerNode(screenId, reactRootViewKey));
 		containerStackLayout.push(pushedContainer);
 	}
 
-	private void pushContainer(BottomTabsLayout containerStackLayout, String screenId, String reactRootViewKey, View rootView) {
+	private void pushContainer(BottomTabsLayout containerStackLayout, String screenId, String reactRootViewKey, View rootView) throws Exception {
 		when(reactRootViewCreator.create(eq(screenId), eq(reactRootViewKey))).thenReturn(rootView);
 		View pushedContainer = createLayoutFactory().create(createContainerNode(screenId, reactRootViewKey));
 		containerStackLayout.push(pushedContainer);
 	}
 
 	@Test
-	public void popScreenFromScreenStackLayout() {
+	public void popScreenFromScreenStackLayout() throws Exception {
 		when(reactRootViewCreator.create(eq(NODE_ID), eq(REACT_ROOT_VIEW_KEY))).thenReturn(mockView);
 		final LayoutNode container = createContainerNode();
 		final LayoutNode stackNode = createContainerStackNode(container);
 	@Ignore
 	public void throwsExceptionForUnknownType() throws Exception {
 		when(reactRootViewCreator.create(eq(NODE_ID), eq(REACT_ROOT_VIEW_KEY))).thenReturn(mockView);
-		final LayoutNode node = new LayoutNode(NODE_ID, null, Collections.<String, Object>emptyMap(), Collections.<LayoutNode>emptyList());
+		final LayoutNode node = new LayoutNode(NODE_ID, null, new JSONObject(), Collections.<LayoutNode>emptyList());
 
 		createLayoutFactory().create(node);
 	}
 		return new LayoutFactory(activity, reactRootViewCreator, bottomTabsCreator);
 	}
 
-	private LayoutNode createContainerNode() {
+	private LayoutNode createContainerNode() throws Exception {
 		return createContainerNode(NODE_ID, REACT_ROOT_VIEW_KEY);
 	}
 
-	private LayoutNode createSideMenuLeftNode() {
+	private LayoutNode createSideMenuLeftNode() throws Exception {
 		List<LayoutNode> children = Arrays.asList(createContainerNode());
 		return new LayoutNode("SideMenuLeft", LayoutNode.Type.SideMenuLeft, null, children);
 	}
 
-	private LayoutNode createSideMenuRightNode() {
+	private LayoutNode createSideMenuRightNode() throws Exception {
 		List<LayoutNode> children = Arrays.asList(createContainerNode());
 		return new LayoutNode("SideMenuRight", LayoutNode.Type.SideMenuRight, null, children);
 	}
 
-	private LayoutNode createContainerNode(final String id, final String name) {
-		return new LayoutNode(id, LayoutNode.Type.Container, new HashMap<String, Object>() {{
-			put("name", name);
-		}}, null);
+	private LayoutNode createContainerNode(final String id, final String name) throws JSONException {
+		return new LayoutNode(id, LayoutNode.Type.Container, new JSONObject().put("name", name), null);
 	}
 
 	private LayoutNode createSideMenuContainerNode(List<LayoutNode> children) {

lib/android/app/src/test/java/com/reactnativenavigation/layout/parse/LayoutNodeTest.java

 
 import com.reactnativenavigation.BaseTest;
 
+import org.json.JSONObject;
 import org.junit.Test;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
 import static org.assertj.core.api.Java6Assertions.assertThat;
-import static org.assertj.core.api.Java6Assertions.entry;
 
 public class LayoutNodeTest extends BaseTest {
 	@Test
 		LayoutNode node = new LayoutNode("the id", LayoutNode.Type.Container);
 		assertThat(node.id).isEqualTo("the id");
 		assertThat(node.type).isEqualTo(LayoutNode.Type.Container);
-		assertThat(node.data).isEmpty();
+		assertThat(node.data.keys()).isEmpty();
 		assertThat(node.children).isEmpty();
 	}
 
 
 	@Test
 	public void parseFromTree() throws Exception {
-		Map<String, Object> tree = new HashMap<>();
-		tree.put("id", "node1");
-		tree.put("type", "ContainerStack");
-		Map<String, Object> rawData = new HashMap<>();
-		rawData.put("dataKey", "dataValue");
-		tree.put("data", rawData);
-		List<Object> rawChildren = new ArrayList<>();
-		Map<String, Object> rawChild = new HashMap<>();
-		rawChild.put("id", "childId1");
-		rawChild.put("type", "Container");
-		rawChildren.add(rawChild);
-		tree.put("children", rawChildren);
+		JSONObject tree = new JSONObject("{id: node1, " +
+				"type: ContainerStack, " +
+				"data: {dataKey: dataValue}, " +
+				"children: [{id: childId1, type: Container}]}");
 
 		LayoutNode result = LayoutNode.fromTree(tree);
 
 		assertThat(result).isNotNull();
 		assertThat(result.id).isEqualTo("node1");
 		assertThat(result.type).isEqualTo(LayoutNode.Type.ContainerStack);
-		assertThat(result.data).containsOnly(entry("dataKey", "dataValue"));
+		assertThat(result.data.length()).isEqualTo(1);
+		assertThat(result.data.getString("dataKey")).isEqualTo("dataValue");
 		assertThat(result.children).hasSize(1);
 		assertThat(result.children.get(0).id).isEqualTo("childId1");
 		assertThat(result.children.get(0).type).isEqualTo(LayoutNode.Type.Container);
-		assertThat(result.children.get(0).data).isEmpty();
+		assertThat(result.children.get(0).data.keys()).isEmpty();
 		assertThat(result.children.get(0).children).isEmpty();
 	}
 }

lib/android/app/src/test/java/com/reactnativenavigation/react/ArgsParserTest.java

 import com.facebook.react.bridge.JavaOnlyMap;
 import com.reactnativenavigation.BaseTest;
 
+import org.json.JSONArray;
+import org.json.JSONObject;
 import org.junit.Test;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
 import static org.assertj.core.api.Java6Assertions.assertThat;
-import static org.assertj.core.api.Java6Assertions.entry;
 
 public class ArgsParserTest extends BaseTest {
 	@Test
-	public void parsesToMap() throws Exception {
+	public void parsesMap() throws Exception {
 		JavaOnlyMap input = new JavaOnlyMap();
 		input.putString("keyString", "stringValue");
 		input.putInt("keyInt", 123);
 		input.putDouble("keyDouble", 123.456);
 		input.putBoolean("keyBoolean", true);
 		input.putArray("keyArray", new JavaOnlyArray());
+		input.putMap("keyMap", new JavaOnlyMap());
 		input.putNull("bla");
 
-		Map<String, Object> result = ArgsParser.parse(input);
+		JSONObject result = ArgsParser.parse(input);
+
+
+		assertThat(result.keys()).containsOnly(
+				"keyString",
+				"keyInt",
+				"keyDouble",
+				"keyBoolean",
+				"keyMap",
+				"keyArray");
 
-		assertThat(result).containsOnly(
-				entry("keyString", "stringValue"),
-				entry("keyInt", 123),
-				entry("keyDouble", 123.456),
-				entry("keyBoolean", true),
-				entry("keyArray", new ArrayList<>())
-		);
+		assertThat(result.get("keyString")).isEqualTo("stringValue");
+		assertThat(result.get("keyInt")).isEqualTo(123);
+		assertThat(result.get("keyDouble")).isEqualTo(123.456);
+		assertThat(result.get("keyBoolean")).isEqualTo(true);
+		assertThat(result.getJSONObject("keyMap").keys()).isEmpty();
+		assertThat(result.getJSONArray("keyArray").length()).isZero();
 	}
 
 	@Test
 		input.pushMap(new JavaOnlyMap());
 		input.pushNull();
 
-		List<Object> result = ArgsParser.parseArray(input);
-		assertThat(result).containsExactly("Hello", 123, 123.456, true, new ArrayList<>(), new HashMap<>());
+		JSONArray result = ArgsParser.parse(input);
+		assertThat(result.length()).isEqualTo(6);
+		assertThat(result.get(0)).isEqualTo("Hello");
+		assertThat(result.get(1)).isEqualTo(123);
+		assertThat(result.get(2)).isEqualTo(123.456);
+		assertThat(result.get(3)).isEqualTo(true);
+		assertThat(result.getJSONArray(4).length()).isZero();
+		assertThat(result.getJSONObject(5).keys()).isEmpty();
 	}
 }

lib/android/app/src/test/java/com/reactnativenavigation/react/NavigationModuleTest.java

 import com.reactnativenavigation.NavigationApplication;
 import com.reactnativenavigation.controllers.CommandsHandler;
 
+import org.json.JSONObject;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.ArgumentCaptor;
 import org.robolectric.Robolectric;
 
 import java.lang.reflect.Method;
-import java.util.HashMap;
 
 import static org.assertj.core.api.Java6Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
 		JavaOnlyMap input = new JavaOnlyMap();
 		input.putString("key", "value");
 		uut.setRoot(input);
-		ArgumentCaptor<Object> captor = ArgumentCaptor.forClass(HashMap.class);
-		verify(NavigationApplication.instance.getConfig().commandsHandler, times(1)).setRoot((NavigationActivity) any(), (HashMap<String, Object>) captor.capture());
+		ArgumentCaptor<JSONObject> captor = ArgumentCaptor.forClass(JSONObject.class);
+		verify(NavigationApplication.instance.getConfig().commandsHandler, times(1)).setRoot((NavigationActivity) any(), captor.capture());
 		assertThat(captor.getAllValues()).hasSize(1);
 		assertThat(captor.getValue()).isNotNull();
 	}

scripts/test.unit.android.js

 run();
 
 function run() {
-  exec.execSync(`cd lib/android && ./gradlew clean unitTest`);
+  exec.execSync(`cd lib/android && ./gradlew ${process.env.CI ? 'clean' : ''} unitTest`);
 }