feat: add support for 32-bit UUID

Author: paroga

host/src/types/uuid.rs

@@ -1,6 +1,6 @@
 //! UUID types.
 
-use bt_hci::uuid::{BluetoothUuid128, BluetoothUuid16};
+use bt_hci::uuid::{BluetoothUuid128, BluetoothUuid16, BluetoothUuid32};
 
 use crate::codec::{Decode, Encode, Error, Type};
 
@@ -10,6 +10,8 @@ use crate::codec::{Decode, Encode, Error, Type};
 pub enum Uuid {
     /// 16-bit UUID
     Uuid16([u8; 2]),
+    /// 32-bit UUID
+    Uuid32([u8; 4]),
     /// 128-bit UUID
     Uuid128([u8; 16]),
 }
@@ -20,6 +22,12 @@ impl From<BluetoothUuid16> for Uuid {
     }
 }
 
+impl From<BluetoothUuid32> for Uuid {
+    fn from(data: bt_hci::uuid::BluetoothUuid32) -> Self {
+        Uuid::Uuid32(data.into())
+    }
+}
+
 impl From<BluetoothUuid128> for Uuid {
     fn from(data: bt_hci::uuid::BluetoothUuid128) -> Self {
         Uuid::Uuid128(data.into())
@@ -38,6 +46,18 @@ impl From<[u8; 16]> for Uuid {
     }
 }
 
+impl From<[u8; 4]> for Uuid {
+    fn from(data: [u8; 4]) -> Self {
+        Uuid::Uuid32(data)
+    }
+}
+
+impl From<u32> for Uuid {
+    fn from(data: u32) -> Self {
+        Uuid::Uuid32(data.to_le_bytes())
+    }
+}
+
 impl From<[u8; 2]> for Uuid {
     fn from(data: [u8; 2]) -> Self {
         Uuid::Uuid16(data)
@@ -65,6 +85,7 @@ impl Uuid {
     pub fn bytes(&self, data: &mut [u8]) {
         match self {
             Uuid::Uuid16(uuid) => data.copy_from_slice(uuid),
+            Uuid::Uuid32(uuid) => data.copy_from_slice(uuid),
             Uuid::Uuid128(uuid) => data.copy_from_slice(uuid),
         }
     }
@@ -73,13 +94,15 @@ impl Uuid {
     pub fn get_type(&self) -> u8 {
         match self {
             Uuid::Uuid16(_) => 0x01,
-            Uuid::Uuid128(_) => 0x02,
+            Uuid::Uuid32(_) => 0x02,
+            Uuid::Uuid128(_) => 0x03,
         }
     }
 
     pub(crate) fn size(&self) -> usize {
         match self {
             Uuid::Uuid16(_) => 6,
+            Uuid::Uuid32(_) => 8,
             Uuid::Uuid128(_) => 20,
         }
     }
@@ -96,6 +119,7 @@ impl Uuid {
     pub fn as_raw(&self) -> &[u8] {
         match self {
             Uuid::Uuid16(uuid) => uuid,
+            Uuid::Uuid32(uuid) => uuid,
             Uuid::Uuid128(uuid) => uuid,
         }
     }
@@ -108,6 +132,7 @@ impl TryFrom<&[u8]> for Uuid {
         match value.len() {
             // Slice length has already been verified, so unwrap can be used
             2 => Ok(Uuid::Uuid16(value.try_into().unwrap())),
+            4 => Ok(Uuid::Uuid32(value.try_into().unwrap())),
             16 => {
                 let mut bytes = [0; 16];
                 bytes.copy_from_slice(value);