LampArray.AvailabilityChanged イベント

定義

名前空間:

Windows.Devices.Lights

IsAvailable の値が変更されると発生します。これは、ユーザーがデバイス設定を介してデバイスへのシステム アクセスを変更したときに発生する可能性があります。

イベント ハンドラーのパラメーターは、プロパティが変更された送信者 LampArray と Object (常に null) です。

// Register
event_token AvailabilityChanged(TypedEventHandler<LampArray, IInspectable const&> const& handler) const;

// Revoke with event_token
void AvailabilityChanged(event_token const* cookie) const;

// Revoke with event_revoker
LampArray::AvailabilityChanged_revoker AvailabilityChanged(auto_revoke_t, TypedEventHandler<LampArray, IInspectable const&> const& handler) const;

public event TypedEventHandler<LampArray,object> AvailabilityChanged;

function onAvailabilityChanged(eventArgs) { /* Your code */ }
lampArray.addEventListener("availabilitychanged", onAvailabilityChanged);
lampArray.removeEventListener("availabilitychanged", onAvailabilityChanged);
- or -
lampArray.onavailabilitychanged = onAvailabilityChanged;

Public Custom Event AvailabilityChanged As TypedEventHandler(Of LampArray, Object) 

イベントの種類

TypedEventHandler<LampArray,Object>

TypedEventHandler<LampArray,IInspectable>

Windows の要件

デバイス ファミリ	Windows 11 Insider Preview (10.0.23504.0 で導入)
API contract	Windows.Foundation.UniversalApiContract (v15.0 で導入)

例

LampArray サンプル

Windows.Devices.Lights API と Windows.Devices.Lights.Effects API を使用して周辺機器の RGB 照明を制御する方法を示します。

AutoRGB サンプル

デスクトップ画面から 1 つの代表的な色を抽出し、それを使用して、接続された RGB デバイス上の LED ランプを点灯させる方法を示します。

AvailabilityChanged イベントの例

次の例は、イベントのハンドラーを設定する方法を AvailabilityChanged 示しています。 ハンドラーを宣言する前に、 IsAvailable コードでプロパティが使用可能かどうかを最初に確認する方法に注意してください。

using System;
using System.Collections.Generic;
using Windows.Devices.Enumeration;
using Windows.Devices.Lights;

namespace Sample
{
    class LampArrayHelper
    {
        private readonly DeviceWatcher watcher;
        private readonly Dictionary<string, LampArray> lampArrays;
        private readonly Dictionary<string, LampArrayEffectPlaylist> playlists;

        public LampArraySample()
        {
            lampArrays = new Dictionary<string, LampArray>();
            playlists = new Dictionary<string, LampArrayEffectPlaylist>();

            watcher = DeviceInformation.CreateWatcher(LampArray.GetDeviceSelector());

            watcher.Added += Watcher_Added;
            watcher.Removed += Watcher_Removed;

            watcher.Start();
        }

        private void DoEffectSetup(LampArray device)
        {
            Console.WriteLine("Starting effect playlist...");

            var indices = Enumerable.Range(0, device.LampCount).ToArray();

            var effect = new LampArraySolidEffect(device, indices)
            {
                Color = Colors.Red,
                CompletionBehavior = LampArrayEffectCompletionBehavior.KeepState,
                Duration = TimeSpan.FromMilliseconds(3000)
            };

            var effect2 = new LampArraySolidEffect(device, indices)
            {
                Color = Colors.Blue,
                CompletionBehavior = LampArrayEffectCompletionBehavior.KeepState,
                Duration = TimeSpan.FromMilliseconds(3000)
            };

            var playlist = new LampArrayEffectPlaylist();
            playlist.Append(effect);
            playlist.Append(effect2);
            playlist.Start();

            lock (playlists)
            {
                playlists.Add(device.DeviceId, playlist);
            }
        }

        private async void Watcher_Added(DeviceWatcher sender, DeviceInformation args)
        {
            var lampArray = await LampArray.FromIdAsync(args.Id);

            lock (lampArrays)
            {
                lampArrays[args.Id] = lampArray;
            }

            if (lampArray.LampArrayKind == LampArrayKind.Headset)
            {
                Console.WriteLine("Headset LampArray attached: " + lampArray.DeviceId);
            }

            if (ApiInformation.IsPropertyPresent("Windows.Devices.Lights.LampArray", "IsAvailable"))
            {
                if (lampArray.IsAvailable)
                {
                    DoEffectSetup(lampArray);
                }

                lampArray.AvailabilityChanged += LampArray_AvailabilityChanged;
            }
            else
            {
                DoEffectSetup(lampArray);
            }
        }

        private void Watcher_Removed(DeviceWatcher sender, DeviceInformationUpdate args)
        {
            lock (lampArrays)
            {
                lampArrays.Remove(args.Id);
            }

            lock (playlists)
            {
                if (playlists.ContainsKey(args.Id))
                {
                    playlists[args.Id].Stop();
                    playlists.Remove(args.Id);
                }
            }
        }

        private void LampArray_AvailabilityChanged(LampArray sender, object args)
        {
            if (sender.IsAvailable)
            {
                Console.WriteLine("Device available: " + sender.DeviceId);
                DoEffectSetup(sender);
            }
            else
            {
                Console.WriteLine("Device unavailable: " + sender.DeviceId);

                lock (playlists)
                {
                    if (playlists.ContainsKey(sender.DeviceId))
                    {
                        playlists[sender.DeviceId].Stop();
                        playlists.Remove(sender.DeviceId);
                    }
                }
            }
        }
    }
}

#include <windows.h>

