Fixes sideMenu shouldStretchDrawer and animationVelocity ooptions - #4178 (#4179)

lib/ios/Bool.h

 
 @interface Bool : Param
 
+- (instancetype)initWithBOOL:(BOOL)boolValue;
+
 - (BOOL)get;
 
 - (NSNumber *)getValue;

lib/ios/Bool.m

 
 @implementation Bool
 
+- (instancetype)initWithBOOL:(BOOL)boolValue {
+	self = [super initWithValue:@(boolValue)];
+	return self;
+}
+
 - (BOOL)get {
 	return [self.value boolValue];
 }

lib/ios/RNNSideMenu/MMDrawerController/MMDrawerController.h

  
  By default, this is set to 840 points per second (three times the default drawer width), meaning it takes 1/3 of a second for the `centerViewController` to open/close across the default drawer width. Note that there is a minimum .1 second duration for built in animations, to account for small distance animations.
  */
-@property (nonatomic, assign) CGFloat animationVelocity;
+@property (nonatomic, assign) CGFloat animationVelocityLeft;
+@property (nonatomic, assign) CGFloat animationVelocityRight;
 
 /**
  A boolean that determines whether or not the panning gesture will "hard-stop" at the maximum width for a given drawer side.
  
  By default, this value is set to YES. Enabling `shouldStretchDrawer` will give the pan a gradual asymptotic stopping point much like `UIScrollView` behaves. Note that if this value is set to YES, the `drawerVisualStateBlock` can be passed a `percentVisible` greater than 1.0, so be sure to handle that case appropriately.
  */
