[EGD-3772] added HSP sink and source (#918)

Added HSP playback to the BT device and stream of the BT device microphone back to the OS

Co-authored-by: SP2FET <[email protected]>

Author: SP2FET

.gitmodules

@@ -59,3 +59,4 @@
 [submodule "module-utils/tinyexpr"]
 	path = module-utils/tinyexpr
 	url = https://github.com/codeplea/tinyexpr.git
+

changelog.md

@@ -9,6 +9,8 @@
 * `[messages][db]` File Indexer db Agent
 * `[testing]` Added key release simulation through service-desktop developerMode
 * `[cellular]` Set pin functionality with Action mockup
+* `[bluetooth]` Added HSP playback and recording
+
 ### Changed
 
 * `[cellular]` Handled properly SIM READY and SIM PIN URC messages with Action mockup

module-bluetooth/Bluetooth/BluetoothWorker.cpp

@@ -4,8 +4,8 @@
 #include "BluetoothWorker.hpp"
 #include "BtCommand.hpp"
 #include "log/log.hpp"
-#include "module-bluetooth/Bluetooth/interface/profiles/A2DP/A2DP.hpp"
-
+#include "interface/profiles/A2DP/A2DP.hpp"
+#include "interface/profiles/HSP/HSP.hpp"
 extern "C"
 {
 #include "module-bluetooth/lib/btstack/src/btstack_util.h"
@@ -28,7 +28,7 @@ const char *c_str(Bt::Error::Code code)
     return "";
 }
 
-BluetoothWorker::BluetoothWorker(sys::Service *service) : Worker(service), currentProfile(std::make_shared<Bt::A2DP>())
+BluetoothWorker::BluetoothWorker(sys::Service *service) : Worker(service), currentProfile(std::make_shared<Bt::HSP>())
 {
     init({
         {"qBtIO", sizeof(Bt::Message), 10},
@@ -86,18 +86,18 @@ bool BluetoothWorker::scan()
     }
 }
 
-void BluetoothWorker::stop_scan()
+void BluetoothWorker::stopScan()
 {
     Bt::GAP::stop_scan();
 }
 
-bool BluetoothWorker::set_visible()
+bool BluetoothWorker::toggleVisibility()
 {
     static bool visibility = true;
     Bt::GAP::set_visibility(visibility);
     visibility = !visibility;
 
-    return false;
+    return visibility;
 }
 
 bool BluetoothWorker::start_pan()
@@ -110,16 +110,6 @@ bool BluetoothWorker::start_pan()
     return false;
 }
 
-BluetoothWorker::Error BluetoothWorker::aud_init()
-{
-    LOG_INFO("%s", __PRETTY_FUNCTION__);
-    Error err = SuccessBt;
-    LOG_INFO("AUDIO - TODO");
-    // start GAVD
-    // &&  ASSIGN_CLASS_OF_DEVICE(ClassOfDevice, 0x28, 0x04, 0x10);
-    return err;
-}
-
 #include <sstream>
 
 bool BluetoothWorker::handleMessage(uint32_t queueID)
@@ -189,36 +179,22 @@ bool BluetoothWorker::handleMessage(uint32_t queueID)
     return true;
 }
 
