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

package/android/src/main/java/com/th3rdwave/safeareacontext/SafeAreaView.java

@@ -0,0 +1,159 @@
+package com.th3rdwave.safeareacontext;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewParent;
+import android.view.ViewTreeObserver;
+
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.views.view.ReactViewGroup;
+
+import java.util.EnumSet;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import androidx.annotation.Nullable;
+
+@SuppressLint("ViewConstructor")
+public class SafeAreaView extends ReactViewGroup implements ViewTreeObserver.OnPreDrawListener {
+  private SafeAreaViewMode mMode = SafeAreaViewMode.PADDING;
+  private @Nullable EdgeInsets mInsets;
+  private @Nullable EnumSet<SafeAreaViewEdges> mEdges;
+  private @Nullable View mProviderView;
+
+  public SafeAreaView(Context context) {
+    super(context);
+  }
+
+  /**
+   * UIManagerHelper.getReactContext only exists in RN 0.63+ so vendor it here for a while.
+   */
+  private static ReactContext getReactContext(View view) {
+    Context context = view.getContext();
+    if (!(context instanceof ReactContext) && context instanceof ContextWrapper) {
+      context = ((ContextWrapper) context).getBaseContext();
+    }
+    return (ReactContext) context;
+  }
+
+  private void updateInsets() {
+    if (mInsets != null) {
+      EnumSet<SafeAreaViewEdges> edges = mEdges != null
+              ? mEdges
+              : EnumSet.allOf(SafeAreaViewEdges.class);
+
+      SafeAreaViewLocalData localData = new SafeAreaViewLocalData(mInsets, mMode, edges);
+
+      ReactContext reactContext = getReactContext(this);
+      UIManagerModule uiManager = reactContext.getNativeModule(UIManagerModule.class);
+      if (uiManager != null) {
+        uiManager.setViewLocalData(getId(), localData);
+        waitForReactLayout();
+      }
+    }
+  }
+
+  private static final long MAX_WAIT_TIME_NANO = 500000000L; // 500ms
+
+  private void waitForReactLayout() {
+    // Block the main thread until the native module thread is finished with
+    // its current tasks. To do this we use the done boolean as a lock and enqueue
+    // a task on the native modules thread. When the task runs we can unblock the
+    // main thread. This should be safe as long as the native modules thread
+    // does not block waiting on the main thread.
+    final AtomicBoolean done = new AtomicBoolean(false);
+    final long startTime = System.nanoTime();
+    long waitTime = 0L;
+    getReactContext(this).runOnNativeModulesQueueThread(new Runnable() {
+      @Override
+      public void run() {
+        synchronized (done) {
+          if (done.compareAndSet(false, true)) {
+            done.notify();
+          }
+        }
+      }
+    });
+    synchronized (done) {
+      while (!done.get() && waitTime < MAX_WAIT_TIME_NANO) {
+        try {
+          done.wait(MAX_WAIT_TIME_NANO / 1000000L);
+        } catch (InterruptedException e) {
+          // In case of an interrupt just give up waiting.
+          done.set(true);
+        }
+        waitTime += System.nanoTime() - startTime;
+      }
+      // Timed out waiting.
+      if (waitTime >= MAX_WAIT_TIME_NANO) {
+        Log.w("SafeAreaView", "Timed out waiting for layout.");
+      }
+    }
+  }
+
+  public void setMode(SafeAreaViewMode mode) {
+    mMode = mode;
+    updateInsets();
+  }
+
+  public void setEdges(EnumSet<SafeAreaViewEdges> edges) {
+    mEdges = edges;
+    updateInsets();
+  }
+
+  private boolean maybeUpdateInsets() {
+    if (mProviderView == null) {
+      return false;
+    }
+    EdgeInsets edgeInsets = SafeAreaUtils.getSafeAreaInsets(mProviderView);
+    if (edgeInsets != null && (mInsets == null || !mInsets.equalsToEdgeInsets(edgeInsets))) {
+      mInsets = edgeInsets;
+      updateInsets();
+      return true;
+    }
+    return false;
+  }
+
+  private View findProvider() {
+    ViewParent current = getParent();
+    while (current != null) {
+      if (current instanceof SafeAreaProvider) {
+        return (View) current;
+      }
+      current = current.getParent();
+    }
+    return this;
+  }
+
+  @Override
+  protected void onAttachedToWindow() {
+    super.onAttachedToWindow();
+
+    mProviderView = findProvider();
+
+    mProviderView.getViewTreeObserver().addOnPreDrawListener(this);
+    maybeUpdateInsets();
+  }
+
+  @Override
+  protected void onDetachedFromWindow() {
+    super.onDetachedFromWindow();
+
+    if (mProviderView != null) {
+      mProviderView.getViewTreeObserver().removeOnPreDrawListener(this);
+    }
+    mProviderView = null;
+  }
+
+  @Override
+  public boolean onPreDraw() {
+    boolean didUpdate = maybeUpdateInsets();
+    if (didUpdate) {
+      requestLayout();
+    }
+    return !didUpdate;
+  }
+}

