@amazon-devices/react-native-safe-area-context 2.0.1759135970 → 8.0.9000000000-rn-83

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

@@ -0,0 +1,155 @@
+package com.th3rdwave.safeareacontext
+
+import android.content.Context
+import android.util.Log
+import android.view.View
+import android.view.ViewTreeObserver
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.UIManagerModule
+import com.facebook.react.views.view.ReactViewGroup
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+
+private const val MAX_WAIT_TIME_NANO = 500000000L // 500ms
+
+class SafeAreaView(context: Context?) :
+    ReactViewGroup(context), ViewTreeObserver.OnPreDrawListener {
+  private var mMode = SafeAreaViewMode.PADDING
+  private var mInsets: EdgeInsets? = null
+  private var mEdges: SafeAreaViewEdges? = null
+  private var mProviderView: View? = null
+  private var mStateWrapper: StateWrapper? = null
+
+  fun getStateWrapper(): StateWrapper? {
+    return mStateWrapper
+  }
+
+  fun setStateWrapper(stateWrapper: StateWrapper?) {
+    mStateWrapper = stateWrapper
+  }
+
+  private fun updateInsets() {
+    val insets = mInsets
+    if (insets != null) {
+      val edges =
+          mEdges
+              ?: SafeAreaViewEdges(
+                  SafeAreaViewEdgeModes.ADDITIVE,
+                  SafeAreaViewEdgeModes.ADDITIVE,
+                  SafeAreaViewEdgeModes.ADDITIVE,
+                  SafeAreaViewEdgeModes.ADDITIVE)
+      val stateWrapper = getStateWrapper()
+      if (stateWrapper != null) {
+        val map = Arguments.createMap()
+        map.putMap("insets", edgeInsetsToJsMap(insets))
+        stateWrapper.updateState(map)
+      } else {
+        val localData = SafeAreaViewLocalData(insets = insets, mode = mMode, edges = edges)
+        val reactContext = getReactContext(this)
+        val uiManager = reactContext.getNativeModule(UIManagerModule::class.java)
+        if (uiManager != null) {
+          uiManager.setViewLocalData(id, localData)
+          // Sadly there doesn't seem to be a way to properly dirty a yoga node from java, so if we
+          // are in
+          // the middle of a layout, we need to recompute it. There is also no way to know whether
+          // we
+          // are in the middle of a layout so always do it.
+          reactContext.runOnNativeModulesQueueThread {
+            uiManager.uiImplementation.dispatchViewUpdates(-1)
+          }
+          waitForReactLayout()
+        }
+      }
+    }
+  }
+
+  private fun 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.
+    var done = false
+    val lock = ReentrantLock()
+    val condition = lock.newCondition()
+    val startTime = System.nanoTime()
+    var waitTime = 0L
+    getReactContext(this).runOnNativeModulesQueueThread {
+      lock.withLock {
+        if (!done) {
+          done = true
+          condition.signal()
+        }
+      }
+    }
+    lock.withLock {
+      while (!done && waitTime < MAX_WAIT_TIME_NANO) {
+        try {
+          condition.awaitNanos(MAX_WAIT_TIME_NANO)
+        } catch (ex: InterruptedException) {
+          // In case of an interrupt just give up waiting.
+          done = true
+        }
+        waitTime += System.nanoTime() - startTime
+      }
+    }
+    // Timed out waiting.
+    if (waitTime >= MAX_WAIT_TIME_NANO) {
+      Log.w("SafeAreaView", "Timed out waiting for layout.")
+    }
+  }
+
+  fun setMode(mode: SafeAreaViewMode) {
+    mMode = mode
+    updateInsets()
+  }
+
+  fun setEdges(edges: SafeAreaViewEdges) {
+    mEdges = edges
+    updateInsets()
+  }
+
+  private fun maybeUpdateInsets(): Boolean {
+    val providerView = mProviderView ?: return false
+    val edgeInsets = getSafeAreaInsets(providerView) ?: return false
+    if (mInsets != edgeInsets) {
+      mInsets = edgeInsets
+      updateInsets()
+      return true
+    }
+    return false
+  }
+
+  private fun findProvider(): View {
+    var current = parent
+    while (current != null) {
+      if (current is SafeAreaProvider) {
+        return current
+      }
+      current = current.parent
+    }
+    return this
+  }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    mProviderView = findProvider()
+    mProviderView?.viewTreeObserver?.addOnPreDrawListener(this)
+    maybeUpdateInsets()
+  }
+
+  override fun onDetachedFromWindow() {
+    super.onDetachedFromWindow()
+    mProviderView?.viewTreeObserver?.removeOnPreDrawListener(this)
+    mProviderView = null
+  }
+
+  override fun onPreDraw(): Boolean {
+    val didUpdate = maybeUpdateInsets()
+    if (didUpdate) {
+      requestLayout()
+    }
+    return !didUpdate
+  }
+}

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

