RTL Layout (#4575)

* Support rtl layout

* ios layout options

* Support rtl layout

* Use View.LAYOUT_DIRECTION_LTR constant instead of 0

* move layout direction logic to RootPresenter

* Fix tests

* Fix tests

* Fix tests

* Fix tests

* fix tests

* Fix tests

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

 import com.reactnativenavigation.parse.params.NullColor;
 import com.reactnativenavigation.parse.params.NullNumber;
 import com.reactnativenavigation.parse.params.Number;
+import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.parse.params.NullText;
 import com.reactnativenavigation.parse.parsers.ColorParser;
 import com.reactnativenavigation.parse.parsers.NumberParser;
+import com.reactnativenavigation.parse.parsers.TextParser;
+
 
 import org.json.JSONObject;
 
         result.componentBackgroundColor = ColorParser.parse(json, "componentBackgroundColor");
         result.topMargin = NumberParser.parse(json, "topMargin");
         result.orientation = OrientationOptions.parse(json);
+        result.direction = TextParser.parse(json, "direction");
 
         return result;
     }
     public Colour componentBackgroundColor = new NullColor();
     public Number topMargin = new NullNumber();
     public OrientationOptions orientation = new OrientationOptions();
+    public Text direction = new NullText();
 
     public void mergeWith(LayoutOptions other) {
         if (other.backgroundColor.hasValue()) backgroundColor = other.backgroundColor;
         if (other.componentBackgroundColor.hasValue()) componentBackgroundColor = other.componentBackgroundColor;
         if (other.topMargin.hasValue()) topMargin = other.topMargin;
         if (other.orientation.hasValue()) orientation = other.orientation;
+        if (other.direction.hasValue()) direction = other.direction;
 
     }
 
         if (!componentBackgroundColor.hasValue()) componentBackgroundColor = defaultOptions.componentBackgroundColor;
         if (!topMargin.hasValue()) topMargin = defaultOptions.topMargin;
         if (!orientation.hasValue()) orientation = defaultOptions.orientation;
