1 /*

     2 * Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Thumbnail server

    15  *

    16 */

    17 

    18 

    19 #include <e32svr.h>

    20 #include <MIHLScaler.h>

    21 #include <driveinfo.h>

    22 #include <caf/data.h>

    23 #include <Oma2Agent.h>

    24 #include <bautils.h>  

    25 #include <mdesession.h>

    26 

    27 #include "thumbnailserver.h"

    28 #include "thumbnailtaskprocessor.h"

    29 #include "thumbnailserversession.h"

    30 #include "thumbnailmanagerconstants.h"

    31 #include "thumbnailmanageruids.hrh"

    32 #include "thumbnaillog.h"

    33 #include "thumbnailstore.h"

    34 #include "thumbnaildiskunmountobserver.h"

    35 #include "thumbnailpanic.h"

    36 #include "thumbnailcenrep.h"

    37 #include "thumbnailmemorycardobserver.h"

    38 #include "tmgetimei.h"

    39 #include "thumbnailfetchedchecker.h"

    40 #include "OstTraceDefinitions.h"

    41 #ifdef OST_TRACE_COMPILER_IN_USE

    42 #include "thumbnailserverTraces.h"

    43 #endif

    44 

    45 

    46 

    47 _LIT8( KThumbnailMimeWildCard, "*" );

    48 _LIT8( KThumbnailMimeImage, "image" );

    49 _LIT8( KThumbnailMimeVideo, "video" );

    50 _LIT8( KThumbnailMimeAudio, "audio" );

    51 _LIT8( KThumbnailMimeContact, "contact" );

    52 

    53 const TChar KThumbnailMimeSeparatorChar = '/';

    54 const TChar KThumbnailMimeWildCardChar = '*';

    55 const TChar KThumbnailMimeTypeSeparatorChar = ' ';

    56 

    57 // ----------------------------------------------------------------------------------------

    58 // Server's policy here

    59 // ----------------------------------------------------------------------------------------

    60 

    61 // ----------------------------------------------------------------------------------------

    62 // Total number of ranges

    63 // ----------------------------------------------------------------------------------------

    64 const TUint KThumbnailServerRangeCount = 16;

    65  

    66 // ----------------------------------------------------------------------------------------

    67 // Definition of the ranges

    68 // ----------------------------------------------------------------------------------------

    69 const TInt KThumbnailServerRanges[KThumbnailServerRangeCount] = 

    70 {

    71     ERequestThumbByPathAsync,      

    72     ERequestThumbByFileHandleAsync,          

    73     EReleaseBitmap,

    74     ECancelRequest,

    75     EChangePriority,

    76     EDeleteThumbnails,

    77     EGetMimeTypeBufferSize,

    78     EGetMimeTypeList,

    79     ERequestThumbByIdAsync,

    80     ERequestThumbByBufferAsync,

    81     ERequestSetThumbnailByBuffer,

    82     EDeleteThumbnailsById,

    83     ERenameThumbnails,

    84     EUpdateThumbnails,

    85     ERequestSetThumbnailByBitmap,

    86     EThumbnailServerRequestCount,

    87 };

    88 

    89 // ----------------------------------------------------------------------------------------

    90 // Policy to implement for each of the above ranges 

    91 // ----------------------------------------------------------------------------------------      

    92 const TUint8 KThumbnailServerElementsIndex[KThumbnailServerRangeCount] = 

    93     {

    94     CPolicyServer::ECustomCheck,    // ERequestThumbByPathAsync

    95     CPolicyServer::ECustomCheck,    // ERequestThumbByFileHandleAsync

    96     CPolicyServer::ECustomCheck,    // EReleaseBitmap

    97     CPolicyServer::ECustomCheck,    // ECancelRequest

    98     CPolicyServer::ECustomCheck,    // EChangePriority

    99     CPolicyServer::ECustomCheck,    // EDeleteThumbnails

   100     CPolicyServer::ECustomCheck,    // EGetMimeTypeBufferSize

   101     CPolicyServer::ECustomCheck,    // EGetMimeTypeList

   102     CPolicyServer::ECustomCheck,    // ERequestThumbByIdAsync

   103     CPolicyServer::ECustomCheck,    // ERequestThumbByBufferAsync

   104     CPolicyServer::ECustomCheck,    // ERequestSetThumbnailByBuffer

   105     CPolicyServer::ECustomCheck,    // EDeleteThumbnailsById

   106     CPolicyServer::ECustomCheck,    // ERenameThumbnails

   107     CPolicyServer::ECustomCheck,    // EUpdateThumbnails

   108     CPolicyServer::ECustomCheck,    // ERequestSetThumbnailByBitmap

   109     CPolicyServer::ECustomCheck,    // EThumbnailServerRequestCount

   110     };

   111 

   112 // ----------------------------------------------------------------------------------------

   113 // Package all the above together into a policy 

   114 // ---------------------------------------------------------------------------------------- 

   115 const CPolicyServer::TPolicy KThumbnailServerPolicy =

   116     {

   117     CPolicyServer::EAlwaysPass,

   118     KThumbnailServerRangeCount,      // number of ranges

   119     KThumbnailServerRanges,          // ranges array

   120     KThumbnailServerElementsIndex,   // elements<->ranges index

   121     NULL 

   122                                // array of elements

   123     };

   124 

   125 // ---------------------------------------------------------------------------

   126 // CustomSecurityCheckL

   127 // ---------------------------------------------------------------------------

   128 //

   129 CPolicyServer::TCustomResult CThumbnailServer::CustomSecurityCheckL(

   130         const RMessage2& aMsg, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/ )

   131     {

   132     CPolicyServer::TCustomResult securityCheckResult = EFail;

   133     

   134     switch ( aMsg.Function() )

   135         {

   136         case ERequestThumbByPathAsync:

   137         case ERequestThumbByFileHandleAsync:

   138         case ERequestThumbByIdAsync:

   139         case ERequestThumbByBufferAsync:

   140             {

   141             securityCheckResult = EPass;

   142             break;

   143             }

   144         case EReleaseBitmap:

   145         case ECancelRequest:

   146         case EChangePriority:

   147         case EDeleteThumbnails:

   148         case EGetMimeTypeBufferSize:

   149         case EGetMimeTypeList:

   150         case ERequestSetThumbnailByBuffer:

   151         case EDeleteThumbnailsById:

   152         case EUpdateThumbnails:

   153         case ERenameThumbnails:    

   154         case ERequestSetThumbnailByBitmap:

   155             {

   156             if( aMsg.HasCapability( ECapabilityReadDeviceData ) && 

   157                 aMsg.HasCapability( ECapabilityWriteDeviceData ) )

   158                 {

   159                 securityCheckResult = EPass;

   160                 }

   161             break;

   162             }

   163         case EThumbnailServerRequestCount:

   164         default:

   165             {

   166             securityCheckResult = EFail;

   167             }

   168         }

   169     

   170     return securityCheckResult;

   171     }

   172 // ---------------------------------------------------------------------------

   173 // CustomFailureActionL

   174 // ---------------------------------------------------------------------------

   175 //

   176 CPolicyServer::TCustomResult CThumbnailServer::CustomFailureActionL(

   177         const RMessage2& /*aMsg*/, TInt /*aAction*/, const TSecurityInfo& /*aMissing*/ )

   178     {

   179     // Not used

   180     return EFail;

   181     }

   182 

   183 // ======== MEMBER FUNCTIONS ========

   184 

   185 // ---------------------------------------------------------------------------

   186 // CThumbnailServer::CThumbnailServer()

   187 // C++ default constructor can NOT contain any code, that might leave.

   188 // ---------------------------------------------------------------------------

   189 //

   190 CThumbnailServer::CThumbnailServer(): CPolicyServer( CActive::EPriorityStandard,

   191     KThumbnailServerPolicy, EUnsharableSessions )

   192     {

   193     // No implementation required

   194     }

   195 

   196 // ---------------------------------------------------------------------------

   197 // CThumbnailServer::NewL()

   198 // Two-phased constructor.

   199 // ---------------------------------------------------------------------------

   200 //

   201 CThumbnailServer* CThumbnailServer::NewL()

   202     {

   203     CThumbnailServer* self = new( ELeave )CThumbnailServer();

   204     CleanupStack::PushL( self );

   205     self->ConstructL();

   206     CleanupStack::Pop( self );

   207     return self;

   208     }

   209 

   210 

   211 // ---------------------------------------------------------------------------

   212 // CThumbnailServer::ConstructL()

   213 // Symbian 2nd phase constructor can leave.

   214 // ---------------------------------------------------------------------------

   215 //

   216 void CThumbnailServer::ConstructL()

   217     {

   218     TN_DEBUG1( "CThumbnailServer::ConstructL()" );

   219     OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_CONSTRUCTL, "CThumbnailServer::ConstructL" );

   220     

   221 #ifdef _DEBUG

   222     iPlaceholderCounter = 0;

   223 #endif

   224     

   225     // create shutdown observer

   226     iShutdownObserver = CTMShutdownObserver::NewL( *this, KTMPSNotification, KShutdown, ETrue );  

   227     iShutdown = EFalse;

   228     

   229     // MDS session reconnect timer

   230     iReconnect = CPeriodic::NewL(CActive::EPriorityIdle);

   231     

   232     // connect to MDS

   233     iMdESession = CMdESession::NewL( *this );

   234     iSessionError = EFalse;

   235     

   236     User::LeaveIfError( iFbsSession.Connect());

   237     User::LeaveIfError( Start( KThumbnailServerName ));

   238     User::LeaveIfError( iFs.Connect());

   239     iProcessor = CThumbnailTaskProcessor::NewL();

   240     REComSession::FinalClose();

   241     REComSession::ListImplementationsL( TUid::Uid( THUMBNAIL_PROVIDER_IF_UID ),

   242         iPluginInfoArray );

   243     

   244 	//preload provide plugins

   245     PreLoadProviders();

   246     

   247     CTMGetImei * imeiGetter = CTMGetImei::NewLC();

   248    

   249     iImei = imeiGetter->GetIMEI();

   250     CleanupStack::PopAndDestroy(imeiGetter);

   251     

   252     iFs.CreatePrivatePath(EDriveC);

   253     iFs.SetSessionToPrivate(EDriveC);

   254     

   255     iCenrep = CThumbnailCenRep::NewL();

   256                

   257     iPersistentSizes = iCenrep->GetPersistentSizes();

   258             

   259     iMMCObserver = CThumbnailMemoryCardObserver::NewL( this, iFs );

   260     

   261     iFormatObserver = CTMFormatObserver::NewL( *this );

   262     

   263     iFormatting = EFalse;

   264     

   265     OpenStoresL();

   266     

   267     AddUnmountObserversL();

   268     iFetchedChecker = CThumbnailFetchedChecker::NewL();

   269     

   270     // Unmount timeout timer

   271     iUnmount = CPeriodic::NewL(CActive::EPriorityIdle);

   272     }

   273 

   274 

   275 // ---------------------------------------------------------------------------

   276 // Destructor.

   277 // ---------------------------------------------------------------------------

   278 //

   279 CThumbnailServer::~CThumbnailServer()

   280     {

   281     TN_DEBUG1( "CThumbnailServer::~CThumbnailServer()" );

   282     OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_CTHUMBNAILSERVER, "CThumbnailServer::~CThumbnailServer" );

   283 

   284     iShutdown = ETrue;

   285     

   286     if(iUnmount)

   287         {

   288         iUnmount->Cancel();

   289         delete iUnmount;

   290         iUnmount = NULL;

   291         }

   292 		

   293 	iUnmountedDrives.Close();

   294     

   295     delete iFetchedChecker;

   296     iFetchedChecker = NULL;

   297     delete iShutdownObserver;

   298     iShutdownObserver = NULL;

   299     delete iProcessor;

   300     iProcessor = NULL;

   301     

   302     if(iReconnect)

   303         {

   304         iReconnect->Cancel();

   305         delete iReconnect;

   306         iReconnect = NULL;

   307         }

   308     

   309     if (iMdESession)

   310         {

   311         delete iMdESession;

   312         iMdESession = NULL;

   313         }

   314 

   315     ResetAndDestroyHashMap < TInt, CThumbnailStore > ( iStores );

   316     ResetAndDestroyHashMap < TInt32, CThumbnailProvider > ( iProviders );

   317     

   318     iUnmountObservers.ResetAndDestroy();

   319     delete iMMCObserver;

   320     iMMCObserver = NULL;

   321     delete iFormatObserver;

   322     iFormatObserver = NULL;

   323     

   324     THashMapIter < TInt, TThumbnailBitmapRef > bpiter( iBitmapPool );

   325 

   326     // const pointer to a non-const object

   327     const TThumbnailBitmapRef* ref = bpiter.NextValue();

   328 

   329     while ( ref )

   330         {

   331         delete ref->iBitmap;

   332         ref = bpiter.NextValue();

   333         }

   334     

   335     delete iScaler;

   336     iScaler = NULL;

   337     iBitmapPool.Close();

   338     iFbsSession.Disconnect();

   339     iRecognizer.Close();

   340     iPluginInfoArray.ResetAndDestroy();

   341     delete iCenrep;

   342     iCenrep = NULL;

   343     iFs.Close();

   344     REComSession::FinalClose();

   345     }

   346 

   347 // -----------------------------------------------------------------------------

   348 // CThumbnailServer::HandleSessionOpened

   349 // -----------------------------------------------------------------------------

   350 //

   351 #ifdef _DEBUG

   352 void CThumbnailServer::HandleSessionOpened( CMdESession& /* aSession */, TInt aError )

   353 #else

   354 void CThumbnailServer::HandleSessionOpened( CMdESession& /* aSession */, TInt /*aError*/ )

   355 #endif

   356     {

   357 #ifdef _DEBUG

   358     TN_DEBUG2( "CThumbnailServer::HandleSessionOpened error == %d", aError );

   359     OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_HANDLESESSIONOPENED, "CThumbnailServer::HandleSessionOpened;aError=%d", aError );

   360 #endif    

   361     }

   362 

   363 // -----------------------------------------------------------------------------

   364 // CThumbnailServer::HandleSessionError

   365 // -----------------------------------------------------------------------------

   366 //

   367 void CThumbnailServer::HandleSessionError( CMdESession& /*aSession*/, TInt aError )

   368     {

   369     TN_DEBUG2( "CThumbnailServer::HandleSessionError == %d", aError );

   370     OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_HANDLESESSIONERROR, "CThumbnailServer::HandleSessionError;aError=%d", aError );

   371     if (aError != KErrNone && !iShutdown && !iSessionError)

   372         {

   373         iSessionError = ETrue;

   374     

   375         if (!iReconnect->IsActive())

   376             {

   377             iReconnect->Start( KMdEReconnect, KMdEReconnect, 

   378                                TCallBack(ReconnectCallBack, this));

   379             

   380             TN_DEBUG1( "CThumbnailServer::HandleSessionError() - reconnect timer started" );

   381             OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_HANDLESESSIONERROR, "CThumbnailServer::HandleSessionError - reconnect timer started" );

   382             }

   383         } 

   384     }

   385 

   386 // -----------------------------------------------------------------------------

   387 // CThumbnailServer::NewSessionL()

   388 // Creates new server session.

   389 // -----------------------------------------------------------------------------

   390 //

   391 CSession2* CThumbnailServer::NewSessionL( const TVersion& aVersion, const

   392     RMessage2&  /*aMessage*/ )const

   393     {

   394     const TVersion v( KThumbnailServerMajorVersionNumber,

   395         KThumbnailServerMinorVersionNumber, KThumbnailServerBuildVersionNumber )

   396         ;

   397     if ( !User::QueryVersionSupported( v, aVersion ))

   398         {

   399         User::Leave( KErrNotSupported );

   400         }

   401     return new( ELeave )CThumbnailServerSession();

   402     }

   403 

   404 

   405 // -----------------------------------------------------------------------------

   406 // CThumbnailServer::ThreadFunctionL()

   407 // -----------------------------------------------------------------------------

   408 //

   409 void CThumbnailServer::ThreadFunctionL()

   410     {

   411     // Rename own thread

   412     User::LeaveIfError( User::RenameThread( KThumbnailServerName ));

   413 

   414     CThumbnailServer* server = NULL;

   415     CActiveScheduler* scheduler = new( ELeave )CActiveScheduler();

   416 

   417     if ( scheduler )

   418         {

   419         CActiveScheduler::Install( scheduler );

   420         CleanupStack::PushL( scheduler );

   421         server = CThumbnailServer::NewL(); // Adds server in scheduler

   422         // No need to CleanupStack::PushL(server) since no leaves can happen

   423         RProcess::Rendezvous( KErrNone );

   424         TN_DEBUG1( 

   425             "CThumbnailServer::ThreadFunctionL() -- CActiveScheduler::Start() in" );

   426         OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_THREADFUNCTIONL, "CThumbnailServer::ThreadFunctionL -- CActiveScheduler::Start() in" );

   427         CActiveScheduler::Start();

   428         TN_DEBUG1( 

   429             "CThumbnailServer::ThreadFunctionL() -- CActiveScheduler::Start() out" );

   430         OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_THREADFUNCTIONL, "CThumbnailServer::ThreadFunctionL - out" );

   431         // Comes here if server gets shut down

   432         delete server;

   433         server = NULL;

   434         CleanupStack::PopAndDestroy( scheduler );

   435         }

   436     }

   437 

   438 

   439 // -----------------------------------------------------------------------------

   440 // CThumbnailServer::AddSession()

   441 // -----------------------------------------------------------------------------

   442 //

   443 void CThumbnailServer::AddSession()

   444     {

   445     TN_DEBUG2( "CThumbnailServer::AddSession() iSessionCount was %d",

   446         iSessionCount );

   447     OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_ADDSESSION, "CThumbnailServer::AddSession;iSessionCount=%d", iSessionCount );

   448     iSessionCount++;

   449     }

   450 

   451 

   452 // -----------------------------------------------------------------------------

   453 // CThumbnailServer::DropSession()

   454 // -----------------------------------------------------------------------------

   455 //

   456 void CThumbnailServer::DropSession(CThumbnailServerSession* aSession)

   457     {

   458     TN_DEBUG2( "CThumbnailServer::DropSession() iSessionCount was %d",

   459         iSessionCount );

   460     OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_DROPSESSION, "CThumbnailServer::DropSession;iSessionCount=%d", iSessionCount );

   461     iSessionCount--;

   462     

   463     if(iProcessor)

   464         {

   465         iProcessor->RemoveTasks(aSession);

   466         }

   467     

   468     TN_DEBUG2( "CThumbnailServer::DropSession() aSession = 0x%08x", aSession );        

   469     OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_DROPSESSION, "CThumbnailServer::DropSession;aSession=%o", aSession );

   470     

   471     // clean-up bitmap pool    

   472     THashMapIter < TInt, TThumbnailBitmapRef > bpiter( iBitmapPool );

   473 

   474     // const pointer to a non-const object

   475     const TThumbnailBitmapRef* ref = bpiter.NextValue();

   476 

   477     while ( ref )

   478         {        

   479         if ( ref->iSession == aSession )

   480             {

   481             TN_DEBUG2( "CThumbnailServer::DropSession() - ref->iSession = 0x%08x", ref->iSession );

   482             OstTrace1( TRACE_NORMAL, DUP2_CTHUMBNAILSERVER_DROPSESSION, "CThumbnailServer::DropSession;ref->iSession=%o", ref->iSession );

   483         

   484             delete ref->iBitmap;

   485             bpiter.RemoveCurrent();

   486                         

   487             TN_DEBUG2( "CThumbnailServer::DropSession() - deleted bitmap, left=%d", iBitmapPool.Count());

   488             OstTrace1( TRACE_NORMAL, DUP3_CTHUMBNAILSERVER_DROPSESSION, "CThumbnailServer::DropSession;iBitmapPool.Count()=%d", iBitmapPool.Count() );

   489             }

   490         

   491         ref = bpiter.NextValue();        

   492         }

   493 

   494     if ( iSessionCount <= 0 )

   495         {

   496         // server shutdown

   497         if (!iShutdown)

   498             {

   499             // rename thread

   500             User::RenameThread( KThumbnailServerShutdown );

   501         

   502             CActiveScheduler::Stop();

   503             iShutdown = ETrue;

   504             }

   505         }

   506     }

   507 

   508 // -----------------------------------------------------------------------------

   509 // CThumbnailServer::ShutdownNotification

   510 // -----------------------------------------------------------------------------

   511 //

   512 void CThumbnailServer::ShutdownNotification()

   513     {

   514     TN_DEBUG1( "CThumbnailServer::ShutdownNotification()");

   515     OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_SHUTDOWNNOTIFICATION, "CThumbnailServer::ShutdownNotification" );

   516     if (!iShutdown)

   517         {

   518         TN_DEBUG1( "CThumbnailServer::ShutdownNotification() shutdown");

   519         OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_SHUTDOWNNOTIFICATION, "CThumbnailServer::ShutdownNotification - shutdown" );

   520         CActiveScheduler::Stop();

   521         iShutdown = ETrue;

   522         }

   523     }

   524 

   525 

   526 // -----------------------------------------------------------------------------

   527 // CThumbnailServer::AddBitmapToPoolL()

   528 // Add bitmap to bitmap pool.

   529 // -----------------------------------------------------------------------------

   530 //

   531 void CThumbnailServer::AddBitmapToPoolL( CThumbnailServerSession* aSession,

   532     CFbsBitmap* aBitmap, TThumbnailServerRequestId aRequestId )

   533     {

   534     if( !aBitmap )

   535         {

   536         TN_DEBUG1( "CThumbnailServer::AddBitmapToPoolL() - KErrArgument");

   537         OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_ADDBITMAPTOPOOLL, "CThumbnailServer::AddBitmapToPoolL - KErrArgument" );

   538         User::Leave( KErrArgument );

   539         }

   540     TN_DEBUG4( 

   541         "CThumbnailServer::AddBitmapToPoolL(aSession=0x%08x, aBitmap=0x%08x), handle=%d", aSession, aBitmap, aBitmap->Handle());

   542 

   543     TThumbnailBitmapRef* ptr = iBitmapPool.Find( aBitmap->Handle());

   544 

   545     TN_DEBUG2( "CThumbnailServer::AddBitmapToPoolL() - req id = %d", aRequestId.iRequestId );

   546     OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_ADDBITMAPTOPOOLL, "CThumbnailServer::AddBitmapToPoolL;aRequestId.iRequestId=%u", aRequestId.iRequestId );

   547     

   548     if ( ptr )

   549         {

   550         ptr->iRefCount++;

   551         }

   552     else

   553         {

   554         TThumbnailBitmapRef ref;

   555         ref.iBitmap = aBitmap;

   556         ref.iSession = aSession;

   557         ref.iRefCount = 1; // magic: first reference        

   558         ref.iRequestId = aRequestId.iRequestId;               

   559         

   560         iBitmapPool.InsertL( aBitmap->Handle(), ref );

   561         }

   562     

   563 #ifdef _DEBUG

   564     TN_DEBUG2( "CThumbnailServer::BITMAP-POOL-COUNTER----------, Bitmaps = %d", iBitmapPool.Count() );

   565     OstTrace1( TRACE_NORMAL, DUP2_CTHUMBNAILSERVER_ADDBITMAPTOPOOLL, "CThumbnailServer::AddBitmapToPoolL;iBitmapPool.Count()=%d", iBitmapPool.Count() );

   566 #endif

   567     }

   568 

   569 

   570 // -----------------------------------------------------------------------------

   571 // CThumbnailServer::StoreThumbnailL()

   572 // -----------------------------------------------------------------------------

   573 //

   574 void CThumbnailServer::StoreThumbnailL( const TDesC& aPath, CFbsBitmap* aBitmap,

   575     const TSize& aOriginalSize, const TBool aCropped, const TThumbnailSize aThumbnailSize,

   576     const TInt64 aModified, const TBool aThumbFromPath, const TBool aCheckExist )

   577     {

   578     TN_DEBUG6( 

   579         "CThumbnailServer::StoreBitmapL(aPath=%S, aBitmap=0x%08x, aOriginalSize=%dx%d, aCropped=%d)", &aPath, aBitmap, aOriginalSize.iWidth, aOriginalSize.iHeight, aCropped );

   580     OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_STORETHUMBNAILL, "CThumbnailServer::StoreThumbnailL;aBitmap=%o", aBitmap );

   581     OstTraceExt1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_STORETHUMBNAILL, "CThumbnailServer::StoreThumbnailL;aPath=%S", aPath );

   582     OstTraceExt3( TRACE_NORMAL, DUP2_CTHUMBNAILSERVER_STORETHUMBNAILL, "CThumbnailServer::StoreThumbnailL;aOriginalSize.iWidth=%d;aOriginalSize.iHeight=%d;aCropped=%u", aOriginalSize.iWidth, aOriginalSize.iHeight, aCropped );

   583     

   584 #ifdef _DEBUG

   585     TN_DEBUG2( "CThumbnailServer::StoreThumbnailL() - iScaledBitmap displaymode is %d", aBitmap->DisplayMode());

   586     OstTrace1( TRACE_NORMAL, DUP3_CTHUMBNAILSERVER_STORETHUMBNAILL, "CThumbnailServer::StoreThumbnailL;aBitmap->DisplayMode()=%u", aBitmap->DisplayMode() );

   587 #endif

   588     

   589     if (!aCheckExist)

   590         {

   591         StoreForPathL( aPath )->StoreThumbnailL( aPath, aBitmap, aOriginalSize,

   592                        aCropped, aThumbnailSize, aModified, aThumbFromPath, EFalse );

   593         }    

   594     else if(BaflUtils::FileExists( iFs, aPath))

   595         {

   596         StoreForPathL( aPath )->StoreThumbnailL( aPath, aBitmap, aOriginalSize,

   597                        aCropped, aThumbnailSize, aModified, aThumbFromPath, EFalse );

   598         }

   599     else

   600         {

   601         TN_DEBUG1( "CThumbnailServer::StoreThumbnailL() - file doesn't exists anymore, skip store!");

   602         OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSERVER_STORETHUMBNAILL, "CThumbnailServer::StoreThumbnailL - file doesn't exists anymore, skip store!" );

   603         }

   604     

   605     if( iFetchedChecker )    

   606         {

   607         iFetchedChecker->SetFetchResult( aPath, aThumbnailSize, KErrNone );

   608         }

   609     }

   610 

   611 

   612 // -----------------------------------------------------------------------------

   613 // CThumbnailServer::FetchThumbnailL()

   614 // -----------------------------------------------------------------------------

   615 //

   616 void CThumbnailServer::FetchThumbnailL( const TDesC& aPath, CFbsBitmap* &

   617     aThumbnail, TDesC8* & aData, const TThumbnailSize aThumbnailSize, TSize &aOriginalSize )

   618     {

   619     TN_DEBUG3( "CThumbnailServer::FetchThumbnailL(aPath=%S aThumbnailSize=%d)", &aPath, aThumbnailSize );

   620     OstTraceExt2( TRACE_NORMAL, CTHUMBNAILSERVER_FETCHTHUMBNAILL, "CThumbnailServer::FetchThumbnailL;aPath=%S;aThumbnailSize=%hu", aPath, aThumbnailSize );

   621     if( iFetchedChecker )

   622         {

   623         TInt err( iFetchedChecker->LastFetchResult( aPath, aThumbnailSize ) );

   624         if ( err == KErrNone ) // To avoid useless sql gets that fails for sure

   625             {

   626             // custom sizes are not stored to db, skip fetching

   627             if ( aThumbnailSize == ECustomThumbnailSize )

   628                 {

   629                 User::Leave( KErrNotFound );

   630                 }

   631         

   632             TRAP( err, StoreForPathL( aPath )->FetchThumbnailL( aPath, aThumbnail, aData, aThumbnailSize, aOriginalSize) );

   633             if ( err != KErrNone )

   634                 {

   635                 iFetchedChecker->SetFetchResult( aPath, aThumbnailSize, err );

   636                 }

   637             }

   638         User::LeaveIfError( err );

   639         }

   640     else

   641         {

   642         // custom sizes are not stored to db, skip fetching

   643         if ( aThumbnailSize == ECustomThumbnailSize )

   644             {

   645             User::Leave( KErrNotFound );

   646             }

   647     

   648         StoreForPathL( aPath )->FetchThumbnailL( aPath, aThumbnail, aData, aThumbnailSize, aOriginalSize);

   649         }

   650     }

   651 

   652 

   653 

   654 // -----------------------------------------------------------------------------

   655 // CThumbnailServer::DeleteBitmapFromPool()

   656 // Removes bitmap from bitmap pool

   657 // -----------------------------------------------------------------------------

   658 //

   659 void CThumbnailServer::DeleteBitmapFromPool( TInt aHandle )

   660     {

   661     TN_DEBUG2( "CThumbnailServer::DeleteBitmapFromPool(%d)", aHandle );

   662     OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_DELETEBITMAPFROMPOOL, "CThumbnailServer::DeleteBitmapFromPool;aHandle=%d", aHandle );

   663 

   664     TThumbnailBitmapRef* ptr = iBitmapPool.Find( aHandle );

   665     if ( ptr )

   666         {

   667         ptr->iRefCount--;

   668         if ( !ptr->iRefCount )

   669             {

   670             TN_DEBUG3( 

   671                 "CThumbnailServer::DeleteBitmapFromPool(%d) -- deleting 0x%08x)", aHandle, ptr );

   672             OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_DELETEBITMAPFROMPOOL, "CThumbnailServer::DeleteBitmapFromPool -- deleting;ptr=%o", ptr );

   673             delete ptr->iBitmap;

   674             ptr->iBitmap = NULL;

   675             iBitmapPool.Remove( aHandle );

   676             TN_DEBUG2( "CThumbnailServer::DeleteBitmapFromPool -- items left %d", iBitmapPool.Count() );

   677             OstTrace1( TRACE_NORMAL, DUP2_CTHUMBNAILSERVER_DELETEBITMAPFROMPOOL, "CThumbnailServer::DeleteBitmapFromPool  -- items left;iBitmapPool.Count()=%d", iBitmapPool.Count() );

   678             }

   679         else

   680             {

   681             TN_DEBUG3( 

   682                 "CThumbnailServer::DeleteBitmapFromPool(%d) -- refcount now %d",

   683                 aHandle, ptr->iRefCount );

   684             OstTraceExt2( TRACE_NORMAL, DUP3_CTHUMBNAILSERVER_DELETEBITMAPFROMPOOL, "CThumbnailServer::DeleteBitmapFromPool) -- refcount now;aHandle=%d;ptr->iRefCount=%d", aHandle, ptr->iRefCount );

   685             }

   686         }

   687     else

   688         {

   689         //__ASSERT_DEBUG(( EFalse ), ThumbnailPanic( EThumbnailBitmapNotReleased ));

   690         TN_DEBUG2( "CThumbnailServer::DeleteBitmapFromPool(%d) -- not found!",

   691             aHandle );

   692         OstTrace1( TRACE_NORMAL, DUP4_CTHUMBNAILSERVER_DELETEBITMAPFROMPOOL, "CThumbnailServer::DeleteBitmapFromPool  -- not found!;aHandle=%d", aHandle );

   693         }

   694     }

   695 

   696 

   697 // -----------------------------------------------------------------------------

   698 // Delete thumbnails for given object file

   699 // -----------------------------------------------------------------------------

   700 //

   701 void CThumbnailServer::DeleteThumbnailsL( const TDesC& aPath )

   702     {

   703     TN_DEBUG2( "CThumbnailServer::DeleteThumbnailsL(%S)", &aPath);

   704     OstTraceExt1( TRACE_NORMAL, CTHUMBNAILSERVER_DELETETHUMBNAILSL, "CThumbnailServer::DeleteThumbnailsL;aPath=%S", aPath );

   705     

   706     StoreForPathL( aPath )->DeleteThumbnailsL( aPath );

   707     

   708     if( iFetchedChecker ) 

   709         {

   710         iFetchedChecker->DeleteFetchResult( aPath );

   711         }

   712     }

   713 

   714 // -----------------------------------------------------------------------------

   715 // CThumbnailServer::ResolveMimeTypeL()

   716 // -----------------------------------------------------------------------------

   717 //

   718 TDataType CThumbnailServer::ResolveMimeTypeL( RFile64& aFile )

   719     {

   720     TN_DEBUG1( "CThumbnailStore::ResolveMimeTypeL()");

   721     RFile64 tmp = aFile;

   722     

   723     // check if DRM

   724     ContentAccess::CData* data = ContentAccess::CData::NewLC( 

   725             tmp, ContentAccess::KDefaultContentObject, ContentAccess::EPeek );

   726 

   727     TInt filetype( 0 );

   728     TInt drm( 0 );

   729     User::LeaveIfError( data->GetAttribute( ContentAccess::EIsProtected, drm ) );

   730     data->GetAttribute( ContentAccess::EFileType, filetype );

   731     CleanupStack::PopAndDestroy();    

   732 

   733 	//close aFile on leave	

   734     CleanupClosePushL( aFile );    

   735     

   736     if ( drm && filetype != ContentAccess::EOma1Dcf )

   737         {

   738         // cannot handle other than Oma DRM 1.x files

   739         TN_DEBUG1( "CThumbnailStore::ResolveMimeTypeL()- only OMA DRM 1.0 supported");

   740         OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_RESOLVEMIMETYPEL, "CThumbnailServer::ResolveMimeTypeL - only OMA DRM 1.0 supported" );

   741         User::Leave(KErrNotSupported);

   742         }    

   743     

   744     TDataRecognitionResult res;

   745     if ( iRecognizer.Handle() == KNullHandle )

   746         {

   747         // error using recognizer, (re)connect

   748         User::LeaveIfError( iRecognizer.Connect());

   749         }

   750     

   751     User::LeaveIfError( iRecognizer.RecognizeData( aFile, res ));

   752     

   753     if ( res.iConfidence == CApaDataRecognizerType::ENotRecognized )

   754         {

   755         // file type not supported

   756         User::Leave( KErrNotSupported );

   757         }

   758 

   759     CleanupStack::Pop( &aFile );

   760     return res.iDataType;

   761     }

   762 

   763 // -----------------------------------------------------------------------------

   764 // CThumbnailServer::ResolveProviderL()

   765 // Resolves plugin to be used in thumbnail creation.

   766 // -----------------------------------------------------------------------------

   767 //

   768 CThumbnailProvider* CThumbnailServer::ResolveProviderL( const TDesC8& aMimeType

   769     )

   770     {

   771 #ifdef _DEBUG

   772     TBuf < KMaxDataTypeLength > buf; // 16-bit descriptor for debug prints

   773     buf.Copy( aMimeType );

   774     TN_DEBUG2( "CThumbnailServer::ResolveProviderL(%S)", &buf );

   775     OstTraceExt1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_RESOLVEMIMETYPEL, "CThumbnailServer::ResolveMimeTypeL;buf=%S", buf );

   776 #endif 

   777 

   778     CThumbnailProvider* ret = NULL;

   779 

   780     TInt separatorPos = aMimeType.Locate( KThumbnailMimeSeparatorChar );

   781     TPtrC8 mediaType( aMimeType.Left( separatorPos ));

   782     TPtrC8 subType( aMimeType.Mid( separatorPos + 1 )); // skip slash

   783 

   784     const TInt count = iPluginInfoArray.Count();

   785     for ( TInt i( 0 ); i < count && !ret; i++ )

   786         {

   787         const TDesC8& opaqueData = iPluginInfoArray[i]->OpaqueData();

   788         TInt pSeparatorPos = opaqueData.Locate( KThumbnailMimeSeparatorChar );

   789         TPtrC8 pMediaType( opaqueData.Left( pSeparatorPos ));

   790         TPtrC8 pSubType( opaqueData.Mid( pSeparatorPos + 1 )); // skip slash

   791         

   792         if ( !pMediaType.CompareF( mediaType ))

   793             {

   794             if ( !pSubType.CompareF( KThumbnailMimeWildCard ) ||

   795                 !pSubType.CompareF( subType ))

   796                 {

   797 #ifdef _DEBUG

   798                 TN_DEBUG3( 

   799                     "CThumbnailServer::ResolveProviderL(%S) -- using provider 0x%08x", &buf, iPluginInfoArray[i]->ImplementationUid().iUid );

   800                 OstTraceExt1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_RESOLVEPROVIDERL, "CThumbnailServer::ResolveProviderL;buf=%S", buf );

   801                 OstTrace1( TRACE_NORMAL, DUP2_CTHUMBNAILSERVER_RESOLVEPROVIDERL, "CThumbnailServer::ResolveProviderL;iPluginInfoArray[i]->ImplementationUid().iUid=%o", iPluginInfoArray[i]->ImplementationUid().iUid );

   802 #endif 

   803                 ret = GetProviderL( iPluginInfoArray[i]->ImplementationUid());

   804                 }

   805             }

   806         }

   807     if ( !ret )

   808         {

   809 #ifdef _DEBUG

   810         TN_DEBUG2( 

   811             "CThumbnailServer::ResolveProviderL(%S) -- provider not found",

   812             &buf );

   813         OstTraceExt1( TRACE_NORMAL, CTHUMBNAILSERVER_RESOLVEPROVIDERL, "CThumbnailServer::ResolveProviderL;buf=%S", buf );

   814 #endif 

   815         User::Leave( KErrNotSupported );

   816         }

   817     return ret;

   818     }

   819 

   820 

   821 // -----------------------------------------------------------------------------

   822 // CThumbnailServer::GetProviderL()

   823 // -----------------------------------------------------------------------------

   824 //

   825 CThumbnailProvider* CThumbnailServer::GetProviderL( const TUid& aImplUid )

   826     {

   827     CThumbnailProvider** resPtr = iProviders.Find( aImplUid.iUid );

   828     CThumbnailProvider* res = NULL;

   829     if ( resPtr )

   830         {

   831         // Use existing instance

   832         res = * resPtr;

   833         }

   834     else

   835         {

   836         // Plug-in needs to be loaded

   837         TN_DEBUG2( 

   838             "CThumbnailServer::GetProviderL() -- loading plug-in, UID 0x%08x",

   839             aImplUid );

   840         res = CThumbnailProvider::NewL( aImplUid );

   841         TN_DEBUG1( "CThumbnailServer::GetProviderL() -- loading complete" );

   842         OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_GETPROVIDERL, "CThumbnailServer::GetProviderL -- loading complete" );

   843         CleanupStack::PushL( res );

   844         iProviders.InsertL( aImplUid.iUid, res );

   845         CleanupStack::Pop( res );

   846         }

   847 

   848     return res;

   849     }

   850 

   851 

   852 // -----------------------------------------------------------------------------

   853 // CThumbnailServer::PreLoadProviders()

   854 // -----------------------------------------------------------------------------

   855 //

   856 void CThumbnailServer::PreLoadProviders(  )

   857     {

   858     TN_DEBUG1( "CThumbnailServer::PreLoadProvidersL()" );

   859     OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_PRELOADPROVIDERS, "CThumbnailServer::PreLoadProviders" );

   860     TInt err(KErrNone);

   861     

   862     for(TInt i=0; i< iPluginInfoArray.Count(); i++)

   863         {

   864         TRAP(err, GetProviderL( iPluginInfoArray[i]->ImplementationUid()));

   865         }

   866     }

   867 

   868 

   869 // -----------------------------------------------------------------------------

   870 // CThumbnailServer::QueueTaskL()

   871 // Adds thumbnailtask to processor queue.

   872 // -----------------------------------------------------------------------------

   873 //

   874 void CThumbnailServer::QueueTaskL( CThumbnailTask* aTask )

   875     {

   876     __ASSERT_DEBUG(( aTask ), ThumbnailPanic( EThumbnailNullPointer ));

   877     iProcessor->AddTaskL( aTask );

   878     }

   879 

   880 

   881 // -----------------------------------------------------------------------------

   882 // CThumbnailServer::DequeTask()

   883 // Removes thumbnailtask from processor queue.

   884 // -----------------------------------------------------------------------------

   885 //

   886 TInt CThumbnailServer::DequeTask( const TThumbnailServerRequestId& aRequestId )

   887     {   

   888     TInt error = iProcessor->RemoveTask( aRequestId );

   889         

   890     // clean-up bitmap pool               

   891     THashMapIter < TInt, TThumbnailBitmapRef > bpiter( iBitmapPool );

   892 

   893     // const pointer to a non-const object

   894     const TThumbnailBitmapRef* ref = bpiter.NextValue();

   895 

   896     while ( ref )

   897         {       

   898         TN_DEBUG2( "CThumbnailServer::DequeTask() - ref->iRequestId = %d", ref->iRequestId );

   899         OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_DEQUETASK, "CThumbnailServer::DequeTask;ref->iRequestId=%u", ref->iRequestId );

   900 

   901         if ( ref->iSession == aRequestId.iSession && 

   902              ref->iRequestId == aRequestId.iRequestId )

   903             {            

   904             delete ref->iBitmap;

   905             bpiter.RemoveCurrent();                        

   906                         

   907             TN_DEBUG2( "CThumbnailServer::DequeTask() - deleted bitmap, left=%d", 

   908                     iBitmapPool.Count());

   909             OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_DEQUETASK, "CThumbnailServer::DequeTask;iBitmapPool.Count()=%d", iBitmapPool.Count() );

   910             }

   911         

   912         ref = bpiter.NextValue();        

   913         }

   914 

   915     return error;

   916     }

   917 

   918 

   919 // -----------------------------------------------------------------------------

   920 // CThumbnailServer::ChangeTaskPriority()

   921 // Changes priority of specific task.

   922 // -----------------------------------------------------------------------------

   923 //

   924 TInt CThumbnailServer::ChangeTaskPriority( const TThumbnailServerRequestId&

   925     aRequestId, TInt aNewPriority )

   926     {

   927     return iProcessor->ChangeTaskPriority( aRequestId, aNewPriority );

   928     }

   929 

   930 

   931 // -----------------------------------------------------------------------------

   932 // CThumbnailServer::ScaleBitmapL()

   933 // Used to scale image.

   934 // -----------------------------------------------------------------------------

   935 //

   936 void CThumbnailServer::ScaleBitmapL( TRequestStatus& aStatus, const CFbsBitmap&

   937     aSource, CFbsBitmap& aDest, const TRect& aSourceRect )

   938     {

   939     if ( !iScaler )

   940         {

   941         iScaler = IHLScaler::CreateL();

   942         }

   943     TRect destRect( TPoint(), aDest.SizeInPixels());

   944     User::LeaveIfError( iScaler->Scale( aStatus, aSource, aSourceRect, aDest,

   945         destRect ));

   946     }

   947 

   948 

   949 // -----------------------------------------------------------------------------

   950 // CThumbnailServer::CancelScale()

   951 // Cancels scaling task.

   952 // -----------------------------------------------------------------------------

   953 //

   954 void CThumbnailServer::CancelScale()

   955     {

   956     if ( iScaler )

   957         {

   958         iScaler->CancelProcess();

   959         }

   960     }

   961 

   962 

   963 // -----------------------------------------------------------------------------

   964 // CThumbnailServer::Processor()

   965 // Returns processor.

   966 // -----------------------------------------------------------------------------

   967 //

   968 CThumbnailTaskProcessor& CThumbnailServer::Processor()

   969     {

   970     __ASSERT_DEBUG(( iProcessor ), ThumbnailPanic( EThumbnailNullPointer ));

   971     return * iProcessor;

   972     }

   973 

   974 // -----------------------------------------------------------------------------

   975 // Get the thumbnail store instance, which is responsible for this drive

   976 // -----------------------------------------------------------------------------

   977 //

   978 CThumbnailStore* CThumbnailServer::StoreForDriveL( const TInt aDrive )

   979     {

   980     TN_DEBUG2( "CThumbnailServer::StoreForDriveL() drive=%d", aDrive );

   981     OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_STOREFORDRIVEL, "CThumbnailServer::StoreForDriveL;aDrive=%d", aDrive );

   982     

   983     if(iUnmountedDrives.Find( aDrive ) >= KErrNone)

   984         {

   985         TN_DEBUG1( "CThumbnailServer::StoreForDriveL() unmount in progress, skip!");

   986         OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSERVER_STOREFORDRIVEL, "CThumbnailServer::StoreForDriveL - unmount in progress, skip!" );

   987         User::Leave( KErrDisMounted );

   988         }

   989     

   990     CThumbnailStore** resPtr = iStores.Find( aDrive );

   991     CThumbnailStore* res = NULL;

   992 

   993     if ( resPtr )

   994         {

   995         res = * resPtr;

   996         }

   997     else

   998         {

   999         if( iFormatting )

  1000            {

  1001            TN_DEBUG1( "CThumbnailServer::StoreForDriveL() - FORMATTING! - ABORT");

  1002            OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSERVER_STOREFORDRIVEL, "CThumbnailServer::StoreForDriveL - FORMATTING! - ABORT" );

  1003            User::Leave( KErrNotSupported );

  1004            } 

  1005         

  1006         TVolumeInfo volumeInfo;

  1007         TInt err = iFs.Volume( volumeInfo, aDrive );

  1008         

  1009         if ( err )

  1010             {

  1011             // Locked

  1012             TN_DEBUG2( "CThumbnailServer::StoreForDriveL() - err %d", err);

  1013             OstTrace1( TRACE_NORMAL, DUP3_CTHUMBNAILSERVER_STOREFORDRIVEL, "CThumbnailServer::StoreForDriveL;err=%d", err );

  1014             User::Leave( err);

  1015             }

  1016         else if( volumeInfo.iDrive.iMediaAtt& KMediaAttLocked )

  1017             {

  1018             TN_DEBUG1( "CThumbnailServer::StoreForDriveL() - locked");

  1019             OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSERVER_STOREFORDRIVEL, "CThumbnailServer::StoreForDriveL - locked" );

  1020             User::Leave( KErrAccessDenied );

  1021             }

  1022 		else if ( volumeInfo.iDrive.iDriveAtt& KDriveAttRom ||

  1023             volumeInfo.iDrive.iDriveAtt& KDriveAttRemote ||

  1024             volumeInfo.iDrive.iMediaAtt& KMediaAttWriteProtected )

  1025             {

  1026             // We support ROM disks and remote disks in read only mode.

  1027             TN_DEBUG1( "CThumbnailServer::StoreForDriveL() - rom/remote/write protected");

  1028             OstTrace0( TRACE_NORMAL, DUP5_CTHUMBNAILSERVER_STOREFORDRIVEL, "CThumbnailServer::StoreForDriveL - rom/remote/write protected" );

  1029             res = CThumbnailStore::NewL( iFs, aDrive, iImei, this, ETrue );

  1030             }

  1031         else

  1032             {

  1033             TN_DEBUG1( "CThumbnailServer::StoreForDriveL() - normal");

  1034             OstTrace0( TRACE_NORMAL, DUP6_CTHUMBNAILSERVER_STOREFORDRIVEL, "CThumbnailServer::StoreForDriveL - normal" );

  1035             res = CThumbnailStore::NewL( iFs, aDrive, iImei, this, EFalse );

  1036             }

  1037 			

  1038         CleanupStack::PushL( res );

  1039         iStores.InsertL( aDrive, res );

  1040         res->SetPersistentSizes(iPersistentSizes);

  1041         CleanupStack::Pop( res );

  1042         

  1043         for(TInt i = 0; i < iUnmountObservers.Count(); i++)

  1044             {

  1045             iUnmountObservers[i]->StartNotify();

  1046             }

  1047         }

  1048 

  1049     return res;

  1050     }

  1051 

  1052 // -----------------------------------------------------------------------------

  1053 // Get the thumbnail store instance, which is responsible for the drive

  1054 // identified by given path

  1055 // -----------------------------------------------------------------------------

  1056 //

  1057 CThumbnailStore* CThumbnailServer::StoreForPathL( const TDesC& aPath )

  1058     {

  1059     if(aPath.Length() < 3 || aPath.Length() > KMaxPath)

  1060         {

  1061         TN_DEBUG1( "CThumbnailServer::StoreForPathL() - KErrArgument");

  1062         OstTrace0( TRACE_NORMAL, CTHUMBNAILSERVER_STOREFORPATHL, "CThumbnailServer::StoreForPathL - KErrArgument" );

  1063         User::Leave(KErrArgument);

  1064         }

  1065     TInt drive = 0;

  1066     User::LeaveIfError( RFs::CharToDrive( aPath[0], drive ));

  1067     return StoreForDriveL( drive );

  1068     }

  1069 

  1070 

  1071 // ---------------------------------------------------------------------------

  1072 // CThumbnailStore::PersistentSizeL()

  1073 // ---------------------------------------------------------------------------

  1074 //

  1075 TThumbnailPersistentSize & CThumbnailServer::PersistentSizeL( TThumbnailSize aThumbnailSize )

  1076     {

  1077     if ( !iCenrep )

  1078        {

  1079        iCenrep = CThumbnailCenRep::NewL();

  1080        }

  1081     

  1082     return iCenrep->PersistentSizeL( aThumbnailSize ); 

  1083     }

  1084 

  1085 // -----------------------------------------------------------------------------

  1086 // Open store for each mounted drive

  1087 // -----------------------------------------------------------------------------

  1088 //

  1089 void CThumbnailServer::OpenStoresL()

  1090     {      

  1091     // get list of mounted drives and open stores

  1092     TDriveList driveListInt;

  1093     TInt driveCountInt(0);

  1094     User::LeaveIfError(DriveInfo::GetUserVisibleDrives(

  1095            iFs, driveListInt, driveCountInt, KDriveAttInternal | KDriveAttRemovable ));

  1096 

  1097     for( TInt i = EDriveA; i <= EDriveZ && driveCountInt; i++ )

  1098         {

  1099         if (driveListInt[i])

  1100             {

  1101             TVolumeInfo volumeInfo;

  1102             TInt err = iFs.Volume( volumeInfo, i );

  1103             

  1104             if (!err)

  1105                 {

  1106                 TN_DEBUG2( "CThumbnailServer::OpenStoresL() StoreForDriveL %d", i);

  1107                 OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_OPENSTORESL, "CThumbnailServer::OpenStoresL;i=%d", i );

  1108                 

  1109                 // ignore errors

  1110                 TRAP_IGNORE( StoreForDriveL( i ));

  1111                 

  1112                 driveCountInt--;

  1113                 }

  1114             }            

  1115         }

  1116     

  1117     }

  1118 

  1119 // -----------------------------------------------------------------------------

  1120 // Close the thumbnail store instance, which is responsible for this drive

  1121 // -----------------------------------------------------------------------------

  1122 //

  1123 void CThumbnailServer::CloseStoreForDriveL( const TInt aDrive )

  1124     {

  1125     TN_DEBUG2( "CThumbnailServer::CloseStoreForDriveL drive=%d", aDrive);

  1126     OstTrace1( TRACE_NORMAL, CTHUMBNAILSERVER_CLOSESTOREFORDRIVEL, "CThumbnailServer::CloseStoreForDriveL;aDrive=%d", aDrive );

  1127     CThumbnailStore** store = iStores.Find( aDrive );

  1128     

  1129     StartUnmountTimeout( aDrive);

  1130     

  1131     if (store)

  1132         {

  1133         delete *store;

  1134         *store = NULL;

  1135         iStores.Remove( aDrive );