@lodev09/react-native-true-sheet 3.0.0-beta.17 → 3.0.0-beta.19

package/README.md

@@ -24,13 +24,20 @@ The true native bottom sheet experience for your React Native Apps. 💩
 
 ### Prerequisites
 
-- React Native >= 0.81
-- New Architecture enabled (`RCT_NEW_ARCH_ENABLED=1` for iOS, `newArchEnabled=true` for Android)
+- React Native >= 0.76 (Expo SDK 52+)
+- New Architecture enabled (default in RN 0.76+)
 
-### Install
+### Expo
+
+```sh
+npx expo install @lodev09/react-native-true-sheet
+```
+
+### Bare React Native
 
 ```sh
 yarn add @lodev09/react-native-true-sheet
+cd ios && pod install
 ```
 
 ## Documentation

package/android/src/main/java/com/lodev09/truesheet/TrueSheetViewController.kt

@@ -2,17 +2,16 @@ package com.lodev09.truesheet
 
 import android.annotation.SuppressLint
 import android.graphics.Color
-import android.graphics.drawable.GradientDrawable
 import android.graphics.drawable.ShapeDrawable
 import android.graphics.drawable.shapes.RoundRectShape
 import android.util.TypedValue
-import android.view.Gravity
 import android.view.MotionEvent
 import android.view.View
 import android.view.WindowManager
 import android.view.accessibility.AccessibilityNodeInfo
 import android.widget.FrameLayout
 import androidx.core.view.isNotEmpty
+import androidx.core.view.isVisible
 import com.facebook.react.R
 import com.facebook.react.uimanager.JSPointerDispatcher
 import com.facebook.react.uimanager.JSTouchDispatcher
@@ -26,6 +25,7 @@ import com.facebook.react.views.view.ReactViewGroup
 import com.google.android.material.bottomsheet.BottomSheetBehavior
 import com.google.android.material.bottomsheet.BottomSheetDialog
 import com.lodev09.truesheet.core.RNScreensFragmentObserver
+import com.lodev09.truesheet.core.TrueSheetGrabberView
 import com.lodev09.truesheet.utils.ScreenUtils
 
 data class DetentInfo(val index: Int, val position: Float)
@@ -62,10 +62,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     private const val GRABBER_TAG = "TrueSheetGrabber"
     private const val DEFAULT_MAX_WIDTH = 640 // dp
     private const val DEFAULT_CORNER_RADIUS = 16 // dp
-    private const val GRABBER_WIDTH = 32f // dp
-    private const val GRABBER_HEIGHT = 4f // dp
-    private const val GRABBER_TOP_MARGIN = 16f // dp
-    private val GRABBER_COLOR = Color.argb((0.4 * 255).toInt(), 73, 69, 79) // #49454F @ 40%
 
     /**
      * Gets the effective sheet height by subtracting headerHeight * 2.
@@ -117,7 +113,11 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   var currentDetentIndex: Int = -1
     private set
 
+  // Resolved detent positions (Y coordinate when sheet rests at each detent)
+  private val resolvedDetentPositions = mutableListOf<Int>()
+
   private var isDragging = false
+  private var isReconfiguring = false
   private var windowAnimation: Int = 0
   private var lastEmittedPositionPx: Int = -1
 
@@ -166,6 +166,13 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   val statusBarHeight: Int
     get() = ScreenUtils.getStatusBarHeight(reactContext)
 
+  /**
+   * The bottom inset (navigation bar height) to add to sheet height.
+   * This matches iOS behavior where the system adds bottom safe area inset internally.
+   */
+  private val bottomInset: Int
+    get() = ScreenUtils.getNavigationBarHeight(reactContext)
+
   /**
    * Edge-to-edge is enabled by default on API 36+, or when explicitly configured.
    */
@@ -273,7 +280,11 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
         val detentInfo = getDetentInfoForIndex(currentDetentIndex)
         val detent = getDetentValueForIndex(detentInfo.index)
         val positionPx = bottomSheetView?.let { ScreenUtils.getScreenY(it) } ?: screenHeight
