com.amanotes.gdk 0.2.65-2 → 0.2.65-4

package/Runtime/AudioToolkit/Plugins/Android/AudioDeviceDetector.java

@@ -0,0 +1,321 @@
+package com.amanotes.audio;
+
+import android.content.Context;
+import android.media.AudioDeviceInfo;
+import android.media.AudioDeviceCallback;
+import android.media.AudioManager;
+import android.media.MediaRouter;
+import android.os.Build;
+import android.util.Log;
+import java.util.HashMap;
+import java.util.Map;
+
+import com.unity3d.player.UnityPlayer;
+
+public class AudioDeviceDetector
+{
+    private static boolean isRegistered = false;
+    private static boolean isFirstCallback = true;
+
+    private static final String PARAM_FORMAT = "%s;%s";
+    private static final String DEFAULT_HEADPHONE_NAME = "h2w";
+
+    private static MediaRouter.RouteInfo currentRoute;
+
+    private static final Map<Integer, String> DEVICE_TYPE_MAP = new HashMap<>();
+    static {
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_UNKNOWN, "TYPE_UNKNOWN");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_BUILTIN_EARPIECE, "TYPE_BUILTIN_EARPIECE");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_BUILTIN_SPEAKER, "TYPE_BUILTIN_SPEAKER");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_WIRED_HEADSET, "TYPE_WIRED_HEADSET");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_WIRED_HEADPHONES, "TYPE_WIRED_HEADPHONES");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_LINE_ANALOG, "TYPE_LINE_ANALOG");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_LINE_DIGITAL, "TYPE_LINE_DIGITAL");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_BLUETOOTH_SCO, "TYPE_BLUETOOTH_SCO");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_BLUETOOTH_A2DP, "TYPE_BLUETOOTH_A2DP");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_HDMI, "TYPE_HDMI");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_HDMI_ARC, "TYPE_HDMI_ARC");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_USB_DEVICE, "TYPE_USB_DEVICE");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_USB_ACCESSORY, "TYPE_USB_ACCESSORY");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_DOCK, "TYPE_DOCK");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_FM, "TYPE_FM");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_BUILTIN_MIC, "TYPE_BUILTIN_MIC");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_FM_TUNER, "TYPE_FM_TUNER");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_TV_TUNER, "TYPE_TV_TUNER");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_TELEPHONY, "TYPE_TELEPHONY");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_AUX_LINE, "TYPE_AUX_LINE");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_IP, "TYPE_IP");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_BUS, "TYPE_BUS");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_USB_HEADSET, "TYPE_USB_HEADSET");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_HEARING_AID, "TYPE_HEARING_AID");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_BUILTIN_SPEAKER_SAFE, "TYPE_BUILTIN_SPEAKER_SAFE");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_REMOTE_SUBMIX, "TYPE_REMOTE_SUBMIX");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_BLE_HEADSET, "TYPE_BLE_HEADSET");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_BLE_SPEAKER, "TYPE_BLE_SPEAKER");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_HDMI_EARC, "TYPE_HDMI_EARC");
+        DEVICE_TYPE_MAP.put(AudioDeviceInfo.TYPE_BLE_BROADCAST, "TYPE_BLE_BROADCAST");
+    }
+
+    public static void registerEvents() {
+        if (isRegistered)
+            return;
+        isRegistered = true;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            registerForVersionM();
+        } else {
+            registerForVersionBeforeM();
+        }
+    }
+
+    public static String getAudioInfo() {
+        return (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
+                ? getActiveParamM()
+                : getActiveParamBeforeM();
+    }
+
+    private static void registerForVersionM() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M)
+            return;
+        Context unityContext = UnityPlayer.currentActivity.getApplicationContext();
+        if (unityContext == null)
+            return;
+        AudioManager audioManager = (AudioManager) unityContext.getSystemService(Context.AUDIO_SERVICE);
+        if (audioManager == null)
+            return;
+
+        audioManager.registerAudioDeviceCallback(new AudioDeviceCallback() {
+            @Override
+            public void onAudioDevicesAdded(AudioDeviceInfo[] addedDevices) {
+                super.onAudioDevicesAdded(addedDevices);
+                if (isFirstCallback) {
+                    isFirstCallback = false;
+                    return;
+                }
+                for (AudioDeviceInfo deviceInfo : addedDevices) {
+                    if (deviceInfo == null)
+                        continue;
+                    if (deviceInfo.isSink()) {
+                        String param = GetParamForDevice(deviceInfo);
+                        UnityPlayer.UnitySendMessage("AmaGDK", "OnAudioDeviceAdded", param);
+                    }
+                }
+            }
+
+            @Override
+            public void onAudioDevicesRemoved(AudioDeviceInfo[] removedDevices) {
+                super.onAudioDevicesRemoved(removedDevices);
+                for (AudioDeviceInfo deviceInfo : removedDevices) {
+                    if (deviceInfo == null)
+                        continue;
+                    if (deviceInfo.isSink()) {
+                        String param = GetParamForDevice(deviceInfo);
+                        UnityPlayer.UnitySendMessage("AmaGDK", "OnAudioDeviceRemoved", param);
+                    }
+                }
+            }
+        }, null);
+
+        MediaRouter mediaRouter = (MediaRouter) unityContext.getSystemService(Context.MEDIA_ROUTER_SERVICE);
+        if (mediaRouter == null)
+            return;
+        //listen to route change
+        mediaRouter.addCallback(MediaRouter.ROUTE_TYPE_LIVE_AUDIO, new MediaRouter.SimpleCallback() {
+            @Override
+            public void onRouteChanged(MediaRouter router, MediaRouter.RouteInfo route) {
+                super.onRouteChanged(router, route);
+                //detect if change active device
+                if (route == router.getSelectedRoute(MediaRouter.ROUTE_TYPE_LIVE_AUDIO))
+                    return;
+                if (route.isEnabled() && route.getPlaybackType() == MediaRouter.RouteInfo.PLAYBACK_TYPE_LOCAL && route.getPlaybackStream() == AudioManager.STREAM_MUSIC) {
+                    //sent empty string to update current
+                    UnityPlayer.UnitySendMessage("AmaGDK", "OnAudioRouteChanged", "");
+                    currentRoute = route;
+                }
+            }
+
+            @Override
+            public void onRouteSelected(MediaRouter router, int type, MediaRouter.RouteInfo info) {
+                super.onRouteSelected(router, type, info);
+                //sent empty string to update current
+                UnityPlayer.UnitySendMessage("AmaGDK", "OnAudioRouteChanged", "");
+                currentRoute = info;
+            }
+        });
+    }
+
+    private static String getActiveParamM() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M)
+            return "";
+
+        Context unityContext = UnityPlayer.currentActivity.getApplicationContext();
+        if (unityContext == null)
+            return "";
+
+        MediaRouter mediaRouter = (MediaRouter) unityContext.getSystemService(Context.MEDIA_ROUTER_SERVICE);
+        if(mediaRouter == null)
+            return "";
+
+        AudioManager am = (AudioManager) unityContext.getSystemService(Context.AUDIO_SERVICE);
+        if (am == null)
+            return "";
+
+        if (currentRoute == null) {
+            currentRoute = mediaRouter.getSelectedRoute(MediaRouter.ROUTE_TYPE_LIVE_AUDIO);
+        }
+
+        AudioDeviceInfo device = null;
+        AudioDeviceInfo[] activeDevices = am.getDevices(AudioManager.GET_DEVICES_OUTPUTS);
+
+        if(activeDevices == null || activeDevices.length == 0)
+            return "";
+
+        String name = currentRoute.getName() != null ? currentRoute.getName().toString() : "";
+        for (AudioDeviceInfo deviceInfo : activeDevices) {
+            int type = deviceInfo.getType();
+            if (deviceInfo.getType() == AudioDeviceInfo.TYPE_BLUETOOTH_SCO)
+                continue;
+            if (isWiredDevice(type) || name.contentEquals(deviceInfo.getProductName())) {
+                device = deviceInfo;
+                break;
+            }
+        }
+
+        if(device != null)
+            return GetParamForDevice(device);
+
+        device = activeDevices[0];
+        for (AudioDeviceInfo deviceInfo : activeDevices) {
+            int type = deviceInfo.getType();
+            if (!deviceInfo.isSink())
+                continue;
+            if (am.isSpeakerphoneOn() && (type == AudioDeviceInfo.TYPE_BUILTIN_EARPIECE || type == AudioDeviceInfo.TYPE_BUILTIN_SPEAKER)) {
+                device = deviceInfo;
+                break;
+            }
+            if (am.isBluetoothA2dpOn() && type == AudioDeviceInfo.TYPE_BLUETOOTH_A2DP) {
+                device = deviceInfo;
+                break;
+            }
+            if (am.isBluetoothScoOn() && type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO) {
+                device = deviceInfo;
+                break;
+            }
+        }
+
+        if (device == null)
+            return "";
+        return GetParamForDevice(device);
+    }
+
+    private static boolean isWiredDevice(int type)
+    {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
+        {
+            return type == AudioDeviceInfo.TYPE_WIRED_HEADSET
+                    || type == AudioDeviceInfo.TYPE_WIRED_HEADPHONES
+                    || type == AudioDeviceInfo.TYPE_LINE_ANALOG
+                    || type == AudioDeviceInfo.TYPE_LINE_DIGITAL;
+        }
+
+        return false;
+    }
+
+    private static String GetParamForDevice(AudioDeviceInfo device)
+    {
+        if(device == null || Build.VERSION.SDK_INT < Build.VERSION_CODES.M)
+            return "";
+
+        int type = device.getType();
+        if (type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO)
+            return "";
+
+        CharSequence name = device.getProductName();
+        if (isWiredDevice(type) || DEFAULT_HEADPHONE_NAME.contentEquals(name)) {
+            return getReturnParam("Headphones", toTypeString(type));
+        }
+        return getReturnParam(name, toTypeString(type));
+    }
+
+    private static String getReturnParam(CharSequence name, String type)
+    {
+        return String.format(PARAM_FORMAT, name, type);
+    }
+
+    private static String toTypeString(int AudioDeviceType)
+    {
+        return DEVICE_TYPE_MAP.getOrDefault(AudioDeviceType, "TYPE_UNKNOWN");
+    }
+
+    // API For Version before M
+    private static String getActiveParamBeforeM()
+    {
+        Context unityContext = UnityPlayer.currentActivity.getApplicationContext();
+        if (unityContext == null)
+            return "";
+        AudioManager audioManager = (AudioManager) unityContext.getSystemService(Context.AUDIO_SERVICE);
+        if (audioManager == null)
+            return "";
+        MediaRouter mediaRouter = (MediaRouter) unityContext.getSystemService(Context.MEDIA_ROUTER_SERVICE);
+        if (mediaRouter == null)
+            return "";
+
+        String type = "NOT_AVAILABLE";
+        MediaRouter.RouteInfo routeInfo = mediaRouter.getSelectedRoute(MediaRouter.ROUTE_TYPE_LIVE_AUDIO);
+        if (audioManager.isBluetoothA2dpOn())
+            type = "TYPE_BLUETOOTH_A2DP";
+        else if (audioManager.isBluetoothScoOn())
+            type = "TYPE_BLUETOOTH_SCO";
+        else if (audioManager.isSpeakerphoneOn())
+            type = "TYPE_BUILTIN_SPEAKER";
+        return getReturnParam(routeInfo.getName(), type);
+    }
+
+    private static void registerForVersionBeforeM()
+    {
+        Context unityContext = UnityPlayer.currentActivity.getApplicationContext();
+        if (unityContext == null)
+            return;
+        MediaRouter mediaRouter = (MediaRouter) unityContext.getSystemService(Context.MEDIA_ROUTER_SERVICE);
+        if (mediaRouter == null)
+            return;
+
+        mediaRouter.addCallback(MediaRouter.ROUTE_TYPE_LIVE_AUDIO, new MediaRouter.SimpleCallback() {
+            @Override
+            public void onRouteChanged(MediaRouter router, MediaRouter.RouteInfo route) {
+                super.onRouteChanged(router, route);
+                //detect if change active device
+                if (route == router.getSelectedRoute(MediaRouter.ROUTE_TYPE_LIVE_AUDIO))
+                    return;
+                if (route.isEnabled() && route.getPlaybackType() == MediaRouter.RouteInfo.PLAYBACK_TYPE_LOCAL && route.getPlaybackStream() == AudioManager.STREAM_MUSIC) {
+                    UnityPlayer.UnitySendMessage("AmaGDK","OnAudioDeviceAdded", formatToParam(route));
+                }
+            }
+
+            @Override
+            public void onRouteSelected(MediaRouter router,int type, MediaRouter.RouteInfo info) {
+                super.onRouteRemoved(router, info);
+                UnityPlayer.UnitySendMessage("AmaGDK","OnAudioDeviceAdded", formatToParam(info));
+            }
+
+            @Override
+            public void onRouteUnselected(MediaRouter router,int type, MediaRouter.RouteInfo info) {
+                super.onRouteAdded(router, info);
+                UnityPlayer.UnitySendMessage("AmaGDK", "OnAudioDeviceRemoved", formatToParam(info));
+            }
+
+            @Override
+            public void onRouteRemoved(MediaRouter router, MediaRouter.RouteInfo info) {
+                super.onRouteRemoved(router, info);
+                UnityPlayer.UnitySendMessage("AmaGDK", "OnAudioDeviceRemoved", formatToParam(info));
+            }
+
+            private String formatToParam(MediaRouter.RouteInfo info)
+            {
+                if (info == null) return "";
+                String type = "NOT_AVAILABLE";
+                CharSequence name = info.getName();
+                return getReturnParam(name, type);
+            }
+        });
+    }
+}

