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                 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                 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                 g_free(_pvr->media_id);
  57                 g_free(_pvr->storage_id);
  58                 g_free(_pvr->channel_name);
  59                 g_free(_pvr->channel_num);
  60                 g_free(_pvr->program_title);
  61                 g_free(_pvr->program_crid);
  62                 g_free(_pvr->guidance);
  63                 g_free(_pvr->synopsis);
  64                 g_free(_pvr->genre);
  65                 g_free(_pvr->language);
  66                 g_free(_pvr->path);
  67                 g_free(_pvr->modified_month);
  68                 g_free(_pvr->private_data);
  69                 g_free(_pvr);
  70
  71                 ret = MEDIA_CONTENT_ERROR_NONE;
  72         } else {
  73                 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         media_pvr_s *_src = (media_pvr_s*)src;
  83
  84         content_retip_if_fail(dst);
  85         content_retip_if_fail(src);
  86
  87         media_pvr_s *_dst = g_new0(media_pvr_s, 1);
  88
  89         _dst->media_id = g_strdup(_src->media_id);
  90         _dst->channel_name = g_strdup(_src->channel_name);
  91         _dst->channel_num = g_strdup(_src->channel_num);
  92         _dst->program_title = g_strdup(_src->program_title);
  93         _dst->program_crid = g_strdup(_src->program_crid);
  94         _dst->guidance = g_strdup(_src->guidance);
  95         _dst->synopsis = g_strdup(_src->synopsis);
  96         _dst->genre = g_strdup(_src->genre);
  97         _dst->language = g_strdup(_src->language);
  98         _dst->path = g_strdup(_src->path);
  99         _dst->storage_id = g_strdup(_src->storage_id);
 100         _dst->modified_month = g_strdup(_src->modified_month);
 101         _dst->private_data = g_strdup(_src->private_data);
 102         _dst->duration = _src->duration;
 103         _dst->timezone = _src->timezone;
 104         _dst->ptc = _src->ptc;
 105         _dst->major = _src->major;
 106         _dst->minor = _src->minor;
 107         _dst->channel_type = _src->channel_type;
 108         _dst->program_num = _src->program_num;
 109         _dst->service_profile = _src->service_profile;
 110         _dst->timer_record = _src->timer_record;
 111         _dst->series_record = _src->series_record;
 112         _dst->hd = _src->hd;
 113         _dst->subtitle = _src->subtitle;
 114         _dst->ttx = _src->ttx;
 115         _dst->ad = _src->ad;
 116         _dst->hard_of_hearing_radio = _src->hard_of_hearing_radio;
 117         _dst->data_service = _src->data_service;
 118         _dst->content_lock = _src->content_lock;
 119         _dst->embargo_time = _src->embargo_time;
 120         _dst->expiry_time = _src->expiry_time;
 121         _dst->size = _src->size;
 122         _dst->parental_rating = _src->parental_rating;
 123         _dst->start_time = _src->start_time;
 124         _dst->program_start_time = _src->program_start_time;
 125         _dst->program_end_time = _src->program_end_time;
 126         _dst->program_date = _src->program_date;
 127         _dst->content_watch = _src->content_watch;
 128         _dst->has_audio_only = _src->has_audio_only;
 129         _dst->is_local_record = _src->is_local_record;
 130         _dst->resolution = _src->resolution;
 131         _dst->aspectratio = _src->aspectratio;
 132         _dst->sports_type = _src->sports_type;
 133         _dst->guidance_length = _src->guidance_length;
 134         _dst->tvmode = _src->tvmode;
 135         _dst->play_count = _src->play_count;
 136
 137         *dst = (media_pvr_h)_dst;
 138
 139         return MEDIA_CONTENT_ERROR_NONE;
 140 }
 141
 142 int media_pvr_get_pvr_from_db(const char *media_id, media_pvr_h *pvr)
 143 {
 144         int ret = MEDIA_CONTENT_ERROR_NONE;
 145         char *select_query = NULL;
 146         sqlite3_stmt *stmt = NULL;
 147
 148         if (!STRING_VALID(media_id) || (pvr == NULL)) {
 149                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 150                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 151         }
 152
 153         select_query = sqlite3_mprintf(SELECT_PVR_FROM_PVR, media_id);
 154
 155         ret = _content_get_result(select_query, &stmt);
 156         sqlite3_free(select_query);
 157         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 158
 159         media_pvr_s *_pvr = NULL;
 160
 161         if (sqlite3_step(stmt) == SQLITE_ROW) {
 162                 _pvr = g_new0(media_pvr_s, 1);
 163
 164                 _media_pvr_item_get_detail(stmt, (media_pvr_h)_pvr);
 165
 166                 *pvr = (media_info_h)_pvr;
 167         } else {
 168                 content_error("Nonexistent media_id[%s]", media_id);
 169                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 170         }
 171
 172         SQLITE3_FINALIZE(stmt);
 173
 174         return ret;
 175 }
 176
 177 int media_pvr_get_media_id(media_pvr_h pvr, char **media_id)
 178 {
 179         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 180
 181         content_retip_if_fail(pvr);
 182         content_retip_if_fail(media_id);
 183
 184         *media_id = g_strdup(_pvr->media_id);
 185
 186         return MEDIA_CONTENT_ERROR_NONE;
 187 }
 188
 189 int media_pvr_get_channel_name(media_pvr_h pvr, char **channel_name)
 190 {
 191         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 192
 193         content_retip_if_fail(pvr);
 194         content_retip_if_fail(channel_name);
 195
 196         *channel_name = g_strdup(_pvr->channel_name);
 197
 198         return MEDIA_CONTENT_ERROR_NONE;
 199 }
 200
 201 int media_pvr_get_channel_num(media_pvr_h pvr, char **channel_num)
 202 {
 203         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 204
 205         content_retip_if_fail(pvr);
 206         content_retip_if_fail(channel_num);
 207
 208         *channel_num = g_strdup(_pvr->channel_num);
 209
 210         return MEDIA_CONTENT_ERROR_NONE;
 211 }
 212
 213 int media_pvr_get_program_title(media_pvr_h pvr, char **program_title)
 214 {
 215         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 216
 217         content_retip_if_fail(pvr);
 218         content_retip_if_fail(program_title);
 219
 220         *program_title = g_strdup(_pvr->program_title);
 221
 222         return MEDIA_CONTENT_ERROR_NONE;
 223 }
 224
 225 int media_pvr_get_program_crid(media_pvr_h pvr, char **program_crid)
 226 {
 227         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 228
 229         content_retip_if_fail(pvr);
 230         content_retip_if_fail(program_crid);
 231
 232         *program_crid = g_strdup(_pvr->program_crid);
 233
 234         return MEDIA_CONTENT_ERROR_NONE;
 235 }
 236
 237 int media_pvr_get_guidance(media_pvr_h pvr, char **guidance)
 238 {
 239         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 240
 241         content_retip_if_fail(pvr);
 242         content_retip_if_fail(guidance);
 243
 244         *guidance = g_strdup(_pvr->guidance);
 245
 246         return MEDIA_CONTENT_ERROR_NONE;
 247 }
 248
 249 int media_pvr_get_synopsis(media_pvr_h pvr, char **synopsis)
 250 {
 251         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 252
 253         content_retip_if_fail(pvr);
 254         content_retip_if_fail(synopsis);
 255
 256         *synopsis = g_strdup(_pvr->synopsis);
 257
 258         return MEDIA_CONTENT_ERROR_NONE;
 259 }
 260
 261 int media_pvr_get_genre(media_pvr_h pvr, char **genre)
 262 {
 263         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 264
 265         content_retip_if_fail(pvr);
 266         content_retip_if_fail(genre);
 267
 268         *genre = g_strdup(_pvr->genre);
 269
 270         return MEDIA_CONTENT_ERROR_NONE;
 271 }
 272
 273 int media_pvr_get_language(media_pvr_h pvr, char **language)
 274 {
 275         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 276
 277         content_retip_if_fail(pvr);
 278         content_retip_if_fail(language);
 279
 280         *language = g_strdup(_pvr->language);
 281
 282         return MEDIA_CONTENT_ERROR_NONE;
 283 }
 284
 285 int media_pvr_get_path(media_pvr_h pvr, char **path)
 286 {
 287         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 288
 289         content_retip_if_fail(pvr);
 290         content_retip_if_fail(path);
 291
 292         *path = g_strdup(_pvr->path);
 293
 294         return MEDIA_CONTENT_ERROR_NONE;
 295 }
 296
 297 int media_pvr_get_storage_id(media_pvr_h pvr, char **storage_id)
 298 {
 299         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 300
 301         content_retip_if_fail(pvr);
 302         content_retip_if_fail(storage_id);
 303
 304         *storage_id = g_strdup(_pvr->storage_id);
 305
 306         return MEDIA_CONTENT_ERROR_NONE;
 307 }
 308
 309 int media_pvr_get_size(media_pvr_h pvr, unsigned long long *size)
 310 {
 311         int ret = MEDIA_CONTENT_ERROR_NONE;
 312         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 313
 314         if (_pvr && size) {
 315                 *size = _pvr->size;
 316                 ret = MEDIA_CONTENT_ERROR_NONE;
 317         } else {
 318                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 319                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 320         }
 321
 322         return ret;
 323 }
 324
 325 int media_pvr_get_timezone(media_pvr_h pvr, int *timezone)
 326 {
 327         int ret = MEDIA_CONTENT_ERROR_NONE;
 328         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 329
 330         if (_pvr && timezone) {
 331                 *timezone = _pvr->timezone;
 332                 ret = MEDIA_CONTENT_ERROR_NONE;
 333         } else {
 334                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 335                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 336         }
 337
 338         return ret;
 339 }
 340
 341 int media_pvr_get_ptc(media_pvr_h pvr, int *ptc)
 342 {
 343         int ret = MEDIA_CONTENT_ERROR_NONE;
 344         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 345
 346         if (_pvr && ptc) {
 347                 *ptc = _pvr->ptc;
 348                 ret = MEDIA_CONTENT_ERROR_NONE;
 349         } else {
 350                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 351                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 352         }
 353
 354         return ret;
 355 }
 356
 357 int media_pvr_get_major(media_pvr_h pvr, int *major)
 358 {
 359         int ret = MEDIA_CONTENT_ERROR_NONE;
 360         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 361
 362         if (_pvr && major) {
 363                 *major = _pvr->major;
 364                 ret = MEDIA_CONTENT_ERROR_NONE;
 365         } else {
 366                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 367                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 368         }
 369
 370         return ret;
 371 }
 372
 373 int media_pvr_get_minor(media_pvr_h pvr, int *minor)
 374 {
 375         int ret = MEDIA_CONTENT_ERROR_NONE;
 376         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 377
 378         if (_pvr && minor) {
 379                 *minor = _pvr->minor;
 380                 ret = MEDIA_CONTENT_ERROR_NONE;
 381         } else {
 382                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 383                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 384         }
 385
 386         return ret;
 387 }
 388
 389 int media_pvr_get_channel_type(media_pvr_h pvr, int *channel_type)
 390 {
 391         int ret = MEDIA_CONTENT_ERROR_NONE;
 392         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 393
 394         if (_pvr && channel_type) {
 395                 *channel_type = _pvr->channel_type;
 396                 ret = MEDIA_CONTENT_ERROR_NONE;
 397         } else {
 398                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 399                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 400         }
 401
 402         return ret;
 403 }
 404
 405 int media_pvr_get_program_num(media_pvr_h pvr, int *program_num)
 406 {
 407         int ret = MEDIA_CONTENT_ERROR_NONE;
 408         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 409
 410         if (_pvr && program_num) {
 411                 *program_num = _pvr->program_num;
 412                 ret = MEDIA_CONTENT_ERROR_NONE;
 413         } else {
 414                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 415                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 416         }
 417
 418         return ret;
 419 }
 420
 421 int media_pvr_get_service_profile(media_pvr_h pvr, unsigned int *service_profile)
 422 {
 423         int ret = MEDIA_CONTENT_ERROR_NONE;
 424         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 425
 426         if (_pvr && service_profile) {
 427                 *service_profile = _pvr->service_profile;
 428                 ret = MEDIA_CONTENT_ERROR_NONE;
 429         } else {
 430                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 431                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 432         }
 433
 434         return ret;
 435 }
 436
 437 int media_pvr_get_duration(media_pvr_h pvr, int *duration)
 438 {
 439         int ret = MEDIA_CONTENT_ERROR_NONE;
 440         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 441
 442         if (_pvr && duration) {
 443                 *duration = _pvr->duration;
 444                 ret = MEDIA_CONTENT_ERROR_NONE;
 445         } else {
 446                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 447                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 448         }
 449
 450         return ret;
 451 }
 452
 453 int media_pvr_get_embargo_time(media_pvr_h pvr, int *embargo_time)
 454 {
 455         int ret = MEDIA_CONTENT_ERROR_NONE;
 456         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 457
 458         if (_pvr && embargo_time) {
 459                 *embargo_time = _pvr->embargo_time;
 460                 ret = MEDIA_CONTENT_ERROR_NONE;
 461         } else {
 462                 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_expiry_time(media_pvr_h pvr, int *expiry_time)
 470 {
 471         int ret = MEDIA_CONTENT_ERROR_NONE;
 472         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 473
 474         if (_pvr && expiry_time) {
 475                 *expiry_time = _pvr->expiry_time;
 476                 ret = MEDIA_CONTENT_ERROR_NONE;
 477         } else {
 478                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 479                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 480         }
 481
 482         return ret;
 483 }
 484
 485 int media_pvr_get_parental_rating(media_pvr_h pvr, int *parental_rating)
 486 {
 487         int ret = MEDIA_CONTENT_ERROR_NONE;
 488         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 489
 490         if (_pvr && parental_rating) {
 491                 *parental_rating = _pvr->parental_rating;
 492                 ret = MEDIA_CONTENT_ERROR_NONE;
 493         } else {
 494                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 495                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 496         }
 497
 498         return ret;
 499 }
 500
 501 int media_pvr_get_start_time(media_pvr_h pvr, int *start_time)
 502 {
 503         int ret = MEDIA_CONTENT_ERROR_NONE;
 504         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 505
 506         if (_pvr && start_time) {
 507                 *start_time = _pvr->start_time;
 508                 ret = MEDIA_CONTENT_ERROR_NONE;
 509         } else {
 510                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 511                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 512         }
 513
 514         return ret;
 515 }
 516
 517 int media_pvr_get_program_start_time(media_pvr_h pvr, int *program_start_time)
 518 {
 519         int ret = MEDIA_CONTENT_ERROR_NONE;
 520         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 521
 522         if (_pvr && program_start_time) {
 523                 *program_start_time = _pvr->program_start_time;
 524                 ret = MEDIA_CONTENT_ERROR_NONE;
 525         } else {
 526                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 527                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 528         }
 529
 530         return ret;
 531 }
 532
 533 int media_pvr_get_program_end_time(media_pvr_h pvr, int *end_time)
 534 {
 535         int ret = MEDIA_CONTENT_ERROR_NONE;
 536         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 537
 538         if (_pvr && end_time) {
 539                 *end_time = _pvr->program_end_time;
 540                 ret = MEDIA_CONTENT_ERROR_NONE;
 541         } else {
 542                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 543                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 544         }
 545
 546         return ret;
 547 }
 548
 549 int media_pvr_get_program_date(media_pvr_h pvr, int *program_date)
 550 {
 551         int ret = MEDIA_CONTENT_ERROR_NONE;
 552         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 553
 554         if (_pvr && program_date) {
 555                 *program_date = _pvr->program_date;
 556                 ret = MEDIA_CONTENT_ERROR_NONE;
 557         } else {
 558                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 559                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 560         }
 561
 562         return ret;
 563 }
 564
 565 int media_pvr_get_timer_record(media_pvr_h pvr, bool* timer_record)
 566 {
 567         int ret = MEDIA_CONTENT_ERROR_NONE;
 568         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 569
 570         if (_pvr && timer_record) {
 571                 *timer_record = _pvr->timer_record;
 572                 ret = MEDIA_CONTENT_ERROR_NONE;
 573         } else {
 574                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 575                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 576         }
 577
 578         return ret;
 579 }
 580
 581 int media_pvr_get_series_record(media_pvr_h pvr, bool* series_record)
 582 {
 583         int ret = MEDIA_CONTENT_ERROR_NONE;
 584         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 585
 586         if (_pvr && series_record) {
 587                 *series_record = _pvr->series_record;
 588                 ret = MEDIA_CONTENT_ERROR_NONE;
 589         } else {
 590                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 591                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 592         }
 593
 594         return ret;
 595 }
 596
 597 int media_pvr_get_hd(media_pvr_h pvr, int* hd)
 598 {
 599         int ret = MEDIA_CONTENT_ERROR_NONE;
 600         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 601
 602         if (_pvr && hd) {
 603                 *hd = _pvr->hd;
 604                 ret = MEDIA_CONTENT_ERROR_NONE;
 605         } else {
 606                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 607                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 608         }
 609
 610         return ret;
 611 }
 612
 613 int media_pvr_get_subtitle(media_pvr_h pvr, bool* subtitle)
 614 {
 615         int ret = MEDIA_CONTENT_ERROR_NONE;
 616         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 617
 618         if (_pvr && subtitle) {
 619                 *subtitle = _pvr->subtitle;
 620                 ret = MEDIA_CONTENT_ERROR_NONE;
 621         } else {
 622                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 623                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 624         }
 625
 626         return ret;
 627 }
 628
 629 int media_pvr_get_ttx(media_pvr_h pvr, bool* ttx)
 630 {
 631         int ret = MEDIA_CONTENT_ERROR_NONE;
 632         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 633
 634         if (_pvr && ttx) {
 635                 *ttx = _pvr->ttx;
 636                 ret = MEDIA_CONTENT_ERROR_NONE;
 637         } else {
 638                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 639                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 640         }
 641
 642         return ret;
 643 }
 644
 645 int media_pvr_get_ad(media_pvr_h pvr, bool* ad)
 646 {
 647         int ret = MEDIA_CONTENT_ERROR_NONE;
 648         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 649
 650         if (_pvr && ad) {
 651                 *ad = _pvr->ad;
 652                 ret = MEDIA_CONTENT_ERROR_NONE;
 653         } else {
 654                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 655                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 656         }
 657
 658         return ret;
 659 }
 660
 661 int media_pvr_get_hard_of_hearing_radio(media_pvr_h pvr, bool* hard_of_hearing_radio)
 662 {
 663         int ret = MEDIA_CONTENT_ERROR_NONE;
 664         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 665
 666         if (_pvr && hard_of_hearing_radio) {
 667                 *hard_of_hearing_radio = _pvr->hard_of_hearing_radio;
 668                 ret = MEDIA_CONTENT_ERROR_NONE;
 669         } else {
 670                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 671                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 672         }
 673
 674         return ret;
 675 }
 676
 677 int media_pvr_get_data_service(media_pvr_h pvr, bool* data_service)
 678 {
 679         int ret = MEDIA_CONTENT_ERROR_NONE;
 680         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 681
 682         if (_pvr && data_service) {
 683                 *data_service = _pvr->data_service;
 684                 ret = MEDIA_CONTENT_ERROR_NONE;
 685         } else {
 686                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 687                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 688         }
 689
 690         return ret;
 691 }
 692
 693 int media_pvr_get_content_lock(media_pvr_h pvr, bool* content_lock)
 694 {
 695         int ret = MEDIA_CONTENT_ERROR_NONE;
 696         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 697
 698         if (_pvr && content_lock) {
 699                 *content_lock = _pvr->content_lock;
 700                 ret = MEDIA_CONTENT_ERROR_NONE;
 701         } else {
 702                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 703                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 704         }
 705
 706         return ret;
 707 }
 708
 709 int media_pvr_get_content_watch(media_pvr_h pvr, bool* content_watch)
 710 {
 711         int ret = MEDIA_CONTENT_ERROR_NONE;
 712         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 713
 714         if (_pvr && content_watch) {
 715                 *content_watch = _pvr->content_watch;
 716                 ret = MEDIA_CONTENT_ERROR_NONE;
 717         } else {
 718                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 719                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 720         }
 721
 722         return ret;
 723 }
 724
 725 int media_pvr_get_has_audio_only(media_pvr_h pvr, bool* has_audio_only)
 726 {
 727         int ret = MEDIA_CONTENT_ERROR_NONE;
 728         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 729
 730         if (_pvr && has_audio_only) {
 731                 *has_audio_only = _pvr->has_audio_only;
 732                 ret = MEDIA_CONTENT_ERROR_NONE;
 733         } else {
 734                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 735                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 736         }
 737
 738         return ret;
 739 }
 740
 741 int media_pvr_get_is_local_record(media_pvr_h pvr, bool* is_local_record)
 742 {
 743         int ret = MEDIA_CONTENT_ERROR_NONE;
 744         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 745
 746         if (_pvr && is_local_record) {
 747                 *is_local_record = _pvr->is_local_record;
 748                 ret = MEDIA_CONTENT_ERROR_NONE;
 749         } else {
 750                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 751                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 752         }
 753
 754         return ret;
 755 }
 756
 757 int media_pvr_get_resolution(media_pvr_h pvr, media_pvr_resolution_e* resolution)
 758 {
 759         int ret = MEDIA_CONTENT_ERROR_NONE;
 760         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 761
 762         if (_pvr && resolution) {
 763                 *resolution = _pvr->resolution;
 764                 ret = MEDIA_CONTENT_ERROR_NONE;
 765         } else {
 766                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 767                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 768         }
 769
 770         return ret;
 771 }
 772
 773 int media_pvr_get_aspectratio(media_pvr_h pvr, media_pvr_aspectratio_e* aspectratio)
 774 {
 775         int ret = MEDIA_CONTENT_ERROR_NONE;
 776         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 777
 778         if (_pvr && aspectratio) {
 779                 *aspectratio = _pvr->aspectratio;
 780                 ret = MEDIA_CONTENT_ERROR_NONE;
 781         } else {
 782                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 783                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 784         }
 785
 786         return ret;
 787 }
 788
 789 int media_pvr_get_modified_month(media_pvr_h pvr, char **modified_month)
 790 {
 791         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 792
 793         content_retip_if_fail(pvr);
 794         content_retip_if_fail(modified_month);
 795
 796         *modified_month = g_strdup(_pvr->modified_month);
 797
 798         return MEDIA_CONTENT_ERROR_NONE;
 799 }
 800
 801 int media_pvr_get_sports_type(media_pvr_h pvr, int* sports_type)
 802 {
 803         int ret = MEDIA_CONTENT_ERROR_NONE;
 804         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 805
 806         if (_pvr && sports_type) {
 807                 *sports_type = _pvr->sports_type;
 808                 ret = MEDIA_CONTENT_ERROR_NONE;
 809         } else {
 810                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 811                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 812         }
 813
 814         return ret;
 815 }
 816
 817 int media_pvr_get_guidance_length(media_pvr_h pvr, int* guidance_length)
 818 {
 819         int ret = MEDIA_CONTENT_ERROR_NONE;
 820         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 821
 822         if (_pvr && guidance_length) {
 823                 *guidance_length = _pvr->guidance_length;
 824                 ret = MEDIA_CONTENT_ERROR_NONE;
 825         } else {
 826                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 827                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 828         }
 829
 830         return ret;
 831 }
 832
 833 int media_pvr_get_tvmode(media_pvr_h pvr, int* tvmode)
 834 {
 835         int ret = MEDIA_CONTENT_ERROR_NONE;
 836         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 837
 838         if (_pvr && tvmode) {
 839                 *tvmode = _pvr->tvmode;
 840                 ret = MEDIA_CONTENT_ERROR_NONE;
 841         } else {
 842                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 843                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 844         }
 845
 846         return ret;
 847 }
 848
 849 int media_pvr_get_play_count(media_pvr_h pvr, int* play_count)
 850 {
 851         int ret = MEDIA_CONTENT_ERROR_NONE;
 852         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 853
 854         if (_pvr && play_count) {
 855                 *play_count = _pvr->play_count;
 856                 ret = MEDIA_CONTENT_ERROR_NONE;
 857         } else {
 858                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 859                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 860         }
 861
 862         return ret;
 863 }
 864
 865 int media_pvr_get_private_data(media_pvr_h pvr, char **private_data)
 866 {
 867         int ret = MEDIA_CONTENT_ERROR_NONE;
 868         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 869
 870         content_retip_if_fail(pvr);
 871         content_retip_if_fail(private_data);
 872
 873         *private_data = g_strdup(_pvr->private_data);
 874
 875         return MEDIA_CONTENT_ERROR_NONE;
 876 }
 877
 878 int media_pvr_get_highlight(media_pvr_h pvr, bool *highlight)
 879 {
 880         int ret = MEDIA_CONTENT_ERROR_NONE;
 881         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 882
 883         if (_pvr && highlight) {
 884                 *highlight = _pvr->highlight;
 885                 ret = MEDIA_CONTENT_ERROR_NONE;
 886         } else {
 887                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 888                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 889         }
 890
 891         return ret;
 892 }
 893
 894 int media_pvr_set_play_count(media_pvr_h pvr, int play_count)
 895 {
 896         int ret = MEDIA_CONTENT_ERROR_NONE;
 897         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 898
 899         if (_pvr != NULL) {
 900                 _pvr->play_count = play_count;
 901         } else {
 902                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 903                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 904         }
 905
 906         return ret;
 907 }
 908
 909 int media_pvr_set_program_title(media_pvr_h pvr, const char *program_title)
 910 {
 911         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 912
 913         content_retip_if_fail(pvr);
 914         content_retip_if_fail(STRING_VALID(program_title));
 915
 916         g_free(_pvr->program_title);
 917         _pvr->program_title = g_strdup(program_title);
 918
 919         return MEDIA_CONTENT_ERROR_NONE;
 920 }
 921
 922 int media_pvr_set_content_lock(media_pvr_h pvr, bool content_lock)
 923 {
 924         int ret = MEDIA_CONTENT_ERROR_NONE;
 925         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 926
 927         if (_pvr != NULL) {
 928                 _pvr->content_lock = content_lock;
 929         } else {
 930                 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_set_content_watch(media_pvr_h pvr, bool content_watch)
 938 {
 939         int ret = MEDIA_CONTENT_ERROR_NONE;
 940         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 941
 942         if (_pvr != NULL) {
 943                 _pvr->content_watch = content_watch;
 944         } else {
 945                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 946                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 947         }
 948
 949         return ret;
 950 }
 951
 952 int media_pvr_set_highlight(media_pvr_h pvr, bool highlight)
 953 {
 954         int ret = MEDIA_CONTENT_ERROR_NONE;
 955         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 956
 957         if (_pvr != NULL) {
 958                 _pvr->highlight = highlight;
 959         } else {
 960                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 961                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 962         }
 963
 964         return ret;
 965 }
 966
 967 int media_pvr_update_to_db(media_pvr_h pvr)
 968 {
 969         int ret = MEDIA_CONTENT_ERROR_NONE;
 970         media_pvr_s *_pvr = (media_pvr_s*)pvr;
 971         char *update_query = NULL;
 972
 973         if (_pvr != NULL && STRING_VALID(_pvr->media_id) && STRING_VALID(_pvr->path)) {
 974                 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);
 975
 976                 ret = _content_query_sql(update_query);
 977                 sqlite3_free(update_query);
 978
 979                 if (ret == MEDIA_CONTENT_ERROR_NONE)
 980                         media_svc_update_pvr_info(_content_get_db_handle(), _pvr->path, _pvr->program_title, _pvr->content_lock);
 981         } else {
 982                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 983                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 984         }
 985
 986         return ret;
 987 }
 988
 989 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)
 990 {
 991         int ret = MEDIA_CONTENT_ERROR_NONE;
 992
 993         if ((callback == NULL) || (group < MEDIA_PVR_GROUP_DURATION) || (group >= MEDIA_GROUP_MAX)) {
 994                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 995                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 996         } else {
 997                 ret = _media_db_get_pvr_group_item(group_name, filter, group, callback, user_data);
 998         }
 999
1000         return ret;
1001 }
1002
1003 int media_pvr_set_is_local_record(const char *pvr_path, bool is_local_record)
1004 {
1005         int ret = MEDIA_CONTENT_ERROR_NONE;
1006         char *update_query = NULL;
1007         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0,};
1008
1009         if (pvr_path == NULL) {
1010                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1011                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1012         } else {
1013
1014                 /*get the storage uuid*/
1015                 ret = media_svc_get_storage_id(_content_get_db_handle(), pvr_path, storage_id, tzplatform_getuid(TZ_USER_NAME));
1016                 if (ret == MS_MEDIA_ERR_NONE) {
1017                         content_error("storage uuid [%s]", storage_id);
1018                         update_query = sqlite3_mprintf(UPDATE_PVR_LOCAL_RECORD_PVR, is_local_record, pvr_path, storage_id);
1019
1020                         ret = _content_query_sql(update_query);
1021                         sqlite3_free(update_query);
1022                 } else {
1023                         content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
1024                         content_error("pvr path[%s] error[%d]", pvr_path, ret);
1025                         ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1026                 }
1027         }
1028
1029         return ret;
1030 }
1031 #endif