src/MfThumbnailManager.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.1 (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://floralicense.org/license/
   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 /**
  18  * @file: ThumbnailManager.cpp
  19  * @brief: This file contains the implementation of ThumbnailManager class,
  20  * which manages creation of Thumbnails for each folder entry.
  21  */
  22
  23 #include <FApp.h>
  24 #include <FBase.h>
  25 #include <FContent.h>
  26 #include <FGraphics.h>
  27 #include <FMedia.h>
  28
  29 #include "MfThumbnailManager.h"
  30 #include "MfUtility.h"
  31
  32 using namespace Tizen::App;
  33 using namespace Tizen::Base::Collection;
  34 using namespace Tizen::Graphics;
  35
  36 static ThumbnailManager* thumbnailManager = null;
  37
  38 #if 0
  39 static const wchar_t* IDB_VIDEO_PLAY_THUMB_BIG = L"U01_thumbnail_icon_video.png";
  40 #endif
  41
  42 using namespace     Tizen::App;
  43 using namespace     Tizen::Base;
  44 using namespace     Tizen::Base::Collection;
  45 using namespace     Tizen::Base::Runtime;
  46 using namespace     Tizen::Content;
  47 using namespace     Tizen::Graphics;
  48 using namespace     Tizen::Media;
  49
  50 ThumbnailManager*
  51 ThumbnailManager::GetInstance(void)
  52 {
  53         if (thumbnailManager == null)
  54         {
  55                 CreateInstance();
  56         }
  57         return thumbnailManager;
  58 }
  59
  60 void
  61 ThumbnailManager::CreateInstance(void)
  62 {
  63         result r = E_SUCCESS;
  64
  65         thumbnailManager = new (std::nothrow) ThumbnailManager();
  66         r = thumbnailManager->Construct();
  67
  68
  69         if (r != E_SUCCESS)
  70         {
  71                 DeleteInstance();
  72                 return;
  73         }
  74
  75         std::atexit(DeleteInstance);
  76 }
  77
  78 void
  79 ThumbnailManager::DeleteInstance(void)
  80 {
  81         if (thumbnailManager != null)
  82         {
  83                 /*thumbnailManager->Stop();
  84                 thumbnailManager->Join();*/
  85
  86                 delete thumbnailManager;
  87                 thumbnailManager = null;
  88         }
  89 }
  90 result
  91 ThumbnailManager::Construct(void)
  92 {
  93         result r = E_FAILURE;
  94         r = Thread::Construct(THREAD_TYPE_EVENT_DRIVEN);
  95
  96         AppResource* pAppResource = null;
  97         pAppResource = Application::GetInstance()->GetAppResource();
  98
  99         __pDummyImage = pAppResource->GetBitmapN(IDB_DUMMY_IMG, BITMAP_PIXEL_FORMAT_ARGB8888);
 100
 101         r = Start();
 102         return r;
 103 }
 104
 105 ThumbnailManager::ThumbnailManager(void)
 106         : __pCurrentThumbReq(null)
 107         , __pDummyImage(null)
 108 {
 109         //Empty Implementation.
 110 }
 111
 112 ThumbnailManager::~ThumbnailManager(void)
 113 {
 114         ClearCurrentThumbRequest();
 115         delete __pDummyImage;
 116 }
 117
 118 ThumbnailManager::ThumbnailManager(const ThumbnailManager& thumbnailManager)
 119 {
 120         __pCurrentThumbReq = null;
 121 }
 122
 123 ThumbnailManager&
 124 ThumbnailManager::operator =(const ThumbnailManager& thumbnailManager)
 125 {
 126         if (this != &thumbnailManager)
 127         {
 128                 __pCurrentThumbReq = thumbnailManager.__pCurrentThumbReq;
 129         }
 130         return *this;
 131
 132 }
 133
 134 ThumbMgrResultValues
 135 ThumbnailManager::GetThumbnail(ThumbRequest* pRequest)
 136 {
 137         result r = E_SUCCESS;
 138         ThumbMgrResultValues thumbMgrRes = THUMB_MGR_RES_SUCCESS;
 139
 140         AppResource* pAppResource = null;
 141
 142         Bitmap* pTempBitmap = null;
 143         Bitmap* pBitmapToMerge = null;
 144         Bitmap* pMergedThumbnail = null;
 145
 146         ImageMetadata* pImageMeta = null;
 147         ImageBuffer* pImage = null;
 148         ImageBuffer*            pRotatedImgBuff = null;
 149
 150         VideoFrameExtractor extractor;
 151         RecordingRotation videoRecordingRotation;
 152
 153         Bitmap* pTmpBmp = null;
 154
 155         bool GenerateThumbnail = false;
 156         bool IsVideoFile = false;
 157
 158
 159         TryCatch((pRequest != null) && (pRequest->iRquestId > -1) && (pRequest->FilePath.IsEmpty() == false), thumbMgrRes = THUMB_MGR_RES_FAILED, "ThumbRequest is NULL, Thumbnail genrataion failed!");
 160
 161         pAppResource = Application::GetInstance()->GetAppResource();
 162         pBitmapToMerge = pAppResource->GetBitmapN(IDB_VIDEO_PLAY_SMALL, BITMAP_PIXEL_FORMAT_ARGB8888);
 163         if (pBitmapToMerge != null)
 164         {
 165                 pBitmapToMerge->Scale(Dimension(ID_THUMBNAIL_WIDH, ID_THUMBNAIL_HEIGHT));
 166         }
 167
 168         //Generate thumbnail
 169         pTempBitmap = MakeBitmapN(pRequest->FilePath, GenerateThumbnail, IsVideoFile);
 170         if (GenerateThumbnail)
 171         {
 172                 if (IsVideoFile)
 173                 {
 174                         AppLogDebug("VideoThumbnail:START");
 175                         r = extractor.Construct(pRequest->FilePath, MEDIA_PIXEL_FORMAT_BGRA8888);
 176
 177                         // Extracts video frames from the video file
 178                         if (!IsFailed(r))
 179                         {
 180                                 AppLogDebug("VideoThumbnail:GetFrameNStart");
 181                                 pImage = extractor.GetFrameN(0);
 182                                 AppLogDebug("VideoThumbnail:GetFrameNStop");
 183                                 if  ( pImage )
 184                                 {
 185                                         videoRecordingRotation = extractor.GetRecordingRotation();
 186
 187                                         if ( videoRecordingRotation != RECORDING_ROTATION_NONE )
 188                                         {
 189                                                 if ( videoRecordingRotation == RECORDING_ROTATION_90 )
 190                                                         pRotatedImgBuff = pImage->RotateN(IMAGE_ROTATION_90);
 191                                                 else if ( videoRecordingRotation == RECORDING_ROTATION_180 )
 192                                                         pRotatedImgBuff = pImage->RotateN(IMAGE_ROTATION_180);
 193                                                 else if ( videoRecordingRotation == RECORDING_ROTATION_270 )
 194                                                         pRotatedImgBuff = pImage->RotateN(IMAGE_ROTATION_270);
 195                                         }
 196
 197                                         pRequest->pBitmap = pRotatedImgBuff->GetBitmapN(BITMAP_PIXEL_FORMAT_ARGB8888, BUFFER_SCALING_NONE);
 198                                         TryCatch(pRequest->pBitmap != null, r = E_OUT_OF_MEMORY, "FRAMEEXTRACTOR : failed to allocate memory to pTempBitmap");
 199
 200                                         delete pImage;
 201                                         pImage = null;
 202                                 }
 203                         }
 204                         if( pRequest->pBitmap==null)
 205                         {
 206                                 pRequest->pBitmap = new (std::nothrow) Bitmap();
 207                                 if (__pDummyImage)
 208                                         r = pRequest->pBitmap->Construct(*__pDummyImage, Rectangle(0, 0, __pDummyImage->GetWidth(), __pDummyImage->GetHeight()));
 209                         }
 210
 211                         if (pBitmapToMerge)
 212                         {
 213                                 pMergedThumbnail = MfUtility::MergeBitmapN(pRequest->pBitmap, pBitmapToMerge, ID_THUMBNAIL_WIDH, ID_THUMBNAIL_HEIGHT);
 214                                 if (pMergedThumbnail != null)
 215                                 {
 216                                         pRequest->pBitmap = pMergedThumbnail;
 217                                         AppLogDebug("Bitmap Merging Completed Successfully: [%s]", GetErrorMessage(GetLastResult()));
 218                                 }
 219                                 pBitmapToMerge = null;
 220                         }
 221                         if (pTempBitmap)
 222                         {
 223                                 delete pTempBitmap;
 224                                 pTempBitmap = null;
 225                         }
 226
 227                         AppLogDebug("VideoThumbnail:STOP");
 228                         thumbMgrRes = THUMB_MGR_RES_SUCCESS;
 229                 }
 230                 else
 231                 {
 232                         pImageMeta = ContentManagerUtil::GetImageMetaN(pRequest->FilePath);
 233                         if (pImageMeta)
 234                         {
 235                                 pTmpBmp = pImageMeta->GetThumbnailN();
 236                                 if (pTmpBmp)
 237                                 {
 238                                         pRequest->pBitmap = pTmpBmp;
 239                                         delete pTempBitmap;
 240                                 }
 241                                 else
 242                                         pRequest->pBitmap = pTempBitmap;
 243
 244                                 delete pImageMeta;
 245                         }
 246                         else
 247                                 pRequest->pBitmap = pTempBitmap;
 248
 249                         thumbMgrRes = THUMB_MGR_RES_SUCCESS;
 250                 }
 251         }
 252         else
 253         {
 254                 TryCatch(pTempBitmap != null, thumbMgrRes = THUMB_MGR_RES_FAILED, "Thumbnail generation failed");
 255                 thumbMgrRes = THUMB_MGR_RES_SUCCESS;
 256                 pRequest->pBitmap = pTempBitmap;
 257         }
 258
 259         if (pBitmapToMerge != null)
 260         {
 261                 delete pBitmapToMerge;
 262                 pBitmapToMerge = null;
 263         }
 264
 265         AppLogDebug("Exit [%s]:", GetErrorMessage(r));
 266         return thumbMgrRes;
 267
 268 CATCH:
 269
 270         AppLogDebug("Exit Error Message[%s]:", GetErrorMessage(r));
 271
 272         if (pRequest != null)
 273         {
 274                 pRequest->pBitmap = null;
 275         }
 276
 277         if (pTempBitmap != null)
 278                 delete pTempBitmap;
 279
 280         if (pMergedThumbnail)
 281                 delete pMergedThumbnail;
 282
 283         return thumbMgrRes;
 284 }
 285
 286
 287 Bitmap*
 288 ThumbnailManager::GetThumbnailN(Tizen::Base::String& FilePath, Tizen::Graphics::Dimension& Dim)
 289 {
 290         bool GenerateThumbnail = false;
 291         bool IsVideoFile = false;
 292         result r = E_SUCCESS;
 293
 294         Bitmap* pTempBitmap = null;
 295         Bitmap* pThumbBitmap = null;
 296         Bitmap* pTmpBmp = null;
 297
 298         ImageMetadata* pImageMeta = null;
 299
 300         if (FilePath.IsEmpty() || FilePath.GetLength() == 0)
 301         {
 302                 return null;
 303         }
 304
 305         pTempBitmap = MakeBitmapN(FilePath, GenerateThumbnail, IsVideoFile);
 306         TryCatch(pTempBitmap != null, r = E_FAILURE, "Thumbnail Generation failed");
 307
 308         if (GenerateThumbnail)
 309         {
 310                 if (IsVideoFile)
 311                 {
 312                         VideoFrameExtractor extractor;
 313                         result r = extractor.Construct(FilePath, MEDIA_PIXEL_FORMAT_BGRA8888);
 314
 315                         // Extracts video frames from the video file
 316                         ImageBuffer* pImage = extractor.GetFrameN(0);
 317                         if  ( pImage )
 318                         {
 319                                 pThumbBitmap = pImage->GetBitmapN(BITMAP_PIXEL_FORMAT_ARGB8888, BUFFER_SCALING_AUTO);
 320                                 TryCatch(pThumbBitmap != null, r = E_OUT_OF_MEMORY, "FRAMEEXTRACTOR : failed to allocate memory to pTempBitmap");
 321                         }
 322
 323                 }
 324                 else
 325                 {
 326                         pImageMeta = ContentManagerUtil::GetImageMetaN(FilePath);
 327                         if (pImageMeta)
 328                         {
 329
 330                                 pTmpBmp = pImageMeta->GetThumbnailN();
 331                                 if (pTmpBmp)
 332                                 {
 333                                         pThumbBitmap = new (std::nothrow) Bitmap();
 334                                         TryCatch(pThumbBitmap != null, r = E_OUT_OF_MEMORY, "failed to allocate memory to pTempBitmap");
 335                                         pThumbBitmap->Construct(*pTmpBmp, Rectangle(0, 0, Dim.width, Dim.height));
 336
 337                                 }
 338                                 else
 339                                         pThumbBitmap = pTempBitmap;
 340
 341                                 delete pTmpBmp;
 342                                 pTmpBmp = null;
 343
 344                                 delete pImageMeta;
 345                                 pImageMeta = null;
 346                         }
 347                 }
 348         }
 349         else
 350         {
 351                 TryCatch(pTempBitmap != null, r = E_FAILURE, "Thumbnail Generation failed");
 352                 pThumbBitmap = pTempBitmap;
 353         }
 354         return pThumbBitmap;
 355
 356 CATCH:
 357
 358         if (pImageMeta)
 359                 delete pImageMeta;
 360         if (pTempBitmap != null)
 361         {
 362                 delete pTempBitmap;
 363                 pTempBitmap = null;
 364         }
 365         return null;
 366
 367 }
 368
 369 Bitmap*
 370 ThumbnailManager::MakeBitmapN(const Tizen::Base::String& FilePath, bool& makeThumbnail, bool& bVideo)
 371 {
 372         result r = E_SUCCESS;
 373
 374         ImageBuffer* imageBuffer = null;
 375         Bitmap* pTempBitmap = null;
 376         AppResource* pAppResource = null;
 377         ContentType contentType = CONTENT_TYPE_UNKNOWN;
 378         BitmapPixelFormat pixelFormat = BITMAP_PIXEL_FORMAT_MIN;
 379         ThumbMgrResultValues thumbMgrRes = THUMB_MGR_RES_SUCCESS;
 380         String TempFilePath;
 381
 382         pAppResource = Application::GetInstance()->GetAppResource();
 383         TryCatch(pAppResource != null, r = E_OUT_OF_MEMORY, "Could not locate app resource manager!");
 384
 385
 386         contentType = ContentManagerUtil::CheckContentType(FilePath);
 387
 388         switch(contentType)
 389         {
 390         case CONTENT_TYPE_IMAGE:
 391         {
 392                 if (FilePath.EndsWith(L"png") || FilePath.EndsWith(L"PNG"))
 393                 {
 394                         pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 395                         makeThumbnail = true;
 396                         bVideo = false;
 397                         return null;
 398                 }
 399                 else
 400                 {
 401                         pixelFormat = BITMAP_PIXEL_FORMAT_RGB565;
 402                         makeThumbnail = true;
 403                         bVideo = false;
 404                         return null;
 405                 }
 406
 407         }
 408         break;
 409         case CONTENT_TYPE_AUDIO:
 410         {
 411                 pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 412                 makeThumbnail = false;
 413                 pTempBitmap = pAppResource->GetBitmapN(IDB_MUSIC, pixelFormat);
 414                 return pTempBitmap;
 415         }
 416         break;
 417         case CONTENT_TYPE_VIDEO:
 418         {
 419                 makeThumbnail = true;
 420                 bVideo = true;
 421                 return null;
 422         }
 423         break;
 424         case CONTENT_TYPE_OTHER:
 425         {
 426                 makeThumbnail = false;
 427                 bVideo = false;
 428                 if (FilePath.EndsWith(L"pdf") || FilePath.EndsWith(L"PDF"))
 429                 {
 430                         pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 431                         pTempBitmap = pAppResource->GetBitmapN(IDB_PDF, pixelFormat);
 432                         return pTempBitmap;
 433                 }
 434                 else if (FilePath.EndsWith(L"doc") || FilePath.EndsWith(L"DOC"))
 435                 {
 436                         pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 437                         pTempBitmap = pAppResource->GetBitmapN(IDB_MS_WORD, pixelFormat);
 438                         return pTempBitmap;
 439                 }
 440                 else if (FilePath.EndsWith(L"docx") || FilePath.EndsWith(L"DOCX"))
 441                 {
 442                         pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 443                         pTempBitmap = pAppResource->GetBitmapN(IDB_MS_WORD, pixelFormat);
 444                         return pTempBitmap;
 445                 }
 446                 else if (FilePath.EndsWith(L"xls") || FilePath.EndsWith(L"XLS"))
 447                 {
 448                         pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 449                         pTempBitmap = pAppResource->GetBitmapN(IDB_MS_EXCEL, pixelFormat);
 450                         return pTempBitmap;
 451                 }
 452                 else if (FilePath.EndsWith(L"xlsx") || FilePath.EndsWith(L"XLSX"))
 453                 {
 454                         pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 455                         pTempBitmap = pAppResource->GetBitmapN(IDB_MS_EXCEL, pixelFormat);
 456                         return pTempBitmap;
 457                 }
 458                 else if (FilePath.EndsWith(L"ppt") || FilePath.EndsWith(L"PPT"))
 459                 {
 460                         pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 461                         pTempBitmap = pAppResource->GetBitmapN(IDB_MS_PPT, pixelFormat);
 462                         return pTempBitmap;
 463                 }
 464                 else if (FilePath.EndsWith(L"pptx") || FilePath.EndsWith(L"PPTX"))
 465                 {
 466                         pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 467                         pTempBitmap = pAppResource->GetBitmapN(IDB_MS_PPT, pixelFormat);
 468                         return pTempBitmap;
 469                 }
 470                 else if (FilePath.EndsWith(L"html") || FilePath.EndsWith(L"HTML") || FilePath.EndsWith(L"htm") ||
 471                                 FilePath.EndsWith(L"HTM") || FilePath.EndsWith(L"JS") || FilePath.EndsWith(L"js"))
 472                 {
 473                         pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 474                         pTempBitmap = pAppResource->GetBitmapN(IDB_HTML, pixelFormat);
 475                         return pTempBitmap;
 476                 }
 477                 else if (FilePath.EndsWith(L"rss") || FilePath.EndsWith(L"RSS"))
 478                 {
 479                         pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 480                         pTempBitmap = pAppResource->GetBitmapN(IDB_RSS, pixelFormat);
 481                         return pTempBitmap;
 482                 }
 483                 else if (FilePath.EndsWith(L"txt") || FilePath.EndsWith(L"TXT"))
 484                 {
 485                         pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 486                         pTempBitmap = pAppResource->GetBitmapN(IDB_TEXT, pixelFormat);
 487                         return pTempBitmap;
 488                 }
 489                 else if (FilePath.EndsWith(L"SVF") || FilePath.EndsWith(L"svg"))
 490                 {
 491                         pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 492                         pTempBitmap = pAppResource->GetBitmapN(IDB_SVG, pixelFormat);
 493                         return pTempBitmap;
 494                 }
 495                 else if (FilePath.EndsWith(L"swf") || FilePath.EndsWith(L"SWF"))
 496                 {
 497                         pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 498                         pTempBitmap = pAppResource->GetBitmapN(IDB_SWF, pixelFormat);
 499                         return pTempBitmap;
 500                 }
 501                 else if (FilePath.EndsWith(L"tpk") || FilePath.EndsWith(L"TPK"))
 502                 {
 503                         pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 504                         pTempBitmap = pAppResource->GetBitmapN(IDB_TPK, pixelFormat);
 505                         return pTempBitmap;
 506                 }
 507                 else if (FilePath.EndsWith(L"VCF") || FilePath.EndsWith(L"vcf"))
 508                 {
 509                         pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 510                         pTempBitmap = pAppResource->GetBitmapN(IDB_VCARD, pixelFormat);
 511                         return pTempBitmap;
 512                 }
 513                 else if (FilePath.EndsWith(L"vcs") || FilePath.EndsWith(L"VCS"))
 514                 {
 515                         pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 516                         pTempBitmap = pAppResource->GetBitmapN(IDB_VCALENDAR, pixelFormat);
 517                         return pTempBitmap;
 518                 }
 519                 else
 520                 {
 521                         pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 522                         pTempBitmap = pAppResource->GetBitmapN(IDB_UNKNOWN, pixelFormat);
 523                         return pTempBitmap;
 524                 }
 525         }
 526         break;
 527         case CONTENT_TYPE_UNKNOWN:
 528         {
 529                 pixelFormat = BITMAP_PIXEL_FORMAT_ARGB8888;
 530                 makeThumbnail = false;
 531                 pTempBitmap = pAppResource->GetBitmapN(IDB_UNKNOWN, pixelFormat);
 532                 return pTempBitmap;
 533         }
 534         break;
 535         case CONTENT_TYPE_ALL:
 536         {
 537                 //Empty Implementation
 538         }
 539         break;
 540         }
 541         //Generate thumbnail
 542         imageBuffer = new (std::nothrow) ImageBuffer();
 543         TryCatch(imageBuffer != null, thumbMgrRes = THUMB_MGR_RES_FAILED, "Failed to allocate memory to imageBuffer");
 544
 545         r = imageBuffer->Construct(FilePath, null, true);
 546         TryCatch(r == E_SUCCESS, thumbMgrRes = THUMB_MGR_RES_FAILED, "Failed to construct to image decoder");
 547
 548         pTempBitmap = imageBuffer->GetBitmapN(pixelFormat, BUFFER_SCALING_AUTO);
 549         TryCatch(pTempBitmap != null, thumbMgrRes = THUMB_MGR_RES_FAILED, "Failed to decode bitmap");
 550
 551         if (imageBuffer != null)
 552         {
 553                 delete imageBuffer;
 554                 imageBuffer = null;
 555         }
 556         AppLogDebug("EXIT: r = %s", GetErrorMessage(r));
 557         return pTempBitmap;
 558
 559 CATCH:
 560         makeThumbnail = false;
 561         bVideo = false;
 562
 563         if (imageBuffer != null)
 564         {
 565                 delete imageBuffer;
 566                 imageBuffer = null;
 567         }
 568         if (pTempBitmap != null)
 569         {
 570                 delete pTempBitmap;
 571                 pTempBitmap = null;
 572         }
 573         AppLogDebug("EXIT: Error Message [%s]", GetErrorMessage(r));
 574         return null;
 575 }
 576 result
 577 ThumbnailManager::SetThumbnailSize(void /*Tizen::Graphics::Dimension& dim*/)
 578 {
 579         //__Dimention = dim;
 580         return E_SUCCESS;
 581 }
 582
 583 Tizen::Graphics::Dimension&
 584 ThumbnailManager::GetDefaultThumbSize(void)
 585 {
 586         return __Dimension;
 587 }
 588
 589 result
 590 ThumbnailManager::ClearCurrentThumbRequest(void)
 591 {
 592         result r = E_SUCCESS;
 593         if (__pCurrentThumbReq)
 594         {
 595                 __pCurrentThumbReq = null;
 596         }
 597         return r;
 598 }
 599 void
 600 ThumbnailManager::OnUserEventReceivedN(RequestId requestId, Tizen::Base::Collection::IList* pArgs)
 601 {
 602         ThumbRequest* pTempThumbReq = null;
 603         ArrayList* pTempArrayList = null;
 604         result r = E_SUCCESS;
 605
 606         switch (requestId)
 607         {
 608         case ThumbnailManager::THUMB_MGR_GET_THUMBNAIL:
 609         {
 610                 TryCatch(pArgs != null, r = E_FAILURE, "Argument list is null");
 611                 pTempThumbReq = (ThumbRequest*) pArgs->GetAt(0);
 612                 TryCatch(pTempThumbReq != null, r = E_FAILURE, "Request is null!");
 613
 614                 __pCurrentThumbReq = pTempThumbReq;
 615                 TryCatch(__pCurrentThumbReq != null, , "E_FAILURE Current Request is null");
 616
 617                 pTempArrayList = new (std::nothrow) ArrayList();
 618                 pTempArrayList->Construct();
 619
 620                 if (GetThumbnail(__pCurrentThumbReq) == THUMB_MGR_RES_SUCCESS)
 621                 {
 622                         pTempArrayList->Add(pTempThumbReq);
 623                         Application::GetInstance()->SendUserEvent(THUMBNAIL_LAODED, pTempArrayList);
 624                 }
 625                 else
 626                 {
 627                         if (__pCurrentThumbReq != null)
 628                         {
 629                                 if (__pCurrentThumbReq->pBitmap != null)
 630                                 {
 631                                         delete __pCurrentThumbReq->pBitmap;
 632                                         __pCurrentThumbReq->pBitmap = null;
 633                                 }
 634                         }
 635                         Application::GetInstance()->SendUserEvent(THUMBNAIL_FAILED, null);
 636                 }
 637         }
 638         break;
 639
 640         case ThumbnailManager::THUMB_MGR_STOP:
 641         {
 642                 ClearCurrentThumbRequest();
 643         }
 644         break;
 645
 646         default:
 647         {
 648                 AppLogDebug("Unsupported case reached!");
 649                 Application::GetInstance()->SendUserEvent(THUMBNAIL_CANCELED, null);
 650         }
 651         break;
 652         }
 653         return;
 654 CATCH:
 655         ClearCurrentThumbRequest();
 656         if (pArgs)
 657         {
 658                 pArgs->RemoveAll(true);
 659                 delete pArgs;
 660         }
 661         Application::GetInstance()->SendUserEvent(THUMBNAIL_FAILED, null);
 662         return;
 663 }
 664
 665 result
 666 ThumbnailManager::StopThumbnailManagerThread(void)
 667 {
 668         result r = E_SUCCESS;
 669         r = Stop();
 670         r = Join();
 671         AppLogDebug("Exit : %s", GetErrorMessage(r));
 672         return r;
 673 }