10 files changed, 207 insertions(+), 44 deletions(-)

M changelog.md
M image/assets/lang/English.json
M module-apps/application-desktop/data/Mmi.hpp
M module-apps/application-desktop/windows/MmiInternalMsgWindow.cpp
M module-apps/application-desktop/windows/MmiInternalMsgWindow.hpp
M module-apps/application-desktop/windows/MmiPushWindow.cpp
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/service-cellular/CellularMessage.hpp

@@ 7,6 7,7 @@
 * Add GUI visitor and DOM documentation.
 * `[PowerManagement]` Critial battery level notification to SystemManager.
 * `[Bluetooth]`  Add settings storage to bluetooth related items
+* `[cellular]`  Add GUI for Custom MMI messages- call forwarding.
 * Add Bluetooth virtual audio device.
 * Add custom repeat window for the alarm application
 

@@ 183,6 183,23 @@
   "app_desktop_menu": "MENU",
   "app_desktop_emergency": "SOS",
   "app_desktop_info": "Info",
+  "app_desktop_info_mmi_none_specified_failed": "Operation failed",
+  "app_desktop_info_mmi_none_specified_success": "Operation successful",
+  "app_desktop_info_mmi_common_failed": "failed",
+  "app_desktop_info_mmi_common_no" :"not",
+  "app_desktop_info_mmi_registration_failed": "Registration failed",
+  "app_desktop_info_mmi_registration_success": "Registration was successful",
+  "app_desktop_info_mmi_erasure_failed": "Erasure failed",
+  "app_desktop_info_mmi_erasure_success": "Erasure was successful",
+  "app_desktop_info_mmi_disabling_failed": "Service disabling failed",
+  "app_desktop_info_mmi_disabling_success": "Service has been disabled",
+  "app_desktop_info_mmi_enabling_failed": "Service enabling failed",
+  "app_desktop_info_mmi_enabling_success": "Service has been enabled",
+  "app_desktop_info_mmi_voice": "voice",
+  "app_desktop_info_mmi_fax": "FAX",
+  "app_desktop_info_mmi_sync": "sync",
+  "app_desktop_info_mmi_async": "async",
+  "app_desktop_info_mmi_call_forwarding" : "Call forwarding",
   "app_desktop_info_mmi_result_success": "Success",
   "app_desktop_info_mmi_result_failed": "Failed",
   "app_desktop_header_sim_setup": "<text><token>$SIM</token> setup</text>",

@@ 3,8 3,11 @@
 
 #pragma once
 
+#include <service-appmgr/data/MmiActionsParams.hpp>
+
 namespace mmi
 {
+
     static inline std::string removePhrase(std::string str, std::string phrase)
     {
         auto find_pos = str.find(phrase);


@@ 14,4 17,80 @@ namespace mmi
         }
         return str;
     }
