Try the Compose way  
Jetpack Compose on Wear OS is the recommended UI toolkit for Wear OS.  
[Create lists using Compose on Wear OS →](https://developer.android.com/training/wearables/compose/lists)  
![](https://developer.android.com/static/images/android-compose-ui-logo.png)


Lists let users select an item from a set of choices easily on Wear OS devices.


The Wearable UI Library includes the
[`WearableRecyclerView`](https://developer.android.com/reference/androidx/wear/widget/WearableRecyclerView) class, which is a
[`RecyclerView`](https://developer.android.com/reference/androidx/recyclerview/widget/RecyclerView)
implementation for creating lists optimized for wearable devices. You can use this
interface in your wearable app by creating a new `WearableRecyclerView` container.


Use a `WearableRecyclerView` for a
long list of simple items, such as an application launcher or a list of contacts. Each item might
have a short string and an associated icon. Alternatively, each item might have only a string
or an icon.


**Note:** Avoid complex layouts. Users should only need to glance at an item to
understand what it is, especially with wearables' limited screen size.


By extending the existing `RecyclerView` class, `WearableRecyclerView`
APIs display a vertically scrollable list of items in a straight list by default. You can also use
the `WearableRecyclerView` APIs to opt-in for a curved layout and
a [circular scrolling gesture](https://developer.android.com/reference/androidx/wear/widget/WearableRecyclerView#setCircularScrollingGestureEnabled(boolean))
in your wearable apps.
![](https://developer.android.com/static/wear/images/06_uilib.png)

**Figure 1.**
Default list view on Wear OS.


This guide shows you how to use the `WearableRecyclerView` class to create
lists in your Wear OS apps, how to opt-in for a curved layout
for your scrollable items, and how to customize the appearance of
the children while scrolling.

## Add WearableRecyclerView to an activity using XML


The following layout adds a `WearableRecyclerView` to an activity:  

```xml
<androidx.wear.widget.WearableRecyclerView
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/recycler_launcher_view"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:scrollbars="vertical" />
```


The following example shows the `WearableRecyclerView`
applied to an activity:  

### Kotlin

```kotlin
class MainActivity : Activity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
    ...
}
```

### Java

```java
public class MainActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    ...
}
```

## Create a curved layout

![](https://developer.android.com/static/wear/images/wrv_new.gif)


To create a curved layout for scrollable items in your wearable app, do the following:

- Use [`WearableRecyclerView`](https://developer.android.com/reference/androidx/wear/widget/WearableRecyclerView) as your main container in the relevant XML layout.
- Set the [`setEdgeItemsCenteringEnabled(boolean)`](https://developer.android.com/reference/androidx/wear/widget/WearableRecyclerView#setEdgeItemsCenteringEnabled(boolean)) method to `true`. This vertically centers the first and last items on the list on the screen.
- Use the `WearableRecyclerView.setLayoutManager()` method to set the layout of the items on the screen.

### Kotlin

```kotlin
wearableRecyclerView.apply {
    // To align the edge children (first and last) with the center of the screen.
    isEdgeItemsCenteringEnabled = true
    ...
    layoutManager = WearableLinearLayoutManager(this@MainActivity)
}
```

### Java

```java
// To align the edge children (first and last) with the center of the screen.
wearableRecyclerView.setEdgeItemsCenteringEnabled(true);
...
wearableRecyclerView.setLayoutManager(
                new WearableLinearLayoutManager(this));
```


If your app has specific requirements to customize the appearance of the children while scrolling---for example,
scaling the icons and text while the items scroll away from the center---extend
the [`WearableLinearLayoutManager.LayoutCallback`](https://developer.android.com/reference/androidx/wear/widget/WearableLinearLayoutManager.LayoutCallback) class and override the
[`onLayoutFinished`](https://developer.android.com/reference/androidx/wear/widget/WearableLinearLayoutManager.LayoutCallback#onLayoutFinished(android.view.View, androidx.recyclerview.widget.RecyclerView)) method.


The following code snippets show an example of customizing the scrolling of items to scale
farther away from the center by extending the
`WearableLinearLayoutManager.LayoutCallback` class:  

### Kotlin

```kotlin
/** How much icons should scale, at most.  */
private const val MAX_ICON_PROGRESS = 0.65f

class CustomScrollingLayoutCallback : WearableLinearLayoutManager.LayoutCallback() {

    private var progressToCenter: Float = 0f

    override fun onLayoutFinished(child: View, parent: RecyclerView) {
        child.apply {
            // Figure out % progress from top to bottom.
            val centerOffset = height.toFloat() / 2.0f / parent.height.toFloat()
            val yRelativeToCenterOffset = y / parent.height + centerOffset

            // Normalize for center.
            progressToCenter = Math.abs(0.5f - yRelativeToCenterOffset)
            // Adjust to the maximum scale.
            progressToCenter = Math.min(progressToCenter, MAX_ICON_PROGRESS)

            scaleX = 1 - progressToCenter
            scaleY = 1 - progressToCenter
        }
    }
}
```

### Java

```java
public class CustomScrollingLayoutCallback extends WearableLinearLayoutManager.LayoutCallback {
    /** How much icons should scale, at most. */
    private static final float MAX_ICON_PROGRESS = 0.65f;

    private float progressToCenter;

    @Override
    public void onLayoutFinished(View child, RecyclerView parent) {

        // Figure out % progress from top to bottom.
        float centerOffset = ((float) child.getHeight() / 2.0f) / (float) parent.getHeight();
        float yRelativeToCenterOffset = (child.getY() / parent.getHeight()) + centerOffset;

        // Normalize for center.
        progressToCenter = Math.abs(0.5f - yRelativeToCenterOffset);
        // Adjust to the maximum scale.
        progressToCenter = Math.min(progressToCenter, MAX_ICON_PROGRESS);

        child.setScaleX(1 - progressToCenter);
        child.setScaleY(1 - progressToCenter);
    }
}
```  

### Kotlin

```kotlin
wearableRecyclerView.layoutManager =
        WearableLinearLayoutManager(this, CustomScrollingLayoutCallback())
```

### Java

```java
CustomScrollingLayoutCallback customScrollingLayoutCallback =
                new CustomScrollingLayoutCallback();
wearableRecyclerView.setLayoutManager(
                new WearableLinearLayoutManager(this, customScrollingLayoutCallback));
```