content/content_instance.h

   1 // Copyright (c) 2014 Intel Corporation. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_CONTENT_INSTANCE_H_
   6 #define CONTENT_CONTENT_INSTANCE_H_
   7
   8 #include <media_content.h>
   9
  10 #include <string>
  11 #include <algorithm>
  12 #include <vector>
  13
  14 #include "common/extension.h"
  15 #include "common/picojson.h"
  16 #include "tizen/tizen.h"
  17
  18 namespace picojson {
  19 class value;
  20 }
  21
  22 class ContentFolderList;
  23 class ContentItemList;
  24
  25 class ContentInstance : public common::Instance {
  26  public:
  27   ContentInstance();
  28   virtual ~ContentInstance();
  29
  30  private:
  31   // common::Instance implementation.
  32   virtual void HandleMessage(const char* msg);
  33   virtual void HandleSyncMessage(const char* msg);
  34
  35   void HandleGetDirectoriesRequest(const picojson::value& json);
  36   void HandleGetDirectoriesReply(const picojson::value& json,
  37     ContentFolderList *);
  38   void HandleFindRequest(const picojson::value& json);
  39   void HandleFindReply(const picojson::value& json, ContentItemList *);
  40   void HandleScanFileRequest(const picojson::value& json);
  41   void HandleScanFileReply(const picojson::value& json);
  42
  43   // Asynchronous message helpers
  44   void PostAsyncErrorReply(const picojson::value&, WebApiAPIErrors);
  45   void PostAsyncSuccessReply(const picojson::value&, picojson::value::object&);
  46   void PostAsyncSuccessReply(const picojson::value&, picojson::value&);
  47   void PostAsyncSuccessReply(const picojson::value&, WebApiAPIErrors);
  48   void PostAsyncSuccessReply(const picojson::value&);
  49
  50   // Tizen CAPI helpers
  51   static bool MediaFolderCallback(media_folder_h handle, void *user_data);
  52   static bool MediaInfoCallback(media_info_h handle, void *user_data);
  53   static void MediaContentChangeCallback(
  54       media_content_error_e error,
  55       int pid,
  56       media_content_db_update_item_type_e update_item,
  57       media_content_db_update_type_e update_type,
  58       media_content_type_e media_type,
  59       char* uuid,
  60       char* path,
  61       char* mime_type,
  62       void* user_data);
  63
  64   static unsigned m_instanceCount;
  65 };
  66
  67 class ContentFolder {
  68  public:
  69   void init(media_folder_h handle);
  70
  71   // Getters & Getters
  72   const std::string& id() const { return id_; }
  73   void setID(const std::string& id) { id_ = id; }
  74   const std::string& directoryURI() const { return directoryURI_; }
  75   void setDirectoryURI(const std::string& uri) { directoryURI_ = uri; }
  76   const std::string& title() const { return title_; }
  77   void setTitle(const std::string& title) { title_ = title; }
  78   const std::string& storageType() const { return storageType_; }
  79   void setStorageType(const std::string& type) { storageType_ = type; }
  80   const std::string& modifiedDate() const { return modifiedDate_; }
  81   void setModifiedDate(const std::string& modifiedDate) {
  82     modifiedDate_ = modifiedDate; }
  83
  84 #ifdef DEBUG_ITEM
  85   void print(void);
  86 #endif
  87
  88  protected:
  89   std::string id_;
  90   std::string directoryURI_;
  91   std::string title_;
  92   std::string storageType_;
  93   std::string modifiedDate_;
  94 };
  95
  96 class ContentItem {
  97  public:
  98   ContentItem() : size_(0), rating_(0), bitrate_(0), trackNumber_(0),
  99       duration_(0), width_(0), height_(0), latitude_(0), longitude_(0)
 100   {}
 101
 102   void init(media_info_h handle);
 103
 104   // Getters & Setters
 105   const std::string& id() const { return id_; }
 106   void setID(const std::string& id) { id_ = id; }
 107   const std::string& name() const { return name_; }
 108   void setName(const std::string& name) { name_ = name; }
 109   const std::string& type() const { return type_; }
 110   void setType(const std::string& type) { type_ = type;}
 111   const std::string& mimeType() const { return mimeType_; }
 112   void setMimeType(const std::string& mimeType) { mimeType_ = mimeType; }
 113   const std::string& title() const { return title_; }
 114   void setTitle(const std::string& title) { title_ = title;}
 115   const std::string& contentURI() const { return contentURI_; }
 116   void setContentURI(const std::string& uri) { contentURI_ = uri; }
 117   const std::string& thumbnailURIs() const { return thumbnailURIs_; }
 118   void setThumbnailURIs(const std::string& uris) { thumbnailURIs_ = uris; }
 119   const std::string& releaseDate() const { return releaseDate_; }
 120   void setReleaseDate(const std::string releaseDate) {
 121     releaseDate_ = releaseDate; }
 122   const std::string& modifiedDate() const { return modifiedDate_; }
 123   void setModifiedDate(const std::string& modifiedDate) {
 124     modifiedDate_ = modifiedDate; }
 125   uint64_t size() const { return size_; }
 126   void setSize(const uint64_t size) { size_ = size; }
 127   const std::string& description() const { return description_; }
 128   void setDescription(const std::string& desc) { description_ = desc; }
 129   uint64_t rating() const { return rating_; }
 130   void setRating(uint64_t rating) { rating_ = rating; }
 131   // type = AUDIO and VIDEO
 132   const std::string& album() const { return album_; }
 133   void setAlbum(const std::string& album) { album_ = album;}
 134   const std::string& genres() const { return genres_; }
 135   void setGenres(const std::string& genres) { genres_ = genres;}
 136   const std::string& artists() const { return artists_; }
 137   void setArtists(const std::string& artists) { artists_ = artists;}
 138   const std::string& composer() const { return composer_; }
 139   void setComposer(const std::string& composer) { composer_ = composer;}
 140   const std::string& copyright() const { return copyright_; }
 141   void setCopyright(const std::string& copyright) { copyright_ = copyright;}
 142   uint64_t bitrate() const { return rating_; }
 143   void setBitrate(uint64_t bitrate) { bitrate_ = bitrate; }
 144   uint64_t trackNumber() const { return bitrate_; }
 145   void setTrackNumber(uint64_t num) { trackNumber_ = num; }
 146   int duration() const { return duration_; }
 147   void setDuration(int duration) { duration_ = duration; }
 148   // type = IMAGE
 149   uint64_t width() const { return width_; }
 150   void setWidth(uint64_t width) { width_ = width; }
 151   uint64_t height() const { return height_; }
 152   void setHeight(uint64_t height) { height_ = height; }
 153   const std::string& orientation() const { return orientation_; }
 154   void setOrientation(const std::string& orintatin) {orientation_ = orintatin;}
 155   double latitude() const { return latitude_; }
 156   void setLatitude(double latitude) { latitude_ = latitude; }
 157   double longitude() const { return latitude_; }
 158   void setLongitude(double latitude) { latitude_ = latitude; }
 159
 160 #ifdef DEBUG_ITEM
 161   void print(void);
 162 #endif
 163
 164  protected:
 165   std::string id_;
 166   std::string name_;
 167   std::string type_;
 168   std::string mimeType_;
 169   std::string title_;
 170   std::string contentURI_;
 171   std::string thumbnailURIs_;
 172   std::string releaseDate_;
 173   std::string modifiedDate_;
 174   uint64_t size_;
 175   std::string description_;
 176   uint64_t rating_;
 177
 178   // type = AUDIO and VIDEO
 179   std::string album_;
 180   std::string genres_;
 181   std::string artists_;
 182   std::string composer_;
 183   std::string copyright_;
 184   uint64_t bitrate_;
 185   uint16_t trackNumber_;
 186   int duration_;
 187
 188   // type = IMAGE
 189   uint64_t width_;
 190   uint64_t height_;
 191   double latitude_;
 192   double longitude_;
 193   std::string orientation_;
 194 };
 195
 196 class ContentFolderList {
 197  public:
 198   ~ContentFolderList() {
 199     for (unsigned i = 0; i < m_folders.size(); i++)
 200       delete m_folders[i];
 201   }
 202   void addFolder(ContentFolder* folder) {
 203     m_folders.push_back(folder);
 204   }
 205   const std::vector<ContentFolder*>& getAllItems() {
 206     return m_folders;
 207   }
 208
 209  private:
 210   std::vector<ContentFolder*> m_folders;
 211 };
 212
 213 class ContentItemList {
 214  public:
 215   ~ContentItemList() {
 216     for (unsigned i = 0; i < m_items.size(); i++)
 217       delete m_items[i];
 218   }
 219   void addItem(ContentItem* item) {
 220     m_items.push_back(item);
 221   }
 222   const std::vector<ContentItem*>& getAllItems() {
 223     return m_items;
 224   }
 225
 226  private:
 227   std::vector<ContentItem*> m_items;
 228 };
 229
 230 #endif  // CONTENT_CONTENT_INSTANCE_H_