Bagikan melalui

Pembaca layar dan tombol sistem perangkat keras

  • Artikel

Pembaca layar, seperti Narator, harus dapat mengenali dan menangani peristiwa tombol sistem perangkat keras dan mengomunikasikan status mereka kepada pengguna. Dalam beberapa kasus, pembaca layar mungkin perlu menangani peristiwa tombol perangkat keras ini secara eksklusif dan tidak membiarkannya menggelegak ke handler lain.

Dimulai dengan Windows 10 versi 2004, aplikasi UWP dapat mendengarkan dan menangani peristiwa tombol sistem perangkat keras Fn dengan cara yang sama seperti tombol perangkat keras lainnya. Sebelumnya, tombol sistem ini hanya bertindak sebagai pengubah tentang bagaimana tombol perangkat keras lainnya melaporkan peristiwa dan statusnya.

Catatan

Dukungan tombol Fn khusus OEM dan dapat mencakup fitur seperti kemampuan untuk mengaktifkan atau mengunci (vs. kombinasi tombol tekan dan tahan), bersama dengan lampu indikator kunci yang sesuai (yang mungkin tidak membantu pengguna yang buta atau mengalami gangguan penglihatan).

Peristiwa tombol Fn diekspos melalui Kelas SystemButtonEventController baru di namespace Windows.UI.Input. Objek SystemButtonEventController mendukung peristiwa berikut:

Penting

SystemButtonEventController tidak dapat menerima peristiwa ini jika telah ditangani oleh handler prioritas yang lebih tinggi.

Contoh

Dalam contoh berikut, kami menunjukkan cara membuat SystemButtonEventController berdasarkan DispatcherQueue dan menangani empat peristiwa yang didukung oleh objek ini.

Umum bagi lebih dari salah satu peristiwa yang didukung untuk diaktifkan ketika tombol Fn ditekan. Misalnya, menekan tombol Fn pada keyboard Surface mengaktifkan SystemFunctionButtonPressed, SystemFunctionLockChanged, dan SystemFunctionLockIndicatorChanged secara bersamaan.

  1. Dalam cuplikan pertama ini, kami hanya menyertakan namespace yang diperlukan dan menentukan beberapa objek global, termasuk objek DispatcherQueue dan DispatcherQueueController untuk mengelola utas SystemButtonEventController .

    Kami kemudian menentukan token peristiwa yang dikembalikan saat mendaftarkan delegasi penanganan peristiwa 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. Kami juga menentukan token peristiwa untuk peristiwa SystemFunctionLockIndicatorChanged bersama dengan bool untuk menunjukkan apakah aplikasi berada dalam "Mode Pembelajaran" (di mana pengguna hanya mencoba menjelajahi keyboard tanpa melakukan fungsi apa pun).

    winrt::event_token _fnLockIndicatorToken;
bool _isLearningMode = false;

  3. Cuplikan ketiga ini mencakup delegasi penanganan aktivitas yang sesuai untuk setiap peristiwa yang didukung oleh objek SystemButtonEventController .

    Setiap penanganan aktivitas mengumumkan peristiwa yang telah terjadi. Selain itu, handler FunctionLockIndicatorChanged juga mengontrol apakah aplikasi berada dalam mode "Learning" (_isLearningMode = true), yang mencegah peristiwa menggelegak ke handler lain dan memungkinkan pengguna menjelajahi fitur keyboard tanpa benar-benar melakukan tindakan.

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

Lihat juga

Kelas SystemButtonEventController