react-native-tvos 0.69.6-2 → 0.69.6-3

package/ReactAndroid/src/main/java/com/facebook/react/animated/EventAnimationDriver.java

@@ -21,8 +21,13 @@ import java.util.List;
 /* package */ class EventAnimationDriver implements RCTEventEmitter {
   private List<String> mEventPath;
   /* package */ ValueAnimatedNode mValueNode;
+  /* package */ String mEventName;
+  /* package */ int mViewTag;
 
-  public EventAnimationDriver(List<String> eventPath, ValueAnimatedNode valueNode) {
+  public EventAnimationDriver(
+      String eventName, int viewTag, List<String> eventPath, ValueAnimatedNode valueNode) {
+    mEventName = eventName;
+    mViewTag = viewTag;
     mEventPath = eventPath;
     mValueNode = valueNode;
   }

package/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedModule.java

@@ -113,7 +113,7 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
 
     @AnyThread
     boolean isEmpty() {
-      return mQueue.isEmpty();
+      return mQueue.isEmpty() && mPeekedOperation != null;
     }
 
     void setSynchronizedAccess(boolean isSynchronizedAccess) {
@@ -393,8 +393,8 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
 
   /**
    * Given a viewTag, detect if we're running in Fabric or non-Fabric and attach an event listener
-   * to the correct UIManager, if necessary. This is expected to only be called from the JS thread,
-   * and not concurrently.
+   * to the correct UIManager, if necessary. This is expected to only be called from the native
+   * module thread, and not concurrently.
    *
    * @param viewTag
    */
@@ -417,8 +417,7 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
     }
 
     // Subscribe to UIManager (Fabric or non-Fabric) lifecycle events if we haven't yet
-    if ((mInitializedForFabric && mUIManagerType == UIManagerType.FABRIC)
-        || (mInitializedForNonFabric && mUIManagerType == UIManagerType.DEFAULT)) {
+    if (mUIManagerType == UIManagerType.FABRIC ? mInitializedForFabric : mInitializedForNonFabric) {
       return;
     }
 

package/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedNodesManager.java

@@ -30,11 +30,9 @@ import com.facebook.react.uimanager.events.EventDispatcher;
 import com.facebook.react.uimanager.events.EventDispatcherListener;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.ListIterator;
-import java.util.Map;
 import java.util.Queue;
 
 /**
@@ -57,9 +55,9 @@ import java.util.Queue;
   private final SparseArray<AnimatedNode> mAnimatedNodes = new SparseArray<>();
   private final SparseArray<AnimationDriver> mActiveAnimations = new SparseArray<>();
   private final SparseArray<AnimatedNode> mUpdatedNodes = new SparseArray<>();
-  // Mapping of a view tag and an event name to a list of event animation drivers. 99% of the time
-  // there will be only one driver per mapping so all code code should be optimized around that.
-  private final Map<String, List<EventAnimationDriver>> mEventDrivers = new HashMap<>();
+  // List of event animation drivers for an event on view.
+  // There may be multiple drivers for the same event and view.
+  private final List<EventAnimationDriver> mEventDrivers = new ArrayList<>();
   private final ReactApplicationContext mReactApplicationContext;
   private int mAnimatedGraphBFSColor = 0;
   // Used to avoid allocating a new array on every frame in `runUpdates` and `onEventDispatch`.
@@ -76,36 +74,27 @@ import java.util.Queue;
 
   /**
    * Initialize event listeners for Fabric UIManager or non-Fabric UIManager, exactly once. Once
-   * Fabric is the only UIManager, this logic can be simplified. This is only called on the JS
-   * thread.
+   * Fabric is the only UIManager, this logic can be simplified. This is expected to only be called
+   * from the native module thread.
    *
    * @param uiManagerType
    */
-  @UiThread
   public void initializeEventListenerForUIManagerType(@UIManagerType final int uiManagerType) {
-    if ((uiManagerType == UIManagerType.FABRIC && mEventListenerInitializedForFabric)
-        || (uiManagerType == UIManagerType.DEFAULT && mEventListenerInitializedForNonFabric)) {
+    if (uiManagerType == UIManagerType.FABRIC
+        ? mEventListenerInitializedForFabric
+        : mEventListenerInitializedForNonFabric) {
       return;
     }
 
-    final NativeAnimatedNodesManager self = this;
-    mReactApplicationContext.runOnUiQueueThread(
-        new Runnable() {
-          @Override
-          public void run() {
-            UIManager uiManager =
-                UIManagerHelper.getUIManager(mReactApplicationContext, uiManagerType);
-            if (uiManager != null) {
-              uiManager.<EventDispatcher>getEventDispatcher().addListener(self);
-
-              if (uiManagerType == UIManagerType.FABRIC) {
-                mEventListenerInitializedForFabric = true;
-              } else {
-                mEventListenerInitializedForNonFabric = true;
-              }
-            }
-          }
-        });
+    UIManager uiManager = UIManagerHelper.getUIManager(mReactApplicationContext, uiManagerType);
+    if (uiManager != null) {
+      uiManager.<EventDispatcher>getEventDispatcher().addListener(this);
+      if (uiManagerType == UIManagerType.FABRIC) {
+        mEventListenerInitializedForFabric = true;
+      } else {
+        mEventListenerInitializedForNonFabric = true;
+      }
+    }
   }
 
   /*package*/ @Nullable
@@ -471,7 +460,8 @@ import java.util.Queue;
   }
 
   @UiThread
-  public void addAnimatedEventToView(int viewTag, String eventName, ReadableMap eventMapping) {
+  public void addAnimatedEventToView(
+      int viewTag, String eventHandlerName, ReadableMap eventMapping) {
     int nodeTag = eventMapping.getInt("animatedValueTag");
     AnimatedNode node = mAnimatedNodes.get(nodeTag);
     if (node == null) {
@@ -482,8 +472,8 @@ import java.util.Queue;
       throw new JSApplicationIllegalArgumentException(
           "addAnimatedEventToView: Animated node on view ["
               + viewTag
-              + "] connected to event ("
-              + eventName
+              + "] connected to event handler ("
+              + eventHandlerName
               + ") should be of type "
               + ValueAnimatedNode.class.getName());
     }
@@ -494,37 +484,31 @@ import java.util.Queue;
       pathList.add(path.getString(i));
     }
 
-    EventAnimationDriver event = new EventAnimationDriver(pathList, (ValueAnimatedNode) node);
-    String key = viewTag + eventName;
-    if (mEventDrivers.containsKey(key)) {
-      mEventDrivers.get(key).add(event);
-    } else {
-      List<EventAnimationDriver> drivers = new ArrayList<>(1);
-      drivers.add(event);
-      mEventDrivers.put(key, drivers);
-    }
+    String eventName = normalizeEventName(eventHandlerName);
+
+    EventAnimationDriver eventDriver =
+        new EventAnimationDriver(eventName, viewTag, pathList, (ValueAnimatedNode) node);
+    mEventDrivers.add(eventDriver);
   }
 
   @UiThread
-  public void removeAnimatedEventFromView(int viewTag, String eventName, int animatedValueTag) {
-    String key = viewTag + eventName;
-    if (mEventDrivers.containsKey(key)) {
-      List<EventAnimationDriver> driversForKey = mEventDrivers.get(key);
-      if (driversForKey.size() == 1) {
-        mEventDrivers.remove(viewTag + eventName);
-      } else {
-        ListIterator<EventAnimationDriver> it = driversForKey.listIterator();
-        while (it.hasNext()) {
-          if (it.next().mValueNode.mTag == animatedValueTag) {
-            it.remove();
-            break;
-          }
-        }
+  public void removeAnimatedEventFromView(
+      int viewTag, String eventHandlerName, int animatedValueTag) {
+
+    String eventName = normalizeEventName(eventHandlerName);
+
+    ListIterator<EventAnimationDriver> it = mEventDrivers.listIterator();
+    while (it.hasNext()) {
+      EventAnimationDriver driver = it.next();
+      if (eventName.equals(driver.mEventName)
+          && viewTag == driver.mViewTag
+          && animatedValueTag == driver.mValueNode.mTag) {
+        it.remove();
+        break;
       }
     }
   }
 
-  @UiThread
   @Override
   public void onEventDispatch(final Event event) {
     // Events can be dispatched from any thread so we have to make sure handleEvent is run from the
@@ -556,18 +540,19 @@ import java.util.Queue;
       if (uiManager == null) {
         return;
       }
-      String eventName = uiManager.resolveCustomDirectEventName(event.getEventName());
-      if (eventName == null) {
-        eventName = "";
-      }
 
-      List<EventAnimationDriver> driversForKey = mEventDrivers.get(event.getViewTag() + eventName);
-      if (driversForKey != null) {
-        for (EventAnimationDriver driver : driversForKey) {
+      boolean foundAtLeastOneDriver = false;
+      Event.EventAnimationDriverMatchSpec matchSpec = event.getEventAnimationDriverMatchSpec();
+      for (EventAnimationDriver driver : mEventDrivers) {
+        if (matchSpec.match(driver.mViewTag, driver.mEventName)) {
+          foundAtLeastOneDriver = true;
           stopAnimationsForNode(driver.mValueNode);
           event.dispatch(driver);
           mRunUpdateNodeList.add(driver.mValueNode);
         }
+      }
+
+      if (foundAtLeastOneDriver) {
         updateNodes(mRunUpdateNodeList);
         mRunUpdateNodeList.clear();
       }
@@ -782,4 +767,14 @@ import java.util.Queue;
       mWarnedAboutGraphTraversal = false;
     }
   }
+
+  private String normalizeEventName(String eventHandlerName) {
+    // Fabric UIManager also makes this assumption
+    String eventName = eventHandlerName;
+    if (eventHandlerName.startsWith("on")) {
+      eventName = "top" + eventHandlerName.substring(2);
+    }
+
+    return eventName;
+  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/modules/systeminfo/ReactNativeVersion.java

@@ -18,5 +18,5 @@ public class ReactNativeVersion {
       "major", 0,
       "minor", 69,
       "patch", 6,
-      "prerelease", "2");
+      "prerelease", "3");
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/Event.java

@@ -39,6 +39,7 @@ public abstract class Event<T extends Event> {
   private int mViewTag;
   private long mTimestampMs;
   private int mUniqueID = sUniqueID++;
+  private @Nullable EventAnimationDriverMatchSpec mEventAnimationDriverMatchSpec;
 
   protected Event() {}
 
@@ -156,6 +157,19 @@ public abstract class Event<T extends Event> {
   /** @return the name of this event as registered in JS */
   public abstract String getEventName();
 
+  public EventAnimationDriverMatchSpec getEventAnimationDriverMatchSpec() {
+    if (mEventAnimationDriverMatchSpec == null) {
+      mEventAnimationDriverMatchSpec =
+          new EventAnimationDriverMatchSpec() {
+            @Override
+            public boolean match(int viewTag, String eventName) {
+              return viewTag == getViewTag() && eventName.equals(getEventName());
+            };
+          };
+    }
+    return mEventAnimationDriverMatchSpec;
+  }
+
   /**
    * Dispatch this event to JS using the given event emitter. Compatible with old and new renderer.
    * Instead of using this or dispatchModern, it is recommended that you simply override
@@ -216,4 +230,8 @@ public abstract class Event<T extends Event> {
     }
     dispatch(rctEventEmitter);
   }
+
+  public interface EventAnimationDriverMatchSpec {
+    boolean match(int viewTag, String eventName);
+  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/view/ReactViewGroup.java

@@ -60,6 +60,9 @@ import com.facebook.react.uimanager.common.UIManagerType;
 import com.facebook.react.uimanager.common.ViewUtil;
 import com.facebook.yoga.YogaConstants;
 
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+
 /**
  * Backing for a React View. Has support for borders, but since borders aren't common, lazy
  * initializes most of the storage needed for them.
@@ -80,6 +83,9 @@ public class ReactViewGroup extends ViewGroup
   /* should only be used in {@link #updateClippingToRect} */
   private static final Rect sHelperRect = new Rect();
   private @NonNull int[] focusDestinations = new int[0];
+  private boolean autoFocus = false;
+  private WeakReference<View> lastFocusedElement;
+  private boolean mRecoverFocus = false;
 
   /**
    * This listener will be set for child views when removeClippedSubview property is enabled. When
@@ -440,6 +446,71 @@ public class ReactViewGroup extends ViewGroup
     }
   }
 
+  boolean moveFocusToFirstFocusable(ReactViewGroup viewGroup) {
+    ArrayList<View> focusables = new ArrayList<View>(0);
+    /**
+     * `addFocusables` is the method used by `FocusFinder` to determine
+     * which elements are `focusable` within the given view.
+     * Here we use it for the exact purpose. It mutates/populates the `focusables` array list.
+     * Focus direction (FOCUS_DOWN) doesn't matter at all because
+     * it's not being used by the underlying implementation.
+     */
+    viewGroup.addFocusables(focusables, FOCUS_DOWN, FOCUSABLES_ALL);
+    /**
+     * Depending on ViewGroup's `descendantFocusability` property,
+     * the first element can be the ViewGroup itself.
+     * The other ones on the list can be non-focusable as well.
+     * So, we run a loop till finding the first real focusable element.
+     */
+    if (focusables.size() <= 0) return false;
+
+    View firstFocusableElement = null;
+    Integer index = 0;
+    while (firstFocusableElement == null && index < focusables.size()) {
+      View elem = focusables.get(index);
+      if (elem.isFocusable() && elem != viewGroup) {
+        firstFocusableElement = elem;
+        break;
+      }
+      index++;
+    }
+
+    if (firstFocusableElement != null) return firstFocusableElement.requestFocus();
+
+    return false;
+  }
+
+  void recoverFocus(View view) {
+    if (!view.hasFocus() || !(view instanceof ReactViewGroup)) return;
+
+    ReactViewGroup parentFocusGuide = findParentFocusGuide(view);
+    if (parentFocusGuide == null) return;
+
+    /**
+     * Making `parentFocusGuide` focusable for a brief time to
+     * temporarily move the focus to it. We do this to prevent
+     * Android from moving the focus to top-left-most element of the screen.
+     */
+    parentFocusGuide.mRecoverFocus = true;
+    parentFocusGuide.setFocusable(true);
+    parentFocusGuide.requestFocus();
+
+    /**
+     * We set a Runnable to wait and make sure every layout related action gets completed
+     * before trying to find a new focus candidate inside the `parentFocusGuide`.
+     */
+    UiThreadUtil.runOnUiThread(
+      new Runnable() {
+        @Override
+        public void run() {
+          moveFocusToFirstFocusable(parentFocusGuide);
+
+          parentFocusGuide.setFocusable(false);
+          parentFocusGuide.mRecoverFocus = false;
+        }
+      });
+  }
+
   @Override
   public boolean getChildVisibleRect(View child, Rect r, android.graphics.Point offset) {
     return super.getChildVisibleRect(child, r, offset);
@@ -494,6 +565,8 @@ public class ReactViewGroup extends ViewGroup
       setChildrenDrawingOrderEnabled(false);
     }
 
+    recoverFocus(view);
+
     super.removeView(view);
   }
 
@@ -508,6 +581,8 @@ public class ReactViewGroup extends ViewGroup
       setChildrenDrawingOrderEnabled(false);
     }
 
+    recoverFocus(getChildAt(index));
+
     super.removeViewAt(index);
   }
 
@@ -1017,12 +1092,121 @@ public class ReactViewGroup extends ViewGroup
     return false;
   }
 
+  private boolean isTVFocusGuide() {
+    return focusDestinations.length > 0 || autoFocus;
+  }
+
+  @Nullable
+  private ReactViewGroup findParentFocusGuide(View view) {
+    ViewParent parent = view.getParent();
+
+    while (parent != null) {
+      if (parent instanceof ReactViewGroup) {
+        ReactViewGroup elem = (ReactViewGroup) parent;
+        if (elem.isTVFocusGuide()) return elem;
+      }
+      parent = parent.getParent();
+    }
+
+    return null;
+  }
+
+  /***
+   * This is meant to be used only for TVFocusGuide.
+   * @return View | null
+   */
+  @Nullable
+  private View getFocusedChildOfFocusGuide() {
+    if (!isTVFocusGuide()) return null;
+
+    /*
+     * We can have nested `TVFocusGuide`s, this is a typical scenario.
+     * The problem is, returned element from `getFocusedChild` can be
+     * either a direct `child` of the `TVFocusGuide` or a `descendant` of it.
+     * Let's say if we run `getFocusedChild` for the Root element, it will always
+     * give us an element even though the Root element is not the direct parent
+     * of the focused element.
+     * So, we need to find the closest `TVFocusGuide` to the focused child
+     * to make sure the focused element's closest `TVFocusGuide` is "this" one.
+     */
+    View focusedChild = this.getFocusedChild();
+    if (focusedChild == null) return null;
+
+    ReactViewGroup parentFocusGuide = findParentFocusGuide(focusedChild);
+    if (parentFocusGuide == this) return focusedChild;
+
+    return null;
+  }
+
+  @Override
+  public void addFocusables(ArrayList<View> views, int direction, int focusableMode) {
+    /**
+     * TVFocusGuides should reveral their children when `mRecoverFocus` is set.
+     * `mRecoverFocus` flag indicates a temporary focus recovery mode it's in which
+     * requires full access to children focusable elements.
+     */
+    if (isTVFocusGuide() && !mRecoverFocus) {
+      View focusedChild = getFocusedChildOfFocusGuide();
+
+      /*
+       * We only include the view's (TVFocusGuide) itself if it doesn't have a child that currently has the focus.
+       * Otherwise, it means focus is already in the `TVFocusGuide` and all of it's descendants should be included
+       * for focus calculations.
+       */
+      if (focusedChild == null) {
+        views.add(this);
+        return;
+      }
+    }
+
+    super.addFocusables(views, direction, focusableMode);
+  }
+
+  @Override
+  public void requestChildFocus(View child, View focused) {
+    super.requestChildFocus(child, focused);
+
+    if (autoFocus) {
+      lastFocusedElement = new WeakReference<View>(focused);
+    }
+  }
+
+  @Override
+  protected void onFocusChanged(boolean gainFocus, int direction, @Nullable Rect previouslyFocusedRect) {
+    super.onFocusChanged(gainFocus, direction, previouslyFocusedRect);
+  }
+
   @Override
   public boolean requestFocus(int direction, Rect previouslyFocusedRect) {
-    if (focusDestinations.length == 0) {
+    if (!isTVFocusGuide() || mRecoverFocus) {
       return super.requestFocus(direction, previouslyFocusedRect);
     }
 
+    if (this.autoFocus) {
+      View lastFocusedElem = lastFocusedElement.get();
+
+      if (lastFocusedElem != null) {
+
+        if (lastFocusedElem.isAttachedToWindow()) {
+          lastFocusedElem.requestFocus();
+          return true;
+        }
+
+        /**
+         * `lastFocusedElem` can get detached based on application logic.
+         * If the code reaches here, that means we're dealing with that case.
+         * We should set `lastFocusedElem` to null and let the focus determination
+         * logic below to do its magic and redirect focus to the first element.
+         */
+        lastFocusedElement = new WeakReference<View>(null);
+      }
+
+      // Try moving the focus to the first focusable element otherwise.
+      if (moveFocusToFirstFocusable(this)) {
+        return true;
+      }
+    }
+
     View destination = findDestinationView();
 
     if (destination != null && requestFocusViewOrAncestor(destination)) {
@@ -1041,4 +1225,9 @@ public class ReactViewGroup extends ViewGroup
   public void setFocusDestinations(@NonNull int[] focusDestinations) {
     this.focusDestinations = focusDestinations;
   }
+
+  public void setAutoFocusTV(boolean autoFocus) {
+    this.autoFocus = autoFocus;
+    lastFocusedElement = new WeakReference<View>(null);
+  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/view/ReactViewManager.java

@@ -369,4 +369,9 @@ public class ReactViewManager extends ReactClippingViewManager<ReactViewGroup> {
     view.setFocusDestinations(fd);
   }
 
+  @ReactProp(name = "autoFocus")
+  public void setAutoFocusTV(ReactViewGroup view, boolean autoFocus) {
+    view.setAutoFocusTV(autoFocus);
+  }
+
 }

package/ReactCommon/cxxreact/ReactNativeVersion.h

@@ -18,7 +18,7 @@ constexpr struct {
   int32_t Major = 0;
   int32_t Minor = 69;
   int32_t Patch = 6;
-  std::string_view Prerelease = "2";
+  std::string_view Prerelease = "3";
 } ReactNativeVersion;
 
 } // namespace facebook::react

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

@@ -52,6 +52,12 @@ ViewProps::ViewProps(
           convertRawProp(context, rawProps, "nextFocusLeft", sourceProps.nextFocusLeft, {})),
       nextFocusRight(
           convertRawProp(context, rawProps, "nextFocusRight", sourceProps.nextFocusRight, {})),
+      autoFocus(convertRawProp(
+          context,
+          rawProps,
+          "autoFocus",
+          sourceProps.autoFocus,
+          (Boolean) false)),
 #endif
       opacity(convertRawProp(
           context,
@@ -210,7 +216,13 @@ ViewProps::ViewProps(
           rawProps,
           "renderToHardwareTextureAndroid",
           sourceProps.renderToHardwareTextureAndroid,
-          {}))
+          {})),
+    autoFocus(convertRawProp(
+            context,
+            rawProps,
+            "autoFocus",
+            sourceProps.autoFocus,
+            false))
 #endif
           {};
 

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

@@ -78,6 +78,7 @@ class ViewProps : public YogaStylableProps, public AccessibilityProps {
   std::optional<int> nextFocusDown;
   std::optional<int> nextFocusLeft;
   std::optional<int> nextFocusRight;
+  bool autoFocus{false};
 #endif
 
   Float elevation{}; /* Android-only */
@@ -91,7 +92,7 @@ class ViewProps : public YogaStylableProps, public AccessibilityProps {
   bool hasTVPreferredFocus{false};
   bool needsOffscreenAlphaCompositing{false};
   bool renderToHardwareTextureAndroid{false};
-
+  bool autoFocus{false};
 #endif
 
 #pragma mark - Convenience Methods

package/android/com/facebook/react/hermes-engine/0.69.6-3/hermes-engine-0.69.6-3-debug-javadoc.jar.md5

@@ -0,0 +1 @@
+30e17a3c87b7749bfe1274ecbce32625

package/android/com/facebook/react/hermes-engine/0.69.6-3/hermes-engine-0.69.6-3-debug-javadoc.jar.sha1

@@ -0,0 +1 @@
+46136471b2e128b02b6899a6f7077e45411cef86

package/android/com/facebook/react/hermes-engine/0.69.6-3/hermes-engine-0.69.6-3-debug-javadoc.jar.sha256

@@ -0,0 +1 @@
+cb54ac291bde395af1a3fdf979feb3d6f1c5877f169eb265032cb1538b6be748

package/android/com/facebook/react/hermes-engine/0.69.6-3/hermes-engine-0.69.6-3-debug-javadoc.jar.sha512

@@ -0,0 +1 @@
+ea55856f042ca2b8bb1b1729ceaafb0911d7d0e7867d81a097bbe19da6a12c23fd0b70f4ae67db67278cc363c20b41739aa2784bb9ea59b41a91b36e607422a9

package/android/com/facebook/react/hermes-engine/0.69.6-3/hermes-engine-0.69.6-3-debug.aar.md5

@@ -0,0 +1 @@
+66de0799def1aeda1e565442acdd59e7

package/android/com/facebook/react/hermes-engine/0.69.6-3/hermes-engine-0.69.6-3-debug.aar.sha1

@@ -0,0 +1 @@
+34ca05140514f0e47a0914e94e77ca2b8c16b0a9

package/android/com/facebook/react/hermes-engine/0.69.6-3/hermes-engine-0.69.6-3-debug.aar.sha256

@@ -0,0 +1 @@
+070356a04d53ef7606de4b1ad9bec0814b9705a061a882d7ecf3415e804d7ddf

package/android/com/facebook/react/hermes-engine/0.69.6-3/hermes-engine-0.69.6-3-debug.aar.sha512

@@ -0,0 +1 @@
+a03e1a01e8258b8aeab1543286e21095cf8e7a8bb0b1dd465444615d2051da77625fb7cf381439288899029ea55604d51a949778a3622682a13a5d36b0d5a1db

package/android/com/facebook/react/hermes-engine/0.69.6-3/hermes-engine-0.69.6-3-release-javadoc.jar.md5

@@ -0,0 +1 @@
+30e17a3c87b7749bfe1274ecbce32625

package/android/com/facebook/react/hermes-engine/0.69.6-3/hermes-engine-0.69.6-3-release-javadoc.jar.sha1

@@ -0,0 +1 @@
+46136471b2e128b02b6899a6f7077e45411cef86

package/android/com/facebook/react/hermes-engine/0.69.6-3/hermes-engine-0.69.6-3-release-javadoc.jar.sha256

@@ -0,0 +1 @@
+cb54ac291bde395af1a3fdf979feb3d6f1c5877f169eb265032cb1538b6be748

package/android/com/facebook/react/hermes-engine/0.69.6-3/hermes-engine-0.69.6-3-release-javadoc.jar.sha512

@@ -0,0 +1 @@
+ea55856f042ca2b8bb1b1729ceaafb0911d7d0e7867d81a097bbe19da6a12c23fd0b70f4ae67db67278cc363c20b41739aa2784bb9ea59b41a91b36e607422a9