react-native-tvos 0.69.6-2 → 0.69.8-0

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

@@ -20,6 +20,7 @@ import android.graphics.RectF;
 import android.graphics.drawable.Drawable;
 import android.graphics.drawable.LayerDrawable;
 import android.os.Build;
+import android.view.FocusFinder;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
@@ -60,6 +61,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 +84,13 @@ 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;
+  private boolean trapFocusUp = false;
+  private boolean trapFocusDown = false;
+  private boolean trapFocusLeft = false;
+  private boolean trapFocusRight = false;
 
   /**
    * This listener will be set for child views when removeClippedSubview property is enabled. When
@@ -385,6 +396,8 @@ public class ReactViewGroup extends ViewGroup
     Animation animation = child.getAnimation();
     boolean isAnimating = animation != null && !animation.hasEnded();
     if (!intersects && child.getParent() != null && !isAnimating) {
+      recoverFocus(child);
+
       // We can try saving on invalidate call here as the view that we remove is out of visible area
       // therefore invalidation is not necessary.
       super.removeViewsInLayout(idx - clippedSoFar, 1);
@@ -440,6 +453,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 +572,8 @@ public class ReactViewGroup extends ViewGroup
       setChildrenDrawingOrderEnabled(false);
     }
 
+    recoverFocus(view);
+
     super.removeView(view);
   }
 
@@ -508,6 +588,8 @@ public class ReactViewGroup extends ViewGroup
       setChildrenDrawingOrderEnabled(false);
     }
 
+    recoverFocus(getChildAt(index));
+
     super.removeViewAt(index);
   }
 
@@ -1017,28 +1099,186 @@ public class ReactViewGroup extends ViewGroup
     return false;
   }
 
+  private boolean isFocusDestinationsSet() {
+    return focusDestinations.length > 0;
+  }
+
+  private boolean isTVFocusGuide() {
+    /**
+     * We don't count a view as `TVFocusGuide` if it has `trapFocus*` props enabled.
+     * The reason is, it's a seperate functionality that has nothing to do with other
+     * TVFocusGuide features that involves heavy focus management. So, the feature
+     * is not directly tied to `TVFocusGuide`.
+     */
+    return isFocusDestinationsSet() || 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);
     }
 
-    View destination = findDestinationView();
+    if (isFocusDestinationsSet()) {
+      View destination = findDestinationView();
 
-    if (destination != null && requestFocusViewOrAncestor(destination)) {
-      return true;
+      if (destination != null && requestFocusViewOrAncestor(destination)) {
+        return true;
+      }
     }
 
-    for (int i = 0; i < getChildCount(); i++) {
-      if (getChildAt(i).requestFocus()) {
+    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;
       }
     }
 
-    return false;
+    return super.requestFocus(direction, previouslyFocusedRect);
+  }
+
+  @Override
+  public View focusSearch(View focused, int direction) {
+    /**
+     * FocusSearch recursively goes all the way up to the Root view
+     * and runs `FocusFinder.findNextFocus()` to determine the next focusable.
+     * It finds the next focusable by accounting *every* focusable elements on the screen.
+     *
+     * That is exactly the thing we want to prevent if the view has a `focusTrap` enabled
+     * matching the `direction`. We interrupt `focusSearch` to make the `FocusFinder` run
+     * the algorithm only accounting the children elements of the focus trap.
+     * This ensures that focus will always stay inside the container until trap gets disabled.
+     */
+    if ((trapFocusUp && direction == FOCUS_UP)
+      || (trapFocusDown && direction == FOCUS_DOWN)
+      || (trapFocusLeft && direction == FOCUS_LEFT)
+      || (trapFocusRight && direction == FOCUS_RIGHT)) {
+      return FocusFinder.getInstance().findNextFocus(this, focused, direction);
+    }
+
+    return super.focusSearch(focused, direction);
   }
 
   public void setFocusDestinations(@NonNull int[] focusDestinations) {
     this.focusDestinations = focusDestinations;
   }
