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