public void BleHostInitialize()
{
Task.Run(() =>
{
CSR_BLE_TRANSPORT transport = new CSR_BLE_TRANSPORT()
{
transportType = (byte)CsrBleDefine.CSR_BLE_TRANSPORT_USB,
usbDeviceNumber = (byte)CsrBleDefine.CSR_BLE_DEFAULT_USB_DEVICE_NUMBER,
};
if (CsrBleDll.CsrBleHostInit(false, null, ref transport) == 0)
{
Error("Unable to initialize uEnergy Host.");
MessageBox.Show("蓝牙无法初始化！");
return;
}
if (!CsrBleDll.CsrBleHostStart(0))
{
Error("Unable to start uEnergy Host.");
MessageBox.Show("蓝牙HOST无法开始！");
return;
}
Trace("BleHostInitialize");
BleHostProcessMsg();
});
}
public void BleHostInitialize()
{
Task.Run(() =>
{
var transport = new CSR_BLE_TRANSPORT
{
transportType = (byte)CsrBleDefine.CSR_BLE_TRANSPORT_USB,
usbDeviceNumber = (byte)CsrBleDefine.CSR_BLE_DEFAULT_USB_DEVICE_NUMBER
};
if (CsrBleDll.CsrBleHostInit(false, null, ref transport) == 0)
{
Error("[CSR]:CsrBleHostInit Fail!");
throw new InvalidOperationException("BleHostInit CsrBleHostInit Fail!");
}
if (!CsrBleDll.CsrBleHostStart(0))
{
Error("[CSR]:CsrBleHostStart Fail!");
throw new InvalidOperationException("BleHostInit CsrBleHostStart Fail!");
}
Info("[CSR]:BleHostInitialize Success!");
BleHostProcessMsg();
});
}
private void OnConnectResult(CSR_BLE_CONNECT_RESULT cr)
{
CurDevInfo.ConnHandle = cr.connectHandle;
CsrBleDll.CsrBleClientDiscoverDatabase(cr.connectHandle);
IsConnected = true;
OnUpdateBleConnectEvent("蓝牙连接:" + CurDevInfo);
}
public async Task <bool> BleClientWriteChar(BleGattCharacteristic character, byte[] data)
{
return(await Task.Run(() =>
{
if (!character.Service.GattDevice.Connected)
{
Error("[CSR]:BleClientWriteChar when device is not connect!");
return false;
}
var value = Marshal.AllocHGlobal(data.Length);
Marshal.Copy(data, 0, value, data.Length);
if (CsrBleDll.CsrBleClientWriteCharByHandle(
character.Service.GattDevice.Handle, false, character.Handle, (ushort)data.Length, value))
{
if (_writeEvent.WaitOne(5000))
{
Marshal.FreeHGlobal(value);
Debug("[CSR]:BleClientWriteChar Success!");
return true;
}
}
Marshal.FreeHGlobal(value);
Debug("[CSR]:BleClientWriteChar Fail!");
return false;
}));
}
public bool BleWriteChar(byte[] data)
{
if (!IsConnected)
{
Error("BleWriteChar when no device is connect!");
}
IntPtr value = Marshal.AllocHGlobal(data.Length);
Marshal.Copy(data, 0, value, data.Length);
if (CsrBleDll.CsrBleClientWriteCharByHandle(CurDevInfo.ConnHandle, false, (ushort)CurDevInfo.WriteHandle,
(ushort)data.Length, value))
{
Marshal.FreeHGlobal(value);
if (_writeEvent.WaitOne(5000))
{
Debug("BleWriteChar Success!");
return(true);
}
}
Marshal.FreeHGlobal(value);
return(false);
}
public void BleHostScanStop()
{
if (!isBleInitialized)
{
Error("BleHostInitialize Fail!");
return;
}
CsrBleDll.CsrBleHostStopLESearch();
}
public void BleHostScanStop()
{
if (!IsBleHosted)
{
Error("[CSR]:BleHostInitialize Fail!");
return;
}
CsrBleDll.CsrBleHostStopLESearch();
Debug("[CSR]:BleHostScanStop");
}
public bool BleHostConnect()
{
CsrBleDll.CsrBleHostStopLESearch();
if (DevInfoSelected == null)
{
Error("BleHostConnect No Device Selected!");
return(false);
}
if (CurDevInfo != null)
{
BleHostDisconnect();
}
CurDevInfo = DevInfoSelected;
DevInfoSelected = null;
if (CurDevInfo != null)
{
string addr = CurDevInfo.Address;
var dev = bleSearchResults.FindAll(r => r.deviceAddress.ToString() == addr);
if (dev.Count == 0)
{
Error(string.Format("BleHostConnect Find Device Error at {0}", addr));
return(false);
}
if (CsrBleDll.CsrBleHostSetConnectionParams((ushort)CsrBleDefine.CSR_BLE_PARAMETER_IGNORE,
(ushort)CsrBleDefine.CSR_BLE_PARAMETER_IGNORE,
CsrBleDefine.MIN_CONN_INTERVAL,
CsrBleDefine.MAX_CONN_INTERVAL,
CsrBleDefine.SLAVE_LATENCY,
CsrBleDefine.LINK_TIMEOUT))
{
//set parameters is success
if (CsrBleDll.CsrBleHostConnect(dev[0].deviceAddress))
{
if (_dbDiscoverEvent.WaitOne(8000))
{
Trace(string.Format("CsrBleHostConnect {0} Success!", dev[0].deviceAddress));
OnUpdateBleConnectEvent("蓝牙连接成功:" + dev[0].deviceAddress);
return(true);
}
}
}
Trace(string.Format("CsrBleHostConnect {0} Fail!", dev[0].deviceAddress));
OnUpdateBleConnectEvent("蓝牙连接失败:" + dev[0].deviceAddress);
}
return(false);
}
public void BleHostTerminate()
{
isRun = false;
if (!CsrBleDll.CsrBleHostDeinit())
{
Error("Unable to de-initialize uEnergy Host.");
}
else
{
OnLogEvent("BleHostTerminate");
}
}
public void BleHostScanStart()
{
if (!isBleInitialized)
{
Error("BleHostInitialize Fail!");
return;
}
bleSearchResults.Clear();
DevInfos.Clear();
CsrBleDll.CsrBleHostCancel();
CsrBleDll.CsrBleHostStopLESearch();
CsrBleDll.CsrBleHostStartLEScan();
}
public void BleClientWriteConfig(BleGattCharacteristic character, byte config)
{
if (!character.Service.GattDevice.Connected)
{
Error("[CSR]:BleClientWriteConfig when device is not connect!");
return;
}
if (!CsrBleDll.CsrBleClientWriteConfiguration(character.Service.GattDevice.Handle, character.DescriptorHandle,
character.Handle, config))
{
Error("[CSR]:BleClientWriteConfig Fail!");
}
}
public void BleHostTerminate()
{
_isRun = false;
CsrBleDll.CsrBleHostCancel();
if (!CsrBleDll.CsrBleHostDeinit())
{
Error("[CSR]:BleHostTerminate Fail!");
}
else
{
Info("[CSR]:BleHostTerminate Success!");
}
}
public void BleHostDisconnect()
{
CsrBleDll.CsrBleHostCancel();
if (CurDevInfo != null)
{
if (CsrBleDll.CsrBleHostDisconnect(CurDevInfo.ConnHandle))
{
Trace(string.Format("CsrBleHostDisconnect {0} Success!", CurDevInfo));
OnUpdateBleConnectEvent("蓝牙断开成功:" + CurDevInfo);
return;
}
Trace(string.Format("CsrBleHostDisconnect {0} Fail!", CurDevInfo));
OnUpdateBleConnectEvent("蓝牙断开失败:" + CurDevInfo);
}
}
public void BleHostScanStart()
{
if (!IsBleHosted)
{
Error("[CSR]:BleHostInitialize Fail!");
return;
}
_csrSearchResults.Clear();
GattSearchDevices.Clear();
CsrBleDll.CsrBleHostCancel();
CsrBleDll.CsrBleHostStopLESearch();
Thread.Sleep(300);
CsrBleDll.CsrBleHostStartLEScan();
Debug("[CSR]:BleHostScanStart");
}
public byte[] BleReadChar()
{
if (!IsConnected)
{
Error("BleWriteChar when no device is connect!");
}
if (CsrBleDll.CsrBleClientReadCharByHandle(CurDevInfo.ConnHandle, (ushort)CurDevInfo.ReadHandle))
{
if (_readEvent.WaitOne(5000))
{
Debug("BleWriteChar SUCCESS!");
return(_readBytes);
}
}
Debug("BleWriteChar FAIL!");
return(null);
}
public bool BleSwitchMode()
{
if (!IsConnected)
{
Error("BleWriteChar when no device is connect!");
}
//switch (mode)
//{
// case XcobraDataMode.NORMAL:
// _curServiceUuid = XIM_NORMAL_SERVICE;
// break;
// //case XcobraDataMode.BLOBS:
// // _curServiceUuid = XIM_BLOBS_SERVICE;
// // break;
// case XcobraDataMode.CALIB:
// _curServiceUuid = XIM_IMU_RAW_SERVICE;
// break;
// case XcobraDataMode.BATTERY:
// _curServiceUuid = XIM_BATTERY_SERVICE;
// break;
// default:
// return true;
//}
if (CurDevInfo != null)
{
CsrBleDll.CsrBleClientDiscoverDatabase(CurDevInfo.ConnHandle);
if (_dbDiscoverEvent.WaitOne(8000))
{
OnLogEvent("BleSwitchMode Success!");
return(true);
}
}
OnLogEvent("BleSwitchMode Fail!");
return(false);
}
private void OnDatabaseDiscoveryResult(CSR_BLE_DATABASE_DISCOVERY_RESULT database)
{
int servicePtrPos = GetServicePtrPos((ushort)_curServiceUuid, ref database);
if (servicePtrPos != 0xFF)
{
CSR_BLE_SERVICE service =
(CSR_BLE_SERVICE)Marshal.PtrToStructure(
database.services + servicePtrPos * Marshal.SizeOf(typeof(CSR_BLE_SERVICE)),
typeof(CSR_BLE_SERVICE));
//if (_curServiceUuid != XIM_BATTERY_SERVICE)
{
var nCharacter = service.nCharacteristics;
CSR_BLE_CHARACTERISTIC readCharcter =
(CSR_BLE_CHARACTERISTIC)
Marshal.PtrToStructure(service.characteristics, typeof(CSR_BLE_CHARACTERISTIC));
CSR_BLE_CHARACTERISTIC writeCharcter =
(CSR_BLE_CHARACTERISTIC)
Marshal.PtrToStructure(
service.characteristics + 1 * Marshal.SizeOf(typeof(CSR_BLE_CHARACTERISTIC)),
typeof(CSR_BLE_CHARACTERISTIC));
CurDevInfo.ReadHandle = readCharcter.handle;
CurDevInfo.WriteHandle = writeCharcter.handle;
if (readCharcter.nDescriptors > 0)
{
var descHandle =
(CSR_BLE_CHARACTERISTIC_DSC)Marshal.PtrToStructure(readCharcter.descriptors,
typeof(CSR_BLE_CHARACTERISTIC_DSC));
CsrBleDll.CsrBleClientWriteConfiguration(CurDevInfo.ConnHandle, descHandle.handle,
readCharcter.handle, 0x01);
}
}
_dbDiscoverEvent.Set();
}
}
private void OnHostConnectResult(CSR_BLE_CONNECT_RESULT conn)
{
var gattDevice = GattConnectDevices.Last();
if (conn.result == 0)
{
gattDevice.Handle = conn.connectHandle;
gattDevice.Connected = true;
CsrBleDll.CsrBleClientDiscoverDatabase(conn.connectHandle);
Debug("[CSR]:OnHostConnectResult Success");
OnDeviceConnectEvent("蓝牙连接 SUCCESS:" + gattDevice.Address);
}
else
{
gattDevice.Connected = false;
Debug("[CSR]:OnHostConnectResult Fail");
OnDeviceConnectEvent("蓝牙连接 FAIL:" + gattDevice.Address);
}
_connectEvent.Set();
}
public async Task <byte[]> BleClientReadChar(BleGattCharacteristic character)
{
return(await Task.Run(() =>
{
if (!character.Service.GattDevice.Connected)
{
Error("[CSR]:BleClientReadChar when device is not connect!");
return null;
}
if (CsrBleDll.CsrBleClientReadCharByHandle(character.Service.GattDevice.Handle, character.Handle))
{
if (_readEvent.WaitOne(5000))
{
Debug("[CSR]:BleClientReadChar Success!");
return _readBytes;
}
}
Debug("[CSR]:BleClientReadChar Fail!");
return null;
}));
}
public async Task <bool> BleHostDisconnect(BleGattDevice gattDevice)
{
if (!IsBleHosted)
{
Error("[CSR]:BleHostInitialize Fail!");
return(false);
}
return(await Task.Run(() =>
{
if (CsrBleDll.CsrBleHostDisconnect(gattDevice.Handle))
{
Debug("[CSR]:CsrBleHostDisconnect true!");
if (_disconnectEvent.WaitOne(2500))
{
if (!GattConnectDevices.Contains(gattDevice))
{
Debug($"[CSR]:CsrBleHostDisconnect {gattDevice.Address} Success!");
OnDeviceConnectEvent("蓝牙断开成功:" + gattDevice.Address);
gattDevice.OnDeviceDisconnectEvent(true);
return true;
}
}
}
if (GattConnectDevices.Contains(gattDevice))
{
GattConnectDevices.Remove(gattDevice);
}
gattDevice.OnDeviceDisconnectEvent(false);
Debug($"[CSR]:CsrBleHostDisconnect {gattDevice.Address} Fail!");
OnDeviceConnectEvent("蓝牙断开失败:" + gattDevice.Address);
return false;
}));
}
public void BleHostProcessMsg()
{
if (isRun)
{
OnLogEvent("BleHostThread is Running...");
return;
}
OnLogEvent("BleHostThread Start...");
isRun = true;
MSG m = new MSG();
IntPtr handle = new IntPtr(-1);
int ret;
while ((ret = User32.GetMessage(ref m, handle, 0, 0)) != 0 && isRun)
{
if (ret == -1)
{
//-1 indicates an error
}
else
{
Trace("[BleMsg]:MSG.message - " + m.message.ToString("X4"));
//if (m.message == 50159)
{
switch ((uint)m.wParam)
{
//init
case CsrBleDefine.CSR_BLE_HOST_READY:
isBleInitialized = m.lParam > 0;
if (isBleInitialized)
{
Info("[BleMsg]:uEnergy Host library is initialized");
BleHostScanStart();
Info("[BleMsg]:CSR_BLE_HOST_READY");
}
else
{
//exit thread
isRun = false;
Error("Dongle failed to initialize! Please insert the dongle to computer!");
//MessageBox.Show("蓝牙初始化失败！");
return;
}
break;
//search result
case CsrBleDefine.CSR_BLE_HOST_SEARCH_RESULT:
var sr =
(CSR_BLE_DEVICE_SEARCH_RESULT)
Marshal.PtrToStructure(new IntPtr(m.lParam),
typeof(CSR_BLE_DEVICE_SEARCH_RESULT));
OnSearchResult(sr);
Trace("[BleMsg]:CSR_BLE_HOST_SEARCH_RESULT");
break;
//search stopped
case CsrBleDefine.CSR_BLE_HOST_SEARCH_STOPPED:
Info("[BleMsg]:CSR_BLE_HOST_SEARCH_STOPPED");
break;
//connect result
case CsrBleDefine.CSR_BLE_HOST_CONNECT_RESULT:
var cr =
(CSR_BLE_CONNECT_RESULT)
Marshal.PtrToStructure(new IntPtr(m.lParam), typeof(CSR_BLE_CONNECT_RESULT));
if (cr.connectHandle != 0)
{
OnConnectResult(cr);
}
Trace("[BleMsg]:CSR_BLE_HOST_CONNECT_RESULT");
break;
//disconnect
case CsrBleDefine.CSR_BLE_HOST_DISCONNECTED:
var dr =
(CSR_BLE_DISCONNECTED)
Marshal.PtrToStructure(new IntPtr(m.lParam), typeof(CSR_BLE_DISCONNECTED));
if (dr.connectHandle != 0)
{
OnDisconnectResult(dr);
}
Trace("[BleMsg]:CSR_BLE_HOST_DISCONNECTED");
break;
//discover database
case CsrBleDefine.CSR_BLE_CLIENT_DATABASE_DISCOVERY_RESULT:
var dbRes = (CSR_BLE_DATABASE_DISCOVERY_RESULT)
Marshal.PtrToStructure(new IntPtr(m.lParam),
typeof(CSR_BLE_DATABASE_DISCOVERY_RESULT));
if (dbRes.result == 0)
{
OnDatabaseDiscoveryResult(dbRes);
}
Trace("[BleMsg]:CSR_BLE_CLIENT_DATABASE_DISCOVERY_RESULT");
break;
//connection update req
case CsrBleDefine.CSR_BLE_HOST_CONNECTION_UPDATE_REQUEST:
var connUpdateRequest =
(CSR_BLE_CONNECTION_UPDATE_REQUEST)
Marshal.PtrToStructure(new IntPtr(m.lParam),
typeof(CSR_BLE_CONNECTION_UPDATE_REQUEST));
CsrBleDll.CsrBleHostAcceptConnUpdate(connUpdateRequest.connectHandle,
connUpdateRequest.id, true);
Trace("[BleMsg]:CSR_BLE_HOST_CONNECTION_UPDATE_REQUEST");
break;
//connection update
case CsrBleDefine.CSR_BLE_HOST_CONNECTION_UPDATED:
var connUpdated =
(CSR_BLE_CONNECTION_UPDATED)
Marshal.PtrToStructure(new IntPtr(m.lParam),
typeof(CSR_BLE_CONNECTION_UPDATED));
OnConnectionUpdated(connUpdated);
Trace("[BleMsg]:CSR_BLE_HOST_CONNECTION_UPDATED");
break;
//host just works
case CsrBleDefine.CSR_BLE_HOST_JUSTWORKS_REQUEST:
var justworksRequest =
(CSR_BLE_JUSTWORKS_REQUEST)
Marshal.PtrToStructure(new IntPtr(m.lParam), typeof(CSR_BLE_JUSTWORKS_REQUEST));
CsrBleDll.CsrBleHostJustWorksResult(justworksRequest.deviceAddress, true, true);
Trace("[BleMsg]:CSR_BLE_HOST_JUSTWORKS_REQUEST");
break;
//scanning
case CsrBleDefine.CSR_BLE_HOST_LE_SCAN_STATUS:
Trace("[BleMsg]:CSR_BLE_HOST_LE_SCAN_STATUS");
break;
//read result
case CsrBleDefine.CSR_BLE_CLIENT_CHAR_READ_RESULT:
var readResult = (CSR_BLE_CHAR_READ_RESULT)
Marshal.PtrToStructure(new IntPtr(m.lParam), typeof(CSR_BLE_CHAR_READ_RESULT));
OnCharReadResult(readResult);
Trace("[BleMsg]:CSR_BLE_CLIENT_CHAR_READ_RESULT");
break;
//write result
case CsrBleDefine.CSR_BLE_CLIENT_CHAR_WRITE_RESULT:
var writeResult = (CSR_BLE_WRITE_RESULT)
Marshal.PtrToStructure(new IntPtr(m.lParam), typeof(CSR_BLE_WRITE_RESULT));
OnCharWriteResult(writeResult);
Trace("[BleMsg]:CSR_BLE_CLIENT_CHAR_WRITE_RESULT");
break;
//char notify
case CsrBleDefine.CSR_BLE_CLIENT_CHAR_NOTIFICATION:
var charData =
(CSR_BLE_CHAR_NOTIFICATION)
Marshal.PtrToStructure(new IntPtr(m.lParam), typeof(CSR_BLE_CHAR_NOTIFICATION));
OnClientCharNofity(charData);
Trace("[BleMsg]:CSR_BLE_CLIENT_CHAR_NOTIFICATION");
break;
case CsrBleDefine.CSR_BLE_HOST_SECURITY_RESULT:
//bool encrypting = false;
//// security result.
//var secRes =
// (CSR_BLE_SECURITY_RESULT)
// Marshal.PtrToStructure(new IntPtr(m.lParam), typeof(CSR_BLE_SECURITY_RESULT));
//if (secRes.result != CsrBleDefines.CSR_BLE_SECURITY_BONDING_ESTABLISHED)
//{
// CsrBleDll.CsrBleHostCancel();
// CsrBleDll.CsrBleHostDisconnect(CurDevInfo.ConnHandle);
//}
//else
//{
// encrypting = true;
//}
Trace("[BleMsg]:CSR_BLE_HOST_SECURITY_RESULT");
break;
default:
Error(string.Format("[BleMsg]:Unhandled uEnergy Host library MSG {0:X}",
(uint)m.wParam));
break;
}
}
}
}
OnLogEvent("BleHostThread Finish.");
}
public async Task <bool> BleHostConnect(BleGattDevice gattDevice)
{
if (!IsBleHosted)
{
Error("[CSR]:BleHostInitialize Fail!");
return(false);
}
CsrBleDll.CsrBleHostStopLESearch();
if (GattConnectDevices.Exists(d => d.Address == gattDevice.Address))
{
Warning($"[CSR]:BleHostConnect GattDevice {gattDevice.Address} Already Connected!");
return(true);
}
return(await Task.Run(() =>
{
var csrDevice = _csrSearchResults.FindAll(r => r.deviceAddress.ToString() == gattDevice.Address);
if (csrDevice.Count == 0)
{
Error($"[CSR]:BleHostConnect Find GattDevice Error at {gattDevice.Address}");
return false;
}
GattSearchDevices.RemoveAll(d => d.Address == gattDevice.Address);
GattConnectDevices.RemoveAll(d => d.Address == gattDevice.Address);
GattConnectDevices.Add(gattDevice);
Debug("[CSR]:GattConnectDevices Add Connecting Device!");
if (CsrBleDll.CsrBleHostSetConnectionParams((ushort)CsrBleDefine.CSR_BLE_PARAMETER_IGNORE,
(ushort)CsrBleDefine.CSR_BLE_PARAMETER_IGNORE,
CsrBleDefine.MIN_CONN_INTERVAL, CsrBleDefine.MAX_CONN_INTERVAL,
CsrBleDefine.SLAVE_LATENCY, CsrBleDefine.LINK_TIMEOUT))
{
//set parameters is success
if (CsrBleDll.CsrBleHostConnect(csrDevice[0].deviceAddress))
{
Debug("[CSR]:CsrBleHostConnect Start!");
if (_connectEvent.WaitOne(5000))
{
Debug($"[CSR]:CsrBleHostConnect {csrDevice[0].deviceAddress} Success!");
if (_databaseEvent.WaitOne(5000))
{
gattDevice.OnDeviceConnectEvent(true);
Debug($"[CSR]:DatabaseDiscover {csrDevice[0].deviceAddress} Success!");
OnDeviceConnectEvent("蓝牙连接成功:" + csrDevice[0].deviceAddress);
return true;
}
}
}
}
GattConnectDevices.Remove(gattDevice);
gattDevice.OnDeviceConnectEvent(false);
Debug("[CSR]:GattConnectDevices Remove Connect Fail Device!");
Debug($"[CSR]:CsrBleHostConnect {csrDevice[0].deviceAddress} Fail!");
OnDeviceConnectEvent("蓝牙连接失败:" + csrDevice[0].deviceAddress);
return false;
}));
}
private void BleHostProcessMsg()
{
if (_isRun)
{
Warning("[CSR]:BleHostProcessMsg is Running...");
return;
}
Debug("[CSR]:BleHostProcessMsg Start...");
_isRun = true;
var m = new MSG();
var handle = new IntPtr(-1);
int ret;
while ((ret = User32.GetMessage(ref m, handle, 0, 0)) != 0 && _isRun)
{
if (ret == -1)
{
//-1 indicates an error
}
else
{
Trace("[CSRMSG]:MSG.message - " + m.message.ToString("X4"));
//if (m.message == 50159)
{
switch ((uint)m.wParam)
{
//init
case CsrBleDefine.CSR_BLE_HOST_READY:
if (!OnHostReady(m.lParam > 0))
{
Debug("[CSRMSG]:CSR_BLE_HOST_READY ERROR!");
return;
}
Debug("[CSRMSG]:CSR_BLE_HOST_READY");
break;
//search result
case CsrBleDefine.CSR_BLE_HOST_SEARCH_RESULT:
var sr =
(CSR_BLE_DEVICE_SEARCH_RESULT)
Marshal.PtrToStructure(new IntPtr(m.lParam),
typeof(CSR_BLE_DEVICE_SEARCH_RESULT));
OnHostSearchResult(sr);
Trace("[CSRMSG]:CSR_BLE_HOST_SEARCH_RESULT");
break;
//search stopped
case CsrBleDefine.CSR_BLE_HOST_SEARCH_STOPPED:
Debug("[CSRMSG]:CSR_BLE_HOST_SEARCH_STOPPED");
break;
//connect result
case CsrBleDefine.CSR_BLE_HOST_CONNECT_RESULT:
var cr =
(CSR_BLE_CONNECT_RESULT)
Marshal.PtrToStructure(new IntPtr(m.lParam), typeof(CSR_BLE_CONNECT_RESULT));
OnHostConnectResult(cr);
Debug("[CSRMSG]:CSR_BLE_HOST_CONNECT_RESULT");
break;
//disconnect
case CsrBleDefine.CSR_BLE_HOST_DISCONNECTED:
var dr =
(CSR_BLE_DISCONNECTED)
Marshal.PtrToStructure(new IntPtr(m.lParam), typeof(CSR_BLE_DISCONNECTED));
OnHostDisconnectResult(dr);
Trace("[CSRMSG]:CSR_BLE_HOST_DISCONNECTED");
break;
//discover database
case CsrBleDefine.CSR_BLE_CLIENT_DATABASE_DISCOVERY_RESULT:
var dbr = (CSR_BLE_DATABASE_DISCOVERY_RESULT)
Marshal.PtrToStructure(new IntPtr(m.lParam),
typeof(CSR_BLE_DATABASE_DISCOVERY_RESULT));
OnClientDatabaseDiscoveryResult(dbr);
Debug("[CSRMSG]:CSR_BLE_CLIENT_DATABASE_DISCOVERY_RESULT");
break;
//connection update request
case CsrBleDefine.CSR_BLE_HOST_CONNECTION_UPDATE_REQUEST:
var cur =
(CSR_BLE_CONNECTION_UPDATE_REQUEST)
Marshal.PtrToStructure(new IntPtr(m.lParam),
typeof(CSR_BLE_CONNECTION_UPDATE_REQUEST));
CsrBleDll.CsrBleHostAcceptConnUpdate(cur.connectHandle,
cur.id, true);
Debug("[CSRMSG]:CSR_BLE_HOST_CONNECTION_UPDATE_REQUEST");
break;
//connection update
case CsrBleDefine.CSR_BLE_HOST_CONNECTION_UPDATED:
var cu =
(CSR_BLE_CONNECTION_UPDATED)
Marshal.PtrToStructure(new IntPtr(m.lParam),
typeof(CSR_BLE_CONNECTION_UPDATED));
OnHostConnectionUpdated(cu);
Debug("[CSRMSG]:CSR_BLE_HOST_CONNECTION_UPDATED");
break;
//host just works
case CsrBleDefine.CSR_BLE_HOST_JUSTWORKS_REQUEST:
var jwr =
(CSR_BLE_JUSTWORKS_REQUEST)
Marshal.PtrToStructure(new IntPtr(m.lParam), typeof(CSR_BLE_JUSTWORKS_REQUEST));
CsrBleDll.CsrBleHostJustWorksResult(jwr.deviceAddress, true, true);
Debug("[CSRMSG]:CSR_BLE_HOST_JUSTWORKS_REQUEST");
break;
//scanning
case CsrBleDefine.CSR_BLE_HOST_LE_SCAN_STATUS:
Debug("[CSRMSG]:CSR_BLE_HOST_LE_SCAN_STATUS");
break;
//read result
case CsrBleDefine.CSR_BLE_CLIENT_CHAR_READ_RESULT:
var read = (CSR_BLE_CHAR_READ_RESULT)
Marshal.PtrToStructure(new IntPtr(m.lParam), typeof(CSR_BLE_CHAR_READ_RESULT));
OnClientCharReadResult(read);
Debug("[CSRMSG]:CSR_BLE_CLIENT_CHAR_READ_RESULT");
break;
//write result
case CsrBleDefine.CSR_BLE_CLIENT_CHAR_WRITE_RESULT:
var write = (CSR_BLE_WRITE_RESULT)
Marshal.PtrToStructure(new IntPtr(m.lParam), typeof(CSR_BLE_WRITE_RESULT));
OnClientCharWriteResult(write);
Debug("[CSRMSG]:CSR_BLE_CLIENT_CHAR_WRITE_RESULT");
break;
//char notify
case CsrBleDefine.CSR_BLE_CLIENT_CHAR_NOTIFICATION:
var notify =
(CSR_BLE_CHAR_NOTIFICATION)
Marshal.PtrToStructure(new IntPtr(m.lParam), typeof(CSR_BLE_CHAR_NOTIFICATION));
OnClientCharNofity(notify);
Trace("[CSRMSG]:CSR_BLE_CLIENT_CHAR_NOTIFICATION");
break;
case CsrBleDefine.CSR_BLE_HOST_SECURITY_RESULT:
//bool encrypting = false;
//// security result.
//var secRes =
// (CSR_BLE_SECURITY_RESULT)
// Marshal.PtrToStructure(new IntPtr(m.lParam), typeof(CSR_BLE_SECURITY_RESULT));
//if (secRes.result != CsrBleDefine.CSR_BLE_SECURITY_BONDING_ESTABLISHED)
//{
// CsrBleDll.CsrBleHostCancel();
// CsrBleDll.CsrBleHostDisconnect(CurDevInfo.ConnHandle);
//}
//else
//{
// encrypting = true;
//}
Trace("[CSRMSG]:CSR_BLE_HOST_SECURITY_RESULT");
break;
default:
Error($"[CSRMSG]:Unhandled uEnergyHost MSG {(uint)m.wParam:X}");
break;
}
}
}
}
Debug("[CSR]:BleHostThread Finish.");
}