package/android/src/main/java/com/th3rdwave/safeareacontext/SafeAreaViewEdges.java

@@ -0,0 +1,8 @@
+package com.th3rdwave.safeareacontext;
+
+public enum SafeAreaViewEdges {
+  TOP,
+  RIGHT,
+  BOTTOM,
+  LEFT
+}

package/android/src/main/java/com/th3rdwave/safeareacontext/SafeAreaViewLocalData.java

@@ -0,0 +1,27 @@
+package com.th3rdwave.safeareacontext;
+
+import java.util.EnumSet;
+
+public class SafeAreaViewLocalData {
+  private EdgeInsets mInsets;
+  private SafeAreaViewMode mMode;
+  private EnumSet<SafeAreaViewEdges> mEdges;
+
+  public SafeAreaViewLocalData(EdgeInsets insets, SafeAreaViewMode mode, EnumSet<SafeAreaViewEdges> edges) {
+    mInsets = insets;
+    mMode = mode;
+    mEdges = edges;
+  }
+
+  public EdgeInsets getInsets() {
+    return mInsets;
+  }
+
+  public SafeAreaViewMode getMode() {
+    return mMode;
+  }
+
+  public  EnumSet<SafeAreaViewEdges> getEdges() {
+    return mEdges;
+  }
+}

package/android/src/main/java/com/th3rdwave/safeareacontext/SafeAreaViewManager.java

@@ -0,0 +1,72 @@
+package com.th3rdwave.safeareacontext;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.uimanager.LayoutShadowNode;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.facebook.react.views.view.ReactViewManager;
+
+import java.util.EnumSet;
+
+public class SafeAreaViewManager extends ReactViewManager {
+  public SafeAreaViewManager() {
+    super();
+  }
+
+  @Override
+  @NonNull
+  public String getName() {
+    return "RNCSafeAreaView";
+  }
+
+  @Override
+  @NonNull
+  public SafeAreaView createViewInstance(@NonNull ThemedReactContext context) {
+    return new SafeAreaView(context);
+  }
+
+  @Override
+  @NonNull
+  public SafeAreaViewShadowNode createShadowNodeInstance() {
+    return new SafeAreaViewShadowNode();
+  }
+
+  @Override
+  public Class<? extends LayoutShadowNode> getShadowNodeClass() {
+    return SafeAreaViewShadowNode.class;
+  }
+
+  @ReactProp(name = "mode")
+  public void setMode(SafeAreaView view, @Nullable String mode) {
+    if ("padding".equals(mode)) {
+      view.setMode(SafeAreaViewMode.PADDING);
+    } else if ("margin".equals(mode)) {
+      view.setMode(SafeAreaViewMode.MARGIN);
+    }
+  }
+
+  @ReactProp(name = "edges")
+  public void setEdges(SafeAreaView view, @Nullable ReadableArray propList) {
+    EnumSet<SafeAreaViewEdges> edges = EnumSet.noneOf(SafeAreaViewEdges.class);
+
+    if (propList != null) {
+      for (int i = 0; i < propList.size(); i += 1) {
+        String edgeName = propList.getString(i);
+        if ("top".equals(edgeName)) {
+          edges.add(SafeAreaViewEdges.TOP);
+        } else if ("right".equals(edgeName)) {
+          edges.add(SafeAreaViewEdges.RIGHT);
+        } else if ("bottom".equals(edgeName)) {
+          edges.add(SafeAreaViewEdges.BOTTOM);
+        } else if ("left".equals(edgeName)) {
+          edges.add(SafeAreaViewEdges.LEFT);
+        }
+      }
+    }
+
+    view.setEdges(edges);
+  }
+}

