src/media_uhd.c

   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 #ifdef _USE_TVPD_MODE
  17 #include <media_info_private.h>
  18 #include <media_util_private.h>
  19 #include <media_uhd.h>
  20
  21 int media_uhd_get_media_count_from_db(filter_h filter, int *media_count)
  22 {
  23         content_retip_if_fail(media_count);
  24
  25         return _media_db_get_group_item_count(NULL, filter, MEDIA_GROUP_UHD, media_count);
  26 }
  27
  28 int media_uhd_foreach_media_from_db(filter_h filter, media_uhd_cb callback, void *user_data)
  29 {
  30         content_retip_if_fail(callback);
  31
  32         return _media_db_get_uhd(filter, callback, user_data);
  33 }
  34
  35 int media_uhd_destroy(media_uhd_h uhd)
  36 {
  37         media_uhd_s *_uhd = (media_uhd_s*)uhd;
  38
  39         content_retip_if_fail(uhd);
  40
  41         g_free(_uhd->media_id);
  42         g_free(_uhd->storage_id);
  43         g_free(_uhd->path);
  44         g_free(_uhd->content_id);
  45         g_free(_uhd->content_title);
  46         g_free(_uhd->file_name);
  47         g_free(_uhd->release_date);
  48         g_free(_uhd);
  49
  50         return MEDIA_CONTENT_ERROR_NONE;
  51 }
  52
  53 int media_uhd_clone(media_uhd_h *dst, media_uhd_h src)
  54 {
  55         media_uhd_s *_src = (media_uhd_s*)src;
  56
  57         content_retip_if_fail(dst);
  58         content_retip_if_fail(src);
  59
  60         media_uhd_s *_dst = g_new0(media_uhd_s, 1);
  61
  62         _dst->media_id = g_strdup(_src->media_id);
  63         _dst->storage_id = g_strdup(_src->storage_id);
  64         _dst->path = g_strdup(_src->path);
  65         _dst->content_id = g_strdup(_src->content_id);
  66         _dst->content_title = g_strdup(_src->content_title);
  67         _dst->release_date = g_strdup(_src->release_date);
  68         _dst->file_name = g_strdup(_src->file_name);
  69         _dst->size = _src->size;
  70         _dst->modified_time = _src->modified_time;
  71         _dst->played_position = _src->played_position;
  72         _dst->sub_type = _src->sub_type;
  73         _dst->played_count = _src->played_count;
  74
  75         *dst = (media_uhd_h)_dst;
  76
  77         return MEDIA_CONTENT_ERROR_NONE;
  78 }
  79
  80 int media_uhd_get_uhd_from_db(const char *media_id, media_uhd_h *uhd)
  81 {
  82         int ret = MEDIA_CONTENT_ERROR_NONE;
  83         char *select_query = NULL;
  84         sqlite3_stmt *stmt = NULL;
  85
  86         content_retip_if_fail(STRING_VALID(media_id));
  87         content_retip_if_fail(uhd);
  88
  89         select_query = sqlite3_mprintf(SELECT_UHD_FROM_UHD, media_id);
  90
  91         ret = _content_get_result(select_query, &stmt);
  92         SQLITE3_SAFE_FREE(select_query);
  93         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  94
  95         media_uhd_s *_uhd = NULL;
  96
  97         if (sqlite3_step(stmt) == SQLITE_ROW) {
  98                 _uhd = g_new0(media_uhd_s, 1);
  99
 100                 _media_uhd_item_get_detail(stmt, (media_uhd_h)_uhd);
 101
 102                 *uhd = (media_uhd_h)_uhd;
 103         } else {
 104                 content_error("Nonexistent media id[%s]", media_id);
 105                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 106         }
 107
 108         SQLITE3_FINALIZE(stmt);
 109
 110         return ret;
 111 }
 112
 113 int media_uhd_get_media_id(media_uhd_h uhd, char **media_id)
 114 {
 115         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 116
 117         content_retip_if_fail(uhd);
 118         content_retip_if_fail(media_id);
 119
 120         *media_id = g_strdup(_uhd->media_id);
 121
 122         return MEDIA_CONTENT_ERROR_NONE;
 123 }
 124
 125 int media_uhd_get_storage_id(media_uhd_h uhd, char **storage_id)
 126 {
 127         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 128
 129         content_retip_if_fail(uhd);
 130         content_retip_if_fail(storage_id);
 131
 132         *storage_id = g_strdup(_uhd->storage_id);
 133
 134         return MEDIA_CONTENT_ERROR_NONE;
 135 }
 136
 137 int media_uhd_get_path(media_uhd_h uhd, char **path)
 138 {
 139         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 140
 141         content_retip_if_fail(uhd);
 142         content_retip_if_fail(path);
 143
 144         *path = g_strdup(_uhd->path);
 145
 146         return MEDIA_CONTENT_ERROR_NONE;
 147 }
 148
 149 int media_uhd_get_size(media_uhd_h uhd, unsigned long long *size)
 150 {
 151         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 152
 153         content_retip_if_fail(uhd);
 154         content_retip_if_fail(size);
 155
 156         *size = _uhd->size;
 157
 158         return MEDIA_CONTENT_ERROR_NONE;
 159 }
 160
 161 int media_uhd_get_content_id(media_uhd_h uhd, char **content_id)
 162 {
 163         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 164
 165         content_retip_if_fail(uhd);
 166         content_retip_if_fail(content_id);
 167
 168         *content_id = g_strdup(_uhd->content_id);
 169
 170         return MEDIA_CONTENT_ERROR_NONE;
 171 }
 172
 173 int media_uhd_get_content_title(media_uhd_h uhd, char **content_title)
 174 {
 175         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 176
 177         content_retip_if_fail(uhd);
 178         content_retip_if_fail(content_title);
 179
 180         *content_title = g_strdup(_uhd->content_title);
 181
 182         return MEDIA_CONTENT_ERROR_NONE;
 183 }
 184
 185 int media_uhd_get_file_name(media_uhd_h uhd, char **file_name)
 186 {
 187         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 188
 189         content_retip_if_fail(uhd);
 190         content_retip_if_fail(file_name);
 191
 192         *file_name = g_strdup(_uhd->file_name);
 193
 194         return MEDIA_CONTENT_ERROR_NONE;
 195 }
 196
 197 int media_uhd_get_release_date(media_uhd_h uhd, char **release_date)
 198 {
 199         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 200
 201         content_retip_if_fail(uhd);
 202         content_retip_if_fail(release_date);
 203
 204         *release_date = g_strdup(_uhd->release_date);
 205
 206         return MEDIA_CONTENT_ERROR_NONE;
 207 }
 208
 209 int media_uhd_get_modified_time(media_uhd_h uhd, time_t *modified_time)
 210 {
 211         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 212
 213         content_retip_if_fail(uhd);
 214         content_retip_if_fail(modified_time);
 215
 216         *modified_time = _uhd->modified_time;
 217
 218         return MEDIA_CONTENT_ERROR_NONE;
 219 }
 220
 221 int media_uhd_get_played_position(media_uhd_h uhd, int *played_position)
 222 {
 223         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 224
 225         content_retip_if_fail(uhd);
 226         content_retip_if_fail(played_position);
 227
 228         *played_position = _uhd->played_position;
 229
 230         return MEDIA_CONTENT_ERROR_NONE;
 231 }
 232
 233 int media_uhd_get_sub_type(media_uhd_h uhd, int *sub_type)
 234 {
 235         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 236
 237         content_retip_if_fail(uhd);
 238         content_retip_if_fail(sub_type);
 239
 240         *sub_type = _uhd->sub_type;
 241
 242         return MEDIA_CONTENT_ERROR_NONE;
 243 }
 244
 245 int media_uhd_get_played_count(media_uhd_h uhd, int *played_count)
 246 {
 247         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 248
 249         content_retip_if_fail(uhd);
 250         content_retip_if_fail(played_count);
 251
 252         *played_count = _uhd->played_count;
 253
 254         return MEDIA_CONTENT_ERROR_NONE;
 255 }
 256
 257 int media_uhd_set_played_position(media_uhd_h uhd, int played_position)
 258 {
 259         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 260
 261         content_retip_if_fail(uhd);
 262         content_retip_if_fail(played_position);
 263
 264         _uhd->played_position = played_position;
 265
 266         return MEDIA_CONTENT_ERROR_NONE;
 267 }
 268
 269 int media_uhd_set_content_title(media_uhd_h uhd, const char *content_title)
 270 {
 271         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 272
 273         content_retip_if_fail(uhd);
 274         content_retip_if_fail(STRING_VALID(content_title));
 275
 276         g_free(_uhd->content_title);
 277         _uhd->content_title = g_strdup(content_title);
 278
 279         return MEDIA_CONTENT_ERROR_NONE;
 280 }
 281
 282 int media_uhd_set_release_date(media_uhd_h uhd, const char *release_date)
 283 {
 284         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 285
 286         content_retip_if_fail(uhd);
 287         content_retip_if_fail(STRING_VALID(release_date));
 288
 289         g_free(_uhd->release_date);
 290         _uhd->release_date = g_strdup(release_date);
 291
 292         return MEDIA_CONTENT_ERROR_NONE;
 293 }
 294
 295 int media_uhd_set_sub_type(media_uhd_h uhd, int sub_type)
 296 {
 297         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 298
 299         content_retip_if_fail(uhd);
 300         content_retip_if_fail(sub_type >= 0);
 301
 302         _uhd->sub_type = sub_type;
 303
 304         return MEDIA_CONTENT_ERROR_NONE;
 305 }
 306
 307 int media_uhd_set_played_count(media_uhd_h uhd, int played_count)
 308 {
 309         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 310
 311         content_retip_if_fail(uhd);
 312
 313         _uhd->played_count = played_count;
 314
 315         return MEDIA_CONTENT_ERROR_NONE;
 316 }
 317
 318 int media_uhd_update_to_db(media_uhd_h uhd)
 319 {
 320         int ret = MEDIA_CONTENT_ERROR_NONE;
 321         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 322         char *update_query = NULL;
 323
 324         content_retip_if_fail(uhd);
 325         content_retip_if_fail(STRING_VALID(_uhd->media_id));
 326         content_retip_if_fail(STRING_VALID(_uhd->path));
 327
 328         update_query = sqlite3_mprintf(UPDATE_UHD_META_FROM_UHD, _uhd->content_title, _uhd->release_date, _uhd->played_position, _uhd->sub_type, _uhd->played_count, _uhd->media_id);
 329
 330         ret = _content_query_sql(update_query);
 331         sqlite3_free(update_query);
 332
 333         return ret;
 334 }
 335 #endif