CODEWITHSUNDEEP
compose-multiplatform
Roy Solberg
Roy Solberg

Reputation: 19783

How to get screen width and height in Compose Multiplatform?

How can I get the screen size in Compose Multiplatform without using expect/actual?

I have found the following explanation in https://github.com/JetBrains/compose-multiplatform/discussions/3225#discussioncomment-7195192:

You can also use a Layout as your root Composable and obtain the size from the passed constraints. This solution doesn't depend on platform implementations and also gives you the exact size given to your Composable which could be different from the device screen size in some cases.

Once you have that size can use a CompositionLocal to pass it down the composable tree

I have not been able to fully understand or successfully implement the suggested layout.

Upvotes: 13

Views: 4796

Answers (5)

Xembo
Xembo

Reputation: 11

How to Get Screen Width and Height in Compose Multiplatform (Android & iOS)

I found a solution that works consistently across both Android and iOS in a Compose Multiplatform project. Below is the exact same approach implemented for both platforms.

For Android:

We use LocalConfiguration to get the screen dimensions in dp and convert them to pixels using LocalDensity.

@Composable
actual fun getScreenHeight(): Float {
    val configuration = LocalConfiguration.current
    return with(LocalDensity.current) { configuration.screenHeightDp.dp.toPx() }
}

@Composable
actual fun getScreenWidth(): Float {
    val configuration = LocalConfiguration.current
    return with(LocalDensity.current) { configuration.screenWidthDp.dp.toPx() }
}


for Ios 

@OptIn(ExperimentalComposeUiApi::class)
@Composable
actual fun getScreenWidth(): Float = with(LocalDensity.current) { 
    LocalWindowInfo.current.containerSize.width.toDp().toPx() 
}

@OptIn(ExperimentalComposeUiApi::class)
@Composable
actual fun getScreenHeight(): Float = with(LocalDensity.current) { 
    LocalWindowInfo.current.containerSize.height.toDp().toPx() 
}

Upvotes: 1

Athar Gul
Athar Gul

Reputation: 11

I would go for the following approach

in the common code

data class ScreenSize(
  val width:Dp,
  val height:Dp,
)

@Composable
expect fun getScreenSize(): ScreenSize


val ScreenSizeValue: ScreenSize
@Composable
get() = getScreenSize()

in androidMain

@Composable
actual fun getScreenSize() = ScreenSize(
    width = LocalConfiguration.current.screenWidthDp.dp,
    height = LocalConfiguration.current.screenHeightDp.dp
)

in IosMain

@Composable
actual fun getScreenSize() = remember {
    val screen = UIScreen.mainScreen
    ScreenSize(
        width = CGRectGetWidth(screen.bounds).dp,
        height = CGRectGetHeight(screen.bounds).dp
    )
}

now in common:

val screenSize = ScreenSizeValue
// or
val screenSize = getScreenSize()

Upvotes: 0

Areeb Momin
Areeb Momin

Reputation: 477

This implementation worked for me:

In commonMain:

@Composable
expect fun getScreenWidth(): Dp

@Composable
expect fun getScreenHeight(): Dp

In androidMain:

@Composable
actual fun getScreenWidth(): Dp = LocalConfiguration.current.screenWidthDp.dp

@Composable
actual fun getScreenHeight(): Dp = LocalConfiguration.current.screenHeightDp.dp

In iosMain:

@OptIn(ExperimentalComposeUiApi::class)
@Composable
actual fun getScreenWidth(): Dp = LocalWindowInfo.current.containerSize.width.pxToPoint().dp

@OptIn(ExperimentalComposeUiApi::class)
@Composable
actual fun getScreenHeight(): Dp = LocalWindowInfo.current.containerSize.height.pxToPoint().dp

fun Int.pxToPoint(): Double = this.toDouble() / UIScreen.mainScreen.scale

Upvotes: 7

Jakub Kostka
Jakub Kostka

Reputation: 905

Starting with Multiplatform Compose version 1.5.10-beta01 (https://github.com/JetBrains/compose-multiplatform/releases/tag/v1.5.10-beta01) you can use LocalWindowInfo.current.containerSize for non-android targets.

Android has the usual LocalConfiguration.current, so you can use that there.

Upvotes: 7

Roy Solberg
Roy Solberg

Reputation: 19783

I got the answer at https://github.com/JetBrains/compose-multiplatform/discussions/3225#discussioncomment-7386013 🙌

Using that I've created a small example that might be helpful for others looking for the answer:

import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.layout.Layout

@Composable
fun App() {
    val screenSize = remember { mutableStateOf(Pair(-1, -1)) }
    Layout(
        content = {
            Box(modifier = Modifier.fillMaxSize()) {
                Text("Screen size: ${screenSize.value.first}x${screenSize.value.second}px", modifier = Modifier.align(Alignment.Center))
            }
        },
        measurePolicy = { measurables, constraints ->
            // Use the max width and height from the constraints
            val width = constraints.maxWidth
            val height = constraints.maxHeight

            screenSize.value = Pair(width, height)
            println("Width: $width, height: $height")

            // Measure and place children composables
            val placeables = measurables.map { measurable ->
                measurable.measure(constraints)
            }

            layout(width, height) {
                var yPosition = 0
                placeables.forEach { placeable ->
                    placeable.placeRelative(x = 0, y = yPosition)
                    yPosition += placeable.height
                }
            }
        }
    )
}

Here's a screenshot of the code running on macOS, iOS simulator and Android emulator: enter image description here

Upvotes: 7

Related Questions