2 files changed, 76 insertions(+), 8 deletions(-)

M module-services/service-cellular/src/VolteHandler.hpp
M module-services/service-cellular/tests/unittest_volteHandler.cpp

@@ 42,20 42,31 @@ namespace cellular::service
 
             if (enable) {
                 // according to Quectel, this setting doesn't have to be reset when disabling
-                constexpr std::uint8_t voiceDomainPacketSwitchedPreferred = 0x03;
                 auto voiceDomainAnswer =
-                    channel.cmd(factory(at::AT::QNVFW) + "\"/nv/item_files/modem/mmode/voice_domain_pref\"," +
-                                utils::byteToHex<std::uint8_t>(voiceDomainPacketSwitchedPreferred));
+                    channel.cmd(factory(at::AT::QNVFW) + NetworkServiceDomain(NetworkServiceDomain::Type::Voice));
                 if (!voiceDomainAnswer) {
                     throw std::runtime_error("[VoLTE] failed to set voice domain before trying to enable VoLTE");
                 }
 
+                auto smsDomainAnswer =
+                    channel.cmd(factory(at::AT::QNVFW) + NetworkServiceDomain(NetworkServiceDomain::Type::SmsViaIms));
+                if (!smsDomainAnswer) {
+                    throw std::runtime_error("[VoLTE] failed to set SMS domain before trying to enable VoLTE");
+                }
+
                 // can be left as always on: doesn't disturb when VoLTE disabled
                 auto qmbnAnswer = channel.cmd(factory(at::AT::QMBNCFG) + std::string("\"autosel\",1"));
                 if (!qmbnAnswer) {
                     throw std::runtime_error("[VoLTE] failed to enable MBN auto-select before trying to enable VoLTE");
                 }
             }
+            else {
+                auto smsDomainAnswer =
+                    channel.cmd(factory(at::AT::QNVFW) + NetworkServiceDomain(NetworkServiceDomain::Type::SmsViaSgs));
+                if (!smsDomainAnswer) {
+                    throw std::runtime_error("[VoLTE] failed to reset SMS domain before trying to disable VoLTE");
+                }
+            }
 
             auto imsCheckAnswer = channel.cmd(factory(AT::QCFG_IMS));
             if (!imsCheckAnswer) {


@@ 103,6 114,47 @@ namespace cellular::service
             return isFirstRunAfterSwitch;
         }
 
