12 files changed, 149 insertions(+), 73 deletions(-)

M module-apps/application-settings/windows/network/SimCardsWindow.cpp
M module-cellular/at/response.cpp
M module-cellular/at/response.hpp
M module-services/service-cellular/CellularServiceAPI.cpp
M module-services/service-cellular/ServiceCellular.cpp
M module-services/service-cellular/service-cellular/ServiceCellular.hpp
M module-services/service-cellular/src/ServiceCellularPriv.cpp
M module-services/service-cellular/src/volte/VolteAllowedList.cpp
M module-services/service-cellular/src/volte/VolteAllowedListInterface.hpp
M module-utils/EventStore/EventStore.cpp
M module-utils/EventStore/EventStore.hpp
M pure_changelog.md

@@ 1,4 1,4 @@
-// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2023, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "SimCardsWindow.hpp"


@@ 118,6 118,8 @@ namespace gui
                                                                    const std::string &phoneNumber)
     {
         std::list<gui::Option> optList;
+
+        const auto &simText = (phoneNumber.empty() ? simStr : (simStr + " / " + phoneNumber));
         optList.emplace_back(std::make_unique<gui::option::OptionSettings>(
             utils::translate("app_settings_network_active_card"),
             [=](gui::Item &item) { return createSwitchSimAction(sim); },


@@ 125,7 127,7 @@ namespace gui
             this,
             gui::option::SettingRightItem::Text,
             false,
-            simStr + " / " + phoneNumber,
+            simText,
             true));
 
         optList.emplace_back(std::make_unique<gui::option::OptionSettings>(

@@ 1,4 1,4 @@
-// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2023, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "response.hpp"


@@ 209,7 209,7 @@ namespace at
             }
             return false;
         }
-        bool parseCSQ(std::string cellularResponse, uint32_t &result)
+        bool parseCSQ(std::string cellularResponse, std::uint32_t &result)
         {
             std::string CSQstring;
             if (parseCSQ(cellularResponse, CSQstring)) {


@@ 228,12 228,12 @@ namespace at
         }
         namespace creg
         {
-            bool isRegistered(uint32_t commandData)
+            bool isRegistered(std::uint32_t commandData)
             {
 
                 // Creg command returns 1 when registered in home network, 5 when registered in roaming
-                constexpr uint32_t registeredHome    = 1;
-                constexpr uint32_t registeredRoaming = 5;
+                constexpr std::uint32_t registeredHome    = 1;
+                constexpr std::uint32_t registeredRoaming = 5;
 
                 if (commandData == registeredHome || commandData == registeredRoaming) {
                     return true;


@@ 241,7 241,7 @@ namespace at
                 return false;
             }
         } // namespace creg
-        bool parseCREG(std::string &response, uint32_t &result)
+        bool parseCREG(std::string &response, std::uint32_t &result)
         {
             auto resp = response;
             auto pos  = resp.find(',');


@@ 258,15 258,15 @@ namespace at
         }
         bool parseCREG(std::string &response, std::string &result)
         {
-            std::map<uint32_t, std::string> cregCodes;
-            cregCodes.insert(std::pair<uint32_t, std::string>(0, "Not registered"));
-            cregCodes.insert(std::pair<uint32_t, std::string>(1, "Registered, home network"));
-            cregCodes.insert(std::pair<uint32_t, std::string>(2, "Not registered, searching"));
-            cregCodes.insert(std::pair<uint32_t, std::string>(3, "Registration denied"));
-            cregCodes.insert(std::pair<uint32_t, std::string>(4, "Unknown"));
-            cregCodes.insert(std::pair<uint32_t, std::string>(5, "Registered, roaming"));
-
-            uint32_t cregValue = 0;
+            std::map<std::uint32_t, std::string> cregCodes;
+            cregCodes.insert(std::pair<std::uint32_t, std::string>(0, "Not registered"));
+            cregCodes.insert(std::pair<std::uint32_t, std::string>(1, "Registered, home network"));
+            cregCodes.insert(std::pair<std::uint32_t, std::string>(2, "Not registered, searching"));
+            cregCodes.insert(std::pair<std::uint32_t, std::string>(3, "Registration denied"));
+            cregCodes.insert(std::pair<std::uint32_t, std::string>(4, "Unknown"));
+            cregCodes.insert(std::pair<std::uint32_t, std::string>(5, "Registered, roaming"));
+
+            std::uint32_t cregValue = 0;
             if (parseCREG(response, cregValue)) {
                 auto cregCode = cregCodes.find(cregValue);
                 if (cregCode != cregCodes.end()) {


@@ 293,11 293,22 @@ namespace at
 
         namespace qnwinfo
         {
-            uint32_t parseNetworkFrequency(std::string &response)
+            auto constexpr qnwinfoResponseSize = 4;
+
+            std::string parseOperatorCode(const std::string &response)
             {
-                auto tokens = utils::split(response, ",");
+                auto const tokens               = utils::split(response, ",");
+                auto constexpr operatorTokenPos = 1;
+
+                if (tokens.size() != qnwinfoResponseSize) {
+                    return "";
+                }
+                return tokens[operatorTokenPos];
+            }
 
-                auto constexpr qnwinfoResponseSize = 4;
+            std::uint32_t parseNetworkFrequency(std::string &response)
+            {
+                auto tokens                        = utils::split(response, ",");
                 auto constexpr bandTokenPos        = 2;
                 if (tokens.size() == qnwinfoResponseSize) {
 


@@ 313,7 324,7 @@ namespace at
                 }
                 return 0;
             }
-            uint32_t parseNumericBandString(std::string &string)
+            std::uint32_t parseNumericBandString(std::string &string)
             {
                 utils::findAndReplaceAll(string, gsmString, "");
                 utils::findAndReplaceAll(string, wcdmaString, "");


@@ 324,27 335,27 @@ namespace at
                 utils::toNumeric(string, freq);
                 return freq;
             }
-            uint32_t parseLteBandString(std::string &string)
+            std::uint32_t parseLteBandString(std::string &string)
             {
 
-                std::map<uint32_t, uint32_t> lteFreqs;
-                lteFreqs.insert(std::pair<uint32_t, uint32_t>(band_1, band_1_freq));
-                lteFreqs.insert(std::pair<uint32_t, uint32_t>(band_2, band_2_freq));
-                lteFreqs.insert(std::pair<uint32_t, uint32_t>(band_3, band_3_freq));
-                lteFreqs.insert(std::pair<uint32_t, uint32_t>(band_4, band_4_freq));
-                lteFreqs.insert(std::pair<uint32_t, uint32_t>(band_5, band_5_freq));
-                lteFreqs.insert(std::pair<uint32_t, uint32_t>(band_7, band_7_freq));
-                lteFreqs.insert(std::pair<uint32_t, uint32_t>(band_8, band_8_freq));
-                lteFreqs.insert(std::pair<uint32_t, uint32_t>(band_12, band_12_freq));
-                lteFreqs.insert(std::pair<uint32_t, uint32_t>(band_13, band_13_freq));
-                lteFreqs.insert(std::pair<uint32_t, uint32_t>(band_18, band_18_freq));
-                lteFreqs.insert(std::pair<uint32_t, uint32_t>(band_20, band_20_freq));
-                lteFreqs.insert(std::pair<uint32_t, uint32_t>(band_25, band_25_freq));
-                lteFreqs.insert(std::pair<uint32_t, uint32_t>(band_26, band_26_freq));
-                lteFreqs.insert(std::pair<uint32_t, uint32_t>(band_28, band_28_freq));
-                lteFreqs.insert(std::pair<uint32_t, uint32_t>(band_38, band_38_freq));
-                lteFreqs.insert(std::pair<uint32_t, uint32_t>(band_40, band_40_freq));
-                lteFreqs.insert(std::pair<uint32_t, uint32_t>(band_41, band_41_freq));
+                std::map<std::uint32_t, std::uint32_t> lteFreqs;
+                lteFreqs.insert(std::pair<std::uint32_t, std::uint32_t>(band_1, band_1_freq));
+                lteFreqs.insert(std::pair<std::uint32_t, std::uint32_t>(band_2, band_2_freq));
+                lteFreqs.insert(std::pair<std::uint32_t, std::uint32_t>(band_3, band_3_freq));
+                lteFreqs.insert(std::pair<std::uint32_t, std::uint32_t>(band_4, band_4_freq));
+                lteFreqs.insert(std::pair<std::uint32_t, std::uint32_t>(band_5, band_5_freq));
+                lteFreqs.insert(std::pair<std::uint32_t, std::uint32_t>(band_7, band_7_freq));
+                lteFreqs.insert(std::pair<std::uint32_t, std::uint32_t>(band_8, band_8_freq));
+                lteFreqs.insert(std::pair<std::uint32_t, std::uint32_t>(band_12, band_12_freq));
+                lteFreqs.insert(std::pair<std::uint32_t, std::uint32_t>(band_13, band_13_freq));
+                lteFreqs.insert(std::pair<std::uint32_t, std::uint32_t>(band_18, band_18_freq));
+                lteFreqs.insert(std::pair<std::uint32_t, std::uint32_t>(band_20, band_20_freq));
+                lteFreqs.insert(std::pair<std::uint32_t, std::uint32_t>(band_25, band_25_freq));
+                lteFreqs.insert(std::pair<std::uint32_t, std::uint32_t>(band_26, band_26_freq));
+                lteFreqs.insert(std::pair<std::uint32_t, std::uint32_t>(band_28, band_28_freq));
+                lteFreqs.insert(std::pair<std::uint32_t, std::uint32_t>(band_38, band_38_freq));
+                lteFreqs.insert(std::pair<std::uint32_t, std::uint32_t>(band_40, band_40_freq));
+                lteFreqs.insert(std::pair<std::uint32_t, std::uint32_t>(band_41, band_41_freq));
 
                 auto constexpr toRemove    = "LTE BAND ";
                 auto constexpr emptyString = "";

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


@@ 181,8 181,8 @@ namespace at
         std::optional<ResponseTokens> getTokensForATResults(const at::Result &resp, std::string_view head);
 
         bool parseCSQ(std::string response, std::string &result);
-        bool parseCSQ(std::string cellularResponse, uint32_t &result);
-        bool parseCREG(std::string &response, uint32_t &result);
+        bool parseCSQ(std::string cellularResponse, std::uint32_t &result);
+        bool parseCREG(std::string &response, std::uint32_t &result);
         bool parseCREG(std::string &response, std::string &result);
         bool parseQNWINFO(std::string &response, std::string &result);
         bool parseQPINC(const at::Result &resp, qpinc::AttemptsCounters &ret);


@@ 208,7 208,7 @@ namespace at
         bool parseQCFG_IMS(const at::Result &resp, std::pair<qcfg_ims::IMSState, qcfg_ims::VoLTEIMSState> &ret);
         namespace creg
         {
-            bool isRegistered(uint32_t commandData);
+            bool isRegistered(std::uint32_t commandData);
         }
         namespace qnwinfo
         {


@@ 255,14 255,15 @@ namespace at
             auto constexpr band_40_freq = 2300;
             auto constexpr band_41_freq = 2500;
 
-            uint32_t parseNetworkFrequency(std::string &response);
-            uint32_t parseNumericBandString(std::string &string);
-            uint32_t parseLteBandString(std::string &string);
+            std::string parseOperatorCode(const std::string &response);
+            std::uint32_t parseNetworkFrequency(std::string &response);
+            std::uint32_t parseNumericBandString(std::string &string);
+            std::uint32_t parseLteBandString(std::string &string);
         } // namespace qnwinfo
 
         namespace clir
         {
-            constexpr uint32_t clirTokens = 2;
+            constexpr std::uint32_t clirTokens = 2;
 
             enum class ServiceState
             {

@@ 197,6 197,7 @@ bool CellularServiceAPI::GetCSQ(sys::Service *serv, std::string &response)
     }
     return false;
 }
+
 bool CellularServiceAPI::GetCREG(sys::Service *serv, std::string &response)
 {
     auto msg = std::make_shared<cellular::GetCregMessage>();


@@ 210,6 211,7 @@ bool CellularServiceAPI::GetCREG(sys::Service *serv, std::string &response)
     }
     return false;
 }
+
 bool CellularServiceAPI::GetQNWINFO(sys::Service *serv, std::string &response)
 {
     auto msg = std::make_shared<cellular::GetNwinfoMessage>();

@@ 1166,6 1166,23 @@ bool ServiceCellular::getIMSI(std::string &destination, bool fullNumber)
     return false;
 }
 
+bool ServiceCellular::getQNWINFO(std::string &destination)
+{
+    const auto channel = cmux->get(CellularMux::Channel::Commands);
+    if (channel == nullptr) {
+        LOG_ERROR("No cmux channel provided");
+        return false;
+    }
+
+    auto result = channel->cmd(at::AT::QNWINFO);
+    if (result.code != at::Result::Code::OK) {
+        LOG_ERROR("Failed to get QNWINFO");
+        return false;
+    }
+
+    return at::response::parseQNWINFO(result.response[0], destination);
+}
+
 std::vector<std::string> ServiceCellular::getNetworkInfo()
 {
     std::vector<std::string> data;


@@ 1736,7 1753,6 @@ void ServiceCellular::apnListChanged(const std::string &value)
 auto ServiceCellular::handleCellularAnswerIncomingCallMessage([[maybe_unused]] CellularMessage *msg)
     -> std::shared_ptr<cellular::ResponseMessage>
 {
-    LOG_INFO("%s", __PRETTY_FUNCTION__);
     auto ret = ongoingCall->handle(call::event::Answer{});
     return std::make_shared<cellular::ResponseMessage>(ret);
 }


@@ 1772,7 1788,6 @@ namespace
 auto ServiceCellular::handleCellularCallRequestMessage(cellular::CallRequestMessage *msg)
     -> std::shared_ptr<cellular::ResponseMessage>
 {
-    LOG_INFO("%s", __PRETTY_FUNCTION__);
     auto channel = cmux->get(CellularMux::Channel::Commands);
     if (channel == nullptr) {
         LOG_WARN("commands channel not ready");


@@ 1808,7 1823,6 @@ auto ServiceCellular::handleCellularCallRequestMessage(cellular::CallRequestMess
 
 void ServiceCellular::handleCellularHangupCallMessage([[maybe_unused]] cellular::HangupCallMessage *msg)
 {
-    LOG_INFO("%s", __PRETTY_FUNCTION__);
     if (!ongoingCall->handle(call::event::Reject{})) {
         LOG_ERROR("Failed to end ongoing call");
     }


@@ 1874,7 1888,6 @@ auto ServiceCellular::handleDBNotificationMessage(db::NotificationMessage *msg) 
 auto ServiceCellular::handleCellularRingingMessage(cellular::RingingMessage *msg)
     -> std::shared_ptr<sys::ResponseMessage>
 {
-    LOG_INFO("%s", __PRETTY_FUNCTION__);
     return std::make_shared<cellular::ResponseMessage>(
         ongoingCall->handle(call::event::StartCall{CallType::CT_OUTGOING, msg->number}));
 }


@@ 2079,6 2092,7 @@ auto ServiceCellular::handlePowerUpProcedureCompleteNotification([[maybe_unused]
     }
     return std::make_shared<cellular::ResponseMessage>(true);
 }
+
 auto ServiceCellular::handlePowerDownDeregisteringNotification([[maybe_unused]] sys::Message *msg)
     -> std::shared_ptr<sys::ResponseMessage>
 {


@@ 2088,12 2102,14 @@ auto ServiceCellular::handlePowerDownDeregisteringNotification([[maybe_unused]] 
     }
     return std::make_shared<cellular::ResponseMessage>(false);
 }
+
 auto ServiceCellular::handlePowerDownDeregisteredNotification([[maybe_unused]] sys::Message *msg)
     -> std::shared_ptr<sys::ResponseMessage>
 {
     priv->state->set(State::ST::PowerDownWaiting);
     return std::make_shared<cellular::ResponseMessage>(true);
 }
+
 auto ServiceCellular::handleNewIncomingSMSNotification(sys::Message *msg) -> std::shared_ptr<sys::ResponseMessage>
 {
     auto message      = static_cast<cellular::NewIncomingSMSNotification *>(msg);


@@ 2108,15 2124,48 @@ auto ServiceCellular::handleSmsDoneNotification([[maybe_unused]] sys::Message *m
     auto resp = handleTextMessagesInit();
     return std::make_shared<cellular::ResponseMessage>(resp);
 }
+
 auto ServiceCellular::handleSignalStrengthUpdateNotification([[maybe_unused]] sys::Message *msg)
     -> std::shared_ptr<sys::ResponseMessage>
 {
     return std::make_shared<cellular::ResponseMessage>(false);
 }
+
 auto ServiceCellular::handleNetworkStatusUpdateNotification([[maybe_unused]] sys::Message *msg)
     -> std::shared_ptr<sys::ResponseMessage>
 {
-    return std::make_shared<cellular::ResponseMessage>(false);
+    constexpr auto mccLength = 3;
+
+    if (Store::GSM::get()->getNetwork().status != Store::Network::Status::RegisteredRoaming) {
+        return std::make_shared<cellular::ResponseMessage>(true);
+    }
+
+    std::string simCardMcc{};
+    if (!getIMSI(simCardMcc)) {
+        LOG_ERROR("Failed to get SIM card's MCC code!");
+        return std::make_shared<cellular::ResponseMessage>(false);
+    }
+
+    std::string qnwinfo{};
+    if (!getQNWINFO(qnwinfo)) {
+        LOG_ERROR("Failed to get QNWINFO!");
+        return std::make_shared<cellular::ResponseMessage>(false);
+    }
+
+    const auto operatorMcc = at::response::qnwinfo::parseOperatorCode(qnwinfo).substr(0, mccLength);
+    if (operatorMcc.empty()) {
+        LOG_ERROR("Failed to get operator's MCC code!");
+        return std::make_shared<cellular::ResponseMessage>(false);
+    }
+
+    if (simCardMcc == operatorMcc) {
+        LOG_INFO("SIM card MCC is the same as operator MCC (%s), phone is in domestic roaming", operatorMcc.c_str());
+
+        auto network   = Store::GSM::get()->getNetwork();
+        network.status = Store::Network::Status::RegisteredHomeNetwork;
+        Store::GSM::get()->setNetwork(network);
+    }
+    return std::make_shared<cellular::ResponseMessage>(true);
 }
 
 auto ServiceCellular::handleUrcIncomingNotification([[maybe_unused]] sys::Message *msg)


@@ 2143,7 2192,6 @@ auto ServiceCellular::handleCellularSetFlightModeMessage(sys::Message *msg) -> s
 auto ServiceCellular::handleCellularRingNotification([[maybe_unused]] sys::Message *msg)
     -> std::shared_ptr<sys::ResponseMessage>
 {
-    LOG_INFO("%s", __PRETTY_FUNCTION__);
     ongoingCall->handle(call::event::RING{});
     return std::make_shared<cellular::ResponseMessage>(true);
 }

@@ 93,6 93,7 @@ class ServiceCellular : public sys::Service
      * @return true when succeed, false when fails
      */
     bool getIMSI(std::string &destination, bool fullNumber = false);
+    bool getQNWINFO(std::string &destination);
     std::vector<std::string> getNetworkInfo();
 
     void externalUSSDRequestHandled();

@@ 65,10 65,9 @@ namespace cellular::internal
             auto channel     = owner->cmux->get(CellularMux::Channel::Commands);
             auto permitVolte = volteCapability->isVolteAllowed(*channel);
             auto enableVolte =
-                owner->settings->getValue(settings::Cellular::volteEnabled, settings::SettingsScope::Global) == "1"
-                    ? true
-                    : false;
-            bool volteNeedReset = false;
+                owner->settings->getValue(settings::Cellular::volteEnabled, settings::SettingsScope::Global) == "1";
+            auto volteNeedReset = false;
+
             try {
                 volteNeedReset    = !volteHandler->switchVolte(*channel, permitVolte, enableVolte);
                 auto notification = std::make_shared<cellular::VolteStateNotification>(volteHandler->getVolteState());


@@ 105,6 104,7 @@ namespace cellular::internal
     void ServiceCellularPriv::connectSimCard()
     {
         using namespace cellular::msg;
+
         /**
          * Request message handlers
          */


@@ 115,6 115,7 @@ namespace cellular::internal
             simCard->handleSimCardSelected();
             return std::make_shared<request::sim::SetActiveSim::Response>(result);
         });
+
         owner->connect(typeid(request::sim::GetPinSettings), [&](sys::Message *) -> sys::MessagePointer {
             if (!simCard->isSimCardInserted()) {
                 owner->bus.sendMulticast<notification::SimNotInserted>();


@@ 126,6 127,7 @@ namespace cellular::internal
             }
             return std::make_shared<request::sim::GetPinSettings::Response>(simLockState.value());
         });
+
         owner->connect(typeid(request::sim::ChangePin), [&](sys::Message *request) -> sys::MessagePointer {
             auto msg = static_cast<request::sim::ChangePin *>(request);
             if (!simCard->isSimCardInserted()) {


@@ 134,6 136,7 @@ namespace cellular::internal
             }
             return std::make_shared<request::sim::ChangePin::Response>(simCard->handleChangePin(msg->oldPin, msg->pin));
         });
+
         owner->connect(typeid(request::sim::UnblockWithPuk), [&](sys::Message *request) -> sys::MessagePointer {
             auto msg = static_cast<request::sim::UnblockWithPuk *>(request);
             if (!simCard->isSimCardInserted()) {


@@ 143,6 146,7 @@ namespace cellular::internal
             return std::make_shared<request::sim::UnblockWithPuk::Response>(
                 simCard->handleUnblockWithPuk(msg->puk, msg->pin));
         });
+
         owner->connect(typeid(request::sim::SetPinLock), [&](sys::Message *request) -> sys::MessagePointer {
             auto msg = static_cast<request::sim::SetPinLock *>(request);
             if (!simCard->isSimCardInserted()) {


@@ 152,6 156,7 @@ namespace cellular::internal
             return std::make_shared<request::sim::SetPinLock::Response>(
                 simCard->handleSetPinLock(msg->pin, msg->pinLock), msg->pinLock);
         });
+
         owner->connect(typeid(request::sim::PinUnlock), [&](sys::Message *request) -> sys::MessagePointer {
             auto msg = static_cast<request::sim::PinUnlock *>(request);
             if (!simCard->isSimCardInserted()) {


@@ 168,6 173,7 @@ namespace cellular::internal
             simCard->handleTrayState();
             return sys::MessageNone{};
         });
+
         owner->connect(typeid(cellular::SimInsertedNotication), [&](sys::Message *request) -> sys::MessagePointer {
             auto message = static_cast<cellular::SimInsertedNotication *>(request);
 

@@ 26,7 26,7 @@ namespace cellular::service
 {
     auto VolteAllowedList::isVolteAllowed(const std::string &imsi) const -> bool
     {
-        for (auto country : allowedList) {
+        for (const auto &country : allowedList) {
             if (country.isAllowed(imsi)) {
                 LOG_INFO("MCC supported, VoLTE allowed.");
                 return true;

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


@@ 12,6 12,6 @@ namespace cellular::service
       public:
         virtual ~VolteAllowedListInterface() = default;
 
-        auto virtual isVolteAllowed(const std::string &imsi) const -> bool = 0;
+        virtual auto isVolteAllowed(const std::string &imsi) const -> bool = 0;
     };
 } // namespace cellular::service

@@ 1,4 1,4 @@
-// Copyright (c) 2017-2022, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2023, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "EventStore.hpp"


@@ 46,15 46,15 @@ namespace Store
         return ptr;
     }
 
-    void GSM::setSignalStrength(const SignalStrength &signalStrength)
+    void GSM::setSignalStrength(const SignalStrength &newSignalStrength)
     {
         cpp_freertos::LockGuard lock(mutex);
         LOG_INFO("Setting signal strength to rssi = %d dBm (%d) : %d bars",
-                 signalStrength.rssidBm,
-                 signalStrength.rssi,
-                 static_cast<int>(signalStrength.rssiBar));
+                 newSignalStrength.rssidBm,
+                 newSignalStrength.rssi,
+                 static_cast<int>(newSignalStrength.rssiBar));
 
-        this->signalStrength = signalStrength;
+        signalStrength = newSignalStrength;
     }
 
     SignalStrength GSM::getSignalStrength() const


@@ 63,10 63,10 @@ namespace Store
         return signalStrength;
     }
 
-    void GSM::setNetwork(const Network &network)
+    void GSM::setNetwork(const Network &newNetwork)
     {
         cpp_freertos::LockGuard lock(mutex);
-        this->network = network;
+        network = newNetwork;
     }
 
     Network GSM::getNetwork() const


@@ 80,21 80,25 @@ namespace Store
         cpp_freertos::LockGuard lock(mutex);
         return (sim == SIM::SIM1 || sim == SIM::SIM2);
     }
+
     void GSM::setNetworkOperatorName(const std::string &newNetworkOperatorName)
     {
         cpp_freertos::LockGuard lock(mutex);
         networkOperatorName = newNetworkOperatorName;
     }
+
     std::string GSM::getNetworkOperatorName() const
     {
         cpp_freertos::LockGuard lock(mutex);
         return networkOperatorName;
     }
-    void GSM::setTethering(const Tethering &tethering)
+
+    void GSM::setTethering(const Tethering &newTethering)
     {
         cpp_freertos::LockGuard lock(mutex);
-        this->tethering = tethering;
+        tethering = newTethering;
     }
+
     Tethering GSM::getTethering() const
     {
         cpp_freertos::LockGuard lock(mutex);

@@ 168,7 168,7 @@ namespace Store
             ON_INITIALIZED,  /// modem is on, and it's fully initialized
         } modem = Modem::OFF;
 
-        void setSignalStrength(const SignalStrength &signalStrength);
+        void setSignalStrength(const SignalStrength &newSignalStrength);
         SignalStrength getSignalStrength() const;
 
         void setNetwork(const Network &network);


@@ 177,7 177,7 @@ namespace Store
         void setNetworkOperatorName(const std::string &newNetworkOperatorName);
         std::string getNetworkOperatorName() const;
 
-        void setTethering(const Tethering &tethering);
+        void setTethering(const Tethering &newTethering);
         Tethering getTethering() const;
 
         static GSM *get();

@@ 12,6 12,7 @@
 ### Changed / Improved
 
 * General improvement in Eink display and error handling
+* Change roaming indicator to show domestic roaming as home network
 
 ### Fixed