16 files changed, 286 insertions(+), 85 deletions(-)

M module-bluetooth/Bluetooth/CommandHandler.cpp
M module-services/service-bluetooth/ServiceBluetooth.cpp
M module-services/service-bluetooth/service-bluetooth/ServiceBluetooth.hpp
M module-services/service-desktop/CMakeLists.txt
M module-services/service-desktop/DesktopMessages.cpp
M module-services/service-desktop/endpoints/EndpointFactory.hpp
A module-services/service-desktop/endpoints/bluetooth/BluetoothEndpoint.cpp
A module-services/service-desktop/endpoints/bluetooth/BluetoothEndpoint.hpp
A module-services/service-desktop/endpoints/bluetooth/BluetoothHelper.cpp
A module-services/service-desktop/endpoints/bluetooth/BluetoothHelper.hpp
M module-services/service-desktop/endpoints/developerMode/DeveloperModeHelper.cpp
M module-services/service-desktop/endpoints/developerMode/DeveloperModeHelper.hpp
M module-services/service-desktop/parser/ParserUtils.hpp
M module-services/service-desktop/service-desktop/DesktopMessages.hpp
M test/harness/interface/defs.py
M test/pytest/service-desktop/test_bluetooth.py

@@ 4,6 4,7 @@
 #include "CommandHandler.hpp"
 
 #include <utility>
+#include <service-bluetooth/ServiceBluetooth.hpp>
 
 #include "Device.hpp"
 #include "BtCommand.hpp"


@@ 60,6 61,7 @@ namespace bluetooth
         }
 
         LOG_INFO("Scan started!");
+        static_cast<ServiceBluetooth *>(service)->scanStartedCallback();
         // open new scan window
         return Error::Success;
     }


@@ 67,6 69,7 @@ namespace bluetooth
     Error::Code CommandHandler::stopScan()
     {
         driver->stopScan();
+        static_cast<ServiceBluetooth *>(service)->scanStoppedCallback();
         return Error::Success;
     }
 