+
+  public void setAutoFocusTV(boolean autoFocus) {
+    this.autoFocus = autoFocus;
+    lastFocusedElement = new WeakReference<View>(null);
+  }
+
+  public void setTrapFocusUp(boolean enabled) {
+    this.trapFocusUp = enabled;
+  }
+
+  public void setTrapFocusDown(boolean enabled) {
+    this.trapFocusDown = enabled;
+  }
+
+  public void setTrapFocusLeft(boolean enabled) {
+    this.trapFocusLeft = enabled;
+  }
+
+  public void setTrapFocusRight(boolean enabled) {
+    this.trapFocusRight = enabled;
+  }
 }

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

@@ -10,6 +10,7 @@ package com.facebook.react.views.view;
 import android.annotation.TargetApi;
 import android.graphics.Rect;
 import android.os.Build;
+import android.util.Log;
 import android.view.View;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -51,6 +52,7 @@ public class ReactViewManager extends ReactClippingViewManager<ReactViewGroup> {
   };
   private static final int CMD_HOTSPOT_UPDATE = 1;
   private static final int CMD_SET_PRESSED = 2;
+  private static final int CMD_SET_DESTINATIONS = 3;
   private static final String HOTSPOT_UPDATE_KEY = "hotspotUpdate";
 
   @ReactProp(name = "accessible")
@@ -305,7 +307,7 @@ public class ReactViewManager extends ReactClippingViewManager<ReactViewGroup> {
 
   @Override
   public Map<String, Integer> getCommandsMap() {
-    return MapBuilder.of(HOTSPOT_UPDATE_KEY, CMD_HOTSPOT_UPDATE, "setPressed", CMD_SET_PRESSED);
+    return MapBuilder.of(HOTSPOT_UPDATE_KEY, CMD_HOTSPOT_UPDATE, "setPressed", CMD_SET_PRESSED, "setDestinations", CMD_SET_DESTINATIONS);
   }
 
   @Override
@@ -321,6 +323,11 @@ public class ReactViewManager extends ReactClippingViewManager<ReactViewGroup> {
           handleSetPressed(root, args);
           break;
         }
+      case CMD_SET_DESTINATIONS:
+      {
+        handleSetDestinations(root, args);
+        break;
+      }
     }
   }
 
@@ -337,6 +344,16 @@ public class ReactViewManager extends ReactClippingViewManager<ReactViewGroup> {
           handleSetPressed(root, args);
           break;
         }
+      case "setDestinations":
+      {
+        handleSetDestinations(root, args);
+        break;
+      }
+      case "requestTVFocus":
+        {
+          root.requestFocus();
+          break;
+        }
     }
   }
 
@@ -359,14 +376,43 @@ public class ReactViewManager extends ReactClippingViewManager<ReactViewGroup> {
     root.drawableHotspotChanged(x, y);
   }
 
+  private void handleSetDestinations(ReactViewGroup root, @Nullable ReadableArray args) {
+    if (args == null || args.size() != 1) {
+      throw new JSApplicationIllegalArgumentException(
+        "Illegal number of arguments for 'setDestinations' command");
+    }
 
-  @ReactProp(name = "destinations")
-  public void setDestinations(final ReactViewGroup view, final ReadableArray destinations) {
+    ReadableArray destinations = args.getArray(0);
     int[] fd = new int[destinations.size()];
     for (int i = 0; i < fd.length; i++) {
       fd[i] = destinations.getInt(i);
     }
-    view.setFocusDestinations(fd);
+    root.setFocusDestinations(fd);
+  }
+
+  @ReactProp(name = "autoFocus")
+  public void setAutoFocusTV(ReactViewGroup view, boolean autoFocus) {
+    view.setAutoFocusTV(autoFocus);
+  }
+
+  @ReactProp(name = "trapFocusUp")
+  public void trapFocusUp(ReactViewGroup view, boolean enabled) {
+    view.setTrapFocusUp(enabled);
+  }
+
+  @ReactProp(name = "trapFocusDown")
+    public void trapFocusDown(ReactViewGroup view, boolean enabled) {
+    view.setTrapFocusDown(enabled);
+  }
+
+  @ReactProp(name = "trapFocusLeft")
+    public void trapFocusLeft(ReactViewGroup view, boolean enabled) {
+    view.setTrapFocusLeft(enabled);
+  }
+
+  @ReactProp(name = "trapFocusRight")
+    public void trapFocusRight(ReactViewGroup view, boolean enabled) {
+    view.setTrapFocusRight(enabled);
   }
 
 }

