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

package/React/Views/RCTTVView.m

@@ -23,6 +23,9 @@
   __weak RCTBridge *_bridge;
   UITapGestureRecognizer *_selectRecognizer;
   BOOL motionEffectsAdded;
+  NSArray* focusDestinations;
+  id<UIFocusItem> previouslyFocusedItem;
+  
 }
 
 - (instancetype)initWithBridge:(RCTBridge *)bridge {
@@ -255,6 +258,23 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
   motionEffectsAdded = NO;
 }
 
+- (BOOL)shouldUpdateFocusInContext:(UIFocusUpdateContext *)context
+{
+  // This is  the `trapFocus*` logic that prevents the focus updates if
+  // focus should be trapped and `nextFocusedItem` is not a child FocusEnv.
+  if ((_trapFocusUp && context.focusHeading == UIFocusHeadingUp)
+     || (_trapFocusDown && context.focusHeading == UIFocusHeadingDown)
+     || (_trapFocusLeft && context.focusHeading == UIFocusHeadingLeft)
+     || (_trapFocusRight && context.focusHeading == UIFocusHeadingRight)) {
+
+    // Checks if `nextFocusedItem` is a child `FocusEnvironment`.
+    // If not, it returns false thus it keeps the focus inside.
+    return [UIFocusSystem environment:self containsEnvironment:context.nextFocusedItem];
+  }
+
+  return [super shouldUpdateFocusInContext:context];
+}
+
 - (void)didUpdateFocusInContext:(UIFocusUpdateContext *)context
        withAnimationCoordinator:(UIFocusAnimationCoordinator *)coordinator
 {
@@ -267,9 +287,8 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
     // So, `previouslyFocusedItem` is always the last focused child of `TVFocusGuide`.
     // We should update `preferredFocusEnvironments` in this case to make sure `FocusGuide` remembers
     // the last focused element and redirects the focus to it whenever focus comes back.
-    // We also add `self` as the second option in case `previouslyFocusedItem` becomes unreachable (e.g gets detached).
-    // `self` helps redirecting focus to the first focusable element in that case.
-    self.focusGuide.preferredFocusEnvironments = @[context.previouslyFocusedItem, self];
+    previouslyFocusedItem = context.previouslyFocusedItem;
+    [self handleFocusGuide];
   }
     
   if (context.nextFocusedView == self && self.isTVSelectable ) {
@@ -445,10 +464,10 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
 
 - (void)setAutoFocus:(BOOL)autoFocus
 {
-    if (_autoFocus != autoFocus) {
-        _autoFocus = autoFocus;
-        [self addFocusGuide:@[self]];
-    }
+  if (_autoFocus != autoFocus) {
+    _autoFocus = autoFocus;
+    [self handleFocusGuide];
+  }
 }
 
 - (void)addFocusGuide:(NSArray*)destinations {
@@ -465,4 +484,57 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
   self.focusGuide.preferredFocusEnvironments = destinations;
 }
 
+- (void)removeFocusGuide {
+	if (self.focusGuide != nil) {
+    focusDestinations = nil;
+    previouslyFocusedItem = nil;
+
+    [self removeLayoutGuide:self.focusGuide];
+    self.focusGuide = nil;
+	}
+}
+
+/// Responsible of determining what focusGuide's next state should be based on the active properties of the component.
+- (void)handleFocusGuide
+{
+  // `destinations` should always be favored against `autoFocus` feature, if provided.
+  if (focusDestinations != nil) {
+    [self addFocusGuide:focusDestinations];
+  } else if (_autoFocus && previouslyFocusedItem != nil) {
+    // We also add `self` as the second option in case `previouslyFocusedItem` becomes unreachable (e.g gets detached).
+    // `self` helps redirecting focus to the first focusable element in that case.
+    [self addFocusGuide:@[previouslyFocusedItem, self]];
+  } else if (_autoFocus) {
+    [self addFocusGuide:@[self]];
+  } else {
+    // Then there's no need to have `focusGuide`, remove it to prevent potential bugs.
+    [self removeFocusGuide];
+  }
+}
+
+- (void)setFocusDestinations:(NSArray*)destinations
+{
+  if(destinations.count == 0) {
+    focusDestinations = nil;
+  } else {
+    focusDestinations = destinations;
+  }
+
+  [self handleFocusGuide];
+}
+
+- (void)requestTVFocus
+{
+  RCTRootView *rootview = [self rootView];
+  if (rootview == nil) return;
+
+  if (self.focusGuide != nil) {
+    rootview.reactPreferredFocusEnvironments = self.focusGuide.preferredFocusEnvironments;
+  } else {
+    rootview.reactPreferredFocusEnvironments = @[self];
+  }
+
+  [rootview setNeedsFocusUpdate];
+  [rootview updateFocusIfNeeded];
+}
 @end

package/React/Views/RCTViewManager.m

@@ -138,6 +138,10 @@ RCT_EXPORT_VIEW_PROPERTY(nextFocusDown, NSNumber)
 RCT_EXPORT_VIEW_PROPERTY(nextFocusLeft, NSNumber)
 RCT_EXPORT_VIEW_PROPERTY(nextFocusRight, NSNumber)
 RCT_EXPORT_VIEW_PROPERTY(autoFocus, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(trapFocusUp, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(trapFocusDown, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(trapFocusLeft, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(trapFocusRight, BOOL)
 #endif
 
 // Accessibility related properties
@@ -452,9 +456,17 @@ RCT_EXPORT_METHOD(setDestinations : (nonnull NSNumber *)viewTag reactTags : (NSA
         [destinations addObject:destination];
       }
     }
-    [view addFocusGuide:destinations];
+    [view setFocusDestinations:destinations];
   }];  
 }
+
+RCT_EXPORT_METHOD(requestTVFocus : (nonnull NSNumber *)viewTag)
+{
+  [self.bridge.uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    RCTTVView *view = (RCTTVView *)viewRegistry[viewTag];
+    [view requestTVFocus];
+  }];
+}
 #endif
 
 // The events below define the properties that are not used by native directly, but required in the view config for new

package/ReactAndroid/gradle.properties

@@ -1,4 +1,4 @@
-VERSION_NAME=0.69.6-3
+VERSION_NAME=0.69.8-0
 GROUP=com.facebook.react
 
 POM_NAME=ReactNative

package/ReactAndroid/src/main/java/com/facebook/react/config/ReactFeatureFlags.java

@@ -105,7 +105,13 @@ public class ReactFeatureFlags {
   public static boolean enableDelayedViewStateDeletion = false;
 
   /**
-   * Send key down events as well as key up events
+   * Android TV: Send key down events as well as key up events. 
+   * Enabling this flag will result in two 'select' TVRemoteEventHandler events
+   * (one with key action 0 and one with key action 1) for each press of the center
+   * DPad button. (Similarly for arrow keys.)
+   * Note: If you enable this flag, long presses of the select or center button will
+   * result in an initial 'select' with eventKeyAction = 0 (ACTION_DOWN), before
+   * the expected 'longSelect' events are fired. (Similarly for arrow keys.)
    */
   public static boolean enableKeyDownEvents = false;
 

package/ReactAndroid/src/main/java/com/facebook/react/modules/core/ReactAndroidHWInputDeviceHelper.java

@@ -81,8 +81,14 @@ public class ReactAndroidHWInputDeviceHelper {
    */
   private int mLastFocusedViewId = View.NO_ID;
 
+  // Presses longer than this number of milliseconds are treated as long presses
+  // This seems to be roughly the time the emulator waits after the first key down event
+  // before sending a continuous stream of rapid key downs on a long press.
+  private long mLongPressedDelta = 300;
+
+  // These are used for long press detection
   private long mLastKeyDownTime = 0;
-  private long mPressedDelta = 1000;
+  private boolean longPressEventActive = false;
 
   public ReactAndroidHWInputDeviceHelper() {}
 
@@ -101,6 +107,12 @@ public class ReactAndroidHWInputDeviceHelper {
       eventKeyCode == KeyEvent.KEYCODE_DPAD_LEFT;
   }
 
+  // True if we are in the long press state and we are more than
+  // mLongPressedDelta milliseconds since the last long press event was fired
+  private boolean isLongPressEventTime(long time) {
+    return mLastKeyDownTime != 0 && time - mLastKeyDownTime > mLongPressedDelta;
+  }
+
   /** Called from {@link com.facebook.react.ReactRootView}. This is the main place the key events are handled. */
   public void handleKeyEvent(KeyEvent ev, ReactContext context) {
     int eventKeyCode = ev.getKeyCode();
@@ -108,30 +120,48 @@ public class ReactAndroidHWInputDeviceHelper {
     long time = SystemClock.uptimeMillis();
     boolean isSelectOrDPadEvent = isDPadEvent(eventKeyCode) || isSelectEvent(eventKeyCode);
 
-    // Simple implementation of long press detection
-    if ((eventKeyAction == KeyEvent.ACTION_DOWN)
-      && isSelectOrDPadEvent && mLastKeyDownTime == 0) {
-      mLastKeyDownTime = time;
+    // Simple implementation of long press detection for key down events
+    if ((eventKeyAction == KeyEvent.ACTION_DOWN) && isSelectOrDPadEvent) {
+      if (mLastKeyDownTime == 0) {
+        mLastKeyDownTime = time;
+      } else {
+        if (isLongPressEventTime(time)) {
+          // Activate long press state and don't reset until key up event arrives
+          longPressEventActive = true;
+        }
+      }
     }
 
-    if (shouldDispatchEvent(eventKeyCode, eventKeyAction)) {
-      long delta = time - mLastKeyDownTime;
-      boolean isLongPress = delta > mPressedDelta;
-
-      if(isLongPress && isSelectOrDPadEvent){
-        dispatchEvent(KEY_EVENTS_LONG_PRESS_ACTIONS.get(eventKeyCode), mLastFocusedViewId, eventKeyAction, context);
+    if (shouldDispatchEvent(eventKeyCode, eventKeyAction, time)) {
+      if(longPressEventActive) {
+        // If we are not sending key down events to JS, send the long press event as a key up to make sure it is received
+        dispatchEvent(
+          KEY_EVENTS_LONG_PRESS_ACTIONS.get(eventKeyCode),
+          mLastFocusedViewId,
+          ReactFeatureFlags.enableKeyDownEvents ? eventKeyAction : KeyEvent.ACTION_UP,
+          context
+        );
+        // Update the start time for detecting the next long press event
+        mLastKeyDownTime = time;
       } else {
         dispatchEvent(KEY_EVENTS_ACTIONS.get(eventKeyCode), mLastFocusedViewId, eventKeyAction, context);
       }
+    }
+
+    // If this is key up event, reset long press detector
+    if ((eventKeyAction == KeyEvent.ACTION_UP) && isSelectOrDPadEvent) {
       mLastKeyDownTime = 0;
+      longPressEventActive = false;
     }
+
   }
 
-  // Android TV: Only send key up actions, unless key down events are enabled
-  private boolean shouldDispatchEvent(int eventKeyCode, int eventKeyAction) {
+  // Android TV: Only send key up actions, unless key down events are enabled or we need to send a long press event
+  private boolean shouldDispatchEvent(int eventKeyCode, int eventKeyAction, long time) {
     return KEY_EVENTS_ACTIONS.containsKey(eventKeyCode) && (
       (eventKeyAction == KeyEvent.ACTION_UP) ||
-      (eventKeyAction == KeyEvent.ACTION_DOWN && ReactFeatureFlags.enableKeyDownEvents)
+      (eventKeyAction == KeyEvent.ACTION_DOWN && !longPressEventActive && ReactFeatureFlags.enableKeyDownEvents) ||
+      (eventKeyAction == KeyEvent.ACTION_DOWN && longPressEventActive && isLongPressEventTime(time))
     );
   }
 

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

@@ -17,6 +17,6 @@ public class ReactNativeVersion {
   public static final Map<String, Object> VERSION = MapBuilder.<String, Object>of(
       "major", 0,
       "minor", 69,
-      "patch", 6,
-      "prerelease", "3");
+      "patch", 8,
+      "prerelease", "0");
 }

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;
@@ -86,6 +87,10 @@ public class ReactViewGroup extends ViewGroup
   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
@@ -391,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);
@@ -1092,8 +1099,18 @@ public class ReactViewGroup extends ViewGroup
     return false;
   }
 
+  private boolean isFocusDestinationsSet() {
+    return focusDestinations.length > 0;
+  }
+
   private boolean isTVFocusGuide() {
-    return focusDestinations.length > 0 || autoFocus;
+    /**
+     * 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
@@ -1182,6 +1199,14 @@ public class ReactViewGroup extends ViewGroup
       return super.requestFocus(direction, previouslyFocusedRect);
     }
 
+    if (isFocusDestinationsSet()) {
+      View destination = findDestinationView();
+
+      if (destination != null && requestFocusViewOrAncestor(destination)) {
+        return true;
+      }
+    }
+
     if (this.autoFocus) {
       View lastFocusedElem = lastFocusedElement.get();
 
@@ -1207,19 +1232,29 @@ public class ReactViewGroup extends ViewGroup
       }
     }
 
-    View destination = findDestinationView();
-
-    if (destination != null && requestFocusViewOrAncestor(destination)) {
-      return true;
-    }
+    return super.requestFocus(direction, previouslyFocusedRect);
+  }
 
-    for (int i = 0; i < getChildCount(); i++) {
-      if (getChildAt(i).requestFocus()) {
-        return true;
-      }
+  @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 false;
+    return super.focusSearch(focused, direction);
   }
 
   public void setFocusDestinations(@NonNull int[] focusDestinations) {
@@ -1230,4 +1265,20 @@ public class ReactViewGroup extends ViewGroup
     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,18 @@ 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")
@@ -374,4 +395,24 @@ public class ReactViewManager extends ReactClippingViewManager<ReactViewGroup> {
     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 = "3";
+  int32_t Patch = 8;
+  std::string_view Prerelease = "0";
 } ReactNativeVersion;
 
 } // namespace facebook::react

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

@@ -31,33 +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,
@@ -217,12 +257,36 @@ ViewProps::ViewProps(
           "renderToHardwareTextureAndroid",
           sourceProps.renderToHardwareTextureAndroid,
           {})),
-    autoFocus(convertRawProp(
-            context,
-            rawProps,
-            "autoFocus",
-            sourceProps.autoFocus,
-            false))
+      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
           {};