package/android/src/main/java/com/th3rdwave/safeareacontext/SafeAreaViewMode.java

@@ -0,0 +1,6 @@
+package com.th3rdwave.safeareacontext;
+
+public enum SafeAreaViewMode {
+  PADDING,
+  MARGIN
+}

package/android/src/main/java/com/th3rdwave/safeareacontext/SafeAreaViewShadowNode.java

@@ -0,0 +1,201 @@
+package com.th3rdwave.safeareacontext;
+
+import com.facebook.react.bridge.Dynamic;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.uimanager.LayoutShadowNode;
+import com.facebook.react.uimanager.NativeViewHierarchyOptimizer;
+import com.facebook.react.uimanager.PixelUtil;
+import com.facebook.react.uimanager.Spacing;
+import com.facebook.react.uimanager.ViewProps;
+import com.facebook.react.uimanager.annotations.ReactPropGroup;
+
+import java.util.EnumSet;
+
+import androidx.annotation.Nullable;
+
+public class SafeAreaViewShadowNode extends LayoutShadowNode {
+  private @Nullable SafeAreaViewLocalData mLocalData;
+
+  private float[] mPaddings;
+  private float[] mMargins;
+  private boolean mNeedsUpdate = false;
+
+  public SafeAreaViewShadowNode() {
+    super();
+
+    mPaddings = new float[ViewProps.PADDING_MARGIN_SPACING_TYPES.length];
+    mMargins = new float[ViewProps.PADDING_MARGIN_SPACING_TYPES.length];
+
+    for (int i = 0; i < ViewProps.PADDING_MARGIN_SPACING_TYPES.length; i += 1) {
+      mPaddings[i] = Float.NaN;
+      mMargins[i] = Float.NaN;
+    }
+  }
+
+  private void updateInsets() {
+    if (mLocalData == null) {
+      return;
+    }
+
+    float top = 0;
+    float right = 0;
+    float bottom = 0;
+    float left = 0;
+
+    float[] meta = mLocalData.getMode() == SafeAreaViewMode.PADDING ? mPaddings : mMargins;
+
+    float allEdges = meta[Spacing.ALL];
+    if (!Float.isNaN(allEdges)) {
+      top = allEdges;
+      right = allEdges;
+      bottom = allEdges;
+      left = allEdges;
+    }
+
+    float verticalEdges = meta[Spacing.VERTICAL];
+    if (!Float.isNaN(verticalEdges)) {
+      top = verticalEdges;
+      bottom = verticalEdges;
+    }
+
+    float horizontalEdges = meta[Spacing.HORIZONTAL];
+    if (!Float.isNaN(horizontalEdges)) {
+      right = horizontalEdges;
+      left = horizontalEdges;
+    }
+
+    float topEdge = meta[Spacing.TOP];
+    if (!Float.isNaN(topEdge)) {
+      top = topEdge;
+    }
+
+    float rightEdge = meta[Spacing.RIGHT];
+    if (!Float.isNaN(rightEdge)) {
+      right = rightEdge;
+    }
+
+    float bottomEdge = meta[Spacing.BOTTOM];
+    if (!Float.isNaN(bottomEdge)) {
+      bottom = bottomEdge;
+    }
+
+    float leftEdge = meta[Spacing.LEFT];
+    if (!Float.isNaN(leftEdge)) {
+      left = leftEdge;
+    }
+
+    top = PixelUtil.toPixelFromDIP(top);
+    right = PixelUtil.toPixelFromDIP(right);
+    bottom = PixelUtil.toPixelFromDIP(bottom);
+    left = PixelUtil.toPixelFromDIP(left);
+
+    EnumSet<SafeAreaViewEdges> edges = mLocalData.getEdges();
+    EdgeInsets insets = mLocalData.getInsets();
+    float insetTop = edges.contains(SafeAreaViewEdges.TOP) ? insets.top : 0;
+    float insetRight = edges.contains(SafeAreaViewEdges.RIGHT) ? insets.right : 0;
+    float insetBottom = edges.contains(SafeAreaViewEdges.BOTTOM) ? insets.bottom : 0;
+    float insetLeft = edges.contains(SafeAreaViewEdges.LEFT) ? insets.left : 0;
+
+    if (mLocalData.getMode() == SafeAreaViewMode.PADDING) {
+      super.setPadding(Spacing.TOP, insetTop + top);
+      super.setPadding(Spacing.RIGHT, insetRight + right);
+      super.setPadding(Spacing.BOTTOM, insetBottom + bottom);
+      super.setPadding(Spacing.LEFT, insetLeft + left);
+    } else {
+      super.setMargin(Spacing.TOP, insetTop + top);
+      super.setMargin(Spacing.RIGHT, insetRight + right);
+      super.setMargin(Spacing.BOTTOM, insetBottom + bottom);
+      super.setMargin(Spacing.LEFT, insetLeft + left);
+    }
+  }
+
+  private void resetInsets(SafeAreaViewMode mode) {
+    if (mode == SafeAreaViewMode.PADDING) {
+      super.setPadding(Spacing.TOP, mPaddings[Spacing.TOP]);
+      super.setPadding(Spacing.RIGHT, mPaddings[Spacing.TOP]);
+      super.setPadding(Spacing.BOTTOM, mPaddings[Spacing.BOTTOM]);
+      super.setPadding(Spacing.LEFT, mPaddings[Spacing.LEFT]);
+    } else {
+      super.setMargin(Spacing.TOP, mMargins[Spacing.TOP]);
+      super.setMargin(Spacing.RIGHT, mMargins[Spacing.TOP]);
+      super.setMargin(Spacing.BOTTOM, mMargins[Spacing.BOTTOM]);
+      super.setMargin(Spacing.LEFT, mMargins[Spacing.LEFT]);
+    }
+  }
+
+  // The signature for onBeforeLayout is different in RN 0.59.
+  // Remove when we drop support for this version and add back @Override and super call to
+  // onBeforeLayout(NativeViewHierarchyOptimizer).
+  public void onBeforeLayout() {
+    if (mNeedsUpdate) {
+      mNeedsUpdate = false;
+      updateInsets();
+    }
+  }
+
+  public void onBeforeLayout(NativeViewHierarchyOptimizer nativeViewHierarchyOptimizer) {
+    if (mNeedsUpdate) {
+      mNeedsUpdate = false;
+      updateInsets();
+    }
+  }
+
+  @Override
+  public void setLocalData(Object data) {
+    if (!(data instanceof SafeAreaViewLocalData)) {
+      return;
+    }
+
+    SafeAreaViewLocalData localData = (SafeAreaViewLocalData) data;
+
+    if (mLocalData != null && mLocalData.getMode() != localData.getMode()) {
+      resetInsets(mLocalData.getMode());
+    }
+
+    mLocalData = localData;
+
+    mNeedsUpdate = false;
+    updateInsets();
+  }
+
+  // Names needs to reflect exact order in LayoutShadowNode.java
+  @Override
+  @ReactPropGroup(
+    names = {
+      ViewProps.PADDING,
+      ViewProps.PADDING_VERTICAL,
+      ViewProps.PADDING_HORIZONTAL,
+      ViewProps.PADDING_START,
+      ViewProps.PADDING_END,
+      ViewProps.PADDING_TOP,
+      ViewProps.PADDING_BOTTOM,
+      ViewProps.PADDING_LEFT,
+      ViewProps.PADDING_RIGHT,
+    })
+  public void setPaddings(int index, Dynamic padding) {
+    int spacingType = ViewProps.PADDING_MARGIN_SPACING_TYPES[index];
+    mPaddings[spacingType] = padding.getType() == ReadableType.Number ? (float) padding.asDouble() : Float.NaN;
+    super.setPaddings(index, padding);
+    mNeedsUpdate = true;
+  }
+
+  @Override
+  @ReactPropGroup(
+    names = {
+      ViewProps.MARGIN,
+      ViewProps.MARGIN_VERTICAL,
+      ViewProps.MARGIN_HORIZONTAL,
+      ViewProps.MARGIN_START,
+      ViewProps.MARGIN_END,
+      ViewProps.MARGIN_TOP,
+      ViewProps.MARGIN_BOTTOM,
+      ViewProps.MARGIN_LEFT,
+      ViewProps.MARGIN_RIGHT,
+    })
+  public void setMargins(int index, Dynamic margin) {
+    int spacingType = ViewProps.PADDING_MARGIN_SPACING_TYPES[index];
+    mMargins[spacingType] = margin.getType() == ReadableType.Number ? (float) margin.asDouble() : Float.NaN;
+    super.setMargins(index, margin);
+    mNeedsUpdate = true;
+  }
+}

