react-native-unified-action-sheet 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -7,6 +7,59 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.0]
+
+### Changed (breaking)
+
+- **Results carry a reason.** `showActionSheetWithOptions()` resolves
+  `{ reason, buttonIndex }` instead of a bare index, and
+  `showPromptWithOptions()` resolves `{ reason, buttonIndex, text, password? }`
+  instead of `{ buttonIndex, text }` or `undefined`. `reason` is `'selected'`,
+  `'cancelled'` (the cancel button, a backdrop tap, back or a swipe down) or
+  `'dismissed'` (closed from code or by a JS reload). A dismissal used to
+  resolve `undefined`; it now resolves `{ reason: 'dismissed', buttonIndex:
+  undefined }`, and a dismissed prompt keeps the text that was in its field.
+  The result types are discriminated unions on `reason`.
+
+  ```ts
+  // before
+  const index = await showActionSheetWithOptions(options);
+  if (index === undefined) { /* dismissed */ }
+
+  // after
+  const { reason, buttonIndex } = await showActionSheetWithOptions(options);
+  if (reason === 'dismissed') { /* dismissed */ }
+  ```
+- **Prompt `onPress` receives an object.** It is called with
+  `{ text, password? }` instead of the text string:
+  `onPress: ({ text }) => rename(text)`.
+- The Jest mock resolves the same shapes, deriving `reason` as the real module
+  does; `setNextPromptResult` accepts an optional `password`.
+
+### Added
+
+- `preferred` on a button: the default action, emphasized. On iOS it is the
+  alert's `preferredAction`, drawn in UIKit's own style (a filled button from
+  iOS 26, bold text before), so the return key presses it in a prompt; in the
+  bottom sheet it is a semibold row; UIKit ignores it in the standard action
+  sheet. On Android the row is bold, and in a prompt the keyboard's done key
+  presses it.
+- `detents` for `presentationStyle: 'bottom'`: `'auto'`, `'medium'` and
+  `'large'`. The sheet opens at the first and can be dragged to the others.
+- Prompt `type`: `'plain-text'`, `'secure-text'` or `'login-password'`, as in
+  React Native's `Alert.prompt`. `'login-password'` adds a masked password
+  field (`passwordPlaceholder`), resolves `password`, and marks both fields
+  for iOS AutoFill and Android autofill. `secureTextEntry` still works, as
+  `type: 'secure-text'`.
+- `requiresText` on a prompt button keeps it disabled while a field is empty.
+- New exported types: `ActionSheetResultInterface`, `ActionSheetDetent`,
+  `CloseReason`, `CloseResultInterface` and `PromptValuesInterface`.
+
+### Fixed
+
+- iOS: alerts and prompts were never freed after closing. Each action's handler
+  held its presentation, which held the alert, which held the action.
+
 ## [0.3.0]
 
 ### Added
@@ -106,7 +159,8 @@ Initial release.
 - No `com.google.android.material` dependency, and no runtime dependencies —
   `react` and `react-native` are peers.
 
-[unreleased]: https://github.com/galikvalkin/react-native-unified-action-sheet/compare/v0.3.0...HEAD
+[unreleased]: https://github.com/galikvalkin/react-native-unified-action-sheet/compare/v0.4.0...HEAD
+[0.4.0]: https://github.com/galikvalkin/react-native-unified-action-sheet/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/galikvalkin/react-native-unified-action-sheet/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/galikvalkin/react-native-unified-action-sheet/compare/v0.1.1...v0.2.0
 [0.1.1]: https://github.com/galikvalkin/react-native-unified-action-sheet/compare/v0.1.0...v0.1.1

package/README.md

