system/bta/le_audio/storage_helper.cc - platform/packages/modules/Bluetooth - Git at Google

 /******************************************************************************
  *
  *  Copyright 2022 The Android Open Source Project
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
  *  You may obtain a copy of the License at:
  *
  *  http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  *
  ******************************************************************************/

 #include "storage_helper.h"

 #include <bluetooth/log.h>

 #include "client_parser.h"
 #include "common/strings.h"
 #include "le_audio_types.h"
 #include "os/log.h"
 #include "stack/include/bt_types.h"

 using bluetooth::le_audio::types::hdl_pair;

 namespace bluetooth::le_audio {
 static constexpr uint8_t LEAUDIO_PACS_STORAGE_CURRENT_LAYOUT_MAGIC = 0x00;
 static constexpr uint8_t LEAUDIO_ASE_STORAGE_CURRENT_LAYOUT_MAGIC = 0x00;
 static constexpr uint8_t LEAUDIO_HANDLES_STORAGE_CURRENT_LAYOUT_MAGIC = 0x00;
 static constexpr uint8_t LEAUDIO_CODEC_ID_SZ = 5;

 static constexpr size_t LEAUDIO_STORAGE_MAGIC_SZ =
     sizeof(uint8_t) /* magic is always uint8_t */;

 static constexpr size_t LEAUDIO_STORAGE_HEADER_WITH_ENTRIES_SZ =
     LEAUDIO_STORAGE_MAGIC_SZ + sizeof(uint8_t); /* num_of_entries */

 static constexpr size_t LEAUDIO_PACS_ENTRY_HDR_SZ =
     sizeof(uint16_t) /*handle*/ + sizeof(uint16_t) /*ccc handle*/ +
     sizeof(uint8_t) /* number of pack records in single characteristic */;

 static constexpr size_t LEAUDIO_PACS_ENTRY_SZ =
     sizeof(uint8_t) /* size of single pac record */ +
     LEAUDIO_CODEC_ID_SZ /*codec id*/ +
     sizeof(uint8_t) /*codec capabilities len*/ +
     sizeof(uint8_t) /*metadata len*/;

 static constexpr size_t LEAUDIO_ASES_ENTRY_SZ =
     sizeof(uint16_t) /*handle*/ + sizeof(uint16_t) /*ccc handle*/ +
     sizeof(uint8_t) /*direction*/ + sizeof(uint8_t) /*ase id*/;

 static constexpr size_t LEAUDIO_STORAGE_HANDLES_ENTRIES_SZ =
     LEAUDIO_STORAGE_MAGIC_SZ + sizeof(uint16_t) /*control point handle*/ +
     sizeof(uint16_t) /*ccc handle*/ +
     sizeof(uint16_t) /*sink audio location handle*/ +
     sizeof(uint16_t) /*ccc handle*/ +
     sizeof(uint16_t) /*source audio location handle*/ +
     sizeof(uint16_t) /*ccc handle*/ +
     sizeof(uint16_t) /*supported context type handle*/ +
     sizeof(uint16_t) /*ccc handle*/ +
     sizeof(uint16_t) /*available context type handle*/ +
     sizeof(uint16_t) /*ccc handle*/ + sizeof(uint16_t) /* tmas handle */;

 bool serializePacs(
     const bluetooth::le_audio::types::PublishedAudioCapabilities& pacs,
     std::vector<uint8_t>& out) {
   auto num_of_pacs = pacs.size();
   if (num_of_pacs == 0 || (num_of_pacs > std::numeric_limits<uint8_t>::max())) {
     log::warn("No pacs available");
     return false;
   }

   /* Calculate the total size */
   auto pac_bin_size = LEAUDIO_STORAGE_HEADER_WITH_ENTRIES_SZ;
   for (auto pac_tuple : pacs) {
     auto& pac_recs = std::get<1>(pac_tuple);
     pac_bin_size += LEAUDIO_PACS_ENTRY_HDR_SZ;
     for (const auto& pac : pac_recs) {
       pac_bin_size += LEAUDIO_PACS_ENTRY_SZ;
       pac_bin_size += pac.metadata.size();
       pac_bin_size += pac.codec_spec_caps_raw.size();
     }
   }

   out.resize(pac_bin_size);
   auto* ptr = out.data();

   /* header */
   UINT8_TO_STREAM(ptr, LEAUDIO_PACS_STORAGE_CURRENT_LAYOUT_MAGIC);
   UINT8_TO_STREAM(ptr, num_of_pacs);

   /* pacs entries */
   for (auto pac_tuple : pacs) {
     auto& pac_recs = std::get<1>(pac_tuple);
     uint16_t handle = std::get<0>(pac_tuple).val_hdl;
     uint16_t ccc_handle = std::get<0>(pac_tuple).ccc_hdl;

     UINT16_TO_STREAM(ptr, handle);
     UINT16_TO_STREAM(ptr, ccc_handle);
     UINT8_TO_STREAM(ptr, pac_recs.size());

     log::verbose("Handle: 0x{:04x}, ccc handle: 0x{:04x}, pac count: {}",
                  handle, ccc_handle, static_cast<int>(pac_recs.size()));

     for (const auto& pac : pac_recs) {
       /* Pac len */
       auto pac_len = LEAUDIO_PACS_ENTRY_SZ + pac.codec_spec_caps_raw.size() +
                      pac.metadata.size();
       log::verbose("Pac size {}", static_cast<int>(pac_len));
       UINT8_TO_STREAM(ptr, pac_len - 1 /* Minus size */);

       /* Codec ID*/
       UINT8_TO_STREAM(ptr, pac.codec_id.coding_format);
       UINT16_TO_STREAM(ptr, pac.codec_id.vendor_company_id);
       UINT16_TO_STREAM(ptr, pac.codec_id.vendor_codec_id);

       /* Codec caps */
       log::verbose("Codec capability size {}",
                    static_cast<int>(pac.codec_spec_caps_raw.size()));
       UINT8_TO_STREAM(ptr, pac.codec_spec_caps_raw.size());
       if (pac.codec_spec_caps_raw.size() > 0) {
         ARRAY_TO_STREAM(ptr, pac.codec_spec_caps_raw.data(),
                         static_cast<int>(pac.codec_spec_caps_raw.size()));
       }

       /* Metadata */
       log::verbose("Metadata size {}", static_cast<int>(pac.metadata.size()));
       UINT8_TO_STREAM(ptr, pac.metadata.size());
       if (pac.metadata.size() > 0) {
         ARRAY_TO_STREAM(ptr, pac.metadata.data(), (int)pac.metadata.size());
       }
     }
   }
   return true;
 }

 bool SerializeSinkPacs(const bluetooth::le_audio::LeAudioDevice* leAudioDevice,
                        std::vector<uint8_t>& out) {
   if (leAudioDevice == nullptr) {
     log::warn("Skipping unknown device");
     return false;
   }
   log::verbose("Device {}, num of PAC characteristics: {}",
                leAudioDevice->address_,
                static_cast<int>(leAudioDevice->snk_pacs_.size()));
   return serializePacs(leAudioDevice->snk_pacs_, out);
 }

 bool SerializeSourcePacs(
     const bluetooth::le_audio::LeAudioDevice* leAudioDevice,
     std::vector<uint8_t>& out) {
   if (leAudioDevice == nullptr) {
     log::warn("Skipping unknown device");
     return false;
   }
   log::verbose("Device {}, num of PAC characteristics: {}",
                leAudioDevice->address_,
                static_cast<int>(leAudioDevice->src_pacs_.size()));
   return serializePacs(leAudioDevice->src_pacs_, out);
 }

 bool deserializePacs(LeAudioDevice* leAudioDevice,
                      types::PublishedAudioCapabilities& pacs_db,
                      const std::vector<uint8_t>& in) {
   if (in.size() <
       LEAUDIO_STORAGE_HEADER_WITH_ENTRIES_SZ + LEAUDIO_PACS_ENTRY_SZ) {
     log::warn("There is not single PACS stored");
     return false;
   }

   auto* ptr = in.data();

   uint8_t magic;
   STREAM_TO_UINT8(magic, ptr);

   if (magic != LEAUDIO_PACS_STORAGE_CURRENT_LAYOUT_MAGIC) {
     log::error("Invalid magic ({}!={}) for device {}", magic,
                LEAUDIO_PACS_STORAGE_CURRENT_LAYOUT_MAGIC,
                leAudioDevice->address_);
     return false;
   }

   uint8_t num_of_pacs_chars;
   STREAM_TO_UINT8(num_of_pacs_chars, ptr);

   if (in.size() < LEAUDIO_STORAGE_HEADER_WITH_ENTRIES_SZ +
                       (num_of_pacs_chars * LEAUDIO_PACS_ENTRY_SZ)) {
     log::error("Invalid persistent storage data for device {}",
                leAudioDevice->address_);
     return false;
   }

   /* pacs entries */
   while (num_of_pacs_chars--) {
     struct hdl_pair hdl_pair;
     uint8_t pac_count;

     STREAM_TO_UINT16(hdl_pair.val_hdl, ptr);
     STREAM_TO_UINT16(hdl_pair.ccc_hdl, ptr);
     STREAM_TO_UINT8(pac_count, ptr);

     log::verbose("Handle: 0x{:04x}, ccc handle: 0x{:04x}, pac_count: {}",
                  hdl_pair.val_hdl, hdl_pair.ccc_hdl, pac_count);

     pacs_db.push_back(std::make_tuple(
         hdl_pair,
         std::vector<struct bluetooth::le_audio::types::acs_ac_record>()));

     auto hdl = hdl_pair.val_hdl;
     auto pac_tuple_iter = std::find_if(
         pacs_db.begin(), pacs_db.end(),
         [&hdl](auto& pac_ent) { return std::get<0>(pac_ent).val_hdl == hdl; });

     std::vector<struct bluetooth::le_audio::types::acs_ac_record> pac_recs;
     while (pac_count--) {
       uint8_t pac_len;
       STREAM_TO_UINT8(pac_len, ptr);
       log::verbose("Pac len {}", pac_len);

       if (client_parser::pacs::ParseSinglePac(pac_recs, pac_len, ptr) < 0) {
         log::error("Cannot parse stored PACs (impossible)");
         return false;
       }
       ptr += pac_len;
     }
     leAudioDevice->RegisterPACs(&std::get<1>(*pac_tuple_iter), &pac_recs);
   }

   return true;
 }

 bool DeserializeSinkPacs(bluetooth::le_audio::LeAudioDevice* leAudioDevice,
                          const std::vector<uint8_t>& in) {
   log::verbose("");
   if (leAudioDevice == nullptr) {
     log::warn("Skipping unknown device");
     return false;
   }
   return deserializePacs(leAudioDevice, leAudioDevice->snk_pacs_, in);
 }

 bool DeserializeSourcePacs(bluetooth::le_audio::LeAudioDevice* leAudioDevice,
                            const std::vector<uint8_t>& in) {
   log::verbose("");
   if (leAudioDevice == nullptr) {
     log::warn("Skipping unknown device");
     return false;
   }
   return deserializePacs(leAudioDevice, leAudioDevice->src_pacs_, in);
 }

 bool SerializeAses(const bluetooth::le_audio::LeAudioDevice* leAudioDevice,
                    std::vector<uint8_t>& out) {
   if (leAudioDevice == nullptr) {
     log::warn("Skipping unknown device");
     return false;
   }

   auto num_of_ases = leAudioDevice->ases_.size();
   log::debug("device: {}, number of ases {}", leAudioDevice->address_,
              static_cast<int>(num_of_ases));

   if (num_of_ases == 0 || (num_of_ases > std::numeric_limits<uint8_t>::max())) {
     log::warn("No ases available for device {}", leAudioDevice->address_);
     return false;
   }

   /* Calculate the total size */
   auto ases_bin_size = LEAUDIO_STORAGE_HEADER_WITH_ENTRIES_SZ +
                        num_of_ases * LEAUDIO_ASES_ENTRY_SZ;
   out.resize(ases_bin_size);
   auto* ptr = out.data();

   /* header */
   UINT8_TO_STREAM(ptr, LEAUDIO_ASE_STORAGE_CURRENT_LAYOUT_MAGIC);
   UINT8_TO_STREAM(ptr, num_of_ases);

   /* pacs entries */
   for (const auto& ase : leAudioDevice->ases_) {
     log::verbose(
         "Storing ASE ID: {}, direction {}, handle 0x{:04x}, ccc_handle "
         "0x{:04x}",
         ase.id,
         ase.direction == bluetooth::le_audio::types::kLeAudioDirectionSink
             ? "sink "
             : "source",
         ase.hdls.val_hdl, ase.hdls.ccc_hdl);

     UINT16_TO_STREAM(ptr, ase.hdls.val_hdl);
     UINT16_TO_STREAM(ptr, ase.hdls.ccc_hdl);
     UINT8_TO_STREAM(ptr, ase.id);
     UINT8_TO_STREAM(ptr, ase.direction);
   }

   return true;
 }

 bool DeserializeAses(bluetooth::le_audio::LeAudioDevice* leAudioDevice,
                      const std::vector<uint8_t>& in) {
   if (leAudioDevice == nullptr) {
     log::warn("Skipping unknown device");
     return false;
   }

   if (in.size() <
       LEAUDIO_STORAGE_HEADER_WITH_ENTRIES_SZ + LEAUDIO_ASES_ENTRY_SZ) {
     log::warn("There is not single ASE stored for device {}",
               leAudioDevice->address_);
     return false;
   }

   auto* ptr = in.data();

   uint8_t magic;
   STREAM_TO_UINT8(magic, ptr);

   if (magic != LEAUDIO_ASE_STORAGE_CURRENT_LAYOUT_MAGIC) {
     log::error("Invalid magic ({}!={}", magic,
                LEAUDIO_PACS_STORAGE_CURRENT_LAYOUT_MAGIC);
     return false;
   }

   uint8_t num_of_ases;
   STREAM_TO_UINT8(num_of_ases, ptr);

   if (in.size() < LEAUDIO_STORAGE_HEADER_WITH_ENTRIES_SZ +
                       (num_of_ases * LEAUDIO_ASES_ENTRY_SZ)) {
     log::error("Invalid persistent storage data for device {}",
                leAudioDevice->address_);
     return false;
   }

   log::debug("Loading {} Ases for device {}", num_of_ases,
              leAudioDevice->address_);
   /* sets entries */
   while (num_of_ases--) {
     uint16_t handle;
     uint16_t ccc_handle;
     uint8_t direction;
     uint8_t ase_id;

     STREAM_TO_UINT16(handle, ptr);
     STREAM_TO_UINT16(ccc_handle, ptr);
     STREAM_TO_UINT8(ase_id, ptr);
     STREAM_TO_UINT8(direction, ptr);

     leAudioDevice->ases_.emplace_back(handle, ccc_handle, direction, ase_id);
     log::verbose(
         "Loading ASE ID: {}, direction {}, handle 0x{:04x}, ccc_handle "
         "0x{:04x}",
         ase_id,
         direction == bluetooth::le_audio::types::kLeAudioDirectionSink
             ? "sink "
             : "source",
         handle, ccc_handle);
   }

   return true;
 }

 bool SerializeHandles(const LeAudioDevice* leAudioDevice,
                       std::vector<uint8_t>& out) {
   if (leAudioDevice == nullptr) {
     log::warn("Skipping unknown device");
     return false;
   }

   /* Calculate the total size */
   out.resize(LEAUDIO_STORAGE_HANDLES_ENTRIES_SZ);
   auto* ptr = out.data();

   /* header */
   UINT8_TO_STREAM(ptr, LEAUDIO_HANDLES_STORAGE_CURRENT_LAYOUT_MAGIC);

   if (leAudioDevice->ctp_hdls_.val_hdl == 0 ||
       leAudioDevice->ctp_hdls_.ccc_hdl == 0) {
     log::warn("Invalid control point handles for device {}",
               leAudioDevice->address_);
     return false;
   }

   UINT16_TO_STREAM(ptr, leAudioDevice->ctp_hdls_.val_hdl);
   UINT16_TO_STREAM(ptr, leAudioDevice->ctp_hdls_.ccc_hdl);

   UINT16_TO_STREAM(ptr, leAudioDevice->snk_audio_locations_hdls_.val_hdl);
   UINT16_TO_STREAM(ptr, leAudioDevice->snk_audio_locations_hdls_.ccc_hdl);

   UINT16_TO_STREAM(ptr, leAudioDevice->src_audio_locations_hdls_.val_hdl);
   UINT16_TO_STREAM(ptr, leAudioDevice->src_audio_locations_hdls_.ccc_hdl);

   UINT16_TO_STREAM(ptr, leAudioDevice->audio_supp_cont_hdls_.val_hdl);
   UINT16_TO_STREAM(ptr, leAudioDevice->audio_supp_cont_hdls_.ccc_hdl);

   UINT16_TO_STREAM(ptr, leAudioDevice->audio_avail_hdls_.val_hdl);
   UINT16_TO_STREAM(ptr, leAudioDevice->audio_avail_hdls_.ccc_hdl);

   UINT16_TO_STREAM(ptr, leAudioDevice->tmap_role_hdl_);

   return true;
 }

 bool DeserializeHandles(LeAudioDevice* leAudioDevice,
                         const std::vector<uint8_t>& in) {
   if (leAudioDevice == nullptr) {
     log::warn("Skipping unknown device");
     return false;
   }

   if (in.size() != LEAUDIO_STORAGE_HANDLES_ENTRIES_SZ) {
     log::warn("There is not single ASE stored for device {}",
               leAudioDevice->address_);
     return false;
   }

   auto* ptr = in.data();

   uint8_t magic;
   STREAM_TO_UINT8(magic, ptr);

   if (magic != LEAUDIO_HANDLES_STORAGE_CURRENT_LAYOUT_MAGIC) {
     log::error("Invalid magic ({}!={}) for device {}", magic,
                LEAUDIO_PACS_STORAGE_CURRENT_LAYOUT_MAGIC,
                leAudioDevice->address_);
     return false;
   }

   STREAM_TO_UINT16(leAudioDevice->ctp_hdls_.val_hdl, ptr);
   STREAM_TO_UINT16(leAudioDevice->ctp_hdls_.ccc_hdl, ptr);
   log::verbose("ctp.val_hdl: 0x{:04x}, ctp.ccc_hdl: 0x{:04x}",
                leAudioDevice->ctp_hdls_.val_hdl,
                leAudioDevice->ctp_hdls_.ccc_hdl);

   STREAM_TO_UINT16(leAudioDevice->snk_audio_locations_hdls_.val_hdl, ptr);
   STREAM_TO_UINT16(leAudioDevice->snk_audio_locations_hdls_.ccc_hdl, ptr);
   log::verbose(
       "snk_audio_locations_hdls_.val_hdl: "
       "0x{:04x},snk_audio_locations_hdls_.ccc_hdl: 0x{:04x}",
       leAudioDevice->snk_audio_locations_hdls_.val_hdl,
       leAudioDevice->snk_audio_locations_hdls_.ccc_hdl);

   STREAM_TO_UINT16(leAudioDevice->src_audio_locations_hdls_.val_hdl, ptr);
   STREAM_TO_UINT16(leAudioDevice->src_audio_locations_hdls_.ccc_hdl, ptr);
   log::verbose(
       "src_audio_locations_hdls_.val_hdl: "
       "0x{:04x},src_audio_locations_hdls_.ccc_hdl: 0x{:04x}",
       leAudioDevice->src_audio_locations_hdls_.val_hdl,
       leAudioDevice->src_audio_locations_hdls_.ccc_hdl);

   STREAM_TO_UINT16(leAudioDevice->audio_supp_cont_hdls_.val_hdl, ptr);
   STREAM_TO_UINT16(leAudioDevice->audio_supp_cont_hdls_.ccc_hdl, ptr);
   log::verbose(
       "audio_supp_cont_hdls_.val_hdl: 0x{:04x},audio_supp_cont_hdls_.ccc_hdl: "
       "0x{:04x}",
       leAudioDevice->audio_supp_cont_hdls_.val_hdl,
       leAudioDevice->audio_supp_cont_hdls_.ccc_hdl);

   STREAM_TO_UINT16(leAudioDevice->audio_avail_hdls_.val_hdl, ptr);
   STREAM_TO_UINT16(leAudioDevice->audio_avail_hdls_.ccc_hdl, ptr);
   log::verbose(
       "audio_avail_hdls_.val_hdl: 0x{:04x},audio_avail_hdls_.ccc_hdl: 0x{:04x}",
       leAudioDevice->audio_avail_hdls_.val_hdl,
       leAudioDevice->audio_avail_hdls_.ccc_hdl);

   STREAM_TO_UINT16(leAudioDevice->tmap_role_hdl_, ptr);
   log::verbose("tmap_role_hdl_: 0x{:04x}", leAudioDevice->tmap_role_hdl_);

   leAudioDevice->known_service_handles_ = true;
   return true;
 }
 }  // namespace bluetooth::le_audio
	/******************************************************************************
	*
	* Copyright 2022 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at:
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	******************************************************************************/

	#include "storage_helper.h"

	#include <bluetooth/log.h>

	#include "client_parser.h"
	#include "common/strings.h"
	#include "le_audio_types.h"
	#include "os/log.h"
	#include "stack/include/bt_types.h"

	using bluetooth::le_audio::types::hdl_pair;

	namespace bluetooth::le_audio {
	static constexpr uint8_t LEAUDIO_PACS_STORAGE_CURRENT_LAYOUT_MAGIC = 0x00;
	static constexpr uint8_t LEAUDIO_ASE_STORAGE_CURRENT_LAYOUT_MAGIC = 0x00;
	static constexpr uint8_t LEAUDIO_HANDLES_STORAGE_CURRENT_LAYOUT_MAGIC = 0x00;
	static constexpr uint8_t LEAUDIO_CODEC_ID_SZ = 5;

	static constexpr size_t LEAUDIO_STORAGE_MAGIC_SZ =
	sizeof(uint8_t) /* magic is always uint8_t */;

	static constexpr size_t LEAUDIO_STORAGE_HEADER_WITH_ENTRIES_SZ =
	LEAUDIO_STORAGE_MAGIC_SZ + sizeof(uint8_t); /* num_of_entries */

	static constexpr size_t LEAUDIO_PACS_ENTRY_HDR_SZ =
	sizeof(uint16_t) /handle/ + sizeof(uint16_t) /ccc handle/ +
	sizeof(uint8_t) /* number of pack records in single characteristic */;

	static constexpr size_t LEAUDIO_PACS_ENTRY_SZ =
	sizeof(uint8_t) /* size of single pac record */ +
	LEAUDIO_CODEC_ID_SZ /codec id/ +
	sizeof(uint8_t) /codec capabilities len/ +
	sizeof(uint8_t) /metadata len/;

	static constexpr size_t LEAUDIO_ASES_ENTRY_SZ =
	sizeof(uint16_t) /handle/ + sizeof(uint16_t) /ccc handle/ +
	sizeof(uint8_t) /direction/ + sizeof(uint8_t) /ase id/;

	static constexpr size_t LEAUDIO_STORAGE_HANDLES_ENTRIES_SZ =
	LEAUDIO_STORAGE_MAGIC_SZ + sizeof(uint16_t) /control point handle/ +
	sizeof(uint16_t) /ccc handle/ +
	sizeof(uint16_t) /sink audio location handle/ +
	sizeof(uint16_t) /ccc handle/ +
	sizeof(uint16_t) /source audio location handle/ +
	sizeof(uint16_t) /ccc handle/ +
	sizeof(uint16_t) /supported context type handle/ +
	sizeof(uint16_t) /ccc handle/ +
	sizeof(uint16_t) /available context type handle/ +
	sizeof(uint16_t) /ccc handle/ + sizeof(uint16_t) /* tmas handle */;

	bool serializePacs(
	const bluetooth::le_audio::types::PublishedAudioCapabilities& pacs,
	std::vector<uint8_t>& out) {
	auto num_of_pacs = pacs.size();
	if (num_of_pacs == 0 \|\| (num_of_pacs > std::numeric_limits<uint8_t>::max())) {
	log::warn("No pacs available");
	return false;
	}

	/* Calculate the total size */
	auto pac_bin_size = LEAUDIO_STORAGE_HEADER_WITH_ENTRIES_SZ;
	for (auto pac_tuple : pacs) {
	auto& pac_recs = std::get<1>(pac_tuple);
	pac_bin_size += LEAUDIO_PACS_ENTRY_HDR_SZ;
	for (const auto& pac : pac_recs) {
	pac_bin_size += LEAUDIO_PACS_ENTRY_SZ;
	pac_bin_size += pac.metadata.size();
	pac_bin_size += pac.codec_spec_caps_raw.size();
	}
	}

	out.resize(pac_bin_size);
	auto* ptr = out.data();

	/* header */
	UINT8_TO_STREAM(ptr, LEAUDIO_PACS_STORAGE_CURRENT_LAYOUT_MAGIC);
	UINT8_TO_STREAM(ptr, num_of_pacs);

	/* pacs entries */
	for (auto pac_tuple : pacs) {
	auto& pac_recs = std::get<1>(pac_tuple);
	uint16_t handle = std::get<0>(pac_tuple).val_hdl;
	uint16_t ccc_handle = std::get<0>(pac_tuple).ccc_hdl;

	UINT16_TO_STREAM(ptr, handle);
	UINT16_TO_STREAM(ptr, ccc_handle);
	UINT8_TO_STREAM(ptr, pac_recs.size());

	log::verbose("Handle: 0x{:04x}, ccc handle: 0x{:04x}, pac count: {}",
	handle, ccc_handle, static_cast<int>(pac_recs.size()));

	for (const auto& pac : pac_recs) {
	/* Pac len */
	auto pac_len = LEAUDIO_PACS_ENTRY_SZ + pac.codec_spec_caps_raw.size() +
	pac.metadata.size();
	log::verbose("Pac size {}", static_cast<int>(pac_len));
	UINT8_TO_STREAM(ptr, pac_len - 1 /* Minus size */);

	/* Codec ID*/
	UINT8_TO_STREAM(ptr, pac.codec_id.coding_format);
	UINT16_TO_STREAM(ptr, pac.codec_id.vendor_company_id);
	UINT16_TO_STREAM(ptr, pac.codec_id.vendor_codec_id);

	/* Codec caps */
	log::verbose("Codec capability size {}",
	static_cast<int>(pac.codec_spec_caps_raw.size()));
	UINT8_TO_STREAM(ptr, pac.codec_spec_caps_raw.size());
	if (pac.codec_spec_caps_raw.size() > 0) {
	ARRAY_TO_STREAM(ptr, pac.codec_spec_caps_raw.data(),
	static_cast<int>(pac.codec_spec_caps_raw.size()));
	}

	/* Metadata */
	log::verbose("Metadata size {}", static_cast<int>(pac.metadata.size()));
	UINT8_TO_STREAM(ptr, pac.metadata.size());
	if (pac.metadata.size() > 0) {
	ARRAY_TO_STREAM(ptr, pac.metadata.data(), (int)pac.metadata.size());
	}
	}
	}
	return true;
	}

	bool SerializeSinkPacs(const bluetooth::le_audio::LeAudioDevice* leAudioDevice,
	std::vector<uint8_t>& out) {
	if (leAudioDevice == nullptr) {
	log::warn("Skipping unknown device");
	return false;
	}
	log::verbose("Device {}, num of PAC characteristics: {}",
	leAudioDevice->address_,
	static_cast<int>(leAudioDevice->snk_pacs_.size()));
	return serializePacs(leAudioDevice->snk_pacs_, out);
	}

	bool SerializeSourcePacs(
	const bluetooth::le_audio::LeAudioDevice* leAudioDevice,
	std::vector<uint8_t>& out) {
	if (leAudioDevice == nullptr) {
	log::warn("Skipping unknown device");
	return false;
	}
	log::verbose("Device {}, num of PAC characteristics: {}",
	leAudioDevice->address_,
	static_cast<int>(leAudioDevice->src_pacs_.size()));
	return serializePacs(leAudioDevice->src_pacs_, out);
	}

	bool deserializePacs(LeAudioDevice* leAudioDevice,
	types::PublishedAudioCapabilities& pacs_db,
	const std::vector<uint8_t>& in) {
	if (in.size() <
	LEAUDIO_STORAGE_HEADER_WITH_ENTRIES_SZ + LEAUDIO_PACS_ENTRY_SZ) {
	log::warn("There is not single PACS stored");
	return false;
	}

	auto* ptr = in.data();

	uint8_t magic;
	STREAM_TO_UINT8(magic, ptr);

	if (magic != LEAUDIO_PACS_STORAGE_CURRENT_LAYOUT_MAGIC) {
	log::error("Invalid magic ({}!={}) for device {}", magic,
	LEAUDIO_PACS_STORAGE_CURRENT_LAYOUT_MAGIC,
	leAudioDevice->address_);
	return false;
	}

	uint8_t num_of_pacs_chars;
	STREAM_TO_UINT8(num_of_pacs_chars, ptr);

	if (in.size() < LEAUDIO_STORAGE_HEADER_WITH_ENTRIES_SZ +
	(num_of_pacs_chars * LEAUDIO_PACS_ENTRY_SZ)) {
	log::error("Invalid persistent storage data for device {}",
	leAudioDevice->address_);
	return false;
	}

	/* pacs entries */
	while (num_of_pacs_chars--) {
	struct hdl_pair hdl_pair;
	uint8_t pac_count;

	STREAM_TO_UINT16(hdl_pair.val_hdl, ptr);
	STREAM_TO_UINT16(hdl_pair.ccc_hdl, ptr);
	STREAM_TO_UINT8(pac_count, ptr);

	log::verbose("Handle: 0x{:04x}, ccc handle: 0x{:04x}, pac_count: {}",
	hdl_pair.val_hdl, hdl_pair.ccc_hdl, pac_count);

	pacs_db.push_back(std::make_tuple(
	hdl_pair,
	std::vector<struct bluetooth::le_audio::types::acs_ac_record>()));

	auto hdl = hdl_pair.val_hdl;
	auto pac_tuple_iter = std::find_if(
	pacs_db.begin(), pacs_db.end(),
	[&hdl](auto& pac_ent) { return std::get<0>(pac_ent).val_hdl == hdl; });

	std::vector<struct bluetooth::le_audio::types::acs_ac_record> pac_recs;
	while (pac_count--) {
	uint8_t pac_len;
	STREAM_TO_UINT8(pac_len, ptr);
	log::verbose("Pac len {}", pac_len);

	if (client_parser::pacs::ParseSinglePac(pac_recs, pac_len, ptr) < 0) {
	log::error("Cannot parse stored PACs (impossible)");
	return false;
	}
	ptr += pac_len;
	}
	leAudioDevice->RegisterPACs(&std::get<1>(*pac_tuple_iter), &pac_recs);
	}

	return true;
	}

	bool DeserializeSinkPacs(bluetooth::le_audio::LeAudioDevice* leAudioDevice,
	const std::vector<uint8_t>& in) {
	log::verbose("");
	if (leAudioDevice == nullptr) {
	log::warn("Skipping unknown device");
	return false;
	}
	return deserializePacs(leAudioDevice, leAudioDevice->snk_pacs_, in);
	}

	bool DeserializeSourcePacs(bluetooth::le_audio::LeAudioDevice* leAudioDevice,
	const std::vector<uint8_t>& in) {
	log::verbose("");
	if (leAudioDevice == nullptr) {
	log::warn("Skipping unknown device");
	return false;
	}
	return deserializePacs(leAudioDevice, leAudioDevice->src_pacs_, in);
	}

	bool SerializeAses(const bluetooth::le_audio::LeAudioDevice* leAudioDevice,
	std::vector<uint8_t>& out) {
	if (leAudioDevice == nullptr) {
	log::warn("Skipping unknown device");
	return false;
	}

	auto num_of_ases = leAudioDevice->ases_.size();
	log::debug("device: {}, number of ases {}", leAudioDevice->address_,
	static_cast<int>(num_of_ases));

	if (num_of_ases == 0 \|\| (num_of_ases > std::numeric_limits<uint8_t>::max())) {
	log::warn("No ases available for device {}", leAudioDevice->address_);
	return false;
	}

	/* Calculate the total size */
	auto ases_bin_size = LEAUDIO_STORAGE_HEADER_WITH_ENTRIES_SZ +
	num_of_ases * LEAUDIO_ASES_ENTRY_SZ;
	out.resize(ases_bin_size);
	auto* ptr = out.data();

	/* header */
	UINT8_TO_STREAM(ptr, LEAUDIO_ASE_STORAGE_CURRENT_LAYOUT_MAGIC);
	UINT8_TO_STREAM(ptr, num_of_ases);

	/* pacs entries */
	for (const auto& ase : leAudioDevice->ases_) {
	log::verbose(
	"Storing ASE ID: {}, direction {}, handle 0x{:04x}, ccc_handle "
	"0x{:04x}",
	ase.id,
	ase.direction == bluetooth::le_audio::types::kLeAudioDirectionSink
	? "sink "
	: "source",
	ase.hdls.val_hdl, ase.hdls.ccc_hdl);

	UINT16_TO_STREAM(ptr, ase.hdls.val_hdl);
	UINT16_TO_STREAM(ptr, ase.hdls.ccc_hdl);
	UINT8_TO_STREAM(ptr, ase.id);
	UINT8_TO_STREAM(ptr, ase.direction);
	}

	return true;
	}

	bool DeserializeAses(bluetooth::le_audio::LeAudioDevice* leAudioDevice,
	const std::vector<uint8_t>& in) {
	if (leAudioDevice == nullptr) {
	log::warn("Skipping unknown device");
	return false;
	}

	if (in.size() <
	LEAUDIO_STORAGE_HEADER_WITH_ENTRIES_SZ + LEAUDIO_ASES_ENTRY_SZ) {
	log::warn("There is not single ASE stored for device {}",
	leAudioDevice->address_);
	return false;
	}

	auto* ptr = in.data();

	uint8_t magic;
	STREAM_TO_UINT8(magic, ptr);

	if (magic != LEAUDIO_ASE_STORAGE_CURRENT_LAYOUT_MAGIC) {
	log::error("Invalid magic ({}!={}", magic,
	LEAUDIO_PACS_STORAGE_CURRENT_LAYOUT_MAGIC);
	return false;
	}

	uint8_t num_of_ases;
	STREAM_TO_UINT8(num_of_ases, ptr);

	if (in.size() < LEAUDIO_STORAGE_HEADER_WITH_ENTRIES_SZ +
	(num_of_ases * LEAUDIO_ASES_ENTRY_SZ)) {
	log::error("Invalid persistent storage data for device {}",
	leAudioDevice->address_);
	return false;
	}

	log::debug("Loading {} Ases for device {}", num_of_ases,
	leAudioDevice->address_);
	/* sets entries */
	while (num_of_ases--) {
	uint16_t handle;
	uint16_t ccc_handle;
	uint8_t direction;
	uint8_t ase_id;

	STREAM_TO_UINT16(handle, ptr);
	STREAM_TO_UINT16(ccc_handle, ptr);
	STREAM_TO_UINT8(ase_id, ptr);
	STREAM_TO_UINT8(direction, ptr);

	leAudioDevice->ases_.emplace_back(handle, ccc_handle, direction, ase_id);
	log::verbose(
	"Loading ASE ID: {}, direction {}, handle 0x{:04x}, ccc_handle "
	"0x{:04x}",
	ase_id,
	direction == bluetooth::le_audio::types::kLeAudioDirectionSink
	? "sink "
	: "source",
	handle, ccc_handle);
	}

	return true;
	}

	bool SerializeHandles(const LeAudioDevice* leAudioDevice,
	std::vector<uint8_t>& out) {
	if (leAudioDevice == nullptr) {
	log::warn("Skipping unknown device");
	return false;
	}

	/* Calculate the total size */
	out.resize(LEAUDIO_STORAGE_HANDLES_ENTRIES_SZ);
	auto* ptr = out.data();

	/* header */
	UINT8_TO_STREAM(ptr, LEAUDIO_HANDLES_STORAGE_CURRENT_LAYOUT_MAGIC);

	if (leAudioDevice->ctp_hdls_.val_hdl == 0 \|\|
	leAudioDevice->ctp_hdls_.ccc_hdl == 0) {
	log::warn("Invalid control point handles for device {}",
	leAudioDevice->address_);
	return false;
	}

	UINT16_TO_STREAM(ptr, leAudioDevice->ctp_hdls_.val_hdl);
	UINT16_TO_STREAM(ptr, leAudioDevice->ctp_hdls_.ccc_hdl);

	UINT16_TO_STREAM(ptr, leAudioDevice->snk_audio_locations_hdls_.val_hdl);
	UINT16_TO_STREAM(ptr, leAudioDevice->snk_audio_locations_hdls_.ccc_hdl);

	UINT16_TO_STREAM(ptr, leAudioDevice->src_audio_locations_hdls_.val_hdl);
	UINT16_TO_STREAM(ptr, leAudioDevice->src_audio_locations_hdls_.ccc_hdl);

	UINT16_TO_STREAM(ptr, leAudioDevice->audio_supp_cont_hdls_.val_hdl);
	UINT16_TO_STREAM(ptr, leAudioDevice->audio_supp_cont_hdls_.ccc_hdl);

	UINT16_TO_STREAM(ptr, leAudioDevice->audio_avail_hdls_.val_hdl);
	UINT16_TO_STREAM(ptr, leAudioDevice->audio_avail_hdls_.ccc_hdl);

	UINT16_TO_STREAM(ptr, leAudioDevice->tmap_role_hdl_);

	return true;
	}

	bool DeserializeHandles(LeAudioDevice* leAudioDevice,
	const std::vector<uint8_t>& in) {
	if (leAudioDevice == nullptr) {
	log::warn("Skipping unknown device");
	return false;
	}

	if (in.size() != LEAUDIO_STORAGE_HANDLES_ENTRIES_SZ) {
	log::warn("There is not single ASE stored for device {}",
	leAudioDevice->address_);
	return false;
	}

	auto* ptr = in.data();

	uint8_t magic;
	STREAM_TO_UINT8(magic, ptr);

	if (magic != LEAUDIO_HANDLES_STORAGE_CURRENT_LAYOUT_MAGIC) {
	log::error("Invalid magic ({}!={}) for device {}", magic,
	LEAUDIO_PACS_STORAGE_CURRENT_LAYOUT_MAGIC,
	leAudioDevice->address_);
	return false;
	}

	STREAM_TO_UINT16(leAudioDevice->ctp_hdls_.val_hdl, ptr);
	STREAM_TO_UINT16(leAudioDevice->ctp_hdls_.ccc_hdl, ptr);
	log::verbose("ctp.val_hdl: 0x{:04x}, ctp.ccc_hdl: 0x{:04x}",
	leAudioDevice->ctp_hdls_.val_hdl,
	leAudioDevice->ctp_hdls_.ccc_hdl);

	STREAM_TO_UINT16(leAudioDevice->snk_audio_locations_hdls_.val_hdl, ptr);
	STREAM_TO_UINT16(leAudioDevice->snk_audio_locations_hdls_.ccc_hdl, ptr);
	log::verbose(
	"snk_audio_locations_hdls_.val_hdl: "
	"0x{:04x},snk_audio_locations_hdls_.ccc_hdl: 0x{:04x}",
	leAudioDevice->snk_audio_locations_hdls_.val_hdl,
	leAudioDevice->snk_audio_locations_hdls_.ccc_hdl);

	STREAM_TO_UINT16(leAudioDevice->src_audio_locations_hdls_.val_hdl, ptr);
	STREAM_TO_UINT16(leAudioDevice->src_audio_locations_hdls_.ccc_hdl, ptr);
	log::verbose(
	"src_audio_locations_hdls_.val_hdl: "
	"0x{:04x},src_audio_locations_hdls_.ccc_hdl: 0x{:04x}",
	leAudioDevice->src_audio_locations_hdls_.val_hdl,
	leAudioDevice->src_audio_locations_hdls_.ccc_hdl);

	STREAM_TO_UINT16(leAudioDevice->audio_supp_cont_hdls_.val_hdl, ptr);
	STREAM_TO_UINT16(leAudioDevice->audio_supp_cont_hdls_.ccc_hdl, ptr);
	log::verbose(
	"audio_supp_cont_hdls_.val_hdl: 0x{:04x},audio_supp_cont_hdls_.ccc_hdl: "
	"0x{:04x}",
	leAudioDevice->audio_supp_cont_hdls_.val_hdl,
	leAudioDevice->audio_supp_cont_hdls_.ccc_hdl);

	STREAM_TO_UINT16(leAudioDevice->audio_avail_hdls_.val_hdl, ptr);
	STREAM_TO_UINT16(leAudioDevice->audio_avail_hdls_.ccc_hdl, ptr);
	log::verbose(
	"audio_avail_hdls_.val_hdl: 0x{:04x},audio_avail_hdls_.ccc_hdl: 0x{:04x}",
	leAudioDevice->audio_avail_hdls_.val_hdl,
	leAudioDevice->audio_avail_hdls_.ccc_hdl);

	STREAM_TO_UINT16(leAudioDevice->tmap_role_hdl_, ptr);
	log::verbose("tmap_role_hdl_: 0x{:04x}", leAudioDevice->tmap_role_hdl_);

	leAudioDevice->known_service_handles_ = true;
	return true;
	}
	} // namespace bluetooth::le_audio