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         _dst->storage_type = _src->storage_type;
 135
 136         *dst = (media_folder_h)_dst;
 137
 138         return MEDIA_CONTENT_ERROR_NONE;
 139 }
 140
 141 int media_folder_get_folder_id(media_folder_h folder, char **folder_id)
 142 {
 143         media_folder_s *_folder = (media_folder_s*)folder;
 144
 145         content_retip_if_fail(folder);
 146         content_retip_if_fail(folder_id);
 147
 148         *folder_id = g_strdup(_folder->folder_id);
 149
 150         return MEDIA_CONTENT_ERROR_NONE;
 151 }
 152
 153 int media_folder_get_path(media_folder_h folder, char **path)
 154 {
 155         media_folder_s *_folder = (media_folder_s*)folder;
 156
 157         content_retip_if_fail(folder);
 158         content_retip_if_fail(path);
 159
 160         *path = g_strdup(_folder->path);
 161
 162         return MEDIA_CONTENT_ERROR_NONE;
 163 }
 164
 165 int media_folder_get_name(media_folder_h folder, char **name)
 166 {
 167         media_folder_s *_folder = (media_folder_s*)folder;
 168
 169         content_retip_if_fail(folder);
 170         content_retip_if_fail(name);
 171
 172         *name = g_strdup(_folder->name);
 173
 174         return MEDIA_CONTENT_ERROR_NONE;
 175 }
 176
 177 int media_folder_get_folder_from_db(const char *folder_id, media_folder_h *folder)
 178 {
 179         int ret = MEDIA_CONTENT_ERROR_NONE;
 180         sqlite3_stmt *stmt = NULL;
 181         char select_query[DEFAULT_QUERY_SIZE] = {0, };
 182         media_folder_s *_folder = NULL;
 183
 184         content_retip_if_fail(STRING_VALID(folder_id));
 185         content_retip_if_fail(folder);
 186
 187         snprintf(select_query, sizeof(select_query), SELECT_FOLDER_FROM_FOLDER, folder_id);
 188
 189         ret = _content_get_result(select_query, &stmt);
 190         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 191
 192         if (sqlite3_step(stmt) == SQLITE_ROW) {
 193                 _folder = g_new0(media_folder_s, 1);
 194
 195                 _folder->folder_id = g_strdup(folder_id);
 196                 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 197                 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 198                 _folder->storage_type = (int)sqlite3_column_int(stmt, 2);
 199                 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 3));
 200
 201                 *folder = (media_folder_h)_folder;
 202         }
 203
 204         SQLITE3_FINALIZE(stmt);
 205
 206         return ret;
 207 }
 208 #ifdef _USE_TVPD_MODE
 209 int media_folder_update_to_db(media_folder_h folder)
 210 {
 211         int ret = MEDIA_CONTENT_ERROR_NONE;
 212         content_warn("DEPRECATION WARNING: media_folder_update_to_db() is deprecated and will be removed from next release.");
 213         media_folder_s *_folder = (media_folder_s*)folder;
 214
 215         content_retip_if_fail(folder);
 216         content_retip_if_fail(STRING_VALID(_folder->folder_id));
 217
 218         if (!g_src_path)
 219                 return ret;
 220
 221         ret = media_svc_rename_folder(_content_get_db_handle(), _folder->storage_uuid, g_src_path, _folder->path, _content_get_uid());
 222         SAFE_FREE(g_src_path);
 223
 224         return _content_error_capi(ret);
 225 }
 226
 227 int media_folder_set_name(media_folder_h folder, const char *name)
 228 {
 229         int ret = MEDIA_CONTENT_ERROR_NONE;
 230         content_warn("DEPRECATION WARNING: media_folder_set_name() is deprecated and will be removed from next release.");
 231         media_folder_s *_folder = (media_folder_s*)folder;
 232         char *parent_folder_path = NULL;
 233
 234         content_retip_if_fail(folder);
 235         content_retip_if_fail(STRING_VALID(name));
 236         content_retip_if_fail(name[0] != '.');
 237         content_retip_if_fail(STRING_VALID(_folder->path));
 238         content_retip_if_fail(STRING_VALID(_folder->name));
 239
 240         // Change name..
 241         g_free(_folder->name);
 242         _folder->name = g_strdup(name);
 243
 244         // Change path..
 245         g_free(g_src_path);
 246         g_src_path = g_strdup(_folder->path);
 247         g_free(_folder->path);
 248
 249         parent_folder_path = g_path_get_dirname(g_src_path);
 250         _folder->path = g_strdup_printf("%s/%s", parent_folder_path, name);
 251         g_free(parent_folder_path);
 252
 253         content_sec_debug("Old[%s] New[%s]", g_src_path, _folder->path);
 254
 255         return ret;
 256 }
 257
 258 int media_folder_insert_to_db(const char *path)
 259 {
 260         int ret = MEDIA_CONTENT_ERROR_NONE;
 261         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
 262
 263         content_retip_if_fail(STRING_VALID(path));
 264
 265         content_retvm_if(_media_util_is_ignorable_dir(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid folder path");
 266
 267         ret = _media_content_check_dir(path);
 268         content_retvm_if(ret == MEDIA_CONTENT_ERROR_PERMISSION_DENIED, ret, "Permission Denied");
 269         content_retvm_if(ret == MEDIA_CONTENT_ERROR_INVALID_PARAMETER, ret, "invalid path[%s]", path);
 270
 271         ret = media_svc_get_storage_id(_content_get_db_handle(), path, storage_id, _content_get_uid());
 272         if (ret != MS_MEDIA_ERR_NONE) {
 273                 content_error("media_svc_get_storage_id failed : %d", ret);
 274                 return _content_error_capi(ret);
 275         }
 276
 277         ret = media_svc_check_folder_exist_by_path(_content_get_db_handle(), storage_id, path);
 278         if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 279                 content_sec_debug("media_svc_check_folder_exist_by_path : no record : %s", path);
 280                 ms_user_storage_type_e storage_type = MS_USER_STORAGE_INTERNAL;
 281
 282                 ret = ms_user_get_storage_type(_content_get_uid(), path, &storage_type);
 283                 if (ret != MS_MEDIA_ERR_NONE) {
 284                         content_sec_error("ms_user_get_storage_type failed : %d", ret);
 285                         return _content_error_capi(ret);
 286                 }
 287
 288                 ret = media_svc_insert_folder(_content_get_db_handle(), storage_id, storage_type, path, false, _content_get_uid());
 289                 if (ret != MS_MEDIA_ERR_NONE) {
 290                         if (ret == MS_MEDIA_ERR_DB_CONSTRAINT_FAIL) {
 291                                 content_sec_error("This item is already inserted. This may be normal operation because other process already did this (%s)", path);
 292                                 ret = MEDIA_CONTENT_ERROR_NONE;
 293                         } else {
 294                                 content_sec_error("media_svc_insert_folder failed : %d (%s)", ret, path);
 295                         }
 296
 297                         return _content_error_capi(ret);
 298                 }
 299
 300                 ret = media_svc_set_folder_scan_status(storage_id, path, MEDIA_DIR_SCAN_DONE, false, _content_get_uid());
 301                 if (ret != MS_MEDIA_ERR_NONE) {
 302                         content_sec_error("media_svc_set_folder_scan_status failed : %d", ret);
 303                         return _content_error_capi(ret);
 304                 }
 305         } else if (ret != MS_MEDIA_ERR_NONE) {
 306                 content_sec_error("media_svc_check_folder_exist_by_path failed : %d (%s)", ret, path);
 307                 return _content_error_capi(ret);
 308         }
 309
 310         return ret;
 311 }
 312
 313 int media_folder_get_scan_status(const char *storage_uuid, char* path, media_folder_scan_status_e *scan_status)
 314 {
 315         int ret = MEDIA_CONTENT_ERROR_NONE;
 316         int status = MEDIA_DIR_SCAN_NONE;
 317
 318         content_retip_if_fail(STRING_VALID(storage_uuid));
 319         content_retip_if_fail(STRING_VALID(path));
 320         content_retip_if_fail(scan_status);
 321
 322         ret = media_svc_get_folder_scan_status(_content_get_db_handle(), storage_uuid, path, &status);
 323         if (ret != MS_MEDIA_ERR_NONE) {
 324                 content_error("media_svc_get_folder_scan_status failed");
 325                 ret = _content_error_capi(ret);
 326         } else {
 327                 *scan_status = status;
 328         }
 329
 330         return ret;
 331 }
 332
 333 int media_folder_reset_scan_status(const char *storage_uuid, const char* path)
 334 {
 335         int ret = MEDIA_CONTENT_ERROR_NONE;
 336
 337         content_retip_if_fail(STRING_VALID(path));
 338
 339         ret = media_svc_set_folder_validity(FALSE, storage_uuid, path, 0, TRUE, _content_get_uid());
 340         if (ret != MS_MEDIA_ERR_NONE) {
 341                 content_error("set folder validity failed");
 342                 return _content_error_capi(ret);
 343         }
 344
 345         ret = media_svc_set_folder_scan_status(storage_uuid, path, MEDIA_DIR_SCAN_NONE, false, _content_get_uid());
 346         if (ret != MS_MEDIA_ERR_NONE) {
 347                 content_error("media_folder_reset_scan_status failed");
 348                 return _content_error_capi(ret);
 349         }
 350
 351         return ret;
 352 }
 353 #endif