package/android/src/main/java/com/th3rdwave/safeareacontext/SerializationUtils.java

@@ -0,0 +1,52 @@
+package com.th3rdwave.safeareacontext;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.PixelUtil;
+
+import java.util.Map;
+
+/* package */ class SerializationUtils {
+  static WritableMap edgeInsetsToJsMap(EdgeInsets insets) {
+    WritableMap insetsMap = Arguments.createMap();
+    insetsMap.putDouble("top", PixelUtil.toDIPFromPixel(insets.top));
+    insetsMap.putDouble("right", PixelUtil.toDIPFromPixel(insets.right));
+    insetsMap.putDouble("bottom", PixelUtil.toDIPFromPixel(insets.bottom));
+    insetsMap.putDouble("left", PixelUtil.toDIPFromPixel(insets.left));
+    return insetsMap;
+  }
+
+  static Map<String, Float> edgeInsetsToJavaMap(EdgeInsets insets) {
+    return MapBuilder.of(
+        "top",
+        PixelUtil.toDIPFromPixel(insets.top),
+        "right",
+        PixelUtil.toDIPFromPixel(insets.right),
+        "bottom",
+        PixelUtil.toDIPFromPixel(insets.bottom),
+        "left",
+        PixelUtil.toDIPFromPixel(insets.left));
+  }
+
+  static WritableMap rectToJsMap(Rect rect) {
+    WritableMap rectMap = Arguments.createMap();
+    rectMap.putDouble("x", PixelUtil.toDIPFromPixel(rect.x));
+    rectMap.putDouble("y", PixelUtil.toDIPFromPixel(rect.y));
+    rectMap.putDouble("width", PixelUtil.toDIPFromPixel(rect.width));
+    rectMap.putDouble("height", PixelUtil.toDIPFromPixel(rect.height));
+    return rectMap;
+  }
+
+  static Map<String, Float> rectToJavaMap(Rect rect) {
+    return MapBuilder.of(
+        "x",
+        PixelUtil.toDIPFromPixel(rect.x),
+        "y",
+        PixelUtil.toDIPFromPixel(rect.y),
+        "width",
+        PixelUtil.toDIPFromPixel(rect.width),
+        "height",
+        PixelUtil.toDIPFromPixel(rect.height));
+  }
+}

