src/modules/tizen/DEPRACATED/Gallery/Gallery.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        Gallery.cpp
  18  * @author      Wojciech Bielawski (w.bielawski@samsung.com)
  19  * @version     0.1
  20  */
  21
  22 #include <algorithm>
  23 #include <commons/Exception.h>
  24 #include <API/Filesystem/INode.h>
  25 #include <API/Filesystem/Enums.h>
  26 #include "Gallery.h"
  27
  28 using namespace std;
  29 using namespace DPL;
  30 using namespace WrtPlugins::Api::Gallery;
  31 using namespace WrtPlugins::Api::Filesystem;
  32
  33 namespace WrtPlugins {
  34 namespace Platform {
  35 using namespace Filesystem;
  36
  37 namespace {
  38 //Map file extension to IMediaItem type
  39 map<string, IMediaItem::MediaType> &createExtToTypeMap()
  40 {
  41     static map<string, IMediaItem::MediaType> retMap;
  42     retMap["jpg"] = IMediaItem::IMAGE;
  43     retMap["jpeg"] = IMediaItem::IMAGE;
  44     retMap["gif"] = IMediaItem::IMAGE;
  45     retMap["bmp"] = IMediaItem::IMAGE;
  46     retMap["png"] = IMediaItem::IMAGE;
  47     retMap["wav"] = IMediaItem::AUDIO;
  48     retMap["mp3"] = IMediaItem::AUDIO;
  49     retMap["wmv"] = IMediaItem::VIDEO;
  50     retMap["3gp"] = IMediaItem::VIDEO;
  51     return retMap;
  52 }
  53
  54 //Map file extension to MIME type
  55 map<string, string> &createExtToMimeMap()
  56 {
  57     static map<string, string> retMap;
  58     retMap["jpg"] = "image/jpeg";
  59     retMap["jpeg"] = "image/jpeg";
  60     retMap["gif"] = "image/gif";
  61     retMap["bmp"] = "image/bmp";
  62     retMap["png"] = "image/png";
  63     retMap["wav"] = "audio/wav";
  64     retMap["mp3"] = "audio/mpeg3";
  65     retMap["wmv"] = "video/x - ms - wmv";
  66     retMap["3gp"] = "video/3gpp";
  67     return retMap;
  68 }
  69
  70 bool compareByFilename(const IMediaItemPtr &lpm,
  71                        const IMediaItemPtr &rpm)
  72 {
  73     return lpm->getFileName().compare(rpm->getFileName()) < 0;
  74 }
  75
  76 bool compareByFileDate(const IMediaItemPtr &lpm,
  77                        const IMediaItemPtr &rpm)
  78 {
  79     return lpm->getDate() < rpm->getDate();
  80 }
  81
  82 bool compareByType(const IMediaItemPtr &lpm,
  83                    const IMediaItemPtr &rpm)
  84 {
  85     return lpm->getType() < rpm->getType();
  86 }
  87
  88 class SearchIdObj
  89 {
  90     unsigned long m_id;
  91
  92   public:
  93     SearchIdObj(unsigned long id) : m_id(id)
  94     {}
  95     bool operator ()(const IMediaItemPtr &elem)
  96     {
  97         return elem->getId() == m_id;
  98     }
  99 };
 100 } //private namespace
 101
 102 map<string,
 103     IMediaItem::MediaType> &Gallery::m_extensionToType = createExtToTypeMap();
 104 map<string, string> &Gallery::m_extensionToMime = createExtToMimeMap();
 105
 106 unsigned int Gallery::getNumberOfItems() const
 107 {
 108     if (!m_opened) {
 109         Throw(Commons::PlatformWrongStateException);
 110     }
 111     //if gallery is opened m_view always stores an object
 112     return m_view->size();
 113 }
 114
 115 std::string Gallery::getName() const
 116 {
 117     LogDebug("Gallery name: " << m_name);
 118     return m_name;
 119 }
 120
 121 void Gallery::open()
 122 {
 123     if (m_opened) {
 124         Throw(Commons::PlatformWrongStateException);
 125     }
 126     m_mediaItems.clear();
 127     m_lastId = 0;
 128     Path path("/");
 129     SharedPtr<INode> node(Node::resolve(path));
 130     node->setPermissions(PERM_READ);
 131     searchFiles(node);
 132     //Destroy previous view and store new one
 133     m_view = IMediaItemsSetPtr(new IMediaItemsSet(m_mediaItems));
 134     m_opened = true;
 135     LogDebug("Gallery contains " << m_mediaItems.size() << " items");
 136 }
 137
 138 void Gallery::searchFiles(const SharedPtr<INode> &node)
 139 {
 140     if (Api::Filesystem::NT_FILE == node->getType()) {
 141         string fileName = node->getPath().getName();
 142         size_t dotPos = fileName.find_last_of(".");
 143         if (dotPos == string::npos) {
 144             //Not supported file
 145             return;
 146         }
 147         string fileExt = fileName.substr(dotPos + 1);
 148         //Check if file has supported type
 149         map<string, string>::iterator it = m_extensionToMime.find(fileExt);
 150         if (it != m_extensionToMime.end()) {
 151             IMediaItemPtr mediaItem(new IMediaItem());
 152             mediaItem->setId(getFreeId());
 153             mediaItem->setFileName(fileName);
 154             mediaItem->setType(m_extensionToType[fileExt]);
 155             mediaItem->setMimeType(m_extensionToMime[fileExt]);
 156             mediaItem->setDate(node->getCreated());
 157             m_mediaItems.push_back(mediaItem);
 158         }
 159         return;
 160     }
 161
 162     //else get recurrent on NT_DIRECTORY
 163     NodeList nodes = node->getChildNodes();
 164     NodeList::iterator it = nodes.begin(), end = nodes.end();
 165     while (it != end) {
 166         //Warning: '*it' element will be deleted after out of scope (next
 167         // iteration)
 168         (*it)->setPermissions(PERM_READ);
 169         searchFiles(SharedPtr<INode>(*it));
 170         ++it;
 171     }
 172 }
 173
 174 unsigned long Gallery::getFreeId()
 175 {
 176     return ++m_lastId;
 177 }
 178
 179 bool Gallery::isOpen() const
 180 {
 181     return m_opened;
 182 }
 183
 184 void Gallery::close()
 185 {
 186     if (!m_opened) {
 187         Throw(Commons::PlatformWrongStateException);
 188     }
 189     m_mediaItems.clear();
 190     m_view.Reset();
 191     m_lastId = 0;
 192     m_opened = false;
 193 }
 194
 195 void Gallery::refresh()
 196 {
 197     if (!m_opened) {
 198         Throw(Commons::PlatformWrongStateException);
 199     }
 200     m_mediaItems.clear();
 201     m_view->clear();
 202     m_lastId = 0;
 203     Path path("/");
 204     SharedPtr<Node> node(Node::resolve(path));
 205     node->setPermissions(PERM_READ);
 206     searchFiles(DynamicPointerCast<INode>(node));
 207     changeView(m_viewProperties);
 208     LogDebug("Gallery contains " << m_mediaItems.size() << " items");
 209 }
 210
 211 void Gallery::changeView(const IViewProperties &props)
 212 {
 213     if (!m_opened) {
 214         Throw(Commons::PlatformWrongStateException);
 215     }
 216     m_viewProperties = props;
 217     m_view->clear();
 218
 219     //Copy elements within date period to view struct
 220     for (IMediaItemsSetIterator it = m_mediaItems.begin(),
 221          end = m_mediaItems.end();
 222          it != end; ++it)
 223     {
 224         if ((m_viewProperties.getStartDate() <= (*it)->getDate()) &&
 225             ((*it)->getDate() <= m_viewProperties.getEndDate()))
 226         {
 227             m_view->push_back(*it);
 228         }
 229     }
 230
 231     //sort elements
 232     IViewProperties::SortOrder sortOrder[] = {
 233         m_viewProperties.getSecondarySortOrder(),
 234         m_viewProperties.getPrimarySortOrder()
 235     };
 236     for (size_t i = 0; i < (sizeof(sortOrder) / sizeof(sortOrder[0])); ++i) {
 237         switch (sortOrder[i]) {
 238         case IViewProperties::BY_FILEDATE:
 239             m_view->sort(compareByFileDate);
 240             break;
 241         case IViewProperties::BY_FILENAME:
 242             m_view->sort(compareByFilename);
 243             break;
 244         case IViewProperties::BY_TYPE:
 245             m_view->sort(compareByType);
 246             break;
 247         default:
 248             break;
 249         }
 250     }
 251
 252     //reverse order if necessary
 253     if (IViewProperties::DESCENDING == m_viewProperties.getSortOrder()) {
 254         m_view->reverse();
 255     }
 256     LogDebug("View contains " << m_view->size() << " items");
 257 }
 258
 259 const IMediaItemsSetPtr Gallery::getMediaItems() const
 260 {
 261     if (!m_opened) {
 262         Throw(Commons::PlatformWrongStateException);
 263     }
 264     LogError("View contains " << m_view->size() << " entries");
 265     return m_view;
 266 }
 267
 268 const IMediaItemPtr Gallery::getMediaItemById(unsigned long id) const
 269 {
 270     if (!m_opened) {
 271         Throw(Commons::PlatformWrongStateException);
 272     }
 273     SearchIdObj searchObj(id);
 274     IMediaItemsSetConstIterator elem = find_if(
 275             m_mediaItems.begin(), m_mediaItems.end(), searchObj);
 276     if (elem == m_mediaItems.end()) {
 277         Throw(Commons::InvalidArgumentException);
 278     }
 279     return *elem;
 280 }
 281 }
 282 }