@@ 68,10 68,15 @@ sys::ReturnCodes ServiceBluetooth::InitHandler()
 
         switch (newBtStatus.state) {
         case BluetoothStatus::State::On:
+            if (msg->sender == "ServiceDesktop") {
+                enabledFromHarness = true;
+                LOG_INFO("BT enabled from Harness");
+            }
             sendWorkerCommand(bluetooth::Command::PowerOn);
             break;
         case BluetoothStatus::State::Off:
             sendWorkerCommand(bluetooth::Command::PowerOff);
+            enabledFromHarness = false;
             break;
         default:
             break;


@@ 83,9 88,9 @@ sys::ReturnCodes ServiceBluetooth::InitHandler()
     connect(sdesktop::developerMode::DeveloperModeRequest(), [&](sys::Message *msg) {
         using namespace sdesktop::developerMode;
         auto req = static_cast<DeveloperModeRequest *>(msg);
-        if (typeid(*req->event) == typeid(BluetoothStatusRequestEvent)) {
+        if (typeid(*req->event) == typeid(sdesktop::bluetooth::BluetoothStatusRequestEvent)) {
             auto state   = std::visit(bluetooth::IntVisitor(), settingsHolder->getValue(bluetooth::Settings::State));
-            auto event   = std::make_unique<BluetoothStatusRequestEvent>(state);
+            auto event   = std::make_unique<sdesktop::bluetooth::BluetoothStatusRequestEvent>(state);
             auto message = std::make_shared<DeveloperModeRequest>(std::move(event));
             bus.sendUnicast(std::move(message), service::name::service_desktop);
         }


@@ 188,3 193,19 @@ void ServiceBluetooth::sendWorkerCommand(bluetooth::Command command)
 {
     xQueueSend(workerQueue, &command, portMAX_DELAY);
 }
+void ServiceBluetooth::scanStartedCallback()
+{
+    if (enabledFromHarness) {
+        auto event   = std::make_unique<sdesktop::bluetooth::ScanStartedEvent>();
+        auto message = std::make_shared<sdesktop::developerMode::DeveloperModeRequest>(std::move(event));
+        bus.sendUnicast(std::move(message), service::name::service_desktop);
+    }
+}
+void ServiceBluetooth::scanStoppedCallback()
+{
+    if (enabledFromHarness) {
+        auto event   = std::make_unique<sdesktop::bluetooth::ScanStoppedEvent>();
+        auto message = std::make_shared<sdesktop::developerMode::DeveloperModeRequest>(std::move(event));
+        bus.sendUnicast(std::move(message), service::name::service_desktop);
+    }
+}

@@ 35,9 35,12 @@ class ServiceBluetooth : public sys::Service
     void sendWorkerCommand(bluetooth::Command command);
     QueueHandle_t workerQueue = nullptr;
     std::shared_ptr<bluetooth::SettingsHolder> settingsHolder;
+    void scanStartedCallback();
+    void scanStoppedCallback();
 
   private:
     std::unique_ptr<BluetoothWorker> worker;
+    bool enabledFromHarness = false;
 };
 
 namespace sys

@@ 4,6 4,8 @@ message( "${PROJECT_NAME}  ${CMAKE_CURRENT_LIST_DIR}" )
 set(SOURCES
     endpoints/backup/BackupEndpoint.cpp
     endpoints/backup/BackupRestore.cpp
+    endpoints/bluetooth/BluetoothEndpoint.cpp
+    endpoints/bluetooth/BluetoothHelper.cpp
     endpoints/calllog/CalllogEndpoint.cpp
     endpoints/calllog/CalllogHelper.cpp
     endpoints/contacts/ContactHelper.cpp

@@ 1,50 1,67 @@
-// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "service-desktop/DesktopMessages.hpp"
 #include "parser/MessageHandler.hpp"
 
-namespace sdesktop::developerMode
+namespace sdesktop
 {
     using namespace parserFSM;
     void Event::send()
     {
         MessageHandler::putToSendQueue(context.createSimpleResponse());
     }
-
-    ATResponseEvent::ATResponseEvent(std::vector<std::string> resp)
+    namespace developerMode
     {
-        context.setResponseStatus(http::Code::OK);
-        context.setEndpoint(EndpointType::developerMode);
-        context.setResponseBody(json11::Json::object{{json::developerMode::ATResponse, resp}});
-    }
 
-    AppFocusChangeEvent::AppFocusChangeEvent(std::string appName)
-    {
-        context.setResponseStatus(http::Code::OK);
-        context.setEndpoint(EndpointType::developerMode);
-        context.setResponseBody(json11::Json::object{{json::developerMode::focus, appName}});
-    }
+        ATResponseEvent::ATResponseEvent(std::vector<std::string> resp)
+        {
+            context.setResponseStatus(http::Code::OK);
+            context.setEndpoint(EndpointType::developerMode);
+            context.setResponseBody(json11::Json::object{{json::developerMode::ATResponse, resp}});
+        }
 
-    ScreenlockCheckEvent::ScreenlockCheckEvent(bool isLocked)
-    {
-        context.setResponseStatus(http::Code::OK);
-        context.setEndpoint(EndpointType::developerMode);
-        context.setResponseBody(json11::Json::object{{json::developerMode::isLocked, isLocked}});
-    }
+        AppFocusChangeEvent::AppFocusChangeEvent(std::string appName)
+        {
+            context.setResponseStatus(http::Code::OK);
+            context.setEndpoint(EndpointType::developerMode);
+            context.setResponseBody(json11::Json::object{{json::developerMode::focus, appName}});
+        }
 
-    DeveloperModeRequest::DeveloperModeRequest(std::unique_ptr<Event> event)
-        : sys::DataMessage(MessageType::DeveloperModeRequest), event(std::move(event))
-    {}
+        ScreenlockCheckEvent::ScreenlockCheckEvent(bool isLocked)
+        {
+            context.setResponseStatus(http::Code::OK);
+            context.setEndpoint(EndpointType::developerMode);
+            context.setResponseBody(json11::Json::object{{json::developerMode::isLocked, isLocked}});
+        }
 
-    DeveloperModeRequest::DeveloperModeRequest() : sys::DataMessage(MessageType::DeveloperModeRequest)
-    {}
+        DeveloperModeRequest::DeveloperModeRequest(std::unique_ptr<Event> event)
+            : sys::DataMessage(MessageType::DeveloperModeRequest), event(std::move(event))
+        {}
 
-    BluetoothStatusRequestEvent::BluetoothStatusRequestEvent(int state)
+        DeveloperModeRequest::DeveloperModeRequest() : sys::DataMessage(MessageType::DeveloperModeRequest)
+        {}
+    } // namespace developerMode
+    namespace bluetooth
     {
-        context.setResponseStatus(http::Code::OK);
-        context.setEndpoint(EndpointType::developerMode);
-        context.setResponseBody(json11::Json::object{{json::developerMode::btState, state}});
-    }
 
-} // namespace sdesktop::developerMode
+        BluetoothStatusRequestEvent::BluetoothStatusRequestEvent(int state)
+        {
+            context.setResponseStatus(http::Code::OK);
+            context.setEndpoint(EndpointType::bluetooth);
+            context.setResponseBody(json11::Json::object{{json::bluetooth::state, state}});
+        }
+        ScanStartedEvent::ScanStartedEvent()
+        {
+            context.setResponseStatus(http::Code::OK);
+            context.setEndpoint(EndpointType::bluetooth);
+            context.setResponseBody(json11::Json::object{{json::bluetooth::scan, json::bluetooth::btOn}});
+        }
+        ScanStoppedEvent::ScanStoppedEvent()
+        {
+            context.setResponseStatus(http::Code::OK);
+            context.setEndpoint(EndpointType::bluetooth);
+            context.setResponseBody(json11::Json::object{{json::bluetooth::scan, json::bluetooth::btOff}});
+        }
+    } // namespace bluetooth
+} // namespace sdesktop

@@ 1,4 1,4 @@
-// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #pragma once


@@ 18,6 18,7 @@
 #include "messages/MessagesEndpoint.hpp"
 #include "restore/RestoreEndpoint.hpp"
 #include "update/UpdateEndpoint.hpp"
+#include <endpoints/bluetooth/BluetoothEndpoint.hpp>
 
 class EndpointFactory
 {


@@ 49,6 50,8 @@ class EndpointFactory
             return std::make_unique<DeveloperModeEndpoint>(ownerServicePtr);
         case parserFSM::EndpointType::calendarEvents:
             return std::make_unique<CalendarEventsEndpoint>(ownerServicePtr);
+        case parserFSM::EndpointType::bluetooth:
+            return std::make_unique<BluetoothEndpoint>(ownerServicePtr);
         default:
             return nullptr;
         }

@@ 0,0 1,23 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+#include "BluetoothHelper.hpp"
+#include "BluetoothEndpoint.hpp"
+#include <endpoints/Context.hpp>
+
+using namespace parserFSM;
+
+auto BluetoothEndpoint::handle(Context &context) -> void
+{
+    switch (context.getMethod()) {
+    case http::Method::get:
+        helper->processGetRequest(context);
+        break;
+    case http::Method::post:
+        break;
+    case http::Method::put:
+        helper->processPutRequest(context);
+        break;
+    case http::Method::del:
+        break;
+    }
+}

@@ 0,0 1,35 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <endpoints/Endpoint.hpp>
+#include <parser/ParserUtils.hpp>
+#include "BluetoothHelper.hpp"
+#include <Service/Service.hpp>
+
+#include <memory>
+#include <string>
+
+namespace parserFSM
+{
+    class Context;
+} // namespace parserFSM
+namespace sys
+{
+    class Service;
+} // namespace sys
+
+class BluetoothEndpoint : public parserFSM::Endpoint
+{
+  private:
+    std::unique_ptr<parserFSM::BluetoothHelper> helper;
+
+  public:
+    BluetoothEndpoint(sys::Service *_ownerServicePtr) : Endpoint(_ownerServicePtr)
+    {
+        debugName = "BluetoothEndpoint";
+        helper    = std::make_unique<parserFSM::BluetoothHelper>(ownerServicePtr);
+    }
+    auto handle(parserFSM::Context &context) -> void override;
+};

@@ 0,0 1,53 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "BluetoothHelper.hpp"
+#include <service-desktop/DesktopMessages.hpp>
+#include <service-bluetooth/BluetoothMessage.hpp>
+#include <parser/MessageHandler.hpp>
+#include <service-bluetooth/messages/SetStatus.hpp>
+
+auto parserFSM::BluetoothHelper::processPutRequest(parserFSM::Context &context) -> sys::ReturnCodes
+{
+    auto body = context.getBody();
+    if (auto command = body[json::bluetooth::command].string_value(); !command.empty()) {
+        BluetoothMessage::Request btRequest{};
+
+        if (command == json::bluetooth::scanOn) {
+            btRequest = BluetoothMessage::Request::Scan;
+        }
+        else if (command == json::bluetooth::scanOff) {
+            btRequest = BluetoothMessage::Request::StopScan;
+        }
+        ownerServicePtr->bus.sendUnicast(std::make_shared<BluetoothMessage>(btRequest), "ServiceBluetooth");
+    }
+    else if (auto state = body[json::bluetooth::state].string_value(); !state.empty()) {
+        BluetoothStatus status{};
+        if (state == json::bluetooth::btOn) {
+            status.state = BluetoothStatus::State::On;
+            LOG_INFO("turning on BT from harness!");
+        }
+        else if (state == json::bluetooth::btOff) {
+            status.state = BluetoothStatus::State::Off;
+            LOG_INFO("turning off BT from harness!");
+        }
+        ::message::bluetooth::SetStatus setStatus(status);
+
+        ownerServicePtr->bus.sendUnicast(std::make_shared<::message::bluetooth::SetStatus>(std::move(setStatus)),
+                                         "ServiceBluetooth");
+        MessageHandler::putToSendQueue(context.createSimpleResponse());
+    }
+
+    return sys::ReturnCodes::Unresolved;
+}
+auto parserFSM::BluetoothHelper::processGetRequest(parserFSM::Context &context) -> sys::ReturnCodes
+{
+    auto body = context.getBody();
+    if (body[json::bluetooth::state].bool_value()) {
+
+        auto event = std::make_unique<sdesktop::bluetooth::BluetoothStatusRequestEvent>();
+        auto msg   = std::make_shared<sdesktop::developerMode::DeveloperModeRequest>(std::move(event));
+        ownerServicePtr->bus.sendUnicast(std::move(msg), "ServiceBluetooth");
+    }
+    return sys::ReturnCodes::Unresolved;
+}

@@ 0,0 1,39 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+#pragma once
+
+#include <endpoints/Context.hpp>
+
+#include <Common/Query.hpp>
+#include <Service/Common.hpp>
+#include <Service/Service.hpp>
+
+namespace sys
+{
+    class Service;
+} // namespace sys
+
+namespace parserFSM
+{
+
+    class BluetoothHelper
+    {
+        sys::Service *ownerServicePtr = nullptr;
+
+      public:
+        BluetoothHelper(sys::Service *_ownerServicePtr) : ownerServicePtr(_ownerServicePtr){};
+        auto processPutRequest(Context &context) -> sys::ReturnCodes;
+        auto processGetRequest(Context &context) -> sys::ReturnCodes;
+    };
+
+    namespace json::bluetooth
+    {
+        inline constexpr auto state   = "state";
+        inline constexpr auto btOn    = "on";
+        inline constexpr auto btOff   = "off";
+        inline constexpr auto scanOn  = "scanOn";
+        inline constexpr auto scanOff = "scanOff";
+        inline constexpr auto scan    = "scan";
+        inline constexpr auto command = "command";
+    } // namespace json::bluetooth
+} // namespace parserFSM

@@ 51,27 51,6 @@ auto DeveloperModeHelper::processPutRequest(Context &context) -> sys::ReturnCode
         auto msg   = std::make_shared<sdesktop::developerMode::DeveloperModeRequest>(std::move(event));
         ownerServicePtr->bus.sendUnicast(std::move(msg), "ApplicationDesktop");
     }