+
+    class MMIMessageVisitor : public app::manager::actions::Visitor
+    {
+      public:
+        MMIMessageVisitor()
+        {
+            messageDictionary.clear();
+            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::NoneSpecifiedFailed,
+                                      "app_desktop_info_mmi_none_specified_failed");
+            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::NoneSpecifiedSuccess,
+                                      "app_desktop_info_mmi_none_specified_success");
+            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CommonFailure,
+                                      "app_desktop_info_mmi_common_failed");
+            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CommonNoMessage,
+                                      "app_desktop_info_mmi_common_no");
+            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::RegistrationSuccessful,
+                                      "app_desktop_info_mmi_registration_success");
+            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::RegistrationFailed,
+                                      "app_desktop_info_mmi_registration_failed");
+            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::ErasureSuccessful,
+                                      "app_desktop_info_mmi_erasure_success");
+            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::ErasureFailed,
+                                      "app_desktop_info_mmi_erasure_failed");
+            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::DisablingSuccessful,
+                                      "app_desktop_info_mmi_disabling_success");
+            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::DisablingFailed,
+                                      "app_desktop_info_mmi_disabling_failed");
+            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::EnablingSuccessful,
+                                      "app_desktop_info_mmi_enabling_success");
+            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::EnablingFailed,
+                                      "app_desktop_info_mmi_enabling_failed");
+        };
+
+        virtual void visit(mmiactions::MMINoneSpecifiedResult &customResult, std::string &displayMessage)
+        {
+            displayMessage += getSelectedMessagesFromDictionary(customResult.getMessage());
+        }
+
+        virtual void visit(mmiactions::MMICustomResultParams &customResult, std::string &displayMessage)
+        {
+            displayMessage += getSelectedMessagesFromDictionary(customResult.getMessage());
+        }
+
+        virtual void visit(mmiactions::MMICallForwardingResult &customResult, std::string &displayMessage)
+        {
+            displayMessage += utils::localize.get("app_desktop_info_mmi_call_forwarding") + "\n";
+            if (customResult.getMessageType() == mmiactions::IMMICustomResultParams::MMIType::CallForwardingData) {
+                auto [voice, fax, sync, async] = customResult.getData();
+                displayMessage += utils::localize.get("app_desktop_info_mmi_voice") + ": " + voice + "\n" +
+                                  utils::localize.get("app_desktop_info_mmi_fax") + ": " + fax + "\n" +
+                                  utils::localize.get("app_desktop_info_mmi_sync") + ": " + sync + "\n" +
+                                  utils::localize.get("app_desktop_info_mmi_async") + ": " + async + "\n";
+            }
+            else if (customResult.getMessageType() ==
+                     mmiactions::IMMICustomResultParams::MMIType::CallForwardingNotification) {
+                displayMessage += getSelectedMessagesFromDictionary(customResult.getMessage());
+            }
+        }
+
+        UTF8 getSelectedMessagesFromDictionary(
+            const std::vector<mmiactions::IMMICustomResultParams::MMIResultMessage> &msgList)
+        {
+            UTF8 selectedMessages = "";
+            for (const auto &msg : msgList) {
+                auto it = messageDictionary.find(msg);
+                if (messageDictionary.end() != it) {
+                    selectedMessages += utils::localize.get(it->second) + "\n";
+                }
+            }
+            return selectedMessages;
+        }
+
+      private:
+        std::map<mmiactions::IMMICustomResultParams::MMIResultMessage, std::string> messageDictionary;
+    };
+
 } // namespace mmi

@@ 5,6 5,7 @@
 #include "MmiInternalMsgWindow.hpp"
 #include <service-appmgr/model/ApplicationManager.hpp>
 #include <service-appmgr/data/MmiActionsParams.hpp>
+#include <application-desktop/data/Mmi.hpp>
 #include <i18n/i18n.hpp>
 
 using namespace gui;


@@ 14,18 15,34 @@ MmiInternalMsgWindow::MmiInternalMsgWindow(app::Application *app, const std::str
 
 void MmiInternalMsgWindow::onBeforeShow(ShowMode mode, SwitchData *data)
 {
-    if (auto metadata = dynamic_cast<app::manager::actions::MMIResultParams *>(data); metadata != nullptr) {
-        auto result = metadata->getData();
-        switch (result) {
-        case app::manager::actions::MMIResultParams::MMIResult::Success:
-            text->setText(utils::localize.get("app_desktop_info_mmi_result_success"));
-            break;
-        case app::manager::actions::MMIResultParams::MMIResult::Failed:
-            text->setText(utils::localize.get("app_desktop_info_mmi_result_failed"));
-            break;
-        default:
-            text->clear();
-            break;
+    if (auto metadata = dynamic_cast<mmiactions::MMIResultParams *>(data); metadata != nullptr) {
+        if (metadata->getCustomData() != nullptr) {
+            mmi::MMIMessageVisitor customMMIvisitor;
+            std::string displayMessage;
+            metadata->getCustomData()->accept(customMMIvisitor, displayMessage);
+            text->setAlignment(gui::Alignment(gui::Alignment::Horizontal::Left, gui::Alignment::Vertical::Top));
+            text->setText(displayMessage);
         }
+        else {
+            handleInternalMessages(metadata);
+        }
+    }
+}
+
+void MmiInternalMsgWindow::handleInternalMessages(mmiactions::MMIResultParams *metadata)
+{
+    std::string displayMessage;
+    text->setAlignment(gui::Alignment(gui::Alignment::Horizontal::Center, gui::Alignment::Vertical::Top));
+    auto result = metadata->getData();
+    switch (result) {
+    case mmiactions::MMIResultParams::MMIResult::Success:
+        text->setText(displayMessage + utils::localize.get("app_desktop_info_mmi_result_success"));
+        break;
+    case mmiactions::MMIResultParams::MMIResult::Failed:
+        text->setText(displayMessage + utils::localize.get("app_desktop_info_mmi_result_failed"));
+        break;
+    default:
+        text->clear();
+        break;
     }
 }

@@ 7,8 7,11 @@
 
 #include <AppWindow.hpp>
 #include <Text.hpp>
-#include <functional>
 #include <DialogMetadata.hpp>
+#include <service-appmgr/data/MmiActionsParams.hpp>
+
+#include <functional>
+#include <map>
 
 namespace gui
 {


@@ 17,6 20,7 @@ namespace gui
       public:
         MmiInternalMsgWindow(app::Application *app, const std::string &name);
         void onBeforeShow(ShowMode mode, SwitchData *data) override;
+        void handleInternalMessages(mmiactions::MMIResultParams *metadata);
     };
 
 }; // namespace gui

@@ 22,7 22,7 @@ namespace style::desktop
         constexpr uint32_t x = 40;
         constexpr uint32_t y = 300;
         constexpr uint32_t w = 400;
-        constexpr uint32_t h = 135;
+        constexpr uint32_t h = 300;
     } // namespace text
 
 } // namespace style::desktop

