src/audio/audio-svc.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 <unistd.h>
  23 #include <stdarg.h>
  24 #include <db-util.h>
  25
  26 #include "media-svc-env.h"
  27 #include "media-svc-util.h"
  28 #include "audio-svc.h"
  29 #include "audio-svc-error.h"
  30 #include "audio-svc-debug.h"
  31 #include "audio-svc-utils.h"
  32 #include "audio-svc-music-table.h"
  33 #include "audio-svc-playlist-table.h"
  34 #include "audio-svc-types-priv.h"
  35 #include "audio-svc-db-utils.h"
  36
  37 #define AUDIO_SVC_DATABASE_NAME "/opt/dbspace/.media.db"
  38
  39 static __thread int g_audio_svc_item_valid_data_cnt = 1;
  40 static __thread int g_audio_svc_item_valid_cur_data_cnt = 0;
  41
  42 static __thread int g_audio_svc_move_item_data_cnt = 1;
  43 static __thread int g_audio_svc_move_item_cur_data_cnt = 0;
  44
  45 static __thread int g_audio_svc_insert_item_data_cnt = 1;
  46 static __thread int g_audio_svc_insert_item_cur_data_cnt = 0;
  47
  48 int audio_svc_create_table(MediaSvcHandle *handle)
  49 {
  50         int ret = AUDIO_SVC_ERROR_NONE;
  51         sqlite3 * db_handle = (sqlite3 *)handle;
  52
  53         if(db_handle == NULL) {
  54                 audio_svc_error("Handle is NULL");
  55                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
  56         }
  57
  58         ret = _audio_svc_create_music_table(db_handle);
  59         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
  60
  61         ret = _audio_svc_create_playlist_table(db_handle);
  62         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
  63
  64         ret = _audio_svc_create_folder_table(db_handle);
  65         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
  66
  67         return AUDIO_SVC_ERROR_NONE;
  68 }
  69
  70 int audio_svc_delete_all(MediaSvcHandle *handle, audio_svc_storage_type_e storage_type)
  71 {
  72         char * dirpath = NULL;
  73         int ret = AUDIO_SVC_ERROR_NONE;
  74         sqlite3 * db_handle = (sqlite3 *)handle;
  75
  76         if(db_handle == NULL) {
  77                 audio_svc_error("Handle is NULL");
  78                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
  79         }
  80
  81         if (storage_type != AUDIO_SVC_STORAGE_PHONE
  82             && storage_type != AUDIO_SVC_STORAGE_MMC) {
  83                 audio_svc_error("storage type should be phone or mmc");
  84                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
  85         }
  86
  87         ret = _audio_svc_truncate_music_table(db_handle, storage_type);
  88         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
  89
  90         /* 20111110, make each thumbnail */
  91         /* 20110428, thumbnail path depends on th album ID. So Don't remove all file in special directory. */
  92         dirpath = (storage_type == AUDIO_SVC_STORAGE_PHONE) ? AUDIO_SVC_THUMB_PHONE_PATH : AUDIO_SVC_THUMB_MMC_PATH;
  93
  94         /* remove thumbnails */
  95         audio_svc_debug("dirpath [%s]", dirpath);
  96         ret = _audio_svc_remove_all_files_in_dir(dirpath);
  97         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
  98
  99         /* update folder table */
 100         ret = _audio_svc_delete_folder(db_handle, storage_type, NULL);
 101         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 102
 103 #if 0
 104         ret = _audio_svc_check_and_update_albums_table(NULL);
 105         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 106 #endif
 107
 108         return AUDIO_SVC_ERROR_NONE;
 109 }
 110
 111 int audio_svc_insert_item_start(MediaSvcHandle *handle, int data_cnt)
 112 {
 113         audio_svc_debug("Transaction data count : [%d]", data_cnt);
 114
 115         if(handle == NULL) {
 116                 audio_svc_error("Handle is NULL");
 117                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 118         }
 119
 120         if(data_cnt < 1) {
 121                 audio_svc_error("data_cnt shuld be bigger than 1. data_cnt : [%d]", data_cnt);
 122                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 123         }
 124
 125         g_audio_svc_insert_item_data_cnt  = data_cnt;
 126         g_audio_svc_insert_item_cur_data_cnt  = 0;
 127
 128         return AUDIO_SVC_ERROR_NONE;
 129 }
 130
 131 int audio_svc_insert_item_end(MediaSvcHandle *handle)
 132 {
 133         audio_svc_debug_func();
 134
 135         int ret = AUDIO_SVC_ERROR_NONE;
 136         sqlite3 * db_handle = (sqlite3 *)handle;
 137
 138         if(db_handle == NULL) {
 139                 audio_svc_error("Handle is NULL");
 140                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 141         }
 142
 143         if (g_audio_svc_insert_item_cur_data_cnt  > 0) {
 144
 145                 ret = _audio_svc_list_query_do(db_handle, AUDIO_SVC_QUERY_INSERT_ITEM);
 146         }
 147
 148         g_audio_svc_insert_item_data_cnt  = 1;
 149         g_audio_svc_insert_item_cur_data_cnt  = 0;
 150
 151         return ret;
 152 }
 153
 154 int audio_svc_insert_item(MediaSvcHandle *handle, audio_svc_storage_type_e storage_type,
 155                           const char *path, audio_svc_category_type_e category)
 156 {
 157         int ret = AUDIO_SVC_ERROR_NONE;
 158         sqlite3 * db_handle = (sqlite3 *)handle;
 159
 160         if(db_handle == NULL) {
 161                 audio_svc_error("Handle is NULL");
 162                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 163         }
 164
 165         if (storage_type != AUDIO_SVC_STORAGE_PHONE
 166             && storage_type != AUDIO_SVC_STORAGE_MMC) {
 167                 audio_svc_error("storage type is incorrect(%d)", storage_type);
 168                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 169         }
 170
 171         if (!STRING_VALID(path)) {
 172                 audio_svc_error("path is NULL");
 173                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 174         }
 175
 176         audio_svc_debug("storage[%d], path[%s], category[%d]", storage_type, path, category);
 177
 178         if ((category != AUDIO_SVC_CATEGORY_MUSIC)
 179             && (category != AUDIO_SVC_CATEGORY_SOUND)) {
 180                 audio_svc_error("invalid category condition");
 181                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 182         }
 183
 184         audio_svc_audio_item_s item;
 185         memset(&item, 0, sizeof(audio_svc_audio_item_s));
 186
 187         item.category = category;
 188         item.time_added = time(NULL);
 189
 190         ret = _audio_svc_extract_metadata_audio(storage_type, path, &item);
 191         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 192
 193         if (g_audio_svc_insert_item_data_cnt == 1) {
 194
 195                 return _audio_svc_insert_item_with_data(db_handle, &item, FALSE);
 196
 197         }
 198         else if(g_audio_svc_insert_item_cur_data_cnt  < (g_audio_svc_insert_item_data_cnt  - 1)) {
 199
 200                 ret = _audio_svc_insert_item_with_data(db_handle, &item, TRUE);
 201                 audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 202                 g_audio_svc_insert_item_cur_data_cnt ++;
 203
 204         }
 205         else if (g_audio_svc_insert_item_cur_data_cnt  == (g_audio_svc_insert_item_data_cnt  - 1)) {
 206
 207                 ret = _audio_svc_insert_item_with_data(db_handle, &item, TRUE);
 208                 audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 209
 210                 ret = _audio_svc_list_query_do(db_handle, AUDIO_SVC_QUERY_INSERT_ITEM);
 211                 audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 212
 213                 g_audio_svc_insert_item_cur_data_cnt = 0;
 214
 215         }
 216         else {
 217                 audio_svc_debug("Error in audio_svc_insert_item");
 218                 return AUDIO_SVC_ERROR_INTERNAL;
 219         }
 220
 221         return AUDIO_SVC_ERROR_NONE;
 222 }
 223
 224 int audio_svc_insert_item_immediately(MediaSvcHandle *handle, audio_svc_storage_type_e storage_type,
 225                           const char *path, audio_svc_category_type_e category)
 226 {
 227         int ret = AUDIO_SVC_ERROR_NONE;
 228         sqlite3 * db_handle = (sqlite3 *)handle;
 229
 230         if(db_handle == NULL) {
 231                 audio_svc_error("Handle is NULL");
 232                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 233         }
 234
 235         if (storage_type != AUDIO_SVC_STORAGE_PHONE
 236             && storage_type != AUDIO_SVC_STORAGE_MMC) {
 237                 audio_svc_error("storage type is incorrect(%d)", storage_type);
 238                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 239         }
 240
 241         if (!STRING_VALID(path)) {
 242                 audio_svc_error("path is NULL");
 243                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 244         }
 245
 246         audio_svc_debug("storage[%d], path[%s], category[%d]", storage_type, path, category);
 247
 248         if ((category != AUDIO_SVC_CATEGORY_MUSIC)
 249             && (category != AUDIO_SVC_CATEGORY_SOUND)) {
 250                 audio_svc_error("invalid category condition");
 251                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 252         }
 253
 254         audio_svc_audio_item_s item;
 255         memset(&item, 0, sizeof(audio_svc_audio_item_s));
 256
 257         item.category = category;
 258         item.time_added = time(NULL);
 259
 260         ret = _audio_svc_extract_metadata_audio(storage_type, path, &item);
 261         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 262
 263         return _audio_svc_insert_item_with_data(db_handle, &item, FALSE);
 264 }
 265
 266 int audio_svc_get_item_by_path(MediaSvcHandle *handle, const char *path, AudioHandleType * item_handle)
 267 {
 268         sqlite3 * db_handle = (sqlite3 *)handle;
 269
 270         if(db_handle == NULL) {
 271                 audio_svc_error("Handle is NULL");
 272                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 273         }
 274
 275         if (!STRING_VALID(path)) {
 276                 audio_svc_error("file path is null");
 277                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 278         }
 279         audio_svc_audio_item_s *item = (audio_svc_audio_item_s *) item_handle;
 280         if (!item) {
 281                 audio_svc_error("item is null");
 282                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 283         }
 284
 285         memset(item, 0, sizeof(audio_svc_audio_item_s));
 286
 287         return _audio_svc_select_music_record_by_path(db_handle, path, item);
 288 }
 289
 290 int audio_svc_get_item_by_audio_id(MediaSvcHandle *handle, const char *audio_id, AudioHandleType *item_handle)
 291 {
 292         sqlite3 * db_handle = (sqlite3 *)handle;
 293
 294         if(db_handle == NULL) {
 295                 audio_svc_error("Handle is NULL");
 296                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 297         }
 298
 299         if (!STRING_VALID(audio_id)) {
 300                 audio_svc_error("invalid audio_id");
 301                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 302         }
 303
 304         audio_svc_audio_item_s *item = (audio_svc_audio_item_s *) item_handle;
 305
 306         if (!item) {
 307                 audio_svc_error("item is null");
 308                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 309         }
 310
 311         memset(item, 0, sizeof(audio_svc_audio_item_s));
 312
 313         return _audio_svc_select_music_record_by_audio_id(db_handle, audio_id, item);
 314 }
 315
 316 int audio_svc_delete_item_by_path(MediaSvcHandle *handle, const char *path)
 317 {
 318         int ret = AUDIO_SVC_ERROR_NONE;
 319         sqlite3 * db_handle = (sqlite3 *)handle;
 320
 321         if(db_handle == NULL) {
 322                 audio_svc_error("Handle is NULL");
 323                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 324         }
 325
 326         if (!STRING_VALID(path)) {
 327                 audio_svc_error("file path is null");
 328                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 329         }
 330
 331         audio_svc_audio_item_s item;
 332         memset(&item, 0, sizeof(audio_svc_audio_item_s));
 333
 334         ret = _audio_svc_select_music_record_by_path(db_handle, path, &item);
 335         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 336
 337         ret = _audio_svc_delete_music_record_by_audio_id(db_handle, item.audio_uuid);
 338         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 339
 340         ret = _audio_svc_delete_playlist_item_records_by_audio_id(db_handle, item.audio_uuid);
 341         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 342
 343         ret = _audio_svc_check_and_update_folder_table(db_handle, path);
 344         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 345
 346 #if 0
 347         ret = _audio_svc_check_and_update_albums_table(item.audio.album);
 348         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 349 #endif
 350 #if 0
 351         if (strlen(item.thumbname) > 0) {
 352                 ret = _audio_svc_check_and_remove_thumbnail(item.thumbname);
 353                 audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 354         }
 355 #endif
 356         if (strlen(item.thumbname) > 0) {
 357                 if (_audio_svc_remove_file(item.thumbname) == FALSE) {
 358                         audio_svc_error("fail to remove thumbnail file.");
 359                         return AUDIO_SVC_ERROR_INTERNAL;
 360                 }
 361         }
 362         return AUDIO_SVC_ERROR_NONE;
 363 }
 364
 365 int audio_svc_move_item_start(MediaSvcHandle *handle, int data_cnt)
 366 {
 367         audio_svc_debug("Transaction data count : [%d]", data_cnt);
 368
 369         if(handle == NULL) {
 370                 audio_svc_error("Handle is NULL");
 371                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 372         }
 373
 374         if(data_cnt < 1) {
 375                 audio_svc_error("data_cnt shuld be bigger than 1. data_cnt : [%d]", data_cnt);
 376                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 377         }
 378
 379         g_audio_svc_move_item_data_cnt  = data_cnt;
 380         g_audio_svc_move_item_cur_data_cnt  = 0;
 381
 382         return AUDIO_SVC_ERROR_NONE;
 383 }
 384
 385 int audio_svc_move_item_end(MediaSvcHandle *handle)
 386 {
 387         int ret = AUDIO_SVC_ERROR_NONE;
 388         sqlite3 * db_handle = (sqlite3 *)handle;
 389
 390         if(db_handle == NULL) {
 391                 audio_svc_error("Handle is NULL");
 392                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 393         }
 394
 395         audio_svc_debug_func();
 396
 397         if (g_audio_svc_move_item_cur_data_cnt  > 0) {
 398
 399                 g_audio_svc_move_item_data_cnt  = 1;
 400                 g_audio_svc_move_item_cur_data_cnt  = 0;
 401
 402                 ret = _audio_svc_list_query_do(db_handle, AUDIO_SVC_QUERY_MOVE_ITEM);
 403                 audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 404         }
 405
 406         g_audio_svc_move_item_data_cnt  = 1;
 407         g_audio_svc_move_item_cur_data_cnt  = 0;
 408
 409         ret = _audio_svc_update_folder_table(db_handle);
 410         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 411
 412         return AUDIO_SVC_ERROR_NONE;
 413 }
 414
 415 //old db was separated into phone and mmc table.
 416 //so when src_storage and dest_storage is not same, then need to remove old one and insert new one
 417 //since audio_id in mmc table is started with over 5000001 . but don't need to do like this anymore.
 418 int audio_svc_move_item(MediaSvcHandle *handle, audio_svc_storage_type_e src_storage,
 419                         const char *src_path,
 420                         audio_svc_storage_type_e dest_storage,
 421                         const char *dest_path)
 422 {
 423         char folder_id[AUDIO_SVC_UUID_SIZE+1] = {0,};
 424         int ret = AUDIO_SVC_ERROR_NONE;
 425
 426         sqlite3 * db_handle = (sqlite3 *)handle;
 427
 428         if(db_handle == NULL) {
 429                 audio_svc_error("Handle is NULL");
 430                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 431         }
 432
 433         if (!STRING_VALID(src_path)) {
 434                 audio_svc_error("src_path is null");
 435                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 436         }
 437
 438         if (!STRING_VALID(dest_path)) {
 439                 audio_svc_error("dest_path is null");
 440                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 441         }
 442
 443         if (src_storage != AUDIO_SVC_STORAGE_PHONE
 444             && src_storage != AUDIO_SVC_STORAGE_MMC) {
 445                 audio_svc_error("storage type should be phone or mmc");
 446                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 447         }
 448
 449         if (dest_storage != AUDIO_SVC_STORAGE_PHONE
 450             && dest_storage != AUDIO_SVC_STORAGE_MMC) {
 451                 audio_svc_error("storage type should be phone or mmc");
 452                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 453         }
 454
 455         audio_svc_debug("g_audio_svc_move_item_data_cnt =[%d], g_audio_svc_move_item_cur_data_cnt =[%d]",
 456                                 g_audio_svc_move_item_data_cnt , g_audio_svc_move_item_cur_data_cnt );
 457
 458         if (g_audio_svc_move_item_data_cnt == 1) {
 459                 /* update path and storage type*/
 460                 ret = _audio_svc_update_path_and_storage_in_music_record(db_handle, src_path, dest_path, dest_storage);
 461                 audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 462
 463                 /* get folder_id */
 464                 ret = _audio_svc_get_and_append_folder_id_by_path(db_handle, dest_path, dest_storage, folder_id);
 465                 audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 466
 467                 /* update folder_id */
 468                 ret = _audio_svc_update_folder_id_in_music_record(db_handle, dest_path, folder_id);
 469                 audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 470
 471                 /* remove old folder path */
 472                 ret = _audio_svc_check_and_update_folder_table(db_handle, src_path);
 473                 audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 474         }
 475         else if (g_audio_svc_move_item_cur_data_cnt  < (g_audio_svc_move_item_data_cnt  - 1)) {
 476
 477                 ret = _audio_svc_get_and_append_folder_id_by_path(db_handle, dest_path, dest_storage, folder_id);
 478                 audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 479
 480                 ret = _audio_svc_move_item_query_add(db_handle, src_path, dest_path, dest_storage, folder_id);
 481
 482                 g_audio_svc_move_item_cur_data_cnt ++;
 483         }
 484         else if (g_audio_svc_move_item_cur_data_cnt  == (g_audio_svc_move_item_data_cnt  - 1)) {
 485
 486                 ret = _audio_svc_get_and_append_folder_id_by_path(db_handle, dest_path, dest_storage, folder_id);
 487                 audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 488
 489                 ret = _audio_svc_move_item_query_add(db_handle, src_path, dest_path, dest_storage, folder_id);
 490
 491                 ret = _audio_svc_list_query_do(db_handle, AUDIO_SVC_QUERY_MOVE_ITEM);
 492                 audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 493
 494                 g_audio_svc_move_item_cur_data_cnt = 0;
 495         }
 496         else {
 497                 audio_svc_debug("Error in audio_svc_move_item");
 498                 return AUDIO_SVC_ERROR_INTERNAL;
 499         }
 500
 501         return AUDIO_SVC_ERROR_NONE;
 502 }
 503
 504 int audio_svc_refresh_metadata(MediaSvcHandle *handle, const char *audio_id)
 505 {
 506         int ret = AUDIO_SVC_ERROR_NONE;
 507         sqlite3 * db_handle = (sqlite3 *)handle;
 508
 509         if(db_handle == NULL) {
 510                 audio_svc_error("Handle is NULL");
 511                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 512         }
 513
 514         if (!STRING_VALID(audio_id)) {
 515                 audio_svc_error("invalid audio_id");
 516                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 517         }
 518
 519         audio_svc_audio_item_s item;
 520         memset(&item, 0, sizeof(audio_svc_audio_item_s));
 521
 522         ret = _audio_svc_select_music_record_by_audio_id(db_handle, audio_id, &item);
 523         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 524
 525         if (item.audio.duration > 0) {
 526                 audio_svc_debug("The item has already valid metadata");
 527                 return AUDIO_SVC_ERROR_NONE;
 528         }
 529
 530         ret = _audio_svc_extract_metadata_audio(item.storage_type, item.pathname, &item);
 531         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
 532
 533         return _audio_svc_update_metadata_in_music_record(db_handle, audio_id, &item);
 534 }
 535
 536 int audio_svc_count_group_item(MediaSvcHandle *handle, audio_svc_group_type_e group_type,
 537                                const char *limit_string1,
 538                                const char *limit_string2,
 539                                const char *filter_string,
 540                                const char *filter_string2, int *count)
 541 {
 542         sqlite3 * db_handle = (sqlite3 *)handle;
 543
 544         if(db_handle == NULL) {
 545                 audio_svc_error("Handle is NULL");
 546                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 547         }
 548
 549         if (group_type < AUDIO_SVC_GROUP_BY_ALBUM
 550             || group_type > AUDIO_SVC_GROUP_BY_COMPOSER) {
 551                 audio_svc_error("group type is wrong : %d", group_type);
 552                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 553         }
 554
 555         if ((group_type == AUDIO_SVC_GROUP_BY_ARTIST_ALBUM ||
 556              group_type == AUDIO_SVC_GROUP_BY_GENRE_ARTIST ||
 557              group_type == AUDIO_SVC_GROUP_BY_GENRE_ALBUM) &&
 558             /* && (!limit_string1 || strlen(limit_string1) == 0)) */
 559             (!limit_string1)) {
 560                 audio_svc_error("limit string1 should be entered");
 561                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 562         }
 563
 564         if ((group_type == AUDIO_SVC_GROUP_BY_GENRE_ARTIST_ALBUM) &&
 565             /* &&    (!limit_string2 || strlen(limit_string2) == 0)) */
 566             (!limit_string2)) {
 567                 audio_svc_error("limit_string2 should be entered");
 568                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 569         }
 570
 571         if (count == NULL) {
 572                 audio_svc_error("invalid count condition");
 573                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 574         }
 575
 576         return _audio_svc_count_music_group_records(db_handle, group_type, limit_string1,
 577                                                     limit_string2,
 578                                                     filter_string,
 579                                                     filter_string2, count);
 580 }
 581
 582 int audio_svc_get_group_item(MediaSvcHandle *handle, audio_svc_group_type_e group_type,
 583                              const char *limit_string1,
 584                              const char *limit_string2,
 585                              const char *filter_string,
 586                              const char *filter_string2, int offset, int rows,
 587                              AudioHandleType *result_records)
 588 {
 589         sqlite3 * db_handle = (sqlite3 *)handle;
 590
 591         if(db_handle == NULL) {
 592                 audio_svc_error("Handle is NULL");
 593                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 594         }
 595
 596         audio_svc_group_item_s *result_groups =
 597             (audio_svc_group_item_s *) result_records;
 598
 599         if (group_type < AUDIO_SVC_GROUP_BY_ALBUM
 600             || group_type > AUDIO_SVC_GROUP_BY_COMPOSER) {
 601                 audio_svc_error("group type is wrong : %d", group_type);
 602                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 603         }
 604
 605         if ((group_type == AUDIO_SVC_GROUP_BY_ARTIST_ALBUM ||
 606              group_type == AUDIO_SVC_GROUP_BY_GENRE_ARTIST ||
 607              group_type == AUDIO_SVC_GROUP_BY_GENRE_ALBUM ||
 608              group_type == AUDIO_SVC_GROUP_BY_GENRE_ARTIST_ALBUM) &&
 609             /* && (!limit_string1 || strlen(limit_string1) == 0)) */
 610             (!limit_string1)) {
 611                 audio_svc_error("limit_string1 should be entered");
 612                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 613         }
 614
 615         if ((group_type == AUDIO_SVC_GROUP_BY_GENRE_ARTIST_ALBUM) &&
 616             /* &&    (!limit_string2 || strlen(limit_string2) == 0)) */
 617             (!limit_string2)) {
 618                 audio_svc_error("limit_string2 should be entered");
 619                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 620         }
 621
 622         if (offset < 0 || rows <= 0) {
 623                 audio_svc_error("offset(%d) or rows value(%d) is wrong", offset,
 624                                 rows);
 625                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 626         }
 627
 628         if (!result_records) {
 629                 audio_svc_error
 630                     ("The memory for search records should be allocated ");
 631                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 632         }
 633
 634         return _audio_svc_get_music_group_records(db_handle, group_type, limit_string1,
 635                                                   limit_string2, filter_string,
 636                                                   filter_string2, offset, rows,
 637                                                   result_groups);
 638
 639 }
 640
 641 int audio_svc_count_list_item(MediaSvcHandle *handle, audio_svc_track_type_e item_type,
 642                               const char *type_string, const char *type_string2,
 643                               const char *filter_string,
 644                               const char *filter_string2, int *count)
 645 {
 646         sqlite3 * db_handle = (sqlite3 *)handle;
 647
 648         if(db_handle == NULL) {
 649                 audio_svc_error("Handle is NULL");
 650                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 651         }
 652
 653         if (item_type < AUDIO_SVC_TRACK_ALL
 654             || item_type > AUDIO_SVC_TRACK_BY_PLAYLIST) {
 655                 audio_svc_error("item type is wrong : %d", item_type);
 656                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 657         }
 658
 659         if (((item_type >= AUDIO_SVC_TRACK_BY_ALBUM)
 660              && (item_type <= AUDIO_SVC_TRACK_BY_COMPOSER)) && (!type_string)) {
 661                 audio_svc_error("type_string should be entered");
 662                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 663         }
 664
 665         if (((item_type == AUDIO_SVC_TRACK_BY_ARTIST_GENRE)
 666              || (item_type == AUDIO_SVC_TRACK_BY_ARTIST_ALBUM))
 667             && (!type_string2)) {
 668                 audio_svc_error("type_string2 should be entered");
 669                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 670         }
 671
 672         if (count == NULL) {
 673                 audio_svc_error("invalid count condition");
 674                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 675         }
 676
 677         return _audio_svc_count_music_track_records(db_handle, item_type, type_string,
 678                                                     type_string2, filter_string,
 679                                                     filter_string2, count);
 680 }
 681
 682 int audio_svc_get_list_item(MediaSvcHandle *handle, audio_svc_track_type_e item_type,
 683                             const char *type_string, const char *type_string2,
 684                             const char *filter_string,
 685                             const char *filter_string2, int offset, int rows,
 686                             AudioHandleType *track)
 687 {
 688         audio_svc_list_item_s *result_track = (audio_svc_list_item_s *) track;
 689         sqlite3 * db_handle = (sqlite3 *)handle;
 690
 691         if(db_handle == NULL) {
 692                 audio_svc_error("Handle is NULL");
 693                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 694         }
 695
 696         if (item_type < AUDIO_SVC_TRACK_ALL
 697             || item_type > AUDIO_SVC_TRACK_BY_PLAYLIST) {
 698                 audio_svc_error("track type is wrong : %d", item_type);
 699                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 700         }
 701
 702         if (((item_type >= AUDIO_SVC_TRACK_BY_ALBUM)
 703              && (item_type <= AUDIO_SVC_TRACK_BY_COMPOSER)) && (!type_string)) {
 704                 audio_svc_error("type_string should be entered");
 705                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 706         }
 707
 708         if (((item_type == AUDIO_SVC_TRACK_BY_ARTIST_GENRE)
 709              || (item_type == AUDIO_SVC_TRACK_BY_ARTIST_ALBUM))
 710             && (!type_string2)) {
 711                 audio_svc_error("type_string2 should be entered");
 712                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 713         }
 714
 715         if (offset < 0 || rows <= 0) {
 716                 audio_svc_error("offset(%d) or row value(%d) is wrong", offset,
 717                                 rows);
 718                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 719         }
 720
 721         if (!track) {
 722                 audio_svc_error
 723                     ("The memory for search records should be allocated ");
 724                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 725         }
 726
 727         memset(result_track, 0, sizeof(audio_svc_list_item_s) * rows);
 728
 729         return _audio_svc_get_music_track_records(db_handle, item_type, type_string,
 730                                                   type_string2, filter_string,
 731                                                   filter_string2, offset, rows,
 732                                                   result_track);
 733
 734 }
 735
 736 int audio_svc_get_audio_id_by_path(MediaSvcHandle *handle, const char *path, char *audio_id, size_t max_audio_id_length)
 737 {
 738         sqlite3 * db_handle = (sqlite3 *)handle;
 739
 740         if(db_handle == NULL) {
 741                 audio_svc_error("Handle is NULL");
 742                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 743         }
 744
 745         if (!STRING_VALID(path)) {
 746                 audio_svc_error("file path is null");
 747                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 748         }
 749
 750         if (audio_id == NULL) {
 751                 audio_svc_error("invalid audio_id condition");
 752                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 753         }
 754
 755         return _audio_svc_search_audio_id_by_path(db_handle, path, audio_id);
 756 }
 757
 758 int audio_svc_get_thumbnail_path_by_path(MediaSvcHandle *handle, const char *path, char *thumb_path,
 759                                          size_t max_thumb_path_length)
 760 {
 761         sqlite3 * db_handle = (sqlite3 *)handle;
 762
 763         if(db_handle == NULL) {
 764                 audio_svc_error("Handle is NULL");
 765                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 766         }
 767
 768         if (!STRING_VALID(path)) {
 769                 audio_svc_error("file path is null");
 770                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 771         }
 772
 773         return _audio_svc_get_thumbnail_path_by_path(db_handle, path, thumb_path);
 774 }
 775
 776 int audio_svc_add_playlist(MediaSvcHandle *handle, const char *playlist_name, int *playlist_id)
 777 {
 778         sqlite3 * db_handle = (sqlite3 *)handle;
 779
 780         if(db_handle == NULL) {
 781                 audio_svc_error("Handle is NULL");
 782                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 783         }
 784
 785         if (!STRING_VALID(playlist_name)) {
 786                 audio_svc_error("invalid playlist_name");
 787                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 788         }
 789
 790         if (playlist_id == NULL) {
 791                 audio_svc_error("invalid playlist_id");
 792                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 793         }
 794
 795         return _audio_svc_insert_playlist_record(db_handle, playlist_name, playlist_id);
 796 }
 797
 798 int audio_svc_delete_playlist(MediaSvcHandle *handle, int playlist_id)
 799 {
 800         sqlite3 * db_handle = (sqlite3 *)handle;
 801
 802         if(db_handle == NULL) {
 803                 audio_svc_error("Handle is NULL");
 804                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 805         }
 806
 807         if (playlist_id < 0) {
 808                 audio_svc_error("invalid playlist_id");
 809                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 810         }
 811
 812         return _audio_svc_delete_playlist_record(db_handle, playlist_id);
 813 }
 814
 815 int audio_svc_update_playlist_name(MediaSvcHandle *handle, int playlist_id,
 816                                    const char *new_playlist_name)
 817 {
 818         sqlite3 * db_handle = (sqlite3 *)handle;
 819
 820         if(db_handle == NULL) {
 821                 audio_svc_error("Handle is NULL");
 822                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 823         }
 824
 825         if (playlist_id < 0) {
 826                 audio_svc_error("invalid playlist_id");
 827                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 828         }
 829
 830         if (!STRING_VALID(new_playlist_name)) {
 831                 audio_svc_error("invalid playlist_name");
 832                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 833         }
 834
 835         return _audio_svc_update_playlist_record_by_name(db_handle, playlist_id,
 836                                                          new_playlist_name);
 837 }
 838
 839 int audio_svc_count_playlist(MediaSvcHandle *handle, const char *filter_string,
 840                              const char *filter_string2, int *count)
 841 {
 842         sqlite3 * db_handle = (sqlite3 *)handle;
 843
 844         if(db_handle == NULL) {
 845                 audio_svc_error("Handle is NULL");
 846                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 847         }
 848
 849         if (count == NULL) {
 850                 audio_svc_error("invalid count condition");
 851                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 852         }
 853
 854         return _audio_svc_count_playlist_records(db_handle, filter_string, filter_string2,
 855                                                  count);
 856 }
 857
 858 int audio_svc_get_playlist(MediaSvcHandle *handle, const char *filter_string,
 859                            const char *filter_string2, int offset, int rows,
 860                            AudioHandleType *playlists)
 861 {
 862         sqlite3 * db_handle = (sqlite3 *)handle;
 863
 864         if(db_handle == NULL) {
 865                 audio_svc_error("Handle is NULL");
 866                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 867         }
 868
 869         audio_svc_playlist_s *ret_playlists = (audio_svc_playlist_s *) playlists;
 870         if (offset < 0 || rows <= 0) {
 871                 audio_svc_error("offset(%d) or row value(%d) is wrong", offset,
 872                                 rows);
 873                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 874         }
 875
 876         if (!playlists) {
 877                 audio_svc_error
 878                     ("The memory for search records should be allocated ");
 879                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 880         }
 881
 882         return _audio_svc_get_playlist_records(db_handle, offset, rows, filter_string,
 883                                                filter_string2, ret_playlists);
 884 }
 885
 886 int audio_svc_count_playlist_item(MediaSvcHandle *handle, int playlist_id, const char *filter_string,
 887                                   const char *filter_string2, int *count)
 888 {
 889         sqlite3 * db_handle = (sqlite3 *)handle;
 890
 891         if(db_handle == NULL) {
 892                 audio_svc_error("Handle is NULL");
 893                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 894         }
 895
 896         if (playlist_id < 0) {
 897                 audio_svc_error("invalid playlist_id");
 898                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 899         }
 900
 901         if (count == NULL) {
 902                 audio_svc_error("invalid count condition");
 903                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 904         }
 905
 906         return _audio_svc_count_playlist_item_records(db_handle, playlist_id,
 907                                                       filter_string,
 908                                                       filter_string2, count);
 909 }
 910
 911 int audio_svc_get_playlist_item(MediaSvcHandle *handle, int playlist_id, const char *filter_string,
 912                                 const char *filter_string2, int offset,
 913                                 int rows, AudioHandleType *playlist_item)
 914 {
 915         sqlite3 * db_handle = (sqlite3 *)handle;
 916
 917         if(db_handle == NULL) {
 918                 audio_svc_error("Handle is NULL");
 919                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 920         }
 921
 922         audio_svc_playlist_item_s *ret_playlist_item = (audio_svc_playlist_item_s *) playlist_item;
 923
 924         if (offset < 0 || rows <= 0) {
 925                 audio_svc_error("offset(%d) or row value(%d) is wrong", offset,
 926                                 rows);
 927                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 928         }
 929
 930         if (!playlist_item) {
 931                 audio_svc_error
 932                     ("The memory for search records should be allocated ");
 933                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 934         }
 935
 936         memset(ret_playlist_item, 0, sizeof(audio_svc_playlist_item_s) * rows);
 937
 938         return _audio_svc_get_playlist_item_records(db_handle, playlist_id, filter_string,
 939                                                     filter_string2, offset,
 940                                                     rows, ret_playlist_item);
 941 }
 942
 943 int audio_svc_get_playlist_id_by_playlist_name(MediaSvcHandle *handle, const char *playlist_name,
 944                                                int *playlist_id)
 945 {
 946         sqlite3 * db_handle = (sqlite3 *)handle;
 947
 948         if(db_handle == NULL) {
 949                 audio_svc_error("Handle is NULL");
 950                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 951         }
 952
 953         if (!STRING_VALID(playlist_name)) {
 954                 audio_svc_error("invalid playlist_name");
 955                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 956         }
 957
 958         if (playlist_id == NULL) {
 959                 audio_svc_error("invalid playlist_id");
 960                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 961         }
 962
 963         return _audio_svc_get_playlist_id_by_name(db_handle, playlist_name, playlist_id);
 964 }
 965
 966 int audio_svc_get_playlist_name_by_playlist_id(MediaSvcHandle *handle, int playlist_id,
 967                                                char *playlist_name,
 968                                                size_t max_playlist_name_length)
 969 {
 970         sqlite3 * db_handle = (sqlite3 *)handle;
 971
 972         if(db_handle == NULL) {
 973                 audio_svc_error("Handle is NULL");
 974                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 975         }
 976
 977         if (playlist_id < 0) {
 978                 audio_svc_error("invalid playlist_id");
 979                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 980         }
 981
 982         return _audio_svc_get_playlist_name_by_playlist_id(db_handle, playlist_id,
 983                                                            playlist_name);
 984 }
 985
 986 int audio_svc_count_playlist_by_name(MediaSvcHandle *handle, const char *playlist_name, int *count)
 987 {
 988         sqlite3 * db_handle = (sqlite3 *)handle;
 989
 990         if(db_handle == NULL) {
 991                 audio_svc_error("Handle is NULL");
 992                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 993         }
 994
 995         if (!STRING_VALID(playlist_name)) {
 996                 audio_svc_error("invalid playlist_name");
 997                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
 998         }
 999
1000         if (count == NULL) {
1001                 audio_svc_error("invalid count condition");
1002                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1003         }
1004
1005         return _audio_svc_count_playlist_records_by_name(db_handle, playlist_name, count);
1006 }
1007
1008 int audio_svc_get_unique_playlist_name(MediaSvcHandle *handle, const char *orig_name, char *unique_name,
1009                                        size_t max_unique_name_length)
1010 {
1011         int ret = AUDIO_SVC_ERROR_NONE;
1012         int count = -1;
1013
1014         char playlist_name[AUDIO_SVC_PLAYLIST_NAME_SIZE] = { 0 };
1015         sqlite3 * db_handle = (sqlite3 *)handle;
1016
1017         if(db_handle == NULL) {
1018                 audio_svc_error("Handle is NULL");
1019                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1020         }
1021
1022         if (!STRING_VALID(orig_name)) {
1023                 audio_svc_error("orig_name is NULL");
1024                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1025         }
1026
1027         snprintf(playlist_name, sizeof(playlist_name), "%s_001", orig_name);
1028         ret = audio_svc_count_playlist_by_name(db_handle, playlist_name, &count);
1029         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
1030
1031         if (count > 0) {
1032                 int i = 1;
1033                 while (i < 1000) {
1034                         count = -1;
1035                         snprintf(unique_name, AUDIO_SVC_PLAYLIST_NAME_SIZE,
1036                                  "%s_%.3d", orig_name, i + 1);
1037                         ret = audio_svc_count_playlist_by_name(db_handle, unique_name, &count);
1038                         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
1039
1040                         if (count == 0) {
1041                                 return AUDIO_SVC_ERROR_NONE;
1042                         } else {
1043                                 i++;
1044                         }
1045                 }
1046
1047                 return AUDIO_SVC_ERROR_MAKE_PLAYLIST_NAME_FAILED;
1048
1049         } else {
1050                 snprintf(unique_name, AUDIO_SVC_PLAYLIST_NAME_SIZE, "%s_%.3d", orig_name, 1);
1051                 return AUDIO_SVC_ERROR_NONE;
1052         }
1053
1054         return AUDIO_SVC_ERROR_NONE;
1055 }
1056
1057 int audio_svc_add_item_to_playlist(MediaSvcHandle *handle, int playlist_id, const char *audio_id)
1058 {
1059         int ret = AUDIO_SVC_ERROR_NONE;
1060         sqlite3 * db_handle = (sqlite3 *)handle;
1061
1062         if(db_handle == NULL) {
1063                 audio_svc_error("Handle is NULL");
1064                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1065         }
1066
1067         if (playlist_id < 0) {
1068                 audio_svc_error("invalid playlist idx");
1069                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1070         }
1071
1072         if (!STRING_VALID(audio_id)) {
1073                 audio_svc_error("invalid audio_id");
1074                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1075         }
1076
1077         ret = _audio_svc_insert_playlist_item_record(db_handle, playlist_id, audio_id);
1078         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
1079
1080         if (playlist_id == AUDIO_SVC_FAVORITE_LIST_ID) {
1081                 ret = _audio_svc_update_favourite_in_music_record(db_handle, audio_id, 1);
1082                 audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
1083         }
1084
1085         return ret;
1086 }
1087
1088 int audio_svc_check_duplicate_insertion_in_playlist(MediaSvcHandle *handle, int playlist_id,
1089                                                     const char *audio_id, int *count)
1090 {
1091         sqlite3 * db_handle = (sqlite3 *)handle;
1092
1093         if(db_handle == NULL) {
1094                 audio_svc_error("Handle is NULL");
1095                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1096         }
1097
1098         if (playlist_id < 0) {
1099                 audio_svc_error("invalid playlist idx");
1100                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1101         }
1102
1103         if (!STRING_VALID(audio_id)) {
1104                 audio_svc_error("invalid audio_id");
1105                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1106         }
1107
1108         if (count == NULL) {
1109                 audio_svc_error("invalid count condition");
1110                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1111         }
1112
1113         return _audio_svc_check_duplication_records_in_playlist(db_handle, playlist_id, audio_id, count);
1114 }
1115
1116 int audio_svc_update_playlist_item_play_order(MediaSvcHandle *handle, int playlist_id, int uid,
1117                                               int new_play_order)
1118 {
1119         sqlite3 * db_handle = (sqlite3 *)handle;
1120
1121         if(db_handle == NULL) {
1122                 audio_svc_error("Handle is NULL");
1123                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1124         }
1125
1126         if (playlist_id < 0) {
1127                 audio_svc_error("invalid playlist id");
1128                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1129         }
1130
1131         if (new_play_order < 0) {
1132                 audio_svc_error("invalid play_order idx");
1133                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1134         }
1135         if (uid <= 0) {
1136                 audio_svc_error("invalid uid");
1137                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1138         }
1139
1140         return _audio_svc_update_item_play_order(db_handle, playlist_id, uid, new_play_order);
1141 }
1142
1143 int audio_svc_remove_item_from_playlist_by_uid(MediaSvcHandle *handle, int playlist_id, int uid)
1144 {
1145         int ret = AUDIO_SVC_ERROR_NONE;
1146         char audio_id[AUDIO_SVC_UUID_SIZE + 1] = {0, };
1147         sqlite3 * db_handle = (sqlite3 *)handle;
1148
1149         if(db_handle == NULL) {
1150                 audio_svc_error("Handle is NULL");
1151                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1152         }
1153
1154         if (playlist_id < 0) {
1155                 audio_svc_error("invalid playlist idx");
1156                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1157         }
1158
1159         if (uid <= 0) {
1160                 audio_svc_error("invalid audio_id");
1161                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1162         }
1163
1164         if (playlist_id == AUDIO_SVC_FAVORITE_LIST_ID) {
1165
1166                 ret = _audio_svc_get_audio_id_by_uid(db_handle, uid, audio_id);
1167                 audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
1168
1169                 ret = _audio_svc_update_favourite_in_music_record(db_handle, audio_id, 0);
1170                 audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
1171         }
1172
1173         ret = _audio_svc_delete_playlist_item_record_from_playlist_by_uid(db_handle, playlist_id, uid);
1174         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
1175
1176         return ret;
1177 }
1178
1179 int audio_svc_remove_item_from_playlist_by_audio_id(MediaSvcHandle *handle, int playlist_id,
1180                                                     const char *audio_id)
1181 {
1182         int ret = AUDIO_SVC_ERROR_NONE;
1183         sqlite3 * db_handle = (sqlite3 *)handle;
1184
1185         if(db_handle == NULL) {
1186                 audio_svc_error("Handle is NULL");
1187                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1188         }
1189
1190         if (playlist_id < 0) {
1191                 audio_svc_error("invalid playlist idx");
1192                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1193         }
1194
1195         if (!STRING_VALID(audio_id)) {
1196                 audio_svc_error("invalid audio_id");
1197                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1198         }
1199
1200         ret = _audio_svc_delete_playlist_item_record_from_playlist_by_audio_id(db_handle, playlist_id, audio_id);
1201         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
1202
1203         if (playlist_id == AUDIO_SVC_FAVORITE_LIST_ID) {
1204                 ret = _audio_svc_update_favourite_in_music_record(db_handle, audio_id, 0);
1205                 audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
1206         }
1207
1208         return ret;
1209 }
1210
1211 int audio_svc_set_db_valid(MediaSvcHandle *handle, audio_svc_storage_type_e storage_type, int valid)
1212 {
1213         audio_svc_debug("storage:%d", storage_type);
1214         sqlite3 * db_handle = (sqlite3 *)handle;
1215
1216         if(db_handle == NULL) {
1217                 audio_svc_error("Handle is NULL");
1218                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1219         }
1220
1221         if (storage_type != AUDIO_SVC_STORAGE_PHONE
1222             && storage_type != AUDIO_SVC_STORAGE_MMC) {
1223                 audio_svc_debug("storage type should be phone or mmc");
1224                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1225         }
1226
1227         return _audio_svc_update_valid_of_music_records(db_handle, storage_type, valid);
1228 }
1229
1230 int audio_svc_delete_invalid_items(MediaSvcHandle *handle, audio_svc_storage_type_e storage_type)
1231 {
1232         int ret = AUDIO_SVC_ERROR_NONE;
1233         sqlite3 * db_handle = (sqlite3 *)handle;
1234
1235         if(db_handle == NULL) {
1236                 audio_svc_error("Handle is NULL");
1237                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1238         }
1239
1240         if (storage_type != AUDIO_SVC_STORAGE_PHONE
1241                 && storage_type != AUDIO_SVC_STORAGE_MMC) {
1242                 audio_svc_debug("storage type should be phone or mmc");
1243                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1244         }
1245
1246         ret = _audio_svc_delete_invalid_music_records(db_handle, storage_type);
1247         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
1248
1249         ret = _audio_svc_update_folder_table(db_handle);
1250         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
1251
1252 #if 0
1253         ret = _audio_svc_check_and_update_albums_table(NULL);
1254         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
1255 #endif
1256
1257         return AUDIO_SVC_ERROR_NONE;
1258 }
1259
1260 int audio_svc_set_item_valid_start(MediaSvcHandle *handle, int data_cnt)
1261 {
1262         audio_svc_debug("Transaction data count : [%d]", data_cnt);
1263
1264         if(handle == NULL) {
1265                 audio_svc_error("Handle is NULL");
1266                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1267         }
1268
1269         if(data_cnt < 1) {
1270                 audio_svc_error("data_cnt shuld be bigger than 1. data_cnt : [%d]", data_cnt);
1271                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1272         }
1273
1274         g_audio_svc_item_valid_data_cnt  = data_cnt;
1275         g_audio_svc_item_valid_cur_data_cnt  = 0;
1276
1277         return AUDIO_SVC_ERROR_NONE;
1278 }
1279
1280 int audio_svc_set_item_valid_end(MediaSvcHandle *handle)
1281 {
1282         audio_svc_debug_func();
1283
1284         int ret = AUDIO_SVC_ERROR_NONE;
1285         sqlite3 * db_handle = (sqlite3 *)handle;
1286
1287         if(db_handle == NULL) {
1288                 audio_svc_error("Handle is NULL");
1289                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1290         }
1291
1292         if (g_audio_svc_item_valid_cur_data_cnt  > 0) {
1293
1294                 ret = _audio_svc_list_query_do(db_handle, AUDIO_SVC_QUERY_SET_ITEM_VALID);
1295
1296         }
1297
1298         g_audio_svc_item_valid_data_cnt  = 1;
1299         g_audio_svc_item_valid_cur_data_cnt  = 0;
1300
1301         return ret;
1302 }
1303
1304 int audio_svc_set_item_valid(MediaSvcHandle *handle, const char *path, int valid)
1305 {
1306         int ret = AUDIO_SVC_ERROR_NONE;
1307         sqlite3 * db_handle = (sqlite3 *)handle;
1308
1309         if(db_handle == NULL) {
1310                 audio_svc_error("Handle is NULL");
1311                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1312         }
1313
1314         audio_svc_debug("path=[%s], valid=[%d]", path, valid);
1315
1316         if (!STRING_VALID(path)) {
1317                 audio_svc_error("path is NULL");
1318                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1319         }
1320
1321 #if 0   //original code
1322         return _audio_svc_update_valid_in_music_record(path, valid);
1323
1324 #else   //stack up querys and commit it at once when query counts are same as g_audio_svc_item_valid_data_cnt
1325
1326         audio_svc_debug("g_audio_svc_item_valid_data_cnt =[%d], g_audio_svc_item_valid_cur_data_cnt =[%d]",
1327                         g_audio_svc_item_valid_data_cnt , g_audio_svc_item_valid_cur_data_cnt );
1328
1329         if (g_audio_svc_item_valid_data_cnt  == 1) {
1330
1331                 return _audio_svc_update_valid_in_music_record(db_handle, path, valid);
1332
1333         } else if (g_audio_svc_item_valid_cur_data_cnt  < (g_audio_svc_item_valid_data_cnt  - 1)) {
1334
1335                 ret = _audio_svc_update_valid_in_music_record_query_add(db_handle, path, valid);
1336
1337                 g_audio_svc_item_valid_cur_data_cnt ++;
1338
1339         } else if (g_audio_svc_item_valid_cur_data_cnt  == (g_audio_svc_item_valid_data_cnt  - 1)) {
1340
1341                 ret = _audio_svc_update_valid_in_music_record_query_add(db_handle, path, valid);
1342
1343                 ret = _audio_svc_list_query_do(db_handle, AUDIO_SVC_QUERY_SET_ITEM_VALID);
1344                 audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
1345
1346                 g_audio_svc_item_valid_cur_data_cnt  = 0;
1347
1348         } else {
1349
1350                 audio_svc_debug("Error in audio_svc_set_item_valid");
1351                 return AUDIO_SVC_ERROR_INTERNAL;
1352         }
1353
1354         return AUDIO_SVC_ERROR_NONE;
1355 #endif
1356 }
1357
1358 int audio_svc_get_path_by_audio_id(MediaSvcHandle *handle, const char *audio_id, char *path,
1359                                    size_t max_path_length)
1360 {
1361         int ret = AUDIO_SVC_ERROR_NONE;
1362         sqlite3 * db_handle = (sqlite3 *)handle;
1363
1364         if(db_handle == NULL) {
1365                 audio_svc_error("Handle is NULL");
1366                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1367         }
1368
1369         if (!STRING_VALID(audio_id)) {
1370                 audio_svc_error("invalid audio_id");
1371                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1372         }
1373
1374         if (!path) {
1375                 audio_svc_error("path must be allocated...");
1376                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1377         }
1378
1379         ret = _audio_svc_get_path(db_handle, audio_id, path);
1380         audio_svc_retv_if(ret != AUDIO_SVC_ERROR_NONE, ret);
1381
1382         return AUDIO_SVC_ERROR_NONE;
1383 }
1384
1385 int audio_svc_group_item_new(AudioHandleType **record, int count)
1386 {
1387         if (count < 1) {
1388                 audio_svc_error("Invalid arguments");
1389                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1390         }
1391
1392         audio_svc_debug("count is [%d]", count);
1393         audio_svc_group_item_s *grp_item =
1394             (audio_svc_group_item_s *) malloc(count *
1395                                               sizeof(audio_svc_group_item_s));
1396         if (grp_item == NULL) {
1397                 return AUDIO_SVC_ERROR_OUT_OF_MEMORY;
1398         }
1399         memset(grp_item, 0, count * sizeof(audio_svc_group_item_s));
1400
1401         *record = (AudioHandleType *) grp_item;
1402
1403         return AUDIO_SVC_ERROR_NONE;
1404 }
1405
1406 int audio_svc_group_item_free(AudioHandleType *record)
1407 {
1408         audio_svc_group_item_s *item = (audio_svc_group_item_s *) record;
1409
1410         if (!item) {
1411                 audio_svc_error("Invalid arguments");
1412                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1413         }
1414         audio_svc_debug_func();
1415         SAFE_FREE(item);
1416
1417         return AUDIO_SVC_ERROR_NONE;
1418 }
1419
1420 int audio_svc_group_item_get_val(AudioHandleType *record, int index,
1421                                  audio_svc_group_item_type_e first_field_name,
1422                                  ...)
1423 {
1424         audio_svc_group_item_s *item = (audio_svc_group_item_s *) record;
1425         va_list var_args;
1426         int ret = AUDIO_SVC_ERROR_NONE;
1427         int field_name = -1;
1428
1429         if (!record) {
1430                 audio_svc_error("Invalid arguments");
1431                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1432         }
1433
1434         if (index < 0) {
1435                 audio_svc_error("Invalid arguments");
1436                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1437         }
1438
1439         if (first_field_name == -1) {
1440                 audio_svc_error("Invalid arguments");
1441                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1442         }
1443
1444         field_name = first_field_name;
1445         va_start(var_args, first_field_name);
1446
1447         while (field_name >= 0) {
1448                 audio_svc_debug("field name = %d", field_name);
1449                 switch (field_name) {
1450                 case AUDIO_SVC_GROUP_ITEM_MAIN_INFO:
1451                         {
1452                                 char **val = va_arg((var_args), char **);
1453                                 int *size = va_arg((var_args), int *);
1454                                 if (strlen(item[index].maininfo) == 0) {
1455                                         audio_svc_debug("maininfo is NULL");
1456                                         *size = 0;
1457                                 } else {
1458                                         *val = item[index].maininfo;
1459                                         *size = strlen(item[index].maininfo);
1460                                 }
1461                                 break;
1462                         }
1463                 case AUDIO_SVC_GROUP_ITEM_SUB_INFO:
1464                         {
1465                                 char **val = va_arg((var_args), char **);
1466                                 int *size = va_arg((var_args), int *);
1467                                 if (strlen(item[index].subinfo) == 0) {
1468                                         audio_svc_debug("subinfo is NULL");
1469                                         *size = 0;
1470                                 } else {
1471                                         *val = item[index].subinfo;
1472                                         *size = strlen(item[index].subinfo);
1473                                 }
1474
1475                                 break;
1476                         }
1477                 case AUDIO_SVC_GROUP_ITEM_RATING:
1478                         {
1479                                 int *val = va_arg((var_args), int *);
1480                                 *val = item[index].album_rating;
1481                                 break;
1482                         }
1483                 case AUDIO_SVC_GROUP_ITEM_THUMBNAIL_PATH:
1484                         {
1485                                 char **val = va_arg((var_args), char **);
1486                                 int *size = va_arg((var_args), int *);
1487                                 if (strlen(item[index].thumbnail_path) == 0) {
1488                                         audio_svc_debug("thumb path is NULL");
1489                                         *size = 0;
1490                                 } else {
1491                                         *val = item[index].thumbnail_path;
1492                                         *size =
1493                                             strlen(item[index].thumbnail_path);
1494                                 }
1495
1496                                 break;
1497                         }
1498                 default:
1499                         {
1500                                 audio_svc_error("Invalid arguments");
1501                                 ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
1502                                 break;
1503                         }
1504                 }
1505                 if (ret != AUDIO_SVC_ERROR_NONE) {
1506                         audio_svc_error("error occured");
1507                         va_end(var_args);
1508                         return ret;
1509                 }
1510                 /* next field */
1511                 field_name = va_arg(var_args, int);
1512         }
1513
1514         va_end(var_args);
1515         return ret;
1516 }
1517
1518 int audio_svc_group_item_get(AudioHandleType *record, int index, AudioHandleType **item)
1519 {
1520         audio_svc_group_item_s *item_arr = (audio_svc_group_item_s *) record;
1521
1522         if (!item_arr) {
1523                 audio_svc_error("Invalid arguments");
1524                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1525         }
1526
1527         *item = (AudioHandleType *) &(item_arr[index]);
1528
1529         return AUDIO_SVC_ERROR_NONE;
1530 }
1531
1532 int audio_svc_list_item_new(AudioHandleType **record, int count)
1533 {
1534         if (count < 1) {
1535                 audio_svc_error("Invalid arguments");
1536                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1537         }
1538
1539         audio_svc_debug("count is [%d]", count);
1540         audio_svc_list_item_s *list_item =
1541             (audio_svc_list_item_s *) malloc(count *
1542                                              sizeof(audio_svc_list_item_s));
1543         if (list_item == NULL) {
1544                 return AUDIO_SVC_ERROR_OUT_OF_MEMORY;
1545         }
1546         memset(list_item, 0, count * sizeof(audio_svc_list_item_s));
1547
1548         *record = (AudioHandleType *) list_item;
1549
1550         return AUDIO_SVC_ERROR_NONE;
1551 }
1552
1553 int audio_svc_list_item_free(AudioHandleType *record)
1554 {
1555         audio_svc_list_item_s *item = (audio_svc_list_item_s *) record;
1556
1557         if (!item) {
1558                 audio_svc_error("Invalid arguments");
1559                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1560         }
1561         audio_svc_debug_func();
1562         SAFE_FREE(item);
1563
1564         return AUDIO_SVC_ERROR_NONE;
1565 }
1566
1567 int audio_svc_list_item_get_val(AudioHandleType *record, int index,
1568                                 audio_svc_list_item_type_e first_field_name,
1569                                 ...)
1570 {
1571         audio_svc_list_item_s *item = (audio_svc_list_item_s *) record;
1572         va_list var_args;
1573         int ret = AUDIO_SVC_ERROR_NONE;
1574         int field_name = -1;
1575
1576         if (!record) {
1577                 audio_svc_error("Invalid arguments");
1578                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1579         }
1580
1581         if (index < 0) {
1582                 audio_svc_error("Invalid arguments");
1583                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1584         }
1585
1586         if (first_field_name == -1) {
1587                 audio_svc_error("Invalid arguments");
1588                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1589         }
1590
1591         field_name = first_field_name;
1592         va_start(var_args, first_field_name);
1593
1594         while (field_name >= 0) {
1595                 switch (field_name) {
1596                 case AUDIO_SVC_LIST_ITEM_AUDIO_ID:
1597                         {
1598                                 char **val = va_arg((var_args), char **);
1599                                 int *size = va_arg((var_args), int *);
1600                                 if (strlen(item[index].audio_uuid) == 0) {
1601                                         audio_svc_error("audio_id is NULL");
1602                                         *size = 0;
1603                                         ret = AUDIO_SVC_ERROR_DB_NO_RECORD;
1604                                 } else {
1605                                         *val = item[index].audio_uuid;
1606                                         *size = strlen(item[index].audio_uuid);
1607                                 }
1608                                 break;
1609                         }
1610                 case AUDIO_SVC_LIST_ITEM_PATHNAME:
1611                         {
1612                                 char **val = va_arg((var_args), char **);
1613                                 int *size = va_arg((var_args), int *);
1614                                 if (strlen(item[index].pathname) == 0) {
1615                                         audio_svc_debug("path is NULL");
1616                                         *size = 0;
1617                                         ret = AUDIO_SVC_ERROR_DB_NO_RECORD;
1618                                 } else {
1619                                         *val = item[index].pathname;
1620                                         *size = strlen(item[index].pathname);
1621                                 }
1622
1623                                 break;
1624                         }
1625                 case AUDIO_SVC_LIST_ITEM_DURATION:
1626                         {
1627                                 int *val = va_arg((var_args), int *);
1628                                 *val = item[index].duration;
1629                                 break;
1630                         }
1631                 case AUDIO_SVC_LIST_ITEM_RATING:
1632                         {
1633                                 int *val = va_arg((var_args), int *);
1634                                 *val = item[index].rating;
1635                                 break;
1636                         }
1637                 case AUDIO_SVC_LIST_ITEM_THUMBNAIL_PATH:
1638                         {
1639                                 char **val = va_arg((var_args), char **);
1640                                 int *size = va_arg((var_args), int *);
1641                                 if (strlen(item[index].thumbnail_path) == 0) {
1642                                         audio_svc_debug("thumb path is NULL");
1643                                         *size = 0;
1644                                 } else {
1645                                         *val = item[index].thumbnail_path;
1646                                         *size =
1647                                             strlen(item[index].thumbnail_path);
1648                                 }
1649
1650                                 break;
1651                         }
1652                 case AUDIO_SVC_LIST_ITEM_TITLE:
1653                         {
1654                                 char **val = va_arg((var_args), char **);
1655                                 int *size = va_arg((var_args), int *);
1656                                 if (strlen(item[index].title) == 0) {
1657                                         audio_svc_debug("title is NULL");
1658                                         *size = 0;
1659                                 } else {
1660                                         *val = item[index].title;
1661                                         *size = strlen(item[index].title);
1662                                 }
1663                                 break;
1664                         }
1665                 case AUDIO_SVC_LIST_ITEM_ARTIST:
1666                         {
1667                                 char **val = va_arg((var_args), char **);
1668                                 int *size = va_arg((var_args), int *);
1669                                 if (strlen(item[index].artist) == 0) {
1670                                         audio_svc_debug("artist is NULL");
1671                                         *size = 0;
1672                                 } else {
1673                                         *val = item[index].artist;
1674                                         *size = strlen(item[index].artist);
1675                                 }
1676
1677                                 break;
1678                         }
1679                 case AUDIO_SVC_LIST_ITEM_ALBUM:
1680                         {
1681                                 char **val = va_arg((var_args), char **);
1682                                 int *size = va_arg((var_args), int *);
1683                                 if (strlen(item[index].album) == 0) {
1684                                         audio_svc_debug("album is NULL");
1685                                         *size = 0;
1686                                 } else {
1687                                         *val = item[index].album;
1688                                         *size = strlen(item[index].album);
1689                                 }
1690
1691                                 break;
1692                         }
1693                 default:
1694                         {
1695                                 audio_svc_error("Invalid arguments");
1696                                 ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
1697                                 break;
1698                         }
1699                 }
1700                 if (ret != AUDIO_SVC_ERROR_NONE) {
1701                         audio_svc_error("error occured");
1702                         va_end(var_args);
1703                         return ret;
1704                 }
1705                 /* next field */
1706                 field_name = va_arg(var_args, int);
1707         }
1708
1709         va_end(var_args);
1710         return ret;
1711 }
1712
1713 int audio_svc_list_item_get(AudioHandleType *record, int index, AudioHandleType **item)
1714 {
1715         audio_svc_list_item_s *item_arr = (audio_svc_list_item_s *) record;
1716
1717         if (!item_arr) {
1718                 audio_svc_error("Invalid arguments");
1719                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1720         }
1721
1722         *item = (AudioHandleType *) &(item_arr[index]);
1723
1724         return AUDIO_SVC_ERROR_NONE;
1725 }
1726
1727 int audio_svc_playlist_new(AudioHandleType **record, int count)
1728 {
1729         if (count < 1) {
1730                 audio_svc_error("Invalid arguments");
1731                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1732         }
1733         audio_svc_debug("");
1734
1735         audio_svc_playlist_s *playlist =
1736             (audio_svc_playlist_s *) malloc(count *
1737                                             sizeof(audio_svc_playlist_s));
1738         if (playlist == NULL) {
1739                 return AUDIO_SVC_ERROR_OUT_OF_MEMORY;
1740         }
1741         memset(playlist, 0, count * sizeof(audio_svc_playlist_s));
1742
1743         *record = (AudioHandleType *) playlist;
1744
1745         return AUDIO_SVC_ERROR_NONE;
1746 }
1747
1748 int audio_svc_playlist_free(AudioHandleType *record)
1749 {
1750         audio_svc_playlist_s *item = (audio_svc_playlist_s *) record;
1751
1752         if (!item) {
1753                 audio_svc_error("Invalid arguments");
1754                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1755         }
1756
1757         SAFE_FREE(item);
1758
1759         return AUDIO_SVC_ERROR_NONE;
1760
1761 }
1762
1763 int audio_svc_playlist_get_val(AudioHandleType *playlists, int index,
1764                                audio_svc_playlist_e first_field_name, ...)
1765 {
1766         int ret = AUDIO_SVC_ERROR_NONE;
1767         va_list var_args;
1768         int field_name;
1769         audio_svc_playlist_s *item = (audio_svc_playlist_s *) playlists;
1770
1771         if (!playlists) {
1772                 audio_svc_error("Invalid arguments");
1773                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1774         }
1775
1776         if (index < 0) {
1777                 audio_svc_error("Invalid arguments");
1778                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1779         }
1780
1781         if (first_field_name == -1) {
1782                 audio_svc_error("Invalid arguments");
1783                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1784         }
1785
1786         field_name = first_field_name;
1787         va_start(var_args, first_field_name);
1788
1789         while (field_name >= 0) {
1790                 audio_svc_debug("field name = %d", field_name);
1791                 switch (field_name) {
1792                 case AUDIO_SVC_PLAYLIST_ID:
1793                         {
1794                                 int *val = va_arg((var_args), int *);
1795                                 *val = item[index].playlist_id;
1796                                 break;
1797                         }
1798                 case AUDIO_SVC_PLAYLIST_NAME:
1799                         {
1800                                 char **val = va_arg((var_args), char **);
1801                                 int *size = va_arg((var_args), int *);
1802                                 if (strlen(item[index].name) == 0) {
1803                                         audio_svc_error("name is NULL");
1804                                         *size = 0;
1805                                 } else {
1806                                         *val = item[index].name;
1807                                         /* *size = AUDIO_SVC_PLAYLIST_NAME_SIZE; */
1808                                         *size = strlen(item[index].name);
1809                                 }
1810                                 break;
1811                         }
1812                 case AUDIO_SVC_PLAYLIST_THUMBNAIL_PATH:
1813                         {
1814                                 char **val = va_arg((var_args), char **);
1815                                 int *size = va_arg((var_args), int *);
1816                                 if (strlen(item[index].thumbnail_path) == 0) {
1817                                         audio_svc_error
1818                                             ("thumbnail_path is NULL");
1819                                         *size = 0;
1820                                 } else {
1821                                         *val = item[index].thumbnail_path;
1822                                         *size =
1823                                             strlen(item[index].thumbnail_path);
1824                                 }
1825                                 break;
1826                         }
1827                 default:
1828                         {
1829                                 audio_svc_error("Invalid arguments");
1830                                 ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
1831                                 break;
1832                         }
1833                 }
1834                 if (ret != AUDIO_SVC_ERROR_NONE) {
1835                         audio_svc_error("error occured");
1836                         va_end(var_args);
1837                         return ret;
1838                 }
1839                 /* next field */
1840                 field_name = va_arg(var_args, int);
1841         }
1842
1843         va_end(var_args);
1844         return AUDIO_SVC_ERROR_NONE;
1845 }
1846
1847 int audio_svc_playlist_set_val(AudioHandleType *playlists, int index,
1848                                audio_svc_playlist_e first_field_name, ...)
1849 {
1850         int ret = AUDIO_SVC_ERROR_NONE;
1851         va_list var_args;
1852         int field_name;
1853         audio_svc_playlist_s *item = (audio_svc_playlist_s *) playlists;
1854
1855         if (!playlists) {
1856                 audio_svc_error("Invalid arguments");
1857                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1858         }
1859
1860         if (index < 0) {
1861                 audio_svc_error("Invalid arguments");
1862                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1863         }
1864
1865         if (first_field_name == -1) {
1866                 audio_svc_error("Invalid arguments");
1867                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1868         }
1869
1870         field_name = first_field_name;
1871         va_start(var_args, first_field_name);
1872
1873         while (field_name >= 0) {
1874                 audio_svc_debug("field name = %d", field_name);
1875                 switch (field_name) {
1876                 case AUDIO_SVC_PLAYLIST_NAME:
1877                         {
1878                                 char *val = va_arg((var_args), char *);
1879                                 int size = va_arg((var_args), int);
1880                                 _strncpy_safe(item[index].name, val,
1881                                               min(size + 1,
1882                                                   sizeof(item[index].name)));
1883                                 break;
1884                         }
1885                 default:
1886                         {
1887                                 audio_svc_error("Invalid arguments");
1888                                 ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
1889                                 break;
1890                         }
1891                 }
1892                 if (ret != AUDIO_SVC_ERROR_NONE) {
1893                         audio_svc_error("error occured");
1894                         va_end(var_args);
1895                         return ret;
1896                 }
1897                 /* next field */
1898                 field_name = va_arg(var_args, int);
1899         }
1900
1901         va_end(var_args);
1902         return AUDIO_SVC_ERROR_NONE;
1903 }
1904
1905 int audio_svc_playlist_get_item(AudioHandleType *record, int index, AudioHandleType **plst)
1906 {
1907         if (!record) {
1908                 audio_svc_error("Invalid arguments");
1909                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1910         }
1911
1912         audio_svc_playlist_s *plst_arr = (audio_svc_playlist_s *) record;
1913         *plst = (AudioHandleType *) &(plst_arr[index]);
1914
1915         return AUDIO_SVC_ERROR_NONE;
1916 }
1917
1918 int audio_svc_playlist_item_new(AudioHandleType **record, int count)
1919 {
1920         if (count < 1) {
1921                 audio_svc_error("Invalid arguments");
1922                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1923         }
1924         audio_svc_debug("");
1925
1926         audio_svc_playlist_item_s *plst_item =
1927             (audio_svc_playlist_item_s *) malloc(count *
1928                                                  sizeof
1929                                                  (audio_svc_playlist_item_s));
1930         if (plst_item == NULL) {
1931                 return AUDIO_SVC_ERROR_OUT_OF_MEMORY;
1932         }
1933         memset(plst_item, 0, count * sizeof(audio_svc_playlist_item_s));
1934
1935         *record = (AudioHandleType *) plst_item;
1936
1937         return AUDIO_SVC_ERROR_NONE;
1938 }
1939
1940 int audio_svc_playlist_item_free(AudioHandleType *record)
1941 {
1942         audio_svc_playlist_item_s *item = (audio_svc_playlist_item_s *) record;
1943
1944         if (!item) {
1945                 audio_svc_error("Invalid arguments");
1946                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1947         }
1948         audio_svc_debug_func();
1949         SAFE_FREE(item);
1950
1951         return AUDIO_SVC_ERROR_NONE;
1952 }
1953
1954 int audio_svc_playlist_item_get_val(AudioHandleType *record, int index,
1955                                     audio_svc_playlist_item_type_e
1956                                     first_field_name, ...)
1957 {
1958         audio_svc_playlist_item_s *item = (audio_svc_playlist_item_s *) record;
1959         va_list var_args;
1960         int ret = AUDIO_SVC_ERROR_NONE;
1961         int field_name = -1;
1962
1963         if (!record) {
1964                 audio_svc_error("Invalid arguments");
1965                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1966         }
1967
1968         if (index < 0) {
1969                 audio_svc_error("Invalid arguments");
1970                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1971         }
1972
1973         if (first_field_name == -1) {
1974                 audio_svc_error("Invalid arguments");
1975                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
1976         }
1977
1978         field_name = first_field_name;
1979         va_start(var_args, first_field_name);
1980
1981         while (field_name >= 0) {
1982                 audio_svc_debug("field name = %d", field_name);
1983                 switch (field_name) {
1984                 case AUDIO_SVC_PLAYLIST_ITEM_UID:
1985                         {
1986                                 int *val = va_arg((var_args), int *);
1987                                 *val = item[index].u_id;
1988                                 break;
1989                         }
1990                 case AUDIO_SVC_PLAYLIST_ITEM_AUDIO_ID:
1991                         {
1992                                 char **val = va_arg((var_args), char **);
1993                                 int *size = va_arg((var_args), int *);
1994                                 if (strlen(item[index].audio_uuid) == 0) {
1995                                         audio_svc_error("audio_id is NULL");
1996                                         *size = 0;
1997                                         ret = AUDIO_SVC_ERROR_DB_NO_RECORD;
1998                                 } else {
1999                                         *val = item[index].audio_uuid;
2000                                         *size = strlen(item[index].audio_uuid);
2001                                 }
2002                                 break;
2003                         }
2004                 case AUDIO_SVC_PLAYLIST_ITEM_PATHNAME:
2005                         {
2006                                 char **val = va_arg((var_args), char **);
2007                                 int *size = va_arg((var_args), int *);
2008                                 if (strlen(item[index].pathname) == 0) {
2009                                         audio_svc_debug("path is NULL");
2010                                         *size = 0;
2011                                         ret = AUDIO_SVC_ERROR_DB_NO_RECORD;
2012                                 } else {
2013                                         *val = item[index].pathname;
2014                                         *size = strlen(item[index].pathname);
2015                                 }
2016
2017                                 break;
2018                         }
2019                 case AUDIO_SVC_PLAYLIST_ITEM_DURATION:
2020                         {
2021                                 int *val = va_arg((var_args), int *);
2022                                 *val = item[index].duration;
2023                                 break;
2024                         }
2025                 case AUDIO_SVC_PLAYLIST_ITEM_RATING:
2026                         {
2027                                 int *val = va_arg((var_args), int *);
2028                                 *val = item[index].rating;
2029                                 break;
2030                         }
2031                 case AUDIO_SVC_PLAYLIST_ITEM_THUMBNAIL_PATH:
2032                         {
2033                                 char **val = va_arg((var_args), char **);
2034                                 int *size = va_arg((var_args), int *);
2035                                 if (strlen(item[index].thumbnail_path) == 0) {
2036                                         audio_svc_debug("thumb path is NULL");
2037                                         *size = 0;
2038                                 } else {
2039                                         *val = item[index].thumbnail_path;
2040                                         *size =
2041                                             strlen(item[index].thumbnail_path);
2042                                 }
2043
2044                                 break;
2045                         }
2046                 case AUDIO_SVC_PLAYLIST_ITEM_TITLE:
2047                         {
2048                                 char **val = va_arg((var_args), char **);
2049                                 int *size = va_arg((var_args), int *);
2050                                 if (strlen(item[index].title) == 0) {
2051                                         audio_svc_debug("title is NULL");
2052                                         *size = 0;
2053                                 } else {
2054                                         *val = item[index].title;
2055                                         *size = strlen(item[index].title);
2056                                 }
2057                                 break;
2058                         }
2059
2060                 case AUDIO_SVC_PLAYLIST_ITEM_ARTIST:
2061                         {
2062                                 char **val = va_arg((var_args), char **);
2063                                 int *size = va_arg((var_args), int *);
2064                                 if (strlen(item[index].artist) == 0) {
2065                                         audio_svc_debug("artist is NULL");
2066                                         *size = 0;
2067                                 } else {
2068                                         *val = item[index].artist;
2069                                         *size = strlen(item[index].artist);
2070                                 }
2071
2072                                 break;
2073                         }
2074                 case AUDIO_SVC_PLAYLIST_ITEM_PLAY_ORDER:
2075                         {
2076                                 int *val = va_arg((var_args), int *);
2077                                 *val = item[index].play_order;
2078                                 break;
2079                         }
2080                 default:
2081                         {
2082                                 audio_svc_error("Invalid arguments");
2083                                 ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2084                                 break;
2085                         }
2086                 }
2087                 if (ret != AUDIO_SVC_ERROR_NONE) {
2088                         audio_svc_error("error occured");
2089                         va_end(var_args);
2090                         return ret;
2091                 }
2092                 /* next field */
2093                 field_name = va_arg(var_args, int);
2094         }
2095
2096         va_end(var_args);
2097         return ret;
2098 }
2099
2100 int audio_svc_playlist_item_get(AudioHandleType *record, int index, AudioHandleType **item)
2101 {
2102         audio_svc_playlist_item_s *item_arr = (audio_svc_playlist_item_s *) record;
2103
2104         if (!item_arr) {
2105                 audio_svc_error("Invalid arguments");
2106                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2107         }
2108
2109         *item = (AudioHandleType *) &(item_arr[index]);
2110
2111         return AUDIO_SVC_ERROR_NONE;
2112 }
2113
2114 int audio_svc_item_new(AudioHandleType **record)
2115 {
2116         int count = 1;
2117
2118         audio_svc_debug("count is [%d]", count);
2119         audio_svc_audio_item_s *item = (audio_svc_audio_item_s *) malloc(count * sizeof(audio_svc_audio_item_s));
2120         if (item == NULL) {
2121                 return AUDIO_SVC_ERROR_OUT_OF_MEMORY;
2122         }
2123         memset(item, 0, count * sizeof(audio_svc_audio_item_s));
2124
2125         *record = (AudioHandleType *) item;
2126
2127         return AUDIO_SVC_ERROR_NONE;
2128 }
2129
2130 int audio_svc_item_free(AudioHandleType *record)
2131 {
2132         audio_svc_audio_item_s *item = (audio_svc_audio_item_s *) record;
2133
2134         if (!item) {
2135                 audio_svc_error("Invalid arguments");
2136                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2137         }
2138         audio_svc_debug_func();
2139         SAFE_FREE(item);
2140
2141         return AUDIO_SVC_ERROR_NONE;
2142 }
2143
2144 int audio_svc_item_get_val(AudioHandleType *record,
2145                            audio_svc_track_data_type_e first_field_name, ...)
2146 {
2147         int ret = AUDIO_SVC_ERROR_NONE;
2148         va_list var_args;
2149         int field_name;
2150         audio_svc_audio_item_s *item = (audio_svc_audio_item_s *) record;
2151
2152         audio_svc_debug_func();
2153         if (!item) {
2154                 audio_svc_error("Invalid arguments");
2155                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2156         }
2157
2158         if (first_field_name == -1) {
2159                 audio_svc_error("Invalid arguments");
2160                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2161         }
2162
2163         field_name = first_field_name;
2164         va_start(var_args, first_field_name);
2165
2166         while (field_name >= 0) {
2167                 audio_svc_debug("field name = %d", field_name);
2168                 switch (field_name) {
2169                 case AUDIO_SVC_TRACK_DATA_STORAGE:
2170                         {
2171                                 int *val = va_arg((var_args), int *);
2172                                 *val = item->storage_type;
2173                                 break;
2174                         }
2175                 case AUDIO_SVC_TRACK_DATA_AUDIO_ID:
2176                         {
2177                                 char **val = va_arg((var_args), char **);
2178                                 int *size = va_arg((var_args), int *);
2179                                 if (strlen(item->audio_uuid) == 0) {
2180                                         audio_svc_error("audio_id is NULL");
2181                                         *size = 0;
2182                                         ret = AUDIO_SVC_ERROR_DB_NO_RECORD;
2183                                 } else {
2184                                         *size = strlen(item->audio_uuid);
2185                                         *val = item->audio_uuid;
2186                                 }
2187                                 break;
2188                         }
2189                 case AUDIO_SVC_TRACK_DATA_PLAYED_COUNT:
2190                         {
2191                                 int *val = va_arg((var_args), int *);
2192                                 *val = item->played_count;
2193                                 break;
2194                         }
2195                 case AUDIO_SVC_TRACK_DATA_PLAYED_TIME:
2196                         {
2197                                 int *val = va_arg((var_args), int *);
2198                                 *val = item->time_played;
2199                                 break;
2200                         }
2201                 case AUDIO_SVC_TRACK_DATA_ADDED_TIME:
2202                         {
2203                                 int *val = va_arg((var_args), int *);
2204                                 *val = item->time_added;
2205                                 break;
2206                         }
2207                 case AUDIO_SVC_TRACK_DATA_RATING:
2208                         {
2209                                 int *val = va_arg((var_args), int *);
2210                                 *val = item->rating;
2211                                 break;
2212                         }
2213                 case AUDIO_SVC_TRACK_DATA_CATEGORY:
2214                         {
2215                                 int *val = va_arg((var_args), int *);
2216                                 *val = item->category;
2217                                 break;
2218                         }
2219                 case AUDIO_SVC_TRACK_DATA_PATHNAME:
2220                         {
2221                                 char **val = va_arg((var_args), char **);
2222                                 int *size = va_arg((var_args), int *);
2223                                 if (strlen(item->pathname) == 0) {
2224                                         audio_svc_error("pah is NULL");
2225                                         *size = 0;
2226                                         ret = AUDIO_SVC_ERROR_DB_NO_RECORD;
2227                                 } else {
2228                                         *size = strlen(item->pathname);
2229                                         *val = item->pathname;
2230                                 }
2231                                 break;
2232                         }
2233                 case AUDIO_SVC_TRACK_DATA_THUMBNAIL_PATH:
2234                         {
2235                                 char **val = va_arg((var_args), char **);
2236                                 int *size = va_arg((var_args), int *);
2237                                 if (strlen(item->thumbname) == 0) {
2238                                         audio_svc_debug("thumbname is NULL");
2239                                         *size = 0;
2240                                 } else {
2241                                         *size = strlen(item->thumbname);
2242                                         *val = item->thumbname;
2243                                 }
2244                                 break;
2245                         }
2246                 case AUDIO_SVC_TRACK_DATA_TITLE:
2247                         {
2248                                 char **val = va_arg((var_args), char **);
2249                                 int *size = va_arg((var_args), int *);
2250                                 if (strlen(item->audio.title) == 0) {
2251                                         audio_svc_debug("title is NULL");
2252                                         *size = 0;
2253                                 } else {
2254                                         *val = item->audio.title;
2255                                         *size = strlen(item->audio.title);
2256                                         audio_svc_debug("title = [%s][%d]",
2257                                                         *val, *size);
2258                                 }
2259                                 break;
2260                         }
2261                 case AUDIO_SVC_TRACK_DATA_ARTIST:
2262                         {
2263                                 char **val = va_arg((var_args), char **);
2264                                 int *size = va_arg((var_args), int *);
2265                                 if (strlen(item->audio.artist) == 0) {
2266                                         audio_svc_debug("artist is NULL");
2267                                         *size = 0;
2268                                 } else {
2269                                         *val = item->audio.artist;
2270                                         *size = strlen(item->audio.artist);
2271                                 }
2272                                 break;
2273                         }
2274                 case AUDIO_SVC_TRACK_DATA_ALBUM:
2275                         {
2276                                 char **val = va_arg((var_args), char **);
2277                                 int *size = va_arg((var_args), int *);
2278                                 if (strlen(item->audio.album) == 0) {
2279                                         audio_svc_debug("album is NULL");
2280                                         *size = 0;
2281                                 } else {
2282                                         *val = item->audio.album;
2283                                         *size = strlen(item->audio.album);
2284                                         audio_svc_debug("album = %s", *val);
2285                                 }
2286                                 break;
2287                         }
2288                 case AUDIO_SVC_TRACK_DATA_GENRE:
2289                         {
2290                                 char **val = va_arg((var_args), char **);
2291                                 int *size = va_arg((var_args), int *);
2292                                 if (strlen(item->audio.genre) == 0) {
2293                                         audio_svc_debug("genre is NULL");
2294                                         *size = 0;
2295                                 } else {
2296                                         *val = item->audio.genre;
2297                                         *size = strlen(item->audio.genre);
2298                                 }
2299                                 break;
2300                         }
2301                 case AUDIO_SVC_TRACK_DATA_AUTHOR:
2302                         {
2303                                 char **val = va_arg((var_args), char **);
2304                                 int *size = va_arg((var_args), int *);
2305                                 if (strlen(item->audio.author) == 0) {
2306                                         audio_svc_debug("author is NULL");
2307                                         *size = 0;
2308                                 } else {
2309                                         *val = item->audio.author;
2310                                         *size = strlen(item->audio.author);
2311                                 }
2312                                 break;
2313                         }
2314                 case AUDIO_SVC_TRACK_DATA_COPYRIGHT:
2315                         {
2316                                 char **val = va_arg((var_args), char **);
2317                                 int *size = va_arg((var_args), int *);
2318                                 if (strlen(item->audio.copyright) == 0) {
2319                                         audio_svc_debug("copyright is NULL");
2320                                         *size = 0;
2321                                 } else {
2322                                         *val = item->audio.copyright;
2323                                         *size = strlen(item->audio.copyright);
2324                                 }
2325                                 break;
2326                         }
2327                 case AUDIO_SVC_TRACK_DATA_DESCRIPTION:
2328                         {
2329                                 char **val = va_arg((var_args), char **);
2330                                 int *size = va_arg((var_args), int *);
2331                                 if (strlen(item->audio.description) == 0) {
2332                                         audio_svc_debug("description is NULL");
2333                                         *size = 0;
2334                                 } else {
2335                                         *val = item->audio.description;
2336                                         *size = strlen(item->audio.description);
2337                                 }
2338                                 break;
2339                         }
2340                 case AUDIO_SVC_TRACK_DATA_FORMAT:
2341                         {
2342                                 char **val = va_arg((var_args), char **);
2343                                 int *size = va_arg((var_args), int *);
2344                                 if (strlen(item->audio.format) == 0) {
2345                                         audio_svc_debug("format is NULL");
2346                                         *size = 0;
2347                                 } else {
2348                                         *val = item->audio.format;
2349                                         *size = strlen(item->audio.format);
2350                                 }
2351                                 break;
2352                         }
2353                 case AUDIO_SVC_TRACK_DATA_DURATION:
2354                         {
2355                                 int *val = va_arg((var_args), int *);
2356                                 *val = item->audio.duration;
2357                                 break;
2358                         }
2359
2360                 case AUDIO_SVC_TRACK_DATA_BITRATE:
2361                         {
2362                                 int *val = va_arg((var_args), int *);
2363                                 *val = item->audio.bitrate;
2364                                 break;
2365                         }
2366                 case AUDIO_SVC_TRACK_DATA_YEAR:
2367                         {
2368                                 char **val = va_arg((var_args), char **);
2369                                 int *size = va_arg((var_args), int *);
2370                                 if (strlen(item->audio.year) == 0) {
2371                                         audio_svc_debug("year is NULL");
2372                                         *size = 0;
2373                                 } else {
2374                                         *val = item->audio.year;
2375                                         *size = strlen(item->audio.year);
2376                                 }
2377                                 break;
2378                         }
2379                 case AUDIO_SVC_TRACK_DATA_TRACK_NUM:
2380                         {
2381                                 int *val = va_arg((var_args), int *);
2382                                 *val = item->audio.track;
2383                                 break;
2384                         }
2385                 case AUDIO_SVC_TRACK_DATA_FAVOURATE:
2386                         {
2387                                 int *val = va_arg((var_args), int *);
2388                                 *val = item->favourate;
2389                                 break;
2390                         }
2391                 default:
2392                         {
2393                                 audio_svc_error("Invalid arguments");
2394                                 ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2395                                 break;
2396                         }
2397                 }
2398                 if (ret != AUDIO_SVC_ERROR_NONE) {
2399                         audio_svc_error("error occured");
2400                         va_end(var_args);
2401                         return ret;
2402                 }
2403                 /* next field */
2404                 field_name = va_arg(var_args, int);
2405         }
2406
2407         va_end(var_args);
2408         return AUDIO_SVC_ERROR_NONE;
2409 }
2410
2411 int audio_svc_search_item_new(AudioHandleType **record, int count)
2412 {
2413         audio_svc_debug("count is [%d]", count);
2414         audio_svc_audio_item_s *item = (audio_svc_audio_item_s *) malloc(count * sizeof(audio_svc_audio_item_s));
2415
2416         if (item == NULL) {
2417                 return AUDIO_SVC_ERROR_OUT_OF_MEMORY;
2418         }
2419
2420         memset(item, 0, count * sizeof(audio_svc_audio_item_s));
2421
2422         *record = (AudioHandleType *) item;
2423
2424         return AUDIO_SVC_ERROR_NONE;
2425 }
2426
2427 int audio_svc_search_item_get(AudioHandleType *record, int index, AudioHandleType **item)
2428 {
2429         audio_svc_audio_item_s *item_arr = (audio_svc_audio_item_s *) record;
2430
2431         if (!item_arr) {
2432                 audio_svc_error("Invalid arguments");
2433                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2434         }
2435
2436         *item = (AudioHandleType *) &(item_arr[index]);
2437         if (*item == NULL) {
2438                 audio_svc_error("Index is invalid");
2439                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2440         }
2441
2442         return AUDIO_SVC_ERROR_NONE;
2443 }
2444
2445 int audio_svc_search_item_free(AudioHandleType *record)
2446 {
2447         audio_svc_audio_item_s *item = (audio_svc_audio_item_s *) record;
2448
2449         if (!item) {
2450                 audio_svc_error("Invalid arguments");
2451                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2452         }
2453         audio_svc_debug_func();
2454         SAFE_FREE(item);
2455
2456         return AUDIO_SVC_ERROR_NONE;
2457 }
2458
2459 int audio_svc_update_item_metadata(MediaSvcHandle *handle, const char *audio_id,
2460                                    audio_svc_track_data_type_e first_field_name,
2461                                    ...)
2462 {
2463         int ret = AUDIO_SVC_ERROR_NONE;
2464         va_list var_args;
2465         int field_name = -1;
2466         sqlite3 * db_handle = (sqlite3 *)handle;
2467
2468         if(db_handle == NULL) {
2469                 audio_svc_error("Handle is NULL");
2470                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2471         }
2472
2473         if (!STRING_VALID(audio_id)) {
2474                 audio_svc_error("invalid audio_id");
2475                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2476         }
2477
2478         if (first_field_name == -1) {
2479                 audio_svc_error("Invalid arguments");
2480                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2481         }
2482
2483         field_name = first_field_name;
2484         va_start(var_args, first_field_name);
2485
2486         while (field_name >= 0) {
2487                 audio_svc_debug("field name = %d", field_name);
2488                 switch (field_name) {
2489                 case AUDIO_SVC_TRACK_DATA_PLAYED_COUNT:
2490                         {
2491                                 int val = va_arg((var_args), int);
2492                                 if (val < 0) {
2493                                         audio_svc_error("play count should be positive value");
2494                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2495                                 } else {
2496                                         ret = _audio_svc_update_playcount_in_music_record(db_handle, audio_id, val);
2497                                 }
2498                                 break;
2499                         }
2500                 case AUDIO_SVC_TRACK_DATA_PLAYED_TIME:
2501                         {
2502                                 int val = va_arg((var_args), int);
2503                                 if (val < 0) {
2504                                         audio_svc_error("play time should be positive value");
2505                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2506                                 } else {
2507                                         ret = _audio_svc_update_playtime_in_music_record(db_handle, audio_id, val);
2508                                 }
2509                                 break;
2510                         }
2511                 case AUDIO_SVC_TRACK_DATA_ADDED_TIME:
2512                         {
2513                                 int val = va_arg((var_args), int);
2514                                 if (val < 0) {
2515                                         audio_svc_error("added time should be positive value");
2516                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2517                                 } else {
2518                                         ret = _audio_svc_update_addtime_in_music_record(db_handle, audio_id, val);
2519                                 }
2520                                 break;
2521                         }
2522                 case AUDIO_SVC_TRACK_DATA_RATING:
2523                         {
2524                                 int val = va_arg((var_args), int);
2525                                 if (val < AUDIO_SVC_RATING_NONE
2526                                     || val > AUDIO_SVC_RATING_5) {
2527                                         audio_svc_error("rating value should be between 0 and 5");
2528                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2529                                 } else {
2530                                         ret = _audio_svc_update_rating_in_music_record(db_handle, audio_id, val);
2531                                 }
2532                                 break;
2533                         }
2534                 case AUDIO_SVC_TRACK_DATA_TITLE:
2535                         {
2536                                 char *val = va_arg((var_args), char *);
2537                                 int size = va_arg((var_args), int);
2538
2539                                 /* title can not be NULL by UX */
2540                                 if (val == NULL) {
2541                                         audio_svc_error("title can not be NULL");
2542                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2543                                 } else if (size >
2544                                            AUDIO_SVC_METADATA_LEN_MAX - 1) {
2545                                         audio_svc_error("text size should be shorter than AUDIO_SVC_METADATA_LEN_MAX");
2546                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2547                                 } else {
2548                                         ret = _audio_svc_update_title_in_music_record(db_handle, audio_id, val);
2549                                 }
2550                                 break;
2551                         }
2552                 case AUDIO_SVC_TRACK_DATA_ARTIST:
2553                         {
2554                                 char *val = va_arg((var_args), char *);
2555                                 int size = va_arg((var_args), int);
2556                                 if (size > AUDIO_SVC_METADATA_LEN_MAX - 1) {
2557                                         audio_svc_error("text size should be shorter than AUDIO_SVC_METADATA_LEN_MAX");
2558                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2559                                 } else {
2560                                         if (val == NULL) {
2561                                                 val = AUDIO_SVC_TAG_UNKNOWN;
2562                                         }
2563                                         ret =_audio_svc_update_artist_in_music_record(db_handle, audio_id, val);
2564                                 }
2565                                 break;
2566                         }
2567                 case AUDIO_SVC_TRACK_DATA_ALBUM:
2568                         {
2569                                 char *val = va_arg((var_args), char *);
2570                                 int size = va_arg((var_args), int);
2571                                 if (size > AUDIO_SVC_METADATA_LEN_MAX - 1) {
2572                                         audio_svc_error("text size should be shorter than AUDIO_SVC_METADATA_LEN_MAX");
2573                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2574                                 } else {
2575                                         if (val == NULL) {
2576                                                 val = AUDIO_SVC_TAG_UNKNOWN;
2577                                         }
2578                                         ret = _audio_svc_update_album_in_music_record(db_handle, audio_id, val);
2579                                 }
2580                                 break;
2581                         }
2582                 case AUDIO_SVC_TRACK_DATA_GENRE:
2583                         {
2584                                 char *val = va_arg((var_args), char *);
2585                                 int size = va_arg((var_args), int);
2586                                 if (size > AUDIO_SVC_METADATA_LEN_MAX - 1) {
2587                                         audio_svc_error("text size should be shorter than AUDIO_SVC_METADATA_LEN_MAX");
2588                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2589                                 } else {
2590                                         if (val == NULL) {
2591                                                 val = AUDIO_SVC_TAG_UNKNOWN;
2592                                         }
2593                                         ret = _audio_svc_update_genre_in_music_record(db_handle, audio_id, val);
2594                                 }
2595                                 break;
2596                         }
2597                 case AUDIO_SVC_TRACK_DATA_AUTHOR:
2598                         {
2599                                 char *val = va_arg((var_args), char *);
2600                                 int size = va_arg((var_args), int);
2601                                 if (size > AUDIO_SVC_METADATA_LEN_MAX - 1) {
2602                                         audio_svc_error("text size should be shorter than AUDIO_SVC_METADATA_LEN_MAX");
2603                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2604                                 } else {
2605                                         if (val == NULL) {
2606                                                 val = AUDIO_SVC_TAG_UNKNOWN;
2607                                         }
2608                                         ret = _audio_svc_update_author_in_music_record(db_handle, audio_id, val);
2609                                 }
2610                                 break;
2611                         }
2612                 case AUDIO_SVC_TRACK_DATA_DESCRIPTION:
2613                         {
2614                                 char *val = va_arg((var_args), char *);
2615                                 int size = va_arg((var_args), int);
2616                                 if (size > AUDIO_SVC_METADATA_LEN_MAX - 1) {
2617                                         audio_svc_error("text size should be shorter than AUDIO_SVC_METADATA_LEN_MAX");
2618                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2619                                 } else {
2620                                         ret = _audio_svc_update_description_in_music_record(db_handle, audio_id, val);
2621                                 }
2622                                 break;
2623                         }
2624                 case AUDIO_SVC_TRACK_DATA_YEAR:
2625                         {
2626                                 int val = va_arg((var_args), int);
2627                                 if (val < 0) {
2628                                         audio_svc_error("year should be positive value");
2629                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2630                                 } else {
2631                                         ret = _audio_svc_update_year_in_music_record(db_handle, audio_id, val);
2632                                 }
2633                                 break;
2634                         }
2635                 case AUDIO_SVC_TRACK_DATA_TRACK_NUM:
2636                         {
2637                                 int val = va_arg((var_args), int);
2638                                 if (val < 0) {
2639                                         audio_svc_error("track number should be positive value");
2640                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2641                                 } else {
2642                                         ret = _audio_svc_update_track_num_in_music_record(db_handle, audio_id, val);
2643                                 }
2644                                 break;
2645                         }
2646                 case AUDIO_SVC_TRACK_DATA_ALBUM_RATING:
2647                         {
2648                                 int val = va_arg((var_args), int);
2649                                 if (val < AUDIO_SVC_RATING_NONE
2650                                     || val > AUDIO_SVC_RATING_5) {
2651                                         audio_svc_error("rating value should be between 0 and 5");
2652                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2653                                 } else {
2654                                         ret = _audio_svc_update_album_rating_in_music_record(db_handle, audio_id, val);
2655                                 }
2656                                 break;
2657                         }
2658                 default:
2659                         {
2660                                 audio_svc_error("Invalid arguments");
2661                                 ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2662                                 break;
2663                         }
2664                 }
2665                 if (ret != AUDIO_SVC_ERROR_NONE) {
2666                         audio_svc_error("invalid parameter");
2667                         va_end(var_args);
2668                         return ret;
2669                 }
2670                 /* next field */
2671                 field_name = va_arg(var_args, int);
2672         }
2673
2674         va_end(var_args);
2675         return AUDIO_SVC_ERROR_NONE;
2676 }
2677
2678 int audio_svc_check_item_exist(MediaSvcHandle *handle, const char *path)
2679 {
2680         sqlite3 * db_handle = (sqlite3 *)handle;
2681
2682         if(db_handle == NULL) {
2683                 audio_svc_error("Handle is NULL");
2684                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2685         }
2686
2687         if (!STRING_VALID(path)) {
2688                 audio_svc_error("path is NULL");
2689                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2690         }
2691
2692         if (_audio_svc_count_record_with_path(db_handle, path) > 0) {
2693                 audio_svc_debug("item is exist in database");
2694                 return AUDIO_SVC_ERROR_NONE;
2695         } else {
2696                 audio_svc_debug("item is not exist in database");
2697                 return AUDIO_SVC_ERROR_DB_NO_RECORD;
2698         }
2699
2700 }
2701
2702 int audio_svc_list_by_search(MediaSvcHandle *handle, AudioHandleType *record,
2703                                                         audio_svc_search_order_e order_field,
2704                                                         int offset,
2705                                                         int count,
2706                                                         audio_svc_serch_field_e first_field_name,
2707                                                         ...)
2708 {
2709         int ret = AUDIO_SVC_ERROR_NONE;
2710         va_list var_args;
2711         int field_name = -1;
2712         int len = 0;
2713         char query_where[AUDIO_SVC_QUERY_SIZE] = { 0 };
2714         char search_str[AUDIO_SVC_METADATA_LEN_MAX] = { 0 };
2715         char *condition_str = NULL;
2716         char *escaped_search_str = NULL;
2717
2718         audio_svc_audio_item_s *item = (audio_svc_audio_item_s *)record;
2719         sqlite3 * db_handle = (sqlite3 *)handle;
2720
2721         if(db_handle == NULL) {
2722                 audio_svc_error("Handle is NULL");
2723                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2724         }
2725
2726         if (!item) {
2727                 audio_svc_error("Invalid arguments");
2728                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2729         }
2730
2731         if (offset < 0 || count <= 0) {
2732                 audio_svc_error("Invalid arguments");
2733                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2734         }
2735
2736         if (order_field < AUDIO_SVC_ORDER_BY_TITLE_DESC ||
2737                         order_field > AUDIO_SVC_ORDER_BY_ADDED_TIME_ASC) {
2738                 audio_svc_error("Invalid arguments");
2739                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2740         }
2741
2742         if (first_field_name < AUDIO_SVC_SEARCH_TITLE ||
2743                         first_field_name > AUDIO_SVC_SEARCH_AUTHOR) {
2744                 audio_svc_error("Invalid arguments");
2745                 return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2746         }
2747
2748         memset(query_where, 0x00, sizeof(query_where));
2749         snprintf(query_where, sizeof(query_where), "valid=1 and ( 0 ");
2750
2751         field_name = first_field_name;
2752         va_start(var_args, first_field_name);
2753
2754         while (field_name >= 0) {
2755                 audio_svc_debug("field name = %d", field_name);
2756                 memset(search_str, 0x00, sizeof(search_str));
2757
2758                 switch (field_name) {
2759                 case AUDIO_SVC_SEARCH_TITLE:
2760                         {
2761                                 char *val = va_arg((var_args), char *);
2762                                 int size = va_arg((var_args), int);
2763
2764                                 if (val == NULL) {
2765                                         audio_svc_error("title is NULL");
2766                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2767                                 } else {
2768                                         _strncpy_safe(search_str, val,
2769                                                       min(size + 1,
2770                                                           sizeof(search_str)));
2771                                 }
2772
2773                                 escaped_search_str = _media_svc_escape_str((char *)search_str, strlen(search_str));
2774                                 if (escaped_search_str == NULL) {
2775                                         audio_svc_error("Failed to escape");
2776                                         return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2777                                 }
2778
2779                                 condition_str = sqlite3_mprintf(" or title like '%%%q%%' ESCAPE('#') ", escaped_search_str);
2780                                 SAFE_FREE(escaped_search_str);
2781
2782                                 len =
2783                                         g_strlcat(query_where, condition_str,
2784                                                 sizeof(query_where));
2785                                 if (len >= sizeof(query_where)) {
2786                                         sqlite3_free(condition_str);
2787                                         audio_svc_error("strlcat returns failure ( %d )", len);
2788                                         return AUDIO_SVC_ERROR_INTERNAL;
2789                                 }
2790                                 sqlite3_free(condition_str);
2791
2792                                 break;
2793                         }
2794                 case AUDIO_SVC_SEARCH_ARTIST:
2795                         {
2796                                 char *val = va_arg((var_args), char *);
2797                                 int size = va_arg((var_args), int);
2798
2799                                 if (val == NULL) {
2800                                         audio_svc_error("artist is NULL");
2801                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2802                                 } else {
2803                                         _strncpy_safe(search_str, val,
2804                                                       min(size + 1,
2805                                                           sizeof(search_str)));
2806                                 }
2807
2808                                 escaped_search_str = _media_svc_escape_str((char *)search_str, strlen(search_str));
2809                                 if (escaped_search_str == NULL) {
2810                                         audio_svc_error("Failed to escape");
2811                                         return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2812                                 }
2813
2814                                 condition_str = sqlite3_mprintf(" or artist like '%%%q%%' ESCAPE('#') ", escaped_search_str);
2815                                 SAFE_FREE(escaped_search_str);
2816
2817                                 len =
2818                                         g_strlcat(query_where, condition_str,
2819                                                 sizeof(query_where));
2820                                 if (len >= sizeof(query_where)) {
2821                                         sqlite3_free(condition_str);
2822                                         audio_svc_error("strlcat returns failure ( %d )", len);
2823                                         return AUDIO_SVC_ERROR_INTERNAL;
2824                                 }
2825                                 sqlite3_free(condition_str);
2826
2827                                 break;
2828                         }
2829                 case AUDIO_SVC_SEARCH_ALBUM:
2830                         {
2831                                 char *val = va_arg((var_args), char *);
2832                                 int size = va_arg((var_args), int);
2833
2834                                 if (val == NULL) {
2835                                         audio_svc_error("album is NULL");
2836                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2837                                 } else {
2838                                         _strncpy_safe(search_str, val,
2839                                                       min(size + 1,
2840                                                           sizeof(search_str)));
2841                                 }
2842
2843                                 escaped_search_str = _media_svc_escape_str((char *)search_str, strlen(search_str));
2844                                 if (escaped_search_str == NULL) {
2845                                         audio_svc_error("Failed to escape");
2846                                         return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2847                                 }
2848
2849                                 condition_str = sqlite3_mprintf(" or album like '%%%q%%' ESCAPE('#') ", escaped_search_str);
2850                                 SAFE_FREE(escaped_search_str);
2851
2852                                 len =
2853                                         g_strlcat(query_where, condition_str,
2854                                                 sizeof(query_where));
2855                                 if (len >= sizeof(query_where)) {
2856                                         sqlite3_free(condition_str);
2857                                         audio_svc_error("strlcat returns failure ( %d )", len);
2858                                         return AUDIO_SVC_ERROR_INTERNAL;
2859                                 }
2860                                 sqlite3_free(condition_str);
2861
2862                                 break;
2863                         }
2864                 case AUDIO_SVC_SEARCH_GENRE:
2865                         {
2866                                 char *val = va_arg((var_args), char *);
2867                                 int size = va_arg((var_args), int);
2868
2869                                 if (val == NULL) {
2870                                         audio_svc_error("genre is NULL");
2871                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2872                                 } else {
2873                                         _strncpy_safe(search_str, val,
2874                                                       min(size + 1,
2875                                                           sizeof(search_str)));
2876                                 }
2877
2878                                 escaped_search_str = _media_svc_escape_str((char *)search_str, strlen(search_str));
2879                                 if (escaped_search_str == NULL) {
2880                                         audio_svc_error("Failed to escape");
2881                                         return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2882                                 }
2883
2884                                 condition_str = sqlite3_mprintf(" or genre like '%%%q%%' ESCAPE('#') ", escaped_search_str);
2885                                 SAFE_FREE(escaped_search_str);
2886
2887                                 len =
2888                                         g_strlcat(query_where, condition_str,
2889                                                 sizeof(query_where));
2890                                 if (len >= sizeof(query_where)) {
2891                                         audio_svc_error("strlcat returns failure ( %d )", len);
2892                                         return AUDIO_SVC_ERROR_INTERNAL;
2893                                 }
2894
2895                                 break;
2896                         }
2897                 case AUDIO_SVC_SEARCH_AUTHOR:
2898                         {
2899                                 char *val = va_arg((var_args), char *);
2900                                 int size = va_arg((var_args), int);
2901
2902                                 if (val == NULL) {
2903                                         audio_svc_error("author is NULL");
2904                                         ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2905                                 } else {
2906                                         _strncpy_safe(search_str, val,
2907                                                       min(size + 1,
2908                                                           sizeof(search_str)));
2909                                 }
2910
2911                                 escaped_search_str = _media_svc_escape_str((char *)search_str, strlen(search_str));
2912                                 if (escaped_search_str == NULL) {
2913                                         audio_svc_error("Failed to escape");
2914                                         return AUDIO_SVC_ERROR_INVALID_PARAMETER;
2915                                 }
2916
2917                                 condition_str = sqlite3_mprintf(" or author like '%%%q%%' ESCAPE('#') ", escaped_search_str);
2918                                 SAFE_FREE(escaped_search_str);
2919
2920                                 len =
2921                                         g_strlcat(query_where, condition_str,
2922                                                 sizeof(query_where));
2923                                 if (len >= sizeof(query_where)) {
2924                                         sqlite3_free(condition_str);
2925                                         audio_svc_error("strlcat returns failure ( %d )", len);
2926                                         return AUDIO_SVC_ERROR_INTERNAL;
2927                                 }
2928                                 sqlite3_free(condition_str);
2929
2930                                 break;
2931                         }
2932                 default:
2933                         {
2934                                 audio_svc_error("Invalid arguments");
2935                                 ret = AUDIO_SVC_ERROR_INVALID_PARAMETER;
2936                                 break;
2937                         }
2938                 }
2939
2940                 if (ret != AUDIO_SVC_ERROR_NONE) {
2941                         audio_svc_error("invalid parameter");
2942                         va_end(var_args);
2943                         return ret;
2944                 }
2945                 /* next field */
2946                 field_name = va_arg(var_args, int);
2947         }
2948
2949         va_end(var_args);
2950         len = g_strlcat(query_where, ") ", sizeof(query_where));
2951         if (len >= sizeof(query_where)) {
2952                 audio_svc_error("strlcat returns failure ( %d )", len);
2953                 return AUDIO_SVC_ERROR_INTERNAL;
2954         }
2955
2956         return _audio_svc_list_search(db_handle, item, query_where, order_field, offset, count);
2957 }
2958