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         int ret = MEDIA_CONTENT_ERROR_NONE;
  24
  25         if (media_count) {
  26                 ret = _media_db_get_group_item_count(NULL, filter, MEDIA_GROUP_UHD, media_count);
  27         } else {
  28                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  29                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  30         }
  31
  32         return ret;
  33 }
  34
  35 int media_uhd_foreach_media_from_db(filter_h filter, media_uhd_cb callback, void *user_data)
  36 {
  37         int ret = MEDIA_CONTENT_ERROR_NONE;
  38
  39         if (callback != NULL) {
  40                 ret = _media_db_get_uhd(filter, callback, user_data);
  41         } else {
  42                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  43                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  44         }
  45
  46         return ret;
  47 }
  48
  49 int media_uhd_destroy(media_uhd_h uhd)
  50 {
  51         int ret = MEDIA_CONTENT_ERROR_NONE;
  52         media_uhd_s *_uhd = (media_uhd_s*)uhd;
  53         if (_uhd) {
  54                 SAFE_FREE(_uhd->media_id);
  55                 SAFE_FREE(_uhd->storage_id);
  56                 SAFE_FREE(_uhd->path);
  57                 SAFE_FREE(_uhd->content_id);
  58                 SAFE_FREE(_uhd->content_title);
  59                 SAFE_FREE(_uhd->file_name);
  60                 SAFE_FREE(_uhd->release_date);
  61                 SAFE_FREE(_uhd);
  62
  63                 ret = MEDIA_CONTENT_ERROR_NONE;
  64         } else {
  65                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  66                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  67         }
  68
  69         return ret;
  70 }
  71
  72 int media_uhd_clone(media_uhd_h *dst, media_uhd_h src)
  73 {
  74         int ret = MEDIA_CONTENT_ERROR_NONE;
  75         media_uhd_s *_src = (media_uhd_s*)src;
  76
  77         if (_src != NULL) {
  78                 media_uhd_s *_dst = (media_uhd_s*)calloc(1, sizeof(media_uhd_s));
  79                 if (_dst == NULL) {
  80                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  81                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  82                 }
  83
  84                 if (STRING_VALID(_src->media_id)) {
  85                         _dst->media_id = strdup(_src->media_id);
  86                         if (_dst->media_id == NULL) {
  87                                 media_uhd_destroy((media_uhd_h)_dst);
  88                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  89                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  90                         }
  91                 }
  92
  93                 if (STRING_VALID(_src->storage_id)) {
  94                         _dst->storage_id = strdup(_src->storage_id);
  95                         if (_dst->storage_id == NULL) {
  96                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  97                                 media_uhd_destroy((media_uhd_h)_dst);
  98                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  99                         }
 100                 }
 101
 102                 if (STRING_VALID(_src->path)) {
 103                         _dst->path = strdup(_src->path);
 104                         if (_dst->path == NULL) {
 105                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 106                                 media_uhd_destroy((media_uhd_h)_dst);
 107                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 108                         }
 109                 }
 110
 111                 if (STRING_VALID(_src->content_id)) {
 112                         _dst->content_id = strdup(_src->content_id);
 113                         if (_dst->content_id == NULL) {
 114                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 115                                 media_uhd_destroy((media_uhd_h)_dst);
 116                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 117                         }
 118                 }
 119
 120                 if (STRING_VALID(_src->content_title)) {
 121                         _dst->content_title = strdup(_src->content_title);
 122                         if (_dst->content_title == NULL) {
 123                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 124                                 media_uhd_destroy((media_uhd_h)_dst);
 125                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 126                         }
 127                 }
 128
 129                 if (STRING_VALID(_src->release_date)) {
 130                         _dst->release_date = strdup(_src->release_date);
 131                         if (_dst->release_date == NULL) {
 132                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 133                                 media_uhd_destroy((media_uhd_h)_dst);
 134                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 135                         }
 136                 }
 137
 138                 if (STRING_VALID(_src->file_name)) {
 139                         _dst->file_name = strdup(_src->file_name);
 140                         if (_dst->file_name == NULL) {
 141                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 142                                 media_uhd_destroy((media_uhd_h)_dst);
 143                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 144                         }
 145                 }
 146
 147                 _dst->size = _src->size;
 148                 _dst->modified_time = _src->modified_time;
 149                 _dst->played_position = _src->played_position;
 150                 _dst->sub_type = _src->sub_type;
 151                 _dst->played_count = _src->played_count;
 152                 *dst = (media_uhd_h)_dst;
 153
 154                 ret = MEDIA_CONTENT_ERROR_NONE;
 155         } else {
 156                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 157                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 158         }
 159
 160         return ret;
 161 }
 162
 163 int media_uhd_get_uhd_from_db(const char *media_id, media_uhd_h *uhd)
 164 {
 165         int ret = MEDIA_CONTENT_ERROR_NONE;
 166         char *select_query = NULL;
 167         sqlite3_stmt *stmt = NULL;
 168
 169         if (!STRING_VALID(media_id) || (uhd == NULL)) {
 170                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 171                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 172         }
 173
 174         select_query = sqlite3_mprintf(SELECT_UHD_FROM_UHD, media_id);
 175
 176         ret = _content_get_result(select_query, &stmt);
 177         SQLITE3_SAFE_FREE(select_query);
 178         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 179
 180         media_uhd_s *_uhd = NULL;
 181
 182         if (sqlite3_step(stmt) == SQLITE_ROW) {
 183                 _uhd = (media_uhd_s*)calloc(1, sizeof(media_uhd_s));
 184
 185                 if (_uhd == NULL) {
 186                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 187                         SQLITE3_FINALIZE(stmt);
 188                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 189                 }
 190
 191                 _media_uhd_item_get_detail(stmt, (media_uhd_h)_uhd);
 192
 193                 *uhd = (media_uhd_h)_uhd;
 194         } else {
 195                 content_error("Nonexistent media id[%s]", media_id);
 196                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 197         }
 198
 199         SQLITE3_FINALIZE(stmt);
 200
 201         return ret;
 202 }
 203
 204 int media_uhd_get_media_id(media_uhd_h uhd, char **media_id)
 205 {
 206         int ret = MEDIA_CONTENT_ERROR_NONE;
 207         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 208
 209         if (_uhd && media_id) {
 210                 if (STRING_VALID(_uhd->media_id)) {
 211                         *media_id = strdup(_uhd->media_id);
 212                         if (*media_id == NULL) {
 213                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 214                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 215                         }
 216                 } else {
 217                         *media_id = NULL;
 218                 }
 219
 220                 ret = MEDIA_CONTENT_ERROR_NONE;
 221         } else {
 222                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 223                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 224         }
 225
 226         return ret;
 227 }
 228
 229 int media_uhd_get_storage_id(media_uhd_h uhd, char **storage_id)
 230 {
 231         int ret = MEDIA_CONTENT_ERROR_NONE;
 232         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 233
 234         if (_uhd && storage_id) {
 235                 if (STRING_VALID(_uhd->storage_id)) {
 236                         *storage_id = strdup(_uhd->storage_id);
 237                         if (*storage_id == NULL) {
 238                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 239                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 240                         }
 241                 } else {
 242                         *storage_id = NULL;
 243                 }
 244
 245                 ret = MEDIA_CONTENT_ERROR_NONE;
 246         } else {
 247                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 248                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 249         }
 250
 251         return ret;
 252 }
 253
 254 int media_uhd_get_path(media_uhd_h uhd, char **path)
 255 {
 256         int ret = MEDIA_CONTENT_ERROR_NONE;
 257         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 258
 259         if (_uhd && path) {
 260                 if (STRING_VALID(_uhd->path)) {
 261                         *path = strdup(_uhd->path);
 262                         if (*path == NULL) {
 263                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 264                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 265                         }
 266                 } else {
 267                         *path = NULL;
 268                 }
 269
 270                 ret = MEDIA_CONTENT_ERROR_NONE;
 271         } else {
 272                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 273                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 274         }
 275
 276         return ret;
 277 }
 278
 279 int media_uhd_get_size(media_uhd_h uhd, unsigned long long *size)
 280 {
 281         int ret = MEDIA_CONTENT_ERROR_NONE;
 282         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 283
 284         if (_uhd && size) {
 285                 *size = _uhd->size;
 286                 ret = MEDIA_CONTENT_ERROR_NONE;
 287         } else {
 288                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 289                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 290         }
 291
 292         return ret;
 293 }
 294
 295 int media_uhd_get_content_id(media_uhd_h uhd, char **content_id)
 296 {
 297         int ret = MEDIA_CONTENT_ERROR_NONE;
 298         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 299
 300         if (_uhd && content_id) {
 301                 if (STRING_VALID(_uhd->content_id)) {
 302                         *content_id = strdup(_uhd->content_id);
 303                         if (*content_id == NULL) {
 304                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 305                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 306                         }
 307                 } else {
 308                         *content_id = NULL;
 309                 }
 310
 311                 ret = MEDIA_CONTENT_ERROR_NONE;
 312         } else {
 313                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 314                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 315         }
 316
 317         return ret;
 318 }
 319
 320 int media_uhd_get_content_title(media_uhd_h uhd, char **content_title)
 321 {
 322         int ret = MEDIA_CONTENT_ERROR_NONE;
 323         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 324
 325         if (_uhd && content_title) {
 326                 if (STRING_VALID(_uhd->content_title)) {
 327                         *content_title = strdup(_uhd->content_title);
 328                         if (*content_title == NULL) {
 329                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 330                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 331                         }
 332                 } else {
 333                         *content_title = NULL;
 334                 }
 335
 336                 ret = MEDIA_CONTENT_ERROR_NONE;
 337         } else {
 338                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 339                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 340         }
 341
 342         return ret;
 343 }
 344
 345 int media_uhd_get_file_name(media_uhd_h uhd, char **file_name)
 346 {
 347         int ret = MEDIA_CONTENT_ERROR_NONE;
 348         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 349
 350         if (_uhd && file_name) {
 351                 if (STRING_VALID(_uhd->file_name)) {
 352                         *file_name = strdup(_uhd->file_name);
 353                         if (*file_name == NULL) {
 354                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 355                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 356                         }
 357                 } else {
 358                         *file_name = NULL;
 359                 }
 360
 361                 ret = MEDIA_CONTENT_ERROR_NONE;
 362         } else {
 363                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 364                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 365         }
 366
 367         return ret;
 368 }
 369
 370 int media_uhd_get_release_date(media_uhd_h uhd, char **release_date)
 371 {
 372         int ret = MEDIA_CONTENT_ERROR_NONE;
 373         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 374
 375         if (_uhd && release_date) {
 376                 if (STRING_VALID(_uhd->release_date)) {
 377                         *release_date = strdup(_uhd->release_date);
 378                         if (*release_date == NULL) {
 379                                 content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 380                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 381                         }
 382                 } else {
 383                         *release_date = NULL;
 384                 }
 385
 386                 ret = MEDIA_CONTENT_ERROR_NONE;
 387         } else {
 388                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 389                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 390         }
 391
 392         return ret;
 393 }
 394
 395 int media_uhd_get_modified_time(media_uhd_h uhd, time_t *modified_time)
 396 {
 397         int ret = MEDIA_CONTENT_ERROR_NONE;
 398         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 399
 400         if (_uhd && modified_time) {
 401                 *modified_time = _uhd->modified_time;
 402                 ret = MEDIA_CONTENT_ERROR_NONE;
 403         } else {
 404                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 405                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 406         }
 407
 408         return ret;
 409 }
 410
 411 int media_uhd_get_played_position(media_uhd_h uhd, int *played_position)
 412 {
 413         int ret = MEDIA_CONTENT_ERROR_NONE;
 414         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 415
 416         if (_uhd) {
 417                 *played_position = _uhd->played_position;
 418                 ret = MEDIA_CONTENT_ERROR_NONE;
 419         } else {
 420                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 421                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 422         }
 423
 424         return ret;
 425 }
 426
 427 int media_uhd_get_sub_type(media_uhd_h uhd, int *sub_type)
 428 {
 429         int ret = MEDIA_CONTENT_ERROR_NONE;
 430         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 431
 432         if (_uhd) {
 433                 *sub_type = _uhd->sub_type;
 434                 ret = MEDIA_CONTENT_ERROR_NONE;
 435         } else {
 436                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 437                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 438         }
 439
 440         return ret;
 441 }
 442
 443 int media_uhd_get_played_count(media_uhd_h uhd, int *played_count)
 444 {
 445         int ret = MEDIA_CONTENT_ERROR_NONE;
 446         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 447
 448         if (_uhd) {
 449                 *played_count = _uhd->played_count;
 450                 ret = MEDIA_CONTENT_ERROR_NONE;
 451         } else {
 452                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 453                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 454         }
 455
 456         return ret;
 457 }
 458
 459 int media_uhd_set_played_position(media_uhd_h uhd, int played_position)
 460 {
 461         int ret = MEDIA_CONTENT_ERROR_NONE;
 462         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 463
 464         if ((_uhd != NULL) && (played_position >= 0)) {
 465                 _uhd->played_position = played_position;
 466         } else {
 467                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 468                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 469         }
 470
 471         return ret;
 472 }
 473
 474 int media_uhd_set_content_title(media_uhd_h uhd, const char *content_title)
 475 {
 476         int ret = MEDIA_CONTENT_ERROR_NONE;
 477         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 478
 479         if (_uhd != NULL && STRING_VALID(content_title)) {
 480                 SAFE_FREE(_uhd->content_title);
 481                 _uhd->content_title = strdup(content_title);
 482                 if (_uhd->content_title == NULL) {
 483                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 484                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 485                 }
 486         } else {
 487                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 488                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 489         }
 490
 491         return ret;
 492 }
 493
 494 int media_uhd_set_release_date(media_uhd_h uhd, const char *release_date)
 495 {
 496         int ret = MEDIA_CONTENT_ERROR_NONE;
 497         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 498
 499         if (_uhd != NULL && STRING_VALID(release_date)) {
 500                 SAFE_FREE(_uhd->release_date);
 501                 _uhd->release_date = strdup(release_date);
 502                 if (_uhd->release_date == NULL) {
 503                         content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 504                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 505                 }
 506         } else {
 507                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 508                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 509         }
 510
 511         return ret;
 512 }
 513
 514 int media_uhd_set_sub_type(media_uhd_h uhd, int sub_type)
 515 {
 516         int ret = MEDIA_CONTENT_ERROR_NONE;
 517         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 518
 519         if ((_uhd != NULL) && (sub_type >= 0)) {
 520                 _uhd->sub_type = sub_type;
 521         } else {
 522                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 523                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 524         }
 525
 526         return ret;
 527 }
 528
 529 int media_uhd_set_played_count(media_uhd_h uhd, int played_count)
 530 {
 531         int ret = MEDIA_CONTENT_ERROR_NONE;
 532         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 533
 534         if (_uhd != NULL) {
 535                 _uhd->played_count = played_count;
 536         } else {
 537                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 538                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 539         }
 540
 541         return ret;
 542 }
 543
 544 int media_uhd_update_to_db(media_uhd_h uhd)
 545 {
 546         int ret = MEDIA_CONTENT_ERROR_NONE;
 547         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 548         char *update_query = NULL;
 549
 550         if (_uhd != NULL && STRING_VALID(_uhd->media_id) && STRING_VALID(_uhd->path)) {
 551                 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);
 552
 553                 ret = _content_query_sql(update_query);
 554                 sqlite3_free(update_query);
 555         } else {
 556                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 557                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 558         }
 559
 560         return ret;
 561 }
 562 #endif