-void BluetoothWorker::initAudioBT()
-{}
-
-bool BluetoothWorker::play_audio()
+bool BluetoothWorker::establishAudioConnection()
 {
-    auto profile = dynamic_cast<Bt::A2DP *>(currentProfile.get());
-    if (profile == nullptr) {
+    currentProfile->setOwnerService(service);
+    if (currentProfile->init() != Bt::Error::Success) {
         return false;
     }
-
-    profile->init();
-    profile->setOwnerService(service);
-    profile->start();
+    currentProfile->connect();
     return true;
 }
-bool BluetoothWorker::stop_audio()
+bool BluetoothWorker::disconnectAudioConnection()
 {
-    auto profile = dynamic_cast<Bt::A2DP *>(currentProfile.get());
-    if (profile == nullptr) {
-        return false;
-    }
-
-    profile->stop();
+    currentProfile->disconnect();
     return true;
 }
-void BluetoothWorker::set_addr(bd_addr_t addr)
+void BluetoothWorker::setDeviceAddress(bd_addr_t addr)
 {
     Bt::GAP::do_pairing(addr);
-    auto profile = dynamic_cast<Bt::A2DP *>(currentProfile.get());
-    if (profile != nullptr) {
-        profile->setDeviceAddress(addr);
-    }
+    currentProfile->setDeviceAddress(addr);
 }

module-bluetooth/Bluetooth/BluetoothWorker.hpp

@@ -92,19 +92,19 @@ class BluetoothWorker : private sys::Worker
 
     bool scan();
 
-    bool set_visible();
+    bool toggleVisibility();
 
     bool start_pan();
 
-    bool play_audio();
+    bool establishAudioConnection();
 
-    bool stop_audio();
+    bool disconnectAudioConnection();
 
     Error aud_init();
     /// bluetooth stack id in use
     unsigned long active_features;
-    void stop_scan();
-    void set_addr(bd_addr_t addr);
+    void stopScan();
+    void setDeviceAddress(bd_addr_t addr);
     void initAudioBT();
 
     std::shared_ptr<Bt::Profile> currentProfile;

module-bluetooth/Bluetooth/Device.hpp

@@ -53,4 +53,5 @@ constexpr unsigned int DATA_BUFFER_SIZE = 256 * 2;
 struct AudioData_t
 {
     std::array<int16_t, DATA_BUFFER_SIZE> data;
+    uint16_t bytesSent;
 };

module-bluetooth/Bluetooth/interface/profiles/A2DP/A2DP.cpp

@@ -12,11 +12,11 @@
 #include <Bluetooth/Device.hpp>
 #include <Bluetooth/Error.hpp>
 #include <log/log.hpp>
-#include <module-sys/Service/Bus.hpp>
+#include <Service/Bus.hpp>
 #include <service-bluetooth/messages/BluetoothMessage.hpp>
-#include <module-audio/Audio/AudioCommon.hpp>
-#include <module-services/service-audio/messages/AudioMessage.hpp>
-#include <module-services/service-evtmgr/Constants.hpp>
+#include <Audio/AudioCommon.hpp>
+#include <service-audio/messages/AudioMessage.hpp>
+#include <service-evtmgr/Constants.hpp>
 extern "C"
 {
 #include "module-bluetooth/lib/btstack/src/btstack.h"
@@ -55,32 +55,37 @@ namespace Bt
         return *this;
     }
 
-    auto A2DP::init() -> Error
+    auto A2DP::init() -> Error::Code
     {
         return pimpl->init();
     }
-    void A2DP::start()
-    {
-        pimpl->start();
-    }
-    void A2DP::stop()
-    {
-        pimpl->stop();
-    }
+
     void A2DP::setDeviceAddress(uint8_t *addr)
     {
         pimpl->setDeviceAddress(addr);
     }
-    void A2DP::setOwnerService(sys::Service *service)
+
+    void A2DP::setOwnerService(const sys::Service *service)
     {
         pimpl->setOwnerService(service);
     }
+
     auto A2DP::getStreamData() -> std::shared_ptr<BluetoothStreamData>
     {
         return pimpl->getStreamData();
     }
 
-    sys::Service *A2DP::A2DPImpl::ownerService;
+    void A2DP::connect()
+    {
+        pimpl->start();
+    }
+
+    void A2DP::disconnect()
+    {
+        pimpl->stop();
+    }
+
+    const sys::Service *A2DP::A2DPImpl::ownerService;
     QueueHandle_t A2DP::A2DPImpl::sourceQueue = nullptr;
     QueueHandle_t A2DP::A2DPImpl::sinkQueue   = nullptr;
     bd_addr_t A2DP::A2DPImpl::deviceAddr;
@@ -95,7 +100,7 @@ namespace Bt
 
     /* LISTING_START(MainConfiguration): Setup Audio Source and AVRCP Target services */
 
-    auto A2DP::A2DPImpl::init() -> Error
+    auto A2DP::A2DPImpl::init() -> Error::Code
     {
         // request role change on reconnecting headset to always use them in slave mode
         hci_set_master_slave_policy(0);
@@ -115,7 +120,7 @@ namespace Bt
                                                AVDTP::sbcCodecConfiguration.size());
         if (local_stream_endpoint == nullptr) {
             LOG_INFO("A2DP Source: not enough memory to create local stream endpoint\n");
-            return Error(Bt::Error::SystemError);
+            return Bt::Error::SystemError;
         }
         AVRCP::mediaTracker.local_seid = avdtp_local_seid(local_stream_endpoint);
         avdtp_source_register_delay_reporting_category(AVRCP::mediaTracker.local_seid);
@@ -160,7 +165,7 @@ namespace Bt
 
         LOG_INFO("Init done!");
 
-        return Error();
+        return Bt::Error::Success;
     }
 
     void A2DP::A2DPImpl::sendMediaPacket()
