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