@lodev09/react-native-true-sheet 2.0.6 → 4.0.0-beta.0

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

@@ -1,413 +0,0 @@
-package com.lodev09.truesheet
-
-import android.annotation.SuppressLint
-import android.graphics.Color
-import android.graphics.drawable.ShapeDrawable
-import android.graphics.drawable.shapes.RoundRectShape
-import android.view.View
-import android.view.ViewGroup
-import android.view.WindowManager
-import com.facebook.react.uimanager.ThemedReactContext
-import com.google.android.material.bottomsheet.BottomSheetBehavior
-import com.google.android.material.bottomsheet.BottomSheetDialog
-import com.lodev09.truesheet.core.KeyboardManager
-import com.lodev09.truesheet.core.RootSheetView
-import com.lodev09.truesheet.core.Utils
-
-data class SizeInfo(val index: Int, val value: Float)
-
-@SuppressLint("ClickableViewAccessibility")
-class TrueSheetDialog(private val reactContext: ThemedReactContext, private val rootSheetView: RootSheetView) :
-  BottomSheetDialog(reactContext) {
-
-  private var keyboardManager = KeyboardManager(reactContext)
-  private var windowAnimation: Int = 0
-
-  // First child of the rootSheetView
-  private val containerView: ViewGroup?
-    get() = if (rootSheetView.childCount > 0) {
-      rootSheetView.getChildAt(0) as? ViewGroup
-    } else {
-      null
-    }
-
-  private val sheetContainerView: ViewGroup?
-    get() = rootSheetView.parent?.let { it as? ViewGroup }
-
-  /**
-   * Specify whether the sheet background is dimmed.
-   * Set to `false` to allow interaction with the background components.
-   */
-  var dimmed = true
-
-  /**
-   * The size index that the sheet should start to dim the background.
-   * This is ignored if `dimmed` is set to `false`.
-   */
-  var dimmedIndex = 0
-
-  /**
-   * The maximum window height
-   */
-  var maxScreenHeight = 0
-
-  var contentHeight = 0
-  var footerHeight = 0
-  var maxSheetHeight: Int? = null
-
-  var edgeToEdge: Boolean = false
-    set(value) {
-      field = value
-      maxScreenHeight = Utils.screenHeight(reactContext, value)
-    }
-
-  var dismissible: Boolean = true
-    set(value) {
-      field = value
-      setCanceledOnTouchOutside(value)
-      setCancelable(value)
-
-      behavior.isHideable = value
-    }
-
-  var cornerRadius: Float = 0f
-  var backgroundColor: Int = Color.WHITE
-
-  // 1st child is the content view
-  val contentView: ViewGroup?
-    get() = containerView?.getChildAt(0) as? ViewGroup
-
-  // 2nd child is the footer view
-  val footerView: ViewGroup?
-    get() = containerView?.getChildAt(1) as? ViewGroup
-
-  var sizes: Array<Any> = arrayOf("medium", "large")
-
-  init {
-    setContentView(rootSheetView)
-
-    sheetContainerView?.setBackgroundColor(backgroundColor)
-    sheetContainerView?.clipToOutline = true
-
-    // Setup window params to adjust layout based on Keyboard state
-    window?.apply {
-      // Store current windowAnimation value to toggle later
-      windowAnimation = attributes.windowAnimations
-    }
-
-    // Update the usable sheet height
-    maxScreenHeight = Utils.screenHeight(reactContext, edgeToEdge)
-  }
-
-  override fun getEdgeToEdgeEnabled(): Boolean = edgeToEdge || super.getEdgeToEdgeEnabled()
-
-  override fun onStart() {
-    super.onStart()
-
-    if (edgeToEdge) {
-      window?.apply {
-        setFlags(
-          WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS,
-          WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS
-        )
-
-        decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_LAYOUT_STABLE or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
-      }
-    }
-  }
-
-  /**
-   * Setup background color and corner radius.
-   */
-  fun setupBackground() {
-    val outerRadii = floatArrayOf(
-      cornerRadius,
-      cornerRadius,
-      cornerRadius,
-      cornerRadius,
-      0f,
-      0f,
-      0f,
-      0f
-    )
-
-    val background = ShapeDrawable(RoundRectShape(outerRadii, null, null))
-
-    // Use current background color
-    background.paint.color = backgroundColor
-    sheetContainerView?.background = background
-  }
-
-  /**
-   * Setup dimmed sheet.
-   * `dimmedIndex` will further customize the dimming behavior.
-   */
-  fun setupDimmedBackground(sizeIndex: Int) {
-    window?.apply {
-      val view = findViewById<View>(com.google.android.material.R.id.touch_outside)
-
-      if (dimmed && sizeIndex >= dimmedIndex) {
-        // Remove touch listener
-        view.setOnTouchListener(null)
-
-        // Add the dimmed background
-        setFlags(
-          WindowManager.LayoutParams.FLAG_DIM_BEHIND,
-          WindowManager.LayoutParams.FLAG_DIM_BEHIND
-        )
-
-        setCanceledOnTouchOutside(dismissible)
-      } else {
-        // Override the background touch and pass it to the components outside
-        view.setOnTouchListener { v, event ->
-          event.setLocation(event.rawX - v.x, event.rawY - v.y)
-          reactContext.currentActivity?.dispatchTouchEvent(event)
-          false
-        }
-
-        // Remove the dimmed background
-        clearFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND)
-
-        setCanceledOnTouchOutside(false)
-      }
-    }
-  }
-
-  fun resetAnimation() {
-    window?.apply {
-      setWindowAnimations(windowAnimation)
-    }
-  }
-
-  /**
-   * Present the sheet.
-   */
-  fun present(sizeIndex: Int, animated: Boolean = true) {
-    setupDimmedBackground(sizeIndex)
-    if (isShowing) {
-      setStateForSizeIndex(sizeIndex)
-    } else {
-      configure()
-      setStateForSizeIndex(sizeIndex)
-
-      if (!animated) {
-        // Disable animation
-        window?.setWindowAnimations(0)
-      }
-
-      show()
-    }
-  }
-
-  fun positionFooter() {
-    footerView?.let { footer ->
-      sheetContainerView?.let { container ->
-        footer.y = (maxScreenHeight - container.top - footerHeight).toFloat()
-      }
-    }
-  }
-
-  /**
-   * Set the state based for the given size index.
-   */
-  fun setStateForSizeIndex(index: Int) {
-    behavior.state = getStateForSizeIndex(index)
-  }
-
-  /**
-   * Get the height value based on the size config value.
-   */
-  private fun getSizeHeight(size: Any): Int {
-    val height: Int =
-      when (size) {
-        is Double -> Utils.toPixel(size).toInt()
-
-        is Int -> Utils.toPixel(size.toDouble()).toInt()
-
-        is String -> {
-          when (size) {
-            "auto" -> contentHeight + footerHeight
-
-            "large" -> maxScreenHeight
-
-            "medium" -> (maxScreenHeight * 0.50).toInt()
-
-            "small" -> (maxScreenHeight * 0.25).toInt()
-
-            else -> {
-              if (size.endsWith('%')) {
-                val percent = size.trim('%').toDoubleOrNull()
-                if (percent == null) {
-                  0
-                } else {
-                  ((percent / 100) * maxScreenHeight).toInt()
-                }
-              } else {
-                val fixedHeight = size.toDoubleOrNull()
-                if (fixedHeight == null) {
-                  0
-                } else {
-                  Utils.toPixel(fixedHeight).toInt()
-                }
-              }
-            }
-          }
-        }
-
-        else -> (maxScreenHeight * 0.5).toInt()
-      }
-
-    return maxSheetHeight?.let { minOf(height, it, maxScreenHeight) } ?: minOf(height, maxScreenHeight)
-  }
-
-  /**
-   * Determines the state based from the given size index.
-   */
-  private fun getStateForSizeIndex(index: Int): Int {
-    return when (sizes.size) {
-      1 -> {
-        return BottomSheetBehavior.STATE_EXPANDED
-      }
-
-      2 -> {
-        when (index) {
-          0 -> BottomSheetBehavior.STATE_COLLAPSED
-          1 -> BottomSheetBehavior.STATE_EXPANDED
-          else -> BottomSheetBehavior.STATE_HIDDEN
-        }
-      }
-
-      3 -> {
-        when (index) {
-          0 -> BottomSheetBehavior.STATE_COLLAPSED
-          1 -> BottomSheetBehavior.STATE_HALF_EXPANDED
-          2 -> BottomSheetBehavior.STATE_EXPANDED
-          else -> BottomSheetBehavior.STATE_HIDDEN
-        }
-      }
-
-      else -> BottomSheetBehavior.STATE_HIDDEN
-    }
-  }
-
-  /**
-   * Handle keyboard state changes and adjust maxScreenHeight (sheet max height) accordingly.
-   * Also update footer's Y position.
-   */
-  fun registerKeyboardManager() {
-    keyboardManager.registerKeyboardListener(object : KeyboardManager.OnKeyboardChangeListener {
-      override fun onKeyboardStateChange(isVisible: Boolean, visibleHeight: Int?) {
-        maxScreenHeight = when (isVisible) {
-          true -> visibleHeight ?: 0
-          else -> Utils.screenHeight(reactContext, edgeToEdge)
-        }
-
-        positionFooter()
-      }
-    })
-  }
-
-  fun setOnSizeChangeListener(listener: (w: Int, h: Int) -> Unit) {
-    rootSheetView.sizeChangeListener = listener
-  }
-
-  /**
-   * Remove keyboard listener.
-   */
-  fun unregisterKeyboardManager() {
-    keyboardManager.unregisterKeyboardListener()
-  }
-
-  /**
-   * Configure the sheet based from the size preference.
-   */
-  fun configure() {
-    // Configure sheet sizes
-    behavior.apply {
-      skipCollapsed = false
-      isFitToContents = true
-
-      // m3 max width 640dp
-      maxWidth = Utils.toPixel(640.0).toInt()
-
-      when (sizes.size) {
-        1 -> {
-          maxHeight = getSizeHeight(sizes[0])
-          skipCollapsed = true
-
-          if (sizes[0] == "auto") {
-            // Force a layout update
-            sheetContainerView?.let {
-              val params = it.layoutParams
-              params.height = maxHeight
-              it.layoutParams = params
-            }
-          }
-        }
-
-        2 -> {
-          setPeekHeight(getSizeHeight(sizes[0]), isShowing)
-          maxHeight = getSizeHeight(sizes[1])
-        }
-
-        3 -> {
-          // Enables half expanded
-          isFitToContents = false
-
-          setPeekHeight(getSizeHeight(sizes[0]), isShowing)
-
-          halfExpandedRatio = minOf(getSizeHeight(sizes[1]).toFloat() / maxScreenHeight.toFloat(), 1.0f)
-          maxHeight = getSizeHeight(sizes[2])
-        }
-      }
-    }
-  }
-
-  /**
-   * Get the SizeInfo data by state.
-   */
-  fun getSizeInfoForState(state: Int): SizeInfo? =
-    when (sizes.size) {
-      1 -> {
-        when (state) {
-          BottomSheetBehavior.STATE_COLLAPSED -> SizeInfo(0, Utils.toDIP(behavior.maxHeight.toFloat()))
-          BottomSheetBehavior.STATE_EXPANDED -> SizeInfo(0, Utils.toDIP(behavior.maxHeight.toFloat()))
-          else -> null
-        }
-      }
-
-      2 -> {
-        when (state) {
-          BottomSheetBehavior.STATE_COLLAPSED -> SizeInfo(0, Utils.toDIP(behavior.peekHeight.toFloat()))
-          BottomSheetBehavior.STATE_EXPANDED -> SizeInfo(1, Utils.toDIP(behavior.maxHeight.toFloat()))
-          else -> null
-        }
-      }
-
-      3 -> {
-        when (state) {
-          BottomSheetBehavior.STATE_COLLAPSED -> SizeInfo(0, Utils.toDIP(behavior.peekHeight.toFloat()))
-
-          BottomSheetBehavior.STATE_HALF_EXPANDED -> {
-            val height = behavior.halfExpandedRatio * maxScreenHeight
-            SizeInfo(1, Utils.toDIP(height))
-          }
-
-          BottomSheetBehavior.STATE_EXPANDED -> SizeInfo(2, Utils.toDIP(behavior.maxHeight.toFloat()))
-
-          else -> null
-        }
-      }
-
-      else -> null
-    }
-
-  /**
-   * Get SizeInfo data for given size index.
-   */
-  fun getSizeInfoForIndex(index: Int) = getSizeInfoForState(getStateForSizeIndex(index)) ?: SizeInfo(0, 0f)
-
-  companion object {
-    const val TAG = "TrueSheetView"
-  }
-}

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

