FCL/sf/mw/imghandling: comparison imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailserver.cpp

equal deleted inserted replaced

-:c5df59b4ae2d
+:473df7bf149f
 #include "thumbnailpanic.h"
 #include "thumbnailcenrep.h"
 #include "thumbnailmemorycardobserver.h"
 #include "tmgetimei.h"
 #include "thumbnailfetchedchecker.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "thumbnailserverTraces.h"
+#endif
 _LIT8( KThumbnailMimeWildCard, "*" );
 _LIT8( KThumbnailMimeImage, "image" );
 _LIT8( KThumbnailMimeVideo, "video" );
 // ---------------------------------------------------------------------------
 //
 void CThumbnailServer::ConstructL()
 {
 TN_DEBUG1( "CThumbnailServer::ConstructL()" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_CONSTRUCTL, "CThumbnailServer::ConstructL" );
 #ifdef _DEBUG
 iPlaceholderCounter = 0;
 #endif
 // ---------------------------------------------------------------------------
 //
 CThumbnailServer::~CThumbnailServer()
 {
 TN_DEBUG1( "CThumbnailServer::~CThumbnailServer()" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_CTHUMBNAILSERVER, "CThumbnailServer::~CThumbnailServer" );
 iShutdown = ETrue;
 if(iUnmount)
 {
 void CThumbnailServer::HandleSessionOpened( CMdESession& /* aSession */, TInt aError )
 #else
 void CThumbnailServer::HandleSessionOpened( CMdESession& /* aSession */, TInt /*aError*/ )
 #endif
 {
+#ifdef _DEBUG
 TN_DEBUG2( "CThumbnailServer::HandleSessionOpened error == %d", aError );
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_HANDLESESSIONOPENED, "CThumbnailServer::HandleSessionOpened;aError=%d", aError );
+#endif
 }
 // -----------------------------------------------------------------------------
 // CThumbnailServer::HandleSessionError
 // -----------------------------------------------------------------------------
 //
 void CThumbnailServer::HandleSessionError( CMdESession& /*aSession*/, TInt aError )
 {
 TN_DEBUG2( "CThumbnailServer::HandleSessionError == %d", aError );
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_HANDLESESSIONERROR, "CThumbnailServer::HandleSessionError;aError=%d", aError );
 if (aError != KErrNone && !iShutdown && !iSessionError)
 {
 iSessionError = ETrue;
 if (!iReconnect->IsActive())
 {
 iReconnect->Start( KMdEReconnect, KMdEReconnect,
 TCallBack(ReconnectCallBack, this));
 TN_DEBUG1( "CThumbnailServer::HandleSessionError() - reconnect timer started" );
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_HANDLESESSIONERROR, "CThumbnailServer::HandleSessionError - reconnect timer started" );
 }
 }
 }
 // -----------------------------------------------------------------------------
 server = CThumbnailServer::NewL(); // Adds server in scheduler
 // No need to CleanupStack::PushL(server) since no leaves can happen
 RProcess::Rendezvous( KErrNone );
 TN_DEBUG1(
 "CThumbnailServer::ThreadFunctionL() -- CActiveScheduler::Start() in" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_THREADFUNCTIONL, "CThumbnailServer::ThreadFunctionL -- CActiveScheduler::Start() in" );
 CActiveScheduler::Start();
 TN_DEBUG1(
 "CThumbnailServer::ThreadFunctionL() -- CActiveScheduler::Start() out" );
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_THREADFUNCTIONL, "CThumbnailServer::ThreadFunctionL - out" );
 // Comes here if server gets shut down
 delete server;
 server = NULL;
 CleanupStack::PopAndDestroy( scheduler );
 }
 //
 void CThumbnailServer::AddSession()
 {
 TN_DEBUG2( "CThumbnailServer::AddSession() iSessionCount was %d",
 iSessionCount );
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_ADDSESSION, "CThumbnailServer::AddSession;iSessionCount=%d", iSessionCount );
 iSessionCount++;
 }
 // -----------------------------------------------------------------------------
 //
 void CThumbnailServer::DropSession(CThumbnailServerSession* aSession)
 {
 TN_DEBUG2( "CThumbnailServer::DropSession() iSessionCount was %d",
 iSessionCount );
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_DROPSESSION, "CThumbnailServer::DropSession;iSessionCount=%d", iSessionCount );
 iSessionCount--;
 if(iProcessor)
 {
 iProcessor->RemoveTasks(aSession);
 }
 TN_DEBUG2( "CThumbnailServer::DropSession() aSession = 0x%08x", aSession );
+OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_DROPSESSION, "CThumbnailServer::DropSession;aSession=%o", aSession );
 // clean-up bitmap pool
 THashMapIter < TInt, TThumbnailBitmapRef > bpiter( iBitmapPool );
 // const pointer to a non-const object
 while ( ref )
 {
 if ( ref->iSession == aSession )
 {
 TN_DEBUG2( "CThumbnailServer::DropSession() - ref->iSession = 0x%08x", ref->iSession );
+OstTrace1( TRACE_NORMAL, DUP2_CTHUMBNAILSERVER_DROPSESSION, "CThumbnailServer::DropSession;ref->iSession=%o", ref->iSession );
 delete ref->iBitmap;
 bpiter.RemoveCurrent();
 TN_DEBUG2( "CThumbnailServer::DropSession() - deleted bitmap, left=%d", iBitmapPool.Count());
+OstTrace1( TRACE_NORMAL, DUP3_CTHUMBNAILSERVER_DROPSESSION, "CThumbnailServer::DropSession;iBitmapPool.Count()=%d", iBitmapPool.Count() );
 }
 ref = bpiter.NextValue();
 }
 // -----------------------------------------------------------------------------
 //
 void CThumbnailServer::ShutdownNotification()
 {
 TN_DEBUG1( "CThumbnailServer::ShutdownNotification()");
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_SHUTDOWNNOTIFICATION, "CThumbnailServer::ShutdownNotification" );
 if (!iShutdown)
 {
 TN_DEBUG1( "CThumbnailServer::ShutdownNotification() shutdown");
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_SHUTDOWNNOTIFICATION, "CThumbnailServer::ShutdownNotification - shutdown" );
 CActiveScheduler::Stop();
 iShutdown = ETrue;
 }
 }
 CFbsBitmap* aBitmap, TThumbnailServerRequestId aRequestId )
 {
 if( !aBitmap )
 {
 TN_DEBUG1( "CThumbnailServer::AddBitmapToPoolL() - KErrArgument");
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_ADDBITMAPTOPOOLL, "CThumbnailServer::AddBitmapToPoolL - KErrArgument" );
 User::Leave( KErrArgument );
 }
 TN_DEBUG4(
 "CThumbnailServer::AddBitmapToPoolL(aSession=0x%08x, aBitmap=0x%08x), handle=%d", aSession, aBitmap, aBitmap->Handle());
 TThumbnailBitmapRef* ptr = iBitmapPool.Find( aBitmap->Handle());
 TN_DEBUG2( "CThumbnailServer::AddBitmapToPoolL() - req id = %d", aRequestId.iRequestId );
+OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_ADDBITMAPTOPOOLL, "CThumbnailServer::AddBitmapToPoolL;aRequestId.iRequestId=%u", aRequestId.iRequestId );
 if ( ptr )
 {
 ptr->iRefCount++;
 }
 iBitmapPool.InsertL( aBitmap->Handle(), ref );
 }
 #ifdef _DEBUG
 TN_DEBUG2( "CThumbnailServer::BITMAP-POOL-COUNTER----------, Bitmaps = %d", iBitmapPool.Count() );
+OstTrace1( TRACE_NORMAL, DUP2_CTHUMBNAILSERVER_ADDBITMAPTOPOOLL, "CThumbnailServer::AddBitmapToPoolL;iBitmapPool.Count()=%d", iBitmapPool.Count() );
 #endif
 }
 // -----------------------------------------------------------------------------
 const TSize& aOriginalSize, const TBool aCropped, const TThumbnailSize aThumbnailSize,
 const TInt64 aModified, const TBool aThumbFromPath, const TBool aCheckExist )
 {
 TN_DEBUG6(
 "CThumbnailServer::StoreBitmapL(aPath=%S, aBitmap=0x%08x, aOriginalSize=%dx%d, aCropped=%d)", &aPath, aBitmap, aOriginalSize.iWidth, aOriginalSize.iHeight, aCropped );
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_STORETHUMBNAILL, "CThumbnailServer::StoreThumbnailL;aBitmap=%o", aBitmap );
+OstTraceExt1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_STORETHUMBNAILL, "CThumbnailServer::StoreThumbnailL;aPath=%S", aPath );
+OstTraceExt3( TRACE_NORMAL, DUP2_CTHUMBNAILSERVER_STORETHUMBNAILL, "CThumbnailServer::StoreThumbnailL;aOriginalSize.iWidth=%d;aOriginalSize.iHeight=%d;aCropped=%u", aOriginalSize.iWidth, aOriginalSize.iHeight, aCropped );
 #ifdef _DEBUG
 TN_DEBUG2( "CThumbnailServer::StoreThumbnailL() - iScaledBitmap displaymode is %d", aBitmap->DisplayMode());
