src/Content/ContentHelper.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include <glib.h>
  19 #include <list>
  20
  21 #include <Export.h>
  22 #include <Logger.h>
  23 #include <JSWebAPIError.h>
  24 #include <Commons/StringUtils.h>
  25 #include <GlobalContextManager.h>
  26
  27 #include "ContentUtility.h"
  28 #include "ContentHelper.h"
  29
  30 #include "ContentGetDirectoryCallback.h"
  31 #include "ContentScanFileCallback.h"
  32 #include "ContentFindCallback.h"
  33 #include "ContentFilterQueryGenerator.h"
  34 #include "ContentUpdateBatchCallback.h"
  35 #include "ContentChangeCallback.h"
  36 #include <TimeTracer.h>
  37
  38
  39
  40 using namespace WrtDeviceApis::Commons;
  41
  42 namespace DeviceAPI {
  43 namespace Content {
  44
  45 #define TAG_DELIMETER '/'
  46 #define UNDEFINED_GEO -200.0
  47
  48 ContentHelper::ContentHelper()
  49 {
  50 }
  51
  52 ContentHelper::~ContentHelper()
  53 {
  54 }
  55
  56 bool ContentHelper::Connect()
  57 {
  58     bool ret = false;
  59     int err = media_content_connect();
  60     if( MEDIA_CONTENT_ERROR_NONE == err)
  61     {
  62         LOGI("Content DB is connected.");
  63         ret =  true;
  64     }
  65     else {
  66         LOGE("%s", ContentUtility::getMediaContentLogMessage(
  67                 err, "media_content_connect()").c_str());
  68     }
  69     return ret;
  70
  71 }
  72 bool ContentHelper::DisConnect()
  73 {
  74     bool ret = false;
  75     int err = media_content_disconnect();
  76     if ( MEDIA_CONTENT_ERROR_NONE == err)
  77     {
  78         LOGI("Content DB is disconnected.");
  79         ret =  true;
  80     } else {
  81         LOGE("%s", ContentUtility::getMediaContentLogMessage(
  82                 err, "media_content_disconnect()").c_str());
  83     }
  84     return ret;
  85
  86 }
  87
  88 int ContentHelper::getCallbackCompleted(void *data)
  89 {
  90     ContentCallbackPtr callbackPtr(static_cast<ContentCallback*>(data));
  91     try
  92     {
  93         callbackPtr->onSuccess();
  94     }
  95     catch(...)
  96     {
  97         callbackPtr->onError("This operation is failed by platform.");
  98     }
  99
 100     LOGI("getCallbackCompleted");
 101     return false;
 102 }
 103
 104 int ContentHelper::getCallbackCanceled(void *data)
 105 {
 106     ContentCallbackPtr callbackPtr(static_cast<ContentCallback*>(data));
 107
 108     callbackPtr->onError();
 109     return false;
 110 }
 111
 112 gboolean ContentHelper::getDirectoryWork(void* data)
 113 {
 114     ContentGetDirectoryCallback* callback = static_cast<ContentGetDirectoryCallback*>(data);
 115     DirectoryLst *directories = callback->getDirectories();
 116
 117     filter_h filter = NULL;
 118     TIME_TRACER_ITEM_BEGIN("getDirectoriesPlatform", 1);
 119     int err = media_filter_create(&filter);
 120     if ( MEDIA_CONTENT_ERROR_NONE == err)
 121     {
 122         std::string condition="(FOLDER_STORAGE_TYPE = 0 OR FOLDER_STORAGE_TYPE = 1)";
 123         //set condition
 124         err = media_filter_set_condition(filter, condition.c_str(), MEDIA_CONTENT_COLLATE_DEFAULT);
 125         if ( MEDIA_CONTENT_ERROR_NONE != err)
 126         {
 127             LOGW("%s", ContentUtility::getMediaContentLogMessage(
 128                     err, "media_filter_set_condition()").c_str());
 129         }
 130
 131         err = media_folder_foreach_folder_from_db(filter, ContentHelper::getDirectoryCallback, directories);
 132         if( MEDIA_CONTENT_ERROR_NONE == err)
 133         {
 134             TIME_TRACER_ITEM_END("getDirectoriesPlatform", 1);
 135             if (G_IDLE_FAILED == g_idle_add(ContentHelper::getCallbackCompleted, callback)) {
 136                 delete callback;
 137                 callback = NULL;
 138                 LOGE("g_idle addition failed");
 139             }
 140         }
 141         else
 142         {
 143             LOGW("%s", ContentUtility::getMediaContentLogMessage(
 144                     err, "media_folder_foreach_folder_from_db()").c_str());
 145
 146             callback->setErrMsg("getDirectoryWork() is failed");
 147             if (G_IDLE_FAILED == g_idle_add(ContentHelper::getCallbackCanceled, callback)) {
 148                 delete callback;
 149                 callback = NULL;
 150                 LOGE("g_idle addition failed");
 151             }
 152         }
 153
 154         err = media_filter_destroy(filter);
 155         if ( MEDIA_CONTENT_ERROR_NONE != err)
 156         {
 157             LOGW("%s", ContentUtility::getMediaContentLogMessage(
 158                     err, "media_filter_destroy()").c_str());
 159         }
 160     }
 161     else
 162     {
 163         LOGE("%s", ContentUtility::getMediaContentLogMessage(
 164                 err, "media_filter_create()").c_str());
 165     }
 166     return false;
 167 }
 168
 169
 170 bool ContentHelper::getDirectoryCallback(media_folder_h folder, void *user_data)
 171 {
 172     int err;
 173     if (user_data != NULL) {
 174         if (folder != NULL) {
 175             char *str = NULL;
 176             ContentDirectoryPtr dirPtr = ContentDirectoryPtr(new ContentDirectory());
 177
 178             err = media_folder_get_folder_id(folder, &str);
 179             if (MEDIA_CONTENT_ERROR_NONE == err) {
 180                 if (str) {
 181                     dirPtr->setId(str);
 182                     free(str);
 183                     str = NULL;
 184                 }
 185             }
 186             else
 187             {
 188                 LOGE("%s", ContentUtility::getMediaContentLogMessage(
 189                         err, "media_folder_get_folder_id()").c_str());
 190             }
 191
 192             err = media_folder_get_path(folder, &str);
 193             if (MEDIA_CONTENT_ERROR_NONE == err) {
 194                 if (str) {
 195                     dirPtr->setDirectoryURI(str);
 196                     free(str);
 197                     str = NULL;
 198                 }
 199             }
 200             else
 201             {
 202                 LOGE("%s", ContentUtility::getMediaContentLogMessage(
 203                         err, "media_folder_get_path()").c_str());
 204             }
 205
 206             err = media_folder_get_name(folder, &str);
 207             if (MEDIA_CONTENT_ERROR_NONE == err) {
 208                 if (str) {
 209                     dirPtr->setTitle(str);
 210                     free(str);
 211                     str = NULL;
 212                 }
 213             }
 214             else
 215             {
 216                 LOGE("%s", ContentUtility::getMediaContentLogMessage(
 217                         err, "media_folder_get_name()").c_str());
 218             }
 219
 220             {
 221                 time_t date;
 222                 err = media_folder_get_modified_time(folder, &date);
 223                 if (MEDIA_CONTENT_ERROR_NONE == err) {
 224                     dirPtr->setModifiedDate(date);
 225                 }
 226                 else
 227                 {
 228                     LOGE("%s", ContentUtility::getMediaContentLogMessage(
 229                             err, "media_folder_get_modified_time()").c_str());
 230                 }
 231             }
 232             {
 233                 media_content_storage_e storageType;
 234                 err = media_folder_get_storage_type(folder, &storageType);
 235                 if (MEDIA_CONTENT_ERROR_NONE == err) {
 236                     if (storageType == MEDIA_CONTENT_STORAGE_INTERNAL) {
 237                         dirPtr->setStorageType("INTERNAL");
 238                     }
 239                     else if (storageType == MEDIA_CONTENT_STORAGE_EXTERNAL) {
 240                         dirPtr->setStorageType("EXTERNAL");
 241                     }
 242                 }
 243                 else
 244                 {
 245                     LOGE("%s", ContentUtility::getMediaContentLogMessage(
 246                             err, "media_folder_get_storage_type()").c_str());
 247                 }
 248             }
 249
 250             if (DirectoryLst* directories = static_cast<DirectoryLst*>(user_data)) {
 251                 directories->push_back(dirPtr);
 252             }
 253             else {
 254                 LOGE("User data is invalid.");
 255             }
 256         }
 257         else {
 258             LOGE("Get Directories Iterator is failed.");
 259             //return false;
 260         }
 261     }
 262     else {
 263         LOGD("user data is NULL");
 264         //return false;
 265     }
 266     return true;
 267 }
 268
 269
 270 gboolean ContentHelper::scanFileWork(void* data)
 271 {
 272     LOGD("Entered");
 273     ContentScanFileCallback* callback = static_cast<ContentScanFileCallback*>(data);
 274     std::string uri = callback->getContentURI();
 275
 276     TIME_TRACER_ITEM_BEGIN("scanFilePlatform", 1);
 277
 278     int err = media_content_scan_file(uri.c_str());
 279     if( MEDIA_CONTENT_ERROR_NONE == err)
 280     {
 281         TIME_TRACER_ITEM_END("scanFilePlatform", 1);
 282         if (G_IDLE_FAILED == g_idle_add(ContentHelper::getCallbackCompleted, callback)) {
 283             delete callback;
 284             callback = NULL;
 285             LOGE("g_idle addition failed");
 286         }
 287     }
 288     else
 289     {
 290         LOGE("%s", ContentUtility::getMediaContentLogMessage(
 291                 err, "media_content_scan_file()").c_str());
 292         callback->setErrMsg("scanFile operation is failed.");
 293         if (G_IDLE_FAILED == g_idle_add(ContentHelper::getCallbackCanceled, callback)) {
 294             delete callback;
 295             callback = NULL;
 296             LOGE("g_idle addition failed");
 297         }
 298     }
 299     return false;
 300 }
 301
 302 gboolean ContentHelper::findWork(void* data)
 303 {
 304     ContentFindCallback* callback = static_cast<ContentFindCallback*>(data);
 305     ContentLst *contents = callback->getContents();
 306
 307     TIME_TRACER_ITEM_BEGIN("findPlatform", 1);
 308     int err;
 309     try
 310     {
 311
 312         filter_h filter = NULL;
 313         err = media_filter_create(&filter);
 314         if ( MEDIA_CONTENT_ERROR_NONE == err)
 315         {
 316             std::shared_ptr<ContentFilterQueryGenerator> query(new ContentFilterQueryGenerator());
 317             std::string condition;
 318             AbstractFilterPtr& jsfilter = callback->getFilter();
 319
 320             if(jsfilter)
 321             {
 322                 query->generate(jsfilter);
 323                 condition = query->getResult();
 324                 err = media_filter_set_condition(
 325                         filter, condition.c_str(), MEDIA_CONTENT_COLLATE_DEFAULT);
 326                 if (MEDIA_CONTENT_ERROR_NONE != err)
 327                 {
 328                     LOGE("ret: %d", err);
 329                     ContentUtility::throwMediaContentException<Common::UnknownException>(
 330                             err, "media_filter_set_condition()");
 331                 }
 332             }
 333
 334             SortModePtr& jssortMode = callback->getSortMode();
 335             if(jssortMode)
 336             {
 337                 media_content_order_e order = MEDIA_CONTENT_ORDER_ASC;
 338                 std::string attrName = query->getPlatformAttr(jssortMode->getAttributeName());
 339                 if(jssortMode->getOrder() == Tizen::ASC)
 340                 {
 341                     order = MEDIA_CONTENT_ORDER_ASC;
 342                 }
 343                 else if(jssortMode->getOrder() == Tizen::DESC)
 344                 {
 345                     order = MEDIA_CONTENT_ORDER_DESC;
 346                 }
 347                 else
 348                 {
 349                     throw Common::UnknownException("SortMode is invalid value.");
 350                 }
 351
 352                 err = media_filter_set_order(
 353                         filter, order, attrName.c_str(), MEDIA_CONTENT_COLLATE_DEFAULT);
 354                 if (MEDIA_CONTENT_ERROR_NONE != err)
 355                 {
 356                     LOGE("ret: %d", err);
 357                     ContentUtility::throwMediaContentException<Common::UnknownException>(
 358                             err, "media_filter_set_order()");
 359                 }
 360             }
 361
 362             int count = callback->getCount();
 363             int offset = callback->getOffset();
 364
 365             err = media_filter_set_offset(filter, offset, count);
 366             if ( MEDIA_CONTENT_ERROR_NONE != err)
 367             {
 368                 LOGE("ret: %d", err);
 369                 ContentUtility::throwMediaContentException<Common::UnknownException>(
 370                         err, "media_filter_set_offset()");
 371             }
 372
 373             if(callback->getDirectoryId().empty())
 374             {
 375                 err = media_info_foreach_media_from_db(filter,findCallback, contents);
 376                 if( MEDIA_CONTENT_ERROR_NONE != err)
 377                 {
 378                     LOGE("ret: %d", err);
 379                     ContentUtility::throwMediaContentException<Common::UnknownException>(
 380                             err, "media_info_foreach_media_from_db()");
 381                 }
 382             }
 383             else
 384             {
 385                 err = media_folder_foreach_media_from_db(
 386                         callback->getDirectoryId().c_str(),
 387                         filter,
 388                         findCallback,
 389                         contents);
 390                 if( MEDIA_CONTENT_ERROR_NONE != err)
 391                 {
 392                     LOGE("ret: %d", err);
 393                     ContentUtility::throwMediaContentException<Common::UnknownException>(
 394                             err, "media_folder_foreach_media_from_db()");
 395                 }
 396             }
 397             TIME_TRACER_ITEM_END("findPlatform", 1);
 398             if (G_IDLE_FAILED == g_idle_add(ContentHelper::getCallbackCompleted, callback)) {
 399                 delete callback;
 400                 callback = NULL;
 401                 LOGE("g_idle addition failed");
 402             }
 403         }
 404         else
 405         {
 406             LOGE("ret: %d", err);
 407             ContentUtility::throwMediaContentException<Common::UnknownException>(
 408                     err, "media_filter_create()");
 409         }
 410
 411         int ret = media_filter_destroy(filter);
 412         if ( MEDIA_CONTENT_ERROR_NONE != ret){
 413             LOGE("%s", ContentUtility::getMediaContentLogMessage(
 414                     ret, "media_filter_destroy()").c_str());
 415         }
 416     }
 417     catch (const BasePlatformException &err) {
 418         callback->setErrMsg(err.getMessage().c_str());
 419         if (G_IDLE_FAILED == g_idle_add(ContentHelper::getCallbackCanceled, callback)) {
 420             delete callback;
 421             callback = NULL;
 422             LOGE("g_idle addition failed");
 423         }
 424     }
 425
 426     return false;
 427 }
 428
 429 bool ContentHelper::findCallback(media_info_h info, void *user_data)
 430 {
 431     int err;
 432     if (user_data != NULL) {
 433         if (info != NULL) {
 434             ContentLst* contents = static_cast<ContentLst*>(user_data);
 435
 436             media_content_type_e type;
 437
 438             err = media_info_get_media_type(info, &type);
 439             if (MEDIA_CONTENT_ERROR_NONE
 440                     == err) {
 441                 if (type == MEDIA_CONTENT_TYPE_IMAGE) {
 442                     ImageContentPtr image = ImageContentPtr(new ImageContent());
 443                     ContentHelper::loadImageContentFromPlatform(info, image);
 444                     contents->push_back(image);
 445                 }
 446                 else if (type == MEDIA_CONTENT_TYPE_VIDEO) {
 447                     VideoContentPtr video = VideoContentPtr(new VideoContent());
 448                     ContentHelper::loadVideoContentFromPlatform(info, video);
 449                     contents->push_back(video);
 450                 }
 451                 else if (type == MEDIA_CONTENT_TYPE_MUSIC) {
 452                     AudioContentPtr audio = AudioContentPtr(new AudioContent());
 453                     ContentHelper::loadAudioContentFromPlatform(info, audio);
 454                     contents->push_back(audio);
 455                 }
 456                 else if (type == MEDIA_CONTENT_TYPE_OTHERS) {
 457                     ContentPtr content = ContentPtr(new Content());
 458                     ContentHelper::loadContentFromPlatform(info, content);
 459                     contents->push_back(content);
 460                 }
 461             }
 462             else
 463             {
 464                 LOGW("%s", ContentUtility::getMediaContentLogMessage(
 465                         err, "media_info_get_media_type()").c_str());
 466             }
 467         }
 468         else {
 469             LOGE("content handle is not valid.");
 470             //return false;
 471         }
 472     }
 473     else {
 474         LOGD("user data is NULL");
 475         //return false;
 476     }
 477     return true;
 478 }
 479
 480 bool ContentHelper::update(ContentPtr content)
 481 {
 482     bool ret = false;
 483     TIME_TRACER_ITEM_BEGIN("updatePlatform", 1);
 484     ret = updateContentToPlatform(content);
 485     TIME_TRACER_ITEM_END("updatePlatform", 1);
 486
 487     return ret;
 488 }
 489
 490 gboolean ContentHelper::updateBatchWork(void* data)
 491 {
 492     ContentUpdateBatchCallback* callback = static_cast<ContentUpdateBatchCallback*>(data);
 493     ContentLst *contents = callback->getContents();
 494
 495     TIME_TRACER_ITEM_BEGIN("updateBatchPlatform", 1);
 496
 497     if(!(contents->empty()))
 498     {
 499         for(unsigned int i = 0 ; i < contents->size(); i++)
 500         {
 501             updateContentToPlatform(contents->at(i));
 502         }
 503         TIME_TRACER_ITEM_END("updateBatchPlatform", 1);
 504         if (G_IDLE_FAILED == g_idle_add(ContentHelper::getCallbackCompleted, callback)) {
 505             delete callback;
 506             callback = NULL;
 507             LOGE("g_idle addition failed");
 508         }
 509     }
 510     else
 511     {
 512         callback->setErrMsg("The Private object is null.");
 513
 514         if (G_IDLE_FAILED == g_idle_add(ContentHelper::getCallbackCanceled, callback)) {
 515             delete callback;
 516             callback = NULL;
 517             LOGE("g_idle addition failed");
 518         }
 519     }
 520
 521     return false;
 522 }
 523
 524 bool ContentHelper::updateContentToPlatform(ContentPtr content)
 525 {
 526
 527     bool ret = true;
 528     int err;
 529
 530     std::string id = content->getId();
 531     if(!id.empty())
 532     {
 533         media_info_h info = NULL;
 534         err = media_info_get_media_from_db(id.c_str(), &info);
 535         if(MEDIA_CONTENT_ERROR_NONE == err)
 536         {
 537             err = media_info_set_rating(info, content->getRating());
 538             if(MEDIA_CONTENT_ERROR_NONE != err)
 539             {
 540                 LOGE("%s", ContentUtility::getMediaContentLogMessage(
 541                         err, "media_info_set_rating()").c_str());
 542             }
 543
 544             err = media_info_set_description (info, content->getDescription().c_str());
 545             if(MEDIA_CONTENT_ERROR_NONE != err)
 546             {
 547                 LOGE("%s", ContentUtility::getMediaContentLogMessage(
 548                         err, "media_info_set_description()").c_str());
 549             }
 550
 551             err = media_info_set_display_name (info, content->getName().c_str());
 552             if(MEDIA_CONTENT_ERROR_NONE != err)
 553             {
 554                 LOGE("%s", ContentUtility::getMediaContentLogMessage(
 555                         err, "media_info_set_display_name()").c_str());
 556             }
 557
 558             err = media_info_set_favorite (info, content->getIsFavorite());
 559             if(MEDIA_CONTENT_ERROR_NONE != err)
 560             {
 561                 LOGE("%s", ContentUtility::getMediaContentLogMessage(
 562                         err, "media_info_set_favorite()").c_str());
 563             }
 564
 565             if(content->getType().compare("IMAGE") == 0)
 566             {
 567                 image_meta_h img=NULL;
 568                 ImageContentPtr imagePtr = std::dynamic_pointer_cast<ImageContent>(content);
 569                 if(imagePtr)
 570                 {
 571                     err = media_info_get_image(info, &img);
 572                     if(MEDIA_CONTENT_ERROR_NONE == err)
 573                     {
 574                         err = image_meta_set_orientation(img, imagePtr->getOrientationEnum());
 575                         if(MEDIA_CONTENT_ERROR_NONE != err)
 576                         {
 577                             LOGE("%s", ContentUtility::getMediaContentLogMessage(
 578                                     err, "image_meta_set_orientation()").c_str());
 579                         }
 580
 581                         double latitude = UNDEFINED_GEO;
 582                         double longitude = UNDEFINED_GEO;
 583                         if (imagePtr->isGeolocationSet()) {
 584                             latitude = imagePtr->getLatitude();
 585                             longitude = imagePtr->getLongitude();
 586                         }
 587
 588                         err = media_info_set_latitude(info, latitude);
 589                         if(MEDIA_CONTENT_ERROR_NONE != err)
 590                         {
 591                             LOGE("%s", ContentUtility::getMediaContentLogMessage(
 592                                     err, "media_info_set_latitude()").c_str());
 593                         }
 594
 595                         err = media_info_set_longitude(info, longitude);
 596                         if(MEDIA_CONTENT_ERROR_NONE != err)
 597                         {
 598                             LOGE("%s", ContentUtility::getMediaContentLogMessage(
 599                                     err, "media_info_set_longitude()").c_str());
 600                         }
 601
 602                         err = image_meta_update_to_db(img);
 603                         if(MEDIA_CONTENT_ERROR_NONE != err)
 604                         {
 605                             LOGE("%s", ContentUtility::getMediaContentLogMessage(
 606                                     err, "image_meta_update_to_db()").c_str());
 607                             ret = false;
 608                         }
 609
 610                         err = image_meta_destroy(img);
 611                         if ( MEDIA_CONTENT_ERROR_NONE != err)
 612                         {
 613                             LOGE("%s", ContentUtility::getMediaContentLogMessage(
 614                                     err, "image_meta_destroy()").c_str());
 615                         }
 616                     }
 617                     else
 618                     {
 619                         LOGE("%s", ContentUtility::getMediaContentLogMessage(
 620                                 err, "media_info_get_image()").c_str());
 621                     }
 622                 }
 623             }
 624             if(content->getType().compare("VIDEO") == 0)
 625             {
 626                 video_meta_h video = NULL;
 627                 VideoContentPtr videoPtr = std::dynamic_pointer_cast<VideoContent>(content);
 628                 if(videoPtr)
 629                 {
 630                     err = media_info_get_video(info, &video);
 631                     if ( MEDIA_CONTENT_ERROR_NONE == err)
 632                     {
 633                         double latitude = UNDEFINED_GEO;
 634                         double longitude = UNDEFINED_GEO;
 635                         if (videoPtr->isGeolocationSet()) {
 636                             latitude = videoPtr->getLatitude();
 637                             longitude = videoPtr->getLongitude();
 638                         }
 639
 640                         err = media_info_set_latitude(info, latitude);
 641                         if(MEDIA_CONTENT_ERROR_NONE != err)
 642                         {
 643                             LOGE("%s", ContentUtility::getMediaContentLogMessage(
 644                                     err, "media_info_set_latitude()").c_str());
 645                         }
 646
 647                         err = media_info_set_longitude(info, longitude);
 648                         if(MEDIA_CONTENT_ERROR_NONE != err)
 649                         {
 650                             LOGE("%s", ContentUtility::getMediaContentLogMessage(
 651                                     err, "media_info_set_longitude()").c_str());
 652                         }
 653
 654                         err = video_meta_update_to_db(video);
 655                         if(MEDIA_CONTENT_ERROR_NONE != err)
 656                         {
 657                             LOGE("%s", ContentUtility::getMediaContentLogMessage(
 658                                     err, "video_meta_update_to_db()").c_str());
 659                             ret = false;
 660                         }
 661
 662                         err = video_meta_destroy(video);
 663                         if(MEDIA_CONTENT_ERROR_NONE != err)
 664                         {
 665                             LOGE("%s", ContentUtility::getMediaContentLogMessage(
 666                                     err, "video_meta_destroy()").c_str());
 667                         }
 668                     }
 669                     else
 670                     {
 671                         LOGW("%s", ContentUtility::getMediaContentLogMessage(
 672                                 err, "media_info_get_video()").c_str());
 673                     }
 674                 }
 675             }
 676
 677             err = media_info_update_to_db(info);
 678             if(MEDIA_CONTENT_ERROR_NONE != err)
 679             {
 680                 LOGE("%s", ContentUtility::getMediaContentLogMessage(
 681                         err, "media_info_update_to_db()").c_str());
 682                 ret = false;
 683             }
 684         }
 685         else
 686         {
 687             LOGW("%s", ContentUtility::getMediaContentLogMessage(
 688                     err, "media_info_get_media_from_db()").c_str());
 689         }
 690         int error = media_info_destroy(info);
 691         if (error != MEDIA_CONTENT_ERROR_NONE) {
 692             LOGE("%s", ContentUtility::getMediaContentLogMessage(
 693                     error, "media_info_destroy()").c_str());
 694         }
 695     }
 696
 697     return ret;
 698 }
 699
 700
 701
 702 void ContentHelper::changeCallbackWork(
 703         media_content_error_e error,
 704         int pid,
 705         media_content_db_update_item_type_e update_item,
 706         media_content_db_update_type_e update_type,
 707         media_content_type_e media_type,
 708         char *uuid,
 709         char *path,
 710         char *mime_type,
 711         void *user_data)
 712 {
 713     ContentChangeCallbackPtrList listener = *(ContentChangeCallbackPtrList*)user_data;
 714     std::string err_msg;
 715     int err;
 716     if( error == MEDIA_CONTENT_ERROR_NONE)
 717     {
 718
 719         err_msg = "";
 720         if( update_item == MEDIA_ITEM_FILE)
 721         {
 722             std::string condition = "MEDIA_ID=\"";
 723             condition += uuid;
 724             condition += "\"";
 725
 726             ContentPtr content;
 727             if(update_type == MEDIA_CONTENT_INSERT ||
 728                     update_type == MEDIA_CONTENT_UPDATE) {
 729
 730                 filter_h filter = NULL;
 731                 err = media_filter_create(&filter);
 732                 if (MEDIA_CONTENT_ERROR_NONE == err) {
 733
 734                     err = media_filter_set_condition(filter, condition.c_str(),
 735                             MEDIA_CONTENT_COLLATE_DEFAULT);
 736                     if ( MEDIA_CONTENT_ERROR_NONE != err)
 737                     {
 738                         LOGW("%s", ContentUtility::getMediaContentLogMessage(
 739                                 err, "media_filter_set_condition()").c_str());
 740                     }
 741
 742                     if(media_type == MEDIA_CONTENT_TYPE_IMAGE) {
 743                         content = ContentPtr(new ImageContent());
 744                     }
 745                     else if(media_type == MEDIA_CONTENT_TYPE_VIDEO) {
 746                         content = ContentPtr(new VideoContent());
 747                     }
 748                     else if(media_type == MEDIA_CONTENT_TYPE_SOUND ||
 749                             media_type == MEDIA_CONTENT_TYPE_MUSIC) {
 750                         content = ContentPtr(new AudioContent());
 751                     }
 752                     else {
 753                         content = ContentPtr(new Content());
 754                     }
 755
 756                     ContentHolder* content_ptr_holder = new ContentHolder();
 757                     content_ptr_holder->ptr = content;
 758
 759                     err = media_info_foreach_media_from_db(
 760                             filter, loadContent, (void*)content_ptr_holder);
 761                     if( MEDIA_CONTENT_ERROR_NONE == err) {
 762
 763                         content->setContentURI(ContentUtility::convertPathToUri(content->getContentURI()));
 764                         ContentChangeCallbackPtrList::iterator itr = listener.begin();
 765                         while( itr != listener.end() ) {
 766                             ContentChangeCallbackPtr callback = *itr;
 767                             if(callback) {
 768                                 if(!GlobalContextManager::getInstance()->isAliveGlobalContext(
 769                                         callback->getContext())) {
 770                                     LOGW("context was closed, so skip");
 771                                     ++itr;
 772                                     continue;
 773                                 }
 774
 775                                 if(update_type == MEDIA_CONTENT_INSERT) {
 776                                     callback->oncontentadded(content);
 777                                 }
 778                                 else {
 779                                     callback->oncontentupdated(content);
 780                                 }
 781                             }
 782                             ++itr;
 783                         }
 784                     }
 785                     else {
 786                         delete content_ptr_holder;
 787                         content_ptr_holder = NULL;
 788
 789                         LOGW("%s", ContentUtility::getMediaContentLogMessage(
 790                                 err, "media_info_foreach_media_from_db()").c_str());
 791
 792                     }
 793                     err = media_filter_destroy(filter);
 794                     if (MEDIA_CONTENT_ERROR_NONE != err) {
 795                         LOGW("%s", ContentUtility::getMediaContentLogMessage(
 796                                 err, "media_filter_destroy()").c_str());
 797                     }
 798                 }
 799                 else
 800                 {
 801                     LOGW("%s", ContentUtility::getMediaContentLogMessage(
 802                             err, "media_filter_create()").c_str());
 803                 }
 804             }
 805             else if(update_type == MEDIA_CONTENT_DELETE)
 806             {
 807                 ContentChangeCallbackPtrList::iterator itr = listener.begin();
 808                 while( itr != listener.end() ) {
 809                     ContentChangeCallbackPtr callback = *itr;
 810                     if(callback) {
 811                         if(!GlobalContextManager::getInstance()->isAliveGlobalContext(
 812                                 callback->getContext())) {
 813                             LOGW("context was closed, so skip");
 814                             ++itr;
 815                             continue;
 816                         }
 817
 818                         callback->oncontentremoved(uuid);
 819                     }
 820                     ++itr;
 821                 }
 822             }
 823         }
 824     }
 825     else
 826     {
 827         LOGW("%s", ContentUtility::getMediaContentLogMessage(
 828                 error, "media_content_set_db_updated_cb()").c_str());
 829     }
 830
 831 }
 832
 833
 834
 835 int ContentHelper::get_utc_offset()
 836 {
 837     time_t zero = 24*60*60L;
 838     struct tm * timeptr;
 839     int gmtime_hours;
 840
 841     /* get the local time for Jan 2, 1900 00:00 UTC */
 842     timeptr = localtime( &zero );
 843     gmtime_hours = timeptr->tm_hour;
 844
 845     /* if the local time is the "day before" the UTC, subtract 24 hours
 846     from the hours to get the UTC offset */
 847     if( timeptr->tm_mday < 2 )
 848         gmtime_hours -= 24;
 849
 850     return gmtime_hours;
 851
 852 }
 853
 854 bool ContentHelper::loadContent(media_info_h info, void* user_data)
 855 {
 856     ContentHolder* hold = static_cast<ContentHolder*>(user_data);
 857     media_content_type_e type;
 858
 859     int err;
 860     err = media_info_get_media_type(info, &type);
 861     if ( MEDIA_CONTENT_ERROR_NONE == err) {
 862         if ( type == MEDIA_CONTENT_TYPE_IMAGE) {
 863             loadImageContentFromPlatform(info,
 864                     std::dynamic_pointer_cast<ImageContent>(hold->ptr));
 865         }
 866         else if ( type == MEDIA_CONTENT_TYPE_VIDEO) {
 867             loadVideoContentFromPlatform(info,
 868                     std::dynamic_pointer_cast<VideoContent>(hold->ptr));
 869         }
 870         else if ( type == MEDIA_CONTENT_TYPE_MUSIC || type == MEDIA_CONTENT_TYPE_SOUND) {
 871             loadAudioContentFromPlatform(info,
 872                     std::dynamic_pointer_cast<AudioContent>(hold->ptr));
 873         }
 874         else if( type == MEDIA_CONTENT_TYPE_OTHERS) {
 875             loadContentFromPlatform(info, hold->ptr);
 876         }
 877     }
 878     else
 879     {
 880         LOGE("%s", ContentUtility::getMediaContentLogMessage(
 881                 err, "media_info_get_media_type()").c_str());
 882     }
 883
 884     delete hold;
 885     hold = NULL;
 886     return false;
 887 }
 888
 889 void ContentHelper::loadContentFromPlatform(media_info_h info, ContentPtr content)
 890 {
 891     if(!content)
 892     {
 893         LOGE("Content creation is failed.");
 894         return;
 895     }
 896
 897     if(info == NULL)
 898     {
 899         LOGE("find operation is failed.");
 900         return;
 901     }
 902
 903     char* tmpStr = NULL;
 904     int tmpInt = 0;
 905     unsigned long long tmplong = 0;
 906     bool tmpBool = false;
 907
 908     time_t tmpDate;
 909
 910
 911     int err = media_info_get_media_id(info, &tmpStr);
 912     if(MEDIA_CONTENT_ERROR_NONE == err)
 913     {
 914         if(tmpStr)
 915         {
 916             content->setId(tmpStr);
 917             free(tmpStr);
 918             tmpStr = NULL;
 919         }
 920     }
 921     else
 922     {
 923         LOGW("%s", ContentUtility::getMediaContentLogMessage(
 924                 err, "media_info_get_media_id()").c_str());
 925     }
 926
 927     err = media_info_get_mime_type(info, &tmpStr);
 928     if(MEDIA_CONTENT_ERROR_NONE == err)
 929     {
 930         if(tmpStr)
 931         {
 932             content->setMimeType(tmpStr);
 933             free(tmpStr);
 934             tmpStr = NULL;
 935         }
 936     }
 937     else
 938     {
 939         LOGW("%s", ContentUtility::getMediaContentLogMessage(
 940                 err, "media_info_get_mime_type()").c_str());
 941     }
 942
 943     err = media_info_get_display_name(info, &tmpStr);
 944     if(MEDIA_CONTENT_ERROR_NONE == err)
 945     {
 946         if(tmpStr)
 947         {
 948             content->setName(tmpStr);
 949             free(tmpStr);
 950             tmpStr = NULL;
 951         }
 952     }
 953     else
 954     {
 955         LOGW("%s", ContentUtility::getMediaContentLogMessage(
 956                 err, "media_info_get_display_name()").c_str());
 957     }
 958
 959     err = media_info_get_title(info, &tmpStr);
 960     if (MEDIA_CONTENT_ERROR_NONE == err)
 961     {
 962         if (tmpStr)
 963         {
 964             content->setTitle(tmpStr);
 965             free(tmpStr);
 966             tmpStr = NULL;
 967         }
 968     }
 969     else
 970     {
 971         LOGW("%s", ContentUtility::getMediaContentLogMessage(
 972                 err, "media_info_get_title()").c_str());
 973     }
 974
 975     err = media_info_get_file_path(info, &tmpStr);
 976     if(MEDIA_CONTENT_ERROR_NONE == err)
 977     {
 978         if(tmpStr)
 979         {
 980             content->setContentURI(ContentUtility::convertPathToUri(tmpStr));
 981             free(tmpStr);
 982             tmpStr = NULL;
 983         }
 984     }
 985     else
 986     {
 987         LOGW("%s", ContentUtility::getMediaContentLogMessage(
 988                 err, "media_info_get_file_path()").c_str());
 989     }
 990
 991     err = media_info_get_thumbnail_path (info, &tmpStr);
 992     if(MEDIA_CONTENT_ERROR_NONE == err)
 993     {
 994         if(tmpStr)
 995         {
 996             std::vector<std::string> thumbnailURIs;
 997             thumbnailURIs.push_back(ContentUtility::convertPathToUri(tmpStr));
 998             content->setThumbnailURIs(thumbnailURIs);
 999             free(tmpStr);
1000             tmpStr = NULL;
1001         }
1002     }
1003     else
1004     {
1005         LOGW("%s", ContentUtility::getMediaContentLogMessage(
1006                 err, "media_info_get_thumbnail_path()").c_str());
1007     }
1008
1009     err = media_info_get_description(info, &tmpStr);
1010     if(MEDIA_CONTENT_ERROR_NONE == err)
1011     {
1012         if(tmpStr)
1013         {
1014             content->setDescription(tmpStr);
1015             free(tmpStr);
1016             tmpStr = NULL;
1017         }
1018     }
1019     else
1020     {
1021         LOGW("%s", ContentUtility::getMediaContentLogMessage(
1022                 err, "media_info_get_description()").c_str());
1023     }
1024
1025     err = media_info_get_modified_time(info, &tmpDate);
1026     if(MEDIA_CONTENT_ERROR_NONE == err)
1027     {
1028         if(tmpDate)
1029         {
1030             content->setModifiedDate(tmpDate);
1031         }
1032     }
1033     else
1034     {
1035         LOGW("%s", ContentUtility::getMediaContentLogMessage(
1036                 err, "media_info_get_modified_time()").c_str());
1037     }
1038
1039     err = media_info_get_rating(info, &tmpInt);
1040     if(MEDIA_CONTENT_ERROR_NONE == err)
1041     {
1042         content->setRating(tmpInt);
1043     }
1044     else
1045     {
1046         LOGW("%s", ContentUtility::getMediaContentLogMessage(
1047                 err, "media_info_get_rating()").c_str());
1048     }
1049
1050     err = media_info_get_favorite(info, &tmpBool);
1051     if(MEDIA_CONTENT_ERROR_NONE == err)
1052     {
1053         content->setIsFavorite(tmpBool);
1054     }
1055     else
1056     {
1057         LOGW("%s", ContentUtility::getMediaContentLogMessage(
1058                 err, "media_info_get_favorite()").c_str());
1059     }
1060
1061     err = media_info_get_size(info, &tmplong);
1062     if(MEDIA_CONTENT_ERROR_NONE == err)
1063     {
1064         content->setSize(tmplong);
1065     }
1066     else
1067     {
1068         LOGW("%s", ContentUtility::getMediaContentLogMessage(
1069                 err, "media_info_get_size()").c_str());
1070     }
1071 }
1072
1073 ImageContentPtr ContentHelper::loadImageContentFromPlatform(media_info_h info,
1074         ImageContentPtr image)
1075 {
1076
1077     if(!image)
1078     {
1079         LOGE("Image Content creation is failed.");
1080         return ImageContentPtr();
1081     }
1082
1083     if(info == NULL)
1084     {
1085         LOGE("find operation is failed.");
1086         return ImageContentPtr();
1087     }
1088
1089     char* tmpStr = NULL;
1090     int tmpInt = 0;
1091     double tmpDouble;
1092
1093     image_meta_h img;
1094
1095     ContentHelper::loadContentFromPlatform(info, image);
1096
1097     int err = media_info_get_image(info, &img);
1098     if(MEDIA_CONTENT_ERROR_NONE == err)
1099     {
1100         //created time
1101         err = image_meta_get_date_taken(img, &tmpStr);
1102         if(MEDIA_CONTENT_ERROR_NONE == err)
1103         {
1104             if(tmpStr )
1105             {
1106                 struct tm *result = (struct tm *)calloc(1, sizeof(struct tm));
1107                 if(strptime(tmpStr, "%Y:%m:%d %H:%M:%S", result) == NULL)
1108                 {
1109                     LOGE( "Couldn't convert supplied date.");
1110                 }
1111
1112                 time_t t = mktime( result );// + get_utc_offset() * 3600;
1113                 image->setReleaseDate(t);
1114                 free(tmpStr);
1115                 free(result);
1116                 tmpStr = NULL;
1117             }
1118         }
1119         else
1120         {
1121             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1122                     err, "image_meta_get_date_taken()").c_str());
1123         }
1124
1125         err = image_meta_get_width(img, &tmpInt);
1126         if(MEDIA_CONTENT_ERROR_NONE == err)
1127         {
1128             image->setWidth(tmpInt);
1129         }
1130         else
1131         {
1132             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1133                     err, "image_meta_get_width()").c_str());
1134         }
1135
1136         err = image_meta_get_height(img, &tmpInt);
1137         if(MEDIA_CONTENT_ERROR_NONE == err)
1138         {
1139             image->setHeight(tmpInt);
1140         }
1141         else
1142         {
1143             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1144                     err, "image_meta_get_height()").c_str());
1145         }
1146
1147         err = media_info_get_latitude(info, &tmpDouble);
1148         if(MEDIA_CONTENT_ERROR_NONE == err)
1149         {
1150             LOGD("Latitude: %f", tmpDouble);
1151             if (UNDEFINED_GEO != tmpDouble) {
1152                 image->setLatitude(tmpDouble);
1153             }
1154         }
1155         else
1156         {
1157             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1158                     err, "media_info_get_latitude()").c_str());
1159         }
1160
1161         err = media_info_get_longitude(info, &tmpDouble);
1162         if(MEDIA_CONTENT_ERROR_NONE == err)
1163         {
1164             LOGD("Longitude: %f", tmpDouble);
1165             if (UNDEFINED_GEO != tmpDouble) {
1166                 image->setLongitude(tmpDouble);
1167             }
1168         }
1169         else
1170         {
1171             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1172                     err, "media_info_get_longitude()").c_str());
1173         }
1174
1175         media_content_orientation_e orientation;
1176         err = image_meta_get_orientation(img, &orientation);
1177         if(MEDIA_CONTENT_ERROR_NONE == err)
1178         {
1179             image->setOrientation(orientation);
1180         }
1181         else
1182         {
1183             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1184                     err, "image_meta_get_orientation()").c_str());
1185         }
1186
1187         err = image_meta_destroy(img);
1188         if(MEDIA_CONTENT_ERROR_NONE != err)
1189         {
1190             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1191                     err, "image_meta_destroy()").c_str());
1192         }
1193     }
1194     else
1195     {
1196         LOGW("%s", ContentUtility::getMediaContentLogMessage(
1197                 err, "media_info_get_image()").c_str());
1198     }
1199     return image;
1200 }
1201
1202 VideoContentPtr ContentHelper::loadVideoContentFromPlatform(media_info_h info,
1203         VideoContentPtr videoPtr)
1204 {
1205
1206     if(!videoPtr)
1207     {
1208         LOGE("Video Content creation is failed.");
1209         return VideoContentPtr();
1210     }
1211
1212     if(info == NULL)
1213     {
1214         LOGE("find operation is failed.");
1215         return VideoContentPtr();
1216     }
1217
1218     char* tmpStr;
1219     int tmpInt = 0;
1220     double tmpDouble;
1221
1222     video_meta_h video;
1223
1224     ContentHelper::loadContentFromPlatform(info, videoPtr);
1225
1226     int err = media_info_get_video(info, &video);
1227     if(MEDIA_CONTENT_ERROR_NONE == err)
1228     {
1229         err = video_meta_get_recorded_date(video, &tmpStr);
1230         if(MEDIA_CONTENT_ERROR_NONE == err)
1231         {
1232             if(tmpStr)
1233             {
1234                 struct tm *result=(struct tm *)calloc(1, sizeof(struct tm));
1235                 if (strptime(tmpStr, "%Y:%m:%d %H:%M:%S", result) == NULL) {
1236                     LOGE( "Couldn't convert supplied date.");
1237                 }
1238                 time_t t = mktime( result ) + get_utc_offset() * 3600;
1239                 videoPtr->setReleaseDate(t);
1240                 free(tmpStr);
1241                 free(result);
1242                 tmpStr = NULL;
1243             }
1244         }
1245         else
1246         {
1247             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1248                     err, "video_meta_get_recorded_date()").c_str());
1249         }
1250
1251         err = video_meta_get_album(video, &tmpStr);
1252         if(MEDIA_CONTENT_ERROR_NONE == err)
1253         {
1254             if(tmpStr)
1255             {
1256                 videoPtr->setAlbum(tmpStr);
1257                 free(tmpStr);
1258                 tmpStr = NULL;
1259             }
1260         }
1261         else
1262         {
1263             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1264                     err, "video_meta_get_album()").c_str());
1265         }
1266
1267         err = video_meta_get_artist(video, &tmpStr);
1268         if(MEDIA_CONTENT_ERROR_NONE == err)
1269         {
1270             if(tmpStr)
1271             {
1272                 std::vector<std::string> artists = WrtDeviceApis::Commons::String::split(tmpStr, TAG_DELIMETER);
1273                 videoPtr->setArtists(artists);
1274                 free(tmpStr);
1275                 tmpStr = NULL;
1276             }
1277         }
1278         else
1279         {
1280             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1281                     err, "video_meta_get_artist()").c_str());
1282         }
1283
1284         err = media_info_get_latitude(info, &tmpDouble);
1285         if(MEDIA_CONTENT_ERROR_NONE == err)
1286         {
1287             LOGD("Latitude: %f", tmpDouble);
1288             if (UNDEFINED_GEO != tmpDouble) {
1289                 videoPtr->setLatitude(tmpDouble);
1290             }
1291         }
1292         else
1293         {
1294             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1295                     err, "media_info_get_latitude()").c_str());
1296         }
1297
1298         err = media_info_get_longitude(info, &tmpDouble);
1299         if(MEDIA_CONTENT_ERROR_NONE == err)
1300         {
1301             LOGD("Longitude: %f", tmpDouble);
1302             if (UNDEFINED_GEO != tmpDouble) {
1303                 videoPtr->setLongitude(tmpDouble);
1304             }
1305         }
1306         else
1307         {
1308             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1309                     err, "media_info_get_longitude()").c_str());
1310         }
1311
1312         err = video_meta_get_width(video, &tmpInt);
1313         if(MEDIA_CONTENT_ERROR_NONE == err)
1314         {
1315             videoPtr->setWidth(tmpInt);
1316         }
1317         else
1318         {
1319             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1320                     err, "video_meta_get_width()").c_str());
1321         }
1322
1323         err = video_meta_get_height(video, &tmpInt);
1324         if(MEDIA_CONTENT_ERROR_NONE == err)
1325         {
1326             videoPtr->setHeight(tmpInt);
1327         }
1328         else
1329         {
1330             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1331                     err, "video_meta_get_height()").c_str());
1332         }
1333
1334         err = video_meta_get_duration(video, &tmpInt);
1335         if(MEDIA_CONTENT_ERROR_NONE == err)
1336         {
1337             videoPtr->setDuration(tmpInt);
1338         }
1339         else
1340         {
1341             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1342                     err, "video_meta_get_duration()").c_str());
1343         }
1344
1345         err = video_meta_destroy(video);
1346         if(MEDIA_CONTENT_ERROR_NONE != err)
1347         {
1348             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1349                     err, "video_meta_destroy()").c_str());
1350         }
1351     }
1352     else
1353     {
1354         LOGW("%s", ContentUtility::getMediaContentLogMessage(
1355                 err, "media_info_get_video()").c_str());
1356     }
1357
1358     return videoPtr;
1359 }
1360
1361 AudioContentPtr ContentHelper::loadAudioContentFromPlatform(media_info_h info,
1362         AudioContentPtr audioPtr)
1363 {
1364     if(!audioPtr)
1365     {
1366         LOGE("Video Content creation is failed.");
1367         return AudioContentPtr();
1368     }
1369
1370     if(info == NULL)
1371     {
1372         LOGE("find operation is failed.");
1373         return AudioContentPtr();
1374     }
1375
1376     audio_meta_h audio;
1377
1378     char* tmpStr;
1379     int tmpInt = 0;
1380
1381     ContentHelper::loadContentFromPlatform(info, audioPtr);
1382
1383     int err = media_info_get_audio(info, &audio);
1384     if(MEDIA_CONTENT_ERROR_NONE == err)
1385     {
1386         err = audio_meta_get_recorded_date(audio, &tmpStr);
1387         if(MEDIA_CONTENT_ERROR_NONE == err)
1388         {
1389             if(tmpStr)
1390             {
1391                 struct tm *result = (struct tm *)calloc(1, sizeof(struct tm));
1392                 if (strptime(tmpStr, "%Y:%m:%d %H:%M:%S", result) == NULL)
1393                 {
1394                     LOGE( "Couldn't convert supplied date.");
1395                 }
1396                 time_t t = mktime( result ) + get_utc_offset() * 3600;
1397                 audioPtr->setReleaseDate(t);
1398                 free(tmpStr);
1399                 free(result);
1400                 tmpStr = NULL;
1401             }
1402         }
1403         else
1404         {
1405             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1406                     err, "audio_meta_get_recorded_date()").c_str());
1407         }
1408
1409         err = audio_meta_get_album(audio, &tmpStr);
1410         if(MEDIA_CONTENT_ERROR_NONE == err)
1411         {
1412             if(tmpStr)
1413             {
1414                 audioPtr->setAlbum(tmpStr);
1415                 free(tmpStr);
1416                 tmpStr = NULL;
1417             }
1418         }
1419         else
1420         {
1421             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1422                     err, "audio_meta_get_album()").c_str());
1423         }
1424
1425         err = audio_meta_get_artist(audio, &tmpStr);
1426         if(MEDIA_CONTENT_ERROR_NONE == err)
1427         {
1428             if(tmpStr)
1429             {
1430                 std::vector<std::string> artists = String::split(tmpStr, TAG_DELIMETER);
1431                 audioPtr->setArtists(artists);
1432                 free(tmpStr);
1433                 tmpStr = NULL;
1434             }
1435         }
1436         else
1437         {
1438             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1439                     err, "audio_meta_get_artist()").c_str());
1440         }
1441
1442         err = audio_meta_get_composer(audio, &tmpStr);
1443         if(MEDIA_CONTENT_ERROR_NONE == err)
1444         {
1445             if(tmpStr)
1446             {
1447                 std::vector<std::string> composers = String::split(tmpStr, TAG_DELIMETER);
1448                 audioPtr->setComposers(composers);
1449                 free(tmpStr);
1450                 tmpStr = NULL;
1451             }
1452         }
1453         else
1454         {
1455             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1456                     err, "audio_meta_get_composer()").c_str());
1457         }
1458
1459         err = audio_meta_get_duration(audio, &tmpInt);
1460         if(MEDIA_CONTENT_ERROR_NONE == err)
1461         {
1462             audioPtr->setDuration(tmpInt);
1463         }
1464         else
1465         {
1466             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1467                     err, "audio_meta_get_duration()").c_str());
1468         }
1469
1470         err = audio_meta_get_copyright(audio, &tmpStr);
1471         if(MEDIA_CONTENT_ERROR_NONE == err)
1472         {
1473             if(tmpStr)
1474             {
1475                 audioPtr->setCopyright(tmpStr);
1476                 free(tmpStr);
1477                 tmpStr = NULL;
1478             }
1479         }
1480         else
1481         {
1482             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1483                     err, "audio_meta_get_copyright()").c_str());
1484         }
1485
1486         err = audio_meta_get_track_num(audio, &tmpStr);
1487         if(MEDIA_CONTENT_ERROR_NONE == err)
1488         {
1489             if(tmpStr)
1490             {
1491                 audioPtr->setTrackNumber(atoi(tmpStr));
1492                 free(tmpStr);
1493                 tmpStr = NULL;
1494             }
1495         }
1496         else
1497         {
1498             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1499                     err, "audio_meta_get_track_num()").c_str());
1500         }
1501
1502         err = audio_meta_get_bit_rate(audio, &tmpInt);
1503         if(MEDIA_CONTENT_ERROR_NONE == err)
1504         {
1505             audioPtr->setBitrate(tmpInt);
1506         }
1507         else
1508         {
1509             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1510                     err, "audio_meta_get_bit_rate()").c_str());
1511         }
1512
1513         err = audio_meta_get_genre(audio, &tmpStr);
1514         if(MEDIA_CONTENT_ERROR_NONE == err)
1515         {
1516             if(tmpStr)
1517             {
1518                 std::vector<std::string> genres = String::split(tmpStr, TAG_DELIMETER);
1519
1520                 audioPtr->setGenres(genres);
1521                 free(tmpStr);
1522                 tmpStr = NULL;
1523             }
1524         }
1525         else
1526         {
1527             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1528                     err, "audio_meta_get_genre()").c_str());
1529         }
1530
1531         err = audio_meta_destroy(audio);
1532         if(MEDIA_CONTENT_ERROR_NONE != err)
1533         {
1534             LOGW("%s", ContentUtility::getMediaContentLogMessage(
1535                     err, "audio_meta_destroy()").c_str());
1536         }
1537     }
1538     else
1539     {
1540         LOGW("%s", ContentUtility::getMediaContentLogMessage(
1541                 err, "media_info_get_audio()").c_str());
1542     }
1543
1544     return audioPtr;
1545 }
1546
1547
1548
1549 } // Content
1550 } // DeviceAPI