@amazon-devices/react-native-safe-area-context 2.0.1758683737

package/ios/SafeAreaView/RNCSafeAreaProviderManager.m

@@ -0,0 +1,61 @@
+#import "RNCSafeAreaProviderManager.h"
+
+#import "RNCSafeAreaProvider.h"
+
+@implementation RNCSafeAreaProviderManager
+
+RCT_EXPORT_MODULE(RNCSafeAreaProvider)
+
+RCT_EXPORT_VIEW_PROPERTY(onInsetsChange, RCTDirectEventBlock)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+- (UIView *)view
+{
+  return [RNCSafeAreaProvider new];
+}
+
+- (NSDictionary *)constantsToExport
+{
+    UIWindow* window = [[UIApplication sharedApplication] keyWindow];
+  if (@available(iOS 11.0, *)) {
+    UIEdgeInsets safeAreaInsets = window.safeAreaInsets;
+    return @{
+      @"initialWindowMetrics": @{
+        @"insets": @{
+          @"top": @(safeAreaInsets.top),
+          @"right": @(safeAreaInsets.right),
+          @"bottom": @(safeAreaInsets.bottom),
+          @"left": @(safeAreaInsets.left),
+        },
+        @"frame": @{
+          @"x": @(window.frame.origin.x),
+          @"y": @(window.frame.origin.y),
+          @"width": @(window.frame.size.width),
+          @"height": @(window.frame.size.height),
+        },
+      }
+    };
+  } else {
+    return @{ @"initialWindowMetrics": @{
+        @"insets": @{
+          @"top": @(20),
+          @"right": @(0),
+          @"bottom": @(0),
+          @"left": @(0),
+        },
+        @"frame": @{
+          @"x": @(window.frame.origin.x),
+          @"y": @(window.frame.origin.y),
+          @"width": @(window.frame.size.width),
+          @"height": @(window.frame.size.height),
+        },
+      }
+    } ;
+  }
+}
+
+@end

package/ios/SafeAreaView/RNCSafeAreaShadowView.h

@@ -0,0 +1,9 @@
+#import <React/RCTShadowView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNCSafeAreaShadowView : RCTShadowView
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SafeAreaView/RNCSafeAreaShadowView.m