+OstTrace1( TRACE_NORMAL, DUP3_CTHUMBNAILSERVER_STORETHUMBNAILL, "CThumbnailServer::StoreThumbnailL;aBitmap->DisplayMode()=%u", aBitmap->DisplayMode() );
 #endif
 if (!aCheckExist)
 {
 StoreForPathL( aPath )->StoreThumbnailL( aPath, aBitmap, aOriginalSize,
 aCropped, aThumbnailSize, aModified, aThumbFromPath, EFalse );
 }
 else
 {
 TN_DEBUG1( "CThumbnailServer::StoreThumbnailL() - file doesn't exists anymore, skip store!");
+OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSERVER_STORETHUMBNAILL, "CThumbnailServer::StoreThumbnailL - file doesn't exists anymore, skip store!" );
 }
 if( iFetchedChecker )
 {
 iFetchedChecker->SetFetchResult( aPath, aThumbnailSize, KErrNone );
 //
 void CThumbnailServer::FetchThumbnailL( const TDesC& aPath, CFbsBitmap* &
 aThumbnail, TDesC8* & aData, const TThumbnailSize aThumbnailSize, TSize &aOriginalSize )
 {
 TN_DEBUG3( "CThumbnailServer::FetchThumbnailL(aPath=%S aThumbnailSize=%d)", &aPath, aThumbnailSize );
+OstTraceExt2( TRACE_NORMAL, CTHUMBNAILSERVER_FETCHTHUMBNAILL, "CThumbnailServer::FetchThumbnailL;aPath=%S;aThumbnailSize=%hu", aPath, aThumbnailSize );
 if( iFetchedChecker )
 {
 TInt err( iFetchedChecker->LastFetchResult( aPath, aThumbnailSize ) );
 if ( err == KErrNone ) // To avoid useless sql gets that fails for sure
 {
 // -----------------------------------------------------------------------------
 //
 void CThumbnailServer::DeleteBitmapFromPool( TInt aHandle )
 {
 TN_DEBUG2( "CThumbnailServer::DeleteBitmapFromPool(%d)", aHandle );
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_DELETEBITMAPFROMPOOL, "CThumbnailServer::DeleteBitmapFromPool;aHandle=%d", aHandle );
 TThumbnailBitmapRef* ptr = iBitmapPool.Find( aHandle );
 if ( ptr )
 {
 ptr->iRefCount--;
 if ( !ptr->iRefCount )
 {
 TN_DEBUG3(
 "CThumbnailServer::DeleteBitmapFromPool(%d) -- deleting 0x%08x)", aHandle, ptr );
+OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_DELETEBITMAPFROMPOOL, "CThumbnailServer::DeleteBitmapFromPool -- deleting;ptr=%o", ptr );
 delete ptr->iBitmap;
 ptr->iBitmap = NULL;
 iBitmapPool.Remove( aHandle );
 TN_DEBUG2( "CThumbnailServer::DeleteBitmapFromPool -- items left %d", iBitmapPool.Count() );
+OstTrace1( TRACE_NORMAL, DUP2_CTHUMBNAILSERVER_DELETEBITMAPFROMPOOL, "CThumbnailServer::DeleteBitmapFromPool  -- items left;iBitmapPool.Count()=%d", iBitmapPool.Count() );
 }
 else
 {
 TN_DEBUG3(
 "CThumbnailServer::DeleteBitmapFromPool(%d) -- refcount now %d",
 aHandle, ptr->iRefCount );
+OstTraceExt2( TRACE_NORMAL, DUP3_CTHUMBNAILSERVER_DELETEBITMAPFROMPOOL, "CThumbnailServer::DeleteBitmapFromPool) -- refcount now;aHandle=%d;ptr->iRefCount=%d", aHandle, ptr->iRefCount );
 }
 }
 else
 {
 //__ASSERT_DEBUG(( EFalse ), ThumbnailPanic( EThumbnailBitmapNotReleased ));
 TN_DEBUG2( "CThumbnailServer::DeleteBitmapFromPool(%d) -- not found!",
 aHandle );
+OstTrace1( TRACE_NORMAL, DUP4_CTHUMBNAILSERVER_DELETEBITMAPFROMPOOL, "CThumbnailServer::DeleteBitmapFromPool  -- not found!;aHandle=%d", aHandle );
 }
 }
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 void CThumbnailServer::DeleteThumbnailsL( const TDesC& aPath )
 {
 TN_DEBUG2( "CThumbnailServer::DeleteThumbnailsL(%S)", &aPath);
+OstTraceExt1( TRACE_NORMAL, CTHUMBNAILSERVER_DELETETHUMBNAILSL, "CThumbnailServer::DeleteThumbnailsL;aPath=%S", aPath );
 StoreForPathL( aPath )->DeleteThumbnailsL( aPath );
 if( iFetchedChecker )
 {
 if ( drm && filetype != ContentAccess::EOma1Dcf )
 {
 // cannot handle other than Oma DRM 1.x files
 TN_DEBUG1( "CThumbnailStore::ResolveMimeTypeL()- only OMA DRM 1.0 supported");
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_RESOLVEMIMETYPEL, "CThumbnailServer::ResolveMimeTypeL - only OMA DRM 1.0 supported" );
 User::Leave(KErrNotSupported);
 }
 TDataRecognitionResult res;
 if ( iRecognizer.Handle() == KNullHandle )
 {
 #ifdef _DEBUG
 TBuf < KMaxDataTypeLength > buf; // 16-bit descriptor for debug prints
 buf.Copy( aMimeType );
 TN_DEBUG2( "CThumbnailServer::ResolveProviderL(%S)", &buf );
+OstTraceExt1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_RESOLVEMIMETYPEL, "CThumbnailServer::ResolveMimeTypeL;buf=%S", buf );
 #endif
 CThumbnailProvider* ret = NULL;
 TInt separatorPos = aMimeType.Locate( KThumbnailMimeSeparatorChar );
 !pSubType.CompareF( subType ))
 {
 #ifdef _DEBUG
 TN_DEBUG3(
 "CThumbnailServer::ResolveProviderL(%S) -- using provider 0x%08x", &buf, iPluginInfoArray[i]->ImplementationUid().iUid );
+OstTraceExt1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_RESOLVEPROVIDERL, "CThumbnailServer::ResolveProviderL;buf=%S", buf );
+OstTrace1( TRACE_NORMAL, DUP2_CTHUMBNAILSERVER_RESOLVEPROVIDERL, "CThumbnailServer::ResolveProviderL;iPluginInfoArray[i]->ImplementationUid().iUid=%o", iPluginInfoArray[i]->ImplementationUid().iUid );
 #endif
 ret = GetProviderL( iPluginInfoArray[i]->ImplementationUid());
 }
 }
 }
 {
 #ifdef _DEBUG
 TN_DEBUG2(
 "CThumbnailServer::ResolveProviderL(%S) -- provider not found",
 &buf );
+OstTraceExt1( TRACE_NORMAL, CTHUMBNAILSERVER_RESOLVEPROVIDERL, "CThumbnailServer::ResolveProviderL;buf=%S", buf );
 #endif
 User::Leave( KErrNotSupported );
 }
 return ret;
 }
 TN_DEBUG2(
 "CThumbnailServer::GetProviderL() -- loading plug-in, UID 0x%08x",
 aImplUid );
 res = CThumbnailProvider::NewL( aImplUid );
 TN_DEBUG1( "CThumbnailServer::GetProviderL() -- loading complete" );
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_GETPROVIDERL, "CThumbnailServer::GetProviderL -- loading complete" );
 CleanupStack::PushL( res );
 iProviders.InsertL( aImplUid.iUid, res );
 CleanupStack::Pop( res );
 }
 // -----------------------------------------------------------------------------
 //
 void CThumbnailServer::PreLoadProviders(  )
 {
 TN_DEBUG1( "CThumbnailServer::PreLoadProvidersL()" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_PRELOADPROVIDERS, "CThumbnailServer::PreLoadProviders" );
 TInt err(KErrNone);
 for(TInt i=0; i< iPluginInfoArray.Count(); i++)
 {
 TRAP(err, GetProviderL( iPluginInfoArray[i]->ImplementationUid()));
 const TThumbnailBitmapRef* ref = bpiter.NextValue();
 while ( ref )
 {
 TN_DEBUG2( "CThumbnailServer::DequeTask() - ref->iRequestId = %d", ref->iRequestId );
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_DEQUETASK, "CThumbnailServer::DequeTask;ref->iRequestId=%u", ref->iRequestId );
 if ( ref->iSession == aRequestId.iSession &&
 ref->iRequestId == aRequestId.iRequestId )
 {
 delete ref->iBitmap;
 bpiter.RemoveCurrent();
 TN_DEBUG2( "CThumbnailServer::DequeTask() - deleted bitmap, left=%d",
 iBitmapPool.Count());
+OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_DEQUETASK, "CThumbnailServer::DequeTask;iBitmapPool.Count()=%d", iBitmapPool.Count() );
 }
 ref = bpiter.NextValue();
 }
 // -----------------------------------------------------------------------------
 //
 CThumbnailStore* CThumbnailServer::StoreForDriveL( const TInt aDrive )
 {
 TN_DEBUG2( "CThumbnailServer::StoreForDriveL() drive=%d", aDrive );
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_STOREFORDRIVEL, "CThumbnailServer::StoreForDriveL;aDrive=%d", aDrive );
 if(iUnmountedDrives.Find( aDrive ) >= KErrNone)
 {
 TN_DEBUG1( "CThumbnailServer::StoreForDriveL() unmount in progress, skip!");
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_STOREFORDRIVEL, "CThumbnailServer::StoreForDriveL - unmount in progress, skip!" );
 User::Leave( KErrDisMounted );
 }
 CThumbnailStore** resPtr = iStores.Find( aDrive );
 CThumbnailStore* res = NULL;
 else
 {
 if( iFormatting )
 {
 TN_DEBUG1( "CThumbnailServer::StoreForDriveL() - FORMATTING! - ABORT");
+OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSERVER_STOREFORDRIVEL, "CThumbnailServer::StoreForDriveL - FORMATTING! - ABORT" );
 User::Leave( KErrNotSupported );
 }
 TVolumeInfo volumeInfo;
 TInt err = iFs.Volume( volumeInfo, aDrive );
 if ( err )
 {
 // Locked
 TN_DEBUG2( "CThumbnailServer::StoreForDriveL() - err %d", err);
+OstTrace1( TRACE_NORMAL, DUP3_CTHUMBNAILSERVER_STOREFORDRIVEL, "CThumbnailServer::StoreForDriveL;err=%d", err );
 User::Leave( err);
 }
 else if( volumeInfo.iDrive.iMediaAtt& KMediaAttLocked )
 {
 TN_DEBUG1( "CThumbnailServer::StoreForDriveL() - locked");
+OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSERVER_STOREFORDRIVEL, "CThumbnailServer::StoreForDriveL - locked" );
 User::Leave( KErrAccessDenied );
 }
 		else if ( volumeInfo.iDrive.iDriveAtt& KDriveAttRom ||
 volumeInfo.iDrive.iDriveAtt& KDriveAttRemote ||
 volumeInfo.iDrive.iMediaAtt& KMediaAttWriteProtected )
 {
 // We support ROM disks and remote disks in read only mode.
 TN_DEBUG1( "CThumbnailServer::StoreForDriveL() - rom/remote/write protected");
+OstTrace0( TRACE_NORMAL, DUP5_CTHUMBNAILSERVER_STOREFORDRIVEL, "CThumbnailServer::StoreForDriveL - rom/remote/write protected" );
 res = CThumbnailStore::NewL( iFs, aDrive, iImei, this, ETrue );
 }
 else
 {
 TN_DEBUG1( "CThumbnailServer::StoreForDriveL() - normal");
+OstTrace0( TRACE_NORMAL, DUP6_CTHUMBNAILSERVER_STOREFORDRIVEL, "CThumbnailServer::StoreForDriveL - normal" );
 res = CThumbnailStore::NewL( iFs, aDrive, iImei, this, EFalse );
 }
 CleanupStack::PushL( res );
 iStores.InsertL( aDrive, res );
 CThumbnailStore* CThumbnailServer::StoreForPathL( const TDesC& aPath )
 {
 if(aPath.Length() < 3 || aPath.Length() > KMaxPath)
 {
 TN_DEBUG1( "CThumbnailServer::StoreForPathL() - KErrArgument");
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_STOREFORPATHL, "CThumbnailServer::StoreForPathL - KErrArgument" );
 User::Leave(KErrArgument);
 }
 TInt drive = 0;
 User::LeaveIfError( RFs::CharToDrive( aPath[0], drive ));
 return StoreForDriveL( drive );
 TInt err = iFs.Volume( volumeInfo, i );
 if (!err)
 {
 TN_DEBUG2( "CThumbnailServer::OpenStoresL() StoreForDriveL %d", i);
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_OPENSTORESL, "CThumbnailServer::OpenStoresL;i=%d", i );
 // ignore errors
 TRAP_IGNORE( StoreForDriveL( i ));
 driveCountInt--;
 // -----------------------------------------------------------------------------
 //
 void CThumbnailServer::CloseStoreForDriveL( const TInt aDrive )
 {
 TN_DEBUG2( "CThumbnailServer::CloseStoreForDriveL drive=%d", aDrive);
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_CLOSESTOREFORDRIVEL, "CThumbnailServer::CloseStoreForDriveL;aDrive=%d", aDrive );
 CThumbnailStore** store = iStores.Find( aDrive );
 StartUnmountTimeout( aDrive);
 if (store)
 // if removable drive, add observer
 if (!err && driveInfo.iDriveAtt& KDriveAttRemovable)
 {
 TN_DEBUG2( "CThumbnailServer::AddOnMountObserver drive=%d", drive);
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_ADDUNMOUNTOBSERVERSL, "CThumbnailServer::AddUnmountObserversL;drive=%d", drive );
 CThumbnailDiskUnmountObserver* obs = CThumbnailDiskUnmountObserver::NewL( iFs, drive, this );
 CleanupStack::PushL( obs );
 iUnmountObservers.AppendL( obs );
 CleanupStack::Pop( obs );
 }
 // ---------------------------------------------------------------------------
 //
 void CThumbnailServer::MemoryCardStatusChangedL()
 {
 TN_DEBUG1( "CThumbnailServer::MemoryCardStatusChangedL in()" );
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_MEMORYCARDSTATUSCHANGEDL, "CThumbnailServer::MemoryCardStatusChangedL - in" );
 TDriveList driveList;
 TInt drive;
 TVolumeInfo volumeInfo;
 TDriveInfo driveInfo;
 if (!err && !err_drive
 && driveInfo.iType != EMediaNotPresent
 && driveInfo.iDriveAtt& KDriveAttRemovable )
 {
 TN_DEBUG2( "CThumbnailServer::MemoryCardStatusChangedL mount drive==%d", drive);
+OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_MEMORYCARDSTATUSCHANGEDL, "CThumbnailServer::MemoryCardStatusChangedL;drive=%d", drive );
 CThumbnailStore** resPtr = iStores.Find( drive );
 if ( resPtr )
 {
 TN_DEBUG2( "CThumbnailServer::MemoryCardStatusChangedL() already mounted, skip %d", drive);
+OstTrace1( TRACE_NORMAL, DUP2_CTHUMBNAILSERVER_MEMORYCARDSTATUSCHANGEDL, "CThumbnailServer::MemoryCardStatusChangedL;drive=%d", drive );
 continue;
 }
 // ignore errors
 TRAP_IGNORE( StoreForDriveL( drive ));
