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
  21 static char *g_src_path = NULL;
  22
  23 int media_folder_get_folder_count_from_db(filter_h filter, int *folder_count)
  24 {
  25         int ret = MEDIA_CONTENT_ERROR_NONE;
  26
  27         if(!folder_count)
  28         {
  29                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  30                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  31         }
  32
  33         ret = _media_db_get_group_count(filter, MEDIA_GROUP_FOLDER, folder_count);
  34
  35         return ret;
  36 }
  37
  38 int media_folder_foreach_folder_from_db(filter_h filter, media_folder_cb callback, void *user_data)
  39 {
  40         int ret = MEDIA_CONTENT_ERROR_NONE;
  41
  42         if(callback == NULL)
  43         {
  44                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  45                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  46         }
  47
  48         ret = _media_db_get_folder(filter, callback, user_data);
  49
  50         return ret;
  51 }
  52
  53 int media_folder_get_media_count_from_db(const char *folder_id, filter_h filter, int *media_count)
  54 {
  55         int ret = MEDIA_CONTENT_ERROR_NONE;
  56
  57         if(STRING_VALID(folder_id) && media_count)
  58         {
  59                 ret = _media_db_get_group_item_count(folder_id, filter, MEDIA_GROUP_FOLDER, media_count);
  60         }
  61         else
  62         {
  63                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  64                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  65         }
  66
  67         return ret;
  68 }
  69
  70 int media_folder_foreach_media_from_db(const char *folder_id, filter_h filter, media_info_cb callback, void *user_data)
  71 {
  72         int ret = MEDIA_CONTENT_ERROR_NONE;
  73
  74         if((callback != NULL) && STRING_VALID(folder_id))
  75         {
  76                 ret = _media_db_get_group_item(folder_id, filter, callback, user_data, MEDIA_GROUP_FOLDER);
  77         }
  78         else
  79         {
  80                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  81                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  82         }
  83
  84         return ret;
  85 }
  86
  87 int media_folder_destroy(media_folder_h folder)
  88 {
  89         int ret = MEDIA_CONTENT_ERROR_NONE;
  90         media_folder_s *_folder = (media_folder_s*)folder;
  91         if(_folder)
  92         {
  93                 SAFE_FREE(_folder->path);
  94                 SAFE_FREE(_folder->name);
  95                 SAFE_FREE(_folder->folder_id);
  96                 SAFE_FREE(_folder->parent_folder_id);
  97                 SAFE_FREE(_folder->storage_uuid);
  98                 SAFE_FREE(_folder);
  99                 ret = MEDIA_CONTENT_ERROR_NONE;
 100         }
 101         else
 102         {
 103                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 104                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 105         }
 106
 107         return ret;
 108 }
 109 int media_folder_clone(media_folder_h *dst, media_folder_h src)
 110 {
 111         int ret = MEDIA_CONTENT_ERROR_NONE;
 112         media_folder_s *_src = (media_folder_s*)src;
 113
 114         if(_src != NULL)
 115         {
 116                 media_folder_s *_dst = (media_folder_s*)calloc(1, sizeof(media_folder_s));
 117                 media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 118
 119                 if(STRING_VALID(_src->folder_id))
 120                 {
 121                         _dst->folder_id = strdup(_src->folder_id);
 122                         if(_dst->folder_id == NULL)
 123                         {
 124                                 SAFE_FREE(_dst);
 125                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 126                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 127                         }
 128                 }
 129
 130                 if(STRING_VALID(_src->parent_folder_id))
 131                 {
 132                         _dst->parent_folder_id = strdup(_src->parent_folder_id);
 133                         if(_dst->parent_folder_id == NULL)
 134                         {
 135                                 media_folder_destroy((media_folder_h)_dst);
 136                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 137                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 138                         }
 139                 }
 140
 141                 if(STRING_VALID(_src->name))
 142                 {
 143                         _dst->name = strdup(_src->name);
 144                         if(_dst->name == NULL)
 145                         {
 146                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 147                                 media_folder_destroy((media_folder_h)_dst);
 148                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 149                         }
 150                 }
 151
 152                 if(STRING_VALID(_src->path))
 153                 {
 154                         _dst->path = strdup(_src->path);
 155                         if(_dst->path == NULL)
 156                         {
 157                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 158                                 media_folder_destroy((media_folder_h)_dst);
 159                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 160                         }
 161                 }
 162
 163                 if(STRING_VALID(_src->storage_uuid))
 164                 {
 165                         _dst->storage_uuid = strdup(_src->storage_uuid);
 166                         if(_dst->storage_uuid == NULL)
 167                         {
 168                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 169                                 media_folder_destroy((media_folder_h)_dst);
 170                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 171                         }
 172                 }
 173
 174                 _dst->storage_type = _src->storage_type;
 175                 _dst->modified_time = _src->modified_time;
 176                 _dst->folder_order= _src->folder_order;
 177
 178                 *dst = (media_folder_h)_dst;
 179
 180                 ret = MEDIA_CONTENT_ERROR_NONE;
 181         }
 182         else
 183         {
 184                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 185                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 186         }
 187
 188         return ret;
 189 }
 190
 191 int media_folder_get_folder_id(media_folder_h folder, char **folder_id)
 192 {
 193         int ret = MEDIA_CONTENT_ERROR_NONE;
 194         media_folder_s *_folder = (media_folder_s*)folder;
 195
 196         if(_folder)
 197         {
 198                 if(STRING_VALID(_folder->folder_id))
 199                 {
 200                         *folder_id = strdup(_folder->folder_id);
 201                         media_content_retvm_if(*folder_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 202                 }
 203                 else
 204                 {
 205                         *folder_id = NULL;
 206                 }
 207                 ret = MEDIA_CONTENT_ERROR_NONE;
 208         }
 209         else
 210         {
 211                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 212                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 213         }
 214
 215         return ret;
 216 }
 217
 218 int media_folder_get_parent_folder_id(media_folder_h folder, char **parent_folder_id)
 219 {
 220         int ret = MEDIA_CONTENT_ERROR_NONE;
 221         media_folder_s *_folder = (media_folder_s*)folder;
 222
 223         if(_folder)
 224         {
 225                 if(STRING_VALID(_folder->parent_folder_id))
 226                 {
 227                         *parent_folder_id = strdup(_folder->parent_folder_id);
 228                         media_content_retvm_if(*parent_folder_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 229                 }
 230                 else
 231                 {
 232                         *parent_folder_id = NULL;
 233                 }
 234                 ret = MEDIA_CONTENT_ERROR_NONE;
 235         }
 236         else
 237         {
 238                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 239                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 240         }
 241
 242         return ret;
 243 }
 244
 245 int media_folder_get_path(media_folder_h folder, char **path)
 246 {
 247         int ret = MEDIA_CONTENT_ERROR_NONE;
 248         media_folder_s *_folder = (media_folder_s*)folder;
 249
 250         if(_folder)
 251         {
 252                 if(STRING_VALID(_folder->path))
 253                 {
 254                         *path = strdup(_folder->path);
 255                         media_content_retvm_if(*path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 256                 }
 257                 else
 258                 {
 259                         *path = NULL;
 260                 }
 261                 ret = MEDIA_CONTENT_ERROR_NONE;
 262
 263         }
 264         else
 265         {
 266                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 267                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 268         }
 269
 270         return ret;
 271
 272 }
 273
 274 int media_folder_get_name(media_folder_h folder, char **name)
 275 {
 276         int ret = MEDIA_CONTENT_ERROR_NONE;
 277         media_folder_s *_folder = (media_folder_s*)folder;
 278
 279         if(_folder)
 280         {
 281                 if(STRING_VALID(_folder->name))
 282                 {
 283                         *name = strdup(_folder->name);
 284                         media_content_retvm_if(*name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 285                 }
 286                 else
 287                 {
 288                         *name = NULL;
 289                 }
 290                 ret = MEDIA_CONTENT_ERROR_NONE;
 291
 292         }
 293         else
 294         {
 295                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 296                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 297         }
 298
 299         return ret;
 300 }
 301
 302 int media_folder_get_modified_time(media_folder_h folder, time_t* time)
 303 {
 304         int ret = MEDIA_CONTENT_ERROR_NONE;
 305         media_folder_s *_folder = (media_folder_s*)folder;
 306
 307         if(_folder)
 308         {
 309                 *time = _folder->modified_time;
 310                 ret = MEDIA_CONTENT_ERROR_NONE;
 311         }
 312         else
 313         {
 314                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 315                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 316         }
 317
 318         return ret;
 319 }
 320
 321 int media_folder_get_storage_type(media_folder_h folder, media_content_storage_e* storage_type)
 322 {
 323         int ret = MEDIA_CONTENT_ERROR_NONE;
 324         media_folder_s *_folder = (media_folder_s*)folder;
 325
 326         if(_folder)
 327         {
 328                 *storage_type = _folder->storage_type;
 329                 ret = MEDIA_CONTENT_ERROR_NONE;
 330         }
 331         else
 332         {
 333                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 334                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 335         }
 336
 337         return ret;
 338 }
 339
 340 int media_folder_get_storage_id(media_folder_h folder, char **storage_id)
 341 {
 342         int ret = MEDIA_CONTENT_ERROR_NONE;
 343         media_folder_s *_folder = (media_folder_s*)folder;
 344
 345         if(_folder)
 346         {
 347                 if(STRING_VALID(_folder->storage_uuid))
 348                 {
 349                         *storage_id = strdup(_folder->storage_uuid);
 350                         media_content_retvm_if(*storage_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 351                 }
 352                 else
 353                 {
 354                         *storage_id = NULL;
 355                 }
 356                 ret = MEDIA_CONTENT_ERROR_NONE;
 357
 358         }
 359         else
 360         {
 361                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 362                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 363         }
 364
 365         return ret;
 366 }
 367
 368 int media_folder_get_order(media_folder_h folder, int *order)
 369 {
 370         int ret = MEDIA_CONTENT_ERROR_NONE;
 371         media_folder_s *_folder = (media_folder_s*)folder;
 372
 373         if(_folder)
 374         {
 375                 *order = _folder->folder_order;
 376                 ret = MEDIA_CONTENT_ERROR_NONE;
 377         }
 378         else
 379         {
 380                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 381                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 382         }
 383
 384         return ret;
 385 }
 386
 387
 388 int media_folder_get_folder_from_db(const char *folder_id, media_folder_h *folder)
 389 {
 390         int ret = MEDIA_CONTENT_ERROR_NONE;
 391         sqlite3_stmt *stmt = NULL;
 392         char select_query[DEFAULT_QUERY_SIZE];
 393
 394         if(!STRING_VALID(folder_id))
 395         {
 396                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 397                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 398         }
 399
 400         memset(select_query, 0x00, sizeof(select_query));
 401
 402         snprintf(select_query, sizeof(select_query), SELECT_FOLDER_FROM_FOLDER, folder_id);
 403
 404         ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
 405         media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 406
 407         media_folder_s *_folder = NULL;
 408
 409         while(sqlite3_step(stmt) == SQLITE_ROW)
 410         {
 411                 if(_folder)
 412                         media_folder_destroy((media_folder_h)_folder);
 413
 414                 _folder = (media_folder_s*)calloc(1, sizeof(media_folder_s));
 415                 if(_folder == NULL)
 416                 {
 417                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 418                         SQLITE3_FINALIZE(stmt);
 419                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 420                 }
 421
 422                 media_content_error("folder handle %x", _folder);
 423
 424                 _folder->folder_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
 425                 _folder->path = g_strdup((const char *)sqlite3_column_text(stmt, 1));
 426                 _folder->name = g_strdup((const char *)sqlite3_column_text(stmt, 2));
 427
 428                 *folder = (media_folder_h)_folder;
 429         }
 430
 431         SQLITE3_FINALIZE(stmt);
 432
 433         return ret;
 434 }
 435
 436 int media_folder_update_to_db(media_folder_h folder)
 437 {
 438         int ret = MEDIA_CONTENT_ERROR_NONE;
 439         media_folder_s *_folder = (media_folder_s*)folder;
 440         char *sql = NULL;
 441
 442         if((_folder == NULL) || (_folder->folder_id == NULL))
 443         {
 444                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 445                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 446         }
 447
 448         /* Update folder order */
 449         sql = sqlite3_mprintf(UPDATE_FOLDER_ORDER, _folder->folder_order, _folder->folder_id);
 450
 451         ret = _content_query_sql(sql);
 452         SQLITE3_SAFE_FREE(sql);
 453
 454         if(STRING_VALID(_folder->folder_id) && g_src_path)
 455         {
 456                 char *name_pinyin = NULL;
 457                 bool pinyin_support = FALSE;
 458
 459                 /* Set modified time */
 460                 time_t date;
 461                 time(&date);
 462                 _folder->modified_time = date;
 463
 464                 /*Update Pinyin If Support Pinyin*/
 465                 media_svc_check_pinyin_support(&pinyin_support);
 466                 if(pinyin_support)
 467                         media_svc_get_pinyin(_content_get_db_handle(), _folder->name, &name_pinyin);
 468
 469                 sql = sqlite3_mprintf("UPDATE %Q SET path='%q', name='%q', modified_time=%d, name_pinyin='%q' WHERE folder_uuid=%Q",
 470                                                 DB_TABLE_FOLDER,  _folder->path, _folder->name, _folder->modified_time, name_pinyin, _folder->folder_id);
 471
 472                 ret = _content_query_sql(sql);
 473                 SQLITE3_SAFE_FREE(sql);
 474                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
 475                         SAFE_FREE(g_src_path);
 476                         return ret;
 477                 }
 478
 479                 /* Update all folder record's path, which are matched by old parent path */
 480                 char *update_folder_path_sql = NULL;
 481                 char src_path_slash[MAX_QUERY_SIZE + 1] = {0, };
 482                 char dst_path_slash[MAX_QUERY_SIZE + 1] = {0, };
 483
 484                 snprintf(src_path_slash, sizeof(src_path_slash), "%s/", g_src_path);
 485                 snprintf(dst_path_slash, sizeof(dst_path_slash), "%s/", _folder->path);
 486
 487                 update_folder_path_sql = sqlite3_mprintf("UPDATE folder SET path = REPLACE( path, '%q', '%q');", src_path_slash, dst_path_slash);
 488
 489                 ret = _content_query_sql(update_folder_path_sql);
 490                 SQLITE3_SAFE_FREE(update_folder_path_sql);
 491                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
 492                         SAFE_FREE(g_src_path);
 493                         return ret;
 494                 }
 495
 496                 ret = media_svc_rename_folder(_content_get_db_handle(), _folder->storage_uuid, g_src_path, _folder->path, tzplatform_getuid(TZ_USER_NAME));
 497                 SAFE_FREE(g_src_path);
 498
 499                 return _content_error_capi(MEDIA_CONTENT_TYPE, ret);
 500         }
 501
 502         return ret;
 503 }
 504
 505 int media_folder_set_name(media_folder_h folder, const char *name)
 506 {
 507         int ret = MEDIA_CONTENT_ERROR_NONE;
 508         media_folder_s *_folder = (media_folder_s*)folder;
 509
 510         if(_folder != NULL && STRING_VALID(name))
 511         {
 512                 if (STRING_VALID(_folder->path) && STRING_VALID(_folder->name)) {
 513                         char *folder_path = NULL;
 514                         char new_folder_path[MAX_QUERY_SIZE] = {0,};
 515                         bool ignore_dir = FALSE;
 516
 517                         folder_path = g_path_get_dirname(_folder->path);
 518                         media_content_sec_debug("Existed Folder Path : %s", _folder->path);
 519                         snprintf(new_folder_path, sizeof(new_folder_path), "%s/%s", folder_path, name);
 520                         media_content_sec_debug("New Path : %s", new_folder_path);
 521
 522                         ret = _media_util_check_ignore_dir(new_folder_path, &ignore_dir);
 523                         if (ignore_dir == TRUE) {
 524                                 media_content_error("Invalid folder path");
 525                                 SAFE_FREE(folder_path);
 526                                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 527                         }
 528
 529                         SAFE_FREE(g_src_path);
 530                         g_src_path = strdup(_folder->path);
 531
 532                         SAFE_FREE(_folder->path);
 533                         SAFE_FREE(_folder->name);
 534                         SAFE_FREE(folder_path);
 535                         _folder->path = strdup(new_folder_path);
 536                         media_content_retvm_if(_folder->path == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 537                 }
 538
 539                 _folder->name = strdup(name);
 540                 media_content_retvm_if(_folder->name == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 541         }
 542         else
 543         {
 544                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 545                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 546         }
 547
 548         return ret;
 549 }
 550
 551 int media_folder_set_order(media_folder_h folder, int order)
 552 {
 553         int ret = MEDIA_CONTENT_ERROR_NONE;
 554         media_folder_s *_folder = (media_folder_s*)folder;
 555
 556         if(_folder != NULL && order >= 0)
 557         {
 558                 _folder->folder_order = order;
 559         }
 560         else
 561         {
 562                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 563                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 564         }
 565
 566         return ret;
 567 }