-    else if (body[json::developerMode::btState].bool_value()) {
-
-        auto event = std::make_unique<sdesktop::developerMode::BluetoothStatusRequestEvent>();
-        auto msg   = std::make_shared<sdesktop::developerMode::DeveloperModeRequest>(std::move(event));
-        ownerServicePtr->bus.sendUnicast(std::move(msg), "ServiceBluetooth");
-    }
-    else if (auto state = body[json::developerMode::btCommand].string_value(); !state.empty()) {
-        BluetoothMessage::Request request;
-        if (state == json::developerMode::btOn) {
-            request = BluetoothMessage::Request::Start;
-            LOG_INFO("turning on BT from harness!");
-        }
-        else {
-            request = BluetoothMessage::Request::StopPlayback;
-            LOG_INFO("turning off BT from harness!");
-        }
-        std::shared_ptr<BluetoothMessage> msg = std::make_shared<BluetoothMessage>(request);
-        ownerServicePtr->bus.sendUnicast(std::move(msg), "ServiceBluetooth");
-
-        MessageHandler::putToSendQueue(context.createSimpleResponse());
-    }
     else if (body[json::developerMode::changeSim].is_number()) {
         int simSelected = body[json::developerMode::changeSim].int_value();
         requestSimChange(simSelected);

@@ 45,9 45,6 @@ namespace parserFSM
         inline constexpr auto AT            = "AT";
         inline constexpr auto focus         = "focus";
         inline constexpr auto isLocked      = "isLocked";
-        inline constexpr auto btState       = "btState";
-        inline constexpr auto btOn          = "on";
-        inline constexpr auto btCommand     = "btCommand";
         inline constexpr auto changeSim     = "changeSim";
         inline constexpr auto smsCommand    = "smsCommand";
         inline constexpr auto getInfo       = "getInfo";

@@ 26,10 26,11 @@ namespace parserFSM
         messages,
         calllog,
         calendarEvents,
-        developerMode
+        developerMode,
+        bluetooth
     };
 
