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
  23 static char *g_src_path = NULL;
  24 #endif
  25
  26 int media_folder_get_folder_count_from_db(filter_h filter, int *folder_count)
  27 {
  28         int ret = MEDIA_CONTENT_ERROR_NONE;
  29
  30         content_retip_if_fail(folder_count);
  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         content_retip_if_fail(callback);
  51
  52 #ifdef _USE_TVPD_MODE
  53         g_mutex_lock(_content_get_db_mutex());
  54 #endif
  55
  56         ret = _media_db_get_folder(filter, callback, user_data);
  57
  58 #ifdef _USE_TVPD_MODE
  59         g_mutex_unlock(_content_get_db_mutex());
  60 #endif
  61
  62         return ret;
  63 }
  64
  65 int media_folder_get_media_count_from_db(const char *folder_id, filter_h filter, int *media_count)
  66 {
  67         int ret = MEDIA_CONTENT_ERROR_NONE;
  68
  69         content_retip_if_fail(STRING_VALID(folder_id));
  70         content_retip_if_fail(media_count);
  71
  72 #ifdef _USE_TVPD_MODE
  73         g_mutex_lock(_content_get_db_mutex());
  74 #endif
  75
  76         ret = _media_db_get_group_item_count(folder_id, filter, MEDIA_GROUP_FOLDER, media_count);
  77
  78 #ifdef _USE_TVPD_MODE
  79         g_mutex_unlock(_content_get_db_mutex());
  80 #endif
  81
  82         return ret;
  83 }
  84
  85 int media_folder_foreach_media_from_db(const char *folder_id, filter_h filter, media_info_cb callback, void *user_data)
  86 {
  87         int ret = MEDIA_CONTENT_ERROR_NONE;
  88
  89         content_retip_if_fail(STRING_VALID(folder_id));
  90         content_retip_if_fail(callback);
  91
  92 #ifdef _USE_TVPD_MODE
  93         g_mutex_lock(_content_get_db_mutex());
  94 #endif
  95
  96         ret = _media_db_get_group_item(folder_id, filter, callback, user_data, MEDIA_GROUP_FOLDER);
  97
  98 #ifdef _USE_TVPD_MODE
  99         g_mutex_unlock(_content_get_db_mutex());
 100 #endif
 101
 102         return ret;
 103 }
 104
 105 int media_folder_destroy(media_folder_h folder)
 106 {
 107         media_folder_s *_folder = (media_folder_s*)folder;
 108
 109         content_retip_if_fail(folder);
 110
 111         g_free(_folder->path);
 112         g_free(_folder->name);
 113         g_free(_folder->folder_id);
 114         g_free(_folder->storage_uuid);
 115         g_free(_folder);
 116
 117         return MEDIA_CONTENT_ERROR_NONE;
 118 }
 119 int media_folder_clone(media_folder_h *dst, media_folder_h src)
 120 {
 121         media_folder_s *_src = (media_folder_s*)src;
 122
 123         content_retip_if_fail(dst);
 124         content_retip_if_fail(src);
 125
 126         media_folder_s *_dst = g_new0(media_folder_s, 1);
 127
 128         _dst->folder_id = g_strdup(_src->folder_id);
 129         _dst->name = g_strdup(_src->name);
 130         _dst->path = g_strdup(_src->path);
 131         _dst->storage_uuid = g_strdup(_src->storage_uuid);
 132
 133         *dst = (media_folder_h)_dst;
 134
 135         return MEDIA_CONTENT_ERROR_NONE;
 136 }
 137
 138 int media_folder_get_folder_id(media_folder_h folder, char **folder_id)
 139 {
 140         media_folder_s *_folder = (media_folder_s*)folder;
 141
 142         content_retip_if_fail(folder);
 143         content_retip_if_fail(folder_id);
 144
 145         *folder_id = g_strdup(_folder->folder_id);
 146
 147         return MEDIA_CONTENT_ERROR_NONE;
 148 }
 149
 150 int media_folder_get_path(media_folder_h folder, char **path)
 151 {
 152         media_folder_s *_folder = (media_folder_s*)folder;
 153
 154         content_retip_if_fail(folder);
 155         content_retip_if_fail(path);
 156
 157         *path = g_strdup(_folder->path);
 158
 159         return MEDIA_CONTENT_ERROR_NONE;
 160 }
 161
 162 int media_folder_get_name(media_folder_h folder, char **name)
 163 {
 164         media_folder_s *_folder = (media_folder_s*)folder;
 165
 166         content_retip_if_fail(folder);
 167         content_retip_if_fail(name);
 168
 169         *name = g_strdup(_folder->name);
 170
 171         return MEDIA_CONTENT_ERROR_NONE;
 172 }
 173
 174 int media_folder_get_folder_from_db(const char *folder_id, media_folder_h *folder)
 175 {
 176         int ret = MEDIA_CONTENT_ERROR_NONE;
 177         sqlite3_stmt *stmt = NULL;
 178         char select_query[DEFAULT_QUERY_SIZE] = {0, };
 179         media_folder_s *_folder = NULL;
 180
 181         content_retip_if_fail(STRING_VALID(folder_id));
 182         content_retip_if_fail(folder);
 183
 184         snprintf(select_query, sizeof(select_query), SELECT_FOLDER_FROM_FOLDER, folder_id);
 185
 186         ret = _content_get_result(select_query, &stmt);
 187         content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 188
 189         if (sqlite3_step(stmt) == SQLITE_ROW) {
 190                 _folder = g_new0(media_folder_s, 1);
 191
 192                 _folder->folder_id = g_strdup(folder_id);
 193                 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 194                 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 195                 _folder->storage_uuid = g_strdup((const char *)sqlite3_column_text(stmt, 3));
 196
 197                 *folder = (media_folder_h)_folder;
 198         }
 199
 200         sqlite3_finalize(stmt);
 201
 202         return ret;
 203 }
 204 #ifdef _USE_TVPD_MODE
 205 int media_folder_update_to_db(media_folder_h folder)
 206 {
 207         int ret = MEDIA_CONTENT_ERROR_NONE;
 208         content_warn("DEPRECATION WARNING: media_folder_update_to_db() is deprecated and will be removed from next release.");
 209         media_folder_s *_folder = (media_folder_s*)folder;
 210
 211         content_retip_if_fail(folder);
 212         content_retip_if_fail(STRING_VALID(_folder->folder_id));
 213
 214         if (!g_src_path)
 215                 return ret;
 216
 217         ret = media_svc_rename_folder(_content_get_db_handle(), _folder->storage_uuid, g_src_path, _folder->path, _content_get_uid());
 218         g_free(g_src_path);
 219         g_src_path = NULL;
 220
 221         return _content_error_capi(ret);
 222 }
 223
 224 int media_folder_set_name(media_folder_h folder, const char *name)
 225 {
 226         int ret = MEDIA_CONTENT_ERROR_NONE;
 227         content_warn("DEPRECATION WARNING: media_folder_set_name() is deprecated and will be removed from next release.");
 228         media_folder_s *_folder = (media_folder_s*)folder;
 229         char *parent_folder_path = NULL;
 230
 231         content_retip_if_fail(folder);
 232         content_retip_if_fail(STRING_VALID(name));
 233         content_retip_if_fail(name[0] != '.');
 234         content_retip_if_fail(STRING_VALID(_folder->path));
 235         content_retip_if_fail(STRING_VALID(_folder->name));
 236
 237         // Change name..
 238         g_free(_folder->name);
 239         _folder->name = g_strdup(name);
 240
 241         // Change path..
 242         g_free(g_src_path);
 243         g_src_path = g_strdup(_folder->path);
 244         g_free(_folder->path);
 245
 246         parent_folder_path = g_path_get_dirname(g_src_path);
 247         _folder->path = g_strdup_printf("%s/%s", parent_folder_path, name);
 248         g_free(parent_folder_path);
 249
 250         content_sec_debug("Old[%s] New[%s]", g_src_path, _folder->path);
 251
 252         return ret;
 253 }
 254
 255 int media_folder_get_scan_status(const char *storage_uuid, char* path, media_folder_scan_status_e *scan_status)
 256 {
 257         int ret = MEDIA_CONTENT_ERROR_NONE;
 258         int status = MEDIA_DIR_SCAN_NONE;
 259
 260         content_retip_if_fail(STRING_VALID(storage_uuid));
 261         content_retip_if_fail(STRING_VALID(path));
 262         content_retip_if_fail(scan_status);
 263
 264         ret = media_svc_get_folder_scan_status(_content_get_db_handle(), path, &status);
 265         if (ret != MS_MEDIA_ERR_NONE) {
 266                 content_error("media_svc_get_folder_scan_status failed");
 267                 ret = _content_error_capi(ret);
 268         } else {
 269                 *scan_status = status;
 270         }
 271
 272         return ret;
 273 }
 274
 275 int media_folder_reset_scan_status(const char *storage_uuid, const char* path)
 276 {
 277         int ret = MEDIA_CONTENT_ERROR_NONE;
 278
 279         content_retip_if_fail(STRING_VALID(path));
 280
 281         ret = media_svc_set_folder_validity(FALSE, path, 0, TRUE, _content_get_uid());
 282         if (ret != MS_MEDIA_ERR_NONE) {
 283                 content_error("set folder validity failed");
 284                 return _content_error_capi(ret);
 285         }
 286
 287         ret = media_svc_set_folder_scan_status(storage_uuid, path, MEDIA_DIR_SCAN_NONE, false, _content_get_uid());
 288         if (ret != MS_MEDIA_ERR_NONE) {
 289                 content_error("media_folder_reset_scan_status failed");
 290                 return _content_error_capi(ret);
 291         }
 292
 293         return ret;
 294 }
 295 #endif