+        if (!direction.hasValue()) direction = defaultOptions.direction;
     }
 }

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

 		handle(() -> {
             navigator().setEventEmitter(eventEmitter);
             final ViewController viewController = newLayoutFactory().create(layoutTree);
-            navigator().setRoot(viewController, new NativeCommandListener(commandId, promise, eventEmitter, now));
+            navigator().setRoot(viewController, new NativeCommandListener(commandId, promise, eventEmitter, now), reactInstanceManager);
         });
 	}
 

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

     }
 
     public void applyNavigationIcon(Toolbar toolbar) {
-        navigationIconResolver.resolve(button, icon -> {
+        Integer direction = getActivity().getWindow().getDecorView().getLayoutDirection();
+        navigationIconResolver.resolve(button, direction, icon -> {
             setIconColor(icon);
             toolbar.setNavigationOnClickListener(view -> onPressListener.onPress(button.id));
             toolbar.setNavigationIcon(icon);

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/button/NavigationIconResolver.java

 import android.support.annotation.NonNull;
 import android.support.v4.content.ContextCompat;
 import android.util.Log;
+import android.view.View;
 
 import com.reactnativenavigation.R;
 import com.reactnativenavigation.parse.params.Button;
         this.imageLoader = imageLoader;
     }
 
-    public void resolve(Button button, Func1<Drawable> onSuccess) {
+    public void resolve(Button button, Integer direction, Func1<Drawable> onSuccess) {
         if (button.icon.hasValue()) {
             imageLoader.loadIcon(context, button.icon.get(), new ImageLoadingListenerAdapter() {
                 @Override
                 }
             });
         } else if (Constants.BACK_BUTTON_ID.equals(button.id)) {
-            onSuccess.run(ContextCompat.getDrawable(context, R.drawable.ic_arrow_back_black_24dp));
+            Boolean isRTL = direction == View.LAYOUT_DIRECTION_RTL;
+            onSuccess.run(ContextCompat.getDrawable(context, isRTL ? R.drawable.ic_arrow_back_black_rtl_24dp : R.drawable.ic_arrow_back_black_24dp));
         } else {
             Log.w("RNN", "Left button needs to have an icon");
         }

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

 import com.reactnativenavigation.viewcontrollers.modal.ModalStack;
 import com.reactnativenavigation.viewcontrollers.stack.StackController;
 
+import com.facebook.react.ReactInstanceManager;
+
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
     }
 
-    public void setRoot(final ViewController viewController, CommandListener commandListener) {
+    public void setRoot(final ViewController viewController, CommandListener commandListener, ReactInstanceManager reactInstanceManager) {
         destroyRoot();
         final boolean removeSplashView = isRootNotCreated();
         if (isRootNotCreated()) getView();
                 if (removeSplashView) removePreviousContentView();
                 super.onSuccess(childId);
             }
-        });
+        }, reactInstanceManager);
     }
 
     private void removePreviousContentView() {

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/navigator/RootPresenter.java

 
 import android.content.Context;
 import android.widget.FrameLayout;
+import android.view.View;
 
 import com.reactnativenavigation.anim.NavigationAnimator;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.views.element.ElementTransitionManager;
 
+import com.facebook.react.modules.i18nmanager.I18nUtil;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.ReactInstanceManager;
+
 public class RootPresenter {
     private NavigationAnimator animator;
     private FrameLayout rootLayout;
         this.animator = animator;
     }
 
-    void setRoot(ViewController root, Options defaultOptions, CommandListener listener) {
+    void setRoot(ViewController root, Options defaultOptions, CommandListener listener, ReactInstanceManager reactInstanceManager) {
+        setLayoutDirection(root, defaultOptions, (ReactApplicationContext) reactInstanceManager.getCurrentReactContext());
         rootLayout.addView(root.getView());
         Options options = root.resolveCurrentOptions(defaultOptions);
         root.setWaitForRender(options.animations.setRoot.waitForRender);
             listener.onSuccess(root.getId());
         }
     }
+
+    private void setLayoutDirection(ViewController root, Options defaultOptions, ReactApplicationContext reactContext) {
+        if (defaultOptions.layout.direction.hasValue()) {
+            I18nUtil i18nUtil = I18nUtil.getInstance();
+            Boolean isRtl = defaultOptions.layout.direction.get().equals("rtl");
+
+            root.getActivity().getWindow().getDecorView().setLayoutDirection(isRtl ? View.LAYOUT_DIRECTION_RTL : View.LAYOUT_DIRECTION_LTR);
+            i18nUtil.allowRTL(reactContext, isRtl);
+            i18nUtil.forceRTL(reactContext, isRtl);
+        }
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/views/titlebar/TitleBar.java

     }
 
     private void alignTextView(Alignment alignment, TextView view) {
+        Integer direction = view.getParent().getLayoutDirection();
+        Boolean isRTL = direction == View.LAYOUT_DIRECTION_RTL;
         int width = view.getResources().getDisplayMetrics().widthPixels;
         view.post(() -> {
             if (alignment == Alignment.Center) {
                 //noinspection IntegerDivisionInFloatingPointContext
                 view.setX((width - view.getWidth()) / 2);
             } else if (leftButtonController != null) {
-                view.setX(getContentInsetStartWithNavigation());
+                view.setX(isRTL ? (getWidth() - view.getWidth()) - getContentInsetStartWithNavigation() : getContentInsetStartWithNavigation());
             } else {
-                view.setX(UiUtils.dpToPx(getContext(), DEFAULT_LEFT_MARGIN));
+                view.setX(isRTL ? (getWidth() - view.getWidth()) - UiUtils.dpToPx(getContext(), DEFAULT_LEFT_MARGIN) : UiUtils.dpToPx(getContext(), DEFAULT_LEFT_MARGIN));
             }
         });
     }

lib/android/app/src/main/res/drawable/ic_arrow_back_black_rtl_24dp.xml

+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportHeight="24.0"
+    android:viewportWidth="24.0">
+    <path
+        android:fillColor="#000000"
+        android:pathData="M4,13H16.15l-5.6,5.6L12,20l8-8L12,4,10.6,5.4,16.15,11H4Z" />
+</vector>

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/button/NavigationIconResolverTest.java

 import android.content.Context;
 import android.graphics.Color;
 import android.graphics.drawable.Drawable;
+import android.view.View;
 
 import com.reactnativenavigation.BaseTest;
 import com.reactnativenavigation.mocks.ImageLoaderMock;
 
             }
         });
