InputDeviceSetting.cs.txt

using System;
using System.Collections.Generic;
using System.Linq;
using Assets.Metater;
using R3;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

public class InputDeviceSetting : MetaMb<InputDeviceSetting>, IInitableSetting
{
    private static readonly string NoMicrophoneDetected = "No Microphone Detected";

    public SerializableReactiveProperty<string> selectedDevice = new(null);

    [Header("Colors")]
    public Color missingColor; // no mic at all
    public Color disconnectedColor; // saved mic is not connected
    public Color nominalColor;
    public Color missingTextColor;
    public Color nominalTextColor;

    [Header("UI")]
    public TMP_Text text;
    public TMP_Dropdown dropdown;
    public Button resetButton;

    private string PlayerPrefsKey => name;

    private bool isInit = false;

    private void Awake()
    {
        dropdown.onValueChanged.AddListener(OnDropdownValueChanged);
        resetButton.onClick.AddListener(OnResetButtonClicked);

        Init();
    }

    private void OnDropdownValueChanged(int i)
    {
        AudioSystem.Instance.PlayClickSfx();

        string device = dropdown.options[i].text;
        if (string.IsNullOrWhiteSpace(device) || device == NoMicrophoneDetected)
        {
            return;
        }

        selectedDevice.Value = device;
    }

    private void OnResetButtonClicked()
    {
        if (dropdown.options.Count != 0)
        {
            OnDropdownValueChanged(0);
        }
    }

    public void Init()
    {
        if (isInit)
        {
            return;
        }

        isInit = true;

        string defaultDevice = Microphone.devices.Length > 0 ? Microphone.devices[0] : null;
        selectedDevice.Value = PlayerPrefs.GetString(PlayerPrefsKey, defaultDevice);

        selectedDevice.Subscribe(selectedDevice =>
        {
            RefreshOptions(Microphone.devices, selectedDevice);

            if (selectedDevice == null)
            {
                return;
            }

            PlayerPrefs.SetString(PlayerPrefsKey, selectedDevice);
        }).AddTo(this);
    }

    public void Delta(string[] devices, string activeDevice)
    {
        Init();

        text.text = activeDevice ?? NoMicrophoneDetected;
        if (activeDevice == null)
        {
            text.color = missingTextColor;
        }
        else
        {
            text.color = nominalTextColor;

            if (string.IsNullOrEmpty(selectedDevice.Value))
            {
                selectedDevice.Value = activeDevice;
            }
        }

        RefreshOptions(devices, selectedDevice.Value);
    }

    private void RefreshOptions(string[] devices, string selectedDevice)
    {
        dropdown.ClearOptions();

        if (devices.Length == 0)
        {
            if (selectedDevice == null)
            {
                SetGraphicState(GraphicState.Missing);
            }
            else
            {
                dropdown.AddOptions(new List<TMP_Dropdown.OptionData> { new(selectedDevice) });
                SetGraphicState(GraphicState.Disconnected);

                dropdown.SetValueWithoutNotify(0);
            }
        }
        else
        {
            if (devices.Contains(selectedDevice))
            {
                dropdown.AddOptions(devices.Select(d => new TMP_Dropdown.OptionData(d)).ToList());
                SetGraphicState(GraphicState.Nominal);

                dropdown.SetValueWithoutNotify(DropdownIndexOf(selectedDevice));
            }
            else if (string.IsNullOrWhiteSpace(selectedDevice))
            {
                dropdown.AddOptions(devices.Select(d => new TMP_Dropdown.OptionData(d)).ToList());
                SetGraphicState(GraphicState.Nominal);

                dropdown.SetValueWithoutNotify(0);

                this.selectedDevice.Value = devices[0];
            }
            else
            {
                dropdown.AddOptions(devices.Select(d => new TMP_Dropdown.OptionData(d)).ToList());
                dropdown.AddOptions(new List<TMP_Dropdown.OptionData> { new(selectedDevice) });
                SetGraphicState(GraphicState.Disconnected);

                dropdown.SetValueWithoutNotify(devices.Length);
            }
        }
    }

    private int DropdownIndexOf(string device)
    {
        for (int i = 0; i < dropdown.options.Count; i++)
        {
            if (dropdown.options[i].text == device)
            {
                return i;
            }
        }

        return -1; // Not found
    }

    private void SetGraphicState(GraphicState graphicState)
    {
        dropdown.targetGraphic.color = graphicState switch
        {
            GraphicState.Missing => missingColor,
            GraphicState.Disconnected => disconnectedColor,
            _ => nominalColor,
        };
    }

    private enum GraphicState
    {
        Missing,
        Disconnected,
        Nominal
    }
}