unity 使用蓝牙通讯(PC版,非安卓)

已于 2025-05-07 11:44:56 修改
阅读量1k 收藏 5
点赞数 3
文章标签： unity android 游戏引擎
于 2025-05-07 11:43:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41590778/article/details/147578115
版权

BlueTooth in pc with unity

最近接到的需求是在unity里面开发蓝牙功能,其实一开始我并不慌,因为据我所知,unity有丰富的插件可以使用,但是问题随之而来
1.unity里面无法直接与蓝牙通讯(后来找到了开启runtime一类的东西,但是我找了半天也没找到在哪里可以打开)
2.引入dll通过dll与蓝牙通讯,包括去微软的官网下载c++编译,但是编译过程中种种问题.而我对于c++这一套也不精通.也是放弃了
3.github上找到一个封装好的BLE的一个 这是网址 但是在我的测试中发现 会有搜不到我的蓝牙设备的问题.并且即使连上了,发出的消息也没有回应.所以也是放弃了

于是只能通过一个比较笨的办法,将蓝牙通讯在winform中或者是wpf中,然后将unity程序放在winform或者是wpf的容器中,二者通过udp协议连接传输数据.最后的效果如下:

运行界面

那么如果是这种办法,那就变得简单的多了.winform开发不在话下.unity也是我熟悉的.其中winform支持原生开发,也就是说不用下载任何dll与插件,用到的只是windows.winmd,而这个windows系统是自带的.

将winmd类型文件引入后,编写开发工具类:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Windows.Devices.Bluetooth;
using Windows.Devices.Bluetooth.Advertisement;
using Windows.Devices.Bluetooth.GenericAttributeProfile;
using Windows.Devices.Enumeration;
using Windows.Foundation;
using Windows.Networking;
using Windows.Networking.Proximity;
using Windows.Networking.Sockets;
using Windows.Security.Cryptography;
using Windows.Storage.Streams;

namespace Bluetooth
{
    internal class BleCore
    {
        private Boolean asyncLock = false;

        /// <summary>
        /// 搜索蓝牙设备对象
        /// </summary>
        private BluetoothLEAdvertisementWatcher watcher;

        /// <summary>
        /// 当前连接的蓝牙设备
        /// </summary>
        public BluetoothLEDevice CurrentDevice { get; set; }

        /// <summary>
        /// 特性通知类型通知启用
        /// </summary>
        private const GattClientCharacteristicConfigurationDescriptorValue CHARACTERISTIC_NOTIFICATION_TYPE = GattClientCharacteristicConfigurationDescriptorValue.Notify;

        /// <summary>
        /// 存储检测到的设备
        /// </summary>
        private List<BluetoothLEDevice> DeviceList = new List<BluetoothLEDevice>();

        /// <summary>
        /// 搜索蓝牙设备委托
        /// </summary>
        public delegate void DeviceScanEvent(BluetoothLEDevice bluetoothLEDevice);

        /// <summary>
        /// 搜索蓝牙事件
        /// </summary>
        public event DeviceScanEvent DeviceScan;

        /// <summary>
        /// 提示信息委托
        /// </summary>
        public delegate void MessAgeLogEvent(MsgType type, string message, byte[] data = null);

        /// <summary>
        /// 提示信息事件
        /// </summary>
        public event MessAgeLogEvent MessAgeLog;

        /// <summary>
        /// 接收通知委托
        /// </summary>
        public delegate void ReceiveNotificationEvent(GattCharacteristic sender, byte[] data);

        /// <summary>
        /// 接收通知事件
        /// </summary>
        public event ReceiveNotificationEvent ReceiveNotification;

        /// <summary>
        /// 获取服务委托
        /// </summary>
        public delegate void DeviceFindServiceEvent(DeviceService deviceService);

        /// <summary>
        /// 获取服务事件
        /// </summary>
        public event DeviceFindServiceEvent DeviceFindService;

        /// <summary>
        /// 蓝牙状态委托
        /// </summary>
        public delegate void DeviceConnectionStatusEvent(BluetoothConnectionStatus status);

        /// <summary>
        /// 蓝牙状态事件
        /// </summary>
        public event DeviceConnectionStatusEvent DeviceConnectionStatus;

        /// <summary>
        /// 当前连接的蓝牙Mac
        /// </summary>
        private string CurrentDeviceMAC { get; set; }