@@ -450,9 +455,7 @@ namespace Bt
             sourceQueue = xQueueCreate(5, sizeof(AudioData_t));
             sinkQueue   = nullptr;
             if (sourceQueue != nullptr) {
-                auto event = std::make_shared<audio::Event>(audio::EventType::BTA2DPOn);
-                auto msg   = std::make_shared<AudioEventRequest>(std::move(event));
-                sys::Bus::SendUnicast(std::move(msg), service::name::evt_manager, ownerService);
+                sendAudioEvent(audio::EventType::BTA2DPOn);
             }
             else {
                 LOG_ERROR("failed to create queue!");
@@ -534,11 +537,7 @@ namespace Bt
                 cid,
                 AVRCP::mediaTracker.local_seid,
                 local_seid);
-            {
-                auto event = std::make_shared<audio::Event>(audio::EventType::BTA2DPOff);
-                auto msg   = std::make_shared<AudioEventRequest>(std::move(event));
-                sys::Bus::SendUnicast(std::move(msg), service::name::evt_manager, ownerService);
-            }
+            sendAudioEvent(audio::EventType::BTA2DPOff);
             if (cid == AVRCP::mediaTracker.a2dp_cid) {
                 AVRCP::mediaTracker.stream_opened = 0;
                 LOG_INFO("A2DP Source: Stream released.\n");
@@ -581,13 +580,22 @@ namespace Bt
         bd_addr_copy(deviceAddr, addr);
         LOG_INFO("Address set!");
     }
-    void A2DP::A2DPImpl::setOwnerService(sys::Service *service)
+
+    void A2DP::A2DPImpl::setOwnerService(const sys::Service *service)
     {
         ownerService = service;
     }
+
     auto A2DP::A2DPImpl::getStreamData() -> std::shared_ptr<BluetoothStreamData>
     {
         return std::make_shared<BluetoothStreamData>(sinkQueue, sourceQueue, metadata);
     }
 
+    void A2DP::A2DPImpl::sendAudioEvent(audio::EventType event)
+    {
+        auto evt = std::make_shared<audio::Event>(event);
+        auto msg = std::make_shared<AudioEventRequest>(std::move(evt));
+        sys::Bus::SendUnicast(std::move(msg), service::name::evt_manager, const_cast<sys::Service *>(ownerService));
+    }
+
 } // namespace Bt

module-bluetooth/Bluetooth/interface/profiles/A2DP/A2DP.hpp

@@ -8,7 +8,7 @@
 #include "Service/Service.hpp"
 #include "queue.h"
 #include <memory>
-#include <module-services/service-bluetooth/ServiceBluetoothCommon.hpp>
+#include <service-bluetooth/ServiceBluetoothCommon.hpp>
 namespace Bt
 {
     class A2DP : public Profile
@@ -22,13 +22,13 @@ namespace Bt
         A2DP(A2DP &&other) noexcept;
         auto operator=(A2DP &&other) noexcept -> A2DP &;
 
-        auto init() -> Error override;
+        auto init() -> Error::Code override;
         void setDeviceAddress(uint8_t *addr) override;
-        void setOwnerService(sys::Service *service);
-        auto getStreamData() -> std::shared_ptr<BluetoothStreamData> override;
+        void setOwnerService(const sys::Service *service) override;
+        [[nodiscard]] auto getStreamData() -> std::shared_ptr<BluetoothStreamData> override;
 
-        void start();
-        void stop();
+        void connect() override;
+        void disconnect() override;
 
       private:
         class A2DPImpl;

module-bluetooth/Bluetooth/interface/profiles/A2DP/A2DPImpl.hpp

@@ -7,6 +7,8 @@
 #include <Bluetooth/Error.hpp>
 #include <BtCommand.hpp>
 #include <log/log.hpp>
+#include <Audio/AudioCommon.hpp>
+
 extern "C"
 {
 #include <btstack.h>
@@ -53,7 +55,7 @@ namespace Bt
         static bd_addr_t deviceAddr;
         static btstack_packet_callback_registration_t hciEventCallbackRegistration;
         static std::array<uint8_t, MEDIA_CAP_SIZE> mediaSbcCodecCapabilities;
-        static sys::Service *ownerService;
+        static const sys::Service *ownerService;
         static QueueHandle_t sourceQueue;
         static QueueHandle_t sinkQueue;
         static DeviceMetadata_t metadata;
@@ -65,13 +67,14 @@ namespace Bt
         static void hciPacketHandler(uint8_t packetType, uint16_t channel, uint8_t *packet, uint16_t size);
         static void sendMediaPacket();
         static auto fillSbcAudioBuffer(MediaContext *context) -> int;
+        static void sendAudioEvent(audio::EventType event);
 
       public:
-        auto init() -> Error;
+        auto init() -> Error::Code;
         void start();
         void stop();
         void setDeviceAddress(bd_addr_t addr);
-        void setOwnerService(sys::Service *service);
+        void setOwnerService(const sys::Service *service);
         auto getStreamData() -> std::shared_ptr<BluetoothStreamData>;
     };
 } // namespace Bt