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
 241         content_retip_if_fail(folder);
 242         content_retip_if_fail(STRING_VALID(_folder->folder_id));
 243
 244         if (!g_src_path)
 245                 return ret;
 246
 247         ret = media_svc_rename_folder(_content_get_db_handle(), _folder->storage_uuid, g_src_path, _folder->path, _content_get_uid());
 248         SAFE_FREE(g_src_path);
 249
 250         return _content_error_capi(ret);
 251 }
 252
 253 int media_folder_set_name(media_folder_h folder, const char *name)
 254 {
 255         int ret = MEDIA_CONTENT_ERROR_NONE;
 256         content_warn("DEPRECATION WARNING: media_folder_set_name() is deprecated and will be removed from next release.");
 257         media_folder_s *_folder = (media_folder_s*)folder;
 258         char *parent_folder_path = NULL;
 259
 260         content_retip_if_fail(folder);
 261         content_retip_if_fail(STRING_VALID(name));
 262         content_retip_if_fail(name[0] != '.');
 263         content_retip_if_fail(STRING_VALID(_folder->path));
 264         content_retip_if_fail(STRING_VALID(_folder->name));
 265
 266         // Change name..
 267         g_free(_folder->name);
 268         _folder->name = g_strdup(name);
 269
 270         // Change path..
 271         g_free(g_src_path);
 272         g_src_path = g_strdup(_folder->path);
 273         g_free(_folder->path);
 274
 275         parent_folder_path = g_path_get_dirname(g_src_path);
 276         _folder->path = g_strdup_printf("%s/%s", parent_folder_path, name);
 277         g_free(parent_folder_path);
 278
 279         content_sec_debug("Old[%s] New[%s]", g_src_path, _folder->path);
 280
 281         return ret;
 282 }
 283
 284 int media_folder_insert_to_db(const char *path)
 285 {
 286         int ret = MEDIA_CONTENT_ERROR_NONE;
 287         char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
 288
 289         content_retip_if_fail(STRING_VALID(path));
 290
 291         content_retvm_if(_media_util_is_ignorable_dir(path), MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid folder path");
 292
 293         ret = _media_content_check_dir(path);
 294         content_retvm_if(ret == MEDIA_CONTENT_ERROR_PERMISSION_DENIED, ret, "Permission Denied");
 295         content_retvm_if(ret == MEDIA_CONTENT_ERROR_INVALID_PARAMETER, ret, "invalid path[%s]", path);
 296
 297         ret = media_svc_get_storage_id(_content_get_db_handle(), path, storage_id, _content_get_uid());
 298         if (ret != MS_MEDIA_ERR_NONE) {
 299                 content_error("media_svc_get_storage_id failed : %d", ret);
 300                 return _content_error_capi(ret);
 301         }
 302
 303         ret = media_svc_check_folder_exist_by_path(_content_get_db_handle(), storage_id, path);
 304         if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
 305                 content_sec_debug("media_svc_check_folder_exist_by_path : no record : %s", path);
 306                 ms_user_storage_type_e storage_type = MS_USER_STORAGE_INTERNAL;
 307
 308                 ret = ms_user_get_storage_type(_content_get_uid(), path, &storage_type);
 309                 if (ret != MS_MEDIA_ERR_NONE) {
 310                         content_sec_error("ms_user_get_storage_type failed : %d", ret);
 311                         return _content_error_capi(ret);
 312                 }
 313
 314                 ret = media_svc_insert_folder(_content_get_db_handle(), storage_id, storage_type, path, false, _content_get_uid());
 315                 if (ret != MS_MEDIA_ERR_NONE) {
 316                         if (ret == MS_MEDIA_ERR_DB_CONSTRAINT_FAIL) {
 317                                 content_sec_error("This item is already inserted. This may be normal operation because other process already did this (%s)", path);
 318                                 ret = MEDIA_CONTENT_ERROR_NONE;
 319                         } else {
 320                                 content_sec_error("media_svc_insert_folder failed : %d (%s)", ret, path);
 321                         }
 322
 323                         return _content_error_capi(ret);
 324                 }
 325
 326                 ret = media_svc_set_folder_scan_status(storage_id, path, MEDIA_DIR_SCAN_DONE, false, _content_get_uid());
 327                 if (ret != MS_MEDIA_ERR_NONE) {
 328                         content_sec_error("media_svc_set_folder_scan_status failed : %d", ret);
 329                         return _content_error_capi(ret);
 330                 }
 331         } else if (ret != MS_MEDIA_ERR_NONE) {
 332                 content_sec_error("media_svc_check_folder_exist_by_path failed : %d (%s)", ret, path);
 333                 return _content_error_capi(ret);
 334         }
 335
 336         return ret;
 337 }
 338
 339 int media_folder_get_scan_status(const char *storage_uuid, char* path, media_folder_scan_status_e *scan_status)
 340 {
 341         int ret = MEDIA_CONTENT_ERROR_NONE;
 342         int status = MEDIA_DIR_SCAN_NONE;
 343
 344         content_retip_if_fail(STRING_VALID(storage_uuid));
 345         content_retip_if_fail(STRING_VALID(path));
 346         content_retip_if_fail(scan_status);
 347
 348         ret = media_svc_get_folder_scan_status(_content_get_db_handle(), storage_uuid, path, &status);
 349         if (ret != MS_MEDIA_ERR_NONE) {
 350                 content_error("media_svc_get_folder_scan_status failed");
 351                 ret = _content_error_capi(ret);
 352         } else {
 353                 *scan_status = status;
 354         }
 355
 356         return ret;
 357 }
 358
 359 int media_folder_reset_scan_status(const char *storage_uuid, const char* path)
 360 {
 361         int ret = MEDIA_CONTENT_ERROR_NONE;
 362
 363         content_retip_if_fail(STRING_VALID(path));
 364
 365         ret = media_svc_set_folder_validity(FALSE, storage_uuid, path, 0, TRUE, _content_get_uid());
 366         if (ret != MS_MEDIA_ERR_NONE) {
 367                 content_error("set folder validity failed");
 368                 return _content_error_capi(ret);
 369         }
 370
 371         ret = media_svc_set_folder_scan_status(storage_uuid, path, MEDIA_DIR_SCAN_NONE, false, _content_get_uid());
 372         if (ret != MS_MEDIA_ERR_NONE) {
 373                 content_error("media_folder_reset_scan_status failed");
 374                 return _content_error_capi(ret);
 375         }
 376
 377         return ret;
 378 }
 379 #endif