src/media_pvr.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
  17 #ifdef _USE_TVPD_MODE
  18 #include <media_info_private.h>
  19 #include <media_util_private.h>
  20 #include <media_pvr.h>
  21
  22
  23 int media_pvr_get_media_count_from_db(filter_h filter, int *media_count)
  24 {
  25         int ret = MEDIA_CONTENT_ERROR_NONE;
  26
  27         if (media_count) {
  28                 ret = _media_db_get_group_item_count(NULL, filter, MEDIA_GROUP_PVR, media_count);
  29         } else {
  30                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  31                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  32         }
  33
  34         return ret;
  35 }
  36
  37 int media_pvr_foreach_media_from_db(filter_h filter, media_pvr_cb callback, void *user_data)
  38 {
  39         int ret = MEDIA_CONTENT_ERROR_NONE;
  40
  41         if (callback != NULL) {
  42                 ret = _media_db_get_pvr(filter, callback, user_data);
  43         } else {
  44                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  45                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  46         }
  47
  48         return ret;
  49 }
  50
  51 int media_pvr_destroy(media_pvr_h pvr)
  52 {
  53         int ret = MEDIA_CONTENT_ERROR_NONE;
  54         media_pvr_s *_pvr = (media_pvr_s*)pvr;
  55         if (_pvr) {
  56                 SAFE_FREE(_pvr->media_id);
  57                 SAFE_FREE(_pvr->storage_id);
  58                 SAFE_FREE(_pvr->channel_name);
  59                 SAFE_FREE(_pvr->channel_num);
  60                 SAFE_FREE(_pvr->program_title);
  61                 SAFE_FREE(_pvr->program_crid);
  62                 SAFE_FREE(_pvr->guidance);
  63                 SAFE_FREE(_pvr->synopsis);
  64                 SAFE_FREE(_pvr->genre);
  65                 SAFE_FREE(_pvr->language);
  66                 SAFE_FREE(_pvr->path);
  67                 SAFE_FREE(_pvr->modified_month);
  68                 SAFE_FREE(_pvr->private_data);
  69                 SAFE_FREE(_pvr);
  70
  71                 ret = MEDIA_CONTENT_ERROR_NONE;
  72         } else {
  73                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  74                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  75         }
  76
  77         return ret;
  78 }
  79
  80 int media_pvr_clone(media_pvr_h *dst, media_pvr_h src)
  81 {
  82         int ret = MEDIA_CONTENT_ERROR_NONE;
  83         media_pvr_s *_src = (media_pvr_s*)src;
  84
  85         if (_src != NULL) {
  86                 media_pvr_s *_dst = (media_pvr_s*)calloc(1, sizeof(media_pvr_s));
  87                 if (_dst == NULL) {
  88                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  89                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  90                 }
  91
  92                 if (STRING_VALID(_src->media_id)) {
  93                         _dst->media_id = strdup(_src->media_id);
  94                         if (_dst->media_id == NULL) {
  95                                 media_pvr_destroy((media_pvr_h)_dst);
  96                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  97                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  98                         }
  99                 }
 100
 101                 if (STRING_VALID(_src->channel_name)) {
 102                         _dst->channel_name = strdup(_src->channel_name);
 103                         if (_dst->channel_name == NULL) {
 104                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 105                                 media_pvr_destroy((media_pvr_h)_dst);
 106                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 107                         }
 108                 }
 109
 110                 if (STRING_VALID(_src->channel_num)) {
 111                         _dst->channel_num = strdup(_src->channel_num);
 112                         if (_dst->channel_num == NULL) {
 113                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 114                                 media_pvr_destroy((media_pvr_h)_dst);
 115                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 116                         }
 117                 }
 118
 119                 if (STRING_VALID(_src->program_title)) {
 120                         _dst->program_title = strdup(_src->program_title);
 121                         if (_dst->program_title == NULL) {
 122                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 123                                 media_pvr_destroy((media_pvr_h)_dst);
 124                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 125                         }
 126                 }
 127
 128                 if (STRING_VALID(_src->program_crid)) {
 129                         _dst->program_crid = strdup(_src->program_crid);
 130                         if (_dst->program_crid == NULL) {
 131                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 132                                 media_pvr_destroy((media_pvr_h)_dst);
 133                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 134                         }
 135                 }
 136
 137                 if (STRING_VALID(_src->guidance)) {
 138                         _dst->guidance = strdup(_src->guidance);
 139                         if (_dst->guidance == NULL) {
 140                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 141                                 media_pvr_destroy((media_pvr_h)_dst);
 142                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 143                         }
 144                 }
 145
 146                 if (STRING_VALID(_src->synopsis)) {
 147                         _dst->synopsis = strdup(_src->synopsis);
 148                         if (_dst->synopsis == NULL) {
 149                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 150                                 media_pvr_destroy((media_pvr_h)_dst);
 151                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 152                         }
 153                 }
 154
 155                 if (STRING_VALID(_src->genre)) {
 156                         _dst->genre = strdup(_src->genre);
 157                         if (_dst->genre == NULL) {
 158                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 159                                 media_pvr_destroy((media_pvr_h)_dst);
 160                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 161                         }
 162                 }
 163
 164                 if (STRING_VALID(_src->language)) {
 165                         _dst->language = strdup(_src->language);
 166                         if (_dst->language == NULL) {
 167                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 168                                 media_pvr_destroy((media_pvr_h)_dst);
 169                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 170                         }
 171                 }
 172
 173                 if (STRING_VALID(_src->path)) {
 174                         _dst->path = strdup(_src->path);
 175                         if (_dst->path == NULL) {
 176                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 177                                 media_pvr_destroy((media_pvr_h)_dst);
 178                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 179                         }
 180                 }
 181
 182                 if (STRING_VALID(_src->storage_id)) {
 183                         _dst->storage_id = strdup(_src->storage_id);
 184                         if (_dst->storage_id == NULL) {
 185                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 186                                 media_pvr_destroy((media_pvr_h)_dst);
 187                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 188                         }
 189                 }
 190
 191                 if (STRING_VALID(_src->modified_month)) {
 192                         _dst->modified_month = strdup(_src->modified_month);
 193                         if (_dst->modified_month == NULL) {
 194                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 195                                 media_pvr_destroy((media_pvr_h)_dst);
 196                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 197                         }
 198                 }
 199
 200                 if (STRING_VALID(_src->private_data)) {
 201                         _dst->private_data = strdup(_src->private_data);
 202                         if (_dst->private_data == NULL) {
 203                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 204                                 media_pvr_destroy((media_pvr_h)_dst);
 205                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 206                         }
 207                 }
 208                 _dst->duration = _src->duration;
 209                 _dst->timezone = _src->timezone;
 210                 _dst->ptc = _src->ptc;
 211                 _dst->major = _src->major;
 212                 _dst->minor = _src->minor;
 213                 _dst->channel_type = _src->channel_type;
 214                 _dst->program_num = _src->program_num;
 215                 _dst->timer_record = _src->timer_record;
 216                 _dst->series_record = _src->series_record;
 217                 _dst->hd = _src->hd;
 218                 _dst->subtitle = _src->subtitle;
 219                 _dst->ttx = _src->ttx;
 220                 _dst->ad = _src->ad;
 221                 _dst->hard_of_hearing_radio = _src->hard_of_hearing_radio;
 222                 _dst->data_service = _src->data_service;
 223                 _dst->content_lock = _src->content_lock;
 224                 _dst->embargo_time = _src->embargo_time;
 225                 _dst->expiry_time = _src->expiry_time;
 226                 _dst->size = _src->size;
 227                 _dst->parental_rating = _src->parental_rating;
 228                 _dst->start_time = _src->start_time;
 229                 _dst->program_start_time = _src->program_start_time;
 230                 _dst->program_end_time = _src->program_end_time;
 231                 _dst->program_date = _src->program_date;
 232                 _dst->content_watch = _src->content_watch;
 233                 _dst->has_audio_only = _src->has_audio_only;
 234                 _dst->is_local_record = _src->is_local_record;
 235                 _dst->resolution = _src->resolution;
 236                 _dst->aspectratio = _src->aspectratio;
 237                 _dst->sports_type = _src->sports_type;
 238                 _dst->guidance_length = _src->guidance_length;
 239                 _dst->tvmode = _src->tvmode;
 240                 _dst->play_count = _src->play_count;
 241
 242                 *dst = (media_pvr_h)_dst;
 243
 244                 ret = MEDIA_CONTENT_ERROR_NONE;
 245         } else {
 246                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 247                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 248         }
 249
 250         return ret;
 251 }
 252
 253 int media_pvr_get_pvr_from_db(const char *media_id, media_pvr_h *pvr)
 254 {
 255         int ret = MEDIA_CONTENT_ERROR_NONE;
 256         char *select_query = NULL;
 257         sqlite3_stmt *stmt = NULL;
 258
 259         if (!STRING_VALID(media_id) || (pvr == NULL)) {
 260                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 261                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 262         }
 263
 264         select_query = sqlite3_mprintf(SELECT_PVR_FROM_PVR, media_id);
 265
 266         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 267         sqlite3_free(select_query);
 268         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 269
 270         media_pvr_s *_pvr = NULL;
 271
 272         while (sqlite3_step(stmt) == SQLITE_ROW) {
 273                 if (_pvr)
 274                         media_pvr_destroy((media_pvr_h)_pvr);
 275
 276                 _pvr = (media_pvr_s*)calloc(1, sizeof(media_pvr_s));
 277
 278                 if (_pvr == NULL) {
 279                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 280                         SQLITE3_FINALIZE(stmt);
 281                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 282                 }
 283
 284                 _media_pvr_item_get_detail(stmt, (media_pvr_h)_pvr);
 285
 286                 *pvr = (media_info_h)_pvr;
 287         }
 288
 289         SQLITE3_FINALIZE(stmt);
 290
 291         return ret;
 292 }
 293
 294 int media_pvr_get_media_id(media_pvr_h pvr, char **media_id)
 295 {
 296         int ret = MEDIA_CONTENT_ERROR_NONE;
 297         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 298
 299         if (_pvr && media_id) {
 300                 if (STRING_VALID(_pvr->media_id)) {
 301                         *media_id = strdup(_pvr->media_id);
 302                         if (*media_id == NULL) {
 303                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 304                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 305                         }
 306                 } else {
 307                         *media_id = NULL;
 308                 }
 309
 310                 ret = MEDIA_CONTENT_ERROR_NONE;
 311         } else {
 312                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 313                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 314         }
 315
 316         return ret;
 317 }
 318
 319 int media_pvr_get_channel_name(media_pvr_h pvr, char **channel_name)
 320 {
 321         int ret = MEDIA_CONTENT_ERROR_NONE;
 322         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 323
 324         if (_pvr && channel_name) {
 325                 if (STRING_VALID(_pvr->channel_name)) {
 326                         *channel_name = strdup(_pvr->channel_name);
 327                         if (*channel_name == NULL) {
 328                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 329                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 330                         }
 331                 } else {
 332                         *channel_name = NULL;
 333                 }
 334
 335                 ret = MEDIA_CONTENT_ERROR_NONE;
 336         } else {
 337                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 338                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 339         }
 340
 341         return ret;
 342 }
 343
 344 int media_pvr_get_channel_num(media_pvr_h pvr, char **channel_num)
 345 {
 346         int ret = MEDIA_CONTENT_ERROR_NONE;
 347         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 348
 349         if (_pvr && channel_num) {
 350                 if (STRING_VALID(_pvr->channel_num)) {
 351                         *channel_num = strdup(_pvr->channel_num);
 352                         if (*channel_num == NULL) {
 353                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 354                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 355                         }
 356                 } else {
 357                         *channel_num = NULL;
 358                 }
 359
 360                 ret = MEDIA_CONTENT_ERROR_NONE;
 361         } else {
 362                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 363                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 364         }
 365
 366         return ret;
 367 }
 368
 369 int media_pvr_get_program_title(media_pvr_h pvr, char **program_title)
 370 {
 371         int ret = MEDIA_CONTENT_ERROR_NONE;
 372         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 373
 374         if (_pvr && program_title) {
 375                 if (STRING_VALID(_pvr->program_title)) {
 376                         *program_title = strdup(_pvr->program_title);
 377                         if (*program_title == NULL) {
 378                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 379                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 380                         }
 381                 } else {
 382                         *program_title = NULL;
 383                 }
 384
 385                 ret = MEDIA_CONTENT_ERROR_NONE;
 386         } else {
 387                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 388                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 389         }
 390
 391         return ret;
 392 }
 393
 394 int media_pvr_get_program_crid(media_pvr_h pvr, char **program_crid)
 395 {
 396         int ret = MEDIA_CONTENT_ERROR_NONE;
 397         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 398
 399         if (_pvr && program_crid) {
 400                 if (STRING_VALID(_pvr->program_crid)) {
 401                         *program_crid = strdup(_pvr->program_crid);
 402                         if (*program_crid == NULL) {
 403                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 404                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 405                         }
 406                 } else {
 407                         *program_crid = NULL;
 408                 }
 409
 410                 ret = MEDIA_CONTENT_ERROR_NONE;
 411         } else {
 412                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 413                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 414         }
 415
 416         return ret;
 417 }
 418
 419 int media_pvr_get_guidance(media_pvr_h pvr, char **guidance)
 420 {
 421         int ret = MEDIA_CONTENT_ERROR_NONE;
 422         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 423
 424         if (_pvr && guidance) {
 425                 if (STRING_VALID(_pvr->guidance)) {
 426                         *guidance = strdup(_pvr->guidance);
 427                         if (*guidance == NULL) {
 428                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 429                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 430                         }
 431                 } else {
 432                         *guidance = NULL;
 433                 }
 434
 435                 ret = MEDIA_CONTENT_ERROR_NONE;
 436         } else {
 437                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 438                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 439         }
 440
 441         return ret;
 442 }
 443
 444 int media_pvr_get_synopsis(media_pvr_h pvr, char **synopsis)
 445 {
 446         int ret = MEDIA_CONTENT_ERROR_NONE;
 447         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 448
 449         if (_pvr && synopsis) {
 450                 if (STRING_VALID(_pvr->synopsis)) {
 451                         *synopsis = strdup(_pvr->synopsis);
 452                         if (*synopsis == NULL) {
 453                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 454                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 455                         }
 456                 } else {
 457                         *synopsis = NULL;
 458                 }
 459
 460                 ret = MEDIA_CONTENT_ERROR_NONE;
 461         } else {
 462                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 463                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 464         }
 465
 466         return ret;
 467 }
 468
 469 int media_pvr_get_genre(media_pvr_h pvr, char **genre)
 470 {
 471         int ret = MEDIA_CONTENT_ERROR_NONE;
 472         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 473
 474         if (_pvr && genre) {
 475                 if (STRING_VALID(_pvr->genre)) {
 476                         *genre = strdup(_pvr->genre);
 477                         if (*genre == NULL) {
 478                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 479                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 480                         }
 481                 } else {
 482                         *genre = NULL;
 483                 }
 484
 485                 ret = MEDIA_CONTENT_ERROR_NONE;
 486         } else {
 487                 media_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_pvr_get_language(media_pvr_h pvr, char **language)
 495 {
 496         int ret = MEDIA_CONTENT_ERROR_NONE;
 497         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 498
 499         if (_pvr && language) {
 500                 if (STRING_VALID(_pvr->language)) {
 501                         *language = strdup(_pvr->language);
 502                         if (*language == NULL) {
 503                                 media_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                         *language = NULL;
 508                 }
 509
 510                 ret = MEDIA_CONTENT_ERROR_NONE;
 511         } else {
 512                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 513                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 514         }
 515
 516         return ret;
 517 }
 518
 519 int media_pvr_get_path(media_pvr_h pvr, char **path)
 520 {
 521         int ret = MEDIA_CONTENT_ERROR_NONE;
 522         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 523
 524         if (_pvr && path) {
 525                 if (STRING_VALID(_pvr->path)) {
 526                         *path = strdup(_pvr->path);
 527                         if (*path == NULL) {
 528                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 529                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 530                         }
 531                 } else {
 532                         *path = NULL;
 533                 }
 534
 535                 ret = MEDIA_CONTENT_ERROR_NONE;
 536         } else {
 537                 media_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_pvr_get_storage_id(media_pvr_h pvr, char **storage_id)
 545 {
 546         int ret = MEDIA_CONTENT_ERROR_NONE;
 547         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 548
 549         if (_pvr && storage_id) {
 550                 if (STRING_VALID(_pvr->storage_id)) {
 551                         *storage_id = strdup(_pvr->storage_id);
 552                         if (*storage_id == NULL) {
 553                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 554                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 555                         }
 556                 } else {
 557                         *storage_id = NULL;
 558                 }
 559
 560                 ret = MEDIA_CONTENT_ERROR_NONE;
 561         } else {
 562                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 563                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 564         }
 565
 566         return ret;
 567 }
 568
 569 int media_pvr_get_size(media_pvr_h pvr, unsigned long long *size)
 570 {
 571         int ret = MEDIA_CONTENT_ERROR_NONE;
 572         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 573
 574         if (_pvr && size) {
 575                 *size = _pvr->size;
 576                 ret = MEDIA_CONTENT_ERROR_NONE;
 577         } else {
 578                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 579                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 580         }
 581
 582         return ret;
 583 }
 584
 585 int media_pvr_get_timezone(media_pvr_h pvr, int *timezone)
 586 {
 587         int ret = MEDIA_CONTENT_ERROR_NONE;
 588         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 589
 590         if (_pvr && timezone) {
 591                 *timezone = _pvr->timezone;
 592                 ret = MEDIA_CONTENT_ERROR_NONE;
 593         } else {
 594                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 595                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 596         }
 597
 598         return ret;
 599 }
 600
 601 int media_pvr_get_ptc(media_pvr_h pvr, int *ptc)
 602 {
 603         int ret = MEDIA_CONTENT_ERROR_NONE;
 604         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 605
 606         if (_pvr && ptc) {
 607                 *ptc = _pvr->ptc;
 608                 ret = MEDIA_CONTENT_ERROR_NONE;
 609         } else {
 610                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 611                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 612         }
 613
 614         return ret;
 615 }
 616
 617 int media_pvr_get_major(media_pvr_h pvr, int *major)
 618 {
 619         int ret = MEDIA_CONTENT_ERROR_NONE;
 620         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 621
 622         if (_pvr && major) {
 623                 *major = _pvr->major;
 624                 ret = MEDIA_CONTENT_ERROR_NONE;
 625         } else {
 626                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 627                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 628         }
 629
 630         return ret;
 631 }
 632
 633 int media_pvr_get_minor(media_pvr_h pvr, int *minor)
 634 {
 635         int ret = MEDIA_CONTENT_ERROR_NONE;
 636         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 637
 638         if (_pvr && minor) {
 639                 *minor = _pvr->minor;
 640                 ret = MEDIA_CONTENT_ERROR_NONE;
 641         } else {
 642                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 643                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 644         }
 645
 646         return ret;
 647 }
 648
 649 int media_pvr_get_channel_type(media_pvr_h pvr, int *channel_type)
 650 {
 651         int ret = MEDIA_CONTENT_ERROR_NONE;
 652         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 653
 654         if (_pvr && channel_type) {
 655                 *channel_type = _pvr->channel_type;
 656                 ret = MEDIA_CONTENT_ERROR_NONE;
 657         } else {
 658                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 659                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 660         }
 661
 662         return ret;
 663 }
 664
 665 int media_pvr_get_program_num(media_pvr_h pvr, int *program_num)
 666 {
 667         int ret = MEDIA_CONTENT_ERROR_NONE;
 668         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 669
 670         if (_pvr && program_num) {
 671                 *program_num = _pvr->program_num;
 672                 ret = MEDIA_CONTENT_ERROR_NONE;
 673         } else {
 674                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 675                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 676         }
 677
 678         return ret;
 679 }
 680
 681 int media_pvr_get_duration(media_pvr_h pvr, int *duration)
 682 {
 683         int ret = MEDIA_CONTENT_ERROR_NONE;
 684         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 685
 686         if (_pvr && duration) {
 687                 *duration = _pvr->duration;
 688                 ret = MEDIA_CONTENT_ERROR_NONE;
 689         } else {
 690                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 691                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 692         }
 693
 694         return ret;
 695 }
 696
 697 int media_pvr_get_embargo_time(media_pvr_h pvr, int *embargo_time)
 698 {
 699         int ret = MEDIA_CONTENT_ERROR_NONE;
 700         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 701
 702         if (_pvr && embargo_time) {
 703                 *embargo_time = _pvr->embargo_time;
 704                 ret = MEDIA_CONTENT_ERROR_NONE;
 705         } else {
 706                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 707                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 708         }
 709
 710         return ret;
 711 }
 712
 713 int media_pvr_get_expiry_time(media_pvr_h pvr, int *expiry_time)
 714 {
 715         int ret = MEDIA_CONTENT_ERROR_NONE;
 716         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 717
 718         if (_pvr && expiry_time) {
 719                 *expiry_time = _pvr->expiry_time;
 720                 ret = MEDIA_CONTENT_ERROR_NONE;
 721         } else {
 722                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 723                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 724         }
 725
 726         return ret;
 727 }
 728
 729 int media_pvr_get_parental_rating(media_pvr_h pvr, int *parental_rating)
 730 {
 731         int ret = MEDIA_CONTENT_ERROR_NONE;
 732         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 733
 734         if (_pvr && parental_rating) {
 735                 *parental_rating = _pvr->parental_rating;
 736                 ret = MEDIA_CONTENT_ERROR_NONE;
 737         } else {
 738                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 739                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 740         }
 741
 742         return ret;
 743 }
 744
 745 int media_pvr_get_start_time(media_pvr_h pvr, int *start_time)
 746 {
 747         int ret = MEDIA_CONTENT_ERROR_NONE;
 748         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 749
 750         if (_pvr && start_time) {
 751                 *start_time = _pvr->start_time;
 752                 ret = MEDIA_CONTENT_ERROR_NONE;
 753         } else {
 754                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 755                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 756         }
 757
 758         return ret;
 759 }
 760
 761 int media_pvr_get_program_start_time(media_pvr_h pvr, int *program_start_time)
 762 {
 763         int ret = MEDIA_CONTENT_ERROR_NONE;
 764         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 765
 766         if (_pvr && program_start_time) {
 767                 *program_start_time = _pvr->program_start_time;
 768                 ret = MEDIA_CONTENT_ERROR_NONE;
 769         } else {
 770                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 771                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 772         }
 773
 774         return ret;
 775 }
 776
 777 int media_pvr_get_program_end_time(media_pvr_h pvr, int *end_time)
 778 {
 779         int ret = MEDIA_CONTENT_ERROR_NONE;
 780         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 781
 782         if (_pvr && end_time) {
 783                 *end_time = _pvr->program_end_time;
 784                 ret = MEDIA_CONTENT_ERROR_NONE;
 785         } else {
 786                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 787                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 788         }
 789
 790         return ret;
 791 }
 792
 793 int media_pvr_get_program_date(media_pvr_h pvr, int *program_date)
 794 {
 795         int ret = MEDIA_CONTENT_ERROR_NONE;
 796         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 797
 798         if (_pvr && program_date) {
 799                 *program_date = _pvr->program_date;
 800                 ret = MEDIA_CONTENT_ERROR_NONE;
 801         } else {
 802                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 803                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 804         }
 805
 806         return ret;
 807 }
 808
 809 int media_pvr_get_timer_record(media_pvr_h pvr, bool* timer_record)
 810 {
 811         int ret = MEDIA_CONTENT_ERROR_NONE;
 812         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 813
 814         if (_pvr && timer_record) {
 815                 *timer_record = _pvr->timer_record;
 816                 ret = MEDIA_CONTENT_ERROR_NONE;
 817         } else {
 818                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 819                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 820         }
 821
 822         return ret;
 823 }
 824
 825 int media_pvr_get_series_record(media_pvr_h pvr, bool* series_record)
 826 {
 827         int ret = MEDIA_CONTENT_ERROR_NONE;
 828         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 829
 830         if (_pvr && series_record) {
 831                 *series_record = _pvr->series_record;
 832                 ret = MEDIA_CONTENT_ERROR_NONE;
 833         } else {
 834                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 835                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 836         }
 837
 838         return ret;
 839 }
 840
 841 int media_pvr_get_hd(media_pvr_h pvr, int* hd)
 842 {
 843         int ret = MEDIA_CONTENT_ERROR_NONE;
 844         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 845
 846         if (_pvr && hd) {
 847                 *hd = _pvr->hd;
 848                 ret = MEDIA_CONTENT_ERROR_NONE;
 849         } else {
 850                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 851                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 852         }
 853
 854         return ret;
 855 }
 856
 857 int media_pvr_get_subtitle(media_pvr_h pvr, bool* subtitle)
 858 {
 859         int ret = MEDIA_CONTENT_ERROR_NONE;
 860         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 861
 862         if (_pvr && subtitle) {
 863                 *subtitle = _pvr->subtitle;
 864                 ret = MEDIA_CONTENT_ERROR_NONE;
 865         } else {
 866                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 867                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 868         }
 869
 870         return ret;
 871 }
 872
 873 int media_pvr_get_ttx(media_pvr_h pvr, bool* ttx)
 874 {
 875         int ret = MEDIA_CONTENT_ERROR_NONE;
 876         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 877
 878         if (_pvr && ttx) {
 879                 *ttx = _pvr->ttx;
 880                 ret = MEDIA_CONTENT_ERROR_NONE;
 881         } else {
 882                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 883                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 884         }
 885
 886         return ret;
 887 }
 888
 889 int media_pvr_get_ad(media_pvr_h pvr, bool* ad)
 890 {
 891         int ret = MEDIA_CONTENT_ERROR_NONE;
 892         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 893
 894         if (_pvr && ad) {
 895                 *ad = _pvr->ad;
 896                 ret = MEDIA_CONTENT_ERROR_NONE;
 897         } else {
 898                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 899                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 900         }
 901
 902         return ret;
 903 }
 904
 905 int media_pvr_get_hard_of_hearing_radio(media_pvr_h pvr, bool* hard_of_hearing_radio)
 906 {
 907         int ret = MEDIA_CONTENT_ERROR_NONE;
 908         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 909
 910         if (_pvr && hard_of_hearing_radio) {
 911                 *hard_of_hearing_radio = _pvr->hard_of_hearing_radio;
 912                 ret = MEDIA_CONTENT_ERROR_NONE;
 913         } else {
 914                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 915                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 916         }
 917
 918         return ret;
 919 }
 920
 921 int media_pvr_get_data_service(media_pvr_h pvr, bool* data_service)
 922 {
 923         int ret = MEDIA_CONTENT_ERROR_NONE;
 924         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 925
 926         if (_pvr && data_service) {
 927                 *data_service = _pvr->data_service;
 928                 ret = MEDIA_CONTENT_ERROR_NONE;
 929         } else {
 930                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 931                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 932         }
 933
 934         return ret;
 935 }
 936
 937 int media_pvr_get_content_lock(media_pvr_h pvr, bool* content_lock)
 938 {
 939         int ret = MEDIA_CONTENT_ERROR_NONE;
 940         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 941
 942         if (_pvr && content_lock) {
 943                 *content_lock = _pvr->content_lock;
 944                 ret = MEDIA_CONTENT_ERROR_NONE;
 945         } else {
 946                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 947                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 948         }
 949
 950         return ret;
 951 }
 952
 953 int media_pvr_get_content_watch(media_pvr_h pvr, bool* content_watch)
 954 {
 955         int ret = MEDIA_CONTENT_ERROR_NONE;
 956         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 957
 958         if (_pvr && content_watch) {
 959                 *content_watch = _pvr->content_watch;
 960                 ret = MEDIA_CONTENT_ERROR_NONE;
 961         } else {
 962                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 963                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 964         }
 965
 966         return ret;
 967 }
 968
 969 int media_pvr_get_has_audio_only(media_pvr_h pvr, bool* has_audio_only)
 970 {
 971         int ret = MEDIA_CONTENT_ERROR_NONE;
 972         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 973
 974         if (_pvr && has_audio_only) {
 975                 *has_audio_only = _pvr->has_audio_only;
 976                 ret = MEDIA_CONTENT_ERROR_NONE;
 977         } else {
 978                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 979                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 980         }
 981
 982         return ret;
 983 }
 984
 985 int media_pvr_get_is_local_record(media_pvr_h pvr, bool* is_local_record)
 986 {
 987         int ret = MEDIA_CONTENT_ERROR_NONE;
 988         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 989
 990         if (_pvr && is_local_record) {
 991                 *is_local_record = _pvr->is_local_record;
 992                 ret = MEDIA_CONTENT_ERROR_NONE;
 993         } else {
 994                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 995                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 996         }
 997
 998         return ret;
 999 }
1000
1001 int media_pvr_get_resolution(media_pvr_h pvr, media_pvr_resolution_e* resolution)
1002 {
1003         int ret = MEDIA_CONTENT_ERROR_NONE;
1004         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1005
1006         if (_pvr && resolution) {
1007                 *resolution = _pvr->resolution;
1008                 ret = MEDIA_CONTENT_ERROR_NONE;
1009         } else {
1010                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1011                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1012         }
1013
1014         return ret;
1015 }
1016
1017 int media_pvr_get_aspectratio(media_pvr_h pvr, media_pvr_aspectratio_e* aspectratio)
1018 {
1019         int ret = MEDIA_CONTENT_ERROR_NONE;
1020         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1021
1022         if (_pvr && aspectratio) {
1023                 *aspectratio = _pvr->aspectratio;
1024                 ret = MEDIA_CONTENT_ERROR_NONE;
1025         } else {
1026                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1027                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1028         }
1029
1030         return ret;
1031 }
1032
1033 int media_pvr_get_modified_month(media_pvr_h pvr, char **modified_month)
1034 {
1035         int ret = MEDIA_CONTENT_ERROR_NONE;
1036         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1037
1038         if (_pvr && modified_month) {
1039                 if (STRING_VALID(_pvr->modified_month)) {
1040                         *modified_month = strdup(_pvr->modified_month);
1041                         if (*modified_month == NULL) {
1042                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1043                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1044                         }
1045                 } else {
1046                         *modified_month = NULL;
1047                 }
1048
1049                 ret = MEDIA_CONTENT_ERROR_NONE;
1050         } else {
1051                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1052                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1053         }
1054
1055         return ret;
1056 }
1057
1058 int media_pvr_get_sports_type(media_pvr_h pvr, int* sports_type)
1059 {
1060         int ret = MEDIA_CONTENT_ERROR_NONE;
1061         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1062
1063         if (_pvr && sports_type) {
1064                 *sports_type = _pvr->sports_type;
1065                 ret = MEDIA_CONTENT_ERROR_NONE;
1066         } else {
1067                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1068                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1069         }
1070
1071         return ret;
1072 }
1073
1074 int media_pvr_get_guidance_length(media_pvr_h pvr, int* guidance_length)
1075 {
1076         int ret = MEDIA_CONTENT_ERROR_NONE;
1077         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1078
1079         if (_pvr && guidance_length) {
1080                 *guidance_length = _pvr->guidance_length;
1081                 ret = MEDIA_CONTENT_ERROR_NONE;
1082         } else {
1083                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1084                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1085         }
1086
1087         return ret;
1088 }
1089
1090 int media_pvr_get_tvmode(media_pvr_h pvr, int* tvmode)
1091 {
1092         int ret = MEDIA_CONTENT_ERROR_NONE;
1093         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1094
1095         if (_pvr && tvmode) {
1096                 *tvmode = _pvr->tvmode;
1097                 ret = MEDIA_CONTENT_ERROR_NONE;
1098         } else {
1099                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1100                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1101         }
1102
1103         return ret;
1104 }
1105
1106 int media_pvr_get_play_count(media_pvr_h pvr, int* play_count)
1107 {
1108         int ret = MEDIA_CONTENT_ERROR_NONE;
1109         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1110
1111         if (_pvr && play_count) {
1112                 *play_count = _pvr->play_count;
1113                 ret = MEDIA_CONTENT_ERROR_NONE;
1114         } else {
1115                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1116                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1117         }
1118
1119         return ret;
1120 }
1121
1122 int media_pvr_get_private_data(media_pvr_h pvr, char **private_data)
1123 {
1124         int ret = MEDIA_CONTENT_ERROR_NONE;
1125         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1126
1127         if (_pvr && private_data) {
1128                 if (STRING_VALID(_pvr->private_data)) {
1129                         *private_data = strdup(_pvr->private_data);
1130                         if (*private_data == NULL) {
1131                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1132                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1133                         }
1134                 } else {
1135                         *private_data = NULL;
1136                 }
1137
1138                 ret = MEDIA_CONTENT_ERROR_NONE;
1139         } else {
1140                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1141                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1142         }
1143
1144         return ret;
1145 }
1146
1147 int media_pvr_get_highlight(media_pvr_h pvr, bool *highlight)
1148 {
1149         int ret = MEDIA_CONTENT_ERROR_NONE;
1150         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1151
1152         if (_pvr && highlight) {
1153                 *highlight = _pvr->highlight;
1154                 ret = MEDIA_CONTENT_ERROR_NONE;
1155         } else {
1156                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1157                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1158         }
1159
1160         return ret;
1161 }
1162
1163 int media_pvr_set_play_count(media_pvr_h pvr, int play_count)
1164 {
1165         int ret = MEDIA_CONTENT_ERROR_NONE;
1166         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1167
1168         if (_pvr != NULL) {
1169                 _pvr->play_count = play_count;
1170         } else {
1171                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1172                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1173         }
1174
1175         return ret;
1176 }
1177
1178 int media_pvr_set_program_title(media_pvr_h pvr, const char *program_title)
1179 {
1180         int ret = MEDIA_CONTENT_ERROR_NONE;
1181         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1182
1183         if (_pvr != NULL && STRING_VALID(program_title)) {
1184                 SAFE_FREE(_pvr->program_title);
1185                 _pvr->program_title = strdup(program_title);
1186                 if (_pvr->program_title == NULL) {
1187                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
1188                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
1189                 }
1190         } else {
1191                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1192                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1193         }
1194
1195         return ret;
1196 }
1197
1198 int media_pvr_set_content_lock(media_pvr_h pvr, bool content_lock)
1199 {
1200         int ret = MEDIA_CONTENT_ERROR_NONE;
1201         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1202
1203         if (_pvr != NULL) {
1204                 _pvr->content_lock = content_lock;
1205         } else {
1206                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1207                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1208         }
1209
1210         return ret;
1211 }
1212
1213 int media_pvr_set_content_watch(media_pvr_h pvr, bool content_watch)
1214 {
1215         int ret = MEDIA_CONTENT_ERROR_NONE;
1216         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1217
1218         if (_pvr != NULL) {
1219                 _pvr->content_watch = content_watch;
1220         } else {
1221                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1222                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1223         }
1224
1225         return ret;
1226 }
1227
1228 int media_pvr_set_highlight(media_pvr_h pvr, bool highlight)
1229 {
1230         int ret = MEDIA_CONTENT_ERROR_NONE;
1231         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1232
1233         if (_pvr != NULL) {
1234                 _pvr->highlight = highlight;
1235         } else {
1236                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1237                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1238         }
1239
1240         return ret;
1241 }
1242
1243 int media_pvr_update_to_db(media_pvr_h pvr)
1244 {
1245         int ret = MEDIA_CONTENT_ERROR_NONE;
1246         media_pvr_s *_pvr = (media_pvr_s*)pvr;
1247         char *update_query = NULL;
1248
1249         if (_pvr != NULL && STRING_VALID(_pvr->media_id) && STRING_VALID(_pvr->path)) {
1250                 update_query = sqlite3_mprintf(UPDATE_PVR_META_FROM_PVR, _pvr->program_title, _pvr->content_lock, _pvr->content_watch, _pvr->play_count, _pvr->highlight, _pvr->media_id);
1251
1252                 ret = _content_query_sql(update_query);
1253                 sqlite3_free(update_query);
1254
1255                 if (ret == MEDIA_CONTENT_ERROR_NONE)
1256                         media_svc_update_pvr_info(_content_get_db_handle(), _pvr->path, _pvr->program_title, _pvr->content_lock);
1257         } else {
1258                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1259                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1260         }
1261
1262         return ret;
1263 }
1264
1265 int media_pvr_group_foreach_media_from_db(const char *group_name, media_group_e group, filter_h filter, media_pvr_cb callback, void *user_data)
1266 {
1267         int ret = MEDIA_CONTENT_ERROR_NONE;
1268
1269         if ((callback == NULL) || (group < MEDIA_PVR_GROUP_DURATION) || (group >= MEDIA_GROUP_MAX)) {
1270                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1271                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1272         } else {
1273                 ret = _media_db_get_pvr_group_item(group_name, filter, group, callback, user_data);
1274         }
1275
1276         return ret;
1277 }
1278
1279 int media_pvr_set_is_local_record(const char *pvr_path, bool is_local_record)
1280 {
1281         int ret = MEDIA_CONTENT_ERROR_NONE;
1282         char *update_query = NULL;
1283         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0,};
1284
1285         if (pvr_path == NULL) {
1286                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1287                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1288         } else {
1289
1290                 /*get the storage uuid*/
1291                 ret = media_svc_get_storage_id(_content_get_db_handle(), pvr_path, storage_id, tzplatform_getuid(TZ_USER_NAME));
1292                 if (ret == MS_MEDIA_ERR_NONE) {
1293                         media_content_error("storage uuid [%s]", storage_id);
1294                         update_query = sqlite3_mprintf(UPDATE_PVR_LOCAL_RECORD_PVR, is_local_record, pvr_path, storage_id);
1295
1296                         ret = _content_query_sql(update_query);
1297                         sqlite3_free(update_query);
1298                 } else {
1299                         media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1300                         media_content_error("pvr path[%s] error[%d]", pvr_path, ret);
1301                         ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1302                 }
1303         }
1304
1305         return ret;
1306 }
1307 #endif