{% setvar book_path %}/reference/androidx/_book.yaml{% endsetvar %} {% include "_shared/_reference-head-tags.html" %}

MovableContentKt

public final class MovableContentKt


Summary

Public methods

static final @Composable @NonNull Function0<Unit>
movableContentOf(@Composable @NonNull Function0<Unit> content)

Convert a lambda into one that moves the remembered state and nodes created in a previous call to the new location it is called.

static final @Composable @NonNull Function1<@NonNull P, Unit>
<P extends Object> movableContentOf(
    @Composable @NonNull Function1<@NonNull P, Unit> content
)

Convert a lambda into one that moves the remembered state and nodes created in a previous call to the new location it is called.

static final @Composable @NonNull Function2<@NonNull P1, @NonNull P2, Unit>
<P1 extends Object, P2 extends Object> movableContentOf(
    @Composable @NonNull Function2<@NonNull P1, @NonNull P2, Unit> content
)

Convert a lambda into one that moves the remembered state and nodes created in a previous call to the new location it is called.

static final @Composable @NonNull Function3<@NonNull P1, @NonNull P2, @NonNull P3, Unit>
<P1 extends Object, P2 extends Object, P3 extends Object> movableContentOf(
    @Composable @NonNull Function3<@NonNull P1, @NonNull P2, @NonNull P3, Unit> content
)

Convert a lambda into one that moves the remembered state and nodes created in a previous call to the new location it is called.

static final @Composable @NonNull Function4<@NonNull P1, @NonNull P2, @NonNull P3, @NonNull P4, Unit>
<P1 extends Object, P2 extends Object, P3 extends Object, P4 extends Object> movableContentOf(
    @Composable @NonNull Function4<@NonNull P1, @NonNull P2, @NonNull P3, @NonNull P4, Unit> content
)

Convert a lambda into one that moves the remembered state and nodes created in a previous call to the new location it is called.

static final @Composable @ExtensionFunctionType @NonNull Function1<@NonNull R, Unit>
<R extends Object> movableContentWithReceiverOf(
    @Composable @ExtensionFunctionType @NonNull Function1<@NonNull R, Unit> content
)

Convert a lambda with a receiver into one that moves the remembered state and nodes created in a previous call to the new location it is called.

static final @Composable @ExtensionFunctionType @NonNull Function2<@NonNull R, @NonNull P, Unit>
<R extends Object, P extends Object> movableContentWithReceiverOf(
    @Composable @ExtensionFunctionType @NonNull Function2<@NonNull R, @NonNull P, Unit> content
)

Convert a lambda with a receiver into one that moves the remembered state and nodes created in a previous call to the new location it is called.

static final @Composable @ExtensionFunctionType @NonNull Function3<@NonNull R, @NonNull P1, @NonNull P2, Unit>
<R extends Object, P1 extends Object, P2 extends Object> movableContentWithReceiverOf(
    @Composable @ExtensionFunctionType @NonNull Function3<@NonNull R, @NonNull P1, @NonNull P2, Unit> content
)

Convert a lambda with a receiver into one that moves the remembered state and nodes created in a previous call to the new location it is called.

static final @Composable @ExtensionFunctionType @NonNull Function4<@NonNull R, @NonNull P1, @NonNull P2, @NonNull P3, Unit>
<R extends Object, P1 extends Object, P2 extends Object, P3 extends Object> movableContentWithReceiverOf(
    @Composable @ExtensionFunctionType @NonNull Function4<@NonNull R, @NonNull P1, @NonNull P2, @NonNull P3, Unit> content
)

Convert a lambda with a receiver into one that moves the remembered state and nodes created in a previous call to the new location it is called.

Public methods

movableContentOf

public static final @Composable @NonNull Function0<UnitmovableContentOf(@Composable @NonNull Function0<Unit> content)

Convert a lambda into one that moves the remembered state and nodes created in a previous call to the new location it is called.

Tracking compositions can be used to produce a composable that moves its content between a row and a column based on a parameter, such as,

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content as Any) { movableContentOf(content) }

if (vertical) {
    Column {
        movableContent()
    }
} else {
    Row {
        movableContent()
    }
}

Or they can be used to ensure the composition state tracks with a model as moves in the layout, such as,

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.Composable
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember {
    mutableMapOf<Item, @Composable () -> Unit>()
}
val movableItems =
    items.map { item -> itemMap.getOrPut(item) { movableContentOf { ItemView(item) } } }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}
Parameters
@Composable @NonNull Function0<Unit> content

The composable lambda to convert into a state tracking lambda.

Returns
@Composable @NonNull Function0<Unit>

A tracking composable lambda

movableContentOf

public static final @Composable @NonNull Function1<@NonNull P, Unit> <P extends Object> movableContentOf(
    @Composable @NonNull Function1<@NonNull P, Unit> content
)

Convert a lambda into one that moves the remembered state and nodes created in a previous call to the new location it is called.

Tracking compositions can be used to produce a composable that moves its content between a row and a column based on a parameter, such as,

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content as Any) { movableContentOf(content) }

