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