engine/collectionframework/datasource/plugins/glxdatasourcemde2.5/src/glxdatasourcetaskmdsthumbnail.cpp
changeset 71 27f2d7aec52a
parent 54 0f0f3f26f787
equal deleted inserted replaced
69:45459746d5e8 71:27f2d7aec52a
    34 #include <glxmediacollectioninternaldefs.h>
    34 #include <glxmediacollectioninternaldefs.h>
    35 #include <glxmediageneraldefs.h>
    35 #include <glxmediageneraldefs.h>
    36 #include <glxrequest.h>
    36 #include <glxrequest.h>
    37 #include <glxthumbnailattributeinfo.h>
    37 #include <glxthumbnailattributeinfo.h>
    38 #include <glxthumbnailrequest.h>
    38 #include <glxthumbnailrequest.h>
    39 #include <glxtndatabase.h>
       
    40 #include <glxtnfileinfo.h>
    39 #include <glxtnfileinfo.h>
    41 #include <glxtnthumbnailcreator.h>
       
    42 #include <glxtracer.h>
    40 #include <glxtracer.h>
    43 #include <lbsposition.h>
    41 #include <lbsposition.h>
    44 #include <mdeconstants.h>
    42 #include <mdeconstants.h>
    45 #include <mdelogiccondition.h>
    43 #include <mdelogiccondition.h>
    46 #include <mdeobject.h>
    44 #include <mdeobject.h>
   127 // ----------------------------------------------------------------------------
   125 // ----------------------------------------------------------------------------
   128 //  	
   126 //  	
   129 CGlxDataSourceTaskMdeThumbnail::~CGlxDataSourceTaskMdeThumbnail()
   127 CGlxDataSourceTaskMdeThumbnail::~CGlxDataSourceTaskMdeThumbnail()
   130     {
   128     {
   131     TRACER("CGlxDataSourceTaskMdeThumbnail::~CGlxDataSourceTaskMdeThumbnail()")    
   129     TRACER("CGlxDataSourceTaskMdeThumbnail::~CGlxDataSourceTaskMdeThumbnail()")    
   132 #ifdef USE_S60_TNM
       
   133     DataSource()->CancelFetchThumbnail();
   130     DataSource()->CancelFetchThumbnail();
   134     delete iTnFileInfo;
   131     delete iTnFileInfo;
   135     iTnFileInfo = NULL;
   132     iTnFileInfo = NULL;
   136 #else
       
   137     if( iTnRequestStatus )
       
   138         {
       
   139         CancelFetchUri(TGlxMediaId());
       
   140         }
       
   141     if( iTnRequestInProgress )
       
   142         {
       
   143         CGlxThumbnailRequest* request = static_cast<CGlxThumbnailRequest*>(iRequest);
       
   144     
       
   145         TGlxThumbnailRequest tnReq;
       
   146         request->ThumbnailRequest(tnReq);
       
   147         DataSource()->ThumbnailCreator().CancelRequest(tnReq.iId);
       
   148         }
       
   149 #endif        
       
   150     }
   133     }
   151 
   134 
   152 // ----------------------------------------------------------------------------
   135 // ----------------------------------------------------------------------------
   153 //  CGlxDataSourceTaskMdeThumbnail::ExecuteRequest
   136 //  CGlxDataSourceTaskMdeThumbnail::ExecuteRequest
   154 // ----------------------------------------------------------------------------
   137 // ----------------------------------------------------------------------------
   165     request->ThumbnailRequest(tnReq);
   148     request->ThumbnailRequest(tnReq);
   166     GLX_DEBUG4("*** CGlxDataSourceTaskMdeThumbnail::ExecuteRequestL() Id=%d, TN Size w(%d) h(%d) ***", tnReq.iId.Value(),
   149     GLX_DEBUG4("*** CGlxDataSourceTaskMdeThumbnail::ExecuteRequestL() Id=%d, TN Size w(%d) h(%d) ***", tnReq.iId.Value(),
   167     						tnReq.iSizeClass.iWidth, tnReq.iSizeClass.iHeight);
   150     						tnReq.iSizeClass.iWidth, tnReq.iSizeClass.iHeight);
   168     GLX_DEBUG2("CGlxDataSourceTaskMdeThumbnail::ExecuteRequestL() iPriorityMode=%d", tnReq.iPriorityMode);
   151     GLX_DEBUG2("CGlxDataSourceTaskMdeThumbnail::ExecuteRequestL() iPriorityMode=%d", tnReq.iPriorityMode);
   169 	
   152 	
   170 #ifdef USE_S60_TNM
       
   171 	if(request->ThumbnailInfo())
   153 	if(request->ThumbnailInfo())
   172 		{
   154 		{
   173 		if (tnReq.iSizeClass.iWidth > 0 && tnReq.iSizeClass.iHeight > 0 )
   155 		if (tnReq.iSizeClass.iWidth > 0 && tnReq.iSizeClass.iHeight > 0 )
   174 			{
   156 			{
   175 			DataSource()->FetchThumbnailL(iRequest, *this);
   157 			DataSource()->FetchThumbnailL(iRequest, *this);
   181 		}
   163 		}
   182 	else
   164 	else
   183 		{
   165 		{
   184 	   	FetchFileInfoL();
   166 	   	FetchFileInfoL();
   185 		}
   167 		}
   186 #else
       
   187     iTnRequestInProgress = ETrue;
       
   188     DataSource()->ThumbnailCreator().FetchThumbnailL(tnReq, *this);
       
   189 #endif
       
   190     }
   168     }
   191 
   169 
   192 // ----------------------------------------------------------------------------
   170 // ----------------------------------------------------------------------------
   193 //  CGlxDataSourceTaskMdeThumbnail::HandleRequestComplete
   171 //  CGlxDataSourceTaskMdeThumbnail::HandleRequestComplete
   194 // ----------------------------------------------------------------------------
   172 // ----------------------------------------------------------------------------
   276     iResponse->SetNoNewLCObjectL(
   254     iResponse->SetNoNewLCObjectL(
   277                 TMPXAttribute(KGlxMediaIdThumbnail, attributeId), tnAttribute);
   255                 TMPXAttribute(KGlxMediaIdThumbnail, attributeId), tnAttribute);
   278     CleanupStack::PopAndDestroy(tnAttribute);
   256     CleanupStack::PopAndDestroy(tnAttribute);
   279     }
   257     }
   280 
   258 
   281 #ifdef USE_S60_TNM
       
   282 void CGlxDataSourceTaskMdeThumbnail::ThumbnailFetchComplete(TInt aError, 
   259 void CGlxDataSourceTaskMdeThumbnail::ThumbnailFetchComplete(TInt aError, 
   283                                                             TBool aQuality)
   260                                                             TBool aQuality)
   284 	{
   261 	{
   285     TRACER("CGlxDataSourceTaskMdeThumbnail::ThumbnailFetchComplete(TNM)")
   262     TRACER("CGlxDataSourceTaskMdeThumbnail::ThumbnailFetchComplete(TNM)")
   286     CGlxThumbnailRequest* request = static_cast<CGlxThumbnailRequest*>(iRequest);
   263     CGlxThumbnailRequest* request = static_cast<CGlxThumbnailRequest*>(iRequest);
   296             }
   273             }
   297         TRAP(err, HandleThumbnailFetchCompleteL(tnRequest.iId, tnQuality));
   274         TRAP(err, HandleThumbnailFetchCompleteL(tnRequest.iId, tnQuality));
   298         }
   275         }
   299     HandleRequestComplete(err);
   276     HandleRequestComplete(err);
   300 	}
   277 	}
   301 #else
       
   302 // -----------------------------------------------------------------------------
       
   303 // ThumbnailFetchComplete
       
   304 // Notifies that a thumbnail for a given item is available, or that
       
   305 // thumbnail generation failed.
       
   306 // -----------------------------------------------------------------------------
       
   307 //
       
   308 void CGlxDataSourceTaskMdeThumbnail::ThumbnailFetchComplete(
       
   309     const TGlxMediaId& aItemId, TGlxThumbnailQuality aQuality, TInt aErrorCode)
       
   310     {
       
   311     TRACER("CGlxDataSourceTaskMdeThumbnail::ThumbnailFetchComplete()")
       
   312     GLX_DEBUG2("CGlxDataSourceTaskMdeThumbnail::ThumbnailFetchComplete() aErrorCode=%d", aErrorCode);
       
   313     iTnRequestInProgress = EFalse;
       
   314     TInt err = aErrorCode;
       
   315     if(!err)
       
   316         {
       
   317         TRAP(err, HandleThumbnailFetchCompleteL(aItemId, aQuality));
       
   318         }
       
   319     HandleRequestComplete(err);
       
   320     }
       
   321 
       
   322 
       
   323 // ----------------------------------------------------------------------------
       
   324 //  CGlxDataSourceTaskMdeThumbnail::ThumbnailDeletionComplete
       
   325 // ----------------------------------------------------------------------------
       
   326 //   
       
   327 void CGlxDataSourceTaskMdeThumbnail::ThumbnailDeletionComplete(
       
   328                                 const TGlxMediaId& /*aItemId*/, TInt /*aErrorCode*/)
       
   329     {
       
   330     TRACER("CGlxDataSourceTaskMdeThumbnail::ThumbnailDeletionComplete()")
       
   331     }
       
   332 
       
   333 
       
   334 // ----------------------------------------------------------------------------
       
   335 //  CGlxDataSourceTaskMdeThumbnail::FilterAvailableComplete
       
   336 // ----------------------------------------------------------------------------
       
   337 //   
       
   338 void CGlxDataSourceTaskMdeThumbnail::FilterAvailableComplete(
       
   339                                 const RArray<TGlxMediaId>& /*aIdArray*/, TInt /*aErrorCode*/)
       
   340     {
       
   341     TRACER("CGlxDataSourceTaskMdeThumbnail::FilterAvailableComplete()")
       
   342     // No implementation
       
   343     }
       
   344 
       
   345 // ----------------------------------------------------------------------------
       
   346 //  CGlxDataSourceTaskMdeThumbnail::FetchFileInfoL
       
   347 // ----------------------------------------------------------------------------
       
   348 //  
       
   349 void CGlxDataSourceTaskMdeThumbnail::FetchFileInfoL(CGlxtnFileInfo* aInfo,
       
   350                         const TGlxMediaId& aItemId, TRequestStatus* aStatus)
       
   351     {
       
   352     TRACER("CGlxDataSourceTaskMdeThumbnail::FetchFileInfoL()")
       
   353     __ASSERT_DEBUG(dynamic_cast<CGlxThumbnailRequest*>(iRequest), Panic(EGlxPanicLogicError));
       
   354     CGlxThumbnailRequest* request = static_cast<CGlxThumbnailRequest*>(iRequest);
       
   355     if(request->ThumbnailInfo())
       
   356         {
       
   357         aInfo->CopyInfoL(*request->ThumbnailInfo());
       
   358         *aStatus = KRequestPending;
       
   359         User::RequestComplete(aStatus, KErrNone);
       
   360         return;
       
   361         }
       
   362 
       
   363     CMdEObject* item = DataSource()->Session().GetObjectL((TItemId)aItemId.Value());
       
   364     if(!item)
       
   365         {
       
   366         User::Leave(KErrNotFound);
       
   367         }
       
   368         
       
   369     CleanupStack::PushL(item);
       
   370     iTnRequestStatus = aStatus;
       
   371     iTnFileInfo = aInfo;
       
   372     *iTnRequestStatus = KRequestPending;
       
   373     
       
   374     CGlxDataSource::TContainerType containerType = DataSource()->ContainerType(item);
       
   375     if( CGlxDataSource::EContainerTypeNotAContainer != containerType )
       
   376         {
       
   377         iTnFileInfo->iTemporary = ETrue;
       
   378         
       
   379         TGlxMediaId container = aItemId;
       
   380         CMdEObjectDef* objectDef = &item->Def();
       
   381         
       
   382         /// @todo: use default filter so we can ensure we always get correct first item if filters change
       
   383         iFilterProperties.iSortOrder = EGlxFilterSortOrderCaptureDate;
       
   384         iFilterProperties.iSortDirection = EGlxFilterSortDirectionOverrideToDescendingIfDate;
       
   385         iFilterProperties.iLastCaptureDate = ETrue;
       
   386 
       
   387         if( CGlxDataSource::EContainerTypeMonth == containerType )
       
   388             {
       
   389             iFilterProperties.iOrigin = EGlxFilterOriginAll;
       
   390             AddMonthFilterL(item, iFilterProperties);
       
   391             container = TGlxMediaId(KGlxCollectionRootId);
       
   392             objectDef = &DataSource()->ObjectDef();
       
   393             }
       
   394             
       
   395         DoQueryL(*objectDef, ETrue, EContainerFirstItemQuery,  
       
   396                 EQueryResultModeItem, container);        
       
   397         }
       
   398     else
       
   399         {
       
   400         CompleteFetchFileInfoL(item);
       
   401         }
       
   402 
       
   403     CleanupStack::PopAndDestroy(item);
       
   404     }
       
   405 
       
   406 // ----------------------------------------------------------------------------
       
   407 //  CGlxDataSourceTaskMdeThumbnail::CancelFetchUri
       
   408 // ----------------------------------------------------------------------------
       
   409 //  
       
   410 void CGlxDataSourceTaskMdeThumbnail::CancelFetchUri(const TGlxMediaId& /*aItemId*/)
       
   411     {
       
   412     TRACER("CGlxDataSourceTaskMdeThumbnail::CancelFetchUri()")
       
   413     CompleteThumbnailRequest(KErrCancel);
       
   414     }
       
   415 
       
   416 // ----------------------------------------------------------------------------
       
   417 //  CGlxDataSourceTaskMdeThumbnail::ThumbnailStorage
       
   418 // ----------------------------------------------------------------------------
       
   419 //  
       
   420 MGlxtnThumbnailStorage* CGlxDataSourceTaskMdeThumbnail::ThumbnailStorage()
       
   421     {
       
   422     TRACER("CGlxDataSourceTaskMdeThumbnail::ThumbnailStorage()")
       
   423     return &DataSource()->ThumbnailDatabase();
       
   424     }
       
   425 #endif
       
   426 
   278 
   427 // ----------------------------------------------------------------------------
   279 // ----------------------------------------------------------------------------
   428 //  CGlxDataSourceTaskMdeThumbnail::CompleteFetchFileInfoL
   280 //  CGlxDataSourceTaskMdeThumbnail::CompleteFetchFileInfoL
   429 // ----------------------------------------------------------------------------
   281 // ----------------------------------------------------------------------------
   430 //  	    
   282 //  	    
   527 //
   379 //
   528 void CGlxDataSourceTaskMdeThumbnail::CompleteThumbnailRequest(TInt aError)
   380 void CGlxDataSourceTaskMdeThumbnail::CompleteThumbnailRequest(TInt aError)
   529 	{
   381 	{
   530     TRACER("CGlxDataSourceTaskMdeThumbnail::CompleteThumbnailRequest(TInt aError)")
   382     TRACER("CGlxDataSourceTaskMdeThumbnail::CompleteThumbnailRequest(TInt aError)")
   531     GLX_DEBUG2("CGlxDataSourceTaskMdeThumbnail::CompleteThumbnailRequest  aError=%d", aError);
   383     GLX_DEBUG2("CGlxDataSourceTaskMdeThumbnail::CompleteThumbnailRequest  aError=%d", aError);
   532 #ifdef USE_S60_TNM
       
   533 	if (aError != KErrNone)
   384 	if (aError != KErrNone)
   534 		{
   385 		{
   535 		ThumbnailFetchComplete(aError, EFalse);
   386 		ThumbnailFetchComplete(aError, EFalse);
   536 		}
   387 		}
   537 	else
   388 	else
   551 		else
   402 		else
   552 			{
   403 			{
   553 		    GLX_LOG_INFO("CGlxDataSourceTaskMdeThumbnail::CompleteThumbnailRequest KErrArgument");
   404 		    GLX_LOG_INFO("CGlxDataSourceTaskMdeThumbnail::CompleteThumbnailRequest KErrArgument");
   554 			ThumbnailFetchComplete(KErrArgument, EFalse);
   405 			ThumbnailFetchComplete(KErrArgument, EFalse);
   555 			}
   406 			}
   556 			}
   407 		}
   557 #else
       
   558     if (iTnRequestStatus)
       
   559         {
       
   560     	*iTnRequestStatus = KRequestPending;
       
   561         User::RequestComplete(iTnRequestStatus, aError);
       
   562         }
       
   563 #endif
       
   564 	}
   408 	}
   565 
   409 
   566 #ifdef USE_S60_TNM
       
   567 // ----------------------------------------------------------------------------
   410 // ----------------------------------------------------------------------------
   568 //  CGlxDataSourceTaskMdeThumbnail::FetchFileInfoL
   411 //  CGlxDataSourceTaskMdeThumbnail::FetchFileInfoL
   569 // ----------------------------------------------------------------------------
   412 // ----------------------------------------------------------------------------
   570 //  
   413 //  
   571 void CGlxDataSourceTaskMdeThumbnail::FetchFileInfoL()
   414 void CGlxDataSourceTaskMdeThumbnail::FetchFileInfoL()
   614         CompleteFetchFileInfoL(item);
   457         CompleteFetchFileInfoL(item);
   615         }
   458         }
   616 
   459 
   617     CleanupStack::PopAndDestroy(item);
   460     CleanupStack::PopAndDestroy(item);
   618     }
   461     }
   619 
       
   620 #endif