@@ -1,22 +0,0 @@
-package com.lodev09.truesheet
-
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.uimanager.events.Event
-
-class TrueSheetEvent(surfaceId: Int, viewId: Int, private val name: String, private val data: WritableMap?) :
-  Event<TrueSheetEvent>(surfaceId, viewId) {
-  override fun getEventName() = name
-  override fun getEventData(): WritableMap = data ?: Arguments.createMap()
-
-  companion object {
-    const val MOUNT = "topMount"
-    const val PRESENT = "topPresent"
-    const val DISMISS = "topDismiss"
-    const val SIZE_CHANGE = "topSizeChange"
-    const val DRAG_BEGIN = "topDragBegin"
-    const val DRAG_CHANGE = "topDragChange"
-    const val DRAG_END = "topDragEnd"
-    const val CONTAINER_SIZE_CHANGE = "topContainerSizeChange"
-  }
-}

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

@@ -1,63 +0,0 @@
-package com.lodev09.truesheet
-
-import android.util.Log
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.UiThreadUtil
-import com.facebook.react.module.annotations.ReactModule
-import com.facebook.react.uimanager.UIManagerHelper
-import com.lodev09.truesheet.core.Utils
-
-@ReactModule(name = TrueSheetViewModule.TAG)
-class TrueSheetViewModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
-  override fun getName(): String = TAG
-
-  private fun withTrueSheetView(tag: Int, closure: (trueSheetView: TrueSheetView) -> Unit) {
-    UiThreadUtil.runOnUiThread {
-      try {
-        val manager = UIManagerHelper.getUIManagerForReactTag(reactApplicationContext, tag)
-        val view = manager?.resolveView(tag)
-        if (view == null) {
-          Log.d(TAG, "Tag $tag not found")
-          return@runOnUiThread
-        }
-
-        if (view is TrueSheetView) {
-          closure(view)
-        } else {
-          Log.d(TAG, "Tag $tag does not match")
-        }
-      } catch (e: Exception) {
-        e.printStackTrace()
-      }
-    }
-  }
-
-  @ReactMethod
-  fun present(tag: Int, index: Int, promise: Promise) {
-    withTrueSheetView(tag) {
-      it.present(index) {
-        Utils.withPromise(promise) {
-          return@withPromise null
-        }
-      }
-    }
-  }
-
-  @ReactMethod
-  fun dismiss(tag: Int, promise: Promise) {
-    withTrueSheetView(tag) {
-      it.dismiss {
-        Utils.withPromise(promise) {
-          return@withPromise null
-        }
-      }
-    }
-  }
-
-  companion object {
-    const val TAG = "TrueSheetView"
-  }
-}

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

