Leitores de tela e botões de sistema do hardware

  • Artigo

Os leitores de tela, como o Narrador, devem ser capazes de reconhecer e manipular eventos de botão do sistema de hardware e comunicar seu estado aos usuários. Em alguns casos, o leitor de tela pode precisar manipular esses eventos de botão de hardware exclusivamente e não deixá-los borbulhar para outros manipuladores.

A partir do Windows 10 versão 2004, os aplicativos UWP podem escutar e manipular os eventos de botão do sistema de hardware Fn da mesma maneira que outros botões de hardware. Anteriormente, esse botão do sistema atuava apenas como um modificador de como outros botões de hardware relatavam seus eventos e estado.

Observação

O suporte ao botão Fn é específico do OEM e pode incluir recursos como a capacidade de ligar/desligar (em vez de uma combinação de teclas de pressionar e segurar), juntamente com uma luz indicadora de bloqueio correspondente (que pode não ser útil para usuários cegos ou com deficiência visual).

Os eventos de botão Fn são expostos por meio de uma nova classe SystemButtonEventController no namespace Windows.UI.Input. O objeto SystemButtonEventController oferece suporte aos seguintes eventos:

Importante

O SystemButtonEventController não pode receber esses eventos se eles já tiverem sido manipulados por um manipulador de prioridade mais alta.

Exemplos

Nos exemplos a seguir, mostramos como criar um SystemButtonEventController com base em um DispatcherQueue e manipular os quatro eventos suportados por esse objeto.

É comum que mais de um dos eventos suportados seja acionado quando o botão Fn é pressionado. Por exemplo, pressionar o botão Fn em um teclado do Surface aciona SystemFunctionButtonPressed, SystemFunctionLockChanged e SystemFunctionLockIndicatorChanged ao mesmo tempo.

  1. Neste primeiro trecho, simplesmente incluímos os namespaces necessários e especificamos alguns objetos globais, incluindo os objetos DispatcherQueue e DispatcherQueueController para gerenciar o thread SystemButtonEventController.

    Em seguida, especificamos os tokens de evento retornados ao registrar os delegados de manipulação de eventos SystemButtonEventController.

    namespace winrt
{
    using namespace Windows::System;
    using namespace Windows::UI::Input;
}

...

// Declare related members
winrt::DispatcherQueueController _queueController;
winrt::DispatcherQueue _queue;
winrt::SystemButtonEventController _controller;
winrt::event_token _fnKeyDownToken;
winrt::event_token _fnKeyUpToken;
winrt::event_token _fnLockToken;

  2. Também especificamos um token de evento para o evento SystemFunctionLockIndicatorChanged junto com um bool para indicar se o aplicativo está no "Modo de Aprendizado" (onde o usuário está simplesmente tentando explorar o teclado sem executar nenhuma função).

    winrt::event_token _fnLockIndicatorToken;
bool _isLearningMode = false;

  3. Esse terceiro trecho inclui os delegados de manipulador de eventos correspondentes para cada evento com suporte no objeto SystemButtonEventController .

    Cada manipulador de eventos anuncia o evento que ocorreu. Além disso, o manipulador FunctionLockIndicatorChanged também controla se o aplicativo está no modo "Aprendizado" (_isLearningMode = true), o que impede que o evento borbulhe para outros manipuladores e permite que o usuário explore os recursos do teclado sem realmente executar a ação.

    void SetupSystemButtonEventController()
{
    // Create dispatcher queue controller and dispatcher queue
    _queueController = winrt::DispatcherQueueController::CreateOnDedicatedThread();
    _queue = _queueController.DispatcherQueue();

    // Create controller based on new created dispatcher queue
    _controller = winrt::SystemButtonEventController::CreateForDispatcherQueue(_queue);

    // Add Event Handler for each different event
    _fnKeyDownToken = _controller->FunctionButtonPressed(
        [](const winrt::SystemButtonEventController& /*sender*/, const winrt:: FunctionButtonEventArgs& args)
        {
            // Mock function to read the sentence "Fn button is pressed"
            PronounceFunctionButtonPressedMock();
            // Set Handled as true means this event is consumed by this controller
            // no more targets will receive this event
            args.Handled(true);
        });

        _fnKeyUpToken = _controller->FunctionButtonReleased(
            [](const winrt::SystemButtonEventController& /*sender*/, const winrt:: FunctionButtonEventArgs& args)
            {
                // Mock function to read the sentence "Fn button is up"
                PronounceFunctionButtonReleasedMock();
                // Set Handled as true means this event is consumed by this controller
                // no more targets will receive this event
                args.Handled(true);
            });

    _fnLockToken = _controller->FunctionLockChanged(
        [](const winrt::SystemButtonEventController& /*sender*/, const winrt:: FunctionLockChangedEventArgs& args)
        {
            // Mock function to read the sentence "Fn shift is locked/unlocked"
            PronounceFunctionLockMock(args.IsLocked());
            // Set Handled as true means this event is consumed by this controller
            // no more targets will receive this event
            args.Handled(true);
        });

    _fnLockIndicatorToken = _controller->FunctionLockIndicatorChanged(
        [](const winrt::SystemButtonEventController& /*sender*/, const winrt:: FunctionLockIndicatorChangedEventArgs& args)
        {
            // Mock function to read the sentence "Fn lock indicator is on/off"
            PronounceFunctionLockIndicatorMock(args.IsIndicatorOn());
            // In learning mode, the user is exploring the keyboard. They expect the program
            // to announce what the key they just pressed WOULD HAVE DONE, without actually
            // doing it. Therefore, handle the event when in learning mode so the key is ignored
            // by the system.
            args.Handled(_isLearningMode);
        });
}

Confira também

SystemButtonEventController Classe