@@ -0,0 +1,16 @@
+package com.th3rdwave.safeareacontext
+
+enum class SafeAreaViewEdgeModes {
+  OFF,
+  ADDITIVE,
+  MAXIMUM
+}
+
+data class SafeAreaViewEdges(
+    val top: SafeAreaViewEdgeModes,
+    val right: SafeAreaViewEdgeModes,
+    val bottom: SafeAreaViewEdgeModes,
+    val left: SafeAreaViewEdgeModes
+)
+
+class Safe

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

@@ -0,0 +1,7 @@
+package com.th3rdwave.safeareacontext
+
+data class SafeAreaViewLocalData(
+    val insets: EdgeInsets,
+    val mode: SafeAreaViewMode,
+    val edges: SafeAreaViewEdges,
+)

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

@@ -0,0 +1,73 @@
+package com.th3rdwave.safeareacontext
+
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.RNCSafeAreaViewManagerInterface
+import com.facebook.react.views.view.ReactViewGroup
+import com.facebook.react.views.view.ReactViewManager
+
+@ReactModule(name = SafeAreaViewManager.REACT_CLASS)
+class SafeAreaViewManager : ReactViewManager(), RNCSafeAreaViewManagerInterface<SafeAreaView> {
+  override fun getName() = REACT_CLASS
+
+  // Make sure we're not using delegates for now since ReactViewGroupManager doesn't use one. If it
+  // does in the future we will need a way to compose delegates together.
+  override fun getDelegate(): ViewManagerDelegate<ReactViewGroup>? = null
+
+  override fun createViewInstance(context: ThemedReactContext) = SafeAreaView(context)
+
+  override fun createShadowNodeInstance() = SafeAreaViewShadowNode()
+
+  override fun getShadowNodeClass() = SafeAreaViewShadowNode::class.java
+
+  @ReactProp(name = "mode")
+  override fun setMode(view: SafeAreaView, mode: String?) {
+    when (mode) {
+      "padding" -> {
+        view.setMode(SafeAreaViewMode.PADDING)
+      }
+      "margin" -> {
+        view.setMode(SafeAreaViewMode.MARGIN)
+      }
+    }
+  }
+
+  @ReactProp(name = "edges")
+  override fun setEdges(view: SafeAreaView, propList: ReadableMap?) {
+    if (propList != null) {
+      view.setEdges(
+          SafeAreaViewEdges(
+              top = propList.getString("top")?.let { SafeAreaViewEdgeModes.valueOf(it.uppercase()) }
+                      ?: SafeAreaViewEdgeModes.OFF,
+              right =
+                  propList.getString("right")?.let { SafeAreaViewEdgeModes.valueOf(it.uppercase()) }
+                      ?: SafeAreaViewEdgeModes.OFF,
+              bottom =
+                  propList.getString("bottom")?.let {
+                    SafeAreaViewEdgeModes.valueOf(it.uppercase())
+                  }
+                      ?: SafeAreaViewEdgeModes.OFF,
+              left =
+                  propList.getString("left")?.let { SafeAreaViewEdgeModes.valueOf(it.uppercase()) }
+                      ?: SafeAreaViewEdgeModes.OFF))
+    }
+  }
+
+  override fun updateState(
+      view: ReactViewGroup,
+      props: ReactStylesDiffMap?,
+      stateWrapper: StateWrapper?
+  ): Any? {
+    (view as SafeAreaView).setStateWrapper(stateWrapper)
+    return null
+  }
+
+  companion object {
+    const val REACT_CLASS = "RNCSafeAreaView"
+  }
+}

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

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

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

