Interagir com blocos

Você pode melhorar ainda mais sua experiência com blocos tornando-a interativa. Ao adicionar o modificador Clickable a um elemento de layout no bloco, é possível reagir a um toque do usuário nesse elemento.

Observação: o sistema cria automaticamente uma área clicável de 48 dp x 48 dp ao redor de cada elemento interativo dentro do seu bloco. Mantenha esses elementos longe o suficiente para que as áreas clicáveis não se sobreponham. Componentes do Material Design já seguem essa orientação.

Esta página lista várias ações comuns que os usuários realizam em blocos interativos, além de orientações sobre como implementar esse comportamento nos blocos do app.

Carregar um novo layout de blocos

Use LoadAction para atualizar o layout do bloco quando o usuário toca em um elemento interativo.

No snippet de código abaixo, o ID clicável definido em setId() é transmitido à chamada de onTileRequest() para que você possa renderizar um layout diferente com base nesse ID:

override fun onTileRequest(requestParams: TileRequest) = Futures.immediateFuture(
    Tile.Builder()
        .setResourcesVersion("1")
        .setTileTimeline(Timeline.fromLayoutElement(
            when(requestParams.currentState.lastClickableId) {
                "foo" -> myFooLayout()
                else -> myOtherLayout()
            }
        )).build()
)

Atualizar o estado dentro do bloco

Se um elemento interativo no seu bloco tiver vários estados possíveis, use uma LoadAction para mostrar o novo valor do elemento. No snippet de código abaixo, o bloco mostra o valor atualizado de uma caixa de seleção:

private fun checkboxChip(
    checkboxValue: Boolean,
    deviceParameters: DeviceParametersBuilders.DeviceParameters
): Chip =
    Chip.Builder(
            context,
            Clickable.Builder()
                .setOnClick(LoadAction.Builder()
                    .build()
                ).build(),
            deviceParameters
        ).setIconContent(if (checkboxValue) "check" else "checkoff")
        // Set checkbox labels and colors here.
        .build()

Solicitar uma atualização do conteúdo do bloco

Para solicitar uma atualização de todo o conteúdo do bloco, use LoadAction e atualize o estado da solicitação, conforme mostrado no snippet de código abaixo.

Observação: para evitar oscilações e animações reiniciadas, não mude a forma como o layout é carregado, exceto as partes em que as expressões literais ou dinâmicas têm valores atualizados.

private fun tappableElement(): LayoutElement =
    Button.Builder(this, Clickable.Builder()
            .setId("foo")
            .setOnClick(LoadAction.Builder()
                .setRequestState(
                    StateBuilders.State.Builder()
                        /* Update state information here. */
                        .build()
                ).build()
            ).build())
        .setTextContent("Tap me!")
        .build()

Carregar uma atividade usando um link direto

Para carregar uma atividade usando um link direto, associe um elemento clicável a um objeto LoadAction:

private fun tappableElement(): LayoutElement =
    Text.Builder()
        .setText("Tap me!")
        .setModifiers(Modifiers.Builder()
            .setClickable(Clickable.Builder()
                .setId("foo")
                .setOnClick(LoadAction.Builder().build())
                .build()
            ).build()
        ).build()

Em seguida, no método onTileRequest(), use um objeto TaskStackBuilder como auxiliar:

override fun onTileRequest(requestParams: TileRequest): ListenableFuture<TileBuilders.Tile> {
    val lastClickableId = requestParams.currentState.lastClickableId
    if (lastClickableId == "foo") {
      TaskStackBuilder.create(this)
        .addNextIntentWithParentStack(Intent(
            Intent.ACTION_VIEW,
            "https://www.example.com/$lastClickableId".toUri(),
            context,
            MyWearOsAppActivity::class.java
        ))
        .startActivities()
    }
    // The user clicked somewhere else on the tile instead.
}

Carregar uma atividade exportada

Para carregar uma atividade exportada por nome de classe e com extras de intents, use uma LaunchAction.

Atenção: considere como a LaunchAction afeta a navegação do app. O Compose para Wear OS recomenda o uso de uma única atividade no app.

private fun tappableElement(): LayoutElement =
    Text.Builder(this, "Tap me!")
        .setModifiers(Modifiers.Builder()
            .setClickable(Clickable.Builder()
                .setId("foo")
                .setOnClick(ActionBuilders.launchAction(
                    ComponentName("my.package.name", "MyActivity")
                )).build()
            ).build()
        ).build()

Dentro da atividade iniciada, você pode extrair o ID usado para o bloco, conforme mostrado neste exemplo:

class MyActivity : FragmentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val clickableId =
            intent.getStringExtra(TileService.EXTRA_CLICKABLE_ID)
        // clickableId will be "foo" when launched from the Tile
    }
}