10 files changed, 66 insertions(+), 142 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-utils/EventStore/EventStore.cpp
M module-utils/EventStore/EventStore.hpp
M pure_changelog.md

@@ 118,8 118,6 @@ 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); },


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

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


@@ 228,12 228,12 @@ namespace at
         }
         namespace creg
         {
-            bool isRegistered(std::uint32_t commandData)
+            bool isRegistered(uint32_t commandData)
             {
 
                 // Creg command returns 1 when registered in home network, 5 when registered in roaming
-                constexpr std::uint32_t registeredHome    = 1;
-                constexpr std::uint32_t registeredRoaming = 5;
+                constexpr uint32_t registeredHome    = 1;
+                constexpr 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, std::uint32_t &result)
+        bool parseCREG(std::string &response, 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<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;
+            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;
             if (parseCREG(response, cregValue)) {
                 auto cregCode = cregCodes.find(cregValue);
                 if (cregCode != cregCodes.end()) {


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


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


@@ 335,27 324,27 @@ namespace at
                 utils::toNumeric(string, freq);
                 return freq;
             }
-            std::uint32_t parseLteBandString(std::string &string)
+            uint32_t parseLteBandString(std::string &string)
             {
 
-                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));
+                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));
 
                 auto constexpr toRemove    = "LTE BAND ";
                 auto constexpr emptyString = "";

@@ 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, std::uint32_t &result);
-        bool parseCREG(std::string &response, std::uint32_t &result);
+        bool parseCSQ(std::string cellularResponse, uint32_t &result);
+        bool parseCREG(std::string &response, 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(std::uint32_t commandData);
+            bool isRegistered(uint32_t commandData);
         }
         namespace qnwinfo
         {


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

@@ 198,7 198,6 @@ 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>();


@@ 212,7 211,6 @@ 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,23 1166,6 @@ 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;


@@ 1753,6 1736,7 @@ 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);
 }


@@ 1788,6 1772,7 @@ 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");


@@ 1823,6 1808,7 @@ 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");
     }


@@ 1888,6 1874,7 @@ 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}));
 }


@@ 2092,7 2079,6 @@ 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>
 {


@@ 2102,14 2088,12 @@ 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);


@@ 2124,48 2108,15 @@ 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>
 {
-    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);
+    return std::make_shared<cellular::ResponseMessage>(false);
 }
 
 auto ServiceCellular::handleUrcIncomingNotification([[maybe_unused]] sys::Message *msg)


@@ 2192,6 2143,7 @@ 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,7 93,6 @@ 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();

@@ 67,9 67,10 @@ 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";
-            auto volteNeedReset = false;
-
+                owner->settings->getValue(settings::Cellular::volteEnabled, settings::SettingsScope::Global) == "1"
+                    ? true
+                    : false;
+            bool volteNeedReset = false;
             try {
                 volteNeedReset    = !volteHandler->switchVolte(*channel, permitVolte, enableVolte);
                 auto notification = std::make_shared<cellular::VolteStateNotification>(volteHandler->getVolteState());


@@ 106,7 107,6 @@ namespace cellular::internal
     void ServiceCellularPriv::connectSimCard()
     {
         using namespace cellular::msg;
-
         /**
          * Request message handlers
          */


@@ 117,7 117,6 @@ 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>();


@@ 129,7 128,6 @@ 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()) {


@@ 138,7 136,6 @@ 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()) {


@@ 148,7 145,6 @@ 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()) {


@@ 158,7 154,6 @@ 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()) {


@@ 175,7 170,6 @@ 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);
 

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


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


@@ 80,25 80,21 @@ 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 &newTethering)
+    void GSM::setTethering(const Tethering &tethering)
     {
         cpp_freertos::LockGuard lock(mutex);
-        tethering = newTethering;
+        this->tethering = tethering;
     }
-
     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 &newSignalStrength);
+        void setSignalStrength(const SignalStrength &signalStrength);
         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 &newTethering);
+        void setTethering(const Tethering &tethering);
         Tethering getTethering() const;
 
         static GSM *get();

@@ 12,7 12,6 @@
 ### Changed / Improved
 
 * General improvement in Eink display and error handling
-* Change roaming indicator to show domestic roaming as home network
 * Optimized ServiceAudio power management
 * Blocked call execution with empty phone number field