-TN_DEBUG2( "CThumbnailServer::MemoryCardStatusChangedL() update KItemsleft == %d", KErrNotReady);
+TUint driveStatus(0);
-RProperty::Set(KTAGDPSNotification, KItemsleft, KErrNotReady );
+DriveInfo::GetDriveStatus(iFs, drive, driveStatus);
+TN_DEBUG2( "CThumbnailServer::MemoryCardStatusChangedL() driveStatus = %d", driveStatus);
+if (!(driveStatus & DriveInfo::EDriveUsbMemory) &&
+			    !(driveStatus & DriveInfo::EDriveRemote))
+{
+TN_DEBUG2( "CThumbnailServer::MemoryCardStatusChangedL() update KItemsleft = %d", KErrNotReady);
+OstTrace1( TRACE_NORMAL, DUP3_CTHUMBNAILSERVER_MEMORYCARDSTATUSCHANGEDL, "CThumbnailServer::MemoryCardStatusChangedL;KErrNotReady=%d - update KItemsleft", KErrNotReady );
+RProperty::Set(KTAGDPSNotification, KItemsleft, KErrNotReady );
+}
 TInt index = iUnmountedDrives.Find( drive );
 if(index >= KErrNone)
 {
 }
 if(!iUnmountedDrives.Count()&& iUnmount && iUnmount->IsActive())
 {
 TN_DEBUG1( "CThumbnailServer::MemoryCardStatusChangedL() cancel unmount timer");
+OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSERVER_MEMORYCARDSTATUSCHANGEDL, "CThumbnailServer::MemoryCardStatusChangedL - cancel unmount timer" );
 iUnmount->Cancel();
 }
 }
 //dismount -- if removable drive, close store
 else if(err && !err_drive && driveInfo.iDriveAtt& KDriveAttRemovable )
 {
 TN_DEBUG2( "CThumbnailServer::MemoryCardStatusChangedL() unmount drive==%d", drive);
+OstTrace1( TRACE_NORMAL, DUP5_CTHUMBNAILSERVER_MEMORYCARDSTATUSCHANGEDL, "CThumbnailServer::MemoryCardStatusChangedL - unmount drive;drive=%d", drive );
 CloseStoreForDriveL( drive);
 }
 }
 TN_DEBUG1( "CThumbnailServer::MemoryCardStatusChangedL out()" );
