react-native-tvos 0.85.0-0rc5 → 0.85.2-0

package/Libraries/Components/ScrollView/AndroidHorizontalScrollViewNativeComponent.js

@@ -54,6 +54,7 @@ export const __INTERNAL_VIEW_CONFIG: PartialViewConfig = {
     borderTopRightRadius: true,
     borderLeftColor: colorAttribute,
     snapToItemPadding: true,
+    scrollAnimationEnabled: true,
     pointerEvents: true,
     scrollsChildToFocus: true,
   },

package/Libraries/Components/ScrollView/ScrollView.d.ts

@@ -754,6 +754,13 @@ export interface ScrollViewProps
    */
   removeClippedSubviews?: boolean | undefined;
 
+  /**
+   * (TV only)
+   * When false, the scroll view will jump to the correct offset without animation
+   * when focus changes. Defaults to true.
+   */
+  scrollAnimationEnabled?: boolean | undefined;
+
   /**
    * When true, shows a horizontal scroll indicator.
    */

package/Libraries/Components/ScrollView/ScrollView.js

@@ -670,6 +670,12 @@ type ScrollViewBaseProps = Readonly<{
    * true.
    */
   removeClippedSubviews?: ?boolean,
+  /**
+   * (TV only)
+   * When false, the scroll view will jump to the correct offset without animation
+   * when focus changes. Defaults to true.
+   */
+  scrollAnimationEnabled?: ?boolean,
   /**
    * A RefreshControl component, used to provide pull-to-refresh
    * functionality for the ScrollView. Only works for vertical ScrollViews

package/Libraries/Components/ScrollView/ScrollViewNativeComponent.js

@@ -76,6 +76,7 @@ export const __INTERNAL_VIEW_CONFIG: PartialViewConfig =
           borderTopRightRadius: true,
           borderLeftColor: colorAttribute,
           snapToItemPadding: true,
+          scrollAnimationEnabled: true,
           pointerEvents: true,
           isInvertedVirtualizedList: true,
           scrollsChildToFocus: true,
@@ -142,6 +143,7 @@ export const __INTERNAL_VIEW_CONFIG: PartialViewConfig =
           scrollsToTop: true,
           showsHorizontalScrollIndicator: true,
           showsVerticalScrollIndicator: true,
+          scrollAnimationEnabled: true,
           showsScrollIndex: true,
           snapToItemPadding: true,
           snapToAlignment: true,

package/Libraries/Components/ScrollView/ScrollViewNativeComponentType.js

@@ -73,6 +73,7 @@ export type ScrollViewNativeProps = Readonly<{
   snapToItemPadding?: ?number,
   sendMomentumEvents?: ?boolean,
   showsHorizontalScrollIndicator?: ?boolean,
+  scrollAnimationEnabled?: ?boolean,
   showsScrollIndex?: ?boolean,
   showsVerticalScrollIndicator?: ?boolean,
   snapToAlignment?: ?('start' | 'center' | 'end' | 'item'),

package/Libraries/Components/TextInput/AndroidTextInputNativeComponent.js

@@ -402,7 +402,11 @@ export type AndroidTextInputNativeProps = Readonly<{
    * Invalid if `multiline={true}` is specified.
    */
   onSubmitEditing?: ?BubblingEventHandler<
-    Readonly<{target: Int32, text: string}>,
+    Readonly<{
+      target: Int32,
+      text: string,
+      action?: 'submit' | 'next' | 'previous',
+    }>,
   >,
 
   /**

package/Libraries/Components/TextInput/TextInput.flow.js

@@ -127,6 +127,7 @@ type TextInputSubmitEditingEventData = Readonly<{
   ...TargetEvent,
   eventCount: number,
   text: string,
+  action?: 'submit' | 'next' | 'previous',
   ...
 }>;
 

package/Libraries/Core/ReactNativeVersion.js

@@ -28,8 +28,8 @@
 export default class ReactNativeVersion {
   static major: number = 0;
   static minor: number = 85;
-  static patch: number = 0;
-  static prerelease: string | null = '0rc5';
+  static patch: number = 2;
+  static prerelease: string | null = '0';
 
   static getVersionString(): string {
     return `${this.major}.${this.minor}.${this.patch}${this.prerelease != null ? `-${this.prerelease}` : ''}`;

package/README.md

@@ -262,6 +262,58 @@ class Game2048 extends React.Component {
   
   - _TVTextScrollView_: On Apple TV, a ScrollView will not scroll unless there are focusable items inside it or above/below it.  This component works on both Apple TV and Android TV, using native code to allow scrolling using swipe gestures from the remote control.
 
+  - _ScrollView snap alignment_: The existing `snapToAlignment` prop has been extended with a new `'item'` value that enables per-item snap alignment on TV. Instead of snapping all items uniformly to `'start'`, `'center'`, or `'end'`, each child can specify its own alignment via the `scrollSnapAlign` View prop. Optional padding can be applied with `snapToItemPadding` on the ScrollView.
+
+  | Prop (ScrollView) | Value | Description |
+  |---|---|---|
+  | snapToAlignment | `'item'` | Enables per-item snap alignment (TV only). Requires `snapToInterval` to be set. |
+  | snapToItemPadding | number? | Extra padding (in dp/pt) applied around items when snapping. Only used with `snapToAlignment="item"`. |
+
+  | Prop (View) | Value | Description |
+  |---|---|---|
+  | scrollSnapAlign | `'start'` \| `'center'` \| `'end'` | Controls where this item snaps inside its parent ScrollView. Only used when the parent has `snapToAlignment="item"`. |
+
+  ```jsx
+  <ScrollView
+    horizontal
+    snapToInterval={300}
+    snapToAlignment="item"
+    snapToItemPadding={20}>
+    <Pressable scrollSnapAlign="start" style={{width: 300}}>
+      <Text>Snaps to start</Text>
+    </Pressable>
+    <Pressable scrollSnapAlign="center" style={{width: 200}}>
+      <Text>Snaps to center</Text>
+    </Pressable>
+    <Pressable scrollSnapAlign="end" style={{width: 300}}>
+      <Text>Snaps to end</Text>
+    </Pressable>
+  </ScrollView>
+  ```
+
+  - _ScrollView animation control_: The `scrollAnimationEnabled` prop allows disabling scroll animations when focus changes on TV. When set to `false`, the scroll view jumps instantly to the focused item instead of animating. This only affects TV platforms and has no effect on mobile.
+
+  | Prop (ScrollView) | Value | Description |
+  |---|---|---|
+  | scrollAnimationEnabled | boolean? | When `false`, disables animated scrolling on focus change. Defaults to `true`. TV only. |
+
+  ```jsx
+  <ScrollView horizontal scrollAnimationEnabled={false}>
+    <Pressable style={{width: 300}}><Text>Item 1</Text></Pressable>
+    <Pressable style={{width: 300}}><Text>Item 2</Text></Pressable>
+    <Pressable style={{width: 300}}><Text>Item 3</Text></Pressable>
+  </ScrollView>
+  ```
+
+  - _Interaction with existing ScrollView props_: The TV scroll props build on top of existing React Native ScrollView behavior. Here is how they interact:
+
+    - `snapToAlignment="item"` does not require `snapToInterval` to be set. It works as a standalone snapping mode where each child's `scrollSnapAlign` determines the snap position. If `snapToInterval` is also set, the interval is applied as an additional constraint after the item offset is computed.
+    - `snapToAlignment="item"` should not be combined with `pagingEnabled`. Both attempt to control scroll positioning independently, which leads to unpredictable behavior. Use one or the other.
+    - `snapToStart` and `snapToEnd` work independently of `snapToAlignment="item"`. They control edge behavior during swipe/drag momentum (whether the scroll view snaps to the first or last position), but do not affect focus driven item snapping.
+    - `scrollAnimationEnabled={false}` disables all scroll animations, including programmatic `scrollTo({animated: true})` calls. When disabled, all scrolling is instant.
+    - `decelerationRate` has no effect when `scrollAnimationEnabled={false}`, since there is no animation to decelerate.
+    - `scrollAnimationEnabled` and `snapToAlignment="item"` work well together. Snapping still occurs, but instantly instead of animated.
+
   - _VirtualizedList_: We extend `VirtualizedList` to make virtualization work well with focus management in mind. All of the improvements that we made are automatically available to all the VirtualizedList based components such as `FlatList`.
     - Defaults: VirtualizeList contents are automatically wrapped with a `TVFocusGuideView` with `trapFocus*` properties enabled depending on the orientation of the list. This default makes sure that focus doesn't leave the list accidentally due to a virtualization issue etc. until reaching the beginning or the end of the list.
     - New Props:

package/React/Base/RCTVersion.m

@@ -23,8 +23,8 @@ NSDictionary* RCTGetReactNativeVersion(void)
     __rnVersion = @{
                   RCTVersionMajor: @(0),
                   RCTVersionMinor: @(85),
-                  RCTVersionPatch: @(0),
-                  RCTVersionPrerelease: @"0rc5",
+                  RCTVersionPatch: @(2),
+                  RCTVersionPrerelease: @"0",
                   };
   });
   return __rnVersion;

package/React/CoreModules/RCTDevLoadingView.mm

@@ -51,10 +51,27 @@ RCT_EXPORT_MODULE()
                                              selector:@selector(hide)
                                                  name:RCTJavaScriptDidFailToLoadNotification
                                                object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(hide)
+                                                 name:@"RCTInstanceDidLoadBundle"
+                                               object:nil];
   }
   return self;
 }
 
+- (void)dealloc
+{
+  [self clearInitialMessageDelay];
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+  UIWindow *window = _window;
+  _window = nil;
+  if (window) {
+    RCTExecuteOnMainQueue(^{
+      window.hidden = YES;
+    });
+  }
+}
+
 + (void)setEnabled:(BOOL)enabled
 {
   RCTDevLoadingViewSetEnabled(enabled);

package/React/Fabric/Mounting/ComponentViews/ScrollView/RCTEnhancedScrollView.h

@@ -52,6 +52,7 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) BOOL snapToEnd;
 @property (nonatomic, copy) NSArray<NSNumber *> *snapToOffsets;
 @property (nonatomic, assign) BOOL scrollSnapEnabled;
+@property (nonatomic, assign) BOOL scrollAnimationEnabled;
 
 /*
  * Makes `setContentOffset:` method no-op when given `block` is executed.

package/React/Fabric/Mounting/ComponentViews/ScrollView/RCTEnhancedScrollView.mm

@@ -9,6 +9,28 @@
 #import <React/RCTUtils.h>
 #import <react/utils/FloatComparison.h>
 
+#if TARGET_OS_TV
+// Layer subclass that can block all animations when scrollAnimationEnabled is NO.
+// This intercepts animations at the point they're added to the layer, which catches
+// all animation sources: UIView animations, focus coordinator animations, and
+// Core Animation implicit/explicit animations.
+@interface RCTScrollViewLayer : CALayer
+@property (nonatomic, assign) BOOL blockAnimations;
+@end
+
+@implementation RCTScrollViewLayer
+
+- (void)addAnimation:(CAAnimation *)anim forKey:(NSString *)key
+{
+  if (_blockAnimations) {
+    return;
+  }
+  [super addAnimation:anim forKey:key];
+}
+
+@end
+#endif
+
 @interface RCTEnhancedScrollView () <UIScrollViewDelegate>
 @end
 
@@ -17,6 +39,13 @@
   BOOL _isSetContentOffsetDisabled;
 }
 
+#if TARGET_OS_TV
++ (Class)layerClass
+{
+  return [RCTScrollViewLayer class];
+}
+#endif
+
 + (BOOL)automaticallyNotifiesObserversForKey:(NSString *)key
 {
   if ([key isEqualToString:@"delegate"]) {
@@ -28,9 +57,18 @@
   return [super automaticallyNotifiesObserversForKey:key];
 }
 
+- (void)setScrollAnimationEnabled:(BOOL)scrollAnimationEnabled
+{
+  _scrollAnimationEnabled = scrollAnimationEnabled;
+#if TARGET_OS_TV
+  ((RCTScrollViewLayer *)self.layer).blockAnimations = !scrollAnimationEnabled;
+#endif
+}
+
 - (instancetype)initWithFrame:(CGRect)frame
 {
   if (self = [super initWithFrame:frame]) {
+    _scrollAnimationEnabled = YES;
     // We set the default behavior to "never" so that iOS
     // doesn't do weird things to UIScrollView insets automatically
     // and keeps it as an opt-in behavior.
@@ -102,6 +140,46 @@
       RCTSanitizeNaNValue(contentOffset.y, @"scrollView.contentOffset.y"));
 }
 
+- (void)setContentOffset:(CGPoint)contentOffset animated:(BOOL)animated
+{
+  if (_isSetContentOffsetDisabled) {
+    return;
+  }
+#if TARGET_OS_TV
+  animated = animated && _scrollAnimationEnabled;
+#endif
+  [super setContentOffset:CGPointMake(
+      RCTSanitizeNaNValue(contentOffset.x, @"scrollView.contentOffset.x"),
+      RCTSanitizeNaNValue(contentOffset.y, @"scrollView.contentOffset.y"))
+                 animated:animated];
+}
+
+- (void)scrollRectToVisible:(CGRect)rect animated:(BOOL)animated
+{
+#if TARGET_OS_TV
+  animated = animated && _scrollAnimationEnabled;
+#endif
+  [super scrollRectToVisible:rect animated:animated];
+}
+
+#if TARGET_OS_TV
+- (void)didUpdateFocusInContext:(UIFocusUpdateContext *)context
+       withAnimationCoordinator:(UIFocusAnimationCoordinator *)coordinator
+{
+  if (_scrollAnimationEnabled) {
+    [super didUpdateFocusInContext:context withAnimationCoordinator:coordinator];
+    return;
+  }
+
+  // When scrollAnimationEnabled is NO, don't call super and don't scroll here.
+  // RCTScrollViewComponentView.didUpdateFocusInContext handles all scrolling
+  // (both snap and non-snap cases) when animation is disabled. Scrolling here
+  // as well would cause conflicts — e.g. at the end of a snapToInterval list,
+  // this method computes a "just make visible" position while the component view
+  // computes the correct snapped position, causing a bounce effect.
+}
+#endif
+
 - (void)setFrame:(CGRect)frame
 {
   [super setFrame:frame];

package/React/Fabric/Mounting/ComponentViews/ScrollView/RCTScrollViewComponentView.mm

@@ -434,6 +434,9 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
 
   scrollView.snapToStart = newScrollViewProps.snapToStart;
   scrollView.snapToEnd = newScrollViewProps.snapToEnd;
+#if TARGET_OS_TV
+  scrollView.scrollAnimationEnabled = newScrollViewProps.scrollAnimationEnabled;
+#endif
 
   if (oldScrollViewProps.snapToOffsets != newScrollViewProps.snapToOffsets) {
     NSMutableArray<NSNumber *> *snapToOffsets = [NSMutableArray array];
@@ -1252,7 +1255,7 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
         ? CGPointMake(targetOffset, scrollView.contentOffset.y)
         : CGPointMake(scrollView.contentOffset.x, targetOffset);
     self.preferredContentOffset = targetContentOffset;
-    [_scrollView setContentOffset:targetContentOffset animated:YES];
+    [_scrollView setContentOffset:targetContentOffset animated:scrollProps.scrollAnimationEnabled];
 }
 
 - (void)didUpdateFocusInContext:(UIFocusUpdateContext *)context
@@ -1261,7 +1264,18 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
     self.preferredContentOffset = NO_PREFERRED_CONTENT_OFFSET;
     const auto &scrollProps = static_cast<const ScrollViewProps &>(*_props);
     BOOL hasItemSnapAlignment = scrollProps.snapToAlignment == ScrollViewSnapToAlignment::Item;
-    if (context.previouslyFocusedView == context.nextFocusedView || (!_props->isTVSelectable && !hasItemSnapAlignment)) {
+    if (context.previouslyFocusedView == context.nextFocusedView) {
+        return;
+    }
+    if (!_props->isTVSelectable && !hasItemSnapAlignment) {
+        if (!scrollProps.scrollAnimationEnabled && [context.nextFocusedView isDescendantOfView:_scrollView]) {
+            // When animations are disabled and there's no snap alignment, manually scroll
+            // the focused view into view instantly. We can't let UIScrollView's default
+            // focus handling do this because it uses deceleration (timer-based) that can't
+            // be blocked by the animation-blocking layer.
+            CGRect targetRect = [context.nextFocusedView convertRect:context.nextFocusedView.bounds toView:_scrollView];
+            [_scrollView scrollRectToVisible:targetRect animated:NO];
+        }
         return;
     }
     if (_props->isTVSelectable && context.nextFocusedView == self) {
@@ -1429,10 +1443,16 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
         limitedOffset = MAX(limitedOffset, 0.0);
         limitedOffset = MIN(limitedOffset, maxOffset);
 
-        [UIView animateWithDuration:[self swipeDuration] animations:^{
+        const auto &scrollProps = static_cast<const ScrollViewProps &>(*self->_props);
+        if (scrollProps.scrollAnimationEnabled) {
+            [UIView animateWithDuration:[self swipeDuration] animations:^{
+                self.scrollView.contentOffset =
+                CGPointMake(self.scrollView.contentOffset.x, limitedOffset);
+            }];
+        } else {
             self.scrollView.contentOffset =
             CGPointMake(self.scrollView.contentOffset.x, limitedOffset);
-        }];
+        }
     });
 }
 
@@ -1453,10 +1473,16 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
         limitedOffset = MAX(limitedOffset, 0.0);
         limitedOffset = MIN(limitedOffset, maxOffset);
 
-        [UIView animateWithDuration:[self swipeDuration] animations:^{
+        const auto &scrollProps = static_cast<const ScrollViewProps &>(*self->_props);
+        if (scrollProps.scrollAnimationEnabled) {
+            [UIView animateWithDuration:[self swipeDuration] animations:^{
+                self.scrollView.contentOffset =
+                CGPointMake(limitedOffset, self.scrollView.contentOffset.y);
+            }];
+        } else {
             self.scrollView.contentOffset =
             CGPointMake(limitedOffset, self.scrollView.contentOffset.y);
-        }];
+        }
     });
 }
 

package/React/Views/ScrollView/RCTScrollViewManager.m

@@ -106,6 +106,7 @@ RCT_EXPORT_VIEW_PROPERTY(onMomentumScrollEnd, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(inverted, BOOL)
 #if TARGET_OS_TV
 RCT_EXPORT_VIEW_PROPERTY(showsScrollIndex, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(scrollAnimationEnabled, BOOL)
 #endif
 RCT_EXPORT_VIEW_PROPERTY(automaticallyAdjustsScrollIndicatorInsets, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(contentInsetAdjustmentBehavior, UIScrollViewContentInsetAdjustmentBehavior)

package/ReactAndroid/build.gradle.kts

@@ -102,6 +102,8 @@ val preparePrefab by
                       Pair("../ReactCommon/hermes/inspector-modern/", "hermes/inspector-modern/"),
                       // fabricjni
                       Pair("src/main/jni/react/fabric", "react/fabric/"),
+                      // uimanagerjni
+                      Pair("src/main/jni/react/uimanager", "react/uimanager/"),
                       // glog
                       Pair(File(buildDir, "third-party-ndk/glog/exported/").absolutePath, ""),
                       // jsiinpsector

package/ReactAndroid/gradle.properties

@@ -1,4 +1,4 @@
-VERSION_NAME=0.85.0-0rc5
+VERSION_NAME=0.85.2-0
 react.internal.publishingGroup=io.github.react-native-tvos
 react.internal.hermesPublishingGroup=com.facebook.hermes
 

package/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsDefaults.kt

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<89c61520177334f93c65ff92c2fc74a6>>
+ * @generated SignedSource<<404cef70d58d40565506ab37a4697da8>>
  */
 
 /**
@@ -57,7 +57,7 @@ public open class ReactNativeFeatureFlagsDefaults : ReactNativeFeatureFlagsProvi
 
   override fun enableCppPropsIteratorSetter(): Boolean = false
 
-  override fun enableCustomFocusSearchOnClippedElementsAndroid(): Boolean = true
+  override fun enableCustomFocusSearchOnClippedElementsAndroid(): Boolean = false
 
   override fun enableDestroyShadowTreeRevisionAsync(): Boolean = false
 

package/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsOverrides_RNOSS_Experimental_Android.kt

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<8531ce29d0e5362517d35559ebda623b>>
+ * @generated SignedSource<<2452c003ffcba8e20b7cd40c68e05e3d>>
  */
 
 /**
@@ -23,6 +23,8 @@ public open class ReactNativeFeatureFlagsOverrides_RNOSS_Experimental_Android :
   // We could use JNI to get the defaults from C++,
   // but that is more expensive than just duplicating the defaults here.
 
+  override fun cxxNativeAnimatedEnabled(): Boolean = true
+
   override fun enableAccessibilityOrder(): Boolean = true
 
   override fun enableSwiftUIBasedFilters(): Boolean = true
@@ -30,4 +32,6 @@ public open class ReactNativeFeatureFlagsOverrides_RNOSS_Experimental_Android :
   override fun fixTextClippingAndroid15useBoundsForWidth(): Boolean = true
 
   override fun preventShadowTreeCommitExhaustion(): Boolean = true
+
+  override fun useSharedAnimatedBackend(): Boolean = true
 }

package/ReactAndroid/src/main/java/com/facebook/react/modules/network/NetworkEventUtil.kt

@@ -19,6 +19,7 @@ import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
 import java.io.IOException
 import java.net.SocketTimeoutException
 import okhttp3.Headers
+import okhttp3.MultipartBody
 import okhttp3.RequestBody
 import okio.Buffer
 
@@ -263,6 +264,13 @@ internal object NetworkEventUtil {
       return "[Preview unavailable]"
     }
 
+    // MultipartBody does not propagate isOneShot() from its parts, so check each
+    // part explicitly. Reading a one-shot part here would drain the underlying
+    // stream and cause the real request to fail.
+    if (body is MultipartBody && body.parts().any { it.body().isOneShot() }) {
+      return "[Preview unavailable]"
+    }
+
     return try {
       val buffer = Buffer()
       body.writeTo(buffer)

package/ReactAndroid/src/main/java/com/facebook/react/modules/network/RequestBodyUtil.kt

@@ -146,6 +146,8 @@ internal object RequestBodyUtil {
         }
       }
 
+      override fun isOneShot(): Boolean = true
+
       @Throws(IOException::class)
       override fun writeTo(sink: BufferedSink) {
         var source: Source? = null

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

@@ -14,7 +14,7 @@ public object ReactNativeVersion {
   public val VERSION: Map<String, Any?> = mapOf(
     "major" to 0,
     "minor" to 85,
-    "patch" to 0,
-    "prerelease" to "0rc5"
+    "patch" to 2,
+    "prerelease" to "0"
   )
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/common/UiModeUtils.kt

@@ -7,12 +7,32 @@
 
 package com.facebook.react.views.common
 
+import android.app.UiModeManager
 import android.content.Context
 import android.content.res.Configuration
 
 /** Utility object providing static methods for working with UI mode properties from Context. */
 internal object UiModeUtils {
 
+  private var isTVDeviceCached: Boolean? = null
+
+  /**
+   * Determines whether the device is a TV (Android TV / Fire TV).
+   * The result is cached after the first call.
+   *
+   * @param context The context to check the UI mode from
+   * @return true if the device is running in television mode, false otherwise
+   */
+  @JvmStatic
+  fun isTVDevice(context: Context): Boolean {
+    return isTVDeviceCached ?: run {
+      val uiModeManager = context.getSystemService(Context.UI_MODE_SERVICE) as? UiModeManager
+      val result = uiModeManager?.currentModeType == Configuration.UI_MODE_TYPE_TELEVISION
+      isTVDeviceCached = result
+      result
+    }
+  }
+
   /**
    * Determines whether the current UI mode is dark mode
    *