+        struct NetworkServiceDomain
+        {
+            enum class Type
+            {
+                SmsViaIms,
+                SmsViaSgs,
+                Voice
+            };
+            explicit NetworkServiceDomain(Type type) : type_{type}
+            {
+                switch (type) {
+                case Type::SmsViaSgs:
+                    domain_     = "sms";
+                    preference_ = 0x00;
+                    return;
+                case Type::SmsViaIms:
+                    domain_     = "sms";
+                    preference_ = 0x01;
+                    return;
+                case Type::Voice:
+                    domain_     = "voice";
+                    preference_ = 0x03;
+                    return;
+                default:
+                    throw std::logic_error("unimplemented network service domain: " +
+                                           std::string(magic_enum::enum_name(type)));
+                }
+            }
+
+            operator std::string()
+            {
+                return "\"/nv/item_files/modem/mmode/" + domain_ + "_domain_pref\"," +
+                       utils::byteToHex<std::uint8_t>(preference_);
+            }
+
+          private:
+            std::string domain_;
+            Type type_;
+            std::uint8_t preference_;
+        };
+
       private:
         std::string imsStateToString(response::qcfg_ims::IMSState imsState) const
         {

@@ 119,7 119,10 @@ TEST_CASE("VoLTE handler test")
     SECTION("ThrowsAboutMbnAutoselectFailure_When_TryingToEnableVolte_And_AutoselectCommandRespondsNOK")
     {
         std::queue<CommandAndResponse> chain;
-        push(chain, std::make_pair(AT::QNVFW, DummyOkResult{}), std::make_pair(AT::QMBNCFG, DummyErrorResult{}));
+        push(chain,
+             std::make_pair(AT::QNVFW, DummyOkResult{}),
+             std::make_pair(AT::QNVFW, DummyOkResult{}),
+             std::make_pair(AT::QMBNCFG, DummyErrorResult{}));
         CommandSequentialChannel channel(std::move(chain));
 
         VolteHandler<CommandSequentialChannel, DummyModemResponseParser> handler;


@@ 132,6 135,7 @@ TEST_CASE("VoLTE handler test")
         std::queue<CommandAndResponse> chain;
         push(chain,
              std::make_pair(AT::QNVFW, DummyOkResult{}),
+             std::make_pair(AT::QNVFW, DummyOkResult{}),
              std::make_pair(AT::QMBNCFG, DummyOkResult{}),
              std::make_pair(AT::QCFG_IMS, DummyErrorResult{}));
         CommandSequentialChannel channel(std::move(chain));


@@ 146,6 150,7 @@ TEST_CASE("VoLTE handler test")
         std::queue<CommandAndResponse> chain;
         push(chain,
              std::make_pair(AT::QNVFW, DummyOkResult{}),
+             std::make_pair(AT::QNVFW, DummyOkResult{}),
              std::make_pair(AT::QMBNCFG, DummyOkResult{}),
              std::make_pair(AT::QCFG_IMS, DummyOkResult{}));
         CommandSequentialChannel channel(std::move(chain));


@@ 160,6 165,7 @@ TEST_CASE("VoLTE handler test")
         std::queue<CommandAndResponse> chain;
         push(chain,
              std::make_pair(AT::QNVFW, DummyOkResult{}),
+             std::make_pair(AT::QNVFW, DummyOkResult{}),
              std::make_pair(AT::QMBNCFG, DummyOkResult{}),
              std::make_pair(AT::QCFG_IMS, DummyOkResult{}));
         CommandSequentialChannel channel(std::move(chain));


@@ 172,7 178,7 @@ TEST_CASE("VoLTE handler test")
     SECTION("ReturnsOk_When_TryingToDisableVolte_And_AlreadyDisabled")
     {
         std::queue<CommandAndResponse> chain;
-        push(chain, std::make_pair(AT::QCFG_IMS, DummyOkResult{}));
+        push(chain, std::make_pair(AT::QNVFW, DummyOkResult{}), std::make_pair(AT::QCFG_IMS, DummyOkResult{}));
         CommandSequentialChannel channel(std::move(chain));
 
         VolteHandler<CommandSequentialChannel, QcfgImsDummyParser<true>> handler;


@@ 183,7 189,10 @@ TEST_CASE("VoLTE handler test")
     SECTION("ReturnsFalse_When_TryingToDisableVolte_And_WasEnabledBefore")
     {
         std::queue<CommandAndResponse> chain;
-        push(chain, std::make_pair(AT::QCFG_IMS, DummyOkResult{}), std::make_pair(AT::QCFG_IMS, DummyOkResult{}));
+        push(chain,
+             std::make_pair(AT::QNVFW, DummyOkResult{}),
+             std::make_pair(AT::QCFG_IMS, DummyOkResult{}),
+             std::make_pair(AT::QCFG_IMS, DummyOkResult{}));
         CommandSequentialChannel channel(std::move(chain));
 
         VolteHandler<CommandSequentialChannel, QcfgImsDummyParser<false>> handler;


@@ 194,7 203,10 @@ TEST_CASE("VoLTE handler test")
     SECTION("ReturnsFalse_When_TryingToEnableVolte_And_WasEnabledBefore")
     {
         std::queue<CommandAndResponse> chain;
-        push(chain, std::make_pair(AT::QCFG_IMS, DummyOkResult{}), std::make_pair(AT::QCFG_IMS, DummyOkResult{}));
+        push(chain,
+             std::make_pair(AT::QNVFW, DummyOkResult{}),
+             std::make_pair(AT::QCFG_IMS, DummyOkResult{}),
+             std::make_pair(AT::QCFG_IMS, DummyOkResult{}));
         CommandSequentialChannel channel(std::move(chain));
 
         VolteHandler<CommandSequentialChannel, QcfgImsDummyParser<false>> handler;


@@ 205,7 217,10 @@ TEST_CASE("VoLTE handler test")
     SECTION("ThrowsAboutImsFailure_When_DisablingVolte_And_ImsSteeringCommandFailed")
     {
         std::queue<CommandAndResponse> chain;
-        push(chain, std::make_pair(AT::QCFG_IMS, DummyOkResult{}), std::make_pair(AT::QCFG_IMS, DummyErrorResult{}));
+        push(chain,
+             std::make_pair(AT::QNVFW, DummyOkResult{}),
+             std::make_pair(AT::QCFG_IMS, DummyOkResult{}),
+             std::make_pair(AT::QCFG_IMS, DummyErrorResult{}));
         CommandSequentialChannel channel(std::move(chain));
 
         VolteHandler<CommandSequentialChannel, QcfgImsDummyParser<false>> handler;


@@ 218,6 233,7 @@ TEST_CASE("VoLTE handler test")
         std::queue<CommandAndResponse> chain;
         push(chain,
              std::make_pair(AT::QNVFW, DummyOkResult{}),
+             std::make_pair(AT::QNVFW, DummyOkResult{}),
              std::make_pair(AT::QMBNCFG, DummyOkResult{}),
              std::make_pair(AT::QCFG_IMS, DummyOkResult{}),
              std::make_pair(AT::QCFG_IMS, DummyErrorResult{}));