package/Runtime/AudioToolkit/Plugins/Android/AudioDeviceDetector.java.meta

@@ -0,0 +1,32 @@
+fileFormatVersion: 2
+guid: 1db90e301ca5c40dcb36104b951a9cbc
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Android: Android
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/AudioToolkit/Plugins/Android.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d562032f6a0e5441f9bacd35bca95d3f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/AudioToolkit/Plugins/AudioDeviceDetector.cs

@@ -0,0 +1,208 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+using Amanotes.Core.Internal;
+using UnityEngine;
+
+namespace Amanotes.Core
+{
+    internal class AudioDeviceDetector : MonoBehaviour
+    {
+#if !UNITY_EDITOR && UNITY_IOS
+        [DllImport("__Internal")]
+        private static extern void _RegisterAudioInfoChanged();
+
+        [DllImport("__Internal")]
+        private static extern string _GetAudioInfo();
+
+        [DllImport("__Internal")]
+        private static extern string _GetCurrentRouteInputs();
+#endif
+
+#if !UNITY_EDITOR && UNITY_ANDROID
+        private readonly AndroidJavaClass _detectorClass = new AndroidJavaClass("com.amanotes.audio.AudioDeviceDetector");
+#endif
+
+        private static readonly Dictionary<string, AudioDeviceType> deviceTypeMapping = new Dictionary<string, AudioDeviceType>(StringComparer.OrdinalIgnoreCase)
+        {
+            //iOS
+            { "AVAudioSessionPortAirPlay", AudioDeviceType.Wireless },
+            { "AVAudioSessionPortBluetoothA2DP", AudioDeviceType.Bluetooth },
+            { "AVAudioSessionPortBluetoothLE", AudioDeviceType.Bluetooth },
+            { "AVAudioSessionPortBluetoothHFP", AudioDeviceType.Bluetooth },
+            { "AVAudioSessionPortBuiltInReceiver", AudioDeviceType.Internal },
+            { "AVAudioSessionPortBuiltInSpeaker", AudioDeviceType.Internal },
+            { "AVAudioSessionPortHDMI", AudioDeviceType.Wire },
+            { "AVAudioSessionPortHeadphones", AudioDeviceType.Wire },
+            { "AVAudioSessionPortLineOut", AudioDeviceType.Wire },
+            { "AVAudioSessionPortDisplayPort", AudioDeviceType.Wire },
+            { "AVAudioSessionPortCarAudio", AudioDeviceType.Wire },
+            { "AVAudioSessionPortFireWire", AudioDeviceType.Wire },
+            { "AVAudioSessionPortPCI", AudioDeviceType.Wire },
+            { "AVAudioSessionPortThunderbolt", AudioDeviceType.Wire },
+            { "AVAudioSessionPortUSBAudio", AudioDeviceType.Wire },
+            { "AVAudioSessionPortVirtual", AudioDeviceType.Wire },
+            //Android
+            { "TYPE_BLUETOOTH_SCO", AudioDeviceType.Bluetooth },
+            { "TYPE_BLUETOOTH_A2DP", AudioDeviceType.Bluetooth },
+            { "TYPE_BLE_HEADSET", AudioDeviceType.Bluetooth },
+            { "TYPE_BLE_SPEAKER", AudioDeviceType.Bluetooth },
+            { "TYPE_BLE_BROADCAST", AudioDeviceType.Bluetooth },
+            { "TYPE_BUILTIN_SPEAKER_SAFE", AudioDeviceType.Internal },
+            { "TYPE_BUILTIN_MIC", AudioDeviceType.Internal },
+            { "TYPE_BUILTIN_EARPIECE", AudioDeviceType.Internal },
+            { "TYPE_BUILTIN_SPEAKER", AudioDeviceType.Internal },
+            { "TYPE_USB_HEADSET", AudioDeviceType.Wire },
+            { "TYPE_USB_DEVICE", AudioDeviceType.Wire },
+            { "TYPE_USB_ACCESSORY", AudioDeviceType.Wire },
+            { "TYPE_TELEPHONY", AudioDeviceType.Wire },
+            { "TYPE_LINE_ANALOG", AudioDeviceType.Wire },
+            { "TYPE_LINE_DIGITAL", AudioDeviceType.Wire },
+            { "TYPE_HDMI_ARC", AudioDeviceType.Wire },
+            { "TYPE_HDMI_EARC", AudioDeviceType.Wire },
+            { "TYPE_HDMI", AudioDeviceType.Wire },
+            { "TYPE_DOCK", AudioDeviceType.Wire },
+            { "TYPE_AUX_LINE", AudioDeviceType.Wire },
+            { "TYPE_WIRED_HEADSET", AudioDeviceType.Wire },
+            { "TYPE_WIRED_HEADPHONES", AudioDeviceType.Wire },
+            { "TYPE_FM", AudioDeviceType.Wireless },
+            { "TYPE_FM_TUNER", AudioDeviceType.Wireless },
+            { "TYPE_IP", AudioDeviceType.Wireless },
+            { "TYPE_REMOTE_SUBMIX", AudioDeviceType.Unknown },
+            { "TYPE_BUS", AudioDeviceType.Unknown },
+            { "TYPE_HEARING_AID", AudioDeviceType.Unknown },
+            { "TYPE_UNKNOWN", AudioDeviceType.Unknown },
+            { "TYPE_TV_TUNER", AudioDeviceType.Unknown }
+        };
+
+        internal event Action<string> onChanged;
+        internal event Action<string> onInterrupted;
+
+        private void OnAudioInterrupted(string param)
+        {
+            onInterrupted?.Invoke(param);
+        }
+
+        private void OnAudioDeviceAdded(string param)
+        {
+            if (string.IsNullOrEmpty(param))
+                return;
+            onChanged?.Invoke(param);
+        }
+
+        private void OnAudioDeviceRemoved(string param)
+        {
+            if (string.IsNullOrEmpty(param))
+                return;
+            onChanged?.Invoke(param);
+        }
+
+        private void OnAudioRouteChanged(string param)
+        {
+            onChanged?.Invoke(param);
+        }
+
+        internal void RegisterEvents()
+        {
+#if !UNITY_EDITOR && UNITY_IOS
+            _RegisterAudioInfoChanged();
+#elif !UNITY_EDITOR && UNITY_ANDROID
+            _detectorClass.CallStatic("registerEvents");
+#endif
+        }
+
+        internal (AudioDeviceType AudioDeviceType, string RawType, string Name) GetInfo()
+        {
+            string param = string.Empty;
+#if !UNITY_EDITOR && UNITY_IOS
+            param = _GetAudioInfo();
+#elif !UNITY_EDITOR && UNITY_ANDROID
+            param = _detectorClass.CallStatic<string>("getAudioInfo");
+#endif
+            return ParseStringInfo(param);
+        }
+
+        internal string GetCurrentRouteInputs()
+        {
+#if !UNITY_EDITOR && UNITY_IOS
+            return _GetCurrentRouteInputs();
+#else
+            return string.Empty;
+#endif
+        }
+
+        internal (AudioDeviceType AudioDeviceType, string RawType, string Name) ParseStringInfo(string param)
+        {
+            if (string.IsNullOrEmpty(param))
+                return (AudioDeviceType.Unknown, null, null);
+
+            string[] parameters = param.Split(';');
+
+            if (parameters.Length < 2)
+                return (AudioDeviceType.Unknown, null, null);
+
+            string name = RemoveSurrogatePairs(parameters[0]);
+            string rawType = parameters[1];
+            AudioDeviceType type = MapDeviceType(rawType);
+            if (type == AudioDeviceType.Internal)
+            {
+                name = string.Empty;
+            }
+
+            return (type, rawType, name);
+        }
+
+        private AudioDeviceType MapDeviceType(string rawType)
+        {
+            if (deviceTypeMapping.TryGetValue(rawType, out var type))
+            {
+                return type;
+            }
+            return AudioDeviceType.Unknown;
+        }
+
+        private static string RemoveSurrogatePairs(string str, string replacementCharacter = "?")
+        {
+            if (str == null)
+            {
+                return null;
+            }
+
+            StringBuilder sb = null;
+
+            for (int i = 0; i < str.Length; i++)
+            {
+                char ch = str[i];
+
+                if (char.IsSurrogate(ch))
+                {
+                    sb ??= new StringBuilder(str, 0, i, str.Length);
+
+                    sb.Append(replacementCharacter);
+
+                    // If there is a high+low surrogate, skip the low surrogate
+                    if (i + 1 < str.Length && char.IsHighSurrogate(ch) && char.IsLowSurrogate(str[i + 1]))
+                    {
+                        i++;
+                    }
+                }
+                else if (sb != null)
+                {
+                    sb.Append(ch);
+                }
+            }
+
+            return sb == null ? str : sb.ToString();
+        }
+    }
+
+    internal enum AudioDeviceType
+    {
+        Unknown = 0,
+        Internal,
+        Wire,
+        Wireless,
+        Bluetooth,
+    }
+}

package/Runtime/AudioToolkit/Plugins/AudioDeviceDetector.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ae405c9800a2487bb39ade689828e18d
+timeCreated: 1717149554