@@ -1,58 +0,0 @@
-package com.lodev09.truesheet.core
-
-import android.content.Context
-import android.view.View
-import android.view.ViewTreeObserver.OnGlobalLayoutListener
-import android.view.inputmethod.InputMethodManager
-import com.facebook.react.bridge.ReactContext
-
-class KeyboardManager(reactContext: ReactContext) {
-  interface OnKeyboardChangeListener {
-    fun onKeyboardStateChange(isVisible: Boolean, visibleHeight: Int?)
-  }
-
-  private var contentView: View? = null
-  private var onGlobalLayoutListener: OnGlobalLayoutListener? = null
-  private var isKeyboardVisible = false
-
-  init {
-    val activity = reactContext.currentActivity
-    contentView = activity?.findViewById(android.R.id.content)
-  }
-
-  fun registerKeyboardListener(listener: OnKeyboardChangeListener?) {
-    contentView?.apply {
-      unregisterKeyboardListener()
-
-      onGlobalLayoutListener = object : OnGlobalLayoutListener {
-        private var previousHeight = 0
-
-        override fun onGlobalLayout() {
-          val heightDiff = rootView.height - height
-          if (heightDiff > Utils.toPixel(200.0)) {
-            // Will ask InputMethodManager.isAcceptingText() to detect if keyboard appeared or not.
-            val inputManager = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
-            if (height != previousHeight && inputManager.isAcceptingText()) {
-              listener?.onKeyboardStateChange(true, height)
-
-              previousHeight = height
-              isKeyboardVisible = true
-            }
-          } else if (isKeyboardVisible) {
-            listener?.onKeyboardStateChange(false, null)
-            previousHeight = 0
-            isKeyboardVisible = false
-          }
-        }
-      }
-
-      getViewTreeObserver().addOnGlobalLayoutListener(onGlobalLayoutListener)
-    }
-  }
-
-  fun unregisterKeyboardListener() {
-    onGlobalLayoutListener?.let {
-      contentView?.getViewTreeObserver()?.removeOnGlobalLayoutListener(onGlobalLayoutListener)
-    }
-  }
-}

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