if (vertical) {
    Column {
        movableContent()
    }
} else {
    Row {
        movableContent()
    }
}

Or they can be used to ensure the composition state tracks with a model as moves in the layout, such as,

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.Composable
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember {
    mutableMapOf<Item, @Composable () -> Unit>()
}
val movableItems =
    items.map { item -> itemMap.getOrPut(item) { movableContentOf { ItemView(item) } } }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}
Parameters
@Composable @NonNull Function1<@NonNull P, Unit> content

The composable lambda to convert into a state tracking lambda.

Returns
@Composable @NonNull Function1<@NonNull P, Unit>

A tracking composable lambda

movableContentOf

public static final @Composable @NonNull Function2<@NonNull P1, @NonNull P2, Unit> <P1 extends Object, P2 extends Object> movableContentOf(
    @Composable @NonNull Function2<@NonNull P1, @NonNull P2, Unit> content
)

Convert a lambda into one that moves the remembered state and nodes created in a previous call to the new location it is called.

Tracking compositions can be used to produce a composable that moves its content between a row and a column based on a parameter, such as,

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content as Any) { movableContentOf(content) }

if (vertical) {
    Column {
        movableContent()
    }
} else {
    Row {
        movableContent()
    }
}

Or they can be used to ensure the composition state tracks with a model as moves in the layout, such as,

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.Composable
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember {
    mutableMapOf<Item, @Composable () -> Unit>()
}
val movableItems =
    items.map { item -> itemMap.getOrPut(item) { movableContentOf { ItemView(item) } } }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}
Parameters
@Composable @NonNull Function2<@NonNull P1, @NonNull P2, Unit> content

The composable lambda to convert into a state tracking lambda.

Returns
@Composable @NonNull Function2<@NonNull P1, @NonNull P2, Unit>

A tracking composable lambda

movableContentOf

public static final @Composable @NonNull Function3<@NonNull P1, @NonNull P2, @NonNull P3, Unit> <P1 extends Object, P2 extends Object, P3 extends Object> movableContentOf(
    @Composable @NonNull Function3<@NonNull P1, @NonNull P2, @NonNull P3, Unit> content
)

Convert a lambda into one that moves the remembered state and nodes created in a previous call to the new location it is called.

Tracking compositions can be used to produce a composable that moves its content between a row and a column based on a parameter, such as,

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content as Any) { movableContentOf(content) }

if (vertical) {
    Column {
        movableContent()
    }
} else {
    Row {
        movableContent()
    }
}

Or they can be used to ensure the composition state tracks with a model as moves in the layout, such as,

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.Composable
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember {
    mutableMapOf<Item, @Composable () -> Unit>()
}
val movableItems =
    items.map { item -> itemMap.getOrPut(item) { movableContentOf { ItemView(item) } } }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}
Parameters
@Composable @NonNull Function3<@NonNull P1, @NonNull P2, @NonNull P3, Unit> content

The composable lambda to convert into a state tracking lambda.

Returns
@Composable @NonNull Function3<@NonNull P1, @NonNull P2, @NonNull P3, Unit>

A tracking composable lambda

movableContentOf

public static final @Composable @NonNull Function4<@NonNull P1, @NonNull P2, @NonNull P3, @NonNull P4, Unit> <P1 extends Object, P2 extends Object, P3 extends Object, P4 extends Object> movableContentOf(
    @Composable @NonNull Function4<@NonNull P1, @NonNull P2, @NonNull P3, @NonNull P4, Unit> content
)

Convert a lambda into one that moves the remembered state and nodes created in a previous call to the new location it is called.

Tracking compositions can be used to produce a composable that moves its content between a row and a column based on a parameter, such as,

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content as Any) { movableContentOf(content) }

if (vertical) {
    Column {
        movableContent()
    }
} else {
    Row {
        movableContent()
    }
}

Or they can be used to ensure the composition state tracks with a model as moves in the layout, such as,

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.Composable
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember {
    mutableMapOf<Item, @Composable () -> Unit>()
}
val movableItems =
    items.map { item -> itemMap.getOrPut(item) { movableContentOf { ItemView(item) } } }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}
Parameters
@Composable @NonNull Function4<@NonNull P1, @NonNull P2, @NonNull P3, @NonNull P4, Unit> content

The composable lambda to convert into a state tracking lambda.

Returns
@Composable @NonNull Function4<@NonNull P1, @NonNull P2, @NonNull P3, @NonNull P4, Unit>

A tracking composable lambda

movableContentWithReceiverOf

public static final @Composable @ExtensionFunctionType @NonNull Function1<@NonNull R, Unit> <R extends Object> movableContentWithReceiverOf(
    @Composable @ExtensionFunctionType @NonNull Function1<@NonNull R, Unit> content
)

Convert a lambda with a receiver into one that moves the remembered state and nodes created in a previous call to the new location it is called.

Tracking compositions can be used to produce a composable that moves its content between a row and a column based on a parameter, such as,

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content as Any) { movableContentOf(content) }

