Criar mostradores de relógios interativos

Um usuário pode interagir com o mostrador do relógio de muitas formas. Por exemplo, ele pode tocar no mostrador do relógio para ver que música está tocando 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.

Confira os seguintes recursos relacionados (links em inglês):

• Mostradores interativos

• Amostra de mostrador do relógio

• Codelab: adicionar complicações em um mostrador do relógio

Esta lição ensina como implementar um mostrador de relógio interativo começando pela criação do estilo do mostrador e, em seguida, implementando o processamento de gestos.

Observação: antes de começar a desenvolver seu mostrador de relógio interativo, leia sobre Mostradores de relógios interativos (em inglês).

Processar gestos de toque

Ao criar um estilo de mostrador de relógio interativo, a primeira ação que o app precisa realizar é 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 na implementação de WatchFaceService.Enginepara iniciar a ação que você quer 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 os de arrastar e de tocar e manter pressionado 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 inicialmente na tela. Esse evento permite que você mostre um feedback visual sobre o toque para o usuário. Seu app não deve iniciar uma IU quando esse evento é acionado. Iniciar uma IU impede que eventos de arrastar abram o inicializador de apps, a aba de configurações e o fluxo de notificações.

Antes de enviar o próximo comando, o sistema analisa se o contato é um toque único, ou seja, o único gesto permitido. Se o usuário levantar o dedo imediatamente, o sistema determinará que um toque único foi realizado e encaminhará um evento TAP_TYPE_TAP. Se o usuário não levantar o dedo imediatamente, o sistema encaminhará 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;
        }
    }
    

Nesse exemplo, o app 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 app exibirá um feedback visual. Se o evento for a elevação imediata do dedo após o contato, o app executará a ação tocada pelo usuário. Se o evento for o contato prolongado do dedo, o app não fará nada.