@@ -0,0 +1,170 @@
+package com.th3rdwave.safeareacontext
+
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.uimanager.*
+import com.facebook.react.uimanager.annotations.ReactPropGroup
+import kotlin.math.max
+
+class SafeAreaViewShadowNode : LayoutShadowNode() {
+  private var mLocalData: SafeAreaViewLocalData? = null
+  private val mPaddings: FloatArray = FloatArray(ViewProps.PADDING_MARGIN_SPACING_TYPES.size)
+  private val mMargins: FloatArray = FloatArray(ViewProps.PADDING_MARGIN_SPACING_TYPES.size)
+  private var mNeedsUpdate = false
+
+  init {
+    for (i in ViewProps.PADDING_MARGIN_SPACING_TYPES.indices) {
+      mPaddings[i] = Float.NaN
+      mMargins[i] = Float.NaN
+    }
+  }
+
+  private fun updateInsets() {
+    val localData = mLocalData ?: return
+    var top = 0f
+    var right = 0f
+    var bottom = 0f
+    var left = 0f
+    val meta = if (localData.mode == SafeAreaViewMode.PADDING) mPaddings else mMargins
+    val allEdges = meta[Spacing.ALL]
+    if (!java.lang.Float.isNaN(allEdges)) {
+      top = allEdges
+      right = allEdges
+      bottom = allEdges
+      left = allEdges
+    }
+    val verticalEdges = meta[Spacing.VERTICAL]
+    if (!java.lang.Float.isNaN(verticalEdges)) {
+      top = verticalEdges
+      bottom = verticalEdges
+    }
+    val horizontalEdges = meta[Spacing.HORIZONTAL]
+    if (!java.lang.Float.isNaN(horizontalEdges)) {
+      right = horizontalEdges
+      left = horizontalEdges
+    }
+    val topEdge = meta[Spacing.TOP]
+    if (!java.lang.Float.isNaN(topEdge)) {
+      top = topEdge
+    }
+    val rightEdge = meta[Spacing.RIGHT]
+    if (!java.lang.Float.isNaN(rightEdge)) {
+      right = rightEdge
+    }
+    val bottomEdge = meta[Spacing.BOTTOM]
+    if (!java.lang.Float.isNaN(bottomEdge)) {
+      bottom = bottomEdge
+    }
+    val leftEdge = meta[Spacing.LEFT]
+    if (!java.lang.Float.isNaN(leftEdge)) {
+      left = leftEdge
+    }
+    top = PixelUtil.toPixelFromDIP(top)
+    right = PixelUtil.toPixelFromDIP(right)
+    bottom = PixelUtil.toPixelFromDIP(bottom)
+    left = PixelUtil.toPixelFromDIP(left)
+    val edges = localData.edges
+    val insets = localData.insets
+    if (localData.mode == SafeAreaViewMode.PADDING) {
+      super.setPadding(Spacing.TOP, getEdgeValue(edges.top, insets.top, top))
+      super.setPadding(Spacing.RIGHT, getEdgeValue(edges.right, insets.right, right))
+      super.setPadding(Spacing.BOTTOM, getEdgeValue(edges.bottom, insets.bottom, bottom))
+      super.setPadding(Spacing.LEFT, getEdgeValue(edges.left, insets.left, left))
+    } else {
+      super.setMargin(Spacing.TOP, getEdgeValue(edges.top, insets.top, top))
+      super.setMargin(Spacing.RIGHT, getEdgeValue(edges.right, insets.right, right))
+      super.setMargin(Spacing.BOTTOM, getEdgeValue(edges.bottom, insets.bottom, bottom))
+      super.setMargin(Spacing.LEFT, getEdgeValue(edges.left, insets.left, left))
+    }
+  }
+
+  private fun getEdgeValue(
+      edgeMode: SafeAreaViewEdgeModes,
+      insetValue: Float,
+      edgeValue: Float
+  ): Float {
+    if (edgeMode == SafeAreaViewEdgeModes.OFF) {
+      return edgeValue
+    } else if (edgeMode == SafeAreaViewEdgeModes.MAXIMUM) {
+      return max(insetValue, edgeValue)
+    } else {
+      return insetValue + edgeValue
+    }
+  }
+
+  private fun resetInsets(mode: SafeAreaViewMode) {
+    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])
+    }
+    markUpdated()
+  }
+
+  override fun onBeforeLayout(nativeViewHierarchyOptimizer: NativeViewHierarchyOptimizer) {
+    if (mNeedsUpdate) {
+      mNeedsUpdate = false
+      updateInsets()
+    }
+  }
+
+  override fun setLocalData(data: Any) {
+    if (data !is SafeAreaViewLocalData) {
+      return
+    }
+    val localData = mLocalData
+    if (localData != null && localData.mode != data.mode) {
+      resetInsets(localData.mode)
+    }
+    mLocalData = data
+    mNeedsUpdate = false
+    updateInsets()
+  }
+
+  // Names needs to reflect exact order in LayoutShadowNode.java
+  @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])
+  override fun setPaddings(index: Int, padding: Dynamic) {
+    val spacingType = ViewProps.PADDING_MARGIN_SPACING_TYPES[index]
+    mPaddings[spacingType] =
+        if (padding.type == ReadableType.Number) padding.asDouble().toFloat() else Float.NaN
+    super.setPaddings(index, padding)
+    mNeedsUpdate = true
+  }
+
+  @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])
+  override fun setMargins(index: Int, margin: Dynamic) {
+    val spacingType = ViewProps.PADDING_MARGIN_SPACING_TYPES[index]
+    mMargins[spacingType] =
+        if (margin.type == ReadableType.Number) margin.asDouble().toFloat() else Float.NaN
+    super.setMargins(index, margin)
+    mNeedsUpdate = true
+  }
+}

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

