src/FCnt_PlayListImpl.cpp

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