---
title: "LazyLayoutItemProvider"
description: "Provides all the needed info about the items which could be later composed and displayed as
children or [LazyLayout]. The number of virtual items is limited by
[LazyLayoutItemProvider.itemCount]. For an efficient implementation this should be an immutable
representation of the underlying data/items, ideally changes to your data source/structure should
re-create this representation, instead of changing state values read inside this implementation.
See [LazyLayout] for additional context."
type: "interface"
---

<div class='type'>Interface</div>


<a id='references'></a>

<div class='sourceset sourceset-common'>Common</div>



```kotlin
interface LazyLayoutItemProvider
```


Provides all the needed info about the items which could be later composed and displayed as
children or `LazyLayout`. The number of virtual items is limited by
`LazyLayoutItemProvider.itemCount`. For an efficient implementation this should be an immutable
representation of the underlying data/items, ideally changes to your data source/structure should
re-create this representation, instead of changing state values read inside this implementation.
See `LazyLayout` for additional context.


## Properties

<div class='sourceset sourceset-common'>Common</div>


```kotlin
@get:IntRange(from = 0) val itemCount: Int
```


The total number of items in the lazy layout (visible or not).



## Functions

```kotlin
@Composable fun Item(@IntRange(from = 0) index: Int, key: Any)
```


The item for the given `index` and `key`. Indices are a core concept on LazyLayouts and
should always be supported, the key is an additional concept that can be introduced per item
and is used to guaranteed the uniqueness of a given item in the Lazy Layout implementation.
For instance, in lists, keys are used to keep an item's scroll position in case of dataset
changes. Therefore, the key provided here will depend if your LazyLayout implementation
supports this concept or not.

Custom keys are provided in the `getKey` function. If a key concept is not needed by your
LazyLayout implementation (`getKey` is not overridden), the internal implementation will
simply use `getDefaultLazyLayoutKey` to implement a key based on an item's index.

It is the responsibility of the implementation to ensure consistency between keys and indices
if custom keys are provided, since both the caller and the implementer of this function are
the same, a contract can be established to ensure the consistency.

#### Parameters

| | |
| --- | --- |
| index | the index of the item in the list |
| key | The key of the item as described above. |



```kotlin
fun getContentType(@IntRange(from = 0) index: Int): Any?
```


Returns the content type for the item on this index. It is used to improve the item
compositions reusing efficiency. Note that null is a valid type and items of such type will
be considered compatible.

#### Parameters

| | |
| --- | --- |
| index | the index of an item in the layout. |


#### Returns

| | |
| --- | --- |
|  | The content type mapped from `index`. |



```kotlin
fun getKey(@IntRange(from = 0) index: Int): Any
```


Returns the key for the item on this index.

#### Parameters

| | |
| --- | --- |
| index | the index of an item in the layout. |


#### Returns

| | |
| --- | --- |
|  | The key mapped from `index`. |



```kotlin
fun getIndex(key: Any): Int
```


Get index for given key. The index is not guaranteed to be known for all keys in layout for
optimization purposes, but must be present for elements in current viewport. If the key is
not present in the layout or is not known, return -1.

#### Parameters

| | |
| --- | --- |
| key | the key of an item in the layout. |


#### Returns

| | |
| --- | --- |
|  | The index mapped from `key` if it is present in the layout, otherwise -1. |




## Code Examples

### LazyLayoutItemProviderSample
```kotlin
@Composable
fun LazyLayoutItemProviderSample() {
    class CustomItemProvider(val data: List<String>) : LazyLayoutItemProvider {
        override val itemCount: Int
            get() = data.size
        @Composable
        override fun Item(index: Int, key: Any) {
            Box(
                modifier =
                    Modifier.width(100.dp)
                        .height(100.dp)
                        .background(color = if (index % 2 == 0) Color.Red else Color.Green)
            ) {
                Text(text = data[index])
            }
        }
    }
    val items = (0..100).toList().map { it.toString() }
    val itemProvider = remember(items) { CustomItemProvider(items) }
}
```