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