@@ -0,0 +1,180 @@
+#import "RNCSafeAreaShadowView.h"
+
+#import <React/RCTAssert.h>
+#include <math.h>
+
+#import "RNCSafeAreaViewLocalData.h"
+#import "RNCSafeAreaViewMode.h"
+#import "RNCSafeAreaViewEdges.h"
+
+// From RCTShadowView.m
+typedef NS_ENUM(unsigned int, meta_prop_t) {
+  META_PROP_LEFT,
+  META_PROP_TOP,
+  META_PROP_RIGHT,
+  META_PROP_BOTTOM,
+  META_PROP_HORIZONTAL,
+  META_PROP_VERTICAL,
+  META_PROP_ALL,
+  META_PROP_COUNT,
+};
+
+@implementation RNCSafeAreaShadowView {
+  RNCSafeAreaViewLocalData *_localData;
+  bool _needsUpdate;
+  YGValue _paddingMetaProps[META_PROP_COUNT];
+  YGValue _marginMetaProps[META_PROP_COUNT];
+}
+
+- (instancetype)init
+{
+  self = [super init];
+  if (self) {
+    _needsUpdate = false;
+    for (unsigned int ii = 0; ii < META_PROP_COUNT; ii++) {
+      _paddingMetaProps[ii] = YGValueUndefined;
+      _marginMetaProps[ii] = YGValueUndefined;
+    }
+  }
+  return self;
+}
+
+- (void)extractEdges:(YGValue[])_metaProps top:(CGFloat *)top right:(CGFloat *)right bottom:(CGFloat *)bottom left:(CGFloat *)left
+{
+  if (_metaProps[META_PROP_ALL].unit == YGUnitPoint) {
+    *top = _metaProps[META_PROP_ALL].value;
+    *right = _metaProps[META_PROP_ALL].value;
+    *bottom = _metaProps[META_PROP_ALL].value;
+    *left = _metaProps[META_PROP_ALL].value;
+  }
+
+  if (_metaProps[META_PROP_HORIZONTAL].unit == YGUnitPoint) {
+    *right = _metaProps[META_PROP_HORIZONTAL].value;
+    *left = _metaProps[META_PROP_HORIZONTAL].value;
+  }
+
+  if (_metaProps[META_PROP_VERTICAL].unit == YGUnitPoint) {
+    *top = _metaProps[META_PROP_VERTICAL].value;
+    *bottom = _metaProps[META_PROP_VERTICAL].value;
+  }
+
+  if (_metaProps[META_PROP_TOP].unit == YGUnitPoint) {
+    *top = _metaProps[META_PROP_TOP].value;
+  }
+    
+  if (_metaProps[META_PROP_RIGHT].unit == YGUnitPoint) {
+    *right = _metaProps[META_PROP_RIGHT].value;
+  }
+
+  if (_metaProps[META_PROP_BOTTOM].unit == YGUnitPoint) {
+    *bottom = _metaProps[META_PROP_BOTTOM].value;
+  }
+
+  if (_metaProps[META_PROP_LEFT].unit == YGUnitPoint) {
+    *left = _metaProps[META_PROP_LEFT].value;
+  }
+}
+
+- (void)resetInsetsForMode:(RNCSafeAreaViewMode)mode {
+  if (mode == RNCSafeAreaViewModePadding) {
+    super.paddingTop = _paddingMetaProps[META_PROP_TOP];
+    super.paddingRight = _paddingMetaProps[META_PROP_RIGHT];
+    super.paddingBottom = _paddingMetaProps[META_PROP_BOTTOM];
+    super.paddingLeft = _paddingMetaProps[META_PROP_LEFT];
+  } else if (mode == RNCSafeAreaViewModeMargin) {
+    super.marginTop = _marginMetaProps[META_PROP_TOP];
+    super.marginRight = _marginMetaProps[META_PROP_RIGHT];
+    super.marginBottom = _marginMetaProps[META_PROP_BOTTOM];
+    super.marginLeft = _marginMetaProps[META_PROP_LEFT];
+  }
+}
+
+- (void)updateInsets
+{
+  if (_localData == nil) {
+    return;
+  }
+
+  UIEdgeInsets insets = _localData.insets;
+  RNCSafeAreaViewMode mode = _localData.mode;
+  RNCSafeAreaViewEdges edges = _localData.edges;
+
+  CGFloat top = 0;
+  CGFloat right = 0;
+  CGFloat bottom = 0;
+  CGFloat left = 0;
+
+  CGFloat insetTop = (edges & RNCSafeAreaViewEdgesTop) ? insets.top : 0;
+  CGFloat insetRight = (edges & RNCSafeAreaViewEdgesRight) ? insets.right : 0;
+  CGFloat insetBottom = (edges & RNCSafeAreaViewEdgesBottom) ? insets.bottom : 0;
+  CGFloat insetLeft = (edges & RNCSafeAreaViewEdgesLeft) ? insets.left : 0;
+
+  if (mode == RNCSafeAreaViewModePadding) {
+    [self extractEdges:_paddingMetaProps top:&top right:&right bottom:&bottom left:&left];
+    super.paddingTop = (YGValue){insetTop + top, YGUnitPoint};
+    super.paddingRight = (YGValue){insetRight + right, YGUnitPoint};
+    super.paddingBottom = (YGValue){insetBottom + bottom, YGUnitPoint};
+    super.paddingLeft = (YGValue){insetLeft + left, YGUnitPoint};
+  } else if (mode == RNCSafeAreaViewModeMargin) {
+    [self extractEdges:_marginMetaProps top:&top right:&right bottom:&bottom left:&left];
+    super.marginTop = (YGValue){insetTop + top, YGUnitPoint};
+    super.marginRight = (YGValue){insetRight + right, YGUnitPoint};
+    super.marginBottom = (YGValue){insetBottom + bottom, YGUnitPoint};
+    super.marginLeft = (YGValue){insetLeft + left, YGUnitPoint};
+  }
+}
+
+- (void)didSetProps:(NSArray<NSString *> *)changedProps
+{
+  if (_needsUpdate) {
+    _needsUpdate = false;
+    [self updateInsets];
+  }
+  [super didSetProps:changedProps];
+}
+
+- (void)setLocalData:(RNCSafeAreaViewLocalData *)localData
+{
+  RCTAssert(
+    [localData isKindOfClass:[RNCSafeAreaViewLocalData class]],
+    @"Local data object for `RCTRNCSafeAreaShadowView` must be `RCTRNCSafeAreaViewLocalData` instance."
+  );
+
+  if (_localData != nil && _localData.mode != localData.mode) {
+    [self resetInsetsForMode:_localData.mode];
+  }
+  
+  _localData = localData;
+  _needsUpdate = false;
+  [self updateInsets];
+  
+  if (_localData.mode == RNCSafeAreaViewModePadding) {
+    [super didSetProps:@[@"paddingTop", @"paddingRight", @"paddingBottom", @"paddingLeft"]];
+  } else {
+    [super didSetProps:@[@"marginTop", @"marginRight", @"marginBottom", @"marginLeft"]];
+  }
+}
+
+#define SHADOW_VIEW_MARGIN_PADDING_PROP(edge, metaProp) \
+- (void)setPadding##edge:(YGValue)value                 \
+{                                                       \
+  [super setPadding##edge:value];                       \
+  _needsUpdate = true;                                  \
+  _paddingMetaProps[META_PROP_##metaProp] = value;      \
+}                                                       \
+- (void)setMargin##edge:(YGValue)value                  \
+{                                                       \
+  [super setMargin##edge:value];                        \
+  _needsUpdate = true;                                  \
+  _marginMetaProps[META_PROP_##metaProp] = value;       \
+}
+
+SHADOW_VIEW_MARGIN_PADDING_PROP(, ALL);
+SHADOW_VIEW_MARGIN_PADDING_PROP(Vertical, VERTICAL);
+SHADOW_VIEW_MARGIN_PADDING_PROP(Horizontal, HORIZONTAL);
+SHADOW_VIEW_MARGIN_PADDING_PROP(Top, TOP);
+SHADOW_VIEW_MARGIN_PADDING_PROP(Right, RIGHT);
+SHADOW_VIEW_MARGIN_PADDING_PROP(Bottom, BOTTOM);
+SHADOW_VIEW_MARGIN_PADDING_PROP(Left, LEFT);
+
+@end

package/ios/SafeAreaView/RNCSafeAreaView.h

@@ -0,0 +1,21 @@
+#import <UIKit/UIKit.h>
+#import <React/RCTView.h>
+#import <React/RCTBridge.h>
+
+#import "RNCSafeAreaViewMode.h"
+#import "RNCSafeAreaViewEdges.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RNCSafeAreaView;
+
+@interface RNCSafeAreaView: RCTView
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge;
+
+@property (nonatomic, assign) RNCSafeAreaViewMode mode;
+@property (nonatomic, assign) RNCSafeAreaViewEdges edges;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SafeAreaView/RNCSafeAreaView.m

@@ -0,0 +1,118 @@
+#import "RNCSafeAreaView.h"
+
+#import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
+
+#import "RNCSafeAreaViewLocalData.h"
+#import "RNCSafeAreaViewMode.h"
+#import "RNCSafeAreaViewEdges.h"
+#import "RCTView+SafeAreaCompat.h"
+#import "RNCSafeAreaProvider.h"
+
+@implementation RNCSafeAreaView {
+  __weak RCTBridge *_bridge;
+  UIEdgeInsets _currentSafeAreaInsets;
+  RNCSafeAreaViewMode _mode;
+  RNCSafeAreaViewEdges _edges;
+  __weak UIView * _Nullable _providerView;
+}
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+{
+  if (self = [super initWithFrame:CGRectZero]) {
+    _bridge = bridge;
+    // Defaults
+    _mode = RNCSafeAreaViewModePadding;
+    _edges = RNCSafeAreaViewEdgesAll;
+  }
+
+  return self;
+}
+
+RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : (NSCoder *)decoder)
+RCT_NOT_IMPLEMENTED(-(instancetype)initWithFrame : (CGRect)frame)
+
+- (NSString *)description
+{
+  NSString *superDescription = [super description];
+
+  // Cutting the last `>` character.
+  if (superDescription.length > 0 && [superDescription characterAtIndex:superDescription.length - 1] == '>') {
+    superDescription = [superDescription substringToIndex:superDescription.length - 1];
+  }
+
+  return [NSString stringWithFormat:@"%@; RNCSafeAreaInsets = %@; appliedRNCSafeAreaInsets = %@>",
+          superDescription,
+          NSStringFromUIEdgeInsets([_providerView safeAreaInsetsOrEmulate]),
+          NSStringFromUIEdgeInsets(_currentSafeAreaInsets)];
+}
+
+- (void)safeAreaInsetsDidChange
+{
+  [super safeAreaInsetsDidChange];
+  [self invalidateSafeAreaInsets];
+}
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+
+  if (!self.nativeSafeAreaSupport) {
+    [self invalidateSafeAreaInsets];
+  }
+}
+
+- (void)didMoveToWindow
+{
+  _providerView = [self findNearestProvider];
+  [self invalidateSafeAreaInsets];
+}
+
+- (void)invalidateSafeAreaInsets
+{
+  if (_providerView == nil) {
+    return;
+  }
+  UIEdgeInsets safeAreaInsets = [_providerView safeAreaInsetsOrEmulate];
+
+  if (UIEdgeInsetsEqualToEdgeInsetsWithThreshold(safeAreaInsets, _currentSafeAreaInsets, 1.0 / RCTScreenScale())) {
+    return;
+  }
+
+  _currentSafeAreaInsets = safeAreaInsets;
+  [self updateLocalData];
+}
+
+- (UIView *)findNearestProvider
+{
+  UIView *current = self.reactSuperview;
+  while (current != nil) {
+    if ([current isKindOfClass:RNCSafeAreaProvider.class] ) {
+      return current;
+    }
+    current = current.reactSuperview;
+  }
+  return self;
+}
+
+- (void)updateLocalData
+{
+  RNCSafeAreaViewLocalData *localData = [[RNCSafeAreaViewLocalData alloc] initWithInsets:_currentSafeAreaInsets
+                                                                                    mode:_mode
+                                                                                   edges:_edges];
+  [_bridge.uiManager setLocalData:localData forView:self];
+}
+
+- (void)setMode:(RNCSafeAreaViewMode)mode
+{
+  _mode = mode;
+  [self updateLocalData];
+}
+
+- (void)setEdges:(RNCSafeAreaViewEdges)edges
+{
+  _edges = edges;
+  [self updateLocalData];
+}
+
+@end

package/ios/SafeAreaView/RNCSafeAreaViewEdges.h

@@ -0,0 +1,9 @@
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, RNCSafeAreaViewEdges) {
+  RNCSafeAreaViewEdgesTop    = 0b1000,
+  RNCSafeAreaViewEdgesRight  = 0b0100,
+  RNCSafeAreaViewEdgesBottom = 0b0010,
+  RNCSafeAreaViewEdgesLeft   = 0b0001,
+  RNCSafeAreaViewEdgesAll    = 0b1111,
+};

package/ios/SafeAreaView/RNCSafeAreaViewEdges.m

@@ -0,0 +1,13 @@
+#import <React/RCTConvert.h>
+#import "RNCSafeAreaViewEdges.h"
+
+@implementation RCTConvert (RNCSafeAreaView)
+
+RCT_MULTI_ENUM_CONVERTER(RNCSafeAreaViewEdges, (@{
+  @"top": @(RNCSafeAreaViewEdgesTop),
+  @"right": @(RNCSafeAreaViewEdgesRight),
+  @"bottom": @(RNCSafeAreaViewEdgesBottom),
+  @"left": @(RNCSafeAreaViewEdgesLeft),
+}), RNCSafeAreaViewEdgesAll, integerValue);
+
+@end

package/ios/SafeAreaView/RNCSafeAreaViewLocalData.h

@@ -0,0 +1,18 @@
+#import <UIKit/UIKit.h>
+
+#import "RNCSafeAreaViewMode.h"
+#import "RNCSafeAreaViewEdges.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNCSafeAreaViewLocalData : NSObject
+
+- (instancetype)initWithInsets:(UIEdgeInsets)insets mode:(RNCSafeAreaViewMode)mode edges:(RNCSafeAreaViewEdges)edges;
+
+@property (atomic, readonly) UIEdgeInsets insets;
+@property (atomic, readonly) RNCSafeAreaViewMode mode;
+@property (atomic, readonly) RNCSafeAreaViewEdges edges;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SafeAreaView/RNCSafeAreaViewLocalData.m

@@ -0,0 +1,16 @@
+#import "RNCSafeAreaViewLocalData.h"
+
+@implementation RNCSafeAreaViewLocalData
+
+- (instancetype)initWithInsets:(UIEdgeInsets)insets mode:(RNCSafeAreaViewMode)mode edges:(RNCSafeAreaViewEdges)edges
+{
+  if (self = [super init]) {
+    _insets = insets;
+    _mode = mode;
+    _edges = edges;
+  }
+
+  return self;
+}
+
+@end

package/ios/SafeAreaView/RNCSafeAreaViewManager.h

@@ -0,0 +1,9 @@
+#import <React/RCTViewManager.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNCSafeAreaViewManager : RCTViewManager
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SafeAreaView/RNCSafeAreaViewManager.m

@@ -0,0 +1,25 @@
+#import "RNCSafeAreaViewManager.h"
+
+#import "RNCSafeAreaShadowView.h"
+#import "RNCSafeAreaView.h"
+#import "RNCSafeAreaViewMode.h"
+#import "RNCSafeAreaViewEdges.h"
+
+@implementation RNCSafeAreaViewManager
+
+RCT_EXPORT_MODULE(RNCSafeAreaView)
+
+- (UIView *)view
+{
+  return [[RNCSafeAreaView alloc] initWithBridge:self.bridge];
+}
+
+- (RNCSafeAreaShadowView *)shadowView
+{
+  return [RNCSafeAreaShadowView new];
+}
+
+RCT_EXPORT_VIEW_PROPERTY(mode, RNCSafeAreaViewMode)
+RCT_EXPORT_VIEW_PROPERTY(edges, RNCSafeAreaViewEdges)
+
+@end

package/ios/SafeAreaView/RNCSafeAreaViewMode.h

@@ -0,0 +1,7 @@
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, RNCSafeAreaViewMode) {
+  RNCSafeAreaViewModePadding,
+  RNCSafeAreaViewModeMargin,
+  RNCSafeAreaViewModeBorder,
+};

package/ios/SafeAreaView/RNCSafeAreaViewMode.m

@@ -0,0 +1,11 @@
+#import <React/RCTConvert.h>
+#import "RNCSafeAreaViewMode.h"
+
+@implementation RCTConvert (RNCSafeAreaView)
+
+RCT_MULTI_ENUM_CONVERTER(RNCSafeAreaViewMode, (@{
+  @"padding": @(RNCSafeAreaViewModePadding),
+  @"margin": @(RNCSafeAreaViewModeMargin),
+}), RNCSafeAreaViewModePadding, integerValue);
+
+@end