@@ -41,7 +41,7 @@ await showActionSheetWithOptions({
 });
 ```
 
-The call resolves with the tapped button's index, and that button's `onPress` runs. A backdrop tap or back resolves the `'cancel'` button. The promise never rejects. See [Behavior](docs/behavior.md).
+The call resolves `{ reason, buttonIndex }`, and the tapped button's `onPress` runs. `reason` is `'selected'`, `'cancelled'` (the cancel button, a backdrop tap, back or a swipe) or `'dismissed'` (closed from code). The promise never rejects. See [Behavior](docs/behavior.md).
 
 ### Presentation styles
 
@@ -62,16 +62,36 @@ const result = await showPromptWithOptions({
   placeholder: 'New name',
   defaultValue: 'Untitled',
   options: [
-    { label: 'Save', onPress: (text) => rename(text) },
+    { label: 'Save', preferred: true, onPress: ({ text }) => rename(text) },
+    { label: 'Cancel', style: 'cancel' },
+  ],
+});
+// { reason, buttonIndex, text }
+```
+
+`type: 'login-password'` adds a password field, and `requiresText: true` keeps a button disabled until the fields are filled:
+
+```ts
+await showPromptWithOptions({
+  title: 'Sign in',
+  type: 'login-password',
+  placeholder: 'Email',
+  passwordPlaceholder: 'Password',
+  options: [
+    {
+      label: 'Sign in',
+      preferred: true,
+      requiresText: true,
+      onPress: ({ text, password }) => signIn(text, password),
+    },
     { label: 'Cancel', style: 'cancel' },
   ],
 });
-// { buttonIndex, text }, or undefined after dismissActionSheet().
 ```
 
 ### Dismissing from code
 
-`dismissActionSheet()` closes the most recently opened sheet, and `dismissAllActionSheets()` closes every open one. Dismissed sheets resolve with `undefined`.
+`dismissActionSheet()` closes the most recently opened sheet, and `dismissAllActionSheets()` closes every open one. They resolve with `reason: 'dismissed'`.
 
 ## Documentation
 

package/android/src/main/java/com/unifiedactionsheet/ActionSheetOptions.kt

@@ -40,6 +40,24 @@ internal enum class AnchorAlignment {
   }
 }
 
