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   public:
  92     SearchIdObj(unsigned long id) : m_id(id)
  93     {
  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 iteration)
 167         (*it)->setPermissions(PERM_READ);
 168         searchFiles(SharedPtr<INode>(*it));
 169         ++it;
 170     }
 171 }
 172
 173 unsigned long Gallery::getFreeId()
 174 {
 175     return ++m_lastId;
 176 }
 177
 178 bool Gallery::isOpen() const
 179 {
 180     return m_opened;
 181 }
 182
 183 void Gallery::close()
 184 {
 185     if (!m_opened) {
 186         Throw(Commons::PlatformWrongStateException);
 187     }
 188     m_mediaItems.clear();
 189     m_view.Reset();
 190     m_lastId = 0;
 191     m_opened = false;
 192 }
 193
 194 void Gallery::refresh()
 195 {
 196     if (!m_opened) {
 197         Throw(Commons::PlatformWrongStateException);
 198     }
 199     m_mediaItems.clear();
 200     m_view->clear();
 201     m_lastId = 0;
 202     Path path("/");
 203     SharedPtr<Node> node(Node::resolve(path));
 204     node->setPermissions(PERM_READ);
 205     searchFiles(DynamicPointerCast<INode>(node));
 206     changeView(m_viewProperties);
 207     LogDebug("Gallery contains " << m_mediaItems.size() << " items");
 208 }
 209
 210 void Gallery::changeView(const IViewProperties &props)
 211 {
 212     if (!m_opened) {
 213         Throw(Commons::PlatformWrongStateException);
 214     }
 215     m_viewProperties = props;
 216     m_view->clear();
 217
 218     //Copy elements within date period to view struct
 219     for (IMediaItemsSetIterator it = m_mediaItems.begin(),
 220          end = m_mediaItems.end();
 221          it != end; ++it) {
 222         if ((m_viewProperties.getStartDate() <= (*it)->getDate()) &&
 223             ((*it)->getDate() <= m_viewProperties.getEndDate())) {
 224             m_view->push_back(*it);
 225         }
 226     }
 227
 228     //sort elements
 229     IViewProperties::SortOrder sortOrder[] = {
 230         m_viewProperties.getSecondarySortOrder(),
 231         m_viewProperties.getPrimarySortOrder()
 232     };
 233     for (size_t i = 0; i < (sizeof(sortOrder) / sizeof(sortOrder[0])); ++i) {
 234         switch (sortOrder[i]) {
 235         case IViewProperties::BY_FILEDATE:
 236             m_view->sort(compareByFileDate);
 237             break;
 238         case IViewProperties::BY_FILENAME:
 239             m_view->sort(compareByFilename);
 240             break;
 241         case IViewProperties::BY_TYPE:
 242             m_view->sort(compareByType);
 243             break;
 244         default:
 245             break;
 246         }
 247     }
 248
 249     //reverse order if necessary
 250     if (IViewProperties::DESCENDING == m_viewProperties.getSortOrder()) {
 251         m_view->reverse();
 252     }
 253     LogDebug("View contains " << m_view->size() << " items");
 254 }
 255
 256 const IMediaItemsSetPtr Gallery::getMediaItems() const
 257 {
 258     if (!m_opened) {
 259         Throw(Commons::PlatformWrongStateException);
 260     }
 261     LogError("View contains " << m_view->size() << " entries");
 262     return m_view;
 263 }
 264
 265 const IMediaItemPtr Gallery::getMediaItemById(unsigned long id) const
 266 {
 267     if (!m_opened) {
 268         Throw(Commons::PlatformWrongStateException);
 269     }
 270     SearchIdObj searchObj(id);
 271     IMediaItemsSetConstIterator elem = find_if(
 272             m_mediaItems.begin(), m_mediaItems.end(), searchObj);
 273     if (elem == m_mediaItems.end()) {
 274         Throw(Commons::InvalidArgumentException);
 275     }
 276     return *elem;
 277 }
 278 }
 279 }