@@ -0,0 +1,39 @@
+package com.th3rdwave.safeareacontext
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.PixelUtil
+
+fun edgeInsetsToJsMap(insets: EdgeInsets): WritableMap {
+  val insetsMap = Arguments.createMap()
+  insetsMap.putDouble("top", PixelUtil.toDIPFromPixel(insets.top).toDouble())
+  insetsMap.putDouble("right", PixelUtil.toDIPFromPixel(insets.right).toDouble())
+  insetsMap.putDouble("bottom", PixelUtil.toDIPFromPixel(insets.bottom).toDouble())
+  insetsMap.putDouble("left", PixelUtil.toDIPFromPixel(insets.left).toDouble())
+  return insetsMap
+}
+
+fun edgeInsetsToJavaMap(insets: EdgeInsets): Map<String, Float> {
+  return mapOf(
+      "top" to PixelUtil.toDIPFromPixel(insets.top),
+      "right" to PixelUtil.toDIPFromPixel(insets.right),
+      "bottom" to PixelUtil.toDIPFromPixel(insets.bottom),
+      "left" to PixelUtil.toDIPFromPixel(insets.left))
+}
+
+fun rectToJsMap(rect: Rect): WritableMap {
+  val rectMap = Arguments.createMap()
+  rectMap.putDouble("x", PixelUtil.toDIPFromPixel(rect.x).toDouble())
+  rectMap.putDouble("y", PixelUtil.toDIPFromPixel(rect.y).toDouble())
+  rectMap.putDouble("width", PixelUtil.toDIPFromPixel(rect.width).toDouble())
+  rectMap.putDouble("height", PixelUtil.toDIPFromPixel(rect.height).toDouble())
+  return rectMap
+}
+
+fun rectToJavaMap(rect: Rect): Map<String, Float> {
+  return mapOf(
+      "x" to PixelUtil.toDIPFromPixel(rect.x),
+      "y" to PixelUtil.toDIPFromPixel(rect.y),
+      "width" to PixelUtil.toDIPFromPixel(rect.width),
+      "height" to PixelUtil.toDIPFromPixel(rect.height))
+}

