Sprachausgaben und Hardwaresystemschaltflächen

Bildschirmleseprogramme, wie zum Beispiel Sprachausgabe, müssen Hardware-Systemschaltflächenereignisse erkennen und verarbeiten können und ihren Zustand den Benutzern mitteilen. In einigen Fällen muss die Sprachausgabe diese Hardwaretastenereignisse eventuell allein behandeln und nicht zulassen, dass sie zu anderen Handlern weitergeleitet werden.

Ab Version 2004 von Windows 10 können UWP-Anwendungen die Fn Hardware-Systemtastenereignisse auf die gleiche Weise überwachen und verarbeiten wie andere Hardwaretasten. Bisher fungierte diese Systemschaltfläche nur als Modifier zum Melden der Ereignisse und des Zustands anderer Hardwareschaltflächen.

Fn-Schaltflächenereignisse werden über eine neue SystemButtonEventController-Klasse im Windows.UI.Input--Namespace bereitgestellt. Das SystemButtonEventController-Objekt unterstützt die folgenden Ereignisse:

• SystemFunctionButtonPressed
• SystemfunktionstasteFreigegeben
• SystemfunktionssperreGeändert
• SystemFunktionsSperrIndikatorGeändert

Beispiele

In den folgenden Beispielen zeigen wir Ihnen, wie Sie einen SystemButtonEventController- basierend auf einer DispatcherQueue erstellen und die von diesem Objekt unterstützten vier Ereignisse behandeln.

Es ist üblich, dass mehrere der unterstützten Ereignisse ausgelöst werden, wenn die Fn-Taste gedrückt wird. Wenn Sie z. B. die Fn-Taste auf einer Surface-Tastatur drücken, werden SystemFunctionButtonPressed, SystemFunctionLockChanged und SystemFunctionLockIndicatorChanged gleichzeitig ausgelöst.

1. In diesem ersten Codeausschnitt binden wir einfach die erforderlichen Namespaces ein und geben einige globale Objekte an, einschließlich der DispatcherQueue- und DispatcherQueueController- Objekte zur Verwaltung des Threads des SystemButtonEventController.

   Anschließend spezifizieren wir die Ereignistoken, die beim Registrieren der SystemButtonEventController Ereignisbehandlungsdelegierten zurückgegeben werden.

   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. Außerdem geben wir ein Ereignistoken für das SystemFunctionLockIndicatorChanged-Ereignis zusammen mit einem Bool an, um anzugeben, ob sich die Anwendung im "Lernmodus" befindet (wobei der Benutzer einfach versucht, die Tastatur zu erkunden, ohne Funktionen auszuführen).

   winrt::event_token _fnLockIndicatorToken;
   bool _isLearningMode = false;
   

3. Dieser dritte Codeausschnitt enthält die entsprechenden Ereignishandlerdelegaten für jedes Ereignis, das vom SystemButtonEventController-Objekt unterstützt wird.

   Jeder Ereignishandler gibt das aufgetretene Ereignis an. Darüber hinaus steuert der FunctionLockIndicatorChanged-Handler auch, ob sich die App im "Learning"-Modus befindet (_isLearningMode = true), wodurch verhindert wird, dass das Ereignis an andere Handler weitergegeben wird und der Benutzer die Tastaturfunktionen erkunden kann, ohne die Aktion wirklich auszuführen.

   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);
           });
   }
   

Siehe auch

SystemButtonEventController-Klasse