V2 Orientation (#1686)

* added orientation options

* removed orientation e2e in modal screen

e2e/Orientations.test.js

+
+const Utils = require('./Utils');
+
+const elementByLabel = Utils.elementByLabel;
+
+describe('orientation', () => {
+  beforeEach(async () => {
+    await device.relaunchApp();
+  });
+
+  it('orientation should not change from landscape', async () => {
+    await elementByLabel('Orientation').tap();
+    await device.setOrientation('landscape');
+    await elementByLabel('Push landscape only screen').tap();
+    await device.setOrientation('portrait');
+    await expect(element(by.id('currentOrientation'))).toHaveText('Landscape');
+  });
+
+  it('orientation should not change from portrait', async () => {
+    await elementByLabel('Orientation').tap();
+    await device.setOrientation('portrait');
+    await elementByLabel('Push portrait only screen').tap();
+    await device.setOrientation('landscape');
+    await expect(element(by.id('currentOrientation'))).toHaveText('Portrait');
+  });
+
+  it('orientation should change to portrait and landscape', async () => {
+    await elementByLabel('Orientation').tap();
+    await device.setOrientation('portrait');
+    await elementByLabel('Push landscape and portrait').tap();
+    await device.setOrientation('landscape');
+    await expect(element(by.id('currentOrientation'))).toHaveText('Landscape');
+    await device.setOrientation('portrait');
+    await expect(element(by.id('currentOrientation'))).toHaveText('Portrait');
+  });
+
+  it('orientation default should change to portrait and landscape', async () => {
+    await elementByLabel('Orientation').tap();
+    await device.setOrientation('portrait');
+    await elementByLabel('Push default').tap();
+    await device.setOrientation('landscape');
+    await expect(element(by.id('currentOrientation'))).toHaveText('Landscape');
+    await device.setOrientation('portrait');
+    await expect(element(by.id('currentOrientation'))).toHaveText('Portrait');
+  });
+});

lib/ios/RNNControllerFactory.m

 #import "RNNSideMenuController.h"
 #import "RNNSideMenuChildVC.h"
 #import "RNNNavigationOptions.h"
-
+#import "RNNNavigationController.h"
+#import "RNNTabBarController.h"
 
 @implementation RNNControllerFactory {
 	id<RNNRootViewCreator> _creator;
 	return [[RNNRootViewController alloc] initWithName:name withOptions:options withContainerId:containerId rootViewCreator:_creator eventEmitter:_eventEmitter];
 }
 
-- (UINavigationController*)createContainerStack:(RNNLayoutNode*)node {
-	UINavigationController* vc = [[UINavigationController alloc] init];
+- (RNNNavigationController*)createContainerStack:(RNNLayoutNode*)node {
+	RNNNavigationController* vc = [[RNNNavigationController alloc] init];
 	
 	NSMutableArray* controllers = [NSMutableArray new];
 	for (NSDictionary* child in node.children) {
 	return vc;
 }
 
--(UITabBarController*)createTabs:(RNNLayoutNode*)node {
-	UITabBarController* vc = [[UITabBarController alloc] init];
+-(RNNTabBarController*)createTabs:(RNNLayoutNode*)node {
+	RNNTabBarController* vc = [[RNNTabBarController alloc] init];
 	
 	NSMutableArray* controllers = [NSMutableArray new];
 	for (NSDictionary *child in node.children) {

lib/ios/RNNNavigationController.h

+
+#import <UIKit/UIKit.h>
+
+@interface RNNNavigationController : UINavigationController
+
+@end

lib/ios/RNNNavigationController.m

+
+#import "RNNNavigationController.h"
+
+@implementation RNNNavigationController
+
+- (UIInterfaceOrientationMask)supportedInterfaceOrientations {
+	return self.viewControllers.lastObject.supportedInterfaceOrientations;
+}
+
+@end

lib/ios/RNNNavigationOptions.h

 @property (nonatomic, strong) NSNumber* topBarTranslucent;
 @property (nonatomic, strong) NSString* tabBadge;
 @property (nonatomic, strong) NSNumber* topBarTextFontSize;
+@property (nonatomic, strong) id orientation;
 @property (nonatomic, strong) NSArray* leftButtons;
 @property (nonatomic, strong) NSArray* rightButtons;
 @property (nonatomic, strong) NSNumber* topBarNoBorder;
 @property (nonatomic, strong) NSNumber* tabBarHidden;
 @property (nonatomic, strong) NSNumber* topBarBlur;
 
+
+- (UIInterfaceOrientationMask)supportedOrientations;
+
 -(instancetype)init;
 -(instancetype)initWithDict:(NSDictionary *)navigationOptions;
 
 -(void)applyOn:(UIViewController*)viewController;
 -(void)mergeWith:(NSDictionary*)otherOptions;
 
-@end
+@end

lib/ios/RNNNavigationOptions.m

 #import "RNNNavigationOptions.h"
 #import <React/RCTConvert.h>
+#import "RNNNavigationController.h"
+#import "RNNTabBarController.h"
 
 const NSInteger BLUR_STATUS_TAG = 78264801;
 const NSInteger BLUR_TOPBAR_TAG = 78264802;
 -(instancetype)init {
 	return [self initWithDict:@{}];
 }
-	
+
 -(instancetype)initWithDict:(NSDictionary *)navigationOptions {
 	self = [super init];
 	self.topBarBackgroundColor = [navigationOptions objectForKey:@"topBarBackgroundColor"];
 	self.topBarTranslucent = [navigationOptions objectForKey:@"topBarTranslucent"];
 	self.tabBadge = [navigationOptions objectForKey:@"tabBadge"];
 	self.topBarTextFontSize = [navigationOptions objectForKey:@"topBarTextFontSize"];
+	self.orientation = [navigationOptions objectForKey:@"orientation"];
 	self.leftButtons = [navigationOptions objectForKey:@"leftButtons"];
 	self.rightButtons = [navigationOptions objectForKey:@"rightButtons"];
 	self.topBarNoBorder = [navigationOptions objectForKey:@"topBarNoBorder"];
 	} else {
 		viewController.navigationController.navigationBar.tintColor = nil;
 	}
-      
+	
 	if (self.tabBadge) {
 		NSString *badge = [RCTConvert NSString:self.tabBadge];
 		if (viewController.navigationController) {
 			viewController.navigationController.tabBarItem.badgeValue = badge;
 		} else {
 			viewController.tabBarItem.badgeValue = badge;
-	  }
+		}
 	}
 	
 	if (self.topBarTranslucent) {
 			viewController.navigationController.navigationBar.translucent = YES;
 		} else {
 			viewController.navigationController.navigationBar.translucent = NO;
-		}		
+		}
 	}
-
+	
 	if (self.topBarNoBorder) {
 		if ([self.topBarNoBorder boolValue]) {
 			viewController.navigationController.navigationBar
 			}
 		}
 	}
-
+	
 	if (self.topBarBlur && [self.topBarBlur boolValue]) {
-
+		
 		if (![viewController.navigationController.navigationBar viewWithTag:BLUR_TOPBAR_TAG]) {
-
+			
 			[viewController.navigationController.navigationBar setBackgroundImage:[UIImage new] forBarMetrics:UIBarMetricsDefault];
 			viewController.navigationController.navigationBar.shadowImage = [UIImage new];
 			UIVisualEffectView *blur = [[UIVisualEffectView alloc] initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
 			[viewController.navigationController.navigationBar insertSubview:blur atIndex:0];
 			[viewController.navigationController.navigationBar sendSubviewToBack:blur];
 		}
-
+		
 	} else {
 		UIView *blur = [viewController.navigationController.navigationBar viewWithTag:BLUR_TOPBAR_TAG];
 		if (blur) {
 			[blur removeFromSuperview];
 		}
 	}
+}
 
+- (UIInterfaceOrientationMask)supportedOrientations {
+	NSArray* orientationsArray = [self.orientation isKindOfClass:[NSString class]] ? @[self.orientation] : self.orientation;
+	NSUInteger supportedOrientationsMask = 0;
+	if (!orientationsArray || [self.orientation isEqual:@"default"]) {
+		return [[UIApplication sharedApplication] supportedInterfaceOrientationsForWindow:[[UIApplication sharedApplication] keyWindow]];
+	} else {
+		for (NSString* orientation in orientationsArray) {
+			if ([orientation isEqualToString:@"all"]) {
+				supportedOrientationsMask = UIInterfaceOrientationMaskAll;
+				break;
+			}
+			if ([orientation isEqualToString:@"landscape"]) {
+				supportedOrientationsMask = (supportedOrientationsMask | UIInterfaceOrientationMaskLandscape);
+			}
+			if ([orientation isEqualToString:@"portrait"]) {
+				supportedOrientationsMask = (supportedOrientationsMask | UIInterfaceOrientationMaskPortrait);
+			}
+			if ([orientation isEqualToString:@"upsideDown"]) {
+				supportedOrientationsMask = (supportedOrientationsMask | UIInterfaceOrientationMaskPortraitUpsideDown);
+			}
+		}
+	}
+	
+	return supportedOrientationsMask;
 }
 
+
 @end

lib/ios/RNNRootViewController.m

 	return NO;
 }
 
+- (UIInterfaceOrientationMask)supportedInterfaceOrientations {
+	return self.navigationOptions.supportedOrientations;
+}
+
 - (BOOL)hidesBottomBarWhenPushed
 {
 	if (self.navigationOptions.tabBarHidden) {

lib/ios/RNNTabBarController.h

+
+#import <UIKit/UIKit.h>
+
+@interface RNNTabBarController : UITabBarController
+
+@end

lib/ios/RNNTabBarController.m

+
+#import "RNNTabBarController.h"
+
+@implementation RNNTabBarController
+
+- (UIInterfaceOrientationMask)supportedInterfaceOrientations {
+	return self.selectedViewController.supportedInterfaceOrientations;
+}
+
+@end

lib/ios/ReactNativeNavigation.xcodeproj/project.pbxproj

 		268692831E5054F800E2C612 /* RNNStore.m in Sources */ = {isa = PBXBuildFile; fileRef = 268692811E5054F800E2C612 /* RNNStore.m */; };
 		26916C981E4B9E7700D13680 /* RNNReactRootViewCreator.h in Headers */ = {isa = PBXBuildFile; fileRef = 26916C961E4B9E7700D13680 /* RNNReactRootViewCreator.h */; };
 		26916C991E4B9E7700D13680 /* RNNReactRootViewCreator.m in Sources */ = {isa = PBXBuildFile; fileRef = 26916C971E4B9E7700D13680 /* RNNReactRootViewCreator.m */; };
+		50F5DFC11F407A8C001A00BC /* RNNTabBarController.h in Headers */ = {isa = PBXBuildFile; fileRef = 50F5DFBF1F407A8C001A00BC /* RNNTabBarController.h */; };
+		50F5DFC21F407A8C001A00BC /* RNNTabBarController.m in Sources */ = {isa = PBXBuildFile; fileRef = 50F5DFC01F407A8C001A00BC /* RNNTabBarController.m */; };
+		50F5DFC51F407AA0001A00BC /* RNNNavigationController.h in Headers */ = {isa = PBXBuildFile; fileRef = 50F5DFC31F407AA0001A00BC /* RNNNavigationController.h */; };
+		50F5DFC61F407AA0001A00BC /* RNNNavigationController.m in Sources */ = {isa = PBXBuildFile; fileRef = 50F5DFC41F407AA0001A00BC /* RNNNavigationController.m */; };
 		7B1126A01E2D263F00F9B03B /* RNNEventEmitter.m in Sources */ = {isa = PBXBuildFile; fileRef = 7B11269F1E2D263F00F9B03B /* RNNEventEmitter.m */; };
 		7B1126A31E2D2B6C00F9B03B /* RNNSplashScreen.h in Headers */ = {isa = PBXBuildFile; fileRef = 7BA500761E254908001B9E1B /* RNNSplashScreen.h */; };
 		7B1126A41E2D2B6C00F9B03B /* ReactNativeNavigation.h in Headers */ = {isa = PBXBuildFile; fileRef = 7BA500731E2544B9001B9E1B /* ReactNativeNavigation.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		26916C941E4B9CCC00D13680 /* RNNRootViewCreator.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNRootViewCreator.h; sourceTree = "<group>"; };
 		26916C961E4B9E7700D13680 /* RNNReactRootViewCreator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RNNReactRootViewCreator.h; sourceTree = "<group>"; };
 		26916C971E4B9E7700D13680 /* RNNReactRootViewCreator.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RNNReactRootViewCreator.m; sourceTree = "<group>"; };
+		50F5DFBF1F407A8C001A00BC /* RNNTabBarController.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNTabBarController.h; sourceTree = "<group>"; };
+		50F5DFC01F407A8C001A00BC /* RNNTabBarController.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNTabBarController.m; sourceTree = "<group>"; };
+		50F5DFC31F407AA0001A00BC /* RNNNavigationController.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNNavigationController.h; sourceTree = "<group>"; };
+		50F5DFC41F407AA0001A00BC /* RNNNavigationController.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNNavigationController.m; sourceTree = "<group>"; };
 		7B11269E1E2D263F00F9B03B /* RNNEventEmitter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RNNEventEmitter.h; sourceTree = "<group>"; };
 		7B11269F1E2D263F00F9B03B /* RNNEventEmitter.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RNNEventEmitter.m; sourceTree = "<group>"; };
 		7B4928061E70415400555040 /* RNNCommandsHandler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RNNCommandsHandler.h; sourceTree = "<group>"; };
 				7BA500771E254908001B9E1B /* RNNSplashScreen.m */,
 				7BEF0D1A1E43771B003E96B0 /* RNNLayoutNode.h */,
 				7BEF0D1B1E43771B003E96B0 /* RNNLayoutNode.m */,
-				7BC9346D1E26886E00EFA125 /* RNNControllerFactory.m */,
 				7BEF0D161E437684003E96B0 /* RNNRootViewController.h */,
 				7BEF0D171E437684003E96B0 /* RNNRootViewController.m */,
+				50F5DFBF1F407A8C001A00BC /* RNNTabBarController.h */,
+				50F5DFC01F407A8C001A00BC /* RNNTabBarController.m */,
+				50F5DFC31F407AA0001A00BC /* RNNNavigationController.h */,
+				50F5DFC41F407AA0001A00BC /* RNNNavigationController.m */,
 				263905D41E4C94970023D7D3 /* RNNSideMenuController.h */,
 				7BC9346C1E26886E00EFA125 /* RNNControllerFactory.h */,
+				7BC9346D1E26886E00EFA125 /* RNNControllerFactory.m */,
 				263905D51E4C94970023D7D3 /* RNNSideMenuController.m */,
 				263905E41E4CAC950023D7D3 /* RNNSideMenuChildVC.h */,
 				263905E51E4CAC950023D7D3 /* RNNSideMenuChildVC.m */,
 				263905CC1E4C6F440023D7D3 /* SidebarWunderlistAnimation.h in Headers */,
 				7B4928081E70415400555040 /* RNNCommandsHandler.h in Headers */,
 				263905AE1E4C6F440023D7D3 /* MMDrawerBarButtonItem.h in Headers */,
+				50F5DFC11F407A8C001A00BC /* RNNTabBarController.h in Headers */,
 				263905BD1E4C6F440023D7D3 /* RCCDrawerProtocol.h in Headers */,
 				263905C21E4C6F440023D7D3 /* SidebarAnimation.h in Headers */,
 				263905B51E4C6F440023D7D3 /* MMExampleDrawerVisualStateManager.h in Headers */,
 				263905C01E4C6F440023D7D3 /* SidebarAirbnbAnimation.h in Headers */,
 				263905E61E4CAC950023D7D3 /* RNNSideMenuChildVC.h in Headers */,
 				263905C41E4C6F440023D7D3 /* SidebarFacebookAnimation.h in Headers */,
+				50F5DFC51F407AA0001A00BC /* RNNNavigationController.h in Headers */,
 				21B85E5F1F44482A00B314B5 /* RNNNavigationButtons.h in Headers */,
 				7BEF0D181E437684003E96B0 /* RNNRootViewController.h in Headers */,
 				7B1126A61E2D2B6C00F9B03B /* RNNBridgeModule.h in Headers */,
 				7BEF0D1D1E43771B003E96B0 /* RNNLayoutNode.m in Sources */,
 				7BA500781E254908001B9E1B /* RNNSplashScreen.m in Sources */,
 				263905BA1E4C6F440023D7D3 /* RCCDrawerController.m in Sources */,
+				50F5DFC21F407A8C001A00BC /* RNNTabBarController.m in Sources */,
 				263905BC1E4C6F440023D7D3 /* RCCDrawerHelper.m in Sources */,
 				2145452A1F4DC85F006E8DA1 /* RCTHelpers.m in Sources */,
 				263905C11E4C6F440023D7D3 /* SidebarAirbnbAnimation.m in Sources */,
 				268692831E5054F800E2C612 /* RNNStore.m in Sources */,
 				7BC9346E1E26886E00EFA125 /* RNNControllerFactory.m in Sources */,
 				263905B61E4C6F440023D7D3 /* MMExampleDrawerVisualStateManager.m in Sources */,
+				50F5DFC61F407AA0001A00BC /* RNNNavigationController.m in Sources */,
 				21B85E5D1F44480200B314B5 /* RNNNavigationButtons.m in Sources */,
 				263905C91E4C6F440023D7D3 /* SidebarFlipboardAnimation.m in Sources */,
 			);

lib/ios/ReactNativeNavigationTests/RNNCommandsHandlerTest.m

 #import "RNNNavigationOptions.h"
 #import "RNNTestRootViewCreator.h"
 #import "RNNRootViewController.h"
+#import "RNNNavigationController.h"
 
 @interface RNNCommandsHandlerTest : XCTestCase
 
 															withContainerId:@"containerId"
 															rootViewCreator:[[RNNTestRootViewCreator alloc] init]
 															   eventEmitter:nil];
-	UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:vc];
+	RNNNavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:vc];
 	[vc viewWillAppear:false];
 	XCTAssertTrue([vc.navigationItem.title isEqual:@"the title"]);
 	