@@ 7,19 7,39 @@ using namespace app::manager::actions;
 
 void MMICustomResultParams::addMessage(const MMIResultMessage &message)
 {
-    messages.push_back(message);
+    messages.emplace_back(message);
 }
 
-auto MMICustomResultParams::getMessage() -> std::vector<MMIResultMessage>
+auto MMICustomResultParams::getMessage() const -> std::vector<MMIResultMessage>
 {
-    return std::move(messages);
+    return messages;
 }
 
-auto MMICustomResultParams::getType() -> MMIType
+auto MMICustomResultParams::getMessageType() const noexcept -> MMIType
 {
     return type;
 }
 
+void MMICustomResultParams::accept(Visitor &v, std::string &displayMessage)
+{
+    v.visit(*this, displayMessage);
+};
+
+void MMINoneSpecifiedResult::accept(Visitor &v, std::string &displayMessage)
+{
+    v.visit(*this, displayMessage);
+};
+
+auto MMICallForwardingResult::getData() const -> std::tuple<std::string, std::string, std::string, std::string>
+{
+    return std::make_tuple(voice, fax, sync, async);
+}
+
+void MMICallForwardingResult::accept(Visitor &v, std::string &displayMessage)
+{
+    v.visit(*this, displayMessage);
+};
+
 MMIParams::MMIParams(std::string mmiData) : mmiData{std::move(mmiData)}
 {}
 


@@ 28,18 48,17 @@ std::string MMIParams::getData() const
     return mmiData;
 }
 
-MMIResultParams::MMIResultParams(MMIResult result) : result(result)
+MMIResultParams::MMIResultParams(MMIResult result, std::shared_ptr<MMICustomResultParams> customResult)
+    : result(result), customResult(std::move(customResult))
 {}
 
-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>
+auto MMIResultParams::getCustomData() const noexcept -> std::shared_ptr<MMICustomResultParams>
 {
     return customResult;
 }

@@ 5,8 5,23 @@
 
 #include <service-appmgr/service-appmgr/Actions.hpp>
 
+namespace mmiactions = app::manager::actions;
+
 namespace app::manager::actions
 {
+
+    class MMINoneSpecifiedResult;
+    class MMICallForwardingResult;
+    class MMICustomResultParams;
+
+    class Visitor
+    {
+      public:
+        virtual void visit(MMINoneSpecifiedResult &, std::string &)  = 0;
+        virtual void visit(MMICallForwardingResult &, std::string &) = 0;
+        virtual void visit(MMICustomResultParams &, std::string &)   = 0;
+    };
+
     class IMMICustomResultParams
     {
       public:


@@ 43,18 58,21 @@ namespace app::manager::actions
             EnablingSuccessful,
             EnablingFailed
         };
-        virtual auto getMessage() -> std::vector<MMIResultMessage> = 0;
-        virtual void addMessage(const MMIResultMessage &message)   = 0;
-        virtual auto getType() -> MMIType                          = 0;
+
+        virtual auto getMessage() const -> std::vector<MMIResultMessage> = 0;
+        virtual void addMessage(const MMIResultMessage &message)         = 0;
+        virtual auto getMessageType() const noexcept -> MMIType          = 0;
+        virtual void accept(Visitor &v, std::string &displayMessage)     = 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;
+        virtual void addMessage(const MMIResultMessage &message) override;
+        virtual auto getMessage() const -> std::vector<MMIResultMessage> override;
+        virtual auto getMessageType() const noexcept -> MMIType override;
+        virtual void accept(Visitor &v, std::string &displayMessage) override;
 
       protected:
         MMIType type;


@@ 66,14 84,23 @@ namespace app::manager::actions
       public:
         MMINoneSpecifiedResult() : MMICustomResultParams(MMIType::NoneSpecified)
         {}
+        virtual void accept(Visitor &v, std::string &displayMessage) override;
     };
 
     class MMICallForwardingResult : public MMICustomResultParams
     {
       public:
-        MMICallForwardingResult() : MMICustomResultParams(MMIType::CallForwardingData)
+        explicit MMICallForwardingResult(MMIType resultType) : MMICustomResultParams(resultType)
+        {}
+
+        MMICallForwardingResult(
+            MMIType resultType, std::string voice, std::string fax, std::string sync, std::string async)
+            : MMICustomResultParams(resultType), voice(voice), fax(fax), sync(sync), async(async)
         {}
 
+        auto getData() const -> std::tuple<std::string, std::string, std::string, std::string>;
+        virtual void accept(Visitor &v, std::string &displayMessage) override;
+
       private:
         std::string voice;
         std::string fax;


@@ 107,13 134,14 @@ namespace app::manager::actions
             Success,
             Failed
         };
