@craft-native/android 0.0.162 → 0.0.163

package/README.md

@@ -137,6 +137,11 @@ their intrinsic width unless explicitly configured.
 Wrapped containers also honor `alignContent` (`center`, `flex-end`,
 `space-between`, `space-around`, `space-evenly`, and `stretch`) consistently
 across hosts.
+The Android local fallback keeps fractional line and grid spacing until each
+child frame is rounded, matching the shared layout ABI when an older runtime
+does not expose its optional alignment symbols.
+Its flex main-axis fallback applies the same fractional treatment to
+`space-around` and `space-evenly` before rounding positions.
 Shared wrapped-line IDs are accepted only when they are complete and monotonic;
 invalid bridge data falls back to the host layout implementation.
 Push, replace, and back preserve the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craft-native/android",
-  "version": "0.0.162",
+  "version": "0.0.163",
   "homepage": "https://github.com/craft-native/craft/tree/main/packages/android#readme",
   "repository": {
     "type": "git",

package/templates/MainActivityNative.kt.template

@@ -791,28 +791,28 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
             } else {
                 val totalRows = layout.rowHeights.sum()
                 val rowGaps = max(0, layout.rowHeights.size - 1) * rowGap
-                val freeRows = max(0, contentHeight - totalRows - rowGaps)
+                val freeRows = max(0, contentHeight - totalRows - rowGaps).toFloat()
                 val rowCount = max(1, layout.rowHeights.size)
-                var rowLeading = 0
-                var rowBetween = rowGap
-                var rowExtra = 0
+                var rowLeading = 0f
+                var rowBetween = rowGap.toFloat()
+                var rowExtra = 0f
                 when (alignContentCode()) {
-                    1 -> rowLeading = freeRows / 2
+                    1 -> rowLeading = freeRows / 2f
                     2 -> rowLeading = freeRows
-                    3 -> if (rowCount > 1) rowBetween += freeRows / (rowCount - 1)
+                    3 -> if (rowCount > 1) rowBetween += freeRows / (rowCount - 1).toFloat()
                     4 -> {
-                        rowLeading = freeRows / (rowCount * 2)
-                        rowBetween += freeRows / rowCount
+                        rowLeading = freeRows / (rowCount * 2).toFloat()
+                        rowBetween += freeRows / rowCount.toFloat()
                     }
                     6 -> {
-                        rowLeading = freeRows / (rowCount + 1)
-                        rowBetween += freeRows / (rowCount + 1)
+                        rowLeading = freeRows / (rowCount + 1).toFloat()
+                        rowBetween += freeRows / (rowCount + 1).toFloat()
                     }
-                    5 -> rowExtra = freeRows / rowCount
+                    5 -> rowExtra = freeRows / rowCount.toFloat()
                 }
-                var rowTop = paddingTop + rowLeading
+                var rowTop = paddingTop.toFloat() + rowLeading
                 for ((rowIndex, row) in layout.rows.withIndex()) {
-                    val rowHeight = layout.rowHeights[rowIndex] + rowExtra
+                    val rowHeight = layout.rowHeights[rowIndex].toFloat() + rowExtra
                     for ((column, entry) in row.withIndex()) {
                         val align = entry.style.alignSelf ?: alignItems
                         val lp = entry.view.layoutParams as? MarginLayoutParams
@@ -821,7 +821,7 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                         val marginTop = lp?.topMargin ?: 0
                         val marginBottom = lp?.bottomMargin ?: 0
                         val availableWidth = max(0, layout.cellWidth - marginLeft - marginRight)
-                        val availableHeight = max(0, rowHeight - marginTop - marginBottom)
+                        val availableHeight = max(0, (rowHeight - marginTop - marginBottom).roundToInt())
                         val childWidth = if (align == "stretch" && entry.style.width == null) availableWidth else min(availableWidth, entry.width)
                         val childHeight = if (align == "stretch" && entry.style.height == null) availableHeight else min(availableHeight, entry.height)
                         val x = paddingLeft + column * (layout.cellWidth + columnGap) + marginLeft + when (align) {
@@ -829,11 +829,11 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                             "flex-end" -> availableWidth - childWidth
                             else -> 0
                         }
-                        val y = rowTop + marginTop + when (align) {
+                        val y = (rowTop + marginTop + when (align) {
                             "center" -> (availableHeight - childHeight) / 2
                             "flex-end" -> availableHeight - childHeight
                             else -> 0
-                        }
+                        }).roundToInt()
                         entry.view.layout(x, y, x + childWidth, y + childHeight)
                     }
                     rowTop += rowHeight + rowBetween
@@ -930,8 +930,7 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
             }
             val free = max(0, availableMain - distributedMain)
             val (leading, between) = distribution(free, line.entries.size)
-            var mainOffset = if (orientation == HORIZONTAL) paddingLeft else paddingTop
-            mainOffset += leading
+            var mainOffset = (if (orientation == HORIZONTAL) paddingLeft else paddingTop).toFloat() + leading
             for ((index, entry) in line.entries.withIndex()) {
                 val lp = entry.view.layoutParams as? MarginLayoutParams
                 val marginStart = if (orientation == HORIZONTAL) lp?.leftMargin ?: 0 else lp?.topMargin ?: 0
@@ -958,10 +957,10 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                 // local main-axis rule remains the fallback for old runtimes
                 // that return widths only.
                 val sharedPosition = if (!reverse) sharedPositions?.get(index)?.roundToInt() else null
-                val positionedMain = sharedPosition?.let { (if (orientation == HORIZONTAL) paddingLeft else paddingTop) + it }
+                val positionedMain = sharedPosition?.let { (if (orientation == HORIZONTAL) paddingLeft else paddingTop).toFloat() + it }
                     ?: mainOffset + marginStart
-                val x = if (orientation == HORIZONTAL) positionedMain else lineOffset + crossPosition
-                val y = if (orientation == HORIZONTAL) lineOffset + crossPosition else positionedMain
+                val x = if (orientation == HORIZONTAL) positionedMain.roundToInt() else lineOffset + crossPosition
+                val y = if (orientation == HORIZONTAL) lineOffset + crossPosition else positionedMain.roundToInt()
                 val distributedPrimary = sharedPrimary?.get(index)?.roundToInt() ?: fallbackWidths[index]
                 val w = if (orientation == HORIZONTAL) distributedPrimary else crossSize
                 val h = if (orientation == HORIZONTAL) crossSize else distributedPrimary
@@ -981,13 +980,16 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         onLayoutChanged?.invoke()
     }
 
-    private fun distribution(free: Int, count: Int): Pair<Int, Int> = when (justifyContent) {
-        "center" -> free / 2 to 0
-        "flex-end" -> free to 0
-        "space-between" -> 0 to if (count > 1) free / (count - 1) else 0
-        "space-around" -> free / (count * 2) to free / count
-        "space-evenly" -> free / (count + 1) to free / (count + 1)
-        else -> 0 to 0
+    private fun distribution(free: Int, count: Int): Pair<Float, Float> {
+        val available = free.toFloat()
+        return when (justifyContent) {
+            "center" -> available / 2f to 0f
+            "flex-end" -> available to 0f
+            "space-between" -> 0f to if (count > 1) available / (count - 1).toFloat() else 0f
+            "space-around" -> available / (count * 2).toFloat() to available / count.toFloat()
+            "space-evenly" -> available / (count + 1).toFloat() to available / (count + 1).toFloat()
+            else -> 0f to 0f
+        }
     }
 }