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