Share via

Utilità per la lettura dello schermo e pulsanti di sistema hardware

  • Articolo

Le utilità per la lettura dello schermo, ad esempio l'Assistente vocale, devono essere in grado di riconoscere e gestire gli eventi dei pulsanti del sistema hardware e di comunicare il proprio stato agli utenti. In alcuni casi, l'utilità per la lettura dello schermo potrebbe dover gestire questi hardware in modo esclusivo e non consentire loro di passare ad altri gestori.

A partire da Windows 10 versione 2004, le applicazioni UWP possono ascoltare e gestire gli eventi del pulsante del sistema hardware Fn nello stesso modo degli altri pulsanti hardware. In precedenza, questo pulsante di sistema fungeva solo da modificatore per il modo in cui gli altri pulsanti hardware segnalavano gli eventi e lo stato.

Nota

Il supporto del pulsante Fn è specifico dell'OEM e può includere funzionalità come la possibilità di attivare/bloccare o disattivare (rispetto a una combinazione di tasti di pressione e blocco), insieme a una luce indicatore di blocco corrispondente (che potrebbe non essere utile per gli utenti che sono ciechi o hanno problemi di vista).

Gli eventi del pulsante Fn vengono esposti tramite una nuova classe SystemButtonEventController nello spazio dei nomi Windows.UI.Input . L'oggetto SystemButtonEventController supporta gli eventi seguenti:

Importante

SystemButtonEventController non può ricevere questi eventi se sono già stati gestiti da un gestore con priorità più alta.

Esempi

Negli esempi seguenti viene illustrato come creare un SystemButtonEventController basato su DispatcherQueue e gestire i quattro eventi supportati da questo oggetto.

È comune che più eventi supportati vengano attivati quando viene premuto il pulsante Fn. Ad esempio, premendo il pulsante Fn su una tastiera surface viene attivato SystemFunctionButtonPressed, SystemFunctionLockChanged e SystemFunctionLockIndicatorChanged contemporaneamente.

  1. In questo primo frammento di codice vengono semplicemente inclusi gli spazi dei nomi necessari e vengono specificati alcuni oggetti globali, inclusi gli oggetti DispatcherQueue e DispatcherQueueController per la gestione del thread SystemButtonEventController .

    Si specificano quindi i token evento restituiti durante la registrazione dei delegati di gestione degli eventi 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. Specifichiamo anche un token di evento per l'evento SystemFunctionLockIndicatorChanged insieme a un bool per indicare se l'applicazione è in modalità di apprendimento (dove l'utente sta semplicemente provando a esplorare la tastiera senza eseguire alcuna funzione).

    winrt::event_token _fnLockIndicatorToken;
bool _isLearningMode = false;

  3. Questo terzo frammento include i delegati del gestore eventi corrispondenti per ogni evento supportato dall'oggetto SystemButtonEventController .

    Ogni gestore eventi annuncia l'evento che si è verificato. Inoltre, il gestore FunctionLockIndicatorChanged controlla anche se l'app è in modalità "Learning" (_isLearningMode = true), che impedisce l'evento di bubbling ad altri gestori e consente all'utente di esplorare le funzionalità della tastiera senza effettivamente eseguire l'azione.

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

Vedi anche

Classe SystemButtonEventController