src/media_audio.c

   1 /*\r
   2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved\r
   3 *\r
   4 * Licensed under the Apache License, Version 2.0 (the "License");\r
   5 * you may not use this file except in compliance with the License.\r
   6 * You may obtain a copy of the License at\r
   7 *\r
   8 * http://www.apache.org/licenses/LICENSE-2.0\r
   9 *\r
  10 * Unless required by applicable law or agreed to in writing, software\r
  11 * distributed under the License is distributed on an "AS IS" BASIS,\r
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  13 * See the License for the specific language governing permissions and\r
  14 * limitations under the License. \r
  15 */\r
  16 \r
  17 \r
  18 #include <media_content.h>\r
  19 #include <media-info-error.h>\r
  20 #include <media-svc-error.h>\r
  21 #include <media-info.h>\r
  22 #include <audio-svc.h>\r
  23 #include <audio-svc-error.h>\r
  24 #include <media_info_private.h>\r
  25 \r
  26 #include <dlog.h>\r
  27 \r
  28 #ifdef LOG_TAG\r
  29 #undef LOG_TAG\r
  30 #endif\r
  31 \r
  32 #define LOG_TAG "TIZEN_N_MEDIACONTENT"\r
  33 \r
  34 \r
  35 \r
  36 int audio_meta_destroy(audio_meta_h audio)\r
  37 {\r
  38         int ret;\r
  39         audio_meta_s* _audio = (audio_meta_s*)audio;    \r
  40         if(_audio) \r
  41         {\r
  42                 if(_audio->audio_id)\r
  43                 {\r
  44                         free(_audio->audio_id);\r
  45                 }\r
  46                 if(_audio->genre) \r
  47                 {\r
  48                         free(_audio->genre);\r
  49                 }                       \r
  50                 if(_audio->author) \r
  51                 {\r
  52                         free(_audio->author);\r
  53                 }                       \r
  54                 if(_audio->copyright) \r
  55                 {\r
  56                         free(_audio->copyright);\r
  57                 }                       \r
  58                 if(_audio->description) \r
  59                 {\r
  60                         free(_audio->description);\r
  61                 }                       \r
  62                 if(_audio->format) \r
  63                 {\r
  64                         free(_audio->format);\r
  65                 }       \r
  66 \r
  67                 free(_audio);\r
  68                 ret = MEDIA_CONTENT_ERROR_NONE;\r
  69         }\r
  70         else \r
  71         {\r
  72                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
  73                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
  74         }\r
  75         return ret;\r
  76 \r
  77 }\r
  78 \r
  79 int audio_meta_clone(audio_meta_h* dst, audio_meta_h src)\r
  80 {\r
  81         int ret;\r
  82         audio_meta_s* _src = (audio_meta_s*)src;        \r
  83 \r
  84         if(_src != NULL)\r
  85         {\r
  86         \r
  87                 audio_meta_s* _dst = (audio_meta_s*)calloc(1,sizeof(audio_meta_s));             \r
  88 \r
  89                 if(_dst == NULL)\r
  90                 {\r
  91 \r
  92                         LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
  93                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
  94                 }\r
  95                 \r
  96                 _dst->audio_id = strdup(_src->audio_id);\r
  97                 if(_dst->audio_id == NULL)\r
  98                 {\r
  99                         LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
 100                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
 101                 }\r
 102 \r
 103                 _dst->year= _src->year;\r
 104                 _dst->bitrate = _src->bitrate;\r
 105                 _dst->track_num = _src->track_num ;\r
 106                 _dst->duration = _src->duration;\r
 107                 _dst->rating = _src->rating;\r
 108                 _dst->count_played = _src->count_played;\r
 109                 _dst->time_played = _src->time_played;\r
 110                 _dst->time_added = _src->time_added;\r
 111                 _dst->size = _src->size;\r
 112                 _dst->category = _src->category;\r
 113                 \r
 114                                         \r
 115                 if((_src->genre != NULL) && (strlen(_src->genre) > 0))\r
 116                 {\r
 117                         _dst->genre = strdup(_src->genre);\r
 118                         if(_dst->genre == NULL)\r
 119                         {\r
 120                                 audio_meta_destroy((audio_meta_h)_dst);\r
 121                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
 122                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
 123                         }\r
 124                 }\r
 125 \r
 126                 if((_src->author != NULL) && (strlen(_src->author ) > 0))\r
 127                 {\r
 128                         _dst->author  = strdup(_src->author );\r
 129                         if(_dst->author == NULL)\r
 130                         {\r
 131                                 audio_meta_destroy((audio_meta_h)_dst);\r
 132                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);                     \r
 133                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
 134                         }\r
 135                 }\r
 136                 if((_src->copyright != NULL) && (strlen(_src->copyright) > 0))\r
 137                 {\r
 138                         _dst->copyright = strdup(_src->copyright);\r
 139                         if(_dst->copyright == NULL)\r
 140                         {\r
 141                                 audio_meta_destroy((audio_meta_h)_dst);\r
 142                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
 143                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
 144                         }       \r
 145                 }\r
 146                 if((_src->description != NULL) && (strlen(_src->description) > 0))\r
 147                 {\r
 148                         _dst->description = strdup(_src->description);\r
 149                         if(_dst->description == NULL)\r
 150                         {\r
 151                                 audio_meta_destroy((audio_meta_h)_dst);\r
 152                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
 153                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
 154                         }               \r
 155                 }\r
 156                 if((_src->format != NULL) && (strlen(_src->format) > 0))\r
 157                 {\r
 158                         _dst->format = strdup(_src->format);\r
 159                         if(_dst->format == NULL)\r
 160                         {\r
 161                                 audio_meta_destroy((audio_meta_h)_dst);\r
 162                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
 163                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
 164                         }               \r
 165                 }\r
 166                 *dst = (audio_meta_h)_dst;\r
 167                 ret = MEDIA_CONTENT_ERROR_NONE;         \r
 168         }\r
 169         else \r
 170         {\r
 171                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 172                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 173         }       \r
 174                 \r
 175         return ret;\r
 176 \r
 177 }\r
 178 \r
 179 \r
 180 int audio_meta_get_genre(audio_meta_h audio, char** name)\r
 181 {\r
 182         int ret;\r
 183         audio_meta_s* _audio = (audio_meta_s*)audio;    \r
 184         if(_audio) \r
 185         {\r
 186                 if((_audio->genre != NULL) && (strlen(_audio->genre) > 0))\r
 187                 {\r
 188                         *name = strdup(_audio->genre);\r
 189                         if(*name == NULL)\r
 190                         {\r
 191                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
 192                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;                               \r
 193                         }\r
 194                 }\r
 195                 else\r
 196                 {\r
 197                         *name = NULL;\r
 198                 }\r
 199                 ret = MEDIA_CONTENT_ERROR_NONE;                                 \r
 200 \r
 201         }\r
 202         else \r
 203         {\r
 204                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 205                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 206         }       \r
 207 \r
 208         return ret;\r
 209         \r
 210 }\r
 211 \r
 212 int audio_meta_get_album(audio_meta_h audio, char **name)\r
 213 {\r
 214         int ret;\r
 215         audio_meta_s* _audio = (audio_meta_s*)audio;    \r
 216         if(_audio) \r
 217         {\r
 218                 if((_audio->album != NULL) && (strlen(_audio->album) > 0))\r
 219                 {\r
 220                         *name = strdup(_audio->album);\r
 221                         if(*name == NULL)\r
 222                         {\r
 223                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
 224                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;                               \r
 225                         }\r
 226                 }\r
 227                 else\r
 228                 {\r
 229                         *name = NULL;\r
 230                 }\r
 231                 ret = MEDIA_CONTENT_ERROR_NONE;                                 \r
 232 \r
 233         }\r
 234         else \r
 235         {\r
 236                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 237                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 238         }       \r
 239 \r
 240         return ret;\r
 241 \r
 242 }\r
 243 int audio_meta_get_artist(audio_meta_h audio, char **name)\r
 244 {\r
 245         int ret;\r
 246         audio_meta_s* _audio = (audio_meta_s*)audio;    \r
 247         if(_audio) \r
 248         {\r
 249                 if((_audio->artist != NULL) && (strlen(_audio->artist) > 0))\r
 250                 {\r
 251                         *name = strdup(_audio->artist);\r
 252                         if(*name == NULL)\r
 253                         {\r
 254                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
 255                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;                               \r
 256                         }\r
 257                 }\r
 258                 else\r
 259                 {\r
 260                         *name = NULL;\r
 261                 }\r
 262                 ret = MEDIA_CONTENT_ERROR_NONE;                                 \r
 263 \r
 264         }\r
 265         else \r
 266         {\r
 267                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 268                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 269         }       \r
 270 \r
 271         return ret;\r
 272 \r
 273 \r
 274 }\r
 275 \r
 276 int audio_meta_get_author(audio_meta_h audio, char** name)\r
 277 {\r
 278         int ret;\r
 279         audio_meta_s* _audio = (audio_meta_s*)audio;    \r
 280         if(_audio) \r
 281         {\r
 282                 if((_audio->author != NULL) && (strlen(_audio->author) > 0))\r
 283                 {\r
 284                         *name = strdup(_audio->author);\r
 285                         if(*name == NULL)\r
 286                         {\r
 287                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
 288                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;                                               \r
 289                         }\r
 290                 }\r
 291                 else\r
 292                 {\r
 293                         *name = NULL;\r
 294                 }\r
 295                 ret = MEDIA_CONTENT_ERROR_NONE;                                 \r
 296 \r
 297         }\r
 298         else \r
 299         {\r
 300                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 301                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 302         }       \r
 303 \r
 304         return ret;\r
 305 \r
 306 }\r
 307 \r
 308 \r
 309 int audio_meta_get_year(audio_meta_h audio,char** year)\r
 310 {\r
 311         int ret;\r
 312         audio_meta_s* _audio = (audio_meta_s*)audio;    \r
 313         if(_audio) \r
 314         {\r
 315                 if((_audio->year != NULL) && (strlen(_audio->year) > 0))\r
 316                 {\r
 317                         *year = strdup(_audio->year);\r
 318                         if(*year == NULL)\r
 319                         {\r
 320                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
 321                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;                                       \r
 322                         }\r
 323                 }\r
 324                 else\r
 325                 {\r
 326                         *year = NULL;\r
 327                 }\r
 328                 ret = MEDIA_CONTENT_ERROR_NONE;                                 \r
 329 \r
 330         }\r
 331         else \r
 332         {\r
 333                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 334                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 335         }       \r
 336 \r
 337         return ret;\r
 338 \r
 339 }\r
 340 \r
 341 int audio_meta_get_copyright(audio_meta_h audio, char** copyright)\r
 342 {\r
 343         int ret;\r
 344         audio_meta_s* _audio = (audio_meta_s*)audio;    \r
 345         if(_audio) \r
 346         {\r
 347                 if((_audio->copyright != NULL) && (strlen(_audio->copyright) > 0))\r
 348                 {\r
 349                         *copyright = strdup(_audio->copyright);\r
 350                         if(*copyright == NULL)\r
 351                         {\r
 352                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
 353                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;                                       \r
 354                         }\r
 355                 }\r
 356                 else\r
 357                 {\r
 358                         *copyright = NULL;\r
 359                 }\r
 360                 ret = MEDIA_CONTENT_ERROR_NONE;                                 \r
 361 \r
 362         }\r
 363         else \r
 364         {\r
 365                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 366                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 367         }       \r
 368 \r
 369         return ret;\r
 370 }\r
 371 \r
 372 \r
 373 \r
 374 int audio_meta_get_description(audio_meta_h audio, char** description)\r
 375 {\r
 376                 int ret;\r
 377                 audio_meta_s* _audio = (audio_meta_s*)audio;    \r
 378                 if(_audio) \r
 379                 {\r
 380                         if((_audio->description != NULL) && (strlen(_audio->description) > 0))\r
 381                         {\r
 382                                 *description = strdup(_audio->description);\r
 383                                 if(*description == NULL)\r
 384                                 {\r
 385                                         LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
 386                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;                                       \r
 387                                 }\r
 388                         }\r
 389                         else\r
 390                         {\r
 391                                 *description = NULL;\r
 392                         }\r
 393                         ret = MEDIA_CONTENT_ERROR_NONE;                                 \r
 394         \r
 395                 }\r
 396                 else \r
 397                 {\r
 398                         LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 399                         ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 400                 }       \r
 401                 return ret;\r
 402 }\r
 403 \r
 404 \r
 405 int audio_meta_get_format(audio_meta_h audio, char** format)\r
 406 {\r
 407                 int ret;\r
 408                 audio_meta_s* _audio = (audio_meta_s*)audio;    \r
 409                 if(_audio) \r
 410                 {\r
 411                         if((_audio->format != NULL) && (strlen(_audio->format) > 0))\r
 412                         {\r
 413                                 *format = strdup(_audio->format);\r
 414                                 if(*format == NULL)\r
 415                                 {\r
 416                                         LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
 417                                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;                                       \r
 418                                 }\r
 419                         }\r
 420                         else\r
 421                         {\r
 422                                 *format = NULL;\r
 423                         }\r
 424                         ret = MEDIA_CONTENT_ERROR_NONE;                                 \r
 425         \r
 426                 }\r
 427                 else \r
 428                 {\r
 429                         LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 430                         ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 431                 }       \r
 432         \r
 433                 return ret;\r
 434 \r
 435 }\r
 436 \r
 437 \r
 438 int audio_meta_get_bitrate(audio_meta_h audio,int* bitrate)\r
 439 {\r
 440         int ret;\r
 441         audio_meta_s* _audio = (audio_meta_s*)audio;    \r
 442         if(_audio && bitrate) \r
 443         {\r
 444                 *bitrate = _audio->bitrate;\r
 445                 ret = MEDIA_CONTENT_ERROR_NONE; \r
 446         }\r
 447         else \r
 448         {\r
 449                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 450                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 451         }       \r
 452 \r
 453         return ret;\r
 454 }\r
 455 \r
 456 \r
 457 int audio_meta_get_track_num(audio_meta_h audio,int* track_num)\r
 458 {\r
 459         int ret;\r
 460         audio_meta_s* _audio = (audio_meta_s*)audio;    \r
 461         if(_audio && track_num) \r
 462         {\r
 463                 *track_num = _audio->track_num;\r
 464                 ret = MEDIA_CONTENT_ERROR_NONE; \r
 465         }\r
 466         else \r
 467         {\r
 468                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 469                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 470         }       \r
 471 \r
 472         return ret;\r
 473 }\r
 474 \r
 475 \r
 476 int audio_meta_get_duration(audio_meta_h audio,int* duration)\r
 477 {\r
 478         int ret;\r
 479         audio_meta_s* _audio = (audio_meta_s*)audio;    \r
 480         if(_audio) \r
 481         {\r
 482                 *duration = _audio->duration;\r
 483                 ret = MEDIA_CONTENT_ERROR_NONE; \r
 484         }\r
 485         else \r
 486         {\r
 487                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 488                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 489         }       \r
 490 \r
 491         return ret;\r
 492 }\r
 493 \r
 494 \r
 495 int audio_meta_get_rating(audio_meta_h audio,int* rating)\r
 496 {\r
 497         int ret;\r
 498         audio_meta_s* _audio = (audio_meta_s*)audio;    \r
 499         if(_audio) \r
 500         {\r
 501                 *rating= _audio->rating;\r
 502                 ret = MEDIA_CONTENT_ERROR_NONE; \r
 503         }\r
 504         else \r
 505         {\r
 506                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 507                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 508         }       \r
 509 \r
 510         return ret;\r
 511 }\r
 512 \r
 513 \r
 514 int audio_meta_get_count_played(audio_meta_h audio,int* count_played)\r
 515 {\r
 516         int ret;\r
 517         audio_meta_s* _audio = (audio_meta_s*)audio;    \r
 518         if(_audio) \r
 519         {\r
 520                 *count_played = _audio->count_played;\r
 521                 ret = MEDIA_CONTENT_ERROR_NONE; \r
 522         }\r
 523         else \r
 524         {\r
 525                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 526                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 527         }       \r
 528 \r
 529         return ret;\r
 530 }\r
 531 \r
 532 \r
 533 int audio_meta_get_time_played(audio_meta_h audio,int* time_played)\r
 534 {\r
 535         int ret;\r
 536         audio_meta_s* _audio = (audio_meta_s*)audio;    \r
 537         if(_audio) \r
 538         {\r
 539                 *time_played = _audio->time_played;\r
 540                 ret = MEDIA_CONTENT_ERROR_NONE; \r
 541         }\r
 542         else \r
 543         {\r
 544                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 545                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 546         }       \r
 547 \r
 548         return ret;\r
 549 }\r
 550 \r
 551 \r
 552 int audio_meta_get_time_added(audio_meta_h audio,time_t* time_added)\r
 553 {\r
 554         int ret;\r
 555         audio_meta_s* _audio = (audio_meta_s*)audio;    \r
 556         if(_audio) \r
 557         {\r
 558                 *time_added = _audio->time_added;\r
 559                 ret = MEDIA_CONTENT_ERROR_NONE; \r
 560         }\r
 561         else \r
 562         {\r
 563                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 564                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 565         }       \r
 566 \r
 567         return ret;\r
 568 }\r
 569 \r
 570 \r
 571 int audio_meta_get_size(audio_meta_h audio,int* size)\r
 572 {\r
 573         int ret;\r
 574         audio_meta_s* _audio = (audio_meta_s*)audio;    \r
 575         if(_audio) \r
 576         {\r
 577                 *size = _audio->size;\r
 578                 ret = MEDIA_CONTENT_ERROR_NONE; \r
 579         }\r
 580         else \r
 581         {\r
 582                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 583                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 584         }       \r
 585 \r
 586         return ret;\r
 587 }\r
 588 \r
 589 \r
 590 int audio_meta_get_category(audio_meta_h audio,audio_category_e* category)\r
 591 {\r
 592         int ret;\r
 593         audio_meta_s* _audio = (audio_meta_s*)audio;    \r
 594         if(_audio) \r
 595         {\r
 596                 *category = _audio->category;\r
 597                 ret = MEDIA_CONTENT_ERROR_NONE; \r
 598         }\r
 599         else \r
 600         {\r
 601                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 602                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 603         }       \r
 604 \r
 605         return ret;\r
 606 }       \r
 607 \r
 608 \r
 609 int audio_meta_update_count_played_to_db(audio_meta_h audio,int count)\r
 610 {\r
 611         int ret = MEDIA_CONTENT_ERROR_NONE;\r
 612 \r
 613         audio_meta_s* _audio = (audio_meta_s*)audio;\r
 614 \r
 615 \r
 616         if(_audio != NULL)\r
 617         {\r
 618                 ret  = audio_svc_update_item_metadata(_audio->audio_id,AUDIO_SVC_TRACK_DATA_PLAYED_COUNT,count,-1);\r
 619 \r
 620                 ret = _content_error_capi(MEDIA_CONTENT_TYPE,ret);\r
 621         }\r
 622         else\r
 623         {\r
 624                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 625                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
 626         }\r
 627         \r
 628         return ret;     \r
 629 }\r
 630 \r
 631 \r
 632 int audio_meta_update_time_played_to_db(audio_meta_h audio,time_t time)\r
 633 {\r
 634         int ret = MEDIA_CONTENT_ERROR_NONE;\r
 635         audio_meta_s* _audio = (audio_meta_s*)audio;\r
 636 \r
 637         \r
 638         if(_audio != NULL)\r
 639         {\r
 640                 ret = audio_svc_update_item_metadata(_audio->audio_id,AUDIO_SVC_TRACK_DATA_PLAYED_TIME,time,-1);\r
 641                 ret = _content_error_capi(MEDIA_CONTENT_TYPE,ret);              \r
 642         }\r
 643         else\r
 644         {\r
 645                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 646                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
 647         }\r
 648         \r
 649         return ret;     \r
 650 }\r
 651 \r
 652 \r
 653 \r
 654 int audio_playlist_foreach_playlist_from_db(media_audio_filter_h filter, audio_playlist_cb callback,  void* user_data )\r
 655 {\r
 656         int ret = MEDIA_CONTENT_ERROR_NONE;\r
 657         char limit_query[MIN_QUERY_SIZE];\r
 658         char search_query[MAX_KEYWORD_SIZE];\r
 659         char order_query[MIN_QUERY_SIZE];\r
 660         char select_query[DEFAULT_QUERY_SIZE];  \r
 661 \r
 662 \r
 663         sqlite3_stmt *stmt = NULL;\r
 664         media_audio_filter_s* _filter = NULL;\r
 665 \r
 666         if( callback == NULL)\r
 667         {\r
 668                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 669                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
 670         }\r
 671 \r
 672 \r
 673         if(filter != NULL)\r
 674                  _filter = (media_audio_filter_s*)filter;\r
 675         else\r
 676         {\r
 677                 media_audio_filter_create((media_audio_filter_h*)&_filter);\r
 678         }\r
 679         \r
 680         \r
 681         memset(limit_query,0x00,sizeof(limit_query));\r
 682         memset(search_query,0x00,sizeof(search_query));\r
 683         memset(order_query,0x00,sizeof(order_query));\r
 684         memset(select_query,0x00,sizeof(select_query));\r
 685 \r
 686 \r
 687         if((_filter->keyword != NULL) && strlen(_filter->keyword) > 0)\r
 688         {\r
 689                 if(strlen(_filter->keyword) < sizeof(search_query))\r
 690                 {\r
 691                         snprintf(search_query,sizeof(search_query)," and name like '%%%s%%'", _filter->keyword);\r
 692                 }\r
 693                 else\r
 694                 {\r
 695                         if((media_audio_filter_s*)filter != _filter)\r
 696                         {\r
 697                                 media_audio_filter_destroy((media_audio_filter_h)_filter);\r
 698                         }\r
 699                         LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 700                         return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
 701                 }\r
 702         }\r
 703         else\r
 704         {\r
 705                 search_query[0] = ' ';\r
 706         }       \r
 707 \r
 708         snprintf(limit_query,sizeof(limit_query),"%s %d,%d",QUERY_KEYWORD_LIMIT,_filter->offset,_filter->count);\r
 709 \r
 710         snprintf(select_query,sizeof(select_query),"%s", SELECT_PLAYLIST);\r
 711 \r
 712 \r
 713         if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_ASC)\r
 714         {\r
 715                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME);\r
 716         }\r
 717         else if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_DESC)\r
 718         {\r
 719                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME,QUERY_KEYWORD_DESC);\r
 720         }\r
 721         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_ASC)\r
 722         {\r
 723                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FIELD_ADDED_TIME);\r
 724         }\r
 725         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_DESC)\r
 726         {\r
 727                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FIELD_ADDED_TIME,QUERY_KEYWORD_DESC);             \r
 728         }\r
 729 \r
 730 \r
 731         if((media_audio_filter_s*)filter != _filter)\r
 732                 media_audio_filter_destroy((media_audio_filter_h)_filter);\r
 733 \r
 734         ret = _content_query_prepare(&stmt,select_query,NULL,search_query,limit_query,order_query);\r
 735 \r
 736         if(ret != MEDIA_CONTENT_ERROR_NONE)\r
 737         {\r
 738                 return ret;\r
 739         }\r
 740         \r
 741         while( sqlite3_step(stmt) == SQLITE_ROW)\r
 742         {\r
 743                 audio_playlist_s* playlist = (audio_playlist_s*)calloc(1,sizeof(audio_playlist_s));\r
 744                 if(playlist == NULL)\r
 745                 {\r
 746                         LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
 747                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
 748                 }\r
 749         \r
 750                 playlist->playlist_id= (int)sqlite3_column_int(stmt,0);\r
 751                 playlist->name= strdup((const char *)sqlite3_column_text(stmt, 1));\r
 752                 if(callback((audio_playlist_h)playlist,user_data) == false)\r
 753                 {\r
 754                         audio_playlist_destroy((audio_playlist_h)playlist);\r
 755                         break;\r
 756                 }\r
 757                 audio_playlist_destroy((audio_playlist_h)playlist);\r
 758         }\r
 759         if(stmt != NULL)\r
 760         {\r
 761                 sqlite3_finalize(stmt);\r
 762         }\r
 763         \r
 764         return ret;\r
 765 \r
 766 }\r
 767 \r
 768 \r
 769 int audio_playlist_foreach_media_from_db(audio_playlist_h playlist, media_audio_filter_h filter, media_info_cb callback, void* user_data )\r
 770 {\r
 771         int ret = MEDIA_CONTENT_ERROR_NONE;\r
 772         \r
 773         char limit_query[MIN_QUERY_SIZE];\r
 774         char search_query[MAX_KEYWORD_SIZE];\r
 775         char order_query[MIN_QUERY_SIZE];\r
 776         char select_query[DEFAULT_QUERY_SIZE];  \r
 777 \r
 778         sqlite3_stmt *stmt = NULL;\r
 779         media_audio_filter_s* _filter = NULL;\r
 780         \r
 781         memset(limit_query,0x00,sizeof(limit_query));\r
 782         memset(search_query,0x00,sizeof(search_query));\r
 783         memset(order_query,0x00,sizeof(order_query));\r
 784         memset(select_query,0x00,sizeof(select_query));\r
 785 \r
 786         audio_playlist_s* _playlist = (audio_playlist_s*)playlist;\r
 787 \r
 788         if(_playlist == NULL )\r
 789         {\r
 790                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 791                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
 792         }\r
 793         if(callback == NULL)\r
 794         {\r
 795                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 796                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
 797         }\r
 798         \r
 799         if(filter != NULL)\r
 800                  _filter = (media_audio_filter_s*)filter;\r
 801         else\r
 802         {\r
 803                 media_audio_filter_create((media_audio_filter_h*)&_filter);\r
 804         }\r
 805         \r
 806 \r
 807         if((_filter->keyword != NULL) && strlen(_filter->keyword) > 0)\r
 808         {\r
 809                 if(strlen(_filter->keyword) < sizeof(search_query))\r
 810                 {\r
 811                         snprintf(search_query,sizeof(search_query),\r
 812                                 " and display_name like '%%%s%%' ",\r
 813                                 _filter->keyword);\r
 814                 }\r
 815                 else\r
 816                 {\r
 817                         LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 818                         if((media_audio_filter_s*)filter != _filter)\r
 819                                 media_audio_filter_destroy((media_audio_filter_h)_filter);\r
 820                         return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
 821                 }\r
 822         }\r
 823         else\r
 824         {\r
 825                 search_query[0] = ' ';\r
 826         }       \r
 827 \r
 828         snprintf(limit_query,sizeof(limit_query),"%s %d,%d",QUERY_KEYWORD_LIMIT,_filter->offset,_filter->count);\r
 829 \r
 830         snprintf(select_query, sizeof(select_query),SELECT_MEDIA_FROM_PLAYLIST, _playlist->playlist_id);\r
 831 \r
 832 \r
 833         if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_ASC)\r
 834         {\r
 835                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME);\r
 836         }\r
 837         else if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_DESC)\r
 838         {\r
 839                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME,QUERY_KEYWORD_DESC);\r
 840         }\r
 841         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_ASC)\r
 842         {\r
 843                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_MODIFIED_DATE);\r
 844         }\r
 845         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_DESC)\r
 846         {\r
 847                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_MODIFIED_DATE,QUERY_KEYWORD_DESC);          \r
 848         }               \r
 849 \r
 850         if((media_audio_filter_s*)filter != _filter)\r
 851                 media_audio_filter_destroy((media_audio_filter_h)_filter);\r
 852         \r
 853         ret = _content_query_prepare(&stmt,select_query,NULL,search_query,limit_query,order_query);\r
 854 \r
 855         if(ret != MEDIA_CONTENT_ERROR_NONE)\r
 856                 return ret;\r
 857 \r
 858         while( sqlite3_step(stmt) == SQLITE_ROW)\r
 859         {\r
 860                 media_info_s* item = (media_info_s*)calloc(1,sizeof(media_info_s));\r
 861                 if(item == NULL)\r
 862                 {\r
 863                         LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
 864                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;       \r
 865                 }\r
 866                 \r
 867                 _content_item_get_detail(stmt,(media_info_h)item);\r
 868                 if(callback((media_info_h)item,user_data) == false )\r
 869                 {\r
 870                         media_info_destroy((media_info_h)item);\r
 871                         break;\r
 872                 }\r
 873                 media_info_destroy((media_info_h)item);         \r
 874 \r
 875         }\r
 876 \r
 877         if(stmt != NULL)\r
 878         {\r
 879                 sqlite3_finalize(stmt);\r
 880         }\r
 881 \r
 882 \r
 883         return ret;\r
 884 }\r
 885 \r
 886 int audio_playlist_get_media_count_from_db(audio_playlist_h playlist,int* count)\r
 887 {\r
 888         int ret = MEDIA_CONTENT_ERROR_NONE;\r
 889 \r
 890         audio_playlist_s* _playlist = (audio_playlist_s*)playlist;\r
 891 \r
 892         if(_playlist != NULL)\r
 893         {\r
 894                 ret = audio_svc_count_playlist_item(_playlist->playlist_id,NULL,NULL, count);\r
 895 \r
 896                 ret = _content_error_capi(MEDIA_CONTENT_TYPE,ret);\r
 897         }\r
 898         else\r
 899         {\r
 900                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 901                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
 902         }\r
 903                 \r
 904         return ret;\r
 905 \r
 906 }\r
 907 \r
 908 \r
 909 int audio_playlist_insert_to_db(const char* name, audio_playlist_h* playlist)\r
 910 {\r
 911         int ret = MEDIA_CONTENT_ERROR_NONE;\r
 912         int playlist_id;\r
 913         \r
 914         if(name != NULL)\r
 915         {\r
 916                 audio_playlist_s* _playlist = (audio_playlist_s*)calloc(1,sizeof(audio_playlist_s));\r
 917 \r
 918                 if( _playlist == NULL )\r
 919                 {\r
 920                         LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
 921                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
 922                 }\r
 923                 \r
 924                         \r
 925                 ret = audio_svc_add_playlist(name,&playlist_id);\r
 926                 ret = _content_error_capi(MEDIA_CONTENT_TYPE,ret);\r
 927                 if(ret != MEDIA_CONTENT_ERROR_NONE)\r
 928                 {\r
 929                         free(_playlist);\r
 930                         return ret;\r
 931                 }\r
 932 \r
 933                 _playlist->playlist_id = playlist_id;\r
 934                 _playlist->name = strdup(name);\r
 935                 if(_playlist->name == NULL)\r
 936                 {\r
 937                         free(_playlist);\r
 938                         LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
 939                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
 940                 }\r
 941 \r
 942                 *playlist = (audio_playlist_h)_playlist;\r
 943         \r
 944         }\r
 945         else\r
 946         {\r
 947                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 948                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
 949         }\r
 950         return ret;\r
 951 \r
 952 }\r
 953 \r
 954 \r
 955 int audio_playlist_delete_from_db(audio_playlist_h playlist)\r
 956 {\r
 957         int ret = MEDIA_CONTENT_ERROR_NONE;\r
 958         audio_playlist_s* _playlist = (audio_playlist_s*)playlist;\r
 959 \r
 960         if(_playlist != NULL)\r
 961         {\r
 962                 ret = audio_svc_delete_playlist(_playlist->playlist_id);\r
 963 \r
 964                 ret = _content_error_capi(MEDIA_CONTENT_TYPE,ret);\r
 965         }\r
 966         else\r
 967         {\r
 968                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 969                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
 970         }\r
 971                 \r
 972         return ret;\r
 973 \r
 974 }\r
 975 \r
 976 int audio_playlist_destroy(audio_playlist_h playlist)\r
 977 {\r
 978         int ret;\r
 979         audio_playlist_s* _playlist = (audio_playlist_s*)playlist;      \r
 980         if(_playlist) \r
 981         {\r
 982                 if(_playlist->name) \r
 983                 {\r
 984                         free(_playlist->name);\r
 985                 }       \r
 986 \r
 987                 free(_playlist);\r
 988                 ret = MEDIA_CONTENT_ERROR_NONE;\r
 989         }\r
 990         else \r
 991         {\r
 992                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
 993                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
 994         }\r
 995         return ret;\r
 996 \r
 997 }\r
 998 int audio_playlist_clone(audio_playlist_h* dst, audio_playlist_h src)\r
 999 {\r
1000         int ret;\r
1001         audio_playlist_s* _src = (audio_playlist_s*)src;        \r
1002 \r
1003         if(_src != NULL )\r
1004         {\r
1005                 audio_playlist_s* _dst = (audio_playlist_s*)calloc(1,sizeof(audio_playlist_s));         \r
1006                 if(_dst == NULL)\r
1007                 {\r
1008                         LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
1009                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
1010                 }\r
1011                 \r
1012                 _dst->playlist_id = _src->playlist_id;\r
1013 \r
1014                 if((_src->name != NULL) && (strlen(_src->name) > 0))\r
1015                 {\r
1016                         _dst->name = strdup(_src->name);\r
1017                         if(_dst->name == NULL)\r
1018                         {\r
1019                                 audio_playlist_destroy((audio_playlist_h)_dst);\r
1020                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
1021                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
1022                         }\r
1023                 }\r
1024                 *dst = (audio_playlist_h)_dst;\r
1025                 ret = MEDIA_CONTENT_ERROR_NONE;         \r
1026         }\r
1027         else \r
1028         {\r
1029                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1030                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
1031         }       \r
1032                 \r
1033         return ret;\r
1034 \r
1035 }\r
1036 \r
1037 \r
1038 int audio_playlist_get_name(audio_playlist_h playlist,char** name)\r
1039 {\r
1040         int ret;\r
1041         audio_playlist_s* _playlist = (audio_playlist_s*)playlist;      \r
1042         if(_playlist) \r
1043         {\r
1044                 if((_playlist->name!= NULL) && (strlen(_playlist->name) > 0))\r
1045                 {\r
1046                         *name = strdup(_playlist->name);\r
1047                         if(*name == NULL)\r
1048                         {\r
1049                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
1050                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
1051                         }\r
1052                 }\r
1053                 else\r
1054                 {\r
1055                         *name = NULL;\r
1056                 }\r
1057                 ret = MEDIA_CONTENT_ERROR_NONE;                                 \r
1058 \r
1059         }\r
1060         else \r
1061         {\r
1062                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1063                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
1064         }       \r
1065 \r
1066         return ret;\r
1067 \r
1068 }\r
1069 \r
1070 \r
1071 \r
1072 int audio_playlist_update_name_to_db(audio_playlist_h playlist,const char* name)\r
1073 {\r
1074         int ret = MEDIA_CONTENT_ERROR_NONE;\r
1075         audio_playlist_s* _playlist = (audio_playlist_s*)playlist;      \r
1076         \r
1077         \r
1078         if(_playlist != NULL && name != NULL)\r
1079         {\r
1080                 ret = audio_svc_update_playlist_name(_playlist->playlist_id,name);\r
1081                 ret = _content_error_capi(MEDIA_CONTENT_TYPE,ret);\r
1082                 if(ret == MEDIA_CONTENT_ERROR_NONE)\r
1083                 {\r
1084                         free(_playlist->name);\r
1085                         _playlist->name = strdup(name);\r
1086                         if(_playlist->name == NULL)\r
1087                         {\r
1088                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
1089                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;                       \r
1090                         }\r
1091                 }               \r
1092                 \r
1093         }\r
1094         else\r
1095         {\r
1096                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1097                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
1098         }\r
1099 \r
1100         \r
1101         return ret;     \r
1102 }\r
1103 \r
1104 int audio_playlist_add_media_to_db(audio_playlist_h playlist, media_info_h item)\r
1105 {\r
1106         int ret = MEDIA_CONTENT_ERROR_NONE;\r
1107         \r
1108         audio_playlist_s* _playlist = (audio_playlist_s*)playlist;      \r
1109         media_info_s* _item = (media_info_s*)item;\r
1110 \r
1111         if(_playlist != NULL && _item != NULL && _item->media_type == 4)\r
1112         {\r
1113 \r
1114                 ret = audio_svc_add_item_to_playlist(_playlist->playlist_id,_item->item_id);\r
1115 \r
1116                 ret = _content_error_capi(MEDIA_CONTENT_TYPE,ret);\r
1117         \r
1118         }\r
1119         else \r
1120         {\r
1121                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1122                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
1123         }\r
1124         \r
1125         return ret;     \r
1126 }\r
1127 \r
1128 \r
1129 int audio_playlist_remove_media_from_db(audio_playlist_h playlist, media_info_h item)\r
1130 {\r
1131         int ret = MEDIA_CONTENT_ERROR_NONE;\r
1132         \r
1133         audio_playlist_s* _playlist = (audio_playlist_s*)playlist;      \r
1134         media_info_s* _item = (media_info_s*)item;\r
1135 \r
1136         if(_playlist != NULL && _item != NULL && _item->media_type == 4)\r
1137         {\r
1138 \r
1139                 ret = audio_svc_remove_item_from_playlist_by_audio_id(_playlist->playlist_id,_item->item_id);\r
1140 \r
1141                 ret = _content_error_capi(MEDIA_CONTENT_TYPE,ret);      \r
1142         }\r
1143         else \r
1144         {\r
1145                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1146                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
1147         }\r
1148 \r
1149                 \r
1150         return ret;     \r
1151 }\r
1152 \r
1153 int audio_genre_foreach_genre_from_db(media_audio_filter_h filter, audio_genre_cb callback, void *user_data)\r
1154 {\r
1155         int ret = MEDIA_CONTENT_ERROR_NONE;\r
1156 \r
1157         char limit_query[MIN_QUERY_SIZE];\r
1158         char search_query[MAX_KEYWORD_SIZE];\r
1159         char order_query[MIN_QUERY_SIZE];\r
1160         char select_query[DEFAULT_QUERY_SIZE];  \r
1161 \r
1162         sqlite3_stmt *stmt = NULL;\r
1163         \r
1164         media_audio_filter_s* _filter = NULL;\r
1165 \r
1166 \r
1167         if(callback == NULL)\r
1168         {\r
1169                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1170                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
1171         }\r
1172         \r
1173         memset(limit_query,0x00,sizeof(limit_query));\r
1174         memset(search_query,0x00,sizeof(search_query));\r
1175         memset(order_query,0x00,sizeof(order_query));\r
1176         memset(select_query,0x00,sizeof(select_query));\r
1177 \r
1178         if(filter != NULL)\r
1179                  _filter = (media_audio_filter_s*)filter;\r
1180         else\r
1181         {\r
1182                 media_audio_filter_create((media_audio_filter_h*)&_filter);\r
1183         }\r
1184         \r
1185         if((_filter->keyword != NULL) && strlen(_filter->keyword) > 0)\r
1186         {\r
1187                 if(strlen(_filter->keyword) < sizeof(search_query))\r
1188                 {\r
1189                         snprintf(search_query,sizeof(search_query)," and name like '%%%s%%'", _filter->keyword);\r
1190                         \r
1191                 }\r
1192                 else\r
1193                 {\r
1194                         LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1195                         if((media_audio_filter_s*)filter != _filter)\r
1196                                 media_audio_filter_destroy((media_audio_filter_h)_filter);\r
1197                         return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
1198                 }\r
1199         }\r
1200         else\r
1201         {\r
1202                 search_query[0] = ' ';\r
1203         }       \r
1204 \r
1205         snprintf(select_query,sizeof(select_query),"%s", SELECT_GENRE_LIST);\r
1206         snprintf(limit_query,sizeof(limit_query),"%s %d,%d",QUERY_KEYWORD_LIMIT,_filter->offset,_filter->count);\r
1207                 \r
1208         if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_ASC)\r
1209         {\r
1210                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME);\r
1211         }\r
1212         else if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_DESC)\r
1213         {\r
1214                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME,QUERY_KEYWORD_DESC);\r
1215         }\r
1216         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_ASC)\r
1217         {\r
1218                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FIELD_ADDED_TIME);\r
1219         }\r
1220         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_DESC)\r
1221         {\r
1222                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FIELD_ADDED_TIME,QUERY_KEYWORD_DESC);     \r
1223         }\r
1224 \r
1225 \r
1226         if((media_audio_filter_s*)filter != _filter)\r
1227                 media_audio_filter_destroy((media_audio_filter_h)_filter);\r
1228 \r
1229         ret = _content_query_prepare(&stmt,select_query,NULL,search_query,limit_query,order_query);\r
1230         if(ret != MEDIA_CONTENT_ERROR_NONE)\r
1231                 return ret;\r
1232 \r
1233         \r
1234         while( sqlite3_step(stmt) == SQLITE_ROW)\r
1235         {\r
1236                 audio_genre_s* genre = (audio_genre_s*)calloc(1,sizeof(audio_genre_s)); \r
1237                 memset(genre,0x00,sizeof(audio_genre_s));\r
1238                 genre->name= strdup((const char *)sqlite3_column_text(stmt, 0));\r
1239                 if(callback((audio_genre_h)genre,user_data) == false)\r
1240                 {\r
1241                         audio_genre_destroy((audio_genre_h)genre);\r
1242                         break;\r
1243                 }\r
1244                 audio_genre_destroy((audio_genre_h)genre);\r
1245         }\r
1246         if(stmt != NULL)\r
1247         {\r
1248                 sqlite3_finalize(stmt);\r
1249         }\r
1250         \r
1251         return ret;\r
1252 \r
1253 }\r
1254 \r
1255 int audio_genre_foreach_media_from_db(audio_genre_h genre, media_audio_filter_h filter, media_info_cb callback,  void* user_data )\r
1256 {\r
1257         int ret = MEDIA_CONTENT_ERROR_NONE;\r
1258 \r
1259         char limit_query[MIN_QUERY_SIZE];\r
1260         char search_query[MAX_KEYWORD_SIZE];\r
1261         char order_query[MIN_QUERY_SIZE];\r
1262         char select_query[DEFAULT_QUERY_SIZE];  \r
1263         \r
1264         sqlite3_stmt *stmt = NULL;\r
1265         media_audio_filter_s* _filter = NULL;\r
1266 \r
1267         audio_genre_s* _genre = (audio_genre_s*)genre;\r
1268         \r
1269 \r
1270         if(_genre == NULL || callback == NULL)\r
1271         {\r
1272                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1273                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
1274         }\r
1275         \r
1276         memset(limit_query,0x00,sizeof(limit_query));\r
1277         memset(search_query,0x00,sizeof(search_query));\r
1278         memset(order_query,0x00,sizeof(order_query));\r
1279         memset(select_query,0x00,sizeof(select_query));\r
1280 \r
1281         if(filter != NULL)\r
1282                  _filter = (media_audio_filter_s*)filter;\r
1283         else\r
1284         {\r
1285                 media_audio_filter_create((media_audio_filter_h*)&_filter);\r
1286         }\r
1287         \r
1288 \r
1289         if((_filter->keyword != NULL) && strlen(_filter->keyword) > 0)\r
1290         {\r
1291                 if(strlen(_filter->keyword) < sizeof(search_query))\r
1292                 {\r
1293                         snprintf(search_query,sizeof(search_query)," and display_name like '%%%s%%'", _filter->keyword);\r
1294         \r
1295                 }\r
1296                 else\r
1297                 {\r
1298                         LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1299                         if((media_audio_filter_s*)filter != _filter)\r
1300                                 media_audio_filter_destroy((media_audio_filter_h)_filter);              \r
1301                         return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
1302                 }\r
1303         }\r
1304         else\r
1305         {\r
1306                 search_query[0] = ' ';\r
1307         }       \r
1308 \r
1309         snprintf(select_query, sizeof(select_query),SELECT_MEDIA_FROM_GENRE, _genre->name);\r
1310 \r
1311         snprintf(limit_query,sizeof(limit_query),"%s %d,%d",QUERY_KEYWORD_LIMIT,_filter->offset,_filter->count);\r
1312 \r
1313 \r
1314         if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_ASC)\r
1315         {\r
1316                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME);\r
1317         }\r
1318         else if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_DESC)\r
1319         {\r
1320                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME,QUERY_KEYWORD_DESC);\r
1321         }\r
1322         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_ASC)\r
1323         {\r
1324                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_MODIFIED_DATE);\r
1325         }\r
1326         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_DESC)\r
1327         {\r
1328                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_MODIFIED_DATE,QUERY_KEYWORD_DESC);          \r
1329         }       \r
1330 \r
1331 \r
1332         if((media_audio_filter_s*)filter != _filter)\r
1333                 media_audio_filter_destroy((media_audio_filter_h)_filter);\r
1334 \r
1335         ret= _content_query_prepare(&stmt,select_query,NULL,search_query,limit_query,order_query);\r
1336         if(ret != MEDIA_CONTENT_ERROR_NONE)\r
1337                 return ret;\r
1338 \r
1339         \r
1340         while( sqlite3_step(stmt) == SQLITE_ROW)\r
1341         {\r
1342                 media_info_s* item = (media_info_s*)calloc(1,sizeof(media_info_s));     \r
1343 \r
1344                 _content_item_get_detail(stmt, (media_info_h)item);\r
1345                 if(callback((media_info_h)item,user_data) == false)\r
1346                 {\r
1347                         media_info_destroy((media_info_h)item);\r
1348                         break;\r
1349                 }\r
1350                 media_info_destroy((media_info_h)item);\r
1351         }\r
1352         if(stmt != NULL)\r
1353         {\r
1354                 sqlite3_finalize(stmt);\r
1355         }\r
1356         \r
1357         return ret;\r
1358 }\r
1359 \r
1360 \r
1361 int audio_genre_get_media_count_from_db(audio_genre_h genre,int* count)\r
1362 {\r
1363         int ret = MEDIA_CONTENT_ERROR_NONE;\r
1364         char select_query[DEFAULT_QUERY_SIZE];  \r
1365 \r
1366         sqlite3_stmt *stmt = NULL;\r
1367         audio_genre_s* _genre = (audio_genre_s*)genre;\r
1368         \r
1369 \r
1370         memset(select_query,0x00,sizeof(select_query));\r
1371         \r
1372         if(_genre == NULL)\r
1373         {\r
1374                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1375                 return  MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
1376         }\r
1377 \r
1378         snprintf(select_query,sizeof(select_query),SELECT_MEDIA_COUNT_FROM_GENRE,_genre->name);\r
1379 \r
1380 \r
1381         ret = _content_query_prepare(&stmt,select_query,NULL,NULL,NULL,NULL);\r
1382         if(ret != MEDIA_CONTENT_ERROR_NONE)\r
1383                 return ret;\r
1384 \r
1385         while( sqlite3_step(stmt) == SQLITE_ROW)\r
1386         {\r
1387                 *count = (int)sqlite3_column_int(stmt,0);\r
1388         }\r
1389         if(stmt != NULL)\r
1390         {\r
1391                 sqlite3_finalize(stmt);\r
1392         }\r
1393         \r
1394         return ret;\r
1395 \r
1396 }\r
1397 \r
1398 int audio_genre_destroy(audio_genre_h genre)\r
1399 {\r
1400         int ret;\r
1401         audio_genre_s* _genre = (audio_genre_s*)genre;  \r
1402         if(_genre) \r
1403         {\r
1404                 if(_genre->name) \r
1405                 {\r
1406                         free(_genre->name);\r
1407                 }       \r
1408 \r
1409                 free(_genre);\r
1410                 ret = MEDIA_CONTENT_ERROR_NONE;\r
1411         }\r
1412         else \r
1413         {\r
1414                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1415                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
1416         }\r
1417         return ret;\r
1418 \r
1419 }\r
1420 \r
1421 int audio_genre_clone(audio_genre_h* dst,audio_genre_h src)\r
1422 {\r
1423         int ret;\r
1424         audio_genre_s* _src = (audio_genre_s*)src;      \r
1425 \r
1426 \r
1427         if(_src != NULL)\r
1428         {\r
1429                 audio_genre_s* _dst = (audio_genre_s*)calloc(1,sizeof(audio_genre_s));          \r
1430                 if(_dst == NULL)\r
1431                 {\r
1432                         LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
1433                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
1434                 }\r
1435                 \r
1436                 if((_src->name != NULL) && (strlen(_src->name) > 0))\r
1437                 {\r
1438                         _dst->name = strdup(_src->name);\r
1439                         if(_dst->name == NULL)\r
1440                         {\r
1441                                 audio_genre_destroy((audio_genre_h)_dst);\r
1442                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
1443                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
1444                         }\r
1445                 }\r
1446 \r
1447                 *dst = (audio_genre_h)_dst;\r
1448                 ret = MEDIA_CONTENT_ERROR_NONE;         \r
1449         }\r
1450         else \r
1451         {\r
1452                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1453                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
1454         }       \r
1455                 \r
1456         return ret;\r
1457 \r
1458 }\r
1459 \r
1460                 \r
1461 int audio_genre_get_name(audio_genre_h genre, char** name)\r
1462 {\r
1463         int ret;\r
1464         audio_genre_s* _genre = (audio_genre_s*)genre;  \r
1465         if(_genre) \r
1466         {\r
1467                 if((_genre->name!= NULL) && (strlen(_genre->name) > 0))\r
1468                 {\r
1469                         *name = strdup(_genre->name);\r
1470                         if(*name == NULL)\r
1471                         {\r
1472                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
1473                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
1474                         }\r
1475                 }\r
1476                 else\r
1477                 {\r
1478                         *name = NULL;\r
1479                 }\r
1480                 ret = MEDIA_CONTENT_ERROR_NONE;                                 \r
1481 \r
1482         }\r
1483         else \r
1484         {\r
1485                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1486                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
1487         }       \r
1488 \r
1489         return ret;\r
1490 \r
1491 }\r
1492 \r
1493 \r
1494 int audio_album_foreach_album_from_db(media_audio_filter_h filter, audio_album_cb callback, void *user_data)\r
1495 {\r
1496         int ret = MEDIA_CONTENT_ERROR_NONE;\r
1497 \r
1498         char limit_query[MIN_QUERY_SIZE];\r
1499         char search_query[MAX_KEYWORD_SIZE];\r
1500         char order_query[MIN_QUERY_SIZE];\r
1501         char select_query[DEFAULT_QUERY_SIZE];  \r
1502         \r
1503         sqlite3_stmt *stmt = NULL;\r
1504         media_audio_filter_s* _filter = NULL;\r
1505         \r
1506 \r
1507         if(callback == NULL )\r
1508         {\r
1509                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1510                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
1511         }\r
1512 \r
1513         memset(limit_query,0x00,sizeof(limit_query));\r
1514         memset(search_query,0x00,sizeof(search_query));\r
1515         memset(order_query,0x00,sizeof(order_query));\r
1516         memset(select_query,0x00,sizeof(select_query));\r
1517 \r
1518         if(filter != NULL)\r
1519                  _filter = (media_audio_filter_s*)filter;\r
1520         else\r
1521         {\r
1522                 media_audio_filter_create((media_audio_filter_h*)&_filter);\r
1523         }\r
1524         \r
1525         if((_filter->keyword != NULL) && strlen(_filter->keyword) > 0)\r
1526         {\r
1527                 if(strlen(_filter->keyword) < sizeof(search_query))\r
1528                 {\r
1529                         snprintf(search_query,sizeof(search_query)," and name like '%%%s%%'",_filter->keyword);\r
1530                         \r
1531                 }\r
1532                 else\r
1533                 {\r
1534                         LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1535                         if((media_audio_filter_s*)filter != _filter)\r
1536                                 media_audio_filter_destroy((media_audio_filter_h)_filter);\r
1537                         return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
1538                 }\r
1539         }\r
1540         else\r
1541         {\r
1542                 search_query[0] = ' ';\r
1543         }       \r
1544         snprintf(select_query,sizeof(select_query),"%s", SELECT_ALBUM_LIST);\r
1545 \r
1546         snprintf(limit_query,sizeof(limit_query),"%s %d,%d",QUERY_KEYWORD_LIMIT,_filter->offset,_filter->count);\r
1547 \r
1548         if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_ASC)\r
1549         {\r
1550                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME);\r
1551         }\r
1552         else if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_DESC)\r
1553         {\r
1554                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME,QUERY_KEYWORD_DESC);\r
1555         }\r
1556         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_ASC)\r
1557         {\r
1558                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FIELD_ADDED_TIME);\r
1559         }\r
1560         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_DESC)\r
1561         {\r
1562                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FIELD_ADDED_TIME,QUERY_KEYWORD_DESC);             \r
1563         }\r
1564 \r
1565 \r
1566         if((media_audio_filter_s*)filter != _filter)\r
1567                 media_audio_filter_destroy((media_audio_filter_h)_filter);\r
1568 \r
1569         ret = _content_query_prepare(&stmt,select_query,NULL,search_query,limit_query,order_query);\r
1570         if(ret != MEDIA_CONTENT_ERROR_NONE)\r
1571                 return ret;\r
1572 \r
1573         while( sqlite3_step(stmt) == SQLITE_ROW)\r
1574         {\r
1575                 audio_album_s* album = (audio_album_s*)calloc(1,sizeof(audio_album_s));\r
1576 \r
1577                 if(album == NULL)\r
1578                 {\r
1579                         LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
1580                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;       \r
1581                 }\r
1582 \r
1583                 album->name= strdup((const char *)sqlite3_column_text(stmt, 0));\r
1584                 if(callback((audio_album_h)album,user_data) == false)\r
1585                 {\r
1586                         audio_album_destroy((audio_album_h)album);\r
1587                         break;\r
1588                 }\r
1589                 audio_album_destroy((audio_album_h)album);\r
1590         }\r
1591         if(stmt != NULL)\r
1592         {\r
1593                 sqlite3_finalize(stmt);\r
1594         }\r
1595         return ret;\r
1596 \r
1597 }\r
1598 \r
1599 int audio_album_foreach_media_from_db(audio_album_h album, media_audio_filter_h filter, media_info_cb callback,  void* user_data )\r
1600 {\r
1601         int ret = MEDIA_CONTENT_ERROR_NONE;\r
1602 \r
1603         char limit_query[MIN_QUERY_SIZE];\r
1604         char search_query[MAX_KEYWORD_SIZE];\r
1605         char order_query[MIN_QUERY_SIZE];\r
1606         char select_query[DEFAULT_QUERY_SIZE];  \r
1607 \r
1608         sqlite3_stmt *stmt = NULL;\r
1609         media_audio_filter_s* _filter = NULL;\r
1610         \r
1611 \r
1612         audio_album_s* _album = (audio_album_s*)album;\r
1613 \r
1614 \r
1615         if( _album == NULL || callback == NULL)\r
1616         {\r
1617                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1618                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
1619         }\r
1620 \r
1621         memset(limit_query,0x00,sizeof(limit_query));\r
1622         memset(search_query,0x00,sizeof(search_query));\r
1623         memset(order_query,0x00,sizeof(order_query));\r
1624         memset(select_query,0x00,sizeof(select_query));\r
1625 \r
1626 \r
1627         if(filter != NULL)\r
1628                  _filter = (media_audio_filter_s*)filter;\r
1629         else\r
1630         {\r
1631                 media_audio_filter_create((media_audio_filter_h*)&_filter);\r
1632         }\r
1633 \r
1634         if((_filter->keyword != NULL) && strlen(_filter->keyword) > 0)\r
1635         {\r
1636                 if(strlen(_filter->keyword) < sizeof(search_query))\r
1637                 {\r
1638                         snprintf(search_query,sizeof(search_query)," and display_name like '%%%s%%'", _filter->keyword);\r
1639         \r
1640                 }\r
1641                 else\r
1642                 {\r
1643                         LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1644                         if((media_audio_filter_s*)filter != _filter)\r
1645                                 media_audio_filter_destroy((media_audio_filter_h)_filter);\r
1646                         return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
1647                 }\r
1648         }\r
1649         else\r
1650         {\r
1651                 search_query[0] = ' ';\r
1652         }       \r
1653 \r
1654 \r
1655         snprintf(limit_query,sizeof(limit_query),"%s %d,%d",QUERY_KEYWORD_LIMIT,_filter->offset,_filter->count);\r
1656 \r
1657         snprintf(select_query, sizeof(select_query),SELECT_MEDIA_FROM_ALBUM, _album->name);\r
1658 \r
1659 \r
1660         if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_ASC)\r
1661         {\r
1662                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME);\r
1663         }\r
1664         else if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_DESC)\r
1665         {\r
1666                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME,QUERY_KEYWORD_DESC);\r
1667         }\r
1668         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_ASC)\r
1669         {\r
1670                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_MODIFIED_DATE);\r
1671         }\r
1672         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_DESC)\r
1673         {\r
1674                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_MODIFIED_DATE,QUERY_KEYWORD_DESC);          \r
1675         }       \r
1676 \r
1677         if((media_audio_filter_s*)filter != _filter)\r
1678                 media_audio_filter_destroy((media_audio_filter_h)_filter);\r
1679 \r
1680         ret = _content_query_prepare(&stmt,select_query,NULL,search_query,limit_query,order_query);\r
1681         if(ret != MEDIA_CONTENT_ERROR_NONE)\r
1682                 return ret;\r
1683 \r
1684         \r
1685         while( sqlite3_step(stmt) == SQLITE_ROW)\r
1686         {\r
1687                 media_info_s* item = (media_info_s*)calloc(1,sizeof(media_info_s));     \r
1688 \r
1689                 _content_item_get_detail(stmt, (media_info_h)item);\r
1690                 if(callback((media_info_h)item,user_data) == false)\r
1691                 {\r
1692                         media_info_destroy((media_info_h)item);\r
1693                         break;\r
1694                 }\r
1695                 media_info_destroy((media_info_h)item);         \r
1696         }\r
1697         if(stmt != NULL)\r
1698         {\r
1699                 sqlite3_finalize(stmt);\r
1700         }\r
1701 \r
1702         return ret;\r
1703 \r
1704 \r
1705 }\r
1706 \r
1707 \r
1708 int audio_album_get_media_count_from_db(audio_album_h album,int* count)\r
1709 {\r
1710         int ret = MEDIA_CONTENT_ERROR_NONE;\r
1711         sqlite3_stmt *stmt = NULL;\r
1712         audio_album_s* _album = (audio_album_s*)album;\r
1713         char select_query[DEFAULT_QUERY_SIZE];  \r
1714         \r
1715         memset(select_query,0x00,sizeof(select_query));\r
1716 \r
1717         if(_album == NULL)\r
1718         {\r
1719                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1720                 return  MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
1721         }\r
1722 \r
1723         snprintf(select_query,sizeof(select_query),SELECT_MEDIA_COUNT_FROM_ALBUM,_album ->name);\r
1724 \r
1725 \r
1726         ret = _content_query_prepare(&stmt,select_query,NULL,NULL,NULL,NULL);\r
1727         if(ret != MEDIA_CONTENT_ERROR_NONE)\r
1728                 return ret;\r
1729 \r
1730         while( sqlite3_step(stmt) == SQLITE_ROW)\r
1731         {\r
1732                 *count = (int)sqlite3_column_int(stmt,0);\r
1733         }\r
1734         if(stmt != NULL)\r
1735         {\r
1736                 sqlite3_finalize(stmt);\r
1737         }\r
1738 \r
1739                 \r
1740         return ret;\r
1741 \r
1742 }\r
1743 \r
1744 int audio_album_destroy(audio_album_h album )\r
1745 {\r
1746         int ret;\r
1747         audio_album_s* _album = (audio_album_s*)album;  \r
1748         if(_album) \r
1749         {\r
1750                 if(_album->name) \r
1751                 {\r
1752                         free(_album->name);\r
1753                 }       \r
1754 \r
1755                 free(_album);\r
1756                 ret = MEDIA_CONTENT_ERROR_NONE;\r
1757         }\r
1758         else \r
1759         {\r
1760                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1761                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
1762         }\r
1763         return ret;\r
1764 \r
1765 }\r
1766 \r
1767 int audio_album_clone(audio_album_h* dst,audio_album_h src)\r
1768 {\r
1769         int ret;\r
1770         audio_album_s* _src = (audio_album_s*)src;      \r
1771         \r
1772 \r
1773         if(_src != NULL)\r
1774         {\r
1775                 audio_album_s* _dst = (audio_album_s*)calloc(1,sizeof(audio_album_s));          \r
1776 \r
1777                 if(_dst == NULL)\r
1778                 {\r
1779                         LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
1780                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
1781                 }\r
1782                 \r
1783                 if((_src->name != NULL) && (strlen(_src->name) > 0))\r
1784                 {\r
1785                         _dst->name = strdup(_src->name);\r
1786                         if(_dst->name == NULL)\r
1787                         {\r
1788                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
1789                                 audio_album_destroy((audio_album_h)_dst);\r
1790                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
1791                         }\r
1792                 }\r
1793 \r
1794                 *dst = (audio_album_h)_dst;\r
1795                 ret = MEDIA_CONTENT_ERROR_NONE;         \r
1796         }\r
1797         else \r
1798         {\r
1799                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1800                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
1801         }       \r
1802                 \r
1803         return ret;\r
1804 \r
1805 }\r
1806                 \r
1807 int audio_album_get_name(audio_album_h album, char** name)\r
1808 {\r
1809         int ret;\r
1810         audio_album_s* _album = (audio_album_s*)album;  \r
1811         if(_album) \r
1812         {\r
1813                 if((_album->name!= NULL) && (strlen(_album->name) > 0))\r
1814                 {\r
1815                         *name = strdup(_album->name);\r
1816                         if(*name == NULL)\r
1817                         {\r
1818                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
1819                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
1820                         }\r
1821                 }\r
1822                 else\r
1823                 {\r
1824                         *name = NULL;\r
1825                 }\r
1826                 ret = MEDIA_CONTENT_ERROR_NONE;                                 \r
1827 \r
1828         }\r
1829         else \r
1830         {\r
1831                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1832                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
1833         }       \r
1834 \r
1835         return ret;\r
1836 \r
1837 }\r
1838 \r
1839 \r
1840 int audio_author_foreach_author_from_db(media_audio_filter_h filter, audio_author_cb callback, void *user_data)\r
1841 {\r
1842         int ret = MEDIA_CONTENT_ERROR_NONE;\r
1843 \r
1844         char limit_query[MIN_QUERY_SIZE];\r
1845         char search_query[MAX_KEYWORD_SIZE];\r
1846         char order_query[MIN_QUERY_SIZE];\r
1847         char select_query[DEFAULT_QUERY_SIZE];  \r
1848 \r
1849         sqlite3_stmt *stmt = NULL;\r
1850         media_audio_filter_s* _filter = NULL;\r
1851 \r
1852         if(callback == NULL)\r
1853         {\r
1854                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1855                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
1856         }\r
1857 \r
1858         memset(limit_query,0x00,sizeof(limit_query));\r
1859         memset(search_query,0x00,sizeof(search_query));\r
1860         memset(order_query,0x00,sizeof(order_query));\r
1861         memset(select_query,0x00,sizeof(select_query));\r
1862 \r
1863         if(filter != NULL)\r
1864                  _filter = (media_audio_filter_s*)filter;\r
1865         else\r
1866         {\r
1867                 media_audio_filter_create((media_audio_filter_h*)&_filter);\r
1868         }\r
1869                 \r
1870 \r
1871         if((_filter->keyword != NULL) && strlen(_filter->keyword) > 0)\r
1872         {\r
1873                 if(strlen(_filter->keyword) < sizeof(search_query))\r
1874                 {\r
1875                         snprintf(search_query,sizeof(search_query)," and name like '%%%s%%'", _filter->keyword);\r
1876                         \r
1877                 }\r
1878                 else\r
1879                 {\r
1880                         LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1881                         if((media_audio_filter_s*)filter != _filter)\r
1882                                 media_audio_filter_destroy((media_audio_filter_h)_filter);\r
1883                         return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
1884                 }\r
1885         }\r
1886         else\r
1887         {\r
1888                 search_query[0] = ' ';\r
1889         }       \r
1890         \r
1891         snprintf(limit_query,sizeof(limit_query),"%s %d,%d",QUERY_KEYWORD_LIMIT,_filter->offset,_filter->count);\r
1892 \r
1893         snprintf(select_query,sizeof(select_query),"%s", SELECT_AUTHOR_LIST);\r
1894 \r
1895 \r
1896         if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_ASC)\r
1897         {\r
1898                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME);\r
1899         }\r
1900         else if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_DESC)\r
1901         {\r
1902                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME,QUERY_KEYWORD_DESC);\r
1903         }\r
1904         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_ASC)\r
1905         {\r
1906                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FIELD_ADDED_TIME);\r
1907         }\r
1908         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_DESC)\r
1909         {\r
1910                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FIELD_ADDED_TIME,QUERY_KEYWORD_DESC);             \r
1911         }\r
1912 \r
1913         if((media_audio_filter_s*)filter != _filter)\r
1914                 media_audio_filter_destroy((media_audio_filter_h)_filter);\r
1915         \r
1916 \r
1917         ret = _content_query_prepare(&stmt,select_query,NULL,search_query,limit_query,order_query);\r
1918         if(ret != MEDIA_CONTENT_ERROR_NONE)\r
1919                 return ret;\r
1920         \r
1921         while( sqlite3_step(stmt) == SQLITE_ROW)\r
1922         {\r
1923                 audio_author_s* author = (audio_author_s*)calloc(1,sizeof(audio_author_s));\r
1924                 if(author == NULL)\r
1925                 {\r
1926                         LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
1927                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;       \r
1928                 }\r
1929 \r
1930                 author->name= strdup((const char *)sqlite3_column_text(stmt, 0));\r
1931                 if(callback((audio_author_h)author,user_data) == false)\r
1932                 {\r
1933                         audio_author_destroy((audio_author_h)author);\r
1934                         break;\r
1935                 }\r
1936                 audio_author_destroy((audio_author_h)author);\r
1937         }\r
1938         if(stmt != NULL)\r
1939         {\r
1940                 sqlite3_finalize(stmt);\r
1941         }\r
1942         return ret;\r
1943 \r
1944 }\r
1945 \r
1946 int audio_author_foreach_media_from_db(audio_author_h author, media_audio_filter_h filter, media_info_cb callback,  void* user_data )\r
1947 {\r
1948         int ret = MEDIA_CONTENT_ERROR_NONE;\r
1949 \r
1950         char limit_query[MIN_QUERY_SIZE];\r
1951         char search_query[MAX_KEYWORD_SIZE];\r
1952         char order_query[MIN_QUERY_SIZE];\r
1953         char select_query[DEFAULT_QUERY_SIZE];  \r
1954 \r
1955         sqlite3_stmt *stmt = NULL;\r
1956         media_audio_filter_s* _filter = NULL;\r
1957 \r
1958         audio_author_s* _author = (audio_author_s*)author;\r
1959         \r
1960 \r
1961         if(_author == NULL || callback == NULL)\r
1962         {\r
1963                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1964                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
1965         }\r
1966 \r
1967         if(filter != NULL)\r
1968                  _filter = (media_audio_filter_s*)filter;\r
1969         else\r
1970         {\r
1971                 media_audio_filter_create((media_audio_filter_h*)&_filter);\r
1972         }\r
1973 \r
1974         memset(limit_query,0x00,sizeof(limit_query));\r
1975         memset(search_query,0x00,sizeof(search_query));\r
1976         memset(order_query,0x00,sizeof(order_query));\r
1977         memset(select_query,0x00,sizeof(select_query));\r
1978 \r
1979         \r
1980         if((_filter->keyword != NULL) && strlen(_filter->keyword) > 0)\r
1981         {\r
1982                 if(strlen(_filter->keyword) < sizeof(search_query))\r
1983                 {\r
1984                         snprintf(search_query,sizeof(search_query)," and display_name like '%%%s%%'", _filter->keyword);\r
1985         \r
1986                 }\r
1987                 else\r
1988                 {\r
1989                         LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
1990                         if((media_audio_filter_s*)filter != _filter)\r
1991                                 media_audio_filter_destroy((media_audio_filter_h)_filter);              \r
1992                         return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
1993                 }\r
1994         }\r
1995         else\r
1996         {\r
1997                 search_query[0] = ' ';\r
1998         }       \r
1999 \r
2000         \r
2001         snprintf(limit_query,sizeof(limit_query),"%s %d,%d",QUERY_KEYWORD_LIMIT,_filter->offset,_filter->count);\r
2002 \r
2003         snprintf(select_query, sizeof(select_query),SELECT_MEDIA_FROM_AUTHOR, _author->name);\r
2004 \r
2005 \r
2006         if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_ASC)\r
2007         {\r
2008                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME);\r
2009         }\r
2010         else if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_DESC)\r
2011         {\r
2012                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME,QUERY_KEYWORD_DESC);\r
2013         }\r
2014         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_ASC)\r
2015         {\r
2016                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_MODIFIED_DATE);\r
2017         }\r
2018         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_DESC)\r
2019         {\r
2020                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_MODIFIED_DATE,QUERY_KEYWORD_DESC);          \r
2021         }       \r
2022 \r
2023 \r
2024         if((media_audio_filter_s*)filter != _filter)\r
2025                 media_audio_filter_destroy((media_audio_filter_h)_filter);\r
2026 \r
2027         ret =_content_query_prepare(&stmt,select_query,NULL,search_query,limit_query,order_query);\r
2028         if(ret != MEDIA_CONTENT_ERROR_NONE)\r
2029                 return ret;\r
2030 \r
2031                 \r
2032         while( sqlite3_step(stmt) == SQLITE_ROW)\r
2033         {\r
2034                 media_info_s* item = (media_info_s*)calloc(1,sizeof(media_info_s));\r
2035                 if(item == NULL)\r
2036                 {\r
2037                         LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
2038                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;       \r
2039                 }\r
2040                 \r
2041                 _content_item_get_detail(stmt, (media_info_h)item);\r
2042                 if(callback((media_info_h)item,user_data) == false)\r
2043                 {\r
2044                         media_info_destroy((media_info_h)item);\r
2045                         break;\r
2046                 }\r
2047                 media_info_destroy((media_info_h)item);\r
2048         }\r
2049         if(stmt != NULL)\r
2050         {\r
2051                 sqlite3_finalize(stmt);\r
2052         }\r
2053 \r
2054         return ret;\r
2055 \r
2056 \r
2057 }\r
2058 \r
2059 \r
2060 int audio_author_get_media_count_from_db(audio_author_h author,int* count)\r
2061 {\r
2062         int ret = MEDIA_CONTENT_ERROR_NONE;\r
2063         sqlite3_stmt *stmt = NULL;\r
2064         audio_author_s* _author = (audio_author_s*)author;\r
2065         char select_query[DEFAULT_QUERY_SIZE];\r
2066 \r
2067         \r
2068         memset(select_query,0x00,sizeof(select_query));\r
2069 \r
2070         if(_author == NULL)\r
2071         {\r
2072                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
2073                 return  MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
2074         }\r
2075 \r
2076 \r
2077         snprintf(select_query,sizeof(select_query),SELECT_MEDIA_COUNT_FROM_AUTHOR,_author ->name);\r
2078 \r
2079         ret = _content_query_prepare(&stmt,select_query,NULL,NULL,NULL,NULL);\r
2080         if(ret!= MEDIA_CONTENT_ERROR_NONE)\r
2081                 return ret;\r
2082 \r
2083         while( sqlite3_step(stmt) == SQLITE_ROW)\r
2084         {\r
2085                 *count = (int)sqlite3_column_int(stmt,0);\r
2086         }\r
2087         if(stmt != NULL)\r
2088         {\r
2089                 sqlite3_finalize(stmt);\r
2090         }\r
2091 \r
2092                 \r
2093         return ret;\r
2094 \r
2095 }\r
2096 \r
2097 int audio_author_destroy(audio_author_h author )\r
2098 {\r
2099         int ret;\r
2100         audio_author_s* _author = (audio_author_s*)author;      \r
2101         if(_author) \r
2102         {\r
2103                 if(_author->name) \r
2104                 {\r
2105                         free(_author->name);\r
2106                 }       \r
2107 \r
2108                 free(_author);\r
2109                 ret = MEDIA_CONTENT_ERROR_NONE;\r
2110         }\r
2111         else \r
2112         {\r
2113                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
2114                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
2115         }\r
2116         return ret;\r
2117 \r
2118 }\r
2119 \r
2120 int audio_author_clone(audio_author_h* dst,audio_author_h src)\r
2121 {\r
2122         int ret;\r
2123         audio_author_s* _src = (audio_author_s*)src;    \r
2124         \r
2125 \r
2126         if(_src != NULL)\r
2127         {\r
2128                 audio_author_s* _dst = (audio_author_s*)calloc(1,sizeof(audio_author_s));       \r
2129 \r
2130                 if(_dst == NULL)\r
2131                 {\r
2132                         LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
2133                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
2134                 }\r
2135                 \r
2136                 if((_src->name != NULL) && (strlen(_src->name) > 0))\r
2137                 {\r
2138                         _dst->name = strdup(_src->name);\r
2139                         if(_dst->name == NULL)\r
2140                         {\r
2141                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
2142                                 audio_author_destroy((audio_author_h)_dst);\r
2143                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
2144                         }\r
2145                 }\r
2146 \r
2147                 *dst = (audio_author_h)_dst;\r
2148                 ret = MEDIA_CONTENT_ERROR_NONE;         \r
2149         }\r
2150         else \r
2151         {\r
2152                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
2153                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
2154         }       \r
2155                 \r
2156         return ret;\r
2157 \r
2158 }\r
2159                 \r
2160 int audio_author_get_name(audio_author_h author, char** name)\r
2161 {\r
2162         int ret;\r
2163         audio_author_s* _author = (audio_author_s*)author;      \r
2164         if(_author) \r
2165         {\r
2166                 if((_author->name!= NULL) && (strlen(_author->name) > 0))\r
2167                 {\r
2168                         *name = strdup(_author->name);\r
2169                         if(*name == NULL)\r
2170                         {\r
2171                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
2172                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
2173                         }\r
2174                 }\r
2175                 else\r
2176                 {\r
2177                         *name = NULL;\r
2178                 }\r
2179                 ret = MEDIA_CONTENT_ERROR_NONE;                                 \r
2180 \r
2181         }\r
2182         else \r
2183         {\r
2184                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
2185                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
2186         }       \r
2187 \r
2188         return ret;\r
2189 \r
2190 }\r
2191 \r
2192 \r
2193 \r
2194 int audio_artist_foreach_artist_from_db(media_audio_filter_h filter, audio_artist_cb callback, void *user_data)\r
2195 {\r
2196         int ret = MEDIA_CONTENT_ERROR_NONE;\r
2197 \r
2198         char limit_query[MIN_QUERY_SIZE];\r
2199         char search_query[MAX_KEYWORD_SIZE];\r
2200         char order_query[MIN_QUERY_SIZE];\r
2201         char select_query[DEFAULT_QUERY_SIZE];  \r
2202 \r
2203         sqlite3_stmt *stmt = NULL;\r
2204         media_audio_filter_s* _filter = NULL;\r
2205 \r
2206         if(callback == NULL)\r
2207         {\r
2208                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
2209                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
2210         }\r
2211 \r
2212         if(filter != NULL)\r
2213                  _filter = (media_audio_filter_s*)filter;\r
2214         else\r
2215         {\r
2216                 media_audio_filter_create((media_audio_filter_h*)&_filter);\r
2217         }\r
2218 \r
2219         memset(limit_query,0x00,sizeof(limit_query));\r
2220         memset(search_query,0x00,sizeof(search_query));\r
2221         memset(order_query,0x00,sizeof(order_query));\r
2222         memset(select_query,0x00,sizeof(select_query));\r
2223         \r
2224         if((_filter->keyword != NULL) && strlen(_filter->keyword) > 0)\r
2225         {\r
2226                 if(strlen(_filter->keyword) < sizeof(search_query))\r
2227                 {\r
2228                         snprintf(search_query,sizeof(search_query)," and name like '%%%s%%'", _filter->keyword);\r
2229                         \r
2230                 }\r
2231                 else\r
2232                 {\r
2233                         LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
2234                         if((media_audio_filter_s*)filter != _filter)\r
2235                                 media_audio_filter_destroy((media_audio_filter_h)_filter);\r
2236                         return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
2237                 }\r
2238         }\r
2239         else\r
2240         {\r
2241                 search_query[0] = ' ';\r
2242         }       \r
2243 \r
2244         snprintf(limit_query,sizeof(limit_query),"%s %d,%d",QUERY_KEYWORD_LIMIT,_filter->offset,_filter->count);\r
2245 \r
2246         snprintf(select_query,sizeof(select_query),"%s", SELECT_MEDIA_ARTIST_LIST);\r
2247 \r
2248 \r
2249         if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_ASC)\r
2250         {\r
2251                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME);\r
2252         }\r
2253         else if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_DESC)\r
2254         {\r
2255                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME,QUERY_KEYWORD_DESC);\r
2256         }\r
2257         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_ASC)\r
2258         {\r
2259                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FIELD_ADDED_TIME);\r
2260         }\r
2261         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_DESC)\r
2262         {\r
2263                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FIELD_ADDED_TIME,QUERY_KEYWORD_DESC);             \r
2264         }\r
2265 \r
2266         if((media_audio_filter_s*)filter != _filter)\r
2267                 media_audio_filter_destroy((media_audio_filter_h)_filter);\r
2268 \r
2269         ret =_content_query_prepare(&stmt,select_query,NULL,search_query,limit_query,order_query);\r
2270         if(ret != MEDIA_CONTENT_ERROR_NONE)\r
2271                 return ret;\r
2272 \r
2273         while( sqlite3_step(stmt) == SQLITE_ROW)\r
2274         {\r
2275                 audio_artist_s* artist = (audio_artist_s*)calloc(1,sizeof(audio_artist_s));\r
2276                 if(artist == NULL)\r
2277                 {\r
2278                         LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
2279                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;       \r
2280                 }\r
2281 \r
2282                 artist->name= strdup((const char *)sqlite3_column_text(stmt, 0));\r
2283                 if(callback((audio_artist_h)artist,user_data) == false)\r
2284                 {\r
2285                         audio_artist_destroy((audio_artist_h)artist);   \r
2286                         break;\r
2287                 }\r
2288                 audio_artist_destroy((audio_artist_h)artist);\r
2289         }\r
2290         if(stmt != NULL)\r
2291         {\r
2292                 sqlite3_finalize(stmt);\r
2293         }\r
2294 \r
2295         return ret;\r
2296 \r
2297 }\r
2298 \r
2299 int audio_artist_foreach_media_from_db(audio_artist_h artist, media_audio_filter_h filter, media_info_cb callback,  void* user_data )\r
2300 {\r
2301         int ret = MEDIA_CONTENT_ERROR_NONE;\r
2302 \r
2303         char limit_query[MIN_QUERY_SIZE];\r
2304         char search_query[MAX_KEYWORD_SIZE];\r
2305         char order_query[MIN_QUERY_SIZE];\r
2306         char select_query[DEFAULT_QUERY_SIZE];  \r
2307 \r
2308         sqlite3_stmt *stmt = NULL;\r
2309         media_audio_filter_s* _filter = NULL;\r
2310 \r
2311         audio_artist_s* _artist = (audio_artist_s*)artist;\r
2312 \r
2313 \r
2314         if(_artist == NULL || callback == NULL)\r
2315         {\r
2316                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
2317                 return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
2318         }\r
2319 \r
2320 \r
2321         if(filter != NULL)\r
2322                  _filter = (media_audio_filter_s*)filter;\r
2323         else\r
2324         {\r
2325                 media_audio_filter_create((media_audio_filter_h*)&_filter);\r
2326         }       \r
2327 \r
2328         memset(limit_query,0x00,sizeof(limit_query));\r
2329         memset(search_query,0x00,sizeof(search_query));\r
2330         memset(order_query,0x00,sizeof(order_query));\r
2331         memset(select_query,0x00,sizeof(select_query));\r
2332 \r
2333         if((_filter->keyword != NULL) && strlen(_filter->keyword) > 0)\r
2334         {\r
2335                 if(strlen(_filter->keyword) < sizeof(search_query))\r
2336                 {\r
2337                         snprintf(search_query,sizeof(search_query)," and display_name like '%%%s%%'", _filter->keyword);\r
2338         \r
2339                 }\r
2340                 else\r
2341                 {\r
2342                         LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
2343                         if((media_audio_filter_s*)filter != _filter)\r
2344                                 media_audio_filter_destroy((media_audio_filter_h)_filter);              \r
2345                         return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
2346                 }\r
2347         }\r
2348         else\r
2349         {\r
2350                 search_query[0] = ' ';\r
2351         }       \r
2352 \r
2353         snprintf(limit_query,sizeof(limit_query),"%s %d,%d",QUERY_KEYWORD_LIMIT,_filter->offset,_filter->count);\r
2354 \r
2355         snprintf(select_query, sizeof(select_query),SELECT_MEDIA_FROM_ARTIST, _artist->name);\r
2356 \r
2357         if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_ASC)\r
2358         {\r
2359                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME);\r
2360         }\r
2361         else if(_filter->order == MEDIA_CONTENT_SORT_BY_NAME_DESC)\r
2362         {\r
2363                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_NAME,QUERY_KEYWORD_DESC);\r
2364         }\r
2365         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_ASC)\r
2366         {\r
2367                 snprintf(order_query,sizeof(order_query),"%s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_MODIFIED_DATE);\r
2368         }\r
2369         else if(_filter->order == MEDIA_CONTENT_SORT_BY_DATE_DESC)\r
2370         {\r
2371                 snprintf(order_query,sizeof(order_query),"%s %s %s",QUERY_KEYWORD_ORDER_BY,DB_FILED_MODIFIED_DATE,QUERY_KEYWORD_DESC);          \r
2372         }       \r
2373 \r
2374         if((media_audio_filter_s*)filter != _filter)\r
2375                 media_audio_filter_destroy((media_audio_filter_h)_filter);\r
2376 \r
2377 \r
2378         ret= _content_query_prepare(&stmt,select_query,NULL,search_query,limit_query,order_query);\r
2379         if(ret != MEDIA_CONTENT_ERROR_NONE)\r
2380                 return ret;\r
2381 \r
2382         while( sqlite3_step(stmt) == SQLITE_ROW)\r
2383         {\r
2384                 media_info_s* item = (media_info_s*)calloc(1,sizeof(media_info_s));\r
2385                 if(item == NULL)\r
2386                 {\r
2387                         LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
2388                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;       \r
2389                 }\r
2390 \r
2391                 _content_item_get_detail(stmt, (media_info_h)item);\r
2392                 if(callback((media_info_h)item,user_data) == false)\r
2393                 {\r
2394                         media_info_destroy((media_info_h)item);\r
2395                         break;\r
2396                 }\r
2397                 media_info_destroy((media_info_h)item);\r
2398         }\r
2399         if(stmt != NULL)\r
2400         {\r
2401                 sqlite3_finalize(stmt);\r
2402         }\r
2403 \r
2404         return ret;\r
2405 \r
2406 \r
2407 }\r
2408 \r
2409 \r
2410 int audio_artist_get_media_count_from_db(audio_artist_h artist,int* count)\r
2411 {\r
2412         int ret = MEDIA_CONTENT_ERROR_NONE;\r
2413         sqlite3_stmt *stmt = NULL;\r
2414         audio_artist_s* _artist = (audio_artist_s*)artist;\r
2415         char select_query[DEFAULT_QUERY_SIZE];  \r
2416 \r
2417         \r
2418         memset(select_query,0x00,sizeof(select_query));\r
2419         if(_artist == NULL)\r
2420         {\r
2421                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
2422                 return  MEDIA_CONTENT_ERROR_INVALID_PARAMETER;\r
2423         }\r
2424 \r
2425         snprintf(select_query,sizeof(select_query),SELECT_MEDIA_COUNT_FROM_ARTIST,_artist ->name);\r
2426 \r
2427         ret = _content_query_prepare(&stmt,select_query,NULL, NULL,NULL,NULL);\r
2428         if(ret != MEDIA_CONTENT_ERROR_NONE)\r
2429                 return ret;\r
2430 \r
2431         while( sqlite3_step(stmt) == SQLITE_ROW)\r
2432         {\r
2433                 *count = (int)sqlite3_column_int(stmt,0);\r
2434         }\r
2435         if(stmt != NULL)\r
2436         {\r
2437                 sqlite3_finalize(stmt);\r
2438         }\r
2439 \r
2440                 \r
2441         return ret;\r
2442 \r
2443 }\r
2444 \r
2445 int audio_artist_destroy(audio_artist_h artist )\r
2446 {\r
2447         int ret;\r
2448         audio_artist_s* _artist = (audio_artist_s*)artist;      \r
2449         if(_artist) \r
2450         {\r
2451                 if(_artist->name) \r
2452                 {\r
2453                         free(_artist->name);\r
2454                 }       \r
2455 \r
2456                 free(_artist);\r
2457                 ret = MEDIA_CONTENT_ERROR_NONE;\r
2458         }\r
2459         else \r
2460         {\r
2461                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
2462                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
2463         }\r
2464         return ret;\r
2465 \r
2466 }\r
2467 \r
2468 int audio_artist_clone(audio_artist_h* dst,audio_artist_h src)\r
2469 {\r
2470         int ret;\r
2471         audio_artist_s* _src = (audio_artist_s*)src;    \r
2472         \r
2473 \r
2474         if(_src != NULL )\r
2475         {\r
2476 \r
2477                 audio_artist_s* _dst = (audio_artist_s*)calloc(1,sizeof(audio_artist_s));               \r
2478 \r
2479                 if(_dst == NULL)\r
2480                 {\r
2481                         LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
2482                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
2483                 }\r
2484 \r
2485                 \r
2486                 if((_src->name != NULL) && (strlen(_src->name) > 0))\r
2487                 {\r
2488                         _dst->name = strdup(_src->name);\r
2489                         if(_dst->name == NULL)\r
2490                         {\r
2491                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
2492                                 audio_artist_destroy((audio_artist_h)_dst);\r
2493                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
2494                         }\r
2495                 }\r
2496 \r
2497                 *dst = (audio_artist_h)_dst;\r
2498                 ret = MEDIA_CONTENT_ERROR_NONE;         \r
2499         }\r
2500         else \r
2501         {\r
2502                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
2503                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
2504         }       \r
2505                 \r
2506         return ret;\r
2507 \r
2508 }\r
2509                 \r
2510 int audio_artist_get_name(audio_artist_h artist, char** name)\r
2511 {\r
2512         int ret;\r
2513         audio_artist_s* _artist = (audio_artist_s*)artist;      \r
2514         if(_artist) \r
2515         {\r
2516                 if((_artist->name!= NULL) && (strlen(_artist->name) > 0))\r
2517                 {\r
2518                         *name = strdup(_artist->name);\r
2519                         if(*name == NULL)\r
2520                         {\r
2521                                 LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);\r
2522                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;\r
2523                         }\r
2524                 }\r
2525                 else\r
2526                 {\r
2527                         *name = NULL;\r
2528                 }\r
2529                 ret = MEDIA_CONTENT_ERROR_NONE;                                 \r
2530 \r
2531         }\r
2532         else \r
2533         {\r
2534                 LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, MEDIA_CONTENT_ERROR_INVALID_PARAMETER);\r
2535                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER ;\r
2536         }       \r
2537 \r
2538         return ret;\r
2539 }\r
2540 \r