Android 12 Developer Preview is here! Try it out, and give us your feedback!

androidx.compose.ui

Interfaces

Alignment

Modifier

An ordered, immutable collection of modifier elements that decorate or add behavior to Compose UI elements.

Classes

BiasAbsoluteAlignment

An Alignment specified by bias: for example, a bias of -1 represents alignment to the left/top, a bias of 0 will represent centering, and a bias of 1 will represent right/bottom.

BiasAlignment

An Alignment specified by bias: for example, a bias of -1 represents alignment to the start/top, a bias of 0 will represent centering, and a bias of 1 will represent end/bottom.

CombinedModifier

A node in a Modifier chain.

Annotations

ExperimentalComposeUiApi

InternalComposeUiApi

Unstable API for use only between compose-ui modules sharing the same exact version, subject to change without notice in major, minor, or patch releases.

Top-level functions summary

Unit

An interface to calculate the position of a sized box inside an available space.

Extension functions summary

For Modifier
Modifier
Modifier.composed(inspectorInfo: InspectorInfo.() -> Unit = NoInspectorInfo, factory: Modifier.() -> Modifier)

Declare a just-in-time composition of a Modifier that will be composed for each element it modifies.

Modifier

Creates a modifier that controls the drawing order for the children of the same layout parent.

For Composer
Modifier

Materialize any instance-specific composed modifiers for applying to a raw tree node.

Top-level functions

<no name provided>

@Immutable fun <no name provided>(): Unit

An interface to calculate the position of a sized box inside an available space. Alignment is often used to define the alignment of a layout inside a parent layout.

Extension functions

composed

fun Modifier.composed(
    inspectorInfo: InspectorInfo.() -> Unit = NoInspectorInfo,
    factory: Modifier.() -> Modifier
): Modifier

Declare a just-in-time composition of a Modifier that will be composed for each element it modifies. composed may be used to implement stateful modifiers that have instance-specific state for each modified element, allowing the same Modifier instance to be safely reused for multiple elements while maintaining element-specific state.

If inspectorInfo is specified this modifier will be visible to tools during development. Specify the name and arguments of the original modifier.

Example usage:

import androidx.compose.ui.composed
import androidx.compose.ui.platform.debugInspectorInfo

// let's create you own custom stateful modifier
fun Modifier.myColorModifier(color: Color) = composed(
    // pass inspector information for debug
    inspectorInfo = debugInspectorInfo {
        // name should match the name of the modifier
        name = "myColorModifier"
        // specify a single argument as the value when the argument name is irrelevant
        value = color
    },
    // pass your modifier implementation that resolved per modified element
    factory = {
        // add your modifier implementation here
        Modifier
    }
)
import androidx.compose.ui.composed
import androidx.compose.ui.platform.debugInspectorInfo

// let's create you own custom stateful modifier with multiple arguments
fun Modifier.myModifier(width: Dp, height: Dp, color: Color) = composed(
    // pass inspector information for debug
    inspectorInfo = debugInspectorInfo {
        // name should match the name of the modifier
        name = "myModifier"
        // add name and value of each argument
        properties["width"] = width
        properties["height"] = height
        properties["color"] = color
    },
    // pass your modifier implementation that resolved per modified element
    factory = {
        // add your modifier implementation here
        Modifier
    }
)
materialize must be called to create instance-specific modifiers if you are directlyapplying a Modifier to an element tree node.

materialize

fun Composer.materialize(modifier: Modifier): Modifier

Materialize any instance-specific composed modifiers for applying to a raw tree node. Call right before setting the returned modifier on an emitted node. You almost certainly do not need to call this function directly.

zIndex

@Stable fun Modifier.zIndex(zIndex: Float): Modifier

Creates a modifier that controls the drawing order for the children of the same layout parent. A child with larger zIndex will be drawn on top of all the children with smaller zIndex. When children have the same zIndex the original order in which the parent placed the children is used.

Note that if there would be multiple zIndex modifiers applied for the same layout the sum of their values will be used as the final zIndex. If no zIndex were applied for the layout then the default zIndex is 0.

import androidx.compose.foundation.layout.Box
import androidx.compose.material.Text
import androidx.compose.ui.zIndex

Box {
    Text("Drawn second", Modifier.zIndex(1f))
    Text("Drawn first")
}