src/visual/media-svc-api.c

   1 /*
   2  * libmedia-service
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21 #include <glib.h>
  22 #include <glib-object.h>
  23 #include <drm-service.h>
  24 #include <dirent.h>
  25 #include <sys/types.h>
  26 #include <string.h>
  27 #include <media-thumbnail.h>
  28 #include "media-svc-debug.h"
  29 #include "media-svc-api.h"
  30 #include "media-svc-thumb.h"
  31 #include "media-svc-db-util.h"
  32 #include "visual-svc-debug.h"
  33 #include "visual-svc-util.h"
  34 #include "media-svc-db.h"
  35 #include "media-svc-util.h"
  36 #include "media-svc-types.h"
  37 #include "visual-svc-error.h"
  38
  39 #ifdef _PERFORMANCE_CHECK_
  40 double g_insertdb = 0;
  41 double g_thumb = 0;
  42 double g_meta = 0;
  43 long start = 0L, end = 0L;
  44 #endif
  45
  46 static __thread GList *g_insert_sql_list = NULL;
  47 static __thread GList *g_move_sql_list = NULL;
  48
  49 const char *mb_svc_media_order[5] = {
  50         "visual_uuid ASC",
  51         "display_name COLLATE NOCASE DESC",
  52         "display_name COLLATE NOCASE ASC",
  53         "modified_date DESC",
  54         "modified_date ASC",
  55 };
  56
  57 const char *mb_svc_folder_order[5] = {
  58         "folder_uuid ASC",
  59         "folder_name COLLATE NOCASE DESC",
  60         "folder_name COLLATE NOCASE ASC",
  61         "modified_date DESC",
  62         "modified_date ASC",
  63 };
  64
  65 typedef struct {
  66         DIR* dp;
  67         struct dirent* entry;
  68         char dir_full_path[MB_SVC_DIR_PATH_LEN_MAX+1];
  69 } mb_svc_sync_param_s;
  70
  71 #define MB_SVC_DB_DEFAULT_GET_ALL_RECORDS -1    /* get all records, not limit on start position */
  72 #define MB_SVC_DB_GET_UNTIL_LAST_RECORD -1      /* get all records until last item */
  73
  74 static int __mb_svc_folder_by_path_iter_start(MediaSvcHandle *mb_svc_handle, char *parent_path, mb_svc_iterator_s *mb_svc_iterator);
  75 static int __mb_svc_get_folder_record_by_path_info(MediaSvcHandle *mb_svc_handle, const char *uri, char *display_name, minfo_store_type storage_type, mb_svc_folder_record_s *record);
  76 static int __mb_svc_get_folder_record_by_full_path(MediaSvcHandle *mb_svc_handle, const char *folder_full_path, mb_svc_folder_record_s *folder_record);
  77 static int __mb_svc_get_media_id_by_fid_name(MediaSvcHandle *mb_svc_handle, const char *folder_id, char *display_name, char *media_id);
  78 static int __mb_svc_get_media_list_by_folder_id(MediaSvcHandle *mb_svc_handle, const char *folder_id, GList **p_record_list, int valid);
  79 static int __mb_svc_delete_media_records_list(MediaSvcHandle *mb_svc_handle, GList *p_record_list);
  80 static int __mb_svc_delete_tag_by_id(MediaSvcHandle *mb_svc_handle, const int tag_id);
  81 static int __mb_svc_update_tag(MediaSvcHandle *mb_svc_handle, int tag_id, const char *tag_name);
  82 static int __mb_svc_update_tagmap(MediaSvcHandle *mb_svc_handle, int src_tag_id, int dst_tag_id);
  83 static int __mb_svc_update_tagmap_by_media_id(MediaSvcHandle *mb_svc_handle, const char *media_id, int src_tag_id, int dst_tag_id);
  84 static int __mb_svc_get_media_cnt_by_tagid(MediaSvcHandle *mb_svc_handle, int tag_id);
  85
  86 int mb_svc_insert_items(MediaSvcHandle *mb_svc_handle)
  87 {
  88         mb_svc_debug("");
  89         int i = 0;
  90         int length = g_list_length(g_insert_sql_list);
  91
  92         for (i = 0; i < length; i++) {
  93                 char *sql = (char*)g_list_nth_data(g_insert_sql_list, i);
  94                 mb_svc_query_sql(mb_svc_handle, sql);
  95         }
  96
  97         mb_svc_sql_list_release(&g_insert_sql_list);
  98
  99         return 0;
 100 }
 101
 102 int mb_svc_move_items(MediaSvcHandle *mb_svc_handle)
 103 {
 104         mb_svc_debug("");
 105         int i = 0;
 106         int length = g_list_length(g_move_sql_list);
 107
 108         for (i = 0; i < length; i++) {
 109                 char *sql = (char*)g_list_nth_data(g_move_sql_list, i);
 110                 mb_svc_query_sql(mb_svc_handle, sql);
 111         }
 112
 113         mb_svc_sql_list_release(&g_move_sql_list);
 114
 115         return 0;
 116 }
 117
 118 int
 119 mb_svc_insert_file_batch(MediaSvcHandle *mb_svc_handle, const char *file_full_path, minfo_file_type content_type)
 120 {
 121         char dir_path[MB_SVC_DIR_PATH_LEN_MAX + 1] = { 0 };
 122         char dir_display_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
 123         char file_display_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
 124         mb_svc_folder_record_s folder_record = {"",};
 125         mb_svc_media_record_s media_record = {"",};
 126         mb_svc_image_meta_record_s image_record = {0,};
 127         mb_svc_video_meta_record_s video_record = {0,};
 128         int folder_modified_date = 0;
 129         int ret = 0;
 130         int store_type = 0;
 131         bool is_drm = false;
 132
 133         char *folder_sql = NULL;
 134         char *insert_sql = NULL;
 135         char *meta_sql = NULL;
 136
 137         if (file_full_path == NULL ) {
 138                 mb_svc_debug("file_full_path == NULL || thumb_path == NULL\n");
 139                 return MB_SVC_ERROR_INVALID_PARAMETER;
 140         }
 141
 142         mb_svc_debug("file_full_path is %s\n", file_full_path);
 143         /* 1. get file detail */
 144         _mb_svc_get_file_parent_path(file_full_path, dir_path);
 145         mb_svc_debug("dir_path is %s\n", dir_path);
 146
 147         folder_modified_date = _mb_svc_get_file_dir_modified_date(dir_path);
 148         mb_svc_debug("folder_modified_date is %d\n", folder_modified_date);
 149
 150         /* 2. insert or update folder table */
 151         ret = __mb_svc_get_folder_record_by_full_path(mb_svc_handle, dir_path, &folder_record);
 152         if (ret < 0) {
 153                 mb_svc_debug("no any record in %s", dir_path);
 154                 store_type = _mb_svc_get_store_type_by_full(file_full_path);
 155
 156                 if (store_type == MB_SVC_ERROR_INTERNAL) {
 157                         mb_svc_debug("Failed to get storage type : %s",
 158                                      file_full_path);
 159                         return MB_SVC_ERROR_INVALID_PARAMETER;
 160                 }
 161                 mb_svc_debug("store_type is %d\n", store_type);
 162
 163                 _mb_svc_get_dir_display_name(dir_path, dir_display_name);
 164                 mb_svc_debug("dir_display_name is %s\n", dir_display_name);
 165
 166                 folder_record.modified_date = folder_modified_date;
 167                 folder_record.storage_type = store_type;
 168                 strncpy(folder_record.uri, dir_path, MB_SVC_DIR_PATH_LEN_MAX + 1);
 169                 strncpy(folder_record.display_name, dir_display_name,
 170                         MB_SVC_FILE_NAME_LEN_MAX + 1);
 171                 strncpy(folder_record.web_account_id, "", MB_SVC_ARRAY_LEN_MAX + 1);
 172                 strncpy(folder_record.web_album_id, "", MB_SVC_ARRAY_LEN_MAX + 1);
 173                 folder_record.lock_status = 0;
 174
 175                 mb_svc_debug
 176                     ("no record in %s, ready insert the folder record into db\n",
 177                      dir_path);
 178
 179                 ret = mb_svc_insert_record_folder(mb_svc_handle, &folder_record);
 180                 if (ret < 0) {
 181                         mb_svc_debug
 182                                 ("mb_svc_insert_record_folder failed (%d)\n", ret);
 183                         return ret;
 184                 }
 185         } else {
 186                 /* there is already matched folder record in folder table, update it if the file is modified */
 187                 mb_svc_debug
 188                     ("folder_record info: uuid is %s,uri is %s,display_name is %s,modified_date is %d,web_account_id is %s,store_type is %d\n",
 189                      folder_record.uuid, folder_record.uri,
 190                      folder_record.display_name, folder_record.modified_date,
 191                      folder_record.web_account_id, folder_record.storage_type);
 192                 mb_svc_debug
 193                     ("existing file date in folder record is %d, new file date is %d",
 194                      folder_record.modified_date, folder_modified_date);
 195
 196                 store_type = folder_record.storage_type;
 197                 if (folder_record.modified_date < folder_modified_date) { /* the file is updated */
 198                         mb_svc_debug("directory %s is modified", dir_path);
 199                         folder_record.modified_date = folder_modified_date;
 200                         ret = mb_svc_update_record_folder_sql(&folder_record, &folder_sql);
 201                         if (ret < 0) {
 202                                 mb_svc_debug
 203                                     ("mb_svc_update_record_folder_sql fails(%d)",
 204                                      ret);
 205                         }
 206
 207                         mb_svc_sql_list_add(&g_insert_sql_list, &folder_sql);
 208                 }
 209         }
 210
 211         /* 3. insert media table, before insert a record, check whether the same record has existed.     */
 212         mb_svc_debug("ready insert file info into media table\n");
 213         mb_svc_debug("file_full_path is %s\n", file_full_path);
 214
 215         strncpy(media_record.path, file_full_path, sizeof(media_record.path));
 216         _mb_svc_get_file_display_name(file_full_path, file_display_name);
 217         mb_svc_debug("file_display_name is %s\n", file_display_name);
 218         strncpy(media_record.display_name, file_display_name,
 219                 MB_SVC_FILE_NAME_LEN_MAX + 1);
 220
 221         media_record.content_type = content_type;
 222         media_record.rate = 0;
 223         mb_svc_debug
 224             ("ready get file date for insert file info into media table\n");
 225         media_record.modified_date =
 226             _mb_svc_get_file_dir_modified_date(file_full_path);
 227         is_drm = (drm_svc_is_drm_file(file_full_path) == DRM_TRUE);
 228
 229         ret = _mb_svc_thumb_generate_hash_name(file_full_path,
 230                                                                                 media_record.thumbnail_path,
 231                                                                                 MB_SVC_FILE_PATH_LEN_MAX + 1);
 232
 233         if (ret < 0) {
 234                 mb_svc_debug("_mb_svc_thumb_generate_hash_name failed : %d", ret);
 235                 return ret;
 236         }
 237
 238         /* 4. if it's image file, insert into image_meta table */
 239         if (media_record.content_type == MINFO_ITEM_IMAGE)      { /* it's image file, insert into image_meta table */
 240                 mb_svc_debug
 241                     ("ready insert file info into media table,file date is %d\n",
 242                      media_record.modified_date);
 243
 244                 bool thumb_done = FALSE;
 245                 ret = mb_svc_get_image_meta(mb_svc_handle, file_full_path, &image_record, &thumb_done);
 246
 247                 if (ret < 0) {
 248                         mb_svc_debug("mb_svc_get_image_meta failed\n");
 249                         return ret;
 250                 }
 251
 252                 strncpy(media_record.folder_uuid, folder_record.uuid, MB_SVC_UUID_LEN_MAX + 1);
 253
 254                 ret = mb_svc_insert_record_media_sql(&media_record, store_type, &insert_sql);
 255
 256                 if (ret < 0) {
 257                         mb_svc_debug("mb_svc_insert_record_media_sql fails(%d)",
 258                                      ret);
 259                         return ret;
 260                 }
 261
 262                 mb_svc_sql_list_add(&g_insert_sql_list, &insert_sql);
 263
 264                 strncpy(image_record.media_uuid, media_record.media_uuid, MB_SVC_UUID_LEN_MAX + 1);
 265
 266                 ret =
 267                     mb_svc_insert_record_image_meta_sql(&image_record, store_type, &meta_sql);
 268
 269                 if (ret < 0) {
 270                         mb_svc_debug("mb_svc_insert_record_image_meta_sql failed(%d)\n", ret);
 271                         return ret;
 272                 }
 273
 274                 mb_svc_sql_list_add(&g_insert_sql_list, &meta_sql);
 275         }
 276         /* 5       if video, insert video_meta and bookmark table */
 277         else if (media_record.content_type == MINFO_ITEM_VIDEO) {       /* it's video file, insert into vidoe table */
 278                 mb_svc_debug
 279                     ("ready insert file info into media table,file date is %d\n",
 280                      media_record.modified_date);
 281
 282                 video_record.last_played_time = 0;
 283                 video_record.latitude = 0.0;
 284                 video_record.longitude = 0.0;
 285
 286                 ret = mb_svc_get_video_meta(mb_svc_handle, file_full_path, &video_record);
 287                 if (ret < 0) {
 288                         mb_svc_debug("mb_svc_get_video_meta failed\n");
 289                         return ret;
 290                 }
 291
 292                 strncpy(media_record.folder_uuid, folder_record.uuid, MB_SVC_UUID_LEN_MAX + 1);
 293
 294                 ret = mb_svc_insert_record_media_sql(&media_record, store_type, &insert_sql);
 295                 if (ret < 0) {
 296                         mb_svc_debug("mb_svc_insert_record_media_sql fails(%d)",
 297                                      ret);
 298                         return ret;
 299                 }
 300                 mb_svc_sql_list_add(&g_insert_sql_list, &insert_sql);
 301
 302                 strncpy(video_record.media_uuid, media_record.media_uuid, MB_SVC_UUID_LEN_MAX + 1);
 303
 304                 ret =
 305                     mb_svc_insert_record_video_meta_sql(&video_record, store_type, &meta_sql);
 306                 if (ret < 0) {
 307                         mb_svc_debug
 308                             ("mb_svc_insert_record_video_meta_sql failed(%d)\n", ret);
 309                         return ret;
 310                 }
 311                 mb_svc_sql_list_add(&g_insert_sql_list, &meta_sql);
 312         }
 313
 314         /* Extracting thumbnail */
 315         ret = thumbnail_request_from_db(file_full_path, media_record.thumbnail_path, sizeof(media_record.thumbnail_path));
 316         if (ret < 0) {
 317                 mb_svc_debug("thumbnail_request_from_db failed: %d", ret);
 318         } else {
 319                 mb_svc_debug("thumbnail_request_from_db success: %s", media_record.thumbnail_path);
 320         }
 321
 322         return 0;
 323 }
 324
 325 int
 326 mb_svc_insert_file(MediaSvcHandle *mb_svc_handle, const char *file_full_path, minfo_file_type content_type)
 327 {
 328         char dir_path[MB_SVC_DIR_PATH_LEN_MAX + 1] = { 0 };
 329         char thumb_path[MB_SVC_DIR_PATH_LEN_MAX + 1] = { 0 };
 330         char dir_display_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
 331         char file_display_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
 332         mb_svc_folder_record_s folder_record = {"",};
 333         mb_svc_media_record_s media_record = {"",};
 334         mb_svc_image_meta_record_s image_record = {0,};
 335         mb_svc_video_meta_record_s video_record = {0,};
 336         int folder_modified_date = 0;
 337         int ret = 0;
 338         int store_type = 0;
 339         bool is_drm = false;
 340         GList *insert_sql_list = NULL;
 341         char *folder_sql = NULL;
 342         char *insert_sql = NULL;
 343         char *meta_sql = NULL;
 344         int insert_new_folder = 0;
 345
 346         if (file_full_path == NULL ) {
 347                 mb_svc_debug("file_full_path == NULL || thumb_path == NULL\n");
 348                 return MB_SVC_ERROR_INVALID_PARAMETER;
 349         }
 350
 351         mb_svc_debug("file_full_path is %s\n", file_full_path);
 352         /* 1. get file detail */
 353         _mb_svc_get_file_parent_path(file_full_path, dir_path);
 354         mb_svc_debug("dir_path is %s\n", dir_path);
 355
 356         folder_modified_date = _mb_svc_get_file_dir_modified_date(dir_path);
 357         mb_svc_debug("folder_modified_date is %d\n", folder_modified_date);
 358
 359         /* 2. insert or update folder table */
 360         ret = __mb_svc_get_folder_record_by_full_path(mb_svc_handle, dir_path, &folder_record);
 361         if (ret < 0) {
 362                 mb_svc_debug("no any record in %s", dir_path);
 363                 store_type = _mb_svc_get_store_type_by_full(file_full_path);
 364
 365                 if (store_type == MB_SVC_ERROR_INTERNAL) {
 366                         mb_svc_debug("Failed to get storage type : %s",
 367                                      file_full_path);
 368                         return MB_SVC_ERROR_INVALID_PARAMETER;
 369                 }
 370                 mb_svc_debug("store_type is %d\n", store_type);
 371
 372                 _mb_svc_get_dir_display_name(dir_path, dir_display_name);
 373                 mb_svc_debug("dir_display_name is %s\n", dir_display_name);
 374
 375                 folder_record.modified_date = folder_modified_date;
 376                 folder_record.storage_type = store_type;
 377                 strncpy(folder_record.uri, dir_path, MB_SVC_DIR_PATH_LEN_MAX + 1);
 378                 strncpy(folder_record.display_name, dir_display_name,
 379                         MB_SVC_FILE_NAME_LEN_MAX + 1);
 380                 strncpy(folder_record.web_account_id, "", MB_SVC_ARRAY_LEN_MAX + 1);
 381                 strncpy(folder_record.web_album_id, "", MB_SVC_ARRAY_LEN_MAX + 1);
 382                 folder_record.lock_status = 0;
 383
 384                 mb_svc_debug
 385                     ("no record in %s, ready insert the folder record into db\n",
 386                      dir_path);
 387
 388                 insert_new_folder = 1;
 389         } else {
 390                 /* there is already matched folder record in folder table, update it if the file is modified */
 391                 mb_svc_debug
 392                     ("folder_record info: uuid is %s,uri is %s,display_name is %s,modified_date is %d,web_account_id is %s,store_type is %d\n",
 393                      folder_record.uuid, folder_record.uri,
 394                      folder_record.display_name, folder_record.modified_date,
 395                      folder_record.web_account_id, folder_record.storage_type);
 396                 mb_svc_debug
 397                     ("existing file date in folder record is %d, new file date is %d",
 398                      folder_record.modified_date, folder_modified_date);
 399
 400                 store_type = folder_record.storage_type;
 401                 if (folder_record.modified_date < folder_modified_date) { /* the file is updated */
 402                         mb_svc_debug("directory %s is modified", dir_path);
 403                         folder_record.modified_date = folder_modified_date;
 404                         ret = mb_svc_update_record_folder_sql(&folder_record, &folder_sql);
 405                         if (ret < 0) {
 406                                 mb_svc_debug
 407                                     ("mb_svc_update_record_folder_sql fails(%d)",
 408                                      ret);
 409                         }
 410
 411                         mb_svc_sql_list_add(&insert_sql_list, &folder_sql);
 412                 }
 413         }
 414
 415         /* 3. insert media table, before insert a record, check whether the same record has existed.     */
 416         mb_svc_debug("ready insert file info into media table\n");
 417         mb_svc_debug("file_full_path is %s\n", file_full_path);
 418
 419         strncpy(media_record.path, file_full_path, sizeof(media_record.path));
 420         _mb_svc_get_file_display_name(file_full_path, file_display_name);
 421         mb_svc_debug("file_display_name is %s\n", file_display_name);
 422         strncpy(media_record.display_name, file_display_name,
 423                 MB_SVC_FILE_NAME_LEN_MAX + 1);
 424
 425         media_record.content_type = content_type;
 426         media_record.rate = 0;
 427         mb_svc_debug
 428             ("ready get file date for insert file info into media table\n");
 429         media_record.modified_date =
 430             _mb_svc_get_file_dir_modified_date(file_full_path);
 431         is_drm = (drm_svc_is_drm_file(file_full_path) == DRM_TRUE);
 432
 433         /* 4. if it's image file, insert into image_meta table */
 434         if (media_record.content_type == MINFO_ITEM_IMAGE)      { /* it's image file, insert into image_meta table */
 435                 mb_svc_debug
 436                     ("ready insert file info into media table,file date is %d\n",
 437                      media_record.modified_date);
 438
 439 #ifdef _PERFORMANCE_CHECK_
 440                 start = mediainfo_get_debug_time();
 441 #endif
 442
 443                 bool thumb_done = FALSE;
 444                 ret = mb_svc_get_image_meta(mb_svc_handle, file_full_path, &image_record, &thumb_done);
 445
 446 #ifdef _PERFORMANCE_CHECK_
 447                 end = mediainfo_get_debug_time();
 448
 449                 g_meta += ((double)(end - start) / (double)CLOCKS_PER_SEC);
 450                 mb_svc_debug("Meta : %f", g_meta);
 451 #endif
 452
 453                 if (ret < 0) {
 454                         mb_svc_debug("mb_svc_get_image_meta failed\n");
 455                         mb_svc_sql_list_release(&insert_sql_list);
 456                         return ret;
 457                 }
 458
 459                 ret = mb_svc_sqlite3_begin_trans(mb_svc_handle);
 460                 if (ret < 0) {
 461                         mb_svc_debug("mb_svc_sqlite3_begin_trans failed\n");
 462                         mb_svc_sql_list_release(&insert_sql_list);
 463                         return ret;
 464                 }
 465
 466                 if (insert_new_folder == 1) {
 467
 468                         ret = mb_svc_insert_record_folder_sql(&folder_record, &folder_sql);
 469                         if (ret < 0) {
 470                                 mb_svc_debug
 471                                         ("mb_svc_insert_record_folder_sql failed (%d)\n", ret);
 472                                 return ret;
 473                         }
 474
 475                         mb_svc_sql_list_add(&insert_sql_list, &folder_sql);
 476                 }
 477
 478                 strncpy(media_record.folder_uuid, folder_record.uuid, MB_SVC_UUID_LEN_MAX + 1);
 479
 480                 ret = mb_svc_insert_record_media_sql(&media_record, store_type, &insert_sql);
 481
 482                 if (ret < 0) {
 483                         mb_svc_debug("mb_svc_insert_record_media_sql fails(%d)",
 484                                      ret);
 485                         mb_svc_sql_list_release(&insert_sql_list);
 486                         return ret;
 487                 }
 488
 489                 mb_svc_sql_list_add(&insert_sql_list, &insert_sql);
 490
 491                 strncpy(image_record.media_uuid, media_record.media_uuid, MB_SVC_UUID_LEN_MAX + 1);
 492
 493                 ret =
 494                     mb_svc_insert_record_image_meta_sql(&image_record, store_type, &meta_sql);
 495
 496                 if (ret < 0) {
 497                         mb_svc_debug("mb_svc_insert_record_image_meta_sql failed(%d)\n", ret);
 498                         mb_svc_sql_list_release(&insert_sql_list);
 499                         return ret;
 500                 }
 501
 502                 mb_svc_sql_list_add(&insert_sql_list, &meta_sql);
 503         }
 504
 505         /* 5       if video, insert video_meta and bookmark table */
 506         else if (media_record.content_type == MINFO_ITEM_VIDEO) {       /* it's video file, insert into vidoe table */
 507
 508                 mb_svc_debug
 509                     ("ready insert file info into media table,file date is %d\n",
 510                      media_record.modified_date);
 511
 512                 video_record.last_played_time = 0;
 513                 video_record.latitude = 0.0;
 514                 video_record.longitude = 0.0;
 515
 516                 ret = mb_svc_get_video_meta(mb_svc_handle, file_full_path, &video_record);
 517                 if (ret < 0) {
 518                         mb_svc_debug("mb_svc_get_video_meta failed\n");
 519                         mb_svc_sql_list_release(&insert_sql_list);
 520                         return ret;
 521                 }
 522
 523                 ret = mb_svc_sqlite3_begin_trans(mb_svc_handle);
 524                 if (ret < 0) {
 525                         mb_svc_debug("mb_svc_sqlite3_begin_trans failed\n");
 526                         mb_svc_sql_list_release(&insert_sql_list);
 527                         return ret;
 528                 }
 529
 530                 if (insert_new_folder == 1) {
 531
 532                         ret = mb_svc_insert_record_folder_sql(&folder_record, &folder_sql);
 533                         if (ret < 0) {
 534                                 mb_svc_debug
 535                                         ("mb_svc_insert_record_folder_sql failed (%d)\n", ret);
 536                                 return ret;
 537                         }
 538
 539                         mb_svc_sql_list_add(&insert_sql_list, &folder_sql);
 540                 }
 541
 542                 strncpy(media_record.folder_uuid, folder_record.uuid, MB_SVC_UUID_LEN_MAX + 1);
 543
 544                 ret = mb_svc_insert_record_media_sql(&media_record, store_type, &insert_sql);
 545                 if (ret < 0) {
 546                         mb_svc_debug("mb_svc_insert_record_media_sql fails(%d)",
 547                                      ret);
 548                         mb_svc_sql_list_release(&insert_sql_list);
 549                         return ret;
 550                 }
 551                 mb_svc_sql_list_add(&insert_sql_list, &insert_sql);
 552
 553                 strncpy(video_record.media_uuid, media_record.media_uuid, MB_SVC_UUID_LEN_MAX + 1);
 554
 555                 ret =
 556                     mb_svc_insert_record_video_meta_sql(&video_record, store_type, &meta_sql);
 557                 if (ret < 0) {
 558                         mb_svc_debug
 559                             ("mb_svc_insert_record_video_meta_sql failed(%d)\n", ret);
 560                         mb_svc_sql_list_release(&insert_sql_list);
 561                         return ret;
 562                 }
 563                 mb_svc_sql_list_add(&insert_sql_list, &meta_sql);
 564         }
 565
 566         /* Start transaction */
 567         int i = 0;
 568         int length = g_list_length(insert_sql_list);
 569
 570 #ifdef _PERFORMANCE_CHECK_
 571         start = mediainfo_get_debug_time();
 572 #endif
 573
 574         for (i = 0; i < length; i++) {
 575                 char *sql = (char *)g_list_nth_data(insert_sql_list, i);
 576                 ret = mb_svc_query_sql(mb_svc_handle, sql);
 577
 578                 if (ret < 0) {
 579                         mb_svc_debug
 580                                 ("mb_svc_query_sql failed.. Now start to rollback\n");
 581                         mb_svc_sqlite3_rollback_trans(mb_svc_handle);
 582                         mb_svc_sql_list_release(&insert_sql_list);
 583                         return ret;
 584                 }
 585         }
 586
 587         ret = mb_svc_sqlite3_commit_trans(mb_svc_handle);
 588         if (ret < 0) {
 589                 mb_svc_debug
 590                         ("mb_svc_sqlite3_commit_trans failed.. Now start to rollback\n");
 591                 mb_svc_sqlite3_rollback_trans(mb_svc_handle);
 592                 mb_svc_sql_list_release(&insert_sql_list);
 593                 return ret;
 594         }
 595
 596         /* Extracting thumbnail */
 597         ret = thumbnail_request_from_db(file_full_path, thumb_path, sizeof(thumb_path));
 598         if (ret < 0) {
 599                 mb_svc_debug("thumbnail_request_from_db failed: %d", ret);
 600         } else {
 601                 mb_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
 602         }
 603
 604 #ifdef _PERFORMANCE_CHECK_
 605         end = mediainfo_get_debug_time();
 606
 607         g_insertdb += ((double)(end - start) / (double)CLOCKS_PER_SEC);
 608         mb_svc_debug("Insert : %f", g_insertdb);
 609         mb_svc_debug
 610         ("========== End of Performance check of one item ==============\n\n");
 611 #endif
 612
 613         /* Release sql list */
 614         mb_svc_sql_list_release(&insert_sql_list);
 615
 616         return 0;
 617 }
 618
 619
 620 int mb_svc_delete_file(MediaSvcHandle *mb_svc_handle, const char *file_full_path)
 621 {
 622         char dir_full_path[MB_SVC_DIR_PATH_LEN_MAX + 1] = { 0 };
 623         char file_display_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
 624         mb_svc_folder_record_s folder_record = {"",};
 625         mb_svc_media_record_s media_record = {"",};
 626         int ret = -1;
 627         int media_id = -1;
 628         int media_record_cnt = 0;
 629         int folder_modified_date = 0;
 630
 631         if (file_full_path == NULL) {
 632                 mb_svc_debug("file_full_path == NULL \n");
 633                 return MB_SVC_ERROR_INVALID_PARAMETER;
 634         }
 635
 636         mb_svc_debug("Delete start : %s", file_full_path);
 637
 638         _mb_svc_get_file_parent_path(file_full_path, dir_full_path);
 639         ret = __mb_svc_get_folder_record_by_full_path(mb_svc_handle, dir_full_path, &folder_record);
 640         if (ret < 0) {
 641                 mb_svc_debug(" file directory %s doesn't exist ",
 642                              dir_full_path);
 643                 return MB_SVC_ERROR_DIR_NOT_EXSITED;
 644         }
 645
 646         _mb_svc_get_file_display_name(file_full_path, file_display_name);
 647         /* if the folder has at least one file */
 648         ret =
 649             mb_svc_get_media_record_by_full_path(mb_svc_handle, file_full_path, &media_record);
 650
 651         if (ret < 0) {
 652                 mb_svc_debug
 653                     ("mb_svc_get_media_record_by_full_path fail:file_full_path is %s ",
 654                      file_full_path);
 655                 return ret;
 656         }
 657
 658         /* delete the matched file info in media table */
 659         ret = mb_svc_delete_record_media_by_id(mb_svc_handle, media_record.media_uuid);
 660         if (ret < 0) {
 661                 mb_svc_debug
 662                     ("mb_svc_delete_record_media fail:folder id is %s,file name is %s ",
 663                      media_record.folder_uuid, file_display_name);
 664                 return ret;
 665         }
 666         mb_svc_debug
 667             ("mb_svc_delete_record_media sccceed,media_id is %s,file type is %d, path is %s\n",
 668              media_record.media_uuid, media_record.content_type, media_record.path);
 669
 670 #ifdef DELETE_FOLDER_RECORD_IF_NO_FILE_IN       /* the media file is deleted succeed, then verify if the folder has no left files */
 671         media_record_cnt = mb_svc_get_folder_content_count_by_folder_id(mb_svc_handle, media_record.folder_uuid);       /* after delete the media file,get the left media file count in the specified folder */
 672         mb_svc_debug("media_record_cnt after delete the media file is %d\n",
 673                      media_record_cnt);
 674         if (media_record_cnt == 0)      { /* the folder has no left files, so delete the folder record */
 675                 ret = mb_svc_delete_record_folder_by_id(mb_svc_handle, folder_record.uuid);
 676                 if (ret < 0) {
 677                         mb_svc_debug("mb_svc_delete_record_older fail:%s\n",
 678                                      folder_record.uuid);
 679                         return ret;
 680                 }
 681         } else {                /* update old folder modified date */
 682                 folder_modified_date =
 683                     _mb_svc_get_file_dir_modified_date(dir_full_path);
 684                 mb_svc_debug("folder_modified_date is %d\n",
 685                              folder_modified_date);
 686                 if (folder_record.modified_date < folder_modified_date) {
 687                         mb_svc_debug("directory %s is modified", dir_full_path);
 688                         folder_record.modified_date = folder_modified_date;
 689                         mb_svc_update_record_folder(mb_svc_handle, &folder_record);
 690                 }
 691         }
 692
 693 #endif
 694         /* delete thumbnail file */
 695         _mb_svc_thumb_delete(file_full_path);
 696
 697         /* delete file info in image_meta table & (video_meta table and bookmark table if it's video file) */
 698         ret =
 699             mb_svc_delete_bookmark_meta_by_media_id(mb_svc_handle, media_record.media_uuid,
 700                                                     media_record.content_type);
 701         if (ret < 0) {
 702                 mb_svc_debug
 703                     ("mb_svc_delete_record_video_or_image_by_media_id fail:media id is %d\n",
 704                      media_id);
 705         }
 706
 707         return ret;
 708 }
 709
 710 int
 711 mb_svc_rename_file(MediaSvcHandle *mb_svc_handle,
 712                         const char *old_file_full_path,
 713                         const char *new_file_full_path,
 714                         minfo_file_type content_type,
 715                         char *thumb_path)
 716 {
 717         mb_svc_debug("");
 718
 719         char old_file_display_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
 720         char new_file_display_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
 721         char old_dir_path[MB_SVC_DIR_PATH_LEN_MAX + 1] = { 0 };
 722         mb_svc_media_record_s media_record = {"",};
 723         mb_svc_folder_record_s folder_record = {"",};
 724         int ret = 0;
 725         int folder_modified_date = 0;
 726         char old_media_uuid[MB_SVC_UUID_LEN_MAX + 1] = {0,};
 727
 728         if (old_file_full_path == NULL || new_file_full_path == NULL) {
 729                 mb_svc_debug
 730                     ("old_file_full_path==NULL || new_file_full_path==NULL\n");
 731                 return MB_SVC_ERROR_INVALID_PARAMETER;
 732         }
 733
 734         mb_svc_debug("old file_full_path is %s, new file full path is %s\n",
 735                      old_file_full_path, new_file_full_path);
 736
 737         _mb_svc_get_file_display_name(old_file_full_path,
 738                                       old_file_display_name);
 739         _mb_svc_get_file_parent_path(old_file_full_path, old_dir_path);
 740
 741         ret = __mb_svc_get_folder_record_by_full_path(mb_svc_handle, old_dir_path, &folder_record);
 742         if (ret < 0) {
 743                 mb_svc_debug(" file directory %s doesn't exist ", old_dir_path);
 744                 return MB_SVC_ERROR_DIR_NOT_EXSITED;
 745         }
 746
 747         ret =
 748             mb_svc_get_media_record_by_fid_name(mb_svc_handle, folder_record.uuid,
 749                                                 old_file_display_name,
 750                                                 &media_record);
 751         if (ret >= 0) {
 752                 strncpy(old_media_uuid, media_record.media_uuid, MB_SVC_UUID_LEN_MAX + 1);
 753
 754                 _mb_svc_get_file_display_name(new_file_full_path,
 755                                               new_file_display_name);
 756                 mb_svc_debug("new file_display_name is %s\n",
 757                              new_file_display_name);
 758
 759                 snprintf(media_record.path, sizeof(media_record.path), "%s/%s",
 760                          folder_record.uri, new_file_display_name);
 761                 strncpy(media_record.display_name, new_file_display_name,
 762                         MB_SVC_FILE_NAME_LEN_MAX + 1);
 763
 764                 media_record.modified_date =
 765                     _mb_svc_get_file_dir_modified_date(new_file_full_path);
 766
 767                 /*  thumb file rename */
 768                 _mb_svc_thumb_rename(old_file_full_path, new_file_full_path,
 769                                      thumb_path);
 770                 strncpy(media_record.thumbnail_path, thumb_path,
 771                         MB_SVC_FILE_PATH_LEN_MAX + 1);
 772
 773                 mb_svc_update_record_media(mb_svc_handle, &media_record);
 774         }
 775
 776         folder_modified_date = _mb_svc_get_file_dir_modified_date(old_dir_path);
 777         mb_svc_debug("folder_modified_date is %d\n", folder_modified_date);
 778         if (folder_record.modified_date < folder_modified_date) {
 779                 mb_svc_debug("directory %s is modified", old_dir_path);
 780                 folder_record.modified_date = folder_modified_date;
 781                 mb_svc_update_record_folder(mb_svc_handle, &folder_record);
 782         }
 783
 784         return 0;
 785 }
 786
 787 int
 788 mb_svc_move_file(MediaSvcHandle *mb_svc_handle,
 789                         const char *old_file_full_path,
 790                         const char *new_file_full_path,
 791                         minfo_file_type content_type,
 792                         char *thumb_path)
 793 {
 794         mb_svc_debug("");
 795
 796         int ret = 0;
 797
 798         if (old_file_full_path == NULL || new_file_full_path == NULL
 799             || thumb_path == NULL) {
 800                 mb_svc_debug
 801                     ("old_file_full_path==NULL || new_file_full_path==NULL || thumb_path == NULL\n");
 802                 return MB_SVC_ERROR_INVALID_PARAMETER;
 803         }
 804         mb_svc_debug("old file_full_path is %s, new file full path is %s\n",
 805                      old_file_full_path, new_file_full_path);
 806
 807         char old_file_display_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
 808         char new_file_display_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
 809         char old_dir_path[MB_SVC_DIR_PATH_LEN_MAX + 1] = { 0 };
 810         char new_dir_path[MB_SVC_DIR_PATH_LEN_MAX + 1] = { 0 };
 811
 812         mb_svc_folder_record_s src_folder_record = {"",};
 813         mb_svc_folder_record_s dst_folder_record = {"",};
 814         mb_svc_media_record_s media_record = {"",};
 815         int src_clus_cont_cnt = 0;
 816         int src_clus_modified_date = 0;
 817         int dst_clus_modified_date = 0;
 818         char src_cluster_uuid[MB_SVC_UUID_LEN_MAX + 1] = {0,};
 819
 820         GList *move_sql_list = NULL;
 821         char *insert_new_folder_sql = NULL;
 822         char *update_old_folder_sql = NULL;
 823         char *update_new_folder_sql = NULL;
 824         char *delete_folder_sql = NULL;
 825         char *media_sql = NULL;
 826         int insert_new_folder = 0;
 827
 828         _mb_svc_get_file_display_name(old_file_full_path, old_file_display_name);
 829         _mb_svc_get_file_parent_path(old_file_full_path, old_dir_path);
 830
 831         _mb_svc_get_file_display_name(new_file_full_path, new_file_display_name);
 832         _mb_svc_get_file_parent_path(new_file_full_path, new_dir_path);
 833
 834         ret = __mb_svc_get_folder_record_by_full_path(mb_svc_handle, new_dir_path, &dst_folder_record);
 835         if (ret < 0) {
 836                 mb_svc_debug("Directory %s is NOT in DB", new_dir_path);
 837                 mb_svc_debug("Now making new dir %s", new_dir_path);
 838
 839                 int store_type = 0;
 840                 char new_dir_display_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
 841                 int folder_modified_date = 0;
 842
 843                 store_type = _mb_svc_get_store_type_by_full(new_file_full_path);
 844
 845                 if (store_type == MB_SVC_ERROR_INTERNAL) {
 846                         mb_svc_debug("Failed to get storage type : %s",
 847                                      new_file_full_path);
 848                         return MB_SVC_ERROR_INVALID_PARAMETER;
 849                 }
 850
 851                 _mb_svc_get_dir_display_name(new_dir_path, new_dir_display_name);
 852                 mb_svc_debug("dir_display_name is %s\n", new_dir_display_name);
 853
 854                 folder_modified_date = _mb_svc_get_file_dir_modified_date(new_dir_path);
 855
 856                 dst_folder_record.modified_date = folder_modified_date;
 857                 dst_folder_record.storage_type = store_type;
 858                 strncpy(dst_folder_record.uri, new_dir_path, MB_SVC_DIR_PATH_LEN_MAX + 1);
 859                 strncpy(dst_folder_record.display_name, new_dir_display_name,
 860                         MB_SVC_FILE_NAME_LEN_MAX + 1);
 861                 strncpy(dst_folder_record.web_account_id, "", MB_SVC_ARRAY_LEN_MAX + 1);
 862                 strncpy(dst_folder_record.web_album_id, "", MB_SVC_ARRAY_LEN_MAX + 1);
 863                 dst_folder_record.lock_status = 0;
 864
 865                 insert_new_folder = 1;
 866         }
 867
 868         ret = mb_svc_get_media_record_by_full_path(mb_svc_handle, old_file_full_path, &media_record);
 869         if (ret < 0) {
 870                 mb_svc_debug("mb_svc_get_media_record_by_full_path fails : %d", ret);
 871                 return ret;
 872         }
 873
 874         strncpy(src_cluster_uuid, media_record.folder_uuid, MB_SVC_UUID_LEN_MAX + 1);
 875
 876         strncpy(media_record.folder_uuid, dst_folder_record.uuid, MB_SVC_UUID_LEN_MAX + 1);
 877         strncpy(media_record.path, new_file_full_path, sizeof(media_record.path));
 878         strncpy(media_record.display_name, new_file_display_name, sizeof(media_record.display_name));
 879         media_record.modified_date = _mb_svc_get_file_dir_modified_date(new_file_full_path);
 880
 881         _mb_svc_thumb_move(old_file_full_path, new_file_full_path, thumb_path);
 882
 883         strncpy(media_record.thumbnail_path, thumb_path, sizeof(media_record.thumbnail_path));
 884
 885         /*  verify if the old folder has no  files left */
 886         src_clus_cont_cnt =
 887             mb_svc_get_folder_content_count_by_folder_id(mb_svc_handle, src_cluster_uuid);
 888
 889         if (src_clus_cont_cnt == 1) {
 890
 891                 ret = mb_svc_delete_record_folder_sql(src_cluster_uuid, &delete_folder_sql);
 892                 if (ret < 0) {
 893                         mb_svc_debug("mb_svc_delete_record_folder_sql fail:%d\n",
 894                                      ret);
 895                         return ret;
 896                 }
 897                 mb_svc_sql_list_add(&move_sql_list, &delete_folder_sql);
 898         } else  {       /* update  modified date */
 899                 src_clus_modified_date =
 900                     _mb_svc_get_file_dir_modified_date(old_dir_path);
 901                 mb_svc_get_folder_record_by_id(mb_svc_handle, src_cluster_uuid, &src_folder_record);
 902                 mb_svc_debug("src cluster modified_date is %d\n",
 903                              src_clus_modified_date);
 904                 if (src_folder_record.modified_date < src_clus_modified_date) {
 905                         src_folder_record.modified_date = src_clus_modified_date;
 906
 907                         ret = mb_svc_update_record_folder_sql(&src_folder_record, &update_old_folder_sql);
 908                         if (ret < 0) {
 909                                 mb_svc_debug("mb_svc_delete_record_folder_sql fail:%d\n",
 910                                                 ret);
 911                                 return ret;
 912                         }
 913
 914                         mb_svc_sql_list_add(&move_sql_list, &update_old_folder_sql);
 915                 }
 916         }
 917
 918         ret = mb_svc_sqlite3_begin_trans(mb_svc_handle);
 919         if (ret < 0) {
 920                 mb_svc_debug("mb_svc_sqlite3_begin_trans failed\n");
 921                 return ret;
 922         }
 923
 924         if (insert_new_folder == 1) {
 925                 ret = mb_svc_insert_record_folder_sql(&dst_folder_record, &insert_new_folder_sql);
 926                 if (ret < 0) {
 927                         mb_svc_debug("mb_svc_insert_record_folder_sql fails : %d", ret);
 928                         return ret;
 929                 }
 930
 931                 mb_svc_sql_list_add(&move_sql_list, &insert_new_folder_sql);
 932
 933                 strncpy(media_record.folder_uuid, dst_folder_record.uuid, MB_SVC_UUID_LEN_MAX + 1);
 934
 935         } else {
 936                 dst_clus_modified_date =
 937                         _mb_svc_get_file_dir_modified_date(new_dir_path);
 938
 939                 mb_svc_debug("dst cluster modified_date is %d\n",
 940                                 dst_clus_modified_date);
 941                 if (dst_folder_record.modified_date < dst_clus_modified_date) {
 942                         dst_folder_record.modified_date = dst_clus_modified_date;
 943
 944                         ret = mb_svc_update_record_folder_sql(&dst_folder_record, &update_new_folder_sql);
 945                         if (ret < 0) {
 946                                 mb_svc_debug("mb_svc_delete_record_folder_sql fail:%d\n",
 947                                                 ret);
 948                                 return ret;
 949                         }
 950
 951                         mb_svc_sql_list_add(&move_sql_list, &update_new_folder_sql);
 952                 }
 953         }
 954
 955         ret = mb_svc_update_record_media_sql(&media_record, &media_sql);
 956         if (ret < 0) {
 957                 mb_svc_debug("mb_svc_update_record_media fails : %d", ret);
 958                 return ret;
 959         }
 960
 961         mb_svc_sql_list_add(&move_sql_list, &media_sql);
 962
 963         /* Start transaction */
 964         int i = 0;
 965         int length = g_list_length(move_sql_list);
 966
 967         for (i = 0; i < length; i++) {
 968                 char *sql = (char *)g_list_nth_data(move_sql_list, i);
 969                 ret = mb_svc_query_sql(mb_svc_handle, sql);
 970
 971                 if (ret < 0) {
 972                         mb_svc_debug
 973                                 ("mb_svc_query_sql failed.. Now start to rollback\n");
 974                         mb_svc_sqlite3_rollback_trans(mb_svc_handle);
 975                         mb_svc_sql_list_release(&move_sql_list);
 976                         return ret;
 977                 }
 978         }
 979
 980         ret = mb_svc_sqlite3_commit_trans(mb_svc_handle);
 981         if (ret < 0) {
 982                 mb_svc_debug
 983                     ("mb_svc_sqlite3_commit_trans failed.. Now start to rollback\n");
 984                 mb_svc_sqlite3_rollback_trans(mb_svc_handle);
 985                 return ret;
 986         }
 987
 988         return ret;
 989 }
 990
 991 int
 992 mb_svc_move_file_batch(MediaSvcHandle *mb_svc_handle,
 993                         const char *old_file_full_path,
 994                         const char *new_file_full_path,
 995                         minfo_file_type content_type,
 996                         char *thumb_path)
 997 {
 998         mb_svc_debug("");
 999
1000         int ret = 0;
1001
1002         if (old_file_full_path == NULL || new_file_full_path == NULL
1003             || thumb_path == NULL) {
1004                 mb_svc_debug
1005                     ("old_file_full_path==NULL || new_file_full_path==NULL || thumb_path == NULL\n");
1006                 return MB_SVC_ERROR_INVALID_PARAMETER;
1007         }
1008         mb_svc_debug("old file_full_path is %s, new file full path is %s\n",
1009                      old_file_full_path, new_file_full_path);
1010
1011         char old_file_display_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
1012         char new_file_display_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
1013         char old_dir_path[MB_SVC_DIR_PATH_LEN_MAX + 1] = { 0 };
1014         char new_dir_path[MB_SVC_DIR_PATH_LEN_MAX + 1] = { 0 };
1015
1016         mb_svc_folder_record_s src_folder_record = {"",};
1017         mb_svc_folder_record_s dst_folder_record = {"",};
1018         mb_svc_media_record_s media_record = {"",};
1019         int src_clus_cont_cnt = 0;
1020         int src_clus_modified_date = 0;
1021         int dst_clus_modified_date = 0;
1022         char src_cluster_uuid[MB_SVC_UUID_LEN_MAX + 1] = {0,};
1023
1024         char *update_old_folder_sql = NULL;
1025         char *update_new_folder_sql = NULL;
1026         char *delete_folder_sql = NULL;
1027         char *media_sql = NULL;
1028         int insert_new_folder = 0;
1029
1030         _mb_svc_get_file_display_name(old_file_full_path,
1031                                       old_file_display_name);
1032         _mb_svc_get_file_parent_path(old_file_full_path, old_dir_path);
1033
1034         _mb_svc_get_file_display_name(new_file_full_path,
1035                                       new_file_display_name);
1036         _mb_svc_get_file_parent_path(new_file_full_path, new_dir_path);
1037
1038         ret = __mb_svc_get_folder_record_by_full_path(mb_svc_handle, new_dir_path, &dst_folder_record);
1039         if (ret < 0) {
1040                 mb_svc_debug("Directory %s is NOT in DB", new_dir_path);
1041                 mb_svc_debug("Now making new dir %s", new_dir_path);
1042
1043                 int store_type = 0;
1044                 char new_dir_display_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
1045                 int folder_modified_date = 0;
1046
1047                 store_type = _mb_svc_get_store_type_by_full(new_file_full_path);
1048
1049                 if (store_type == MB_SVC_ERROR_INTERNAL) {
1050                         mb_svc_debug("Failed to get storage type : %s",
1051                                      new_file_full_path);
1052                         return MB_SVC_ERROR_INVALID_PARAMETER;
1053                 }
1054
1055                 _mb_svc_get_dir_display_name(new_dir_path, new_dir_display_name);
1056                 mb_svc_debug("dir_display_name is %s\n", new_dir_display_name);
1057
1058                 folder_modified_date = _mb_svc_get_file_dir_modified_date(new_dir_path);
1059
1060                 dst_folder_record.modified_date = folder_modified_date;
1061                 dst_folder_record.storage_type = store_type;
1062                 strncpy(dst_folder_record.uri, new_dir_path, MB_SVC_DIR_PATH_LEN_MAX + 1);
1063                 strncpy(dst_folder_record.display_name, new_dir_display_name,
1064                         MB_SVC_FILE_NAME_LEN_MAX + 1);
1065                 strncpy(dst_folder_record.web_account_id, "", MB_SVC_ARRAY_LEN_MAX + 1);
1066                 strncpy(dst_folder_record.web_album_id, "", MB_SVC_ARRAY_LEN_MAX + 1);
1067                 dst_folder_record.lock_status = 0;
1068
1069                 insert_new_folder = 1;
1070         }
1071
1072         ret = mb_svc_get_media_record_by_full_path(mb_svc_handle, old_file_full_path, &media_record);
1073         if (ret < 0) {
1074                 mb_svc_debug("mb_svc_get_media_record_by_full_path fails : %d", ret);
1075                 return ret;
1076         }
1077
1078         strncpy(src_cluster_uuid, media_record.folder_uuid, MB_SVC_UUID_LEN_MAX + 1);
1079
1080         strncpy(media_record.folder_uuid, dst_folder_record.uuid, MB_SVC_UUID_LEN_MAX + 1);
1081         strncpy(media_record.path, new_file_full_path, sizeof(media_record.path));
1082         strncpy(media_record.display_name, new_file_display_name, sizeof(media_record.display_name));
1083         media_record.modified_date = _mb_svc_get_file_dir_modified_date(new_file_full_path);
1084
1085         _mb_svc_thumb_move(old_file_full_path, new_file_full_path, thumb_path);
1086
1087         strncpy(media_record.thumbnail_path, thumb_path, sizeof(media_record.thumbnail_path));
1088
1089         /*  verify if the old folder has no  files left */
1090         src_clus_cont_cnt =
1091             mb_svc_get_folder_content_count_by_folder_id(mb_svc_handle, src_cluster_uuid);
1092
1093         if (src_clus_cont_cnt == 1) {
1094
1095                 ret = mb_svc_delete_record_folder_sql(src_cluster_uuid, &delete_folder_sql);
1096                 if (ret < 0) {
1097                         mb_svc_debug("mb_svc_delete_record_folder_sql fail:%d\n",
1098                                      ret);
1099                         return ret;
1100                 }
1101                 mb_svc_sql_list_add(&g_move_sql_list, &delete_folder_sql);
1102         } else  {       /* update  modified date */
1103                 src_clus_modified_date =
1104                     _mb_svc_get_file_dir_modified_date(old_dir_path);
1105                 mb_svc_get_folder_record_by_id(mb_svc_handle, src_cluster_uuid, &src_folder_record);
1106                 mb_svc_debug("src cluster modified_date is %d\n",
1107                              src_clus_modified_date);
1108                 if (src_folder_record.modified_date < src_clus_modified_date) {
1109                         src_folder_record.modified_date = src_clus_modified_date;
1110
1111                         ret = mb_svc_update_record_folder_sql(&src_folder_record, &update_old_folder_sql);
1112                         if (ret < 0) {
1113                                 mb_svc_debug("mb_svc_delete_record_folder_sql fail:%d\n",
1114                                                 ret);
1115                                 return ret;
1116                         }
1117
1118                         mb_svc_sql_list_add(&g_move_sql_list, &update_old_folder_sql);
1119                 }
1120         }
1121
1122         if (insert_new_folder == 1) {
1123                 ret = mb_svc_insert_record_folder(mb_svc_handle, &dst_folder_record);
1124                 if (ret < 0) {
1125                         mb_svc_debug("mb_svc_insert_record_folder_sql fails : %d", ret);
1126                         return ret;
1127                 }
1128
1129                 strncpy(media_record.folder_uuid, dst_folder_record.uuid, MB_SVC_UUID_LEN_MAX + 1);
1130
1131         } else {
1132                 dst_clus_modified_date =
1133                         _mb_svc_get_file_dir_modified_date(new_dir_path);
1134
1135                 mb_svc_debug("dst cluster modified_date is %d\n",
1136                                 dst_clus_modified_date);
1137                 if (dst_folder_record.modified_date < dst_clus_modified_date) {
1138                         dst_folder_record.modified_date = dst_clus_modified_date;
1139
1140                         ret = mb_svc_update_record_folder_sql(&dst_folder_record, &update_new_folder_sql);
1141                         if (ret < 0) {
1142                                 mb_svc_debug("mb_svc_delete_record_folder_sql fail:%d\n",
1143                                                 ret);
1144                                 return ret;
1145                         }
1146
1147                         mb_svc_sql_list_add(&g_move_sql_list, &update_new_folder_sql);
1148                 }
1149         }
1150
1151         ret = mb_svc_update_record_media_sql(&media_record, &media_sql);
1152         if (ret < 0) {
1153                 mb_svc_debug("mb_svc_update_record_media fails : %d", ret);
1154                 return ret;
1155         }
1156
1157         mb_svc_sql_list_add(&g_move_sql_list, &media_sql);
1158
1159         return ret;
1160 }
1161
1162 int mb_svc_move_file_by_id(MediaSvcHandle *mb_svc_handle, const char *src_media_id, const char *dst_cluster_id)
1163 {
1164         mb_svc_debug("");
1165
1166         int ret = 0;
1167         mb_svc_media_record_s media_record = {"",};
1168         int src_clus_cont_cnt = 0;
1169         int src_clus_modified_date = 0;
1170         char src_clus_path[MB_SVC_FILE_PATH_LEN_MAX + 1] = { 0 };
1171         int dst_clus_modified_date = 0;
1172         char dst_clus_path[MB_SVC_FILE_PATH_LEN_MAX + 1] = { 0 };
1173         mb_svc_folder_record_s folder_record = {"",};
1174         char thumb_path[MB_SVC_FILE_PATH_LEN_MAX + 1] = { 0 };
1175         char dst_file_full_path[MB_SVC_FILE_PATH_LEN_MAX + 1] = { 0 };
1176         char src_cluster_uuid[MB_SVC_UUID_LEN_MAX + 1] = {0,};
1177
1178         mb_svc_debug("minfo_mv_media#src_media_id: %s", src_media_id);
1179         mb_svc_debug("minfo_mv_media#dst_cluster_id: %s", dst_cluster_id);
1180
1181         ret = mb_svc_get_media_record_by_id(mb_svc_handle, src_media_id, &media_record);
1182         if (ret < 0) {
1183                 mb_svc_debug("mb_svc_get_media_record_by_id failed\n");
1184                 return ret;
1185         }
1186
1187         strncpy(src_cluster_uuid, media_record.folder_uuid, MB_SVC_UUID_LEN_MAX + 1);
1188
1189         mb_svc_get_folder_fullpath_by_folder_id(mb_svc_handle, dst_cluster_id, dst_clus_path,
1190                                                 sizeof(dst_clus_path));
1191         snprintf(dst_file_full_path, MB_SVC_FILE_PATH_LEN_MAX + 1, "%s/%s",
1192                  dst_clus_path, media_record.display_name);
1193
1194         strncpy(media_record.path, dst_file_full_path, MB_SVC_FILE_PATH_LEN_MAX + 1);
1195
1196         _mb_svc_thumb_move(media_record.path, dst_file_full_path, thumb_path);
1197
1198         media_record.modified_date =
1199             _mb_svc_get_file_dir_modified_date(dst_file_full_path);
1200         strncpy(media_record.thumbnail_path, thumb_path,
1201                 MB_SVC_FILE_PATH_LEN_MAX + 1);
1202         //media_record.folder_id = dst_cluster_id;
1203         strncpy(media_record.folder_uuid, dst_cluster_id, MB_SVC_UUID_LEN_MAX + 1);
1204
1205         mb_svc_update_record_media(mb_svc_handle, &media_record);
1206
1207         /*  verify if the old folder has no  files left */
1208         src_clus_cont_cnt =
1209             mb_svc_get_folder_content_count_by_folder_id(mb_svc_handle, src_cluster_uuid);
1210         if (src_clus_cont_cnt == 0) {
1211                 ret = mb_svc_delete_record_folder_by_id(mb_svc_handle, src_cluster_uuid);
1212                 if (ret < 0) {
1213                         mb_svc_debug("mb_svc_delete_record_older fail:%d\n",
1214                                      src_clus_cont_cnt);
1215                         return ret;
1216                 }
1217         } else  {       /* update  modified date */
1218                 mb_svc_get_folder_fullpath_by_folder_id(mb_svc_handle, src_cluster_uuid,
1219                                                         src_clus_path,
1220                                                         sizeof(src_clus_path));
1221                 src_clus_modified_date =
1222                     _mb_svc_get_file_dir_modified_date(src_clus_path);
1223                 mb_svc_get_folder_record_by_id(mb_svc_handle, src_cluster_uuid, &folder_record);
1224                 mb_svc_debug("src cluster modified_date is %d\n",
1225                              src_clus_modified_date);
1226                 if (folder_record.modified_date < src_clus_modified_date) {
1227                         mb_svc_debug("src cluster directory %s is modified",
1228                                      src_clus_path);
1229                         folder_record.modified_date = src_clus_modified_date;
1230                         mb_svc_update_record_folder(mb_svc_handle, &folder_record);
1231                 }
1232         }
1233
1234         mb_svc_get_folder_fullpath_by_folder_id(mb_svc_handle, dst_cluster_id, dst_clus_path,
1235                                                 sizeof(dst_clus_path));
1236         dst_clus_modified_date =
1237             _mb_svc_get_file_dir_modified_date(dst_clus_path);
1238         mb_svc_get_folder_record_by_id(mb_svc_handle, dst_cluster_id, &folder_record);
1239         mb_svc_debug("src cluster modified_date is %d\n",
1240                      dst_clus_modified_date);
1241         if (folder_record.modified_date < dst_clus_modified_date) {
1242                 mb_svc_debug("src cluster directory %s is modified",
1243                              dst_clus_path);
1244                 folder_record.modified_date = dst_clus_modified_date;
1245                 mb_svc_update_record_folder(mb_svc_handle, &folder_record);
1246         }
1247
1248         return 0;
1249 }
1250
1251 int
1252 mb_svc_copy_file(MediaSvcHandle *mb_svc_handle,
1253                                 const char *old_file_full_path,
1254                                 const char *new_file_full_path,
1255                                 minfo_file_type content_type,
1256                                 char *thumb_path)
1257 {
1258         char new_file_display_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
1259         char new_dir_path[MB_SVC_DIR_PATH_LEN_MAX + 1] = { 0 };
1260         char dir_display_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
1261         mb_svc_media_record_s media_record = {"",};
1262         mb_svc_folder_record_s folder_record = {"",};
1263         mb_svc_image_meta_record_s image_record = {0,};
1264         mb_svc_video_meta_record_s video_record = {0,};
1265         int folder_modified_date = 0;
1266         int ret = 0;
1267         int store_type = 0;
1268         char old_media_uuid[MB_SVC_UUID_LEN_MAX + 1] = {0,};
1269         bool is_new_folder = FALSE;
1270
1271         if (old_file_full_path == NULL || new_file_full_path == NULL
1272             || thumb_path == NULL) {
1273                 mb_svc_debug
1274                     ("old_file_full_path==NULL || new_file_full_path==NULL || thumb_path == NULL\n");
1275                 return MB_SVC_ERROR_INVALID_PARAMETER;
1276         }
1277         mb_svc_debug("old file_full_path is %s, new file full path is %s\n",
1278                      old_file_full_path, new_file_full_path);
1279
1280         /* 1. copy to dest dir */
1281
1282         /* 1.1. get old media record info */
1283         ret =
1284             mb_svc_get_media_record_by_full_path(mb_svc_handle, old_file_full_path,
1285                                                  &media_record);
1286
1287         if (ret < 0) {
1288                 mb_svc_debug
1289                     ("mb_svc_get_media_record_by_fid_name fail: %d\n", ret);
1290                 return ret;
1291         }
1292
1293         /* 1.2. check new dir  */
1294         _mb_svc_get_file_parent_path(new_file_full_path, new_dir_path);
1295         folder_modified_date = _mb_svc_get_file_dir_modified_date(new_dir_path);
1296         mb_svc_debug("folder_modified_date is %d\n", folder_modified_date);
1297
1298         ret = __mb_svc_get_folder_record_by_full_path(mb_svc_handle, new_dir_path, &folder_record);
1299
1300         if (ret < 0 && ret == MB_SVC_ERROR_DB_INTERNAL) {
1301
1302                 is_new_folder = TRUE;
1303                 mb_svc_debug("no any record in %s", new_dir_path);
1304
1305                 store_type = _mb_svc_get_store_type_by_full(new_file_full_path);
1306                 if (store_type == MB_SVC_ERROR_INTERNAL) {
1307                         mb_svc_debug("Failed to get storage type : %s",
1308                                      new_file_full_path);
1309                         return MB_SVC_ERROR_INVALID_PARAMETER;
1310                 }
1311                 mb_svc_debug("store_type is %d\n", store_type);
1312
1313                 _mb_svc_get_dir_display_name(new_dir_path, dir_display_name);
1314                 mb_svc_debug("dir_display_name is %s\n", dir_display_name);
1315
1316                 /* _mb_svc_get_rel_path_by_full(new_dir_path, rel_path);
1317                 mb_svc_debug("rel path is %s\n", rel_path);
1318                 _mb_svc_get_dir_parent_path(rel_path, uri);
1319                 mb_svc_debug("uri is %s\n", uri); */
1320
1321                 folder_record.modified_date = folder_modified_date;
1322                 folder_record.storage_type = store_type;
1323                 strncpy(folder_record.uri, new_dir_path,
1324                         MB_SVC_DIR_PATH_LEN_MAX + 1);
1325                 strncpy(folder_record.display_name, dir_display_name,
1326                         MB_SVC_FILE_NAME_LEN_MAX + 1);
1327                 strncpy(folder_record.web_account_id, "", MB_SVC_ARRAY_LEN_MAX + 1);
1328                 strncpy(folder_record.web_album_id, "", MB_SVC_ARRAY_LEN_MAX + 1);
1329                 folder_record.lock_status = 0;
1330
1331                 mb_svc_debug
1332                     ("no record in %s, ready insert the folder record into db\n",
1333                      new_dir_path);
1334
1335                 ret = mb_svc_insert_record_folder(mb_svc_handle, &folder_record);
1336                 if (ret < 0) {
1337                         mb_svc_debug
1338                             ("insert file info into folder table failed. Trying to get folder record again.\n");
1339                         memset(&folder_record, 0x00,
1340                                sizeof(mb_svc_folder_record_s));
1341                         ret = __mb_svc_get_folder_record_by_full_path(mb_svc_handle, new_dir_path,
1342                                                                   &folder_record);
1343                         if (ret < 0) {
1344                                 mb_svc_debug("__mb_svc_get_folder_record_by_full_path failed again.");
1345                                 return ret;
1346                         }
1347                         is_new_folder = FALSE;
1348                 }
1349                 mb_svc_debug("folder record id of new inserted is %s\n",
1350                              folder_record.uuid);
1351         } else {
1352                 mb_svc_debug
1353                     ("folder_record info: uuid is %s,uri is %s,display_name is %s,modified_date is %d,web_account_id is %s,store_type is %d\n",
1354                      folder_record.uuid, folder_record.uri,
1355                      folder_record.display_name, folder_record.modified_date,
1356                      folder_record.web_account_id, folder_record.storage_type);
1357
1358                 if (folder_record.modified_date < folder_modified_date) {
1359                         mb_svc_debug("directory %s is modified", new_dir_path);
1360                         folder_record.modified_date = folder_modified_date;
1361                         mb_svc_update_record_folder(mb_svc_handle, &folder_record);
1362                 }
1363         }
1364
1365         strncpy(old_media_uuid, media_record.media_uuid, MB_SVC_UUID_LEN_MAX + 1);
1366
1367         /* 2.3. set new values, take care of  file rename  */
1368         _mb_svc_get_file_display_name(new_file_full_path,
1369                                       new_file_display_name);
1370         mb_svc_debug("new file_display_name is %s\n", new_file_display_name);
1371         strncpy(media_record.display_name, new_file_display_name,
1372                 MB_SVC_FILE_NAME_LEN_MAX + 1);
1373         strncpy(media_record.path, new_file_full_path,
1374                 MB_SVC_FILE_PATH_LEN_MAX + 1);
1375
1376         strncpy(media_record.folder_uuid, folder_record.uuid, MB_SVC_UUID_LEN_MAX + 1);
1377         media_record.modified_date =
1378             _mb_svc_get_file_dir_modified_date(new_file_full_path);
1379
1380         _mb_svc_thumb_generate_hash_name(new_file_full_path, thumb_path,
1381                                          MB_SVC_FILE_PATH_LEN_MAX + 1);
1382         strncpy(media_record.thumbnail_path, thumb_path,
1383                 MB_SVC_FILE_PATH_LEN_MAX + 1);
1384
1385         ret = mb_svc_insert_record_media(mb_svc_handle, &media_record, store_type);
1386         if (ret < 0) {
1387                 if (is_new_folder == TRUE) {
1388                         ret =
1389                             mb_svc_delete_record_folder_by_id(mb_svc_handle, folder_record.uuid);
1390                         if (ret < 0) {
1391                                 mb_svc_debug
1392                                     ("mb_svc_delete_record_older fail:%s\n",
1393                                      folder_record.uuid);
1394                         }
1395                 }
1396                 return ret;
1397         }
1398
1399         /* 2.4. copy  image_meta record or video_meta record */
1400         if (content_type == MINFO_ITEM_IMAGE) {
1401                 mb_svc_debug("update image record\n");
1402                 ret =
1403                     mb_svc_get_image_record_by_media_id(mb_svc_handle, old_media_uuid,
1404                                                         &image_record);
1405                 if (ret < 0) {
1406                         mb_svc_debug("get image record by media id failed\n");
1407                         return ret;
1408                 }
1409
1410                 strncpy(image_record.media_uuid, media_record.media_uuid, MB_SVC_UUID_LEN_MAX + 1);
1411
1412                 ret =
1413                     mb_svc_insert_record_image_meta(mb_svc_handle, &image_record, store_type);
1414                 if (ret < 0) {
1415                         mb_svc_debug
1416                             ("mb_svc_insert_record_image_meta failed\n");
1417                         return ret;
1418                 }
1419
1420         } else if (content_type == MINFO_ITEM_VIDEO) {
1421                 mb_svc_debug("update video record\n");
1422                 ret =
1423                     mb_svc_get_video_record_by_media_id(mb_svc_handle, old_media_uuid,
1424                                                         &video_record);
1425                 if (ret < 0) {
1426                         mb_svc_debug("get video record by media id failed\n");
1427                         return ret;
1428                 }
1429
1430                 strncpy(video_record.media_uuid, media_record.media_uuid, MB_SVC_UUID_LEN_MAX + 1);
1431
1432                 ret =
1433                     mb_svc_insert_record_video_meta(mb_svc_handle, &video_record, store_type);
1434                 if (ret < 0) {
1435                         mb_svc_debug
1436                             ("mb_svc_insert_record_video_meta failed\n");
1437                         return ret;
1438                 }
1439
1440                 /* Get bookmark list and update them */
1441                 mb_svc_bookmark_record_s bookmark_record = { 0 };
1442                 mb_svc_iterator_s mb_svc_bm_iterator = { 0 };
1443                 int record_cnt = 0;
1444
1445                 ret =
1446                     mb_svc_bookmark_iter_start(mb_svc_handle, old_media_uuid,
1447                                                &mb_svc_bm_iterator);
1448                 if (ret < 0) {
1449                         mb_svc_debug("mb-svc iterator start failed");
1450                         return MB_SVC_ERROR_DB_INTERNAL;
1451                 }
1452
1453                 while (1) {
1454                         ret =
1455                             mb_svc_bookmark_iter_next(&mb_svc_bm_iterator,
1456                                                       &bookmark_record);
1457
1458                         if (ret == MB_SVC_NO_RECORD_ANY_MORE)
1459                                 break;
1460
1461                         if (ret < 0) {
1462                                 mb_svc_debug
1463                                     ("mb-svc iterator get next recrod failed");
1464                                 mb_svc_iter_finish(&mb_svc_bm_iterator);
1465                                 return ret;
1466                         }
1467
1468                         record_cnt++;
1469
1470                         strncpy(bookmark_record.media_uuid, media_record.media_uuid, MB_SVC_UUID_LEN_MAX + 1);
1471
1472                         ret = mb_svc_insert_record_bookmark(mb_svc_handle, &bookmark_record);
1473                         if (ret < 0) {
1474                                 mb_svc_debug
1475                                     ("mb_svc_insert_record_bookmark failed\n");
1476                                 return ret;
1477                         }
1478                 }
1479
1480                 mb_svc_iter_finish(&mb_svc_bm_iterator);
1481         }
1482
1483         /* 2.5 copy thumnail file */
1484         ret =
1485             _mb_svc_thumb_copy(old_file_full_path, new_file_full_path,
1486                                thumb_path);
1487         if (ret < 0) {
1488                 mb_svc_debug("thumb copy fails [%d]", ret);
1489                 /* return ret; */
1490         }
1491
1492         return 0;
1493 }
1494
1495 int mb_svc_copy_file_by_id(MediaSvcHandle *mb_svc_handle, const char *src_media_id, const char *dst_cluster_id)
1496 {
1497         int ret = 0;
1498         mb_svc_media_record_s media_record = {"",};
1499         mb_svc_image_meta_record_s image_record = {0,};
1500         mb_svc_video_meta_record_s video_record = {0,};
1501         mb_svc_folder_record_s folder_record = {"",};
1502         char dst_clus_path[MB_SVC_DIR_PATH_LEN_MAX + 1] = { 0 };
1503         char dst_file_full_path[MB_SVC_FILE_PATH_LEN_MAX + 1] = { 0 };
1504         int dst_clus_modified_date = 0;
1505         char thumb_path[MB_SVC_FILE_PATH_LEN_MAX + 1] = { 0 };
1506         minfo_store_type store_type = MINFO_SYSTEM;
1507
1508         ret = mb_svc_get_media_record_by_id(mb_svc_handle, src_media_id, &media_record);
1509         if (ret < 0) {
1510                 mb_svc_debug("mb_svc_get_media_record_by_id failed\n");
1511                 return ret;
1512         }
1513
1514         mb_svc_get_folder_fullpath_by_folder_id(mb_svc_handle, dst_cluster_id, dst_clus_path,
1515                                                 sizeof(dst_clus_path));
1516         snprintf(dst_file_full_path, MB_SVC_FILE_PATH_LEN_MAX + 1, "%s/%s",
1517                  dst_clus_path, media_record.display_name);
1518
1519         store_type = _mb_svc_get_store_type_by_full(dst_file_full_path);
1520         if (store_type == MB_SVC_ERROR_INTERNAL) {
1521                 mb_svc_debug("Failed to get storage type : %s",
1522                              dst_file_full_path);
1523                 return MB_SVC_ERROR_INVALID_PARAMETER;
1524         }
1525
1526         _mb_svc_thumb_generate_hash_name(dst_file_full_path, thumb_path,
1527                                          MB_SVC_FILE_PATH_LEN_MAX + 1);
1528
1529         media_record.modified_date =
1530             _mb_svc_get_file_dir_modified_date(dst_file_full_path);
1531         strncpy(media_record.path, dst_file_full_path,
1532                 MB_SVC_FILE_PATH_LEN_MAX + 1);
1533         strncpy(media_record.thumbnail_path, thumb_path,
1534                 MB_SVC_FILE_PATH_LEN_MAX + 1);
1535         //media_record.folder_id = dst_cluster_id;
1536         strncpy(media_record.folder_uuid, dst_cluster_id, MB_SVC_UUID_LEN_MAX + 1);
1537
1538         mb_svc_insert_record_media(mb_svc_handle, &media_record, store_type);
1539
1540         if (media_record.content_type == MINFO_ITEM_IMAGE) {
1541                 mb_svc_debug("update image record\n");
1542                 ret =
1543                     mb_svc_get_image_record_by_media_id(mb_svc_handle, src_media_id,
1544                                                         &image_record);
1545                 if (ret < 0) {
1546                         mb_svc_debug("get image record by media id failed\n");
1547                         return ret;
1548                 }
1549
1550                 strncpy(image_record.media_uuid, media_record.media_uuid, MB_SVC_UUID_LEN_MAX + 1);
1551
1552                 ret =
1553                     mb_svc_insert_record_image_meta(mb_svc_handle, &image_record, store_type);
1554                 if (ret < 0) {
1555                         mb_svc_debug
1556                             ("mb_svc_insert_record_image_meta failed\n");
1557                         return ret;
1558                 }
1559         } else if (media_record.content_type == MINFO_ITEM_VIDEO) {
1560                 mb_svc_debug("update video record\n");
1561                 ret =
1562                     mb_svc_get_video_record_by_media_id(mb_svc_handle, src_media_id,
1563                                                         &video_record);
1564                 if (ret < 0) {
1565                         mb_svc_debug("get video record by media id failed\n");
1566                         return ret;
1567                 }
1568
1569                 strncpy(video_record.media_uuid, media_record.media_uuid, MB_SVC_UUID_LEN_MAX + 1);
1570                 mb_svc_insert_record_video_meta(mb_svc_handle, &video_record, store_type);
1571         }
1572
1573         mb_svc_get_folder_fullpath_by_folder_id(mb_svc_handle, dst_cluster_id, dst_clus_path,
1574                                                 sizeof(dst_clus_path));
1575         dst_clus_modified_date =
1576             _mb_svc_get_file_dir_modified_date(dst_clus_path);
1577         mb_svc_get_folder_record_by_id(mb_svc_handle, dst_cluster_id, &folder_record);
1578         mb_svc_debug("src cluster modified_date is %d\n",
1579                      dst_clus_modified_date);
1580         if (folder_record.modified_date < dst_clus_modified_date) {
1581                 mb_svc_debug("src cluster directory %s is modified",
1582                              dst_clus_path);
1583                 folder_record.modified_date = dst_clus_modified_date;
1584                 mb_svc_update_record_folder(mb_svc_handle, &folder_record);
1585         }
1586
1587         ret =
1588             _mb_svc_thumb_copy(media_record.path, dst_file_full_path,
1589                                thumb_path);
1590         if (ret < 0) {
1591                 mb_svc_debug("thumb copy fails [%d]", ret);
1592                 /* return ret; */
1593         }
1594
1595         return 0;
1596 }
1597
1598 int mb_svc_update_cluster_name(MediaSvcHandle *mb_svc_handle, const char *cluster_id, const char *new_name)
1599 {
1600         int ret = -1;
1601         int len = 0;
1602         mb_svc_folder_record_s folder_record = {"",};
1603         char old_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
1604         char dir_full_path[MB_SVC_DIR_PATH_LEN_MAX + 1] = { 0 };
1605         char src_parent_path[MB_SVC_DIR_PATH_LEN_MAX + 1] = { 0 };
1606         char src_full_path[MB_SVC_DIR_PATH_LEN_MAX + 1] = { 0 };
1607         char dst_full_path[MB_SVC_DIR_PATH_LEN_MAX + 1] = { 0 };
1608         time_t date;
1609
1610         if (new_name == NULL) {
1611                 mb_svc_debug(" new name is NULL");
1612                 return MB_SVC_ERROR_INVALID_PARAMETER;
1613         }
1614
1615         mb_svc_debug("minfo_update_cluster_name#cluster_id: %s", cluster_id);
1616         mb_svc_debug("minfo_update_cluster_name#new_name: %s", new_name);
1617
1618         ret = mb_svc_get_folder_record_by_id(mb_svc_handle, cluster_id, &folder_record);
1619         if (ret < 0) {
1620                 mb_svc_debug
1621                     ("minfo_update_cluster_name: no folder record matched with the folder id\n");
1622                 return ret;
1623         }
1624
1625         strncpy(old_name, folder_record.display_name, sizeof(old_name));
1626         strncpy(folder_record.display_name, new_name,
1627                 sizeof(folder_record.display_name));
1628         _mb_svc_get_file_parent_path(folder_record.uri, dir_full_path);
1629         snprintf(src_parent_path, sizeof(src_parent_path), "%s/",
1630                  folder_record.uri);
1631
1632         len = g_strlcat(dir_full_path, "/", sizeof(dir_full_path));
1633         if (len >= sizeof(dir_full_path)) {
1634                 mb_svc_debug("strlcat returns failure ( %d )", len);
1635                 return MB_SVC_ERROR_INVALID_PARAMETER;
1636         }
1637
1638         len = g_strlcat(dir_full_path, new_name, sizeof(dir_full_path));
1639         if (len >= sizeof(dir_full_path)) {
1640                 mb_svc_debug("strlcat returns failure ( %d )", len);
1641                 return MB_SVC_ERROR_INVALID_PARAMETER;
1642         }
1643
1644         strncpy(folder_record.uri, dir_full_path, sizeof(folder_record.uri));
1645         mb_svc_debug("uri: %s", folder_record.uri);
1646
1647         len = g_strlcat(dir_full_path, "/", sizeof(dir_full_path));
1648         if (len >= sizeof(dir_full_path)) {
1649                 mb_svc_debug("strlcat returns failure ( %d )", len);
1650                 return MB_SVC_ERROR_INVALID_PARAMETER;
1651         }
1652
1653         /* Update all folder record's path, which are matched by old parent path */
1654         ret = mb_svc_update_record_folder_path(mb_svc_handle, src_parent_path, dir_full_path);
1655         if (ret < 0) {
1656                 mb_svc_debug("mb_svc_update_record_folder_path failed\n");
1657                 return ret;
1658         }
1659
1660         time(&date);
1661         folder_record.modified_date = date;
1662
1663         /* Update all folder record's modified date, which are changed above */
1664         ret =
1665             mb_svc_update_folder_modified_date(mb_svc_handle, dir_full_path,
1666                                                folder_record.modified_date);
1667         if (ret < 0) {
1668                 mb_svc_debug("mb_svc_update_folder_modified_date failed\n");
1669                 return ret;
1670         }
1671
1672         ret = mb_svc_update_record_folder(mb_svc_handle, &folder_record);
1673         if (ret < 0) {
1674                 mb_svc_debug
1675                     ("minfo_update_cluster_name: update cluster name failed\n");
1676                 return ret;
1677         }
1678
1679         mb_svc_folder_record_s matched_folder_record = {"",};
1680         mb_svc_media_record_s media_record = {"",};
1681         mb_svc_iterator_s mb_svc_folder_iterator = { 0 };
1682         mb_svc_iterator_s mb_svc_media_iterator = { 0 };
1683         minfo_item_filter filter = { 0 };
1684         filter.favorite = MINFO_MEDIA_FAV_ALL;
1685         filter.start_pos = -1;
1686         filter.sort_type = MINFO_MEDIA_SORT_BY_NONE;
1687         filter.file_type = MINFO_ITEM_ALL;
1688         char old_media_uuid[MB_SVC_UUID_LEN_MAX + 1] = {0,};
1689
1690         ret = __mb_svc_folder_by_path_iter_start(mb_svc_handle, folder_record.uri, &mb_svc_folder_iterator);
1691
1692         if (ret < 0) {
1693                 mb_svc_debug("mb-svc iterator start failed");
1694                 return ret;
1695         }
1696
1697         while (1) {
1698                 ret =
1699                     mb_svc_folder_iter_next(&mb_svc_folder_iterator,
1700                                             &matched_folder_record);
1701
1702                 if (ret == MB_SVC_NO_RECORD_ANY_MORE) {
1703                         break;
1704                 }
1705                 if (ret < 0) {
1706                         mb_svc_debug
1707                             ("mb_svc_folder_iterator get next recrod failed");
1708                         mb_svc_iter_finish(&mb_svc_folder_iterator);
1709                         return ret;
1710                 }
1711
1712                 ret =
1713                     mb_svc_media_iter_start_new(mb_svc_handle, matched_folder_record.uuid,
1714                                                 &filter, MINFO_CLUSTER_TYPE_ALL,
1715                                                 1, NULL,
1716                                                 &mb_svc_media_iterator);
1717
1718                 if (ret < 0) {
1719                         mb_svc_debug("mb-svc iterator start failed");
1720                         mb_svc_iter_finish(&mb_svc_folder_iterator);
1721                         return ret;
1722                 }
1723
1724                 while (1) {
1725                         ret =
1726                             mb_svc_media_iter_next(&mb_svc_media_iterator,
1727                                                    &media_record);
1728
1729                         if (ret == MB_SVC_NO_RECORD_ANY_MORE) {
1730                                 break;
1731                         }
1732
1733                         if (ret < 0) {
1734                                 mb_svc_debug
1735                                     ("mb-svc iterator get next recrod failed");
1736                                 mb_svc_iter_finish(&mb_svc_folder_iterator);
1737                                 mb_svc_iter_finish(&mb_svc_media_iterator);
1738                                 return ret;
1739                         }
1740
1741                         strncpy(old_media_uuid, media_record.media_uuid, MB_SVC_UUID_LEN_MAX + 1);
1742
1743                         snprintf(src_full_path, sizeof(src_full_path), "%s",
1744                                  media_record.path);
1745
1746                         memset(media_record.path, 0x00,
1747                                sizeof(media_record.path));
1748                         snprintf(media_record.path, sizeof(media_record.path),
1749                                  "%s/%s", matched_folder_record.uri,
1750                                  media_record.display_name);
1751
1752                         snprintf(dst_full_path, sizeof(dst_full_path), "%s",
1753                                  media_record.path);
1754
1755                         mb_svc_debug
1756                             ("_mb_svc_thumb_move : src[ %s ], dst[ %s ]",
1757                              src_full_path, dst_full_path);
1758                         ret =
1759                             _mb_svc_thumb_move(src_full_path, dst_full_path,
1760                                                media_record.thumbnail_path);
1761                         if (ret < 0) {
1762                                 mb_svc_debug
1763                                     ("_mb_svc_thumb_move fails.. so use default thumbnail");
1764                                 snprintf(media_record.thumbnail_path,
1765                                          sizeof(media_record.thumbnail_path),
1766                                          "%s", DEFAULT_IMAGE_THUMB);
1767                         }
1768
1769                         ret = mb_svc_update_record_media(mb_svc_handle, &media_record);
1770                         if (ret < 0) {
1771                                 mb_svc_debug
1772                                     ("Error : mb_svc_update_record_media path : %s",
1773                                      media_record.path);
1774                                 mb_svc_iter_finish(&mb_svc_folder_iterator);
1775                                 mb_svc_iter_finish(&mb_svc_media_iterator);
1776                                 return ret;
1777                         }
1778                 }
1779
1780                 mb_svc_iter_finish(&mb_svc_media_iterator);
1781         }
1782
1783         mb_svc_iter_finish(&mb_svc_folder_iterator);
1784
1785         return 0;
1786 }
1787
1788 /* clock_t */
1789 long mb_svc_get_clock(void)
1790 {
1791         struct timeval tv;
1792         long curtime;
1793
1794         gettimeofday(&tv, NULL);
1795         curtime = tv.tv_sec * USEC_PER_SEC + tv.tv_usec;
1796
1797         /* int curtime = time((time_t*)NULL); */
1798         return curtime;
1799 }
1800
1801 int mb_svc_table_member_count(MediaSvcHandle *mb_svc_handle, char *table_name)
1802 {
1803         char q_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
1804         int rc = 0;
1805         sqlite3_stmt *stmt = NULL;
1806         int count = 0;
1807         int err = -1;
1808
1809         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
1810         if (handle == NULL) {
1811                 mb_svc_debug("handle is NULL");
1812                 return MB_SVC_ERROR_DB_INTERNAL;
1813         }
1814
1815         if (table_name == NULL) {
1816                 mb_svc_debug("Error:table_name == NULL\n");
1817                 return MB_SVC_ERROR_INVALID_PARAMETER;
1818         }
1819
1820         snprintf(q_string, sizeof(q_string), MB_SVC_TABLE_COUNT_QUERY_STRING,
1821                  table_name);
1822
1823         err =
1824             sqlite3_prepare_v2(handle, q_string, strlen(q_string), &stmt, NULL);
1825         if (SQLITE_OK != err) {
1826                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
1827                 mb_svc_debug("query string is %s\n", q_string);
1828                 return MB_SVC_ERROR_DB_INTERNAL;
1829         }
1830         rc = sqlite3_step(stmt);
1831         while (rc == SQLITE_ROW) {
1832                 count = sqlite3_column_int(stmt, 0);
1833                 rc = sqlite3_step(stmt);
1834         }
1835         sqlite3_finalize(stmt);
1836
1837         stmt = NULL;
1838         mb_svc_debug("record count of table %s is %d\n", table_name, count);
1839         return count;
1840 }
1841
1842 int
1843 mb_svc_check_exist_by_path(MediaSvcHandle *mb_svc_handle, const char *path, const char *table_name)
1844 {
1845         char *query = NULL;
1846         int rc = 0;
1847         sqlite3_stmt *stmt = NULL;
1848         int count = 0;
1849         int err = -1;
1850
1851         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
1852         if (handle == NULL) {
1853                 mb_svc_debug("handle is NULL");
1854                 return MB_SVC_ERROR_DB_INTERNAL;
1855         }
1856
1857         query = sqlite3_mprintf(MB_SVC_TABLE_COUNT_BY_PATH_QUERY_STRING, table_name, path);
1858
1859         err = sqlite3_prepare_v2(handle, query, strlen(query), &stmt, NULL);
1860
1861         if (SQLITE_OK != err) {
1862                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
1863                 mb_svc_debug("query string is %s\n", query);
1864                 sqlite3_free(query);
1865                 return MB_SVC_ERROR_DB_INTERNAL;
1866         }
1867
1868         rc = sqlite3_step(stmt);
1869         while (rc == SQLITE_ROW) {
1870                 count = sqlite3_column_int(stmt, 0);
1871                 rc = sqlite3_step(stmt);
1872         }
1873
1874         sqlite3_finalize(stmt);
1875         sqlite3_free(query);
1876         mb_svc_debug("record count of table %s is %d\n", table_name, count);
1877
1878         if (count > 0) {
1879                 return MB_SVC_ERROR_NONE;
1880         } else {
1881                 return MB_SVC_ERROR_DB_NO_RECORD;
1882         }
1883 }
1884
1885 int
1886 mb_svc_geo_media_iter_start(MediaSvcHandle *mb_svc_handle,
1887                                 const char *folder_id,
1888                                 minfo_folder_type store_filter,
1889                                 minfo_item_filter *filter,
1890                                 mb_svc_iterator_s *mb_svc_iterator,
1891                                 double min_longitude,
1892                                 double max_longitude,
1893                                 double min_latitude, double max_latitude)
1894 {
1895         mb_svc_debug("");
1896
1897         int err = -1;
1898         char *table_name = MB_SVC_TBL_NAME_MEDIA;
1899         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
1900         char query_complete_string[MB_SVC_DEFAULT_QUERY_SIZE * 3 + 1] = { 0 };
1901         char query_where[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
1902         char tmp_str[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
1903
1904         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
1905         if (handle == NULL) {
1906                 mb_svc_debug("handle is NULL");
1907                 return MB_SVC_ERROR_DB_INTERNAL;
1908         }
1909         /* mb_svc_debug ("mb_svc_media_iter_start--enter\n"); */
1910
1911         if (mb_svc_iterator == NULL || filter == NULL) {
1912                 mb_svc_debug("Error:mb_svc_iterator == NULL || filter == NULL");
1913                 return MB_SVC_ERROR_INVALID_PARAMETER;
1914         }
1915         if (filter->start_pos >= 0 && filter->start_pos > filter->end_pos) {
1916                 mb_svc_debug(" filter->start_pos (%d) > filter->end_pos (%d) = %d\n",
1917                              filter->start_pos, filter->end_pos);
1918                 return MB_SVC_ERROR_INVALID_PARAMETER;
1919         }
1920         strncpy(query_where, "", MB_SVC_DEFAULT_QUERY_SIZE);
1921
1922         if (store_filter != MINFO_CLUSTER_TYPE_ALL) {
1923                 switch (store_filter) {
1924                 case MINFO_CLUSTER_TYPE_LOCAL_ALL:
1925                         snprintf(tmp_str, sizeof(tmp_str),
1926                                  " and (storage_type = %d or storage_type = %d)",
1927                                  MINFO_PHONE, MINFO_MMC);
1928                         break;
1929                 case MINFO_CLUSTER_TYPE_LOCAL_PHONE:
1930                         snprintf(tmp_str, sizeof(tmp_str),
1931                                  " and storage_type = %d ", MINFO_PHONE);
1932                         break;
1933                 case MINFO_CLUSTER_TYPE_LOCAL_MMC:
1934                         snprintf(tmp_str, sizeof(tmp_str),
1935                                  " and storage_type = %d ", MINFO_MMC);
1936                         break;
1937                 case MINFO_CLUSTER_TYPE_WEB:
1938                         snprintf(tmp_str, sizeof(tmp_str),
1939                                  " and storage_type = %d ", MINFO_WEB);
1940                         break;
1941                 case MINFO_CLUSTER_TYPE_STREAMING:
1942                         snprintf(tmp_str, sizeof(tmp_str),
1943                                  " and storage_type = %d ",
1944                                  MINFO_WEB_STREAMING);
1945                         break;
1946                 default:
1947                         break;
1948                 }
1949         }
1950
1951         snprintf(query_string, MB_SVC_DEFAULT_QUERY_SIZE + 1,
1952                  MB_SVC_TABLE_SELECT_GEO_LIST, table_name, min_longitude,
1953                  max_longitude, min_latitude, max_latitude, min_longitude,
1954                  max_longitude, min_latitude, max_latitude, tmp_str);
1955
1956         memset(tmp_str, 0x00, sizeof(tmp_str));
1957
1958         mb_svc_debug("Query string: %s", query_string);
1959
1960         if (filter->favorite == MINFO_MEDIA_FAV_ONLY) {
1961                 strncat(query_where, " and a.rating = 1",
1962                         MB_SVC_DEFAULT_QUERY_SIZE + 1);
1963         } else if (filter->favorite == MINFO_MEDIA_UNFAV_ONLY) {
1964                 strncat(query_where, " and a.rating = 0",
1965                         MB_SVC_DEFAULT_QUERY_SIZE + 1);
1966         }
1967
1968         /* set to get only unlocked items */
1969         strncat(query_where, " and b.lock_status = 0",
1970                 MB_SVC_DEFAULT_QUERY_SIZE + 1);
1971
1972         if (folder_id != NULL) {
1973                 snprintf(tmp_str, MB_SVC_DEFAULT_QUERY_SIZE + 1,
1974                          " and a.folder_uuid = '%s'", folder_id);
1975                 strncat(query_where, tmp_str, MB_SVC_DEFAULT_QUERY_SIZE + 1);
1976         }
1977
1978         snprintf(tmp_str, MB_SVC_DEFAULT_QUERY_SIZE + 1,
1979                  " and (a.content_type = 0");
1980         strncat(query_where, tmp_str, MB_SVC_DEFAULT_QUERY_SIZE + 1);
1981
1982         if (filter->file_type & MINFO_ITEM_ALL) {
1983                 filter->file_type = MINFO_ITEM_IMAGE | MINFO_ITEM_VIDEO;
1984         }
1985
1986         if (filter->file_type & MINFO_ITEM_IMAGE) {
1987                 snprintf(tmp_str, sizeof(tmp_str), " or a.content_type = %d",
1988                          MINFO_ITEM_IMAGE);
1989                 strncat(query_where, tmp_str, MB_SVC_DEFAULT_QUERY_SIZE + 1);
1990         }
1991
1992         if (filter->file_type & MINFO_ITEM_VIDEO) {
1993                 snprintf(tmp_str, sizeof(tmp_str), " or a.content_type = %d",
1994                          MINFO_ITEM_VIDEO);
1995                 strncat(query_where, tmp_str, MB_SVC_DEFAULT_QUERY_SIZE + 1);
1996         }
1997
1998         strncat(query_where, ")", MB_SVC_DEFAULT_QUERY_SIZE + 1);
1999
2000         if (filter->sort_type == MINFO_MEDIA_SORT_BY_NONE)
2001                 filter->sort_type = MINFO_MEDIA_SORT_BY_NAME_ASC;
2002
2003         snprintf(query_complete_string, MB_SVC_DEFAULT_QUERY_SIZE * 3 + 1,
2004                  "%s %s ORDER BY a.%s", query_string, query_where,
2005                  mb_svc_media_order[filter->sort_type]);
2006
2007         if (filter->start_pos != MB_SVC_DB_DEFAULT_GET_ALL_RECORDS) {   /* -1 get all record */
2008                 int length = filter->end_pos - filter->start_pos + 1;
2009                 if (length <= 0) {
2010                         mb_svc_debug
2011                             ("start position and end position is invalid ( start:%d, end:%d )",
2012                              filter->start_pos, filter->end_pos);
2013                         return MB_SVC_ERROR_INVALID_PARAMETER;
2014                 }
2015
2016                 snprintf(tmp_str, sizeof(tmp_str), " LIMIT %d,%d",
2017                          filter->start_pos, length);
2018                 strncat(query_complete_string, tmp_str,
2019                         sizeof(query_complete_string));
2020         }
2021
2022         mb_svc_debug("############### SQL: %s\n", query_complete_string);
2023
2024         mb_svc_iterator->current_position = 0;
2025
2026         err =
2027             sqlite3_prepare_v2(handle, query_complete_string,
2028                                strlen(query_complete_string),
2029                                &mb_svc_iterator->stmt, NULL);
2030         if (SQLITE_OK != err) {
2031                 mb_svc_debug("prepare error [%s]", sqlite3_errmsg(handle));
2032                 mb_svc_debug("query string is %s\n", query_complete_string);
2033                 return MB_SVC_ERROR_DB_INTERNAL;
2034         }
2035
2036         return err;
2037 }
2038
2039 int
2040 mb_svc_media_iter_start_new(MediaSvcHandle *mb_svc_handle,
2041                                 const char *folder_id,
2042                                 minfo_item_filter *filter,
2043                                 minfo_folder_type folder_type,
2044                                 int valid,
2045                                 GList *p_folder_id_list,
2046                                 mb_svc_iterator_s *mb_svc_iterator)
2047 {
2048         int err = -1;
2049         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
2050         char query_complete_string[MB_SVC_DEFAULT_QUERY_SIZE * 3 + 1] = { 0 };
2051         char query_where[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
2052         char condition_str[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
2053         int len = 0;
2054
2055         char table_name[MB_SVC_TABLE_NAME_MAX_LEN] = { 0, };
2056         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
2057         snprintf(table_name, MB_SVC_TABLE_NAME_MAX_LEN, "%s",
2058                  MB_SVC_TBL_NAME_MEDIA);
2059
2060         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
2061         if (handle == NULL) {
2062                 mb_svc_debug("handle is NULL");
2063                 return MB_SVC_ERROR_DB_INTERNAL;
2064         }
2065
2066         if (mb_svc_iterator == NULL || filter == NULL) {
2067                 mb_svc_debug("Error:mb_svc_iterator == NULL || filter == NULL");
2068                 return MB_SVC_ERROR_INVALID_PARAMETER;
2069         }
2070         if (filter->start_pos >= 0 && filter->start_pos > filter->end_pos) {
2071                 mb_svc_debug(" filter->start_pos (%d) > filter->end_pos (%d)",
2072                              filter->start_pos, filter->end_pos);
2073                 return MB_SVC_ERROR_INVALID_PARAMETER;
2074         }
2075
2076         snprintf(query_string, sizeof(query_string), MB_SVC_SELECT_ALL_MEDIA,
2077                  table_name);
2078
2079         if (valid) {
2080                 strncpy(query_where,
2081                         " f.folder_uuid = m.folder_uuid and m.valid=1 and f.valid=1 ",
2082                         sizeof(query_where));
2083         } else {
2084                 strncpy(query_where,
2085                         " f.folder_uuid = m.folder_uuid and m.valid=0 and f.valid=0 ",
2086                         sizeof(query_where));
2087         }
2088
2089         if (filter->favorite == MINFO_MEDIA_FAV_ONLY) {
2090                 len =
2091                     g_strlcat(query_where, " and m.rating = 1 ",
2092                               sizeof(query_where));
2093                 if (len >= sizeof(query_where)) {
2094                         mb_svc_debug("strlcat returns failure ( %d )", len);
2095                         return MB_SVC_ERROR_INVALID_PARAMETER;
2096                 }
2097         } else if (filter->favorite == MINFO_MEDIA_UNFAV_ONLY) {
2098                 len =
2099                     g_strlcat(query_where, " and m.rating = 0 ",
2100                               sizeof(query_where));
2101                 if (len >= sizeof(query_where)) {
2102                         mb_svc_debug("strlcat returns failure ( %d )", len);
2103                         return MB_SVC_ERROR_INVALID_PARAMETER;
2104                 }
2105         }
2106
2107         memset(condition_str, 0x00, sizeof(condition_str));
2108
2109         if (folder_id != NULL) {
2110                 int len =
2111                     snprintf(condition_str, sizeof(condition_str),
2112                              " and m.folder_uuid = '%s' ", folder_id);
2113                 if (len < 0) {
2114                         mb_svc_debug("snprintf returns failure ( %d )", len);
2115                         condition_str[0] = '\0';
2116                 } else {
2117                         condition_str[len] = '\0';
2118                 }
2119
2120                 len =
2121                     g_strlcat(query_where, condition_str, sizeof(query_where));
2122                 if (len >= sizeof(query_where)) {
2123                         mb_svc_debug("strlcat returns failure ( %d )", len);
2124                         return MB_SVC_ERROR_INVALID_PARAMETER;
2125                 }
2126         } else {
2127                 int len =
2128                     snprintf(condition_str, sizeof(condition_str),
2129                              " and lock_status = 0 ");
2130                 if (len < 0) {
2131                         mb_svc_debug("snprintf returns failure ( %d )", len);
2132                         condition_str[0] = '\0';
2133                 } else {
2134                         condition_str[len] = '\0';
2135                 }
2136
2137                 len =
2138                     g_strlcat(query_where, condition_str, sizeof(query_where));
2139                 if (len >= sizeof(query_where)) {
2140                         mb_svc_debug("strlcat returns failure ( %d )", len);
2141                         return MB_SVC_ERROR_INVALID_PARAMETER;
2142                 }
2143         }
2144
2145         memset(condition_str, 0x00, sizeof(condition_str));
2146
2147         if (folder_type != MINFO_CLUSTER_TYPE_ALL) {
2148                 switch (folder_type) {
2149                 case MINFO_CLUSTER_TYPE_LOCAL_ALL:
2150                         snprintf(condition_str, sizeof(condition_str),
2151                                  " and (storage_type = %d or storage_type = %d)",
2152                                  MINFO_PHONE, MINFO_MMC);
2153                         break;
2154                 case MINFO_CLUSTER_TYPE_LOCAL_PHONE:
2155                         snprintf(condition_str, sizeof(condition_str),
2156                                  " and storage_type = %d ", MINFO_PHONE);
2157                         break;
2158                 case MINFO_CLUSTER_TYPE_LOCAL_MMC:
2159                         snprintf(condition_str, sizeof(condition_str),
2160                                  " and storage_type = %d ", MINFO_MMC);
2161                         break;
2162                 case MINFO_CLUSTER_TYPE_WEB:
2163                         snprintf(condition_str, sizeof(condition_str),
2164                                  " and storage_type = %d ", MINFO_WEB);
2165                         break;
2166                 case MINFO_CLUSTER_TYPE_STREAMING:
2167                         snprintf(condition_str, sizeof(condition_str),
2168                                  " and storage_type = %d ",
2169                                  MINFO_WEB_STREAMING);
2170                         break;
2171                 default:
2172                         break;
2173                 }
2174
2175                 len =
2176                     g_strlcat(query_where, condition_str, sizeof(query_where));
2177                 if (len >= sizeof(query_where)) {
2178                         mb_svc_debug("strlcat returns failure ( %d )", len);
2179                         return MB_SVC_ERROR_INVALID_PARAMETER;
2180                 }
2181         }
2182
2183         memset(condition_str, 0x00, sizeof(condition_str));
2184         len =
2185             snprintf(condition_str, sizeof(condition_str),
2186                      " and (content_type = 0");
2187         if (len < 0) {
2188                 mb_svc_debug("snprintf returns failure ( %d )", len);
2189                 condition_str[0] = '\0';
2190         } else {
2191                 condition_str[len] = '\0';
2192         }
2193
2194         len = g_strlcat(query_where, condition_str, sizeof(query_where));
2195         if (len >= sizeof(query_where)) {
2196                 mb_svc_debug("strlcat returns failure ( %d )", len);
2197                 return MB_SVC_ERROR_INVALID_PARAMETER;
2198         }
2199
2200         memset(condition_str, 0x00, sizeof(condition_str));
2201         if (filter->file_type & MINFO_ITEM_ALL) {
2202                 filter->file_type = MINFO_ITEM_IMAGE | MINFO_ITEM_VIDEO;
2203         }
2204
2205         if (filter->file_type & MINFO_ITEM_IMAGE) {
2206                 len =
2207                     snprintf(condition_str, sizeof(condition_str),
2208                              " or content_type = %d", MINFO_ITEM_IMAGE);
2209                 if (len < 0) {
2210                         mb_svc_debug("snprintf returns failure ( %d )", len);
2211                         condition_str[0] = '\0';
2212                 } else {
2213                         condition_str[len] = '\0';
2214                 }
2215         }
2216
2217         len = g_strlcat(query_where, condition_str, sizeof(query_where));
2218         if (len >= sizeof(query_where)) {
2219                 mb_svc_debug("strlcat returns failure ( %d )", len);
2220                 return MB_SVC_ERROR_INVALID_PARAMETER;
2221         }
2222
2223         memset(condition_str, 0x00, sizeof(condition_str));
2224         if (filter->file_type & MINFO_ITEM_VIDEO) {
2225                 len =
2226                     snprintf(condition_str, sizeof(condition_str),
2227                              " or content_type = %d", MINFO_ITEM_VIDEO);
2228                 if (len < 0) {
2229                         mb_svc_debug("snprintf returns failure ( %d )", len);
2230                         condition_str[0] = '\0';
2231                 } else {
2232                         condition_str[len] = '\0';
2233                 }
2234         }
2235
2236         len = g_strlcat(condition_str, ")", sizeof(condition_str));
2237         if (len >= sizeof(condition_str)) {
2238                 mb_svc_debug("strlcat returns failure ( %d )", len);
2239                 return MB_SVC_ERROR_INVALID_PARAMETER;
2240         }
2241
2242         len = g_strlcat(query_where, condition_str, sizeof(query_where));
2243         if (len >= sizeof(query_where)) {
2244                 mb_svc_debug("strlcat returns failure ( %d )", len);
2245                 return MB_SVC_ERROR_INVALID_PARAMETER;
2246         }
2247
2248         len =
2249             snprintf(query_complete_string, sizeof(query_complete_string),
2250                      "%s %s ORDER BY m.%s", query_string, query_where,
2251                      mb_svc_media_order[filter->sort_type]);
2252         if (len < 0) {
2253                 mb_svc_debug("snprintf returns failure ( %d )", len);
2254                 query_complete_string[0] = '\0';
2255         } else {
2256                 query_complete_string[len] = '\0';
2257         }
2258
2259         memset(condition_str, 0x00, sizeof(condition_str));
2260
2261         if (filter->start_pos != MB_SVC_DB_DEFAULT_GET_ALL_RECORDS)     {/* -1 get all record */
2262                 int length = filter->end_pos - filter->start_pos + 1;
2263                 if (length <= 0) {
2264                         mb_svc_debug
2265                             ("start position and end position is invalid ( start:%d, end:%d )",
2266                              filter->start_pos, filter->end_pos);
2267                         return MB_SVC_ERROR_INVALID_PARAMETER;
2268                 }
2269
2270                 len =
2271                     snprintf(condition_str, sizeof(condition_str),
2272                              " LIMIT %d,%d", filter->start_pos, length);
2273                 if (len < 0) {
2274                         mb_svc_debug("snprintf returns failure ( %d )", len);
2275                         condition_str[0] = '\0';
2276                 } else {
2277                         condition_str[len] = '\0';
2278                 }
2279                 len =
2280                     g_strlcat(query_complete_string, condition_str,
2281                               sizeof(query_complete_string));
2282                 if (len >= sizeof(query_complete_string)) {
2283                         mb_svc_debug("strlcat returns failure ( %d )", len);
2284                         return MB_SVC_ERROR_INVALID_PARAMETER;
2285                 }
2286         }
2287
2288         mb_svc_debug("############### SQL: %s\n", query_complete_string);
2289
2290         mb_svc_iterator->current_position = 0;
2291
2292         err =
2293             sqlite3_prepare_v2(handle, query_complete_string,
2294                                strlen(query_complete_string),
2295                                &mb_svc_iterator->stmt, NULL);
2296         if (SQLITE_OK != err) {
2297                 mb_svc_debug("prepare error [%s]", sqlite3_errmsg(handle));
2298                 mb_svc_debug("query string is %s\n", query_complete_string);
2299                 return MB_SVC_ERROR_DB_INTERNAL;
2300         }
2301
2302         return err;
2303 }
2304
2305 int
2306 mb_svc_media_search_iter_start(MediaSvcHandle *mb_svc_handle,
2307                                                                 minfo_search_field_t search_field,
2308                                                                 const char *search_str,
2309                                                                 minfo_folder_type folder_type,
2310                                                                 minfo_item_filter filter,
2311                                                                 mb_svc_iterator_s *mb_svc_iterator)
2312 {
2313         int err = -1;
2314         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
2315         char query_complete_string[MB_SVC_DEFAULT_QUERY_SIZE * 3 + 1] = { 0 };
2316         char query_where[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
2317         char condition_str[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
2318         int len = 0;
2319         char *like_str = NULL;
2320         char *escaped_search_str = NULL;
2321         char table_name[MB_SVC_TABLE_NAME_MAX_LEN] = { 0, };
2322         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
2323         snprintf(table_name, MB_SVC_TABLE_NAME_MAX_LEN, "%s",
2324                  MB_SVC_TBL_NAME_MEDIA);
2325
2326         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
2327         if (handle == NULL) {
2328                 mb_svc_debug("handle is NULL");
2329                 return MB_SVC_ERROR_DB_INTERNAL;
2330         }
2331
2332         if (mb_svc_iterator == NULL) {
2333                 mb_svc_debug("Error:mb_svc_iterator == NULL");
2334                 return MB_SVC_ERROR_INVALID_PARAMETER;
2335         }
2336
2337         if (filter.start_pos >= 0 && filter.start_pos > filter.end_pos) {
2338                 mb_svc_debug(" filter.start_pos (%d) > filter.end_pos (%d) = %d\n",
2339                              filter.start_pos, filter.end_pos);
2340                 return MB_SVC_ERROR_INVALID_PARAMETER;
2341         }
2342
2343         snprintf(query_string, sizeof(query_string), MB_SVC_SELECT_ALL_MEDIA,
2344                  table_name);
2345
2346         strncpy(query_where,
2347                 " f.folder_uuid = m.folder_uuid and m.valid=1 and f.valid=1 ",
2348                 sizeof(query_where));
2349
2350         if (filter.favorite == MINFO_MEDIA_FAV_ONLY) {
2351                 len =
2352                     g_strlcat(query_where, " and m.rating = 1 ",
2353                               sizeof(query_where));
2354                 if (len >= sizeof(query_where)) {
2355                         mb_svc_debug("strlcat returns failure ( %d )", len);
2356                         return MB_SVC_ERROR_INVALID_PARAMETER;
2357                 }
2358         } else if (filter.favorite == MINFO_MEDIA_UNFAV_ONLY) {
2359                 len =
2360                     g_strlcat(query_where, " and m.rating = 0 ",
2361                               sizeof(query_where));
2362                 if (len >= sizeof(query_where)) {
2363                         mb_svc_debug("strlcat returns failure ( %d )", len);
2364                         return MB_SVC_ERROR_INVALID_PARAMETER;
2365                 }
2366         }
2367
2368         memset(condition_str, 0x00, sizeof(condition_str));
2369
2370         if (folder_type != MINFO_CLUSTER_TYPE_ALL) {
2371                 switch (folder_type) {
2372                 case MINFO_CLUSTER_TYPE_LOCAL_ALL:
2373                         snprintf(condition_str, sizeof(condition_str),
2374                                  " and (storage_type = %d or storage_type = %d)",
2375                                  MINFO_PHONE, MINFO_MMC);
2376                         break;
2377                 case MINFO_CLUSTER_TYPE_LOCAL_PHONE:
2378                         snprintf(condition_str, sizeof(condition_str),
2379                                  " and storage_type = %d ", MINFO_PHONE);
2380                         break;
2381                 case MINFO_CLUSTER_TYPE_LOCAL_MMC:
2382                         snprintf(condition_str, sizeof(condition_str),
2383                                  " and storage_type = %d ", MINFO_MMC);
2384                         break;
2385                 case MINFO_CLUSTER_TYPE_WEB:
2386                         snprintf(condition_str, sizeof(condition_str),
2387                                  " and storage_type = %d ", MINFO_WEB);
2388                         break;
2389                 case MINFO_CLUSTER_TYPE_STREAMING:
2390                         snprintf(condition_str, sizeof(condition_str),
2391                                  " and storage_type = %d ",
2392                                  MINFO_WEB_STREAMING);
2393                         break;
2394                 default:
2395                         break;
2396                 }
2397
2398                 len =
2399                     g_strlcat(query_where, condition_str, sizeof(query_where));
2400                 if (len >= sizeof(query_where)) {
2401                         mb_svc_debug("strlcat returns failure ( %d )", len);
2402                         return MB_SVC_ERROR_INVALID_PARAMETER;
2403                 }
2404         }
2405
2406         memset(condition_str, 0x00, sizeof(condition_str));
2407         len =
2408             snprintf(condition_str, sizeof(condition_str),
2409                      " and (content_type = 0");
2410         if (len < 0) {
2411                 mb_svc_debug("snprintf returns failure ( %d )", len);
2412                 condition_str[0] = '\0';
2413         } else {
2414                 condition_str[len] = '\0';
2415         }
2416
2417         len = g_strlcat(query_where, condition_str, sizeof(query_where));
2418         if (len >= sizeof(query_where)) {
2419                 mb_svc_debug("strlcat returns failure ( %d )", len);
2420                 return MB_SVC_ERROR_INVALID_PARAMETER;
2421         }
2422
2423         memset(condition_str, 0x00, sizeof(condition_str));
2424         if (filter.file_type & MINFO_ITEM_ALL) {
2425                 filter.file_type = MINFO_ITEM_IMAGE | MINFO_ITEM_VIDEO;
2426         }
2427
2428         if (filter.file_type & MINFO_ITEM_IMAGE) {
2429                 len =
2430                     snprintf(condition_str, sizeof(condition_str),
2431                              " or content_type = %d", MINFO_ITEM_IMAGE);
2432                 if (len < 0) {
2433                         mb_svc_debug("snprintf returns failure ( %d )", len);
2434                         condition_str[0] = '\0';
2435                 } else {
2436                         condition_str[len] = '\0';
2437                 }
2438         }
2439
2440         len = g_strlcat(query_where, condition_str, sizeof(query_where));
2441         if (len >= sizeof(query_where)) {
2442                 mb_svc_debug("strlcat returns failure ( %d )", len);
2443                 return MB_SVC_ERROR_INVALID_PARAMETER;
2444         }
2445
2446         memset(condition_str, 0x00, sizeof(condition_str));
2447         if (filter.file_type & MINFO_ITEM_VIDEO) {
2448                 len =
2449                     snprintf(condition_str, sizeof(condition_str),
2450                              " or content_type = %d", MINFO_ITEM_VIDEO);
2451                 if (len < 0) {
2452                         mb_svc_debug("snprintf returns failure ( %d )", len);
2453                         condition_str[0] = '\0';
2454                 } else {
2455                         condition_str[len] = '\0';
2456                 }
2457         }
2458
2459         len = g_strlcat(condition_str, ") ", sizeof(condition_str));
2460         if (len >= sizeof(condition_str)) {
2461                 mb_svc_debug("strlcat returns failure ( %d )", len);
2462                 return MB_SVC_ERROR_INVALID_PARAMETER;
2463         }
2464
2465         len = g_strlcat(query_where, condition_str, sizeof(query_where));
2466         if (len >= sizeof(query_where)) {
2467                 mb_svc_debug("strlcat returns failure ( %d )", len);
2468                 return MB_SVC_ERROR_INVALID_PARAMETER;
2469         }
2470 /*
2471         switch (search_field) {
2472                 case MINFO_SEARCH_BY_NAME:
2473                         like_str = sqlite3_mprintf("and display_name like '%%%s%%' ", search_str);
2474                         break;
2475                 case MINFO_SEARCH_BY_PATH:
2476                         like_str = sqlite3_mprintf("and path like '%%%s%%' ", search_str);
2477                         break;
2478                 case MINFO_SEARCH_BY_HTTP_URL:
2479                         like_str = sqlite3_mprintf("and http_url like '%%%s%%' ", search_str);
2480                         break;
2481                 default:
2482                         break;
2483         }
2484 */
2485 /*
2486         if (search_field & MINFO_SEARCH_BY_NAME) {
2487                 like_str = sqlite3_mprintf("and (display_name like '%%%q%%' ", search_str);
2488
2489                 len = g_strlcat(query_where, like_str, sizeof(query_where));
2490                 sqlite3_free(like_str);
2491
2492                 if (len >= sizeof(query_where)) {
2493                         mb_svc_debug("strlcat returns failure ( %d )", len);
2494                         return MB_SVC_ERROR_INVALID_PARAMETER;
2495                 }
2496         }
2497
2498         if (search_field & MINFO_SEARCH_BY_PATH) {
2499                 if (search_field & MINFO_SEARCH_BY_NAME) {
2500                         like_str = sqlite3_mprintf("or m.path like '%%%q%%' ", search_str);
2501                 } else {
2502                         like_str = sqlite3_mprintf("and (m.path like '%%%q%%' ", search_str);
2503                 }
2504
2505                 len = g_strlcat(query_where, like_str, sizeof(query_where));
2506                 sqlite3_free(like_str);
2507
2508                 if (len >= sizeof(query_where)) {
2509                         mb_svc_debug("strlcat returns failure ( %d )", len);
2510                         return MB_SVC_ERROR_INVALID_PARAMETER;
2511                 }
2512         }
2513
2514         if (search_field & MINFO_SEARCH_BY_HTTP_URL) {
2515                 if ((search_field & MINFO_SEARCH_BY_NAME) || (search_field & MINFO_SEARCH_BY_PATH)) {
2516                         like_str = sqlite3_mprintf("or http_url like '%%%q%%' ", search_str);
2517                 } else {
2518                         like_str = sqlite3_mprintf("and (http_url like '%%%q%%' ", search_str);
2519                 }
2520
2521                 len = g_strlcat(query_where, like_str, sizeof(query_where));
2522                 sqlite3_free(like_str);
2523
2524                 if (len >= sizeof(query_where)) {
2525                         mb_svc_debug("strlcat returns failure ( %d )", len);
2526                         return MB_SVC_ERROR_INVALID_PARAMETER;
2527                 }
2528         }
2529 */
2530         escaped_search_str = _media_svc_escape_str((char *)search_str, strlen(search_str));
2531         if (escaped_search_str == NULL) {
2532                 mb_svc_debug("Failed to escape");
2533                 return MB_SVC_ERROR_INVALID_PARAMETER;
2534         }
2535
2536         if (search_field & MINFO_SEARCH_BY_NAME) {
2537                 like_str = sqlite3_mprintf("and (display_name like '%%%q%%' ESCAPE('#') ", escaped_search_str);
2538
2539                 len = g_strlcat(query_where, like_str, sizeof(query_where));
2540                 sqlite3_free(like_str);
2541
2542                 if (len >= sizeof(query_where)) {
2543                         mb_svc_debug("strlcat returns failure ( %d )", len);
2544                         return MB_SVC_ERROR_INVALID_PARAMETER;
2545                 }
2546         }
2547
2548         if (search_field & MINFO_SEARCH_BY_PATH) {
2549                 if (search_field & MINFO_SEARCH_BY_NAME) {
2550                         like_str = sqlite3_mprintf("or m.path like '%%%q%%' ESCAPE('#') ", escaped_search_str);
2551                 } else {
2552                         like_str = sqlite3_mprintf("and (m.path like '%%%q%%' ESCAPE('#') ", escaped_search_str);
2553                 }
2554
2555                 len = g_strlcat(query_where, like_str, sizeof(query_where));
2556                 sqlite3_free(like_str);
2557
2558                 if (len >= sizeof(query_where)) {
2559                         mb_svc_debug("strlcat returns failure ( %d )", len);
2560                         return MB_SVC_ERROR_INVALID_PARAMETER;
2561                 }
2562         }
2563
2564         if (search_field & MINFO_SEARCH_BY_HTTP_URL) {
2565                 if ((search_field & MINFO_SEARCH_BY_NAME) || (search_field & MINFO_SEARCH_BY_PATH)) {
2566                         like_str = sqlite3_mprintf("or http_url like '%%%q%%' ESCAPE('#') ", escaped_search_str);
2567                 } else {
2568                         like_str = sqlite3_mprintf("and (http_url like '%%%q%%' ESCAPE('#') ", escaped_search_str);
2569                 }
2570
2571                 len = g_strlcat(query_where, like_str, sizeof(query_where));
2572                 sqlite3_free(like_str);
2573
2574                 if (len >= sizeof(query_where)) {
2575                         mb_svc_debug("strlcat returns failure ( %d )", len);
2576                         return MB_SVC_ERROR_INVALID_PARAMETER;
2577                 }
2578         }
2579
2580         if (escaped_search_str) free(escaped_search_str);
2581
2582         len = g_strlcat(query_where, ") ", sizeof(query_where));
2583
2584         if (len >= sizeof(query_where)) {
2585                 mb_svc_debug("strlcat returns failure ( %d )", len);
2586                 return MB_SVC_ERROR_INVALID_PARAMETER;
2587         }
2588
2589         len =
2590             snprintf(query_complete_string, sizeof(query_complete_string),
2591                      "%s %s ORDER BY m.%s", query_string, query_where,
2592                      mb_svc_media_order[filter.sort_type]);
2593         if (len < 0) {
2594                 mb_svc_debug("snprintf returns failure ( %d )", len);
2595                 query_complete_string[0] = '\0';
2596         } else {
2597                 query_complete_string[len] = '\0';
2598         }
2599
2600         memset(condition_str, 0x00, sizeof(condition_str));
2601
2602         if (filter.start_pos != MB_SVC_DB_DEFAULT_GET_ALL_RECORDS)      {/* -1 get all record */
2603                 int length = filter.end_pos - filter.start_pos + 1;
2604                 if (length <= 0) {
2605                         mb_svc_debug
2606                             ("start position and end position is invalid ( start:%d, end:%d )",
2607                              filter.start_pos, filter.end_pos);
2608                         return MB_SVC_ERROR_INVALID_PARAMETER;
2609                 }
2610
2611                 len =
2612                     snprintf(condition_str, sizeof(condition_str),
2613                              " LIMIT %d,%d", filter.start_pos, length);
2614                 if (len < 0) {
2615                         mb_svc_debug("snprintf returns failure ( %d )", len);
2616                         condition_str[0] = '\0';
2617                 } else {
2618                         condition_str[len] = '\0';
2619                 }
2620                 len =
2621                     g_strlcat(query_complete_string, condition_str,
2622                               sizeof(query_complete_string));
2623                 if (len >= sizeof(query_complete_string)) {
2624                         mb_svc_debug("strlcat returns failure ( %d )", len);
2625                         return MB_SVC_ERROR_INVALID_PARAMETER;
2626                 }
2627         }
2628
2629         mb_svc_debug("############### SQL: %s\n", query_complete_string);
2630
2631         mb_svc_iterator->current_position = 0;
2632
2633         err =
2634             sqlite3_prepare_v2(handle, query_complete_string,
2635                                strlen(query_complete_string),
2636                                &mb_svc_iterator->stmt, NULL);
2637         if (SQLITE_OK != err) {
2638                 mb_svc_debug("prepare error [%s]", sqlite3_errmsg(handle));
2639                 mb_svc_debug("query string is %s\n", query_complete_string);
2640                 return MB_SVC_ERROR_DB_INTERNAL;
2641         }
2642
2643         return err;
2644 }
2645
2646 int
2647 mb_svc_media_iter_next(mb_svc_iterator_s *mb_svc_iterator,
2648                        mb_svc_media_record_s *record)
2649 {
2650         int err = -1;
2651
2652         /* mb_svc_debug ("mb_svc_media_iter_next--enter\n"); */
2653
2654         if (mb_svc_iterator == NULL) {
2655                 mb_svc_debug("mb_svc_iterator == NULL || record == NULL\n");
2656                 return MB_SVC_ERROR_INVALID_PARAMETER;
2657         }
2658
2659         err = sqlite3_step(mb_svc_iterator->stmt);
2660         if (err != SQLITE_ROW) {
2661                 mb_svc_debug("end of iteration : count = %d\n",
2662                              mb_svc_iterator->current_position);
2663                 return MB_SVC_NO_RECORD_ANY_MORE;
2664         }
2665
2666         if (record) {
2667                 err = mb_svc_load_record_media(mb_svc_iterator->stmt, record);
2668                 if (err < 0) {
2669                         mb_svc_debug("failed to load item\n");
2670                         sqlite3_finalize(mb_svc_iterator->stmt);
2671                         mb_svc_iterator->current_position = -1;
2672                         return MB_SVC_ERROR_DB_INTERNAL;
2673                 }
2674         }
2675         mb_svc_iterator->current_position++;
2676
2677         return 0;
2678 }
2679
2680 int mb_svc_iter_finish(mb_svc_iterator_s *mb_svc_iterator)
2681 {
2682         int err = -1;
2683
2684         /* mb_svc_debug ("mb_svc_iter_finish---enter\n"); */
2685
2686         if (mb_svc_iterator == NULL) {
2687                 mb_svc_debug("Error:mb_svc_iterator == NULL \n");
2688                 return MB_SVC_ERROR_INVALID_PARAMETER;
2689         }
2690
2691         err = sqlite3_finalize(mb_svc_iterator->stmt);
2692         if (SQLITE_OK != err) {
2693                 mb_svc_debug("failed to clear row\n");
2694                 return MB_SVC_ERROR_DB_INTERNAL;
2695         }
2696
2697         mb_svc_iterator->current_position = -1;
2698         mb_svc_iterator->total_count = -1;
2699         mb_svc_iterator->stmt = NULL;
2700
2701         /* mb_svc_debug ("mb_svc_iter_finish---leave\n"); */
2702         return 0;
2703 }
2704
2705 int
2706 mb_svc_get_video_record_by_media_id(MediaSvcHandle *mb_svc_handle,
2707                                         const char *media_id,
2708                                         mb_svc_video_meta_record_s *
2709                                         video_meta_record)
2710 {
2711
2712         int err = -1;
2713         char *table_name = MB_SVC_TBL_NAME_VIDEO_META;
2714         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
2715         sqlite3_stmt *p_Stmt_mb = NULL;
2716
2717         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
2718         if (handle == NULL) {
2719                 mb_svc_debug("handle is NULL");
2720                 return MB_SVC_ERROR_DB_INTERNAL;
2721         }
2722
2723         if (video_meta_record == NULL) {
2724                 mb_svc_debug("folder path is null \n");
2725                 return MB_SVC_ERROR_INVALID_PARAMETER;
2726         }
2727
2728         snprintf(query_string, sizeof(query_string),
2729                  MB_SVC_TABLE_SELECT_VIDEO_BY_MUUID, table_name,
2730                  media_id);
2731
2732         mb_svc_debug("Query: %s", query_string);
2733
2734         err =
2735             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
2736                                &p_Stmt_mb, NULL);
2737         if (SQLITE_OK != err) {
2738                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
2739                 return MB_SVC_ERROR_DB_INTERNAL;
2740         }
2741         err = sqlite3_step(p_Stmt_mb);
2742         if (err != SQLITE_ROW) {
2743                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
2744                 sqlite3_finalize(p_Stmt_mb);
2745                 return MB_SVC_ERROR_DB_INTERNAL;
2746         }
2747         mb_svc_load_record_video_meta(p_Stmt_mb, video_meta_record);
2748
2749         sqlite3_finalize(p_Stmt_mb);
2750
2751         return 0;
2752
2753 }
2754
2755 /*
2756 *
2757 *   get video by media_id from "video_meta" table,
2758 *   condition: each video_meta record mapped to  media_id one by one
2759 */
2760 int
2761 mb_svc_get_image_record_by_media_id(MediaSvcHandle *mb_svc_handle,
2762                                         const char *media_id,
2763                                         mb_svc_image_meta_record_s *
2764                                         image_meta_record)
2765 {
2766
2767         int err = -1;
2768         char *table_name = MB_SVC_TBL_NAME_IMAGE_META;
2769         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
2770         sqlite3_stmt *stmt = NULL;
2771
2772         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
2773         if (handle == NULL) {
2774                 mb_svc_debug("handle is NULL");
2775                 return MB_SVC_ERROR_DB_INTERNAL;
2776         }
2777
2778         if (image_meta_record == NULL) {
2779                 mb_svc_debug("folder path is null \n");
2780                 return MB_SVC_ERROR_INVALID_PARAMETER;
2781         }
2782
2783         snprintf(query_string, sizeof(query_string),
2784                  MB_SVC_TABLE_SELECT_IMAGE_BY_MUUID, table_name,
2785                  media_id);
2786
2787         mb_svc_debug("Query: %s", query_string);
2788
2789         err =
2790             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
2791                                &stmt, NULL);
2792         if (SQLITE_OK != err) {
2793                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
2794                 return MB_SVC_ERROR_DB_INTERNAL;
2795         }
2796         err = sqlite3_step(stmt);
2797         if (err != SQLITE_ROW) {
2798                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
2799                 sqlite3_finalize(stmt);
2800                 return MB_SVC_ERROR_DB_INTERNAL;
2801         }
2802         mb_svc_load_record_image_meta(stmt, image_meta_record);
2803
2804         sqlite3_finalize(stmt);
2805
2806         return 0;
2807
2808 }
2809
2810 int
2811 mb_svc_get_folder_fullpath_by_folder_id(MediaSvcHandle *mb_svc_handle, const char *folder_id, char *folder_fullpath,
2812                                         int max_length)
2813 {
2814         int err = -1;
2815         char *table_name = MB_SVC_TBL_NAME_FOLDER;
2816         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
2817         sqlite3_stmt *stmt = NULL;
2818         char uri[MB_SVC_DIR_PATH_LEN_MAX + 1] = { 0 };
2819         int ret_len = 0;
2820         char *tmp = NULL;
2821
2822         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
2823         if (handle == NULL) {
2824                 mb_svc_debug("handle is NULL");
2825                 return MB_SVC_ERROR_DB_INTERNAL;
2826         }
2827
2828         if (folder_fullpath == NULL) {
2829                 mb_svc_debug("folder path is null \n");
2830                 return MB_SVC_ERROR_INVALID_PARAMETER;
2831         }
2832
2833         ret_len =
2834             snprintf(query_string, sizeof(query_string),
2835                      MB_SVC_TABLE_SELECT_FOLDER_URI_BY_FUUID,
2836                      table_name, folder_id);
2837
2838         if (ret_len >= sizeof(query_string)) {
2839                 mb_svc_debug("the query string's length is violation!\n");
2840                 return MB_SVC_ERROR_INTERNAL;
2841         } else if (ret_len < 0) {
2842                 mb_svc_debug("snprintf failed!\n");
2843                 return MB_SVC_ERROR_INTERNAL;
2844         }
2845
2846         mb_svc_debug("Query : %s", query_string);
2847
2848         err =
2849             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
2850                                &stmt, NULL);
2851         if (SQLITE_OK != err) {
2852                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
2853                 mb_svc_debug("query string is %s\n", query_string);
2854                 return MB_SVC_ERROR_DB_INTERNAL;
2855         }
2856         err = sqlite3_step(stmt);
2857         if (err != SQLITE_ROW) {
2858                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
2859                 sqlite3_finalize(stmt);
2860                 return MB_SVC_ERROR_DB_INTERNAL;
2861         }
2862
2863         /* only one field(uri) selected, so the second para of *_text is int 0, means the first one of the selected result. */
2864         tmp = (char *)sqlite3_column_text(stmt, 0);
2865         if (strlen(tmp) >= sizeof(uri)) {
2866                 mb_svc_debug("real uri's length is violation!\n");
2867                 return MB_SVC_ERROR_INTERNAL;
2868         }
2869
2870         strncpy(uri, (const char *)tmp, sizeof(uri));   /* get path of folder */
2871         strncpy(folder_fullpath, uri, max_length);
2872         mb_svc_debug("Full path : %s", folder_fullpath);
2873
2874         sqlite3_finalize(stmt);
2875
2876         return 0;
2877 }
2878
2879 int
2880 mb_svc_get_media_fullpath(MediaSvcHandle *mb_svc_handle, const char *folder_id, char *media_display_name,
2881                           char *media_fullpath)
2882 {
2883         int err = -1;
2884         char folder_fullpath[MB_SVC_DIR_PATH_LEN_MAX + 1] = { 0 };
2885
2886         if (media_display_name == NULL || media_fullpath == NULL) {
2887                 mb_svc_debug("Error: NULL pointer  \n");
2888                 return MB_SVC_ERROR_INVALID_PARAMETER;
2889         }
2890         err =
2891             mb_svc_get_folder_fullpath_by_folder_id(mb_svc_handle, folder_id, folder_fullpath,
2892                                                     sizeof(folder_fullpath));
2893         if (err < 0) {
2894                 mb_svc_debug("get folder fullpath error\n");
2895                 return err;
2896         }
2897
2898         strncat(folder_fullpath, "/",
2899                 MB_SVC_FILE_PATH_LEN_MAX - strlen(folder_fullpath));
2900         strncat(folder_fullpath, media_display_name,
2901                 MB_SVC_FILE_PATH_LEN_MAX - strlen(folder_fullpath));
2902         strncpy(media_fullpath, folder_fullpath, MB_SVC_FILE_PATH_LEN_MAX);
2903
2904         return 0;
2905 }
2906
2907 int
2908 mb_svc_folder_iter_start(MediaSvcHandle *mb_svc_handle, minfo_cluster_filter *cluster_filter,
2909                          mb_svc_iterator_s *mb_svc_iterator)
2910 {
2911         int err = -1;
2912         char *table_name = MB_SVC_TBL_NAME_FOLDER;
2913         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
2914         char query_where[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
2915         char tmp_str[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
2916
2917         mb_svc_debug("mb_svc_folder_iter_start--enter\n");
2918
2919         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
2920         if (handle == NULL) {
2921                 mb_svc_debug("handle is NULL");
2922                 return MB_SVC_ERROR_DB_INTERNAL;
2923         }
2924
2925         if (cluster_filter == NULL || mb_svc_iterator == NULL) {
2926                 mb_svc_debug
2927                     ("cluster_filter == NULL || mb_svc_iterator == NULL\n");
2928                 return MB_SVC_ERROR_INVALID_PARAMETER;
2929         }
2930
2931         if (cluster_filter->start_pos >= 0
2932             && cluster_filter->start_pos > cluster_filter->end_pos) {
2933                 mb_svc_debug(" cluster_filter->start_pos (%d) > cluster_filter->end_pos (%d) = %d\n",
2934                              cluster_filter->start_pos, cluster_filter->end_pos);
2935                 return MB_SVC_ERROR_INVALID_PARAMETER;
2936         }
2937         strncpy(query_where, " WHERE valid = 1 ", MB_SVC_DEFAULT_QUERY_SIZE);
2938
2939         snprintf(query_string, MB_SVC_DEFAULT_QUERY_SIZE,
2940                  MB_SVC_TABLE_SELECT_FOLDER_ALL_QUERY_STRING, table_name);
2941
2942         if (cluster_filter->cluster_type != MINFO_CLUSTER_TYPE_ALL) {
2943                 switch (cluster_filter->cluster_type) {
2944                 case MINFO_CLUSTER_TYPE_LOCAL_ALL:
2945                         snprintf(tmp_str, sizeof(tmp_str),
2946                                  " and (storage_type = %d or storage_type = %d)",
2947                                  MINFO_PHONE, MINFO_MMC);
2948                         break;
2949                 case MINFO_CLUSTER_TYPE_LOCAL_PHONE:
2950                         snprintf(tmp_str, sizeof(tmp_str),
2951                                  " and storage_type = %d ", MINFO_PHONE);
2952                         break;
2953                 case MINFO_CLUSTER_TYPE_LOCAL_MMC:
2954                         snprintf(tmp_str, sizeof(tmp_str),
2955                                  " and storage_type = %d ", MINFO_MMC);
2956                         break;
2957                 case MINFO_CLUSTER_TYPE_WEB:
2958                         snprintf(tmp_str, sizeof(tmp_str),
2959                                  " and storage_type = %d ", MINFO_WEB);
2960                         break;
2961                 case MINFO_CLUSTER_TYPE_STREAMING:
2962                         snprintf(tmp_str, sizeof(tmp_str),
2963                                  " and storage_type = %d ",
2964                                  MINFO_WEB_STREAMING);
2965                         break;
2966                 default:
2967                         break;
2968                 }
2969                 strncat(query_where, tmp_str,
2970                         MB_SVC_DEFAULT_QUERY_SIZE - strlen(tmp_str));
2971         }
2972         strncat(query_string, query_where,
2973                 MB_SVC_DEFAULT_QUERY_SIZE - strlen(query_string));
2974         strncat(query_string, " ORDER BY ",
2975                 MB_SVC_DEFAULT_QUERY_SIZE - strlen(query_string));
2976         strncat(query_string, mb_svc_folder_order[cluster_filter->sort_type],
2977                 MB_SVC_DEFAULT_QUERY_SIZE - strlen(query_string));
2978
2979         if (cluster_filter->start_pos != MB_SVC_DB_DEFAULT_GET_ALL_RECORDS)     {/* -1 get all record */
2980                 int length =
2981                     cluster_filter->end_pos - cluster_filter->start_pos + 1;
2982                 if (length <= 0) {
2983                         mb_svc_debug
2984                             ("start position and end position is invalid ( start:%d, end:%d )",
2985                              cluster_filter->start_pos,
2986                              cluster_filter->end_pos);
2987                         return MB_SVC_ERROR_INVALID_PARAMETER;
2988                 }
2989
2990                 snprintf(tmp_str, sizeof(tmp_str), " LIMIT %d,%d",
2991                          cluster_filter->start_pos, length);
2992                 strcat(query_string, tmp_str);
2993         }
2994
2995         mb_svc_debug("############### SQL: %s\n", query_string);
2996
2997         mb_svc_iterator->current_position = 0;
2998
2999         err =
3000             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
3001                                &mb_svc_iterator->stmt, NULL);
3002         if (SQLITE_OK != err) {
3003                 mb_svc_debug("prepare error [%s]", sqlite3_errmsg(handle));
3004                 mb_svc_debug("query string is %s\n", query_string);
3005                 return MB_SVC_ERROR_DB_INTERNAL;
3006         }
3007
3008         return err;
3009 }
3010
3011 static int __mb_svc_folder_by_path_iter_start(MediaSvcHandle *mb_svc_handle, char *parent_path, mb_svc_iterator_s *mb_svc_iterator)
3012 {
3013         mb_svc_debug("");
3014
3015         if (parent_path == NULL || mb_svc_iterator == NULL) {
3016                 mb_svc_debug("parent_path == NULL || mb_svc_iterator == NULL");
3017                 return MB_SVC_ERROR_INVALID_PARAMETER;
3018         }
3019
3020         int err = -1;
3021         char *query_string = NULL;
3022         char path_like[MB_SVC_FILE_PATH_LEN_MAX + 1];
3023
3024         char table_name[MB_SVC_TABLE_NAME_MAX_LEN] = { 0, };
3025         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
3026         snprintf(table_name, MB_SVC_TABLE_NAME_MAX_LEN, "%s",
3027                  MB_SVC_TBL_NAME_FOLDER);
3028         snprintf(path_like, sizeof(path_like), "%s/%%", parent_path);
3029
3030         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
3031         if (handle == NULL) {
3032                 mb_svc_debug("handle is NULL");
3033                 return MB_SVC_ERROR_DB_INTERNAL;
3034         }
3035
3036         query_string =
3037             sqlite3_mprintf(MB_SVC_SELECT_FOLDER_BY_PATH, table_name,
3038                             parent_path, path_like);
3039         mb_svc_debug("############### SQL: %s\n", query_string);
3040
3041         mb_svc_iterator->current_position = 0;
3042
3043         err =
3044             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
3045                                &mb_svc_iterator->stmt, NULL);
3046         if (SQLITE_OK != err) {
3047                 mb_svc_debug("prepare error [%s]", sqlite3_errmsg(handle));
3048                 mb_svc_debug("query string is %s\n", query_string);
3049                 return MB_SVC_ERROR_DB_INTERNAL;
3050         }
3051
3052         return err;
3053 }
3054
3055 int
3056 mb_svc_folder_iter_next(mb_svc_iterator_s *mb_svc_iterator,
3057                         mb_svc_folder_record_s *record)
3058 {
3059         int err = -1;
3060
3061         if (mb_svc_iterator == NULL) {
3062                 mb_svc_debug("pointer mb_svc_iterator is null\n");
3063                 return MB_SVC_ERROR_INVALID_PARAMETER;
3064         }
3065
3066         err = sqlite3_step(mb_svc_iterator->stmt);
3067         if (err != SQLITE_ROW) {
3068                 mb_svc_debug("end of iteration : count = %d\n",
3069                              mb_svc_iterator->current_position);
3070                 return MB_SVC_NO_RECORD_ANY_MORE;
3071         }
3072
3073         if (record) {
3074                 err = mb_svc_load_record_folder(mb_svc_iterator->stmt, record);
3075                 if (err < 0) {
3076                         mb_svc_debug("failed to load item\n");
3077                         sqlite3_finalize(mb_svc_iterator->stmt);
3078                         mb_svc_iterator->current_position = -1;
3079                         return MB_SVC_ERROR_DB_INTERNAL;
3080                 }
3081         }
3082
3083         mb_svc_iterator->current_position++;
3084
3085         return 0;
3086 }
3087
3088 /*
3089 *
3090 * get folder content count from media table according to specified folder ID
3091 */
3092 int mb_svc_get_folder_content_count_by_folder_id(MediaSvcHandle *mb_svc_handle, const char *folder_id)
3093 {
3094         char q_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
3095         int rc = 0;
3096         sqlite3_stmt *stmt = NULL;
3097         int count = 0;
3098         int err = -1;
3099
3100         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
3101         if (handle == NULL) {
3102                 mb_svc_debug("handle is NULL");
3103                 return MB_SVC_ERROR_DB_INTERNAL;
3104         }
3105
3106         char table_name[MB_SVC_TABLE_NAME_MAX_LEN] = { 0, };
3107         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
3108
3109
3110         snprintf(table_name, MB_SVC_TABLE_NAME_MAX_LEN, "%s",
3111                  MB_SVC_TBL_NAME_MEDIA);
3112
3113         snprintf(q_string, sizeof(q_string),
3114                  MB_SVC_FOLDER_CONTENT_COUNT_BY_FUUID, table_name,
3115                  folder_id);
3116
3117         mb_svc_debug("Query : %s", q_string);
3118
3119         err =
3120             sqlite3_prepare_v2(handle, q_string, strlen(q_string), &stmt, NULL);
3121         if (SQLITE_OK != err) {
3122                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
3123                 mb_svc_debug("query string is %s\n", q_string);
3124                 return MB_SVC_ERROR_DB_INTERNAL;
3125         }
3126
3127         rc = sqlite3_step(stmt);
3128         while (rc == SQLITE_ROW) {
3129                 count = sqlite3_column_int(stmt, 0);
3130                 rc = sqlite3_step(stmt);
3131         }
3132         sqlite3_finalize(stmt);
3133
3134         stmt = NULL;
3135         mb_svc_debug("record count of table %s is %d\n", table_name, count);
3136         return count;
3137 }
3138
3139 /**
3140 *   caller need to provide memory space for storing bookmark_record
3141 */
3142 int
3143 mb_svc_get_bookmark_record_by_id(MediaSvcHandle *mb_svc_handle,
3144                                 int record_id,
3145                                 mb_svc_bookmark_record_s *record)
3146 {
3147         sqlite3_stmt *stmt = NULL;
3148         int err = -1;
3149         char *table_name = MB_SVC_TBL_NAME_BOOKMARK;
3150         char q_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
3151
3152         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
3153         if (handle == NULL) {
3154                 mb_svc_debug("handle is NULL");
3155                 return MB_SVC_ERROR_DB_INTERNAL;
3156         }
3157
3158         if (record == NULL) {
3159                 mb_svc_debug(" record pointer is null\n");
3160                 return MB_SVC_ERROR_INVALID_PARAMETER;
3161         }
3162
3163         int len =
3164             snprintf(q_string, sizeof(q_string),
3165                      MB_SVC_TABLE_SELECT_BOOKMARK_BY_BID_QUERY_STRING,
3166                      table_name, record_id);
3167         if (len < 0) {
3168                 mb_svc_debug("snprintf returns failure ( %d )", len);
3169                 q_string[0] = '\0';
3170         } else {
3171                 q_string[len] = '\0';
3172         }
3173
3174         mb_svc_debug("Query: %s", q_string);
3175
3176         err =
3177             sqlite3_prepare_v2(handle, q_string, strlen(q_string), &stmt, NULL);
3178         if (SQLITE_OK != err) {
3179                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
3180                 mb_svc_debug("query string is %s\n", q_string);
3181                 return MB_SVC_ERROR_DB_INTERNAL;
3182         }
3183         err = sqlite3_step(stmt);
3184         if (err != SQLITE_ROW) {
3185                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
3186                 mb_svc_debug("query string is %s\n", q_string);
3187                 sqlite3_finalize(stmt);
3188                 return MB_SVC_ERROR_DB_INTERNAL;
3189         }
3190         mb_svc_load_record_bookmark(stmt, record);
3191         mb_svc_debug(" bookmark record thumbnail path = %s\n",
3192                      record->thumbnail_path);
3193
3194         sqlite3_finalize(stmt);
3195         stmt = NULL;
3196
3197         return 0;
3198 }
3199
3200 /**
3201 *   caller need to provide memory space for storing bookmark_record
3202 */
3203 int mb_svc_get_media_tag_by_id(MediaSvcHandle *mb_svc_handle, int _id, mb_svc_tag_record_s *mtag_record)
3204 {
3205         sqlite3_stmt *stmt = NULL;
3206         int err = -1;
3207         char *table_name = MB_SVC_TBL_NAME_TAG;
3208         char q_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
3209
3210         if (mtag_record == NULL) {
3211                 mb_svc_debug(" record pointer is null\n");
3212                 return MB_SVC_ERROR_INVALID_PARAMETER;
3213         }
3214
3215         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
3216         if (handle == NULL) {
3217                 mb_svc_debug("handle is NULL");
3218                 return MB_SVC_ERROR_DB_INTERNAL;
3219         }
3220
3221         snprintf(q_string, sizeof(q_string),
3222                  MB_SVC_TABLE_SELECT_TAG_BY_TID_QUERY_STRING, table_name, _id);
3223         mb_svc_debug("Query: %s", q_string);
3224
3225         err =
3226             sqlite3_prepare_v2(handle, q_string, strlen(q_string), &stmt, NULL);
3227         if (SQLITE_OK != err) {
3228                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
3229                 mb_svc_debug("query string is %s\n", q_string);
3230                 return MB_SVC_ERROR_DB_INTERNAL;
3231         }
3232         err = sqlite3_step(stmt);
3233         if (err != SQLITE_ROW) {
3234                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
3235                 mb_svc_debug("query string is %s\n", q_string);
3236                 sqlite3_finalize(stmt);
3237                 return MB_SVC_ERROR_DB_INTERNAL;
3238         }
3239         mb_svc_load_record_tag(stmt, mtag_record);
3240         mb_svc_debug(" tag record tag name = %s and media_id is %s!\n",
3241                      mtag_record->tag_name, mtag_record->media_uuid);
3242
3243         sqlite3_finalize(stmt);
3244         stmt = NULL;
3245
3246         return 0;
3247 }
3248
3249 int
3250 mb_svc_get_web_album_cluster_record(MediaSvcHandle *mb_svc_handle,
3251                                                         int sns_type,
3252                                                         const char *name,
3253                                                         const char *account_id,
3254                                                         const char *album_id,
3255                                                         mb_svc_folder_record_s *folder_record)
3256 {
3257         int err = -1;
3258         sqlite3_stmt *stmt = NULL;
3259         char *table_name = MB_SVC_TBL_NAME_FOLDER;
3260         char *query_string = NULL;
3261
3262         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
3263         if (handle == NULL) {
3264                 mb_svc_debug("handle is NULL");
3265                 return MB_SVC_ERROR_DB_INTERNAL;
3266         }
3267
3268         if(album_id == NULL) {
3269                 query_string = sqlite3_mprintf(MB_SVC_TABLE_SELECT_WEB_CLUSTER_RECORD_QUERY_STRING,
3270                                                                                 table_name, sns_type, name, account_id);
3271         }else {
3272                 query_string = sqlite3_mprintf(MB_SVC_TABLE_SELECT_WEB_ALBUM_CLUSTER_RECORD_QUERY_STRING,
3273                                                                                 table_name, sns_type, name, account_id, album_id);
3274         }
3275
3276         err = sqlite3_prepare_v2(handle, query_string, strlen(query_string), &stmt, NULL);
3277         if (SQLITE_OK != err) {
3278                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
3279                 mb_svc_debug("query string is %s\n", query_string);
3280                 sqlite3_free(query_string);
3281                 return MB_SVC_ERROR_DB_INTERNAL;
3282         }
3283         err = sqlite3_step(stmt);
3284         if (err != SQLITE_ROW) {
3285                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
3286                 mb_svc_debug("query string is %s\n", query_string);
3287                 sqlite3_free(query_string);
3288                 sqlite3_finalize(stmt);
3289                 return MB_SVC_ERROR_DB_INTERNAL;
3290         }
3291         err = mb_svc_load_record_folder(stmt, folder_record);
3292         if (err < 0) {
3293                 mb_svc_debug("mb-svc load data failed");
3294                 sqlite3_free(query_string);
3295                 sqlite3_finalize(stmt);
3296                 return MB_SVC_ERROR_DB_INTERNAL;
3297         }
3298
3299         sqlite3_free(query_string);
3300         sqlite3_finalize(stmt);
3301
3302         return 0;
3303 }
3304
3305 int
3306 mb_svc_get_folder_list_by_web_account_id(MediaSvcHandle *mb_svc_handle,
3307                                                 char *web_account,
3308                                                 GList **p_record_list)
3309 {
3310         int record_cnt = 0;
3311         mb_svc_folder_record_s *fd_record;
3312         int err = -1;
3313         GList *l_record_list = NULL;
3314         mb_svc_iterator_s mb_svc_iterator;
3315         minfo_cluster_filter cluster_filter = { 0 };
3316
3317         if (web_account == NULL || p_record_list == NULL) {
3318                 mb_svc_debug
3319                     ("Error: web_account == NULL || p_record_list == NULL\n");
3320                 return MB_SVC_ERROR_INVALID_PARAMETER;
3321         }
3322
3323         cluster_filter.cluster_type = MINFO_CLUSTER_TYPE_WEB;
3324         cluster_filter.sort_type = MINFO_CLUSTER_SORT_BY_NONE;
3325         cluster_filter.start_pos = MB_SVC_DB_DEFAULT_GET_ALL_RECORDS;
3326
3327         err = mb_svc_folder_iter_start(mb_svc_handle, &cluster_filter, &mb_svc_iterator);
3328
3329         if (err == MB_SVC_ERROR_DB_NO_RECORD) {
3330                 return err;
3331         } else if (err < 0) {
3332                 mb_svc_debug("mb-svc iterator start failed\n");
3333                 return MB_SVC_ERROR_DB_INTERNAL;
3334         }
3335
3336         while (1) {
3337                 fd_record =
3338                     (mb_svc_folder_record_s *)
3339                     malloc(sizeof(mb_svc_folder_record_s));
3340                 if (fd_record == NULL) {
3341                         mb_svc_debug("allocate memory failed\n");
3342                         mb_svc_iter_finish(&mb_svc_iterator);
3343                         return MB_SVC_ERROR_OUT_OF_MEMORY;
3344                 }
3345                 memset(fd_record, 0x00, sizeof(mb_svc_folder_record_s));
3346
3347                 err = mb_svc_folder_iter_next(&mb_svc_iterator, fd_record);
3348                 if (err == MB_SVC_NO_RECORD_ANY_MORE) {
3349                         free(fd_record);
3350                         fd_record = NULL;
3351                         break;
3352                 }
3353
3354                 if (err < 0) {
3355                         mb_svc_debug
3356                             ("mb-svc iterator get next recrod failed\n");
3357                         mb_svc_iter_finish(&mb_svc_iterator);
3358                         free(fd_record);
3359                         return err;
3360                 }
3361
3362                 if (strcmp(fd_record->web_account_id, web_account)) {
3363                         free(fd_record);
3364                         mb_svc_debug
3365                             ("mb-svc iterator -------different get next\n ");
3366                         continue;
3367                 }
3368
3369                 record_cnt++;
3370                 l_record_list = g_list_append(l_record_list, fd_record);
3371         }
3372
3373         mb_svc_iter_finish(&mb_svc_iterator);
3374         *p_record_list = l_record_list;
3375
3376         if (record_cnt == 0)
3377                 return MB_SVC_ERROR_DB_NO_RECORD;
3378         else
3379                 return 0;
3380 }
3381
3382 static int __mb_svc_get_folder_record_by_path_info(MediaSvcHandle *mb_svc_handle,
3383                                                                         const char *uri,
3384                                                                         char *display_name,
3385                                                                         minfo_store_type storage_type,
3386                                                                         mb_svc_folder_record_s *record)
3387 {
3388         int err = -1;
3389         char table_name[MB_SVC_TABLE_NAME_MAX_LEN] = { 0, };
3390         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
3391         char *query_string = NULL;
3392
3393         sqlite3_stmt *stmt = NULL;
3394         if (record == NULL || uri == NULL || display_name == NULL) {
3395                 mb_svc_debug("pointer image_meta_record is null\n");
3396                 return MB_SVC_ERROR_INVALID_PARAMETER;
3397         }
3398
3399         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
3400         if (handle == NULL) {
3401                 mb_svc_debug("handle is NULL");
3402                 return MB_SVC_ERROR_DB_INTERNAL;
3403         }
3404
3405         snprintf(table_name, MB_SVC_TABLE_NAME_MAX_LEN, "%s",
3406                  MB_SVC_TBL_NAME_FOLDER);
3407
3408         query_string = sqlite3_mprintf(MB_SVC_TABLE_SELECT_FOLDER_BY_PATH_INFO,
3409                                                                         table_name, uri, display_name, storage_type);
3410
3411         err =
3412             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
3413                                &stmt, NULL);
3414         if (SQLITE_OK != err) {
3415                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
3416                 mb_svc_debug("query string is %s\n", query_string);
3417                 sqlite3_free(query_string);
3418                 return MB_SVC_ERROR_DB_INTERNAL;
3419         }
3420         err = sqlite3_step(stmt);
3421         if (err != SQLITE_ROW) {
3422                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
3423                 mb_svc_debug("query string is %s\n", query_string);
3424                 sqlite3_free(query_string);
3425                 sqlite3_finalize(stmt);
3426                 return MB_SVC_ERROR_DB_INTERNAL;
3427         }
3428         err = mb_svc_load_record_folder(stmt, record);
3429         if (err < 0) {
3430                 mb_svc_debug("mb-svc load data failed");
3431                 sqlite3_free(query_string);
3432                 sqlite3_finalize(stmt);
3433                 return MB_SVC_ERROR_DB_INTERNAL;
3434         }
3435
3436         sqlite3_free(query_string);
3437         sqlite3_finalize(stmt);
3438
3439         return 0;
3440 }
3441
3442 static int __mb_svc_get_folder_record_by_full_path(
3443                                         MediaSvcHandle *mb_svc_handle,
3444                                         const char *folder_full_path,
3445                                         mb_svc_folder_record_s *folder_record)
3446 {
3447         minfo_store_type store_type = MINFO_SYSTEM;
3448         int err = -1;
3449         char display_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
3450
3451         if (folder_full_path == NULL || folder_record == NULL) {
3452                 mb_svc_debug
3453                     ("Error:folder_full_path == NULL || folder_record == NULL\n");
3454                 return MB_SVC_ERROR_INVALID_PARAMETER;
3455         }
3456
3457         store_type = _mb_svc_get_store_type_by_full(folder_full_path);
3458         if (store_type == MB_SVC_ERROR_INTERNAL) {
3459                 mb_svc_debug("Failed to get storage type : %s",
3460                              folder_full_path);
3461                 return MB_SVC_ERROR_INVALID_PARAMETER;
3462         }
3463
3464         _mb_svc_get_dir_display_name(folder_full_path, display_name);
3465
3466         err = __mb_svc_get_folder_record_by_path_info(mb_svc_handle, folder_full_path, display_name, store_type, folder_record);
3467         if (err < 0) {
3468                 mb_svc_debug
3469                     ("Error:get folder record via uri and display name failed\n");
3470                 return err;
3471         }
3472
3473         return 0;
3474 }
3475
3476 int
3477 mb_svc_get_folder_id_by_full_path(MediaSvcHandle *mb_svc_handle, const char *folder_full_path, char *folder_id, int max_length)
3478 {
3479         minfo_store_type store_type = MINFO_SYSTEM;
3480         int err = -1;
3481         char display_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
3482         char rel_path[MB_SVC_FILE_PATH_LEN_MAX + 1] = { 0 };
3483         char *table_name = MB_SVC_TBL_NAME_FOLDER;
3484         char *query_string = NULL;
3485         sqlite3_stmt *stmt = NULL;
3486
3487         if (folder_full_path == NULL || folder_id == NULL) {
3488                 mb_svc_debug
3489                     ("Error:folder_full_path == NULL || folder_id == NULL\n");
3490                 return MB_SVC_ERROR_INVALID_PARAMETER;
3491         }
3492
3493         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
3494         if (handle == NULL) {
3495                 mb_svc_debug("handle is NULL");
3496                 return MB_SVC_ERROR_DB_INTERNAL;
3497         }
3498
3499         store_type = _mb_svc_get_store_type_by_full(folder_full_path);
3500         if (store_type == MB_SVC_ERROR_INTERNAL) {
3501                 mb_svc_debug("Failed to get storage type : %s",
3502                              folder_full_path);
3503                 return MB_SVC_ERROR_INVALID_PARAMETER;
3504         }
3505
3506         _mb_svc_get_rel_path_by_full(folder_full_path, rel_path);
3507         _mb_svc_get_dir_display_name(rel_path, display_name);
3508
3509         query_string = sqlite3_mprintf(MB_SVC_TABLE_SELECT_FOLDER_UUID_BY_PATH_INFO,
3510                                                                         table_name, folder_full_path, display_name, store_type);
3511
3512         mb_svc_debug("Query : %s", query_string);
3513
3514         err =
3515             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
3516                                &stmt, NULL);
3517         if (SQLITE_OK != err) {
3518                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
3519                 mb_svc_debug("query string is %s\n", query_string);
3520                 sqlite3_free(query_string);
3521                 return MB_SVC_ERROR_DB_INTERNAL;
3522         }
3523         err = sqlite3_step(stmt);
3524         if (err != SQLITE_ROW) {
3525                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
3526                 mb_svc_debug("query string is %s\n", query_string);
3527                 sqlite3_free(query_string);
3528                 sqlite3_finalize(stmt);
3529                 return MB_SVC_ERROR_DB_INTERNAL;
3530         }
3531
3532         strncpy(folder_id, (const char *)sqlite3_column_text(stmt, 0), max_length);
3533
3534         sqlite3_free(query_string);
3535         sqlite3_finalize(stmt);
3536
3537         return 0;
3538 }
3539
3540 int
3541 mb_svc_get_folder_id_by_web_album_id(MediaSvcHandle *mb_svc_handle, const char *web_album_id, char *folder_id)
3542 {
3543         int err = -1;
3544         char *table_name = MB_SVC_TBL_NAME_FOLDER;
3545         char *query_string = NULL;
3546         sqlite3_stmt *stmt = NULL;
3547
3548         if (web_album_id == NULL || folder_id == NULL) {
3549                 mb_svc_debug
3550                     ("Error:web_album_id == NULL || folder_id == NULL\n");
3551                 return MB_SVC_ERROR_INVALID_PARAMETER;
3552         }
3553
3554         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
3555         if (handle == NULL) {
3556                 mb_svc_debug("handle is NULL");
3557                 return MB_SVC_ERROR_DB_INTERNAL;
3558         }
3559
3560         query_string = sqlite3_mprintf(MB_SVC_TABLE_SELECT_FOLDER_UUID_BY_WEB_ALBUM_ID_QUERY_STRING,
3561                                                                         table_name, web_album_id);
3562
3563         err =
3564             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
3565                                &stmt, NULL);
3566         if (SQLITE_OK != err) {
3567                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
3568                 mb_svc_debug("query string is %s\n", query_string);
3569                 sqlite3_free(query_string);
3570                 return MB_SVC_ERROR_DB_INTERNAL;
3571         }
3572         err = sqlite3_step(stmt);
3573         if (err != SQLITE_ROW) {
3574                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
3575                 mb_svc_debug("query string is %s\n", query_string);
3576                 sqlite3_free(query_string);
3577                 sqlite3_finalize(stmt);
3578                 return MB_SVC_ERROR_DB_INTERNAL;
3579         }
3580
3581         strncpy(folder_id, (const char *)sqlite3_column_text(stmt, 0), MB_SVC_UUID_LEN_MAX + 1);
3582
3583         sqlite3_free(query_string);
3584         sqlite3_finalize(stmt);
3585         return 0;
3586 }
3587
3588 static int __mb_svc_get_media_id_by_fid_name(MediaSvcHandle *mb_svc_handle, const char *folder_id, char *display_name, char *media_id)
3589 {
3590         int err = -1;
3591         char *query_string = NULL;
3592         sqlite3_stmt *stmt = NULL;
3593         char *table_name = MB_SVC_TBL_NAME_MEDIA;
3594
3595         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
3596         if (handle == NULL) {
3597                 mb_svc_debug("handle is NULL");
3598                 return MB_SVC_ERROR_DB_INTERNAL;
3599         }
3600
3601         query_string = sqlite3_mprintf(MB_SVC_SELECT_MEDIA_ID_BY_FOLDER_UUID_AND_DISPLAY_NAME,
3602                                                                 table_name, folder_id, display_name);
3603
3604         mb_svc_debug("Query: %s", query_string);
3605
3606         err =
3607             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
3608                                &stmt, NULL);
3609         if (SQLITE_OK != err) {
3610                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
3611                 mb_svc_debug("query string is %s\n", query_string);
3612                 sqlite3_free(query_string);
3613                 return MB_SVC_ERROR_DB_INTERNAL;
3614         }
3615
3616         err = sqlite3_step(stmt);
3617         if (err != SQLITE_ROW) {
3618                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
3619                 mb_svc_debug("query string is %s\n", query_string);
3620                 sqlite3_free(query_string);
3621                 sqlite3_finalize(stmt);
3622                 return MB_SVC_ERROR_DB_INTERNAL;
3623         }
3624
3625         strncpy(media_id, (const char *)sqlite3_column_text(stmt, 0), MB_SVC_UUID_LEN_MAX + 1);
3626
3627         sqlite3_free(query_string);
3628         sqlite3_finalize(stmt);
3629
3630         return 0;
3631 }
3632
3633 int
3634 mb_svc_get_media_record_by_fid_name(MediaSvcHandle *mb_svc_handle, const char *folder_id, const char *display_name,
3635                                     mb_svc_media_record_s *m_record)
3636 {
3637         int err = -1;
3638         char *query_string = NULL;
3639         sqlite3_stmt *stmt = NULL;
3640         char *table_name = MB_SVC_TBL_NAME_MEDIA;
3641
3642         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
3643         if (handle == NULL) {
3644                 mb_svc_debug("handle is NULL");
3645                 return MB_SVC_ERROR_DB_INTERNAL;
3646         }
3647
3648         query_string = sqlite3_mprintf(MB_SVC_SELECT_MEDIA_RECORD_BY_FOLDER_ID_AND_DISPLAY_NAME,
3649                                                                         table_name, folder_id, display_name);
3650
3651         err =
3652             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
3653                                &stmt, NULL);
3654         if (SQLITE_OK != err) {
3655                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
3656                 mb_svc_debug("query string is %s\n", query_string);
3657                 sqlite3_free(query_string);
3658                 return MB_SVC_ERROR_DB_INTERNAL;
3659         }
3660         err = sqlite3_step(stmt);
3661         if (err != SQLITE_ROW) {
3662                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
3663                 mb_svc_debug("query string is %s\n", query_string);
3664                 sqlite3_free(query_string);
3665                 sqlite3_finalize(stmt);
3666                 return MB_SVC_ERROR_DB_INTERNAL;
3667         }
3668         mb_svc_load_record_media(stmt, m_record);
3669
3670         sqlite3_free(query_string);
3671         sqlite3_finalize(stmt);
3672
3673         return 0;
3674 }
3675
3676 int mb_svc_update_favorite_by_media_id(MediaSvcHandle *mb_svc_handle, const char *media_id, int favorite)
3677 {
3678         int err = mb_svc_update_favorite_by_id(mb_svc_handle, media_id, favorite);
3679
3680         return err;
3681 }
3682
3683 int
3684 mb_svc_get_media_record_by_id(MediaSvcHandle *mb_svc_handle,
3685                                         const char *media_id,
3686                                         mb_svc_media_record_s *media_record)
3687 {
3688         int err = -1;
3689         char *table_name = MB_SVC_TBL_NAME_MEDIA;
3690         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
3691         sqlite3_stmt *p_Stmt_mb = NULL;
3692
3693         if (media_id == NULL || media_record == NULL) {
3694                 mb_svc_debug("media_id == NULL || media_record == NULL");
3695                 return MB_SVC_ERROR_INVALID_PARAMETER;
3696         }
3697
3698         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
3699         if (handle == NULL) {
3700                 mb_svc_debug("handle is NULL");
3701                 return MB_SVC_ERROR_DB_INTERNAL;
3702         }
3703
3704         snprintf(query_string, sizeof(query_string),
3705                  MB_SVC_TABLE_SELECT_MEDIA_BY_MEDIA_UUID, table_name, media_id);
3706
3707         mb_svc_debug("Query: %s", query_string);
3708
3709         err =
3710             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
3711                                &p_Stmt_mb, NULL);
3712         if (SQLITE_OK != err) {
3713                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
3714                 return MB_SVC_ERROR_DB_INTERNAL;
3715         }
3716         err = sqlite3_step(p_Stmt_mb);
3717         if (err != SQLITE_ROW) {
3718                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
3719                 sqlite3_finalize(p_Stmt_mb);
3720                 return MB_SVC_ERROR_DB_INTERNAL;
3721         }
3722         mb_svc_load_record_media(p_Stmt_mb, media_record);
3723
3724         mb_svc_debug("Path : %s", media_record->path);
3725         mb_svc_debug("Thumb : %s", media_record->thumbnail_path);
3726         sqlite3_finalize(p_Stmt_mb);
3727         return 0;
3728 }
3729
3730 int
3731 mb_svc_get_folder_name_by_id(MediaSvcHandle *mb_svc_handle, const char *folder_id, char *folder_name, int max_length)
3732 {
3733         int err = -1;
3734         char *table_name = MB_SVC_TBL_NAME_FOLDER;
3735         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
3736
3737         sqlite3_stmt *stmt = NULL;
3738
3739         if (folder_id == NULL) {
3740                 mb_svc_debug("folder_id is NULL");
3741                 return MB_SVC_ERROR_INVALID_PARAMETER;
3742         }
3743
3744         if (folder_name == NULL) {
3745                 mb_svc_debug("pointer folder_name is null\n");
3746                 return MB_SVC_ERROR_INVALID_PARAMETER;
3747         }
3748
3749         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
3750         if (handle == NULL) {
3751                 mb_svc_debug("handle is NULL");
3752                 return MB_SVC_ERROR_DB_INTERNAL;
3753         }
3754
3755         snprintf(query_string, sizeof(query_string),
3756                  MB_SVC_TABLE_SELECT_FOLDER_NAME_BY_UUID, table_name, folder_id);
3757
3758         err =
3759             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
3760                                &stmt, NULL);
3761         if (SQLITE_OK != err) {
3762                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
3763                 mb_svc_debug("query string is %s\n", query_string);
3764                 return MB_SVC_ERROR_DB_INTERNAL;
3765         }
3766         err = sqlite3_step(stmt);
3767         if (err != SQLITE_ROW) {
3768                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
3769                 mb_svc_debug("query string is %s\n", query_string);
3770                 sqlite3_finalize(stmt);
3771                 return MB_SVC_ERROR_DB_INTERNAL;
3772         }
3773
3774         err = mb_svc_load_record_folder_name(stmt, folder_name, max_length);
3775
3776         if (err < 0) {
3777                 mb_svc_debug("mb-svc load data failed");
3778                 sqlite3_finalize(stmt);
3779                 return MB_SVC_ERROR_DB_INTERNAL;
3780         }
3781
3782         sqlite3_finalize(stmt);
3783
3784         return 0;
3785
3786 }
3787
3788 int
3789 mb_svc_get_folder_record_by_id(MediaSvcHandle *mb_svc_handle,
3790                                         const char *folder_id,
3791                                         mb_svc_folder_record_s *folder_record)
3792 {
3793         int err = -1;
3794         char *table_name = MB_SVC_TBL_NAME_FOLDER;
3795         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
3796         sqlite3_stmt *stmt = NULL;
3797
3798         if (folder_record == NULL) {
3799                 mb_svc_debug("pointer folder_record is null\n");
3800                 return MB_SVC_ERROR_INVALID_PARAMETER;
3801         }
3802
3803         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
3804         if (handle == NULL) {
3805                 mb_svc_debug("handle is NULL");
3806                 return MB_SVC_ERROR_DB_INTERNAL;
3807         }
3808
3809         snprintf(query_string, sizeof(query_string),
3810                  MB_SVC_TABLE_SELECT_FOLDER_RECORD_BY_UUID, table_name,
3811                  folder_id);
3812
3813         err =
3814             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
3815                                &stmt, NULL);
3816         if (SQLITE_OK != err) {
3817                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
3818                 mb_svc_debug("query string is %s\n", query_string);
3819                 return MB_SVC_ERROR_DB_INTERNAL;
3820         }
3821         err = sqlite3_step(stmt);
3822         if (err != SQLITE_ROW) {
3823                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
3824                 mb_svc_debug("query string is %s\n", query_string);
3825                 sqlite3_finalize(stmt);
3826                 return MB_SVC_ERROR_DB_INTERNAL;
3827         }
3828         err = mb_svc_load_record_folder(stmt, folder_record);
3829         if (err < 0) {
3830                 mb_svc_debug("mb-svc load data failed");
3831                 sqlite3_finalize(stmt);
3832                 return MB_SVC_ERROR_DB_INTERNAL;
3833         }
3834
3835         sqlite3_finalize(stmt);
3836
3837         return 0;
3838
3839 }
3840
3841 int
3842 mb_svc_get_web_streaming_record_by_id(MediaSvcHandle *mb_svc_handle,
3843                                                 int webstreaming_id,
3844                                                 mb_svc_web_streaming_record_s *
3845                                                 webstreaming_record)
3846 {
3847         int err = -1;
3848         char *table_name = MB_SVC_TBL_NAME_WEB_STREAMING;
3849         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
3850
3851         sqlite3_stmt *stmt = NULL;
3852         if (webstreaming_record == NULL) {
3853                 mb_svc_debug("pointer webstreaming_record is null\n");
3854                 return MB_SVC_ERROR_INVALID_PARAMETER;
3855         }
3856
3857         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
3858         if (handle == NULL) {
3859                 mb_svc_debug("handle is NULL");
3860                 return MB_SVC_ERROR_DB_INTERNAL;
3861         }
3862
3863         snprintf(query_string, sizeof(query_string),
3864                  MB_SVC_TABLE_SELECT_WEBSTREAMING_RECORD_BY_ID, table_name,
3865                  webstreaming_id);
3866         err =
3867             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
3868                                &stmt, NULL);
3869         if (SQLITE_OK != err) {
3870                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
3871                 mb_svc_debug("query string is %s\n", query_string);
3872                 return MB_SVC_ERROR_DB_INTERNAL;
3873         }
3874         err = sqlite3_step(stmt);
3875         if (err != SQLITE_ROW) {
3876                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
3877                 mb_svc_debug("query string is %s\n", query_string);
3878                 sqlite3_finalize(stmt);
3879                 return MB_SVC_ERROR_DB_INTERNAL;
3880         }
3881         err = mb_svc_load_record_web_streaming(stmt, webstreaming_record);
3882         if (err < 0) {
3883                 mb_svc_debug("mb-svc load data failed");
3884                 sqlite3_finalize(stmt);
3885                 return MB_SVC_ERROR_DB_INTERNAL;
3886         }
3887
3888         sqlite3_finalize(stmt);
3889
3890         return 0;
3891
3892 }
3893
3894 int mb_svc_webstreaming_iter_start(MediaSvcHandle *mb_svc_handle, mb_svc_iterator_s *mb_svc_iterator)
3895 {
3896         int err = -1;
3897         char *table_name = MB_SVC_TBL_NAME_FOLDER;
3898         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
3899
3900         if (mb_svc_iterator == NULL) {
3901                 mb_svc_debug("mb_svc_iterator == NULL\n");
3902                 return MB_SVC_ERROR_INVALID_PARAMETER;
3903         }
3904
3905         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
3906         if (handle == NULL) {
3907                 mb_svc_debug("handle is NULL");
3908                 return MB_SVC_ERROR_DB_INTERNAL;
3909         }
3910
3911         snprintf(query_string, sizeof(query_string),
3912                  MB_SVC_TABLE_SELECT_FOLDER_ALL_QUERY_STRING, table_name);
3913
3914         mb_svc_iterator->current_position = 0;
3915
3916         err =
3917             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
3918                                &mb_svc_iterator->stmt, NULL);
3919         if (SQLITE_OK != err) {
3920                 mb_svc_debug("prepare error [%s]", sqlite3_errmsg(handle));
3921                 mb_svc_debug("query string is %s\n", query_string);
3922                 return MB_SVC_ERROR_DB_INTERNAL;
3923         }
3924
3925         return err;
3926 }
3927
3928 int
3929 mb_svc_webstreaming_iter_next(mb_svc_iterator_s *mb_svc_iterator,
3930                               mb_svc_web_streaming_record_s *
3931                               webstreaming_record)
3932 {
3933         int err = -1;
3934
3935         if (webstreaming_record == NULL || mb_svc_iterator == NULL) {
3936                 mb_svc_debug
3937                     ("webstreaming_record == NULL || mb_svc_iterator == NULL\n");
3938                 return MB_SVC_ERROR_INVALID_PARAMETER;
3939         }
3940 /*
3941         if (mb_svc_iterator->current_position < -1 || mb_svc_iterator->current_position >= mb_svc_iterator->total_count - 1) {
3942                 mb_svc_debug ("iteration is not started: %d\n", mb_svc_iterator->current_position);
3943                 return MB_SVC_ERROR_DB_OUT_OF_RANGE;
3944         }
3945 */
3946         err = sqlite3_step(mb_svc_iterator->stmt);
3947         if (err != SQLITE_ROW) {
3948                 mb_svc_debug("end of iteration : count = %d\n",
3949                              mb_svc_iterator->current_position);
3950                 return MB_SVC_NO_RECORD_ANY_MORE;
3951         }
3952
3953         memset(webstreaming_record, 0, sizeof(mb_svc_web_streaming_record_s));
3954         err =
3955             mb_svc_load_record_web_streaming(mb_svc_iterator->stmt,
3956                                              webstreaming_record);
3957         if (err < 0) {
3958                 mb_svc_debug("failed to load item\n");
3959                 sqlite3_finalize(mb_svc_iterator->stmt);
3960                 mb_svc_iterator->current_position = -1;
3961                 return MB_SVC_ERROR_DB_INTERNAL;
3962         }
3963
3964         mb_svc_iterator->current_position++;
3965
3966         return 0;
3967 }
3968
3969 static int __mb_svc_get_media_list_by_folder_id(MediaSvcHandle *mb_svc_handle,
3970                         const char *folder_id,
3971                         GList **p_record_list,
3972                         int valid)
3973 {
3974         int record_cnt = 0;
3975         mb_svc_media_record_s *md_record;
3976         int err = -1;
3977         GList *l_record_list = NULL;
3978         mb_svc_iterator_s mb_svc_iterator = { 0 };
3979
3980         if (p_record_list == NULL) {
3981                 mb_svc_debug("p_record_list is null \n");
3982                 return MB_SVC_ERROR_INVALID_PARAMETER;
3983         }
3984
3985         minfo_item_filter filter = { 0 };
3986         filter.favorite = MINFO_MEDIA_FAV_ALL;
3987         filter.start_pos = MB_SVC_DB_DEFAULT_GET_ALL_RECORDS;
3988         filter.sort_type = MINFO_MEDIA_SORT_BY_NONE;
3989         filter.file_type = MINFO_ITEM_IMAGE | MINFO_ITEM_VIDEO;
3990
3991         err =
3992             mb_svc_media_iter_start_new(mb_svc_handle, folder_id, &filter,
3993                                         MINFO_CLUSTER_TYPE_ALL, valid, NULL,
3994                                         &mb_svc_iterator);
3995
3996         if (err < 0) {
3997                 mb_svc_debug("mb-svc iterator start failed");
3998                 return err;
3999         }
4000
4001         while (1) {
4002                 md_record =
4003                     (mb_svc_media_record_s *)
4004                     malloc(sizeof(mb_svc_media_record_s));
4005                 if (md_record == NULL) {
4006                         mb_svc_debug("Error: memory allocation failed\n");
4007                         mb_svc_iter_finish(&mb_svc_iterator);
4008                         _mb_svc_glist_free(&l_record_list, true);
4009                         return MB_SVC_ERROR_OUT_OF_MEMORY;
4010                 }
4011                 memset(md_record, 0x00, sizeof(mb_svc_media_record_s));
4012
4013                 err = mb_svc_media_iter_next(&mb_svc_iterator, md_record);
4014
4015                 if (err == MB_SVC_NO_RECORD_ANY_MORE) {
4016                         if (md_record)
4017                                 free(md_record);
4018                         md_record = NULL;
4019                         break;
4020                 }
4021
4022                 if (err < 0) {
4023                         mb_svc_debug("mb-svc iterator get next recrod failed");
4024                         mb_svc_iter_finish(&mb_svc_iterator);
4025                         if (md_record)
4026                                 free(md_record);
4027                         md_record = NULL;
4028                         _mb_svc_glist_free(&l_record_list, true);
4029                         return err;
4030                 }
4031
4032                 record_cnt++;
4033
4034                 l_record_list = g_list_append(l_record_list, md_record);
4035         }
4036
4037         mb_svc_iter_finish(&mb_svc_iterator);
4038         *p_record_list = l_record_list;
4039
4040         if (record_cnt == 0)
4041                 return MB_SVC_ERROR_DB_NO_RECORD;
4042         else
4043                 return 0;
4044 }
4045
4046 static int __mb_svc_get_all_media_list(MediaSvcHandle *mb_svc_handle, const minfo_store_type storage_type, GList **p_record_list)
4047 {
4048         int record_cnt = 0;
4049         char *sql = NULL;
4050         mb_svc_media_record_s *md_record;
4051         int err = -1;
4052         GList *l_record_list = NULL;
4053         mb_svc_iterator_s mb_svc_iterator = { 0 };
4054
4055         if (p_record_list == NULL) {
4056                 mb_svc_debug("p_record_list is null \n");
4057                 return MB_SVC_ERROR_INVALID_PARAMETER;
4058         }
4059
4060         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
4061         if (handle == NULL) {
4062                 mb_svc_debug("handle is NULL");
4063                 return MB_SVC_ERROR_DB_INTERNAL;
4064         }
4065
4066         sql = sqlite3_mprintf(MB_SVC_SELECT_ALL_MEDIA_LIST_BY_STORAGE, storage_type);
4067         err =
4068             sqlite3_prepare_v2(handle, sql, strlen(sql), &mb_svc_iterator.stmt, NULL);
4069
4070         sqlite3_free(sql);
4071
4072         if (SQLITE_OK != err) {
4073                 mb_svc_debug("prepare error [%s]", sqlite3_errmsg(handle));
4074                 return MB_SVC_ERROR_DB_INTERNAL;
4075         }
4076
4077         while (1) {
4078                 md_record =
4079                     (mb_svc_media_record_s *)
4080                     malloc(sizeof(mb_svc_media_record_s));
4081                 if (md_record == NULL) {
4082                         mb_svc_debug("Error: memory allocation failed\n");
4083                         mb_svc_iter_finish(&mb_svc_iterator);
4084                         _mb_svc_glist_free(&l_record_list, true);
4085                         return MB_SVC_ERROR_OUT_OF_MEMORY;
4086                 }
4087                 memset(md_record, 0x00, sizeof(mb_svc_media_record_s));
4088
4089                 err = mb_svc_media_iter_next(&mb_svc_iterator, md_record);
4090
4091                 if (err == MB_SVC_NO_RECORD_ANY_MORE) {
4092                         if (md_record)
4093                                 free(md_record);
4094                         md_record = NULL;
4095                         break;
4096                 }
4097
4098                 if (err < 0) {
4099                         mb_svc_debug("mb-svc iterator get next recrod failed");
4100                         mb_svc_iter_finish(&mb_svc_iterator);
4101                         if (md_record)
4102                                 free(md_record);
4103                         md_record = NULL;
4104                         _mb_svc_glist_free(&l_record_list, true);
4105                         return err;
4106                 }
4107
4108                 record_cnt++;
4109
4110                 l_record_list = g_list_append(l_record_list, md_record);
4111         }
4112
4113         mb_svc_iter_finish(&mb_svc_iterator);
4114         *p_record_list = l_record_list;
4115
4116         if (record_cnt == 0)
4117                 return MB_SVC_ERROR_DB_NO_RECORD;
4118         else
4119                 return 0;
4120 }
4121
4122 static int __mb_svc_get_invalid_media_list(MediaSvcHandle *mb_svc_handle, const minfo_store_type storage_type, GList **p_record_list)
4123 {
4124         int record_cnt = 0;
4125         char *sql = NULL;
4126         mb_svc_media_record_s *md_record;
4127         int err = -1;
4128         GList *l_record_list = NULL;
4129         mb_svc_iterator_s mb_svc_iterator = { 0 };
4130
4131         if (p_record_list == NULL) {
4132                 mb_svc_debug("p_record_list is null \n");
4133                 return MB_SVC_ERROR_INVALID_PARAMETER;
4134         }
4135
4136         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
4137         if (handle == NULL) {
4138                 mb_svc_debug("handle is NULL");
4139                 return MB_SVC_ERROR_DB_INTERNAL;
4140         }
4141
4142         sql = sqlite3_mprintf(MB_SVC_SELECT_INVALID_MEDIA_LIST, storage_type);
4143         err =
4144             sqlite3_prepare_v2(handle, sql, strlen(sql), &mb_svc_iterator.stmt, NULL);
4145
4146         sqlite3_free(sql);
4147
4148         if (SQLITE_OK != err) {
4149                 mb_svc_debug("prepare error [%s]", sqlite3_errmsg(handle));
4150                 return MB_SVC_ERROR_DB_INTERNAL;
4151         }
4152
4153         while (1) {
4154                 md_record =
4155                     (mb_svc_media_record_s *)
4156                     malloc(sizeof(mb_svc_media_record_s));
4157                 if (md_record == NULL) {
4158                         mb_svc_debug("Error: memory allocation failed\n");
4159                         mb_svc_iter_finish(&mb_svc_iterator);
4160                         _mb_svc_glist_free(&l_record_list, true);
4161                         return MB_SVC_ERROR_OUT_OF_MEMORY;
4162                 }
4163                 memset(md_record, 0x00, sizeof(mb_svc_media_record_s));
4164
4165                 err = mb_svc_media_iter_next(&mb_svc_iterator, md_record);
4166
4167                 if (err == MB_SVC_NO_RECORD_ANY_MORE) {
4168                         if (md_record)
4169                                 free(md_record);
4170                         md_record = NULL;
4171                         break;
4172                 }
4173
4174                 if (err < 0) {
4175                         mb_svc_debug("mb-svc iterator get next recrod failed");
4176                         mb_svc_iter_finish(&mb_svc_iterator);
4177                         if (md_record)
4178                                 free(md_record);
4179                         md_record = NULL;
4180                         _mb_svc_glist_free(&l_record_list, true);
4181                         return err;
4182                 }
4183
4184                 record_cnt++;
4185
4186                 l_record_list = g_list_append(l_record_list, md_record);
4187         }
4188
4189         mb_svc_iter_finish(&mb_svc_iterator);
4190         *p_record_list = l_record_list;
4191
4192         if (record_cnt == 0)
4193                 return MB_SVC_ERROR_DB_NO_RECORD;
4194         else
4195                 return 0;
4196 }
4197
4198 static int __mb_svc_delete_media_records_list(MediaSvcHandle *mb_svc_handle, GList *p_record_list)
4199 {
4200         int ret = -1;
4201         mb_svc_media_record_s *m_data = NULL;
4202         int i = 0;
4203
4204         if (p_record_list != NULL) {
4205                 char *sql = NULL;
4206                 GList *delete_sql_list = NULL;
4207                 int trans_count = 30;
4208                 int cur_trans_count = 0;
4209                 int length = g_list_length(p_record_list);
4210
4211                 for (i = 0; i < length; i++) {
4212
4213                         m_data =
4214                             (mb_svc_media_record_s *)
4215                             g_list_nth_data(p_record_list, i);
4216
4217                         ret = mb_svc_delete_record_media_sql(m_data->media_uuid, &sql);
4218                         if (ret < 0) {
4219                                 mb_svc_debug
4220                                     ("mb_svc_delete_record_media_sql failed\n");
4221                         }
4222
4223                         mb_svc_sql_list_add(&delete_sql_list, &sql);
4224
4225                         if (m_data->content_type == MINFO_ITEM_IMAGE) {
4226                                 ret = mb_svc_delete_record_image_meta_sql(m_data->media_uuid, &sql);
4227                                 if (ret < 0) {
4228                                         mb_svc_debug
4229                                                 ("mb_svc_delete_record_image_meta_sql failed\n");
4230                                 }
4231
4232                                 mb_svc_sql_list_add(&delete_sql_list, &sql);
4233
4234                         } else if (m_data->content_type == MINFO_ITEM_VIDEO) {
4235                                 ret = mb_svc_delete_record_video_meta_sql(m_data->media_uuid, &sql);
4236                                 if (ret < 0) {
4237                                         mb_svc_debug
4238                                                 ("mb_svc_delete_record_video_meta_sql failed\n");
4239                                 }
4240
4241                                 mb_svc_sql_list_add(&delete_sql_list, &sql);
4242
4243                                 ret =
4244                                         mb_svc_delete_bookmark_meta_by_media_id_sql(m_data->media_uuid, &sql);
4245                                 if (ret < 0) {
4246                                         mb_svc_debug
4247                                                 ("mb_svc_delete_bookmark_meta_by_media_id_sql failed\n");
4248                                 }
4249
4250                                 mb_svc_sql_list_add(&delete_sql_list, &sql);
4251                         }
4252
4253                         ret =
4254                             mb_svc_delete_tagmap_by_media_id_sql(m_data->media_uuid, &sql);
4255                         if (ret < 0) {
4256                                 mb_svc_debug
4257                                     ("mb_svc_delete_tagmap_by_media_id_sql failed (%d)\n", ret);
4258                         }
4259
4260                         mb_svc_sql_list_add(&delete_sql_list, &sql);
4261
4262                         /* delete thumbnail file directly */
4263                         if (strlen(m_data->http_url) == 0) {
4264                                 ret = _mb_svc_thumb_rm(m_data->thumbnail_path);
4265                         }
4266                         if (ret < 0) {
4267                                 mb_svc_debug
4268                                     ("_mb_svc_thumb_delete fail:file is %s\n",
4269                                      m_data->thumbnail_path);
4270                         }
4271
4272                         cur_trans_count++;
4273
4274                         if (cur_trans_count >= trans_count) {
4275                                 cur_trans_count = 0;
4276
4277                                 /* Start transaction */
4278                                 int i = 0;
4279                                 int length = g_list_length(delete_sql_list);
4280
4281                                 ret = mb_svc_sqlite3_begin_trans(mb_svc_handle);
4282                                 if (ret < 0) {
4283                                         mb_svc_debug("mb_svc_sqlite3_begin_trans failed\n");
4284                                         mb_svc_sql_list_release(&delete_sql_list);
4285                                         return ret;
4286                                 }
4287
4288                                 for (i = 0; i < length; i++) {
4289                                         char *sql = (char *)g_list_nth_data(delete_sql_list, i);
4290                                         ret = mb_svc_query_sql(mb_svc_handle, sql);
4291
4292                                         if (ret < 0) {
4293                                                 mb_svc_debug
4294                                                         ("mb_svc_query_sql failed.. Now start to rollback\n");
4295                                                 mb_svc_sqlite3_rollback_trans(mb_svc_handle);
4296                                                 mb_svc_sql_list_release(&delete_sql_list);
4297                                                 return ret;
4298                                         }
4299                                 }
4300
4301                                 ret = mb_svc_sqlite3_commit_trans(mb_svc_handle);
4302                                 if (ret < 0) {
4303                                         mb_svc_debug
4304                                                 ("mb_svc_sqlite3_commit_trans failed.. Now start to rollback\n");
4305                                         mb_svc_sqlite3_rollback_trans(mb_svc_handle);
4306                                         mb_svc_sql_list_release(&delete_sql_list);
4307                                         return ret;
4308                                 }
4309                         }
4310                 }
4311
4312                 if (cur_trans_count > 0) {
4313                         cur_trans_count = 0;
4314
4315                         /* Start transaction */
4316                         int i = 0;
4317                         int length = g_list_length(delete_sql_list);
4318
4319                         ret = mb_svc_sqlite3_begin_trans(mb_svc_handle);
4320                         if (ret < 0) {
4321                                 mb_svc_debug("mb_svc_sqlite3_begin_trans failed\n");
4322                                 mb_svc_sql_list_release(&delete_sql_list);
4323                                 return ret;
4324                         }
4325
4326                         for (i = 0; i < length; i++) {
4327                                 char *sql = (char *)g_list_nth_data(delete_sql_list, i);
4328                                 ret = mb_svc_query_sql(mb_svc_handle, sql);
4329
4330                                 if (ret < 0) {
4331                                         mb_svc_debug
4332                                                 ("mb_svc_query_sql failed.. Now start to rollback\n");
4333                                         mb_svc_sqlite3_rollback_trans(mb_svc_handle);
4334                                         mb_svc_sql_list_release(&delete_sql_list);
4335                                         return ret;
4336                                 }
4337                         }
4338
4339                         ret = mb_svc_sqlite3_commit_trans(mb_svc_handle);
4340                         if (ret < 0) {
4341                                 mb_svc_debug
4342                                         ("mb_svc_sqlite3_commit_trans failed.. Now start to rollback\n");
4343                                 mb_svc_sqlite3_rollback_trans(mb_svc_handle);
4344                                 mb_svc_sql_list_release(&delete_sql_list);
4345                                 return ret;
4346                         }
4347                 }
4348
4349                 mb_svc_sql_list_release(&delete_sql_list);
4350         }
4351
4352         return 0;
4353 }
4354
4355 int mb_svc_delete_folder(MediaSvcHandle *mb_svc_handle, const char *folder_id, minfo_store_type storage_type)
4356 {
4357         int ret = 0;
4358         GList *p_record_list = NULL;
4359
4360         if (folder_id == NULL) {
4361                 mb_svc_debug("folder_id is NULL");
4362                 return MB_SVC_ERROR_INVALID_PARAMETER;
4363         }
4364
4365         ret = __mb_svc_get_media_list_by_folder_id(mb_svc_handle, folder_id, &p_record_list, TRUE);
4366
4367         if (ret == MB_SVC_ERROR_DB_NO_RECORD) {
4368                 mb_svc_debug("There's no item in the folder %s", folder_id);
4369                 goto DELETE_FOLDER;
4370         } else if (ret < 0) {
4371                 mb_svc_debug("minfo_delete_cluster, __mb_svc_get_media_list_by_folder_id failed\n");
4372                 return ret;
4373         }
4374
4375         ret = __mb_svc_delete_media_records_list(mb_svc_handle, p_record_list);
4376         _mb_svc_glist_free(&p_record_list, true);
4377
4378         if (ret < 0) {
4379                 mb_svc_debug
4380                     ("minfo_delete_cluster, delete media related records by folder_id failed\n");
4381                 return ret;
4382         }
4383
4384  DELETE_FOLDER:
4385         ret = mb_svc_delete_record_folder_by_id(mb_svc_handle, folder_id);
4386
4387         if (ret < 0) {
4388                 mb_svc_debug
4389                     ("minfo_delete_cluster, delete matched folder record failed\n");
4390                 return ret;
4391         }
4392
4393         return 0;
4394 }
4395
4396 /*
4397 *
4398 * caller need to provide the local statement--stmt
4399 */
4400 int
4401 mb_svc_bookmark_iter_start(MediaSvcHandle *mb_svc_handle, const char *media_id, mb_svc_iterator_s *mb_svc_iterator)
4402 {
4403         int err = -1;
4404         char *table_name = MB_SVC_TBL_NAME_BOOKMARK;
4405         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
4406
4407         if (mb_svc_iterator == NULL) {
4408                 mb_svc_debug("mb_svc_iterator == NULL\n");
4409                 return MB_SVC_ERROR_INVALID_PARAMETER;
4410         }
4411
4412         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
4413         if (handle == NULL) {
4414                 mb_svc_debug("handle is NULL");
4415                 return MB_SVC_ERROR_DB_INTERNAL;
4416         }
4417
4418         snprintf(query_string, sizeof(query_string),
4419                  MB_SVC_TABLE_SELECT_BOOKMARK_ALL_BY_MUUID, table_name,
4420                  media_id);
4421
4422         mb_svc_debug("Query : %s", query_string);
4423
4424         mb_svc_iterator->current_position = 0;
4425
4426         err =
4427             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
4428                                &mb_svc_iterator->stmt, NULL);
4429         if (SQLITE_OK != err) {
4430                 mb_svc_debug("prepare error [%s]", sqlite3_errmsg(handle));
4431                 mb_svc_debug("query string is %s\n", query_string);
4432                 return MB_SVC_ERROR_DB_INTERNAL;
4433         }
4434
4435         return 0;
4436 }
4437
4438 int
4439 mb_svc_bookmark_iter_next(mb_svc_iterator_s *mb_svc_iterator,
4440                           mb_svc_bookmark_record_s *record)
4441 {
4442         int err = -1;
4443
4444         if (record == NULL || mb_svc_iterator == NULL) {
4445                 mb_svc_debug("pointer record is null\n");
4446                 return MB_SVC_ERROR_INVALID_PARAMETER;
4447         }
4448         err = sqlite3_step(mb_svc_iterator->stmt);
4449         if (err != SQLITE_ROW) {
4450                 mb_svc_debug("end of iteration : count = %d\n",
4451                              mb_svc_iterator->current_position);
4452                 return MB_SVC_NO_RECORD_ANY_MORE;
4453         }
4454
4455         err = mb_svc_load_record_bookmark(mb_svc_iterator->stmt, record);
4456         if (err < 0) {
4457                 mb_svc_debug("failed to load item\n");
4458                 sqlite3_finalize(mb_svc_iterator->stmt);
4459                 mb_svc_iterator->current_position = -1;
4460                 return MB_SVC_ERROR_DB_INTERNAL;
4461         }
4462         mb_svc_iterator->current_position++;
4463
4464         return 0;
4465 }
4466
4467 /*
4468 *
4469 * caller need to provide the local statement--stmt
4470 */
4471 int
4472 mb_svc_tag_iter_start(MediaSvcHandle *mb_svc_handle,
4473                                 const char *tag_name,
4474                                 const char *media_id,
4475                                 mb_svc_iterator_s *mb_svc_iterator)
4476 {
4477         int err = -1;
4478         char query_string_with_lock_status[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
4479         int len = 0;
4480
4481         if (mb_svc_iterator == NULL) {
4482                 mb_svc_debug("mb_svc_iterator == NULL\n");
4483                 return MB_SVC_ERROR_INVALID_PARAMETER;
4484         }
4485
4486         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
4487         if (handle == NULL) {
4488                 mb_svc_debug("handle is NULL");
4489                 return MB_SVC_ERROR_DB_INTERNAL;
4490         }
4491
4492         if (tag_name != NULL) {
4493                 /* set to get only unlocked items */
4494                 len =
4495                     snprintf(query_string_with_lock_status,
4496                              sizeof(query_string_with_lock_status),
4497                              MB_SVC_TABLE_SELECT_TAG_ALL_QUERY_STRING_BY_TAG_NAME_WITH_LOCK_STATUS,
4498                              tag_name, 0);
4499         } else if (media_id == NULL) {
4500                 /* set to get only unlocked items */
4501                 len =
4502                     snprintf(query_string_with_lock_status,
4503                              sizeof(query_string_with_lock_status),
4504                              MB_SVC_TABLE_SELECT_TAG_ALL_QUERY_STRING_WITH_LOCK_STATUS,
4505                              0);
4506         } else {
4507                 /* set to get only unlocked items */
4508                 len =
4509                     snprintf(query_string_with_lock_status,
4510                              sizeof(query_string_with_lock_status),
4511                              MB_SVC_TABLE_SELECT_TAG_ALL_QUERY_STRING_BY_MEDIA_ID_WITH_LOCK_STATUS,
4512                              media_id, 0);
4513         }
4514
4515         if (len < 0) {
4516                 mb_svc_debug("snprintf returns failure ( %d )", len);
4517                 query_string_with_lock_status[0] = '\0';
4518         } else {
4519                 query_string_with_lock_status[len] = '\0';
4520         }
4521
4522         mb_svc_debug("Query : %s", query_string_with_lock_status);
4523
4524         mb_svc_iterator->current_position = 0;
4525
4526         err =
4527             sqlite3_prepare_v2(handle, query_string_with_lock_status,
4528                                strlen(query_string_with_lock_status),
4529                                &mb_svc_iterator->stmt, NULL);
4530         if (SQLITE_OK != err) {
4531                 mb_svc_debug("prepare error [%s]", sqlite3_errmsg(handle));
4532                 mb_svc_debug("query string is %s\n",
4533                              query_string_with_lock_status);
4534                 return MB_SVC_ERROR_DB_INTERNAL;
4535         }
4536
4537         return 0;
4538 }
4539
4540 int
4541 mb_svc_tag_iter_with_filter_start(MediaSvcHandle *mb_svc_handle,
4542                                         const char *tag_name,
4543                                         minfo_tag_filter filter,
4544                                         mb_svc_iterator_s *mb_svc_iterator)
4545 {
4546         int err = -1;
4547         char query_string_with_lock_status[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
4548         char condition_str[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
4549         int len = 0;
4550
4551         if (mb_svc_iterator == NULL) {
4552                 mb_svc_debug("mb_svc_iterator == NULL\n");
4553                 return MB_SVC_ERROR_INVALID_PARAMETER;
4554         }
4555
4556         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
4557         if (handle == NULL) {
4558                 mb_svc_debug("handle is NULL");
4559                 return MB_SVC_ERROR_DB_INTERNAL;
4560         }
4561
4562         memset(condition_str, 0x00, sizeof(condition_str));
4563         if (!(filter.file_type & MINFO_ITEM_ALL)) {
4564                 char content_str[MB_SVC_DEFAULT_QUERY_SIZE] = { 0 };
4565
4566                 len =
4567                     snprintf(content_str, sizeof(content_str),
4568                              " and ( m.content_type=%d ", 0);
4569                 if (len < 0) {
4570                         mb_svc_debug("snprintf returns failure ( %d )", len);
4571                         content_str[0] = '\0';
4572                 } else {
4573                         content_str[len] = '\0';
4574                 }
4575
4576                 len =
4577                     g_strlcat(condition_str, content_str,
4578                               sizeof(condition_str));
4579                 if (len >= sizeof(condition_str)) {
4580                         mb_svc_debug("strlcat returns failure ( %d )", len);
4581                         return MB_SVC_ERROR_INVALID_PARAMETER;
4582                 }
4583
4584                 if (filter.file_type & MINFO_ITEM_IMAGE) {
4585                         len =
4586                             snprintf(content_str, sizeof(content_str),
4587                                      " or m.content_type=%d ",
4588                                      MINFO_ITEM_IMAGE);
4589                         if (len < 0) {
4590                                 mb_svc_debug("snprintf returns failure ( %d )",
4591                                              len);
4592                                 content_str[0] = '\0';
4593                         } else {
4594                                 content_str[len] = '\0';
4595                         }
4596
4597                         len =
4598                             g_strlcat(condition_str, content_str,
4599                                       sizeof(condition_str));
4600                         if (len >= sizeof(condition_str)) {
4601                                 mb_svc_debug("strlcat returns failure ( %d )",
4602                                              len);
4603                                 return MB_SVC_ERROR_INVALID_PARAMETER;
4604                         }
4605                 }
4606
4607                 if (filter.file_type & MINFO_ITEM_VIDEO) {
4608                         len =
4609                             snprintf(content_str, sizeof(content_str),
4610                                      " or m.content_type=%d ",
4611                                      MINFO_ITEM_VIDEO);
4612                         if (len < 0) {
4613                                 mb_svc_debug("snprintf returns failure ( %d )",
4614                                              len);
4615                                 content_str[0] = '\0';
4616                         } else {
4617                                 content_str[len] = '\0';
4618                         }
4619
4620                         len =
4621                             g_strlcat(condition_str, content_str,
4622                                       sizeof(condition_str));
4623                         if (len >= sizeof(condition_str)) {
4624                                 mb_svc_debug("strlcat returns failure ( %d )",
4625                                              len);
4626                                 return MB_SVC_ERROR_INVALID_PARAMETER;
4627                         }
4628                 }
4629
4630                 len = g_strlcat(condition_str, ") ", sizeof(condition_str));
4631                 if (len >= sizeof(condition_str)) {
4632                         mb_svc_debug("strlcat returns failure ( %d )", len);
4633                         return MB_SVC_ERROR_INVALID_PARAMETER;
4634                 }
4635         }
4636
4637         if (filter.start_pos != MB_SVC_DB_DEFAULT_GET_ALL_RECORDS) {    /* -1 get all record */
4638                 int length = filter.end_pos - filter.start_pos + 1;
4639                 if (length <= 0) {
4640                         mb_svc_debug
4641                             ("start position and end position is invalid ( start:%d, end:%d )",
4642                              filter.start_pos, filter.end_pos);
4643                         return MB_SVC_ERROR_INVALID_PARAMETER;
4644                 }
4645
4646                 char limit_str[MB_SVC_DEFAULT_QUERY_SIZE] = { 0 };
4647                 len =
4648                     snprintf(limit_str, sizeof(limit_str), " LIMIT %d,%d",
4649                              filter.start_pos, length);
4650                 if (len < 0) {
4651                         mb_svc_debug("snprintf returns failure ( %d )", len);
4652                         limit_str[0] = '\0';
4653                 } else {
4654                         limit_str[len] = '\0';
4655                 }
4656
4657                 len =
4658                     g_strlcat(condition_str, limit_str, sizeof(condition_str));
4659                 if (len >= sizeof(condition_str)) {
4660                         mb_svc_debug("strlcat returns failure ( %d )", len);
4661                         return MB_SVC_ERROR_INVALID_PARAMETER;
4662                 }
4663         }
4664
4665         /* set to get only unlocked items */
4666         len =
4667             snprintf(query_string_with_lock_status,
4668                      sizeof(query_string_with_lock_status),
4669                      MB_SVC_TABLE_SELECT_TAG_ALL_QUERY_STRING_BY_TAG_NAME_WITH_LOCK_STATUS_AND_FILTER,
4670                      tag_name, 0, condition_str);
4671
4672         if (len < 0) {
4673                 mb_svc_debug("snprintf returns failure ( %d )", len);
4674                 query_string_with_lock_status[0] = '\0';
4675         } else {
4676                 query_string_with_lock_status[len] = '\0';
4677         }
4678
4679         mb_svc_debug("Query : %s", query_string_with_lock_status);
4680
4681         mb_svc_iterator->current_position = 0;
4682
4683         err =
4684             sqlite3_prepare_v2(handle, query_string_with_lock_status,
4685                                strlen(query_string_with_lock_status),
4686                                &mb_svc_iterator->stmt, NULL);
4687         if (SQLITE_OK != err) {
4688                 mb_svc_debug("prepare error [%s]", sqlite3_errmsg(handle));
4689                 mb_svc_debug("query string is %s\n",
4690                              query_string_with_lock_status);
4691                 return MB_SVC_ERROR_DB_INTERNAL;
4692         }
4693
4694         return 0;
4695 }
4696
4697 static int __mb_svc_delete_tag_by_id(MediaSvcHandle *mb_svc_handle, const int tag_id)
4698 {
4699         int err = -1;
4700         char *query_string = NULL;
4701         char *table_name = MB_SVC_TBL_NAME_TAG;
4702
4703         query_string =
4704             sqlite3_mprintf(MB_SVC_TABLE_DELETE_TAG_BY_TAGID, table_name,
4705                             tag_id);
4706
4707         err = mb_svc_query_sql(mb_svc_handle, query_string);
4708         sqlite3_free(query_string);
4709
4710         if (err < 0) {
4711                 mb_svc_debug("failed to delete tagmap\n");
4712                 return MB_SVC_ERROR_DB_INTERNAL;
4713         }
4714
4715         return err;
4716 }
4717
4718 int mb_svc_delete_tagmap_by_media_id(MediaSvcHandle *mb_svc_handle, const char *media_id)
4719 {
4720         int err = -1;
4721         char *query_string = NULL;
4722         char *table_name = MB_SVC_TBL_NAME_TAG_MAP;
4723
4724         query_string =
4725             sqlite3_mprintf(MB_SVC_TABLE_DELETE_TAG_MAP_BY_MEDIA_UUID, table_name,
4726                             media_id);
4727
4728         err = mb_svc_query_sql(mb_svc_handle, query_string);
4729         sqlite3_free(query_string);
4730
4731         if (err < 0) {
4732                 mb_svc_debug("failed to delete tagmap\n");
4733                 return MB_SVC_ERROR_DB_INTERNAL;
4734         }
4735
4736         return err;
4737 }
4738
4739 int mb_svc_delete_record_tag(MediaSvcHandle *mb_svc_handle, const char *tag_name, const char *media_id)
4740 {
4741         int err = -1;
4742         int tag_id = 0;
4743         int count = 0;
4744         char *query_string = NULL;
4745         char *table_name = MB_SVC_TBL_NAME_TAG_MAP;
4746
4747         if (tag_name == NULL) {
4748                 mb_svc_debug("tag_name pointer is null\n");
4749                 return MB_SVC_ERROR_INVALID_PARAMETER;
4750         }
4751
4752         tag_id = mb_svc_get_tagid_by_tagname(mb_svc_handle, tag_name);
4753         if (tag_id <= 0) {
4754                 mb_svc_debug("There's no tag %s in the table");
4755
4756                 return MB_SVC_ERROR_INVALID_PARAMETER;
4757         }
4758
4759         if (media_id == NULL) {
4760                 query_string =
4761                     sqlite3_mprintf(MB_SVC_TABLE_DELETE_TAG_MAP_BY_TAGNAME,
4762                                     table_name, tag_id);
4763         } else {
4764                 query_string =
4765                     sqlite3_mprintf
4766                     (MB_SVC_TABLE_DELETE_TAG_MAP_BY_TAGNAME_MEDIA_UUID,
4767                      table_name, media_id, tag_id);
4768         }
4769
4770         err = mb_svc_query_sql(mb_svc_handle, query_string);
4771         sqlite3_free(query_string);
4772
4773         if (err < 0) {
4774                 mb_svc_debug("failed to delete tagmap\n");
4775                 return MB_SVC_ERROR_DB_INTERNAL;
4776         }
4777
4778         count = __mb_svc_get_media_cnt_by_tagid(mb_svc_handle, tag_id);
4779
4780         if (count <= 0) {
4781                 err = __mb_svc_delete_tag_by_id(mb_svc_handle, tag_id);
4782                 if (err < 0) {
4783                         mb_svc_debug("__mb_svc_delete_tag_by_id : %d", tag_id);
4784                         return err;
4785                 }
4786         }
4787
4788         return err;
4789 }
4790
4791 int
4792 mb_svc_media_id_list_by_tag_iter_next(mb_svc_iterator_s *mb_svc_iterator,
4793                                       mb_svc_tag_record_s *record)
4794 {
4795         int err = -1;
4796
4797         if (record == NULL || mb_svc_iterator == NULL) {
4798                 mb_svc_debug("pointer record is null\n");
4799                 return MB_SVC_ERROR_INVALID_PARAMETER;
4800         }
4801
4802         err = sqlite3_step(mb_svc_iterator->stmt);
4803         if (err != SQLITE_ROW) {
4804                 mb_svc_debug("end of iteration : count = %d\n",
4805                              mb_svc_iterator->current_position);
4806                 return MB_SVC_NO_RECORD_ANY_MORE;
4807         }
4808
4809         record->_id = sqlite3_column_int(mb_svc_iterator->stmt, 0);
4810         //record->media_id = sqlite3_column_int(mb_svc_iterator->stmt, 1);
4811         strncpy(record->media_uuid, (const char *)sqlite3_column_text(mb_svc_iterator->stmt, 1), MB_SVC_UUID_LEN_MAX + 1);
4812         strncpy(record->tag_name, "", MB_SVC_ARRAY_LEN_MAX + 1);
4813
4814         mb_svc_iterator->current_position++;
4815         return 0;
4816 }
4817
4818 int
4819 mb_svc_tag_iter_next(mb_svc_iterator_s *mb_svc_iterator,
4820                      mb_svc_tag_record_s *record)
4821 {
4822         int err = -1;
4823
4824         if (record == NULL || mb_svc_iterator == NULL) {
4825                 mb_svc_debug("pointer record is null\n");
4826                 return MB_SVC_ERROR_INVALID_PARAMETER;
4827         }
4828
4829         err = sqlite3_step(mb_svc_iterator->stmt);
4830         if (err != SQLITE_ROW) {
4831                 mb_svc_debug("end of iteration : count = %d\n",
4832                              mb_svc_iterator->current_position);
4833                 return MB_SVC_NO_RECORD_ANY_MORE;
4834         }
4835
4836         err = mb_svc_load_record_tag(mb_svc_iterator->stmt, record);
4837         if (err < 0) {
4838                 mb_svc_debug("failed to load item\n");
4839                 sqlite3_finalize(mb_svc_iterator->stmt);
4840                 mb_svc_iterator->current_position = -1;
4841                 return MB_SVC_ERROR_DB_INTERNAL;
4842         }
4843         mb_svc_iterator->current_position++;
4844         return 0;
4845 }
4846
4847 int mb_svc_rename_record_tag(MediaSvcHandle *mb_svc_handle, const char *src_tagname, const char *dst_tag_name)
4848 {
4849         int err = 0;
4850
4851         int src_tag_id = mb_svc_get_tagid_by_tagname(mb_svc_handle, src_tagname);
4852
4853         if (src_tag_id <= 0) {
4854                 mb_svc_debug("there's no tag %s ", src_tagname);
4855                 return MB_SVC_ERROR_INVALID_PARAMETER;
4856         }
4857
4858         int dst_tag_id = mb_svc_get_tagid_by_tagname(mb_svc_handle, dst_tag_name);
4859
4860         if (dst_tag_id > 0) {
4861                 err = __mb_svc_update_tagmap(mb_svc_handle, src_tag_id, dst_tag_id);
4862         } else {
4863                 err = __mb_svc_update_tag(mb_svc_handle, src_tag_id, dst_tag_name);
4864         }
4865
4866         return err;
4867 }
4868
4869 int
4870 mb_svc_rename_record_tag_by_id(MediaSvcHandle *mb_svc_handle,
4871                                         const char *media_id,
4872                                         const char *src_tagname,
4873                                         const char *dst_tag_name)
4874 {
4875         int err = 0;
4876         mb_svc_tag_record_s tag_record = { 0 };
4877
4878         int src_tag_id = mb_svc_get_tagid_by_tagname(mb_svc_handle, src_tagname);
4879
4880         if (src_tag_id <= 0) {
4881                 mb_svc_debug("there's no tag %s ", src_tagname);
4882                 return MB_SVC_ERROR_INVALID_PARAMETER;
4883         }
4884
4885         int dst_tag_id = mb_svc_get_tagid_by_tagname(mb_svc_handle, dst_tag_name);
4886
4887         if (dst_tag_id > 0) {
4888                 err = __mb_svc_update_tagmap_by_media_id(mb_svc_handle, media_id, src_tag_id, dst_tag_id);
4889         } else {
4890
4891                 strncpy(tag_record.tag_name, dst_tag_name,
4892                         MB_SVC_ARRAY_LEN_MAX + 1);
4893
4894                 err = mb_svc_insert_record_tag(mb_svc_handle, &tag_record);
4895                 if (err < 0) {
4896                         mb_svc_debug("mb_svc_insert_record_tag fail\n");
4897                         return err;
4898                 }
4899
4900                 err = __mb_svc_update_tagmap_by_media_id(mb_svc_handle, media_id, src_tag_id, tag_record._id);
4901         }
4902
4903         return err;
4904 }
4905
4906 static int __mb_svc_update_tag(MediaSvcHandle *mb_svc_handle, int tag_id, const char *tag_name)
4907 {
4908         mb_svc_debug("");
4909
4910         int err = -1;
4911         char *query_string = NULL;
4912         char *table_name = MB_SVC_TBL_NAME_TAG;
4913
4914         query_string =
4915             sqlite3_mprintf(MB_SVC_TABLE_UPDATE_TAG_NAME_QUERY_STRING_BY_TAG_ID,
4916                             table_name, tag_name, tag_id);
4917
4918         mb_svc_debug("Query : %s", query_string);
4919
4920         err = mb_svc_query_sql(mb_svc_handle, query_string);
4921         sqlite3_free(query_string);
4922
4923         if (err < 0) {
4924                 mb_svc_debug("__mb_svc_update_tag failed\n");
4925                 return MB_SVC_ERROR_DB_INTERNAL;
4926         }
4927
4928         return err;
4929 }
4930
4931 static int __mb_svc_update_tagmap(MediaSvcHandle *mb_svc_handle, int src_tag_id, int dst_tag_id)
4932 {
4933         mb_svc_debug("");
4934
4935         int err = -1;
4936         char *query_string = NULL;
4937         char *table_name = MB_SVC_TBL_NAME_TAG_MAP;
4938
4939         query_string =
4940             sqlite3_mprintf(MB_SVC_TABLE_UPDATE_TAG_MAP_QUERY_STRING_BY_TAG_ID,
4941                             table_name, dst_tag_id, src_tag_id);
4942
4943         mb_svc_debug("Query : %s", query_string);
4944
4945         err = mb_svc_query_sql(mb_svc_handle, query_string);
4946         sqlite3_free(query_string);
4947
4948         if (err < 0) {
4949                 mb_svc_debug("mb_svc_update_tag failed\n");
4950                 return MB_SVC_ERROR_DB_INTERNAL;
4951         }
4952
4953         return err;
4954 }
4955
4956 static int __mb_svc_update_tagmap_by_media_id(MediaSvcHandle *mb_svc_handle,
4957                                         const char *media_id,
4958                                         int src_tag_id,
4959                                         int dst_tag_id)
4960 {
4961         mb_svc_debug("");
4962
4963         int err = -1;
4964         char *query_string = NULL;
4965         char *table_name = MB_SVC_TBL_NAME_TAG_MAP;
4966
4967         query_string =
4968             sqlite3_mprintf
4969             (MB_SVC_TABLE_UPDATE_TAG_MAP_QUERY_STRING_BY_TAG_ID_AND_MEDIA_ID,
4970              table_name, dst_tag_id, media_id, src_tag_id);
4971
4972         mb_svc_debug("Query : %s", query_string);
4973
4974         err = mb_svc_query_sql(mb_svc_handle, query_string);
4975         sqlite3_free(query_string);
4976
4977         if (err < 0) {
4978                 mb_svc_debug("mb_svc_update_tag failed\n");
4979                 return MB_SVC_ERROR_DB_INTERNAL;
4980         }
4981
4982         return err;
4983 }
4984
4985 int mb_svc_get_tagid_by_tagname(MediaSvcHandle *mb_svc_handle, const char *tag_name)
4986 {
4987         mb_svc_debug("");
4988         char *table_name = MB_SVC_TBL_NAME_TAG;
4989         char *query_string = NULL;
4990
4991         int rc = 0;
4992         sqlite3_stmt *stmt = NULL;
4993         int return_id = 0;
4994         int err = -1;
4995
4996         if (tag_name == NULL) {
4997                 mb_svc_debug("Error:tag_name == NULL");
4998                 return MB_SVC_ERROR_INVALID_PARAMETER;
4999         }
5000
5001         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
5002         if (handle == NULL) {
5003                 mb_svc_debug("handle is NULL");
5004                 return MB_SVC_ERROR_DB_INTERNAL;
5005         }
5006
5007         query_string =
5008             sqlite3_mprintf(MB_SVC_TABLE_SELECT_TAG_COUNT_QUERY_STRING,
5009                             table_name, tag_name);
5010
5011         err =
5012             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
5013                                &stmt, NULL);
5014         sqlite3_free(query_string);
5015
5016         if (SQLITE_OK != err) {
5017                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
5018                 return MB_SVC_ERROR_DB_INTERNAL;
5019         }
5020         rc = sqlite3_step(stmt);
5021         while (rc == SQLITE_ROW) {
5022                 return_id = sqlite3_column_int(stmt, 0);
5023                 rc = sqlite3_step(stmt);
5024         }
5025         sqlite3_finalize(stmt);
5026
5027         stmt = NULL;
5028
5029         return return_id;
5030 }
5031
5032 static int __mb_svc_get_media_cnt_by_tagid(MediaSvcHandle *mb_svc_handle, int tag_id)
5033 {
5034         int rc = 0;
5035         sqlite3_stmt *stmt = NULL;
5036         int count = 0;
5037         int err = -1;
5038         char *table_name = MB_SVC_TBL_NAME_TAG_MAP;
5039         char *query_string = NULL;
5040
5041         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
5042         if (handle == NULL) {
5043                 mb_svc_debug("handle is NULL");
5044                 return MB_SVC_ERROR_DB_INTERNAL;
5045         }
5046
5047         query_string =
5048             sqlite3_mprintf(MB_SVC_TABLE_SELECT_MEDIA_CNT_BY_TAGID, table_name,
5049                             tag_id);
5050
5051         err =
5052             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
5053                                &stmt, NULL);
5054         sqlite3_free(query_string);
5055
5056         if (SQLITE_OK != err) {
5057                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
5058                 return MB_SVC_ERROR_DB_INTERNAL;
5059         }
5060         rc = sqlite3_step(stmt);
5061         while (rc == SQLITE_ROW) {
5062                 count = sqlite3_column_int(stmt, 0);
5063                 rc = sqlite3_step(stmt);
5064         }
5065         sqlite3_finalize(stmt);
5066
5067         stmt = NULL;
5068         mb_svc_debug("record count is %d\n", count);
5069         return count;
5070 }
5071
5072 int mb_svc_add_web_streaming_folder(MediaSvcHandle *mb_svc_handle, char *folder_id)
5073 {
5074         mb_svc_folder_record_s folder_record = {"",};
5075         int ret = 0;
5076
5077         folder_record.modified_date = 0;
5078         folder_record.sns_type = 0;
5079         folder_record.storage_type = MINFO_WEB_STREAMING;
5080         strncpy(folder_record.uri, "", MB_SVC_DIR_PATH_LEN_MAX + 1);
5081         strncpy(folder_record.display_name, "", MB_SVC_FILE_NAME_LEN_MAX + 1);
5082         strncpy(folder_record.web_account_id, "", MB_SVC_ARRAY_LEN_MAX + 1);
5083         strncpy(folder_record.web_album_id, "", MB_SVC_ARRAY_LEN_MAX + 1);
5084
5085         ret = mb_svc_insert_record_folder(mb_svc_handle, &folder_record);
5086         if (ret < 0) {
5087                 mb_svc_debug("mb_svc_insert_record_folder failed\n");
5088                 return ret;
5089         }
5090
5091         strncpy(folder_id, folder_record.uuid, MB_SVC_UUID_LEN_MAX + 1);
5092
5093         return 0;
5094 }
5095
5096 int mb_svc_get_web_streaming_folder_uuid(MediaSvcHandle *mb_svc_handle, char *folder_uuid, int max_length)
5097 {
5098         int err = -1;
5099         char *table_name = MB_SVC_TBL_NAME_FOLDER;
5100         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
5101         sqlite3_stmt *stmt = NULL;
5102         int folder_id = 0;
5103
5104         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
5105         if (handle == NULL) {
5106                 mb_svc_debug("handle is NULL");
5107                 return MB_SVC_ERROR_DB_INTERNAL;
5108         }
5109
5110         snprintf(query_string, sizeof(query_string),
5111                  MB_SVC_TABLE_SELECT_FOLDER_UUID_BY_WEB_STREAMING, table_name,
5112                  MINFO_WEB_STREAMING);
5113         err =
5114             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
5115                                &stmt, NULL);
5116         if (SQLITE_OK != err) {
5117                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
5118                 mb_svc_debug("query string is %s\n", query_string);
5119                 return MB_SVC_ERROR_DB_INTERNAL;
5120         }
5121
5122         err = sqlite3_step(stmt);
5123         if (err != SQLITE_ROW) {
5124                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
5125                 mb_svc_debug("query string is %s\n", query_string);
5126                 sqlite3_finalize(stmt);
5127                 folder_id = -1;
5128                 return MB_SVC_ERROR_DB_INTERNAL;
5129         }
5130
5131         strncpy(folder_uuid, (const char *)sqlite3_column_text(stmt, 0), max_length);
5132
5133         sqlite3_finalize(stmt);
5134
5135         return 0;
5136 }
5137
5138 int mb_svc_get_media_id_by_full_path(MediaSvcHandle *mb_svc_handle, const char *file_full_path, char *media_id)
5139 {
5140         int err = 0;
5141         int folder_id = 0;
5142         char folder_uuid[MB_SVC_UUID_LEN_MAX + 1] = {0,};
5143         char file_display_name[MB_SVC_FILE_NAME_LEN_MAX + 1] = { 0 };
5144         char dir_full_path[MB_SVC_DIR_PATH_LEN_MAX + 1] = { 0 };
5145
5146         _mb_svc_get_file_parent_path(file_full_path, dir_full_path);
5147         _mb_svc_get_file_display_name(file_full_path, file_display_name);
5148
5149         err = mb_svc_get_folder_id_by_full_path(mb_svc_handle, dir_full_path, folder_uuid, sizeof(folder_uuid));
5150         if (err < 0) {
5151                 mb_svc_debug("mb_svc_get_folder_id_by_full_path fails:%s",
5152                              dir_full_path);
5153                 return err;
5154         }
5155
5156         _mb_svc_get_file_display_name(file_full_path, file_display_name);
5157         err = __mb_svc_get_media_id_by_fid_name(mb_svc_handle, folder_uuid, file_display_name, media_id);
5158         if (err < 0) {
5159                 mb_svc_debug("__mb_svc_get_media_id_by_fid_name fails:%d,%s",
5160                              folder_id, file_display_name);
5161                 return err;
5162         }
5163
5164         return 0;
5165 }
5166
5167 int mb_svc_get_media_id_by_http_url(MediaSvcHandle *mb_svc_handle, const char *http_url, char *media_id)
5168 {
5169         int err = -1;
5170         char *table_name = MB_SVC_TBL_NAME_MEDIA;
5171         char *query_string;
5172         sqlite3_stmt *stmt = NULL;
5173
5174         if (http_url == NULL) {
5175                 mb_svc_debug("Error: http_url == NULL");
5176                 return MB_SVC_ERROR_INVALID_PARAMETER;
5177         }
5178
5179         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
5180         if (handle == NULL) {
5181                 mb_svc_debug("handle is NULL");
5182                 return MB_SVC_ERROR_DB_INTERNAL;
5183         }
5184
5185         query_string =
5186             sqlite3_mprintf(MB_SVC_TABLE_SELECT_MEDIA_ID_BY_HTTP_URL,
5187                             table_name, http_url);
5188         mb_svc_debug("Query : %s", query_string);
5189
5190         err =
5191             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
5192                                &stmt, NULL);
5193         if (SQLITE_OK != err) {
5194                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
5195                 mb_svc_debug("query string is %s\n", query_string);
5196                 sqlite3_free(query_string);
5197                 return MB_SVC_ERROR_DB_INTERNAL;
5198         }
5199         err = sqlite3_step(stmt);
5200         if (err != SQLITE_ROW) {
5201                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
5202                 mb_svc_debug("query string is %s\n", query_string);
5203                 sqlite3_free(query_string);
5204                 sqlite3_finalize(stmt);
5205                 return MB_SVC_ERROR_DB_INTERNAL;
5206         }
5207
5208         strncpy(media_id, (const char *)sqlite3_column_text(stmt,0),
5209                 MB_SVC_UUID_LEN_MAX + 1);
5210
5211         sqlite3_free(query_string);
5212         sqlite3_finalize(stmt);
5213
5214         return 0;
5215 }
5216
5217 int
5218 mb_svc_get_media_record_by_full_path(MediaSvcHandle *mb_svc_handle,
5219                                         const char *file_full_path,
5220                                         mb_svc_media_record_s *record)
5221 {
5222         int err = -1;
5223         char *table_name = MB_SVC_TBL_NAME_MEDIA;
5224         char *query_string = NULL;
5225         sqlite3_stmt *p_Stmt_mb = NULL;
5226
5227         if (record == NULL) {
5228                 mb_svc_debug("media_record is null \n");
5229                 return MB_SVC_ERROR_INVALID_PARAMETER;
5230         }
5231
5232         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
5233         if (handle == NULL) {
5234                 mb_svc_debug("handle is NULL");
5235                 return MB_SVC_ERROR_DB_INTERNAL;
5236         }
5237
5238         query_string =
5239             sqlite3_mprintf(MB_SVC_TABLE_SELECT_MEDIA_BY_PATH, table_name,
5240                             file_full_path);
5241
5242         mb_svc_debug("Query : %s", query_string);
5243
5244         err =
5245             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
5246                                &p_Stmt_mb, NULL);
5247         sqlite3_free(query_string);
5248
5249         if (SQLITE_OK != err) {
5250                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
5251                 return MB_SVC_ERROR_DB_INTERNAL;
5252         }
5253         err = sqlite3_step(p_Stmt_mb);
5254         if (err != SQLITE_ROW) {
5255                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
5256                 sqlite3_finalize(p_Stmt_mb);
5257                 return MB_SVC_ERROR_DB_INTERNAL;
5258         }
5259         mb_svc_load_record_media(p_Stmt_mb, record);
5260
5261         sqlite3_finalize(p_Stmt_mb);
5262
5263         return 0;
5264 }
5265
5266 int mb_svc_delete_all_media_records(MediaSvcHandle *mb_svc_handle, const minfo_store_type storage_type)
5267 {
5268         mb_svc_debug("storage_type: %d", storage_type);
5269
5270         sqlite3_stmt *stmt = NULL;
5271
5272         int err = -1;
5273         char folder_uuid[MB_SVC_UUID_LEN_MAX + 1] = {0,};
5274
5275         char *sql = NULL;
5276         char table_name[MB_SVC_TABLE_NAME_MAX_LEN] = { 0, };
5277         GList *delete_media_list = NULL;
5278
5279         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
5280         if (handle == NULL) {
5281                 mb_svc_debug("handle is NULL");
5282                 return MB_SVC_ERROR_DB_INTERNAL;
5283         }
5284
5285         err = __mb_svc_get_all_media_list(mb_svc_handle, storage_type, &delete_media_list);
5286         if (err == MB_SVC_ERROR_DB_NO_RECORD) {
5287                 mb_svc_debug("There is no media");
5288                 return 0;
5289         } else if (err < 0) {
5290                 mb_svc_debug("__mb_svc_get_all_media_list failed : %d", err);
5291                 mb_svc_debug("Keep going to remove folder..");
5292         } else {
5293                 err = __mb_svc_delete_media_records_list(mb_svc_handle, delete_media_list);
5294                 if (err < 0) {
5295                         _mb_svc_glist_free(&delete_media_list, true);
5296                         mb_svc_debug
5297                                 ("__mb_svc_delete_media_records_list failed : %d", err);
5298                         return err;
5299                 }
5300         }
5301
5302         _mb_svc_glist_free(&delete_media_list, true);
5303
5304         /* Get folder list to remove */
5305         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
5306         snprintf(table_name, MB_SVC_TABLE_NAME_MAX_LEN, "%s",
5307                  MB_SVC_TBL_NAME_FOLDER);
5308
5309         sql =
5310             sqlite3_mprintf("select folder_uuid from %s where storage_type = %d;",
5311                             table_name, storage_type);
5312         err = sqlite3_prepare_v2(handle, sql, strlen(sql), &stmt, NULL);
5313
5314         mb_svc_debug("query string is %s\n", sql);
5315         sqlite3_free(sql);
5316
5317         if (SQLITE_OK != err) {
5318                 mb_svc_debug("prepare error [%s]", sqlite3_errmsg(handle));
5319                 return MB_SVC_ERROR_DB_INTERNAL;
5320         }
5321
5322         for (;;) {
5323                 err = sqlite3_step(stmt);
5324                 if (err != SQLITE_ROW) {
5325                         break;
5326                 }
5327
5328                 strncpy(folder_uuid, (const char *)sqlite3_column_text(stmt, 0), MB_SVC_UUID_LEN_MAX + 1);
5329
5330                 err = mb_svc_delete_record_folder_by_id(mb_svc_handle, folder_uuid);
5331                 if (err < 0) {
5332                         mb_svc_debug("mb_svc_delete_record_folder_by_id fail:%d\n", err);
5333                         return err;
5334                 }
5335         }
5336
5337         err = sqlite3_finalize(stmt);
5338         if (SQLITE_OK != err) {
5339                 mb_svc_debug("failed to clear row\n");
5340                 return MB_SVC_ERROR_DB_INTERNAL;
5341         }
5342
5343         return 0;
5344 }
5345
5346 int mb_svc_delete_invalid_media_records(MediaSvcHandle *mb_svc_handle, const minfo_store_type storage_type)
5347 {
5348         mb_svc_debug("storage_type: %d", storage_type);
5349
5350         sqlite3_stmt *stmt = NULL;
5351
5352         int err = -1;
5353         char folder_uuid[MB_SVC_UUID_LEN_MAX + 1] = {0,};
5354
5355         char *sql = NULL;
5356         char table_name[MB_SVC_TABLE_NAME_MAX_LEN] = { 0, };
5357         GList *invalid_media_list = NULL;
5358
5359         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
5360         if (handle == NULL) {
5361                 mb_svc_debug("handle is NULL");
5362                 return MB_SVC_ERROR_DB_INTERNAL;
5363         }
5364
5365         err = __mb_svc_get_invalid_media_list(mb_svc_handle, storage_type, &invalid_media_list);
5366         if (err == MB_SVC_ERROR_DB_NO_RECORD) {
5367                 mb_svc_debug("There is no invalid media");
5368                 return 0;
5369         } else if (err < 0) {
5370                 mb_svc_debug("__mb_svc_get_invalid_media_list failed : %d", err);
5371                 mb_svc_debug("Keep going to remove invalid folder..");
5372         } else {
5373                 err = __mb_svc_delete_media_records_list(mb_svc_handle, invalid_media_list);
5374                 if (err < 0) {
5375                         _mb_svc_glist_free(&invalid_media_list, true);
5376                         mb_svc_debug
5377                                 ("__mb_svc_delete_media_records_list failed : %d", err);
5378                         return err;
5379                 }
5380         }
5381
5382         _mb_svc_glist_free(&invalid_media_list, true);
5383
5384         /* Get folder list to remove, which is invalid */
5385         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
5386         snprintf(table_name, MB_SVC_TABLE_NAME_MAX_LEN, "%s",
5387                  MB_SVC_TBL_NAME_FOLDER);
5388
5389         sql =
5390             sqlite3_mprintf("select folder_uuid from %s where storage_type = %d and valid=0;",
5391                             table_name, storage_type);
5392         err = sqlite3_prepare_v2(handle, sql, strlen(sql), &stmt, NULL);
5393
5394         if (SQLITE_OK != err) {
5395                 mb_svc_debug("prepare error [%s]", sqlite3_errmsg(handle));
5396                 mb_svc_debug("query string is %s\n", sql);
5397                 sqlite3_free(sql);
5398                 return MB_SVC_ERROR_DB_INTERNAL;
5399         }
5400         sqlite3_free(sql);
5401
5402         for (;;) {
5403                 err = sqlite3_step(stmt);
5404                 if (err != SQLITE_ROW) {
5405                         break;
5406                 }
5407
5408                 strncpy(folder_uuid, (const char *)sqlite3_column_text(stmt, 0), MB_SVC_UUID_LEN_MAX + 1);
5409
5410                 err = mb_svc_delete_record_folder_by_id(mb_svc_handle, folder_uuid);
5411                 if (err < 0) {
5412                         mb_svc_debug("mb_svc_delete_record_folder_by_id fail:%d\n", err);
5413                         return err;
5414                 }
5415         }
5416
5417         err = sqlite3_finalize(stmt);
5418         if (SQLITE_OK != err) {
5419                 mb_svc_debug("failed to clear row\n");
5420                 return MB_SVC_ERROR_DB_INTERNAL;
5421         }
5422
5423         return 0;
5424 }
5425
5426 int mb_svc_get_all_item_count(
5427                                 MediaSvcHandle *mb_svc_handle,
5428                                 minfo_folder_type folder_type,
5429                                 minfo_file_type file_type,
5430                                 minfo_media_favorite_type fav_type,
5431                                 int *cnt)
5432 {
5433         char q_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
5434         char folder_type_str[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
5435         char file_type_str[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
5436         char fav_type_str[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
5437
5438         int rc = 0;
5439         sqlite3_stmt *stmt = NULL;
5440
5441         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
5442         if (handle == NULL) {
5443                 mb_svc_debug("handle is NULL");
5444                 return MB_SVC_ERROR_DB_INTERNAL;
5445         }
5446
5447         if (folder_type == MINFO_CLUSTER_TYPE_ALL) {
5448                 snprintf(folder_type_str, sizeof(folder_type_str), "%s", "1 and ");
5449         } else if (folder_type == MINFO_CLUSTER_TYPE_LOCAL_ALL) {
5450                 snprintf(folder_type_str, sizeof(folder_type_str), "%s", "(f.storage_type=0 or f.storage_type=1) and ");
5451         } else if (folder_type == MINFO_CLUSTER_TYPE_LOCAL_PHONE) {
5452                 snprintf(folder_type_str, sizeof(folder_type_str), "%s", "f.storage_type=0 and ");
5453         } else if (folder_type == MINFO_CLUSTER_TYPE_LOCAL_MMC) {
5454                 snprintf(folder_type_str, sizeof(folder_type_str), "%s", "f.storage_type=1 and ");
5455         } else if (folder_type == MINFO_CLUSTER_TYPE_WEB) {
5456                 snprintf(folder_type_str, sizeof(folder_type_str), "%s", "f.storage_type=2 and ");
5457         } else if (folder_type == MINFO_CLUSTER_TYPE_STREAMING) {
5458                 snprintf(folder_type_str, sizeof(folder_type_str), "%s", "f.storage_type=3 and ");
5459         } else {
5460                 mb_svc_debug("Invalid Folder type: %d", folder_type);
5461                 return MB_SVC_ERROR_INVALID_PARAMETER;
5462         }
5463
5464         if (file_type == MINFO_ITEM_ALL) {
5465                 snprintf(file_type_str, sizeof(file_type_str), "%s", " 1 and ");
5466         } else if (file_type == MINFO_ITEM_IMAGE) {
5467                 snprintf(file_type_str, sizeof(file_type_str), "%s", " m.content_type=1 and ");
5468         } else if (file_type == MINFO_ITEM_VIDEO) {
5469                 snprintf(file_type_str, sizeof(file_type_str), "%s", " m.content_type=2 and ");
5470         } else {
5471                 mb_svc_debug("Invalid File type: %d", folder_type);
5472                 return MB_SVC_ERROR_INVALID_PARAMETER;
5473         }
5474
5475         if (fav_type == MINFO_MEDIA_FAV_ALL) {
5476                 snprintf(fav_type_str, sizeof(fav_type_str), "%s", " 1");
5477         } else if (fav_type == MINFO_MEDIA_FAV_ONLY) {
5478                 snprintf(fav_type_str, sizeof(fav_type_str), "%s", " m.rating=1");
5479         } else if (fav_type == MINFO_MEDIA_UNFAV_ONLY) {
5480                 snprintf(fav_type_str, sizeof(fav_type_str), "%s", " m.rating=0");
5481         } else {
5482                 mb_svc_debug("Invalid favorite type: %d", folder_type);
5483                 return MB_SVC_ERROR_INVALID_PARAMETER;
5484         }
5485
5486         int len =
5487             snprintf(q_string, sizeof(q_string), MB_SVC_SELECT_ALL_ITEM_COUNT,
5488                      MB_SVC_TBL_NAME_MEDIA, folder_type_str, file_type_str, fav_type_str);
5489         if (len < 0) {
5490                 mb_svc_debug("snprintf returns failure ( %d )", len);
5491                 q_string[0] = '\0';
5492         } else {
5493                 q_string[len] = '\0';
5494         }
5495
5496         mb_svc_debug("Query : %s", q_string);
5497
5498         rc = sqlite3_prepare_v2(handle, q_string, strlen(q_string), &stmt,
5499                                 NULL);
5500         if (SQLITE_OK != rc) {
5501                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
5502                 return MB_SVC_ERROR_DB_INTERNAL;
5503         }
5504
5505         rc = sqlite3_step(stmt);
5506         while (rc == SQLITE_ROW) {
5507                 *cnt = sqlite3_column_int(stmt, 0);
5508                 rc = sqlite3_step(stmt);
5509         }
5510
5511         sqlite3_finalize(stmt);
5512         stmt = NULL;
5513
5514         return 0;
5515 }
5516
5517 int mb_svc_get_media_count_by_tagname(MediaSvcHandle *mb_svc_handle, const char *tagname, int *count)
5518 {
5519         char q_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
5520         int rc = 0;
5521         sqlite3_stmt *stmt = NULL;
5522
5523         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
5524         if (handle == NULL) {
5525                 mb_svc_debug("handle is NULL");
5526                 return MB_SVC_ERROR_DB_INTERNAL;
5527         }
5528
5529         char *tag_name_with_escape = NULL;
5530         tag_name_with_escape = sqlite3_mprintf("%q", tagname);
5531
5532         int len =
5533             snprintf(q_string, sizeof(q_string),
5534                      MB_SVC_TABLE_SELECT_COUNT_BY_TAG_NAME_WITH_LOCK_STATUS,
5535                      tag_name_with_escape, 0);
5536         if (len < 0) {
5537                 mb_svc_debug("snprintf returns failure ( %d )", len);
5538                 q_string[0] = '\0';
5539         } else {
5540                 q_string[len] = '\0';
5541         }
5542
5543         sqlite3_free(tag_name_with_escape);
5544
5545         rc = sqlite3_prepare_v2(handle, q_string, strlen(q_string), &stmt,
5546                                 NULL);
5547         if (SQLITE_OK != rc) {
5548                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
5549                 return MB_SVC_ERROR_DB_INTERNAL;
5550         }
5551
5552         rc = sqlite3_step(stmt);
5553         while (rc == SQLITE_ROW) {
5554                 *count = sqlite3_column_int(stmt, 0);
5555                 rc = sqlite3_step(stmt);
5556         }
5557
5558         sqlite3_finalize(stmt);
5559         stmt = NULL;
5560
5561         return 0;
5562 }
5563