-    inline constexpr auto lastEndpoint = static_cast<int>(EndpointType::developerMode);
+    inline constexpr auto lastEndpoint = static_cast<int>(EndpointType::bluetooth);
     // Message defs and utils
     namespace message
     {

@@ 1,10 1,11 @@
-// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #pragma once
 
 #include <endpoints/update/UpdateMuditaOS.hpp>
 #include <endpoints/developerMode/DeveloperModeEndpoint.hpp>
+#include <endpoints/bluetooth/BluetoothEndpoint.hpp>
 
 #include <Service/Message.hpp>
 #include <MessageType.hpp>


@@ 65,18 66,20 @@ namespace sdesktop
         ~FactoryMessage() override = default;
     };
 
+    class Event
+    {
+      protected:
+        parserFSM::Context context;
+
+      public:
+        void send();
+        virtual ~Event() = default;
+    };
+
     namespace developerMode
     {
 
-        class Event
-        {
-          protected:
-            parserFSM::Context context;
 
-          public:
-            void send();
-            virtual ~Event() = default;
-        };
 
         class ATResponseEvent : public Event
         {


@@ 98,12 101,6 @@ namespace sdesktop
             explicit ScreenlockCheckEvent(bool isLocked);
         };
 
-        class BluetoothStatusRequestEvent : public Event
-        {
-          public:
-            BluetoothStatusRequestEvent() = default;
-            explicit BluetoothStatusRequestEvent(int state);
-        };
 
         class DeveloperModeRequest : public sys::DataMessage
         {


@@ 115,4 112,24 @@ namespace sdesktop
         };
     } // namespace developerMode
 