@@ -1,102 +0,0 @@
-package com.lodev09.truesheet.core
-
-import android.annotation.SuppressLint
-import android.content.Context
-import android.view.MotionEvent
-import android.view.View
-import com.facebook.react.config.ReactFeatureFlags
-import com.facebook.react.uimanager.JSPointerDispatcher
-import com.facebook.react.uimanager.JSTouchDispatcher
-import com.facebook.react.uimanager.RootView
-import com.facebook.react.uimanager.ThemedReactContext
-import com.facebook.react.uimanager.events.EventDispatcher
-import com.facebook.react.views.view.ReactViewGroup
-
-/**
- * RootSheetView is the ViewGroup which contains all the children of a Modal. It gets all
- * child information forwarded from TrueSheetView and uses that to create children. It is
- * also responsible for acting as a RootView and handling touch events. It does this the same way
- * as ReactRootView.
- *
- *
- * To get layout to work properly, we need to layout all the elements within the Modal as if
- * they can fill the entire window. To do that, we need to explicitly set the styleWidth and
- * styleHeight on the LayoutShadowNode to be the window size. This is done through the
- * UIManagerModule, and will then cause the children to layout as if they can fill the window.
- */
-class RootSheetView(private val context: Context?) :
-  ReactViewGroup(context),
-  RootView {
-  private var viewWidth = 0
-  private var viewHeight = 0
-
-  private val jSTouchDispatcher = JSTouchDispatcher(this)
-  private var jSPointerDispatcher: JSPointerDispatcher? = null
-
-  var sizeChangeListener: ((w: Int, h: Int) -> Unit)? = null
-  var eventDispatcher: EventDispatcher? = null
-
-  private val reactContext: ThemedReactContext
-    get() = context as ThemedReactContext
-
-  init {
-    if (ReactFeatureFlags.dispatchPointerEvents) {
-      jSPointerDispatcher = JSPointerDispatcher(this)
-    }
-  }
-
-  override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
-    super.onSizeChanged(w, h, oldw, oldh)
-
-    viewWidth = w
-    viewHeight = h
-
-    sizeChangeListener?.let { it(viewWidth, viewHeight) }
-  }
-
-  override fun handleException(t: Throwable) {
-    reactContext.reactApplicationContext.handleException(RuntimeException(t))
-  }
-
-  override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
-    eventDispatcher?.let { eventDispatcher ->
-      jSTouchDispatcher.handleTouchEvent(event, eventDispatcher, reactContext)
-      jSPointerDispatcher?.handleMotionEvent(event, eventDispatcher, true)
-    }
-    return super.onInterceptTouchEvent(event)
-  }
-
-  @SuppressLint("ClickableViewAccessibility")
-  override fun onTouchEvent(event: MotionEvent): Boolean {
-    eventDispatcher?.let { eventDispatcher ->
-      jSTouchDispatcher.handleTouchEvent(event, eventDispatcher, reactContext)
-      jSPointerDispatcher?.handleMotionEvent(event, eventDispatcher, false)
-    }
-    super.onTouchEvent(event)
-    // In case when there is no children interested in handling touch event, we return true from
-    // the root view in order to receive subsequent events related to that gesture
-    return true
-  }
-
-  override fun onInterceptHoverEvent(event: MotionEvent): Boolean {
-    eventDispatcher?.let { jSPointerDispatcher?.handleMotionEvent(event, it, true) }
-    return super.onHoverEvent(event)
-  }
-
-  override fun onHoverEvent(event: MotionEvent): Boolean {
-    eventDispatcher?.let { jSPointerDispatcher?.handleMotionEvent(event, it, false) }
-    return super.onHoverEvent(event)
-  }
-
-  override fun onChildStartedNativeGesture(childView: View?, ev: MotionEvent) {
-    eventDispatcher?.let { eventDispatcher ->
-      jSTouchDispatcher.onChildStartedNativeGesture(ev, eventDispatcher)
-      jSPointerDispatcher?.onChildStartedNativeGesture(childView, ev, eventDispatcher)
-    }
-  }
-
-  override fun onChildEndedNativeGesture(childView: View, ev: MotionEvent) {
-    eventDispatcher?.let { jSTouchDispatcher.onChildEndedNativeGesture(ev, it) }
-    jSPointerDispatcher?.onChildEndedNativeGesture()
-  }
-}