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