+
         delegate?.viewControllerDidPresent(detentInfo.index, detentInfo.position, detent)
+
+        // Store resolved position for initial detent
+        storeResolvedPosition(detentInfo.index)
         emitChangePositionDelegate(detentInfo.index, positionPx, realtime = false)
 
         // Notify parent sheet that it has lost focus (after this sheet appeared)
@@ -340,7 +351,38 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
             BottomSheetBehavior.STATE_EXPANDED,
             BottomSheetBehavior.STATE_COLLAPSED,
-            BottomSheetBehavior.STATE_HALF_EXPANDED -> handleDragEnd(newState)
+            BottomSheetBehavior.STATE_HALF_EXPANDED -> {
+              // Ignore state changes triggered by content size reconfiguration
+              if (isReconfiguring) return
+
+              getDetentInfoForState(newState)?.let { detentInfo ->
+                // Store resolved position when sheet settles
+                storeResolvedPosition(detentInfo.index)
+
+                if (isDragging) {
+                  // Handle drag end
+                  val detent = getDetentValueForIndex(detentInfo.index)
+                  delegate?.viewControllerDidDragEnd(detentInfo.index, detentInfo.position, detent)
+
+                  if (detentInfo.index != currentDetentIndex) {
+                    presentPromise?.invoke()
+                    presentPromise = null
+                    currentDetentIndex = detentInfo.index
+                    setupDimmedBackground(detentInfo.index)
+                    delegate?.viewControllerDidChangeDetent(detentInfo.index, detentInfo.position, detent)
+                  }
+
+                  isDragging = false
+                } else {
+                  // Handle programmatic resize - emit detent change after sheet settles
+                  if (detentInfo.index != currentDetentIndex) {
+                    val detent = getDetentValueForIndex(detentInfo.index)
+                    currentDetentIndex = detentInfo.index
+                    delegate?.viewControllerDidChangeDetent(detentInfo.index, detentInfo.position, detent)
+                  }
+                }
+              }
+            }
 
             else -> {}
           }
@@ -436,15 +478,14 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       return
     }
 
