Leitores de tela e botões de sistema do hardware

Leitores de tela, como o Narrador, devem saber reconhecer e tratar eventos de botão do sistema de hardware e comunicar o estado deles aos usuários. Em alguns casos, o leitor de tela pode precisar lidar com 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.

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

• SystemFunctionButtonPressed
• SystemFunctionButtonReleased
• SystemFunctionLockChanged
• SystemFunctionLockIndicatorChanged

Exemplos

Nos exemplos a seguir, mostramos como criar um SystemButtonEventController com base em um DispatcherQueue e manipular os quatro eventos compatíveis com 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 snippet, 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 Aprendizagem" (em que o usuário está simplesmente tentando explorar o teclado sem executar nenhuma função).

   winrt::event_token _fnLockIndicatorToken;
   bool _isLearningMode = false;
   

3. Esse terceiro snippet inclui os delegados do manipulador de eventos correspondentes para cada evento com suporte do 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 "Aprendizagem" (_isLearningMode = true), o que impede que o evento se espalhe 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

Classe SystemButtonEventController