package/ios/SafeAreaView/RCTView+SafeAreaCompat.h

@@ -0,0 +1,16 @@
+#import <UIKit/UIKit.h>
+#import <React/RCTDefines.h>
+#import <React/RCTView.h>
+
+RCT_EXTERN BOOL UIEdgeInsetsEqualToEdgeInsetsWithThreshold(UIEdgeInsets insets1, UIEdgeInsets insets2, CGFloat threshold);
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface UIView(SafeAreaCompat)
+
+- (BOOL)nativeSafeAreaSupport;
+- (UIEdgeInsets)safeAreaInsetsOrEmulate;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SafeAreaView/RCTView+SafeAreaCompat.m

@@ -0,0 +1,57 @@
+#import "RCTView+SafeAreaCompat.h"
+
+#import <React/RCTUIManager.h>
+
+BOOL UIEdgeInsetsEqualToEdgeInsetsWithThreshold(UIEdgeInsets insets1, UIEdgeInsets insets2, CGFloat threshold)
+{
+  return ABS(insets1.left - insets2.left) <= threshold &&
+    ABS(insets1.right - insets2.right) <= threshold &&
+    ABS(insets1.top - insets2.top) <= threshold &&
+    ABS(insets1.bottom - insets2.bottom) <= threshold;
+}
+
+@implementation UIView(SafeAreaCompat)
+
+- (BOOL)nativeSafeAreaSupport
+{
+  return [self respondsToSelector:@selector(safeAreaInsets)];
+}
+
+- (UIEdgeInsets)safeAreaInsetsOrEmulate
+{
+  #if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && __IPHONE_OS_VERSION_MAX_ALLOWED >= 110000 /* __IPHONE_11_0 */
+  if (self.nativeSafeAreaSupport) {
+    if (@available(iOS 11.0, *)) {
+      return self.safeAreaInsets;
+    }
+  }
+  #endif
+  return self.emulatedSafeAreaInsets;
+}
+
+- (UIEdgeInsets)emulatedSafeAreaInsets
+{
+  UIViewController* vc = self.reactViewController;
+
+  if (!vc) {
+    return UIEdgeInsetsZero;
+  }
+
+  CGFloat topLayoutOffset = vc.topLayoutGuide.length;
+  CGFloat bottomLayoutOffset = vc.bottomLayoutGuide.length;
+  CGRect safeArea = vc.view.bounds;
+  safeArea.origin.y += topLayoutOffset;
+  safeArea.size.height -= topLayoutOffset + bottomLayoutOffset;
+  CGRect localSafeArea = [vc.view convertRect:safeArea toView:self];
+  UIEdgeInsets safeAreaInsets = UIEdgeInsetsMake(0, 0, 0, 0);
+  if (CGRectGetMinY(localSafeArea) > CGRectGetMinY(self.bounds)) {
+    safeAreaInsets.top = CGRectGetMinY(localSafeArea) - CGRectGetMinY(self.bounds);
+  }
+  if (CGRectGetMaxY(localSafeArea) < CGRectGetMaxY(self.bounds)) {
+    safeAreaInsets.bottom = CGRectGetMaxY(self.bounds) - CGRectGetMaxY(localSafeArea);
+  }
+
+  return safeAreaInsets;
+}
+
+@end