+OstTrace0( TRACE_NORMAL, DUP6_CTHUMBNAILSERVER_MEMORYCARDSTATUSCHANGEDL, "CThumbnailServer::MemoryCardStatusChangedL - out" );
 }
 // -----------------------------------------------------------------------------
 // Get the required size (in characters) for a buffer that contains the
 //
 TBool CThumbnailServer::UpdateThumbnailsL( const TDesC& aPath,
 const TInt /*aOrientation*/, const TInt64 aModified )
 {
 TN_DEBUG1( "CThumbnailServer::UpdateThumbnailsL()");
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_UPDATETHUMBNAILSL, "CThumbnailServer::UpdateThumbnailsL" );
 // 1. check path change
-// 2. check orientation change
+// 2. check timestamp change
-// 3. check timestamp change
-TBool orientationChanged = EFalse;
 TBool modifiedChanged = EFalse;
 CThumbnailStore* store = StoreForPathL( aPath );
-// placeholder for orientation check
+TN_DEBUG1( "CThumbnailServer::UpdateThumbnailsL() - exist");
-orientationChanged = EFalse;
+OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSERVER_UPDATETHUMBNAILSL, "CThumbnailServer::UpdateThumbnailsL - exist" );
-if (orientationChanged)
+TBool exists = store->CheckModifiedByPathL(aPath, aModified, modifiedChanged);
-{
-TN_DEBUG1( "CThumbnailServer::UpdateThumbnailsL() - orientation updated");
+if(!exists)
+{
-// orientation updated, no need to check further
+TN_DEBUG1( "CThumbnailServer::UpdateThumbnailsL() - exists NO");
+	OstTrace0( TRACE_NORMAL, DUP3_CTHUMBNAILSERVER_UPDATETHUMBNAILSL, "CThumbnailServer::UpdateThumbnailsL - exists NO" );
+//not found, needs to be generated
+return EFalse;
+}
+TN_DEBUG1( "CThumbnailServer::UpdateThumbnailsL() - modified ?");
+OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSERVER_UPDATETHUMBNAILSL, "CThumbnailServer::UpdateThumbnailsL - modified ?" );
+if (modifiedChanged)
+{
+TN_DEBUG1( "CThumbnailServer::UpdateThumbnailsL() - modified YES");
+OstTrace0( TRACE_NORMAL, DUP5_CTHUMBNAILSERVER_UPDATETHUMBNAILSL, "CThumbnailServer::UpdateThumbnailsL - modified YES" );
+// delete old thumbs
+store->DeleteThumbnailsL(aPath, ETrue);
+if( iFetchedChecker )
+{
+iFetchedChecker->DeleteFetchResult( aPath );
+}
+// need to create new thumbs
+}
+else
+{
+TN_DEBUG1( "CThumbnailServer::UpdateThumbnailsL() - modified NO");
+OstTrace0( TRACE_NORMAL, DUP6_CTHUMBNAILSERVER_UPDATETHUMBNAILSL, "CThumbnailServer::UpdateThumbnailsL - modified NO" );
+// not modified
 return ETrue;
 }