        public BleCore()
        {
        }

        /// <summary>
        /// 搜索蓝牙设备
        /// </summary>
        public void StartBleDeviceWatcher()
        {
            watcher = new BluetoothLEAdvertisementWatcher();

            watcher.ScanningMode = BluetoothLEScanningMode.Active;

            //只有在接收到数值大于等于 -80 的情况下才激活监视器
            watcher.SignalStrengthFilter.InRangeThresholdInDBm = -80;

            // 如果数值低于 -90（用户离开），则停止监测
            watcher.SignalStrengthFilter.OutOfRangeThresholdInDBm = -90;

            // 注册回调函数，以便在我们看到广播时触发（执行）相关操作
            watcher.Received += OnAdvertisementReceived;

            // 等待 5 秒钟以确保设备确实超出范围
            watcher.SignalStrengthFilter.OutOfRangeTimeout = TimeSpan.FromMilliseconds(5000);
            watcher.SignalStrengthFilter.SamplingInterval = TimeSpan.FromMilliseconds(2000);

            // starting watching for advertisements
            this.DeviceList.Clear();
            watcher.Start();
            string msg = "开始搜索蓝牙设备...";

            this.MessAgeLog(MsgType.NotifyTxt, msg);
        }

        /// <summary>
        /// 停止搜索蓝牙
        /// </summary>
        public void StopBleDeviceWatcher()
        {
            this.watcher.Stop();
        }

        private void OnAdvertisementReceived(BluetoothLEAdvertisementWatcher watcher, BluetoothLEAdvertisementReceivedEventArgs eventArgs)
        {
            //this.MessAgeChanged(MsgType.NotifyTxt, "发现设备FR_NAME:"+ eventArgs.Advertisement.LocalName + "BT_ADDR: " + eventArgs.BluetoothAddress);
            BluetoothLEDevice.FromBluetoothAddressAsync(eventArgs.BluetoothAddress).Completed = (asyncInfo, asyncStatus) =>
            {
                if (asyncStatus == AsyncStatus.Completed)
                {
                    if (asyncInfo.GetResults() != null)
                    {
                        BluetoothLEDevice currentDevice = asyncInfo.GetResults();

                        Boolean contain = false;
                        foreach (BluetoothLEDevice device in DeviceList)//过滤重复的设备
                        {
                            if (device.BluetoothAddress == currentDevice.BluetoothAddress)
                            {
                                contain = true;
                            }
                        }
                        if (!contain)
                        {
                            byte[] _Bytes1 = BitConverter.GetBytes(currentDevice.BluetoothAddress);
                            Array.Reverse(_Bytes1);
                            this.DeviceList.Add(currentDevice);
                            string str;

                            if (currentDevice.DeviceInformation.Name != "")
                            {
                                str = "发现设备：" + currentDevice.DeviceInformation.Name + " - MAC: \r\n" +
                                BitConverter.ToString(_Bytes1, 2, 6).Replace('-', ':').ToUpper() + " - ID: /r/n" + currentDevice.DeviceInformation.Id;
                            }
                            //舍弃没有名字的设备(匿名设备)
                            else
                            {
                                //    str = "发现设备：" + BitConverter.ToString(_Bytes1, 2, 6).Replace('-', ':').ToUpper();
                                return;
                            }
                            this.MessAgeLog(MsgType.NotifyTxt, str);
                            this.DeviceScan(currentDevice);
                        }
                    }
                }
            };
        }

        /// <summary>
        /// 匹配
        /// </summary>
        /// <param name="Device"></param>
        public void StartMatching(BluetoothLEDevice Device)
        {
            this.CurrentDevice?.Dispose();
            this.CurrentDevice = Device;
            Connect();
            FindService();
        }

        /// <summary>
        /// 获取蓝牙服务
        /// </summary>
        public async void FindService()
        {
            this.MessAgeLog(MsgType.NotifyTxt, "开始获取服务列表");
            this.CurrentDevice.GetGattServicesAsync().Completed = async (asyncInfo, asyncStatus) =>
            {
                if (asyncStatus == AsyncStatus.Completed)
                {
                    var services = asyncInfo.GetResults().Services;
                    //this.MessAgeChanged(MsgType.NotifyTxt, "GattServices size=" + services.Count);
                    foreach (GattDeviceService ser in services)
                    {
                        FindCharacteristic(ser);
                    }
                }
            };
        }

