Focus best practices

To respond to rotary input events, your scroll view must be in focus. In most cases,
this happens automatically; your scrolling view becomes focused immediately after you create your
Activity.
However, there are situations where you need to manually handle focus of your app's view, such as:

If your scrollable view is attached after
Activity.onCreate() (for example, if you wait for a network request to finish
before building your UI), then you must call
requestFocus
after attaching it.

If your scrollable view is initially
INVISIBLE or GONE, you must call
requestFocus when you set it to
VISIBLE.

If your Activity contains multiple scrollable views (for example, if you are using nested
scrolling) you need to choose one to be focused (usually via the
<requestFocus /> tag).
Nested scrolling is not currently supported for RSB scrolling.

If your UI contains some other view that steals focus when the user interacts with it
(these are rare; the most common example is an InputText), you need to provide
the user with some way to restore focus to the scrollable view if it loses focus. Usually
this is done by listening for taps on the scrollable view and calling
requestFocus in response.

Add custom rotary input scrolling

If your scrollable view doesn't natively support rotary input scrolling, or if you want to
do something other than scrolling in response to rotary input events (zoom in/out,
turn dials, etc.), you can use the RotaryEncoder methods in the
Wearable Support Library.

The following code snippet shows how to use RotaryEncoder to add custom scrolling
in your app's view:

Test rotary input button on the emulator

You can use the Android Emulator to simulate
rotary input scrolling on a Wear device. Launch your Wear app on the emulator when you run your
project, or drag an APK file onto the emulator to install it.

To test the rotary input on the emulator:

From the SDK
manager, use the SDK tools tab to get Android Emulator 26.0.3 or higher.

Click the overflow button (three dots at the bottom of the emulator toolbar).
Click the Rotary input tab in the new window to open the rotary input interface.

The following video shows rotary input in the emulator:

Focus behavior tips

A view is focusable if it has
setFocusableInTouchMode(true). By default, this is only true for
scrollable views (for example, ScrollView) and InputText.

By default, tapping on a view does not focus it (even if it is focusable). To achieve
this behavior, the view must listen for tap events and manually call
View.requestFocus().

Immediately after an Activity is created, it automatically focuses the first
focusable view that it finds in its view hierarchy. If you have multiple focusable views in
your Activity, this may not be the one you wanted. You can focus a different view using the
<requestFocus /> tag (or by manually calling View.requestFocus
in Activity.onResume).

A focusable view is not automatically focused if it is attached or unhidden after an Activity
has been created, even if there is no currently focused view. In this case you need to manually
call View.requestFocus.