6 files changed, 85 insertions(+), 67 deletions(-)

M module-services/service-antenna/ServiceAntenna.cpp
M module-services/service-antenna/api/AntennaServiceAPI.cpp
M module-services/service-antenna/include/service-antenna/AntennaMessage.hpp
M module-services/service-antenna/include/service-antenna/AntennaServiceAPI.hpp
M module-services/service-antenna/include/service-antenna/ServiceAntenna.hpp
M module-services/service-cellular/CellularUrcHandler.cpp

@@ 74,11 74,6 @@ ServiceAntenna::ServiceAntenna()
     bus.channels.push_back(sys::BusChannel::AntennaNotifications);
     bus.channels.push_back(sys::BusChannel::PhoneModeChanges);
 
-    connect(typeid(cellular::msg::notification::SimReady), [this](sys::Message *) {
-        state->set(antenna::State::init);
-        return sys::MessageNone{};
-    });
-
     phoneModeObserver->connect(this);
     phoneModeObserver->subscribe([this](sys::phone_modes::PhoneMode mode) {
         if (mode == sys::phone_modes::PhoneMode::Offline) {


@@ 100,32 95,6 @@ sys::MessagePointer ServiceAntenna::DataReceivedHandler(sys::DataMessage *msgl, 
 {
     bool handled = false;
 
-    if (auto msg = dynamic_cast<CellularMessage *>(msgl)) {
-        switch (msg->type) {
-        case CellularMessage::Type::Notification: {
-
-            if (auto notif = dynamic_cast<CellularNotificationMessage *>(msg)) {
-                if (notif->content == CellularNotificationMessage::Content::CallAborted) {
-                    AntennaServiceAPI::LockRequest(this, antenna::lockState::unlocked);
-                }
-            }
-            handled = true;
-            break;
-        }
-        case CellularMessage::Type::IncomingCall: {
-            AntennaServiceAPI::LockRequest(this, antenna::lockState::locked);
-        } break;
-        case CellularMessage::Type::Ringing: {
-            AntennaServiceAPI::LockRequest(this, antenna::lockState::locked);
-        } break;
-        case CellularMessage::Type::HangupCall: {
-            AntennaServiceAPI::LockRequest(this, antenna::lockState::unlocked);
-        } break;
-        default:
-            break;
-        }
-    }
-    else
         switch (msgl->messageType) {
         case MessageType::StateChange:
             HandleStateChange(state->get());


@@ 146,12 115,6 @@ sys::MessagePointer ServiceAntenna::DataReceivedHandler(sys::DataMessage *msgl, 
             handled = true;
             break;
         }
-        case MessageType::AntennaCSQChange:
-            LOG_DEBUG("CSQChange message");
-            if (state->get() == antenna::State::idle) {
-                state->set(antenna::State::csqChange);
-            }
-            break;
         case MessageType::AntennaLockService: {
             auto msg = dynamic_cast<AntennaLockRequestMessage *>(msgl);
             if (msg != nullptr) {


@@ 176,6 139,7 @@ sys::MessagePointer ServiceAntenna::DataReceivedHandler(sys::DataMessage *msgl, 
 // Invoked during initialization
 sys::ReturnCodes ServiceAntenna::InitHandler()
 {
+    registerMessageHandlers();
     return sys::ReturnCodes::Success;
 }
 


@@ 325,23 289,16 @@ bool ServiceAntenna::switchAntennaStateHandler(void)
 
 bool ServiceAntenna::signalCheckStateHandler(void)
 {
-    std::string csq;
-    uint32_t csqValue = 0;
-    if (CellularServiceAPI::GetCSQ(this, csq)) {
-        at::response::parseCSQ(csq, csqValue);
-        if (csqValue <= antenna::signalTreshold) {
-            LOG_INFO("Signal strength below the threshold (CSQ = %" PRIu32 ", Threshold = %" PRIu32 "). Switch antenna",
-                     csqValue,
-                     antenna::signalTreshold);
-            state->set(antenna::State::switchAntenna);
-            return true;
-        }
-        lastCsq = csqValue;
-        state->set(antenna::State::idle);
+    if (currentCsq <= antenna::signalTreshold) {
+        LOG_INFO("Signal strength below the threshold (CSQ = %" PRIu32 ", Threshold = %" PRIu32 "). Switch antenna",
+                 currentCsq,
+                 antenna::signalTreshold);
+        state->set(antenna::State::switchAntenna);
         return true;
     }
-
-    return false;
+    lastCsq = currentCsq;
+    state->set(antenna::State::idle);
+    return true;
 }
 bool ServiceAntenna::bandCheckStateHandler(void)
 {


@@ 373,12 330,6 @@ bool ServiceAntenna::bandCheckStateHandler(void)
         }
 
         LOG_INFO("Band match.");
-        std::string csq;
-        uint32_t csqValue = 0;
-        if (CellularServiceAPI::GetCSQ(this, csq)) {
-            at::response::parseCSQ(csq, csqValue);
-            lastCsq = csqValue;
-        }
         state->set(antenna::State::idle);
         return true;
     }


@@ 392,14 343,7 @@ bool ServiceAntenna::idleStateHandler(void)
 
 bool ServiceAntenna::csqChangeStateHandler(void)
 {
-    std::string csq;
-    uint32_t csqValue = 0;
-
     constexpr uint32_t notValidCsq = 99;
-    if (CellularServiceAPI::GetCSQ(this, csq)) {
-        at::response::parseCSQ(csq, csqValue);
-        currentCsq = csqValue;
-    }
 
     auto nextState = antenna::State::idle;
     if (lastCsq != currentCsq || currentCsq == notValidCsq) {


@@ 420,3 364,60 @@ bool ServiceAntenna::lockedStateHandler(void)
     state->disableTimeout();
     return true;
 }
+void ServiceAntenna::registerMessageHandlers()
+{
+    connect(typeid(antenna::message::InvalidCsqNotification), [&](sys::Message *request) -> sys::MessagePointer {
+        if (state->get() == antenna::State::idle) {
+            state->set(antenna::State::connectionStatus);
+        }
+        return sys::MessageNone{};
+    });
+
+    connect(typeid(cellular::msg::notification::SimReady), [this](sys::Message *) {
+        state->set(antenna::State::init);
+        return sys::MessageNone{};
+    });
+
+    connect(typeid(antenna::message::InvalidCsqNotification), [&](sys::Message *request) -> sys::MessagePointer {
+        if (state->get() == antenna::State::idle) {
+            state->set(antenna::State::connectionStatus);
+        }
+        return sys::MessageNone{};
+    });
+
+    connect(typeid(CellularSignalStrengthUpdateNotification), [&](sys::Message *request) -> sys::MessagePointer {
+        currentCsq = Store::GSM::get()->getSignalStrength().rssi;
+        if (state->get() == antenna::State::idle) {
+            state->set(antenna::State::csqChange);
+        }
+        return sys::MessageNone{};
+    });
+
+    connect(typeid(CellularIncominCallMessage), [&](sys::Message *request) -> sys::MessagePointer {
+        auto message =
+            std::make_shared<AntennaLockRequestMessage>(MessageType::AntennaLockService, antenna::lockState::locked);
+        bus.sendUnicast(std::move(message), service::name::antenna);
+        return sys::MessageNone{};
+    });
+
+    connect(typeid(CellularRingingMessage), [&](sys::Message *request) -> sys::MessagePointer {
+        auto message =
+            std::make_shared<AntennaLockRequestMessage>(MessageType::AntennaLockService, antenna::lockState::locked);
+        bus.sendUnicast(std::move(message), service::name::antenna);
+        return sys::MessageNone{};
+    });
+
+    connect(typeid(CellularHangupCallMessage), [&](sys::Message *request) -> sys::MessagePointer {
+        auto message =
+            std::make_shared<AntennaLockRequestMessage>(MessageType::AntennaLockService, antenna::lockState::unlocked);
+        bus.sendUnicast(std::move(message), service::name::antenna);
+        return sys::MessageNone{};
+    });
+
+    connect(typeid(CellularCallAbortedNotification), [&](sys::Message *request) -> sys::MessagePointer {
+        auto message =
+            std::make_shared<AntennaLockRequestMessage>(MessageType::AntennaLockService, antenna::lockState::unlocked);
+        bus.sendUnicast(std::move(message), service::name::antenna);
+        return sys::MessageNone{};
+    });
+}

@@ 41,4 41,9 @@ namespace AntennaServiceAPI
         }
         return false;
     }
+
+    void InvalidCSQNotification(sys::Service *serv)
+    {
+        serv->bus.sendUnicast(std::make_shared<antenna::message::InvalidCsqNotification>(), service::name::antenna);
+    }
 } // namespace AntennaServiceAPI

@@ 34,3 34,13 @@ class AntennaLockRequestResponse : public sys::ResponseMessage
     bool retCode;
     antenna::lockState data;
 };
+
+namespace antenna::message
+{
+    class InvalidCsqNotification : public sys::DataMessage
+    {
+      public:
+        InvalidCsqNotification() : sys::DataMessage(MessageType::MessageTypeUninitialized)
+        {}
+    };
+} // namespace antenna::message

@@ 12,7 12,7 @@ namespace sys
 
 namespace AntennaServiceAPI
 {
-    void CSQChange(sys::Service *serv);
+    void InvalidCSQNotification(sys::Service *serv);
     bool LockRequest(sys::Service *serv, antenna::lockState request);
     bool GetLockState(sys::Service *serv, antenna::lockState &state);
 } // namespace AntennaServiceAPI

@@ 60,6 60,8 @@ class ServiceAntenna : public sys::Service
     void handleLockRequest(antenna::lockState request);
     std::unique_ptr<sys::phone_modes::Observer> phoneModeObserver;
 
+    void registerMessageHandlers();
+
   protected:
     // flag informs about suspend/resume status
     bool suspended = false;

@@ 113,10 113,10 @@ void CellularUrcHandler::Handle(Qind &urc)
 {
     if (urc.isCsq()) {
         // Received signal strength change
-        AntennaServiceAPI::CSQChange(&cellularService);
         auto rssi = urc.getRSSI();
         if (!rssi) {
             LOG_INFO("Invalid csq - ignore");
+            AntennaServiceAPI::InvalidCSQNotification(&cellularService);
         }
         else {
             SignalStrength signalStrength(*rssi);