package/ios/SafeAreaView/RNCSafeAreaProvider.h

@@ -0,0 +1,13 @@
+#import <UIKit/UIKit.h>
+
+#import <React/RCTView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNCSafeAreaProvider : RCTView
+
+@property (nonatomic, copy) RCTBubblingEventBlock onInsetsChange;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/SafeAreaView/RNCSafeAreaProvider.m

@@ -0,0 +1,65 @@
+#import "RNCSafeAreaProvider.h"
+
+#import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
+#import "RCTView+SafeAreaCompat.h"
+
+@implementation RNCSafeAreaProvider
+{
+  UIEdgeInsets _currentSafeAreaInsets;
+  CGRect _currentFrame;
+  BOOL _initialInsetsSent;
+}
+
+- (void)safeAreaInsetsDidChange
+{
+  [self invalidateSafeAreaInsets];
+}
+
+- (void)invalidateSafeAreaInsets
+{
+  // This gets called before the view size is set by react-native so
+  // make sure to wait so we don't set wrong insets to JS.
+  if (CGSizeEqualToSize(self.frame.size, CGSizeZero)) {
+    return;
+  }
+
+  UIEdgeInsets safeAreaInsets = [self safeAreaInsetsOrEmulate];
+  CGRect frame = [self convertRect:self.bounds toView:nil];
+
+  if (
+    _initialInsetsSent &&
+    UIEdgeInsetsEqualToEdgeInsetsWithThreshold(safeAreaInsets, _currentSafeAreaInsets, 1.0 / RCTScreenScale()) &&
+    CGRectEqualToRect(frame, _currentFrame)
+  ) {
+    return;
+  }
+
+  _initialInsetsSent = YES;
+  _currentSafeAreaInsets = safeAreaInsets;
+  _currentFrame = frame;
+
+  self.onInsetsChange(@{
+    @"insets": @{
+      @"top": @(safeAreaInsets.top),
+      @"right": @(safeAreaInsets.right),
+      @"bottom": @(safeAreaInsets.bottom),
+      @"left": @(safeAreaInsets.left),
+    },
+    @"frame": @{
+      @"x": @(frame.origin.x),
+      @"y": @(frame.origin.y),
+      @"width": @(frame.size.width),
+      @"height": @(frame.size.height),
+    },
+  });
+}
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+
+  [self invalidateSafeAreaInsets];
+}
+
+@end

package/ios/SafeAreaView/RNCSafeAreaProviderManager.h

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