lib/ios/ReactNativeNavigationTests/RNNControllerFactoryTest.m

 #import "RNNRootViewController.h"
 #import "RNNSideMenuController.h"
 #import "RNNSideMenuChildVC.h"
-
+#import "RNNNavigationController.h"
+#import "RNNTabBarController.h"
 
 @interface RNNControllerFactoryTest : XCTestCase
 
 				@"type": @"ContainerStack",
 				@"data": @{},
 				@"children": @[]}];
-	XCTAssertTrue([ans isMemberOfClass:[UINavigationController class]]);
+	XCTAssertTrue([ans isMemberOfClass:[RNNNavigationController class]]);
 }
 
 - (void)testCreateLayout_ContainerStackLayoutRecursive {
-	UINavigationController* ans = (UINavigationController*) [self.factory createLayoutAndSaveToStore:
+	RNNNavigationController* ans = (RNNNavigationController*) [self.factory createLayoutAndSaveToStore:
 															 @{@"id": @"cntId",
 															   @"type": @"ContainerStack",
 															   @"data": @{},
 																		 @"data": @{},
 																		 @"children": @[]}]}];
 	
-	XCTAssertTrue([ans isMemberOfClass:[UINavigationController class]]);
+	XCTAssertTrue([ans isMemberOfClass:[RNNNavigationController class]]);
 	XCTAssertTrue(ans.childViewControllers.count == 1);
 	XCTAssertTrue([ans.childViewControllers[0] isMemberOfClass:[RNNRootViewController class]]);
 }
 
 - (void)testCreateLayout_BottomTabsLayout {
-	UITabBarController* tabBar = (UITabBarController*) [self.factory createLayoutAndSaveToStore:
+	RNNTabBarController* tabBar = (RNNTabBarController*) [self.factory createLayoutAndSaveToStore:
 														@{
 														  @"id": @"cntId",
 														  @"type": @"BottomTabs",
 																			  @"data": @{},
 																			  @"children": @[]}]}]}];
 	