-@property (nonatomic, assign) BOOL shouldStretchDrawer;
+@property (nonatomic, assign) BOOL shouldStretchLeftDrawer;
+@property (nonatomic, assign) BOOL shouldStretchRightDrawer;
 
 /**
  The current open side of the drawer.

lib/ios/RNNSideMenu/MMDrawerController/MMDrawerController.m

     [self setMaximumLeftDrawerWidth:MMDrawerDefaultWidth];
     [self setMaximumRightDrawerWidth:MMDrawerDefaultWidth];
     
-    [self setAnimationVelocity:MMDrawerDefaultAnimationVelocity];
+    [self setAnimationVelocityLeft:MMDrawerDefaultAnimationVelocity];
+	[self setAnimationVelocityRight:MMDrawerDefaultAnimationVelocity];
     
     [self setShowsShadow:YES];
-    [self setShouldStretchDrawer:YES];
+    [self setShouldStretchLeftDrawer:YES];
+	[self setShouldStretchRightDrawer:YES];
     
     [self setOpenDrawerGestureModeMask:MMOpenDrawerGestureModeNone];
     [self setCloseDrawerGestureModeMask:MMCloseDrawerGestureModeNone];
 }
 
 -(void)closeDrawerAnimated:(BOOL)animated completion:(void (^)(BOOL finished))completion{
-    [self closeDrawerAnimated:animated velocity:self.animationVelocity animationOptions:UIViewAnimationOptionCurveEaseInOut completion:completion];
+	CGFloat velocity = self.openSide == MMDrawerSideLeft ? self.animationVelocityLeft : self.animationVelocityRight;
+	[self closeDrawerAnimated:animated velocity:velocity animationOptions:UIViewAnimationOptionCurveEaseInOut completion:completion];
 }
 
 -(void)closeDrawerAnimated:(BOOL)animated velocity:(CGFloat)velocity animationOptions:(UIViewAnimationOptions)options completion:(void (^)(BOOL finished))completion{
 
 -(void)openDrawerSide:(MMDrawerSide)drawerSide animated:(BOOL)animated completion:(void (^)(BOOL finished))completion{
     NSParameterAssert(drawerSide != MMDrawerSideNone);
-    
-    [self openDrawerSide:drawerSide animated:animated velocity:self.animationVelocity animationOptions:UIViewAnimationOptionCurveEaseInOut completion:completion];
+	CGFloat velocity = drawerSide == MMDrawerSideLeft ? self.animationVelocityLeft : self.animationVelocityRight;
+    [self openDrawerSide:drawerSide animated:animated velocity:velocity animationOptions:UIViewAnimationOptionCurveEaseInOut completion:completion];
 }
 
 -(void)openDrawerSide:(MMDrawerSide)drawerSide animated:(BOOL)animated velocity:(CGFloat)velocity animationOptions:(UIViewAnimationOptions)options completion:(void (^)(BOOL finished))completion{
     if(self.drawerVisualState){
         self.drawerVisualState(self,drawerSide,percentVisible);
     }
-    else if(self.shouldStretchDrawer){
+    else if([self shouldStretchForSide:drawerSide]){
         [self applyOvershootScaleTransformForDrawerSide:drawerSide percentVisible:percentVisible];
     }
 }
 
+- (BOOL)shouldStretchForSide:(MMDrawerSide)drawerSide {
+	switch (drawerSide) {
+		case MMDrawerSideLeft:
+			return self.shouldStretchLeftDrawer;
+			break;
+		case MMDrawerSideRight:
+			return self.shouldStretchRightDrawer;
+			break;
+		default:
+			return YES;
+			break;
+	}
+}
+
 - (void)applyOvershootScaleTransformForDrawerSide:(MMDrawerSide)drawerSide percentVisible:(CGFloat)percentVisible{
     
     if (percentVisible >= 1.f) {
 -(CGFloat)roundedOriginXForDrawerConstriants:(CGFloat)originX{
     
     if (originX < -self.maximumRightDrawerWidth) {
-        if (self.shouldStretchDrawer &&
+        if (self.shouldStretchRightDrawer &&
             self.rightDrawerViewController) {
             CGFloat maxOvershoot = (CGRectGetWidth(self.centerContainerView.frame)-self.maximumRightDrawerWidth)*MMDrawerOvershootPercentage;
             return originXForDrawerOriginAndTargetOriginOffset(originX, -self.maximumRightDrawerWidth, maxOvershoot);
         }
     }
     else if(originX > self.maximumLeftDrawerWidth){
-        if (self.shouldStretchDrawer &&
+        if (self.shouldStretchLeftDrawer &&
             self.leftDrawerViewController) {
             CGFloat maxOvershoot = (CGRectGetWidth(self.centerContainerView.frame)-self.maximumLeftDrawerWidth)*MMDrawerOvershootPercentage;
             return originXForDrawerOriginAndTargetOriginOffset(originX, self.maximumLeftDrawerWidth, maxOvershoot);
 }
 
 -(NSTimeInterval)animationDurationForAnimationDistance:(CGFloat)distance{
-    NSTimeInterval duration = MAX(distance/self.animationVelocity,MMDrawerMinimumAnimationDuration);
+	CGFloat velocity = self.openSide == MMDrawerSideLeft ? self.animationVelocityLeft : self.animationVelocityRight;
+    NSTimeInterval duration = MAX(distance/velocity,MMDrawerMinimumAnimationDuration);
     return duration;
 }
 

lib/ios/RNNSideMenuController.m

 	}
 }
 
-- (void)viewWillAppear:(BOOL)animated {
-	[super viewWillAppear:animated];
-	[_presenter applyOptions:self.options];
-}
-
 - (UITabBarItem *)tabBarItem {
 	return self.center.tabBarItem;
 }

lib/ios/RNNSideMenuOptions.h

 @property (nonatomic, strong) RNNSideMenuSideOptions* left;
 @property (nonatomic, strong) RNNSideMenuSideOptions* right;
 
-@property (nonatomic, strong) Bool* shouldStretchDrawer;
-@property (nonatomic, strong) Double* animationVelocity;
-
 @end

lib/ios/RNNSideMenuOptions.m

 	
 	self.left = [[RNNSideMenuSideOptions alloc] initWithDict:dict[@"left"]];
 	self.right = [[RNNSideMenuSideOptions alloc] initWithDict:dict[@"right"]];
-	self.shouldStretchDrawer = [BoolParser parse:dict key:@"shouldStretchDrawer"];
-	self.animationVelocity = [DoubleParser parse:dict key:@"animationVelocity"];
 	
 	return self;
 }

lib/ios/RNNSideMenuPresenter.m

 	[sideMenuController side:MMDrawerSideLeft enabled:[options.sideMenu.left.enabled getWithDefaultValue:YES]];
 	[sideMenuController side:MMDrawerSideRight enabled:[options.sideMenu.right.enabled getWithDefaultValue:YES]];
 	
-	[sideMenuController setShouldStretchDrawer:[options.sideMenu.shouldStretchDrawer getWithDefaultValue:YES]];
-	[sideMenuController setAnimationVelocity:[options.sideMenu.animationVelocity getWithDefaultValue:840.0f]];
+	[sideMenuController setShouldStretchLeftDrawer:[options.sideMenu.left.shouldStretchDrawer getWithDefaultValue:YES]];
+	[sideMenuController setShouldStretchRightDrawer:[options.sideMenu.right.shouldStretchDrawer getWithDefaultValue:YES]];
+	
+	[sideMenuController setAnimationVelocityLeft:[options.sideMenu.left.animationVelocity getWithDefaultValue:840.0f]];
+	[sideMenuController setAnimationVelocityRight:[options.sideMenu.right.animationVelocity getWithDefaultValue:840.0f]];
 	
 	if (options.sideMenu.left.width.hasValue) {
 		[sideMenuController side:MMDrawerSideLeft width:options.sideMenu.left.width.get];
 		[sideMenuController side:MMDrawerSideRight width:options.sideMenu.right.width.get];
 	}
 	
-	if (options.sideMenu.shouldStretchDrawer.hasValue) {
-		sideMenuController.shouldStretchDrawer = options.sideMenu.shouldStretchDrawer.get;
+	if (options.sideMenu.left.shouldStretchDrawer.hasValue) {
+		sideMenuController.shouldStretchLeftDrawer = options.sideMenu.left.shouldStretchDrawer.get;
+	}
+	
+	if (options.sideMenu.right.shouldStretchDrawer.hasValue) {
+		sideMenuController.shouldStretchRightDrawer = options.sideMenu.right.shouldStretchDrawer.get;
+	}
+	
+	if (options.sideMenu.left.animationVelocity.hasValue) {
+		sideMenuController.animationVelocityLeft = options.sideMenu.left.animationVelocity.get;
 	}
 	
-	if (options.sideMenu.animationVelocity.hasValue) {
-		sideMenuController.animationVelocity = options.sideMenu.animationVelocity.get;
+	if (options.sideMenu.right.animationVelocity.hasValue) {
+		sideMenuController.animationVelocityRight = options.sideMenu.right.animationVelocity.get;
 	}
 }
 

lib/ios/RNNSideMenuSideOptions.h

 @property (nonatomic, strong) Bool* enabled;
 @property (nonatomic, strong) Double* width;
 @property (nonatomic, strong) Text* animationType;
+@property (nonatomic, strong) Bool* shouldStretchDrawer;
+@property (nonatomic, strong) Double* animationVelocity;
 
 @end

lib/ios/RNNSideMenuSideOptions.m

 	
 	self.visible = [BoolParser parse:dict key:@"visible"];
 	self.enabled = [BoolParser parse:dict key:@"enabled"];
-	
 	self.width = [DoubleParser parse:dict key:@"width"];
-	
 	self.animationType = [TextParser parse:dict key:@"animationType"];
+	self.shouldStretchDrawer = [BoolParser parse:dict key:@"shouldStretchDrawer"];
+	self.animationVelocity = [DoubleParser parse:dict key:@"animationVelocity"];
 	
 	return self;
 }

lib/ios/ReactNativeNavigation.xcodeproj/project.pbxproj

 		50C5FD8320D7D6DD00F1EA8A /* RNNBridgeManagerDelegate.h in CopyFiles */ = {isa = PBXBuildFile; fileRef = 502CB43920CBCA140019B2FE /* RNNBridgeManagerDelegate.h */; };
 		50CB3B691FDE911400AA153B /* RNNSideMenuOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 50CB3B671FDE911400AA153B /* RNNSideMenuOptions.h */; };
 		50CB3B6A1FDE911400AA153B /* RNNSideMenuOptions.m in Sources */ = {isa = PBXBuildFile; fileRef = 50CB3B681FDE911400AA153B /* RNNSideMenuOptions.m */; };
