src/media_folder.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
  18 #include <media_info_private.h>
  19 #include <media_util_private.h>
  20 #ifdef _USE_TVPD_MODE
  21 #include <media_content_type_product.h>
  22 #endif
  23
  24 #ifdef _USE_TVPD_MODE
  25 static char *g_src_path = NULL;
  26 #endif
  27
  28 int media_folder_get_folder_count_from_db(filter_h filter, int *folder_count)
  29 {
  30         int ret = MEDIA_CONTENT_ERROR_NONE;
  31
  32         content_retip_if_fail(folder_count);
  33
  34 #ifdef _USE_TVPD_MODE
  35         g_mutex_lock(_content_get_db_mutex());
  36 #endif
  37
  38         ret = _media_db_get_group_count(filter, MEDIA_GROUP_FOLDER, folder_count);
  39
  40 #ifdef _USE_TVPD_MODE
  41         g_mutex_unlock(_content_get_db_mutex());
  42 #endif
  43
  44
  45         return ret;
  46 }
  47
  48 int media_folder_foreach_folder_from_db(filter_h filter, media_folder_cb callback, void *user_data)
  49 {
  50         int ret = MEDIA_CONTENT_ERROR_NONE;
  51
  52         content_retip_if_fail(callback);
  53
  54 #ifdef _USE_TVPD_MODE
  55         g_mutex_lock(_content_get_db_mutex());
  56 #endif
  57
  58         ret = _media_db_get_folder(filter, callback, user_data);
  59
  60 #ifdef _USE_TVPD_MODE
  61         g_mutex_unlock(_content_get_db_mutex());
  62 #endif
  63
  64         return ret;
  65 }
  66
  67 int media_folder_get_media_count_from_db(const char *folder_id, filter_h filter, int *media_count)
  68 {
  69         int ret = MEDIA_CONTENT_ERROR_NONE;
  70
  71         content_retip_if_fail(STRING_VALID(folder_id));
  72         content_retip_if_fail(media_count);
  73
  74 #ifdef _USE_TVPD_MODE
  75         g_mutex_lock(_content_get_db_mutex());
  76 #endif
  77
  78         ret = _media_db_get_group_item_count(folder_id, filter, MEDIA_GROUP_FOLDER, media_count);
  79
  80 #ifdef _USE_TVPD_MODE
  81         g_mutex_unlock(_content_get_db_mutex());
  82 #endif
  83
  84         return ret;
  85 }
  86
  87 int media_folder_foreach_media_from_db(const char *folder_id, filter_h filter, media_info_cb callback, void *user_data)
  88 {
  89         int ret = MEDIA_CONTENT_ERROR_NONE;
  90
  91         content_retip_if_fail(STRING_VALID(folder_id));
  92         content_retip_if_fail(callback);
  93
  94 #ifdef _USE_TVPD_MODE
  95         g_mutex_lock(_content_get_db_mutex());
  96 #endif
  97
  98         ret = _media_db_get_group_item(folder_id, filter, callback, user_data, MEDIA_GROUP_FOLDER);
  99
 100 #ifdef _USE_TVPD_MODE
 101         g_mutex_unlock(_content_get_db_mutex());
 102 #endif
 103
 104         return ret;
 105 }
 106
 107 int media_folder_destroy(media_folder_h folder)
 108 {
 109         media_folder_s *_folder = (media_folder_s*)folder;
 110
 111         content_retip_if_fail(folder);
 112
 113         g_free(_folder->path);
 114         g_free(_folder->name);
 115         g_free(_folder->folder_id);
 116         g_free(_folder->storage_uuid);
 117         g_free(_folder);
 118
 119         return MEDIA_CONTENT_ERROR_NONE;
 120 }
 121 int media_folder_clone(media_folder_h *dst, media_folder_h src)
 122 {
 123         media_folder_s *_src = (media_folder_s*)src;
 124
 125         content_retip_if_fail(dst);
 126         content_retip_if_fail(src);
 127
 128         media_folder_s *_dst = g_new0(media_folder_s, 1);
 129
 130         _dst->folder_id = g_strdup(_src->folder_id);
 131         _dst->name = g_strdup(_src->name);
 132         _dst->path = g_strdup(_src->path);
 133         _dst->storage_uuid = g_strdup(_src->storage_uuid);
 134
 135         *dst = (media_folder_h)_dst;
 136
 137         return MEDIA_CONTENT_ERROR_NONE;
 138 }
 139
 140 int media_folder_get_folder_id(media_folder_h folder, char **folder_id)
 141 {
 142         media_folder_s *_folder = (media_folder_s*)folder;
 143
 144         content_retip_if_fail(folder);
 145         content_retip_if_fail(folder_id);
 146
 147         *folder_id = g_strdup(_folder->folder_id);
 148
 149         return MEDIA_CONTENT_ERROR_NONE;
 150 }
 151
 152 int media_folder_get_path(media_folder_h folder, char **path)
 153 {
 154         media_folder_s *_folder = (media_folder_s*)folder;
 155
 156         content_retip_if_fail(folder);
 157         content_retip_if_fail(path);
 158
 159         *path = g_strdup(_folder->path);
 160
 161         return MEDIA_CONTENT_ERROR_NONE;
 162 }
 163
 164 int media_folder_get_name(media_folder_h folder, char **name)
 165 {
 166         media_folder_s *_folder = (media_folder_s*)folder;
 167
 168         content_retip_if_fail(folder);
 169         content_retip_if_fail(name);
 170
 171         *name = g_strdup(_folder->name);
 172
 173         return MEDIA_CONTENT_ERROR_NONE;
 174 }
 175
 176 int media_folder_get_folder_from_db(const char *folder_id, media_folder_h *folder)
 177 {
 178         int ret = MEDIA_CONTENT_ERROR_NONE;
 179         sqlite3_stmt *stmt = NULL;
 180         char select_query[DEFAULT_QUERY_SIZE] = {0, };
 181         media_folder_s *_folder = NULL;
 182
 183         content_retip_if_fail(STRING_VALID(folder_id));
 184         content_retip_if_fail(folder);
 185
 186         snprintf(select_query, sizeof(select_query), SELECT_FOLDER_FROM_FOLDER, folder_id);
 187
 188         ret = _content_get_result(select_query, &stmt);
 189         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 190
 191         if (sqlite3_step(stmt) == SQLITE_ROW) {
 192                 _folder = g_new0(media_folder_s, 1);
 193
 194                 _folder->folder_id = g_strdup(folder_id);
 195                 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 196                 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 197                 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 3));
 198
 199                 *folder = (media_folder_h)_folder;
 200         }
 201
 202         SQLITE3_FINALIZE(stmt);
 203
 204         return ret;
 205 }
 206 #ifdef _USE_TVPD_MODE
 207 int media_folder_update_to_db(media_folder_h folder)
 208 {
 209         int ret = MEDIA_CONTENT_ERROR_NONE;
 210         content_warn("DEPRECATION WARNING: media_folder_update_to_db() is deprecated and will be removed from next release.");
 211         media_folder_s *_folder = (media_folder_s*)folder;
 212
 213         content_retip_if_fail(folder);
 214         content_retip_if_fail(STRING_VALID(_folder->folder_id));
 215
 216         if (!g_src_path)
 217                 return ret;
 218
 219         ret = media_svc_rename_folder(_content_get_db_handle(), _folder->storage_uuid, g_src_path, _folder->path, _content_get_uid());
 220         SAFE_FREE(g_src_path);
 221
 222         return _content_error_capi(ret);
 223 }
 224
 225 int media_folder_set_name(media_folder_h folder, const char *name)
 226 {
 227         int ret = MEDIA_CONTENT_ERROR_NONE;
 228         content_warn("DEPRECATION WARNING: media_folder_set_name() is deprecated and will be removed from next release.");
 229         media_folder_s *_folder = (media_folder_s*)folder;
 230         char *parent_folder_path = NULL;
 231
 232         content_retip_if_fail(folder);
 233         content_retip_if_fail(STRING_VALID(name));
 234         content_retip_if_fail(name[0] != '.');
 235         content_retip_if_fail(STRING_VALID(_folder->path));
 236         content_retip_if_fail(STRING_VALID(_folder->name));
 237
 238         // Change name..
 239         g_free(_folder->name);
 240         _folder->name = g_strdup(name);
 241
 242         // Change path..
 243         g_free(g_src_path);
 244         g_src_path = g_strdup(_folder->path);
 245         g_free(_folder->path);
 246
 247         parent_folder_path = g_path_get_dirname(g_src_path);
 248         _folder->path = g_strdup_printf("%s/%s", parent_folder_path, name);
 249         g_free(parent_folder_path);
 250
 251         content_sec_debug("Old[%s] New[%s]", g_src_path, _folder->path);
 252
 253         return ret;
 254 }
 255
 256 int media_folder_get_scan_status(const char *storage_uuid, char* path, media_folder_scan_status_e *scan_status)
 257 {
 258         int ret = MEDIA_CONTENT_ERROR_NONE;
 259         int status = MEDIA_DIR_SCAN_NONE;
 260
 261         content_retip_if_fail(STRING_VALID(storage_uuid));
 262         content_retip_if_fail(STRING_VALID(path));
 263         content_retip_if_fail(scan_status);
 264
 265         ret = media_svc_get_folder_scan_status(_content_get_db_handle(), storage_uuid, path, &status);
 266         if (ret != MS_MEDIA_ERR_NONE) {
 267                 content_error("media_svc_get_folder_scan_status failed");
 268                 ret = _content_error_capi(ret);
 269         } else {
 270                 *scan_status = status;
 271         }
 272
 273         return ret;
 274 }
 275
 276 int media_folder_reset_scan_status(const char *storage_uuid, const char* path)
 277 {
 278         int ret = MEDIA_CONTENT_ERROR_NONE;
 279
 280         content_retip_if_fail(STRING_VALID(path));
 281
 282         ret = media_svc_set_folder_validity(FALSE, storage_uuid, path, 0, TRUE, _content_get_uid());
 283         if (ret != MS_MEDIA_ERR_NONE) {
 284                 content_error("set folder validity failed");
 285                 return _content_error_capi(ret);
 286         }
 287
 288         ret = media_svc_set_folder_scan_status(storage_uuid, path, MEDIA_DIR_SCAN_NONE, false, _content_get_uid());
 289         if (ret != MS_MEDIA_ERR_NONE) {
 290                 content_error("media_folder_reset_scan_status failed");
 291                 return _content_error_capi(ret);
 292         }
 293
 294         return ret;
 295 }
 296 #endif