+/// A bottom sheet's resting height: the content, half the screen, or the full
+/// height below the status bar.
+internal enum class Detent {
+  AUTO,
+  MEDIUM,
+  LARGE,
+  ;
+
+  companion object {
+    fun fromWire(value: String?): Detent? = when (value) {
+      "auto" -> AUTO
+      "medium" -> MEDIUM
+      "large" -> LARGE
+      else -> null
+    }
+  }
+}
+
 internal enum class ForcedAppearance {
   SYSTEM,
   LIGHT,
@@ -70,6 +88,10 @@ internal data class ActionSheetOptions(
   val presentationStyle: PresentationStyle,
   val anchorRect: Rect?,
   val anchorAlignment: AnchorAlignment,
+  /// Bold, as the default action. Only the first preferred button counts.
+  val preferredButtonIndex: Int? = null,
+  /// 'bottom' only, in the caller's order: the sheet opens at the first.
+  val detents: List<Detent> = emptyList(),
 ) {
   companion object {
     /// density converts the anchor rect: measureInWindow reports dp, while
@@ -111,9 +133,22 @@ internal data class ActionSheetOptions(
         presentationStyle = PresentationStyle.fromWire(optString(map, "presentationStyle")),
         anchorRect = optRect(map, "anchorRect", density),
         anchorAlignment = AnchorAlignment.fromWire(optString(map, "anchorAlignment")),
+        preferredButtonIndex = optInt(map, "preferredButtonIndex"),
+        detents = optDetents(map),
       )
     }
 
+    private fun optDetents(map: ReadableMap): List<Detent> {
+      val detents = mutableListOf<Detent>()
+      map.getArray("detents")?.let { array ->
+        for (index in 0 until array.size()) {
+          Detent.fromWire(array.getString(index))?.let(detents::add)
+        }
+      }
+
+      return detents.distinct()
+    }
+
     private fun optRect(map: ReadableMap, key: String, density: Float): Rect? {
       if (!map.hasKey(key) || map.isNull(key)) return null
       val rect = map.getMap(key) ?: return null

package/android/src/main/java/com/unifiedactionsheet/PromptOptions.kt

@@ -43,6 +43,23 @@ internal enum class PromptKeyboardType {
   }
 }
 
+/// As in React Native's Alert.prompt. LOGIN_PASSWORD adds a secure field below
+/// the first.
+internal enum class PromptType {
+  PLAIN_TEXT,
+  SECURE_TEXT,
+  LOGIN_PASSWORD,
+  ;
+
+  companion object {
+    fun fromWire(value: String?): PromptType = when (value) {
+      "secure-text" -> SECURE_TEXT
+      "login-password" -> LOGIN_PASSWORD
+      else -> PLAIN_TEXT
+    }
+  }
+}
+
 internal data class PromptOptions(
   val options: List<String>,
   val cancelButtonIndex: Int?,
@@ -50,10 +67,14 @@ internal data class PromptOptions(
   val disabledButtonIndices: Set<Int>,
   val title: String?,
   val message: String?,
+  val type: PromptType,
   val placeholder: String?,
+  val passwordPlaceholder: String?,
   val defaultValue: String?,
   val keyboardType: PromptKeyboardType,
-  val secureTextEntry: Boolean,
+  val preferredButtonIndex: Int?,
+  /// Buttons kept disabled while any field is empty.
+  val textRequiredButtonIndices: Set<Int>,
   val tintColor: String?,
   val cancelButtonTintColor: String?,
   val destructiveColor: String?,
@@ -79,6 +100,7 @@ internal data class PromptOptions(
     presentationStyle = PresentationStyle.CENTERED,
     anchorRect = null,
     anchorAlignment = AnchorAlignment.START,
+    preferredButtonIndex = preferredButtonIndex,
   )
 
   companion object {
@@ -97,10 +119,13 @@ internal data class PromptOptions(
         disabledButtonIndices = optIndices(map, "disabledButtonIndices"),
         title = optString(map, "title"),
         message = optString(map, "message"),
+        type = PromptType.fromWire(optString(map, "type")),
         placeholder = optString(map, "placeholder"),
+        passwordPlaceholder = optString(map, "passwordPlaceholder"),
         defaultValue = optString(map, "defaultValue"),
         keyboardType = PromptKeyboardType.fromWire(optString(map, "keyboardType")),
-        secureTextEntry = optBoolean(map, "secureTextEntry"),
+        preferredButtonIndex = optInt(map, "preferredButtonIndex"),
+        textRequiredButtonIndices = optIndices(map, "textRequiredButtonIndices"),
         tintColor = optString(map, "tintColor"),
         cancelButtonTintColor = optString(map, "cancelButtonTintColor"),
         destructiveColor = optString(map, "destructiveColor"),
@@ -123,9 +148,6 @@ internal data class PromptOptions(
     private fun optInt(map: ReadableMap, key: String): Int? =
       if (map.hasKey(key) && !map.isNull(key)) map.getInt(key) else null
 
-    private fun optBoolean(map: ReadableMap, key: String): Boolean =
-      map.hasKey(key) && !map.isNull(key) && map.getBoolean(key)
-
     private fun optString(map: ReadableMap, key: String): String? =
       if (map.hasKey(key) && !map.isNull(key)) map.getString(key) else null
   }

package/android/src/main/java/com/unifiedactionsheet/SheetContentBuilder.kt

@@ -2,15 +2,19 @@ package com.unifiedactionsheet
 
 import android.content.Context
 import android.graphics.Color
+import android.graphics.Typeface
+import android.os.Build
 import android.util.TypedValue
 import android.view.Gravity
 import android.view.View
+import android.view.ViewGroup
 import android.widget.Button
 import android.widget.EditText
 import android.widget.LinearLayout
 import android.widget.TextView
 import androidx.appcompat.content.res.AppCompatResources
 import androidx.appcompat.widget.AppCompatEditText
+import androidx.appcompat.widget.AppCompatTextView
 import androidx.core.graphics.ColorUtils
 import androidx.core.view.AccessibilityDelegateCompat
 import androidx.core.view.ViewCompat
@@ -19,6 +23,27 @@ import androidx.core.widget.NestedScrollView
 
 private const val DISABLED_TEXT_ALPHA = 97
 
+/// A button row. Knows its index and both of its colors, so a prompt can
+/// enable or disable it while the user types (requiresText).
+internal class OptionRow(
+  context: Context,
+  val index: Int,
+  private val enabledColor: Int,
+  private val disabledColor: Int,
+) : AppCompatTextView(context) {
+  fun setRowEnabled(enabled: Boolean) {
+    isEnabled = enabled
+    setTextColor(if (enabled) enabledColor else disabledColor)
+  }
+}
+
+/// Every OptionRow below this view, in layout order.
+internal fun View.optionRows(): List<OptionRow> = when (this) {
+  is OptionRow -> listOf(this)
+  is ViewGroup -> (0 until childCount).flatMap { getChildAt(it).optionRows() }
+  else -> emptyList()
+}
+
 internal fun buildContent(
   context: Context,
   options: ActionSheetOptions,
@@ -60,10 +85,12 @@ internal fun buildContent(
     optionRows.addView(
       buildOption(
         context = context,
+        index = index,
         label = label,
         color = if (isDestructive) parseColor(options.destructiveColor) ?: palette.error else optionColor,
         centered = centerLabels,
         enabled = index !in options.disabledButtonIndices,
+        bold = index == options.preferredButtonIndex,
         disabledColor = disabledColor,
         onPress = { onSelect(index) },
       ),
@@ -77,10 +104,12 @@ internal fun buildContent(
         optionRows.addView(
           buildOption(
             context = context,
+            index = cancelIdx,
             label = options.options[cancelIdx],
             color = cancelColor,
             centered = centerLabels,
             enabled = cancelIdx !in options.disabledButtonIndices,
+            bold = cancelIdx == options.preferredButtonIndex,
             disabledColor = disabledColor,
             onPress = { onSelect(cancelIdx) },
           ),
@@ -102,13 +131,45 @@ internal fun buildContent(
   return container
 }
 
-internal fun buildPromptInput(
+/// The prompt's field, or for LOGIN_PASSWORD its login and password fields.
+internal fun buildPromptFields(
   context: Context,
   options: PromptOptions,
   palette: SheetPalette,
+): List<EditText> {
+  val first = buildPromptField(
+    context = context,
+    palette = palette,
+    hint = options.placeholder,
+    inputType = options.keyboardType.toInputType(options.type == PromptType.SECURE_TEXT),
+    autofillHint = if (options.type == PromptType.LOGIN_PASSWORD) View.AUTOFILL_HINT_USERNAME else null,
+  ).apply {
+    setText(options.defaultValue.orEmpty())
+    // Land the caret after any default value rather than before it.
+    setSelection(text?.length ?: 0)
+  }
+
+  if (options.type != PromptType.LOGIN_PASSWORD) return listOf(first)
+
+  val password = buildPromptField(
+    context = context,
+    palette = palette,
+    hint = options.passwordPlaceholder,
+    inputType = PromptKeyboardType.DEFAULT.toInputType(secure = true),
+    autofillHint = View.AUTOFILL_HINT_PASSWORD,
+  )
+
+  return listOf(first, password)
+}
+
+private fun buildPromptField(
+  context: Context,
+  palette: SheetPalette,
+  hint: String?,
+  inputType: Int,
+  autofillHint: String?,
 ): EditText = AppCompatEditText(context).apply {
-  setText(options.defaultValue.orEmpty())
-  hint = options.placeholder
+  this.hint = hint
   setTextSize(TypedValue.COMPLEX_UNIT_SP, 16f)
   setTextColor(palette.primaryText)
   setHintTextColor(ColorUtils.setAlphaComponent(palette.secondaryText, DISABLED_TEXT_ALPHA))
@@ -118,9 +179,11 @@ internal fun buildPromptInput(
   // SingleLineTransformationMethod, which replaces the password masking that
   // setInputType() sets up. Ordering them the other way renders a secure field
   // in plain text while still reporting a password input type.
-  inputType = options.keyboardType.toInputType(options.secureTextEntry)
-  // Land the caret after any default value rather than before it.
-  setSelection(text?.length ?: 0)
+  this.inputType = inputType
+  // Lets the autofill service offer saved credentials, like iOS AutoFill.
+  if (autofillHint != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+    setAutofillHints(autofillHint)
+  }
   layoutParams = LinearLayout.LayoutParams(
     LinearLayout.LayoutParams.MATCH_PARENT,
     LinearLayout.LayoutParams.WRAP_CONTENT,
@@ -146,22 +209,25 @@ private fun buildHeader(
 
 private fun buildOption(
   context: Context,
+  index: Int,
   label: String,
   color: Int,
   centered: Boolean,
   enabled: Boolean,
+  bold: Boolean,
   disabledColor: Int,
   onPress: () -> Unit,
-): View = TextView(context).apply {
+): View = OptionRow(context, index, color, disabledColor).apply {
   text = label
   gravity = if (centered) Gravity.CENTER_HORIZONTAL else Gravity.START
   setPadding(dp(context, 16), dp(context, 16), dp(context, 16), dp(context, 16))
   setTextSize(TypedValue.COMPLEX_UNIT_SP, 16f)
-  setTextColor(if (enabled) color else disabledColor)
+  // The preferred button: bold, as iOS shows an alert's preferred action.
+  if (bold) setTypeface(typeface, Typeface.BOLD)
   background = AppCompatResources.getDrawable(context, selectableItemBackgroundRes(context))
   isClickable = true
   isFocusable = true
-  isEnabled = enabled
+  setRowEnabled(enabled)
   setOnClickListener { onPress() }
   contentDescription = label
   ViewCompat.setAccessibilityDelegate(

package/android/src/main/java/com/unifiedactionsheet/SheetPresenters.kt

@@ -7,12 +7,16 @@ import android.graphics.Color
 import android.graphics.Rect
 import android.graphics.drawable.ColorDrawable
 import android.graphics.drawable.GradientDrawable
+import android.text.Editable
+import android.text.TextWatcher
 import android.view.Gravity
 import android.view.View
 import android.view.View.MeasureSpec
 import android.view.Window
 import android.view.WindowManager
+import android.view.inputmethod.EditorInfo
 import android.widget.FrameLayout
+import android.widget.LinearLayout
 import androidx.appcompat.app.AppCompatDialog
 import androidx.core.graphics.Insets
 import androidx.core.view.ViewCompat
@@ -83,29 +87,76 @@ internal object CenteredDialogPresenter : SheetPresenter {
   }
 }
 
-/// The centered dialog with a text field above the buttons. Deliberately not a
-/// SheetPresenter: it takes PromptOptions and hands the field's text back with
-/// the index, which the sheet interface has no place for.
+/// What the prompt's fields held. password is empty unless LOGIN_PASSWORD.
+internal data class PromptValues(val text: String, val password: String)
+
+/// The centered dialog with text fields above the buttons. Deliberately not a
+/// SheetPresenter: it takes PromptOptions and hands the fields back with the
+/// index, which the sheet interface has no place for.
 internal fun buildPromptDialog(
   activity: Activity,
   options: PromptOptions,
-  onSelect: (Dialog, Int, String) -> Unit,
-): Pair<Dialog, () -> String> {
+  onSelect: (Dialog, Int, PromptValues) -> Unit,
+): Pair<Dialog, () -> PromptValues> {
   val isDark = isDarkAppearance(activity, options.userInterfaceStyle)
   val palette = paletteFor(isDark)
   val dialog = AppCompatDialog(activity, dialogTheme(isDark))
   dialog.supportRequestWindowFeature(Window.FEATURE_NO_TITLE)
 
   val context: Context = dialog.context
-  val input = buildPromptInput(context, options, palette)
-  val currentText = { input.text?.toString().orEmpty() }
+  val fields = buildPromptFields(context, options, palette)
+  val input = fields.singleOrNull() ?: LinearLayout(context).apply {
+    orientation = LinearLayout.VERTICAL
+    fields.forEach(::addView)
+  }
+  val currentValues = {
+    PromptValues(
+      text = fields[0].text?.toString().orEmpty(),
+      password = fields.getOrNull(1)?.text?.toString().orEmpty(),
+    )
+  }
 
   val container = buildContent(
     context = context,
     options = options.toSheetOptions(),
     palette = palette,
     inputView = input,
-  ) { index -> onSelect(dialog, index, currentText()) }
+  ) { index -> onSelect(dialog, index, currentValues()) }
+
+  val rows = container.optionRows()
+
+  // requiresText: those buttons stay disabled while any field is empty.
+  if (options.textRequiredButtonIndices.isNotEmpty()) {
+    val update = {
+      val filled = fields.all { !it.text.isNullOrEmpty() }
+      rows.filter { it.index in options.textRequiredButtonIndices }.forEach { row ->
+        row.setRowEnabled(filled && row.index !in options.disabledButtonIndices)
+      }
+    }
+    val watcher = object : TextWatcher {
+      override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) = Unit
+      override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) = Unit
+      override fun afterTextChanged(s: Editable?) = update()
+    }
+    fields.forEach { it.addTextChangedListener(watcher) }
+    // A defaultValue may already satisfy it.
+    update()
+  }
+
+  // The keyboard's action key moves to the next field, then presses the
+  // preferred button, as the return key does in an iOS alert.
+  fields.forEachIndexed { index, field ->
+    field.imeOptions = if (index == fields.lastIndex) EditorInfo.IME_ACTION_DONE else EditorInfo.IME_ACTION_NEXT
+  }
+  val preferredRow = rows.firstOrNull { it.index == options.preferredButtonIndex }
+  if (preferredRow != null) {
+    fields.last().setOnEditorActionListener { _, actionId, _ ->
+      if (actionId != EditorInfo.IME_ACTION_DONE || !preferredRow.isEnabled) return@setOnEditorActionListener false
+
+      preferredRow.performClick()
+      true
+    }
+  }
 
   dialog.setContentView(container)
   dialog.setCanceledOnTouchOutside(true)
@@ -127,9 +178,9 @@ internal fun buildPromptDialog(
   // A prompt exists to be typed into, so raise the keyboard with it rather than
   // making the user tap the field first.
   dialog.window?.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE)
-  input.requestFocus()
+  fields[0].requestFocus()
 
-  return dialog to currentText
+  return dialog to currentValues
 }
 
 private const val PROMPT_CORNER_RADIUS_DP = 28

package/android/src/main/java/com/unifiedactionsheet/UnifiedActionSheetModule.kt

@@ -147,32 +147,33 @@ class UnifiedActionSheetModule(reactContext: ReactApplicationContext) :
     promise: Promise,
   ) {
     val resolved = AtomicBoolean(false)
-    val resolveOnce: (Int?, String) -> Unit = { index, text ->
+    val resolveOnce: (Int?, PromptValues) -> Unit = { index, values ->
       if (resolved.compareAndSet(false, true)) {
         promise.resolve(
           Arguments.createMap().apply {
             putInt("buttonIndex", index ?: -1)
-            putString("text", text)
+            putString("text", values.text)
+            putString("password", values.password)
           },
         )
       }
     }
 
-    val (dialog, currentText) = buildPromptDialog(activity, options) { presented, index, text ->
+    val (dialog, currentValues) = buildPromptDialog(activity, options) { presented, index, values ->
       presented.dismiss()
-      resolveOnce(index, text)
+      resolveOnce(index, values)
     }
     openDialogs.add(dialog)
 
     // Read the field at dismissal time: what the user typed survives a backdrop
     // tap, so a caller can still recover a draft.
-    dialog.setOnCancelListener { resolveOnce(options.cancelButtonIndex, currentText()) }
+    dialog.setOnCancelListener { resolveOnce(options.cancelButtonIndex, currentValues()) }
     dialog.setOnDismissListener {
       openDialogs.remove(dialog)
       if (dismissedByApi.remove(dialog)) {
-        resolveOnce(DISMISSED_BY_API, currentText())
+        resolveOnce(DISMISSED_BY_API, currentValues())
       } else {
-        resolveOnce(options.cancelButtonIndex, currentText())
+        resolveOnce(options.cancelButtonIndex, currentValues())
       }
     }
 

package/android/src/material/java/com/unifiedactionsheet/MaterialBottomSheetPresenter.kt

@@ -4,10 +4,12 @@ import android.app.Activity
 import android.app.Dialog
 import android.content.res.ColorStateList
 import android.view.View
+import android.view.View.MeasureSpec
 import android.widget.LinearLayout
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
+import com.google.android.material.bottomsheet.BottomSheetBehavior
 import com.google.android.material.bottomsheet.BottomSheetDialog
 import com.google.android.material.bottomsheet.BottomSheetDragHandleView
 import com.google.android.material.R as MaterialR
@@ -72,16 +74,77 @@ internal object MaterialBottomSheetPresenter : SheetPresenter {
     // expand behind the status bar, so cap the sheet just below it (and any
     // display cutout); the rows scroll inside it instead.
     val decor = activity.window.decorView
-    val topInset = ViewCompat.getRootWindowInsets(decor)
+    val insets = ViewCompat.getRootWindowInsets(decor)
+    val topInset = insets
       ?.getInsets(WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout())
       ?.top ?: 0
+    val bottomInset = insets?.getInsets(WindowInsetsCompat.Type.navigationBars())?.bottom ?: 0
     if (decor.height > topInset) {
-      dialog.behavior.maxHeight = decor.height - topInset
+      val maxHeight = decor.height - topInset
+      dialog.behavior.maxHeight = maxHeight
+      applyDetents(dialog, root, options.detents, decor, maxHeight, bottomInset)
     }
 
     return dialog
   }
 
+  /// The caller's detents, mapped onto Material's states. Each one becomes a
+  /// height: 'auto' the content (plus the navigation bar the sheet now draws
+  /// behind), 'medium' half the screen, 'large' everything below the status
+  /// bar. The sheet is as tall as the tallest; with two heights the lower one
+  /// is the collapsed state, and a third in between is the half-expanded one.
+  /// It opens at the first detent listed. None listed keeps Material's own
+  /// behavior: a short list fits, a long one peeks and expands.
+  private fun applyDetents(
+    dialog: BottomSheetDialog,
+    root: View,
+    detents: List<Detent>,
+    decor: View,
+    maxHeight: Int,
+    bottomInset: Int,
+  ) {
+    if (detents.isEmpty()) return
+    val sheet = dialog.findViewById<View>(MaterialR.id.design_bottom_sheet) ?: return
+
+    root.measure(
+      MeasureSpec.makeMeasureSpec(decor.width, MeasureSpec.EXACTLY),
+      MeasureSpec.makeMeasureSpec(maxHeight, MeasureSpec.AT_MOST),
+    )
+    val heightOf = detents.associateWith { detent ->
+      when (detent) {
+        Detent.AUTO -> (root.measuredHeight + bottomInset).coerceAtMost(maxHeight)
+        Detent.MEDIUM -> (decor.height / 2).coerceAtMost(maxHeight)
+        Detent.LARGE -> maxHeight
+      }
+    }
+    // Equal heights are one resting point, e.g. 'auto' for a list that fills
+    // the screen and 'large'.
+    val heights = heightOf.values.distinct().sorted()
+    val tallest = heights.last()
+    val behavior = dialog.behavior
+
+    sheet.layoutParams = sheet.layoutParams.apply { height = tallest }
+    // Only three resting points need Material's half-expanded state, which
+    // requires fitToContents off.
+    behavior.isFitToContents = heights.size < 3
+    behavior.skipCollapsed = heights.size == 1
+    if (heights.size > 1) {
+      // Material adds the navigation bar inset to the peek height itself.
+      behavior.peekHeight = heights.first() - bottomInset
+    }
+    if (heights.size == 3) {
+      behavior.halfExpandedRatio = heights[1].toFloat() / decor.height
+      behavior.expandedOffset = decor.height - tallest
+    }
+
+    val initial = heightOf.getValue(detents.first())
+    behavior.state = when {
+      initial == tallest -> BottomSheetBehavior.STATE_EXPANDED
+      heights.size == 3 && initial == heights[1] -> BottomSheetBehavior.STATE_HALF_EXPANDED
+      else -> BottomSheetBehavior.STATE_COLLAPSED
+    }
+  }
+
   private fun bottomSheetTheme(isDark: Boolean): Int = if (isDark) {
     R.style.UnifiedActionSheet_BottomSheetDialog_Dark
   } else {