-        explicit MMIResultParams(MMIResult result);
-        explicit MMIResultParams(std::shared_ptr<IMMICustomResultParams> cParams);
+
+        explicit MMIResultParams(MMIResult result, std::shared_ptr<MMICustomResultParams> customResult = nullptr);
+
         [[nodiscard]] MMIResult getData() const noexcept;
-        [[nodiscard]] auto getCustomMessage() const noexcept -> std::shared_ptr<IMMICustomResultParams>;
+        [[nodiscard]] auto getCustomData() const noexcept -> std::shared_ptr<MMICustomResultParams>;
 
       private:
         MMIResult result;
-        std::shared_ptr<IMMICustomResultParams> customResult = nullptr;
+        std::shared_ptr<MMICustomResultParams> customResult = nullptr;
     };
 } // namespace app::manager::actions

@@ 92,7 92,7 @@ void CellularRequestHandler::handle(ClirRequest &request, at::Result &result)
     using namespace at::response;
     auto requestHandled = request.checkModemResponse(result);
 
-    std::shared_ptr<IMMICustomResultParams> response = std::make_shared<MMIClirResult>();
+    std::shared_ptr<MMICustomResultParams> response = std::make_shared<MMIClirResult>();
     if (requestHandled) {
         auto procedureType = request.getProcedureType();
         if (procedureType == SupplementaryServicesRequest::ProcedureType::Activation) {


@@ 112,7 112,7 @@ void CellularRequestHandler::handle(ClirRequest &request, at::Result &result)
             response->addMessage(IMMICustomResultParams::MMIResultMessage::CommonFailure);
         }
     }
-    auto msg = std::make_shared<CellularMMIResultMessage>(response);
+    auto msg = std::make_shared<CellularMMIResultMessage>(MMIResultParams::MMIResult::Success, response);
     sys::Bus::SendUnicast(msg, app::manager::ApplicationManager::ServiceName, &cellular);
     request.setHandled(requestHandled);
 }

@@ 549,23 549,21 @@ class CellularMMIResult : public CellularMessage
   protected:
     app::manager::actions::MMIResultParams params;
 
-    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)
+    explicit CellularMMIResult(app::manager::actions::MMIResultParams::MMIResult result,
+                               std::shared_ptr<app::manager::actions::MMICustomResultParams> customResult = nullptr)
+        : CellularMessage(MessageType::CellularMMIData), params(result, std::move(customResult))
     {}
 };
 
 class CellularMMIResultMessage : public CellularMMIResult, public app::manager::actions::ConvertibleToAction
 {
   public:
-    CellularMMIResultMessage(app::manager::actions::MMIResultParams::MMIResult result) : CellularMMIResult(result)
+    explicit CellularMMIResultMessage(
+        app::manager::actions::MMIResultParams::MMIResult result,
+        std::shared_ptr<app::manager::actions::MMICustomResultParams> customResult = nullptr)
+        : CellularMMIResult(result, std::move(customResult))
     {}
 
-    CellularMMIResultMessage(std::shared_ptr<app::manager::actions::IMMICustomResultParams> &result)
-        : CellularMMIResult(result)
-    {}
 
     [[nodiscard]] auto toAction() const -> std::unique_ptr<app::manager::ActionRequest>
     {