Save the date! Android Dev Summit is coming to Sunnyvale, CA on Oct 23-24, 2019.

Criar mostradores de relógios interativos

Um usuário pode interagir com o mostrador do relógio de muitas formas. Por exemplo, o usuário pode tocar no mostrador do relógio para ver qual música está sendo reproduzida ou para ver a agenda do dia. O Wear OS by Google permite que o mostrador do relógio aceite o gesto de um toque em um determinado local de sua interface, desde que não haja outro elemento de IU que também responda a esse gesto.

Esta lição ensina você a implementar um mostrador do relógio interativo ao construir o estilo do mostrador e, em seguida, implementar o processamento de gestos.

Observação: Antes de começar a desenvolver seu mostrador do relógio interativo, não deixe de ler sobre Mostradores de relógios interativos.

Processar gestos de toque

Ao construir um estilo de mostrador do relógio, a primeira coisa que o aplicativo precisa fazer é informar o sistema de que o mostrador recebe eventos de toque. O exemplo a seguir mostra como fazer isso:

Kotlin

setWatchFaceStyle(WatchFaceStyle.Builder(service)
        .setAcceptsTapEvents(true)
        // other style customizations
        .build())

Java

setWatchFaceStyle(new WatchFaceStyle.Builder(service)
        .setAcceptsTapEvents(true)
        // other style customizations
        .build());

Quando o sistema detecta um evento de toque no mostrador do relógio, ele aciona o método WatchFaceService.Engine.onTapCommand(). Modifique esse método em sua implementação de WatchFaceService.Enginepara iniciar a ação que você deseja executar, como mostrar uma contagem detalhada de passos ou alterar o tema do mostrador do relógio. O snippet de código em Processar gestos mostra um exemplo dessa implementação.

Processar gestos

Para proporcionar uma experiência de usuário consistente, o sistema reserva gestos como arrastar ou pressionamento longo para elementos da IU do sistema. Portanto, sistema não envia eventos de toque brutos para o mostrador do relógio. Em vez disso, ele encaminha comandos específicos para o método onTapCommand().

O sistema envia o primeiro comando, TAP_TYPE_TOUCH, quando o usuário toca a tela inicialmente. Esse evento permite que você forneça um feedback visual sobre o toque para o usuário. Seu aplicativo não deve iniciar uma IU quando esse evento é acionado. Iniciar uma IU impede que eventos de arrastar abram o inicializador de aplicativos, o shade de configurações e o stream de notificações.

Antes de enviar o próximo comando, o sistema julga se o contato é um único toque, que é o único gesto permitido. Se o usuário levantar o dedo imediatamente, o sistema determina que um único toque foi realizado e encaminha um evento TAP_TYPE_TAP. Se o usuário não levantar o dedo imediatamente, o sistema encaminha um evento TAP_TYPE_TOUCH_CANCEL. Quando o usuário aciona um evento TAP_TYPE_TOUCH_CANCEL, ele não pode acionar um evento TAP_TYPE_TAP até fazer um novo contato com a tela.

O exemplo abaixo mostra como implementar eventos de toque no mostrador do relógio:

Kotlin

override fun onTapCommand(@TapType tapType: Int, x: Int, y: Int, eventTime: Long) {
    when (tapType) {
        WatchFaceService.TAP_TYPE_TAP -> {
            hideTapHighlight()
            if (withinTapRegion(x, y)) {
                // Implement the tap action
                // (e.g. show detailed step count)
                onWatchFaceTap()
            }
        }

        WatchFaceService.TAP_TYPE_TOUCH ->
            if (withinTapRegion(x, y)) {
                // Provide visual feedback of touch event
                startTapHighlight(x, y, eventTime)
            }

        WatchFaceService.TAP_TYPE_TOUCH_CANCEL -> hideTapHighlight()

        else -> super.onTapCommand(tapType, x, y, eventTime)
    }
}

Java

@Override
public void onTapCommand(
       @TapType int tapType, int x, int y, long eventTime) {
    switch (tapType) {
        case WatchFaceService.TAP_TYPE_TAP:
            hideTapHighlight();
            if (withinTapRegion(x, y)) {
                // Implement the tap action
                // (e.g. show detailed step count)
                onWatchFaceTap();
            }
            break;

        case WatchFaceService.TAP_TYPE_TOUCH:
            if (withinTapRegion(x, y)) {
                // Provide visual feedback of touch event
                startTapHighlight(x, y, eventTime);
            }
            break;

        case WatchFaceService.TAP_TYPE_TOUCH_CANCEL:
            hideTapHighlight();
            break;

        default:
            super.onTapCommand(tapType, x, y, eventTime);
            break;
    }
}

Neste exemplo, o aplicativo determina o tipo de evento que ocorreu e responde da forma adequada. Se o evento for o contato inicial do dedo do usuário, o aplicativo exibe um feedback visual. Se o evento for a remoção imediata do dedo após o contato, ele executa a ação na qual o usuário tocou. Se o evento for o contato prolongado do dedo, o aplicativo não faz nada.