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