11 files changed, 275 insertions(+), 2 deletions(-)

M changelog.md
M module-cellular/at/response.cpp
M module-cellular/at/response.hpp
M module-services/service-appmgr/data/MmiActionsParams.cpp
M module-services/service-appmgr/service-appmgr/data/MmiActionsParams.hpp
M module-services/service-cellular/CellularRequestHandler.cpp
M module-services/service-cellular/requests/SupplementaryServicesRequest.cpp
M module-services/service-cellular/service-cellular/CellularMessage.hpp
M module-services/service-cellular/service-cellular/CellularRequestHandler.hpp
M module-services/service-cellular/service-cellular/RequestHandler.hpp
M module-services/service-cellular/service-cellular/requests/SupplementaryServicesRequest.hpp

@@ 10,6 10,7 @@
 * `[file indexer]` Support for deleting entries in File Indexer DB.
 * `[listview]` Added onEmpty list callbacks and implemented them for notes and messages. 
 * `[notes]` Added list rebuild on notifications.
+* `[cellular]` Custom MMI response message.
 
 ### Changed
 

@@ 3,6 3,7 @@
 
 #include "response.hpp"
 #include <Utils.hpp>
+#include <magic_enum.hpp>
 
 #include <algorithm>
 


@@ 218,5 219,79 @@ namespace at
                 return 0;
             }
         } // namespace qnwinfo
+
+        namespace clir
+        {
+            std::optional<ClirResponse> parseClir(const std::string &response)
+            {
+                auto constexpr toRemove    = "+CLIR: ";
+                auto constexpr emptyString = "";
+
+                auto resp = response;
+                utils::findAndReplaceAll(resp, toRemove, emptyString);
+
+                auto tokens = utils::split(resp, ",");
+                for (auto &t : tokens) {
+                    t = utils::trim(t);
+                }
+                if (tokens.size() == clirTokens) {
+                    int state;
+                    int status;
+
+                    if (!utils::toNumeric(tokens[0], state) || !utils::toNumeric(tokens[1], status)) {
+                        return std::nullopt;
+                    }
+                    if (static_cast<unsigned int>(state) < magic_enum::enum_count<ServiceState>() &&
+                        static_cast<unsigned int>(status) < magic_enum::enum_count<ServiceStatus>()) {
+                        return ClirResponse(static_cast<ServiceState>(state), static_cast<ServiceStatus>(status));
+                    }
+                }
+                return std::nullopt;
+            }
+
+            app::manager::actions::IMMICustomResultParams::MMIResultMessage getState(const ServiceState &state)
+            {
+                using namespace app::manager::actions;
+
+                auto message = IMMICustomResultParams::MMIResultMessage::CommonNoMessage;
+                switch (state) {
+                case ServiceState::AccordingToSubscription:
+                    message = IMMICustomResultParams::MMIResultMessage::ClirAccordingToSubscription;
+                    break;
+                case ServiceState::ServiceEnabled:
+                    message = IMMICustomResultParams::MMIResultMessage::ClirEnabled;
+                    break;
+                case ServiceState::ServiceDisabled:
+                    message = IMMICustomResultParams::MMIResultMessage::ClirDisabled;
+                    break;
+                }
+                return message;
+            }
+
+            app::manager::actions::IMMICustomResultParams::MMIResultMessage getStatus(const ServiceStatus &status)
+            {
+                using namespace app::manager::actions;
+
+                auto message = IMMICustomResultParams::MMIResultMessage::CommonNoMessage;
+                switch (status) {
+                case ServiceStatus::NotProvisioned:
+                    message = IMMICustomResultParams::MMIResultMessage::ClirNotProvisioned;
+                    break;
+                case ServiceStatus::PermanentProvisioned:
+                    message = IMMICustomResultParams::MMIResultMessage::ClirPermanentProvisioned;
+                    break;
+                case ServiceStatus::Unknown:
+                    message = IMMICustomResultParams::MMIResultMessage::ClirUnknown;
+                    break;
+                case ServiceStatus::TemporaryRestricted:
+                    message = IMMICustomResultParams::MMIResultMessage::ClirTemporaryRestricted;
+                    break;
+                case ServiceStatus::TemporaryAllowed:
+                    message = IMMICustomResultParams::MMIResultMessage::ClirTemporaryAllowed;
+                    break;
+                }
+                return message;
+            }
+        } // namespace clir
     }     // namespace response
 } // namespace at

@@ 9,6 9,8 @@
 #include <memory>
 #include <string>
 
+#include <service-appmgr/service-appmgr/data/MmiActionsParams.hpp>
+
 namespace at
 {
     namespace response


@@ 86,5 88,42 @@ namespace at
             uint32_t parseNumericBandString(std::string &string);
             uint32_t parseLteBandString(std::string &string);
         } // namespace qnwinfo