+		50CE8503217C6C9B00084EBF /* RNNSideMenuPresenterTest.m in Sources */ = {isa = PBXBuildFile; fileRef = 50CE8502217C6C9B00084EBF /* RNNSideMenuPresenterTest.m */; };
 		50D031342005149000386B3D /* RNNOverlayManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 50D031322005149000386B3D /* RNNOverlayManager.h */; };
 		50D031352005149000386B3D /* RNNOverlayManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 50D031332005149000386B3D /* RNNOverlayManager.m */; };
 		50EB4ED72068EBE000D6ED34 /* RNNBackgroundOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 50EB4ED52068EBE000D6ED34 /* RNNBackgroundOptions.h */; };
 		50C4A495206BDDBB00DB292E /* RNNSubtitleOptions.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNSubtitleOptions.m; sourceTree = "<group>"; };
 		50CB3B671FDE911400AA153B /* RNNSideMenuOptions.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNSideMenuOptions.h; sourceTree = "<group>"; };
 		50CB3B681FDE911400AA153B /* RNNSideMenuOptions.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNSideMenuOptions.m; sourceTree = "<group>"; };
+		50CE8502217C6C9B00084EBF /* RNNSideMenuPresenterTest.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNSideMenuPresenterTest.m; sourceTree = "<group>"; };
 		50D031322005149000386B3D /* RNNOverlayManager.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNOverlayManager.h; sourceTree = "<group>"; };
 		50D031332005149000386B3D /* RNNOverlayManager.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNOverlayManager.m; sourceTree = "<group>"; };
 		50EB4ED52068EBE000D6ED34 /* RNNBackgroundOptions.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNBackgroundOptions.h; sourceTree = "<group>"; };
 				506F630E216A5AD700AD0D0A /* RNNViewControllerPresenterTest.m */,
 				509B258E2178BE7A00C83C23 /* RNNNavigationControllerPresenterTest.m */,
 				502F0E172179C39900367CC3 /* RNNTabBarPresenterTest.m */,