-    currentDetentIndex = detentIndex
     setupDimmedBackground(detentIndex)
 
     if (isPresented) {
-      val detentInfo = getDetentInfoForIndex(detentIndex)
-      val detent = getDetentValueForIndex(detentInfo.index)
-      delegate?.viewControllerDidChangeDetent(detentInfo.index, detentInfo.position, detent)
+      // Detent change will be emitted when sheet settles in onStateChanged
+      // Don't update currentDetentIndex here - it will be updated when sheet settles
       setStateForDetentIndex(detentIndex)
     } else {
+      currentDetentIndex = detentIndex
       isDragging = false
       setupSheetDetents()
       setStateForDetentIndex(detentIndex)
@@ -480,39 +521,53 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   fun setupSheetDetents() {
     val behavior = this.behavior ?: return
 
+    // Reset resolved positions if detents count changed
+    if (resolvedDetentPositions.size != detents.size) {
+      resolvedDetentPositions.clear()
+      repeat(detents.size) { resolvedDetentPositions.add(0) }
+    }
+
+    // Always update auto detent positions based on current content height
+    for (i in detents.indices) {
+      if (detents[i] == -1.0) {
+        val detentHeight = getDetentHeight(detents[i])
+        resolvedDetentPositions[i] = screenHeight - detentHeight
+      }
+    }
+
+    // Flag to prevent state change callbacks from updating detent index during reconfiguration
+    isReconfiguring = true
+
     behavior.apply {
       skipCollapsed = false
-      isFitToContents = true
+      isFitToContents = false
       maxWidth = DEFAULT_MAX_WIDTH.dpToPx().toInt()
 
       when (detents.size) {
         1 -> {
-          maxHeight = getDetentHeight(detents[0])
-          skipCollapsed = true
-
-          if (isPresented && detents[0] == -1.0) {
-            sheetContainer?.apply {
-              val params = layoutParams
-              params.height = maxHeight
-              layoutParams = params
-            }
-          }
+          setPeekHeight(getDetentHeight(detents[0]), isPresented)
+          expandedOffset = screenHeight - peekHeight
         }
 
         2 -> {
           setPeekHeight(getDetentHeight(detents[0]), isPresented)
-          maxHeight = getDetentHeight(detents[1])
+          expandedOffset = screenHeight - getDetentHeight(detents[1])
         }
 
         3 -> {
-          isFitToContents = false
           setPeekHeight(getDetentHeight(detents[0]), isPresented)
-          maxHeight = getDetentHeight(detents[2])
-          expandedOffset = sheetTopInset
           halfExpandedRatio = minOf(getDetentHeight(detents[1]).toFloat() / screenHeight.toFloat(), 1.0f)
+          expandedOffset = screenHeight - getDetentHeight(detents[2])
         }
       }
     }
+
+    // Re-apply current state to update position after config changes
+    if (isPresented) {
+      setStateForDetentIndex(currentDetentIndex)
+    }
+
+    isReconfiguring = false
   }
 
   fun setupGrabber() {
@@ -524,21 +579,8 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
     if (!grabber || !draggable) return
 
-    val grabberView = View(reactContext).apply {
+    val grabberView = TrueSheetGrabberView(reactContext).apply {
       tag = GRABBER_TAG
-      layoutParams = FrameLayout.LayoutParams(
-        GRABBER_WIDTH.dpToPx().toInt(),
-        GRABBER_HEIGHT.dpToPx().toInt()
-      ).apply {
-        gravity = Gravity.CENTER_HORIZONTAL or Gravity.TOP
-        topMargin = GRABBER_TOP_MARGIN.dpToPx().toInt()
-      }
-      background = GradientDrawable().apply {
-        shape = GradientDrawable.RECTANGLE
-        cornerRadius = (GRABBER_HEIGHT / 2).dpToPx()
-        setColor(GRABBER_COLOR)
-      }
-      elevation = 1f
     }
 
     bottomSheet.addView(grabberView)
@@ -650,49 +692,132 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     lastEmittedPositionPx = positionPx
     val position = positionPx.pxToDp()
     val interpolatedIndex = getInterpolatedIndexForPosition(positionPx)
-    val detent = getDetentValueForIndex(kotlin.math.round(interpolatedIndex).toInt())
+    val detent = getInterpolatedDetentForPosition(positionPx)
     delegate?.viewControllerDidChangePosition(interpolatedIndex, position, detent, realtime)
   }
 
+  /**
+   * Stores the current Y position as the resolved position for the given detent index.
+   * This is called when the sheet settles at a detent to capture the actual position
+   * which may differ from the calculated position due to system adjustments.
+   */
+  private fun storeResolvedPosition(index: Int) {
+    if (index < 0 || index >= resolvedDetentPositions.size) return
+    val positionPx = bottomSheetView?.let { ScreenUtils.getScreenY(it) } ?: return
+    if (positionPx in 1..<screenHeight) {
+      resolvedDetentPositions[index] = positionPx
+    }
+  }
+
+  /**
+   * Stores the resolved position for the current detent.
+   * Called from TrueSheetView when content size changes.
+   */
+  fun storeCurrentResolvedPosition() {
+    storeResolvedPosition(currentDetentIndex)
+  }
+
+  /**
+   * Returns the estimated Y position for a detent index, using stored positions when available.
+   */
+  private fun getEstimatedPositionForIndex(index: Int): Int {
+    if (index < 0 || index >= resolvedDetentPositions.size) return screenHeight
+
+    val storedPos = resolvedDetentPositions[index]
+    if (storedPos > 0) return storedPos
+
+    // Estimate based on getDetentHeight which accounts for bottomInset and maxAllowedHeight
+    if (index < detents.size) {
+      val detentHeight = getDetentHeight(detents[index])
+      return screenHeight - detentHeight
+    }
+
+    return screenHeight
+  }
+
+  /**
+   * Finds the segment index and interpolation progress for a given position.
+   * Returns a Triple of (fromIndex, toIndex, progress) where progress is 0-1 within that segment.
+   * Returns null if position count is less than 2.
+   */
+  private fun findSegmentForPosition(positionPx: Int): Triple<Int, Int, Float>? {
+    val count = resolvedDetentPositions.size
+    if (count < 2) return null
+
+    val firstPos = getEstimatedPositionForIndex(0)
+    val lastPos = getEstimatedPositionForIndex(count - 1)
+
+    // Below first detent
+    if (positionPx > firstPos) {
+      val range = screenHeight - firstPos
+      val progress = if (range > 0) (positionPx - firstPos).toFloat() / range else 0f
+      return Triple(-1, 0, progress) // Special index -1 for below first
+    }
+
+    // Above last detent
+    if (positionPx < lastPos) {
+      return Triple(count - 1, count - 1, 0f)
+    }
+
+    // Find segment (positions decrease as index increases)
+    for (i in 0 until count - 1) {
+      val pos = getEstimatedPositionForIndex(i)
+      val nextPos = getEstimatedPositionForIndex(i + 1)
+
+      if (positionPx <= pos && positionPx >= nextPos) {
+        val range = pos - nextPos
+        val progress = if (range > 0) (pos - positionPx).toFloat() / range else 0f
+        return Triple(i, i + 1, maxOf(0f, minOf(1f, progress)))
+      }
+    }
+
+    return Triple(count - 1, count - 1, 0f)
+  }
+
   /**
    * Calculates the interpolated index based on position.
    * Returns a continuous value (e.g., 0.5 means halfway between detent 0 and 1).
    */
   private fun getInterpolatedIndexForPosition(positionPx: Int): Float {
-    val count = detents.size
+    val count = resolvedDetentPositions.size
     if (count == 0) return -1f
     if (count == 1) return 0f
 
-    // Convert position to detent fraction
-    val currentDetent = (screenHeight - positionPx).toFloat() / screenHeight.toFloat()
+    val segment = findSegmentForPosition(positionPx) ?: return 0f
+    val (fromIndex, _, progress) = segment
 
-    // Handle below first detent (interpolate from -1 to 0)
-    val firstDetentValue = getDetentValueForIndex(0)
-    if (currentDetent < firstDetentValue) {
-      if (firstDetentValue <= 0) return 0f
-      val progress = currentDetent / firstDetentValue
-      return progress - 1f
-    }
+    // Below first detent
+    if (fromIndex == -1) return -progress
 
-    // Find which segment the current detent falls into and interpolate
-    for (i in 0 until count - 1) {
-      val detentValue = getDetentValueForIndex(i)
-      val nextDetentValue = getDetentValueForIndex(i + 1)
-
-      if (currentDetent <= nextDetentValue) {
-        val range = nextDetentValue - detentValue
-        if (range <= 0) return i.toFloat()
-        val progress = (currentDetent - detentValue) / range
-        return i + maxOf(0f, minOf(1f, progress))
-      }
+    return fromIndex + progress
+  }
+
+  /**
+   * Calculates the interpolated detent value based on position.
+   * Returns the actual screen fraction, clamped to valid detent range.
+   */
+  private fun getInterpolatedDetentForPosition(positionPx: Int): Float {
+    val count = resolvedDetentPositions.size
+    if (count == 0) return 0f
+
+    val segment = findSegmentForPosition(positionPx) ?: return getDetentValueForIndex(0)
+    val (fromIndex, toIndex, progress) = segment
+
+    // Below first detent
+    if (fromIndex == -1) {
+      val firstDetent = getDetentValueForIndex(0)
+      return maxOf(0f, firstDetent * (1 - progress))
     }
 
-    return (count - 1).toFloat()
+    val fromDetent = getDetentValueForIndex(fromIndex)
+    val toDetent = getDetentValueForIndex(toIndex)
+    return fromDetent + progress * (toDetent - fromDetent)
   }
 
   /**
    * Gets the detent value (fraction) for a given index.
-   * For auto (-1), calculates the actual fraction from content + header height.
+   * Returns the raw screen fraction without bottomInset for interpolation calculations.
+   * Note: bottomInset is only added in getDetentHeight() for actual sheet sizing.
    */
   private fun getDetentValueForIndex(index: Int): Float {
     if (index < 0 || index >= detents.size) return 0f
@@ -749,39 +874,21 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     delegate?.viewControllerDidDragChange(detentInfo.index, detentInfo.position, detent)
   }
 
-  private fun handleDragEnd(state: Int) {
-    if (!isDragging) return
-
-    val detentInfo = getDetentInfoForState(state)
-    detentInfo?.let {
-      val detent = getDetentValueForIndex(it.index)
-      delegate?.viewControllerDidDragEnd(it.index, it.position, detent)
-
-      if (it.index != currentDetentIndex) {
-        presentPromise?.invoke()
-        presentPromise = null
-
-        currentDetentIndex = it.index
-        setupDimmedBackground(it.index)
-        delegate?.viewControllerDidChangeDetent(it.index, it.position, detent)
-      }
-    }
-
-    isDragging = false
-  }
-
   // ====================================================================
   // MARK: - Detent Calculations
   // ====================================================================
 
   private fun getDetentHeight(detent: Double): Int {
     val height: Int = if (detent == -1.0) {
-      contentHeight + headerHeight
+      // For auto detent, add bottomInset to match iOS behavior where the system
+      // adds bottom safe area inset internally to the sheet height
+      contentHeight + headerHeight + bottomInset
     } else {
       if (detent <= 0.0 || detent > 1.0) {
         throw IllegalArgumentException("TrueSheet: detent fraction ($detent) must be between 0 and 1")
       }
-      (detent * screenHeight).toInt()
+      // For fractional detents, add bottomInset to match iOS behavior
+      (detent * screenHeight).toInt() + bottomInset
     }
 
     val maxAllowedHeight = screenHeight - sheetTopInset
@@ -869,6 +976,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       setupSheetDetents()
       this.post {
         positionFooter()
+        storeResolvedPosition(currentDetentIndex)
         val positionPx = bottomSheetView?.let { ScreenUtils.getScreenY(it) } ?: screenHeight
         emitChangePositionDelegate(currentDetentIndex, positionPx, realtime = false)
       }
@@ -890,7 +998,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
    */
   override fun dispatchTouchEvent(event: MotionEvent): Boolean {
     val footer = containerView?.footerView
-    if (footer != null && footer.visibility == View.VISIBLE) {
+    if (footer != null && footer.isVisible) {
       val footerLocation = ScreenUtils.getScreenLocation(footer)
       val touchScreenX = event.rawX.toInt()
       val touchScreenY = event.rawY.toInt()

package/android/src/main/java/com/lodev09/truesheet/core/TrueSheetGrabberView.kt

@@ -0,0 +1,44 @@
+package com.lodev09.truesheet.core
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.graphics.Color
+import android.graphics.drawable.GradientDrawable
+import android.view.Gravity
+import android.view.View
+import android.widget.FrameLayout
+import com.facebook.react.uimanager.PixelUtil.dpToPx
+
+/**
+ * Native grabber (drag handle) view for the bottom sheet.
+ * Displays a small pill-shaped indicator at the top of the sheet.
+ */
+@SuppressLint("ViewConstructor")
+class TrueSheetGrabberView(context: Context) : View(context) {
+
+  companion object {
+    private const val GRABBER_WIDTH = 32f // dp
+    private const val GRABBER_HEIGHT = 4f // dp
+    private const val GRABBER_TOP_MARGIN = 16f // dp
+    private val GRABBER_COLOR = Color.argb((0.4 * 255).toInt(), 73, 69, 79) // #49454F @ 40%
+  }
+
+  init {
+    layoutParams = FrameLayout.LayoutParams(
+      GRABBER_WIDTH.dpToPx().toInt(),
+      GRABBER_HEIGHT.dpToPx().toInt()
+    ).apply {
+      gravity = Gravity.CENTER_HORIZONTAL or Gravity.TOP
+      topMargin = GRABBER_TOP_MARGIN.dpToPx().toInt()
+    }
+
+    background = GradientDrawable().apply {
+      shape = GradientDrawable.RECTANGLE
+      cornerRadius = (GRABBER_HEIGHT / 2).dpToPx()
+      setColor(GRABBER_COLOR)
+    }
+
+    // High elevation to ensure grabber appears above content views
+    elevation = 100f
+  }
+}

package/android/src/main/java/com/lodev09/truesheet/utils/ScreenUtils.kt

@@ -19,6 +19,18 @@ object ScreenUtils {
       context.resources.getIdentifier(name, "dimen", "android")
     ).takeIf { it > 0 } ?: 0
 
+  /**
+   * Get the WindowInsets for API 30+, or null for older APIs
+   */
+  private fun getWindowInsets(context: ReactContext): WindowInsets? {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      return context.getSystemService(WindowManager::class.java)
+        ?.currentWindowMetrics
+        ?.windowInsets
+    }
+    return null
+  }
+
   /**
    * Get the status bar height
    *
@@ -26,20 +38,29 @@ object ScreenUtils {
    * @return Status bar height in pixels
    */
   fun getStatusBarHeight(context: ReactContext): Int {
-    // Modern approach using WindowInsets (API 30+)
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-      val windowManager = context.getSystemService(WindowManager::class.java)
-      val windowMetrics = windowManager?.currentWindowMetrics
-      val insets = windowMetrics?.windowInsets?.getInsetsIgnoringVisibility(WindowInsets.Type.statusBars())
-      if (insets != null) {
-        return insets.top
-      }
+      getWindowInsets(context)
+        ?.getInsetsIgnoringVisibility(WindowInsets.Type.statusBars())
+        ?.let { return it.top }
     }
-
-    // Fallback to legacy approach for older APIs
     return getIdentifierHeight(context, "status_bar_height")
   }
 
+  /**
+   * Get the navigation bar height (bottom inset)
+   *
+   * @param context React context
+   * @return Navigation bar height in pixels
+   */
+  fun getNavigationBarHeight(context: ReactContext): Int {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      getWindowInsets(context)
+        ?.getInsetsIgnoringVisibility(WindowInsets.Type.navigationBars())
+        ?.let { return it.bottom }
+    }
+    return getIdentifierHeight(context, "navigation_bar_height")
+  }
+
   /**
    * Calculate the screen height
    *
@@ -55,36 +76,20 @@ object ScreenUtils {
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
       context.display?.getRealMetrics(displayMetrics)
     } else {
+      @Suppress("DEPRECATION")
       windowManager.defaultDisplay.getMetrics(displayMetrics)
     }
 
     val screenHeight = displayMetrics.heightPixels
-    val statusBarHeight = getStatusBarHeight(context)
-
-    val hasNavigationBar = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-      context.getSystemService(WindowManager::class.java)
-        ?.currentWindowMetrics
-        ?.windowInsets
-        ?.isVisible(WindowInsets.Type.navigationBars()) ?: false
-    } else {
-      context.resources.getIdentifier("navigation_bar_height", "dimen", "android") > 0
-    }
-
-    val navigationBarHeight = if (hasNavigationBar) {
-      getIdentifierHeight(context, "navigation_bar_height")
-    } else {
-      0
-    }
 
     return if (edgeToEdge) {
-      // getRealMetrics includes navigation bar height
-      // windowManager.defaultDisplay.getMetrics doesn't
-      when (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-        true -> screenHeight
-        false -> screenHeight + navigationBarHeight
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+        screenHeight
+      } else {
+        screenHeight + getNavigationBarHeight(context)
       }
     } else {
-      screenHeight - statusBarHeight - navigationBarHeight
+      screenHeight - getStatusBarHeight(context) - getNavigationBarHeight(context)
     }
   }
 
@@ -98,8 +103,7 @@ object ScreenUtils {
     val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
 
     return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-      val windowMetrics = windowManager.currentWindowMetrics
-      windowMetrics.bounds.width()
+      windowManager.currentWindowMetrics.bounds.width()
     } else {
       val displayMetrics = DisplayMetrics()
       @Suppress("DEPRECATION")