src/FCnt_ContentTransferImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file                FCnt_ContentTransferImpl.cpp
  19  * @brief               This is the implementation file for the %_ContentTransferImpl class.
  20  *
  21  * This file contains implementation of the %_ContentTransferImpl class.
  22  */
  23
  24 #include <FBaseSysLog.h>
  25 #include <FBaseString.h>
  26 #include <FBaseColIList.h>
  27 #include <FBaseUtilUri.h>
  28 #include <FIoDirectory.h>
  29 #include <FCntIContentTransferListener.h>
  30 #include <FCntContentTransfer.h>
  31 #include <FCntContentTransferInfo.h>
  32 #include <FIoRegistry.h>
  33 #include <FAppApp.h>
  34 #include <FSysEnvironment.h>
  35 #include <FApp_AppInfo.h>
  36 #include <FCnt_ContentTransferImpl.h>
  37 #include <FSys_EnvironmentImpl.h>
  38 #include <FIo_FileImpl.h>
  39 #include <FIo_FileAttributesImpl.h>
  40 #include <FSys_SystemTimeImpl.h>
  41 #include "FCnt_ContentDownloadHandler.h"
  42 #include "FCnt_ContentTransferEvent.h"
  43
  44 using namespace Tizen;
  45 using namespace Tizen::App;
  46 using namespace Tizen::Base;
  47 using namespace Tizen::Base::Collection;
  48 using namespace Tizen::Base::Utility;
  49 using namespace Tizen::Base::Runtime;
  50 using namespace Tizen::Io;
  51 using namespace Tizen::System;
  52
  53 static RequestId downloadRequestId = 0;
  54 static bool initSlot = false;
  55 static const int MAX_DOWNLOAD_COUNT = 5;
  56
  57 namespace Tizen { namespace Content
  58 {
  59
  60 static const wchar_t CONTENT_DOWNLOAD_TEMP_DIRECTORY[] = L"/tmp/content/";
  61 static const wchar_t CONTENT_DOWNLOAD_TEMP_FILE_PATH[] = L"/tmp/content/downloadtempfile";
  62 static const wchar_t CONTENT_DOWNLOAD_PATH_MEDIA[] = L"/Media";
  63 static const wchar_t CONTENT_DOWNLOAD_PATH_MEDIA_MMC[] = L"/Storagecard/Media";
  64 static const wchar_t CONTENT_DOWNLOAD_PATH_HOME[] = L"/Home";
  65 static const wchar_t CONTENT_DOWNLOAD_PATH_HOME_MMC[] = L"/HomeExt";
  66
  67 static const int CONTENT_TRANSFER_DEFAULT_PROGRESS_INTERVAL = 0;
  68 static const int CONTENT_DOWNLOAD_CHECKING_PERIOD = 1000;
  69
  70 _ContentTransferImpl::_ContentTransferImpl(void)
  71         : __requestId(INVALID_REQUEST_ID)
  72         , __restRequestId(INVALID_REQUEST_ID)
  73         , __timeout(0)
  74         , __percent(CONTENT_TRANSFER_DEFAULT_PROGRESS_INTERVAL)
  75         , __timerStarted(false)
  76         , __isBuffer(false)
  77         , __destFilePath(L"")
  78         , __pContentDownloadUserData(null)
  79         , __pContentDownloadUserDataSequence(null)
  80         , __pContentDownloadHandler(null)
  81         , __pContentDownloadHandlerSequence(null)
  82         , __pTransferEvent(null)
  83         , __pTransferInfoList(null)
  84         , __pTimer(null)
  85 {
  86
  87 }
  88
  89 _ContentTransferImpl::~_ContentTransferImpl(void)
  90 {
  91                 initSlot = false;
  92 }
  93
  94 _ContentTransferImpl*
  95 _ContentTransferImpl::GetInstance(ContentTransfer& contentTransfer)
  96 {
  97         return contentTransfer.__pImpl;
  98 }
  99
 100 const _ContentTransferImpl*
 101 _ContentTransferImpl::GetInstance(const ContentTransfer& contentTransfer)
 102 {
 103         return contentTransfer.__pImpl;
 104 }
 105
 106 result
 107 _ContentTransferImpl::Construct(IContentTransferListener& listener)
 108 {
 109         // E_SUCCESS, E_OUT_OF_MEMORY, E_SYSTEM
 110
 111         ClearLastResult();
 112         result r = E_SUCCESS;
 113
 114         std::unique_ptr<_ContentDownloadHandler> pContentDownloadHandler(new (std::nothrow) _ContentDownloadHandler);
 115         SysTryReturn(NID_CNT, pContentDownloadHandler != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 116                         "[E_OUT_OF_MEMORY] Failed to construct ContentDownloadHandler.");
 117
 118         r = pContentDownloadHandler->Construct();
 119         SysTryReturn(NID_CNT, !IsFailed(r), r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 120                         "[E_OUT_OF_MEMORY] Failed to construct ContentDownloadHandler.");
 121
 122         std::unique_ptr<_ContentDownloadHandler[]> pContentDownloadHandlerSequence(new (std::nothrow) _ContentDownloadHandler[MAX_DOWNLOAD_COUNT]);
 123         SysTryReturn(NID_CNT, pContentDownloadHandlerSequence != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 124                         "[E_OUT_OF_MEMORY] Failed to construct ContentDownloadHandler array.");
 125
 126         for (int i = 0; i < MAX_DOWNLOAD_COUNT; i++)
 127         {
 128                 r = (pContentDownloadHandlerSequence.get())[i].Construct();
 129                 SysTryReturn(NID_CNT, !IsFailed(r), r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 130                                    "[E_OUT_OF_MEMORY] Failed to construct ContentDownloadHandler array.");
 131         }
 132
 133         std::unique_ptr<_ContentDownloadUserData> pContentDownloadUserData(new (std::nothrow) _ContentDownloadUserData);
 134         SysTryReturn(NID_CNT, pContentDownloadUserData != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 135                         "[E_OUT_OF_MEMORY] Failed to construct ContentDownloadUserData.");
 136
 137         std::unique_ptr<_ContentDownloadUserData[]> pContentDownloadUserDataSequence(new (std::nothrow) _ContentDownloadUserData[MAX_DOWNLOAD_COUNT]);
 138         SysTryReturn(NID_CNT, pContentDownloadUserDataSequence != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 139                         "[E_OUT_OF_MEMORY] Failed to construct ContentDownloadUserData.");
 140
 141         std::unique_ptr<_ContentTransferEvent> pTransferEvent(new (std::nothrow) _ContentTransferEvent);
 142         SysTryReturn(NID_CNT, pTransferEvent != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 143                            "[E_OUT_OF_MEMORY] Failed to construct ContentTransferEvent.");
 144
 145         r = pTransferEvent->AddListener(listener, true);
 146         SysTryReturn(NID_CNT, !IsFailed(r), r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to perform AddListener to ContentTransferEvent.");
 147
 148         std::unique_ptr<ArrayList, AllElementsDeleter> pTransferInfoList(new (std::nothrow) ArrayList());
 149         SysTryReturn(NID_CNT, pTransferInfoList != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 150                            "[E_OUT_OF_MEMORY] Failed to construct ArrayList.");
 151
 152         r = pTransferInfoList->Construct();
 153         SysTryReturn(NID_CNT, !IsFailed(r), r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 154                         "[E_OUT_OF_MEMORY] Failed to construct ArrayList.");
 155
 156         std::unique_ptr<Timer> pTimer(new (std::nothrow) Timer());
 157         SysTryReturn(NID_CNT, pTimer != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Failed to construct Timer.");
 158
 159         r = pTimer->Construct(*this);
 160         SysTryReturn(NID_CNT, !IsFailed(r), r, r, "[%s] Failed to construct Timer.", GetErrorMessage(r));
 161
 162         InitializeEmptySlotInternal(pContentDownloadUserData.get());
 163         r = GetLastResult();
 164         SysTryReturn(NID_CNT, !IsFailed(r), r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to perform initiate the download slot.");
 165
 166         __pContentDownloadHandler = std::move(pContentDownloadHandler);
 167         __pContentDownloadHandlerSequence = std::move(pContentDownloadHandlerSequence);
 168
 169         __pContentDownloadUserData = std::move(pContentDownloadUserData);
 170         __pContentDownloadUserDataSequence = std::move(pContentDownloadUserDataSequence);
 171
 172         __pTransferEvent = std::move(pTransferEvent);
 173
 174         __pTransferInfoList = std::move(pTransferInfoList);
 175
 176         __pTimer = std::move(pTimer);
 177
 178         return r;
 179 }
 180
 181 void
 182 _ContentTransferImpl::InitializeEmptySlotInternal(_ContentDownloadUserData* pUserData)
 183 {
 184         ClearLastResult();
 185         result r = E_SUCCESS;
 186         bool check = false;
 187         String tempPath(CONTENT_DOWNLOAD_TEMP_DIRECTORY);
 188         int i = 0;
 189
 190         SysTryReturnVoidResult(NID_CNT, pUserData != null, r = E_SYSTEM,
 191                         "[E_SYSTEM] ContentDownloadUserData instance must not be null.");
 192
 193         pUserData->SetMaxCount(MAX_DOWNLOAD_COUNT);
 194
 195         if (!initSlot)
 196         {
 197                 for (i = 0; i < MAX_DOWNLOAD_COUNT; i++)
 198                 {
 199                         pUserData->SetCheckDownloading(i, false);
 200                 }
 201
 202                 // not exist
 203                 check = _FileImpl::IsFileExist(tempPath);
 204                 r = GetLastResult();
 205                 SysTryReturnVoidResult(NID_CNT, !IsFailed(r), r,
 206                                 "[%s] Failed to perform IsFileExist operation for [%ls] path.", GetErrorMessage(r), tempPath.GetPointer());
 207
 208                 if (!check)
 209                 {
 210                         r = Directory::Create(tempPath, false);
 211                         SysTryReturnVoidResult(NID_CNT, !IsFailed(r), r,
 212                                         "[%s] Failed to perform Create operation for [%ls] path.", GetErrorMessage(r), tempPath.GetPointer());
 213                 }
 214                 initSlot = true;
 215         }
 216
 217         return;
 218 }
 219
 220 int
 221 _ContentTransferImpl::GetEmptySlotInternal(void) const
 222 {
 223         int i = 0;
 224         for (i = 0; i < MAX_DOWNLOAD_COUNT; i++)
 225         {
 226                 if (!(__pContentDownloadUserData->GetCheckDownloading(i)))
 227                 {
 228                         return i;
 229                 }
 230         }
 231         return -1;
 232 }
 233
 234 void
 235 _ContentTransferImpl::SetEmptySlotInternal(void)
 236 {
 237         for (int i = 0; i < MAX_DOWNLOAD_COUNT; i++)
 238         {
 239                 if (!((__pContentDownloadUserDataSequence.get())[i].GetSlotFlag()))
 240                 {
 241                         __pContentDownloadUserData->SetCheckDownloading(i, false);
 242                 }
 243         }
 244 }
 245
 246 void
 247 _ContentTransferImpl::SetUsedSlotInternal(int slot)
 248 {
 249         // TODO : If the error is occured in this command, set the mutex.
 250         if (slot >= 0 && slot < MAX_DOWNLOAD_COUNT)
 251         {
 252                 __pContentDownloadUserData->SetCheckDownloading(slot, true);
 253                 (__pContentDownloadUserDataSequence.get())[slot].SetSlotFlag(true);
 254         }
 255 }
 256
 257 result
 258 _ContentTransferImpl::Cancel(RequestId reqId)
 259 {
 260         // E_SUCCESS, E_OBJ_NOT_FOUND, E_INVALID_ARG, E_INVALID_STATE
 261
 262         SysLog(NID_CNT, "Cancel the request ID(%d) in download.", reqId);
 263
 264         ClearLastResult();
 265         result r = E_SUCCESS;
 266         String destFilePath = null;
 267         ContentTransferInfo* pContentTransferInfo = null;
 268         int slot = -1;
 269
 270         SysAssertf(__pContentDownloadHandler != null, "Not yet constructed. Construct() should be called before use.");
 271
 272         pContentTransferInfo = GetContentTransferInfoByRequestId(reqId);
 273         SysTryReturn(NID_CNT, pContentTransferInfo != null, r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND,
 274                                 "[E_OBJ_NOT_FOUND] Unable to find the current Download operation.");
 275
 276         if (pContentTransferInfo->GetContentTransferStatus() == CONTENT_TRANSFER_STATUS_DOWNLOADING)
 277         {
 278                 slot = pContentTransferInfo->GetSlotId();
 279                 r = (__pContentDownloadHandlerSequence.get())[slot].Cancel(pContentTransferInfo->GetRestRequestId(),
 280                                                                                                                    &(__pContentDownloadUserDataSequence.get())[slot]);
 281                 SysTryReturn(NID_CNT, !IsFailed(r), r = E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Failed to perform Cancel operation.");
 282         }
 283         else
 284         {
 285                 // TODO : check timing issue.
 286                 r = E_INVALID_STATE;
 287                 SysLogException(NID_CNT, E_INVALID_STATE, "[E_INVALID_STATE] This [%d] request isn't under download.", reqId);
 288         }
 289
 290         return r;
 291 }
 292
 293 void
 294 _ContentTransferImpl::SetDefaultTimeout(int sec)
 295 {
 296         if (sec > 0)
 297         {
 298                 __timeout = sec;
 299         }
 300         else
 301         {
 302                 __timeout = 0;
 303         }
 304 }
 305
 306 int
 307 _ContentTransferImpl::GetDefaultTimeout(void) const
 308 {
 309         return __timeout;
 310 }
 311
 312 result
 313 _ContentTransferImpl::Remove(RequestId reqId)
 314 {
 315         // E_SUCCESS, E_OBJ_NOT_FOUND, E_OUT_OF_MEMORY, E_INVALID_STATE
 316
 317         SysLog(NID_CNT, "Remove the download request ID(%d) in queue.", reqId);
 318
 319         ClearLastResult();
 320         result r = E_SUCCESS;
 321         ContentTransferInfo* pTransferInfo = null;
 322         std::unique_ptr<IEnumerator> pEnum;
 323         int idx = 0;
 324         int findIdx = -1;
 325
 326         SysAssertf(__pTransferInfoList != null, "Not yet constructed. Construct() should be called before use.");
 327
 328         pEnum = std::unique_ptr<IEnumerator>(__pTransferInfoList->GetEnumeratorN());
 329         SysTryReturn(NID_CNT, pEnum != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 330                            "[E_OUT_OF_MEMORY] Remove operation can not perform for [%d] request ID.", reqId);
 331
 332         while (pEnum->MoveNext() == E_SUCCESS)
 333         {
 334                 pTransferInfo = dynamic_cast<ContentTransferInfo*>(pEnum->GetCurrent());
 335                 SysTryReturn(NID_CNT, pTransferInfo != null, r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND,
 336                                    "[E_OBJ_NOT_FOUND] ContentTransferInfo instance must not be null.");
 337
 338                 if (pTransferInfo->GetRequestId() == reqId)
 339                 {
 340                         ContentTransferStatus status = pTransferInfo->GetContentTransferStatus();
 341                         if (status == CONTENT_TRANSFER_STATUS_DOWNLOAD_READY ||
 342                                 status == CONTENT_TRANSFER_STATUS_DOWNLOAD_COMPLETED)
 343                         {
 344                                 findIdx = idx;
 345                                 break;
 346                         }
 347                         else if (status == CONTENT_TRANSFER_STATUS_DOWNLOADING)
 348                         {
 349                                 SysLogException(NID_CNT, E_INVALID_STATE, "[E_INVALID_STATE] This [%d] request operation is under download.", reqId);
 350                                 return E_INVALID_STATE;
 351                         }
 352                 }
 353                 idx++;
 354         }
 355
 356         if (findIdx == -1)
 357         {
 358                 SysLogException(NID_CNT, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] [%d] request operation cannot found.", reqId);
 359                 return E_OBJ_NOT_FOUND;
 360         }
 361         else
 362         {
 363                 __pTransferInfoList->RemoveAt(findIdx, true);
 364                 r = GetLastResult();
 365                 SysTryReturn(NID_CNT, !IsFailed(r), r = E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND,
 366                                                 "[E_OBJ_NOT_FOUND] Failed to perform RemoveAt operation for a content in transfer info list.");
 367         }
 368
 369         return r;
 370 }
 371
 372 result
 373 _ContentTransferImpl::RemoveAll(void)
 374 {
 375         // E_SUCCESS, E_OUT_OF_MEMORY, E_INVALID_STATE
 376
 377         SysLog(NID_CNT, "Remove all download request ID in queue.");
 378
 379         ClearLastResult();
 380         result r = E_SUCCESS;
 381         ContentTransferInfo* pTransferInfo = null;
 382         std::unique_ptr<IEnumerator> pTransferEnum;
 383         std::unique_ptr<IEnumerator> pDeleteEnum;
 384         ArrayList deleteList;
 385
 386         SysAssertf(__pTransferInfoList != null, "Not yet constructed. Construct() should be called before use.");
 387
 388         pTransferEnum = std::unique_ptr<IEnumerator>(__pTransferInfoList->GetEnumeratorN());
 389         SysTryReturn(NID_CNT, pTransferEnum != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 390                            "[E_OUT_OF_MEMORY] Failed to perform GetEnumeratorN operation.");
 391
 392         while (pTransferEnum->MoveNext() == E_SUCCESS)
 393         {
 394                 pTransferInfo = dynamic_cast<ContentTransferInfo*>(pTransferEnum->GetCurrent());
 395                 SysTryReturn(NID_CNT, pTransferInfo != null, r = E_INVALID_STATE, r,
 396                                 "[E_INVALID_STATE] ContentTransferInfo instance must not be null.");
 397
 398                 ContentTransferStatus status = pTransferInfo->GetContentTransferStatus();
 399                 if (status == CONTENT_TRANSFER_STATUS_DOWNLOAD_READY || status == CONTENT_TRANSFER_STATUS_DOWNLOAD_COMPLETED)
 400                 {
 401                         deleteList.Add(*pTransferInfo);
 402                 }
 403         }
 404
 405         pDeleteEnum = std::unique_ptr<IEnumerator>(deleteList.GetEnumeratorN());
 406         SysTryReturn(NID_CNT, pDeleteEnum != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 407                                    "[E_OUT_OF_MEMORY] Failed to perform GetEnumeratorN operation.");
 408
 409         while (pDeleteEnum->MoveNext() == E_SUCCESS)
 410         {
 411                 pTransferInfo = dynamic_cast<ContentTransferInfo*>(pDeleteEnum->GetCurrent());
 412                 SysTryReturn(NID_CNT, pTransferInfo != null, r = E_INVALID_STATE, r,
 413                                                 "[E_INVALID_STATE] ContentTransferInfo instance must not be null.");
 414
 415                 __pTransferInfoList->Remove(*pTransferInfo, true);
 416                 r = GetLastResult();
 417                 SysTryReturn(NID_CNT, !IsFailed(r), r = E_INVALID_STATE, E_INVALID_STATE,
 418                                 "[E_INVALID_STATE] Failed to perform Remove operation for a content in transfer info list.");
 419         }
 420
 421         return r;
 422 }
 423
 424 result
 425 _ContentTransferImpl::CancelAll(void)
 426 {
 427         // E_SUCCESS, E_OUT_OF_MEMORY, E_INVALID_STATE
 428
 429         SysLog(NID_CNT, "Cancel the all request ID in download.");
 430
 431         ClearLastResult();
 432         result r = E_SUCCESS;
 433         std::unique_ptr<IEnumerator> pEnum;
 434         ContentTransferInfo* pTransferInfo = null;
 435
 436         SysAssertf(__pTransferInfoList != null && __pContentDownloadUserDataSequence != null,
 437                         "Not yet constructed. Construct() should be called before use.");
 438
 439         pEnum = std::unique_ptr<IEnumerator>(__pTransferInfoList->GetEnumeratorN());
 440         SysTryReturn(NID_CNT, pEnum != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 441                            "[E_OUT_OF_MEMORY] Failed to perform GetEnumeratorN operation.");
 442
 443         while (pEnum->MoveNext() == E_SUCCESS)
 444         {
 445                 pTransferInfo = dynamic_cast<ContentTransferInfo*>(pEnum->GetCurrent());
 446                 SysTryReturn(NID_CNT, pTransferInfo != null, r = E_INVALID_STATE, r,
 447                                 "[E_INVALID_STATE] ContentTransferInfo instance must not be null.");
 448
 449                 ContentTransferStatus status = pTransferInfo->GetContentTransferStatus();
 450                 if (status == CONTENT_TRANSFER_STATUS_DOWNLOADING)
 451                 {
 452                         SysLog(NID_CNT, "========== Canceled download slot : %d ==========", pTransferInfo->GetSlotId());
 453
 454                         r = (__pContentDownloadHandlerSequence.get())[pTransferInfo->GetSlotId()].Cancel(
 455                                 pTransferInfo->GetRestRequestId(), &(__pContentDownloadUserDataSequence.get())[pTransferInfo->GetSlotId()]);
 456                         SysTryReturn(NID_CNT, !IsFailed(r), r = E_INVALID_STATE, E_INVALID_STATE,
 457                                         "[E_INVALID_STATE] Failed to perform Cancel operation.");
 458                 }
 459         }
 460
 461         return r;
 462 }
 463
 464 Collection::IList*
 465 _ContentTransferImpl::GetContentTransferInfoListN(void) const
 466 {
 467         std::unique_ptr<ArrayList, AllElementsDeleter> pTransferInfoList;
 468         std::unique_ptr<IEnumerator> pEnum;
 469         ContentTransferInfo* pTransferInfoCopy = null;
 470         ContentTransferInfo* pTransferInfo = null;
 471
 472         SysAssertf(__pTransferInfoList != null, "Not yet constructed. Construct() should be called before use.");
 473
 474         pTransferInfoList = std::unique_ptr<ArrayList, AllElementsDeleter>(new (std::nothrow) ArrayList());
 475         SysTryLogReturn(NID_CNT, pTransferInfoList != null, null, "Failed to construct ArrayList.");
 476
 477         pEnum = std::unique_ptr<IEnumerator>(__pTransferInfoList->GetEnumeratorN());
 478         SysTryLogReturn(NID_CNT, pEnum != null, null, "Failed to perform GetEnumeratorN operation.");
 479
 480         while (pEnum->MoveNext() == E_SUCCESS)
 481         {
 482                 pTransferInfo = dynamic_cast<ContentTransferInfo*>(pEnum->GetCurrent());
 483                 SysTryLogReturn(NID_CNT, pTransferInfo != null, null, "ContentTransferInfo instance must not be null.");
 484
 485                 pTransferInfoCopy = pTransferInfo->CopyN();
 486
 487                 pTransferInfoList->Add(*pTransferInfoCopy);
 488         }
 489
 490         return pTransferInfoList.release();
 491 }
 492
 493 Collection::IList*
 494 _ContentTransferImpl::GetContentTransferInfoListInProgressN(void) const
 495 {
 496         std::unique_ptr<ArrayList, AllElementsDeleter> pTransferInfoList;
 497         std::unique_ptr<IEnumerator> pEnum;
 498         ContentTransferInfo* pTransferInfoCopy = null;
 499         ContentTransferInfo* pTransferInfo = null;
 500
 501         SysAssertf(__pTransferInfoList != null, "Not yet constructed. Construct() should be called before use.");
 502
 503         pTransferInfoList = std::unique_ptr<ArrayList, AllElementsDeleter>(new (std::nothrow) ArrayList());
 504         SysTryLogReturn(NID_CNT, pTransferInfoList != null, null, "Failed to construct ArrayList.");
 505
 506         pEnum = std::unique_ptr<IEnumerator>(__pTransferInfoList->GetEnumeratorN());
 507         SysTryLogReturn(NID_CNT, pEnum != null, null, "Failed to perform GetEnumerator operation.");
 508
 509         while (pEnum->MoveNext() == E_SUCCESS)
 510         {
 511                 pTransferInfo = dynamic_cast<ContentTransferInfo*>(pEnum->GetCurrent());
 512                 SysTryLogReturn(NID_CNT, pTransferInfo != null, null, "ContentTransferInfo instance must not be null.");
 513
 514                 ContentTransferStatus status = pTransferInfo->GetContentTransferStatus();
 515                 if (status == CONTENT_TRANSFER_STATUS_DOWNLOADING)
 516                 {
 517                         pTransferInfoCopy = pTransferInfo->CopyN();
 518                         pTransferInfoList->Add(*pTransferInfoCopy);
 519                 }
 520         }
 521
 522         return pTransferInfoList.release();
 523 }
 524
 525 void
 526 _ContentTransferImpl::SetProgressIntervalByPercent(int percent)
 527 {
 528         if (percent > 0 && percent <= 100)
 529         {
 530                 __percent = percent;
 531         }
 532         else
 533         {
 534                 __percent = 0;
 535         }
 536 }
 537
 538 result
 539 _ContentTransferImpl::Download(const Utility::Uri& uri, int fileSize, const String& destFilePath, bool replace,
 540                 RequestId& requestID, IContentTransferListener* pListener, int sec)
 541 {
 542         // E_SUCCESS, E_INVALID_ARG, E_INVALID_STATE, E_ILLEGAL_ACCESS, E_FILE_ALREADY_EXIST, E_PRIVILEGE_DENIED, E_IN_PROGRESS
 543
 544         SysLog(NID_CNT, "Download operation start with listener.");
 545
 546         ClearLastResult();
 547         result r = E_SUCCESS;
 548         String sourcePath(L"");
 549         String destPath(L"");
 550         String tempPath(L"");
 551         String scheme(L"");
 552         String checkName(L"");
 553         String checkPath(L"");
 554         int copySize = 0;
 555         int maxSize = 1024;
 556         int lengthString = 0;
 557         FileAttributes fileAttr;
 558
 559         SysAssertf(__pContentDownloadHandler != null, "Not yet constructed. Construct() should be called before use.");
 560
 561         SysTryReturn(NID_CNT, fileSize >= 0, r = E_INVALID_ARG, E_INVALID_ARG,
 562                         "[E_INVALID_ARG] The size of the source file is less than 0.");
 563         SysTryReturn(NID_CNT, !destFilePath.IsEmpty(), r = E_INVALID_ARG, E_INVALID_ARG,
 564                         "[E_INVALID_ARG] The destination file path is empty.");
 565         SysTryReturn(NID_CNT, !uri.ToString().IsEmpty(), r = E_INVALID_ARG, E_INVALID_ARG,
 566                         "[E_INVALID_ARG] The source URI is empty.");
 567         SysTryReturn(NID_CNT, !uri.GetHost().IsEmpty() && !uri.GetPath().IsEmpty(), r = E_INVALID_ARG, E_INVALID_ARG,
 568                         "[E_INVALID_ARG] The source URI is empty.");
 569         SysTryReturn(NID_CNT, sec >= 0, r = E_INVALID_ARG, E_INVALID_ARG,
 570                         "[E_INVALID_ARG] The timeout value is less than 0.");
 571
 572         destPath = destFilePath;
 573
 574         if (_FileImpl::IsSystemPath(destPath))
 575         {
 576                 SysLogException(NID_CNT, E_ILLEGAL_ACCESS, "[E_ILLEGAL_ACCESS] [%ls] path isn't permitted.", destFilePath.GetPointer());
 577
 578                 return E_ILLEGAL_ACCESS;
 579         }
 580
 581         if (_FileImpl::IsFileExist(destPath))
 582         {
 583                 if (replace != true)
 584                 {
 585                         SysLogException(NID_CNT, E_FILE_ALREADY_EXIST, "[E_FILE_ALREADY_EXIST] The download file is already exist.");
 586
 587                         return E_FILE_ALREADY_EXIST;
 588                 }
 589
 590                 SysTryReturn(NID_CNT, _FileImpl::IsMediaPath(destPath) == true || _FileImpl::IsAppPath(destPath) == true,
 591                                 r = E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The file path is not a media or an app path.");
 592
 593                 // read-only, directory or file
 594                 // check whether the destination file is read-only.
 595                 // check whether the destination path without the file extension is a directory or not.
 596                 r = _FileImpl::GetAttributes(destFilePath, fileAttr);
 597                 SysTryReturn(NID_CNT, !IsFailed(r), r = E_INVALID_ARG, E_INVALID_ARG,
 598                                 "[E_INVALID_ARG] Failed to perform GetAttributes operation for the destination path. ");
 599                 SysTryReturn(NID_CNT, !fileAttr.IsDirectory(), r = E_ILLEGAL_ACCESS, E_ILLEGAL_ACCESS,
 600                                 "[E_ILLEGAL_ACCESS] The file path is directory.");
 601                 SysTryReturn(NID_CNT, !fileAttr.IsReadOnly(), r = E_ILLEGAL_ACCESS, E_ILLEGAL_ACCESS,
 602                                 "[E_ILLEGAL_ACCESS] The file path is read only.");
 603         }
 604         else
 605         {
 606                 // check the destination file path
 607                 // check the path
 608                 SysTryReturn(NID_CNT, _FileImpl::IsMediaPath(destPath) == true || _FileImpl::IsAppPath(destPath) == true,
 609                                 r = E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The file path is not a media or an app path.");
 610
 611                 // 1st: file name
 612                 // check whether the destination path includes the file name
 613                 checkName = _FileImpl::GetFileName(destPath);
 614                 SysTryReturn(NID_CNT, !checkName.IsEmpty(), r = E_INVALID_ARG, E_INVALID_ARG,
 615                                 "[E_INVALID_ARG] The file name is empty.");
 616
 617                 // 2nd: parent directory
 618                 lengthString = destFilePath.String::GetLength();
 619                 r = destPath.String::LastIndexOf('/', lengthString - 1, copySize);
 620                 SysTryReturn(NID_CNT, copySize > 0 && copySize < maxSize, r = E_INVALID_ARG, E_INVALID_ARG,
 621                                 "[E_INVALID_ARG] The length of path is invalid size.");
 622
 623                 // copy the parent path
 624                 r = destPath.SubString(0, copySize + 1, checkPath);
 625                 SysTryReturn(NID_CNT, !IsFailed(r), r = E_INVALID_ARG, E_INVALID_ARG,
 626                                 "[E_INVALID_ARG] Failed to perform SubString operation.");
 627
 628                 // check the validation of the parent path
 629                 r = _FileImpl::GetAttributes(checkPath, fileAttr);
 630                 SysTryReturn(NID_CNT, !IsFailed(r), r = E_INVALID_ARG, E_INVALID_ARG,
 631                                 "[E_INVALID_ARG] Failed to perform GetAttributes operation.");
 632                 SysTryReturn(NID_CNT, fileAttr.IsDirectory(), r = E_ILLEGAL_ACCESS, E_ILLEGAL_ACCESS,
 633                                 "[E_ILLEGAL_ACCESS] The path is not directory path.");
 634         }
 635
 636         __destFilePath = destPath;
 637         scheme = uri.GetScheme();
 638
 639         if (scheme.CompareTo(L"http") == 0 || scheme.CompareTo(L"https") == 0)
 640         {
 641                 sourcePath = uri.GetEncodedString();
 642
 643                 r = AddTransferItem(uri, destPath, sourcePath, fileSize, CONTENT_TRANSFER_STATUS_DOWNLOAD_READY,
 644                                 pListener, sec, false, requestID);
 645                 SysTryReturn(NID_CNT, !IsFailed(r), r, r, "[%s] Failed to add a transfer item to queue.", GetErrorMessage(r));
 646
 647                 // TODO : if timer is started, it doesn't need call it..
 648                 ContentTransferHandler();
 649                 r = GetLastResult();
 650                 SysTryReturn(NID_CNT, !IsFailed(r), r, r, "[%s] Failed to handle the content transfer.", GetErrorMessage(r));
 651         }
 652         else
 653         {
 654                 SysLogException(NID_CNT, E_INVALID_ARG, "[E_INVALID_ARG] It is unsupported URI(%ls) address format.", uri.ToString().GetPointer());
 655
 656                 return E_INVALID_ARG;
 657         }
 658
 659         return r;
 660 }
 661
 662 result
 663 _ContentTransferImpl::DownloadToBuffer(const Utility::Uri& uri, int fileSize, RequestId& reqId,
 664                 IContentTransferListener* pListener, int sec)
 665 {
 666         // E_SUCCESS, E_INVALID_ARG, E_INVALID_STATE, E_PRIVILEGE_DENIED
 667
 668         SysLog(NID_CNT, "DownloadToBuffer operation start with listener.");
 669
 670         ClearLastResult();
 671         result r = E_SUCCESS;
 672         String tempFilePath(CONTENT_DOWNLOAD_TEMP_FILE_PATH);
 673         String sourcePath(L"");
 674         String scheme(L"");
 675         long long ticks = 0;
 676
 677         SysAssertf(__pContentDownloadHandler != null, "Not yet constructed. Construct() should be called before use.");
 678
 679         SysTryReturn(NID_CNT, fileSize >= 0, r = E_INVALID_ARG, E_INVALID_ARG,
 680                         "[E_INVALID_ARG] The size of the source file is less than 0.");
 681         SysTryReturn(NID_CNT, !uri.ToString().IsEmpty(), r = E_INVALID_ARG, E_INVALID_ARG,
 682                         "[E_INVALID_ARG] The source URI is empty.");
 683         SysTryReturn(NID_CNT, !uri.GetHost().IsEmpty() && !uri.GetPath().IsEmpty(), r = E_INVALID_ARG, E_INVALID_ARG,
 684                         "[E_INVALID_ARG] The source URI is empty.");
 685         SysTryReturn(NID_CNT, sec >= 0, E_INVALID_ARG, E_INVALID_ARG,
 686                         "[E_INVALID_ARG] The timeout value is less than 0.");
 687
 688         scheme = uri.GetScheme();
 689
 690         if (scheme.CompareTo(L"http") == 0 || scheme.CompareTo(L"https") == 0)
 691         {
 692                 r = _SystemTimeImpl::GetTicks(ticks);
 693                 SysTryReturn(NID_CNT, !IsFailed(r), r = E_INVALID_STATE, E_INVALID_STATE,
 694                                 "[E_INVALID_STATE] Failed to perform GetTicks operation.");
 695
 696                 r = tempFilePath.Append(ticks);
 697                 SysTryReturn(NID_CNT, !IsFailed(r), r = E_INVALID_STATE, E_INVALID_STATE,
 698                                 "[E_INVALID_STATE] Failed to append long long type to temporary file path.");
 699
 700                 r = tempFilePath.Append(downloadRequestId);
 701                 SysTryReturn(NID_CNT, !IsFailed(r), r = E_INVALID_ARG, E_INVALID_ARG,
 702                                 "[E_INVALID_ARG] Failed to append int type to temporary file path.");
 703
 704                 sourcePath = uri.GetEncodedString();
 705
 706                 r = AddTransferItem(uri, tempFilePath, sourcePath, fileSize,
 707                                 CONTENT_TRANSFER_STATUS_DOWNLOAD_READY, pListener, sec, true, reqId);
 708                 SysTryReturn(NID_CNT, !IsFailed(r), r = E_INVALID_ARG, E_INVALID_ARG,
 709                                 "[E_INVALID_ARG] Failed to add a transfer item to queue.");
 710
 711                 // TODO : if timer is started, it doesn't need call it..
 712                 __destFilePath = tempFilePath;
 713                 ContentTransferHandler();
 714                 r = GetLastResult();
 715                 SysTryReturn(NID_CNT, !IsFailed(r), r, r, "[%s] Failed to handle the content transfer.", GetErrorMessage(r));
 716         }
 717         else
 718         {
 719                 SysLogException(NID_CNT, E_INVALID_ARG, "[E_INVALID_ARG] It is unsupported URI(%ls) address format.", uri.ToString().GetPointer());
 720
 721                 return E_INVALID_ARG;
 722         }
 723
 724         return r;
 725 }
 726
 727 result
 728 _ContentTransferImpl::Download(const Utility::Uri& uri, const String& filePath,
 729                                                            RequestId& reqId, bool replace, int timeout, int progressInterval)
 730 {
 731         // E_SUCCESS, E_PRIVILEGE_DENIED, E_INVALID_ARG, E_INVALID_STATE, E_ILLEGAL_ACCESS, E_FILE_ALREADY_EXIST, E_IN_PROGRESS, E_OUT_OF_MEMORY, E_SYSTEM
 732
 733         SysLog(NID_CNT, "Download operation start without listener.");
 734
 735         ClearLastResult();
 736         result r = E_SUCCESS;
 737         String srcFilePath(L"");
 738         String scheme(L"");
 739
 740         SysAssertf(__pContentDownloadHandler != null, "Not yet constructed. Construct() should be called before use.");
 741
 742         SysTryReturn(NID_CNT, !filePath.IsEmpty(), r = E_INVALID_ARG, E_INVALID_ARG,
 743                                 "[E_INVALID_ARG] The destination file path is empty.");
 744         SysTryReturn(NID_CNT, !uri.ToString().IsEmpty(), r = E_INVALID_ARG, E_INVALID_ARG,
 745                                 "[E_INVALID_ARG] The source URI is empty.");
 746         SysTryReturn(NID_CNT, !uri.GetHost().IsEmpty() && !uri.GetPath().IsEmpty(), r = E_INVALID_ARG, E_INVALID_ARG,
 747                                 "[E_INVALID_ARG] The source URI is empty.");
 748         SysTryReturn(NID_CNT, timeout >= 0, r = E_INVALID_ARG, E_INVALID_ARG,
 749                                 "[E_INVALID_ARG] The timeout value is less than 0.");
 750         SysTryReturn(NID_CNT, progressInterval >= 0 && progressInterval <= 100, r = E_INVALID_ARG, E_INVALID_ARG,
 751                                 "[E_INVALID_ARG] The progress interval is less than 0.");
 752
 753         if (!_AppInfo::IsOspCompat())
 754         {
 755                 if (filePath.StartsWith(CONTENT_DOWNLOAD_PATH_MEDIA, 0) || filePath.StartsWith(CONTENT_DOWNLOAD_PATH_MEDIA_MMC, 0) ||
 756                                 filePath.StartsWith(CONTENT_DOWNLOAD_PATH_HOME, 0) || filePath.StartsWith(CONTENT_DOWNLOAD_PATH_HOME_MMC, 0))
 757                 {
 758                         SysLogException(NID_CNT, E_INVALID_ARG,
 759                                         "[E_INVALID_ARG] /Media/ , /Storagecard/Media/ , /Home/ , /HomeExt/ are not supported from Tizen 2.0.");
 760
 761                         return E_INVALID_ARG;
 762                 }
 763                 if (!(filePath.StartsWith(Tizen::App::App::GetInstance()->GetAppRootPath(), 0) || filePath.StartsWith(Environment::GetMediaPath(), 0) ||
 764                                 filePath.StartsWith(Environment::GetExternalStoragePath(), 0)))
 765                 {
 766                         SysLogException(NID_CNT, E_INVALID_ARG,
 767                                         "[E_INVALID_ARG] The [%ls] path is not supported.", filePath.GetPointer());
 768
 769                         return E_INVALID_ARG;
 770                 }
 771         }
 772         else
 773         {
 774                 // prior to 2.0
 775                 if (filePath.StartsWith(Tizen::App::App::GetInstance()->GetAppRootPath(), 0) || filePath.StartsWith(Environment::GetMediaPath(), 0) ||
 776                                 filePath.StartsWith(Environment::GetExternalStoragePath(), 0))
 777                 {
 778                         SysLogException(NID_CNT, E_INVALID_ARG,
 779                                         "[E_INVALID_ARG] This [%ls] path can be used from Tizen 2.0.", filePath.GetPointer());
 780
 781                         return E_INVALID_ARG;
 782                 }
 783                 if (!(filePath.StartsWith(CONTENT_DOWNLOAD_PATH_MEDIA, 0) || filePath.StartsWith(CONTENT_DOWNLOAD_PATH_MEDIA_MMC, 0) ||
 784                                 filePath.StartsWith(CONTENT_DOWNLOAD_PATH_HOME, 0) || filePath.StartsWith(CONTENT_DOWNLOAD_PATH_HOME_MMC, 0)))
 785                 {
 786                         SysLogException(NID_CNT, E_INVALID_ARG,
 787                                         "[E_INVALID_ARG] The [%ls] is not supported.", filePath.GetPointer());
 788
 789                         return E_INVALID_ARG;
 790                 }
 791         }
 792
 793         __destFilePath = filePath;
 794
 795         r = CheckDestPath(__destFilePath, replace);
 796         SysTryReturn(NID_CNT, !IsFailed(r), r, r, "[%s] Failed to perform CheckDestPath operation.", GetErrorMessage(r));
 797
 798         scheme = uri.GetScheme();
 799
 800         if (scheme.CompareTo(L"http") == 0 || scheme.CompareTo(L"https") == 0)
 801         {
 802                 srcFilePath = uri.GetEncodedString();
 803
 804                 r = AddTransferItem(uri, __destFilePath, srcFilePath, CONTENT_TRANSFER_STATUS_DOWNLOAD_READY,
 805                                                         timeout, progressInterval, false, reqId);
 806                 SysTryReturn(NID_CNT, !IsFailed(r), r, r, "[%s] Failed to add a transfer item to queue.", GetErrorMessage(r));
 807         }
 808         else
 809         {
 810                 SysLogException(NID_CNT, E_INVALID_ARG,
 811                                 "[E_INVALID_ARG] It is unsupported URI(%ls) address format.", uri.ToString().GetPointer());
 812
 813                 return E_INVALID_ARG;
 814         }
 815
 816         ContentTransferHandler();
 817         r = GetLastResult();
 818         SysTryReturn(NID_CNT, !IsFailed(r), r, r, "[%s] Failed to handle the content transfer.", GetErrorMessage(r));
 819
 820         return r;
 821 }
 822
 823 result
 824 _ContentTransferImpl::DownloadToBuffer(const Utility::Uri& uri, RequestId& reqId, int timeout, int progressInterval)
 825 {
 826         // E_SUCCESS, E_PRIVILEGE_DENIED, E_INVALID_ARG, E_INVALID_STATE, E_ILLEGAL_ACCESS, E_IN_PROGRESS, E_OUT_OF_MEMORY
 827
 828         SysLog(NID_CNT, "DownloadToBuffer operation start without listener.");
 829         ClearLastResult();
 830         result r = E_SUCCESS;
 831         String srcFilePath(L"");
 832         String tempDestFilePath(CONTENT_DOWNLOAD_TEMP_FILE_PATH);
 833         String scheme(L"");
 834         long long ticks = 0;
 835
 836         SysAssertf(__pContentDownloadHandler != null, "Not yet constructed. Construct() should be called before use.");
 837
 838         SysTryReturn(NID_CNT, !uri.ToString().IsEmpty(), E_INVALID_ARG, E_INVALID_ARG,
 839                                 "[E_INVALID_ARG] The source URI is empty.");
 840         SysTryReturn(NID_CNT, !uri.GetHost().IsEmpty() && !uri.GetPath().IsEmpty(), E_INVALID_ARG, E_INVALID_ARG,
 841                                 "[E_INVALID_ARG] The source URI is empty.");
 842         SysTryReturn(NID_CNT, timeout >= 0, E_INVALID_ARG, E_INVALID_ARG,
 843                                 "[E_INVALID_ARG] The timeout value is less than 0.");
 844         SysTryReturn(NID_CNT, progressInterval >= 0 && progressInterval <= 100, E_INVALID_ARG, E_INVALID_ARG,
 845                                 "[E_INVALID_ARG] The progress interval is less than 0.");
 846
 847         scheme = uri.GetScheme();
 848         if (scheme.CompareTo(L"http") == 0 || scheme.CompareTo(L"https") == 0)
 849         {
 850                 r = _SystemTimeImpl::GetTicks(ticks);
 851                 SysTryReturn(NID_CNT, !IsFailed(r), r, r, "[%s] Failed to perform GetTicks operation.", GetErrorMessage(r));
 852
 853                 r = tempDestFilePath.Append(ticks);
 854                 SysTryReturn(NID_CNT, !IsFailed(r), r, r, "[%s] Failed to append long long type to temporary file path.", GetErrorMessage(r));
 855
 856                 r = tempDestFilePath.Append(downloadRequestId);
 857                 SysTryReturn(NID_CNT, !IsFailed(r), r, r, "[%s] Failed to append int type to temporary file path.", GetErrorMessage(r));
 858
 859                 srcFilePath = uri.GetEncodedString();
 860
 861                 r = AddTransferItem(uri, tempDestFilePath, srcFilePath, CONTENT_TRANSFER_STATUS_DOWNLOAD_READY,
 862                                                         timeout, progressInterval, true, reqId);
 863                 SysTryReturn(NID_CNT, !IsFailed(r), r, r, "[%s] Failed to add a transfer item to queue.", GetErrorMessage(r));
 864         }
 865         else
 866         {
 867                 SysLogException(NID_CNT, E_INVALID_ARG,
 868                                 "[E_INVALID_ARG] It is unsupported URI(%ls) address format.", uri.ToString().GetPointer());
 869
 870                 return E_INVALID_ARG;
 871         }
 872
 873         ContentTransferHandler();
 874         r = GetLastResult();
 875         SysTryReturn(NID_CNT, !IsFailed(r), r, r, "[%s] Failed to handle the content transfer.", GetErrorMessage(r));
 876
 877         return r;
 878 }
 879
 880 void
 881 _ContentTransferImpl::OnTimerExpired(Runtime::Timer& timer)
 882 {
 883         ClearLastResult();
 884         bool check = false;
 885         check = ContentTransferHandler();
 886
 887         SysAssertf(__pTimer != null, "Not yet constructed. Construct() should be called before use.");
 888
 889         if (check == true)
 890         {
 891                 __pTimer->Start(CONTENT_DOWNLOAD_CHECKING_PERIOD);
 892                 __timerStarted = true;
 893         }
 894         else
 895         {
 896                 __timerStarted = false;
 897         }
 898 }
 899
 900 RequestId
 901 _ContentTransferImpl::GetRequestId(void) const
 902 {
 903         return ++downloadRequestId;
 904 }
 905
 906 ContentTransferInfo*
 907 _ContentTransferImpl::GetContentTransferInfoByRequestId(RequestId requestId) const
 908 {
 909         ClearLastResult();
 910         result r = E_SUCCESS;
 911         std::unique_ptr<IEnumerator> pEnum;
 912         ContentTransferInfo* pTransferInfo = null;
 913
 914         pEnum = std::unique_ptr<IEnumerator>(__pTransferInfoList->GetEnumeratorN());
 915
 916         if (pEnum == null)
 917         {
 918                 r = GetLastResult();
 919                 SysLogException(NID_CNT, r, "[%s] Failed to perform GetEnumeratorN operation.", GetErrorMessage(r));
 920                 return null;
 921         }
 922
 923         while (pEnum->MoveNext() == E_SUCCESS)
 924         {
 925                 pTransferInfo = dynamic_cast<ContentTransferInfo*>(pEnum->GetCurrent());
 926                 SysTryReturn(NID_CNT, pTransferInfo != null, null, E_INVALID_ARG,
 927                                    "[E_INVALID_ARG] ContentTransferInfo instance must not be null.");
 928
 929                 if (pTransferInfo->GetRequestId() == requestId)
 930                 {
 931                         break;
 932                 }
 933                 pTransferInfo = null;
 934         }
 935
 936         return pTransferInfo;
 937 }
 938
 939 void
 940 _ContentTransferImpl::StartTimer(void)
 941 {
 942         ClearLastResult();
 943         result r = E_SUCCESS;
 944
 945         if (!(__timerStarted))
 946         {
 947                 r = __pTimer->Start(CONTENT_DOWNLOAD_CHECKING_PERIOD);
 948                 SysTryReturnVoidResult(NID_CNT, !IsFailed(r), r = E_INVALID_ARG, "[E_INVALID_ARG] Failed to start timer.");
 949
 950                 __timerStarted = true;
 951         }
 952 }
 953
 954 result
 955 _ContentTransferImpl::GetEmptySlot(int& slot) const
 956 {
 957         ClearLastResult();
 958         result r = E_SUCCESS;
 959
 960         slot = GetEmptySlotInternal();
 961
 962         if (slot < 0 || slot > MAX_DOWNLOAD_COUNT)
 963         {
 964                 r = E_OBJ_NOT_FOUND;
 965                 SysLog(NID_CNT, "Failed to get empty slot for download.");
 966         }
 967
 968         return r;
 969 }
 970
 971 result
 972 _ContentTransferImpl::CheckDestPath(const String& destPath, bool replace)
 973 {
 974         result r = E_SUCCESS;
 975         String destFilePath(L"");
 976         String checkName(L"");
 977         String checkPath(L"");
 978         FileAttributes fileAttr;
 979         int copySize = 0;
 980         int maxSize = 1024;
 981         int lengthString = 0;
 982         Directory dir;
 983
 984         destFilePath = destPath;
 985         SysTryReturn(NID_CNT, !destFilePath.IsEmpty(), r = E_INVALID_ARG, E_INVALID_ARG,
 986                                 "[E_INVALID_ARG] The destination file path is empty.");
 987
 988         if (!_AppInfo::IsOspCompat())
 989         {
 990                 if (!(destFilePath.String::StartsWith(Environment::GetMediaPath(), 0) ||
 991                           destFilePath.String::StartsWith(Environment::GetExternalStoragePath(), 0) ||
 992                           destFilePath.String::StartsWith(Tizen::App::App::GetInstance()->GetAppRootPath(), 0)))
 993                 {
 994                         SysLogException(NID_CNT, E_INVALID_ARG, "[E_INVALID_ARG] The destination path is not allowed path.");
 995                         return E_INVALID_ARG;
 996                 }
 997         }
 998         else
 999         {
1000                 // the allowed destination path
1001                 // /Media, /Storagecard/Media
1002                 // /Home, /HomeExt
1003                 if (!(destFilePath.String::StartsWith(CONTENT_DOWNLOAD_PATH_MEDIA, 0) ||
1004                           destFilePath.String::StartsWith(CONTENT_DOWNLOAD_PATH_MEDIA_MMC, 0) ||
1005                           destFilePath.String::StartsWith(CONTENT_DOWNLOAD_PATH_HOME, 0) ||
1006                           destFilePath.String::StartsWith(CONTENT_DOWNLOAD_PATH_HOME_MMC, 0)))
1007                 {
1008                         SysLogException(NID_CNT, E_INVALID_ARG, "[E_INVALID_ARG] The destination path is not allowed path.");
1009                         return E_INVALID_ARG;
1010                 }
1011         }
1012
1013         //check overwrite
1014         if (_FileImpl::IsFileExist(destFilePath) == true)
1015         {
1016                 // not allowed overwrite
1017                 if (replace != true)
1018                 {
1019                         SysLogException(NID_CNT, E_FILE_ALREADY_EXIST, "[E_FILE_ALREADY_EXIST] The file already exists in destination path.");
1020                         return E_FILE_ALREADY_EXIST;
1021                 }
1022
1023                 // allowed overwrite
1024                 r = _FileImpl::GetAttributes(destFilePath, fileAttr);
1025                 SysTryReturn(NID_CNT, !IsFailed(r), r = E_INVALID_ARG, E_INVALID_ARG,
1026                                 "[E_INVALID_ARG] Failed to perform GetAttributes operation. ");
1027                 SysTryReturn(NID_CNT, !(fileAttr.IsDirectory()), r = E_ILLEGAL_ACCESS, E_ILLEGAL_ACCESS,
1028                                    "[E_ILLEGAL_ACCESS] The file path is directory path.");
1029                 SysTryReturn(NID_CNT, !(fileAttr.IsReadOnly()), r = E_ILLEGAL_ACCESS, E_ILLEGAL_ACCESS,
1030                                    "[E_ILLEGAL_ACCESS] The file can only read.");
1031         }
1032         else
1033         {
1034
1035                 if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
1036                 {
1037                         // check the destination file path
1038                         // check the path
1039                         SysTryReturn(NID_CNT, _FileImpl::IsMediaPath(destFilePath) == true || _FileImpl::IsAppPath(destFilePath) == true,
1040                                         r = E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The file path is not a media or an app path.");
1041                 }
1042
1043                 // 1st: file name
1044                 // check whether the destination path includes the file name
1045                 checkName = _FileImpl::GetFileName(destFilePath);
1046                 SysTryReturn(NID_CNT, !checkName.IsEmpty(), r = E_INVALID_ARG, E_INVALID_ARG,
1047                                    "[E_INVALID_ARG] Failed to get the file name from a path.");
1048
1049                 // 2nd: parent directory
1050                 lengthString = destFilePath.String::GetLength();
1051                 r = destFilePath.String::LastIndexOf('/', lengthString - 1, copySize);
1052                 SysTryReturn(NID_CNT, copySize > 0 && copySize < maxSize, r = E_INVALID_ARG, E_INVALID_ARG,
1053                                 "[E_INVALID_ARG] Failed to get the size of path.");
1054
1055                 // copy the parent path
1056                 r = destFilePath.SubString(0, copySize + 1, checkPath);
1057                 SysTryReturn(NID_CNT, !IsFailed(r), r = E_INVALID_ARG, E_INVALID_ARG,
1058                                 "[E_INVALID_ARG] Failed to perform SubString operation.");
1059
1060                 if (!_AppInfo::IsOspCompat())
1061                 {
1062                         SysTryReturn(NID_CNT, destFilePath.String::StartsWith(Environment::GetMediaPath(), 0) ||
1063                                           destFilePath.String::StartsWith(Environment::GetExternalStoragePath(), 0) ||
1064                                         _FileImpl::IsAppPath(destFilePath) == true,
1065                                         r = E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The path is invalid media path.");
1066
1067                         if (!(_FileImpl::IsFileExist(checkPath)))
1068                         {
1069                                 r = dir.Create(checkPath);
1070                                 SysTryReturn(NID_CNT, !IsFailed(r), r = E_INVALID_ARG, E_INVALID_ARG,
1071                                                 "[E_INVALID_ARG] Failed to create the directory.");
1072                         }
1073                 }
1074
1075                 // check the validation of the parent path
1076                 r = _FileImpl::GetAttributes(checkPath, fileAttr);
1077                 SysTryReturn(NID_CNT, !IsFailed(r), r = E_INVALID_ARG, E_INVALID_ARG,
1078                                 "[E_INVALID_ARG] Failed to perform GetAttributes operation.");
1079                 SysTryReturn(NID_CNT, fileAttr.IsDirectory() == true, r = E_ILLEGAL_ACCESS, E_ILLEGAL_ACCESS,
1080                                 "[E_ILLEGAL_ACCESS] The path is not a directory path.");
1081         }
1082
1083         return r;
1084 }
1085
1086 result
1087 _ContentTransferImpl::CheckDownloadStatus(const Uri& uri, const String& destPath)
1088 {
1089         ClearLastResult();
1090         std::unique_ptr<IEnumerator> pEnum;
1091         ContentTransferInfo* pTransferInfoTemp = null;
1092         ContentTransferStatus statusTemp = CONTENT_TRANSFER_STATUS_NONE;
1093         result r = E_SUCCESS;
1094
1095         pEnum = std::unique_ptr<IEnumerator>(__pTransferInfoList->GetEnumeratorN());
1096         SysTryReturn(NID_CNT, pEnum != null, r = E_ILLEGAL_ACCESS, E_ILLEGAL_ACCESS,
1097                            "[%s] Failed to perform GetEnumeratorN operation.", GetErrorMessage(r));
1098
1099         while (pEnum->MoveNext() == E_SUCCESS)
1100         {
1101                 pTransferInfoTemp = dynamic_cast<ContentTransferInfo*>(pEnum->GetCurrent());
1102                 SysTryReturn(NID_CNT, pTransferInfoTemp != null, r = E_INVALID_STATE, E_INVALID_STATE,
1103                                    "[E_INVALID_STATE] ContentTransferInfo instance must not be null.");
1104
1105                 statusTemp = pTransferInfoTemp->GetContentTransferStatus();
1106
1107                 if (statusTemp == CONTENT_TRANSFER_STATUS_DOWNLOAD_READY ||
1108                         statusTemp == CONTENT_TRANSFER_STATUS_DOWNLOADING)
1109                 {
1110                         if (destPath.CompareTo(pTransferInfoTemp->GetDestPath()) == 0)
1111                         {
1112                                 if (uri.CompareTo(pTransferInfoTemp->GetUri()) == 0)
1113                                 {
1114                                         SysLogException(NID_CNT, E_IN_PROGRESS, "[E_IN_PROGRESS] Transfer is in progress.");
1115                                         return E_IN_PROGRESS;
1116                                 }
1117                                 else
1118                                 {
1119                                         SysLogException(NID_CNT, E_ILLEGAL_ACCESS, "[E_ILLEGAL_ACCESS] Access to source is illegal access.");
1120                                         return E_ILLEGAL_ACCESS;
1121                                 }
1122                         }
1123                 }
1124         }
1125
1126         return r;
1127 }
1128
1129 result
1130 _ContentTransferImpl::AddTransferItem(const Uri& uri, const String& destPath, const String& sourcePath, int sourceFileSize,
1131                 ContentTransferStatus status, IContentTransferListener* pListener, int sec, bool isBuffer, RequestId& requestId)
1132 {
1133         ClearLastResult();
1134         result r = E_SUCCESS;
1135         std::unique_ptr<IEnumerator> pEnum;
1136         std::unique_ptr<ContentTransferInfo> pTransferInfo;
1137         ContentTransferInfo* pTransferInfoTemp = null;
1138         ContentTransferStatus statusTemp = CONTENT_TRANSFER_STATUS_NONE;
1139         requestId = INVALID_REQUEST_ID;
1140
1141         SysAssertf(__pTransferInfoList != null, "Not yet constructed. Construct() should be called before use.");
1142
1143         pEnum = std::unique_ptr<IEnumerator>(__pTransferInfoList->GetEnumeratorN());
1144         SysTryReturn(NID_CNT, pEnum != null, r = E_ILLEGAL_ACCESS, E_ILLEGAL_ACCESS,
1145                         "[E_ILLEGAL_ACCESS] Failed to perform GetEnumeratorN operation.");
1146
1147         while (pEnum->MoveNext() == E_SUCCESS)
1148         {
1149                 pTransferInfoTemp = dynamic_cast<ContentTransferInfo*>(pEnum->GetCurrent());
1150                 SysTryReturn(NID_CNT, pTransferInfoTemp != null, r = E_INVALID_ARG, E_INVALID_ARG,
1151                                    "[E_INVALID_ARG] ContentTransferInfo instance must not be null.");
1152
1153                 statusTemp = pTransferInfoTemp->GetContentTransferStatus();
1154
1155                 if (statusTemp == CONTENT_TRANSFER_STATUS_DOWNLOAD_READY || statusTemp == CONTENT_TRANSFER_STATUS_DOWNLOADING)
1156                 {
1157                         if (destPath.CompareTo(pTransferInfoTemp->GetDestPath()) == 0)
1158                         {
1159                                 if (uri.CompareTo(pTransferInfoTemp->GetUri()) == 0)
1160                                 {
1161                                         SysLogException(NID_CNT, E_IN_PROGRESS, "[E_IN_PROGRESS] The request is already in progress.");
1162                                         return E_IN_PROGRESS;
1163                                 }
1164                                 else
1165                                 {
1166                                         SysLogException(NID_CNT, E_ILLEGAL_ACCESS,
1167                                                         "[E_ILLEGAL_ACCESS] The destination path [%ls] is already in progress.", destPath.GetPointer());
1168                                         return E_ILLEGAL_ACCESS;
1169                                 }
1170                         }
1171                 }
1172         }
1173
1174         pTransferInfo = std::unique_ptr<ContentTransferInfo>(new (std::nothrow) ContentTransferInfo);
1175         SysTryReturn(NID_CNT, pTransferInfo != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
1176                         "[E_OUT_OF_MEMORY] Failed to construct ContentTransferInfo.");
1177
1178         requestId = GetRequestId();
1179
1180         pTransferInfo->SetAllInfo(requestId, uri, destPath, sourcePath, sourceFileSize, status);
1181
1182         if (pListener)
1183         {
1184                 pTransferInfo->SetListener(pListener);
1185         }
1186
1187         if (sec > 0)
1188         {
1189                 __timeout = sec;
1190                 pTransferInfo->SetTimeout(sec);
1191         }
1192         else
1193         {
1194                 __timeout = 0;
1195                 pTransferInfo->SetTimeout(0);
1196         }
1197
1198         if (__percent > 0 && __percent <= 100)
1199         {
1200                 pTransferInfo->SetProgressInterval(__percent);
1201         }
1202         else
1203         {
1204                 pTransferInfo->SetProgressInterval(0);
1205         }
1206
1207         if (isBuffer == true)
1208         {
1209                 __isBuffer = isBuffer;
1210                 pTransferInfo->SetIsBuffer(true);
1211         }
1212
1213         r = __pTransferInfoList->Add(*(pTransferInfo.release()));
1214         SysTryReturn(NID_CNT, !IsFailed(r), r = E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Failed to add item to info list.");
1215
1216         return r;
1217 }
1218
1219 result
1220 _ContentTransferImpl::AddTransferItem(const Uri& uri, const String& destPath, const String& sourcePath,
1221                                                                           ContentTransferStatus status, int timeout, int interval, bool isBuffer, RequestId& requestId)
1222 {
1223         ClearLastResult();
1224         result r = E_SUCCESS;
1225         std::unique_ptr<ContentTransferInfo> pTransferInfo;
1226         requestId = INVALID_REQUEST_ID;
1227
1228         r = CheckDownloadStatus(uri, destPath);
1229         SysTryReturn(NID_CNT, !IsFailed(r), r, r, "[%s] Failed to perform CheckDownloadStatus operation.", GetErrorMessage(r));
1230
1231         // pTransferInfo will be deallocated in the Response routine
1232         pTransferInfo = std::unique_ptr<ContentTransferInfo>(new (std::nothrow) ContentTransferInfo);
1233         SysTryReturn(NID_CNT, pTransferInfo != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
1234                                 "[%s] Failed to construct ContentTransferInfo.", GetErrorMessage(r));
1235
1236         requestId = GetRequestId();
1237
1238         pTransferInfo->SetAllInfo(requestId, uri, destPath, sourcePath, 0, status);
1239
1240         if (timeout > 0)
1241         {
1242                 __timeout = timeout;
1243                 pTransferInfo->SetTimeout(timeout);
1244         }
1245         else
1246         {
1247                 __timeout = 0;
1248                 pTransferInfo->SetTimeout(0);
1249         }
1250
1251         if (interval > 0 && interval <= 100)
1252         {
1253                 __percent = interval;
1254                 pTransferInfo->SetProgressInterval(interval);
1255         }
1256         else
1257         {
1258                 __percent = 0;
1259                 pTransferInfo->SetProgressInterval(0);
1260         }
1261
1262         if (isBuffer == true)
1263         {
1264                 __isBuffer = isBuffer;
1265                 pTransferInfo->SetIsBuffer(true);
1266         }
1267
1268         r = __pTransferInfoList->Add(*(pTransferInfo.release()));
1269         SysTryReturn(NID_CNT, !IsFailed(r), r = E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Failed to add item to info list.");
1270
1271         return r;
1272 }
1273
1274 result
1275 _ContentTransferImpl::SetDownloadSlotInfo(ContentTransferInfo* pTransferInfo, int& slot)
1276 {
1277         ClearLastResult();
1278         result r = E_SUCCESS;
1279         String destPath(L"");
1280
1281         SysAssertf(__pContentDownloadHandler != null, "Not yet constructed. Construct() should be called before use.");
1282
1283         SysTryReturn(NID_CNT, pTransferInfo != null, r = E_INVALID_ARG, E_INVALID_ARG,
1284                                 "[E_INVALID_ARG] ContentTransferInfo instance must not be null.");
1285
1286         destPath = pTransferInfo->GetDestPath();
1287
1288         r = GetEmptySlot(slot);
1289         SysLog(NID_CNT, "Set the download slot [%d].", slot);
1290         SysTryReturn(NID_CNT, !IsFailed(r) && slot != -1, r = E_INVALID_ARG, E_INVALID_ARG,
1291                         "[E_INVALID_ARG] Failed to get the empty slot.");
1292
1293         SetUsedSlotInternal(slot);
1294
1295         (__pContentDownloadHandlerSequence.get())[slot].SetSlot(slot);
1296         (__pContentDownloadHandlerSequence.get())[slot].SetRequestId(pTransferInfo->GetRequestId());
1297         (__pContentDownloadHandlerSequence.get())[slot].SetTimeout(pTransferInfo->GetTimeout());
1298         (__pContentDownloadHandlerSequence.get())[slot].SetProgressIntervalByPercent(pTransferInfo->GetProgressInterval());
1299         (__pContentDownloadHandlerSequence.get())[slot].SetDownloadPath(destPath);
1300
1301         (__pContentDownloadUserDataSequence.get())[slot].SetSlot(slot);
1302         (__pContentDownloadUserDataSequence.get())[slot].SetContentTransferInfo(pTransferInfo);
1303         (__pContentDownloadUserDataSequence.get())[slot].SetRequestId(pTransferInfo->GetRequestId());
1304         (__pContentDownloadUserDataSequence.get())[slot].SetPercent(pTransferInfo->GetProgressInterval());
1305         (__pContentDownloadUserDataSequence.get())[slot].SetContentTransferEvent(__pTransferEvent.get());
1306         (__pContentDownloadUserDataSequence.get())[slot].SetDestPath(destPath);
1307
1308         if (__isBuffer == true)
1309         {
1310                 (__pContentDownloadUserDataSequence.get())[slot].SetDownloadBufferFlag(true);
1311         }
1312
1313         pTransferInfo->SetSlotId(slot);
1314
1315         return r;
1316 }
1317
1318 result
1319 _ContentTransferImpl::RequestErrorEvent(result requestErrorCode, ContentTransferInfo* pTransferInfo)
1320 {
1321         ClearLastResult();
1322         result r = E_SUCCESS;
1323         std::unique_ptr<_ContentTransferEventArg> pTransferEventArg;
1324
1325         pTransferEventArg = std::unique_ptr<_ContentTransferEventArg>(new (std::nothrow) _ContentTransferEventArg);
1326         SysTryReturn(NID_CNT, pTransferEventArg != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
1327                                 "[E_OUT_OF_MEMORY] Failed to construct ContentTransferEventArg.");
1328
1329         pTransferEventArg->SetResult(requestErrorCode);
1330
1331         if (pTransferInfo->GetIsBuffer() == true)
1332         {
1333                 pTransferEventArg->SetEventType(Content::CONTENT_TRANSFER_EVENT_DOWNLOAD_TO_BUFFER_COMPLETED);
1334
1335         }
1336         else
1337         {
1338                 pTransferEventArg->SetEventType(Content::CONTENT_TRANSFER_EVENT_DOWNLOAD_COMPLETED);
1339         }
1340
1341         pTransferEventArg->SetRequestId(pTransferInfo->GetRequestId());
1342
1343         r = __pTransferEvent->Fire(*(pTransferEventArg.release()));
1344         SysTryReturn(NID_CNT, !IsFailed(r), r, r, "[%s] Failed to perform fire operation on ContentTransferEvent.", GetErrorMessage(r));
1345
1346         pTransferInfo->SetDownloadStatus(CONTENT_TRANSFER_STATUS_DOWNLOAD_COMPLETED);
1347
1348         return r;
1349 }
1350
1351 result
1352 _ContentTransferImpl::RemoveCompletedTransferInfo(ArrayList* pTransferInfoList)
1353 {
1354         ClearLastResult();
1355         std::unique_ptr<IEnumerator> pEnum;
1356         ContentTransferInfo* pTransferInfo = null;
1357         result r = E_SUCCESS;
1358
1359         if (pTransferInfoList == null)
1360         {
1361                 return r;
1362         }
1363
1364         pEnum = std::unique_ptr<IEnumerator>(pTransferInfoList->GetEnumeratorN());
1365         SysTryReturn(NID_CNT, pEnum != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
1366                                    "[E_OUT_OF_MEMORY] Failed to perform GetEnumeratorN operation.");
1367
1368         while (pEnum->MoveNext() == E_SUCCESS)
1369         {
1370                 pTransferInfo = dynamic_cast<ContentTransferInfo*>(pEnum->GetCurrent());
1371                 SysTryReturn(NID_CNT, pTransferInfo != null, r = E_INVALID_ARG, r,
1372                                    "[E_INVALID_ARG] ContentTransferInfo instance must not be null.");
1373
1374                 __pTransferInfoList->Remove(*pTransferInfo, true);
1375                 r = GetLastResult();
1376                 SysTryReturn(NID_CNT, !IsFailed(r), r, r, "[%s] Failed to remove a item from transfer info list.", GetErrorMessage(r));
1377         }
1378
1379         return r;
1380 }
1381
1382 bool
1383 _ContentTransferImpl::ContentTransferHandler(void)
1384 {
1385         ClearLastResult();
1386         result r = E_SUCCESS;
1387         std::unique_ptr<IEnumerator> pEnum;
1388         std::unique_ptr<ArrayList> pDeleteList;
1389         ContentTransferInfo* pTransferInfo = null;
1390         ContentTransferStatus status = CONTENT_TRANSFER_STATUS_NONE;
1391         int downloadCount = 0;
1392         RequestId restRequestId = INVALID_REQUEST_ID;
1393         bool full = false;
1394         int idx = 0;
1395         bool check = false;
1396         int slot = 0;
1397         String destPath(L"");
1398         String sourcePath(L"");
1399
1400         pEnum = std::unique_ptr<IEnumerator>(__pTransferInfoList->GetEnumeratorN());
1401         if (pEnum == null)
1402         {
1403                 return false;
1404         }
1405
1406         while (pEnum->MoveNext() == E_SUCCESS)
1407         {
1408                 pTransferInfo = dynamic_cast<ContentTransferInfo*>(pEnum->GetCurrent());
1409                 SysTryReturn(NID_CNT, pTransferInfo != null, check, E_INVALID_ARG,
1410                                    "[E_INVALID_ARG] ContentTransferInfo instance must not be null.");
1411
1412                 status = pTransferInfo->GetContentTransferStatus();
1413
1414                 if (status == CONTENT_TRANSFER_STATUS_DOWNLOADING)
1415                 {
1416                         downloadCount++;
1417                         if (downloadCount == MAX_DOWNLOAD_COUNT)
1418                         {
1419                                 full = true;
1420                                 continue;
1421                         }
1422                         else
1423                         {
1424                                 continue;
1425                         }
1426                 }
1427                 else if (status == CONTENT_TRANSFER_STATUS_DOWNLOAD_READY)
1428                 {
1429                         if (full == true)
1430                         {
1431                                 StartTimer();
1432                                 r = GetLastResult();
1433                                 SysTryReturn(NID_CNT, !IsFailed(r), check, r, "[%s] Failed to perform StartTimer operation.", GetErrorMessage(r));
1434
1435                                 check = true;
1436                                 break;
1437                         }
1438
1439                         // get empty buffer slot from download buffer
1440                         // set slot information
1441                         r = SetDownloadSlotInfo(pTransferInfo, slot);
1442                         if (slot < 0)
1443                         {
1444                                 SysLogException(NID_CNT, r, "[%s] Failed to find an empty slot.", GetErrorMessage(r));
1445                                 check = true;
1446                                 break;
1447                         }
1448
1449                         if (IsFailed(r))
1450                         {
1451                                 SysLogException(NID_CNT, r, "[%s] Propagating.", GetErrorMessage(r));
1452                                 break;
1453                         }
1454
1455                         destPath = pTransferInfo->GetDestPath();
1456                         sourcePath = pTransferInfo->GetUri().ToString();
1457                         (__pContentDownloadHandlerSequence.get())[slot].SetSlot(slot);
1458
1459                         // request download
1460                         restRequestId = (__pContentDownloadHandlerSequence.get())[slot].HttpDownload(sourcePath,
1461                                         pTransferInfo->GetSourceFileSize(), destPath, &(__pContentDownloadUserDataSequence.get())[slot]);
1462                         r = GetLastResult();
1463                         SysTryLog(NID_CNT, restRequestId != INVALID_REQUEST_ID,
1464                                         "[%s] The rest request ID is invalid.", GetErrorMessage(r));
1465
1466                         if (IsFailed(r))
1467                         {
1468                                 r = RequestErrorEvent(r, pTransferInfo);
1469                                 SysTryReturn(NID_CNT, !IsFailed(r), check, E_INVALID_ARG,
1470                                                 "[E_INVALID_ARG] Failed to perform RequestErrorEvent operation.");
1471
1472                                 (__pContentDownloadUserDataSequence.get())[slot].SetSlotFlag(false);
1473
1474                                 continue;
1475                         }
1476
1477                         sourcePath = null;
1478                         destPath = null;
1479
1480                         pTransferInfo->SetRestRequestId(restRequestId);
1481                         pTransferInfo->SetDownloadStatus(CONTENT_TRANSFER_STATUS_DOWNLOADING);
1482                         downloadCount++;
1483
1484                         if (downloadCount == MAX_DOWNLOAD_COUNT)
1485                         {
1486                                 full = true;
1487                         }
1488                         else
1489                         {
1490                                 continue;
1491                         }
1492                 }
1493                 else if (status == CONTENT_TRANSFER_STATUS_DOWNLOAD_COMPLETED)
1494                 {
1495                         SetEmptySlotInternal();
1496
1497                         // TODO : should i check to sync
1498                         if (pDeleteList == null)
1499                         {
1500                                 pDeleteList = std::unique_ptr<ArrayList>(new (std::nothrow) ArrayList());
1501                                 SysTryReturn(NID_CNT, !IsFailed(r), check, E_OUT_OF_MEMORY,
1502                                                 "[E_OUT_OF_MEMORY] Failed to construct ArrayList.");
1503                         }
1504                         pDeleteList->Add(*pTransferInfo);
1505                 }
1506                 idx++;
1507         }
1508
1509         r = RemoveCompletedTransferInfo(pDeleteList.get());
1510         SysTryReturn(NID_CNT, !IsFailed(r), check, E_INVALID_ARG,
1511                         "[E_INVALID_ARG] Failed to remove the completed transfer info.");
1512
1513         return check;
1514 }
1515 }}