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