        /// <summary>
        /// 获取特性
        /// </summary>
        public async void FindCharacteristic(GattDeviceService gattDeviceService)
        {
            IAsyncOperation<GattCharacteristicsResult> result = gattDeviceService.GetCharacteristicsAsync();
            result.Completed = async (asyncInfo, asyncStatus) =>
            {
                if (asyncStatus == AsyncStatus.Completed)
                {
                    var characters = asyncInfo.GetResults().Characteristics;

                    List<GattCharacteristic> characteristics = new List<GattCharacteristic>();
                    foreach (GattCharacteristic characteristic in characters)
                    {
                        characteristics.Add(characteristic);
                        this.MessAgeLog(MsgType.NotifyTxt, "服务UUID:" + gattDeviceService.Uuid.ToString() + " --- 特征UUID:" + characteristic.Uuid.ToString());
                    }

                    DeviceService deviceService = new DeviceService();
                    deviceService.gattDeviceService = gattDeviceService;
                    deviceService.gattCharacteristic = characteristics;

                    this.DeviceFindService(deviceService);
                }
            };
        }

        /// <summary>
        /// 获取操作
        /// </summary>
        /// <returns></returns>
        public async Task SetNotify(GattCharacteristic gattCharacteristic)
        {
            GattCharacteristic CurrentNotifyCharacteristic;
            if ((gattCharacteristic.CharacteristicProperties & GattCharacteristicProperties.Notify) != 0)
            {
                CurrentNotifyCharacteristic = gattCharacteristic;
                CurrentNotifyCharacteristic.ProtectionLevel = GattProtectionLevel.Plain;
                CurrentNotifyCharacteristic.ValueChanged += Characteristic_ValueChanged;
                await this.EnableNotifications(CurrentNotifyCharacteristic);
            }
        }

        /// <summary>
        /// 连接蓝牙
        /// </summary>
        /// <returns></returns>
        private async Task Connect()
        {
            byte[] _Bytes1 = BitConverter.GetBytes(this.CurrentDevice.BluetoothAddress);
            Array.Reverse(_Bytes1);
            this.CurrentDeviceMAC = BitConverter.ToString(_Bytes1, 2, 6).Replace('-', ':').ToLower();

            string msg = "正在连接设备:" + this.CurrentDeviceMAC.ToUpper() + " ...";
            this.MessAgeLog(MsgType.NotifyTxt, msg);
            this.CurrentDevice.ConnectionStatusChanged += this.CurrentDevice_ConnectionStatusChanged;
        }

        /// <summary>
        /// 搜索到的蓝牙设备
        /// </summary>
        /// <returns></returns>
        private async Task Matching(string Id)
        {
            try
            {
                BluetoothLEDevice.FromIdAsync(Id).Completed = async (asyncInfo, asyncStatus) =>
                {
                    if (asyncStatus == AsyncStatus.Completed)
                    {
                        BluetoothLEDevice bleDevice = asyncInfo.GetResults();
                        this.DeviceList.Add(bleDevice);
                        this.DeviceScan(bleDevice);
                        this.CurrentDevice = bleDevice;
                        FindService();
                    }
                };
            }
            catch (Exception e)
            {
                string msg = "没有发现设备" + e.ToString();
                this.MessAgeLog(MsgType.NotifyTxt, msg);
                this.StartBleDeviceWatcher();
            }
        }

        /// <summary>
        /// 主动断开连接
        /// </summary>
        /// <returns></returns>
        public void Dispose()
        {
            CurrentDeviceMAC = null;
            CurrentDevice?.Dispose();
            CurrentDevice = null;

            MessAgeLog(MsgType.NotifyTxt, "主动断开连接");
        }

        private void CurrentDevice_ConnectionStatusChanged(BluetoothLEDevice sender, object args)
        {
            this.DeviceConnectionStatus(sender.ConnectionStatus);
            if (sender.ConnectionStatus == BluetoothConnectionStatus.Disconnected && CurrentDeviceMAC != null)
            {
                string msg = "设备已断开,自动重连...";
                MessAgeLog(MsgType.NotifyTxt, msg);
                if (!asyncLock)
                {
                    asyncLock = true;
                    this.CurrentDevice.Dispose();
                    this.CurrentDevice = null;
                    SelectDeviceFromIdAsync(CurrentDeviceMAC);
                }
            }
            else
            {
                string msg = "设备已连接！";
                MessAgeLog(MsgType.NotifyTxt, msg);
            }
        }