#include <algorithm>
#include <memory>
#include <numeric>
#include <vector>
#include <map>

#include <wil/resource.h>

#include <winrt/base.h>
#include <winrt/windows.devices.lights.h>
#include <winrt/windows.devices.lights.effects.h>
#include <winrt/windows.devices.enumeration.h>
#include <winrt/windows.foundation.h>
#include <winrt/windows.foundation.metadata.h>
#include <winrt/windows.ui.h>

namespace winrt
{
    using namespace winrt::Windows::Devices::Enumeration;
    using namespace winrt::Windows::Devices::Lights;
    using namespace winrt::Windows::Devices::Lights::Effects;
    using namespace winrt::Windows::Foundation;
    using namespace winrt::Windows::Foundation::Metadata;
    using namespace winrt::Windows::UI;
}

wil::srwlock lampArraysLock;
std::shared_ptr<std::map<winrt::hstring, winrt::LampArray>> lampArrays;

wil::srwlock playlistsLock;
std::shared_ptr<std::map<winrt::hstring, winrt::LampArrayEffectPlaylist>> playlists;

void DoEffectSetup(winrt::LampArray device)
{
    wprintf(L"Starting effect playlist...\n");

    std::vector<int32_t> indices(device.LampCount());
    std::iota(indices.begin(), indices.end(), 0);

    auto effect = winrt::LampArraySolidEffect(device, indices);
    effect.Color(winrt::Colors::Red());
    effect.CompletionBehavior(winrt::LampArrayEffectCompletionBehavior::KeepState);
    effect.Duration(std::chrono::milliseconds(3000));

    auto effect2 = winrt::LampArraySolidEffect(device, indices);
    effect2.Color(winrt::Colors::Blue());
    effect2.CompletionBehavior(winrt::LampArrayEffectCompletionBehavior::KeepState);
    effect2.Duration(std::chrono::milliseconds(3000));

    auto playlist = winrt::LampArrayEffectPlaylist();
    playlist.RepetitionMode(winrt::LampArrayRepetitionMode::Forever);

    playlist.Append(effect);
    playlist.Append(effect2);
    playlist.Start();

    auto lock = playlistsLock.lock_exclusive();
    playlists->emplace(std::make_pair(device.DeviceId(), playlist));
}

int __cdecl main()
{
    lampArrays = std::make_shared<std::map<winrt::hstring, winrt::LampArray>>();
    playlists = std::make_shared<std::map<winrt::hstring, winrt::LampArrayEffectPlaylist>>();

    auto deviceWatcher = winrt::DeviceInformation::CreateWatcher(winrt::LampArray::GetDeviceSelector());

    auto deviceAddedRevoker = deviceWatcher.Added(winrt::auto_revoke, [](winrt::DeviceWatcher, winrt::DeviceInformation info)
    {
        auto deviceId = info.Id();
        auto lampArray = winrt::LampArray::FromIdAsync(deviceId).get();

        if (lampArray)
        {
            wprintf(L"LampArray %s added\n", deviceId.c_str());

            {
                auto lock = lampArraysLock.lock_exclusive();
                lampArrays->emplace(std::make_pair(deviceId, lampArray));
            }

            if (winrt::ApiInformation::IsPropertyPresent(L"Windows.Devices.Lights.LampArray", L"IsAvailable"))
            {
                if (lampArray.IsAvailable())
                {
                    DoEffectSetup(lampArray);
                }

                lampArray.AvailabilityChanged([](winrt::LampArray device, winrt::IInspectable)
                {
                    if (device.IsAvailable())
                    {
                        wprintf(L"Device available: %s\n", device.DeviceId().c_str());
                        DoEffectSetup(device);
                    }
                    else
                    {
                        wprintf(L"Device unavailable: %s\n", device.DeviceId().c_str());

                        auto lock = playlistsLock.lock_exclusive();

                        auto entry = playlists->find(device.DeviceId());
                        if (entry != playlists->end())
                        {
                            entry->second.Stop();
                            playlists->erase(entry);
                        }
                    }
                });
            }
            else
            {
                DoEffectSetup(lampArray);
            }
        }
    });

    auto deviceRemovedRevoker = deviceWatcher.Removed(winrt::auto_revoke, [](winrt::DeviceWatcher, winrt::DeviceInformationUpdate info)
    {
        auto deviceId = info.Id();

        {
            auto lock = lampArraysLock.lock_exclusive();
            lampArrays->erase(deviceId);
        }

        {
            auto lock = playlistsLock.lock_exclusive();

            auto entry = playlists->find(deviceId);
            if (entry != playlists->end())
            {
                entry->second.Stop();
                playlists->erase(entry);
            }
        }

        wprintf(L"LampArray %s removed\n", deviceId.c_str());
    });

    deviceWatcher.Start();

    wprintf(L"Press any key to exit\n");
    getchar();

    deviceWatcher.Stop();

    return 0;
}

注釈

フォアグラウンド アプリとバックグラウンド アプリ ("アンビエント") の両方で、このイベントを受信して処理できます。

このイベントを使用するには、アプリ マニフェストで "com.microsoft.windows.lighting" AppExtension を宣言する必要があります。 その方法の詳細については、「 アプリ拡張機能を作成してホストする」を参照してください。

<Extensions>
    <uap3:Extension Category="windows.appExtension">
        <uap3:AppExtension Name="com.microsoft.windows.lighting" Id="Id" DisplayName="Id">
        </uap3:AppExtension> 
    </uap3:Extension>
</Extensions>

こちらもご覧ください

• IsAvailable
• 照明と照明 (www.usb.org)
• 動的ライティング