src/media_uhd.c

   1  /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 #ifdef _USE_TVPD_MODE
  17 #include <media_info_private.h>
  18 #include <media_util_private.h>
  19 #include <media_uhd.h>
  20
  21 int media_uhd_foreach_media_from_db(filter_h filter, media_uhd_cb callback, void *user_data)
  22 {
  23         content_retip_if_fail(callback);
  24
  25         return _media_db_get_uhd(filter, callback, user_data);
  26 }
  27
  28 int media_uhd_destroy(media_uhd_h uhd)
  29 {
  30         media_uhd_s *_uhd = (media_uhd_s*)uhd;
  31
  32         content_retip_if_fail(uhd);
  33
  34         g_free(_uhd->media_id);
  35         g_free(_uhd->path);
  36         g_free(_uhd->content_id);
  37         g_free(_uhd->content_title);
  38         g_free(_uhd->file_name);
  39         g_free(_uhd->release_date);
  40         g_free(_uhd);
  41
  42         return MEDIA_CONTENT_ERROR_NONE;
  43 }
  44
  45 int media_uhd_clone(media_uhd_h *dst, media_uhd_h src)
  46 {
  47         media_uhd_s *_src = (media_uhd_s*)src;
  48
  49         content_retip_if_fail(dst);
  50         content_retip_if_fail(src);
  51
  52         media_uhd_s *_dst = g_new0(media_uhd_s, 1);
  53
  54         _dst->media_id = g_strdup(_src->media_id);
  55         _dst->path = g_strdup(_src->path);
  56         _dst->content_id = g_strdup(_src->content_id);
  57         _dst->content_title = g_strdup(_src->content_title);
  58         _dst->release_date = g_strdup(_src->release_date);
  59         _dst->file_name = g_strdup(_src->file_name);
  60         _dst->size = _src->size;
  61         _dst->modified_time = _src->modified_time;
  62         _dst->played_position = _src->played_position;
  63         _dst->played_count = _src->played_count;
  64
  65         *dst = (media_uhd_h)_dst;
  66
  67         return MEDIA_CONTENT_ERROR_NONE;
  68 }
  69
  70 int media_uhd_get_uhd_from_db(const char *media_id, media_uhd_h *uhd)
  71 {
  72         int ret = MEDIA_CONTENT_ERROR_NONE;
  73         char *select_query = NULL;
  74         sqlite3_stmt *stmt = NULL;
  75
  76         content_retip_if_fail(STRING_VALID(media_id));
  77         content_retip_if_fail(uhd);
  78
  79         select_query = sqlite3_mprintf(SELECT_UHD_FROM_UHD, media_id);
  80
  81         ret = _content_get_result(select_query, &stmt);
  82         SQLITE3_SAFE_FREE(select_query);
  83         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
  84
  85         media_uhd_s *_uhd = NULL;
  86
  87         if (sqlite3_step(stmt) == SQLITE_ROW) {
  88                 _uhd = g_new0(media_uhd_s, 1);
  89
  90                 _media_uhd_item_get_detail(stmt, (media_uhd_h)_uhd);
  91
  92                 *uhd = (media_uhd_h)_uhd;
  93         } else {
  94                 content_error("Nonexistent media id[%s]", media_id);
  95                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  96         }
  97
  98         SQLITE3_FINALIZE(stmt);
  99
 100         return ret;
 101 }
 102
 103 int media_uhd_get_media_id(media_uhd_h uhd, char **media_id)
 104 {
 105         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 106
 107         content_retip_if_fail(uhd);
 108         content_retip_if_fail(media_id);
 109
 110         *media_id = g_strdup(_uhd->media_id);
 111
 112         return MEDIA_CONTENT_ERROR_NONE;
 113 }
 114
 115 int media_uhd_get_path(media_uhd_h uhd, char **path)
 116 {
 117         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 118
 119         content_retip_if_fail(uhd);
 120         content_retip_if_fail(path);
 121
 122         *path = g_strdup(_uhd->path);
 123
 124         return MEDIA_CONTENT_ERROR_NONE;
 125 }
 126
 127 int media_uhd_get_size(media_uhd_h uhd, unsigned long long *size)
 128 {
 129         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 130
 131         content_retip_if_fail(uhd);
 132         content_retip_if_fail(size);
 133
 134         *size = _uhd->size;
 135
 136         return MEDIA_CONTENT_ERROR_NONE;
 137 }
 138
 139 int media_uhd_get_content_id(media_uhd_h uhd, char **content_id)
 140 {
 141         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 142
 143         content_retip_if_fail(uhd);
 144         content_retip_if_fail(content_id);
 145
 146         *content_id = g_strdup(_uhd->content_id);
 147
 148         return MEDIA_CONTENT_ERROR_NONE;
 149 }
 150
 151 int media_uhd_get_content_title(media_uhd_h uhd, char **content_title)
 152 {
 153         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 154
 155         content_retip_if_fail(uhd);
 156         content_retip_if_fail(content_title);
 157
 158         *content_title = g_strdup(_uhd->content_title);
 159
 160         return MEDIA_CONTENT_ERROR_NONE;
 161 }
 162
 163 int media_uhd_get_file_name(media_uhd_h uhd, char **file_name)
 164 {
 165         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 166
 167         content_retip_if_fail(uhd);
 168         content_retip_if_fail(file_name);
 169
 170         *file_name = g_strdup(_uhd->file_name);
 171
 172         return MEDIA_CONTENT_ERROR_NONE;
 173 }
 174
 175 int media_uhd_get_release_date(media_uhd_h uhd, char **release_date)
 176 {
 177         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 178
 179         content_retip_if_fail(uhd);
 180         content_retip_if_fail(release_date);
 181
 182         *release_date = g_strdup(_uhd->release_date);
 183
 184         return MEDIA_CONTENT_ERROR_NONE;
 185 }
 186
 187 int media_uhd_get_modified_time(media_uhd_h uhd, time_t *modified_time)
 188 {
 189         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 190
 191         content_retip_if_fail(uhd);
 192         content_retip_if_fail(modified_time);
 193
 194         *modified_time = _uhd->modified_time;
 195
 196         return MEDIA_CONTENT_ERROR_NONE;
 197 }
 198
 199 int media_uhd_get_played_position(media_uhd_h uhd, int *played_position)
 200 {
 201         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 202
 203         content_retip_if_fail(uhd);
 204         content_retip_if_fail(played_position);
 205
 206         *played_position = _uhd->played_position;
 207
 208         return MEDIA_CONTENT_ERROR_NONE;
 209 }
 210
 211 int media_uhd_get_played_count(media_uhd_h uhd, int *played_count)
 212 {
 213         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 214
 215         content_retip_if_fail(uhd);
 216         content_retip_if_fail(played_count);
 217
 218         *played_count = _uhd->played_count;
 219
 220         return MEDIA_CONTENT_ERROR_NONE;
 221 }
 222
 223 int media_uhd_set_played_position(media_uhd_h uhd, int played_position)
 224 {
 225         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 226
 227         content_retip_if_fail(uhd);
 228         content_retip_if_fail(played_position);
 229
 230         _uhd->played_position = played_position;
 231
 232         return MEDIA_CONTENT_ERROR_NONE;
 233 }
 234
 235 int media_uhd_set_content_title(media_uhd_h uhd, const char *content_title)
 236 {
 237         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 238
 239         content_retip_if_fail(uhd);
 240         content_retip_if_fail(STRING_VALID(content_title));
 241
 242         g_free(_uhd->content_title);
 243         _uhd->content_title = g_strdup(content_title);
 244
 245         return MEDIA_CONTENT_ERROR_NONE;
 246 }
 247
 248 int media_uhd_set_played_count(media_uhd_h uhd, int played_count)
 249 {
 250         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 251
 252         content_retip_if_fail(uhd);
 253
 254         _uhd->played_count = played_count;
 255
 256         return MEDIA_CONTENT_ERROR_NONE;
 257 }
 258
 259 int media_uhd_update_to_db(media_uhd_h uhd)
 260 {
 261         int ret = MEDIA_CONTENT_ERROR_NONE;
 262         media_uhd_s *_uhd = (media_uhd_s*)uhd;
 263         char *update_query = NULL;
 264
 265         content_retip_if_fail(uhd);
 266         content_retip_if_fail(STRING_VALID(_uhd->media_id));
 267         content_retip_if_fail(STRING_VALID(_uhd->path));
 268
 269         update_query = sqlite3_mprintf(UPDATE_UHD_META_FROM_UHD, _uhd->content_title, _uhd->played_position, _uhd->played_count, _uhd->media_id);
 270
 271         ret = _content_query_sql(update_query);
 272         sqlite3_free(update_query);
 273
 274         return ret;
 275 }
 276 #endif