+    namespace bluetooth
+    {
+        class BluetoothStatusRequestEvent : public Event
+        {
+          public:
+            BluetoothStatusRequestEvent() = default;
+            explicit BluetoothStatusRequestEvent(int state);
+        };
+        class ScanStartedEvent : public Event
+        {
+          public:
+            ScanStartedEvent();
+        };
+        class ScanStoppedEvent : public Event
+        {
+          public:
+            ScanStoppedEvent();
+        };
+
+    } // namespace bluetooth
 } // namespace sdesktop

@@ 1,4 1,4 @@
-# Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+# Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
 # For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 from enum import Enum
 


@@ 13,7 13,8 @@ endpoint = {
     "messages": 8,
     "calllog": 9,
     "events": 10,
-    "developerMode": 11
+    "developerMode": 11,
+    "bluetooth":12
 }
 
 method = {

@@ 11,23 11,30 @@ import time
 @pytest.mark.service_desktop_test
 def test_bluetooth(harness):
 
-    body = {"btState": True}
-    ret = harness.endpoint_request("developerMode", "put", body)
+    body = {"state": True}
+    ret = harness.endpoint_request("bluetooth", "get", body)
     print(ret)
     assert ret["status"] == status["OK"]
-    if ret["body"]["btState"] == 0:
+    if ret["body"]["state"] == 0:
 
         log.info("BT turned off, turning on...")
-        body = {"btCommand": "on"}
-        ret = harness.endpoint_request("developerMode", "put", body)
+        body = {"state": "on"}
+        ret = harness.endpoint_request("bluetooth", "put", body)
 
         time.sleep(5)
-        body = {"btState": True}
-        ret = harness.endpoint_request("developerMode", "put", body)
+        body = {"state": True}
+        ret = harness.endpoint_request("bluetooth", "get", body)
 
         assert ret["status"] == status["OK"]
 
-    assert ret["body"]["btState"] == 1
+    assert ret["body"]["state"] == 1
 
+    body = {"command": "scanOn"}
+    ret = harness.endpoint_request("bluetooth", "put", body)
+    assert ret["body"]["scan"] == "on"
 
+    time.sleep(1)
+    body = {"command": "scanOff"}
+    ret = harness.endpoint_request("bluetooth", "put", body)
+    assert ret["body"]["scan"] == "off"