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         if (!folder_count) {
  33                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  34                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  35         }
  36 #ifdef _USE_TVPD_MODE
  37         g_mutex_lock(_content_get_db_mutex());
  38 #endif
  39
  40         ret = _media_db_get_group_count(filter, MEDIA_GROUP_FOLDER, folder_count);
  41
  42 #ifdef _USE_TVPD_MODE
  43         g_mutex_unlock(_content_get_db_mutex());
  44 #endif
  45
  46
  47         return ret;
  48 }
  49
  50 int media_folder_foreach_folder_from_db(filter_h filter, media_folder_cb callback, void *user_data)
  51 {
  52         int ret = MEDIA_CONTENT_ERROR_NONE;
  53
  54         if (callback == NULL) {
  55                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  56                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  57         }
  58
  59 #ifdef _USE_TVPD_MODE
  60         g_mutex_lock(_content_get_db_mutex());
  61 #endif
  62
  63         ret = _media_db_get_folder(filter, callback, user_data);
  64
  65 #ifdef _USE_TVPD_MODE
  66         g_mutex_unlock(_content_get_db_mutex());
  67 #endif
  68
  69         return ret;
  70 }
  71
  72 int media_folder_get_media_count_from_db(const char *folder_id, filter_h filter, int *media_count)
  73 {
  74         int ret = MEDIA_CONTENT_ERROR_NONE;
  75
  76         if (STRING_VALID(folder_id) && media_count) {
  77 #ifdef _USE_TVPD_MODE
  78                 g_mutex_lock(_content_get_db_mutex());
  79 #endif
  80
  81                 ret = _media_db_get_group_item_count(folder_id, filter, MEDIA_GROUP_FOLDER, media_count);
  82
  83 #ifdef _USE_TVPD_MODE
  84                 g_mutex_unlock(_content_get_db_mutex());
  85 #endif
  86
  87         } else {
  88                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  89                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  90         }
  91
  92         return ret;
  93 }
  94
  95 int media_folder_foreach_media_from_db(const char *folder_id, filter_h filter, media_info_cb callback, void *user_data)
  96 {
  97         int ret = MEDIA_CONTENT_ERROR_NONE;
  98
  99         if ((callback != NULL) && STRING_VALID(folder_id)) {
 100 #ifdef _USE_TVPD_MODE
 101                 g_mutex_lock(_content_get_db_mutex());
 102 #endif
 103
 104                 ret = _media_db_get_group_item(folder_id, filter, callback, user_data, MEDIA_GROUP_FOLDER);
 105
 106 #ifdef _USE_TVPD_MODE
 107                 g_mutex_unlock(_content_get_db_mutex());
 108 #endif
 109
 110         } else {
 111                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 112                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 113         }
 114
 115         return ret;
 116 }
 117
 118 #ifdef _USE_SENIOR_MODE
 119 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)
 120 {
 121         int ret = MEDIA_CONTENT_ERROR_NONE;
 122
 123         if ((callback != NULL) && STRING_VALID(folder_id)) {
 124                 ret = _media_db_get_group_item_by_union_select(folder_id, filter1, filter2, callback, user_data);
 125         } else {
 126                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 127                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 128         }
 129
 130         return ret;
 131 }
 132 #endif
 133
 134 int media_folder_destroy(media_folder_h folder)
 135 {
 136         int ret = MEDIA_CONTENT_ERROR_NONE;
 137         media_folder_s *_folder = (media_folder_s*)folder;
 138
 139         if (_folder) {
 140                 g_free(_folder->path);
 141                 g_free(_folder->name);
 142                 g_free(_folder->folder_id);
 143                 g_free(_folder->storage_uuid);
 144                 g_free(_folder);
 145                 ret = MEDIA_CONTENT_ERROR_NONE;
 146         } else {
 147                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 148                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 149         }
 150
 151         return ret;
 152 }
 153 int media_folder_clone(media_folder_h *dst, media_folder_h src)
 154 {
 155         media_folder_s *_src = (media_folder_s*)src;
 156
 157         content_retip_if_fail(dst);
 158         content_retip_if_fail(src);
 159
 160         media_folder_s *_dst = g_new0(media_folder_s, 1);
 161
 162         _dst->folder_id = g_strdup(_src->folder_id);
 163         _dst->name = g_strdup(_src->name);
 164         _dst->path = g_strdup(_src->path);
 165         _dst->storage_uuid = g_strdup(_src->storage_uuid);
 166         _dst->storage_type = _src->storage_type;
 167
 168         *dst = (media_folder_h)_dst;
 169
 170         return MEDIA_CONTENT_ERROR_NONE;
 171 }
 172
 173 int media_folder_get_folder_id(media_folder_h folder, char **folder_id)
 174 {
 175         media_folder_s *_folder = (media_folder_s*)folder;
 176
 177         content_retip_if_fail(folder);
 178         content_retip_if_fail(folder_id);
 179
 180         *folder_id = g_strdup(_folder->folder_id);
 181
 182         return MEDIA_CONTENT_ERROR_NONE;
 183 }
 184
 185 int media_folder_get_path(media_folder_h folder, char **path)
 186 {
 187         media_folder_s *_folder = (media_folder_s*)folder;
 188
 189         content_retip_if_fail(folder);
 190         content_retip_if_fail(path);
 191
 192         *path = g_strdup(_folder->path);
 193
 194         return MEDIA_CONTENT_ERROR_NONE;
 195 }
 196
 197 int media_folder_get_name(media_folder_h folder, char **name)
 198 {
 199         media_folder_s *_folder = (media_folder_s*)folder;
 200
 201         content_retip_if_fail(folder);
 202         content_retip_if_fail(name);
 203
 204         *name = g_strdup(_folder->name);
 205
 206         return MEDIA_CONTENT_ERROR_NONE;
 207 }
 208
 209 int media_folder_get_storage_type(media_folder_h folder, media_content_storage_e* storage_type)
 210 {
 211         int ret = MEDIA_CONTENT_ERROR_NONE;
 212         content_warn("DEPRECATION WARNING: media_folder_get_storage_type() is deprecated and will be removed from next release. Use storage_get_type_dev() instead.");
 213         media_folder_s *_folder = (media_folder_s*)folder;
 214
 215         if (_folder) {
 216                 *storage_type = _folder->storage_type;
 217                 ret = MEDIA_CONTENT_ERROR_NONE;
 218         } else {
 219                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 220                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 221         }
 222
 223         return ret;
 224 }
 225
 226 int media_folder_get_storage_id(media_folder_h folder, char **storage_id)
 227 {
 228         content_warn("DEPRECATION WARNING: media_folder_get_storage_id() is deprecated and will be removed from next release.");
 229         media_folder_s *_folder = (media_folder_s*)folder;
 230
 231         content_retip_if_fail(folder);
 232         content_retip_if_fail(storage_id);
 233
 234         *storage_id = g_strdup(_folder->storage_uuid);
 235
 236         return MEDIA_CONTENT_ERROR_NONE;
 237 }
 238
 239 int media_folder_get_folder_from_db(const char *folder_id, media_folder_h *folder)
 240 {
 241         int ret = MEDIA_CONTENT_ERROR_NONE;
 242         sqlite3_stmt *stmt = NULL;
 243         char select_query[DEFAULT_QUERY_SIZE] = {0, };
 244         media_folder_s *_folder = NULL;
 245
 246         content_retip_if_fail(STRING_VALID(folder_id));
 247         content_retip_if_fail(folder);
 248
 249         snprintf(select_query, sizeof(select_query), SELECT_FOLDER_FROM_FOLDER, folder_id);
 250
 251         ret = _content_get_result(select_query, &stmt);
 252         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 253
 254         if (sqlite3_step(stmt) == SQLITE_ROW) {
 255                 _folder = g_new0(media_folder_s, 1);
 256
 257                 _folder->folder_id = g_strdup(folder_id);
 258                 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 259                 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 260                 _folder->storage_type = (int)sqlite3_column_int(stmt, 2);
 261                 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 3));
 262
 263                 *folder = (media_folder_h)_folder;
 264         }
 265
 266         SQLITE3_FINALIZE(stmt);
 267
 268         return ret;
 269 }
 270 #ifdef _USE_TVPD_MODE
 271 int media_folder_update_to_db(media_folder_h folder)
 272 {
 273         int ret = MEDIA_CONTENT_ERROR_NONE;
 274         content_warn("DEPRECATION WARNING: media_folder_update_to_db() is deprecated and will be removed from next release.");
 275         media_folder_s *_folder = (media_folder_s*)folder;
 276         char repl_path[MAX_PATH_LEN] = {0, };
 277
 278         if ((_folder == NULL) || (_folder->folder_id == NULL)) {
 279                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 280                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 281         }
 282
 283         if (STRING_VALID(_folder->folder_id) && g_src_path) {
 284                 ret = _media_content_replace_path(_folder->path, repl_path);
 285                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
 286                         SAFE_FREE(g_src_path);
 287                         return ret;
 288                 }
 289                 ret = media_svc_rename_folder(_content_get_db_handle(), _folder->storage_uuid, g_src_path, repl_path, _content_get_uid());
 290                 SAFE_FREE(g_src_path);
 291
 292                 return _content_error_capi(ret);
 293         }
 294
 295         return ret;
 296 }
 297
 298 int media_folder_set_name(media_folder_h folder, const char *name)
 299 {
 300         int ret = MEDIA_CONTENT_ERROR_NONE;
 301         content_warn("DEPRECATION WARNING: media_folder_set_name() is deprecated and will be removed from next release.");
 302         media_folder_s *_folder = (media_folder_s*)folder;
 303
 304         if (_folder != NULL && STRING_VALID(name) && name[0] != '.') {
 305                 if (STRING_VALID(_folder->path) && STRING_VALID(_folder->name)) {
 306                         char *folder_path = NULL;
 307                         char new_folder_path[MAX_PATH_LEN] = {0,};
 308                         char repl_path[MAX_PATH_LEN] = {0, };
 309
 310                         ret = _media_content_replace_path(_folder->path, repl_path);
 311                         content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 312
 313                         folder_path = g_path_get_dirname(repl_path);
 314                         content_sec_debug("Existed Folder Path : %s", repl_path);
 315                         snprintf(new_folder_path, sizeof(new_folder_path), "%s/%s", folder_path, name);
 316                         content_sec_debug("New Path : %s", new_folder_path);
 317
 318                         g_free(g_src_path);
 319                         g_src_path = g_strdup(repl_path);
 320
 321                         g_free(_folder->path);
 322                         g_free(_folder->name);
 323                         g_free(folder_path);
 324
 325                         _folder->path = g_strdup(new_folder_path);
 326                         _folder->name = g_strdup(name);
 327                 } else {
 328                         content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 329                         ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 330                 }
 331         } else {
 332                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 333                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 334         }
 335
 336         return ret;
 337 }
 338
 339 int media_folder_insert_to_db(const char *path)
 340 {
 341         int ret = MEDIA_CONTENT_ERROR_NONE;
 342         char repl_path[MAX_PATH_LEN] = {0, };
 343         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
 344
 345         content_retvm_if(!STRING_VALID(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid path");
 346
 347         ret = _media_content_replace_path(path, repl_path);
 348         content_retvm_if(!STRING_VALID(repl_path), MEDIA_CONTENT_ERROR_INVALID_OPERATION, "path replacement failed");
 349
 350         content_retvm_if(_media_util_is_ignorable_dir(repl_path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid folder path");
 351
 352         ret = _media_content_check_dir(repl_path);
 353         content_retvm_if(ret == MEDIA_CONTENT_ERROR_PERMISSION_DENIED, ret, "Permission Denied");
 354         content_retvm_if(ret == MEDIA_CONTENT_ERROR_INVALID_PARAMETER, ret, "invalid path[%s]", path);
 355
 356         ret = media_svc_get_storage_id(_content_get_db_handle(), repl_path, storage_id, _content_get_uid());
 357         if (ret != MS_MEDIA_ERR_NONE) {
 358                 content_error("media_svc_get_storage_id failed : %d", ret);
 359                 return _content_error_capi(ret);
 360         }
 361
 362         ret = media_svc_check_folder_exist_by_path(_content_get_db_handle(), storage_id, repl_path);
 363         if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 364                 content_sec_debug("media_svc_check_folder_exist_by_path : no record : %s", repl_path);
 365                 ms_user_storage_type_e storage_type = MS_USER_STORAGE_INTERNAL;
 366
 367                 ret = ms_user_get_storage_type(_content_get_uid(), repl_path, &storage_type);
 368                 if (ret != MS_MEDIA_ERR_NONE) {
 369                         content_sec_error("ms_user_get_storage_type failed : %d", ret);
 370                         return _content_error_capi(ret);
 371                 }
 372
 373                 ret = media_svc_insert_folder(_content_get_db_handle(), storage_id, storage_type, repl_path, _content_get_uid());
 374                 if (ret != MS_MEDIA_ERR_NONE) {
 375                         if (ret == MS_MEDIA_ERR_DB_CONSTRAINT_FAIL) {
 376                                 content_sec_error("This item is already inserted. This may be normal operation because other process already did this (%s)", repl_path);
 377                                 ret = MEDIA_CONTENT_ERROR_NONE;
 378                         } else {
 379                                 content_sec_error("media_svc_insert_folder failed : %d (%s)", ret, repl_path);
 380                         }
 381
 382                         return _content_error_capi(ret);
 383                 }
 384
 385                 ret = media_svc_set_folder_scan_status(storage_id, repl_path, MEDIA_DIR_SCAN_DONE, _content_get_uid());
 386                 if (ret != MS_MEDIA_ERR_NONE) {
 387                         content_sec_error("ms_set_folder_scan_status failed : %d", ret);
 388                         return _content_error_capi(ret);
 389                 }
 390         } else if (ret != MS_MEDIA_ERR_NONE) {
 391                 content_sec_error("media_svc_check_folder_exist_by_path failed : %d (%s)", ret, repl_path);
 392                 return _content_error_capi(ret);
 393         }
 394
 395         return ret;
 396 }
 397
 398 int media_folder_get_scan_status(const char *storage_uuid, char* path, media_folder_scan_status_e *scan_status)
 399 {
 400         int ret = MEDIA_CONTENT_ERROR_NONE;
 401         int status = MEDIA_DIR_SCAN_NONE;
 402
 403         if (STRING_VALID(storage_uuid) && STRING_VALID(path)) {
 404                 ret = media_svc_get_folder_scan_status(_content_get_db_handle(), storage_uuid, path, &status);
 405                 if (ret != MS_MEDIA_ERR_NONE) {
 406                         content_error("media_svc_get_folder_scan_status failed");
 407                         ret = _content_error_capi(ret);
 408                 } else {
 409                         *scan_status = status;
 410                 }
 411         } else {
 412                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 413                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 414         }
 415
 416         return ret;
 417 }
 418
 419 int media_folder_reset_scan_status(const char *storage_uuid, const char* path)
 420 {
 421         int ret = MEDIA_CONTENT_ERROR_NONE;
 422         if (STRING_VALID(path)) {
 423                 ret = media_svc_set_folder_validity(FALSE, storage_uuid, path, 0, TRUE, _content_get_uid());
 424                 if (ret != MS_MEDIA_ERR_NONE) {
 425                         content_error("set folder validity failed");
 426                         ret = _content_error_capi(ret);
 427                         return ret;
 428                 }
 429
 430                 ret = media_svc_set_folder_scan_status(storage_uuid, path, MEDIA_DIR_SCAN_NONE, _content_get_uid());
 431                 if (ret != MS_MEDIA_ERR_NONE) {
 432                         content_error("media_folder_reset_scan_status failed");
 433                         ret = _content_error_capi(ret);
 434                 }
 435         } else {
 436                 content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 437                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 438         }
 439
 440         return ret;
 441 }
 442 #endif