        /// <summary>
        /// 按MAC地址直接组装设备ID查找设备
        /// </summary>
        public async Task SelectDeviceFromIdAsync(string MAC)
        {
            CurrentDeviceMAC = MAC;
            CurrentDevice = null;
            BluetoothAdapter.GetDefaultAsync().Completed = async (asyncInfo, asyncStatus) =>
            {
                if (asyncStatus == AsyncStatus.Completed)
                {
                    BluetoothAdapter mBluetoothAdapter = asyncInfo.GetResults();
                    byte[] _Bytes1 = BitConverter.GetBytes(mBluetoothAdapter.BluetoothAddress);//ulong转换为byte数组
                    Array.Reverse(_Bytes1);
                    string macAddress = BitConverter.ToString(_Bytes1, 2, 6).Replace('-', ':').ToLower();
                    string Id = "BluetoothLE#BluetoothLE" + macAddress + "-" + MAC;
                    await Matching(Id);
                }
            };
        }

        /// <summary>
        /// 设置特征对象为接收通知对象
        /// </summary>
        /// <param name="characteristic"></param>
        /// <returns></returns>
        public async Task EnableNotifications(GattCharacteristic characteristic)
        {
            if (CurrentDevice.ConnectionStatus != BluetoothConnectionStatus.Connected)
            {
                this.MessAgeLog(MsgType.NotifyTxt, "蓝牙未连接！");
                return;
            }

            characteristic.WriteClientCharacteristicConfigurationDescriptorAsync(CHARACTERISTIC_NOTIFICATION_TYPE).Completed = async (asyncInfo, asyncStatus) =>
            {
                Console.WriteLine("asyncStatus:" + asyncStatus);
                if (asyncStatus == AsyncStatus.Completed)
                {
                    GattCommunicationStatus status = asyncInfo.GetResults();

                    asyncLock = false;
                    string msg = "Notify(" + characteristic.Uuid.ToString() + ")：" + status;
                    this.MessAgeLog(MsgType.NotifyTxt, msg);
                }
                else
                {
                    Console.WriteLine(asyncInfo.ErrorCode.ToString());
                }
            };
        }

        /// <summary>
        /// 接受到蓝牙数据
        /// </summary>
        private void Characteristic_ValueChanged(GattCharacteristic characteristic, GattValueChangedEventArgs args)
        {
            byte[] data;
            CryptographicBuffer.CopyToByteArray(args.CharacteristicValue, out data);
            string str = System.Text.Encoding.UTF8.GetString(data);
            this.ReceiveNotification(characteristic, data);

            this.MessAgeLog(MsgType.BleData, "收到数据(" + characteristic.Uuid.ToString() + ")：" + str);
        }

        /// <summary>
        /// 发送数据接口
        /// </summary>
        /// <returns></returns>
        public async Task Write(GattCharacteristic writeCharacteristic, byte[] data)
        {
            if (writeCharacteristic != null)
            {
                string str = "发送数据(" + writeCharacteristic.Uuid.ToString() + ")：" + BitConverter.ToString(data);
                this.MessAgeLog(MsgType.BleData, str, data);
                IAsyncOperation<GattCommunicationStatus> async = writeCharacteristic.WriteValueAsync(CryptographicBuffer.CreateFromByteArray(data), GattWriteOption.WriteWithResponse);
                async.Completed = async (asyncInfo, asyncStatus) =>
                {
                    if (asyncStatus == AsyncStatus.Completed)
                    {
                        this.MessAgeLog(MsgType.BleData, "数据发送成功！");
                    }
                    else
                    {
                        this.MessAgeLog(MsgType.BleData, "数据发送失败：" + asyncInfo.ErrorCode.ToString());
                    }
                };
            }
        }
    }

    public enum MsgType
    {
        NotifyTxt,
        BleData,
        BleDevice
    }

    public class DeviceService
    {
        public GattDeviceService gattDeviceService;
        public List<GattCharacteristic> gattCharacteristic;
    }
}

