~aleteoryx/muditaos

muditaos/module-apps/application-desktop/data/Mmi.hpp -rw-r--r-- 14.0 KiB
a405cad6 — Aleteoryx trim readme 6 days ago 
                                                                                
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226

// Copyright (c) 2017-2024, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/blob/master/LICENSE.md

#pragma once

#include <i18n/i18n.hpp>
#include <service-appmgr/data/MmiActionsParams.hpp>
#include <utf8/UTF8.hpp>

#include <map>

namespace mmi
{

    static inline std::string removePhrase(std::string str, std::string phrase)
    {
        auto find_pos = str.find(phrase);
        while (find_pos != std::string::npos) {
            str.replace(find_pos, phrase.size(), "");
            find_pos = str.find(phrase, find_pos);
        }
        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_message");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CommonMMINotSupported,
                                      "app_desktop_info_mmi_common_mmi_not_supported");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CommonEnabled,
                                      "app_desktop_info_mmi_common_enabled");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CommonDisabled,
                                      "app_desktop_info_mmi_common_disabled");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CommonVoice,
                                      "app_desktop_info_mmi_common_voice");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CommonData,
                                      "app_desktop_info_mmi_common_data");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CommonFax,
                                      "app_desktop_info_mmi_common_fax");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CommonSync,
                                      "app_desktop_info_mmi_common_sync");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CommonAsync,
                                      "app_desktop_info_mmi_common_async");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CommonAllDisabled,
                                      "app_desktop_info_mmi_common_all_disabled");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CommonDeactivated,
                                      "app_desktop_info_mmi_common_deactivated");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CommonActivated,
                                      "app_desktop_info_mmi_common_activated");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CommonQuery,
                                      "app_desktop_info_mmi_common_query");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::ClirAccordingToSubscription,
                                      "app_desktop_info_mmi_clir_according_to_subscription");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::ClirEnabled,
                                      "app_desktop_info_mmi_clir_enabled");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::ClirDisabled,
                                      "app_desktop_info_mmi_clir_disabled");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::ClirNotProvisioned,
                                      "app_desktop_info_mmi_clir_not_provisioned");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::ClirPermanentProvisioned,
                                      "app_desktop_info_mmi_clir_permanent_provisioned");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::ClirUnknown,
                                      "app_desktop_info_mmi_clir_unknown");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::ClirTemporaryRestricted,
                                      "app_desktop_info_mmi_clir_temporary_restricted");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::ClirTemporaryAllowed,
                                      "app_desktop_info_mmi_clir_temporary_allowed");
            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");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CallForwardingDisabled,
                                      "app_desktop_info_mmi_call_forwarding_disabled");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CallBarringActivated,
                                      "app_desktop_info_mmi_call_barring_activated");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CallBarringDeactivated,
                                      "app_desktop_info_mmi_call_barring_deactivated");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::ClipActivted,
                                      "app_desktop_info_mmi_clip_activated");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::ClipDeactivated,
                                      "app_desktop_info_mmi_clip_deactivated");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::ClipNotProvisioned,
                                      "app_desktop_info_mmi_clip_not_provisioned");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::ClipProvisioned,
                                      "app_desktop_info_mmi_clip_provisioned");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::ClipUnknown,
                                      "app_desktop_info_mmi_clip_unknown");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CallWaitingActivated,
                                      "app_desktop_info_mmi_call_waiting_activated");
            messageDictionary.emplace(mmiactions::IMMICustomResultParams::MMIResultMessage::CallWaitingDeactivated,
                                      "app_desktop_info_mmi_call_waiting_deactivated");
        };

        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::translate("app_desktop_info_mmi_call_forwarding") + "\n";
            if (customResult.getMessageType() == mmiactions::IMMICustomResultParams::MMIType::CallForwardingData) {
                auto [voice, fax, sync, async] = customResult.getData();
                displayMessage += utils::translate("app_desktop_info_mmi_common_voice") + ": " + voice + "\n" +
                                  utils::translate("app_desktop_info_mmi_common_fax") + ": " + fax + "\n" +
                                  utils::translate("app_desktop_info_mmi_common_sync") + ": " + sync + "\n" +
                                  utils::translate("app_desktop_info_mmi_common_async") + ": " + async + "\n";
            }
            else if (customResult.getMessageType() ==
                     mmiactions::IMMICustomResultParams::MMIType::CallForwardingNotification) {
                displayMessage += getSelectedMessagesFromDictionary(customResult.getMessage());
            }
        }

        virtual void visit(mmiactions::MMICallBarringResult &customResult, std::string &displayMessage)
        {
            displayMessage += utils::translate("app_desktop_info_mmi_call_barring") + "\n";
            if (customResult.getMessageType() == mmiactions::IMMICustomResultParams::MMIType::CallBarringData) {
                displayMessage += getCustomMessagesFromDictionary(customResult.getMessages());
            }
            else if (customResult.getMessageType() ==
                     mmiactions::IMMICustomResultParams::MMIType::CallBarringNotification) {
                displayMessage += getSelectedMessagesFromDictionary(customResult.getMessage());
            }
        }

        virtual void visit(mmiactions::MMICallWaitingResult &customResult, std::string &displayMessage)
        {
            displayMessage += utils::translate("app_desktop_info_mmi_call_waiting") + "\n";
            if (customResult.getMessageType() == mmiactions::IMMICustomResultParams::MMIType::CallWaitingData) {
                displayMessage += getCustomMessagesFromDictionary(customResult.getMessages());
            }
            else if (customResult.getMessageType() ==
                     mmiactions::IMMICustomResultParams::MMIType::CallWaitingNotification) {
                displayMessage += getSelectedMessagesFromDictionary(customResult.getMessage());
            }
        }

        virtual void visit(mmiactions::MMIClipResult &customResult, std::string &displayMessage)
        {
            displayMessage += utils::translate("app_desktop_info_mmi_clip") + "\n";
            displayMessage += getSelectedMessagesFromDictionary(customResult.getMessage());
        }

        virtual void visit(mmiactions::MMIClirResult &customResult, std::string &displayMessage)
        {
            displayMessage += utils::translate("app_desktop_info_mmi_clir") + "\n";
            displayMessage += getSelectedMessagesFromDictionary(customResult.getMessage());
        }

        virtual void visit(mmiactions::MMIImeiResult &customResult, std::string &displayMessage)
        {
            displayMessage += utils::translate("app_desktop_info_mmi_imei") + "\n";
            displayMessage += customResult.getImei() + "\n";
            displayMessage += getSelectedMessagesFromDictionary(customResult.getMessage());
        }

        std::string getCustomMessagesFromDictionary(
            std::vector<std::pair<mmiactions::IMMICustomResultParams::MMIResultMessage,
                                  mmiactions::IMMICustomResultParams::MMIResultMessage>> msgData)
        {
            std::string queryStr;
            for (auto msg : msgData) {
                auto serviceClass = msg.first;
                auto serviceState = msg.second;

                auto it = messageDictionary.find(serviceState);
                if (messageDictionary.end() != it) {
                    if (queryStr.empty()) {
                        queryStr += utils::translate(it->second) + "\n";
                    }
                }
                it = messageDictionary.find(serviceClass);
                if (messageDictionary.end() != it) {
                    queryStr += utils::translate(it->second) + "\n";
                }
            }
            return queryStr;
        }

        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::translate(it->second) + "\n";
                }
            }
            return selectedMessages;
        }

      private:
        std::map<mmiactions::IMMICustomResultParams::MMIResultMessage, std::string> messageDictionary;
    };

} // namespace mmi