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 #ifdef _USE_SENIOR_MODE
 108 int media_folder_foreach_media_from_db_by_union_select(const char* folder_id, filter_h filter1, filter_h filter2, media_info_cb callback, void* user_data)
 109 {
 110         content_retip_if_fail(STRING_VALID(folder_id));
 111         content_retip_if_fail(callback);
 112
 113         return _media_db_get_group_item_by_union_select(folder_id, filter1, filter2, callback, user_data);
 114 }
 115 #endif
 116
 117 int media_folder_destroy(media_folder_h folder)
 118 {
 119         media_folder_s *_folder = (media_folder_s*)folder;
 120
 121         content_retip_if_fail(folder);
 122
 123         g_free(_folder->path);
 124         g_free(_folder->name);
 125         g_free(_folder->folder_id);
 126         g_free(_folder->storage_uuid);
 127         g_free(_folder);
 128
 129         return MEDIA_CONTENT_ERROR_NONE;
 130 }
 131 int media_folder_clone(media_folder_h *dst, media_folder_h src)
 132 {
 133         media_folder_s *_src = (media_folder_s*)src;
 134
 135         content_retip_if_fail(dst);
 136         content_retip_if_fail(src);
 137
 138         media_folder_s *_dst = g_new0(media_folder_s, 1);
 139
 140         _dst->folder_id = g_strdup(_src->folder_id);
 141         _dst->name = g_strdup(_src->name);
 142         _dst->path = g_strdup(_src->path);
 143         _dst->storage_uuid = g_strdup(_src->storage_uuid);
 144         _dst->storage_type = _src->storage_type;
 145
 146         *dst = (media_folder_h)_dst;
 147
 148         return MEDIA_CONTENT_ERROR_NONE;
 149 }
 150
 151 int media_folder_get_folder_id(media_folder_h folder, char **folder_id)
 152 {
 153         media_folder_s *_folder = (media_folder_s*)folder;
 154
 155         content_retip_if_fail(folder);
 156         content_retip_if_fail(folder_id);
 157
 158         *folder_id = g_strdup(_folder->folder_id);
 159
 160         return MEDIA_CONTENT_ERROR_NONE;
 161 }
 162
 163 int media_folder_get_path(media_folder_h folder, char **path)
 164 {
 165         media_folder_s *_folder = (media_folder_s*)folder;
 166
 167         content_retip_if_fail(folder);
 168         content_retip_if_fail(path);
 169
 170         *path = g_strdup(_folder->path);
 171
 172         return MEDIA_CONTENT_ERROR_NONE;
 173 }
 174
 175 int media_folder_get_name(media_folder_h folder, char **name)
 176 {
 177         media_folder_s *_folder = (media_folder_s*)folder;
 178
 179         content_retip_if_fail(folder);
 180         content_retip_if_fail(name);
 181
 182         *name = g_strdup(_folder->name);
 183
 184         return MEDIA_CONTENT_ERROR_NONE;
 185 }
 186
 187 int media_folder_get_storage_type(media_folder_h folder, media_content_storage_e* storage_type)
 188 {
 189         content_warn("DEPRECATION WARNING: media_folder_get_storage_type() is deprecated and will be removed from next release. Use storage_get_type_dev() instead.");
 190         media_folder_s *_folder = (media_folder_s*)folder;
 191
 192         content_retip_if_fail(folder);
 193         content_retip_if_fail(storage_type);
 194
 195         *storage_type = _folder->storage_type;
 196
 197         return MEDIA_CONTENT_ERROR_NONE;
 198 }
 199
 200 int media_folder_get_storage_id(media_folder_h folder, char **storage_id)
 201 {
 202         content_warn("DEPRECATION WARNING: media_folder_get_storage_id() is deprecated and will be removed from next release.");
 203         media_folder_s *_folder = (media_folder_s*)folder;
 204
 205         content_retip_if_fail(folder);
 206         content_retip_if_fail(storage_id);
 207
 208         *storage_id = g_strdup(_folder->storage_uuid);
 209
 210         return MEDIA_CONTENT_ERROR_NONE;
 211 }
 212
 213 int media_folder_get_folder_from_db(const char *folder_id, media_folder_h *folder)
 214 {
 215         int ret = MEDIA_CONTENT_ERROR_NONE;
 216         sqlite3_stmt *stmt = NULL;
 217         char select_query[DEFAULT_QUERY_SIZE] = {0, };
 218         media_folder_s *_folder = NULL;
 219
 220         content_retip_if_fail(STRING_VALID(folder_id));
 221         content_retip_if_fail(folder);
 222
 223         snprintf(select_query, sizeof(select_query), SELECT_FOLDER_FROM_FOLDER, folder_id);
 224
 225         ret = _content_get_result(select_query, &stmt);
 226         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 227
 228         if (sqlite3_step(stmt) == SQLITE_ROW) {
 229                 _folder = g_new0(media_folder_s, 1);
 230
 231                 _folder->folder_id = g_strdup(folder_id);
 232                 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 233                 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 234                 _folder->storage_type = (int)sqlite3_column_int(stmt, 2);
 235                 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 3));
 236
 237                 *folder = (media_folder_h)_folder;
 238         }
 239
 240         SQLITE3_FINALIZE(stmt);
 241
 242         return ret;
 243 }
 244 #ifdef _USE_TVPD_MODE
 245 int media_folder_update_to_db(media_folder_h folder)
 246 {
 247         int ret = MEDIA_CONTENT_ERROR_NONE;
 248         content_warn("DEPRECATION WARNING: media_folder_update_to_db() is deprecated and will be removed from next release.");
 249         media_folder_s *_folder = (media_folder_s*)folder;
 250         char repl_path[MAX_PATH_LEN] = {0, };
 251
 252         content_retip_if_fail(folder);
 253         content_retip_if_fail(STRING_VALID(_folder->folder_id));
 254
 255         if (!g_src_path)
 256                 return ret;
 257
 258
 259         ret = _media_content_replace_path(_folder->path, repl_path);
 260         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 261                 SAFE_FREE(g_src_path);
 262                 return ret;
 263         }
 264         ret = media_svc_rename_folder(_content_get_db_handle(), _folder->storage_uuid, g_src_path, repl_path, _content_get_uid());
 265         SAFE_FREE(g_src_path);
 266
 267         return _content_error_capi(ret);
 268 }
 269
 270 int media_folder_set_name(media_folder_h folder, const char *name)
 271 {
 272         int ret = MEDIA_CONTENT_ERROR_NONE;
 273         content_warn("DEPRECATION WARNING: media_folder_set_name() is deprecated and will be removed from next release.");
 274         media_folder_s *_folder = (media_folder_s*)folder;
 275
 276         char *folder_path = NULL;
 277         char new_folder_path[MAX_PATH_LEN] = {0,};
 278         char repl_path[MAX_PATH_LEN] = {0, };
 279
 280         content_retip_if_fail(folder);
 281         content_retip_if_fail(STRING_VALID(name));
 282         content_retip_if_fail(name[0] != '.');
 283         content_retip_if_fail(STRING_VALID(_folder->path));
 284         content_retip_if_fail(STRING_VALID(_folder->name));
 285
 286         ret = _media_content_replace_path(_folder->path, repl_path);
 287         content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 288
 289         folder_path = g_path_get_dirname(repl_path);
 290         content_sec_debug("Existed Folder Path : %s", repl_path);
 291         snprintf(new_folder_path, sizeof(new_folder_path), "%s/%s", folder_path, name);
 292         content_sec_debug("New Path : %s", new_folder_path);
 293
 294         g_free(g_src_path);
 295         g_src_path = g_strdup(repl_path);
 296
 297         g_free(_folder->path);
 298         g_free(_folder->name);
 299         g_free(folder_path);
 300
 301         _folder->path = g_strdup(new_folder_path);
 302         _folder->name = g_strdup(name);
 303
 304         return ret;
 305 }
 306
 307 int media_folder_insert_to_db(const char *path)
 308 {
 309         int ret = MEDIA_CONTENT_ERROR_NONE;
 310         char repl_path[MAX_PATH_LEN] = {0, };
 311         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
 312
 313         content_retip_if_fail(STRING_VALID(path));
 314
 315         ret = _media_content_replace_path(path, repl_path);
 316         content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 317
 318         content_retvm_if(_media_util_is_ignorable_dir(repl_path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid folder path");
 319
 320         ret = _media_content_check_dir(repl_path);
 321         content_retvm_if(ret == MEDIA_CONTENT_ERROR_PERMISSION_DENIED, ret, "Permission Denied");
 322         content_retvm_if(ret == MEDIA_CONTENT_ERROR_INVALID_PARAMETER, ret, "invalid path[%s]", path);
 323
 324         ret = media_svc_get_storage_id(_content_get_db_handle(), repl_path, storage_id, _content_get_uid());
 325         if (ret != MS_MEDIA_ERR_NONE) {
 326                 content_error("media_svc_get_storage_id failed : %d", ret);
 327                 return _content_error_capi(ret);
 328         }
 329
 330         ret = media_svc_check_folder_exist_by_path(_content_get_db_handle(), storage_id, repl_path);
 331         if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 332                 content_sec_debug("media_svc_check_folder_exist_by_path : no record : %s", repl_path);
 333                 ms_user_storage_type_e storage_type = MS_USER_STORAGE_INTERNAL;
 334
 335                 ret = ms_user_get_storage_type(_content_get_uid(), repl_path, &storage_type);
 336                 if (ret != MS_MEDIA_ERR_NONE) {
 337                         content_sec_error("ms_user_get_storage_type failed : %d", ret);
 338                         return _content_error_capi(ret);
 339                 }
 340
 341                 ret = media_svc_insert_folder(_content_get_db_handle(), storage_id, storage_type, repl_path, _content_get_uid());
 342                 if (ret != MS_MEDIA_ERR_NONE) {
 343                         if (ret == MS_MEDIA_ERR_DB_CONSTRAINT_FAIL) {
 344                                 content_sec_error("This item is already inserted. This may be normal operation because other process already did this (%s)", repl_path);
 345                                 ret = MEDIA_CONTENT_ERROR_NONE;
 346                         } else {
 347                                 content_sec_error("media_svc_insert_folder failed : %d (%s)", ret, repl_path);
 348                         }
 349
 350                         return _content_error_capi(ret);
 351                 }
 352
 353                 ret = media_svc_set_folder_scan_status(storage_id, repl_path, MEDIA_DIR_SCAN_DONE, _content_get_uid());
 354                 if (ret != MS_MEDIA_ERR_NONE) {
 355                         content_sec_error("ms_set_folder_scan_status failed : %d", ret);
 356                         return _content_error_capi(ret);
 357                 }
 358         } else if (ret != MS_MEDIA_ERR_NONE) {
 359                 content_sec_error("media_svc_check_folder_exist_by_path failed : %d (%s)", ret, repl_path);
 360                 return _content_error_capi(ret);
 361         }
 362
 363         return ret;
 364 }
 365
 366 int media_folder_get_scan_status(const char *storage_uuid, char* path, media_folder_scan_status_e *scan_status)
 367 {
 368         int ret = MEDIA_CONTENT_ERROR_NONE;
 369         int status = MEDIA_DIR_SCAN_NONE;
 370
 371         content_retip_if_fail(STRING_VALID(storage_uuid));
 372         content_retip_if_fail(STRING_VALID(path));
 373         content_retip_if_fail(scan_status);
 374
 375         ret = media_svc_get_folder_scan_status(_content_get_db_handle(), storage_uuid, path, &status);
 376         if (ret != MS_MEDIA_ERR_NONE) {
 377                 content_error("media_svc_get_folder_scan_status failed");
 378                 ret = _content_error_capi(ret);
 379         } else {
 380                 *scan_status = status;
 381         }
 382
 383         return ret;
 384 }
 385
 386 int media_folder_reset_scan_status(const char *storage_uuid, const char* path)
 387 {
 388         int ret = MEDIA_CONTENT_ERROR_NONE;
 389
 390         content_retip_if_fail(STRING_VALID(path));
 391
 392         ret = media_svc_set_folder_validity(FALSE, storage_uuid, path, 0, TRUE, _content_get_uid());
 393         if (ret != MS_MEDIA_ERR_NONE) {
 394                 content_error("set folder validity failed");
 395                 return _content_error_capi(ret);
 396         }
 397
 398         ret = media_svc_set_folder_scan_status(storage_uuid, path, MEDIA_DIR_SCAN_NONE, _content_get_uid());
 399         if (ret != MS_MEDIA_ERR_NONE) {
 400                 content_error("media_folder_reset_scan_status failed");
 401                 return _content_error_capi(ret);
 402         }
 403
 404         return ret;
 405 }
 406 #endif