Leitores de tela e botões do sistema de hardware

Os leitores de ecrã, como o Narrador, devem ser capazes de reconhecer e manipular eventos dos botões do sistema de hardware e comunicar o seu estado aos utilizadores. Em alguns casos, o leitor de ecrã pode precisar lidar exclusivamente com esses eventos de botão de hardware e impedir que os eventos passem para outros manipuladores.

A partir do Windows 10 versão 2004, as aplicações UWP podem escutar e tratar os eventos do botão de sistema de hardware Fn da mesma forma 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 um novo SystemButtonEventController Class no namespace Windows.UI.Input. O objeto SystemButtonEventController suporta os seguintes eventos:

• BotãoDeFunçãoDoSistemaPressionado
• BotaoFuncaoSistemaLiberado
• SystemFunctionLockChanged
• IndicadorDeBloqueioDeFunçãoDoSistemaAlterado

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, premir o botão Fn num teclado do Surface dispara 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 que são retornados ao registar delegados de manipulação de eventos no 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á em "Modo de Aprendizagem" (onde o usuário está simplesmente tentando explorar o teclado sem executar nenhuma função).

   winrt::event_token _fnLockIndicatorToken;
   bool _isLearningMode = false;
   

3. Este terceiro trecho inclui os delegados do manipulador de eventos correspondentes para cada evento suportado pelo 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 "Learning" (_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);
           });
   }
   

Ver também

SystemButtonEventController Classe