然后对于页面的按钮进行赋值,并将unity开发的exe放在合适的位置,其中通讯部分只需要简单的通讯即可,不需要考虑什么分包问题.因为本机通讯很稳定.
winform部分的udp:

using System;
using System.Diagnostics;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace VincentUDP
{
    public class UdpServer
    {
        private UdpClient udpClient;
        private IPEndPoint remoteEndPoint;

        public void Init()
        {
            int port = 8888; // 选择一个端口
            udpClient = new UdpClient();
            remoteEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port); // 目标IP和端口
        }

        public void Send(byte[] message)
        {
            // byte[] data = Encoding.UTF8.GetBytes(message);
            udpClient.Send(message, message.Length, remoteEndPoint);
        }

        public void Close()
        {
            udpClient.Close();
        }
    }
}

unity接收部分:

using System;
using System.Collections;
using System.Net;
using System.Net.Sockets;
using UnityEngine;

public class RecvUDPMsg : MonoBehaviour
{
    private UdpClient udpClient;

    //消息队列
    private Queue queue = new Queue();

    private void Start()
    {
        // 初始化UDP客户端
        udpClient = new UdpClient(8888); // 监听的端口
        StartReceiving();
    }

    private void StartReceiving()
    {
        udpClient.BeginReceive(ReceiveCallback, null);
    }

    private void ReceiveCallback(IAsyncResult ar)
    {
        IPEndPoint remoteIpEndPoint = new IPEndPoint(IPAddress.Any, 0);
        byte[] receivedBytes = udpClient.EndReceive(ar, ref remoteIpEndPoint);
        // string receivedText = Encoding.UTF8.GetString(receivedBytes);

        //Debug.Log("Received: " + receivedText);
        queue.Enqueue(receivedBytes);
        // 继续监听
        StartReceiving();
    }

    private void OnDestroy()
    {
        // 关闭UDP客户端
        udpClient.Close();
    }
}

那么最后的运行如下:
最终效果
最后附上下载地址: 点击这里
PS:如果下载不了(非csdn会员)请私信我.

