modules/localization/src/w3c_file_localization.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   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
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16 /*
  17  * @file    w3c_file_localization.cpp
  18  * @author  Lukasz Wrzosek (l.wrzosek@samsung.com)
  19  * @version 1.0
  20  */
  21
  22 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include <unistd.h>
  25 #include <assert.h>
  26
  27 #include <dpl/localization/w3c_file_localization.h>
  28
  29 #include <dpl/wrt-dao-ro/widget_dao_read_only.h>
  30 #include <dpl/localization/localization_utils.h>
  31
  32 #include <dpl/log/log.h>
  33 #include <dpl/string.h>
  34 #include <dpl/optional.h>
  35 #include <dpl/foreach.h>
  36
  37 #include <LanguageTagsProvider.h>
  38
  39 using namespace WrtDB;
  40
  41 namespace {
  42 const DPL::String FILE_URI_BEGIN = L"file://";
  43 const DPL::String WIDGET_URI_BEGIN = L"widget://";
  44 const DPL::String LOCALE_PREFIX = L"locales/";
  45
  46 DPL::Optional<std::string> GetFilePathInWidgetPackageInternal(
  47         const std::string& basePath,
  48         std::string filePath)
  49 {
  50     LogDebug("Looking for file: " << filePath << "  in: " << basePath);
  51
  52     const LanguageTags& ltags = LanguageTagsProviderSingleton::Instance().getLanguageTags();
  53
  54     //Check if string isn't empty
  55     if (filePath.size() == 0) { return DPL::Optional<std::string>::Null; }
  56     //Removing preceding '/'
  57     if (filePath[0] == '/') { filePath.erase(0, 1); }
  58     // In some cases (start file localization) url has unnecessary "/" at the end
  59     if(filePath[filePath.size()-1] == '/') { filePath.erase(filePath.size()-1, 1); }
  60     //Check if string isn't empty
  61     if (filePath.size() == 0) { return DPL::Optional<std::string>::Null; }
  62
  63     LogDebug("locales size = " << ltags.size());
  64     for (LanguageTags::const_iterator it = ltags.begin();
  65             it != ltags.end();
  66             ++it) {
  67         LogDebug("Trying locale: " << *it);
  68         std::string path = basePath;
  69         if (path[path.size() - 1] == '/') {
  70             path.erase(path.size() - 1);
  71         }
  72
  73         if (it->empty()) {
  74             path += "/" + filePath;
  75         } else {
  76             path += "/locales/" + DPL::ToUTF8String(*it) + "/" + filePath;
  77         }
  78
  79         LogDebug("Trying locale: " << *it << " | " << path);
  80         struct stat buf;
  81         if (0 == stat(path.c_str(), &buf)) {
  82             if ((buf.st_mode & S_IFMT) == S_IFREG) {
  83                 path.erase(0, basePath.length());
  84                 return DPL::Optional<std::string>(path);
  85             }
  86         }
  87     }
  88
  89     return DPL::Optional<std::string>::Null;
  90 }
  91
  92 DPL::Optional<DPL::String> GetFilePathInWidgetPackageInternal(
  93         const DPL::String& basePath,
  94         const DPL::String& filePath)
  95 {
  96     DPL::Optional<std::string> path =
  97         GetFilePathInWidgetPackageInternal(DPL::ToUTF8String(basePath),
  98                                            DPL::ToUTF8String(filePath));
  99     DPL::Optional<DPL::String> dplPath;
 100     if (!!path) {
 101         dplPath = DPL::FromUTF8String(*path);
 102     }
 103     return dplPath;
 104 }
 105 }
 106
 107 namespace W3CFileLocalization {
 108 DPL::Optional<DPL::String> getFilePathInWidgetPackageFromUrl(
 109         DbWidgetHandle widgetHandle,
 110         const DPL::String &url)
 111 {
 112     DPL::String req = url;
 113     WidgetDAOReadOnly dao(widgetHandle);
 114
 115     if (req.find(WIDGET_URI_BEGIN) == 0) {
 116         req.erase(0, WIDGET_URI_BEGIN.length());
 117     } else if (req.find(FILE_URI_BEGIN) == 0) {
 118         req.erase(0, FILE_URI_BEGIN.length());
 119         if (req.find(dao.getPath()) == 0) {
 120             req.erase(0, dao.getPath().length());
 121         }
 122         if (req.find(LOCALE_PREFIX) == 0) {
 123             req.erase(0, LOCALE_PREFIX.length());
 124             int position = req.find('/');
 125             // should always be >0 as correct locales path is
 126             // always locales/xx/ or locales/xx-XX/
 127             if (position != std::string::npos && position > 0) {
 128                 req.erase(0, position+1);
 129             }
 130         }
 131     } else {
 132         LogDebug("Unknown path format, ignoring");
 133         return DPL::Optional<DPL::String>::Null;
 134     }
 135
 136     auto widgetPath = dao.getPath();
 137
 138     DPL::Optional<DPL::String> found =
 139         GetFilePathInWidgetPackageInternal(widgetPath, req);
 140
 141     if (!found) {
 142         LogError("Path not found within current locale in current widget");
 143         return DPL::Optional<DPL::String>::Null;
 144     }
 145
 146     found = widgetPath + *found;
 147
 148     return found;
 149 }
 150
 151 DPL::Optional<DPL::String> getFilePathInWidgetPackage(
 152         WrtDB::DbWidgetHandle widgetHandle,
 153         const DPL::String& file)
 154 {
 155     WidgetDAOReadOnly dao(widgetHandle);
 156     return GetFilePathInWidgetPackageInternal(dao.getPath(), file);
 157 }
 158
 159 DPL::OptionalString getStartFile(const WrtDB::DbWidgetHandle handle)
 160 {
 161     return getStartFile(WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(handle)));
 162 }
 163
 164 DPL::OptionalString getStartFile(WrtDB::WidgetDAOReadOnlyPtr dao)
 165 {
 166     WidgetDAOReadOnly::LocalizedStartFileList locList = dao->getLocalizedStartFileList();
 167     WidgetDAOReadOnly::WidgetStartFileList list = dao->getStartFileList();
 168     LanguageTags tagsList = LanguageTagsProviderSingleton::Instance().getLanguageTags();
 169
 170     DPL::OptionalString defaultLoc = dao->getDefaultlocale();
 171     if (!!defaultLoc) {
 172         tagsList.push_back(*defaultLoc);
 173     }
 174
 175     FOREACH(tag, tagsList)
 176     {
 177         FOREACH(sFile, locList)
 178         {
 179             if (*tag == sFile->widgetLocale) {
 180                 FOREACH(it, list)
 181                 {
 182                     if (it->startFileId == sFile->startFileId) {
 183                         return it->src;
 184                     }
 185                 }
 186             }
 187         }
 188     }
 189
 190     return DPL::OptionalString::Null;
 191 }
 192
 193 OptionalWidgetIcon getIcon(const WrtDB::DbWidgetHandle widgetHandle)
 194 {
 195     WidgetDAOReadOnly dao(widgetHandle);
 196
 197     WidgetDAOReadOnly::WidgetLocalizedIconList locList = dao.getLocalizedIconList();
 198     WidgetDAOReadOnly::WidgetIconList list = dao.getIconList();
 199     LanguageTags tagsList = LanguageTagsProviderSingleton::Instance().getLanguageTags();
 200
 201     DPL::OptionalString defaultLoc = dao.getDefaultlocale();
 202     if (!!defaultLoc) {
 203         tagsList.push_back(*defaultLoc);
 204     }
 205
 206     FOREACH(tag, tagsList)
 207     {
 208         FOREACH(icon, locList)
 209         {
 210             if (*tag == icon->widgetLocale) {
 211                 FOREACH(it, list)
 212                 {
 213                     if (it->iconId == icon->iconId) {
 214                         WidgetIcon ret;
 215                         ret.src = it->iconSrc;
 216                         ret.width = it->iconWidth;
 217                         ret.height = it->iconHeight;
 218                         return ret;
 219                     }
 220                 }
 221             }
 222         }
 223     }
 224
 225     return OptionalWidgetIcon::Null;
 226 }
 227
 228 WidgetIconList getValidIconsList(
 229         WrtDB::DbWidgetHandle widgetHandle)
 230 {
 231     WidgetDAOReadOnly dao(widgetHandle);
 232     WidgetDAOReadOnly::WidgetIconList list = dao.getIconList();
 233
 234     WidgetIconList outlist;
 235
 236     FOREACH(it, list)
 237     {
 238         LogDebug(":" << it->iconSrc);
 239         if (!!getFilePathInWidgetPackage(widgetHandle,
 240                                          it->iconSrc))
 241         {
 242             WidgetIcon ret;
 243             ret.src = it->iconSrc;
 244             ret.width = it->iconWidth;
 245             ret.height = it->iconHeight;
 246             outlist.push_back(ret);
 247         }
 248     }
 249     return outlist;
 250 }
 251
 252 OptionalWidgetStartFileInfo getStartFileInfo(
 253         WrtDB::DbWidgetHandle widgetHandle)
 254 {
 255     WidgetStartFileInfo info;
 256
 257     WidgetDAOReadOnly dao(widgetHandle);
 258     WidgetDAOReadOnly::LocalizedStartFileList locList =
 259         dao.getLocalizedStartFileList();
 260     WidgetDAOReadOnly::WidgetStartFileList list = dao.getStartFileList();
 261     const LanguageTags tagsList = LanguageTagsProviderSingleton::Instance().getLanguageTags();
 262
 263     FOREACH(tag, tagsList)
 264     {
 265         FOREACH(sFile, locList)
 266         {
 267             if (*tag == sFile->widgetLocale) {
 268                 FOREACH(it, list)
 269                 {
 270                     if (it->startFileId ==
 271                         sFile->startFileId) {
 272                         info.file = it->src;
 273                         info.encoding = sFile->encoding;
 274                         info.type = sFile->type;
 275                         if (tag->empty()) {
 276                             info.localizedPath = it->src;
 277                         } else {
 278                             info.localizedPath = L"locales/" + *tag + L"/";
 279                             info.localizedPath += it->src;
 280                         }
 281                         return info;
 282                     }
 283                 }
 284             }
 285         }
 286     }
 287
 288     return OptionalWidgetStartFileInfo::Null;
 289 }
 290
 291 WidgetLocalizedInfo getLocalizedInfo(const WrtDB::DbWidgetHandle handle)
 292 {
 293     return getLocalizedInfo(WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(handle)));
 294 }
 295
 296 WidgetLocalizedInfo getLocalizedInfo(WidgetDAOReadOnlyPtr dao)
 297 {
 298     LanguageTags languages = LanguageTagsProviderSingleton::Instance().getLanguageTags();
 299     DPL::OptionalString dl = dao->getDefaultlocale();
 300     if (!!dl) {
 301         languages.push_back(*dl);
 302     }
 303
 304     WidgetLocalizedInfo result;
 305     FOREACH(i, languages)
 306     {
 307         WidgetLocalizedInfo languageResult = dao->getLocalizedInfo(*i);
 308
 309 #define OVERWRITE_IF_NULL(FIELD) if (!result.FIELD) { \
 310         result.FIELD = languageResult.FIELD; \
 311 }
 312
 313         OVERWRITE_IF_NULL(name);
 314         OVERWRITE_IF_NULL(shortName);
 315         OVERWRITE_IF_NULL(description);
 316         OVERWRITE_IF_NULL(license);
 317         OVERWRITE_IF_NULL(licenseHref);
 318
 319 #undef OVERWRITE_IF_NULL
 320     }
 321
 322     return result;
 323 }
 324 }