+
+        namespace clir
+        {
+            constexpr uint32_t clirTokens = 2;
+
+            enum class ServiceState
+            {
+                AccordingToSubscription,
+                ServiceEnabled,
+                ServiceDisabled,
+            };
+
+            enum class ServiceStatus
+            {
+                NotProvisioned,
+                PermanentProvisioned,
+                Unknown,
+                TemporaryRestricted,
+                TemporaryAllowed
+            };
+
+            class ClirResponse
+            {
+              public:
+                ServiceState serviceState;
+                ServiceStatus serviceStatus;
+
+                explicit ClirResponse(const ServiceState &state, const ServiceStatus &status)
+                    : serviceState(state), serviceStatus(status)
+                {}
+            };
+
+            auto parseClir(const std::string &response) -> std::optional<ClirResponse>;
+            auto getState(const ServiceState &state) -> app::manager::actions::IMMICustomResultParams::MMIResultMessage;
+            auto getStatus(const ServiceStatus &status)
+                -> app::manager::actions::IMMICustomResultParams::MMIResultMessage;
+        } // namespace clir
     }     // namespace response
 } // namespace at

@@ 5,6 5,21 @@
 
 using namespace app::manager::actions;
 
+void MMICustomResultParams::addMessage(const MMIResultMessage &message)
+{
+    messages.push_back(message);
+}
+
+auto MMICustomResultParams::getMessage() -> std::vector<MMIResultMessage>
+{
+    return std::move(messages);
+}
+
+auto MMICustomResultParams::getType() -> MMIType
+{
+    return type;
+}
+
 MMIParams::MMIParams(std::string mmiData) : mmiData{std::move(mmiData)}
 {}
 


@@ 16,7 31,15 @@ std::string MMIParams::getData() const
 MMIResultParams::MMIResultParams(MMIResult result) : result(result)
 {}
 
+MMIResultParams::MMIResultParams(std::shared_ptr<IMMICustomResultParams> cResult) : customResult(cResult)
+{}
+
 MMIResultParams::MMIResult MMIResultParams::getData() const noexcept
 {
     return result;
 }
+
+auto MMIResultParams::getCustomMessage() const noexcept -> std::shared_ptr<IMMICustomResultParams>
+{
+    return customResult;
+}

@@ 7,6 7,86 @@
 
 namespace app::manager::actions
 {
+    class IMMICustomResultParams
+    {
+      public:
+        enum class MMIType
+        {
+            NoneSpecified,
+            CallForwardingNotification,
+            CallForwardingData,
+            Clir
+        };
+
+        enum class MMIResultMessage
+        {
+            NoneSpecifiedSuccess,
+            NoneSpecifiedFailed,
+            CommonFailure,
+            CommonNoMessage,
+
+            ClirAccordingToSubscription,
+            ClirEnabled,
+            ClirDisabled,
+            ClirNotProvisioned,
+            ClirPermanentProvisioned,
+            ClirUnknown,
+            ClirTemporaryRestricted,
+            ClirTemporaryAllowed,
+
+            RegistrationSuccessful,
+            RegistrationFailed,
+            ErasureSuccessful,
+            ErasureFailed,
+            DisablingSuccessful,
+            DisablingFailed,
+            EnablingSuccessful,
+            EnablingFailed
+        };
+        virtual auto getMessage() -> std::vector<MMIResultMessage> = 0;
+        virtual void addMessage(const MMIResultMessage &message)   = 0;
+        virtual auto getType() -> MMIType                          = 0;
+    };
+
+    class MMICustomResultParams : public IMMICustomResultParams
+    {
+      public:
+        MMICustomResultParams(MMIType resultType) : type(resultType){};
+        void addMessage(const MMIResultMessage &message) override;
+        auto getMessage() -> std::vector<MMIResultMessage> override;
+        auto getType() -> MMIType override;
+
+      protected:
+        MMIType type;
+        std::vector<MMIResultMessage> messages;
+    };
+
+    class MMINoneSpecifiedResult : public MMICustomResultParams
+    {
+      public:
+        MMINoneSpecifiedResult() : MMICustomResultParams(MMIType::NoneSpecified)
+        {}
+    };
+
+    class MMICallForwardingResult : public MMICustomResultParams
+    {
+      public:
+        MMICallForwardingResult() : MMICustomResultParams(MMIType::CallForwardingData)
+        {}
+
+      private:
+        std::string voice;
+        std::string fax;
+        std::string sync;
+        std::string async;
+    };
+
+    class MMIClirResult : public MMICustomResultParams
+    {
+      public:
+        MMIClirResult() : MMICustomResultParams(MMIType::Clir)
+        {}
+    };
 
     class MMIParams : public ActionParams
     {


@@ 28,9 108,12 @@ namespace app::manager::actions
             Failed
         };
         explicit MMIResultParams(MMIResult result);
+        explicit MMIResultParams(std::shared_ptr<IMMICustomResultParams> cParams);
         [[nodiscard]] MMIResult getData() const noexcept;
+        [[nodiscard]] auto getCustomMessage() const noexcept -> std::shared_ptr<IMMICustomResultParams>;
 
       private:
         MMIResult result;
+        std::shared_ptr<IMMICustomResultParams> customResult = nullptr;
     };
 } // namespace app::manager::actions

