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_storage_type(media_folder_h folder, media_content_storage_e* storage_type)
 178 {
 179         content_warn("DEPRECATION WARNING: media_folder_get_storage_type() is deprecated and will be removed from next release. Use storage_get_type_dev() instead.");
 180         media_folder_s *_folder = (media_folder_s*)folder;
 181
 182         content_retip_if_fail(folder);
 183         content_retip_if_fail(storage_type);
 184
 185         *storage_type = _folder->storage_type;
 186
 187         return MEDIA_CONTENT_ERROR_NONE;
 188 }
 189
 190 int media_folder_get_storage_id(media_folder_h folder, char **storage_id)
 191 {
 192         content_warn("DEPRECATION WARNING: media_folder_get_storage_id() is deprecated and will be removed from next release.");
 193         media_folder_s *_folder = (media_folder_s*)folder;
 194
 195         content_retip_if_fail(folder);
 196         content_retip_if_fail(storage_id);
 197
 198         *storage_id = g_strdup(_folder->storage_uuid);
 199
 200         return MEDIA_CONTENT_ERROR_NONE;
 201 }
 202
 203 int media_folder_get_folder_from_db(const char *folder_id, media_folder_h *folder)
 204 {
 205         int ret = MEDIA_CONTENT_ERROR_NONE;
 206         sqlite3_stmt *stmt = NULL;
 207         char select_query[DEFAULT_QUERY_SIZE] = {0, };
 208         media_folder_s *_folder = NULL;
 209
 210         content_retip_if_fail(STRING_VALID(folder_id));
 211         content_retip_if_fail(folder);
 212
 213         snprintf(select_query, sizeof(select_query), SELECT_FOLDER_FROM_FOLDER, folder_id);
 214
 215         ret = _content_get_result(select_query, &stmt);
 216         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 217
 218         if (sqlite3_step(stmt) == SQLITE_ROW) {
 219                 _folder = g_new0(media_folder_s, 1);
 220
 221                 _folder->folder_id = g_strdup(folder_id);
 222                 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 223                 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 224                 _folder->storage_type = (int)sqlite3_column_int(stmt, 2);
 225                 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 3));
 226
 227                 *folder = (media_folder_h)_folder;
 228         }
 229
 230         SQLITE3_FINALIZE(stmt);
 231
 232         return ret;
 233 }
 234 #ifdef _USE_TVPD_MODE
 235 int media_folder_update_to_db(media_folder_h folder)
 236 {
 237         int ret = MEDIA_CONTENT_ERROR_NONE;
 238         content_warn("DEPRECATION WARNING: media_folder_update_to_db() is deprecated and will be removed from next release.");
 239         media_folder_s *_folder = (media_folder_s*)folder;
 240         char repl_path[MAX_PATH_LEN] = {0, };
 241
 242         content_retip_if_fail(folder);
 243         content_retip_if_fail(STRING_VALID(_folder->folder_id));
 244
 245         if (!g_src_path)
 246                 return ret;
 247
 248
 249         ret = _media_content_replace_path(_folder->path, repl_path);
 250         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 251                 SAFE_FREE(g_src_path);
 252                 return ret;
 253         }
 254         ret = media_svc_rename_folder(_content_get_db_handle(), _folder->storage_uuid, g_src_path, repl_path, _content_get_uid());
 255         SAFE_FREE(g_src_path);
 256
 257         return _content_error_capi(ret);
 258 }
 259
 260 int media_folder_set_name(media_folder_h folder, const char *name)
 261 {
 262         int ret = MEDIA_CONTENT_ERROR_NONE;
 263         content_warn("DEPRECATION WARNING: media_folder_set_name() is deprecated and will be removed from next release.");
 264         media_folder_s *_folder = (media_folder_s*)folder;
 265
 266         char *folder_path = NULL;
 267         char new_folder_path[MAX_PATH_LEN] = {0,};
 268         char repl_path[MAX_PATH_LEN] = {0, };
 269
 270         content_retip_if_fail(folder);
 271         content_retip_if_fail(STRING_VALID(name));
 272         content_retip_if_fail(name[0] != '.');
 273         content_retip_if_fail(STRING_VALID(_folder->path));
 274         content_retip_if_fail(STRING_VALID(_folder->name));
 275
 276         ret = _media_content_replace_path(_folder->path, repl_path);
 277         content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 278
 279         folder_path = g_path_get_dirname(repl_path);
 280         content_sec_debug("Existed Folder Path : %s", repl_path);
 281         snprintf(new_folder_path, sizeof(new_folder_path), "%s/%s", folder_path, name);
 282         content_sec_debug("New Path : %s", new_folder_path);
 283
 284         g_free(g_src_path);
 285         g_src_path = g_strdup(repl_path);
 286
 287         g_free(_folder->path);
 288         g_free(_folder->name);
 289         g_free(folder_path);
 290
 291         _folder->path = g_strdup(new_folder_path);
 292         _folder->name = g_strdup(name);
 293
 294         return ret;
 295 }
 296
 297 int media_folder_insert_to_db(const char *path)
 298 {
 299         int ret = MEDIA_CONTENT_ERROR_NONE;
 300         char repl_path[MAX_PATH_LEN] = {0, };
 301         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
 302
 303         content_retip_if_fail(STRING_VALID(path));
 304
 305         ret = _media_content_replace_path(path, repl_path);
 306         content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 307
 308         content_retvm_if(_media_util_is_ignorable_dir(repl_path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid folder path");
 309
 310         ret = _media_content_check_dir(repl_path);
 311         content_retvm_if(ret == MEDIA_CONTENT_ERROR_PERMISSION_DENIED, ret, "Permission Denied");
 312         content_retvm_if(ret == MEDIA_CONTENT_ERROR_INVALID_PARAMETER, ret, "invalid path[%s]", path);
 313
 314         ret = media_svc_get_storage_id(_content_get_db_handle(), repl_path, storage_id, _content_get_uid());
 315         if (ret != MS_MEDIA_ERR_NONE) {
 316                 content_error("media_svc_get_storage_id failed : %d", ret);
 317                 return _content_error_capi(ret);
 318         }
 319
 320         ret = media_svc_check_folder_exist_by_path(_content_get_db_handle(), storage_id, repl_path);
 321         if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 322                 content_sec_debug("media_svc_check_folder_exist_by_path : no record : %s", repl_path);
 323                 ms_user_storage_type_e storage_type = MS_USER_STORAGE_INTERNAL;
 324
 325                 ret = ms_user_get_storage_type(_content_get_uid(), repl_path, &storage_type);
 326                 if (ret != MS_MEDIA_ERR_NONE) {
 327                         content_sec_error("ms_user_get_storage_type failed : %d", ret);
 328                         return _content_error_capi(ret);
 329                 }
 330
 331                 ret = media_svc_insert_folder(_content_get_db_handle(), storage_id, storage_type, repl_path, false, _content_get_uid());
 332                 if (ret != MS_MEDIA_ERR_NONE) {
 333                         if (ret == MS_MEDIA_ERR_DB_CONSTRAINT_FAIL) {
 334                                 content_sec_error("This item is already inserted. This may be normal operation because other process already did this (%s)", repl_path);
 335                                 ret = MEDIA_CONTENT_ERROR_NONE;
 336                         } else {
 337                                 content_sec_error("media_svc_insert_folder failed : %d (%s)", ret, repl_path);
 338                         }
 339
 340                         return _content_error_capi(ret);
 341                 }
 342
 343                 ret = media_svc_set_folder_scan_status(storage_id, repl_path, MEDIA_DIR_SCAN_DONE, false, _content_get_uid());
 344                 if (ret != MS_MEDIA_ERR_NONE) {
 345                         content_sec_error("ms_set_folder_scan_status failed : %d", ret);
 346                         return _content_error_capi(ret);
 347                 }
 348         } else if (ret != MS_MEDIA_ERR_NONE) {
 349                 content_sec_error("media_svc_check_folder_exist_by_path failed : %d (%s)", ret, repl_path);
 350                 return _content_error_capi(ret);
 351         }
 352
 353         return ret;
 354 }
 355
 356 int media_folder_get_scan_status(const char *storage_uuid, char* path, media_folder_scan_status_e *scan_status)
 357 {
 358         int ret = MEDIA_CONTENT_ERROR_NONE;
 359         int status = MEDIA_DIR_SCAN_NONE;
 360
 361         content_retip_if_fail(STRING_VALID(storage_uuid));
 362         content_retip_if_fail(STRING_VALID(path));
 363         content_retip_if_fail(scan_status);
 364
 365         ret = media_svc_get_folder_scan_status(_content_get_db_handle(), storage_uuid, path, &status);
 366         if (ret != MS_MEDIA_ERR_NONE) {
 367                 content_error("media_svc_get_folder_scan_status failed");
 368                 ret = _content_error_capi(ret);
 369         } else {
 370                 *scan_status = status;
 371         }
 372
 373         return ret;
 374 }
 375
 376 int media_folder_reset_scan_status(const char *storage_uuid, const char* path)
 377 {
 378         int ret = MEDIA_CONTENT_ERROR_NONE;
 379
 380         content_retip_if_fail(STRING_VALID(path));
 381
 382         ret = media_svc_set_folder_validity(FALSE, storage_uuid, path, 0, TRUE, _content_get_uid());
 383         if (ret != MS_MEDIA_ERR_NONE) {
 384                 content_error("set folder validity failed");
 385                 return _content_error_capi(ret);
 386         }
 387
 388         ret = media_svc_set_folder_scan_status(storage_uuid, path, MEDIA_DIR_SCAN_NONE, false, _content_get_uid());
 389         if (ret != MS_MEDIA_ERR_NONE) {
 390                 content_error("media_folder_reset_scan_status failed");
 391                 return _content_error_capi(ret);
 392         }
 393
 394         return ret;
 395 }
 396 #endif