src/FCnt_PlayListImpl.cpp

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