Jetpack WindowManager: What It Is, Library for Foldable Devices

What is Jetpack WindowManager?

Jetpack WindowManager is a library from the AndroidX suite that abstracts working with windows and screen configurations on Android devices. It solves the problem of screen fragmentation: from compact phones to foldable devices and tablets with desktop mode.

Before WindowManager, developers used the outdated Display API and Resources#getConfiguration, which did not account for foldable devices and multi-window modes. WindowManager provides a unified API for all scenarios: one library covers FoldingFeature, WindowMetrics, WindowSizeClass and ScreenContinuity. This reduces boilerplate code and eliminates bugs when adapting interfaces for different devices.

According to Google I/O 2024, Jetpack WindowManager stable version 1.3 includes support for hinge sensors, an API for determining the opening angle and improved integration with Jetpack Compose. The library is backward compatible down to Android 10 (API 29) through Support Library and automatically adapts to device capabilities.

FoldingFeature: Working with the Device Fold

FoldingFeature is the central class of Jetpack WindowManager for working with foldable devices. It encapsulates all information about the physical position of the fold: state (HALF_OPENED, FLAT, TABLE_TOP), orientation (VERTICAL, HORIZONTAL), hinge coordinates and opening angle in degrees.

FoldingFeature States

The library defines four fold states. STATE_FLAT — the device is fully unfolded, the screen is flat. STATE_HALF_OPENED — the device is partially folded, the screen is at an angle of 30 to 160 degrees. STATE_TABLE_TOP — the device is standing on a surface in laptop posture. STATE_FULLY_OPENED — a deprecated state, replaced by FLAT in version 1.2.

Fold Orientation and Coordinates

The fold can be vertical (VERTICAL_FOLD) or horizontal (HORIZONTAL_FOLD). Bounds is a rectangle describing the fold area in application window coordinates. The developer uses this data to place UI elements above and below the fold, avoiding content overlap with the critical area.

val windowManager = WindowManager(context)
val flow = windowManager.foldingFeature()

flow.collect { feature: FoldingFeature ->
    when (feature.state) {
        FoldingFeature.State.FLAT -> showFullScreen(feature.bounds)
        FoldingFeature.State.HALF_OPENED -> splitContentAcrossFold(feature.bounds)
        FoldingFeature.State.TABLE_TOP -> enableTouchpadMode()
    }
}

WindowMetrics and WindowSizeClass

WindowMetrics is an API for getting precise application window dimensions, available since WindowManager 1.0. Unlike Display#getSize, WindowMetrics accounts for multi-window mode, DeX and free-form window. The metrics return currentWindowMetrics (current size) and maximumWindowMetrics (maximum possible size on the device).

WindowSizeClass is a classifier that appeared in WindowManager 1.1. It divides screens into three categories: Compact (width less than 600dp — phone), Medium (600–840dp — tablet in portrait orientation) and Expanded (over 840dp — tablet in landscape). This class simplifies adaptive layout by replacing dozens of size checks with a single classification.

class MyComposable {
    @Composable
    fun AdaptiveLayout(windowSizeClass: WindowSizeClass) {
        when (windowSizeClass.widthSizeClass) {
            WindowWidthSizeClass.Compact -> CompactScreen()
            WindowWidthSizeClass.Expanded -> ExpandedScreen()
            else -> MediumScreen()
        }
    }
}

ScreenContinuityController and Screen Continuity

ScreenContinuityController is a WindowManager component responsible for preserving Activity state when the foldable device configuration changes. When the user unfolds or folds the phone, the controller notifies the application about the new posture and provides mechanisms for smooth transition.

The controller registers listeners via registerContinuityListener, which takes a callback with a FoldingFeature object. On each posture change, the callback fires before Activity recreation, giving the developer an opportunity to save state manually. If the application uses ViewModel, no additional handling is required — data is saved automatically.

ScreenContinuity in Jetpack Compose

Compose applications benefit from ScreenContinuity through LocalWindowSizeClass and CompositionLocalProvider. Components automatically recompose when WindowMetrics change. rememberSaveable preserves state between recompositions, and Modifier.windowInsets accounts for system screen areas.

val controller = WindowManager(context).screenContinuityController
controller.registerContinuityListener { feature ->
    if (feature.state == FoldingFeature.State.FLAT) {
        logContinuityEvent("Device unfolded")
    }
}

Integration Examples in Kotlin

Let’s look at a complete example of an Activity using Jetpack WindowManager to adapt the interface for different foldable postures. WindowManagerActivity subscribes to FoldingFeature changes via the Flow API and switches between single-pane and dual-pane layouts.

class WindowManagerActivity : AppCompatActivity() {
    private lateinit var binding: ActivityWindowBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityWindowBinding.inflate(layoutInflater)
        setContentView(binding.root)

        val windowManager = WindowManager(this)
        val metrics = windowManager.currentWindowMetrics

        if (metrics.bounds.width() > dpToPx(600)) {
            showDualPaneLayout()
        } else {
            showSinglePaneLayout()
        }
    }

    private fun showDualPaneLayout() {
        binding.content.layoutManager = GridLayoutManager(this, 2)
    }

    private fun showSinglePaneLayout() {
        binding.content.layoutManager = LinearLayoutManager(this)
    }
}

The example demonstrates a basic scenario: the application checks WindowMetrics and selects a single-pane or dual-pane layout. In real projects, it is recommended to use WindowSizeClass for more flexible adaptation and FoldingFeature for handling foldable devices. The library also supports seamless transition — smooth animation when switching between layouts.

Testing and Debugging WindowManager

Android Studio includes built-in tools for testing Jetpack WindowManager. The emulator supports foldable devices (Pixel Fold, Galaxy Z Fold) with posture switching via the Folding Postures tab. Layout Inspector shows current WindowMetrics and FoldingFeature boundaries in real time.

Debugging via ADB

The command adb shell dumpsys window displays outputs information about all connected displays and their configurations. To simulate a fold, use adb shell am broadcast -a android.intent.action.SCREEN_ON with additional posture parameters. WindowManager logs all FoldingFeature changes via WindowManager#logState.

Common Mistakes

The main integration issues — ignoring WindowMetrics updates in multi-window mode, incorrect handling of bounds with a vertical fold and lack of testing on all postures. It is recommended to test each posture separately and check behavior when switching between them. Using WindowSizeClass instead of manual size checks reduces bugs by 60%.