package/android/src/main/jni/CMakeLists.txt

@@ -0,0 +1,87 @@
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+
+set(LIB_LITERAL safeareacontext)
+set(LIB_TARGET_NAME react_codegen_${LIB_LITERAL})
+
+set(LIB_ANDROID_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../..)
+set(LIB_COMMON_DIR ${LIB_ANDROID_DIR}/../common/cpp)
+set(LIB_ANDROID_GENERATED_JNI_DIR ${LIB_ANDROID_DIR}/build/generated/source/codegen/jni)
+set(LIB_ANDROID_GENERATED_COMPONENTS_DIR ${LIB_ANDROID_GENERATED_JNI_DIR}/react/renderer/components/${LIB_LITERAL})
+
+add_compile_options(
+  -fexceptions
+  -frtti
+  -std=c++20
+  -Wall
+  -Wpedantic
+  -Wno-gnu-zero-variadic-macro-arguments
+  -Wno-dollar-in-identifier-extension
+)
+
+file(GLOB LIB_CUSTOM_SRCS CONFIGURE_DEPENDS *.cpp ${LIB_COMMON_DIR}/react/renderer/components/${LIB_LITERAL}/*.cpp)
+file(GLOB LIB_CODEGEN_SRCS CONFIGURE_DEPENDS ${LIB_ANDROID_GENERATED_JNI_DIR}/*.cpp ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}/*.cpp)
+
+add_library(
+  ${LIB_TARGET_NAME}
+  SHARED
+  ${LIB_CUSTOM_SRCS}
+  ${LIB_CODEGEN_SRCS}
+)
+
+target_include_directories(
+  ${LIB_TARGET_NAME}
+  PUBLIC
+  .
+  ${LIB_COMMON_DIR}
+  ${LIB_ANDROID_GENERATED_JNI_DIR}
+  ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}
+)
+
+# https://github.com/react-native-community/discussions-and-proposals/discussions/816
+# This if-then-else can be removed once this library does not support version below 0.76
+if (REACTNATIVE_MERGED_SO)
+  target_link_libraries(
+          ${LIB_TARGET_NAME}
+          fbjni
+          jsi
+          reactnative
+  )
+else()
+  target_link_libraries(
+          ${LIB_TARGET_NAME}
+          fbjni
+          folly_runtime
+          glog
+          jsi
+          react_codegen_rncore
+          react_debug
+          react_nativemodule_core
+          react_render_core
+          react_render_debug
+          react_render_graphics
+          react_render_mapbuffer
+          react_render_componentregistry
+          react_utils
+          rrc_view
+          turbomodulejsijni
+          yoga
+  )
+endif()
+
+
+target_compile_options(
+  ${LIB_TARGET_NAME}
+  PRIVATE
+  -DLOG_TAG=\"ReactNative\"
+  -fexceptions
+  -frtti
+  -std=c++20
+  -Wall
+)
+
+target_include_directories(
+  ${CMAKE_PROJECT_NAME}
+  PUBLIC
+  ${CMAKE_CURRENT_SOURCE_DIR}
+)

package/android/src/main/jni/safeareacontext.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <ReactCommon/JavaTurboModule.h>
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+#include <react/renderer/components/safeareacontext/RNCSafeAreaViewComponentDescriptor.h>
+
+namespace facebook {
+namespace react {
+
+JSI_EXPORT
+std::shared_ptr<TurboModule> safeareacontext_ModuleProvider(
+    const std::string &moduleName,
+    const JavaTurboModule::InitParams &params);
+
+} // namespace react
+} // namespace facebook

package/android/src/paper/java/com/facebook/react/viewmanagers/RNCSafeAreaProviderManagerDelegate.java

@@ -0,0 +1,31 @@
+/**
+ * This code was generated by
+ * [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * <p>Do not edit this file as changes may cause incorrect behavior and will be lost once the code
+ * is regenerated.
+ *
+ * @generated by codegen project: GeneratePropsJavaDelegate.js
+ */
+package com.facebook.react.viewmanagers;
+
+import android.view.View;
+import androidx.annotation.Nullable;
+import com.facebook.react.uimanager.BaseViewManager;
+import com.facebook.react.uimanager.BaseViewManagerDelegate;
+import com.facebook.react.uimanager.LayoutShadowNode;
+
+public class RNCSafeAreaProviderManagerDelegate<
+        T extends View,
+        U extends
+            BaseViewManager<T, ? extends LayoutShadowNode> & RNCSafeAreaProviderManagerInterface<T>>
+    extends BaseViewManagerDelegate<T, U> {
+  public RNCSafeAreaProviderManagerDelegate(U viewManager) {
+    super(viewManager);
+  }
+
+  @Override
+  public void setProperty(T view, String propName, @Nullable Object value) {
+    super.setProperty(view, propName, value);
+  }
+}

package/android/src/paper/java/com/facebook/react/viewmanagers/RNCSafeAreaProviderManagerInterface.java

@@ -0,0 +1,16 @@
+/**
+ * This code was generated by
+ * [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * <p>Do not edit this file as changes may cause incorrect behavior and will be lost once the code
+ * is regenerated.
+ *
+ * @generated by codegen project: GeneratePropsJavaInterface.js
+ */
+package com.facebook.react.viewmanagers;
+
+import android.view.View;
+
+public interface RNCSafeAreaProviderManagerInterface<T extends View> {
+  // No props
+}

package/android/src/paper/java/com/facebook/react/viewmanagers/RNCSafeAreaViewManagerDelegate.java

@@ -0,0 +1,41 @@
+/**
+ * This code was generated by
+ * [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * <p>Do not edit this file as changes may cause incorrect behavior and will be lost once the code
+ * is regenerated.
+ *
+ * @generated by codegen project: GeneratePropsJavaDelegate.js
+ */
+package com.facebook.react.viewmanagers;
+
+import android.view.View;
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.uimanager.BaseViewManager;
+import com.facebook.react.uimanager.BaseViewManagerDelegate;
+import com.facebook.react.uimanager.LayoutShadowNode;
+
+public class RNCSafeAreaViewManagerDelegate<
+        T extends View,
+        U extends
+            BaseViewManager<T, ? extends LayoutShadowNode> & RNCSafeAreaViewManagerInterface<T>>
+    extends BaseViewManagerDelegate<T, U> {
+  public RNCSafeAreaViewManagerDelegate(U viewManager) {
+    super(viewManager);
+  }
+
+  @Override
+  public void setProperty(T view, String propName, @Nullable Object value) {
+    switch (propName) {
+      case "mode":
+        mViewManager.setMode(view, (String) value);
+        break;
+      case "edges":
+        mViewManager.setEdges(view, (ReadableMap) value);
+        break;
+      default:
+        super.setProperty(view, propName, value);
+    }
+  }
+}

package/android/src/paper/java/com/facebook/react/viewmanagers/RNCSafeAreaViewManagerInterface.java

@@ -0,0 +1,20 @@
+/**
+ * This code was generated by
+ * [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * <p>Do not edit this file as changes may cause incorrect behavior and will be lost once the code
+ * is regenerated.
+ *
+ * @generated by codegen project: GeneratePropsJavaInterface.js
+ */
+package com.facebook.react.viewmanagers;
+
+import android.view.View;
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.ReadableMap;
+
+public interface RNCSafeAreaViewManagerInterface<T extends View> {
+  void setMode(T view, @Nullable String value);
+
+  void setEdges(T view, @Nullable ReadableMap value);
+}