src/data/mediainfo.cpp

   1 /*
   2  * Copyright (c) 2014 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 #include <media_content_type.h>
  18 #include <AppCommon.h>
  19 #include "mediainfo.h"
  20 #include "menudef.h"
  21 #include "util.h"
  22
  23 struct SMediaInfo {
  24         media_info_h media_h;
  25
  26         char *location_tag;
  27         time_t created_time;
  28         int source;
  29 };
  30
  31 CMediaInfo::CMediaInfo(void)
  32 {
  33         m = new SMediaInfo();
  34         if (!m) {
  35                 _ERR("MediaInfo Create Failed");
  36                 return;
  37         }
  38
  39         memset(m, 0, sizeof(*m));
  40 }
  41
  42 CMediaInfo::~CMediaInfo(void)
  43 {
  44         media_info_destroy(m->media_h);
  45
  46         delete[] m->location_tag;
  47         delete m;
  48
  49         m = NULL;
  50 }
  51
  52 bool CMediaInfo::Update(void)
  53 {
  54         char *buf;
  55         unsigned long long val;
  56
  57         if (media_info_get_media_id(m->media_h, &buf) !=
  58                 MEDIA_CONTENT_ERROR_NONE) {
  59                 _ERR("Media ID Fetch error");
  60                 return false;
  61         }
  62         SetId(buf);
  63
  64         if (media_info_get_display_name(m->media_h, &buf) !=
  65                 MEDIA_CONTENT_ERROR_NONE) {
  66                 _ERR("Media display nam))e Fetch error");
  67                 return false;
  68         }
  69         SetName(buf);
  70
  71         if (media_info_get_size(m->media_h, &val) !=
  72                 MEDIA_CONTENT_ERROR_NONE) {
  73                 _ERR("Media size Fetch error");
  74                 return false;
  75         }
  76         SetSize(val);
  77
  78         if (media_info_get_file_path(m->media_h, &buf)
  79                 != MEDIA_CONTENT_ERROR_NONE) {
  80                 _ERR("Media file path Fetch error");
  81                 return false;
  82         }
  83         SetPath(buf);
  84
  85         if (media_info_get_thumbnail_path(m->media_h, &buf) !=
  86                 MEDIA_CONTENT_ERROR_NONE) {
  87                 _ERR("Media thumbnail path Fetch error");
  88                 return false;
  89         }
  90         SetThumbnailPath(buf);
  91
  92         if (media_info_get_modified_time(m->media_h, (time_t *)&val) !=
  93                 MEDIA_CONTENT_ERROR_NONE) {
  94                 _ERR("Media modified time Fetch error");
  95                 return false;
  96         }
  97         SetModifiedTime(val);
  98
  99         if (media_info_get_modified_time(m->media_h, (time_t *)&val) !=
 100                 MEDIA_CONTENT_ERROR_NONE) {
 101                 _ERR("Media created time Fetch error");
 102                 return false;
 103         }
 104         m_SetCreatedTime(val);
 105
 106         if (media_info_get_location_tag(m->media_h, &buf) !=
 107                 MEDIA_CONTENT_ERROR_NONE) {
 108                 _ERR("Media location tag Fetch error");
 109                 return false;
 110         }
 111         m_SetLocationTag(buf);
 112
 113         if (media_info_get_storage_type(m->media_h,
 114                 (media_content_storage_e *)&val) !=
 115                 MEDIA_CONTENT_ERROR_NONE) {
 116                 _ERR("Media location tag Fetch error");
 117                 return false;
 118         }
 119         m_SetSource(val);
 120
 121         return true;
 122 }
 123
 124 bool CMediaInfo::GetImageHandle(image_meta_h *image_h)
 125 {
 126         int r;
 127
 128         r = media_info_get_image(m->media_h, image_h);
 129         if (r != MEDIA_CONTENT_ERROR_NONE) {
 130                 _ERR("Media Image Handle Fetch Error");
 131                 return false;
 132         }
 133
 134         return true;
 135 }
 136
 137 bool CMediaInfo::GetVideoHandle(video_meta_h *video_h)
 138 {
 139         int r;
 140
 141         r = media_info_get_video(m->media_h, video_h);
 142         if (r != MEDIA_CONTENT_ERROR_NONE) {
 143                 _ERR("Media Video Handle Fetch Error");
 144                 return false;
 145         }
 146
 147         return true;
 148 }
 149
 150 char *CMediaInfo::LocationTag(void)
 151 {
 152         if (!m)
 153                 return NULL;
 154
 155         return m->location_tag;
 156 }
 157
 158 time_t CMediaInfo::CreatedTime(void)
 159 {
 160         if (!m)
 161                 return -1;
 162
 163         return m->created_time;
 164 }
 165
 166 time_t CMediaInfo::Time(void)
 167 {
 168         time_t timeval;
 169
 170         if (!m)
 171                 return -1;
 172
 173         timeval = CreatedTime();
 174         if (timeval < 0)
 175                 timeval = ModifiedTime();
 176
 177         return timeval;
 178 }
 179
 180 int CMediaInfo::Source(void)
 181 {
 182         int source = E_SOURCE_ALL;
 183
 184         if (!m)
 185                 return -1;
 186
 187         if (m->source == MEDIA_CONTENT_STORAGE_EXTERNAL)
 188                 source = E_SOURCE_USB;
 189
 190         return source;
 191 }
 192
 193 media_info_h CMediaInfo::MediaInfo(void)
 194 {
 195         if (!m)
 196                 return NULL;
 197
 198         return m->media_h;
 199 }
 200
 201 bool CMediaInfo::m_SetLocationTag(const char *location_tag)
 202 {
 203         if (!m)
 204                 return false;
 205
 206         delete[] m->location_tag;
 207         m->location_tag = NULL;
 208
 209         if (location_tag) {
 210                 m->location_tag = t_Clone(location_tag);
 211                 if (!m->location_tag)
 212                         return false;
 213         }
 214
 215         return true;
 216 }
 217
 218 bool CMediaInfo::m_SetCreatedTime(time_t created_time)
 219 {
 220         if (!m)
 221                 return false;
 222
 223         m->created_time = created_time;
 224
 225         return true;
 226 }
 227
 228 bool CMediaInfo::m_SetSource(int source)
 229 {
 230         if (!m)
 231                 return false;
 232
 233         m->source = source;
 234
 235         return true;
 236 }
 237
 238 bool CMediaInfo::SetMediaInfo(media_info_h media_h)
 239 {
 240         if (!m)
 241                 return false;
 242
 243         if (media_info_clone(&(m->media_h), media_h)
 244                 != MEDIA_CONTENT_ERROR_NONE) {
 245                 _ERR("Media info clone error");
 246                 return false;
 247         }
 248
 249         return true;
 250 }
 251
 252 bool CMediaInfo::Duplicate(CNameInfo *obj)
 253 {
 254         if (!m)
 255                 return false;
 256
 257         CMediaInfo *dst = (CMediaInfo *)obj;
 258
 259         if (!CExtNameInfo::Duplicate(obj))
 260                 return false;
 261
 262         if (!m_SetLocationTag(dst->LocationTag()))
 263                 return false;
 264         if (!m_SetCreatedTime(dst->CreatedTime()))
 265                 return false;
 266         if (!m_SetSource(dst->Source()))
 267                 return false;
 268         if (!SetMediaInfo(dst->MediaInfo()))
 269                 return false;
 270
 271         return true;
 272 }
 273
 274 bool CMediaInfo::UpdateDb(void)
 275 {
 276         char *media_id;
 277
 278         media_info_get_media_id(m->media_h, &media_id);
 279
 280         if (media_info_refresh_metadata_to_db(media_id)
 281                 != MEDIA_CONTENT_ERROR_NONE)
 282                 return false;
 283
 284         return true;
 285 }