src/visual/media-svc-db.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
  22 #include <string.h>
  23 #include <util-func.h>
  24 #include <sys/stat.h>
  25 #include "media-svc-env.h"
  26 #include "media-svc-util.h"
  27 #include "media-svc-db.h"
  28 #include "visual-svc-debug.h"
  29 #include "media-svc-db-util.h"
  30 #include "visual-svc-util.h"
  31 #include "media-svc-api.h"
  32 #include "media-svc-structures.h"
  33 #include "visual-svc-types.h"
  34 #include "visual-svc-error.h"
  35
  36 /**
  37  * Enumerations for table name.
  38  */
  39 typedef enum {
  40         MB_SVC_TABLE_NONE = -1,
  41         MB_SVC_TABLE_BOOKMARK,
  42         MB_SVC_TABLE_FOLDER,
  43         MB_SVC_TABLE_WEB_STREAMING,
  44         MB_SVC_TABLE_MEDIA,
  45         MB_SVC_TABLE_VIDEO_META,
  46         MB_SVC_TABLE_IMAGE_META,
  47         MB_SVC_TABLE_TAG_MAP,
  48         MB_SVC_TABLE_TAG,
  49         MB_SVC_TABLE_NUM,
  50 } mb_svc_tbl_name_e;
  51
  52
  53 /**
  54  * Enumerations for bookmark field name.
  55  */
  56 typedef enum {
  57         MB_SVC_BOOKMARK_NONE            = -1,
  58         MB_SVC_BOOKMARK_ID,
  59         MB_SVC_BOOKMARK_MEDIA_UUID,
  60         MB_SVC_BOOKMARK_MARKED_TIME,
  61         MB_SVC_BOOKMARK_THUMBNAIL_PATH,
  62         MB_SVC_BOOKMARK_NUM,
  63 } mb_svc_bookmark_field_e;
  64
  65 /**
  66  * Enumerations for FOLDER field name.
  67  */
  68 typedef enum {
  69         MB_SVC_FOLDER_NONE              = -1,
  70         MB_SVC_FOLDER_UUID,
  71         MB_SVC_FOLDER_PATH,
  72         MB_SVC_FOLDER_DISPLAY_NAME,
  73         MB_SVC_FOLDER_MODIFIED_DATE,
  74         MB_SVC_FOLDER_WEB_ACCOUNT_ID,
  75         MB_SVC_FOLDER_STORAGE_TYPE,
  76         MB_SVC_FOLDER_SNS_TYPE,
  77         MB_SVC_FOLDER_ALBUM_LOCK_STATUS,
  78         MB_SVC_FOLDER_WEB_ALBUM_ID,
  79         MB_SVC_FOLDER_VALID,
  80         MB_SVC_FOLDER_NUM,
  81 } mb_svc_folder_field_e;
  82 /**
  83  * Enumerations for web_streaming field name.
  84  */
  85 typedef enum {
  86         MB_SVC_WEB_STREAMING_NONE               = -1,
  87         MB_SVC_WEB_STREAMING_ID,
  88         MB_SVC_WEB_STREAMING_FOLDER_UUID,
  89         MB_SVC_WEB_STREAMING_TITLE,
  90         MB_SVC_WEB_STREAMING_DURATION,
  91         MB_SVC_WEB_STREAMING_URL,
  92         MB_SVC_WEB_STREAMING_THNMB_PATH,
  93         MB_SVC_WEB_STREAMING_NUM,
  94 } mb_svc_web_streaming_field_e;
  95
  96
  97 /**
  98  * Enumerations for MEDIA field name.
  99  */
 100 typedef enum {
 101         MB_SVC_MEDIA_NONE               = -1,
 102         MB_SVC_MEDIA_UUID,
 103         MB_SVC_MEDIA_PATH,
 104         MB_SVC_MEDIA_FOLDER_UUID,
 105         MB_SVC_MEDIA_DISPLAY_NAME,
 106         MB_SVC_MEDIA_CONTENT_TYPE,
 107         MB_SVC_MEDIA_RATING,
 108         MB_SVC_MEDIA_MODIFIED_DATE,
 109         MB_SVC_MEDIA_THUMBNAIL_PATH,
 110         MB_SVC_MEDIA_HTTP_URL,
 111         MB_SVC_MEDIA_SIZE,
 112         MB_SVC_MEDIA_VALID,
 113         MB_SVC_MEDIA_NUM,
 114 } mb_svc_media_field_e;
 115
 116 /**
 117  * Enumerations for videl_meta field name.
 118  */
 119 typedef enum {
 120         MB_SVC_VIDEO_META_NONE          = -1,
 121         MB_SVC_VIDEO_META_ID,
 122         MB_SVC_VIDEO_META_MEDIA_UUID,
 123         MB_SVC_VIDEO_META_ALBUM,
 124         MB_SVC_VIDEO_META_ARTIST,
 125         MB_SVC_VIDEO_META_TITLE,
 126         MB_SVC_VIDEO_META_GENRE,
 127         MB_SVC_VIDEO_META_DESCRIPTION,
 128         MB_SVC_VIDEO_META_YOUTUBE_CATEGORY,
 129         MB_SVC_VIDEO_META_BOOKMARK_LAST_PLAYED,
 130         MB_SVC_VIDEO_META_DURATION,
 131         MB_SVC_VIDEO_META_LONGISTUDE,
 132         MB_SVC_VIDEO_META_LATITUDE,
 133         MB_SVC_VIDEO_META_WIDTH,
 134         MB_SVC_VIDEO_META_HEIGHT,
 135         MB_SVC_VIDEO_META_DATETAKEN,
 136         MB_SVC_VIDEO_META_NUM,
 137 } mb_svc_video_meta_field_e;
 138
 139
 140 /**
 141  * Enumerations for IMAGE_META field name.
 142  */
 143 typedef enum {
 144         MB_SVC_IMAGE_META_NONE          = -1,
 145         MB_SVC_IMAGE_META_ID,
 146         MB_SVC_IMAGE_META_MEDIA_UUID,
 147         MB_SVC_IMAGE_META_LONGISTUDE,
 148         MB_SVC_IMAGE_META_LATITUDE,
 149         MB_SVC_IMAGE_META_DESCRIPTION,
 150         MB_SVC_IMAGE_META_WIDTH,
 151         MB_SVC_IMAGE_META_HEIGHT,
 152         MB_SVC_IMAGE_META_ORIENTATION,
 153         MB_SVC_IMAGE_META_DATETAKEN,
 154         MB_SVC_IMAGE_META_NUM,
 155 } mb_svc_image_meta_field_e;
 156
 157 /**
 158  * Enumerations for VISUAL_TAG_MAP field name.
 159  */
 160 typedef enum {
 161         MB_SVC_TAG_MAP_NONE             = -1,
 162         MB_SVC_TAG_MAP_ID,
 163         MB_SVC_TAG_MAP_MEDIA_UUID,
 164         MB_SVC_TAG_MAP_TAG_ID,
 165         MB_SVC_TAG_MAP_NUM,
 166 } mb_svc_tag_map_field_e;
 167
 168 /**
 169  * Enumerations for VISUAL_TAG field name.
 170  */
 171 typedef enum {
 172         MB_SVC_TAG_NONE         = -1,
 173         MB_SVC_TAG_ID,
 174         MB_SVC_TAG_NAME,
 175         MB_SVC_TAG_NUM,
 176 } mb_svc_tag_field_e;
 177
 178 /**
 179  *      table fields information
 180  */
 181 typedef struct {
 182          char *field_name;
 183          char *field_type;
 184 }mb_svc_tbl_field_s;
 185
 186 /**
 187  *      table information
 188  */
 189
 190 #define MB_SVC_FIELD_CNT_MAX 16
 191 #define MB_SVC_TABLE_CNT_MAX 8
 192
 193 typedef struct {
 194         char *table_name;
 195         mb_svc_tbl_field_s mb_svc_field[MB_SVC_FIELD_CNT_MAX];
 196         char *primary_key;
 197 } mb_svc_tbl_s;
 198
 199
 200 mb_svc_tbl_s mb_svc_tbl[MB_SVC_TABLE_CNT_MAX] = {
 201         {"video_bookmark", {
 202                             {"_id", "INTEGER"} ,        /* PK */
 203                             {"visual_uuid", "VARCHAR(256)"} ,
 204                             {"marked_time", "INT"}
 205                             ,
 206                             {"thumbnail_path", "VARCHAR(256)"}
 207                             ,
 208                             {0}
 209                             }
 210          ,
 211          ", primary key (_id)"}
 212         ,
 213
 214         {"visual_folder", {
 215                            {"folder_uuid", "VARCHAR(256)"} ,    /* PK */
 216                            {"path", "VARCHAR(256)"} ,   /* full path */
 217                            {"folder_name", "VARCHAR(256)"}
 218                            ,
 219                            {"modified_date", "INT"}
 220                            ,
 221                            {"web_account_id", "VARCHAR(256)"}
 222                            ,
 223                            {"storage_type", "INT"}
 224                            ,
 225                            {"sns_type", "INT"}
 226                            ,
 227                            {"lock_status", "INT"}
 228                            ,
 229                            {"web_album_id", "VARCHAR(256)"}
 230                            ,
 231                            {"valid", "INT"}
 232                            ,
 233                            {0}
 234                            }
 235          ,
 236          ", primary key (_id)"}
 237         ,
 238
 239         {"web_streaming", {
 240                            {"_id", "INTEGER"} /* PK */
 241                            ,
 242                            {"folder_uuid", "VARCHAR(256)"}      /* FK, folder table */
 243                            ,
 244                            {"title", "VARCHAR(256)"}
 245                            ,
 246                            {"duration", "INT"}
 247                            ,
 248                            {"url", "VARCHAR(256)"}
 249                            ,
 250                            {"thumb_path", "VARCHAR(256)"}
 251                            ,
 252                            {0}
 253                            }
 254          ,
 255          ", primary key (_id)"}
 256         ,
 257
 258         {"visual_media", {
 259                           {"visual_uuid", "VARCHAR(256)"}
 260                           ,
 261                           {"path", "VARCHAR(256)"}
 262                           ,
 263                           {"folder_uuid", "VARCHAR(256)"}
 264                           ,
 265                           {"display_name", "VARCHAR(256)"}
 266                           ,
 267                           {"content_type", "INT"}
 268                           ,
 269                           {"rating", "INT"}
 270                           ,
 271                           {"modified_date", "INT"}
 272                           ,
 273                           {"thumbnail_path", "VARCHAR(256)"}
 274                           ,
 275                           {"http_url", "VARCHAR(256)"}
 276                           ,
 277                           {"size", "INT"}
 278                           ,
 279                           {"valid", "INT"}
 280                           ,
 281                           {0}
 282                           }
 283          ,
 284          ", primary key (_id)"}
 285         ,
 286
 287         {"video_meta", {
 288                         {"_id", "INTEGER"}
 289                         ,
 290                         {"visual_uuid", "VARCHAR(256)"}
 291                         ,
 292                         {"album", "VARCHAR(256)"}
 293                         ,
 294                         {"artist", "VARCHAR(256)"}
 295                         ,
 296                         {"title", "VARCHAR(256)"}
 297                         ,
 298                         {"genre", "VARCHAR(256)"}
 299                         ,
 300                         {"description", "VARCHAR(256)"}
 301                         ,
 302                         {"youtube_category", "VARCHAR(256)"}
 303                         ,
 304                         {"last_played_time", "INT"}
 305                         ,
 306                         {"duration", "INT"}
 307                         ,
 308                         {"longitude", "DOUBLE"}
 309                         ,
 310                         {"latitude", "DOUBLE"}
 311                         ,
 312                         {"width", "INT"}
 313                         ,
 314                         {"height", "INT"}
 315                         ,
 316                         {"datetaken", "INT"}
 317                         ,
 318                         {0}
 319                         }
 320          ,
 321          ", primary key (_id)"}
 322         ,
 323
 324         {"image_meta", {
 325                         {"_id", "INTEGER"}
 326                         ,
 327                         {"visual_uuid", "VARCHAR(256)"}
 328                         ,
 329                         {"longitude", "DOUBLE"}
 330                         ,
 331                         {"latitude", "DOUBLE"}
 332                         ,
 333                         {"description", "VARCHAR(256)"}
 334                         ,
 335                         {"width", "INT"}
 336                         ,
 337                         {"height", "INT"}
 338                         ,
 339                         {"orientation", "INT"}
 340                         ,
 341                         {"datetaken", "INT"}
 342                         ,
 343                         {0}
 344                         }
 345          ,
 346          ", primary key (_id)"}
 347         ,
 348
 349         {"visual_tag_map", {
 350                             {"_id", "INTEGER"} /* PK */
 351                             ,
 352                                 {"visual_uuid", "VARCHAR(256)"}
 353                             ,
 354                             {"tag_id", "INT"}
 355                             ,
 356                             {0}
 357                             }
 358          ,
 359          ", primary key (_id)"}
 360         ,
 361
 362         {"visual_tag", {
 363                         {"_id", "INTEGER"} /* FK, media table */
 364                         ,
 365                         {"tag_name", "VARCHAR(256)"}
 366                         ,
 367                         {0}
 368                         }
 369          ,
 370          ", primary key (_id)"}
 371 };
 372
 373 int field_num_max[MB_SVC_TABLE_CNT_MAX] = { MB_SVC_BOOKMARK_NUM,
 374         MB_SVC_FOLDER_NUM,
 375         MB_SVC_WEB_STREAMING_NUM,
 376         MB_SVC_MEDIA_NUM,
 377         MB_SVC_VIDEO_META_NUM,
 378         MB_SVC_IMAGE_META_NUM,
 379         MB_SVC_TAG_MAP_NUM,
 380         MB_SVC_TAG_NUM
 381 };
 382
 383 static __thread GList *g_sql_list = NULL;
 384 static __thread char g_last_updated_folder_uuid[MB_SVC_UUID_LEN_MAX + 1] = {0,};
 385
 386 static int __mb_svc_delete_record(MediaSvcHandle *mb_svc_handle, int id, mb_svc_tbl_name_e tbl_name);
 387 static int __mb_svc_delete_record_by_uuid(MediaSvcHandle *mb_svc_handle, const char *id, mb_svc_tbl_name_e tbl_name);
 388 static int __mb_svc_db_get_next_id(MediaSvcHandle *mb_svc_handle, int table_id);
 389
 390
 391 int mb_svc_set_folder_as_valid_sql_add(const char *folder_id, int valid)
 392 {
 393         mb_svc_debug("Folder ID:%s, valid:%d", folder_id, valid);
 394         char *sql = NULL;
 395
 396         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_FOLDER;
 397
 398         char table_name[MB_SVC_TABLE_NAME_MAX_LEN] = { 0, };
 399         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
 400
 401         snprintf(table_name, MB_SVC_TABLE_NAME_MAX_LEN, "%s",
 402                  mb_svc_tbl[field_seq].table_name);
 403
 404         sql = sqlite3_mprintf(MB_SVC_UPDATE_FOLDER_VALID_BY_UUID,
 405                                                                                 table_name,
 406                                                                                 valid,
 407                                                                                 folder_id);
 408
 409         mb_svc_sql_list_add(&g_sql_list, &sql);
 410
 411         return 0;
 412 }
 413
 414 int mb_svc_set_item_as_valid_sql_add(MediaSvcHandle *mb_svc_handle, const char *full_path, int valid)
 415 {
 416         mb_svc_debug("full path: %s, valid:%d", full_path, valid);
 417
 418         mb_svc_media_record_s media_record = {"",};
 419         int ret = -1;
 420
 421         if (full_path == NULL) {
 422                 mb_svc_debug("full_path == NULL \n");
 423                 return MB_SVC_ERROR_INVALID_PARAMETER;
 424         }
 425
 426         ret = mb_svc_get_media_record_by_full_path(mb_svc_handle, full_path, &media_record);
 427         if (ret < 0) {
 428                 mb_svc_debug(" mb_svc_get_media_record_by_full_path fails (%d)", ret);
 429                 return ret;
 430         }
 431         mb_svc_debug("Media ID : %s", media_record.media_uuid);
 432
 433         /* Set the record as valid/invalid in 'media' table */
 434         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_MEDIA;
 435
 436         char table_name[MB_SVC_TABLE_NAME_MAX_LEN] = { 0, };
 437         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
 438
 439         snprintf(table_name, MB_SVC_TABLE_NAME_MAX_LEN, "%s",
 440                  mb_svc_tbl[field_seq].table_name);
 441
 442         char *sql =
 443             sqlite3_mprintf(MB_SVC_UPDATE_MEDIA_VALID_BY_UUID, table_name, valid,
 444                             media_record.media_uuid);
 445
 446         mb_svc_sql_list_add(&g_sql_list, &sql);
 447
 448         if ((valid == 1) && (strcmp(g_last_updated_folder_uuid, media_record.folder_uuid) != 0)) {
 449                 strncpy(g_last_updated_folder_uuid, media_record.folder_uuid, MB_SVC_UUID_LEN_MAX + 1);
 450
 451                 ret =
 452                     mb_svc_set_folder_as_valid_sql_add(media_record.folder_uuid, valid);
 453                 if (ret < 0) {
 454                         mb_svc_debug
 455                             ("mb_svc_update_folder_valid_sql_add fail:%d\n", ret);
 456                         return ret;
 457                 }
 458         }
 459
 460         return 0;
 461 }
 462
 463 int mb_svc_set_item_as_valid(MediaSvcHandle *mb_svc_handle)
 464 {
 465         mb_svc_debug("");
 466         int i = 0;
 467         int length = g_list_length(g_sql_list);
 468
 469         for (i = 0; i < length; i++) {
 470                 char *sql = (char*)g_list_nth_data(g_sql_list, i);
 471                 mb_svc_query_sql(mb_svc_handle, sql);
 472         }
 473
 474         mb_svc_sql_list_release(&g_sql_list);
 475
 476         return 0;
 477 }
 478
 479 mb_svc_tbl_s *mb_svc_search_matched_svc_tbl(mb_svc_tbl_name_e tbl_name)
 480 {
 481         int i;
 482
 483         if (tbl_name <= MB_SVC_TABLE_NONE || tbl_name >= MB_SVC_TABLE_NUM) {
 484                 mb_svc_debug("table name is invalid\n");
 485                 return NULL;
 486         }
 487
 488         char *table_name = mb_svc_tbl[tbl_name].table_name;
 489
 490         if (table_name == NULL) {
 491                 mb_svc_debug("table_name pointer is null\n");
 492                 return NULL;
 493         }
 494
 495         for (i = 0; i < MB_SVC_TABLE_CNT_MAX; ++i) { /* search the matched table */
 496                 if (!strncmp
 497                     (table_name, mb_svc_tbl[i].table_name,
 498                      MB_SVC_ARRAY_LEN_MAX)) {
 499                         return &mb_svc_tbl[i];
 500                 }
 501         }
 502         mb_svc_debug("error, no matched mb svc table found. %s", table_name);
 503         return NULL;
 504 }
 505
 506 int _mb_svc_table_exist(MediaSvcHandle *mb_svc_handle, char *table_name)
 507 {
 508         char szQuery[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
 509         int ret = -1;;
 510         char szTableName[64] = { 0 };
 511         char *pszTempName = NULL;
 512         sqlite3_stmt *pstStmt_pb = NULL;
 513
 514         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
 515         if (handle == NULL) {
 516                 mb_svc_debug("handle is NULL");
 517                 return MB_SVC_ERROR_DB_INTERNAL;
 518         }
 519
 520         if (table_name == NULL) {
 521                 mb_svc_debug("table_name pointer is null\n");
 522                 return MB_SVC_ERROR_INVALID_PARAMETER;
 523         }
 524         snprintf(szQuery, sizeof(szQuery), MB_SVC_TABLE_EXIST_QUERY_STRING,
 525                  table_name);
 526
 527         ret =
 528             sqlite3_prepare_v2(handle, szQuery, strlen(szQuery), &pstStmt_pb,
 529                                NULL);
 530         if (SQLITE_OK != ret) {
 531                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
 532                 mb_svc_debug("query string is %s\n", szQuery);
 533                 return MB_SVC_ERROR_DB_INTERNAL;
 534         }
 535
 536         ret = sqlite3_step(pstStmt_pb);
 537         if (SQLITE_ROW != ret) {
 538                 mb_svc_debug("end of row [%s]\n", sqlite3_errmsg(handle));
 539                 mb_svc_debug("query string is %s\n", szQuery);
 540                 sqlite3_finalize(pstStmt_pb);
 541                 return MB_SVC_ERROR_DB_INTERNAL;
 542         }
 543
 544         pszTempName = (char *)sqlite3_column_text(pstStmt_pb, 0);
 545         if (NULL != pszTempName) {
 546                 strncpy(szTableName, pszTempName, strlen(pszTempName));
 547         }
 548         sqlite3_finalize(pstStmt_pb);
 549
 550         mb_svc_debug("if [%s]=[%s], table exist!!!\n", table_name, szTableName);
 551         ret = !(strcmp(table_name, szTableName));
 552
 553         return ret;
 554 }
 555
 556 int _mb_svc_truncate_tbl(MediaSvcHandle *mb_svc_handle)
 557 {
 558         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
 559         int i, err;
 560         char *table_name;
 561         mb_svc_debug("_mb_svc_truncate_tbl--enter\n");
 562
 563         for (i = 0; i < MB_SVC_TABLE_CNT_MAX; ++i) {
 564                 table_name = mb_svc_tbl[i].table_name;
 565                 if (table_name == NULL) {
 566                         mb_svc_debug("table_name is null\n");
 567                         return MB_SVC_ERROR_INVALID_PARAMETER;
 568                 }
 569                 err = _mb_svc_table_exist(mb_svc_handle, table_name);
 570                 if (err > 0) {
 571                         snprintf(query_string, sizeof(query_string),
 572                                  MB_SVC_TABLE_DELETE_QUERY_STRING, table_name);
 573                         err = mb_svc_query_sql(mb_svc_handle, query_string);
 574                         if (err < 0) {
 575                                 mb_svc_debug("truncate table failed\n");
 576                                 mb_svc_debug("query string is %s\n",
 577                                              query_string);
 578                                 return MB_SVC_ERROR_DB_INTERNAL;
 579                         }
 580                 }
 581         }
 582         mb_svc_debug("_mb_svc_truncate_tbl--leave\n");
 583         return 0;
 584 }
 585
 586 static int __mb_svc_db_get_next_id(MediaSvcHandle *mb_svc_handle, int table_id)
 587 {
 588         int ret = 0;
 589         sqlite3_stmt *stmt = NULL;
 590         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
 591
 592         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
 593         if (handle == NULL) {
 594                 mb_svc_debug("handle is NULL");
 595                 return MB_SVC_ERROR_DB_INTERNAL;
 596         }
 597
 598         snprintf(query_string, sizeof(query_string), "select max(_id) from %s;",
 599                  (char *)mb_svc_tbl[table_id].table_name);
 600
 601         mb_svc_debug("Query : %s", query_string);
 602         ret =
 603             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
 604                                &stmt, NULL);
 605
 606         if (ret != SQLITE_OK) {
 607                 mb_svc_debug("Make Sequence error for prepare %s",
 608                              sqlite3_errmsg(handle));
 609                 return MB_SVC_ERROR_DB_INTERNAL;
 610         }
 611
 612         ret = sqlite3_step(stmt);
 613         if (ret != SQLITE_ROW) {
 614                 mb_svc_debug("There's no record %s", sqlite3_errmsg(handle));
 615
 616                 sqlite3_finalize(stmt);
 617                 stmt = NULL;
 618                 return MB_SVC_ERROR_DB_INTERNAL;
 619         }
 620         ret = sqlite3_column_int(stmt, 0);
 621
 622         sqlite3_finalize(stmt);
 623         stmt = NULL;
 624
 625         mb_svc_debug("Next ID : %d", ret + 1);
 626
 627         return ret + 1;
 628 }
 629
 630 static int __mb_svc_delete_record(MediaSvcHandle *mb_svc_handle, int id, mb_svc_tbl_name_e tbl_name)
 631 {
 632         int err = -1;
 633         mb_svc_tbl_s *matched_tbl = NULL;
 634         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
 635         char table_name[MB_SVC_TABLE_NAME_MAX_LEN] = { 0, };
 636         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
 637
 638         if (id <= 0) {
 639                 mb_svc_debug("id is wrong");
 640                 return MB_SVC_ERROR_INVALID_PARAMETER;
 641         }
 642
 643         if (tbl_name <= MB_SVC_TABLE_NONE || tbl_name >= MB_SVC_TABLE_NUM) {
 644                 mb_svc_debug("table name is invalid\n");
 645                 return MB_SVC_ERROR_INVALID_PARAMETER;
 646         }
 647
 648         matched_tbl = mb_svc_search_matched_svc_tbl(tbl_name);
 649         if (matched_tbl != NULL) {
 650                 snprintf(table_name, sizeof(table_name), "%s",
 651                          mb_svc_tbl[tbl_name].table_name);
 652                 snprintf(query_string, sizeof(query_string),
 653                          MB_SVC_RECORD_DELETE_QUERY_STRING, table_name, id);
 654
 655                 mb_svc_debug("Query: %s", query_string);
 656
 657                 err = mb_svc_query_sql(mb_svc_handle, query_string);
 658                 if (err < 0) {
 659                         mb_svc_debug("failed to delete record\n");
 660                         mb_svc_debug("query string is %s\n", query_string);
 661                         return MB_SVC_ERROR_DB_INTERNAL;
 662                 } else {
 663                         mb_svc_debug("Succeed to delete record\n");
 664                         mb_svc_debug("query string is %s\n", query_string);
 665                 }
 666         } else {
 667                 mb_svc_debug("failed to delete record\n");
 668                 return MB_SVC_ERROR_DB_INTERNAL;
 669         }
 670
 671         return 0;
 672 }
 673
 674 static int __mb_svc_delete_record_by_uuid(MediaSvcHandle *mb_svc_handle, const char *id, mb_svc_tbl_name_e tbl_name)
 675 {
 676         int err = -1;
 677         mb_svc_tbl_s *matched_tbl = NULL;
 678         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
 679         char table_name[MB_SVC_TABLE_NAME_MAX_LEN] = { 0, };
 680         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
 681
 682         if (id == NULL) {
 683                 mb_svc_debug("id is NULL");
 684                 return MB_SVC_ERROR_INVALID_PARAMETER;
 685         }
 686
 687         if (tbl_name <= MB_SVC_TABLE_NONE || tbl_name >= MB_SVC_TABLE_NUM) {
 688                 mb_svc_debug("table name is invalid\n");
 689                 return MB_SVC_ERROR_INVALID_PARAMETER;
 690         }
 691
 692         matched_tbl = mb_svc_search_matched_svc_tbl(tbl_name);
 693         if (matched_tbl != NULL) {
 694                 snprintf(table_name, sizeof(table_name), "%s",
 695                          mb_svc_tbl[tbl_name].table_name);
 696
 697                 if (tbl_name == MB_SVC_TABLE_FOLDER) {
 698                         snprintf(query_string, sizeof(query_string),
 699                                 MB_SVC_RECORD_FOLDER_DELETE_BY_UUID, table_name, id);
 700                 } else {
 701                         snprintf(query_string, sizeof(query_string),
 702                                 MB_SVC_RECORD_MEDIA_DELETE_BY_UUID, table_name, id);
 703                 }
 704                 mb_svc_debug("Query: %s", query_string);
 705
 706                 err = mb_svc_query_sql(mb_svc_handle, query_string);
 707                 if (err < 0) {
 708                         mb_svc_debug("failed to delete record\n");
 709                         mb_svc_debug("query string is %s\n", query_string);
 710                         return MB_SVC_ERROR_DB_INTERNAL;
 711                 } else {
 712                         mb_svc_debug("Succeed to delete record\n");
 713                         mb_svc_debug("query string is %s\n", query_string);
 714                 }
 715         } else {
 716                 mb_svc_debug("failed to delete record\n");
 717                 return MB_SVC_ERROR_DB_INTERNAL;
 718         }
 719
 720         return 0;
 721 }
 722
 723 int mb_svc_delete_record_bookmark_by_id(MediaSvcHandle *mb_svc_handle, int id)
 724 {
 725         return __mb_svc_delete_record(mb_svc_handle, id, MB_SVC_TABLE_BOOKMARK);
 726 }
 727
 728 int mb_svc_delete_record_folder_by_id(MediaSvcHandle *mb_svc_handle, const char *id)
 729 {
 730         return __mb_svc_delete_record_by_uuid(mb_svc_handle, id, MB_SVC_TABLE_FOLDER);
 731 }
 732
 733 int mb_svc_delete_record_web_streaming_by_id(MediaSvcHandle *mb_svc_handle, int id)
 734 {
 735         return __mb_svc_delete_record(mb_svc_handle, id, MB_SVC_TABLE_WEB_STREAMING);
 736 }
 737
 738 int mb_svc_delete_record_media_by_id(MediaSvcHandle *mb_svc_handle, const char *id)
 739 {
 740         return __mb_svc_delete_record_by_uuid(mb_svc_handle, id, MB_SVC_TABLE_MEDIA);
 741 }
 742
 743 int mb_svc_delete_record_video_meta_by_id(MediaSvcHandle *mb_svc_handle, int id)
 744 {
 745         return __mb_svc_delete_record(mb_svc_handle, id, MB_SVC_TABLE_VIDEO_META);
 746 }
 747
 748 int mb_svc_delete_record_image_meta_by_id(MediaSvcHandle *mb_svc_handle, int id)
 749 {
 750         return __mb_svc_delete_record(mb_svc_handle, id, MB_SVC_TABLE_IMAGE_META);
 751 }
 752
 753 int mb_svc_insert_record_bookmark(MediaSvcHandle *mb_svc_handle, mb_svc_bookmark_record_s *record)
 754 {
 755         mb_svc_debug("");
 756
 757         if (record == NULL) {
 758                 mb_svc_debug("record pointer is null\n");
 759                 return MB_SVC_ERROR_INVALID_PARAMETER;
 760         }
 761
 762         int err = -1;
 763         mb_svc_tbl_field_s *mb_svc_field;
 764         char *query_string = NULL;
 765         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_BOOKMARK;
 766         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
 767 /*
 768         record->_id = __mb_svc_db_get_next_id(MB_SVC_TABLE_BOOKMARK);
 769
 770         if (record->_id < 0) {
 771                 mb_svc_debug("__mb_svc_db_get_next_id failed");
 772                 return MB_SVC_ERROR_DB_INTERNAL;
 773         }
 774 */
 775         query_string =
 776             sqlite3_mprintf(MB_SVC_INSERT_BOOKMARK_TABLE,
 777                             mb_svc_tbl[field_seq].table_name,
 778 //                          mb_svc_field[MB_SVC_BOOKMARK_ID].field_name,
 779                             mb_svc_field[MB_SVC_BOOKMARK_MEDIA_UUID].field_name,
 780                             mb_svc_field[MB_SVC_BOOKMARK_MARKED_TIME].field_name,
 781                             mb_svc_field[MB_SVC_BOOKMARK_THUMBNAIL_PATH].
 782                             field_name, /* record->_id, */record->media_uuid,
 783                             record->marked_time, record->thumbnail_path);
 784
 785         mb_svc_debug("Query : %s", query_string);
 786
 787         err = mb_svc_query_sql(mb_svc_handle, query_string);
 788         sqlite3_free(query_string);
 789
 790         if (err < 0) {
 791                 mb_svc_debug("Inserting bookmark table failed\n");
 792                 mb_svc_debug("query string is %s\n", query_string);
 793                 return MB_SVC_ERROR_DB_INTERNAL;
 794         }
 795
 796         return err;
 797 }
 798
 799 int mb_svc_insert_record_folder(MediaSvcHandle *mb_svc_handle, mb_svc_folder_record_s *record)
 800 {
 801         mb_svc_debug("");
 802
 803         if (record == NULL) {
 804                 mb_svc_debug("record pointer is null\n");
 805                 return MB_SVC_ERROR_INVALID_PARAMETER;
 806         }
 807
 808         int err = -1;
 809         mb_svc_tbl_field_s *mb_svc_field;
 810         char *query_string = NULL;
 811         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_FOLDER;
 812         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
 813
 814         strncpy(record->uuid, _media_info_generate_uuid(), MB_SVC_UUID_LEN_MAX + 1);
 815
 816         query_string =
 817             sqlite3_mprintf(MB_SVC_INSERT_FOLDER_TABLE,
 818                             mb_svc_tbl[field_seq].table_name,
 819                             mb_svc_field[MB_SVC_FOLDER_UUID].field_name,
 820                             mb_svc_field[MB_SVC_FOLDER_PATH].field_name,
 821                             mb_svc_field[MB_SVC_FOLDER_DISPLAY_NAME].field_name,
 822                             mb_svc_field[MB_SVC_FOLDER_MODIFIED_DATE].
 823                             field_name,
 824                             mb_svc_field[MB_SVC_FOLDER_WEB_ACCOUNT_ID].
 825                             field_name,
 826                             mb_svc_field[MB_SVC_FOLDER_STORAGE_TYPE].field_name,
 827                             mb_svc_field[MB_SVC_FOLDER_SNS_TYPE].field_name,
 828                             mb_svc_field[MB_SVC_FOLDER_ALBUM_LOCK_STATUS].
 829                             field_name,
 830                             mb_svc_field[MB_SVC_FOLDER_WEB_ALBUM_ID].field_name,
 831                             mb_svc_field[MB_SVC_FOLDER_VALID].field_name,
 832                             record->uuid, record->uri, record->display_name,
 833                             record->modified_date, record->web_account_id,
 834                             record->storage_type, record->sns_type,
 835                             record->lock_status, record->web_album_id, 1);
 836
 837         mb_svc_debug("Query : %s", query_string);
 838
 839         err = mb_svc_query_sql(mb_svc_handle, query_string);
 840         sqlite3_free(query_string);
 841
 842         if (err < 0) {
 843                 mb_svc_debug("Inserting folder table failed\n");
 844                 mb_svc_debug("query string is %s\n", query_string);
 845                 return MB_SVC_ERROR_DB_INTERNAL;
 846         }
 847
 848         return err;
 849 }
 850
 851 int mb_svc_insert_record_folder_sql(mb_svc_folder_record_s *record, char **sql)
 852 {
 853         mb_svc_debug("");
 854
 855         if (record == NULL) {
 856                 mb_svc_debug("record pointer is null\n");
 857                 return MB_SVC_ERROR_INVALID_PARAMETER;
 858         }
 859
 860         int err = 0;
 861         mb_svc_tbl_field_s *mb_svc_field;
 862
 863         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_FOLDER;
 864         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
 865
 866         strncpy(record->uuid, _media_info_generate_uuid(), MB_SVC_UUID_LEN_MAX + 1);
 867
 868         *sql =
 869             sqlite3_mprintf(MB_SVC_INSERT_FOLDER_TABLE,
 870                             mb_svc_tbl[field_seq].table_name,
 871                             mb_svc_field[MB_SVC_FOLDER_UUID].field_name,
 872                             mb_svc_field[MB_SVC_FOLDER_PATH].field_name,
 873                             mb_svc_field[MB_SVC_FOLDER_DISPLAY_NAME].field_name,
 874                             mb_svc_field[MB_SVC_FOLDER_MODIFIED_DATE].
 875                             field_name,
 876                             mb_svc_field[MB_SVC_FOLDER_WEB_ACCOUNT_ID].
 877                             field_name,
 878                             mb_svc_field[MB_SVC_FOLDER_STORAGE_TYPE].field_name,
 879                             mb_svc_field[MB_SVC_FOLDER_SNS_TYPE].field_name,
 880                             mb_svc_field[MB_SVC_FOLDER_ALBUM_LOCK_STATUS].
 881                             field_name,
 882                             mb_svc_field[MB_SVC_FOLDER_WEB_ALBUM_ID].field_name,
 883                             mb_svc_field[MB_SVC_FOLDER_VALID].field_name,
 884                             record->uuid, record->uri, record->display_name,
 885                             record->modified_date, record->web_account_id,
 886                             record->storage_type, record->sns_type,
 887                             record->lock_status, record->web_album_id, 1);
 888
 889         mb_svc_debug("Query : %s", *sql);
 890
 891         return err;
 892 }
 893
 894 int mb_svc_insert_record_web_streaming(MediaSvcHandle *mb_svc_handle, mb_svc_web_streaming_record_s *record)
 895 {
 896         mb_svc_debug("");
 897
 898         if (record == NULL) {
 899                 mb_svc_debug("record pointer is null\n");
 900                 return MB_SVC_ERROR_INVALID_PARAMETER;
 901         }
 902
 903         int err = -1;
 904         mb_svc_tbl_field_s *mb_svc_field;
 905         char *query_string = NULL;
 906         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_WEB_STREAMING;
 907         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
 908
 909         record->_id = __mb_svc_db_get_next_id(mb_svc_handle, MB_SVC_TABLE_WEB_STREAMING);
 910
 911         if (record->_id < 0) {
 912                 mb_svc_debug("__mb_svc_db_get_next_id failed");
 913                 return MB_SVC_ERROR_DB_INTERNAL;
 914         }
 915
 916         query_string =
 917             sqlite3_mprintf(MB_SVC_INSERT_WEB_STREAMING_TABLE,
 918                             mb_svc_tbl[field_seq].table_name,
 919                             mb_svc_field[MB_SVC_WEB_STREAMING_ID].field_name,
 920                             mb_svc_field[MB_SVC_WEB_STREAMING_FOLDER_UUID].
 921                             field_name,
 922                             mb_svc_field[MB_SVC_WEB_STREAMING_TITLE].field_name,
 923                             mb_svc_field[MB_SVC_WEB_STREAMING_DURATION].
 924                             field_name,
 925                             mb_svc_field[MB_SVC_WEB_STREAMING_URL].field_name,
 926                             mb_svc_field[MB_SVC_WEB_STREAMING_THNMB_PATH].
 927                             field_name, record->_id, record->folder_uuid,
 928                             record->title, record->duration, record->url,
 929                             record->thumb_path);
 930
 931         mb_svc_debug("Query : %s", query_string);
 932
 933         err = mb_svc_query_sql(mb_svc_handle, query_string);
 934         sqlite3_free(query_string);
 935
 936         if (err < 0) {
 937                 mb_svc_debug("Inserting web streaming table failed\n");
 938                 mb_svc_debug("query string is %s\n", query_string);
 939                 return MB_SVC_ERROR_DB_INTERNAL;
 940         }
 941
 942         return err;
 943 }
 944
 945 /**
 946  *      insert record into table--media
 947  */
 948 int mb_svc_insert_record_media(MediaSvcHandle *mb_svc_handle, mb_svc_media_record_s *record,
 949                                minfo_store_type storage_type)
 950 {
 951         mb_svc_debug("");
 952
 953         if (record == NULL) {
 954                 mb_svc_debug("record pointer is null\n");
 955                 return MB_SVC_ERROR_INVALID_PARAMETER;
 956         }
 957
 958         int err = -1;
 959         mb_svc_tbl_field_s *mb_svc_field;
 960         char *query_string = NULL;
 961         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_MEDIA;
 962         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
 963
 964         strncpy(record->media_uuid, _media_info_generate_uuid(), MB_SVC_UUID_LEN_MAX + 1);
 965
 966         query_string =
 967             sqlite3_mprintf(MB_SVC_INSERT_MEDIA_TABLE,
 968                             mb_svc_tbl[field_seq].table_name,
 969                             mb_svc_field[MB_SVC_MEDIA_UUID].field_name,
 970                             mb_svc_field[MB_SVC_MEDIA_PATH].field_name,
 971                             mb_svc_field[MB_SVC_MEDIA_FOLDER_UUID].field_name,
 972                             mb_svc_field[MB_SVC_MEDIA_DISPLAY_NAME].field_name,
 973                             mb_svc_field[MB_SVC_MEDIA_CONTENT_TYPE].field_name,
 974                             mb_svc_field[MB_SVC_MEDIA_RATING].field_name,
 975                             mb_svc_field[MB_SVC_MEDIA_MODIFIED_DATE].field_name,
 976                             mb_svc_field[MB_SVC_MEDIA_THUMBNAIL_PATH].field_name,
 977                             mb_svc_field[MB_SVC_MEDIA_HTTP_URL].field_name,
 978                             mb_svc_field[MB_SVC_MEDIA_SIZE].field_name,
 979                             mb_svc_field[MB_SVC_MEDIA_VALID].field_name,
 980                             record->media_uuid, record->path,
 981                             record->folder_uuid, record->display_name, record->content_type,
 982                             record->rate, record->modified_date,
 983                             record->thumbnail_path, record->http_url, record->size, 1);
 984
 985         mb_svc_debug("Query : %s", query_string);
 986
 987         err = mb_svc_query_sql(mb_svc_handle, query_string);
 988         sqlite3_free(query_string);
 989
 990         if (err < 0) {
 991                 mb_svc_debug("Inserting media table failed\n");
 992                 mb_svc_debug("query string is %s\n", query_string);
 993                 return MB_SVC_ERROR_DB_INTERNAL;
 994         }
 995
 996         return err;
 997 }
 998
 999 int mb_svc_insert_record_media_sql(mb_svc_media_record_s *record,
1000                                         minfo_store_type storage_type,
1001                                         char **sql)
1002 {
1003         mb_svc_debug("");
1004
1005         if (record == NULL) {
1006                 mb_svc_debug("record pointer is null\n");
1007                 return MB_SVC_ERROR_INVALID_PARAMETER;
1008         }
1009
1010         int err = 0;
1011         mb_svc_tbl_field_s *mb_svc_field;
1012
1013         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_MEDIA;
1014         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
1015
1016         strncpy(record->media_uuid, _media_info_generate_uuid(), MB_SVC_UUID_LEN_MAX + 1);
1017
1018         *sql =
1019             sqlite3_mprintf(MB_SVC_INSERT_MEDIA_TABLE,
1020                             mb_svc_tbl[field_seq].table_name,
1021                             mb_svc_field[MB_SVC_MEDIA_UUID].field_name,
1022                             mb_svc_field[MB_SVC_MEDIA_PATH].field_name,
1023                             mb_svc_field[MB_SVC_MEDIA_FOLDER_UUID].field_name,
1024                             mb_svc_field[MB_SVC_MEDIA_DISPLAY_NAME].field_name,
1025                             mb_svc_field[MB_SVC_MEDIA_CONTENT_TYPE].field_name,
1026                             mb_svc_field[MB_SVC_MEDIA_RATING].field_name,
1027                             mb_svc_field[MB_SVC_MEDIA_MODIFIED_DATE].field_name,
1028                             mb_svc_field[MB_SVC_MEDIA_THUMBNAIL_PATH].field_name,
1029                             mb_svc_field[MB_SVC_MEDIA_HTTP_URL].field_name,
1030                             mb_svc_field[MB_SVC_MEDIA_SIZE].field_name,
1031                             mb_svc_field[MB_SVC_MEDIA_VALID].field_name,
1032                             record->media_uuid, record->path,
1033                                 record->folder_uuid,
1034                             record->display_name, record->content_type,
1035                             record->rate, record->modified_date,
1036                             record->thumbnail_path, record->http_url, record->size, 1);
1037
1038         mb_svc_debug("Query : %s", *sql);
1039
1040         return err;
1041 }
1042
1043 int
1044 mb_svc_insert_record_video_meta(MediaSvcHandle *mb_svc_handle, mb_svc_video_meta_record_s *record,
1045                                 minfo_store_type storage_type)
1046 {
1047         mb_svc_debug("");
1048
1049         if (record == NULL) {
1050                 mb_svc_debug("record pointer is null\n");
1051                 return MB_SVC_ERROR_INVALID_PARAMETER;
1052         }
1053
1054         int err = -1;
1055         mb_svc_tbl_field_s *mb_svc_field;
1056         char *query_string = NULL;
1057         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_VIDEO_META;
1058         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
1059 /*
1060         record->_id = __mb_svc_db_get_next_id(MB_SVC_TABLE_VIDEO_META);
1061
1062         if (record->_id < 0) {
1063                 mb_svc_debug("__mb_svc_db_get_next_id failed");
1064                 return MB_SVC_ERROR_DB_INTERNAL;
1065         }
1066 */
1067         query_string =
1068             sqlite3_mprintf(MB_SVC_INSERT_VIDEO_META_TABLE,
1069                             mb_svc_tbl[field_seq].table_name,
1070 //                          mb_svc_field[MB_SVC_VIDEO_META_ID].field_name,
1071                             mb_svc_field[MB_SVC_VIDEO_META_MEDIA_UUID].field_name,
1072                             mb_svc_field[MB_SVC_VIDEO_META_ALBUM].field_name,
1073                             mb_svc_field[MB_SVC_VIDEO_META_ARTIST].field_name,
1074                             mb_svc_field[MB_SVC_VIDEO_META_TITLE].field_name,
1075                             mb_svc_field[MB_SVC_VIDEO_META_GENRE].field_name,
1076                             mb_svc_field[MB_SVC_VIDEO_META_DESCRIPTION].
1077                             field_name,
1078                             mb_svc_field[MB_SVC_VIDEO_META_YOUTUBE_CATEGORY].
1079                             field_name,
1080                             mb_svc_field
1081                             [MB_SVC_VIDEO_META_BOOKMARK_LAST_PLAYED].field_name,
1082                             mb_svc_field[MB_SVC_VIDEO_META_DURATION].field_name,
1083                             mb_svc_field[MB_SVC_VIDEO_META_LONGISTUDE].
1084                             field_name,
1085                             mb_svc_field[MB_SVC_VIDEO_META_LATITUDE].field_name,
1086                             mb_svc_field[MB_SVC_VIDEO_META_WIDTH].field_name,
1087                             mb_svc_field[MB_SVC_VIDEO_META_HEIGHT].field_name,
1088                             mb_svc_field[MB_SVC_VIDEO_META_DATETAKEN].
1089                             field_name, /* record->_id, */record->media_uuid,
1090                             record->album, record->artist, record->title, record->genre,
1091                             record->description, record->youtube_category,
1092                             record->last_played_time, record->duration,
1093                             record->longitude, record->latitude, record->width,
1094                             record->height, record->datetaken);
1095
1096         mb_svc_debug("Query : %s", query_string);
1097
1098         err = mb_svc_query_sql(mb_svc_handle, query_string);
1099         sqlite3_free(query_string);
1100
1101         if (err < 0) {
1102                 mb_svc_debug("Inserting video meta table failed\n");
1103                 mb_svc_debug("query string is %s\n", query_string);
1104                 return MB_SVC_ERROR_DB_INTERNAL;
1105         }
1106
1107         return err;
1108 }
1109
1110 int
1111 mb_svc_insert_record_video_meta_sql(mb_svc_video_meta_record_s *record,
1112                                 minfo_store_type storage_type,
1113                                 char **sql)
1114 {
1115         mb_svc_debug("");
1116
1117         if (record == NULL) {
1118                 mb_svc_debug("record pointer is null\n");
1119                 return MB_SVC_ERROR_INVALID_PARAMETER;
1120         }
1121
1122         int err = 0;
1123         mb_svc_tbl_field_s *mb_svc_field;
1124         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_VIDEO_META;
1125         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
1126 /*
1127         record->_id = __mb_svc_db_get_next_id(MB_SVC_TABLE_VIDEO_META);
1128
1129         if (record->_id < 0) {
1130                 mb_svc_debug("__mb_svc_db_get_next_id failed");
1131                 return MB_SVC_ERROR_DB_INTERNAL;
1132         }
1133 */
1134         *sql =
1135             sqlite3_mprintf(MB_SVC_INSERT_VIDEO_META_TABLE,
1136                             mb_svc_tbl[field_seq].table_name,
1137 //                          mb_svc_field[MB_SVC_VIDEO_META_ID].field_name,
1138                             mb_svc_field[MB_SVC_VIDEO_META_MEDIA_UUID].field_name,
1139                             mb_svc_field[MB_SVC_VIDEO_META_ALBUM].field_name,
1140                             mb_svc_field[MB_SVC_VIDEO_META_ARTIST].field_name,
1141                             mb_svc_field[MB_SVC_VIDEO_META_TITLE].field_name,
1142                             mb_svc_field[MB_SVC_VIDEO_META_GENRE].field_name,
1143                             mb_svc_field[MB_SVC_VIDEO_META_DESCRIPTION].
1144                             field_name,
1145                             mb_svc_field[MB_SVC_VIDEO_META_YOUTUBE_CATEGORY].
1146                             field_name,
1147                             mb_svc_field
1148                             [MB_SVC_VIDEO_META_BOOKMARK_LAST_PLAYED].field_name,
1149                             mb_svc_field[MB_SVC_VIDEO_META_DURATION].field_name,
1150                             mb_svc_field[MB_SVC_VIDEO_META_LONGISTUDE].
1151                             field_name,
1152                             mb_svc_field[MB_SVC_VIDEO_META_LATITUDE].field_name,
1153                             mb_svc_field[MB_SVC_VIDEO_META_WIDTH].field_name,
1154                             mb_svc_field[MB_SVC_VIDEO_META_HEIGHT].field_name,
1155                             mb_svc_field[MB_SVC_VIDEO_META_DATETAKEN].
1156                             field_name, /* record->_id, */record->media_uuid,
1157                             record->album, record->artist, record->title, record->genre,
1158                             record->description, record->youtube_category,
1159                             record->last_played_time, record->duration,
1160                             record->longitude, record->latitude, record->width,
1161                             record->height, record->datetaken);
1162
1163         mb_svc_debug("Query : %s", *sql);
1164
1165         return err;
1166 }
1167
1168 int
1169 mb_svc_insert_record_image_meta(MediaSvcHandle *mb_svc_handle,
1170                                 mb_svc_image_meta_record_s *record,
1171                                 minfo_store_type storage_type)
1172 {
1173         mb_svc_debug("");
1174
1175         if (record == NULL) {
1176                 mb_svc_debug("record pointer is null\n");
1177                 return MB_SVC_ERROR_INVALID_PARAMETER;
1178         }
1179
1180         int err = -1;
1181         mb_svc_tbl_field_s *mb_svc_field;
1182         char *query_string = NULL;
1183         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_IMAGE_META;
1184         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
1185 /*
1186         record->_id = __mb_svc_db_get_next_id(MB_SVC_TABLE_IMAGE_META);
1187
1188         if (record->_id < 0) {
1189                 mb_svc_debug("__mb_svc_db_get_next_id failed");
1190                 return MB_SVC_ERROR_DB_INTERNAL;
1191         }
1192 */
1193         query_string =
1194             sqlite3_mprintf(MB_SVC_INSERT_IMAGE_META_TABLE,
1195                             mb_svc_tbl[field_seq].table_name,
1196 //                          mb_svc_field[MB_SVC_IMAGE_META_ID].field_name,
1197                             mb_svc_field[MB_SVC_IMAGE_META_MEDIA_UUID].field_name,
1198                             mb_svc_field[MB_SVC_IMAGE_META_LONGISTUDE].
1199                             field_name,
1200                             mb_svc_field[MB_SVC_IMAGE_META_LATITUDE].field_name,
1201                             mb_svc_field[MB_SVC_IMAGE_META_DESCRIPTION].
1202                             field_name,
1203                             mb_svc_field[MB_SVC_IMAGE_META_WIDTH].field_name,
1204                             mb_svc_field[MB_SVC_IMAGE_META_HEIGHT].field_name,
1205                             mb_svc_field[MB_SVC_IMAGE_META_ORIENTATION].
1206                             field_name,
1207                             mb_svc_field[MB_SVC_IMAGE_META_DATETAKEN].
1208                             field_name, /* record->_id, */record->media_uuid,
1209                             record->longitude, record->latitude,
1210                             record->description, record->width, record->height,
1211                             record->orientation, record->datetaken);
1212
1213         mb_svc_debug("Query : %s", query_string);
1214
1215         err = mb_svc_query_sql(mb_svc_handle, query_string);
1216         sqlite3_free(query_string);
1217
1218         if (err < 0) {
1219                 mb_svc_debug("Inserting image meta table failed\n");
1220                 mb_svc_debug("query string is %s\n", query_string);
1221                 return MB_SVC_ERROR_DB_INTERNAL;
1222         }
1223
1224         return err;
1225 }
1226
1227 int
1228 mb_svc_insert_record_image_meta_sql(mb_svc_image_meta_record_s *record,
1229                                 minfo_store_type storage_type,
1230                                 char **sql)
1231 {
1232         mb_svc_debug("");
1233
1234         if (record == NULL) {
1235                 mb_svc_debug("record pointer is null\n");
1236                 return MB_SVC_ERROR_INVALID_PARAMETER;
1237         }
1238
1239         int err = 0;
1240         mb_svc_tbl_field_s *mb_svc_field;
1241         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_IMAGE_META;
1242         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
1243 /*
1244         record->_id = __mb_svc_db_get_next_id(MB_SVC_TABLE_IMAGE_META);
1245
1246         if (record->_id < 0) {
1247                 mb_svc_debug("__mb_svc_db_get_next_id failed");
1248                 return MB_SVC_ERROR_DB_INTERNAL;
1249         }
1250 */
1251         *sql =
1252             sqlite3_mprintf(MB_SVC_INSERT_IMAGE_META_TABLE,
1253                             mb_svc_tbl[field_seq].table_name,
1254 //                          mb_svc_field[MB_SVC_IMAGE_META_ID].field_name,
1255                             mb_svc_field[MB_SVC_IMAGE_META_MEDIA_UUID].field_name,
1256                             mb_svc_field[MB_SVC_IMAGE_META_LONGISTUDE].
1257                             field_name,
1258                             mb_svc_field[MB_SVC_IMAGE_META_LATITUDE].field_name,
1259                             mb_svc_field[MB_SVC_IMAGE_META_DESCRIPTION].
1260                             field_name,
1261                             mb_svc_field[MB_SVC_IMAGE_META_WIDTH].field_name,
1262                             mb_svc_field[MB_SVC_IMAGE_META_HEIGHT].field_name,
1263                             mb_svc_field[MB_SVC_IMAGE_META_ORIENTATION].
1264                             field_name,
1265                             mb_svc_field[MB_SVC_IMAGE_META_DATETAKEN].
1266                             field_name, /* record->_id, */record->media_uuid,
1267                             record->longitude, record->latitude,
1268                             record->description, record->width, record->height,
1269                             record->orientation, record->datetaken);
1270
1271         mb_svc_debug("Query : %s", *sql);
1272
1273         return err;
1274 }
1275
1276 int mb_svc_update_record_folder(MediaSvcHandle *mb_svc_handle, mb_svc_folder_record_s *record)
1277 {
1278         mb_svc_debug("");
1279
1280         if (record == NULL) {
1281                 mb_svc_debug("record pointer is null\n");
1282                 return MB_SVC_ERROR_INVALID_PARAMETER;
1283         }
1284
1285         int err = -1;
1286         mb_svc_tbl_field_s *mb_svc_field;
1287         char *query_string = NULL;
1288         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_FOLDER;
1289         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
1290
1291         query_string =
1292             sqlite3_mprintf(MB_SVC_UPDATE_FOLDER_TABLE,
1293                             mb_svc_tbl[field_seq].table_name,
1294                             mb_svc_field[MB_SVC_FOLDER_PATH].field_name,
1295                             record->uri,
1296                             mb_svc_field[MB_SVC_FOLDER_DISPLAY_NAME].field_name,
1297                             record->display_name,
1298                             mb_svc_field[MB_SVC_FOLDER_MODIFIED_DATE].
1299                             field_name, record->modified_date,
1300                             mb_svc_field[MB_SVC_FOLDER_WEB_ACCOUNT_ID].
1301                             field_name, record->web_account_id,
1302                             mb_svc_field[MB_SVC_FOLDER_STORAGE_TYPE].field_name,
1303                             record->storage_type,
1304                             mb_svc_field[MB_SVC_FOLDER_SNS_TYPE].field_name,
1305                             record->sns_type,
1306                             mb_svc_field[MB_SVC_FOLDER_ALBUM_LOCK_STATUS].
1307                             field_name, record->lock_status, record->uuid);
1308
1309         mb_svc_debug("Query : %s", query_string);
1310
1311         err = mb_svc_query_sql(mb_svc_handle, query_string);
1312         sqlite3_free(query_string);
1313
1314         if (err < 0) {
1315                 mb_svc_debug("Updating folder table failed\n");
1316                 mb_svc_debug("query string is %s\n", query_string);
1317                 return MB_SVC_ERROR_DB_INTERNAL;
1318         }
1319
1320         return err;
1321 }
1322
1323 int mb_svc_update_record_folder_sql(mb_svc_folder_record_s *record, char **sql)
1324 {
1325         mb_svc_debug("");
1326
1327         if (record == NULL) {
1328                 mb_svc_debug("record pointer is null\n");
1329                 return MB_SVC_ERROR_INVALID_PARAMETER;
1330         }
1331
1332         int err = 0;
1333         mb_svc_tbl_field_s *mb_svc_field;
1334         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_FOLDER;
1335         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
1336
1337         *sql =
1338             sqlite3_mprintf(MB_SVC_UPDATE_FOLDER_TABLE,
1339                             mb_svc_tbl[field_seq].table_name,
1340                             mb_svc_field[MB_SVC_FOLDER_PATH].field_name,
1341                             record->uri,
1342                             mb_svc_field[MB_SVC_FOLDER_DISPLAY_NAME].field_name,
1343                             record->display_name,
1344                             mb_svc_field[MB_SVC_FOLDER_MODIFIED_DATE].
1345                             field_name, record->modified_date,
1346                             mb_svc_field[MB_SVC_FOLDER_WEB_ACCOUNT_ID].
1347                             field_name, record->web_account_id,
1348                             mb_svc_field[MB_SVC_FOLDER_STORAGE_TYPE].field_name,
1349                             record->storage_type,
1350                             mb_svc_field[MB_SVC_FOLDER_SNS_TYPE].field_name,
1351                             record->sns_type,
1352                             mb_svc_field[MB_SVC_FOLDER_ALBUM_LOCK_STATUS].
1353                             field_name, record->lock_status, record->uuid);
1354
1355         mb_svc_debug("Query : %s", *sql);
1356
1357         return err;
1358 }
1359
1360 int mb_svc_update_record_folder_path(MediaSvcHandle *mb_svc_handle, char *old_path, char *new_path)
1361 {
1362         mb_svc_debug("");
1363
1364         if (old_path == NULL || new_path == NULL) {
1365                 mb_svc_debug("old_path == NULL || new_path ");
1366                 return MB_SVC_ERROR_INVALID_PARAMETER;
1367         }
1368
1369         int err = -1;
1370         mb_svc_tbl_field_s *mb_svc_field;
1371         char *query_string = NULL;
1372         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_FOLDER;
1373         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
1374
1375         query_string =
1376             sqlite3_mprintf(MB_SVC_UPDATE_FOLDER_PATH_TABLE,
1377                             mb_svc_tbl[field_seq].table_name, old_path,
1378                             new_path);
1379
1380         mb_svc_debug("Query : %s", query_string);
1381
1382         err = mb_svc_query_sql(mb_svc_handle, query_string);
1383         sqlite3_free(query_string);
1384
1385         if (err < 0) {
1386                 mb_svc_debug("Updating folder table failed\n");
1387                 mb_svc_debug("query string is %s\n", query_string);
1388                 return MB_SVC_ERROR_DB_INTERNAL;
1389         }
1390
1391         return err;
1392 }
1393
1394 int mb_svc_update_folder_modified_date(MediaSvcHandle *mb_svc_handle, char *path, int date)
1395 {
1396         mb_svc_debug("");
1397
1398         if (path == NULL) {
1399                 mb_svc_debug("old_path == NULL || new_path == NULL ");
1400                 return MB_SVC_ERROR_INVALID_PARAMETER;
1401         }
1402
1403         int err = -1;
1404         mb_svc_tbl_field_s *mb_svc_field;
1405         char *query_string = NULL;
1406         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_FOLDER;
1407         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
1408         char path_like[MB_SVC_FILE_PATH_LEN_MAX + 1];
1409
1410         snprintf(path_like, sizeof(path_like), "%s%%", path);
1411
1412         query_string =
1413             sqlite3_mprintf(MB_SVC_UPDATE_FOLDER_MODIFIED_DATE_TABLE,
1414                             mb_svc_tbl[field_seq].table_name, date, path_like);
1415
1416         mb_svc_debug("Query : %s", query_string);
1417
1418         err = mb_svc_query_sql(mb_svc_handle, query_string);
1419         sqlite3_free(query_string);
1420
1421         if (err < 0) {
1422                 mb_svc_debug("Updating folder table failed\n");
1423                 mb_svc_debug("query string is %s\n", query_string);
1424                 return MB_SVC_ERROR_DB_INTERNAL;
1425         }
1426
1427         return err;
1428 }
1429
1430 int mb_svc_update_record_media(MediaSvcHandle *mb_svc_handle, mb_svc_media_record_s *record)
1431 {
1432         mb_svc_debug("");
1433
1434         if (record == NULL) {
1435                 mb_svc_debug("record pointer is null\n");
1436                 return MB_SVC_ERROR_INVALID_PARAMETER;
1437         }
1438
1439         int err = -1;
1440         mb_svc_tbl_field_s *mb_svc_field;
1441         char *query_string = NULL;
1442         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_MEDIA;
1443         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
1444
1445         query_string =
1446             sqlite3_mprintf(MB_SVC_UPDATE_MEDIA_TABLE,
1447                             mb_svc_tbl[field_seq].table_name,
1448                             mb_svc_field[MB_SVC_MEDIA_FOLDER_UUID].field_name,
1449                             record->folder_uuid,
1450                             mb_svc_field[MB_SVC_MEDIA_PATH].field_name,
1451                             record->path,
1452                             mb_svc_field[MB_SVC_MEDIA_DISPLAY_NAME].field_name,
1453                             record->display_name,
1454                             mb_svc_field[MB_SVC_MEDIA_CONTENT_TYPE].field_name,
1455                             record->content_type,
1456                             mb_svc_field[MB_SVC_MEDIA_RATING].field_name,
1457                             record->rate,
1458                             mb_svc_field[MB_SVC_MEDIA_MODIFIED_DATE].field_name,
1459                             record->modified_date,
1460                             mb_svc_field[MB_SVC_MEDIA_THUMBNAIL_PATH].
1461                             field_name, record->thumbnail_path,
1462                             mb_svc_field[MB_SVC_MEDIA_HTTP_URL].field_name,
1463                             record->http_url,
1464                             mb_svc_field[MB_SVC_MEDIA_SIZE].field_name,
1465                             record->size,
1466                                 record->media_uuid);
1467
1468         mb_svc_debug("Query : %s", query_string);
1469
1470         err = mb_svc_query_sql(mb_svc_handle, query_string);
1471         sqlite3_free(query_string);
1472
1473         if (err < 0) {
1474                 mb_svc_debug("Updating media table failed\n");
1475                 mb_svc_debug("query string is %s\n", query_string);
1476                 return MB_SVC_ERROR_DB_INTERNAL;
1477         }
1478
1479         return err;
1480 }
1481
1482 int mb_svc_update_record_media_sql(mb_svc_media_record_s *record, char **sql)
1483 {
1484         mb_svc_debug("");
1485
1486         if (record == NULL) {
1487                 mb_svc_debug("record pointer is null\n");
1488                 return MB_SVC_ERROR_INVALID_PARAMETER;
1489         }
1490
1491         int err = 0;
1492         mb_svc_tbl_field_s *mb_svc_field;
1493         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_MEDIA;
1494         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
1495
1496         *sql =
1497             sqlite3_mprintf(MB_SVC_UPDATE_MEDIA_TABLE,
1498                             mb_svc_tbl[field_seq].table_name,
1499                             mb_svc_field[MB_SVC_MEDIA_FOLDER_UUID].field_name,
1500                             record->folder_uuid,
1501                             mb_svc_field[MB_SVC_MEDIA_PATH].field_name,
1502                             record->path,
1503                             mb_svc_field[MB_SVC_MEDIA_DISPLAY_NAME].field_name,
1504                             record->display_name,
1505                             mb_svc_field[MB_SVC_MEDIA_CONTENT_TYPE].field_name,
1506                             record->content_type,
1507                             mb_svc_field[MB_SVC_MEDIA_RATING].field_name,
1508                             record->rate,
1509                             mb_svc_field[MB_SVC_MEDIA_MODIFIED_DATE].field_name,
1510                             record->modified_date,
1511                             mb_svc_field[MB_SVC_MEDIA_THUMBNAIL_PATH].
1512                             field_name, record->thumbnail_path,
1513                             mb_svc_field[MB_SVC_MEDIA_HTTP_URL].field_name,
1514                             record->http_url,
1515                             mb_svc_field[MB_SVC_MEDIA_SIZE].field_name,
1516                             record->size,
1517                                 record->media_uuid);
1518
1519         mb_svc_debug("Query : %s", *sql);
1520
1521         return err;
1522 }
1523
1524 int mb_svc_update_record_video_meta(MediaSvcHandle *mb_svc_handle, mb_svc_video_meta_record_s *record)
1525 {
1526         mb_svc_debug("");
1527
1528         if (record == NULL) {
1529                 mb_svc_debug("record pointer is null\n");
1530                 return MB_SVC_ERROR_INVALID_PARAMETER;
1531         }
1532
1533         int err = -1;
1534         mb_svc_tbl_field_s *mb_svc_field;
1535         char *query_string = NULL;
1536         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_VIDEO_META;
1537         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
1538
1539         query_string =
1540             sqlite3_mprintf(MB_SVC_UPDATE_VIDEO_META_TABLE,
1541                             mb_svc_tbl[field_seq].table_name,
1542                             mb_svc_field[MB_SVC_VIDEO_META_MEDIA_UUID].field_name,
1543                             record->media_uuid,
1544                             mb_svc_field[MB_SVC_VIDEO_META_ALBUM].field_name,
1545                             record->album,
1546                             mb_svc_field[MB_SVC_VIDEO_META_ARTIST].field_name,
1547                             record->artist,
1548                             mb_svc_field[MB_SVC_VIDEO_META_TITLE].field_name,
1549                             record->title,
1550                             mb_svc_field[MB_SVC_VIDEO_META_GENRE].field_name,
1551                             record->genre,
1552                             mb_svc_field[MB_SVC_VIDEO_META_DESCRIPTION].
1553                             field_name, record->description,
1554                             mb_svc_field[MB_SVC_VIDEO_META_YOUTUBE_CATEGORY].
1555                             field_name, record->youtube_category,
1556                             mb_svc_field
1557                             [MB_SVC_VIDEO_META_BOOKMARK_LAST_PLAYED].field_name,
1558                             record->last_played_time,
1559                             mb_svc_field[MB_SVC_VIDEO_META_DURATION].field_name,
1560                             record->duration,
1561                             mb_svc_field[MB_SVC_VIDEO_META_LONGISTUDE].
1562                             field_name, record->longitude,
1563                             mb_svc_field[MB_SVC_VIDEO_META_LATITUDE].field_name,
1564                             record->latitude,
1565                             mb_svc_field[MB_SVC_VIDEO_META_WIDTH].field_name,
1566                             record->width,
1567                             mb_svc_field[MB_SVC_VIDEO_META_HEIGHT].field_name,
1568                             record->height,
1569                             mb_svc_field[MB_SVC_VIDEO_META_DATETAKEN].
1570                             field_name, record->datetaken, record->_id);
1571
1572         mb_svc_debug("Query : %s", query_string);
1573
1574         err = mb_svc_query_sql(mb_svc_handle, query_string);
1575         sqlite3_free(query_string);
1576
1577         if (err < 0) {
1578                 mb_svc_debug("Updating video meta table failed\n");
1579                 mb_svc_debug("query string is %s\n", query_string);
1580                 return MB_SVC_ERROR_DB_INTERNAL;
1581         }
1582
1583         return err;
1584 }
1585
1586 int mb_svc_update_record_image_meta(MediaSvcHandle *mb_svc_handle, mb_svc_image_meta_record_s *record)
1587 {
1588         mb_svc_debug("");
1589
1590         if (record == NULL) {
1591                 mb_svc_debug("record pointer is null\n");
1592                 return MB_SVC_ERROR_INVALID_PARAMETER;
1593         }
1594
1595         int err = -1;
1596         mb_svc_tbl_field_s *mb_svc_field;
1597         char *query_string = NULL;
1598         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_IMAGE_META;
1599         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
1600
1601         query_string =
1602             sqlite3_mprintf(MB_SVC_UPDATE_IMAGE_META_TABLE,
1603                             mb_svc_tbl[field_seq].table_name,
1604                             mb_svc_field[MB_SVC_IMAGE_META_MEDIA_UUID].field_name,
1605                             record->media_uuid,
1606                             mb_svc_field[MB_SVC_IMAGE_META_LONGISTUDE].
1607                             field_name, record->longitude,
1608                             mb_svc_field[MB_SVC_IMAGE_META_LATITUDE].field_name,
1609                             record->latitude,
1610                             mb_svc_field[MB_SVC_IMAGE_META_DESCRIPTION].
1611                             field_name, record->description,
1612                             mb_svc_field[MB_SVC_IMAGE_META_WIDTH].field_name,
1613                             record->width,
1614                             mb_svc_field[MB_SVC_IMAGE_META_HEIGHT].field_name,
1615                             record->height,
1616                             mb_svc_field[MB_SVC_IMAGE_META_ORIENTATION].
1617                             field_name, record->orientation,
1618                             mb_svc_field[MB_SVC_IMAGE_META_DATETAKEN].
1619                             field_name, record->datetaken, record->_id);
1620
1621         mb_svc_debug("Query : %s", query_string);
1622
1623         err = mb_svc_query_sql(mb_svc_handle, query_string);
1624         sqlite3_free(query_string);
1625
1626         if (err < 0) {
1627                 mb_svc_debug("Updating image meta table failed\n");
1628                 mb_svc_debug("query string is %s\n", query_string);
1629                 return MB_SVC_ERROR_DB_INTERNAL;
1630         }
1631
1632         return err;
1633 }
1634
1635 int
1636 mb_svc_load_record_bookmark(sqlite3_stmt *stmt,
1637                             mb_svc_bookmark_record_s *record)
1638 {
1639         if (record == NULL) {
1640                 mb_svc_debug("record pointer is null\n");
1641                 return MB_SVC_ERROR_INVALID_PARAMETER;
1642         }
1643         record->_id = sqlite3_column_int(stmt, MB_SVC_BOOKMARK_ID);
1644         strncpy(record->media_uuid,
1645                 (const char *)sqlite3_column_text(stmt,
1646                                                   MB_SVC_BOOKMARK_MEDIA_UUID),
1647                 MB_SVC_UUID_LEN_MAX + 1);
1648         record->marked_time =
1649             sqlite3_column_int(stmt, MB_SVC_BOOKMARK_MARKED_TIME);
1650         strncpy(record->thumbnail_path,
1651                 (const char *)sqlite3_column_text(stmt,
1652                                                   MB_SVC_BOOKMARK_THUMBNAIL_PATH),
1653                 MB_SVC_FILE_PATH_LEN_MAX + 1);
1654
1655         return 0;
1656 }
1657
1658 int
1659 mb_svc_load_record_folder(sqlite3_stmt *stmt, mb_svc_folder_record_s *record)
1660 {
1661         if (record == NULL) {
1662                 mb_svc_debug("record pointer is null\n");
1663                 return MB_SVC_ERROR_INVALID_PARAMETER;
1664         }
1665
1666         strncpy(record->uuid,
1667                 (const char *)sqlite3_column_text(stmt, MB_SVC_FOLDER_UUID),
1668                 MB_SVC_UUID_LEN_MAX + 1);
1669         strncpy(record->uri,
1670                 (const char *)sqlite3_column_text(stmt, MB_SVC_FOLDER_PATH),
1671                 MB_SVC_DIR_PATH_LEN_MAX + 1);
1672         strncpy(record->display_name,
1673                 (const char *)sqlite3_column_text(stmt,
1674                                                   MB_SVC_FOLDER_DISPLAY_NAME),
1675                 MB_SVC_FILE_NAME_LEN_MAX + 1);
1676         record->modified_date =
1677             sqlite3_column_int(stmt, MB_SVC_FOLDER_MODIFIED_DATE);
1678         strncpy(record->web_account_id,
1679                 (const char *)sqlite3_column_text(stmt,
1680                                                   MB_SVC_FOLDER_WEB_ACCOUNT_ID),
1681                 MB_SVC_ARRAY_LEN_MAX + 1);
1682         record->storage_type =
1683             sqlite3_column_int(stmt, MB_SVC_FOLDER_STORAGE_TYPE);
1684         record->sns_type = sqlite3_column_int(stmt, MB_SVC_FOLDER_SNS_TYPE);
1685         record->lock_status =
1686             sqlite3_column_int(stmt, MB_SVC_FOLDER_ALBUM_LOCK_STATUS);
1687         strncpy(record->web_album_id,
1688                 (const char *)sqlite3_column_text(stmt,
1689                                                   MB_SVC_FOLDER_WEB_ALBUM_ID),
1690                 MB_SVC_ARRAY_LEN_MAX + 1);
1691
1692         return 0;
1693 }
1694
1695 int
1696 mb_svc_load_record_folder_name(sqlite3_stmt *stmt, char *folder_name,
1697                                int max_length)
1698 {
1699         if (folder_name == NULL) {
1700                 mb_svc_debug("record pointer is null\n");
1701                 return MB_SVC_ERROR_INVALID_PARAMETER;
1702         }
1703
1704         strncpy(folder_name, (const char *)sqlite3_column_text(stmt, 0),
1705                 max_length);
1706
1707         return 0;
1708 }
1709
1710 int
1711 mb_svc_load_record_web_streaming(sqlite3_stmt *stmt,
1712                                  mb_svc_web_streaming_record_s *record)
1713 {
1714         if (record == NULL) {
1715                 mb_svc_debug("record pointer is null\n");
1716                 return MB_SVC_ERROR_INVALID_PARAMETER;
1717         }
1718
1719         record->_id = sqlite3_column_int(stmt, MB_SVC_WEB_STREAMING_ID);
1720         strncpy(record->folder_uuid,
1721                 (const char *)sqlite3_column_text(stmt,
1722                                                   MB_SVC_WEB_STREAMING_FOLDER_UUID),
1723                 sizeof(record->folder_uuid));
1724         strncpy(record->title,
1725                 (const char *)sqlite3_column_text(stmt,
1726                                                   MB_SVC_WEB_STREAMING_TITLE),
1727                 sizeof(record->title));
1728         record->title[sizeof(record->title) - 1] = '\0';
1729         record->duration =
1730             sqlite3_column_int(stmt, MB_SVC_WEB_STREAMING_DURATION);
1731         strncpy(record->url,
1732                 (const char *)sqlite3_column_text(stmt,
1733                                                   MB_SVC_WEB_STREAMING_URL),
1734                 MB_SVC_FILE_PATH_LEN_MAX + 1);
1735         strncpy(record->thumb_path,
1736                 (const char *)sqlite3_column_text(stmt,
1737                                                   MB_SVC_WEB_STREAMING_THNMB_PATH),
1738                 MB_SVC_FILE_PATH_LEN_MAX + 1);
1739
1740         return 0;
1741 }
1742
1743 int
1744 mb_svc_load_record_media(sqlite3_stmt *stmt, mb_svc_media_record_s *record)
1745 {
1746         if (record == NULL) {
1747                 mb_svc_debug("record pointer is null\n");
1748                 return MB_SVC_ERROR_INVALID_PARAMETER;
1749         }
1750
1751         strncpy(record->media_uuid,
1752                 (const char *)sqlite3_column_text(stmt, MB_SVC_MEDIA_UUID),
1753                 MB_SVC_UUID_LEN_MAX + 1);
1754         strncpy(record->folder_uuid,
1755                 (const char *)sqlite3_column_text(stmt, MB_SVC_MEDIA_FOLDER_UUID),
1756                 MB_SVC_UUID_LEN_MAX + 1);
1757         strncpy(record->path,
1758                 (const char *)sqlite3_column_text(stmt, MB_SVC_MEDIA_PATH),
1759                 MB_SVC_FILE_PATH_LEN_MAX + 1);
1760         strncpy(record->display_name,
1761                 (const char *)sqlite3_column_text(stmt,
1762                                                   MB_SVC_MEDIA_DISPLAY_NAME),
1763                 MB_SVC_FILE_NAME_LEN_MAX + 1);
1764         record->content_type =
1765             sqlite3_column_int(stmt, MB_SVC_MEDIA_CONTENT_TYPE);
1766         record->rate = sqlite3_column_int(stmt, MB_SVC_MEDIA_RATING);
1767         record->modified_date =
1768             sqlite3_column_int(stmt, MB_SVC_MEDIA_MODIFIED_DATE);
1769         strncpy(record->thumbnail_path,
1770                 (const char *)sqlite3_column_text(stmt,
1771                                                   MB_SVC_MEDIA_THUMBNAIL_PATH),
1772                 MB_SVC_FILE_PATH_LEN_MAX + 1);
1773         strncpy(record->http_url,
1774                 (const char *)sqlite3_column_text(stmt, MB_SVC_MEDIA_HTTP_URL),
1775                 MB_SVC_DIR_PATH_LEN_MAX + 1);
1776
1777         record->size = sqlite3_column_int(stmt, MB_SVC_MEDIA_SIZE);
1778
1779         return 0;
1780 }
1781
1782 int
1783 mb_svc_load_record_video_meta(sqlite3_stmt *stmt,
1784                               mb_svc_video_meta_record_s *record)
1785 {
1786         if (record == NULL) {
1787                 mb_svc_debug("record pointer is null\n");
1788                 return MB_SVC_ERROR_INVALID_PARAMETER;
1789         }
1790         record->_id = sqlite3_column_int(stmt, MB_SVC_VIDEO_META_ID);
1791         strncpy(record->media_uuid,
1792                 (const char *)sqlite3_column_text(stmt,
1793                                                   MB_SVC_VIDEO_META_MEDIA_UUID),
1794                 MB_SVC_UUID_LEN_MAX + 1);
1795         strncpy(record->album,
1796                 (const char *)sqlite3_column_text(stmt,
1797                                                   MB_SVC_VIDEO_META_ALBUM),
1798                 MB_SVC_FILE_NAME_LEN_MAX + 1);
1799         strncpy(record->artist,
1800                 (const char *)sqlite3_column_text(stmt,
1801                                                   MB_SVC_VIDEO_META_ARTIST),
1802                 MB_SVC_ARRAY_LEN_MAX + 1);
1803         strncpy(record->title,
1804                 (const char *)sqlite3_column_text(stmt,
1805                                                   MB_SVC_VIDEO_META_TITLE),
1806                 MB_SVC_FILE_NAME_LEN_MAX + 1);
1807         strncpy(record->genre,
1808                 (const char *)sqlite3_column_text(stmt,
1809                                                   MB_SVC_VIDEO_META_GENRE),
1810                 MB_SVC_FILE_NAME_LEN_MAX + 1);
1811         strncpy(record->description,
1812                 (const char *)sqlite3_column_text(stmt,
1813                                                   MB_SVC_VIDEO_META_DESCRIPTION),
1814                 MB_SVC_ARRAY_LEN_MAX + 1);
1815         strncpy(record->youtube_category,
1816                 (const char *)sqlite3_column_text(stmt,
1817                                                   MB_SVC_VIDEO_META_YOUTUBE_CATEGORY),
1818                 MB_SVC_ARRAY_LEN_MAX + 1);
1819         record->last_played_time =
1820             sqlite3_column_int(stmt, MB_SVC_VIDEO_META_BOOKMARK_LAST_PLAYED);
1821         record->duration = sqlite3_column_int(stmt, MB_SVC_VIDEO_META_DURATION);
1822         record->longitude =
1823             sqlite3_column_double(stmt, MB_SVC_VIDEO_META_LONGISTUDE);
1824         record->latitude =
1825             sqlite3_column_double(stmt, MB_SVC_VIDEO_META_LATITUDE);
1826         record->width = sqlite3_column_int(stmt, MB_SVC_VIDEO_META_WIDTH);
1827         record->height = sqlite3_column_int(stmt, MB_SVC_VIDEO_META_HEIGHT);
1828         record->datetaken =
1829             sqlite3_column_int(stmt, MB_SVC_VIDEO_META_DATETAKEN);
1830
1831         return 0;
1832 }
1833
1834 int
1835 mb_svc_load_record_image_meta(sqlite3_stmt *stmt,
1836                               mb_svc_image_meta_record_s *record)
1837 {
1838         if (record == NULL) {
1839                 mb_svc_debug("record pointer is null\n");
1840                 return MB_SVC_ERROR_INVALID_PARAMETER;
1841         }
1842         record->_id = sqlite3_column_int(stmt, MB_SVC_IMAGE_META_ID);
1843         strncpy(record->media_uuid,
1844                 (const char *)sqlite3_column_text(stmt,
1845                                                   MB_SVC_IMAGE_META_MEDIA_UUID),
1846                 MB_SVC_UUID_LEN_MAX + 1);
1847         record->longitude =
1848             sqlite3_column_double(stmt, MB_SVC_IMAGE_META_LONGISTUDE);
1849         record->latitude =
1850             sqlite3_column_double(stmt, MB_SVC_IMAGE_META_LATITUDE);
1851         strncpy(record->description,
1852                 (const char *)sqlite3_column_text(stmt,
1853                                                   MB_SVC_IMAGE_META_DESCRIPTION),
1854                 MB_SVC_ARRAY_LEN_MAX + 1);
1855         record->width = sqlite3_column_int(stmt, MB_SVC_IMAGE_META_WIDTH);
1856         record->height = sqlite3_column_int(stmt, MB_SVC_IMAGE_META_HEIGHT);
1857         record->orientation =
1858             sqlite3_column_int(stmt, MB_SVC_IMAGE_META_ORIENTATION);
1859         record->datetaken =
1860             sqlite3_column_int(stmt, MB_SVC_IMAGE_META_DATETAKEN);
1861
1862         return 0;
1863 }
1864
1865 int mb_svc_delete_record_media(MediaSvcHandle *mb_svc_handle, const char *folder_id, char *display_name)
1866 {
1867         int err = -1;
1868         char *query_string = NULL;
1869
1870         char table_name[MB_SVC_TABLE_NAME_MAX_LEN] = { 0, };
1871         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
1872
1873         snprintf(table_name, MB_SVC_TABLE_NAME_MAX_LEN, "%s",
1874                  mb_svc_tbl[MB_SVC_TABLE_MEDIA].table_name);
1875
1876         query_string = sqlite3_mprintf(MB_SVC_DELETE_MEDIA_BY_FOLDER_ID_AND_DISPLAY_NAME,
1877                                                                         table_name, folder_id, display_name);
1878
1879         err = mb_svc_query_sql(mb_svc_handle, query_string);
1880         if (err < 0) {
1881                 mb_svc_debug("failed to delete record\n");
1882                 mb_svc_debug("query string is %s\n", query_string);
1883                 sqlite3_free(query_string);
1884                 return MB_SVC_ERROR_DB_INTERNAL;
1885         }
1886
1887         return 0;
1888 }
1889
1890 int mb_svc_delete_record_folder_sql(const char *folder_id, char **sql)
1891 {
1892         *sql = sqlite3_mprintf(MB_SVC_RECORD_FOLDER_DELETE_BY_UUID,
1893                                                         mb_svc_tbl[MB_SVC_TABLE_FOLDER].table_name,
1894                                                         folder_id);
1895
1896         return 0;
1897 }
1898
1899 int mb_svc_delete_record_media_sql(const char *media_id, char **sql)
1900 {
1901         *sql = sqlite3_mprintf(MB_SVC_RECORD_MEDIA_DELETE_BY_UUID,
1902                                                         mb_svc_tbl[MB_SVC_TABLE_MEDIA].table_name,
1903                                                         media_id);
1904
1905         return 0;
1906 }
1907
1908 int mb_svc_delete_record_image_meta_sql(const char *media_id, char **sql)
1909 {
1910         *sql = sqlite3_mprintf(MB_SVC_DELETE_MEDIA_RELATED_INFO_BY_MEDIA_UUID,
1911                                                         mb_svc_tbl[MB_SVC_TABLE_IMAGE_META].table_name,
1912                                                         media_id);
1913
1914         return 0;
1915 }
1916
1917
1918 int mb_svc_delete_record_video_meta_sql(const char *media_id, char **sql)
1919 {
1920         *sql = sqlite3_mprintf(MB_SVC_DELETE_MEDIA_RELATED_INFO_BY_MEDIA_UUID,
1921                                                         mb_svc_tbl[MB_SVC_TABLE_VIDEO_META].table_name,
1922                                                         media_id);
1923
1924         return 0;
1925 }
1926
1927 int
1928 mb_svc_delete_tagmap_by_media_id_sql(const char *media_id, char **sql)
1929 {
1930         *sql = sqlite3_mprintf(MB_SVC_DELETE_MEDIA_RELATED_INFO_BY_MEDIA_UUID,
1931                                                         mb_svc_tbl[MB_SVC_TABLE_TAG_MAP].table_name,
1932                                                         media_id);
1933
1934         return 0;
1935 }
1936
1937 int mb_svc_insert_record_tag(MediaSvcHandle *mb_svc_handle, mb_svc_tag_record_s *record)
1938 {
1939         mb_svc_debug("");
1940
1941         if (record == NULL) {
1942                 mb_svc_debug("record pointer is null\n");
1943                 return MB_SVC_ERROR_INVALID_PARAMETER;
1944         }
1945
1946         int err = -1;
1947         mb_svc_tbl_field_s *mb_svc_field;
1948         char *query_string = NULL;
1949         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_TAG;
1950         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
1951
1952         record->_id = __mb_svc_db_get_next_id(mb_svc_handle, MB_SVC_TABLE_TAG);
1953
1954         if (record->_id < 0) {
1955                 mb_svc_debug("__mb_svc_db_get_next_id failed");
1956                 return MB_SVC_ERROR_DB_INTERNAL;
1957         }
1958
1959         query_string =
1960             sqlite3_mprintf(MB_SVC_INSERT_TAG_TABLE,
1961                             mb_svc_tbl[field_seq].table_name,
1962                             mb_svc_field[MB_SVC_TAG_ID].field_name,
1963                             mb_svc_field[MB_SVC_TAG_NAME].field_name,
1964                             record->_id, record->tag_name);
1965
1966         mb_svc_debug("Query : %s", query_string);
1967
1968         err = mb_svc_query_sql(mb_svc_handle, query_string);
1969         sqlite3_free(query_string);
1970
1971         if (err < 0) {
1972                 mb_svc_debug("Inserting tag table failed\n");
1973                 mb_svc_debug("query string is %s\n", query_string);
1974                 return MB_SVC_ERROR_DB_INTERNAL;
1975         }
1976
1977         return err;
1978 }
1979
1980 int mb_svc_insert_record_tag_map(MediaSvcHandle *mb_svc_handle, const char *media_uuid, int tag_id)
1981 {
1982         mb_svc_debug("");
1983
1984         int err = -1;
1985         mb_svc_tbl_field_s *mb_svc_field;
1986         char *query_string = NULL;
1987         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_TAG_MAP;
1988         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
1989
1990         int _id = __mb_svc_db_get_next_id(mb_svc_handle, MB_SVC_TABLE_TAG_MAP);
1991
1992         if (_id < 0) {
1993                 mb_svc_debug("__mb_svc_db_get_next_id failed");
1994                 return MB_SVC_ERROR_DB_INTERNAL;
1995         }
1996
1997         query_string =
1998             sqlite3_mprintf(MB_SVC_INSERT_TAG_MAP_TABLE,
1999                             mb_svc_tbl[field_seq].table_name,
2000                             mb_svc_field[MB_SVC_TAG_MAP_ID].field_name,
2001                             mb_svc_field[MB_SVC_TAG_MAP_MEDIA_UUID].field_name,
2002                             mb_svc_field[MB_SVC_TAG_MAP_TAG_ID].field_name, _id,
2003                             media_uuid, tag_id);
2004
2005         mb_svc_debug("Query : %s", query_string);
2006
2007         err = mb_svc_query_sql(mb_svc_handle, query_string);
2008         sqlite3_free(query_string);
2009
2010         if (err < 0) {
2011                 mb_svc_debug("Inserting tag map table failed\n");
2012                 mb_svc_debug("query string is %s\n", query_string);
2013                 return MB_SVC_ERROR_DB_INTERNAL;
2014         }
2015
2016         return err;
2017 }
2018
2019 int mb_svc_load_record_tag(sqlite3_stmt *stmt, mb_svc_tag_record_s *record)
2020 {
2021         mb_svc_debug("mb_svc_load_record_tag--enter\n");
2022         if (record == NULL) {
2023                 mb_svc_debug("record pointer is null\n");
2024                 return MB_SVC_ERROR_INVALID_PARAMETER;
2025         }
2026         record->_id = sqlite3_column_int(stmt, MB_SVC_TAG_ID);
2027         strncpy(record->tag_name,
2028                 (const char *)sqlite3_column_text(stmt, MB_SVC_TAG_NAME),
2029                 MB_SVC_ARRAY_LEN_MAX + 1);
2030
2031         mb_svc_debug("mb_svc_load_record_tag--leave\n");
2032         return 0;
2033 }
2034
2035 int mb_svc_load_record_tagmap(sqlite3_stmt *stmt, mb_svc_tag_record_s *record)
2036 {
2037         mb_svc_debug("mb_svc_load_record_tag--enter\n");
2038         if (record == NULL) {
2039                 mb_svc_debug("record pointer is null\n");
2040                 return MB_SVC_ERROR_INVALID_PARAMETER;
2041         }
2042
2043         record->_id = sqlite3_column_int(stmt, MB_SVC_TAG_MAP_ID);
2044         strncpy(record->media_uuid,
2045                 (const char *)sqlite3_column_text(stmt, MB_SVC_TAG_MAP_MEDIA_UUID),
2046                 MB_SVC_UUID_LEN_MAX + 1);
2047
2048         strncpy(record->tag_name, "", MB_SVC_ARRAY_LEN_MAX + 1);
2049
2050         mb_svc_debug("mb_svc_load_record_tag--leave\n");
2051         return 0;
2052 }
2053
2054 int
2055 mb_svc_delete_bookmark_meta_by_media_id(MediaSvcHandle *mb_svc_handle, const char *media_id, minfo_file_type content_type)
2056 {
2057         int err = -1;
2058         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
2059         char *tbl_name = NULL;
2060
2061         if (content_type == MINFO_ITEM_IMAGE) {
2062                 tbl_name = MB_SVC_TBL_NAME_IMAGE_META;
2063         } else if (content_type == MINFO_ITEM_VIDEO) {
2064                 tbl_name = MB_SVC_TBL_NAME_VIDEO_META;
2065         } else {
2066                 return MB_SVC_ERROR_INTERNAL;
2067         }
2068
2069         /* delete video or image record */
2070         char table_name[MB_SVC_TABLE_NAME_MAX_LEN] = { 0, };
2071         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
2072
2073         snprintf(table_name, MB_SVC_TABLE_NAME_MAX_LEN, "%s", tbl_name);
2074
2075         snprintf(query_string, sizeof(query_string),
2076                  MB_SVC_DELETE_MEDIA_RELATED_INFO_BY_MEDIA_UUID, table_name,
2077                  media_id);
2078         err = mb_svc_query_sql(mb_svc_handle, query_string);
2079         if (err < 0) {
2080                 mb_svc_debug("failed to delete record\n");
2081                 mb_svc_debug("query string is %s\n", query_string);
2082                 return MB_SVC_ERROR_DB_INTERNAL;
2083         }
2084
2085         /* if video record delete, then its related bookmark should be deleted too. */
2086         if (content_type == MINFO_ITEM_VIDEO) {
2087                 tbl_name = MB_SVC_TBL_NAME_BOOKMARK;
2088                 snprintf(query_string, sizeof(query_string),
2089                          MB_SVC_DELETE_MEDIA_RELATED_INFO_BY_MEDIA_UUID, tbl_name,
2090                          media_id);
2091                 err = mb_svc_query_sql(mb_svc_handle, query_string);
2092                 if (err < 0) {
2093                         mb_svc_debug("failed to delete record\n");
2094                         mb_svc_debug("query string is %s\n", query_string);
2095                         return MB_SVC_ERROR_DB_INTERNAL;
2096                 }
2097         }
2098
2099         /* still delete a tag record. */
2100         tbl_name = MB_SVC_TBL_NAME_TAG_MAP;
2101         snprintf(query_string, sizeof(query_string),
2102                  MB_SVC_DELETE_MEDIA_RELATED_INFO_BY_MEDIA_UUID, tbl_name,
2103                  media_id);
2104
2105         err = mb_svc_query_sql(mb_svc_handle, query_string);
2106         if (err < 0) {
2107                 mb_svc_debug("failed to delete record\n");
2108                 mb_svc_debug("query string is %s\n", query_string);
2109                 return MB_SVC_ERROR_DB_INTERNAL;
2110         }
2111
2112         return 0;
2113 }
2114
2115 int
2116 mb_svc_delete_bookmark_meta_by_media_id_sql(const char *media_id, char **sql)
2117 {
2118         *sql = sqlite3_mprintf(MB_SVC_DELETE_MEDIA_RELATED_INFO_BY_MEDIA_UUID,
2119                                                         mb_svc_tbl[MB_SVC_TABLE_BOOKMARK].table_name,
2120                                                         media_id);
2121
2122         return 0;
2123 }
2124
2125 int mb_svc_update_thumb_path_by_id(MediaSvcHandle *mb_svc_handle, const char *media_id, const char *thumb_path)
2126 {
2127         int err = -1;
2128         char *query_string = NULL;
2129
2130         char table_name[MB_SVC_TABLE_NAME_MAX_LEN] = { 0, };
2131         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
2132
2133         snprintf(table_name, MB_SVC_TABLE_NAME_MAX_LEN, "%s",
2134                  mb_svc_tbl[MB_SVC_TABLE_MEDIA].table_name);
2135
2136         query_string = sqlite3_mprintf(MB_SVC_UPDATE_MEDIA_THUMB_PATH,
2137                                                                                 table_name, thumb_path, media_id);
2138
2139         err = mb_svc_query_sql(mb_svc_handle, query_string);
2140         if (err < 0) {
2141                 mb_svc_debug("failed to update record favorite\n");
2142                 mb_svc_debug("query string is %s\n", query_string);
2143                 sqlite3_free(query_string);
2144                 return MB_SVC_ERROR_DB_INTERNAL;
2145         }
2146
2147         sqlite3_free(query_string);
2148
2149         return 0;
2150 }
2151
2152 int mb_svc_update_favorite_by_id(MediaSvcHandle *mb_svc_handle, const char *media_id, int favorite)
2153 {
2154         int err = -1;
2155         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
2156
2157         char table_name[MB_SVC_TABLE_NAME_MAX_LEN] = { 0, };
2158         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
2159
2160         snprintf(table_name, MB_SVC_TABLE_NAME_MAX_LEN, "%s",
2161                  mb_svc_tbl[MB_SVC_TABLE_MEDIA].table_name);
2162
2163         snprintf(query_string, sizeof(query_string),
2164                  MB_SVC_UPDATE_MEDIA_FAVORITE_BY_ID, table_name, favorite,
2165                  media_id);
2166         err = mb_svc_query_sql(mb_svc_handle, query_string);
2167         if (err < 0) {
2168                 mb_svc_debug("failed to update record favorite\n");
2169                 mb_svc_debug("query string is %s\n", query_string);
2170                 return MB_SVC_ERROR_DB_INTERNAL;
2171         }
2172
2173         return 0;
2174 }
2175
2176 int mb_svc_update_date_by_id(MediaSvcHandle *mb_svc_handle, const char *media_id, int date)
2177 {
2178         mb_svc_debug("");
2179         int err = -1;
2180         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
2181
2182         char table_name[MB_SVC_TABLE_NAME_MAX_LEN] = { 0, };
2183         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
2184
2185         snprintf(table_name, sizeof(table_name), "%s",
2186                  mb_svc_tbl[MB_SVC_TABLE_MEDIA].table_name);
2187
2188         snprintf(query_string, sizeof(query_string),
2189                  MB_SVC_UPDATE_MEDIA_DATE_BY_ID, table_name, date, media_id);
2190         err = mb_svc_query_sql(mb_svc_handle, query_string);
2191         if (err < 0) {
2192                 mb_svc_debug("failed to update record date\n");
2193                 mb_svc_debug("query string is %s\n", query_string);
2194                 return MB_SVC_ERROR_DB_INTERNAL;
2195         }
2196
2197         return 0;
2198 }
2199
2200 int mb_svc_update_thumb_path_sql(const char *media_id, const char *thumb_path, char **sql)
2201 {
2202         mb_svc_debug("");
2203
2204         if (thumb_path == NULL) {
2205                 mb_svc_debug("thumb_path is null\n");
2206                 return MB_SVC_ERROR_INVALID_PARAMETER;
2207         }
2208
2209         mb_svc_debug("thumb:%s, id:%d", thumb_path, media_id);
2210
2211         int err = 0;
2212         mb_svc_tbl_field_s *mb_svc_field;
2213         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_MEDIA;
2214         mb_svc_field = mb_svc_tbl[field_seq].mb_svc_field;
2215
2216         *sql =
2217             sqlite3_mprintf(MB_SVC_UPDATE_MEDIA_THUMB_PATH,
2218                                                 mb_svc_tbl[field_seq].table_name,
2219                                                 thumb_path,
2220                                                 media_id);
2221
2222         mb_svc_debug("Query : %s", *sql);
2223
2224         return err;
2225 }
2226
2227 int
2228 mb_svc_update_album_lock_status(MediaSvcHandle *mb_svc_handle, const char *folder_id, int lock,
2229                                 minfo_store_type storage_type)
2230 {
2231         int err = 0;
2232         sqlite3_stmt *stmt = NULL;
2233         char query_string[MB_SVC_DEFAULT_QUERY_SIZE + 1] = { 0 };
2234
2235         if (lock != 0 && lock != 1) {
2236                 mb_svc_debug("lock status is invalid");
2237                 return MB_SVC_ERROR_INVALID_PARAMETER;
2238         }
2239
2240         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
2241         if (handle == NULL) {
2242                 mb_svc_debug("handle is NULL");
2243                 return MB_SVC_ERROR_DB_INTERNAL;
2244         }
2245
2246         mb_svc_debug
2247             ("mb_svc_update_album_lock_status( folder id:%d, storage_type:%d, lock:%d",
2248              folder_id, storage_type, lock);
2249
2250         char table_name[MB_SVC_TABLE_NAME_MAX_LEN] = { 0, };
2251         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
2252
2253         snprintf(table_name, MB_SVC_TABLE_NAME_MAX_LEN, "%s",
2254                  MB_SVC_TBL_NAME_FOLDER);
2255
2256         snprintf(query_string, sizeof(query_string),
2257                  MB_SVC_UPDATE_FOLDER_ALBUM_STATUS, table_name);
2258         mb_svc_debug("Query : %s", query_string);
2259
2260         err =
2261             sqlite3_prepare_v2(handle, query_string, strlen(query_string),
2262                                &stmt, NULL);
2263
2264         if (err != SQLITE_OK) {
2265                 mb_svc_debug("prepare error [%s]\n", sqlite3_errmsg(handle));
2266                 mb_svc_debug("query string is %s\n", query_string);
2267                 return MB_SVC_ERROR_DB_INTERNAL;
2268         }
2269
2270         sqlite3_bind_int(stmt, 1, lock);
2271         sqlite3_bind_text(stmt, 2, folder_id, strlen(folder_id), NULL);
2272
2273         err = sqlite3_step(stmt);
2274
2275         if (err != SQLITE_OK && err != SQLITE_DONE) {
2276                 mb_svc_debug("sqlite3_step fails : %s, db error info is : %s",
2277                              query_string, sqlite3_errmsg(handle));
2278
2279                 err = MB_SVC_ERROR_DB_INTERNAL;
2280         }
2281
2282         sqlite3_finalize(stmt);
2283
2284         return err;
2285 }
2286
2287 int
2288 mb_svc_set_media_records_as_valid(MediaSvcHandle *mb_svc_handle, const minfo_store_type storage_type,
2289                                   int valid)
2290 {
2291         mb_svc_debug("storage_type: %d", storage_type);
2292
2293         /* 1. first set reords as valid/invalid in 'folder' table */
2294         mb_svc_tbl_name_e field_seq = MB_SVC_TABLE_FOLDER;
2295         sqlite3_stmt *stmt = NULL;
2296         int f_id = 0;
2297         char folder_uuid[MB_SVC_UUID_LEN_MAX + 1] = {0,};
2298
2299         char table_name[MB_SVC_TABLE_NAME_MAX_LEN] = { 0, };
2300         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
2301
2302         sqlite3 *handle = (sqlite3 *)mb_svc_handle;
2303         if (handle == NULL) {
2304                 mb_svc_debug("handle is NULL");
2305                 return MB_SVC_ERROR_DB_INTERNAL;
2306         }
2307
2308         snprintf(table_name, MB_SVC_TABLE_NAME_MAX_LEN, "%s",
2309                  mb_svc_tbl[field_seq].table_name);
2310
2311         int err;
2312         char *sql =
2313             sqlite3_mprintf("update %s set valid = %d where storage_type = %d;",
2314                             table_name, valid, storage_type);
2315         err = mb_svc_query_sql(mb_svc_handle, sql);
2316         sqlite3_free(sql);
2317         if (err != SQLITE_OK) {
2318                 mb_svc_debug
2319                     ("To set all items as valid is failed in folder table(%d)",
2320                      err);
2321                 return MB_SVC_ERROR_DB_INTERNAL;
2322         }
2323         /* 2. get all of related folder id. */
2324         sql =
2325             sqlite3_mprintf("select folder_uuid from %s where storage_type = %d;",
2326                             table_name, storage_type);
2327         err = sqlite3_prepare_v2(handle, sql, strlen(sql), &stmt, NULL);
2328
2329         mb_svc_debug("SQL : %s", sql);
2330
2331         if (SQLITE_OK != err) {
2332                 mb_svc_debug("prepare error [%s]", sqlite3_errmsg(handle));
2333                 mb_svc_debug("query string is %s\n", sql);
2334                 sqlite3_free(sql);
2335                 return MB_SVC_ERROR_DB_INTERNAL;
2336         }
2337
2338         sqlite3_free(sql);
2339
2340         field_seq = MB_SVC_TABLE_MEDIA;
2341         memset(table_name, 0x00, MB_SVC_TABLE_NAME_MAX_LEN);
2342         snprintf(table_name, MB_SVC_TABLE_NAME_MAX_LEN, "%s",
2343                  mb_svc_tbl[field_seq].table_name);
2344
2345         for (;;) {
2346                 err = sqlite3_step(stmt);
2347                 if (err != SQLITE_ROW) {
2348                         break;
2349                 }
2350
2351                 //f_id = sqlite3_column_int(stmt, 0);
2352                 strncpy(folder_uuid, (const char *)sqlite3_column_text(stmt, 0), MB_SVC_UUID_LEN_MAX + 1);
2353
2354                 /* 3. then set every reords as valid/invalid in 'media' table */
2355                 sql =
2356                     sqlite3_mprintf
2357                     ("update %s set valid = %d where folder_uuid = '%s';",
2358                      table_name, valid, folder_uuid);
2359                 err = mb_svc_query_sql(mb_svc_handle, sql);
2360                 sqlite3_free(sql);
2361                 if (err != SQLITE_OK) {
2362                         mb_svc_debug
2363                             ("To set all items as valid is failed in folder[%d]",
2364                              f_id);
2365                         sqlite3_finalize(stmt);
2366                         return MB_SVC_ERROR_DB_INTERNAL;
2367                 }
2368         }
2369
2370         sqlite3_finalize(stmt);
2371
2372         return 0;
2373 }