package/ReactCommon/cxxreact/ReactNativeVersion.h

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

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

@@ -31,27 +31,73 @@ ViewProps::ViewProps(
           rawProps,
           "isTVSelectable",
           sourceProps.isTVSelectable,
-          (Boolean)false)),
+          (Boolean) false)),
       hasTVPreferredFocus(convertRawProp(
           context,
           rawProps,
           "hasTVPreferredFocus",
           sourceProps.hasTVPreferredFocus,
-          (Boolean)false)),
+          (Boolean) false)),
       tvParallaxProperties(convertRawProp(
           context,
           rawProps,
           "tvParallaxProperties",
           sourceProps.tvParallaxProperties,
           {})),
-      nextFocusUp(
-          convertRawProp(context, rawProps, "nextFocusUp", sourceProps.nextFocusUp, {})),
-      nextFocusDown(
-          convertRawProp(context, rawProps, "nextFocusDown", sourceProps.nextFocusDown, {})),
-      nextFocusLeft(
-          convertRawProp(context, rawProps, "nextFocusLeft", sourceProps.nextFocusLeft, {})),
-      nextFocusRight(
-          convertRawProp(context, rawProps, "nextFocusRight", sourceProps.nextFocusRight, {})),
+      nextFocusUp(convertRawProp(
+          context,
+          rawProps,
+          "nextFocusUp",
+          sourceProps.nextFocusUp,
+          {})),
+      nextFocusDown(convertRawProp(
+          context,
+          rawProps,
+          "nextFocusDown",
+          sourceProps.nextFocusDown,
+          {})),
+      nextFocusLeft(convertRawProp(
+          context,
+          rawProps,
+          "nextFocusLeft",
+          sourceProps.nextFocusLeft,
+          {})),
+      nextFocusRight(convertRawProp(
+          context,
+          rawProps,
+          "nextFocusRight",
+          sourceProps.nextFocusRight,
+          {})),
+      autoFocus(convertRawProp(
+          context,
+          rawProps,
+          "autoFocus",
+          sourceProps.autoFocus,
+          (Boolean) false)),
+      trapFocusUp(convertRawProp(
+          context,
+          rawProps,
+          "trapFocusUp",
+          sourceProps.trapFocusUp,
+          false)),
+      trapFocusDown(convertRawProp(
+          context,
+          rawProps,
+          "trapFocusDown",
+          sourceProps.trapFocusDown,
+          false)),
+      trapFocusLeft(convertRawProp(
+          context,
+          rawProps,
+          "trapFocusLeft",
+          sourceProps.trapFocusLeft,
+          false)),
+      trapFocusRight(convertRawProp(
+          context,
+          rawProps,
+          "trapFocusRight",
+          sourceProps.trapFocusRight,
+          false)),
 #endif
       opacity(convertRawProp(
           context,
@@ -210,7 +256,37 @@ ViewProps::ViewProps(
           rawProps,
           "renderToHardwareTextureAndroid",
           sourceProps.renderToHardwareTextureAndroid,
-          {}))
+          {})),
+      autoFocus(convertRawProp(
+          context,
+          rawProps,
+          "autoFocus",
+          sourceProps.autoFocus,
+          false)),
+      trapFocusUp(convertRawProp(
+          context,
+          rawProps,
+          "trapFocusUp",
+          sourceProps.trapFocusUp,
+          false)),
+      trapFocusDown(convertRawProp(
+          context,
+          rawProps,
+          "trapFocusDown",
+          sourceProps.trapFocusDown,
+          false)),
+      trapFocusLeft(convertRawProp(
+          context,
+          rawProps,
+          "trapFocusLeft",
+          sourceProps.trapFocusLeft,
+          false)),
+      trapFocusRight(convertRawProp(
+          context,
+          rawProps,
+          "trapFocusRight",
+          sourceProps.trapFocusRight,
+          false))
 #endif
           {};
 

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

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

package/android/com/facebook/react/hermes-engine/0.69.8-0/hermes-engine-0.69.8-0-debug-javadoc.jar.md5

@@ -0,0 +1 @@
+997d5856e0278a47950534c7b7abd0b0

package/android/com/facebook/react/hermes-engine/0.69.8-0/hermes-engine-0.69.8-0-debug-javadoc.jar.sha1