-	XCTAssertTrue([tabBar isMemberOfClass:[UITabBarController class]]);
+	XCTAssertTrue([tabBar isMemberOfClass:[RNNTabBarController class]]);
 	XCTAssertTrue(tabBar.childViewControllers.count == 1);
-	XCTAssertTrue([tabBar.childViewControllers[0] isMemberOfClass:[UINavigationController class]]);
+	XCTAssertTrue([tabBar.childViewControllers[0] isMemberOfClass:[RNNNavigationController class]]);
 	
 	UINavigationController *navController = tabBar.childViewControllers[0];
 	XCTAssertTrue(navController.childViewControllers.count == 1);

lib/ios/ReactNativeNavigationTests/RNNRootViewControllerTest.m

 #import "RNNTestRootViewCreator.h"
 #import <React/RCTConvert.h>
 #import "RNNNavigationOptions.h"
+#import "RNNNavigationController.h"
+#import "RNNTabBarController.h"
 #import "RNNUIBarButtonItem.h"
 
 @interface RNNRootViewControllerTest : XCTestCase
 -(void)testTopBarBackgroundColor_validColor{
 	NSNumber* inputColor = @(0xFFFF0000);
 	self.options.topBarBackgroundColor = inputColor;
-	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
+	__unused RNNNavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
 	[self.uut viewWillAppear:false];
 	UIColor* expectedColor = [UIColor colorWithRed:1 green:0 blue:0 alpha:1];
 	
 }
 
 - (void)testStatusBarHidden_default {
-	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
+	__unused RNNNavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
 	[self.uut viewWillAppear:false];
 	
 	XCTAssertFalse([self.uut prefersStatusBarHidden]);
 
 - (void)testStatusBarHidden_true {
 	self.options.statusBarHidden = @(1);
-	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
+	__unused RNNNavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
 	[self.uut viewWillAppear:false];
 	
 	XCTAssertTrue([self.uut prefersStatusBarHidden]);
 
 - (void)testStatusBarHidden_false {
 	self.options.statusBarHidden = @(0);
-	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
+	__unused RNNNavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
 	[self.uut viewWillAppear:false];
 	
 	XCTAssertFalse([self.uut prefersStatusBarHidden]);
 -(void)testTitle_string{
 	NSString* title =@"some title";
 	self.options.title= title;
-	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
+	__unused RNNNavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
 	
 	[self.uut viewWillAppear:false];
 	XCTAssertTrue([self.uut.navigationItem.title isEqual:title]);
 }
 
 -(void)testTitle_default{
-	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
+	__unused RNNNavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
 	
 	[self.uut viewWillAppear:false];
 	XCTAssertNil(self.uut.navigationItem.title);
 -(void)testTopBarTextColor_validColor{
 	NSNumber* inputColor = @(0xFFFF0000);
 	self.options.topBarTextColor = inputColor;
-	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
+	__unused UINavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
 	[self.uut viewWillAppear:false];
 	UIColor* expectedColor = [UIColor colorWithRed:1 green:0 blue:0 alpha:1];
 	XCTAssertTrue([self.uut.navigationController.navigationBar.titleTextAttributes[@"NSColor"] isEqual:expectedColor]);
 
 -(void)testTopBarTextFontFamily_validFont{
 	NSString* inputFont = @"HelveticaNeue";
-	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
+	__unused RNNNavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
 	self.options.topBarTextFontFamily = inputFont;
 	[self.uut viewWillAppear:false];
 	UIFont* expectedFont = [UIFont fontWithName:inputFont size:20];
 
 -(void)testTopBarHideOnScroll_true {
 	NSNumber* hideOnScrollInput = @(1);
-	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
+	__unused RNNNavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
 	self.options.topBarHideOnScroll = hideOnScrollInput;
 	[self.uut viewWillAppear:false];
 	XCTAssertTrue(self.uut.navigationController.hidesBarsOnSwipe);
 
 -(void)testTopBarButtonColor {
 	NSNumber* inputColor = @(0xFFFF0000);
-	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
+	__unused RNNNavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
 	self.options.topBarButtonColor = inputColor;
 	[self.uut viewWillAppear:false];
 	UIColor* expectedColor = [UIColor colorWithRed:1 green:0 blue:0 alpha:1];
 -(void)testTopBarTranslucent {
 	NSNumber* topBarTranslucentInput = @(0);
 	self.options.topBarTranslucent = topBarTranslucentInput;
-	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
+	__unused RNNNavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
 	[self.uut viewWillAppear:false];
 	XCTAssertFalse(self.uut.navigationController.navigationBar.translucent);
 }
 -(void)testTabBadge {
 	NSString* tabBadgeInput = @"5";
 	self.options.tabBadge = tabBadgeInput;
-	__unused UITabBarController* vc = [[UITabBarController alloc] init];
+	__unused RNNTabBarController* vc = [[RNNTabBarController alloc] init];
 	NSMutableArray* controllers = [NSMutableArray new];
 	UITabBarItem* item = [[UITabBarItem alloc] initWithTitle:@"A Tab" image:nil tag:1];
 	[self.uut setTabBarItem:item];
 -(void)testTopBarTextFontSize_withoutTextFontFamily_withoutTextColor {
 	NSNumber* topBarTextFontSizeInput = @(15);
 	self.options.topBarTextFontSize = topBarTextFontSizeInput;
-	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
+	__unused RNNNavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
 	[self.uut viewWillAppear:false];
 	UIFont* expectedFont = [UIFont systemFontOfSize:15];
 	XCTAssertTrue([self.uut.navigationController.navigationBar.titleTextAttributes[@"NSFont"] isEqual:expectedFont]);
 	NSNumber* inputColor = @(0xFFFF0000);
 	self.options.topBarTextFontSize = topBarTextFontSizeInput;
 	self.options.topBarTextColor = inputColor;
-	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
+	__unused RNNNavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
 	[self.uut viewWillAppear:false];
 	UIFont* expectedFont = [UIFont systemFontOfSize:15];
 	UIColor* expectedColor = [UIColor colorWithRed:1 green:0 blue:0 alpha:1];
 	self.options.topBarTextFontSize = topBarTextFontSizeInput;
 	self.options.topBarTextColor = inputColor;
 	self.options.topBarTextFontFamily = inputFont;
-	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
+	__unused RNNNavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
 	[self.uut viewWillAppear:false];
 	UIColor* expectedColor = [UIColor colorWithRed:1 green:0 blue:0 alpha:1];
 	UIFont* expectedFont = [UIFont fontWithName:inputFont size:15];
 	NSString* inputFont = @"HelveticaNeue";
 	self.options.topBarTextFontSize = topBarTextFontSizeInput;
 	self.options.topBarTextFontFamily = inputFont;
-	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
+	__unused RNNNavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
 	[self.uut viewWillAppear:false];
 	UIFont* expectedFont = [UIFont fontWithName:inputFont size:15];
 	XCTAssertTrue([self.uut.navigationController.navigationBar.titleTextAttributes[@"NSFont"] isEqual:expectedFont]);
 // TODO: Currently not passing
 -(void)testTopBarTextFontFamily_invalidFont{
 	NSString* inputFont = @"HelveticaNeueeeee";
-	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];
+	__unused RNNNavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
 	self.options.topBarTextFontFamily = inputFont;
 	//	XCTAssertThrows([self.uut viewWillAppear:false]);
 }
 
+-(void)testOrientation_portrait {
+	NSArray* supportedOrientations = @[@"portrait"];
+	self.options.orientation = supportedOrientations;
+	__unused UINavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
+	[self.uut viewWillAppear:false];
+	UIInterfaceOrientationMask expectedOrientation = UIInterfaceOrientationMaskPortrait;
+	XCTAssertTrue(self.uut.navigationController.supportedInterfaceOrientations == expectedOrientation);
+}
+
+-(void)testOrientation_portraitString {
+	NSString* supportedOrientation = @"portrait";
+	self.options.orientation = supportedOrientation;
+	__unused UINavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
+	[self.uut viewWillAppear:false];
+	UIInterfaceOrientationMask expectedOrientation = (UIInterfaceOrientationMaskPortrait);
+	XCTAssertTrue(self.uut.navigationController.supportedInterfaceOrientations == expectedOrientation);
+}
+
+-(void)testOrientation_portraitAndLandscape {
+	NSArray* supportedOrientations = @[@"portrait", @"landscape"];
+	self.options.orientation = supportedOrientations;
+	__unused UINavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
+	[self.uut viewWillAppear:false];
+	UIInterfaceOrientationMask expectedOrientation = (UIInterfaceOrientationMaskPortrait | UIInterfaceOrientationMaskLandscape);
+	XCTAssertTrue(self.uut.navigationController.supportedInterfaceOrientations == expectedOrientation);
+}
+
+-(void)testOrientation_all {
+	NSArray* supportedOrientations = @[@"all"];
+	self.options.orientation = supportedOrientations;
+	__unused UINavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
+	[self.uut viewWillAppear:false];
+	UIInterfaceOrientationMask expectedOrientation = UIInterfaceOrientationMaskAll;
+	XCTAssertTrue(self.uut.navigationController.supportedInterfaceOrientations == expectedOrientation);
+}
+
+-(void)testOrientation_default {
+	NSString* supportedOrientations = @"default";
+	self.options.orientation = supportedOrientations;
+	__unused UINavigationController* nav = [[RNNNavigationController alloc] initWithRootViewController:self.uut];
+	[self.uut viewWillAppear:false];
+	UIInterfaceOrientationMask expectedOrientation = [[UIApplication sharedApplication] supportedInterfaceOrientationsForWindow:[[UIApplication sharedApplication] keyWindow]];
+	XCTAssertTrue(self.uut.navigationController.supportedInterfaceOrientations == expectedOrientation);
+}
+
+
+-(void)testOrientationTabsController_portrait {
+	NSArray* supportedOrientations = @[@"portrait"];
+	self.options.orientation = supportedOrientations;
+	__unused RNNTabBarController* vc = [[RNNTabBarController alloc] init];
+	NSMutableArray* controllers = [NSMutableArray new];
+	
+	[controllers addObject:self.uut];
+	[vc setViewControllers:controllers];
+	[self.uut viewWillAppear:false];
+	
+	UIInterfaceOrientationMask expectedOrientation = UIInterfaceOrientationMaskPortrait;
+	XCTAssertTrue(self.uut.tabBarController.supportedInterfaceOrientations == expectedOrientation);
+}
+
+-(void)testOrientationTabsController_portraitAndLandscape {
+	NSArray* supportedOrientations = @[@"portrait", @"landscape"];
+	self.options.orientation = supportedOrientations;
+	__unused RNNTabBarController* vc = [[RNNTabBarController alloc] init];
+	NSMutableArray* controllers = [NSMutableArray new];
+	
+	[controllers addObject:self.uut];
+	[vc setViewControllers:controllers];
+	[self.uut viewWillAppear:false];
+	
+	UIInterfaceOrientationMask expectedOrientation = (UIInterfaceOrientationMaskPortrait | UIInterfaceOrientationMaskLandscape);
+	XCTAssertTrue(self.uut.tabBarController.supportedInterfaceOrientations == expectedOrientation);
+}
+
+-(void)testOrientationTabsController_all {
+	NSArray* supportedOrientations = @[@"all"];
+	self.options.orientation = supportedOrientations;
+	__unused RNNTabBarController* vc = [[RNNTabBarController alloc] init];
+	NSMutableArray* controllers = [NSMutableArray new];
+	
+	[controllers addObject:self.uut];
+	[vc setViewControllers:controllers];
+	[self.uut viewWillAppear:false];
+	
+	UIInterfaceOrientationMask expectedOrientation = UIInterfaceOrientationMaskAll;
+	XCTAssertTrue(self.uut.tabBarController.supportedInterfaceOrientations == expectedOrientation);
+}
+
 -(void)testRightButtonsWithTitle_withoutStyle {
 	self.options.rightButtons = @[@{@"id": @"testId", @"title": @"test"}];
 	__unused UINavigationController* nav = [[UINavigationController alloc] initWithRootViewController:self.uut];

playground/src/containers/ModalScreen.js

 const Navigation = require('react-native-navigation');
 
 class ModalScreen extends Component {
+  static get navigationOptions() {
+    return {
+      orientation: ['portrait']
+    };
+  }
+
   constructor(props) {
     super(props);
     this.onClickShowModal = this.onClickShowModal.bind(this);
     this.onClickDismissFirstInStack = this.onClickDismissFirstInStack.bind(this);
     this.onClickDismissAllModals = this.onClickDismissAllModals.bind(this);
   }
+
   render() {
     return (
       <View style={styles.root}>
         {this.props.previousModalIds ? (<Button title="Dismiss ALL Previous Modals" onPress={this.onClickDismissAllPreviousModals} />) : undefined}
         {this.props.previousModalIds ? (<Button title="Dismiss First In Stack" onPress={this.onClickDismissFirstInStack} />) : undefined}
         <Text style={styles.footer}>{`this.props.containerId = ${this.props.containerId}`}</Text>
-
       </View>
     );
   }
         passProps: {
           modalPosition: this.getModalPosition() + 1,
           previousModalIds: _.concat([], this.props.previousModalIds || [], this.props.containerId)
-        }
+        },
+        orientation: ['landscape']
       }
     });
   }

playground/src/containers/OrientationMenuScreen.js

+const React = require('react');
+const { Component } = require('react');
+const { View, Text, Button } = require('react-native');
+
+const Navigation = require('react-native-navigation');
+
+class OrientationMenuScreen extends Component {
+  constructor(props) {
+    super(props);
+    this.onClickPushOrientationScreen = this.onClickPushOrientationScreen.bind(this);
+  }
+
+  render() {
+    return (
+      <View style={styles.root}>
+        <Text style={styles.h1}>{`Orientation Menu`}</Text>
+        <Button title="Push landscape only screen" onPress={() => this.onClickPushOrientationScreen(['landscape'])} />
+        <Button title="Push portrait only screen" onPress={() => this.onClickPushOrientationScreen('portrait')} />
+        <Button title="Push landscape and portrait" onPress={() => this.onClickPushOrientationScreen(['landscape', 'portrait'])} />
+        <Button title="Push default" onPress={() => this.onClickPushOrientationScreen('default')} />
+      </View>
+    );
+  }
+
+  onClickPushOrientationScreen(orientation) {
+    Navigation.push(this.props.containerId, {
+      name: 'navigation.playground.OrientationScreen',
+      passProps: {
+        orientation
+      }
+    });
+  }
+}
+
+module.exports = OrientationMenuScreen;
+
+const styles = {
+  root: {
+    flexGrow: 1,
+    justifyContent: 'center',
+    alignItems: 'center'
+  },
+  h1: {
+    fontSize: 24,
+    textAlign: 'center',
+    margin: 30
+  },
+  footer: {
+    fontSize: 10,
+    color: '#888',
+    marginTop: 10
+  }
+};

playground/src/containers/OrientationScreen.js

+const React = require('react');
+const { Component } = require('react');
+
+const { View, Text } = require('react-native');
+
+const Navigation = require('react-native-navigation');
+
+class OrientationScreen extends Component {
+  constructor(props) {
+    super(props);
+
+    this.detectHorizontal = this.detectHorizontal.bind(this);
+    this.state = { horizontal: false };
+    Navigation.setOptions(this.props.containerId, {
+      orientation: props.orientation
+    });
+  }
+
+  render() {
+    return (
+      <View style={styles.root} onLayout={this.detectHorizontal}>
+        <Text style={styles.h1}>{`Orientation Screen`}</Text>
+        <Text style={styles.footer}>{`this.props.containerId = ${this.props.containerId}`}</Text>
+        <Text style={styles.footer} testID="currentOrientation">{this.state.horizontal ? 'Landscape' : 'Portrait'}</Text>
+      </View>
+    );
+  }
+
+  detectHorizontal({ nativeEvent: { layout: { width, height } } }) {
+    this.setState({
+      horizontal: width > height
+    });
+  }
+}
+
+const styles = {
+  root: {
+    flexGrow: 1,
+    justifyContent: 'center',
+    alignItems: 'center'
+  },
+  h1: {
+    fontSize: 24,
+    textAlign: 'center',
+    margin: 10
+  },
+  h2: {
+    fontSize: 12,
+    textAlign: 'center',
+    margin: 10
+  },
+  footer: {
+    fontSize: 10,
+    color: '#888',
+    marginTop: 10
+  }
+};
+
+module.exports = OrientationScreen;

playground/src/containers/TextScreen.js

 const Navigation = require('react-native-navigation');
 
 class TextScreen extends Component {
+  static get navigationOptions() {
+    return {
+      orientation: ['landscape']
+    };
+  }
+
   render() {
     return (
       <View style={styles.root}>

playground/src/containers/WelcomeScreen.js

     this.onClickShowModal = this.onClickShowModal.bind(this);
     this.onClickLifecycleScreen = this.onClickLifecycleScreen.bind(this);
     this.onClickPushOptionsScreen = this.onClickPushOptionsScreen.bind(this);
+    this.onClickPushOrientationMenuScreen = this.onClickPushOrientationMenuScreen.bind(this);
   }
 
   render() {
         <Button title="Push Options Screen" onPress={this.onClickPushOptionsScreen} />
         <Button title="Show Modal" onPress={this.onClickShowModal} />
         <Button title="Show Redbox" onPress={this.onClickShowRedbox} />
+        <Button title="Orientation" onPress={this.onClickPushOrientationMenuScreen} />
         <Text style={styles.footer}>{`this.props.containerId = ${this.props.containerId}`}</Text>
       </View>
     );
       name: 'navigation.playground.OptionsScreen'
     });
   }
+
+  onClickPushOrientationMenuScreen() {
+    Navigation.push(this.props.containerId, {
+      name: 'navigation.playground.OrientationMenuScreen'
+    });
+  }
 }
 
 module.exports = WelcomeScreen;

playground/src/containers/index.js

 const LifecycleScreen = require('./LifecycleScreen');
 const ModalScreen = require('./ModalScreen');
 const OptionsScreen = require('./OptionsScreen');
+const OrientationScreen = require('./OrientationScreen');
+const OrientationMenuScreen = require('./OrientationMenuScreen');
 const ScrollViewScreen = require('./ScrollViewScreen');
 
 function registerContainers() {
   Navigation.registerContainer(`navigation.playground.TextScreen`, () => TextScreen);
   Navigation.registerContainer(`navigation.playground.PushedScreen`, () => PushedScreen);
   Navigation.registerContainer(`navigation.playground.OptionsScreen`, () => OptionsScreen);
+  Navigation.registerContainer(`navigation.playground.OrientationScreen`, () => OrientationScreen);
+  Navigation.registerContainer(`navigation.playground.OrientationMenuScreen`, () => OrientationMenuScreen);
 }
 
 module.exports = {