+				50CE8502217C6C9B00084EBF /* RNNSideMenuPresenterTest.m */,
 				502F0E152178D09600367CC3 /* RNNBottomTabPresenterTest.m */,
 				5038A378216D01F6009280BC /* RNNBottomTabOptionsTest.m */,
 				7B49FEBF1E95090800DEB3EA /* Info.plist */,
 				509B258F2178BE7A00C83C23 /* RNNNavigationControllerPresenterTest.m in Sources */,
 				7B49FECD1E95098500DEB3EA /* RNNModalManagerTest.m in Sources */,
 				E83BAD791F27416B00A9F3DD /* RNNRootViewControllerTest.m in Sources */,
+				50CE8503217C6C9B00084EBF /* RNNSideMenuPresenterTest.m in Sources */,
 				E8DA243D1F973C1900CD552B /* RNNTransitionStateHolderTest.m in Sources */,
 				7B49FECC1E95098500DEB3EA /* RNNStoreTest.m in Sources */,
 			);

lib/ios/ReactNativeNavigationTests/RNNSideMenuPresenterTest.m

+#import <XCTest/XCTest.h>
+#import <OCMock/OCMock.h>
+#import "RNNSideMenuPresenter.h"
+#import "RNNSideMenuController.h"
+
+@interface RNNSideMenuPresenterTest : XCTestCase
+
+@property (nonatomic, strong) RNNSideMenuPresenter *uut;
+@property (nonatomic, strong) RNNNavigationOptions *options;
+@property (nonatomic, strong) id bindedViewController;
+
+@end
+
+@implementation RNNSideMenuPresenterTest
+
+- (void)setUp {
+    [super setUp];
+	self.uut = [[RNNSideMenuPresenter alloc] init];
+	self.bindedViewController = [OCMockObject partialMockForObject:[RNNSideMenuController new]];
+	[self.uut bindViewController:self.bindedViewController];
+	self.options = [[RNNNavigationOptions alloc] initEmptyOptions];
+}
+
+- (void)testApplyOptionsShouldSetDefaultValues {
+	[[self.bindedViewController expect] side:MMDrawerSideLeft enabled:YES];
+	[[self.bindedViewController expect] side:MMDrawerSideRight enabled:YES];
+	[[self.bindedViewController expect] setShouldStretchLeftDrawer:YES];
+	[[self.bindedViewController expect] setShouldStretchRightDrawer:YES];
+	[[self.bindedViewController expect] setAnimationVelocityLeft:840.0f];
+	[[self.bindedViewController expect] setAnimationVelocityRight:840.0f];
+	[[self.bindedViewController reject] side:MMDrawerSideLeft width:0];
+	[[self.bindedViewController reject] side:MMDrawerSideRight width:0];
+	
+	[self.uut applyOptions:self.options];
+
+	[self.bindedViewController verify];
+}
+
+- (void)testApplyOptionsShouldSetInitialValues {
+	self.options.sideMenu.left.enabled = [[Bool alloc] initWithBOOL:NO];
+	self.options.sideMenu.right.enabled = [[Bool alloc] initWithBOOL:NO];
+	self.options.sideMenu.left.shouldStretchDrawer = [[Bool alloc] initWithBOOL:NO];
+	self.options.sideMenu.right.shouldStretchDrawer = [[Bool alloc] initWithBOOL:NO];
+	self.options.sideMenu.right.animationVelocity = [[Double alloc] initWithValue:@(100.0f)];
+	self.options.sideMenu.left.animationVelocity = [[Double alloc] initWithValue:@(100.0f)];
+	self.options.sideMenu.right.width = [[Double alloc] initWithValue:@(100.0f)];
+	self.options.sideMenu.left.width = [[Double alloc] initWithValue:@(100.0f)];
+	
+	[[self.bindedViewController expect] side:MMDrawerSideLeft enabled:NO];
+	[[self.bindedViewController expect] side:MMDrawerSideRight enabled:NO];
+	[[self.bindedViewController expect] setShouldStretchLeftDrawer:NO];
+	[[self.bindedViewController expect] setShouldStretchRightDrawer:NO];
+	[[self.bindedViewController expect] setAnimationVelocityLeft:100.0f];
+	[[self.bindedViewController expect] setAnimationVelocityRight:100.0f];
+	[[self.bindedViewController expect] side:MMDrawerSideLeft width:100.0f];
+	[[self.bindedViewController expect] side:MMDrawerSideRight width:100.0f];
+	
+	[self.uut applyOptions:self.options];
+	
+	[self.bindedViewController verify];
+}
+
+
+@end