if (vertical) {
    Column {
        movableContent()
    }
} else {
    Row {
        movableContent()
    }
}

Or they can be used to ensure the composition state tracks with a model as moves in the layout, such as,

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.Composable
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember {
    mutableMapOf<Item, @Composable () -> Unit>()
}
val movableItems =
    items.map { item -> itemMap.getOrPut(item) { movableContentOf { ItemView(item) } } }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}
Parameters
@Composable @ExtensionFunctionType @NonNull Function1<@NonNull R, Unit> content

The composable lambda to convert into a state tracking lambda.

Returns
@Composable @ExtensionFunctionType @NonNull Function1<@NonNull R, Unit>

A tracking composable lambda

movableContentWithReceiverOf

public static final @Composable @ExtensionFunctionType @NonNull Function2<@NonNull R, @NonNull P, Unit> <R extends Object, P extends Object> movableContentWithReceiverOf(
    @Composable @ExtensionFunctionType @NonNull Function2<@NonNull R, @NonNull P, Unit> content
)

Convert a lambda with a receiver into one that moves the remembered state and nodes created in a previous call to the new location it is called.

Tracking compositions can be used to produce a composable that moves its content between a row and a column based on a parameter, such as,

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content as Any) { movableContentOf(content) }

if (vertical) {
    Column {
        movableContent()
    }
} else {
    Row {
        movableContent()
    }
}

Or they can be used to ensure the composition state tracks with a model as moves in the layout, such as,

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.Composable
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember {
    mutableMapOf<Item, @Composable () -> Unit>()
}
val movableItems =
    items.map { item -> itemMap.getOrPut(item) { movableContentOf { ItemView(item) } } }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}
Parameters
@Composable @ExtensionFunctionType @NonNull Function2<@NonNull R, @NonNull P, Unit> content

The composable lambda to convert into a state tracking lambda.

Returns
@Composable @ExtensionFunctionType @NonNull Function2<@NonNull R, @NonNull P, Unit>

A tracking composable lambda

movableContentWithReceiverOf

public static final @Composable @ExtensionFunctionType @NonNull Function3<@NonNull R, @NonNull P1, @NonNull P2, Unit> <R extends Object, P1 extends Object, P2 extends Object> movableContentWithReceiverOf(
    @Composable @ExtensionFunctionType @NonNull Function3<@NonNull R, @NonNull P1, @NonNull P2, Unit> content
)

Convert a lambda with a receiver into one that moves the remembered state and nodes created in a previous call to the new location it is called.

Tracking compositions can be used to produce a composable that moves its content between a row and a column based on a parameter, such as,

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content as Any) { movableContentOf(content) }

if (vertical) {
    Column {
        movableContent()
    }
} else {
    Row {
        movableContent()
    }
}

Or they can be used to ensure the composition state tracks with a model as moves in the layout, such as,

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.Composable
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember {
    mutableMapOf<Item, @Composable () -> Unit>()
}
val movableItems =
    items.map { item -> itemMap.getOrPut(item) { movableContentOf { ItemView(item) } } }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}
Parameters
@Composable @ExtensionFunctionType @NonNull Function3<@NonNull R, @NonNull P1, @NonNull P2, Unit> content

The composable lambda to convert into a state tracking lambda.

Returns
@Composable @ExtensionFunctionType @NonNull Function3<@NonNull R, @NonNull P1, @NonNull P2, Unit>

A tracking composable lambda

movableContentWithReceiverOf

public static final @Composable @ExtensionFunctionType @NonNull Function4<@NonNull R, @NonNull P1, @NonNull P2, @NonNull P3, Unit> <R extends Object, P1 extends Object, P2 extends Object, P3 extends Object> movableContentWithReceiverOf(
    @Composable @ExtensionFunctionType @NonNull Function4<@NonNull R, @NonNull P1, @NonNull P2, @NonNull P3, Unit> content
)

Convert a lambda with a receiver into one that moves the remembered state and nodes created in a previous call to the new location it is called.

Tracking compositions can be used to produce a composable that moves its content between a row and a column based on a parameter, such as,

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content as Any) { movableContentOf(content) }

if (vertical) {
    Column {
        movableContent()
    }
} else {
    Row {
        movableContent()
    }
}

Or they can be used to ensure the composition state tracks with a model as moves in the layout, such as,

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.Composable
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember {
    mutableMapOf<Item, @Composable () -> Unit>()
}
val movableItems =
    items.map { item -> itemMap.getOrPut(item) { movableContentOf { ItemView(item) } } }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}
Parameters
@Composable @ExtensionFunctionType @NonNull Function4<@NonNull R, @NonNull P1, @NonNull P2, @NonNull P3, Unit> content

The composable lambda to convert into a state tracking lambda.

Returns
@Composable @ExtensionFunctionType @NonNull Function4<@NonNull R, @NonNull P1, @NonNull P2, @NonNull P3, Unit>

A tracking composable lambda