ScalingLazyListScope
@ScalingLazyScopeMarker
sealed interface ScalingLazyListScope
Receiver scope which is used by ScalingLazyColumn.
Summary
Public functions |
|
|---|---|
Unit |
item(key: Any?, content: @Composable ScalingLazyListItemScope.() -> Unit)Adds a single item. |
Unit |
items(Adds a |
Extension functions |
|
|---|---|
Unit |
ScalingLazyListScope.expandableButton(Adds a single item, for the button that controls expandable item(s). |
Unit |
ScalingLazyListScope.expandableItem(Adds a single item, that will be expanded/collapsed according to the |
Unit |
ScalingLazyListScope.expandableItems(Adds a series of items, that will be expanded/collapsed according to the |
inline Unit |
<T : Any?> ScalingLazyListScope.items(Adds an array of items. |
inline Unit |
<T : Any?> ScalingLazyListScope.items(Adds a list of items. |
inline Unit |
<T : Any?> ScalingLazyListScope.itemsIndexed(Adds an array of items where the content of an item is aware of its index. |
inline Unit |
<T : Any?> ScalingLazyListScope.itemsIndexed(Adds a list of items where the content of an item is aware of its index. |
Public functions
item
fun item(key: Any? = null, content: @Composable ScalingLazyListItemScope.() -> Unit): Unit
Adds a single item.
| Parameters | |
|---|---|
key: Any? = null |
a stable and unique key representing the item. Using the same key for multiple items in the list is not allowed. Type of the key should be saveable via Bundle on Android. If null is passed the position in the list will represent the key. When you specify the key the scroll position will be maintained based on the key, which means if you add/remove items before the current visible item the item with the given key will be kept as the first visible one. |
content: @Composable ScalingLazyListItemScope.() -> Unit |
the content of the item |
items
fun items(
count: Int,
key: ((index: Int) -> Any)? = null,
itemContent: @Composable ScalingLazyListItemScope.(index: Int) -> Unit
): Unit
Adds a count of items.
| Parameters | |
|---|---|
count: Int |
the items count |
key: ((index: Int) -> Any)? = null |
a factory of stable and unique keys representing the item. Using the same key for multiple items in the list is not allowed. Type of the key should be saveable via Bundle on Android. If null is passed the position in the list will represent the key. When you specify the key the scroll position will be maintained based on the key, which means if you add/remove items before the current visible item the item with the given key will be kept as the first visible one. |
itemContent: @Composable ScalingLazyListItemScope.(index: Int) -> Unit |
the content displayed by a single item |
Extension functions
expandableButton
fun ScalingLazyListScope.expandableButton(
state: ExpandableState,
key: Any? = null,
content: @Composable () -> Unit
): Unit
Adds a single item, for the button that controls expandable item(s). The button will be animated out when the corresponding expandables are expanded.
Example of an expandable text:
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.unit.dp
import androidx.wear.compose.foundation.expandableButton
import androidx.wear.compose.foundation.expandableItem
import androidx.wear.compose.foundation.lazy.ScalingLazyColumn
import androidx.wear.compose.foundation.rememberExpandableState
import androidx.wear.compose.material.Chip
import androidx.wear.compose.material.Icon
import androidx.wear.compose.material.OutlinedCompactChip
import androidx.wear.compose.material.Text
val expandableState = rememberExpandableState()
ScalingLazyColumn(
modifier = Modifier.fillMaxSize()
) {
expandableItem(expandableState) { expanded ->
Text(
"Account Alert: you have made a large purchase.\n" +
"We have noticed that a large purchase was charged to " +
"your credit card account. " +
"Please contact us if you did not perform this purchase. " +
"Our Customer Service team is available 24 hours a day, " +
"7 days a week to answer your account or product support question.",
maxLines = if (expanded) 20 else 3,
modifier = Modifier.padding(horizontal = 10.dp)
)
}
expandableButton(expandableState) {
OutlinedCompactChip(
label = {
Text("Show More")
Spacer(Modifier.size(6.dp))
Icon(
painterResource(R.drawable.ic_expand_more_24),
"Expand"
)
},
onClick = { expandableState.expanded = true }
)
}
}
| Parameters | |
|---|---|
state: ExpandableState |
The |
key: Any? = null |
A stable and unique key representing the item. Using the same key for multiple items in the list is not allowed. Type of the key should be saveable via Bundle on Android. If null is passed the position in the list will represent the key. When you specify the key the scroll position will be maintained based on the key, which means if you add/remove items before the current visible item the item with the given key will be kept as the first visible one. |
content: @Composable () -> Unit |
the content displayed, this should usually be a CompactChip or OutlineCompactChip. |
expandableItem
fun ScalingLazyListScope.expandableItem(
state: ExpandableState,
key: Any? = null,
content: @Composable (expanded: Boolean) -> Unit
): Unit
Adds a single item, that will be expanded/collapsed according to the ExpandableState.
Example of an expandable text:
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.unit.dp
import androidx.wear.compose.foundation.expandableButton
import androidx.wear.compose.foundation.expandableItem
import androidx.wear.compose.foundation.lazy.ScalingLazyColumn
import androidx.wear.compose.foundation.rememberExpandableState
import androidx.wear.compose.material.Chip
import androidx.wear.compose.material.Icon
import androidx.wear.compose.material.OutlinedCompactChip
import androidx.wear.compose.material.Text
val expandableState = rememberExpandableState()
ScalingLazyColumn(
modifier = Modifier.fillMaxSize()
) {
expandableItem(expandableState) { expanded ->
Text(
"Account Alert: you have made a large purchase.\n" +
"We have noticed that a large purchase was charged to " +
"your credit card account. " +
"Please contact us if you did not perform this purchase. " +
"Our Customer Service team is available 24 hours a day, " +
"7 days a week to answer your account or product support question.",
maxLines = if (expanded) 20 else 3,
modifier = Modifier.padding(horizontal = 10.dp)
)
}
expandableButton(expandableState) {
OutlinedCompactChip(
label = {
Text("Show More")
Spacer(Modifier.size(6.dp))
Icon(
painterResource(R.drawable.ic_expand_more_24),
"Expand"
)
},
onClick = { expandableState.expanded = true }
)
}
}
The item should support two levels of information display (for example, a text showing a few lines in the collapsed state, and more in the expanded state)
| Parameters | |
|---|---|
state: ExpandableState |
The |
key: Any? = null |
A stable and unique key representing the item. Using the same key for multiple items in the list is not allowed. Type of the key should be saveable via Bundle on Android. If null is passed the position in the list will represent the key. When you specify the key the scroll position will be maintained based on the key, which means if you add/remove items before the current visible item the item with the given key will be kept as the first visible one. |
content: @Composable (expanded: Boolean) -> Unit |
the content displayed by the item, according to its expanded/collapsed state. |
expandableItems
fun ScalingLazyListScope.expandableItems(
state: ExpandableState,
count: Int,
key: ((index: Int) -> Any)? = null,
itemContent: @Composable BoxScope.(index: Int) -> Unit
): Unit
Adds a series of items, that will be expanded/collapsed according to the ExpandableState
Example of an expandable list:
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.size
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.unit.dp
import androidx.wear.compose.foundation.expandableButton
import androidx.wear.compose.foundation.expandableItem
import androidx.wear.compose.foundation.expandableItems
import androidx.wear.compose.foundation.lazy.ScalingLazyColumn
import androidx.wear.compose.foundation.rememberExpandableState
import androidx.wear.compose.material.Chip
import androidx.wear.compose.material.Icon
import androidx.wear.compose.material.OutlinedCompactChip
import androidx.wear.compose.material.Text
val expandableState = rememberExpandableState()
val sampleItem: @Composable (String) -> Unit = { label ->
Chip(
label = { Text(label) },
onClick = { },
secondaryLabel = { Text("line 2 - Secondary") }
)
}
val items = List(10) { "Item $it" }
val top = items.take(3)
val rest = items.drop(3)
ScalingLazyColumn(
modifier = Modifier.fillMaxSize()
) {
items(top.size) {
sampleItem(top[it])
}
expandableItems(expandableState, rest.size) {
sampleItem(rest[it])
}
expandableButton(expandableState) {
OutlinedCompactChip(
label = {
Text("Show More")
Spacer(Modifier.size(6.dp))
Icon(
painterResource(R.drawable.ic_expand_more_24),
"Expand"
)
},
onClick = {
expandableState.expanded = true
}
)
}
}
| Parameters | |
|---|---|
state: ExpandableState |
The |
count: Int |
The number of items |
key: ((index: Int) -> Any)? = null |
a factory of stable and unique keys representing the item. Using the same key for multiple items in the list is not allowed. Type of the key should be saveable via Bundle on Android. If null is passed the position in the list will represent the key. When you specify the key the scroll position will be maintained based on the key, which means if you add/remove items before the current visible item the item with the given key will be kept as the first visible one. |
itemContent: @Composable BoxScope.(index: Int) -> Unit |
the content displayed by a single item |
items
inline fun <T : Any?> ScalingLazyListScope.items(
items: Array<T>,
noinline key: ((item) -> Any)? = null,
crossinline itemContent: @Composable ScalingLazyListItemScope.(item) -> Unit
): Unit
Adds an array of items.
| Parameters | |
|---|---|
items: Array<T> |
the data array |
noinline key: ((item) -> Any)? = null |
a factory of stable and unique keys representing the item. Using the same key for multiple items in the list is not allowed. Type of the key should be saveable via Bundle on Android. If null is passed the position in the list will represent the key. When you specify the key the scroll position will be maintained based on the key, which means if you add/remove items before the current visible item the item with the given key will be kept as the first visible one. |
crossinline itemContent: @Composable ScalingLazyListItemScope.(item) -> Unit |
the content displayed by a single item |
items
inline fun <T : Any?> ScalingLazyListScope.items(
items: List<T>,
noinline key: ((item) -> Any)? = null,
crossinline itemContent: @Composable ScalingLazyListItemScope.(item) -> Unit
): Unit
Adds a list of items.
| Parameters | |
|---|---|
items: List<T> |
the data list |
noinline key: ((item) -> Any)? = null |
a factory of stable and unique keys representing the item. Using the same key for multiple items in the list is not allowed. Type of the key should be saveable via Bundle on Android. If null is passed the position in the list will represent the key. When you specify the key the scroll position will be maintained based on the key, which means if you add/remove items before the current visible item the item with the given key will be kept as the first visible one. |
crossinline itemContent: @Composable ScalingLazyListItemScope.(item) -> Unit |
the content displayed by a single item |
itemsIndexed
inline fun <T : Any?> ScalingLazyListScope.itemsIndexed(
items: Array<T>,
noinline key: ((index: Int, item) -> Any)? = null,
crossinline itemContent: @Composable ScalingLazyListItemScope.(index: Int, item) -> Unit
): Unit
Adds an array of items where the content of an item is aware of its index.
| Parameters | |
|---|---|
items: Array<T> |
the data array |
noinline key: ((index: Int, item) -> Any)? = null |
a factory of stable and unique keys representing the item. Using the same key for multiple items in the list is not allowed. Type of the key should be saveable via Bundle on Android. If null is passed the position in the list will represent the key. When you specify the key the scroll position will be maintained based on the key, which means if you add/remove items before the current visible item the item with the given key will be kept as the first visible one. |
crossinline itemContent: @Composable ScalingLazyListItemScope.(index: Int, item) -> Unit |
the content displayed by a single item |
itemsIndexed
inline fun <T : Any?> ScalingLazyListScope.itemsIndexed(
items: List<T>,
noinline key: ((index: Int, item) -> Any)? = null,
crossinline itemContent: @Composable ScalingLazyListItemScope.(index: Int, item) -> Unit
): Unit
Adds a list of items where the content of an item is aware of its index.
| Parameters | |
|---|---|
items: List<T> |
the data list |
noinline key: ((index: Int, item) -> Any)? = null |
a factory of stable and unique keys representing the item. Using the same key for multiple items in the list is not allowed. Type of the key should be saveable via Bundle on Android. If null is passed the position in the list will represent the key. When you specify the key the scroll position will be maintained based on the key, which means if you add/remove items before the current visible item the item with the given key will be kept as the first visible one. |
crossinline itemContent: @Composable ScalingLazyListItemScope.(index: Int, item) -> Unit |
the content displayed by a single item |