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

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/textinput/ReactEditText.java

@@ -586,6 +586,10 @@ public class ReactEditText extends AppCompatEditText
         new SpannableStringBuilder(reactTextUpdate.getText());
 
     manageSpans(spannableStringBuilder, reactTextUpdate.mContainsMultipleFragments);
+
+    // Mitigation for https://github.com/facebook/react-native/issues/35936 (S318090)
+    stripAbsoluteSizeSpans(spannableStringBuilder);
+
     mContainsImages = reactTextUpdate.containsImages();
 
     // When we update text, we trigger onChangeText code that will
@@ -659,6 +663,27 @@ public class ReactEditText extends AppCompatEditText
     }
   }
 
+  private void stripAbsoluteSizeSpans(SpannableStringBuilder sb) {
+    // We have already set a font size on the EditText itself. We can safely remove sizing spans
+    // which are the same as the set font size, and not otherwise overlapped.
+    final int effectiveFontSize = mTextAttributes.getEffectiveFontSize();
+    ReactAbsoluteSizeSpan[] spans = sb.getSpans(0, sb.length(), ReactAbsoluteSizeSpan.class);
+
+    outerLoop:
+    for (ReactAbsoluteSizeSpan span : spans) {
+      ReactAbsoluteSizeSpan[] overlappingSpans =
+          sb.getSpans(sb.getSpanStart(span), sb.getSpanEnd(span), ReactAbsoluteSizeSpan.class);
+
+      for (ReactAbsoluteSizeSpan overlappingSpan : overlappingSpans) {
+        if (span.getSize() != effectiveFontSize) {
+          continue outerLoop;
+        }
+      }
+
+      sb.removeSpan(span);
+    }
+  }
+
   private static boolean sameTextForSpan(
       final Editable oldText,
       final SpannableStringBuilder newText,

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
@@ -440,6 +451,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 +570,8 @@ public class ReactViewGroup extends ViewGroup
       setChildrenDrawingOrderEnabled(false);
     }
 
+    recoverFocus(view);
+
     super.removeView(view);
   }
 
@@ -508,6 +586,8 @@ public class ReactViewGroup extends ViewGroup
       setChildrenDrawingOrderEnabled(false);
     }
 
+    recoverFocus(getChildAt(index));
+
     super.removeViewAt(index);
   }
 
@@ -1017,28 +1097,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,11 @@ public class ReactViewManager extends ReactClippingViewManager<ReactViewGroup> {
           handleSetPressed(root, args);
           break;
         }
+      case "setDestinations":
+      {
+        handleSetDestinations(root, args);
+        break;
+      }
     }
   }
 
@@ -359,14 +371,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 = "0rc";
 } 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-0rc/hermes-engine-0.69.8-0rc-debug-javadoc.jar.md5

@@ -0,0 +1 @@
+6201960e9347682bbc00ae9944a632c4

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

@@ -0,0 +1 @@
+9e8b5eb666da9f08d0908808dd7d9c16aba4b1c2

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

@@ -0,0 +1 @@
+c255a9cbbfc674bcc34776435b85dcf390bc56c2341329971951d556b6162907

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

@@ -0,0 +1 @@
+4927a35f8ef2836598e81608424fe18557522c9a0985b58596e15cc992c233992e9d568e391c28c3d74d997793123e32b764959867aaec66681f035df463dc24

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

@@ -0,0 +1 @@
+8b30cc1e32b0ebb5f2af337204416078

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

@@ -0,0 +1 @@
+4b8c8be5bc8c00dfb4715cc8a11488ecf08c657a

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

@@ -0,0 +1 @@
+3464ef617b14406c64d3c3cbf74f4ffeb897dcd2bde49ec919b00130cbb180c5

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

@@ -0,0 +1 @@
+a72a2164acad5c06eec6eb6bce29e5640f8ae2eb5c2870545fd79f0a2f2c7b261885e106a6477bdd8d961a2fb17545273a7d44a4aaff57aa6751c43936d8bf18

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

@@ -0,0 +1 @@
+6201960e9347682bbc00ae9944a632c4

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

@@ -0,0 +1 @@
+9e8b5eb666da9f08d0908808dd7d9c16aba4b1c2

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

@@ -0,0 +1 @@
+c255a9cbbfc674bcc34776435b85dcf390bc56c2341329971951d556b6162907