2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 * This file have been implemented in compliance with W3C WARP SPEC.
18 * but there are some patent issue between W3C WARP SPEC and APPLE.
19 * so if you want to use this file, refer to the README file in root directory
22 * @file widget_parser.cpp
23 * @author Lukasz Wrzosek (l.wrzosek@samsung.com)
27 #include "widget_parser.h"
28 #include "ignoring_parser.h"
29 #include "deny_all_parser.h"
30 #include <dpl/wrt-dao-ro/config_parser_data.h>
31 #include "libiriwrapper.h"
32 #include <dpl/utils/warp_iri.h>
33 #include <dpl/utils/mime_type_utils.h>
34 #include <language_subtag_rst_tree.h>
37 #include <dpl/log/log.h>
38 #include <dpl/fast_delegate.h>
39 #include <dpl/foreach.h>
44 using namespace WrtDB;
47 static const DPL::String UTF_LRE = L"\x0202a";
48 static const DPL::String UTF_LRO = L"\x0202d";
49 static const DPL::String UTF_RLE = L"\x0202b";
50 static const DPL::String UTF_RLO = L"\x0202e";
51 static const DPL::String UTF_PDF = L"\x0202c";
53 Direction ParseDirAttribute(const XmlAttribute& attribute)
55 Assert(L"dir" == attribute.name);
56 if (L"ltr" == attribute.value) {
58 } else if (L"rtl" == attribute.value) {
60 } else if (L"lro" == attribute.value) {
62 } else if (L"rlo" == attribute.value) {
65 LogWarning("dir attribute has wrong value:" << attribute.value);
70 void UpdateTextWithDirectionMark(Direction direction,
76 *text = UTF_RLO + *text + UTF_PDF;
79 *text = UTF_RLE + *text + UTF_PDF;
82 *text = UTF_LRE + *text + UTF_PDF;
85 *text = UTF_LRO + *text + UTF_PDF;
93 } // namespace Unicode
95 class InnerElementsParser : public ElementParser
98 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
99 const DPL::String& /*name*/)
101 return DPL::MakeDelegate(this, &InnerElementsParser::Other);
104 virtual void Accept(const Element& /*element*/)
108 virtual void Accept(const Text& text)
110 if (m_text.IsNull()) {
113 m_text->value += text.value;
117 virtual void Accept(const XmlAttribute& attribute)
119 if (attribute.name == L"dir") {
120 m_textDirection = Unicode::ParseDirAttribute(attribute);
124 virtual void Verify()
126 if (!m_text.IsNull()) {
127 Unicode::UpdateTextWithDirectionMark(m_textDirection,
129 m_parentParser->Accept(*m_text);
133 InnerElementsParser(ElementParserPtr parent) :
134 m_parentParser(parent),
135 m_textDirection(Unicode::EMPTY)
139 ElementParserPtr Other()
141 return ElementParserPtr(new InnerElementsParser(
142 std::static_pointer_cast<ElementParser>(
143 shared_from_this())));
147 DPL::Optional<Text> m_text;
148 ElementParserPtr m_parentParser;
149 Unicode::Direction m_textDirection;
152 class NameParser : public ElementParser
155 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
156 const DPL::String& /*name*/)
158 return DPL::MakeDelegate(this, &NameParser::Other);
161 virtual void Accept(const Element& element)
163 m_lang = element.lang;
167 virtual void Accept(const Text& text)
169 if (m_name.IsNull()) {
172 *m_name += text.value;
176 virtual void Accept(const XmlAttribute& attribute)
178 if (attribute.name == L"short") {
179 if (m_shortName.IsNull()) {
180 m_shortName = attribute.value;
182 } else if (attribute.name == L"dir") {
183 m_textDirection = Unicode::ParseDirAttribute(attribute);
187 virtual void Verify()
189 ConfigParserData::LocalizedData& data = m_data.localizedDataSet[m_lang];
190 if (data.name.IsNull()) {
191 NormalizeString(m_name);
192 NormalizeString(m_shortName);
193 if (!m_name.IsNull()) {
194 Unicode::UpdateTextWithDirectionMark(m_textDirection, &*m_name);
197 if (!m_shortName.IsNull()) {
198 Unicode::UpdateTextWithDirectionMark(m_textDirection,
201 data.shortName = m_shortName;
205 NameParser(Unicode::Direction direction,
206 ConfigParserData& data) :
208 m_textDirection(direction)
212 ElementParserPtr Other()
214 return ElementParserPtr(new InnerElementsParser(
215 std::static_pointer_cast<ElementParser>(
216 shared_from_this())));
220 ConfigParserData& m_data;
221 DPL::OptionalString m_name;
222 DPL::OptionalString m_shortName;
223 DPL::OptionalString m_dir;
225 Unicode::Direction m_textDirection;
228 class AccessParser : public ElementParser
237 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
238 const DPL::String& /*name*/)
240 return DPL::MakeDelegate(this, &AccessParser::Other);
243 virtual void Accept(const Element& element)
245 // for tizen web apps WARP should be used
246 if (element.ns == ConfigurationNamespace::W3CWidgetNamespaceName ||
247 element.ns == ConfigurationNamespace::TizenWebAppNamespaceName)
249 m_standardType = STANDARD_TYPE_WARP;
253 virtual void Accept(const Text& /*text*/)
257 void AcceptWac(const XmlAttribute& attribute)
259 if (attribute.name == L"origin") {
260 m_strIRIOrigin = attribute.value;
261 NormalizeString(m_strIRIOrigin);
262 } else if (attribute.name == L"subdomains") {
263 DPL::String normalizedValue = attribute.value;
264 NormalizeString(normalizedValue);
266 if (normalizedValue == L"true") {
267 m_bSubDomainAccess = true;
268 } else if (normalizedValue == L"false") {
269 m_bSubDomainAccess = false;
274 virtual void Accept(const XmlAttribute& attribute)
276 switch (m_standardType) {
277 case STANDARD_TYPE_WARP:
278 AcceptWac(attribute);
281 LogError("Error in Access tag - unknown standard.");
288 iri.set(m_strIRIOrigin, false);
290 if (!iri.isAccessDefinition()) {
291 LogWarning("Access list element: " <<
293 " is not acceptable by WARP" <<
294 "standard and will be ignored!");
298 ConfigParserData::AccessInfo accessInfo(m_strIRIOrigin,
300 std::pair <ConfigParserData::AccessInfoSet::iterator, bool> ret =
301 m_data.accessInfoSet.insert(accessInfo);
304 virtual void Verify()
306 switch (m_standardType) {
307 case STANDARD_TYPE_WARP:
311 LogError("Error in Access tag - unknown standard.");
315 AccessParser(ConfigParserData& data) :
317 m_bSubDomainAccess(false),
318 m_standardType(STANDARD_TYPE_NONE),
324 ElementParserPtr Other()
326 return ElementParserPtr(new InnerElementsParser(
327 ElementParserPtr(shared_from_this())));
331 DPL::String m_strIRIOrigin;
332 bool m_bSubDomainAccess;
333 StandardType m_standardType;
335 ConfigParserData& m_data;
338 class DescriptionParser : public ElementParser
341 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
342 const DPL::String& /*name*/)
344 return DPL::MakeDelegate(this, &DescriptionParser::Other);
347 virtual void Accept(const Element& element)
349 m_lang = element.lang;
353 ElementParserPtr Other()
355 return ElementParserPtr(new InnerElementsParser(
356 std::static_pointer_cast<ElementParser>(
357 shared_from_this())));
360 virtual void Accept(const Text& text)
362 if (m_description.IsNull()) {
363 m_description = text.value;
365 *m_description += text.value;
369 virtual void Accept(const XmlAttribute& attribute)
371 if (attribute.name == L"dir") {
372 m_textDirection = Unicode::ParseDirAttribute(attribute);
376 virtual void Verify()
378 ConfigParserData::LocalizedData& data = m_data.localizedDataSet[m_lang];
379 if (data.description.IsNull()) {
380 if (!m_description.IsNull()) {
381 Unicode::UpdateTextWithDirectionMark(m_textDirection,
384 data.description = m_description;
388 DescriptionParser(Unicode::Direction direction,
389 ConfigParserData& data) :
393 m_textDirection(direction)
398 ConfigParserData& m_data;
400 DPL::OptionalString m_description;
401 Unicode::Direction m_textDirection;
404 class AuthorParser : public ElementParser
407 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
408 const DPL::String& /*name*/)
410 return DPL::MakeDelegate(this, &AuthorParser::Other);
413 AuthorParser(Unicode::Direction direction,
414 ConfigParserData& data) :
416 m_textDirection(direction)
420 virtual void Accept(const Element& /*element*/)
425 virtual void Accept(const Text& text)
427 *(m_authorName) += text.value;
430 virtual void Accept(const XmlAttribute& attribute)
432 if (attribute.name == L"href") {
433 //Validate href IRI and ignore it if invalid
434 //See also test: ta-argMozRiC-an
435 LibIri::Wrapper iri(DPL::ToUTF8String(attribute.value).c_str());
436 if (iri.Validate()) {
437 m_authorHref = attribute.value;
439 } else if (attribute.name == L"email") {
440 m_authorEmail = attribute.value;
441 } else if (attribute.name == L"dir") {
442 m_textDirection = Unicode::ParseDirAttribute(attribute);
446 virtual void Verify()
448 if (!m_data.authorName && !m_data.authorHref && !m_data.authorEmail) {
449 NormalizeString(m_authorName);
450 NormalizeString(m_authorHref);
451 NormalizeString(m_authorEmail);
452 if (!!m_authorName) {
453 Unicode::UpdateTextWithDirectionMark(m_textDirection,
455 m_data.authorName = m_authorName;
457 if (!!m_authorHref) {
458 m_data.authorHref = m_authorHref;
460 if (!!m_authorEmail) {
461 m_data.authorEmail = m_authorEmail;
466 ElementParserPtr Other()
468 return ElementParserPtr(new InnerElementsParser(
469 std::static_pointer_cast<ElementParser>(
470 shared_from_this())));
474 ConfigParserData& m_data;
475 DPL::OptionalString m_authorEmail;
476 DPL::OptionalString m_authorHref;
477 DPL::OptionalString m_authorName;
478 Unicode::Direction m_textDirection;
481 class LicenseParser : public ElementParser
484 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
485 const DPL::String& /*name*/)
487 return DPL::MakeDelegate(this, &LicenseParser::Other);
490 LicenseParser(Unicode::Direction direction,
491 ConfigParserData& data) :
494 m_textDirection(direction)
498 virtual void Accept(const Element& element)
500 if (m_license.IsNull()) {
501 m_lang = element.lang;
507 virtual void Accept(const Text& text)
510 *m_license += text.value;
514 virtual void Accept(const XmlAttribute& attribute)
517 if (attribute.name == L"href" && m_licenseHref.IsNull()) {
518 m_licenseHref = attribute.value;
519 } else if (attribute.name == L"file" && m_licenseFile.IsNull()) {
520 m_licenseFile = attribute.value;
521 } else if (attribute.name == L"dir") {
522 m_textDirection = Unicode::ParseDirAttribute(attribute);
527 virtual void Verify()
529 ConfigParserData::LocalizedData& data = m_data.localizedDataSet[m_lang];
530 if (data.license.IsNull()) {
531 if (!m_license.IsNull()) {
532 Unicode::UpdateTextWithDirectionMark(m_textDirection,
535 data.license = m_license;
536 data.licenseHref = m_licenseHref;
537 data.licenseFile = m_licenseFile;
541 ElementParserPtr Other()
543 return ElementParserPtr(new InnerElementsParser(
544 ElementParserPtr(shared_from_this())));
548 ConfigParserData& m_data;
552 DPL::OptionalString m_license;
553 DPL::OptionalString m_licenseFile;
554 DPL::OptionalString m_licenseHref;
555 Unicode::Direction m_textDirection;
558 class IconParser : public ElementParser
560 DECLARE_EXCEPTION_TYPE(ElementParser::Exception::ParseError, BadSrcError)
563 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
564 const DPL::String& /*name*/)
566 return &IgnoringParser::Create;
569 IconParser(ConfigParserData& data) : ElementParser(),
574 virtual void Accept(const Element& /*element*/)
578 virtual void Accept(const XmlAttribute& attribute)
580 if (attribute.name == L"src") {
581 if (attribute.value.size() > 0) {
582 m_src = attribute.value;
584 } else if (attribute.name == L"width") {
585 m_width = ParseSizeAttributeValue(attribute.value);
586 } else if (attribute.name == L"height") {
587 m_height = ParseSizeAttributeValue(attribute.value);
591 virtual void Accept(const Text& /*text*/)
593 ThrowMsg(Exception::ParseError, "Icon element must be empty");
596 virtual void Verify()
598 if (m_src.IsNull()) {
599 LogWarning("src attribute of icon element is mandatory - ignoring");
605 ConfigParserData::Icon icon(delocalizeSrcPath(*m_src));
606 icon.width = m_width;
607 icon.height = m_height;
609 ConfigParserData::IconsList::iterator it = std::find(
610 m_data.iconsList.begin(), m_data.iconsList.end(), icon);
611 if (it == m_data.iconsList.end()) {
612 m_data.iconsList.push_front(icon);
617 LogWarning("src attribute is invalid: " << m_src);
622 ConfigParserData& m_data;
623 DPL::OptionalString m_src;
624 DPL::OptionalInt m_width;
625 DPL::OptionalInt m_height;
627 static DPL::OptionalInt ParseSizeAttributeValue(const DPL::String& value)
629 DPL::OptionalString normalizedValue = value;
630 NormalizeString(normalizedValue);
631 if (!(*normalizedValue).empty()) {
635 strtol(DPL::ToUTF8String(value).c_str(), &reterr, 10);
637 std::string(reterr) == DPL::ToUTF8String(value) ||
639 return DPL::OptionalInt::Null;
644 return DPL::OptionalInt::Null;
648 * @brief delocalizePath removes locales folder from relative path if neccessary
649 * @param source source string
651 * @throw BadSrcError if string is bad value of src attribute
653 * @return corrected string
655 static DPL::String delocalizeSrcPath(const DPL::String & source)
657 static const DPL::String localeFolder(L"locales/");
658 static const int index = localeFolder.size();
660 DPL::String result = source;
662 if(source.substr(0,index) == localeFolder)
664 size_t pos = result.find_first_of('/',index);
665 if(pos != std::string::npos && pos + 1 < source.size())
667 result = result.substr(pos + 1,source.size());
678 class ContentParser : public ElementParser
681 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
682 const DPL::String& /*name*/)
684 return &IgnoringParser::Create;
687 ContentParser(ConfigParserData& data) :
693 virtual void Accept(const Element& /*element*/)
697 virtual void Accept(const Text& /*text*/)
701 virtual void Accept(const XmlAttribute& attribute)
703 DPL::String value = attribute.value;
704 NormalizeString(value);
706 if (attribute.name == L"src") {
708 } else if (attribute.name == L"type") {
710 MimeTypeUtils::MimeAttributes mimeAttributes =
711 MimeTypeUtils::getMimeAttributes(value);
712 if (mimeAttributes.count(L"charset") > 0) {
713 m_encoding = mimeAttributes[L"charset"];
715 } else if (attribute.name == L"encoding") {
716 if (!value.empty()) {
722 virtual void Verify()
724 if (m_data.startFileEncountered) {
725 LogWarning("This is not the first encountered "
726 "'content' element - ignoring.");
730 m_data.startFileEncountered = true;
732 //we're consciously setting startFile even if m_src is null or invalid.
733 //WidgetConfigurationManager will deal with this.
734 m_data.startFile = m_src;
737 m_data.startFileContentType = m_type;
739 m_data.startFileEncoding = m_encoding;
741 m_data.startFileEncoding = L"UTF-8";
747 DPL::OptionalString m_src;
748 DPL::OptionalString m_type;
749 DPL::OptionalString m_encoding;
750 ConfigParserData& m_data;
753 class FeatureParser : public ElementParser
756 struct ParamParser : public ElementParser
758 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
759 const DPL::String& /*name*/)
761 return &IgnoringParser::Create;
764 virtual void Accept(const XmlAttribute& attribute)
766 if (attribute.name == L"name") {
767 m_name = attribute.value;
768 NormalizeString(m_name);
769 } else if (attribute.name == L"value") {
770 m_value = attribute.value;
771 NormalizeString(m_value);
775 virtual void Accept(const Element& /*element*/)
779 virtual void Accept(const Text& /*text*/)
781 ThrowMsg(Exception::ParseError, "param element must be empty");
784 virtual void Verify()
786 if (m_name.IsNull() || *m_name == L"") {
789 if (m_value.IsNull() || *m_value == L"") {
793 ConfigParserData::Param param(*m_name);
794 param.value = *m_value;
796 if (m_data.paramsList.find(param) == m_data.paramsList.end()) {
797 m_data.paramsList.insert(param);
801 ParamParser(ConfigParserData::Feature& data) :
808 DPL::OptionalString m_name;
809 DPL::OptionalString m_value;
810 ConfigParserData::Feature& m_data;
813 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
814 const DPL::String& name)
816 if (name == L"param") {
817 return DPL::MakeDelegate(this, &FeatureParser::OnParamElement);
819 return &IgnoringParser::Create;
823 virtual void Accept(const Text& /*text*/)
827 virtual void Accept(const Element& /*element*/)
831 virtual void Accept(const XmlAttribute& attribute)
833 if (attribute.name == L"name") {
834 m_feature.name = attribute.value;
835 } else if (attribute.name == L"required") {
836 if (attribute.value == L"false") {
837 m_feature.required = false;
839 m_feature.required = true;
844 virtual void Verify()
846 LibIri::Wrapper iri(DPL::ToUTF8String(m_feature.name).c_str());
848 if (m_feature.name != L"") {
849 if (iri.Validate()) {
850 if (m_data.featuresList.find(m_feature) ==
851 m_data.featuresList.end()) {
852 m_data.featuresList.insert(m_feature);
854 LogDebug("Ignoring feature with name" <<
855 DPL::ToUTF8String(m_feature.name));
858 if (m_feature.required) {
859 //Throw only if required
860 ThrowMsg(Exception::ParseError, "invalid feature IRI");
866 ElementParserPtr OnParamElement()
868 return ElementParserPtr(new ParamParser(m_feature));
871 FeatureParser(ConfigParserData& data) :
879 ConfigParserData& m_data;
880 ConfigParserData::Feature m_feature;
883 class PreferenceParser : public ElementParser
886 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
887 const DPL::String& /*name*/)
889 return &IgnoringParser::Create;
892 virtual void Accept(const XmlAttribute& attribute)
894 if (attribute.name == L"name") {
895 m_name = attribute.value;
896 } else if (attribute.name == L"value") {
897 m_value = attribute.value;
898 } else if (attribute.name == L"readonly") {
899 if (attribute.value == L"true") {
907 virtual void Accept(const Element& /*element*/)
911 virtual void Accept(const Text& /*text*/)
913 ThrowMsg(Exception::ParseError, "param element must be empty");
916 virtual void Verify()
918 if (m_name.IsNull()) {
919 LogWarning("preference element must have name attribute");
922 NormalizeString(m_name);
923 NormalizeString(m_value);
924 ConfigParserData::Preference preference(*m_name, m_required);
925 preference.value = m_value;
926 if (m_data.preferencesList.find(preference) ==
927 m_data.preferencesList.end()) {
928 m_data.preferencesList.insert(preference);
932 PreferenceParser(ConfigParserData& data) :
940 DPL::OptionalString m_name;
941 DPL::OptionalString m_value;
943 ConfigParserData& m_data;
946 class LinkParser : public ElementParser
949 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
950 const DPL::String& /*name*/)
952 return &DenyAllParser::Create;
955 virtual void Accept(const XmlAttribute& attribute)
957 if (m_properNamespace) {
958 LogDebug("attribute");
959 if (attribute.name == L"rel") {
960 if (attribute.value != L"describedby") {
961 ThrowMsg(Exception::ParseError,
962 "rel attribute must have describedby value");
964 } else if (attribute.name == L"type") {
965 } else if (attribute.name == L"href") {
966 LogDebug("here is href");
967 m_href = attribute.value;
969 ThrowMsg(Exception::ParseError,
970 "unknown attribute '" +
971 DPL::ToUTF8String(attribute.name) +
972 "' in link element");
977 virtual void Accept(const Element& element)
980 ConfigurationNamespace::WacWidgetNamespaceNameForLinkElement)
982 m_properNamespace = true;
987 virtual void Accept(const Text&)
989 if (m_properNamespace) {
991 ThrowMsg(Exception::ParseError, "link element must be empty");
995 virtual void Verify()
998 ThrowMsg(Exception::ParseError,
999 "link element must have href attribute");
1002 LibIri::Wrapper iri(DPL::ToUTF8String(*m_href).c_str());
1003 if (!iri.Validate()) { // TODO: Better uri validator ?
1004 ThrowMsg(Exception::ParseError,
1005 "href attribute must be a valid iri/uri/url");
1009 LinkParser(ConfigParserData& data) :
1011 m_properNamespace(false),
1013 m_href(DPL::OptionalString::Null)
1018 bool m_properNamespace;
1019 ConfigParserData& m_data;
1020 DPL::OptionalString m_href;
1023 class SettingParser : public ElementParser
1026 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
1027 const DPL::String& /*name*/)
1029 return &IgnoringParser::Create;
1032 virtual void Accept(const Text& /*text*/)
1036 virtual void Accept(const Element& /*element*/)
1040 virtual void Accept(const XmlAttribute& attribute)
1042 m_setting.m_name = attribute.name;
1043 m_setting.m_value = attribute.value;
1044 m_data.settingsList.insert(m_setting);
1047 virtual void Verify()
1051 SettingParser(ConfigParserData& data) :
1059 ConfigParserData& m_data;
1060 ConfigParserData::Setting m_setting;
1063 class AppServiceParser : public ElementParser
1066 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
1067 const DPL::String& /*name*/)
1069 return &IgnoringParser::Create;
1072 virtual void Accept(const XmlAttribute& attribute)
1074 if (attribute.name == L"src") {
1075 m_src = attribute.value;
1076 } else if (attribute.name == L"operation") {
1077 m_operation = attribute.value;
1078 } else if (attribute.name == L"scheme") {
1079 m_scheme = attribute.value;
1080 } else if (attribute.name == L"mime") {
1081 m_mime = attribute.value;
1085 virtual void Accept(const Element& element)
1087 LogWarning("namespace for app service = " << element.ns);
1088 if (element.ns == ConfigurationNamespace::W3CWidgetNamespaceName) {
1089 ThrowMsg(Exception::ParseError,
1090 "Wrong xml namespace for widget element");
1094 virtual void Accept(const Text& /*text*/)
1096 ThrowMsg(Exception::ParseError, "param element must be empty");
1099 virtual void Verify()
1101 if (m_src.IsNull()) {
1102 LogWarning("service element must have target attribute");
1104 } else if (m_operation.IsNull()) {
1105 LogWarning("service element must have operation attribute");
1108 NormalizeString(m_src);
1109 NormalizeString(m_operation);
1110 NormalizeString(m_scheme);
1111 NormalizeString(m_mime);
1113 // verify duplicate element
1114 DPL::String wildString(L"*/*");
1115 DPL::String nullString(L"");
1116 ConfigParserData::ServiceInfo serviceInfo(
1117 m_src.IsNull() ? nullString:*m_src,
1118 m_operation.IsNull() ? nullString:*m_operation,
1119 m_scheme.IsNull() ? nullString:*m_scheme,
1120 m_mime.IsNull() ? nullString:*m_mime);
1122 FOREACH(iterator, m_data.appServiceList) {
1123 if (iterator->m_operation == serviceInfo.m_operation &&
1125 (iterator->m_scheme == serviceInfo.m_scheme ||
1126 // check input scheme is "*/*" case
1127 (iterator->m_scheme == wildString &&
1128 serviceInfo.m_scheme != nullString) ||
1129 // check iterator scheme is "*/*" case
1130 (serviceInfo.m_scheme == wildString &&
1131 iterator->m_scheme != nullString)) &&
1133 (iterator->m_mime == serviceInfo.m_mime ||
1134 // check input mime is "*/*" case
1135 (iterator->m_mime == wildString &&
1136 serviceInfo.m_mime != nullString) ||
1137 // check iterator mime is "*/*" case
1138 (serviceInfo.m_mime == wildString &&
1139 iterator->m_mime != nullString)))
1141 ThrowMsg(Exception::ParseError,
1142 "service operation is duplicated " +
1143 DPL::ToUTF8String(*m_operation));
1146 m_data.appServiceList.push_back(serviceInfo);
1149 AppServiceParser(ConfigParserData& data) :
1151 m_src(DPL::OptionalString::Null),
1152 m_operation(DPL::OptionalString::Null),
1153 m_scheme(DPL::OptionalString::Null),
1154 m_mime(DPL::OptionalString::Null),
1160 DPL::OptionalString m_src;
1161 DPL::OptionalString m_operation;
1162 DPL::OptionalString m_scheme;
1163 DPL::OptionalString m_mime;
1164 ConfigParserData& m_data;
1167 class AppControlParser : public ElementParser
1170 struct SourceParser : public ElementParser
1173 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
1174 const DPL::String& /*name*/)
1176 return &IgnoringParser::Create;
1179 virtual void Accept(const Text& /*text*/)
1183 virtual void Accept(const Element& /*element*/)
1187 virtual void Accept(const XmlAttribute& attribute)
1189 if (attribute.name == L"name") {
1190 if (attribute.value.size() > 0) {
1191 m_value = attribute.value;
1192 NormalizeString(m_value);
1197 virtual void Verify()
1199 if (m_value.IsNull() || *m_value== L"") {
1203 m_data.m_src = *m_value;
1206 SourceParser(ConfigParserData::AppControlInfo& data) :
1208 m_properNamespace(false),
1214 bool m_properNamespace;
1215 DPL::OptionalString m_value;
1216 ConfigParserData::AppControlInfo& m_data;
1219 struct OperationParser : public ElementParser
1222 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
1223 const DPL::String& /*name*/)
1225 return &IgnoringParser::Create;
1228 virtual void Accept(const Text& /*text*/)
1232 virtual void Accept(const Element& /*element*/)
1236 virtual void Accept(const XmlAttribute& attribute)
1238 if (attribute.name == L"name") {
1239 if (attribute.value.size() > 0) {
1240 m_value = attribute.value;
1241 NormalizeString(m_value);
1246 virtual void Verify()
1248 if (m_value.IsNull() || *m_value== L"") {
1252 m_data.m_operation = *m_value;
1255 OperationParser(ConfigParserData::AppControlInfo& data) :
1257 m_properNamespace(false),
1263 bool m_properNamespace;
1264 DPL::OptionalString m_value;
1265 ConfigParserData::AppControlInfo& m_data;
1268 struct UriParser : public ElementParser
1271 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
1272 const DPL::String& /*name*/)
1274 return &IgnoringParser::Create;
1277 virtual void Accept(const Text& /*text*/)
1281 virtual void Accept(const Element& /*element*/)
1285 virtual void Accept(const XmlAttribute& attribute)
1287 if (attribute.name == L"name") {
1288 if (attribute.value.size() > 0) {
1289 m_value = attribute.value;
1290 NormalizeString(m_value);
1295 virtual void Verify()
1297 if (m_value.IsNull() || *m_value == L"") {
1301 DPL::String wildString(L"*/*");
1302 if ((m_data.m_uriList.find(wildString) ==
1303 m_data.m_uriList.end())
1304 && (m_data.m_uriList.find(*m_value) ==
1305 m_data.m_uriList.end())) {
1307 m_data.m_uriList.insert(*m_value);
1309 LogDebug("Ignoring uri with name" <<
1310 DPL::ToUTF8String(*m_value));
1314 UriParser(ConfigParserData::AppControlInfo& data) :
1316 m_properNamespace(false),
1322 bool m_properNamespace;
1323 DPL::OptionalString m_value;
1324 ConfigParserData::AppControlInfo& m_data;
1327 struct MimeParser : public ElementParser
1330 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
1331 const DPL::String& /*name*/)
1333 return &IgnoringParser::Create;
1336 virtual void Accept(const Text& /*text*/)
1340 virtual void Accept(const Element& /*element*/)
1344 virtual void Accept(const XmlAttribute& attribute)
1346 if (attribute.name == L"name") {
1347 if (attribute.value.size() > 0) {
1348 m_value = attribute.value;
1349 NormalizeString(m_value);
1354 virtual void Verify()
1356 if (m_value.IsNull() || *m_value == L"") {
1360 DPL::String wildString(L"*/*");
1361 if ((m_data.m_mimeList.find(wildString) ==
1362 m_data.m_mimeList.end())
1363 && (m_data.m_mimeList.find(*m_value) ==
1364 m_data.m_mimeList.end())) {
1365 m_data.m_mimeList.insert(*m_value);
1367 LogDebug("Ignoring mime with name" <<
1368 DPL::ToUTF8String(*m_value));
1372 MimeParser(ConfigParserData::AppControlInfo& data) :
1374 m_properNamespace(false),
1380 bool m_properNamespace;
1381 DPL::OptionalString m_value;
1382 ConfigParserData::AppControlInfo& m_data;
1385 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
1386 const DPL::String& name)
1388 if (name == L"src") {
1389 return DPL::MakeDelegate(this, &AppControlParser::OnSourceElement);
1390 } else if (name == L"operation") {
1391 return DPL::MakeDelegate(this, &AppControlParser::OnOperationElement);
1392 } else if (name == L"uri") {
1393 return DPL::MakeDelegate(this, &AppControlParser::OnUriElement);
1394 } else if (name == L"mime") {
1395 return DPL::MakeDelegate(this, &AppControlParser::OnMimeElement);
1397 return &IgnoringParser::Create;
1401 virtual void Accept(const XmlAttribute& attribute)
1405 virtual void Accept(const Element& element)
1407 LogWarning("namespace for app service = " << element.ns);
1408 if (element.ns == ConfigurationNamespace::W3CWidgetNamespaceName) {
1409 ThrowMsg(Exception::ParseError,
1410 "Wrong xml namespace for widget element");
1414 virtual void Accept(const Text& /*text*/)
1416 ThrowMsg(Exception::ParseError, "param element must be empty");
1419 virtual void Verify()
1421 if (m_appControl.m_src == L""){
1422 LogWarning("service element must have src element");
1426 if (m_appControl.m_operation == L""){
1427 LogWarning("service element must have operation element");
1431 FOREACH(iterator, m_data.appControlList) {
1432 if (iterator->m_src == m_appControl.m_src &&
1433 iterator->m_operation == m_appControl.m_operation )
1435 ThrowMsg(Exception::ParseError,
1436 "app control element is duplicated " +
1437 DPL::ToUTF8String(m_appControl.m_src) + ", " +
1438 DPL::ToUTF8String(m_appControl.m_operation));
1441 m_data.appControlList.push_back(m_appControl);
1444 ElementParserPtr OnSourceElement()
1446 return ElementParserPtr(new SourceParser(m_appControl));
1449 ElementParserPtr OnOperationElement()
1451 return ElementParserPtr(new OperationParser(m_appControl));
1454 ElementParserPtr OnUriElement()
1456 return ElementParserPtr(new UriParser(m_appControl));
1459 ElementParserPtr OnMimeElement()
1461 return ElementParserPtr(new MimeParser(m_appControl));
1464 AppControlParser(ConfigParserData& data) :
1472 ConfigParserData& m_data;
1473 ConfigParserData::AppControlInfo m_appControl;
1476 class ApplicationParser : public ElementParser
1479 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
1480 const DPL::String& /*name*/)
1482 return &IgnoringParser::Create;
1485 virtual void Accept(const Text& text)
1487 if (m_properNamespace) {
1489 ThrowMsg(Exception::ParseError, "application element must be empty");
1493 virtual void Accept(const Element& element)
1496 ConfigurationNamespace::TizenWebAppNamespaceName)
1498 m_properNamespace = true;
1500 LogDebug("element");
1503 virtual void Accept(const XmlAttribute& attribute)
1505 if (m_properNamespace) {
1506 LogDebug("attribute");
1507 if (attribute.name == L"id") {
1508 m_id = attribute.value;
1509 NormalizeAndTrimSpaceString(m_id);
1510 } else if (attribute.name == L"package") {
1511 m_package = attribute.value;
1512 } else if (attribute.name == L"required_version") {
1513 m_version = attribute.value;
1514 NormalizeString(m_version);
1516 ThrowMsg(Exception::ParseError,
1517 "unknown attribute '" +
1518 DPL::ToUTF8String(attribute.name) +
1519 "' in application element");
1524 virtual void Verify()
1527 ThrowMsg(Exception::ParseError,
1528 "application element must have id attribute");
1532 m_data.tizenPkgId = m_package;
1536 ThrowMsg(Exception::ParseError,
1537 "application element must have required_version attribute");
1540 //TODO check if id and version format is right
1541 m_data.tizenAppId = m_id;
1542 m_data.tizenMinVersionRequired = m_version;
1545 ApplicationParser(ConfigParserData& data) :
1548 m_id(DPL::OptionalString::Null),
1549 m_version(DPL::OptionalString::Null),
1550 m_properNamespace(false)
1555 ConfigParserData& m_data;
1556 DPL::OptionalString m_id;
1557 DPL::OptionalString m_package;
1558 DPL::OptionalString m_version;
1559 bool m_properNamespace;
1562 class SplashParser : public ElementParser
1565 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
1566 const DPL::String& /*name*/)
1568 return &IgnoringParser::Create;
1571 virtual void Accept(const XmlAttribute& attribute)
1573 if (attribute.name == L"src") {
1574 if (attribute.value.size() > 0) {
1575 m_src = attribute.value;
1580 virtual void Accept(const Element& element)
1584 virtual void Accept(const Text& /*text*/)
1588 virtual void Verify()
1590 if (m_src.IsNull()) {
1591 LogWarning("src attribute of splash element is mandatory - ignoring");
1595 m_data.splashImgSrc = m_src;
1598 SplashParser(ConfigParserData& data) :
1605 DPL::OptionalString m_src;
1606 ConfigParserData& m_data;
1609 class BackgroundParser : public ElementParser
1612 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
1613 const DPL::String& /*name*/)
1615 return &IgnoringParser::Create;
1618 virtual void Accept(const XmlAttribute& attribute)
1620 if (attribute.name == L"src") {
1621 if (attribute.value.size() > 0) {
1622 m_src = attribute.value;
1627 virtual void Accept(const Element& /*element*/)
1631 virtual void Accept(const Text& /*text*/)
1635 virtual void Verify()
1637 if (m_src.IsNull()) {
1638 LogWarning("src attribute of background element is mandatory - ignoring");
1642 m_data.backgroundPage = m_src;
1645 explicit BackgroundParser(ConfigParserData& data) :
1651 DPL::OptionalString m_src;
1652 ConfigParserData& m_data;
1655 class PrivilegeParser : public ElementParser
1658 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
1659 const DPL::String& name)
1661 return &IgnoringParser::Create;
1664 virtual void Accept(const Text& /*text*/)
1668 virtual void Accept(const Element& element)
1671 ConfigurationNamespace::TizenWebAppNamespaceName)
1673 m_properNamespace = true;
1675 LogDebug("element");
1678 virtual void Accept(const XmlAttribute& attribute)
1680 if (m_properNamespace) {
1681 if (attribute.name == L"name") {
1682 m_feature.name = attribute.value;
1683 m_privilege.name = attribute.value;
1686 m_feature.required = false;
1689 virtual void Verify()
1691 LibIri::Wrapper iri(DPL::ToUTF8String(m_feature.name).c_str());
1693 if (m_feature.name != L"") {
1694 if (iri.Validate()) {
1695 if (m_data.featuresList.find(m_feature) ==
1696 m_data.featuresList.end()) {
1697 m_data.featuresList.insert(m_feature);
1699 LogDebug("Ignoring feature with name" <<
1700 DPL::ToUTF8String(m_feature.name));
1705 LibIri::Wrapper iriPrivilege(
1706 DPL::ToUTF8String(m_privilege.name).c_str());
1708 if (m_privilege.name != L"") {
1709 if (iriPrivilege.Validate()) {
1710 if (m_data.privilegeList.find(m_privilege) ==
1711 m_data.privilegeList.end()) {
1712 m_data.privilegeList.insert(m_privilege);
1714 LogDebug("Ignoring privilege with name" <<
1715 DPL::ToUTF8String(m_privilege.name));
1721 PrivilegeParser(ConfigParserData& data) :
1726 m_properNamespace(false)
1731 ConfigParserData& m_data;
1732 ConfigParserData::Feature m_feature;
1733 ConfigParserData::Privilege m_privilege;
1734 bool m_properNamespace;
1737 class CategoryParser : public ElementParser
1740 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
1741 const DPL::String& /*name*/)
1743 return &IgnoringParser::Create;
1746 virtual void Accept(const XmlAttribute& attribute)
1748 if (attribute.name == L"name") {
1749 if (attribute.value.size() > 0) {
1750 m_name = attribute.value;
1755 virtual void Accept(const Element& /*element*/)
1759 virtual void Accept(const Text& /*text*/)
1763 virtual void Verify()
1765 if (m_name.IsNull()) {
1766 LogWarning("name attribute of category element is mandatory - ignoring");
1770 if (m_data.categoryList.find(*m_name) ==
1771 m_data.categoryList.end()) {
1772 m_data.categoryList.insert(*m_name);
1776 explicit CategoryParser(ConfigParserData& data) :
1782 DPL::OptionalString m_name;
1783 ConfigParserData& m_data;
1786 class LiveboxParser : public ElementParser
1790 struct BoxLabelParser : public ElementParser
1792 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
1793 const DPL::String& /*name*/)
1795 return &IgnoringParser::Create;
1798 virtual void Accept(const XmlAttribute& attribute)
1802 virtual void Accept(const Element& element)
1805 ConfigurationNamespace::TizenWebAppNamespaceName)
1807 m_properNamespace = true;
1811 virtual void Accept(const Text& text)
1813 if(m_properNamespace)
1814 m_label = text.value;
1817 virtual void Verify()
1819 m_data.m_label = m_label;
1822 BoxLabelParser(ConfigParserData::LiveboxInfo& data) :
1824 m_properNamespace(false),
1830 DPL::String m_label;
1831 bool m_properNamespace;
1832 ConfigParserData::LiveboxInfo& m_data;
1835 struct BoxIconParser : public ElementParser
1837 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
1838 const DPL::String& /*name*/)
1840 return &IgnoringParser::Create;
1843 virtual void Accept(const XmlAttribute& attribute)
1845 if(m_properNamespace) {
1846 if (attribute.name == L"src") {
1847 m_icon = attribute.value;
1852 virtual void Accept(const Element& element)
1855 ConfigurationNamespace::TizenWebAppNamespaceName)
1857 m_properNamespace = true;
1861 virtual void Accept(const Text& /*text*/)
1865 virtual void Verify()
1867 m_data.m_icon = m_icon;
1870 explicit BoxIconParser(ConfigParserData::LiveboxInfo& data) :
1872 m_properNamespace(false),
1879 bool m_properNamespace;
1880 ConfigParserData::LiveboxInfo& m_data;
1883 struct BoxContentParser : public ElementParser
1885 struct BoxSizeParser : public ElementParser
1887 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
1888 const DPL::String& /*name*/)
1890 return &IgnoringParser::Create;
1893 virtual void Accept(const XmlAttribute& attribute)
1895 if(m_properNamespace) {
1896 if (attribute.name == L"preview") {
1897 m_preview = attribute.value;
1902 virtual void Accept(const Element& element)
1905 ConfigurationNamespace::TizenWebAppNamespaceName)
1907 m_properNamespace = true;
1911 virtual void Accept(const Text& text)
1913 if(m_properNamespace)
1914 m_size = text.value;
1917 virtual void Verify()
1919 std::pair<DPL::String, DPL::String> boxSize;
1920 boxSize.first = m_size;
1921 boxSize.second = m_preview;
1922 m_data.m_boxSize.push_back(boxSize);
1925 explicit BoxSizeParser(ConfigParserData::LiveboxInfo::BoxContentInfo& data) :
1933 DPL::String m_preview;
1934 bool m_properNamespace;
1935 ConfigParserData::LiveboxInfo::BoxContentInfo& m_data;
1938 struct PdParser : public ElementParser
1940 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
1941 const DPL::String& name)
1943 return &IgnoringParser::Create;
1946 virtual void Accept(const XmlAttribute& attribute)
1948 if(m_properNamespace) {
1949 if (attribute.name == L"src") {
1950 m_src = attribute.value;
1951 } else if (attribute.name == L"width") {
1952 m_width = attribute.value;
1953 } else if (attribute.name == L"height") {
1954 m_height = attribute.value;
1959 virtual void Accept(const Element& element)
1962 ConfigurationNamespace::TizenWebAppNamespaceName)
1964 m_properNamespace = true;
1968 virtual void Accept(const Text& /*text*/)
1972 virtual void Verify()
1974 m_data.m_pdSrc = m_src;
1975 m_data.m_pdWidth = m_width;
1976 m_data.m_pdHeight = m_height;
1979 explicit PdParser(ConfigParserData::LiveboxInfo::BoxContentInfo& data) :
1981 m_properNamespace(false),
1988 DPL::String m_width;
1989 DPL::String m_height;
1991 bool m_properNamespace;
1992 ConfigParserData::LiveboxInfo::BoxContentInfo& m_data;
1995 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
1996 const DPL::String& name)
1998 if (name == L"box-size") {
1999 return DPL::MakeDelegate(this, &LiveboxParser::BoxContentParser::OnBoxSizeElement);
2000 } else if (name == L"pd") {
2001 return DPL::MakeDelegate(this, &LiveboxParser::BoxContentParser::OnPdElement);
2003 ThrowMsg(Exception::ParseError, "No element parser for name: " << name);
2007 virtual void Accept(const XmlAttribute& attribute)
2009 if (m_properNamespace) {
2010 if (attribute.name == L"src")
2011 m_box.m_boxSrc = attribute.value;
2012 if (attribute.name == L"mouse-event")
2013 m_box.m_boxMouseEvent = attribute.value;
2017 virtual void Accept(const Element& element)
2020 ConfigurationNamespace::TizenWebAppNamespaceName)
2022 m_properNamespace = true;
2026 virtual void Accept(const Text& /*text*/)
2030 virtual void Verify()
2032 m_data.m_boxInfo = m_box;
2035 explicit BoxContentParser(ConfigParserData::LiveboxInfo& data) :
2037 m_properNamespace(false),
2042 ElementParserPtr OnBoxSizeElement()
2044 return ElementParserPtr(new BoxSizeParser(m_box));
2047 ElementParserPtr OnPdElement()
2049 return ElementParserPtr(new PdParser(m_box));
2054 bool m_properNamespace;
2055 ConfigParserData::LiveboxInfo& m_data;
2056 ConfigParserData::LiveboxInfo::BoxContentInfo m_box;
2059 virtual ActionFunc GetElementParser(const DPL::String& /*ns*/,
2060 const DPL::String& name)
2062 if (name == L"box-label") {
2063 return DPL::MakeDelegate(this, &LiveboxParser::OnBoxLabelElement);
2064 } else if (name == L"box-icon") {
2065 return DPL::MakeDelegate(this, &LiveboxParser::OnBoxIconElement);
2066 } else if (name == L"box-content") {
2067 return DPL::MakeDelegate(this, &LiveboxParser::OnBoxContentElement);
2069 return &IgnoringParser::Create;
2073 virtual void Accept(const XmlAttribute& attribute)
2075 if (m_properNamespace) {
2076 if (attribute.name == L"id") {
2077 m_liveboxId = attribute.value;
2078 } else if (attribute.name == L"primary") {
2079 m_primary = attribute.value;
2080 } else if (attribute.name == L"auto-launch") {
2081 m_autoLaunch = attribute.value;
2082 } else if (attribute.name == L"update-period") {
2083 m_updatePeriod = attribute.value;
2084 } else if (attribute.name == L"type") {
2085 m_type = attribute.value;
2090 virtual void Accept(const Element& element)
2093 ConfigurationNamespace::TizenWebAppNamespaceName)
2095 m_properNamespace = true;
2099 virtual void Accept(const Text& /*text*/)
2103 virtual void Verify()
2105 m_livebox.m_liveboxId = m_liveboxId;
2106 m_livebox.m_primary = m_primary;
2107 m_livebox.m_autoLaunch = m_autoLaunch;
2108 m_livebox.m_updatePeriod = m_updatePeriod;
2109 m_livebox.m_type = m_type;
2111 m_data.m_livebox.push_back(m_livebox);
2114 explicit LiveboxParser(ConfigParserData& data) :
2117 m_properNamespace(false)
2119 m_livebox = ConfigParserData::LiveboxInfo();
2122 ElementParserPtr OnBoxLabelElement()
2124 return ElementParserPtr(new BoxLabelParser(m_livebox));
2127 ElementParserPtr OnBoxIconElement()
2129 return ElementParserPtr(new BoxIconParser(m_livebox));
2132 ElementParserPtr OnBoxContentElement()
2134 return ElementParserPtr(new BoxContentParser(m_livebox));
2138 ConfigParserData& m_data;
2139 ConfigParserData::LiveboxInfo m_livebox;
2140 DPL::String m_liveboxId;
2141 DPL::String m_primary;
2142 DPL::String m_autoLaunch;
2143 DPL::String m_updatePeriod;
2145 bool m_properNamespace;
2149 ElementParser::ActionFunc WidgetParser::GetElementParser(const DPL::String& /*ns*/,
2150 const DPL::String& name)
2152 FuncMap::const_iterator it = m_map.find(name);
2153 if (it != m_map.end()) {
2156 return &IgnoringParser::Create;
2160 WidgetParser::WidgetParser(ConfigParserData& data) :
2162 m_textDirection(Unicode::EMPTY)
2164 m_map[L"name"] = DPL::MakeDelegate(this, &WidgetParser::OnNameElement);
2165 m_map[L"access"] = DPL::MakeDelegate(this, &WidgetParser::OnAccessElement);
2166 m_map[L"description"] =
2167 DPL::MakeDelegate(this, &WidgetParser::OnDescriptionElement);
2168 m_map[L"author"] = DPL::MakeDelegate(this, &WidgetParser::OnAuthorElement);
2170 DPL::MakeDelegate(this, &WidgetParser::OnLicenseElement);
2171 m_map[L"icon"] = DPL::MakeDelegate(this, &WidgetParser::OnIconElement);
2173 DPL::MakeDelegate(this, &WidgetParser::OnContentElement);
2175 DPL::MakeDelegate(this, &WidgetParser::OnFeatureElement);
2176 m_map[L"preference"] =
2177 DPL::MakeDelegate(this, &WidgetParser::OnPreferenceElement);
2178 m_map[L"link"] = DPL::MakeDelegate(this, &WidgetParser::OnLinkElement);
2180 DPL::MakeDelegate(this, &WidgetParser::OnSettingElement);
2181 // TODO: appservice will be removed
2182 m_map[L"appservice"] = DPL::MakeDelegate(this, &WidgetParser::OnAppServiceElement);
2183 m_map[L"application"] = DPL::MakeDelegate(this, &WidgetParser::OnApplicationElement);
2184 m_map[L"splash"] = DPL::MakeDelegate(this, &WidgetParser::OnSplashElement);
2185 m_map[L"background"] = DPL::MakeDelegate(this, &WidgetParser::OnBackgroundElement);
2186 m_map[L"privilege"] = DPL::MakeDelegate(this, &WidgetParser::OnPrivilegeElement);
2187 m_map[L"app-control"] = DPL::MakeDelegate(this,
2188 &WidgetParser::OnAppControlElement);
2189 m_map[L"category"] = DPL::MakeDelegate(this,
2190 &WidgetParser::OnCategoryElement);
2191 m_map[L"livebox"] = DPL::MakeDelegate(this, &WidgetParser::OnLiveboxElement);
2195 ElementParserPtr WidgetParser::OnNameElement()
2197 return ElementParserPtr(new NameParser(m_textDirection, m_data));
2200 ElementParserPtr WidgetParser::OnAccessElement()
2202 return ElementParserPtr(new AccessParser(m_data));
2205 ElementParserPtr WidgetParser::OnDescriptionElement()
2207 return ElementParserPtr(new DescriptionParser(m_textDirection, m_data));
2210 ElementParserPtr WidgetParser::OnAuthorElement()
2212 return ElementParserPtr(new AuthorParser(m_textDirection, m_data));
2215 ElementParserPtr WidgetParser::OnLicenseElement()
2217 return ElementParserPtr(new LicenseParser(m_textDirection, m_data));
2220 ElementParserPtr WidgetParser::OnIconElement()
2222 return ElementParserPtr(new IconParser(m_data));
2225 ElementParserPtr WidgetParser::OnContentElement()
2227 return ElementParserPtr(new ContentParser(m_data));
2230 ElementParserPtr WidgetParser::OnFeatureElement()
2232 return ElementParserPtr(new FeatureParser(m_data));
2235 ElementParserPtr WidgetParser::OnPreferenceElement()
2237 return ElementParserPtr(new PreferenceParser(m_data));
2240 ElementParserPtr WidgetParser::OnLinkElement()
2242 return ElementParserPtr(new LinkParser(m_data));
2245 ElementParserPtr WidgetParser::OnSettingElement()
2247 return ElementParserPtr(new SettingParser(m_data));
2250 ElementParserPtr WidgetParser::OnApplicationElement()
2252 return ElementParserPtr(new ApplicationParser(m_data));
2255 ElementParserPtr WidgetParser::OnSplashElement()
2257 return ElementParserPtr(new SplashParser(m_data));
2260 ElementParserPtr WidgetParser::OnBackgroundElement()
2262 return ElementParserPtr(new BackgroundParser(m_data));
2265 ElementParserPtr WidgetParser::OnPrivilegeElement()
2267 return ElementParserPtr(new PrivilegeParser(m_data));
2270 ElementParserPtr WidgetParser::OnAppServiceElement()
2272 return ElementParserPtr(new AppServiceParser(m_data));
2275 ElementParserPtr WidgetParser::OnAppControlElement()
2277 return ElementParserPtr(new AppControlParser(m_data));
2280 ElementParserPtr WidgetParser::OnCategoryElement()
2282 return ElementParserPtr(new CategoryParser(m_data));
2285 ElementParserPtr WidgetParser::OnLiveboxElement()
2287 return ElementParserPtr(new LiveboxParser(m_data));
2290 void WidgetParser::Accept(const Element& element)
2292 if (element.ns != ConfigurationNamespace::W3CWidgetNamespaceName &&
2293 element.ns != ConfigurationNamespace::TizenWebAppNamespaceName)
2295 ThrowMsg(Exception::ParseError,
2296 "Wrong xml namespace for widget element");
2300 void WidgetParser::Accept(const Text& /*text*/)
2302 ThrowMsg(Exception::ParseError, "widged element must be empty");
2305 void WidgetParser::Accept(const XmlAttribute& attribute)
2307 if (attribute.name == L"id") {
2308 LibIri::Wrapper iri(DPL::ToUTF8String(attribute.value).c_str());
2309 //If may important tests starts to fail this test we will have
2310 //to consider commenting this test out again.
2311 if (iri.Validate()) {
2312 m_data.widget_id = attribute.value;
2313 NormalizeString(m_data.widget_id);
2315 LogWarning("Widget id validation failed: " << attribute.value);
2317 } else if (attribute.name == L"version") {
2318 m_version = attribute.value;
2319 NormalizeString(m_version);
2320 } else if (attribute.name == L"min-version") {
2321 LogInfo("min-version attribute was found. Value: " << attribute.value);
2322 m_minVersion = attribute.value;
2323 NormalizeString(m_minVersion);
2324 m_data.minVersionRequired = m_minVersion;
2325 } else if (attribute.name == L"height") {
2326 DPL::OptionalString value = attribute.value;
2327 NormalizeString(value);
2328 std::string v = DPL::ToUTF8String(*value);
2331 unsigned char c = v.c_str()[0];
2332 if (c >= '0' && c <= '9') {
2334 for (size_t i = 0; i < v.size(); ++i) {
2336 if (c >= '0' && c <= '9') {
2343 m_data.height = val;
2346 } else if (attribute.name == L"width") {
2347 DPL::OptionalString value = attribute.value;
2348 NormalizeString(value);
2349 std::string v = DPL::ToUTF8String(*value);
2352 unsigned char c = v.c_str()[0];
2353 if (c >= '0' && c <= '9') {
2355 for (size_t i = 0; i < v.size(); ++i) {
2357 if (c >= '0' && c <= '9') {
2367 } else if (attribute.name == L"viewmodes") {
2368 DPL::Tokenize(attribute.value,
2370 std::inserter(m_windowModes,
2371 m_windowModes.end()),
2373 } else if (attribute.name == L"dir") {
2374 m_textDirection = Unicode::ParseDirAttribute(attribute);
2375 } else if (L"defaultlocale" == attribute.name) {
2376 if (!m_defaultlocale) {
2377 m_defaultlocale = attribute.value;
2378 NormalizeString(m_defaultlocale);
2379 if (!LanguageSubtagRstTreeSingleton::Instance().ValidateLanguageTag(
2380 DPL::ToUTF8String(*m_defaultlocale))) {
2381 LogWarning("Language tag: " <<
2382 m_defaultlocale << " is not valid");
2383 m_defaultlocale = DPL::OptionalString::Null;
2386 LogDebug("Default Locale Found " << m_defaultlocale);
2388 LogWarning("Ignoring subsequent default locale");
2391 //Any other value consider as a namespace definition
2392 } else if (attribute.name == L"xmlns" || attribute.prefix == L"xmlns") {
2393 LogInfo("Namespace domain: " << attribute.name);
2394 LogInfo("Namespace value: " << attribute.value);
2395 m_nameSpaces[attribute.name] = attribute.value;
2397 LogError("Unknown attirbute: namespace=" << attribute.ns <<
2398 ", name=" << attribute.name <<
2399 ", value=" << attribute.value);
2403 void WidgetParser::Verify()
2405 FOREACH(mode, m_windowModes) {
2406 if (L"windowed" == *mode || L"floating" == *mode ||
2407 L"fullscreen" == *mode || L"maximized" == *mode ||
2408 L"minimized" == *mode) {
2409 m_data.windowModes.insert(*mode);
2412 if (!m_version.IsNull()) {
2413 Unicode::UpdateTextWithDirectionMark(m_textDirection, &*m_version);
2414 m_data.version = m_version;
2416 m_data.defaultlocale = m_defaultlocale;
2417 FOREACH(ns, m_nameSpaces) {
2418 m_data.nameSpaces.insert(ns->second);