12 files changed, 1 insertions(+), 286 deletions(-)

M module-apps/CMakeLists.txt
M module-apps/application-settings/ApplicationSettings.cpp
M module-apps/application-settings/include/application-settings/ApplicationSettings.hpp
M module-apps/application-settings/windows/network/NetworkWindow.cpp
M module-services/service-cellular/CellularServiceAPI.cpp
M module-services/service-cellular/NetworkSettings.cpp
M module-services/service-cellular/NetworkSettings.hpp
M module-services/service-cellular/ServiceCellular.cpp
M module-services/service-cellular/service-cellular/CellularMessage.hpp
M module-services/service-cellular/service-cellular/CellularServiceAPI.hpp
M module-services/service-cellular/service-cellular/ServiceCellular.hpp
M module-services/service-db/agents/settings/SystemSettings.hpp

@@ 58,11 58,6 @@ if (${CMAKE_BUILD_TYPE} STREQUAL "Debug")
     endforeach()
 endif()
 
-option(ENABLE_VOLTE "Enable VoLTE" OFF)
-if(${ENABLE_VOLTE})
-    target_compile_definitions(${PROJECT_NAME} PUBLIC ENABLE_VOLTE=1)
-endif()
-
 option(DISABLED_SETTINGS_OPTIONS "Enable Disabled Settings Options" OFF)
 if(${DISABLED_SETTINGS_OPTIONS})
     target_compile_definitions(${PROJECT_NAME} PUBLIC DISABLED_SETTINGS_OPTIONS=1)

@@ 322,10 322,6 @@ namespace app
         settings->registerValueChange(settings::operators_on,
                                       [this](const std::string &value) { operatorOnChanged(value); });
         settings->registerValueChange(
-            ::settings::Cellular::volte_on,
-            [this](const std::string &value) { volteChanged(value); },
-            ::settings::SettingsScope::Global);
-        settings->registerValueChange(
             ::settings::Cellular::offlineMode,
             [this](const std::string &value) { flightModeOn = utils::getNumericValue<bool>(value); },
             ::settings::SettingsScope::Global);


@@ 635,24 631,6 @@ namespace app
         settings->setValue(settings::operators_on, std::to_string(static_cast<int>(value)));
     }
 
-    void ApplicationSettings::setVoLTEOn(bool value)
-    {
-        voLteStateOn = value;
-        CellularServiceAPI::SetVoLTE(this, voLteStateOn);
-    };
-
-    bool ApplicationSettings::getVoLTEOn() const noexcept
-    {
-        return voLteStateOn;
-    }
-
-    void ApplicationSettings::volteChanged(const std::string &value)
-    {
-        if (!value.empty()) {
-            voLteStateOn = utils::getNumericValue<bool>(value);
-        }
-    }
-
     void ApplicationSettings::setOsUpdateVersion(const std::string &value)
     {
         LOG_DEBUG("[ApplicationSettings::setOsUpdateVersion] to value=%s", value.c_str());

@@ 37,8 37,6 @@ namespace app
             virtual ~OperatorsSettings()                               = default;
             virtual void setOperatorsOn(bool value)                    = 0;
             [[nodiscard]] virtual bool getOperatorsOn() const noexcept = 0;
-            virtual void setVoLTEOn(bool value)                        = 0;
-            [[nodiscard]] virtual bool getVoLTEOn() const noexcept     = 0;
         };
         class ScreenLightSettings
         {


@@ 154,9 152,6 @@ namespace app
         void operatorOnChanged(const std::string &value);
         void setOperatorsOn(bool value) override;
         bool getOperatorsOn() const noexcept override;
-        void setVoLTEOn(bool value) override;
-        bool getVoLTEOn() const noexcept override;
-        void volteChanged(const std::string &value);
         void setOsUpdateVersion(const std::string &value);
 
         ScreenLightSettings::Values getCurrentValues() override;


@@ 197,7 192,6 @@ namespace app
         std::string selectedSimNumber = {};
 
         bool operatorsOn                                               = false;
-        bool voLteStateOn                                              = false;
         bool notificationsWhenLocked                                   = true;
         bool callsFromFavorites                                        = false;
         int connectionFrequency                                        = 0;

@@ 63,20 63,6 @@ namespace gui
         }
 #endif // DISABLED_SETTINGS_OPTIONS
 