@@ 17,6 17,10 @@
 #include "service-cellular/requests/UssdRequest.hpp"
 
 #include <service-appmgr/model/ApplicationManager.hpp>
+#include "service-cellular/service-cellular/requests/ClirRequest.hpp"
+#include "service-cellular/service-cellular/requests/SupplementaryServicesRequest.hpp"
+
+#include <module-cellular/at/response.hpp>
 
 void CellularRequestHandler::handle(ImeiRequest &request, at::Result &result)
 {


@@ 81,6 85,37 @@ void CellularRequestHandler::handle(PinChangeRequest &request, at::Result &resul
     sendMmiResult(requestHandled);
 }
 
+void CellularRequestHandler::handle(ClirRequest &request, at::Result &result)
+{
+    using namespace app::manager::actions;
+    using namespace cellular;
+    using namespace at::response;
+    auto requestHandled = request.checkModemResponse(result);
+
+    std::shared_ptr<IMMICustomResultParams> response = std::make_shared<MMIClirResult>();
+    if (requestHandled) {
+        auto procedureType = request.getProcedureType();
+        if (procedureType == SupplementaryServicesRequest::ProcedureType::Activation) {
+            response->addMessage(IMMICustomResultParams::MMIResultMessage::ClirEnabled);
+        }
+        else if (procedureType == SupplementaryServicesRequest::ProcedureType::Deactivation) {
+            response->addMessage(IMMICustomResultParams::MMIResultMessage::ClirDisabled);
+        }
+        else if (procedureType == SupplementaryServicesRequest::ProcedureType::Interrogation) {
+            auto clirParsed = clir::parseClir(result.response[0]);
+            if (clirParsed != std::nullopt) {
+                response->addMessage(clir::getStatus(clirParsed->serviceStatus));
+                response->addMessage(clir::getState(clirParsed->serviceState));
+            }
+        }
+        else {
+            response->addMessage(IMMICustomResultParams::MMIResultMessage::CommonFailure);
+        }
+    }
+    auto msg = std::make_shared<CellularMMIResultMessage>(response);
+    sys::Bus::SendUnicast(msg, app::manager::ApplicationManager::ServiceName, &cellular);
+    request.setHandled(requestHandled);
+}
 void CellularRequestHandler::sendMmiResult(bool result)
 {
     using namespace app::manager::actions;

@@ 146,4 146,9 @@ namespace cellular
         return utils::to_string(informationClass);
     }
 
+    auto SupplementaryServicesRequest::getProcedureType() -> ProcedureType
+    {
+        return procedureType;
+    }
+
 }; // namespace cellular

@@ 549,7 549,10 @@ class CellularMMIResult : public CellularMessage
   protected:
     app::manager::actions::MMIResultParams params;
 
-    explicit CellularMMIResult(app::manager::actions::MMIResultParams::MMIResult result)
+    CellularMMIResult(app::manager::actions::MMIResultParams::MMIResult result)
+        : CellularMessage(MessageType::CellularMMIData), params(result)
+    {}
+    CellularMMIResult(std::shared_ptr<app::manager::actions::IMMICustomResultParams> &result)
         : CellularMessage(MessageType::CellularMMIData), params(result)
     {}
 };


@@ 557,7 560,10 @@ class CellularMMIResult : public CellularMessage
 class CellularMMIResultMessage : public CellularMMIResult, public app::manager::actions::ConvertibleToAction
 {
   public:
-    explicit CellularMMIResultMessage(app::manager::actions::MMIResultParams::MMIResult result)
+    CellularMMIResultMessage(app::manager::actions::MMIResultParams::MMIResult result) : CellularMMIResult(result)
+    {}
+
+    CellularMMIResultMessage(std::shared_ptr<app::manager::actions::IMMICustomResultParams> &result)
         : CellularMMIResult(result)
     {}
 

@@ 20,6 20,7 @@ class CellularRequestHandler : public RequestHandler
     void handle(PasswordRegistrationRequest &request, at::Result &result) final;
     void handle(SupplementaryServicesRequest &request, at::Result &result) final;
     void handle(PinChangeRequest &request, at::Result &result) final;
+    void handle(ClirRequest &request, at::Result &result) final;
 
   private:
     ServiceCellular &cellular;

@@ 13,6 13,8 @@ namespace cellular
     class SupplementaryServicesRequest;
     class PasswordRegistrationRequest;
     class PinChangeRequest;
+    class ClipRequest;
+    class ClirRequest;
 
     class RequestHandler
     {


@@ 23,5 25,6 @@ namespace cellular
         virtual void handle(PasswordRegistrationRequest &request, at::Result &result)  = 0;
         virtual void handle(PinChangeRequest &request, at::Result &result)             = 0;
         virtual void handle(SupplementaryServicesRequest &request, at::Result &result) = 0;
+        virtual void handle(ClirRequest &request, at::Result &result)                  = 0;
     };
 } // namespace cellular

@@ 44,6 44,8 @@ namespace cellular
             Erasure        ///< MMI string starts with ##
         };
 
+        auto getProcedureType() -> ProcedureType;
+
       protected:
         std::string request;
         std::string serviceCode;