Create lists on Wear

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

The Wearable UI Library includes the WearableRecyclerView class, which is a RecyclerView implementation for creating lists optimized for wearable devices. You can use this interface in your wearable app by creating a new WearableRecyclerView container.

Refer to the following related resources:

• Wear OS design principles

You should decide whether to use a WearableRecyclerView, based on the kind of user experience you want to provide. We recommend using the WearableRecyclerView for a long list of simple items, such as an application launcher, or a list contacts. Each item might have a short string and an associated icon. Alternatively, each item might have only a string or an icon. We do not recommend using a WearableRecyclerView for very short or complex lists. In that case use the RecyclerView or a ListView from the regular Android support library.

By extending the existing RecyclerView class, WearableRecyclerView APIs display a vertically scrollable list of items in a straight list by default. You can use the WearableRecyclerView APIs to opt-in for a curved layout and a circular scrolling gesture in your wearable apps.

Figure 1. Default list view on Wear OS.

This lesson shows you how to use the WearableRecyclerView class to create lists in your Wear OS apps. The document also describes how to opt-in for a curved layout for your scrollable items, enable circular scrolling gesture, and customize the appearance of the children while scrolling.

Add WearableRecyclerView to an activity using XML

The following layout (as inserted into, for example, res/layout/activity_main.xml) adds a WearableRecyclerView to an activity, so the list is displayed properly on both round and square devices:

<android.support.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 shows the WearableRecyclerView as it could be applied to an activity:

Kotlin

import android.os.Bundle
import android.app.Activity
import android.support.wear.widget.WearableRecyclerView

class MainActivity : Activity() {

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

    ...
}

Java

import android.os.Bundle;
import android.app.Activity;
import android.support.wear.widget.WearableRecyclerView;

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

    ...
}

Note: The WearableRecyclerView class replaces a similar, deprecated class in the Wearable Support Library.

Create a curved layout

To create a curved layout for scrollable items in your wearable app:

• Use WearableRecyclerView as your main container in the relevant XML layout.
• Set the setEdgeItemsCenteringEnabled(boolean) method to true. This will align the first and last items on the list vertically centered on the screen.
• Use the WearableRecyclerView.setLayoutManager() method to set layout of the items on the screen.

Kotlin

wearableRecyclerView.apply {
    // To align the edge children (first and last) with the center of the screen
    isEdgeItemsCenteringEnabled = true
    ...

    layoutManager = WearableLinearLayoutManager(this@MainActivity)
}

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, scale the icons and text while the items scroll away from the center), extend the WearableLinearLayoutManager.LayoutCallback class and override the onLayoutFinished method.

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

Kotlin

/** How much should we scale the icon 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

public class CustomScrollingLayoutCallback extends WearableLinearLayoutManager.LayoutCallback {
    /** How much should we scale the icon 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

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

Java

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

Add a circular scrolling gesture

By default, circular scrolling is disabled in the WearableRecyclerView. If you want to enable a circular scrolling gesture in your child view, use the WearableRecyclerView’s setCircularScrollingGestureEnabled() method. You can also customize the circular scrolling gesture by defining one or both of the following:

• How many degrees the user has to rotate by to scroll through one screen height. This effectively influences the speed of the scolling — setScrollDegreesPerScreen — the default value is set at 180 degrees.
• The width of a virtual ‘bezel’ near the edge of the screen in which the gesture will be recognized — setBezelFraction —the default value is set at 1. This is expressed as a fraction of the radius of the view.

The following code snippet shows how to set these methods:

Kotlin

wearableRecyclerView.apply {
    isCircularScrollingGestureEnabled = true
    bezelFraction = 0.5f
    scrollDegreesPerScreen = 90f
}

Java

wearableRecyclerView.setCircularScrollingGestureEnabled(true);
wearableRecyclerView.setBezelFraction(0.5f);
wearableRecyclerView.setScrollDegreesPerScreen(90);