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_content.h>
  19 #include <media_info_private.h>
  20 #include <media_util_private.h>
  21
  22 static char *g_src_path = NULL;
  23
  24 static char *__media_folder_get_update_folder_sql(media_folder_h folder);
  25
  26 static char *__media_folder_get_update_folder_sql(media_folder_h folder)
  27 {
  28         media_folder_s *_folder = (media_folder_s*)folder;
  29         char *return_sql = NULL;
  30
  31         return_sql = sqlite3_mprintf("%q='%q', %q='%q', %q=%d ",
  32                                                                                         DB_FIELD_FOLDER_PATH, _folder->path,
  33                                                                                         DB_FIELD_FOLDER_NAME, _folder->name,
  34                                                                                         DB_FIELD_FOLDER_MODIFIED_TIME, _folder->modified_time);
  35
  36         return return_sql;
  37 }
  38
  39 int media_folder_get_folder_count_from_db(filter_h filter, int *folder_count)
  40 {
  41         int ret = MEDIA_CONTENT_ERROR_NONE;
  42
  43         media_content_debug_func();
  44
  45         if(!folder_count)
  46         {
  47                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  48                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  49         }
  50
  51         ret = _media_db_get_group_count(filter, MEDIA_GROUP_FOLDER, folder_count);
  52
  53         return ret;
  54 }
  55
  56 int media_folder_foreach_folder_from_db(filter_h filter, media_folder_cb callback, void *user_data)
  57 {
  58         int ret = MEDIA_CONTENT_ERROR_NONE;
  59
  60         media_content_debug_func();
  61
  62         if(callback == NULL)
  63         {
  64                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  65                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  66         }
  67
  68         ret = _media_db_get_folder(filter, callback, user_data);
  69
  70         return ret;
  71 }
  72
  73 int media_folder_get_media_count_from_db(const char *folder_id, filter_h filter, int *media_count)
  74 {
  75         int ret = MEDIA_CONTENT_ERROR_NONE;
  76
  77         media_content_debug_func();
  78
  79         if(STRING_VALID(folder_id) && media_count)
  80         {
  81                 ret = _media_db_get_group_item_count(folder_id, filter, MEDIA_GROUP_FOLDER, media_count);
  82         }
  83         else
  84         {
  85                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  86                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  87         }
  88
  89         return ret;
  90 }
  91
  92 int media_folder_foreach_media_from_db(const char *folder_id, filter_h filter, media_info_cb callback, void *user_data)
  93 {
  94         int ret = MEDIA_CONTENT_ERROR_NONE;
  95
  96         media_content_debug_func();
  97
  98         if((callback != NULL) && STRING_VALID(folder_id))
  99         {
 100                 ret = _media_db_get_group_item(folder_id, filter, callback, user_data, MEDIA_GROUP_FOLDER);
 101         }
 102         else
 103         {
 104                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 105                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 106         }
 107
 108         return ret;
 109 }
 110
 111 int media_folder_destroy(media_folder_h folder)
 112 {
 113         int ret = MEDIA_CONTENT_ERROR_NONE;
 114         media_folder_s *_folder = (media_folder_s*)folder;
 115         if(_folder)
 116         {
 117                 SAFE_FREE(_folder->path);
 118                 SAFE_FREE(_folder->name);
 119                 SAFE_FREE(_folder->folder_id);
 120                 SAFE_FREE(_folder);
 121                 ret = MEDIA_CONTENT_ERROR_NONE;
 122         }
 123         else
 124         {
 125                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 126                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 127         }
 128
 129         return ret;
 130 }
 131 int media_folder_clone(media_folder_h *dst, media_folder_h src)
 132 {
 133         int ret = MEDIA_CONTENT_ERROR_NONE;
 134         media_folder_s *_src = (media_folder_s*)src;
 135
 136         if(_src != NULL)
 137         {
 138                 media_folder_s *_dst = (media_folder_s*)calloc(1, sizeof(media_folder_s));
 139                 if(_dst == NULL)
 140                 {
 141                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 142                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 143                 }
 144
 145                 if(STRING_VALID(_src->folder_id))
 146                 {
 147                         _dst->folder_id = strdup(_src->folder_id);
 148                         if(_dst->folder_id == NULL)
 149                         {
 150                                 SAFE_FREE(_dst);
 151                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 152                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 153                         }
 154                 }
 155
 156                 _dst->storage_type = _src->storage_type;
 157
 158                 if(STRING_VALID(_src->name))
 159                 {
 160                         _dst->name = strdup(_src->name);
 161                         if(_dst->name == NULL)
 162                         {
 163                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 164                                 media_folder_destroy((media_folder_h)_dst);
 165                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 166                         }
 167                 }
 168
 169                 if(STRING_VALID(_src->path))
 170                 {
 171                         _dst->path = strdup(_src->path);
 172                         if(_dst->path == NULL)
 173                         {
 174                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 175                                 media_folder_destroy((media_folder_h)_dst);
 176                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 177                         }
 178                 }
 179
 180                 *dst = (media_folder_h)_dst;
 181
 182                 ret = MEDIA_CONTENT_ERROR_NONE;
 183         }
 184         else
 185         {
 186                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 187                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 188         }
 189
 190         return ret;
 191 }
 192
 193 int media_folder_get_folder_id(media_folder_h folder, char **folder_id)
 194 {
 195         int ret = MEDIA_CONTENT_ERROR_NONE;
 196         media_folder_s *_folder = (media_folder_s*)folder;
 197
 198         if(_folder)
 199         {
 200                 if(STRING_VALID(_folder->folder_id))
 201                 {
 202                         *folder_id = strdup(_folder->folder_id);
 203                         if(*folder_id == NULL)
 204                         {
 205                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 206                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 207                         }
 208                 }
 209                 else
 210                 {
 211                         *folder_id = NULL;
 212                 }
 213                 ret = MEDIA_CONTENT_ERROR_NONE;
 214         }
 215         else
 216         {
 217                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 218                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 219         }
 220
 221         return ret;
 222 }
 223
 224 int media_folder_get_path(media_folder_h folder, char **path)
 225 {
 226         int ret = MEDIA_CONTENT_ERROR_NONE;
 227         media_folder_s *_folder = (media_folder_s*)folder;
 228         if(_folder)
 229         {
 230                 if(STRING_VALID(_folder->path))
 231                 {
 232                         *path = strdup(_folder->path);
 233                         if(*path == NULL)
 234                         {
 235                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 236                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 237                         }
 238                 }
 239                 else
 240                 {
 241                         *path = NULL;
 242                 }
 243                 ret = MEDIA_CONTENT_ERROR_NONE;
 244
 245         }
 246         else
 247         {
 248                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 249                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 250         }
 251
 252         return ret;
 253
 254 }
 255
 256 int media_folder_get_name(media_folder_h folder, char **name)
 257 {
 258         int ret = MEDIA_CONTENT_ERROR_NONE;
 259         media_folder_s *_folder = (media_folder_s*)folder;
 260         if(_folder)
 261         {
 262                 if(STRING_VALID(_folder->name))
 263                 {
 264                         *name = strdup(_folder->name);
 265                         if(*name == NULL)
 266                         {
 267                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 268                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 269                         }
 270                 }
 271                 else
 272                 {
 273                         *name = NULL;
 274                 }
 275                 ret = MEDIA_CONTENT_ERROR_NONE;
 276
 277         }
 278         else
 279         {
 280                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 281                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 282         }
 283
 284         return ret;
 285 }
 286
 287 int media_folder_get_modified_time(media_folder_h folder, time_t* time)
 288 {
 289         int ret = MEDIA_CONTENT_ERROR_NONE;
 290         media_folder_s *_folder = (media_folder_s*)folder;
 291         if(_folder)
 292         {
 293                 *time = _folder->modified_time;
 294                 ret = MEDIA_CONTENT_ERROR_NONE;
 295         }
 296         else
 297         {
 298                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 299                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 300         }
 301
 302         return ret;
 303 }
 304
 305 int media_folder_get_storage_type(media_folder_h folder, media_content_storage_e* storage_type)
 306 {
 307         int ret = MEDIA_CONTENT_ERROR_NONE;
 308         media_folder_s *_folder = (media_folder_s*)folder;
 309         if(_folder)
 310         {
 311                 *storage_type = _folder->storage_type;
 312                 ret = MEDIA_CONTENT_ERROR_NONE;
 313         }
 314         else
 315         {
 316                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 317                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 318         }
 319
 320         return ret;
 321 }
 322
 323 int media_folder_get_folder_from_db(const char *folder_id, media_folder_h *folder)
 324 {
 325         int ret = MEDIA_CONTENT_ERROR_NONE;
 326         int ret_view = MEDIA_CONTENT_ERROR_NONE;
 327         sqlite3_stmt *stmt = NULL;
 328         char select_query[DEFAULT_QUERY_SIZE];
 329
 330         if(!STRING_VALID(folder_id))
 331         {
 332                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 333                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 334         }
 335
 336         memset(select_query, 0x00, sizeof(select_query));
 337
 338         snprintf(select_query, sizeof(select_query), SELECT_FOLDER_FROM_FOLDER, folder_id);
 339
 340         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 341         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 342
 343         while(sqlite3_step(stmt) == SQLITE_ROW)
 344         {
 345                 media_folder_s *_folder = (media_folder_s*)calloc(1, sizeof(media_folder_s));
 346
 347                 if(_folder == NULL)
 348                 {
 349                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 350                         SQLITE3_FINALIZE(stmt);
 351                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 352                 }
 353
 354                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
 355                         _folder->folder_id = strdup((const char *)sqlite3_column_text(stmt, 0));
 356
 357                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 1)))
 358                         _folder->path = strdup((const char *)sqlite3_column_text(stmt, 1));
 359
 360                 if(STRING_VALID((const char *)sqlite3_column_text(stmt, 2)))
 361                         _folder->name = strdup((const char *)sqlite3_column_text(stmt, 2));
 362
 363                 *folder = (media_folder_h)_folder;
 364         }
 365
 366         SQLITE3_FINALIZE(stmt);
 367         return ret;
 368 }
 369
 370 int media_folder_update_to_db(media_folder_h folder)
 371 {
 372         int ret = MEDIA_CONTENT_ERROR_NONE;
 373         int len = 0;
 374         media_folder_s *_folder = (media_folder_s*)folder;
 375
 376         char sql[MAX_QUERY_SIZE];
 377         memset(sql, '\0', sizeof(sql));
 378         char *set_sql = NULL;
 379         char *where_sql = NULL;
 380
 381         if((_folder != NULL) && STRING_VALID(_folder->folder_id) && g_src_path)
 382         {
 383                 /* Set modified time */
 384                 time_t date;
 385                 time(&date);
 386                 _folder->modified_time = date;
 387
 388                 set_sql = __media_folder_get_update_folder_sql((media_folder_h)_folder);
 389                 if(set_sql == NULL)
 390                 {
 391                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 392                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 393                 }
 394
 395                 where_sql = sqlite3_mprintf("folder_uuid='%q'", _folder->folder_id);
 396
 397                 len = snprintf(sql, sizeof(sql), UPDATE_SQL, DB_TABLE_FOLDER, set_sql, where_sql);
 398                 if (len > 0) {
 399                         sql[len] = '\0';
 400                 } else {
 401                         media_content_error("snprintf failed");
 402                         return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 403                 }
 404
 405                 ret = _content_query_sql(sql);
 406
 407                 sqlite3_free(set_sql);
 408                 sqlite3_free(where_sql);
 409
 410                 /* Do folder rename operation using libmedia-service */
 411                 ret = media_svc_rename_folder(_content_get_db_handle(), g_src_path, _folder->path, tzplatform_getuid(TZ_USER_NAME));
 412                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 413         }
 414         else
 415         {
 416                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 417                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 418         }
 419
 420         return ret;
 421 }
 422
 423 int media_folder_set_name(media_folder_h folder, const char *name)
 424 {
 425         int ret = MEDIA_CONTENT_ERROR_NONE;
 426         media_folder_s *_folder = (media_folder_s*)folder;
 427
 428         if(_folder != NULL && STRING_VALID(name))
 429         {
 430                 if (STRING_VALID(_folder->path) && STRING_VALID(_folder->name)) {
 431                         char *folder_path = NULL;
 432                         char new_folder_path[MAX_QUERY_SIZE] = {0,};
 433
 434                         folder_path = g_path_get_dirname(_folder->path);
 435                         media_content_debug("Existed Folder Path : %s", _folder->path);
 436                         snprintf(new_folder_path, sizeof(new_folder_path), "%s/%s", folder_path, name);
 437                         media_content_debug("New Path : %s", new_folder_path);
 438
 439                         SAFE_FREE(g_src_path);
 440                         g_src_path = strdup(_folder->path);
 441
 442                         SAFE_FREE(_folder->path);
 443                         SAFE_FREE(_folder->name);
 444                         _folder->path = strdup(new_folder_path);
 445
 446                         if(_folder->path == NULL)
 447                         {
 448                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 449                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 450                         }
 451                 }
 452
 453                 _folder->name = strdup(name);
 454                 if(_folder->name == NULL)
 455                 {
 456                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 457                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 458                 }
 459         }
 460         else
 461         {
 462                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 463                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 464         }
 465
 466         return ret;
 467 }