-#if ENABLE_VOLTE == 1
-        auto voLteOn = operatorsSettings->getVoLTEOn();
-        optList.emplace_back(std::make_unique<gui::option::OptionSettings>(
-            utils::translate("app_settings_network_voice_over_lte"),
-            [=](gui::Item &item) {
-                operatorsSettings->setVoLTEOn(!voLteOn);
-                refreshOptionsList();
-                return true;
-            },
-            nullptr,
-            nullptr,
-            voLteOn ? gui::option::SettingRightItem::On : gui::option::SettingRightItem::Off));
-#endif // ENABLE_VOLTE
-
         optList.emplace_back(std::make_unique<gui::option::OptionSettings>(
             utils::translate("app_settings_network_apn_settings"),
             [=](gui::Item &item) {

@@ 313,12 313,6 @@ bool CellularServiceAPI::GetDataTransfer(sys::Service *serv)
     return serv->bus.sendUnicast(std::make_shared<cellular::GetDataTransferMessage>(), ServiceCellular::serviceName);
 }
 
-bool CellularServiceAPI::SetVoLTE(sys::Service *serv, bool voLTE)
-{
-    return serv->bus.sendUnicast(std::make_shared<cellular::ChangeVoLTEDataMessage>(voLTE),
-                                 ServiceCellular::serviceName);
-}
-
 bool CellularServiceAPI::ChangeModulePowerState(sys::Service *serv, cellular::service::State::PowerState newState)
 {
     return serv->bus.sendUnicast(std::make_shared<cellular::PowerStateChange>(newState), ServiceCellular::serviceName);

@@ 2,7 2,6 @@
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "NetworkSettings.hpp"
-#include "QMBNManager.hpp"
 #include <unordered_map>
 #include <at/ATFactory.hpp>
 #include <at/cmd/QNWINFO.hpp>


@@ 184,6 183,7 @@ bool NetworkSettings::setOperatorAutoSelect()
     auto resp = channel->cmd(buildCmd);
     return (resp.code == at::Result::Code::OK);
 }
+
 bool NetworkSettings::setOperator(at::response::cops::CopsMode mode,
                                   at::response::cops::NameFormat format,
                                   const std::string &name)


@@ 199,162 199,3 @@ bool NetworkSettings::setOperator(at::response::cops::CopsMode mode,
     auto resp = channel->cmd(buildCmd);
     return (resp.code == at::Result::Code::OK);
 }
-
-at::Result::Code NetworkSettings::getPreferredVoiceDomain(VoiceDomainPreference &pref)
-{
-    auto channel = cellularService.cmux->get(CellularMux::Channel::Commands);
-    if (!channel) {
-        return at::Result::Code::ERROR;
-    }
-
-    QMBNManager qmbn(channel);
-    std::uint8_t retval;
-    auto ret = qmbn.readNVByte(nv_paths::voice_domain_pref, retval);
-    if (ret == at::Result::Code::OK) {
-        pref = static_cast<VoiceDomainPreference>(retval);
-    }
-
-    return ret;
-}
-
-at::Result::Code NetworkSettings::setPreferredVoiceDomain(VoiceDomainPreference pref)
-{
-    auto channel = cellularService.cmux->get(CellularMux::Channel::Commands);
-    if (!channel) {
-        return at::Result::Code::ERROR;
-    }
-
-    QMBNManager qmbn(channel);
-    auto ret = qmbn.writeNVByte(nv_paths::voice_domain_pref, static_cast<std::uint8_t>(pref));
-    return ret;
-}
-
-at::Result::Code NetworkSettings::getPreferredSMSDomain(SMSDomainPreference &pref)
-{
-    auto channel = cellularService.cmux->get(CellularMux::Channel::Commands);
-    if (!channel) {
-        return at::Result::Code::ERROR;
-    }
-
-    QMBNManager qmbn(channel);
-    std::uint8_t retval;
-    auto ret = qmbn.readNVByte(nv_paths::sms_domain_pref, retval);
-    if (ret == at::Result::Code::OK) {
-        pref = static_cast<SMSDomainPreference>(retval);
-    }
-
-    return ret;
-}
-
-at::Result::Code NetworkSettings::setPreferredSMSDomain(SMSDomainPreference pref)
-{
-    auto channel = cellularService.cmux->get(CellularMux::Channel::Commands);
-    if (!channel) {
-        return at::Result::Code::ERROR;
-    }
-
-    QMBNManager qmbn(channel);
-    auto ret = qmbn.writeNVByte(nv_paths::sms_domain_pref, static_cast<std::uint8_t>(pref));
-    return ret;
-}
-
-at::Result::Code NetworkSettings::setIMSState(at::response::qcfg_ims::IMSState state)
-{
-    auto channel = cellularService.cmux->get(CellularMux::Channel::Commands);
-    if (!channel) {
-        return at::Result::Code::ERROR;
-    }
-    at::Cmd buildCmd = at::factory(at::AT::QCFG_IMS) + "," + utils::to_string(static_cast<int>(state));
-    auto resp        = channel->cmd(buildCmd);
-    return resp.code;
-}
-
-std::optional<std::pair<at::response::qcfg_ims::IMSState, at::response::qcfg_ims::VoLTEIMSState>> NetworkSettings::
-    getIMSState()
-{
-    std::vector<std::string> operatorNames;
-    auto channel = cellularService.cmux->get(CellularMux::Channel::Commands);
-    if (channel) {
-
-        at::Cmd buildCmd = at::factory(at::AT::QCFG_IMS);
-        auto resp        = channel->cmd(buildCmd);
-        std::pair<at::response::qcfg_ims::IMSState, at::response::qcfg_ims::VoLTEIMSState> ret;
-        if ((resp.code == at::Result::Code::OK) && (at::response::parseQCFG_IMS(resp, ret))) {
-            return ret;
-        }
-    }
-
-    return std::nullopt;
-}
-
-at::Result::Code NetworkSettings::setVoLTEState(VoLTEState state)
-{
-    /**
-     * VoLTE On scenario
-     * 1^) auto select off
-     * 2) voice domain pref to PS,  [sms domain pref to PS - optional]
-     * 3) NV enable VoLTE
-     * 4^) select ROW_Generic_3GPP, also could be Volte_OpenMkt-Comercial-CMCC  << could need reboot
-     * 5) set QCFG ims to 1
-     * 6) If need reboot modem AT+CFUN=1,1
-     *
-     * ^ optional if not work, should be tested with operator
-     *
-     *VoLTE off switch
-     * 1) "ims" QCFG to 0
-     * 2) autoselect of MBN to On
-     * 3) Reboot
-     */
-
-    auto channel = cellularService.cmux->get(CellularMux::Channel::Commands);
-    if (!channel) {
-        return at::Result::Code::ERROR;
-    }
-
-    QMBNManager qmbn(channel);
-    if (state == VoLTEState::On) {
-        setPreferredVoiceDomain(VoiceDomainPreference::PSPreferred);
-        qmbn.setAutoSelect(at::response::qmbncfg::MBNAutoSelect::On);
-        setIMSState(at::response::qcfg_ims::IMSState::Enable);
-    }
-    else {
-        setIMSState(at::response::qcfg_ims::IMSState::Disable);
-        qmbn.setAutoSelect(at::response::qmbncfg::MBNAutoSelect::On);
-    }
-    LOG_DEBUG("Modem soft reboot");
-    return at::Result::Code::OK;
-}
-
-VoLTEState NetworkSettings::getVoLTEConfigurationState()
-{
-    /** VoLTE on could be detect in general by one parameter,
-     * based on enable IP multimedia services ON (via QCFG="ims")
-     * but could be completed based on
-     * NV state of VoLTE Disable
-     *
-     * This is information about configuration setup, not information
-     * about whether the VoLTE actually works in the selected network
-     *
-     */
-    if (auto state = getIMSState(); state) {
-        /// check disable in any other state VoLTE is likely
-        return state->first == at::response::qcfg_ims::IMSState::Disable ? VoLTEState::Off : VoLTEState::On;
-    }
-    return VoLTEState::Unknown;
-}
-
-std::string NetworkSettings::printVoLTEDebug()
-{
-    auto channel = cellularService.cmux->get(CellularMux::Channel::Commands);
-    if (channel) {
-        auto resp = channel->cmd("AT+QVOLTEDBG");
-        if (resp.code == at::Result::Code::OK) {
-            std::string buffer = "";
-            for (auto el : resp.response) {
-                buffer = el + "\r\n";
-            }
-            return buffer;
-        }
-    }
-    return {};
-}

@@ 56,27 56,12 @@ class NetworkSettings
      * @return
      */
     std::vector<std::string> scanOperators(bool fullInfoList = false);
-    at::Result::Code setVoLTEState(VoLTEState state);
-
-    /// This is information about configuration setup, not information
-    /// about whether the VoLTE actually works in the selected network
-    VoLTEState getVoLTEConfigurationState();
-
-    at::Result::Code getPreferredVoiceDomain(VoiceDomainPreference &pref);
-    at::Result::Code setPreferredVoiceDomain(VoiceDomainPreference pref);
 
     bool setOperatorAutoSelect();
     std::string getCurrentOperatorName() const;
     std::optional<at::response::cops::Operator> getCurrentOperator() const;
-    at::Result::Code getPreferredSMSDomain(SMSDomainPreference &pref);
-    at::Result::Code setPreferredSMSDomain(SMSDomainPreference pref);
     bool setOperator(at::response::cops::CopsMode mode, at::response::cops::NameFormat format, const std::string &name);
 
-    at::Result::Code setIMSState(at::response::qcfg_ims::IMSState state);
-    std::optional<std::pair<at::response::qcfg_ims::IMSState, at::response::qcfg_ims::VoLTEIMSState>> getIMSState();
-
-    std::string printVoLTEDebug();
-
     enum class SimpleNAT
     {
         GSM,

@@ 239,10 239,6 @@ sys::ReturnCodes ServiceCellular::InitHandler()
 
     priv->state->set(State::ST::WaitForStartPermission);
     settings->registerValueChange(
-        settings::Cellular::volte_on,
-        [this](const std::string &value) { volteChanged(value); },
-        ::settings::SettingsScope::Global);
-    settings->registerValueChange(
         settings::Cellular::apn_list,
         [this](const std::string &value) { apnListChanged(value); },
         ::settings::SettingsScope::Global);


@@ 388,27 384,6 @@ void ServiceCellular::registerMessageHandlers()
         return handleCellularDeactivateContextMessage(msg);
     });
 
-    connect(typeid(cellular::ChangeVoLTEDataMessage), [&](sys::Message *request) -> sys::MessagePointer {
-        auto msg = static_cast<cellular::ChangeVoLTEDataMessage *>(request);
-        volteOn  = msg->getVoLTEon();
-        settings->setValue(settings::Cellular::volte_on, std::to_string(volteOn), settings::SettingsScope::Global);
-        NetworkSettings networkSettings(*this);
-        auto vstate = networkSettings.getVoLTEConfigurationState();
-        if ((vstate != VoLTEState::On) && volteOn) {
-            LOG_DEBUG("VoLTE On");
-            if (networkSettings.setVoLTEState(VoLTEState::On) == at::Result::Code::OK) {
-                priv->modemResetHandler->performSoftReset();
-            }
-        }
-        else if (!volteOn) {
-            LOG_DEBUG("VoLTE Off");
-            if (networkSettings.setVoLTEState(VoLTEState::Off) == at::Result::Code::OK) {
-                priv->modemResetHandler->performSoftReset();
-            }
-        }
-        return std::make_shared<cellular::ResponseMessage>(true);
-    });
-
     connect(typeid(cellular::SetFlightModeMessage), [&](sys::Message *request) -> sys::MessagePointer {
         auto msg = static_cast<cellular::SetFlightModeMessage *>(request);
         return handleCellularSetFlightModeMessage(msg);


@@ 1741,14 1716,6 @@ std::shared_ptr<cellular::SetOperatorResponse> ServiceCellular::handleCellularSe
         networkSettings.setOperator(msg->getMode(), msg->getFormat(), msg->getName()));
 }
 
-void ServiceCellular::volteChanged(const std::string &value)
-{
-    if (!value.empty()) {
-        LOG_INFO("VoLTE setting state changed to '%s'.", value.c_str());
-        volteOn = utils::getNumericValue<bool>(value);
-    }
-}
-
 void ServiceCellular::apnListChanged(const std::string &value)
 {
     if (!value.empty()) {

@@ 46,7 46,6 @@ class CellularMessage : public sys::DataMessage
 
         ListCurrentCalls,
         SimResponse, // Send to PIN window (show, error state, hide)
-        SetVoLTE,
         SetFlightMode,
 
         PacketData, ///< for all PacketData messages


@@ 467,26 466,6 @@ namespace cellular
         {}
     };
 
-    class VoLTEDataMessage : public CellularMessage
-    {
-        bool VoLTEon = false;
-
-      public:
-        explicit VoLTEDataMessage(bool VoLTEon) : CellularMessage{Type::SetVoLTE}, VoLTEon{VoLTEon}
-        {}
-        [[nodiscard]] bool getVoLTEon() const noexcept
-        {
-            return VoLTEon;
-        }
-    };
-
-    class ChangeVoLTEDataMessage : public VoLTEDataMessage
-    {
-      public:
-        explicit ChangeVoLTEDataMessage(bool VoLTEon) : VoLTEDataMessage{VoLTEon}
-        {}
-    };
-
     class CheckIfStartAllowedMessage : public sys::DataMessage
     {};
 

@@ 138,7 138,6 @@ namespace CellularServiceAPI
 
     bool SetDataTransfer(sys::Service *serv, packet_data::DataTransfer dt);
     bool GetDataTransfer(sys::Service *serv);
-    bool SetVoLTE(sys::Service *serv, bool value);
 
     bool ChangeModulePowerState(sys::Service *serv, cellular::service::State::PowerState newState);
 

@@ 255,9 255,7 @@ class ServiceCellular : public sys::Service
     friend class ConnectionManagerCellularCommands;
     friend class cellular::Api;
 
-    void volteChanged(const std::string &value);
     void apnListChanged(const std::string &value);
-    bool volteOn = false;
 
     auto handleCellularAnswerIncomingCallMessage(CellularMessage *msg) -> std::shared_ptr<cellular::ResponseMessage>;
     auto handleCellularCallRequestMessage(cellular::CallRequestMessage *msg)

@@ 45,7 45,6 @@ namespace settings
 
     namespace Cellular
     {
-        constexpr inline auto volte_on    = "cl_volte_on";
         constexpr inline auto apn_list    = "cl_apn_list";
         constexpr inline auto offlineMode = "cl_offline_mode";
         constexpr inline auto currentUID  = "cl_current_uid";