src/FCnt_PlayListImpl.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   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  * @file                FCnt_PlayLisImpl.cpp
  18  * @brief               This is the implementation file for the %_PlayListImpl class.
  19  *
  20  * This file contains implementation of the %_PlayListImpl class.
  21  */
  22
  23 #include <FBaseSysLog.h>
  24 #include <FBaseInteger.h>
  25 #include <FBaseLongLong.h>
  26 #include <FBaseFloat.h>
  27 #include <FCntPlayList.h>
  28 #include <FBase_StringConverter.h>
  29 #include <FCnt_PlayListImpl.h>
  30 #include <FCnt_ContentUtility.h>
  31
  32 using namespace Tizen::Base;
  33 using namespace Tizen::Base::Collection;
  34 using namespace Tizen::Io;
  35
  36 namespace Tizen { namespace Content
  37 {
  38         // Declaration for Callback function registered to playlist details
  39         bool MediaPlayListImplCb(media_playlist_h playlistHandle, void *pUserData);
  40
  41         // Declaration for Callback function registered to playlist items details
  42         bool PlaylistImplItemCb(int playlistMemberId, media_info_h media, void *pUserData);
  43
  44         // Declaration for Callback function registered to playlist items details
  45         bool PlaylistItemsCb(int playlistId, media_info_h media, void *pUserData);
  46
  47 _PlayListImpl::_PlayListImpl(void)
  48         : Object()
  49         , __pFilterHandle(NULL)
  50         , __playListName(L"")
  51 {
  52
  53 }
  54
  55 //(disconnects the DB connection)
  56 _PlayListImpl::~_PlayListImpl(void)
  57 {
  58         int ret = MEDIA_CONTENT_ERROR_NONE;
  59         result r = E_SUCCESS;
  60
  61         ret = media_content_disconnect();
  62         r = MapCoreErrorToNativeResult(ret);
  63         SysTryLog(r == E_SUCCESS, "[%s] Propagating for media_content_disconnect", GetErrorMessage(r));
  64
  65         SysLog(NID_CNT, "media_content_disconnect result[%d].", ret);
  66 }
  67
  68  _PlayListImpl*
  69  _PlayListImpl::GetInstance(PlayList& playList)
  70 {
  71         return (&playList != null) ? playList.__pImpl : null;
  72 }
  73
  74 const _PlayListImpl*
  75 _PlayListImpl::GetInstance(const PlayList& playList)
  76 {
  77         return (&playList != null) ? playList.__pImpl : null;
  78 }
  79
  80 result
  81 _PlayListImpl::Construct(const Tizen::Base::String& playListName, bool isAdd)
  82 {
  83         int ret = media_content_connect();
  84         result r = MapCoreErrorToNativeResult(ret);
  85         SysTryReturnResult(NID_CNT, r == E_SUCCESS , r, "Propagating for media_content_connect");
  86
  87         SysLog(NID_CNT, "media_content_connect result[%d].", ret);
  88
  89         __playListName = playListName;
  90
  91         if (isAdd == true)
  92         {
  93                 std::unique_ptr<char[]> pInputCond(_StringConverter::CopyToCharArrayN(playListName));
  94                 SysTryReturnResult(NID_CNT, pInputCond, E_OUT_OF_MEMORY, "The memory is insufficient.");
  95
  96                 media_playlist_h tempHandle = null;
  97                 ret = media_playlist_insert_to_db(pInputCond.get(), &tempHandle);
  98                 r = MapCoreErrorToNativeResult(ret);
  99
 100                 std::unique_ptr<media_playlist_s, PlayListHandleDeleter> pPlaylistHandle(tempHandle);
 101                 SysTryReturnResult(NID_CNT, pPlaylistHandle != null, E_OUT_OF_MEMORY, "pPlaylistHandle is null.");
 102         }
 103
 104         return r;
 105 }
 106
 107 result
 108 _PlayListImpl::CreateFilterUsingContentId(const ContentId& contentId) const
 109 {
 110         std::unique_ptr<char[]> pInputCond;
 111         filter_h tempFilter = NULL;
 112         String uuidStr = L"";
 113         String playListName = L"";
 114         String inputCondition = L"MEDIA_ID = ";
 115         String inputListNameCondition = L"PLAYLIST_NAME = ";
 116
 117         int ret = media_filter_create(&tempFilter);
 118         result r = MapCoreErrorToNativeResult(ret);
 119         SysTryReturnResult(NID_CNT, ret == MEDIA_CONTENT_ERROR_NONE, r, "Failed to perform media_filter_create operation.");
 120
 121         std::unique_ptr<filter_s, FilterHandleDeleter> pFilterHandle(tempFilter);
 122         SysTryReturnResult(NID_CNT, pFilterHandle != null, E_OUT_OF_MEMORY, "pFilterHandle is null.");
 123
 124         uuidStr = contentId.ToString();
 125         r = uuidStr.Insert('"', 0);
 126         SysTryReturnResult(NID_CNT, r == E_SUCCESS, r, "Failed to perform Insert operation for uuidStr.");
 127         r = uuidStr.Insert('"', uuidStr.GetLength());
 128         SysTryReturnResult(NID_CNT, r == E_SUCCESS, r, "Failed to perform Insert operation for uuidStr.");
 129
 130         r = inputCondition.Append(uuidStr);
 131         SysTryReturnResult(NID_CNT, r == E_SUCCESS, r, "Failed to perform Append operation for inputCondition.");
 132
 133         playListName = __playListName;
 134         r = playListName.Insert('"', 0);
 135         SysTryReturnResult(NID_CNT, r == E_SUCCESS, r, "Failed to perform Insert operation for playListName.");
 136         r = playListName.Insert('"', playListName.GetLength());
 137         SysTryReturnResult(NID_CNT, r == E_SUCCESS, r, "Failed to perform Insert operation for playListName.");
 138
 139         r = inputListNameCondition.Append(playListName);
 140         SysTryReturnResult(NID_CNT, r == E_SUCCESS, r, "Failed to perform Append operation for inputListNameCondition.");
 141
 142         r = inputCondition.Append(" AND ");
 143         SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform append operation.");
 144
 145         r = inputCondition.Append(inputListNameCondition);
 146         SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform append operation.");
 147
 148         if (!inputCondition.IsEmpty())
 149         {
 150                 //CopyToCharArrayN: utility function, converts a osp string to char*
 151                 pInputCond = std::unique_ptr<char[]>(_StringConverter::CopyToCharArrayN(inputCondition));
 152                 SysTryReturnResult(NID_CNT, pInputCond, E_SYSTEM, "pInputCond is NULL.");
 153
 154                 SysLog(NID_CNT, "pInputCond = %s", pInputCond.get());
 155
 156                 ret = media_filter_set_condition(pFilterHandle.get(), pInputCond.get(), MEDIA_CONTENT_COLLATE_DEFAULT);
 157                 r = MapCoreErrorToNativeResult(ret);
 158                 SysTryReturnResult(NID_CNT, ret == MEDIA_CONTENT_ERROR_NONE, r, "Failed to perform media_filter_set_condition operation.");
 159         }
 160
 161         __pFilterHandle.reset(pFilterHandle.release());
 162
 163         return  r;
 164 }
 165
 166 result
 167 _PlayListImpl::CreateFilter(const Tizen::Base::String& playListName)const
 168 {
 169         std::unique_ptr<char[]> pInputCond;
 170         String inputCondition = L"PLAYLIST_NAME = ";
 171         String nameExpr(playListName);
 172         filter_h tempFilter = NULL;
 173
 174         int ret = media_filter_create(&tempFilter);
 175         result r = MapCoreErrorToNativeResult(ret);
 176         SysTryReturnResult(NID_CNT, ret == MEDIA_CONTENT_ERROR_NONE, r, "Failed to perform media_filter_create operation.");
 177
 178         std::unique_ptr<filter_s, FilterHandleDeleter> pFilterHandle(tempFilter);
 179         SysTryReturnResult(NID_CNT, pFilterHandle != null, E_OUT_OF_MEMORY, "pFilterHandle is null.");
 180
 181         if (!nameExpr.IsEmpty())
 182         {
 183                 r = nameExpr.Replace("\'", "''");
 184                 SysTryReturnResult(NID_CNT, r == E_SUCCESS, r, "Failed to perform Replace operation for nameExpr.");
 185
 186                 r = nameExpr.Insert('\'', 0);
 187                 SysTryReturnResult(NID_CNT, r == E_SUCCESS, r, "Failed to perform Insert operation for nameExpr.");
 188
 189                 r = nameExpr.Insert('\'', nameExpr.GetLength());
 190                 SysTryReturnResult(NID_CNT, r == E_SUCCESS, r, "Failed to perform Insert operation for nameExpr.");
 191
 192                 r = inputCondition.Append(nameExpr);
 193                 SysTryReturnResult(NID_CNT, r == E_SUCCESS, r, "Failed to perform Append operation for inputCondition.");
 194         }
 195
 196         if (!inputCondition.IsEmpty())
 197         {
 198                 //CopyToCharArrayN: utility function, converts a osp string to char*
 199                 pInputCond = std::unique_ptr<char[]>(_StringConverter::CopyToCharArrayN(inputCondition));
 200                 SysTryReturnResult(NID_CNT, pInputCond, E_SYSTEM, "pInputCond is NULL.");
 201
 202                 SysLog(NID_CNT, "pInputCond is [%s]", pInputCond.get());
 203
 204                 ret = media_filter_set_condition(pFilterHandle.get(), pInputCond.get(), MEDIA_CONTENT_COLLATE_DEFAULT);
 205                 r = MapCoreErrorToNativeResult(ret);
 206                 SysTryReturnResult(NID_CNT, ret == MEDIA_CONTENT_ERROR_NONE, r, "Failed to perform media_filter_set_condition operation.");
 207         }
 208
 209         __pFilterHandle.reset(pFilterHandle.release());
 210
 211         return  r;
 212 }
 213
 214 int
 215 _PlayListImpl::GetPlayListItemCount(const Tizen::Base::String& playlistName) const
 216 {
 217         std::unique_ptr<GList, GListDeleter> pItemList;
 218         GList* pTemp = NULL;
 219         std::unique_ptr<media_playlist_s, PlayListHandleDeleter> pPlaylistHandle;
 220         int playlistId = 0;
 221         int ret = MEDIA_CONTENT_ERROR_NONE;
 222         int playlistItemCount = 0;
 223
 224         result r = CreateFilter(playlistName);
 225         SysTryReturn(NID_CNT, r == E_SUCCESS, 0, E_DATABASE, "[E_DATABASE] Failed to perform CreateFilter operation.");
 226
 227         pTemp = pItemList.get();
 228         ret = media_playlist_foreach_playlist_from_db(__pFilterHandle.get(), MediaPlayListImplCb, &pTemp);
 229         r = MapCoreDatabaseErrorToNativeResult(ret);
 230         SysTryReturn(NID_CNT, r == E_SUCCESS , 0, r,
 231                         "[%s] Failed to perform media_playlist_foreach_playlist_from_db operation.", GetErrorMessage(r));
 232
 233         if (pTemp == NULL)
 234         {
 235                 r = E_DATABASE; // No match found.
 236         }
 237         else
 238         {
 239                 pPlaylistHandle.reset(static_cast<media_playlist_h>(g_list_nth_data(pTemp, 0)));
 240                 if (pPlaylistHandle.get() != NULL)
 241                 {
 242                         ret = media_playlist_get_playlist_id(pPlaylistHandle.get(), &playlistId);
 243                         r = MapCoreDatabaseErrorToNativeResult(ret);
 244                         SysTryReturn(NID_CNT, !IsFailed(r), 0, r, "[%s] Failed to perform media_playlist_get_playlist_id operation.", GetErrorMessage(r));
 245
 246                         ret = media_playlist_get_media_count_from_db(playlistId, NULL, &playlistItemCount);
 247                         r = MapCoreDatabaseErrorToNativeResult(ret);
 248                         SysTryReturn(NID_CNT, !IsFailed(r), 0, r, "[%s] Failed to perform media_playlist_get_media_count_from_db operation.", GetErrorMessage(r));
 249
 250                         SysLog(NID_CNT, "playlistItemCount is [%d] for media_playlist_get_media_count_from_db", playlistItemCount);
 251                 }
 252         }
 253
 254         SetLastResult(r);
 255         return playlistItemCount;
 256 }
 257
 258 Tizen::Base::Collection::IList*
 259 _PlayListImpl::GetContentInfoListN(const Tizen::Base::String& playlistName) const
 260 {
 261         std::unique_ptr<GList, GListDeleter> pItemList;
 262         GList* pTemp = NULL;
 263         std::unique_ptr<media_playlist_s, PlayListHandleDeleter> pPlaylistHandle;
 264         std::unique_ptr<ArrayList, AllElementsDeleter> pPlayListItemList;
 265         int playlistId = 0;
 266         int ret = MEDIA_CONTENT_ERROR_NONE;
 267
 268         result r = CreateFilter(playlistName);
 269         SysTryReturn(NID_CNT, r == E_SUCCESS, NULL, E_DATABASE, "[E_DATABASE] Failed to perform CreateFilter operation.");
 270
 271         pTemp = pItemList.get();
 272         ret = media_playlist_foreach_playlist_from_db(__pFilterHandle.get(), MediaPlayListImplCb, &pTemp);
 273         r = MapCoreDatabaseErrorToNativeResult(ret);
 274         SysTryReturn(NID_CNT, r == E_SUCCESS , NULL, r,
 275                         "[%s] Failed to perform media_playlist_foreach_playlist_from_db operation.", GetErrorMessage(r));
 276
 277         if (pTemp == NULL)
 278         {
 279                 r = E_DATABASE; // No match found.
 280         }
 281         else
 282         {
 283                 pPlaylistHandle.reset(static_cast<media_playlist_h>(g_list_nth_data(pTemp, 0)));
 284                 if (pPlaylistHandle.get() != NULL)
 285                 {
 286                         int playlistItemCount = 0;
 287
 288                         ret = media_playlist_get_playlist_id(pPlaylistHandle.get(), &playlistId);
 289                         r = MapCoreDatabaseErrorToNativeResult(ret);
 290                         SysTryReturn(NID_CNT, !IsFailed(r), NULL, r,
 291                                         "[%s] Failed to perform media_playlist_get_playlist_id operation.", GetErrorMessage(r));
 292
 293                         ret = media_playlist_get_media_count_from_db(playlistId, NULL, &playlistItemCount);
 294                         r = MapCoreDatabaseErrorToNativeResult(ret);
 295                         SysTryReturn(NID_CNT, !IsFailed(r), NULL, r,
 296                                         "[%s] Failed to perform media_playlist_get_media_count_from_db operation.", GetErrorMessage(r));
 297
 298                         SysLog(NID_CNT, "playlistItemCount is [%d] for media_playlist_get_media_count_from_db", playlistItemCount);
 299
 300                         pPlayListItemList = std::unique_ptr<ArrayList, AllElementsDeleter>(new (std::nothrow) ArrayList());
 301                         SysTryReturn(NID_CNT, pPlayListItemList != null, NULL, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] FinalOutList  is null.");
 302
 303                         r = pPlayListItemList->Construct();
 304                         SysTryReturn(NID_CNT, !IsFailed(r), NULL, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Failed to construct pPlayListItemList ArrayList.");
 305
 306                         if (playlistItemCount > 0)
 307                         {
 308                                 r = FillPlayListInfo(playlistId, pPlayListItemList.get());
 309                                 SysTryReturn(NID_CNT, !IsFailed(r), NULL, E_DATABASE, "Failed to perform FillPlayListInfo operation.");
 310                         }
 311                 }
 312         }
 313
 314         SetLastResult(r);
 315         return pPlayListItemList.release();
 316 }
 317
 318 result
 319 _PlayListImpl::FillPlayListInfo(int playlistId, ArrayList* pPlayListItemList) const
 320 {
 321         std::unique_ptr<GList, GListDeleter> pItemList;
 322         GList* pTemp = NULL;
 323         std::unique_ptr<media_info_s, MediaHandleDeleter> pMediaHandle;
 324
 325         ContentInfo::_ContentData* pContentData = null;
 326         ImageContentInfo::_ImageContentData* pImageContentData = null;
 327         AudioContentInfo::_AudioContentData* pAudioContentData = null;
 328         VideoContentInfo::_VideoContentData* pVideoContentData = null;
 329
 330         std::unique_ptr<ImageContentInfo> pImageContentInfo;
 331         std::unique_ptr<AudioContentInfo> pAudioContentInfo;
 332         std::unique_ptr<VideoContentInfo> pVideoContentInfo;
 333         std::unique_ptr<OtherContentInfo> pOtherContentInfo;
 334
 335         //SysTryReturn(NID_CNT, pPlayListItemList != NULL , r, r, "[E_SUCCESS] pPlayListItemList is null");
 336
 337         pTemp = pItemList.get();
 338         int ret = media_playlist_foreach_media_from_db(playlistId, NULL, PlaylistItemsCb, &pTemp);
 339         result r = MapCoreErrorToNativeResult(ret);
 340         SysTryReturnResult(NID_CNT, r == E_SUCCESS, r, "Failed to perform media_playlist_foreach_media_from_db operation.");
 341
 342         media_content_type_e mediaType = MEDIA_CONTENT_TYPE_OTHERS;
 343
 344         if (pTemp)
 345         {
 346                 for (int idx = 0; idx < (int)g_list_length(pTemp); idx++)
 347                 {
 348                         pMediaHandle.reset(static_cast<media_info_h>(g_list_nth_data(pTemp, idx)));
 349
 350                         ret = media_info_get_media_type(pMediaHandle.get(), &mediaType);
 351                         r = MapCoreErrorToNativeResult(ret);
 352                         SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform media_info_get_media_type.");
 353
 354                         switch (mediaType)
 355                         {
 356                         case MEDIA_CONTENT_TYPE_IMAGE:
 357                                 pImageContentInfo = std::unique_ptr<ImageContentInfo>(new (std::nothrow) ImageContentInfo);
 358                                 SysTryReturnResult(NID_CNT, pImageContentInfo.get() != null, E_OUT_OF_MEMORY, "Failed to create pImageContentInfo.");
 359
 360                                 pContentData = pImageContentInfo->GetContentData();
 361                                 SysTryReturnResult(NID_CNT, pContentData != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 362
 363                                 pImageContentData = pImageContentInfo->GetImageContentData();
 364                                 SysTryReturnResult(NID_CNT, pImageContentData != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 365
 366                                 r = _ContentUtility::FillContentData(pMediaHandle.get(), pContentData);
 367                                 SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform FillContentData operation.");
 368
 369                                 r = _ContentUtility::FillImageContentData(pMediaHandle.get(), pImageContentData);
 370                                 SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform GetDataFromImageTable operation.");
 371
 372                                 // Shallow copy, adds just the pointer: not the element
 373                                 r = pPlayListItemList->Add(*(pImageContentInfo.release()));
 374                                 SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform Add operation for ArrayList.");
 375
 376                                 break;
 377                         case MEDIA_CONTENT_TYPE_MUSIC:
 378                                 //fall through
 379                         case MEDIA_CONTENT_TYPE_SOUND:
 380                                 pAudioContentInfo = std::unique_ptr<AudioContentInfo>(new (std::nothrow) AudioContentInfo);
 381                                 SysTryReturnResult(NID_CNT, pAudioContentInfo.get() != null, E_OUT_OF_MEMORY, "Failed to create pAudioContentInfo.");
 382
 383                                 pContentData = pAudioContentInfo->GetContentData();
 384                                 SysTryReturnResult(NID_CNT, pContentData != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 385
 386                                 pAudioContentData = pAudioContentInfo->GetAudioContentData();
 387                                 SysTryReturnResult(NID_CNT, pAudioContentData != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 388
 389                                 r = _ContentUtility::FillContentData(pMediaHandle.get(), pContentData);
 390                                 SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform FillContentData operation.");
 391
 392                                 r = _ContentUtility::FillAudioContentData(pMediaHandle.get(), pAudioContentData);
 393                                 SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform FillAudioContentData operation.");
 394
 395                                 // Shallow copy, adds just the pointer: not the element
 396                                 r = pPlayListItemList->Add(*(pAudioContentInfo.release()));
 397                                 SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform Add operation for __pFinalOutList.");
 398
 399                                 break;
 400                         case MEDIA_CONTENT_TYPE_VIDEO:
 401                                 pVideoContentInfo = std::unique_ptr<VideoContentInfo>(new (std::nothrow) VideoContentInfo);
 402                                 SysTryReturnResult(NID_CNT, pVideoContentInfo.get() != null, E_OUT_OF_MEMORY, "Failed to create pVideoContentInfo.");
 403
 404                                 pContentData = pVideoContentInfo->GetContentData();
 405                                 SysTryReturnResult(NID_CNT, pContentData != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 406
 407                                 pVideoContentData = pVideoContentInfo->GetVideoContentData();
 408                                 SysTryReturnResult(NID_CNT, pVideoContentData != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 409
 410                                 r = _ContentUtility::FillContentData(pMediaHandle.get(), pContentData);
 411                                 SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform FillContentData operation.");
 412
 413                                 r = _ContentUtility::FillVideoContentData(pMediaHandle.get(), pVideoContentData);
 414                                 SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform FillVideoContentData operation.");
 415
 416                                 // Shallow copy, adds just the pointer: not the element
 417                                 r = pPlayListItemList->Add(*(pVideoContentInfo.release()));
 418                                 SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform Add operation for ArrayList.");
 419
 420                                 break;
 421                         case MEDIA_CONTENT_TYPE_OTHERS:
 422                                 pOtherContentInfo = std::unique_ptr<OtherContentInfo>(new (std::nothrow) OtherContentInfo);
 423                                 SysTryReturnResult(NID_CNT, pOtherContentInfo.get() != null, E_OUT_OF_MEMORY, "Failed to create pOtherContentInfo.");
 424
 425                                 pContentData = pOtherContentInfo->GetContentData();
 426                                 SysTryReturnResult(NID_CNT, pContentData != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 427
 428                                 r = _ContentUtility::FillContentData(pMediaHandle.get(), pContentData);
 429                                 SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform FillContentData operation.");
 430
 431                                 // Shallow copy, adds just the pointer: not the element
 432                                 r = pPlayListItemList->Add(*(pOtherContentInfo.release()));
 433                                 SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform Add operation for ArrayList.");
 434
 435                                 break;
 436                         default:
 437                                 break;
 438                         }
 439                 }
 440         }
 441
 442         return r;
 443 }
 444
 445 result
 446 _PlayListImpl::AddItemInternal(media_playlist_h playListHandle, const ContentId& contentId)
 447 {
 448         String uuidStr = L"";
 449         int ret = MEDIA_CONTENT_ERROR_NONE;
 450         result r = E_SUCCESS;
 451
 452         uuidStr = contentId.ToString();
 453         std::unique_ptr<char[]> pInputCond(_StringConverter::CopyToCharArrayN(uuidStr));
 454         SysTryReturnResult(NID_CNT, pInputCond, E_OUT_OF_MEMORY, "The memory is insufficient.");
 455
 456         ret = media_playlist_add_media(playListHandle, pInputCond.get());
 457         r = MapCoreErrorToNativeResult(ret);
 458         SysTryReturnResult(NID_CNT, r == E_SUCCESS, r, "Failed to perform media_playlist_add_media operation.");
 459
 460         ret = media_playlist_update_to_db(playListHandle);
 461         r = MapCoreErrorToNativeResult(ret);
 462         SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform media_playlist_update_to_db operation.");
 463
 464         return r;
 465 }
 466
 467 result
 468 _PlayListImpl::AddItem(const Tizen::Base::String& playlistName, const ContentId& contentId)
 469 {
 470         std::unique_ptr<media_playlist_s, PlayListHandleDeleter> pPlayListHandle;
 471         media_playlist_h tempHandle = NULL;
 472
 473         result r = CreateFilter(playlistName);
 474         SysTryReturnResult(NID_CNT, r == E_SUCCESS, E_DATABASE, "Failed to perform CreateFilter operation.");
 475
 476         tempHandle = pPlayListHandle.get();
 477         r = GetPlayListHandle(&tempHandle);
 478         SysTryReturnResult(NID_CNT, r == E_SUCCESS, E_DATABASE, "Failed to perform GetPlayListHandle operation.");
 479
 480         r = AddItemInternal(tempHandle, contentId);
 481         SysTryReturnResult(NID_CNT, r == E_SUCCESS, r, "Failed to perform AddItemInternal operation.");
 482
 483         return r;
 484 }
 485
 486 result
 487 _PlayListImpl::AddItems(const Tizen::Base::String& playlistName, const Tizen::Base::Collection::IList& contentIdList)
 488 {
 489         int listCount = contentIdList.GetCount();
 490         ContentId *pContentId = NULL;
 491         std::unique_ptr<media_playlist_s, PlayListHandleDeleter> pPlayListHandle;
 492         media_playlist_h tempHandle = NULL;
 493
 494         result r = CreateFilter(playlistName);
 495         SysTryReturnResult(NID_CNT, r == E_SUCCESS, E_DATABASE, "Failed to perform CreateFilter operation.");
 496
 497         tempHandle = pPlayListHandle.get();
 498         r = GetPlayListHandle(&tempHandle);
 499         SysTryReturnResult(NID_CNT, r == E_SUCCESS, E_DATABASE, "Failed to perform GetPlayListHandle operation.");
 500
 501         for(int index = 0; index < listCount; index++)
 502         {
 503                 pContentId = (ContentId*)contentIdList.GetAt(index);
 504                 r = AddItemInternal(tempHandle, *pContentId);
 505                 SysTryReturnResult(NID_CNT, r == E_SUCCESS, r, "Failed to perform AddItemInternal operation.");
 506         }
 507
 508         return r;
 509 }
 510
 511 result
 512 _PlayListImpl::RemoveItem(const ContentId& contentId)
 513 {
 514         std::unique_ptr<media_playlist_s, PlayListHandleDeleter> pPlayListHandle;
 515         media_playlist_h tempHandle = NULL;
 516         int ret = MEDIA_CONTENT_ERROR_NONE;
 517         std::unique_ptr<GList, GListDeleter> pItemList;
 518         GList* pTemp = NULL;
 519
 520         result r = CreateFilterUsingContentId(contentId);
 521         SysTryReturnResult(NID_CNT, r == E_SUCCESS, E_DATABASE, "Failed to perform CreateFilterUsingContentId operation.");
 522
 523         tempHandle = pPlayListHandle.get();
 524         r = GetPlayListHandle(&tempHandle);
 525         SysTryReturnResult(NID_CNT, r == E_SUCCESS, E_DATABASE, "Failed to perform GetPlayListHandle operation.");
 526
 527         if (tempHandle != NULL)
 528         {
 529                 int playlistId = 0;
 530                 int playlistMemberId = 0;
 531
 532                 ret = media_playlist_get_playlist_id(tempHandle, &playlistId);
 533                 r = MapCoreErrorToNativeResult(ret);
 534                 SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform media_playlist_get_playlist_id operation.");
 535
 536                 pTemp = pItemList.get();
 537                 int ret = media_playlist_foreach_media_from_db(playlistId, __pFilterHandle.get(), PlaylistImplItemCb, &pTemp);
 538                 result r = MapCoreErrorToNativeResult(ret);
 539                 SysTryReturnResult(NID_CNT, r == E_SUCCESS , r, "Failed to perform media_playlist_foreach_media_from_db operation.");
 540
 541                 if (pTemp != NULL)
 542                 {
 543                         playlistMemberId = (int)g_list_nth_data(pTemp, 0);
 544
 545                         ret = media_playlist_remove_media(tempHandle, playlistMemberId);
 546                         r = MapCoreErrorToNativeResult(ret);
 547                         SysTryReturnResult(NID_CNT, r == E_SUCCESS, r, "Failed to perform media_playlist_remove_media operation.");
 548
 549                         ret = media_playlist_update_to_db(tempHandle);
 550                         r = MapCoreErrorToNativeResult(ret);
 551                         SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform media_playlist_update_to_db operation.");
 552                 }
 553         }
 554
 555         return r;
 556 }
 557
 558 result
 559 _PlayListImpl::RemoveItems(const Tizen::Base::Collection::IList& contentIdList)
 560 {
 561         int listCount = contentIdList.GetCount();
 562         ContentId *pContentId = NULL;
 563         result r = E_SUCCESS;
 564
 565         for (int index = 0; index < listCount; index++)
 566         {
 567                 pContentId = (ContentId*)contentIdList.GetAt(index);
 568                 r = RemoveItem(*pContentId);
 569         }
 570
 571         return r;
 572 }
 573
 574 result
 575 _PlayListImpl::SetPlayListName(const Tizen::Base::String& oldName, const Tizen::Base::String& newName)
 576 {
 577         std::unique_ptr<media_playlist_s, PlayListHandleDeleter> pPlayListHandle;
 578         media_playlist_h tempHandle = NULL;
 579         int ret = MEDIA_CONTENT_ERROR_NONE;
 580
 581         result r = CreateFilter(oldName);
 582         SysTryReturnResult(NID_CNT, r == E_SUCCESS, E_DATABASE, "Failed to perform CreateFilter operation.");
 583
 584         tempHandle = pPlayListHandle.get();
 585         r = GetPlayListHandle(&tempHandle);
 586         SysTryReturnResult(NID_CNT, r == E_SUCCESS, E_DATABASE, "Failed to perform GetPlayListHandle operation.");
 587
 588         std::unique_ptr<char[]> pInputCond(_StringConverter::CopyToCharArrayN(newName));
 589         SysTryReturnResult(NID_CNT, pInputCond, E_OUT_OF_MEMORY, "The memory is insufficient.");
 590
 591         ret = media_playlist_set_name(tempHandle, pInputCond.get());
 592         r = MapCoreErrorToNativeResult(ret);
 593         SysTryReturnResult(NID_CNT, r == E_SUCCESS, r, "Failed to perform media_playlist_set_name operation.");
 594
 595         ret = media_playlist_update_to_db(tempHandle);
 596         r = MapCoreErrorToNativeResult(ret);
 597         SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform media_playlist_update_to_db operation.");
 598
 599         return r;
 600 }
 601 result
 602 _PlayListImpl::SetorGetPlayOrder(const ContentId& contentId, int& playOrder, bool isSet) const
 603 {
 604         std::unique_ptr<media_playlist_s, PlayListHandleDeleter> pPlayListHandle;
 605         media_playlist_h tempHandle = NULL;
 606         std::unique_ptr<GList, GListDeleter> pItemList;
 607         GList* pTemp = NULL;
 608         int ret = MEDIA_CONTENT_ERROR_NONE;
 609
 610         SysTryReturnResult(NID_CNT, contentId != UuId::GetInvalidUuId(), E_INVALID_ARG, "The specified parameter is invalid.");
 611
 612         result r = CreateFilterUsingContentId(contentId);
 613         SysTryReturnResult(NID_CNT, r == E_SUCCESS, E_DATABASE, "Failed to perform CreateFilterUsingContentId operation.");
 614
 615         tempHandle = pPlayListHandle.get();
 616         r = GetPlayListHandle(&tempHandle);
 617         SysTryReturnResult(NID_CNT, r == E_SUCCESS, E_DATABASE, "Failed to perform GetPlayListHandle operation.");
 618
 619         if (tempHandle != NULL)
 620         {
 621                 int playlistId = 0;
 622                 int playlistMemberId = 0;
 623
 624                 ret = media_playlist_get_playlist_id(tempHandle, &playlistId);
 625                 r = MapCoreErrorToNativeResult(ret);
 626                 SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform media_playlist_get_playlist_id operation.");
 627
 628                 pTemp = pItemList.get();
 629                 int ret = media_playlist_foreach_media_from_db(playlistId, __pFilterHandle.get(), PlaylistImplItemCb, &pTemp);
 630                 result r = MapCoreErrorToNativeResult(ret);
 631                 SysTryReturnResult(NID_CNT, r == E_SUCCESS , r, "media_playlist_foreach_media_from_db failed.");
 632
 633                 if (pTemp != NULL)
 634                 {
 635                         playlistMemberId = (int)g_list_nth_data(pTemp, 0);
 636
 637                         if (isSet == true)
 638                         {
 639                                 ret = media_playlist_set_play_order(tempHandle, playlistMemberId, playOrder);
 640                                 r = MapCoreErrorToNativeResult(ret);
 641                                 SysTryReturnResult(NID_CNT, r == E_SUCCESS, r, "Failed to perform media_playlist_set_play_order operation.");
 642
 643                                 ret = media_playlist_update_to_db(tempHandle);
 644                                 r = MapCoreErrorToNativeResult(ret);
 645                                 SysTryReturnResult(NID_CNT, !IsFailed(r), r, "Failed to perform media_playlist_update_to_db operation.");
 646                         }
 647                         else
 648                         {
 649                                 ret = media_playlist_get_play_order(tempHandle, playlistMemberId, &playOrder);
 650                                 r = MapCoreErrorToNativeResult(ret);
 651                                 SysTryReturnResult(NID_CNT, r == E_SUCCESS, r, "Failed to perform media_playlist_set_play_order operation.");
 652                         }
 653                 }
 654         }
 655
 656         return r;
 657 }
 658 result
 659 _PlayListImpl::SetPlayOrder(const ContentId& contentId, const ContentId& nextContentId)
 660 {
 661         int playOrder = GetPlayOrder(contentId) + 1;
 662         result r = GetLastResult();
 663         SysTryReturnResult(NID_CNT, r == E_SUCCESS , r, "Failed to perform GetPlayOrder operation.");
 664
 665         r = SetorGetPlayOrder(nextContentId, playOrder, true);
 666
 667         return r;
 668 }
 669
 670 int
 671 _PlayListImpl::GetPlayOrder(const ContentId& contentId) const
 672 {
 673         int playOrder = 0;
 674
 675         result r = SetorGetPlayOrder(contentId, playOrder, false);
 676
 677         SetLastResult(r);
 678         return playOrder;
 679 }
 680
 681 result
 682 _PlayListImpl::GetPlayListHandle(media_playlist_h* pPlayListHandle) const
 683 {
 684         std::unique_ptr<GList, GListDeleter> pItemList;
 685         GList* pTemp = NULL;
 686
 687         pTemp = pItemList.get();
 688         int ret = media_playlist_foreach_playlist_from_db(__pFilterHandle.get(), MediaPlayListImplCb, &pTemp);
 689         result r = MapCoreErrorToNativeResult(ret);
 690         SysTryReturnResult(NID_CNT, r == E_SUCCESS , r, "Failed to perform media_playlist_foreach_playlist_from_db operation.");
 691
 692         if (pTemp == NULL)
 693         {
 694                 r = E_INVALID_ARG; // No match found.
 695         }
 696         else
 697         {
 698                 *pPlayListHandle = static_cast< media_playlist_h >(g_list_nth_data(pTemp, 0));
 699         }
 700
 701         return r;
 702 }
 703
 704 result
 705 _PlayListImpl::MapCoreErrorToNativeResult(int reason) const
 706 {
 707         result r = E_SUCCESS;
 708
 709         switch (reason)
 710         {
 711         case MEDIA_CONTENT_ERROR_NONE:
 712                 r = E_SUCCESS;
 713                 break;
 714
 715         case MEDIA_CONTENT_ERROR_INVALID_PARAMETER:
 716                 r = E_INVALID_ARG;
 717                 SysLog(NID_CNT, "MEDIA_CONTENT_ERROR_INVALID_PARAMETER");
 718                 break;
 719
 720         case MEDIA_CONTENT_ERROR_DB_FAILED:
 721                 r = E_DATABASE;
 722                 SysLog(NID_CNT, "MEDIA_CONTENT_ERROR_DB_FAILED");
 723                 break;
 724
 725         case MEDIA_CONTENT_ERROR_DB_BUSY:
 726                 r = E_SERVICE_BUSY;
 727                 SysLog(NID_CNT, "MEDIA_CONTENT_ERROR_DB_BUSY");
 728                 break;
 729
 730         default:
 731                 SysLog(NID_CNT, "default");
 732                 r = E_DATABASE;
 733                 break;
 734         }
 735         return r;
 736 }
 737
 738 result
 739 _PlayListImpl::MapCoreDatabaseErrorToNativeResult(int reason) const
 740 {
 741         result r = E_SUCCESS;
 742
 743         switch (reason)
 744         {
 745         case MEDIA_CONTENT_ERROR_NONE:
 746                 r = E_SUCCESS;
 747                 break;
 748
 749         case MEDIA_CONTENT_ERROR_DB_FAILED:
 750                 r = E_DATABASE;
 751                 SysLog(NID_CNT, "MEDIA_CONTENT_ERROR_DB_FAILED");
 752                 break;
 753
 754         case MEDIA_CONTENT_ERROR_DB_BUSY:
 755                 r = E_SERVICE_BUSY;
 756                 SysLog(NID_CNT, "MEDIA_CONTENT_ERROR_DB_BUSY");
 757                 break;
 758
 759         default:
 760                 SysLog(NID_CNT, "default");
 761                 r = E_DATABASE;
 762                 break;
 763         }
 764         return r;
 765 }
 766
 767 bool
 768 MediaPlayListImplCb(media_playlist_h playlistHandle, void *pUserData)
 769 {
 770         media_playlist_h newPlayListHandle = NULL;
 771         media_playlist_clone(&newPlayListHandle, playlistHandle);
 772
 773         GList** pList = (GList**)pUserData;
 774         *pList = g_list_append(*pList, newPlayListHandle);
 775
 776         return true;
 777 }
 778
 779 // This callback appends List with playlistMemberId's
 780 bool
 781 PlaylistImplItemCb(int playlistMemberId, media_info_h media, void *pUserData)
 782 {
 783         GList** pList = (GList**)pUserData;
 784         *pList = g_list_append(*pList, (gpointer)playlistMemberId);
 785
 786         return true;
 787 }
 788
 789 // This callback appends List with media handles
 790 bool
 791 PlaylistItemsCb(int playlistId, media_info_h media, void *pUserData)
 792 {
 793         media_info_h new_media = NULL;
 794         media_info_clone(&new_media, media);
 795
 796         GList** pList = (GList**)pUserData;
 797         *pList = g_list_append(*pList, new_media);
 798
 799         return true;
 800 }
 801
 802 }}