-        uut.resolve(iconButton(), onSuccess);
+        uut.resolve(iconButton(), View.LAYOUT_DIRECTION_LTR, onSuccess);
         verify(imageLoader).loadIcon(eq(context), eq(ICON_URI), any());
         verify(onSuccess).run(any(Drawable.class));
     }
 
             }
         });
-        uut.resolve(backButton(), onSuccess);
+        uut.resolve(backButton(), View.LAYOUT_DIRECTION_LTR, onSuccess);
         verifyZeroInteractions(imageLoader);
         verify(onSuccess).run(any());
     }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/navigator/NavigatorTest.java

 import com.reactnativenavigation.viewcontrollers.stack.StackController;
 import com.reactnativenavigation.views.BottomTabs;
 
+import com.facebook.react.ReactInstanceManager;
+
 import org.junit.Test;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Mockito;
     private EventEmitter eventEmitter;
     private ViewController.ViewVisibilityListener parentVisibilityListener;
     private ModalStack modalStack;
+    private ReactInstanceManager reactInstanceManager;
 
     @Override
     public void beforeEach() {
         childRegistry = new ChildControllersRegistry();
         eventEmitter = Mockito.mock(EventEmitter.class);
+        reactInstanceManager = Mockito.mock(ReactInstanceManager.class);
         overlayManager = spy(new OverlayManager());
         imageLoaderMock = ImageLoaderMock.mock();
         activityController = newActivityController(TestActivity.class);
         uut.setDefaultOptions(new Options());
 
         SimpleViewController spy = spy(child1);
-        uut.setRoot(spy, new CommandListenerAdapter());
+        uut.setRoot(spy, new CommandListenerAdapter(), reactInstanceManager);
         Options defaultOptions = new Options();
         uut.setDefaultOptions(defaultOptions);
 
     @Test
     public void setRoot_delegatesToRootPresenter() {
         CommandListenerAdapter listener = new CommandListenerAdapter();
-        uut.setRoot(child1, listener);
+        uut.setRoot(child1, listener, reactInstanceManager);
         ArgumentCaptor<CommandListenerAdapter> captor = ArgumentCaptor.forClass(CommandListenerAdapter.class);
-        verify(rootPresenter).setRoot(eq(child1), eq(uut.getDefaultOptions()), captor.capture());
+        verify(rootPresenter).setRoot(eq(child1), eq(uut.getDefaultOptions()), captor.capture(), eq(reactInstanceManager));
         assertThat(captor.getValue().getListener()).isEqualTo(listener);
     }
 
         FrameLayout content = activity.findViewById(android.R.id.content);
         assertThat(content.getChildCount()).isEqualTo(4); // 3 frame layouts and the default splash layout
 
-        uut.setRoot(child2, new CommandListenerAdapter());
+        uut.setRoot(child2, new CommandListenerAdapter(), reactInstanceManager);
 
         assertThat(content.getChildCount()).isEqualTo(3);
     }
 
     @Test
     public void setRoot_AddsChildControllerView() {
-        uut.setRoot(child1, new CommandListenerAdapter());
+        uut.setRoot(child1, new CommandListenerAdapter(), reactInstanceManager);
         assertIsChild(uut.getRootLayout(), child1.getView());
     }
 
     @Test
     public void setRoot_ReplacesExistingChildControllerViews() {
-        uut.setRoot(child1, new CommandListenerAdapter());
-        uut.setRoot(child2, new CommandListenerAdapter());
+        uut.setRoot(child1, new CommandListenerAdapter(), reactInstanceManager);
+        uut.setRoot(child2, new CommandListenerAdapter(), reactInstanceManager);
         assertIsChild(uut.getRootLayout(), child2.getView());
     }
 
     public void push() {
         StackController stackController = newStack();
         stackController.push(child1, new CommandListenerAdapter());
-        uut.setRoot(stackController, new CommandListenerAdapter());
+        uut.setRoot(stackController, new CommandListenerAdapter(), reactInstanceManager);
 
         assertIsChild(uut.getView(), stackController.getView());
         assertIsChild(stackController.getView(), child1.getView());
 
     @Test
     public void push_InvalidPushWithoutAStack_DoesNothing() {
-        uut.setRoot(child1, new CommandListenerAdapter());
+        uut.setRoot(child1, new CommandListenerAdapter(), reactInstanceManager);
         uut.push(child1.getId(), child2, new CommandListenerAdapter());
         assertIsChild(uut.getView(), child1.getView());
     }
         stack1.push(child1, new CommandListenerAdapter());
         stack2.push(child2, new CommandListenerAdapter());
         BottomTabsController bottomTabsController = newTabs(Arrays.asList(stack1, stack2));
-        uut.setRoot(bottomTabsController, new CommandListenerAdapter());
+        uut.setRoot(bottomTabsController, new CommandListenerAdapter(), reactInstanceManager);
 
         SimpleViewController newChild = new SimpleViewController(activity, childRegistry, "new child", tabOptions);
         uut.push(child2.getId(), newChild, new CommandListenerAdapter());
     @Test
     public void pop_InvalidDoesNothing() {
         uut.pop("123", Options.EMPTY, new CommandListenerAdapter());
-        uut.setRoot(child1, new CommandListenerAdapter());
+        uut.setRoot(child1, new CommandListenerAdapter(), reactInstanceManager);
         uut.pop(child1.getId(), Options.EMPTY, new CommandListenerAdapter());
         assertThat(uut.getChildControllers()).hasSize(1);
     }
         StackController stack1 = newStack();
         StackController stack2 = newStack();
         BottomTabsController bottomTabsController = newTabs(Arrays.asList(stack1, stack2));
-        uut.setRoot(bottomTabsController, new CommandListenerAdapter());
+        uut.setRoot(bottomTabsController, new CommandListenerAdapter(), reactInstanceManager);
         stack1.push(child1, new CommandListenerAdapter());
         stack2.push(child2, new CommandListenerAdapter());
         stack2.push(child3, new CommandListenerAdapter() {
         disablePushAnimation(child1, child2);
         disablePopAnimation(child2, child1);
         StackController stack = newStack(); stack.ensureViewIsCreated();
-        uut.setRoot(stack, new CommandListenerAdapter());
+        uut.setRoot(stack, new CommandListenerAdapter(), reactInstanceManager);
         stack.push(child1, new CommandListenerAdapter());
         stack.push(child2, new CommandListenerAdapter());
 
         StackController stack1 = newStack();
         StackController stack2 = newStack();
         BottomTabsController bottomTabsController = newTabs(Arrays.asList(stack1, stack2));
-        uut.setRoot(bottomTabsController, new CommandListenerAdapter());
+        uut.setRoot(bottomTabsController, new CommandListenerAdapter(), reactInstanceManager);
 
         stack1.push(child1, new CommandListenerAdapter());
         stack2.push(child2, new CommandListenerAdapter());
         StackController stack1 = newStack();
         StackController stack2 = newStack();
         BottomTabsController bottomTabsController = newTabs(Arrays.asList(stack1, stack2));
-        uut.setRoot(bottomTabsController, new CommandListenerAdapter());
+        uut.setRoot(bottomTabsController, new CommandListenerAdapter(), reactInstanceManager);
 
         stack1.push(child1, new CommandListenerAdapter());
         stack2.push(child2, new CommandListenerAdapter());
         disablePushAnimation(child1, child2, child3);
 
         StackController stack = newStack();
-        uut.setRoot(stack, new CommandListenerAdapter());
+        uut.setRoot(stack, new CommandListenerAdapter(), reactInstanceManager);
 
         stack.push(child1, new CommandListenerAdapter());
         stack.push(child2, new CommandListenerAdapter());
         assertThat(uut.handleBack(new CommandListenerAdapter())).isFalse();
 
         ViewController root = spy(child1);
-        uut.setRoot(root, new CommandListenerAdapter());
+        uut.setRoot(root, new CommandListenerAdapter(), reactInstanceManager);
         when(root.handleBack(any(CommandListener.class))).thenReturn(true);
         assertThat(uut.handleBack(new CommandListenerAdapter())).isTrue();
         verify(root, times(1)).handleBack(any());
     @Test
     public void handleBack_modalTakePrecedenceOverRoot() {
         ViewController root = spy(child1);
-        uut.setRoot(root, new CommandListenerAdapter());
+        uut.setRoot(root, new CommandListenerAdapter(), reactInstanceManager);
         uut.showModal(child2, new CommandListenerAdapter());
         verify(root, times(0)).handleBack(new CommandListenerAdapter());
     }
         ComponentViewController componentVc = new SimpleComponentViewController(activity, childRegistry, "theId", new Options());
         componentVc.setParentController(parentController);
         assertThat(componentVc.options.topBar.title.text.get("")).isEmpty();
-        uut.setRoot(componentVc, new CommandListenerAdapter());
+        uut.setRoot(componentVc, new CommandListenerAdapter(), reactInstanceManager);
 
         Options options = new Options();
         options.topBar.title.text = new Text("new title");
 
     @Test
     public void findController_root() {
-        uut.setRoot(child1, new CommandListenerAdapter());
+        uut.setRoot(child1, new CommandListenerAdapter(), reactInstanceManager);
         assertThat(uut.findController(child1.getId())).isEqualTo(child1);
     }
 
     public void push_promise() {
         final StackController stackController = newStack();
         stackController.push(child1, new CommandListenerAdapter());
-        uut.setRoot(stackController, new CommandListenerAdapter());
+        uut.setRoot(stackController, new CommandListenerAdapter(), reactInstanceManager);
 
         assertIsChild(uut.getView(), stackController.getView());
         assertIsChild(stackController.getView(), child1.getView());
 
     @Test
     public void push_InvalidPushWithoutAStack_DoesNothing_Promise() {
-        uut.setRoot(child1, new CommandListenerAdapter());
+        uut.setRoot(child1, new CommandListenerAdapter(), reactInstanceManager);
         uut.push(child1.getId(), child2, new CommandListenerAdapter() {
             @Override
             public void onError(String message) {
     @Test
     public void pop_InvalidDoesNothing_Promise() {
         uut.pop("123", Options.EMPTY, new CommandListenerAdapter());
-        uut.setRoot(child1, new CommandListenerAdapter());
+        uut.setRoot(child1, new CommandListenerAdapter(), reactInstanceManager);
         uut.pop(child1.getId(), Options.EMPTY, new CommandListenerAdapter() {
             @Override
             public void onError(String reason) {
         StackController stack1 = newStack();
         final StackController stack2 = newStack();
         BottomTabsController bottomTabsController = newTabs(Arrays.asList(stack1, stack2));
-        uut.setRoot(bottomTabsController, new CommandListenerAdapter());
+        uut.setRoot(bottomTabsController, new CommandListenerAdapter(), reactInstanceManager);
 
         stack1.push(child1, new CommandListenerAdapter());
         stack2.push(child2, new CommandListenerAdapter());
 
     @Test
     public void pushIntoModal() {
-        uut.setRoot(parentController, new CommandListenerAdapter());
+        uut.setRoot(parentController, new CommandListenerAdapter(), reactInstanceManager);
         StackController stackController = newStack();
         stackController.push(child1, new CommandListenerAdapter());
         uut.showModal(stackController, new CommandListenerAdapter());
         StackController spy = spy(parentController);
         StackController parent = newStack();
         parent.ensureViewIsCreated();
-        uut.setRoot(parent, new CommandListenerAdapter());
+        uut.setRoot(parent, new CommandListenerAdapter(), reactInstanceManager);
         parent.push(spy, new CommandListenerAdapter());
 
         spy.push(child1, new CommandListenerAdapter());
                     }
                 });
             }
-        });
+        }, reactInstanceManager);
     }
 
     @Test
         disableShowModalAnimation(child1, child2, child3);
         disableDismissModalAnimation(child1, child2);
 
-        uut.setRoot(parentController, new CommandListenerAdapter());
+        uut.setRoot(parentController, new CommandListenerAdapter(), reactInstanceManager);
         parentController.push(child3, new CommandListenerAdapter());
         uut.showModal(child1, new CommandListenerAdapter());
         uut.showModal(child2, new CommandListenerAdapter());
     public void dismissModal_reattachedToRoot() {
         disableModalAnimations(child1);
 
-        uut.setRoot(parentController, new CommandListenerAdapter());
+        uut.setRoot(parentController, new CommandListenerAdapter(), reactInstanceManager);
         assertThat(ViewUtils.isChildOf(uut.getRootLayout(), parentController.getView()));
         uut.showModal(child1, new CommandListenerAdapter());
 
         uut.dismissAllModals(Options.EMPTY, new CommandListenerAdapter());
         verify(parentVisibilityListener, times(0)).onViewAppeared(parentController.getView());
 
-        uut.setRoot(parentController, new CommandListenerAdapter());
+        uut.setRoot(parentController, new CommandListenerAdapter(), reactInstanceManager);
         parentController.push(child2, new CommandListenerAdapter());
 
         verify(parentVisibilityListener, times(1)).onViewAppeared(parentController.getView());
 
         parentController.push(child3, new CommandListenerAdapter());
         StackController spy = spy(parentController);
-        uut.setRoot(spy, new CommandListenerAdapter());
+        uut.setRoot(spy, new CommandListenerAdapter(), reactInstanceManager);
         uut.showModal(child1, new CommandListenerAdapter());
         uut.showModal(child2, new CommandListenerAdapter());
 
 
         StackController spy = spy(parentController);
         spy.options.animations.setRoot.enabled = new Bool(false);
-        uut.setRoot(spy, new CommandListenerAdapter());
+        uut.setRoot(spy, new CommandListenerAdapter(), reactInstanceManager);
         spy.push(child1, new CommandListenerAdapter());
         activityController.destroy();
         verify(spy, times(1)).destroy();
 
     @Test
     public void destroy_destroyOverlayManager() {
-        uut.setRoot(parentController, new CommandListenerAdapter());
+        uut.setRoot(parentController, new CommandListenerAdapter(), reactInstanceManager);
         activityController.destroy();
         verify(overlayManager).destroy();
     }
 
     @Test
     public void destroyViews() {
-        uut.setRoot(parentController, new CommandListenerAdapter());
+        uut.setRoot(parentController, new CommandListenerAdapter(), reactInstanceManager);
         uut.showModal(child1, new CommandListenerAdapter());
         uut.showOverlay(child2, new CommandListenerAdapter());
         uut.destroy();

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/navigator/RootPresenterTest.java

 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.views.element.ElementTransitionManager;
 
+import com.facebook.react.ReactInstanceManager;
+
 import org.junit.Test;
 import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
 
 import static org.assertj.core.api.Java6Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
     private ViewController root;
     private NavigationAnimator animator;
     private Options defaultOptions;
+    private ReactInstanceManager reactInstanceManager;
 
 
     @Override
     public void beforeEach() {
+        reactInstanceManager = Mockito.mock(ReactInstanceManager.class);
         Activity activity = newActivity();
         rootContainer = new FrameLayout(activity);
         root = new SimpleViewController(activity, new ChildControllersRegistry(), "child1", new Options());
 
     @Test
     public void setRoot_viewIsAddedToContainer() {
-        uut.setRoot(root, defaultOptions, new CommandListenerAdapter());
+        uut.setRoot(root, defaultOptions, new CommandListenerAdapter(), reactInstanceManager);
         assertThat(root.getView().getParent()).isEqualTo(rootContainer);
     }
 
     @Test
     public void setRoot_reportsOnSuccess() {
         CommandListenerAdapter listener = spy(new CommandListenerAdapter());
-        uut.setRoot(root, defaultOptions, listener);
+        uut.setRoot(root, defaultOptions, listener, reactInstanceManager);
         verify(listener).onSuccess(root.getId());
     }
 
     @Test
     public void setRoot_doesNotAnimateByDefault() {
         CommandListenerAdapter listener = spy(new CommandListenerAdapter());
-        uut.setRoot(root, defaultOptions, listener);
+        uut.setRoot(root, defaultOptions, listener, reactInstanceManager);
         verifyZeroInteractions(animator);
         verify(listener).onSuccess(root.getId());
     }
         when(spy.resolveCurrentOptions(defaultOptions)).thenReturn(animatedSetRoot);
         CommandListenerAdapter listener = spy(new CommandListenerAdapter());
 
-        uut.setRoot(spy, defaultOptions, listener);
+        uut.setRoot(spy, defaultOptions, listener, reactInstanceManager);
         verify(animator).setRoot(eq(spy.getView()), eq(animatedSetRoot.animations.setRoot), any());
         verify(listener).onSuccess(spy.getId());
     }
         root.options.animations.setRoot.waitForRender = new Bool(true);
         ViewController spy = spy(root);
 
-        uut.setRoot(spy, defaultOptions, new CommandListenerAdapter());
+        uut.setRoot(spy, defaultOptions, new CommandListenerAdapter(), reactInstanceManager);
 
         ArgumentCaptor<Bool> captor = ArgumentCaptor.forClass(Bool.class);
         verify(spy).setWaitForRender(captor.capture());
 
         ViewController spy = spy(root);
         CommandListenerAdapter listener = spy(new CommandListenerAdapter());
-        uut.setRoot(spy, defaultOptions, listener);
+        uut.setRoot(spy, defaultOptions, listener, reactInstanceManager);
         verify(spy).addOnAppearedListener(any());
         assertThat(spy.getView().getAlpha()).isZero();
         verifyZeroInteractions(listener);

lib/ios/RNNCommandsHandler.m

 #import "RNNErrorHandler.h"
 #import "RNNDefaultOptionsHelper.h"
 #import "UIViewController+RNNOptions.h"
+#import "React/RCTI18nUtil.h"
 
 static NSString* const setRoot	= @"setRoot";
 static NSString* const setStackRoot	= @"setStackRoot";
 
 - (void)setRoot:(NSDictionary*)layout completion:(RNNTransitionCompletionBlock)completion {
 	[self assertReady];
-	
+
+	if (@available(iOS 9, *)) {
+	    if(_controllerFactory.defaultOptions.layout.direction.hasValue) {
+	        if ([_controllerFactory.defaultOptions.layout.direction.get isEqualToString:@"rtl"]) {
+                [[RCTI18nUtil sharedInstance] allowRTL:YES];
+                [[RCTI18nUtil sharedInstance] forceRTL:YES];
+                [[UIView appearance] setSemanticContentAttribute:UISemanticContentAttributeForceRightToLeft];
+                [[UINavigationBar appearance] setSemanticContentAttribute:UISemanticContentAttributeForceRightToLeft];
+            } else {
+                [[RCTI18nUtil sharedInstance] allowRTL:NO];
+                [[RCTI18nUtil sharedInstance] forceRTL:NO];
+                [[UIView appearance] setSemanticContentAttribute:UISemanticContentAttributeForceLeftToRight];
+                [[UINavigationBar appearance] setSemanticContentAttribute:UISemanticContentAttributeForceLeftToRight];
+            }
+	    }
+	}
+
 	[_modalManager dismissAllModalsAnimated:NO];
 	[_store removeAllComponentsFromWindow:_mainWindow];
 	

lib/ios/RNNLayoutOptions.h

 @interface RNNLayoutOptions : RNNOptions
 
 @property (nonatomic, strong) Color* backgroundColor;
+@property (nonatomic, strong) Text* direction;
 @property (nonatomic, strong) id orientation;
 
 - (UIInterfaceOrientationMask)supportedOrientations;

lib/ios/RNNLayoutOptions.m

 	self = [super init];
 	
 	self.backgroundColor = [ColorParser parse:dict key:@"backgroundColor"];
+	self.direction = [TextParser parse:dict key:@"direction"];
 	self.orientation = dict[@"orientation"];
-	
+
 	return self;
 }
 

lib/ios/RNNNavigationStackManager.m

 #import "RNNNavigationStackManager.h"
 #import "RNNErrorHandler.h"
+#import <React/RCTI18nUtil.h>
 
 typedef void (^RNNAnimationBlock)(void);
 
 - (void)push:(UIViewController *)newTop onTop:(UIViewController *)onTopViewController animated:(BOOL)animated animationDelegate:(id)animationDelegate completion:(RNNTransitionCompletionBlock)completion rejection:(RCTPromiseRejectBlock)rejection {
 	UINavigationController *nvc = onTopViewController.navigationController;
 
+	if([[RCTI18nUtil sharedInstance] isRTL]) {
+		nvc.view.semanticContentAttribute = UISemanticContentAttributeForceRightToLeft;
+		nvc.navigationBar.semanticContentAttribute = UISemanticContentAttributeForceRightToLeft;
+	} else {
+		nvc.view.semanticContentAttribute = UISemanticContentAttributeForceLeftToRight;
+		nvc.navigationBar.semanticContentAttribute = UISemanticContentAttributeForceLeftToRight;
+	}
+
 	if (animationDelegate) {
 		nvc.delegate = animationDelegate;
 	} else {