react-native 0.0.0-263478b91 → 0.0.0-268efb102

package/ReactCommon/react/renderer/components/view/AccessibilityProps.cpp

@@ -16,79 +16,102 @@ namespace facebook {
 namespace react {
 
 AccessibilityProps::AccessibilityProps(
+    const PropsParserContext &context,
     AccessibilityProps const &sourceProps,
     RawProps const &rawProps)
     : accessible(convertRawProp(
+          context,
           rawProps,
           "accessible",
           sourceProps.accessible,
           false)),
       accessibilityTraits(convertRawProp(
+          context,
           rawProps,
           "accessibilityRole",
           sourceProps.accessibilityTraits,
           AccessibilityTraits::None)),
       accessibilityState(convertRawProp(
+          context,
           rawProps,
           "accessibilityState",
           sourceProps.accessibilityState,
           {})),
       accessibilityLabel(convertRawProp(
+          context,
           rawProps,
           "accessibilityLabel",
           sourceProps.accessibilityLabel,
           "")),
       accessibilityHint(convertRawProp(
+          context,
           rawProps,
           "accessibilityHint",
           sourceProps.accessibilityHint,
           "")),
+      accessibilityValue(convertRawProp(
+          context,
+          rawProps,
+          "accessibilityValue",
+          sourceProps.accessibilityValue,
+          {})),
       accessibilityActions(convertRawProp(
+          context,
           rawProps,
           "accessibilityActions",
           sourceProps.accessibilityActions,
           {})),
       accessibilityViewIsModal(convertRawProp(
+          context,
           rawProps,
           "accessibilityViewIsModal",
           sourceProps.accessibilityViewIsModal,
           false)),
       accessibilityElementsHidden(convertRawProp(
+          context,
           rawProps,
           "accessibilityElementsHidden",
           sourceProps.accessibilityElementsHidden,
           false)),
       accessibilityIgnoresInvertColors(convertRawProp(
+          context,
           rawProps,
           "accessibilityIgnoresInvertColors",
           sourceProps.accessibilityIgnoresInvertColors,
           false)),
       onAccessibilityTap(convertRawProp(
+          context,
           rawProps,
           "onAccessibilityTap",
           sourceProps.onAccessibilityTap,
           {})),
       onAccessibilityMagicTap(convertRawProp(
+          context,
           rawProps,
           "onAccessibilityMagicTap",
           sourceProps.onAccessibilityMagicTap,
           {})),
       onAccessibilityEscape(convertRawProp(
+          context,
           rawProps,
           "onAccessibilityEscape",
           sourceProps.onAccessibilityEscape,
           {})),
       onAccessibilityAction(convertRawProp(
+          context,
           rawProps,
           "onAccessibilityAction",
           sourceProps.onAccessibilityAction,
           {})),
       importantForAccessibility(convertRawProp(
+          context,
           rawProps,
           "importantForAccessibility",
           sourceProps.importantForAccessibility,
           ImportantForAccessibility::Auto)),
-      testId(convertRawProp(rawProps, "testID", sourceProps.testId, "")) {}
+      testId(
+          convertRawProp(context, rawProps, "testID", sourceProps.testId, "")) {
+}
 
 #pragma mark - DebugStringConvertible
 

package/ReactCommon/react/renderer/components/view/AccessibilityProps.h

@@ -9,6 +9,7 @@
 
 #include <react/renderer/components/view/AccessibilityPrimitives.h>
 #include <react/renderer/core/Props.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/ReactPrimitives.h>
 #include <react/renderer/debug/DebugStringConvertible.h>
 
@@ -19,6 +20,7 @@ class AccessibilityProps {
  public:
   AccessibilityProps() = default;
   AccessibilityProps(
+      const PropsParserContext &context,
       AccessibilityProps const &sourceProps,
       RawProps const &rawProps);
 
@@ -29,7 +31,8 @@ class AccessibilityProps {
   AccessibilityState accessibilityState;
   std::string accessibilityLabel{""};
   std::string accessibilityHint{""};
-  std::vector<std::string> accessibilityActions{};
+  AccessibilityValue accessibilityValue;
+  std::vector<AccessibilityAction> accessibilityActions{};
   bool accessibilityViewIsModal{false};
   bool accessibilityElementsHidden{false};
   bool accessibilityIgnoresInvertColors{false};

package/ReactCommon/react/renderer/components/view/Android.mk

@@ -11,7 +11,7 @@ LOCAL_MODULE := rrc_view
 
 LOCAL_SRC_FILES := $(wildcard $(LOCAL_PATH)/*.cpp)
 
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/../../../../
 LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/../../../../
 
 LOCAL_CFLAGS := \
@@ -21,7 +21,7 @@ LOCAL_CFLAGS += -fexceptions -frtti -std=c++17 -Wall
 
 LOCAL_STATIC_LIBRARIES :=
 
-LOCAL_SHARED_LIBRARIES := libyoga glog libfolly_json libglog_init libreact_render_core libreact_render_debug libreact_render_graphics libreact_debug
+LOCAL_SHARED_LIBRARIES := libyoga glog libfolly_json libglog_init libreact_render_core libreact_render_debug libreact_render_graphics libreact_debug logger libjsi
 
 include $(BUILD_SHARED_LIBRARY)
 
@@ -31,5 +31,6 @@ $(call import-module,fbgloginit)
 $(call import-module,react/renderer/core)
 $(call import-module,react/renderer/debug)
 $(call import-module,react/renderer/graphics)
+$(call import-module,logger)
 $(call import-module,yogajni)
 $(call import-module,react/debug)

package/ReactCommon/react/renderer/components/view/BUCK

@@ -64,6 +64,7 @@ rn_xplat_cxx_library(
         react_native_xplat_target("react/renderer/core:core"),
         react_native_xplat_target("react/renderer/debug:debug"),
         react_native_xplat_target("react/renderer/graphics:graphics"),
+        react_native_xplat_target("logger:logger"),
     ],
 )
 

package/ReactCommon/react/renderer/components/view/Touch.h

@@ -52,38 +52,7 @@ struct Touch {
   Float force;
 
   /*
-   * The time in seconds (with fractional milliseconds) when the touch occurred
-   * or when it was last mutated.
-   *
-   * Whenever possible this should be computed as:
-   * 1. Pick MONO_CLOCK_NOW, a monotonic system clock. Generally, something like
-   * `systemUptimeMillis`.
-   * 2. BASIS_TIME = unix timestamp from unix epoch (ms) - MONO_CLOCK_NOW
-   * 3. Then assign timestamp = BASIS_TIME + MONO_CLOCK_NOW
-   *
-   * The effect should be UNIX timestamp from UNIX epoch, but as a monotonic
-   * clock (if you just assign to current system time, it can move backwards due
-   * to clock adjustements, leap seconds, etc etc). So the vast majority of the
-   * time it will look identical to current UNIX time, but there are some
-   * edge-cases where it can drift.
-   *
-   * If you are not able to use the scheme above for some reason, prefer to use
-   * a monotonic clock. This timestamp MUST be monotonic. Do NOT just pass along
-   * system time.
-   *
-   * The goal is to allow touch latency to be computed in JS. JS does not have
-   * access to something like `systemUptimeMillis`, it generally can only access
-   * the current system time. This *does* mean that the touch latency could be
-   * computed incorrectly in cases of clock drift, so you should only use this
-   * as telemetry to get a decent, but not totally perfect, idea of performance.
-   * Do not use this latency information for anything "mission critical". You
-   * can assume it's probably reasonably accurate 99% of the time.
-   *
-   * Note that we attempt to adhere to the spec of timestamp here:
-   * https://dom.spec.whatwg.org/#dom-event-timestamp
-   * Notably, since `global` is not a Window object in React Native, we have
-   * some flexibility in how we define the time origin:
-   * https://w3c.github.io/hr-time/#dfn-time-origin
+   * The time in seconds when the touch occurred or when it was last mutated.
    */
   Float timestamp;
 

package/ReactCommon/react/renderer/components/view/TouchEventEmitter.cpp

@@ -62,17 +62,23 @@ static jsi::Value touchEventPayload(
 void TouchEventEmitter::dispatchTouchEvent(
     std::string const &type,
     TouchEvent const &event,
-    EventPriority const &priority) const {
+    EventPriority priority,
+    RawEvent::Category category) const {
   dispatchEvent(
       type,
       [event](jsi::Runtime &runtime) {
         return touchEventPayload(runtime, event);
       },
-      priority);
+      priority,
+      category);
 }
 
 void TouchEventEmitter::onTouchStart(TouchEvent const &event) const {
-  dispatchTouchEvent("touchStart", event, EventPriority::AsynchronousBatched);
+  dispatchTouchEvent(
+      "touchStart",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousStart);
 }
 
 void TouchEventEmitter::onTouchMove(TouchEvent const &event) const {
@@ -82,11 +88,19 @@ void TouchEventEmitter::onTouchMove(TouchEvent const &event) const {
 }
 
 void TouchEventEmitter::onTouchEnd(TouchEvent const &event) const {
-  dispatchTouchEvent("touchEnd", event, EventPriority::AsynchronousBatched);
+  dispatchTouchEvent(
+      "touchEnd",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousEnd);
 }
 
 void TouchEventEmitter::onTouchCancel(TouchEvent const &event) const {
-  dispatchTouchEvent("touchCancel", event, EventPriority::AsynchronousBatched);
+  dispatchTouchEvent(
+      "touchCancel",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousEnd);
 }
 
 } // namespace react

package/ReactCommon/react/renderer/components/view/TouchEventEmitter.h

@@ -33,7 +33,8 @@ class TouchEventEmitter : public EventEmitter {
   void dispatchTouchEvent(
       std::string const &type,
       TouchEvent const &event,
-      EventPriority const &priority) const;
+      EventPriority priority,
+      RawEvent::Category category) const;
 };
 
 } // namespace react

package/ReactCommon/react/renderer/components/view/ViewComponentDescriptor.h

@@ -9,8 +9,6 @@
 
 #include <react/renderer/components/view/ViewShadowNode.h>
 #include <react/renderer/core/ConcreteComponentDescriptor.h>
-#include "ViewProps.h"
-#include "ViewPropsInterpolation.h"
 
 namespace facebook {
 namespace react {
@@ -20,26 +18,6 @@ class ViewComponentDescriptor
  public:
   ViewComponentDescriptor(ComponentDescriptorParameters const &parameters)
       : ConcreteComponentDescriptor<ViewShadowNode>(parameters) {}
-
-  virtual SharedProps interpolateProps(
-      float animationProgress,
-      const SharedProps &props,
-      const SharedProps &newProps) const override {
-#ifdef ANDROID
-    // On Android only, the merged props should have the same RawProps as the
-    // final props struct
-    SharedProps interpolatedPropsShared =
-        (newProps != nullptr ? cloneProps(newProps, newProps->rawProps)
-                             : cloneProps(newProps, {}));
-#else
-    SharedProps interpolatedPropsShared = cloneProps(newProps, {});
-#endif
-
-    interpolateViewProps(
-        animationProgress, props, newProps, interpolatedPropsShared);
-
-    return interpolatedPropsShared;
-  };
 };
 
 } // namespace react

package/ReactCommon/react/renderer/components/view/ViewEventEmitter.cpp

@@ -15,7 +15,7 @@ namespace react {
 void ViewEventEmitter::onAccessibilityAction(const std::string &name) const {
   dispatchEvent("accessibilityAction", [name](jsi::Runtime &runtime) {
     auto payload = jsi::Object(runtime);
-    payload.setProperty(runtime, "action", name);
+    payload.setProperty(runtime, "actionName", name);
     return payload;
   });
 }

package/ReactCommon/react/renderer/components/view/ViewProps.cpp

@@ -18,83 +18,131 @@
 namespace facebook {
 namespace react {
 
-ViewProps::ViewProps(ViewProps const &sourceProps, RawProps const &rawProps)
-    : YogaStylableProps(sourceProps, rawProps),
-      AccessibilityProps(sourceProps, rawProps),
-      opacity(
-          convertRawProp(rawProps, "opacity", sourceProps.opacity, (Float)1.0)),
+ViewProps::ViewProps(
+    const PropsParserContext &context,
+    ViewProps const &sourceProps,
+    RawProps const &rawProps)
+    : YogaStylableProps(context, sourceProps, rawProps),
+      AccessibilityProps(context, sourceProps, rawProps),
+      opacity(convertRawProp(
+          context,
+          rawProps,
+          "opacity",
+          sourceProps.opacity,
+          (Float)1.0)),
       foregroundColor(convertRawProp(
+          context,
           rawProps,
           "foregroundColor",
           sourceProps.foregroundColor,
           {})),
       backgroundColor(convertRawProp(
+          context,
           rawProps,
           "backgroundColor",
           sourceProps.backgroundColor,
           {})),
       borderRadii(convertRawProp(
+          context,
           rawProps,
           "border",
           "Radius",
           sourceProps.borderRadii,
           {})),
       borderColors(convertRawProp(
+          context,
           rawProps,
           "border",
           "Color",
           sourceProps.borderColors,
           {})),
       borderStyles(convertRawProp(
+          context,
           rawProps,
           "border",
           "Style",
           sourceProps.borderStyles,
           {})),
-      shadowColor(
-          convertRawProp(rawProps, "shadowColor", sourceProps.shadowColor, {})),
+      shadowColor(convertRawProp(
+          context,
+          rawProps,
+          "shadowColor",
+          sourceProps.shadowColor,
+          {})),
       shadowOffset(convertRawProp(
+          context,
           rawProps,
           "shadowOffset",
           sourceProps.shadowOffset,
           {})),
       shadowOpacity(convertRawProp(
+          context,
           rawProps,
           "shadowOpacity",
           sourceProps.shadowOpacity,
           {})),
       shadowRadius(convertRawProp(
+          context,
           rawProps,
           "shadowRadius",
           sourceProps.shadowRadius,
           {})),
-      transform(
-          convertRawProp(rawProps, "transform", sourceProps.transform, {})),
+      transform(convertRawProp(
+          context,
+          rawProps,
+          "transform",
+          sourceProps.transform,
+          {})),
       backfaceVisibility(convertRawProp(
+          context,
           rawProps,
           "backfaceVisibility",
           sourceProps.backfaceVisibility,
           {})),
       shouldRasterize(convertRawProp(
+          context,
           rawProps,
           "shouldRasterize",
           sourceProps.shouldRasterize,
           {})),
-      zIndex(convertRawProp(rawProps, "zIndex", sourceProps.zIndex, {})),
+      zIndex(
+          convertRawProp(context, rawProps, "zIndex", sourceProps.zIndex, {})),
       pointerEvents(convertRawProp(
+          context,
           rawProps,
           "pointerEvents",
           sourceProps.pointerEvents,
           {})),
-      hitSlop(convertRawProp(rawProps, "hitSlop", sourceProps.hitSlop, {})),
-      onLayout(convertRawProp(rawProps, "onLayout", sourceProps.onLayout, {})),
+      hitSlop(convertRawProp(
+          context,
+          rawProps,
+          "hitSlop",
+          sourceProps.hitSlop,
+          {})),
+      onLayout(convertRawProp(
+          context,
+          rawProps,
+          "onLayout",
+          sourceProps.onLayout,
+          {})),
       collapsable(convertRawProp(
+          context,
           rawProps,
           "collapsable",
           sourceProps.collapsable,
           true)),
-      elevation(
-          convertRawProp(rawProps, "elevation", sourceProps.elevation, {})){};
+      removeClippedSubviews(convertRawProp(
+          context,
+          rawProps,
+          "removeClippedSubviews",
+          sourceProps.removeClippedSubviews,
+          false)),
+      elevation(convertRawProp(
+          context,
+          rawProps,
+          "elevation",
+          sourceProps.elevation,
+          {})){};
 
 #pragma mark - Convenience Methods
 

package/ReactCommon/react/renderer/components/view/ViewProps.h

@@ -12,6 +12,7 @@
 #include <react/renderer/components/view/primitives.h>
 #include <react/renderer/core/LayoutMetrics.h>
 #include <react/renderer/core/Props.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/graphics/Color.h>
 #include <react/renderer/graphics/Geometry.h>
 #include <react/renderer/graphics/Transform.h>
@@ -26,7 +27,10 @@ using SharedViewProps = std::shared_ptr<ViewProps const>;
 class ViewProps : public YogaStylableProps, public AccessibilityProps {
  public:
   ViewProps() = default;
-  ViewProps(ViewProps const &sourceProps, RawProps const &rawProps);
+  ViewProps(
+      const PropsParserContext &context,
+      ViewProps const &sourceProps,
+      RawProps const &rawProps);
 
 #pragma mark - Props
 
@@ -59,6 +63,8 @@ class ViewProps : public YogaStylableProps, public AccessibilityProps {
 
   bool collapsable{true};
 
+  bool removeClippedSubviews{false};
+
   Float elevation{}; /* Android-only */
 
 #pragma mark - Convenience Methods

package/ReactCommon/react/renderer/components/view/ViewPropsInterpolation.h

@@ -7,9 +7,8 @@
 
 #pragma once
 
-#include "ViewProps.h"
-
-#include <react/debug/react_native_assert.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/graphics/Transform.h>
 
 namespace facebook {
 namespace react {
@@ -25,15 +24,11 @@ static inline void interpolateViewProps(
     const SharedProps &newPropsShared,
     SharedProps &interpolatedPropsShared) {
   ViewProps const *oldViewProps =
-      dynamic_cast<ViewProps const *>(oldPropsShared.get());
+      static_cast<ViewProps const *>(oldPropsShared.get());
   ViewProps const *newViewProps =
-      dynamic_cast<ViewProps const *>(newPropsShared.get());
+      static_cast<ViewProps const *>(newPropsShared.get());
   ViewProps *interpolatedProps = const_cast<ViewProps *>(
-      dynamic_cast<ViewProps const *>(interpolatedPropsShared.get()));
-
-  react_native_assert(
-      oldViewProps != nullptr && newViewProps != nullptr &&
-      interpolatedProps != nullptr);
+      static_cast<ViewProps const *>(interpolatedPropsShared.get()));
 
   interpolatedProps->opacity = oldViewProps->opacity +
       (newViewProps->opacity - oldViewProps->opacity) * animationProgress;

package/ReactCommon/react/renderer/components/view/ViewShadowNode.cpp

@@ -28,14 +28,6 @@ ViewShadowNode::ViewShadowNode(
   initialize();
 }
 
-static bool isColorMeaningful(SharedColor const &color) noexcept {
-  if (!color) {
-    return false;
-  }
-
-  return colorComponentsFromColor(color).alpha > 0;
-}
-
 void ViewShadowNode::initialize() noexcept {
   auto &viewProps = static_cast<ViewProps const &>(*props_);
 
@@ -50,15 +42,16 @@ void ViewShadowNode::initialize() noexcept {
       viewProps.getClipsContentToBounds() ||
       isColorMeaningful(viewProps.shadowColor) ||
       viewProps.accessibilityElementsHidden ||
-      viewProps.importantForAccessibility != ImportantForAccessibility::Auto;
+      viewProps.accessibilityViewIsModal ||
+      viewProps.importantForAccessibility != ImportantForAccessibility::Auto ||
+      viewProps.removeClippedSubviews;
 
-  bool formsView = isColorMeaningful(viewProps.backgroundColor) ||
+  bool formsView = formsStackingContext ||
+      isColorMeaningful(viewProps.backgroundColor) ||
       isColorMeaningful(viewProps.foregroundColor) ||
       !(viewProps.yogaStyle.border() == YGStyle::Edges{}) ||
       !viewProps.testId.empty();
 
-  formsView = formsView || formsStackingContext;
-
   if (formsView) {
     traits_.set(ShadowNodeTraits::Trait::FormsView);
   } else {

package/ReactCommon/react/renderer/components/view/ViewShadowNode.h

@@ -24,7 +24,7 @@ class ViewShadowNode final : public ConcreteViewShadowNode<
                                  ViewEventEmitter> {
  public:
   static ShadowNodeTraits BaseTraits() {
-    auto traits = BaseShadowNode::BaseTraits();
+    auto traits = ConcreteViewShadowNode::BaseTraits();
     traits.set(ShadowNodeTraits::Trait::View);
     return traits;
   }