src/content/content_manager.cc

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16
  17 #include "content/content_manager.h"
  18
  19 #include <metadata_extractor.h>
  20 #include <stdlib.h>
  21 #include <unistd.h>
  22 #include <algorithm>
  23 #include <cstring>
  24 #include <map>
  25 #include <sstream>
  26 #include <string>
  27
  28 #include "common/converter.h"
  29 #include "common/filesystem/filesystem_provider.h"
  30 #include "common/logger.h"
  31 #include "common/scope_exit.h"
  32 #include "common/tools.h"
  33
  34 #include "content/content_filter.h"
  35
  36 using namespace std;
  37 using namespace common;
  38
  39 using common::tools::ReportSuccess;
  40 using common::tools::ReportError;
  41
  42 namespace extension {
  43 namespace content {
  44
  45 namespace {
  46 static const std::string uri_prefix = "file://";
  47 static const std::string uri_absolute_prefix = "file:///";
  48 }
  49
  50 const std::map<std::string, media_content_orientation_e> orientationMap = {
  51     {"NORMAL", MEDIA_CONTENT_ORIENTATION_NORMAL},
  52     {"FLIP_HORIZONTAL", MEDIA_CONTENT_ORIENTATION_HFLIP},
  53     {"ROTATE_180", MEDIA_CONTENT_ORIENTATION_ROT_180},
  54     {"FLIP_VERTICAL", MEDIA_CONTENT_ORIENTATION_VFLIP},
  55     {"TRANSPOSE", MEDIA_CONTENT_ORIENTATION_TRANSPOSE},
  56     {"ROTATE_90", MEDIA_CONTENT_ORIENTATION_ROT_90},
  57     {"TRANSVERSE", MEDIA_CONTENT_ORIENTATION_TRANSVERSE},
  58     {"ROTATE_270", MEDIA_CONTENT_ORIENTATION_ROT_270},
  59 };
  60
  61 std::string get_date(char* tmpStr) {
  62   ScopeLogger();
  63   if (tmpStr) {
  64     struct tm* result = (struct tm*)calloc(1, sizeof(struct tm));
  65     if (nullptr != result) {
  66       if (strptime(tmpStr, "%Y:%m:%d %H:%M:%S", result) == NULL) {
  67         free(result);
  68         return std::string();
  69       } else {
  70         time_t t = mktime(result);  // + get_utc_offset() * 3600;
  71         std::stringstream str_date;
  72         str_date << t;
  73         free(result);
  74         return str_date.str();
  75       }
  76     }
  77   }
  78   return std::string();
  79 }
  80
  81 void ContentToJson(media_info_h info, picojson::object& o) {
  82   ScopeLogger();
  83   int ret;
  84   int tmpInt = 0;
  85   bool tmpBool = false;
  86   char* tmpStr = NULL;
  87   time_t tmpDate;
  88   double tmpDouble;
  89   long long unsigned int tmpLong;
  90   media_content_type_e type;
  91
  92   ret = media_info_get_media_type(info, &type);
  93
  94   if (ret != MEDIA_CONTENT_ERROR_NONE) {
  95     LoggerE("Get media type failed: %d", ret);
  96     type = MEDIA_CONTENT_TYPE_OTHERS;
  97   }
  98
  99   if (type == MEDIA_CONTENT_TYPE_IMAGE) {
 100     o["type"] = picojson::value(std::string("IMAGE"));
 101     image_meta_h img;
 102     if (MEDIA_CONTENT_ERROR_NONE == media_info_get_image(info, &img)) {
 103       std::unique_ptr<std::remove_pointer<image_meta_h>::type, int (*)(image_meta_h)> img_ptr(
 104           img, &image_meta_destroy);  // automatically release the memory
 105       if (MEDIA_CONTENT_ERROR_NONE == image_meta_get_date_taken(img, &tmpStr)) {
 106         if (tmpStr) {
 107           o["releaseDate"] = picojson::value(get_date(tmpStr));
 108           free(tmpStr);
 109           tmpStr = NULL;
 110         }
 111       }
 112       if (MEDIA_CONTENT_ERROR_NONE == image_meta_get_width(img, &tmpInt)) {
 113         o["width"] = picojson::value(static_cast<double>(tmpInt));
 114       }
 115       if (MEDIA_CONTENT_ERROR_NONE == image_meta_get_height(img, &tmpInt)) {
 116         o["height"] = picojson::value(static_cast<double>(tmpInt));
 117       }
 118       picojson::object geo;
 119       if (MEDIA_CONTENT_ERROR_NONE == media_info_get_latitude(info, &tmpDouble)) {
 120         geo["latitude"] = picojson::value(tmpDouble);
 121       }
 122       if (MEDIA_CONTENT_ERROR_NONE == media_info_get_longitude(info, &tmpDouble)) {
 123         geo["longitude"] = picojson::value(tmpDouble);
 124       }
 125       o["geolocation"] = picojson::value(geo);
 126       std::string ori;
 127       media_content_orientation_e orientation;
 128       if (MEDIA_CONTENT_ERROR_NONE == image_meta_get_orientation(img, &orientation)) {
 129         switch (orientation) {
 130           case MEDIA_CONTENT_ORIENTATION_NOT_AVAILABLE:
 131           case MEDIA_CONTENT_ORIENTATION_NORMAL:
 132             ori = "NORMAL";
 133             break;
 134           case MEDIA_CONTENT_ORIENTATION_HFLIP:
 135             ori = "FLIP_HORIZONTAL";
 136             break;
 137           case MEDIA_CONTENT_ORIENTATION_ROT_180:
 138             ori = "ROTATE_180";
 139             break;
 140           case MEDIA_CONTENT_ORIENTATION_VFLIP:
 141             ori = "FLIP_VERTICAL";
 142             break;
 143           case MEDIA_CONTENT_ORIENTATION_TRANSPOSE:
 144             ori = "TRANSPOSE";
 145             break;
 146           case MEDIA_CONTENT_ORIENTATION_ROT_90:
 147             ori = "ROTATE_90";
 148             break;
 149           case MEDIA_CONTENT_ORIENTATION_TRANSVERSE:
 150             ori = "TRANSVERSE";
 151             break;
 152           case MEDIA_CONTENT_ORIENTATION_ROT_270:
 153             ori = "ROTATE_270";
 154             break;
 155         }
 156         o["orientation"] = picojson::value(ori);
 157       }
 158     }
 159   } else if (type == MEDIA_CONTENT_TYPE_VIDEO) {
 160     o["type"] = picojson::value(std::string("VIDEO"));
 161     video_meta_h video;
 162     if (MEDIA_CONTENT_ERROR_NONE == media_info_get_video(info, &video)) {
 163       std::unique_ptr<std::remove_pointer<video_meta_h>::type, int (*)(video_meta_h)> video_ptr(
 164           video, &video_meta_destroy);  // automatically release the memory
 165       if (MEDIA_CONTENT_ERROR_NONE == video_meta_get_width(video, &tmpInt)) {
 166         o["width"] = picojson::value(static_cast<double>(tmpInt));
 167       }
 168
 169       if (MEDIA_CONTENT_ERROR_NONE == video_meta_get_height(video, &tmpInt)) {
 170         o["height"] = picojson::value(static_cast<double>(tmpInt));
 171       }
 172       if (MEDIA_CONTENT_ERROR_NONE == video_meta_get_artist(video, &tmpStr)) {
 173         picojson::array artists;
 174         if (tmpStr) {
 175           artists.push_back(picojson::value(std::string(tmpStr)));
 176           free(tmpStr);
 177           tmpStr = NULL;
 178         }
 179         o["artists"] = picojson::value(artists);
 180       }
 181       if (MEDIA_CONTENT_ERROR_NONE == video_meta_get_album(video, &tmpStr)) {
 182         if (tmpStr) {
 183           o["album"] = picojson::value(tmpStr);
 184           free(tmpStr);
 185           tmpStr = NULL;
 186         }
 187       }
 188       if (MEDIA_CONTENT_ERROR_NONE == video_meta_get_duration(video, &tmpInt)) {
 189         o["duration"] = picojson::value(static_cast<double>(tmpInt));
 190       }
 191       if (MEDIA_CONTENT_ERROR_NONE == video_meta_get_recorded_date(video, &tmpStr)) {
 192         if (tmpStr) {
 193           o["releaseDate"] = picojson::value(get_date(tmpStr));
 194           free(tmpStr);
 195           tmpStr = NULL;
 196         }
 197       }
 198     }
 199     picojson::object geo;
 200     if (MEDIA_CONTENT_ERROR_NONE == media_info_get_latitude(info, &tmpDouble)) {
 201       geo["latitude"] = picojson::value(tmpDouble);
 202     }
 203     if (MEDIA_CONTENT_ERROR_NONE == media_info_get_longitude(info, &tmpDouble)) {
 204       geo["longitude"] = picojson::value(tmpDouble);
 205     }
 206     o["geolocation"] = picojson::value(geo);
 207   } else if (type == MEDIA_CONTENT_TYPE_SOUND || type == MEDIA_CONTENT_TYPE_MUSIC) {
 208     o["type"] = picojson::value(std::string("AUDIO"));
 209     audio_meta_h audio;
 210     if (MEDIA_CONTENT_ERROR_NONE == media_info_get_audio(info, &audio)) {
 211       std::unique_ptr<std::remove_pointer<audio_meta_h>::type, int (*)(audio_meta_h)> audio_ptr(
 212           audio, &audio_meta_destroy);  // automatically release the memory
 213       if (MEDIA_CONTENT_ERROR_NONE == audio_meta_get_recorded_date(audio, &tmpStr)) {
 214         if (tmpStr) {
 215           o["releaseDate"] = picojson::value(get_date(tmpStr));
 216           free(tmpStr);
 217           tmpStr = NULL;
 218         }
 219       }
 220       if (MEDIA_CONTENT_ERROR_NONE == audio_meta_get_album(audio, &tmpStr)) {
 221         if (tmpStr) {
 222           o["album"] = picojson::value(std::string(tmpStr));
 223           free(tmpStr);
 224           tmpStr = NULL;
 225         }
 226       }
 227       if (MEDIA_CONTENT_ERROR_NONE == audio_meta_get_artist(audio, &tmpStr)) {
 228         if (tmpStr) {
 229           picojson::array artists;
 230           artists.push_back(picojson::value(std::string(tmpStr)));
 231           o["artists"] = picojson::value(artists);
 232           free(tmpStr);
 233           tmpStr = NULL;
 234         }
 235       }
 236       if (MEDIA_CONTENT_ERROR_NONE == audio_meta_get_genre(audio, &tmpStr)) {
 237         if (tmpStr) {
 238           picojson::array genres;
 239           genres.push_back(picojson::value(std::string(tmpStr)));
 240           o["genres"] = picojson::value(genres);
 241           free(tmpStr);
 242           tmpStr = NULL;
 243         }
 244       }
 245       if (MEDIA_CONTENT_ERROR_NONE == audio_meta_get_composer(audio, &tmpStr)) {
 246         if (tmpStr) {
 247           picojson::array composers;
 248           composers.push_back(picojson::value(std::string(tmpStr)));
 249           o["composers"] = picojson::value(composers);
 250           free(tmpStr);
 251           tmpStr = NULL;
 252         }
 253       }
 254       if (MEDIA_CONTENT_ERROR_NONE == audio_meta_get_copyright(audio, &tmpStr)) {
 255         if (tmpStr) {
 256           o["copyright"] = picojson::value(std::string(tmpStr));
 257           free(tmpStr);
 258           tmpStr = NULL;
 259         }
 260       }
 261       if (MEDIA_CONTENT_ERROR_NONE == audio_meta_get_bit_rate(audio, &tmpInt)) {
 262         o["bitrate"] = picojson::value(static_cast<double>(tmpInt));
 263       }
 264       if (MEDIA_CONTENT_ERROR_NONE == audio_meta_get_track_num(audio, &tmpStr)) {
 265         if (tmpStr) {
 266           o["trackNumber"] = picojson::value(static_cast<double>(std::atoi(tmpStr)));
 267           free(tmpStr);
 268           tmpStr = NULL;
 269         } else {
 270           o["trackNumber"] = picojson::value();
 271         }
 272       }
 273       if (MEDIA_CONTENT_ERROR_NONE == audio_meta_get_duration(audio, &tmpInt)) {
 274         o["duration"] = picojson::value(static_cast<double>(tmpInt));
 275       }
 276     }
 277   } else {
 278     o["type"] = picojson::value(std::string("OTHER"));
 279   }
 280
 281   ret = media_info_get_media_id(info, &tmpStr);
 282   if (ret == MEDIA_CONTENT_ERROR_NONE) {
 283     if (tmpStr) {
 284       o["id"] = picojson::value(std::string(tmpStr));
 285       free(tmpStr);
 286       tmpStr = NULL;
 287     }
 288   }
 289   ret = media_info_get_display_name(info, &tmpStr);
 290   if (ret == MEDIA_CONTENT_ERROR_NONE) {
 291     if (tmpStr) {
 292       o["name"] = picojson::value(std::string(tmpStr));
 293       free(tmpStr);
 294       tmpStr = NULL;
 295     }
 296   }
 297
 298   ret = media_info_get_mime_type(info, &tmpStr);
 299   if (ret == MEDIA_CONTENT_ERROR_NONE) {
 300     if (tmpStr) {
 301       o["mimeType"] = picojson::value(std::string(tmpStr));
 302       free(tmpStr);
 303       tmpStr = NULL;
 304     }
 305   }
 306   ret = media_info_get_title(info, &tmpStr);
 307   if (ret == MEDIA_CONTENT_ERROR_NONE) {
 308     if (tmpStr) {
 309       o["title"] = picojson::value(std::string(tmpStr));
 310       free(tmpStr);
 311       tmpStr = NULL;
 312     }
 313   }
 314   ret = media_info_get_file_path(info, &tmpStr);
 315   if (ret == MEDIA_CONTENT_ERROR_NONE) {
 316     if (tmpStr) {
 317       o["contentURI"] = picojson::value(std::string(tmpStr));
 318       free(tmpStr);
 319       tmpStr = NULL;
 320     }
 321   }
 322   ret = media_info_get_thumbnail_path(info, &tmpStr);
 323   if (ret == MEDIA_CONTENT_ERROR_NONE) {
 324     if (tmpStr) {
 325       picojson::array thumbnails;
 326       thumbnails.push_back(picojson::value(std::string(tmpStr)));
 327       o["thumbnailURIs"] = picojson::value(thumbnails);
 328       free(tmpStr);
 329       tmpStr = NULL;
 330     }
 331   }
 332   ret = media_info_get_description(info, &tmpStr);
 333   if (ret == MEDIA_CONTENT_ERROR_NONE) {
 334     if (tmpStr) {
 335       o["description"] = picojson::value(std::string(tmpStr));
 336       free(tmpStr);
 337       tmpStr = NULL;
 338     }
 339   }
 340   ret = media_info_get_rating(info, &tmpInt);
 341   if (ret == MEDIA_CONTENT_ERROR_NONE) {
 342     o["rating"] = picojson::value(static_cast<double>(tmpInt));
 343   }
 344   ret = media_info_get_size(info, &tmpLong);
 345   if (ret == MEDIA_CONTENT_ERROR_NONE) {
 346     o["size"] = picojson::value(static_cast<double>(tmpLong));
 347   }
 348   ret = media_info_get_favorite(info, &tmpBool);
 349   if (ret == MEDIA_CONTENT_ERROR_NONE) {
 350     o["isFavorite"] = picojson::value(tmpBool);
 351   }
 352   ret = media_info_get_modified_time(info, &tmpDate);
 353   if (ret == MEDIA_CONTENT_ERROR_NONE) {
 354     o["modifiedDate"] = picojson::value(static_cast<double>(tmpDate));
 355   }
 356 }
 357
 358 void ContentDirToJson(media_folder_h folder, picojson::object& o) {
 359   ScopeLogger();
 360   int ret;
 361   char* tmpStr = NULL;
 362   media_content_storage_e storage_type;
 363   time_t tmpDate;
 364
 365   // id
 366   ret = media_folder_get_folder_id(folder, &tmpStr);
 367   if (ret == MEDIA_CONTENT_ERROR_NONE) {
 368     if (tmpStr) {
 369       o["id"] = picojson::value(std::string(tmpStr));
 370       free(tmpStr);
 371       tmpStr = NULL;
 372     }
 373   }
 374
 375   // directoryURI
 376   ret = media_folder_get_path(folder, &tmpStr);
 377   if (ret == MEDIA_CONTENT_ERROR_NONE) {
 378     if (tmpStr) {
 379       o["directoryURI"] = picojson::value(std::string(tmpStr));
 380       free(tmpStr);
 381       tmpStr = NULL;
 382     }
 383   }
 384
 385   // title
 386   ret = media_folder_get_name(folder, &tmpStr);
 387   if (ret == MEDIA_CONTENT_ERROR_NONE) {
 388     if (tmpStr) {
 389       o["title"] = picojson::value(std::string(tmpStr));
 390       free(tmpStr);
 391       tmpStr = NULL;
 392     }
 393   }
 394
 395   // storageType
 396   ret = media_folder_get_storage_type(folder, &storage_type);
 397   if (ret == MEDIA_CONTENT_ERROR_NONE) {
 398     if (storage_type == MEDIA_CONTENT_STORAGE_INTERNAL) {
 399       o["storageType"] = picojson::value(std::string("INTERNAL"));
 400     } else if (storage_type == MEDIA_CONTENT_STORAGE_EXTERNAL) {
 401       o["storageType"] = picojson::value(std::string("EXTERNAL"));
 402     } else if (storage_type == MEDIA_CONTENT_STORAGE_CLOUD) {
 403       o["storageType"] = picojson::value(std::string("CLOUD"));
 404     }
 405   }
 406
 407   // modifiedData
 408   ret = media_folder_get_modified_time(folder, &tmpDate);
 409   if (ret == MEDIA_CONTENT_ERROR_NONE) {
 410     o["modifiedDate"] = picojson::value(static_cast<double>(tmpDate));
 411   }
 412 }
 413
 414 static int setContent(media_info_h media, const picojson::value& content) {
 415   ScopeLogger();
 416
 417   int ret;
 418   std::string name = content.get("name").to_str();
 419   std::string description = content.get("description").to_str();
 420   int rating = std::stoi(content.get("rating").to_str());
 421   bool is_fav = content.get("isFavorite").get<bool>();
 422
 423   if (NULL == media) {
 424     LoggerE("MEDIA_CONTENT_ERROR_DB_FAILED");
 425     return MEDIA_CONTENT_ERROR_DB_FAILED;
 426   }
 427
 428   media_content_type_e type;
 429   ret = media_info_get_media_type(media, &type);
 430   if (ret != MEDIA_CONTENT_ERROR_NONE) {
 431     LoggerE("Failed: media_info_get_media_type()");
 432     return ret;
 433   }
 434
 435   ret = media_info_set_display_name(media, name.c_str());
 436   if (ret != MEDIA_CONTENT_ERROR_NONE) {
 437     LoggerE("Updating name failed.");
 438   }
 439
 440   ret = media_info_set_description(media, description.c_str());
 441   if (ret != MEDIA_CONTENT_ERROR_NONE) {
 442     LoggerE("Updating description failed.");
 443   }
 444
 445   ret = media_info_set_rating(media, rating);
 446   if (ret != MEDIA_CONTENT_ERROR_NONE) {
 447     LoggerE("Updating rating failed.");
 448   }
 449
 450   ret = media_info_set_favorite(media, is_fav);
 451   if (ret != MEDIA_CONTENT_ERROR_NONE) {
 452     LoggerE("Updating isFavorite failed.");
 453   }
 454
 455   if (ret != MEDIA_CONTENT_ERROR_NONE) {
 456     LoggerE("Updating favorite failed.");
 457   }
 458
 459   if (type == MEDIA_CONTENT_TYPE_IMAGE) {
 460     std::string orientation = content.get("orientation").to_str();
 461     auto orientationToSet = orientationMap.find(orientation);
 462
 463     if (orientationToSet != orientationMap.end()) {
 464       image_meta_h img;
 465       if (MEDIA_CONTENT_ERROR_NONE == media_info_get_image(media, &img) &&
 466           MEDIA_CONTENT_ERROR_NONE == image_meta_set_orientation(img, orientationToSet->second) &&
 467           MEDIA_CONTENT_ERROR_NONE == image_meta_update_to_db(img)) {
 468         LoggerD("orientation update was successful");
 469       } else {
 470         LoggerE("orientation update failed");
 471       }
 472       image_meta_destroy(img);
 473     }
 474   }
 475
 476   if (type == MEDIA_CONTENT_TYPE_IMAGE || type == MEDIA_CONTENT_TYPE_VIDEO) {
 477     picojson::value geo = content.get("geolocation");
 478     if (geo.evaluate_as_boolean()) {
 479       LoggerD("geolocation is not null");
 480       double latitude = atof(geo.get("latitude").to_str().c_str());
 481       double longitude = atof(geo.get("longitude").to_str().c_str());
 482       ret = media_info_set_latitude(media, latitude);
 483       if (ret != MEDIA_CONTENT_ERROR_NONE) {
 484         LoggerE("Updating geolocation is failed.");
 485       }
 486       ret = media_info_set_longitude(media, longitude);
 487       if (ret != MEDIA_CONTENT_ERROR_NONE) {
 488         LoggerD("Updating geolocation is failed.");
 489       }
 490     } else {
 491       LoggerD("geolocation is null");
 492     }
 493   }
 494
 495   return MEDIA_CONTENT_ERROR_NONE;
 496 }
 497
 498 static void FolderToJson(media_folder_h folder, picojson::object* out) {
 499   ScopeLogger();
 500
 501   char* name = NULL;
 502   char* id = NULL;
 503   char* path = NULL;
 504   time_t date;
 505   media_content_storage_e storageType;
 506
 507   int ret;
 508
 509   ret = media_folder_get_folder_id(folder, &id);
 510   if (ret != MEDIA_CONTENT_ERROR_NONE) {
 511     LogAndReportError(ContentManager::convertError(ret), out,
 512                       ("Failed: media_folder_get_folder_id"));
 513     return;
 514   }
 515
 516   ret = media_folder_get_name(folder, &name);
 517   if (ret != MEDIA_CONTENT_ERROR_NONE) {
 518     LogAndReportError(ContentManager::convertError(ret), out, ("Failed: media_folder_get_name"));
 519     free(id);
 520     return;
 521   }
 522
 523   ret = media_folder_get_path(folder, &path);
 524   if (ret != MEDIA_CONTENT_ERROR_NONE) {
 525     LogAndReportError(ContentManager::convertError(ret), out, ("Failed: media_folder_get_path"));
 526     free(id);
 527     free(name);
 528     return;
 529   }
 530
 531   ret = media_folder_get_modified_time(folder, &date);
 532   if (ret != MEDIA_CONTENT_ERROR_NONE) {
 533     LogAndReportError(ContentManager::convertError(ret), out, ("Failed: media_folder_get_path"));
 534     free(id);
 535     free(name);
 536     free(path);
 537     return;
 538   }
 539
 540   ret = media_folder_get_storage_type(folder, &storageType);
 541   if (ret != MEDIA_CONTENT_ERROR_NONE) {
 542     free(id);
 543     free(name);
 544     free(path);
 545     LogAndReportError(ContentManager::convertError(ret), out,
 546                       ("Failed: media_folder_get_storage_type"));
 547     return;
 548   }
 549
 550   (*out)["id"] = picojson::value(std::string(id));
 551   (*out)["directoryURI"] = picojson::value(std::string(path));
 552   (*out)["title"] = picojson::value(std::string(name));
 553
 554   if (storageType == MEDIA_CONTENT_STORAGE_INTERNAL) {
 555     (*out)["storageType"] = picojson::value(std::string("INTERNAL"));
 556   } else if (storageType == MEDIA_CONTENT_STORAGE_EXTERNAL) {
 557     (*out)["storageType"] = picojson::value(std::string("EXTERNAL"));
 558   }
 559
 560   (*out)["modifiedDate"] = picojson::value(static_cast<double>(date));
 561
 562   free(name);
 563   free(id);
 564   free(path);
 565 }
 566
 567 static bool media_foreach_directory_cb(media_folder_h folder, void* user_data) {
 568   ScopeLogger();
 569   picojson::array* array = static_cast<picojson::array*>(user_data);
 570   picojson::object json;
 571   FolderToJson(folder, &json);
 572   array->push_back(picojson::value(json));
 573   return true;
 574 }
 575
 576 static bool media_foreach_content_cb(media_info_h media, void* user_data) {
 577   ScopeLogger();
 578   picojson::value::array* contents = static_cast<picojson::value::array*>(user_data);
 579   picojson::value::object o;
 580   ContentToJson(media, o);
 581   contents->push_back(picojson::value(o));
 582   return true;
 583 }
 584
 585 static bool playlist_foreach_cb(media_playlist_h playlist, void* user_data) {
 586   ScopeLogger();
 587   picojson::value::array* playlists = static_cast<picojson::value::array*>(user_data);
 588   picojson::value::object o;
 589   if (playlist != NULL) {
 590     int id, cnt;
 591     char* thumb_path = NULL;
 592     char* name = NULL;
 593     filter_h filter = NULL;
 594     if (media_playlist_get_playlist_id(playlist, &id) == MEDIA_CONTENT_ERROR_NONE) {
 595       std::stringstream str_id;
 596       str_id << id;
 597       o["id"] = picojson::value(std::to_string(id));
 598     } else {
 599       LoggerD("Invalid ID for playlist.");
 600     }
 601     if (media_playlist_get_thumbnail_path(playlist, &thumb_path) == MEDIA_CONTENT_ERROR_NONE) {
 602       if (thumb_path != NULL) {
 603         std::string thumbnail_uri(thumb_path);
 604         if (thumbnail_uri != " ") {
 605           thumbnail_uri = uri_prefix + thumbnail_uri;
 606         }
 607         o["thumbnailURI"] = picojson::value(thumbnail_uri);
 608         free(thumb_path);
 609       } else {
 610         o["thumbnailURI"] = picojson::value();  // picojson::value(std::string(""));
 611       }
 612     } else {
 613       LoggerD("Invalid thumbnail path for playlist.");
 614     }
 615     if (media_playlist_get_name(playlist, &name) == MEDIA_CONTENT_ERROR_NONE) {
 616       o["name"] = picojson::value(std::string(name));
 617       free(name);
 618     } else {
 619       LoggerD("Invalid name for playlist.");
 620     }
 621
 622     media_filter_create(&filter);
 623     std::unique_ptr<std::remove_pointer<filter_h>::type, int (*)(filter_h)> filter_ptr(
 624         filter, &media_filter_destroy);  // automatically release the memory
 625     if (media_playlist_get_media_count_from_db(id, filter, &cnt) == MEDIA_CONTENT_ERROR_NONE) {
 626       o["numberOfTracks"] = picojson::value(static_cast<double>(cnt));
 627     } else {
 628       LoggerE("Invalid count for playlist.");
 629     }
 630     playlists->push_back(picojson::value(o));
 631   }
 632   return true;
 633 }
 634
 635 static bool playlist_content_member_cb(int playlist_member_id, media_info_h media,
 636                                        void* user_data) {
 637   ScopeLogger();
 638   picojson::value::array* contents = static_cast<picojson::value::array*>(user_data);
 639   picojson::value::object o;
 640
 641   o["playlist_member_id"] = picojson::value(static_cast<double>(playlist_member_id));
 642   ContentToJson(media, o);
 643   contents->push_back(picojson::value(o));
 644   return true;
 645 }
 646
 647 ContentManager::ContentManager() {
 648   ScopeLogger("ContentManager called");
 649   if (media_content_connect() == MEDIA_CONTENT_ERROR_NONE) {
 650     m_dbConnected = true;
 651   } else {
 652     m_dbConnected = false;
 653   }
 654   m_contentInstance = nullptr;
 655 }
 656
 657 ContentManager::~ContentManager() {
 658   ScopeLogger();
 659   if (m_dbConnected) {
 660     if (media_content_disconnect() == MEDIA_CONTENT_ERROR_NONE) {
 661       m_dbConnected = false;
 662     }
 663   }
 664 }
 665
 666 ContentManager* ContentManager::getInstance() {
 667   ScopeLogger();
 668   static ContentManager instance;
 669   return &instance;
 670 }
 671
 672 ContentInstance* ContentManager::getContentInstance() {
 673   ScopeLogger();
 674   return m_contentInstance;
 675 }
 676
 677 void ContentManager::setContentInstance(ContentInstance* const content_instance) {
 678   ScopeLogger();
 679   m_contentInstance = content_instance;
 680 }
 681
 682 bool ContentManager::isConnected() {
 683   ScopeLogger();
 684   return m_dbConnected;
 685 }
 686
 687 void ContentManager::getDirectories(const std::shared_ptr<ReplyCallbackData>& user_data) {
 688   ScopeLogger();
 689   int ret;
 690   filter_h filter = NULL;
 691   ret = media_filter_create(&filter);
 692   if (ret != MEDIA_CONTENT_ERROR_NONE) {
 693     LoggerE("Failed: media_filter_create failed");
 694     return;
 695   }
 696
 697   SCOPE_EXIT {
 698     media_filter_destroy(filter);
 699   };
 700
 701   std::string condition = "(FOLDER_STORAGE_TYPE = 0 OR FOLDER_STORAGE_TYPE = 1)";
 702   media_filter_set_condition(filter, condition.c_str(), MEDIA_CONTENT_COLLATE_DEFAULT);
 703
 704   picojson::array pico_dirs;
 705   ret = media_folder_foreach_folder_from_db(filter, media_foreach_directory_cb, &pico_dirs);
 706   if (ret != MEDIA_CONTENT_ERROR_NONE) {
 707     PlatformResult err = LogAndCreateResult(
 708         ErrorCode::UNKNOWN_ERR, "Getting the directories failed.",
 709         ("Failed: Getting the directories failed %d (%s)", ret, get_error_message(ret)));
 710     user_data->isSuccess = err;
 711     return;
 712   }
 713
 714   user_data->result = picojson::value(pico_dirs);
 715 }
 716
 717 void ContentManager::find(const std::shared_ptr<ReplyCallbackData>& user_data) {
 718   ScopeLogger();
 719
 720   int ret;
 721   int count, offset;
 722   std::string dirId;
 723
 724   picojson::value::array arrayContent;
 725   filter_h filter = nullptr;
 726   media_filter_create(&filter);
 727   SCOPE_EXIT {
 728     if (filter) {
 729       media_filter_destroy(filter);
 730     }
 731   };
 732
 733   if (!IsNull(user_data->args.get("filter"))) {
 734     ContentFilter filterMechanism;
 735     std::string query;
 736     picojson::object argsObject = JsonCast<picojson::object>(user_data->args);
 737     if (filterMechanism.BuildQuery(FromJson<picojson::object>(argsObject, "filter"), &query)) {
 738       LoggerD("Filter query: %s", query.c_str());
 739       ret = media_filter_set_condition(filter, query.c_str(), MEDIA_CONTENT_COLLATE_DEFAULT);
 740       if (MEDIA_CONTENT_ERROR_NONE != ret) {
 741         LoggerE("Platform filter setting failed, error %d", ret);
 742       }
 743     }
 744   }
 745
 746   if (user_data->args.contains("sortMode")) {
 747     picojson::value vSortMode = user_data->args.get("sortMode");
 748
 749     if (vSortMode.is<picojson::object>()) {
 750       std::string sortModeName, sortModeOrder;
 751
 752       ContentFilter::MapField(vSortMode.get("attributeName").to_str(), &sortModeName);
 753
 754       sortModeOrder = vSortMode.get("order").to_str();
 755       if (!sortModeOrder.empty()) {
 756         media_content_order_e order = MEDIA_CONTENT_ORDER_ASC;
 757
 758         if (sortModeOrder == "ASC") {
 759           order = MEDIA_CONTENT_ORDER_ASC;
 760         } else if (sortModeOrder == "DESC") {
 761           order = MEDIA_CONTENT_ORDER_DESC;
 762         }
 763
 764         ret = media_filter_set_order(filter, order, sortModeName.c_str(),
 765                                      MEDIA_CONTENT_COLLATE_DEFAULT);
 766         if (MEDIA_CONTENT_ERROR_NONE != ret) {
 767           LoggerE("Platform SortMode setting failed, error: %d", ret);
 768         }
 769       }
 770     }
 771   }
 772
 773   if (!IsNull(user_data->args.get("count"))) {
 774     count = static_cast<int>(user_data->args.get("count").get<double>());
 775   } else {
 776     count = -1;
 777   }
 778   if (!IsNull(user_data->args.get("offset"))) {
 779     offset = static_cast<int>(user_data->args.get("offset").get<double>());
 780   } else {
 781     offset = -1;
 782   }
 783   ret = media_filter_set_offset(filter, offset, count);
 784   if (MEDIA_CONTENT_ERROR_NONE != ret) {
 785     LoggerE("A platform error occurs in media_filter_set_offset: %d", ret);
 786   }
 787   if (!IsNull(user_data->args.get("directoryId"))) {
 788     dirId = user_data->args.get("directoryId").get<std::string>();
 789     ret = media_folder_foreach_media_from_db(dirId.c_str(), filter, media_foreach_content_cb,
 790                                              static_cast<void*>(&arrayContent));
 791   } else {
 792     ret = media_info_foreach_media_from_db(filter, media_foreach_content_cb,
 793                                            static_cast<void*>(&arrayContent));
 794   }
 795
 796   if (ret == MEDIA_CONTENT_ERROR_NONE) {
 797     user_data->result = picojson::value(arrayContent);
 798   } else {
 799     PlatformResult err = LogAndCreateResult(
 800         ErrorCode::UNKNOWN_ERR, "The iteration failed in platform",
 801         ("The iteration failed in platform: %d (%s)", ret, get_error_message(ret)));
 802     user_data->isSuccess = err;
 803   }
 804 }
 805
 806 int ContentManager::scanFile(std::string& uri) {
 807   ScopeLogger();
 808   return media_content_scan_file(uri.c_str());
 809 }
 810
 811 PlatformResult ContentManager::scanDirectory(media_scan_completed_cb callback,
 812                                              ReplyCallbackData* cbData) {
 813   ScopeLogger();
 814   const std::string& contentDirURI = cbData->args.get("contentDirURI").get<std::string>();
 815   std::string real_path = common::FilesystemProvider::Create().GetRealPath(contentDirURI);
 816   const bool recursive = cbData->args.get("recursive").get<bool>();
 817
 818   int ret = media_content_scan_folder(real_path.c_str(), recursive, callback, (void*)cbData);
 819
 820   if (ret != MEDIA_CONTENT_ERROR_NONE) {
 821     if (MEDIA_CONTENT_ERROR_INVALID_PARAMETER == ret) {
 822       return LogAndCreateResult(
 823           ErrorCode::INVALID_VALUES_ERR, "Scanning content directory failed",
 824           ("Scan folder failed in platform: %d (%s)", ret, get_error_message(ret)));
 825
 826     } else {
 827       return LogAndCreateResult(
 828           ErrorCode::UNKNOWN_ERR, "Scanning content directory failed",
 829           ("Scan folder failed in platform: %d (%s)", ret, get_error_message(ret)));
 830     }
 831   }
 832   return PlatformResult(ErrorCode::NO_ERROR);
 833 }
 834
 835 PlatformResult ContentManager::cancelScanDirectory(const std::string& content_dir_uri) {
 836   ScopeLogger();
 837
 838   int ret = media_content_cancel_scan_folder(content_dir_uri.c_str());
 839   if (ret != MEDIA_CONTENT_ERROR_NONE) {
 840     return LogAndCreateResult(
 841         ErrorCode::UNKNOWN_ERR, "Cancel scan content directory failed",
 842         ("Cancel scan folder failed in platform: %d (%s)", ret, get_error_message(ret)));
 843   }
 844   return PlatformResult(ErrorCode::NO_ERROR);
 845 }
 846
 847 PlatformResult ContentManager::addChangeListener(media_content_noti_h* noti_handle,
 848                                                  media_content_db_update_cb callback,
 849                                                  void* user_data) {
 850   ScopeLogger();
 851
 852   int ret = media_content_add_db_updated_cb(callback, user_data, noti_handle);
 853
 854   if (MEDIA_CONTENT_ERROR_NONE != ret) {
 855     return LogAndCreateResult(ErrorCode::ABORT_ERR, "Failed to add the listener.",
 856                               ("Failed to add the listener: %d (%s)", ret, get_error_message(ret)));
 857   }
 858
 859   return PlatformResult(ErrorCode::NO_ERROR);
 860 }
 861
 862 PlatformResult ContentManager::removeChangeListener(media_content_noti_h noti_handle) {
 863   ScopeLogger();
 864
 865   int ret = media_content_remove_db_updated_cb(noti_handle);
 866
 867   switch (ret) {
 868     case MEDIA_CONTENT_ERROR_NONE:
 869       return PlatformResult(ErrorCode::NO_ERROR);
 870     case MEDIA_CONTENT_ERROR_INVALID_PARAMETER:
 871       // Trying to remove non-existent listener, ignoring
 872       LoggerI("Failed to remove the listener: %d (%s)", ret, get_error_message(ret));
 873       return PlatformResult(ErrorCode::NO_ERROR);
 874     default:
 875       return LogAndCreateResult(
 876           ErrorCode::ABORT_ERR, "Failed to remove the listener.",
 877           ("Failed to remove the listener: %d (%s)", ret, get_error_message(ret)));
 878   }
 879 }
 880
 881 void ContentManager::createPlaylist(std::string name,
 882                                     const std::shared_ptr<ReplyCallbackData>& user_data) {
 883   ScopeLogger();
 884   media_playlist_h playlist = NULL;
 885
 886   int ret = media_playlist_insert_to_db(name.c_str(), &playlist);
 887   std::unique_ptr<std::remove_pointer<media_playlist_h>::type, int (*)(media_playlist_h)>
 888       playlist_ptr(playlist, &media_playlist_destroy);  // automatically release the memory
 889   if (ret != MEDIA_CONTENT_ERROR_NONE) {
 890     // MEDIA_CONTENT_ERROR_DB_FAILED means that playlist probably already exists
 891     PlatformResult err = LogAndCreateResult(
 892         MEDIA_CONTENT_ERROR_DB_FAILED == ret ? ErrorCode::INVALID_VALUES_ERR
 893                                              : ErrorCode::UNKNOWN_ERR,
 894         "Creation of playlist has failed.",
 895         ("Failed: creation of playlist is failed: %d (%s)", ret, get_error_message(ret)));
 896     user_data->isSuccess = err;
 897     return;
 898   }
 899   picojson::value::object o;
 900
 901   if (playlist != NULL) {
 902     int id, cnt;
 903     char* thumb_path = NULL;
 904     char* name_playlist = NULL;
 905     filter_h filter = NULL;
 906     if (media_playlist_get_playlist_id(playlist, &id) == MEDIA_CONTENT_ERROR_NONE) {
 907       o["id"] = picojson::value(std::to_string(id));
 908     } else {
 909       PlatformResult err =
 910           LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "loading of playlist is failed.");
 911       user_data->isSuccess = err;
 912       return;
 913     }
 914     if (media_playlist_get_thumbnail_path(playlist, &thumb_path) == MEDIA_CONTENT_ERROR_NONE) {
 915       if (thumb_path != NULL) {
 916         o["thumbnailURI"] = picojson::value(std::string(thumb_path));
 917         free(thumb_path);
 918       } else {
 919         o["thumbnailURI"] = picojson::value();
 920       }
 921     } else {
 922       LoggerE("Invalid thumbnail path for playlist.");
 923     }
 924     if (media_playlist_get_name(playlist, &name_playlist) == MEDIA_CONTENT_ERROR_NONE) {
 925       o["name"] = picojson::value(std::string(name_playlist));
 926       free(name_playlist);
 927     } else {
 928       LoggerE("Invalid name for playlist.");
 929     }
 930     media_filter_create(&filter);
 931     std::unique_ptr<std::remove_pointer<filter_h>::type, int (*)(filter_h)> filter_ptr(
 932         filter, &media_filter_destroy);  // automatically release the memory
 933
 934     if (media_playlist_get_media_count_from_db(id, filter, &cnt) == MEDIA_CONTENT_ERROR_NONE) {
 935       o["numberOfTracks"] = picojson::value(static_cast<double>(cnt));
 936     } else {
 937       LoggerE("Invalid count for playlist.");
 938     }
 939   }
 940
 941   user_data->result = picojson::value(o);
 942 }
 943
 944 void ContentManager::getPlaylists(const std::shared_ptr<ReplyCallbackData>& user_data) {
 945   ScopeLogger();
 946   int ret;
 947   filter_h filter = nullptr;
 948   media_filter_create(&filter);
 949   std::unique_ptr<std::remove_pointer<filter_h>::type, int (*)(filter_h)> filter_ptr(
 950       filter, &media_filter_destroy);  // automatically release the memory
 951   picojson::value::array playlists;
 952
 953   ret = media_playlist_foreach_playlist_from_db(filter, playlist_foreach_cb,
 954                                                 static_cast<void*>(&playlists));
 955
 956   if (ret != MEDIA_CONTENT_ERROR_NONE) {
 957     PlatformResult err = LogAndCreateResult(
 958         ErrorCode::UNKNOWN_ERR, "Getting playlist is failed.",
 959         ("Failed: Getting playlist is failed %d (%s)", ret, get_error_message(ret)));
 960     user_data->isSuccess = err;
 961   }
 962
 963   user_data->result = picojson::value(playlists);
 964 }
 965
 966 void ContentManager::removePlaylist(std::string playlistId,
 967                                     const std::shared_ptr<ReplyCallbackData>& user_data) {
 968   ScopeLogger();
 969   int id = std::atoi(playlistId.c_str());
 970   if (id == 0) {
 971     PlatformResult err = LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "PlaylistId is wrong.");
 972     user_data->isSuccess = err;
 973     return;
 974   }
 975
 976   int ret = media_playlist_delete_from_db(id);
 977   if (ret != MEDIA_CONTENT_ERROR_NONE) {
 978     PlatformResult err =
 979         LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Removal of playlist is failed.");
 980     user_data->isSuccess = err;
 981   }
 982 }
 983
 984 int ContentManager::update(picojson::value args) {
 985   ScopeLogger();
 986
 987   int ret;
 988   picojson::value content = args.get("content");
 989   std::string id = content.get("id").to_str();
 990
 991   media_info_h media = NULL;
 992   ret = media_info_get_media_from_db(id.c_str(), &media);
 993   if (ret == MEDIA_CONTENT_ERROR_NONE) {
 994     setContent(media, content);
 995     ret = media_info_update_to_db(media);
 996     media_info_destroy(media);
 997   }
 998
 999   return ret;
1000 }
1001
1002 int ContentManager::updateBatch(picojson::value args) {
1003   ScopeLogger();
1004   int ret = 0;
1005   std::vector<picojson::value> contents = args.get("contents").get<picojson::array>();
1006
1007   for (picojson::value::array::iterator it = contents.begin(); it != contents.end(); ++it) {
1008     picojson::value content = *it;
1009     std::string id = content.get("id").to_str();
1010     media_info_h media = NULL;
1011     ret = media_info_get_media_from_db(id.c_str(), &media);
1012     if (media != NULL && ret == MEDIA_CONTENT_ERROR_NONE) {
1013       ret = setContent(media, content);
1014       if (ret != MEDIA_CONTENT_ERROR_NONE) {
1015         LoggerE("setContent failed");
1016         return ret;
1017       }
1018
1019       ret = media_info_update_to_db(media);
1020       if (ret != MEDIA_CONTENT_ERROR_NONE) {
1021         LoggerE("update to db failed");
1022       }
1023       media_info_destroy(media);
1024     } else {
1025       return ret;
1026     }
1027   }
1028   return ret;
1029 }
1030
1031 int ContentManager::playlistAdd(std::string playlist_id, std::string content_id) {
1032   ScopeLogger();
1033
1034   media_playlist_h playlist = NULL;
1035   int ret = media_playlist_get_playlist_from_db(std::stoi(playlist_id), &playlist);
1036
1037   if (playlist != NULL && ret == MEDIA_CONTENT_ERROR_NONE) {
1038     ret = media_playlist_add_media(playlist, content_id.c_str());
1039     if (ret != MEDIA_CONTENT_ERROR_NONE) {
1040       LoggerE("The content(id:%s) can't add to playlist", content_id.c_str());
1041     }
1042
1043     ret = media_playlist_update_to_db(playlist);
1044     if (ret != MEDIA_CONTENT_ERROR_NONE) {
1045       LoggerE("The content(id:%s) can't add to playlist", content_id.c_str());
1046     }
1047   } else {
1048     LoggerE("Playlist(id:%s) is not exist", playlist_id.c_str());
1049   }
1050
1051   media_playlist_destroy(playlist);
1052   return ret;
1053 }
1054
1055 int ContentManager::playlistRemove(std::string playlist_id, int member_id) {
1056   ScopeLogger();
1057
1058   media_playlist_h playlist = NULL;
1059   int ret = media_playlist_get_playlist_from_db(std::stoi(playlist_id), &playlist);
1060   if (playlist != NULL && ret == MEDIA_CONTENT_ERROR_NONE) {
1061     ret = media_playlist_remove_media(playlist, member_id);
1062     if (ret != MEDIA_CONTENT_ERROR_NONE) {
1063       LoggerE("The content can't remove to playlist");
1064     }
1065
1066     ret = media_playlist_update_to_db(playlist);
1067     if (ret != MEDIA_CONTENT_ERROR_NONE) {
1068       LoggerE("The content can't remove to playlist");
1069     }
1070   } else {
1071     LoggerE("Playlist(id:%s) is not exist", playlist_id.c_str());
1072   }
1073   media_playlist_destroy(playlist);
1074
1075   return ret;
1076 }
1077
1078 void ContentManager::playlistAddbatch(const std::shared_ptr<ReplyCallbackData>& user_data) {
1079   ScopeLogger();
1080   std::string playlist_id = user_data->args.get("playlistId").get<std::string>();
1081
1082   media_playlist_h playlist = NULL;
1083   int ret = media_playlist_get_playlist_from_db(std::stoi(playlist_id), &playlist);
1084
1085   if (ret != MEDIA_CONTENT_ERROR_NONE && playlist == NULL) {
1086     PlatformResult err =
1087         LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Getting playlist is failed.",
1088                            ("Getting playlist is failed: %d (%s)", ret, get_error_message(ret)));
1089     user_data->isSuccess = err;
1090     return;
1091   }
1092
1093   std::vector<picojson::value> contents = user_data->args.get("contents").get<picojson::array>();
1094   for (picojson::value::array::iterator it = contents.begin(); it != contents.end(); ++it) {
1095     picojson::value content = *it;
1096     std::string id = content.get("id").to_str();
1097     ret = media_playlist_add_media(playlist, id.c_str());
1098     if (ret != MEDIA_CONTENT_ERROR_NONE) {
1099       LoggerE("Adding Content(id:%s) is failed.", id.c_str());
1100     }
1101   }
1102
1103   ret = media_playlist_update_to_db(playlist);
1104   if (ret != MEDIA_CONTENT_ERROR_NONE) {
1105     PlatformResult err =
1106         LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Adding playlist is failed.",
1107                            ("Adding playlist is failed: %d (%s)", ret, get_error_message(ret)));
1108     user_data->isSuccess = err;
1109   }
1110   media_playlist_destroy(playlist);
1111 }
1112
1113 void ContentManager::playlistGet(const std::shared_ptr<ReplyCallbackData>& user_data) {
1114   ScopeLogger();
1115   media_playlist_h playlist = NULL;
1116   media_content_order_e order = MEDIA_CONTENT_ORDER_ASC;
1117   const std::string playOrder("play_order");
1118
1119   SCOPE_EXIT {
1120     if (playlist) {
1121       media_playlist_destroy(playlist);
1122     }
1123   };
1124
1125   std::string playlist_id = user_data->args.get("playlistId").get<std::string>();
1126   int ret = media_playlist_get_playlist_from_db(std::stoi(playlist_id), &playlist);
1127   if (ret != MEDIA_CONTENT_ERROR_NONE && playlist == NULL) {
1128     PlatformResult err =
1129         LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Getting playlist is failed.",
1130                            ("Getting playlist is failed: %d (%s)", ret, get_error_message(ret)));
1131     user_data->isSuccess = err;
1132     return;
1133   }
1134
1135   filter_h filter = NULL;
1136   ret = media_filter_create(&filter);
1137   if (ret != MEDIA_CONTENT_ERROR_NONE) {
1138     PlatformResult err =
1139         LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Creating a filter is failed.",
1140                            ("Creating a filter is failed: %d (%s)", ret, get_error_message(ret)));
1141     user_data->isSuccess = err;
1142     return;
1143   }
1144
1145   int count = user_data->args.get("count").get<double>();
1146   int offset = user_data->args.get("offset").get<double>();
1147   ret = media_filter_set_offset(filter, offset, count);
1148   if (ret != MEDIA_CONTENT_ERROR_NONE) {
1149     LoggerD("Setting a offset/count is failed.");
1150   }
1151   ret = media_filter_set_order(filter, order, playOrder.c_str(), MEDIA_CONTENT_COLLATE_DEFAULT);
1152   if (ret != MEDIA_CONTENT_ERROR_NONE) {
1153     LoggerD("Setting a offset/count is failed.");
1154   }
1155
1156   picojson::value::array arrayContent;
1157   ret = media_playlist_foreach_media_from_db(std::stoi(playlist_id), filter,
1158                                              playlist_content_member_cb,
1159                                              static_cast<void*>(&arrayContent));
1160
1161   media_filter_destroy(filter);
1162   if (ret == MEDIA_CONTENT_ERROR_NONE) {
1163     user_data->result = picojson::value(arrayContent);
1164   } else {
1165     PlatformResult err =
1166         LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Creating a filter is failed.",
1167                            ("Creating a filter is failed: %d (%s)", ret, get_error_message(ret)));
1168     user_data->isSuccess = err;
1169   }
1170 }
1171
1172 void ContentManager::playlistRemovebatch(const std::shared_ptr<ReplyCallbackData>& user_data) {
1173   ScopeLogger();
1174   media_playlist_h playlist = NULL;
1175
1176   SCOPE_EXIT {
1177     if (playlist) {
1178       media_playlist_destroy(playlist);
1179     }
1180   };
1181
1182   std::string playlist_id = user_data->args.get("playlistId").get<std::string>();
1183   int ret = media_playlist_get_playlist_from_db(std::stoi(playlist_id), &playlist);
1184   if (ret != MEDIA_CONTENT_ERROR_NONE && playlist == NULL) {
1185     PlatformResult err =
1186         LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Getting playlist is failed.",
1187                            ("Getting playlist is failed: %d (%s)", ret, get_error_message(ret)));
1188     user_data->isSuccess = err;
1189     return;
1190   }
1191
1192   std::vector<picojson::value> members = user_data->args.get("members").get<picojson::array>();
1193   std::size_t members_size = members.size();
1194   for (std::size_t i = 0; i < members_size; ++i) {
1195     int member_id = static_cast<int>(members.at(i).get<double>());
1196     ret = media_playlist_remove_media(playlist, member_id);
1197
1198     if (ret != MEDIA_CONTENT_ERROR_NONE) {
1199       LoggerD("Removing a content is failed.");
1200     }
1201   }
1202
1203   ret = media_playlist_update_to_db(playlist);
1204   if (ret != MEDIA_CONTENT_ERROR_NONE) {
1205     PlatformResult err = LogAndCreateResult(
1206         ErrorCode::UNKNOWN_ERR, "Removing the contents is failed.",
1207         ("Removing the contents is failed: %d (%s)", ret, get_error_message(ret)));
1208     user_data->isSuccess = err;
1209   }
1210 }
1211
1212 void ContentManager::playlistSetOrder(const std::shared_ptr<ReplyCallbackData>& user_data) {
1213   ScopeLogger();
1214   media_playlist_h playlist = NULL;
1215
1216   SCOPE_EXIT {
1217     if (playlist) {
1218       media_playlist_destroy(playlist);
1219     }
1220   };
1221
1222   std::string playlist_id = user_data->args.get("playlistId").get<std::string>();
1223   int ret = media_playlist_get_playlist_from_db(std::stoi(playlist_id), &playlist);
1224   if (ret != MEDIA_CONTENT_ERROR_NONE && playlist == NULL) {
1225     PlatformResult err =
1226         LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Getting playlist is failed.",
1227                            ("Getting playlist is failed: %d (%s)", ret, get_error_message(ret)));
1228     user_data->isSuccess = err;
1229     return;
1230   }
1231
1232   int cnt;
1233   std::vector<picojson::value> members = user_data->args.get("members").get<picojson::array>();
1234
1235   ret = media_playlist_get_media_count_from_db(std::stoi(playlist_id), NULL, &cnt);
1236   if (ret != MEDIA_CONTENT_ERROR_NONE) {
1237     LoggerE("Failed: media_playlist_get_media_count_from_db");
1238     PlatformResult err = convertError(ret);
1239     user_data->isSuccess = err;
1240     return;
1241   }
1242   std::size_t members_size = members.size();
1243   if (cnt < 0 || static_cast<size_t>(cnt) != members_size) {
1244     PlatformResult err = LogAndCreateResult(
1245         ErrorCode::INVALID_VALUES_ERR,
1246         "The items array does not contain all items from the playlist.",
1247         ("Failed: The items array does not contain all items from the playlist: %d (%s)", ret,
1248          get_error_message(ret)));
1249     user_data->isSuccess = err;
1250     return;
1251   }
1252
1253   for (std::size_t i = 0; i < members_size; ++i) {
1254     int member_id = static_cast<int>(members.at(i).get<double>());
1255     ret = media_playlist_set_play_order(playlist, member_id, i);
1256     if (ret != MEDIA_CONTENT_ERROR_NONE) {
1257       LoggerD("Removing a content is failed.");
1258     }
1259   }
1260
1261   ret = media_playlist_update_to_db(playlist);
1262   if (ret != MEDIA_CONTENT_ERROR_NONE) {
1263     PlatformResult err = LogAndCreateResult(
1264         ErrorCode::UNKNOWN_ERR, "Removing the contents is failed.",
1265         ("Removing the contents is failed: %d (%s)", ret, get_error_message(ret)));
1266     user_data->isSuccess = err;
1267   }
1268 }
1269
1270 void ContentManager::playlistMove(const std::shared_ptr<ReplyCallbackData>& user_data) {
1271   ScopeLogger();
1272   media_playlist_h playlist = NULL;
1273
1274   SCOPE_EXIT {
1275     if (playlist) {
1276       media_playlist_destroy(playlist);
1277     }
1278   };
1279
1280   std::string playlist_id = user_data->args.get("playlistId").get<std::string>();
1281   int ret = media_playlist_get_playlist_from_db(std::stoi(playlist_id), &playlist);
1282   if (ret != MEDIA_CONTENT_ERROR_NONE && playlist == NULL) {
1283     PlatformResult err =
1284         LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Getting playlist is failed.",
1285                            ("Getting playlist is failed: %d (%s)", ret, get_error_message(ret)));
1286     user_data->isSuccess = err;
1287     return;
1288   }
1289   int old_order;
1290   double member_id = user_data->args.get("memberId").get<double>();
1291   double delta = user_data->args.get("delta").get<double>();
1292   ret = media_playlist_get_play_order(playlist, static_cast<int>(member_id), &old_order);
1293   if (ret != MEDIA_CONTENT_ERROR_NONE) {
1294     PlatformResult err = LogAndCreateResult(
1295         ErrorCode::UNKNOWN_ERR, "The content can't find form playlist.",
1296         ("The content can't find form playlist: %d (%s)", ret, get_error_message(ret)));
1297     user_data->isSuccess = err;
1298     return;
1299   }
1300   int new_order = static_cast<int>(old_order) + static_cast<int>(delta);
1301   ret = media_playlist_set_play_order(playlist, static_cast<int>(member_id), new_order);
1302   if (ret != MEDIA_CONTENT_ERROR_NONE) {
1303     PlatformResult err = LogAndCreateResult(
1304         ErrorCode::UNKNOWN_ERR, "The content can't update play_order.",
1305         ("The content can't update play_order: %d (%s)", ret, get_error_message(ret)));
1306     user_data->isSuccess = err;
1307     return;
1308   }
1309   ret = media_playlist_update_to_db(playlist);
1310   if (ret != MEDIA_CONTENT_ERROR_NONE) {
1311     PlatformResult err = LogAndCreateResult(
1312         ErrorCode::UNKNOWN_ERR, "Updateing play_order is failed.",
1313         ("Updateing play_order is failed: %d (%s)", ret, get_error_message(ret)));
1314     user_data->isSuccess = err;
1315   }
1316 }
1317
1318 int ContentManager::getLyrics(const picojson::value& args, picojson::object& result) {
1319   ScopeLogger();
1320
1321   int ret = METADATA_EXTRACTOR_ERROR_NONE;
1322   const std::string& contentURI = args.get("contentURI").to_str();
1323   if (contentURI.empty()) {
1324     LoggerE("contentURI empty - skipping media extractor");
1325     return -1;
1326   }
1327
1328   metadata_extractor_h extractor;
1329   ret = metadata_extractor_create(&extractor);
1330   if (METADATA_EXTRACTOR_ERROR_NONE != ret) {
1331     LoggerE("metadata_extractor_create failed, error: %d", ret);
1332   }
1333   std::unique_ptr<std::remove_pointer<metadata_extractor_h>::type, int (*)(metadata_extractor_h)>
1334       extractor_ptr(extractor, &metadata_extractor_destroy);  // automatically release the memory
1335
1336   ret = metadata_extractor_set_path(extractor, contentURI.c_str());
1337   if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
1338     LoggerE("metadata_extractor_set_path failed, error: %d", ret);
1339     return ret;
1340   }
1341   picojson::array timestamps;
1342   picojson::array texts = picojson::array();
1343   char* strSyncTextNum = NULL;
1344
1345   ret = metadata_extractor_get_metadata(extractor, METADATA_SYNCLYRICS_NUM, &strSyncTextNum);
1346   if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
1347     LoggerE("Media extractor error %d", ret);
1348     return ret;
1349   }
1350
1351   int nSyncTextNum = 0;
1352   if (strSyncTextNum) {
1353     nSyncTextNum = atoi(strSyncTextNum);
1354     free(strSyncTextNum);
1355     strSyncTextNum = NULL;
1356   }
1357   if (nSyncTextNum > 0) {
1358     result["type"] = picojson::value(std::string("SYNCHRONIZED"));
1359     for (int i = 0; i < nSyncTextNum; i++) {
1360       unsigned long time_info = 0;
1361       char* lyrics = NULL;
1362       ret = metadata_extractor_get_synclyrics(extractor, i, &time_info, &lyrics);
1363       if (ret == METADATA_EXTRACTOR_ERROR_NONE) {
1364         timestamps.push_back(picojson::value(static_cast<double>(time_info)));
1365         texts.push_back(picojson::value(std::string(lyrics)));
1366         free(lyrics);
1367       }
1368     }
1369     result["texts"] = picojson::value(texts);
1370     result["timestamps"] = picojson::value(timestamps);
1371     ret = METADATA_EXTRACTOR_ERROR_NONE;
1372   } else {
1373     char* unSyncText = nullptr;
1374     ret = metadata_extractor_get_metadata(extractor, METADATA_UNSYNCLYRICS, &unSyncText);
1375     if (ret == METADATA_EXTRACTOR_ERROR_NONE) {
1376       result["type"] = picojson::value(std::string("UNSYNCHRONIZED"));
1377       if (nullptr == unSyncText) {
1378         LoggerE("Unsynchronized lyrics text is NULL");
1379       }
1380       texts.push_back(picojson::value(unSyncText ? unSyncText : ""));
1381       result["texts"] = picojson::value(texts);
1382       free(unSyncText);
1383     }
1384   }
1385
1386   return ret;
1387 }
1388
1389 media_playlist_h getPlaylistHandle(int id) {
1390   ScopeLogger();
1391   media_playlist_h playlist_handle = nullptr;
1392   int ret_code = media_playlist_get_playlist_from_db(id, &playlist_handle);
1393   if (MEDIA_CONTENT_ERROR_NONE != ret_code || playlist_handle == nullptr) {
1394     LoggerE("could not get playlist handle for id: %d", id);
1395     return nullptr;
1396   }
1397
1398   return playlist_handle;
1399 }
1400
1401 void destroyMediaPlaylistHandle(media_playlist_h& playlist_handle) {
1402   ScopeLogger();
1403   if (playlist_handle) {
1404     int ret_code = media_playlist_destroy(playlist_handle);
1405     playlist_handle = nullptr;
1406
1407     if (MEDIA_CONTENT_ERROR_NONE != ret_code) {
1408       LoggerE("media_playlist_destroy failed");
1409     }
1410   }
1411 }
1412
1413 int ContentManager::getPlaylistName(int id, std::string* result) {
1414   ScopeLogger();
1415   media_playlist_h playlist_handle = getPlaylistHandle(id);
1416   PlaylistUniquePtr playlist_ptr(playlist_handle, destroyMediaPlaylistHandle);
1417
1418   char* tmp_playlist_name = nullptr;
1419   const int ret_code = media_playlist_get_name(playlist_handle, &tmp_playlist_name);
1420
1421   if (MEDIA_CONTENT_ERROR_NONE != ret_code) {
1422     LoggerE("media_playlist_get_name failed");
1423     return TIZEN_ERROR_UNKNOWN;
1424   }
1425
1426   std::string playlist_name;
1427   if (tmp_playlist_name) {
1428     playlist_name = tmp_playlist_name;
1429     free(tmp_playlist_name);
1430     tmp_playlist_name = nullptr;
1431   }
1432
1433   *result = playlist_name;
1434   return MEDIA_CONTENT_ERROR_NONE;
1435 }
1436
1437 int updatePlaylistInDB(media_playlist_h playlist_handle) {
1438   ScopeLogger();
1439   int ret_code = media_playlist_update_to_db(playlist_handle);
1440   if (MEDIA_CONTENT_ERROR_NONE != ret_code) {
1441     LoggerE("media_playlist_update_to_db failed");
1442     return ret_code;
1443   }
1444   return MEDIA_CONTENT_ERROR_NONE;
1445 }
1446
1447 int ContentManager::setPlaylistName(int id, const std::string& name) {
1448   ScopeLogger();
1449   if (name.empty()) {
1450     LoggerE("Cannot set empty playlist name!");
1451     return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1452   }
1453
1454   media_playlist_h playlist_handle = getPlaylistHandle(id);
1455   PlaylistUniquePtr playlist_ptr(playlist_handle, destroyMediaPlaylistHandle);
1456
1457   const int ret_code = media_playlist_set_name(playlist_handle, name.c_str());
1458   if (MEDIA_CONTENT_ERROR_NONE != ret_code) {
1459     LoggerE("media_playlist_set_name failed");
1460     // Setting name that is used by other playlist does not return bad error code here.
1461     // MEDIA_CONTENT_ERROR_INVALID_OPERATION is being returned in updatePlaylistInDB
1462     return TIZEN_ERROR_UNKNOWN;
1463   }
1464
1465   int ret = updatePlaylistInDB(playlist_handle);
1466   if (MEDIA_CONTENT_ERROR_NONE != ret) {
1467     LoggerE("Error while updating playlist: %d", ret);
1468     if (MEDIA_CONTENT_ERROR_DB_FAILED == ret) {
1469       // We could fetch list of playlists and check if other playlist is using this
1470       // name, but that seems to be to much work in synchronous method
1471       LoggerE("Playlist name: %s is probably already used", name.c_str());
1472       return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1473     }
1474     return ret;
1475   }
1476   return MEDIA_CONTENT_ERROR_NONE;
1477 }
1478
1479 int ContentManager::getThumbnailUri(int id, std::string* result) {
1480   ScopeLogger();
1481   media_playlist_h playlist_handle = getPlaylistHandle(id);
1482   PlaylistUniquePtr playlist_ptr(playlist_handle, destroyMediaPlaylistHandle);
1483
1484   char* tmp_playlist_thb_path = nullptr;
1485   const int ret_code = media_playlist_get_thumbnail_path(playlist_handle, &tmp_playlist_thb_path);
1486
1487   if (MEDIA_CONTENT_ERROR_NONE != ret_code) {
1488     LoggerE("media_playlist_get_name failed");
1489     return TIZEN_ERROR_UNKNOWN;
1490   }
1491
1492   std::string playlist_thb_path;
1493   if (tmp_playlist_thb_path) {
1494     playlist_thb_path = tmp_playlist_thb_path;
1495     free(tmp_playlist_thb_path);
1496     tmp_playlist_thb_path = nullptr;
1497   }
1498
1499   if (playlist_thb_path != " ") {
1500     playlist_thb_path = uri_prefix + playlist_thb_path;
1501   }
1502
1503   *result = playlist_thb_path;
1504   return MEDIA_CONTENT_ERROR_NONE;
1505 }
1506
1507 int ContentManager::setThumbnailUri(int id, const std::string& thb_uri) {
1508   ScopeLogger();
1509
1510   // Allow setting empty URI, unfortunately Core API does not allow to set empty
1511   // path so we need to set one empty space. This is probably issue of Core API.
1512   if (!thb_uri.empty() && " " != thb_uri) {
1513     if (thb_uri.find(uri_absolute_prefix) != 0) {
1514       LoggerE("thumbnail URI is not valid: [%s]", thb_uri.c_str());
1515       return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
1516     }
1517   }
1518
1519   media_playlist_h playlist_handle = getPlaylistHandle(id);
1520   PlaylistUniquePtr playlist_ptr(playlist_handle, destroyMediaPlaylistHandle);
1521
1522   std::string real_path = common::FilesystemProvider::Create().GetRealPath(thb_uri);
1523   const int ret_code = media_playlist_set_thumbnail_path(playlist_handle, real_path.c_str());
1524   if (MEDIA_CONTENT_ERROR_NONE != ret_code) {
1525     LoggerE("media_playlist_set_thumbnail_path failed");
1526     return TIZEN_ERROR_UNKNOWN;
1527   }
1528
1529   int ret = updatePlaylistInDB(playlist_handle);
1530   return ret;
1531 }
1532
1533 int ContentManager::getNumberOfTracks(int id, int* result) {
1534   ScopeLogger();
1535
1536   int count = 0;
1537   const int ret_code = media_playlist_get_media_count_from_db(id, nullptr, &count);
1538
1539   if (MEDIA_CONTENT_ERROR_NONE != ret_code) {
1540     LoggerE("media_playlist_get_media_count_from_db failed");
1541     return TIZEN_ERROR_UNKNOWN;
1542   }
1543
1544   *result = count;
1545   return MEDIA_CONTENT_ERROR_NONE;
1546 }
1547
1548 common::PlatformResult ContentManager::createThumbnail(const std::string& id,
1549                                                        picojson::object* obj) {
1550   ScopeLogger();
1551
1552   media_info_h media_h = nullptr;
1553   int ret = media_info_get_media_from_db(id.c_str(), &media_h);
1554   if (MEDIA_CONTENT_ERROR_NONE != ret || nullptr == media_h) {
1555     return LogAndCreateResult(ErrorCode::ABORT_ERR, "Getting media failed.",
1556                               ("Getting media failed: %d (%s)", ret, get_error_message(ret)));
1557   }
1558   SCOPE_EXIT {
1559     media_info_destroy(media_h);
1560   };
1561
1562   ret = media_info_generate_thumbnail(media_h);
1563   if (MEDIA_CONTENT_ERROR_NONE != ret) {
1564     return LogAndCreateResult(ErrorCode::ABORT_ERR, "Creating thumbnail failed.",
1565                               ("Creating thumbnail failed: %d (%s)", ret, get_error_message(ret)));
1566   }
1567
1568   char* path = nullptr;
1569   ret = media_info_get_thumbnail_path(media_h, &path);
1570   if (MEDIA_CONTENT_ERROR_NONE != ret) {
1571     return LogAndCreateResult(
1572         ErrorCode::ABORT_ERR, "Creating thumbnail succeeded, but failed to get thumbnail path.",
1573         ("Getting thumbnail path failed: %d (%s)", ret, get_error_message(ret)));
1574   }
1575   obj->emplace("result", picojson::value(path));
1576   std::unique_ptr<char[], decltype(&free)>(path, free);
1577   return PlatformResult(ErrorCode::NO_ERROR);
1578 }
1579
1580 PlatformResult ContentManager::convertError(int err) {
1581   char* error_msg = get_error_message(err);
1582   switch (err) {
1583     case MEDIA_CONTENT_ERROR_INVALID_PARAMETER:
1584       return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, error_msg);
1585     case MEDIA_CONTENT_ERROR_OUT_OF_MEMORY:
1586       return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, error_msg);
1587     case MEDIA_CONTENT_ERROR_INVALID_OPERATION:
1588       return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, error_msg);
1589     case MEDIA_CONTENT_FILE_NO_SPACE_ON_DEVICE:
1590       return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, error_msg);
1591     case MEDIA_CONTENT_ERROR_PERMISSION_DENIED:
1592       return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, error_msg);
1593     case MEDIA_CONTENT_ERROR_DB_FAILED:
1594       return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, error_msg);
1595     case MEDIA_CONTENT_ERROR_DB_BUSY:
1596       return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, error_msg);
1597     case MEDIA_CONTENT_ERROR_NETWORK:
1598       return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, error_msg);
1599     case MEDIA_CONTENT_ERROR_UNSUPPORTED_CONTENT:
1600       return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, error_msg);
1601     default:
1602       return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unknown error.");
1603   }
1604 }
1605
1606 }  // namespace content
1607 }  // namespace extension