-else
-{
-TN_DEBUG1( "CThumbnailServer::UpdateThumbnailsL() - exist");
-TBool exists = store->CheckModifiedByPathL(aPath, aModified, modifiedChanged);
-if(!exists)
-{
-TN_DEBUG1( "CThumbnailServer::UpdateThumbnailsL() - exists NO");
-//not found, needs to be generated
-return EFalse;
-}
-TN_DEBUG1( "CThumbnailServer::UpdateThumbnailsL() - modified ?");
-if (modifiedChanged)
-{
-TN_DEBUG1( "CThumbnailServer::UpdateThumbnailsL() - modified YES");
-// delete old thumbs
-store->DeleteThumbnailsL(aPath, ETrue);
-if( iFetchedChecker )
-{
-iFetchedChecker->DeleteFetchResult( aPath );
-}
-// need to create new thumbs
-}
-else
-{
-TN_DEBUG1( "CThumbnailServer::UpdateThumbnailsL() - modified NO");
-// not modified
-return ETrue;
-}
-}
 TN_DEBUG1( "CThumbnailServer::UpdateThumbnailsL() - no thumbs found, create new");
+OstTrace0( TRACE_NORMAL, DUP7_CTHUMBNAILSERVER_UPDATETHUMBNAILSL, "CThumbnailServer::UpdateThumbnailsL - no thumbs found, create new" );
 return EFalse;
 }
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 void CThumbnailServer::RenameThumbnailsL( const TDesC& aCurrentPath, const TDesC& aNewPath )
 {
 TN_DEBUG2( "CThumbnailServer::RenameThumbnailsL(%S)", &aCurrentPath);
+OstTraceExt1( TRACE_NORMAL, CTHUMBNAILSERVER_RENAMETHUMBNAILSL, "CThumbnailServer::RenameThumbnailsL;aCurrentPath=%S", aCurrentPath );
 StoreForPathL( aCurrentPath )->RenameThumbnailsL( aCurrentPath, aNewPath );
 if( iFetchedChecker )
 {
 aMimeType = TDataType( KBmpMime );
 }
 else if ( ext.CompareF( K3gpExt ) == 0 )
 {
 aMimeType = TDataType( KVideo3gppMime );
+return KErrNotFound;
+// 3gp can contain video or audio, should go to recognizer
 }
 else if ( ext.CompareF( K3gppExt ) == 0 )
 {
 aMimeType = TDataType( KVideo3gppMime );
+return KErrNotFound;
+// 3gp can contain video or audio, should go to recognizer
 }
 else if ( ext.CompareF( KAmrExt ) == 0 )
 {
 aMimeType = TDataType( KAudioAmrMime );
 }
 {
 TRAP( result, CThumbnailServer::ThreadFunctionL());
 TN_DEBUG2(
 "CThumbnailServer::E32Main() -- thread function out, result=%d",
 result );
+OstTrace1( TRACE_NORMAL, _E32MAIN, "::E32Main;result=%d - thread function out", result );
 delete cleanup;
 cleanup = NULL;
 }
 if ( result != KErrNone )
 {
 // Signal the client that server creation failed
 TN_DEBUG1( "CThumbnailServer::E32Main() -- Rendezvous() in" );
+OstTrace0( TRACE_NORMAL, DUP2__E32MAIN, "::E32Main - in" );
 RProcess::Rendezvous( result );
 TN_DEBUG1( "CThumbnailServer::E32Main() -- Rendezvous() out" );
+OstTrace0( TRACE_NORMAL, DUP1__E32MAIN, "::E32Main - out" );
 }
 __UHEAP_MARKEND;
 return result;
 }
 // if removable drive, close store
 if (!err && driveInfo.iDriveAtt& KDriveAttRemovable)
 {
 TN_DEBUG2( "CThumbnailServer::CloseRemovableDrive drive=%d", drive);
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_CLOSEREMOVABLEDRIVESL, "CThumbnailServer::CloseRemovableDrivesL;drive=%d", drive );
 CloseStoreForDriveL(drive);
 }
 }
 iProcessor->RemoveAllTasks();
 }
 // if removable drive, open store
 if (!err && driveInfo.iDriveAtt& KDriveAttRemovable)
 {
 TN_DEBUG2( "CThumbnailServer::OpenRemovableDrive drive=%d", drive);
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_OPENREMOVABLEDRIVESL, "CThumbnailServer::OpenRemovableDrivesL;drive=%d", drive );
 StoreForDriveL(drive);
 }
 }
 }
 // ---------------------------------------------------------------------------
 //
 void CThumbnailServer::FormatNotification( TBool aFormat )
 {
 TN_DEBUG2( "CThumbnailServer::FormatNotification(%d)", aFormat );
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_FORMATNOTIFICATION, "CThumbnailServer::FormatNotification;aFormat=%d", aFormat );
 if(aFormat)
 {
 TRAP_IGNORE( CloseRemovableDrivesL() );
 }
 // ---------------------------------------------------------------------------
 //
 TInt CThumbnailServer::ReconnectCallBack(TAny* aAny)
 {
 TN_DEBUG1( "CThumbnailServer::ReconnectCallBack() - reconnect");
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_RECONNECTCALLBACK, "CThumbnailServer::ReconnectCallBack - reconnect" );
 CThumbnailServer* self = static_cast<CThumbnailServer*>( aAny );
 self->iReconnect->Cancel();
 // reconnect to MDS
 TRAP_IGNORE( self->iMdESession = CMdESession::NewL( *self ) );
 self->iSessionError = EFalse;
 TN_DEBUG1( "CThumbAGDaemon::ReconnectCallBack() - done");
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_RECONNECTCALLBACK, "CThumbnailServer::ReconnectCallBack - done" );
 return KErrNone;
 }
 // -----------------------------------------------------------------------------
 TInt pos = aPath.FindF(KPrivateFolder);
 if ( pos == 1 )
 {
 TN_DEBUG1( "CThumbnailServer::IsPublicPath() NO");
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_ISPUBLICPATH, "CThumbnailServer::IsPublicPath - NO" );
 return EFalse;
 }
 pos = aPath.FindF(KSysFolder);
 if ( pos == 1 )
 {
 TN_DEBUG1( "CThumbnailServer::IsPublicPath() NO");
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_ISPUBLICPATH, "CThumbnailServer::IsPublicPath - NO" );
 return EFalse;
 }
 return ETrue;
 }
 // ---------------------------------------------------------------------------
 //
 void CThumbnailServer::StartUnmountTimeout( const TInt aDrive)
 {
 TN_DEBUG2( "CThumbnailServer::StartUnmountTimeout(%d)", aDrive);
+OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_STARTUNMOUNTTIMEOUT, "CThumbnailServer::StartUnmountTimeout;aDrive=%d", aDrive );
 if(iUnmount )
 {
 if(iUnmountedDrives.Find( aDrive ) == KErrNotFound)
 {
 {
 iUnmount->Cancel();
 }
 TN_DEBUG1( "CThumbnailServer::StartUnmountTimeout() start unmount timer");
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_STARTUNMOUNTTIMEOUT, "CThumbnailServer::StartUnmountTimeout - start unmount timer" );
 iUnmount->Start( KUnmountTimerTimeout, KUnmountTimerTimeout, TCallBack(UnmountCallBack, this));
 }
 __ASSERT_DEBUG(( iUnmount ), ThumbnailPanic( EThumbnailNullPointer ));
 }
 // ---------------------------------------------------------------------------
 //
 TInt CThumbnailServer::UnmountCallBack(TAny* aAny)
 {
 TN_DEBUG1( "CThumbnailServer::UnmountCallBack() - unmount finished");
+OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_UNMOUNTCALLBACK, "CThumbnailServer::UnmountCallBack - unmount finished" );
 CThumbnailServer* self = static_cast<CThumbnailServer*>( aAny );
 self->iUnmount->Cancel();
 self->iUnmountedDrives.Reset();
 TN_DEBUG1( "CThumbAGDaemon::UnmountCallBack() - done");
+OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_UNMOUNTCALLBACK, "CThumbnailServer::UnmountCallBack - done" );
 return KErrNone;
 }

changeset 43	473df7bf149f
parent 36	c5df59b4ae2d