Window width is limited

[ElliotAl86]

Hi!
I've noticed some strange behavior. Maybe it's a bug, or maybe I'm missing something.
For some reason, the window width gets limited to about 3/4 of the display width.
For a simple repro, I took the service-hilt module from the library and replaced FloatingScreen.kt with this:

package io.github.arthurkun.service.hilt.ui.floating

import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.size
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import com.github.only52607.compose.service.dragServiceFloatingWindow
import io.github.arthurkun.service.hilt.ui.theme.ComposeFloatingWindowTheme

@Composable
fun FloatingScreen(
    vm: FloatingViewModel = viewModel(),
) {
    ComposeFloatingWindowTheme(darkTheme = false) {
        Box(
            modifier = Modifier
                .size(500.dp)
                .background(color = Color.Blue)
                .dragServiceFloatingWindow() // this doesn't seem to affect
        )
    }
}

As a result, I get this:

The width is limited, but the height isn't.
I checked this on several devices, and it doesn't seem to depend on the API level or the device manufacturer.

[ElliotAl86]

I played around with ChatGPT for a while (I asked to compare it with EasyWindow since that library doesn't have this issue) and got this fix. Tried it out and it actually works, solves the problem. Not sure if it's the proper fix though, or if it'll mess up something else.

ChatGPT answer

Problem

When using TYPE_APPLICATION_OVERLAY with WindowManager.LayoutParams.WRAP_CONTENT, the window may receive an artificially constrained MeasureSpec from the system during layout.

As a result, content wider than the imposed limit can be clipped even when it explicitly requests a larger size (for example, Modifier.size(500.dp) in Compose).

The issue is not that WRAP_CONTENT itself is incorrect. In fact, preserving WRAP_CONTENT is desirable because it allows the overlay window to dynamically resize based on its content.

Changing the window to MATCH_PARENT or forcing a fixed width only hides the symptom and breaks the intended dynamic sizing behavior.

---

Root Cause

For overlay windows (TYPE_APPLICATION_OVERLAY), Android may propagate constrained measurement bounds to the root view hierarchy when the window dimensions are configured as WRAP_CONTENT.

Those constraints are delivered through the root MeasureSpec, causing the content tree to measure against a smaller maximum size than the actual available display area.

Because Compose relies on the Android view measurement pipeline, the restriction propagates into ComposeView, resulting in content being measured and laid out smaller than intended.

The key insight is that the problem originates at the root container measurement stage, not in Compose itself and not in the window creation logic.

---

Solution

Override onMeasure() in FloatingWindowDecorView and replace the constrained MeasureSpec only when the corresponding window dimension is configured as WRAP_CONTENT.

---

Proposed Fix

private class FloatingWindowDecorView(
    context: Context,
    private val onWindowSizeChanged: () -> Unit,
) : FrameLayout(context) {

    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
        val lp = layoutParams as? WindowManager.LayoutParams

        val adjustedWidthMeasureSpec =
            if (lp?.width == WindowManager.LayoutParams.WRAP_CONTENT) {
                MeasureSpec.makeMeasureSpec(
                    maxAvailableWidth(),
                    MeasureSpec.AT_MOST
                )
            } else {
                widthMeasureSpec
            }

        val adjustedHeightMeasureSpec =
            if (lp?.height == WindowManager.LayoutParams.WRAP_CONTENT) {
                MeasureSpec.makeMeasureSpec(
                    maxAvailableHeight(),
                    MeasureSpec.AT_MOST
                )
            } else {
                heightMeasureSpec
            }

        super.onMeasure(
            adjustedWidthMeasureSpec,
            adjustedHeightMeasureSpec
        )
    }

    override fun onSizeChanged(
        width: Int,
        height: Int,
        oldWidth: Int,
        oldHeight: Int
    ) {
        super.onSizeChanged(width, height, oldWidth, oldHeight)

        if (width != oldWidth || height != oldHeight) {
            onWindowSizeChanged()
        }
    }

    private fun maxAvailableWidth(): Int {
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
            val wm = context.getSystemService(WindowManager::class.java)
            wm.currentWindowMetrics.bounds.width()
        } else {
            @Suppress("DEPRECATION")
            context.resources.displayMetrics.widthPixels
        }
    }

    private fun maxAvailableHeight(): Int {
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
            val wm = context.getSystemService(WindowManager::class.java)
            wm.currentWindowMetrics.bounds.height()
        } else {
            @Suppress("DEPRECATION")
            context.resources.displayMetrics.heightPixels
        }
    }
}

---

Notes

A comment should be added above onMeasure() to explain why the override exists:

// Overlay windows configured with WRAP_CONTENT may receive
// artificially constrained MeasureSpecs from the system.
// Replace those constraints with the current window bounds so
// content can measure to its actual desired size.