Unity3D获取各种设备的MAC地址
心疼你的一切博客
08-15 1185
mac地址也称为物理（或硬件）地址，是分配给计算机的nic（网络接口卡）的唯一标识符，存储在硬件中；nic有助于将计算机与网络中的其他计算机连接，而mac地址对于所有nic都是唯一的。MAC地址的格式MAC地址的编号是以十六进制格式进行唯一格式化，格式为六组两个数字或字符，即12位十六进制数字（48位或6字节长），用连字符（或分号）分隔。大家好，我是心疼你的一切，不定时更新Unity开发技巧，觉得有用记得一键三连哦。下面就让我们进入正文吧!提示：以下是本篇文章正文内容，下面案例可供参考。
unity开发程序连接HC_05蓝牙
weixin_42454034的博客
02-24 5904
之前一直使用的是qt做上位机，但是开发的上位机在安卓上使用蓝牙的时候一直有问题，就是连接上蓝牙一段时间后，app会直接挂掉，这个问题就是得不到解决。 qt安卓开发使用蓝牙 后来搜索到了unity连接蓝牙的文章。 UNITY 实现蓝牙通信ARDUINO BLUETOOTH PLUGIN 就打算用unity重新写连接蓝牙的程序。 首先下载 Arduino Bluetooth Plugin 这个插件，可以在unity商店或者百度下载。 导入到unity项目中，插件导入成功后我们可以看到目录下 Assets/Blu
unity bluetooth android,Unity 实现蓝牙通信Arduino Bluetooth Plugin
weixin_35225144的博客
05-28 6194
Unity 实现蓝牙通信1.话不多说上效果，目前开发的是Android版本的蓝牙和带蓝牙电子设备连接，下图展示的蓝牙控制机器小车运动，由于上传完整视频会比较麻烦，所以选择截屏展示，望大家见谅。2.首先导入一个插件，插件官方地址 https://assetstore.unity.com/packages/tools/input-management/arduino-bluetooth-plug...
Unity pc蓝牙和安卓蓝牙通信
Findfriends的博客
10-12 3716
Unity pc蓝牙和安卓蓝牙通信
[Unity插件使用心得] 适用于iOS，tvOS和Android的蓝牙LE
uukosama的博客
12-22 2118
unity使用【适用于iOS，tvOS和Android的蓝牙LE】插件 与传感器进行连接时碰到的一些问题和解决办法。
Unity-Bluetooth：Unity的蓝牙通信插件
gitblog_00585的博客
01-12 700
Unity-Bluetooth：Unity的蓝牙通信插件 unity-bluetooth 项目地址: https://gitcode.com/gh_mirrors/un/unity-bluetooth ...
Unity源码 蓝牙通信 支持IOS和Android
08-04
Unity蓝牙通信测试DEMO
UnityBluetooth:适用于Unity3D的简单易用的蓝牙适配器
05-03
在Unity3D中，通过使用UnityBluetooth，开发者可以绕过原生平台的复杂蓝牙API，以更简洁的方式实现蓝牙连接和数据传输。 Unity3D是一款强大的跨平台游戏开发工具，支持多种操作系统和设备，包括Android、iOS、...
Unity蓝牙插件更新版（2019年10月7日）支持iOS/Android
- **Unity蓝牙插件，最新版（2019年10月7号更新）Bluetooth LE for iOS tvOS and Android2.25**: 文件名称列表与标题内容相同，强调了插件的版本和适用平台，同时确认了文件的压缩包形式。 ### 总结 综上所述，该...
Unity移动平台相关（一）Android打包设置
热门推荐
liuyingbo.com
10-16 1万+
可以在此设置自定义编译标志。再使用一些第三方内容时有时会在此处添加脚本符号比如：Lua热更相关、FairyGUI相关该清单文件是一个xml文件我们可以在此决定一些应用程序启动之前的外观和行为。（比如：图标、名称、安装位置等等）Gradle 是一个构建系统，可自动执行许多构建过程并防止许多常见的构建错误。Unity将Gradle用于所有Android版本。
unity蓝牙
03-08
### 如何在 Unity 中使用蓝牙进行设备连接和数据传输 #### 硬件准备 为了使Unity能够通过蓝牙与外部设备通信，需确保Arduino或其他目标设备支持蓝牙通信，并已经正确配置了蓝牙模块[^1]。对于PC端而言，在尝试直接...
Unity 蓝牙插件
07-31
Bluetooth LE for Android 为Unity插件，Unity蓝牙插件，请下载解压后选择Bluetooth LE for iOS and Android.unitypackage，导入Unity使用
unity-bluetooth：游戏开发者的蓝牙互连神器
gitblog_00688的博客
08-30 830
unity-bluetooth：游戏开发者的蓝牙互连神器 项目地址:https://gitcode.com/gh_mirrors/un/unity-bluetooth 在当今的移动游戏和应用程序领域中，无线通信技术成为了连接玩家、设备的关键桥梁。今天，我们隆重推荐一个开源宝藏——unity-bluetooth，这是一款专为Unity开发者设计的蓝牙插件，无论是经典蓝牙还是低功耗蓝牙，它都能轻松驾驭...
Unity-Bluetooth 项目常见问题解决方案
gitblog_01086的博客
01-03 1141
Unity-Bluetooth 项目常见问题解决方案 unity-bluetooth 项目地址: https://gitcode.com/gh_mirrors/un/unity-bluetooth ...
Unity安卓蓝牙插件：轻松实现Unity与安卓设备的蓝牙通信
最新发布
gitblog_06769的博客
05-11 296
Unity安卓蓝牙插件：轻松实现Unity与安卓设备的蓝牙通信 【下载地址】Unity安卓蓝牙插件 Unity安卓蓝牙插件专为Unity开发者打造，简化了安卓设备蓝牙功能的调用流程。通过该插件，开发者可以轻松实现与蓝牙模块的连接，并支持高效的数据发送与接收，满足设备间数据交互的需求。只需将插件导入Unity项目，调用相关...
Unity3D+蓝牙:二:Unity3D获取蓝牙数据
qq_40544338的博客
06-25 4216
一.目的 1. 二.参考 1.C# 如何接收蓝牙字符数据 https://www.cnblogs.com/zzu-liulei/p/6097444.html 待检测 1.
unity安卓及ide切换蓝牙音乐没有的bug
qq983985955的博客
10-12 965
目前在PAudioCtr.cs中增加OnAudioConfigurationChanged的委托，如果发生改变非暂停状态直接重新play，因为之前的音乐被销毁了，并特殊判断一下暂停音乐的情况恢复音乐直接playmusic。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Unity-Plane

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值