@@ -0,0 +1 @@
+c2ea17c3e281e3d9b0e6d26fda7dff8209a147d3

package/android/com/facebook/react/hermes-engine/0.69.8-0/hermes-engine-0.69.8-0-debug-javadoc.jar.sha256

@@ -0,0 +1 @@
+71ca84c5b8dd1922e17dabf3996c7c0c97e173bae4735fb8fee0e5bac5c3cc07

package/android/com/facebook/react/hermes-engine/0.69.8-0/hermes-engine-0.69.8-0-debug-javadoc.jar.sha512

@@ -0,0 +1 @@
+297e3655c67f9408915cb689609c9e5628bf7e47f1c95021e177a944ab5fdedfb7dd485e993ea0c3ef4dcfda0b77cfd454d1a7bb123a395b925e585efa8fa4df

package/android/com/facebook/react/hermes-engine/0.69.8-0/hermes-engine-0.69.8-0-debug.aar.md5

@@ -0,0 +1 @@
+ee2b2730343b8716d190c80803c6ce5d

package/android/com/facebook/react/hermes-engine/0.69.8-0/hermes-engine-0.69.8-0-debug.aar.sha1

@@ -0,0 +1 @@
+c3ff9590abdb134bcfa1c2bb3bb1e3522fef468f

package/android/com/facebook/react/hermes-engine/0.69.8-0/hermes-engine-0.69.8-0-debug.aar.sha256

@@ -0,0 +1 @@
+53a6ba2595a81699797a95e0af6def3baffc8f6ff12230da5593db9bd5df93d7

package/android/com/facebook/react/hermes-engine/0.69.8-0/hermes-engine-0.69.8-0-debug.aar.sha512

@@ -0,0 +1 @@
+a1b3bfa6e56cc856991c6cdc0e048224555d8762662a85e31282b6f6759044bbdf6fdb1420809a59bad1781fc53744c6fd780f61aafdefd8f251ea7000ed607c

package/android/com/facebook/react/hermes-engine/0.69.8-0/hermes-engine-0.69.8-0-release-javadoc.jar.md5

@@ -0,0 +1 @@
+997d5856e0278a47950534c7b7abd0b0

package/android/com/facebook/react/hermes-engine/0.69.8-0/hermes-engine-0.69.8-0-release-javadoc.jar.sha1

@@ -0,0 +1 @@
+c2ea17c3e281e3d9b0e6d26fda7dff8209a147d3

package/android/com/facebook/react/hermes-engine/0.69.8-0/hermes-engine-0.69.8-0-release-javadoc.jar.sha256

@@ -0,0 +1 @@
+71ca84c5b8dd1922e17dabf3996c7c0c97e173bae4735fb8fee0e5bac5c3cc07

package/android/com/facebook/react/hermes-engine/0.69.8-0/hermes-engine-0.69.8-0-release-javadoc.jar.sha512

@@ -0,0 +1 @@
+297e3655c67f9408915cb689609c9e5628bf7e47f1c95021e177a944ab5fdedfb7dd485e993ea0c3ef4dcfda0b77cfd454d1a7bb123a395b925e585efa8fa4df

package/android/com/facebook/react/hermes-engine/0.69.8-0/hermes-engine-0.69.8-0-release.aar.md5

@@ -0,0 +1 @@
+64b7555285628d425f07e904320b0845

package/android/com/facebook/react/hermes-engine/0.69.8-0/hermes-engine-0.69.8-0-release.aar.sha1

@@ -0,0 +1 @@
+fee8ee3dfc5b2e97ab62407c1780a72d0e3f4c2d

package/android/com/facebook/react/hermes-engine/0.69.8-0/hermes-engine-0.69.8-0-release.aar.sha256

@@ -0,0 +1 @@
+72b9bcf2ae5c81a1df3aa5d1cf4bb86015d932a22b040515d64094f4989d7265

package/android/com/facebook/react/hermes-engine/0.69.8-0/hermes-engine-0.69.8-0-release.aar.sha512

@@ -0,0 +1 @@
+fbb7aa8c30cd3697c2153140dd36deb1095bb418405d50fb0141ad92b80091b391018db23ad15fa19b74869cfcc133a6fa751a903f540e915de1d875073a360c