# HG changeset patch # User Dremov Kirill (Nokia-D-MSW/Tampere) # Date 1277307228 -10800 # Node ID 4bdfb6b5c9b43d9cc24f8992a2296e628d2de9c5 # Parent cb86b71cae0a1f080daa8662dfc4b49682602df7 Revision: 201023 Kit: 2010125 diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlinglib/Group/IHL.mmp --- a/imagehandlinglib/Group/IHL.mmp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlinglib/Group/IHL.mmp Wed Jun 23 18:33:48 2010 +0300 @@ -49,7 +49,7 @@ // Default system include paths for middleware layer modules. MW_LAYER_SYSTEMINCLUDE -SYSTEMINCLUDE /epoc32/include/icl // Needs to be removed after ICL has made SF structural changes. +SYSTEMINCLUDE /epoc32/include/icl LIBRARY euser.lib diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/conf/102830B0.txt Binary file imagehandlingutilities/thumbnailmanager/conf/102830B0.txt has changed diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/conf/thumbnailmanager.confml Binary file imagehandlingutilities/thumbnailmanager/conf/thumbnailmanager.confml has changed diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/inc/thumbnailmanagerconstants.h --- a/imagehandlingutilities/thumbnailmanager/inc/thumbnailmanagerconstants.h Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/inc/thumbnailmanagerconstants.h Wed Jun 23 18:33:48 2010 +0300 @@ -22,7 +22,7 @@ #include #include #include - +#include #include #include "thumbnailmanager.h" // TThumbnailFlags @@ -64,15 +64,22 @@ //how many items daemon will query at once from MDS const TUint KMaxQueryItems = 100; // max items for PH & AllItems query -const TUint KMaxQueryItems2 = 100; +const TUint KMaxQueryBatchSize = 100; // maximum number of active client side queue requests const TUint KMaxClientRequests = 2; +#ifdef __RETRY_ON_SERVERCRASH +// maximum number of request retry +const TUint KMaxRequestRetryCount = 2; +#endif + // maximum number of active daemon requests const TUint KMaxDaemonRequests = 2; -const TUint KMdEReconnect = 100000; //100 ms +const TUint KMdEReconnect = 1*1000*1000; //1 second + +const TUint KUnmountTimerTimeout = 5*1000*1000; //5 seconds const TUint KClientRequestTimeout = 60000000; //60 sec const TUint KClientRequestStartErrorTimeout = 100000; //100 ms @@ -83,9 +90,12 @@ const TInt KThumbnailErrThumbnailNotFound = -62000; -//give MDS 1000 msec time to settle before starting generating TNs +//give MDS some to settle before starting generating TNs const TInt KHarvestingCompleteTimeout = 10000000; //10 sec +//after MMC mount wait while before count is calculated +const TInt KMountTimeout = 5*1000*1000; //5 sec + const TInt KPSKeyTimeout = 10000000; //10 sec //Store's auto flush timeout const TInt KAutoFlushTimeout = 65; //65 sec @@ -487,75 +497,6 @@ EThumbnailFormatJpeg }; -struct TThumbnailDatabaseData - { -public: - /** - * Full path to object to which the imported thumb is to be linked. - */ - TPath iPath; - /** - * Thumbnail ID - */ - TInt iTnId; - /** - * Requested thumbnail size new requests. - */ - TInt iSize; - /** - * type of data - */ - TInt iFormat; - /** - * Path for the thumbnails - */ - TPath iTnPath; - /** - * Data if bitmap - */ - CFbsBitmap* iBlob; - /** - * Data if jpeg - */ - TDesC8* iData; - /** - * Width of thumbnail - */ - TInt iWidth; - /** - * Height of thumbnail - */ - TInt iHeight; - /** - * Original width of thumbnail - */ - TInt iOrigWidth; - /** - * Original height of thumbnail - */ - TInt iOrigHeight; - /** - * flags - */ - TInt iFlags; - /** - * videoposition - */ - TInt iVideoPosition; - /** - * thumb oritentation - */ - TInt iOrientation; - /** - * Thumb created from associated path - */ - TInt iThumbFromPath; - /** - * last modified - */ - TInt64 iModified; - - }; /** * MDS query modes used during thumbnail generation diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/plugins/audio/src/thumbnailaudioprovider.cpp --- a/imagehandlingutilities/thumbnailmanager/plugins/audio/src/thumbnailaudioprovider.cpp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/plugins/audio/src/thumbnailaudioprovider.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -95,6 +95,8 @@ TPtrC8 ptr = metaCont.Field8( EMetaDataJpeg ); HBufC8* data = ptr.AllocL(); + CleanupStack::PopAndDestroy(&wantedFields); + CleanupStack::PopAndDestroy(metaDataUtil); CleanupStack::PushL( data ); if(data->Length() == 0) @@ -111,12 +113,18 @@ iFlags = aFlags; //set default mode displaymode from global constants iDisplayMode = KStoreDisplayMode; - - iImageDecoderv3->CreateL( data, *iObserver, iFlags, iMimeType, iTargetSize ); - - CleanupStack::Pop( data ); - CleanupStack::PopAndDestroy(&wantedFields); - CleanupStack::PopAndDestroy(metaDataUtil); + TRAPD( err, iImageDecoderv3->CreateL( data, *iObserver, iFlags, iMimeType, iTargetSize ) ); + if (err == KErrNone) + { + CleanupStack::Pop( data ); + } + else + { + // this is because data buffer is already released in CreateDecoderL + // and we must prevent automatic PopAndDestroy + CleanupStack::Pop( data ); + User::Leave(err); + } iOriginalSize = iImageDecoderv3->OriginalSize(); iImageDecoderv3->DecodeL( iDisplayMode ); diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/plugins/audio/src/thumbnailimagedecoderv3.cpp --- a/imagehandlingutilities/thumbnailmanager/plugins/audio/src/thumbnailimagedecoderv3.cpp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/plugins/audio/src/thumbnailimagedecoderv3.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -137,8 +137,7 @@ TInt err = iBitmap->Create( loadSize, aDisplayMode ); if (err != KErrNone) { - delete iBitmap; - iBitmap = NULL; + Release(); User::Leave(err); } @@ -240,9 +239,7 @@ TRAPD( decErr, iDecoder = CImageDecoder::DataNewL( iFs, *iBuffer, options ) ); if ( decErr != KErrNone ) { - delete iBuffer; - iBuffer = NULL; - + Release(); TN_DEBUG2( "CThumbnailImageDecoderv3::CreateDecoderL() - CImageDecoder error %d", decErr ); User::Leave( decErr ); @@ -282,6 +279,7 @@ //no sense to try other codecs if image is corrupted if( aError == KErrCorrupt || aError == KErrUnderflow) { + Release(); User::Leave( aError ); } } diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbagdaemon/group/thumbagdaemon.mmp --- a/imagehandlingutilities/thumbnailmanager/thumbagdaemon/group/thumbagdaemon.mmp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/thumbagdaemon/group/thumbagdaemon.mmp Wed Jun 23 18:33:48 2010 +0300 @@ -49,6 +49,12 @@ SOURCE tmformatobserver.cpp SOURCE tmsrproptertyobserver.cpp +SOURCEPATH ../src +SOURCE thumbagimageobserver.cpp +SOURCE thumbagcameraobserver.cpp +SOURCE thumbagaudioobserver.cpp +SOURCE thumbagvideoobserver.cpp + // Default system include paths for middleware layer modules. MW_LAYER_SYSTEMINCLUDE diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbagdaemon/inc/thumbagaudioobserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/imagehandlingutilities/thumbnailmanager/thumbagdaemon/inc/thumbagaudioobserver.h Wed Jun 23 18:33:48 2010 +0300 @@ -0,0 +1,148 @@ +/* +* Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Thumbnail Auto Generate Daemon + * +*/ + + +#ifndef THUMBAGAUDIOOBSERVER_H +#define THUMBAGAUDIOOBSERVER_H + +#include +#include + +#include + +#include "thumbagprocessor.h" +#include "tmshutdownobserver.h" +#include "thumbnaillog.h" + + +/** + * ThumbAG daemon. + * + * @since S60 v5.0 + */ +NONSHARABLE_CLASS( CThumbAGAudioObserver ): public CBase, + public MMdESessionObserver, + public MMdEObjectObserver, + public MTMShutdownObserver + { +public: + + /** + * Two-phased constructor + * + * @since S60 v5.0 + * @return New CThumbAGAudioObserver server. + */ + static CThumbAGAudioObserver* NewLC(CThumbAGProcessor* aProcessor); + + /** + * Two-phased constructor + * + * @since S60 v5.0 + * @return New CThumbAGAudioObserver server. + */ + static CThumbAGAudioObserver* NewL(CThumbAGProcessor* aProcessor); + + /** + * Destructor + * + * @since S60 v5.0 + */ + virtual ~CThumbAGAudioObserver(); + + +public: + + // from MMdESessionObserver + void HandleSessionOpened( CMdESession& aSession, TInt aError ); + void HandleSessionError( CMdESession& aSession, TInt aError ); + + // from MMdEObjectObserver + void HandleObjectNotification(CMdESession& aSession, + TObserverNotificationType aType, + const RArray& aObjectIdArray); + + // from MTMShutdownObserver + void ShutdownNotification(); + +protected: + + /** + * AddObserversL + * + * @since S60 v5.0 + */ + void AddObserversL(); + + +private: + + /** + * C++ default constructor + * + * @since S60 v5.0 + * @return New CThumbAGAudioObserver instance. + */ + CThumbAGAudioObserver(CThumbAGProcessor* aProcessor); + + /** + * Symbian 2nd phase constructor can leave. + * + * @since S60 v5.0 + */ + void ConstructL(); + + /** + * Initilization helper + * + * @since S60 v5.2 + */ + void InitializeL(); + + /** + * Callback for reconnect timer + * + * @since S60 v5.0 + */ + static TInt ReconnectCallBack(TAny* aAny); + + void Shutdown(); + +private: + + // own + CTMShutdownObserver* iShutdownObserver; + CTMShutdownObserver* iMDSShutdownObserver; + CMdESession* iMdESession; + + //not owned + CThumbAGProcessor* iProcessor; + + TBool iShutdown; + + // reconnect timer + CPeriodic* iReconnect; + + TBool iSessionError; + +#ifdef _DEBUG + TUint32 iAddCounter; + TUint32 iModCounter; +#endif +}; + +#endif // THUMBAGDAEMON_H diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbagdaemon/inc/thumbagcameraobserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/imagehandlingutilities/thumbnailmanager/thumbagdaemon/inc/thumbagcameraobserver.h Wed Jun 23 18:33:48 2010 +0300 @@ -0,0 +1,145 @@ +/* +* Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Thumbnail Auto Generate Daemon + * +*/ + + +#ifndef THUMBAGCAMERAOBSERVER_H +#define THUMBAGCAMERAOBSERVER_H + +#include +#include + +#include + +#include "thumbagprocessor.h" +#include "tmshutdownobserver.h" +#include "thumbnaillog.h" + + +/** + * ThumbAG daemon. + * + * @since S60 v5.0 + */ +NONSHARABLE_CLASS( CThumbAGCameraObserver ): public CBase, + public MMdESessionObserver, + public MMdEObjectObserver, + public MTMShutdownObserver + { +public: + + /** + * Two-phased constructor + * + * @since S60 v5.0 + * @return New CThumbAGCameraObserver server. + */ + static CThumbAGCameraObserver* NewLC(CThumbAGProcessor* aProcessor); + + /** + * Two-phased constructor + * + * @since S60 v5.0 + * @return New CThumbAGCameraObserver server. + */ + static CThumbAGCameraObserver* NewL(CThumbAGProcessor* aProcessor); + + /** + * Destructor + * + * @since S60 v5.0 + */ + virtual ~CThumbAGCameraObserver(); + + +public: + + // from MMdESessionObserver + void HandleSessionOpened( CMdESession& aSession, TInt aError ); + void HandleSessionError( CMdESession& aSession, TInt aError ); + + // from MMdEObjectObserver + void HandleObjectNotification(CMdESession& aSession, + TObserverNotificationType aType, + const RArray& aObjectIdArray); + + // from MTMShutdownObserver + void ShutdownNotification(); + +protected: + + /** + * AddObserversL + * + * @since S60 v5.0 + */ + void AddObserversL(); + + +private: + + /** + * C++ default constructor + * + * @since S60 v5.0 + * @return New CThumbAGCameraObserver instance. + */ + CThumbAGCameraObserver(CThumbAGProcessor* aProcessor); + + /** + * Symbian 2nd phase constructor can leave. + * + * @since S60 v5.0 + */ + void ConstructL(); + + /** + * Initilization helper + * + * @since S60 v5.2 + */ + void InitializeL(); + + /** + * Callback for reconnect timer + * + * @since S60 v5.0 + */ + static TInt ReconnectCallBack(TAny* aAny); + +private: + + // own + CTMShutdownObserver* iShutdownObserver; + CTMShutdownObserver* iMDSShutdownObserver; + CMdESession* iMdESession; + //not owned + CThumbAGProcessor* iProcessor; + + TBool iShutdown; + + // reconnect timer + CPeriodic* iReconnect; + + TBool iSessionError; + +#ifdef _DEBUG + TUint32 iAddCounter; + TUint32 iModCounter; +#endif +}; + +#endif // THUMBAGDAEMON_H diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbagdaemon/inc/thumbagdaemon.h --- a/imagehandlingutilities/thumbnailmanager/thumbagdaemon/inc/thumbagdaemon.h Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/thumbagdaemon/inc/thumbagdaemon.h Wed Jun 23 18:33:48 2010 +0300 @@ -27,6 +27,10 @@ #include "thumbagprocessor.h" #include "tmshutdownobserver.h" #include "thumbnaillog.h" +#include "thumbagimageobserver.h" +#include "thumbagcameraobserver.h" +#include "thumbagaudioobserver.h" +#include "thumbagvideoobserver.h" /** @@ -177,9 +181,14 @@ #ifdef _DEBUG TUint32 iAddCounter; - TUint32 iModCounter; TUint32 iDelCounter; #endif + + //observers + CThumbAGImageObserver* iImageObserver; + CThumbAGCameraObserver* iCameraObserver; + CThumbAGAudioObserver* iAudioObserver; + CThumbAGVideoObserver* iVideoObserver; }; #endif // THUMBAGDAEMON_H diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbagdaemon/inc/thumbagimageobserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/imagehandlingutilities/thumbnailmanager/thumbagdaemon/inc/thumbagimageobserver.h Wed Jun 23 18:33:48 2010 +0300 @@ -0,0 +1,144 @@ +/* +* Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Thumbnail Auto Generate Daemon + * +*/ + + +#ifndef THUMBAGIMAGEOBSERVER_H +#define THUMBAGIMAGEOBSERVER_H + +#include +#include + +#include + +#include "thumbagprocessor.h" +#include "thumbnaillog.h" +#include "tmshutdownobserver.h" + +/** + * ThumbAG daemon. + * + * @since S60 v5.0 + */ +NONSHARABLE_CLASS( CThumbAGImageObserver ): public CBase, + public MMdESessionObserver, + public MMdEObjectObserver, + public MTMShutdownObserver + { +public: + + /** + * Two-phased constructor + * + * @since S60 v5.0 + * @return New CThumbAGImageObserver server. + */ + static CThumbAGImageObserver* NewLC(CThumbAGProcessor* aProcessor); + + /** + * Two-phased constructor + * + * @since S60 v5.0 + * @return New CThumbAGImageObserver server. + */ + static CThumbAGImageObserver* NewL(CThumbAGProcessor* aProcessor); + + /** + * Destructor + * + * @since S60 v5.0 + */ + virtual ~CThumbAGImageObserver(); + + +public: + + // from MMdESessionObserver + void HandleSessionOpened( CMdESession& aSession, TInt aError ); + void HandleSessionError( CMdESession& aSession, TInt aError ); + + // from MMdEObjectObserver + void HandleObjectNotification(CMdESession& aSession, + TObserverNotificationType aType, + const RArray& aObjectIdArray); + + // from MTMShutdownObserver + void ShutdownNotification(); + +protected: + + /** + * AddObserversL + * + * @since S60 v5.0 + */ + void AddObserversL(); + + +private: + + /** + * C++ default constructor + * + * @since S60 v5.0 + * @return New CThumbAGImageObserver instance. + */ + CThumbAGImageObserver(CThumbAGProcessor* aProcessor); + + /** + * Symbian 2nd phase constructor can leave. + * + * @since S60 v5.0 + */ + void ConstructL(); + + /** + * Initilization helper + * + * @since S60 v5.2 + */ + void InitializeL(); + + /** + * Callback for reconnect timer + * + * @since S60 v5.0 + */ + static TInt ReconnectCallBack(TAny* aAny); + +private: + + // own + CTMShutdownObserver* iShutdownObserver; + CTMShutdownObserver* iMDSShutdownObserver; + CMdESession* iMdESession; + //not owned + CThumbAGProcessor* iProcessor; + + TBool iShutdown; + + // reconnect timer + CPeriodic* iReconnect; + + TBool iSessionError; + +#ifdef _DEBUG + TUint32 iAddCounter; + TUint32 iModCounter; +#endif +}; + +#endif // THUMBAGDAEMON_H diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbagdaemon/inc/thumbagprocessor.h --- a/imagehandlingutilities/thumbnailmanager/thumbagdaemon/inc/thumbagprocessor.h Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/thumbagdaemon/inc/thumbagprocessor.h Wed Jun 23 18:33:48 2010 +0300 @@ -32,10 +32,46 @@ #include "tmactivitymanager.h" #include "tmformatobserver.h" #include "tmrpropertyobserver.h" +#include "thumbnailmanagerconstants.h" //FORWARD DECLARATIONS class MMPXCollectionUtility; + +enum TThumbnailGenerationItemType + { + EGenerationItemTypeUnknown, + EGenerationItemTypeNotFound, + EGenerationItemTypeCamera, + EGenerationItemTypeAny, + EGenerationItemTypeAudio, + EGenerationItemTypeVideo, + EGenerationItemTypeImage, + EGenerationItemTypeItemCount + }; + + enum TThumbnailGenerationItemAction + { + EGenerationItemActionAdd, + EGenerationItemActionDelete, + EGenerationItemActionModify, + EGenerationItemAction2ndAdd, + EGenerationItemActionResolveType, + EGenerationItemActionCount + }; + + struct TThumbnailGenerationItem + { + inline TThumbnailGenerationItem(): iItemId( KErrNotFound ), iItemType(EGenerationItemTypeUnknown), iItemAction(EGenerationItemActionAdd), iPlaceholder(EFalse), iUri(NULL){} + inline ~TThumbnailGenerationItem(){delete iUri; iUri = NULL;} + + TItemId iItemId; + TThumbnailGenerationItemType iItemType; + TThumbnailGenerationItemAction iItemAction; + TBool iPlaceholder; + HBufC* iUri; + }; + /** * Processor object for handling thumb generation * @@ -119,17 +155,18 @@ * @since S60 v5.0 * @param aMdESession MdE Session */ - void SetMdESession( CMdESession* aMdESession ); + void SetMdESessionL( CMdESession* aMdESession ); /** * Adds new IDs to queue * * @since S60 v5.0 * @param aType TObserverNotificationType + * @param TThumbnailGenerationItemType * @param aIDArray IDs for thumbnail creation * @param aForce pass ETrue if processor is forced to run without waiting harvesting complete */ - void AddToQueueL( TObserverNotificationType aType, const RArray& aIDArray, const RPointerArray& aObjectUriArray, TBool aPresent ); + void AddToQueueL( TObserverNotificationType aType, TThumbnailGenerationItemType aItemType, const RArray& aIDArray, const RPointerArray& aObjectUriArray, TBool aPresent ); /** * Calls Thumbnail Manager to create thumbnails @@ -148,6 +185,9 @@ void RemoveFromQueues( const RArray& aIDArray, const TBool aRemoveFromDelete = EFalse); void SetForceRun( const TBool aForceRun ); + + //prepare processor for shutdown + void Shutdown(); protected: @@ -157,9 +197,9 @@ * QueryL * * @since S60 v5.0 - * @param aIDArray Item IDs to query + * @param TThumbnailGenerationItemAction */ - void QueryL( RArray& aIDArray ); + void QueryL( TThumbnailGenerationItemAction aType); /** * QueryPlaceholdersL @@ -257,14 +297,58 @@ * @since S60 v5.0 * @param aDefine (re)define PS key before setting value */ - void UpdatePSValues(const TBool aDefine = EFalse); + void UpdatePSValues(const TBool aDefine, const TBool aForce); /** * Comparison function for logaritmic use of queue arrays * + * @since S60 S^3 + */ + static TInt Compare(const TThumbnailGenerationItem& aLeft, const TThumbnailGenerationItem& aRight); + + /** + * Comparison function for logaritmic use of queue arrays + * + * @since S60 S^3 + */ + static TInt CompareId(const TItemId& aLeft, const TItemId& aRight); + + /** + * Recalculate item counts + * + * @since S60 S^3 + */ + void UpdateItemCounts(); + + /** + * Callback for mount timeout + * * @since S60 v5.0 */ - static TInt Compare(const TItemId& aLeft, const TItemId& aRight); + static TInt MountTimerCallBack(TAny* aAny); + + /** + * Set item's action from type + * + * @since S^3 + */ + void SetGenerationItemAction( TThumbnailGenerationItem& aGenerationItem, const TThumbnailGenerationItemType aItemType ); + + /** + * Set item type property from TDedIf + * @param aGenerationItem TThumbnailGenerationItem + * @param aItemType TThumbnailGenerationItemType + * @since S^3 + */ + void SetGenerationItemType( TThumbnailGenerationItem& aGenerationItem, const TDefId aDefId ); + + /** + * Append item to processing queue or update existing + * @param aGenerationItem modified TThumbnailGenerationItem + * @param aDefId items MDS object definition ID + * @since S^3 + */ + void AppendProcessingQueue(TThumbnailGenerationItem& item ); private: @@ -278,20 +362,19 @@ CMdEObjectQuery* iQueryAllItems; CMdEObjectQuery* iQueryPlaceholders; - RArray iAddQueue; - RArray iModifyQueue; - RPointerArray iRemoveQueue; + RArray iGenerationQueue; + //RPointerArray iRemoveQueue; RArray iQueryQueue; - RArray iPlaceholderQueue; - //not processing queue, used to keep KItemsLeft PS correct - RArray i2ndRoundGenerateQueue; - //reference to current processing queue - RArray* iLastQueue; //background generation state // EFalse = 1st round, create only grid size thumbnail for images and videos // ETrue = 2nds round, create all missing sizes for all media items TBool i2ndRound; + + // query state + // EFalse = normal mode + // ETrue = querying unknown items + TBool iUnknown; //MDS query issues TBool iQueryActive; @@ -300,7 +383,7 @@ //Processing MDS itens which are modified TBool iModify; - TInt iProcessingCount; + TUint iProcessingCount; //MDS harvester's overall state TBool iHarvesting; @@ -315,6 +398,7 @@ TBool iMMCHarvestingTemp; CPeriodic* iPeriodicTimer; + CPeriodic* iMountTimer; //MDS Harvester client RHarvesterClient iHarvesterClient; @@ -325,7 +409,7 @@ //2nd phase init after MDE session is open TBool iInit2; - // auto create + // auto create values from centrep TBool iAutoImage; TBool iAutoVideo; TBool iAutoAudio; @@ -335,14 +419,16 @@ // controlled by Photos application to run TN generation on foreground TBool iForegroundRun; //request pending in TNM side - TBool iActive; CTMFormatObserver* iFormatObserver; + //formating started TBool iFormatting; + //TNM server session died TBool iSessionDied; - TInt iActiveCount; + //pending request count + TUint iActiveCount; MMPXCollectionUtility* iCollectionUtility; // own @@ -352,6 +438,7 @@ //overall status of device TBool iIdle; + //monitors device activity CTMActivityManager* iActivityManager; //Observer foreground generation @@ -362,6 +449,30 @@ TBool iPreviousDaemonProcessing; //set ETrue when QueryAllItems needs to be run after placeholder query TBool iDoQueryAllItems; -}; + + TBool iShutdown; + + //item counts + TUint32 iModifyItemCount; + TUint32 iImageItemCount; + TUint32 iVideoItemCount; + TUint32 iAudioItemCount; + TUint32 iDeleteItemCount; + TUint32 iAddItemCount; + TUint32 iCameraItemCount; + TUint32 iUnknownItemCount; + TUint32 i2ndAddItemCount; + TUint32 iPlaceholderItemCount; + + //for book keeping previous items left count got from MDS harvester + TUint32 iMMCHarvestingItemsLeftTemp; + TUint32 iPHHarvestingItemsLeftTemp; + + //MdE object definitons used in query + CMdEObjectDef* iImageObjectDef; + CMdEObjectDef* iVideoObjectDef; + CMdEObjectDef* iAudioObjectDef; + TBool iHarvesterActivated; + }; #endif // THUMBAGPROCESSOR_H diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbagdaemon/inc/thumbagvideoobserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/imagehandlingutilities/thumbnailmanager/thumbagdaemon/inc/thumbagvideoobserver.h Wed Jun 23 18:33:48 2010 +0300 @@ -0,0 +1,145 @@ +/* +* Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Thumbnail Auto Generate Daemon + * +*/ + + +#ifndef THUMBAGVIDEOBSERVER_H +#define THUMBAGVIDEOBSERVER_H + +#include +#include + +#include + +#include "thumbagprocessor.h" +#include "thumbnaillog.h" +#include "tmshutdownobserver.h" + + +/** + * ThumbAG daemon. + * + * @since S60 v5.0 + */ +NONSHARABLE_CLASS( CThumbAGVideoObserver ): public CBase, + public MMdESessionObserver, + public MMdEObjectObserver, + public MTMShutdownObserver + { +public: + + /** + * Two-phased constructor + * + * @since S60 v5.0 + * @return New CThumbAGVideoObserver server. + */ + static CThumbAGVideoObserver* NewLC(CThumbAGProcessor* aProcessor); + + /** + * Two-phased constructor + * + * @since S60 v5.0 + * @return New CThumbAGVideoObserver server. + */ + static CThumbAGVideoObserver* NewL(CThumbAGProcessor* aProcessor); + + /** + * Destructor + * + * @since S60 v5.0 + */ + virtual ~CThumbAGVideoObserver(); + + +public: + + // from MMdESessionObserver + void HandleSessionOpened( CMdESession& aSession, TInt aError ); + void HandleSessionError( CMdESession& aSession, TInt aError ); + + // from MMdEObjectObserver + void HandleObjectNotification(CMdESession& aSession, + TObserverNotificationType aType, + const RArray& aObjectIdArray); + + // from MTMShutdownObserver + void ShutdownNotification(); + +protected: + + /** + * AddObserversL + * + * @since S60 v5.0 + */ + void AddObserversL(); + + +private: + + /** + * C++ default constructor + * + * @since S60 v5.0 + * @return New CThumbAGVideoObserver instance. + */ + CThumbAGVideoObserver(CThumbAGProcessor* aProcessor); + + /** + * Symbian 2nd phase constructor can leave. + * + * @since S60 v5.0 + */ + void ConstructL(); + + /** + * Initilization helper + * + * @since S60 v5.2 + */ + void InitializeL(); + + /** + * Callback for reconnect timer + * + * @since S60 v5.0 + */ + static TInt ReconnectCallBack(TAny* aAny); + +private: + + // own + CTMShutdownObserver* iShutdownObserver; + CTMShutdownObserver* iMDSShutdownObserver; + CMdESession* iMdESession; + //not owned + CThumbAGProcessor* iProcessor; + + TBool iShutdown; + + // reconnect timer + CPeriodic* iReconnect; + + TBool iSessionError; + +#ifdef _DEBUG + TUint32 iAddCounter; + TUint32 iModCounter; +#endif +}; + +#endif // THUMBAGDAEMON_H diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagaudioobserver.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagaudioobserver.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -0,0 +1,348 @@ +/* +* Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Thumbnail Auto Generate Daemon +* +*/ + + +#include +#include + +#include +#include +#include +#include + +#include "thumbagaudioobserver.h" +#include "thumbnaillog.h" +#include "thumbnailmanagerconstants.h" +#include "thumbnailmanagerprivatecrkeys.h" + + +// --------------------------------------------------------------------------- +// NewLC +// --------------------------------------------------------------------------- +// +CThumbAGAudioObserver* CThumbAGAudioObserver::NewLC(CThumbAGProcessor* aProcessor) + { + TN_DEBUG1( "CThumbAGAudioObserver::NewLC() - begin" ); + + CThumbAGAudioObserver* self = new (ELeave) CThumbAGAudioObserver(aProcessor); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// --------------------------------------------------------------------------- +// NewL +// --------------------------------------------------------------------------- +// +CThumbAGAudioObserver* CThumbAGAudioObserver::NewL(CThumbAGProcessor* aProcessor) + { + TN_DEBUG1( "CThumbAGAudioObserver::NewL() - begin" ); + + CThumbAGAudioObserver* self = CThumbAGAudioObserver::NewLC(aProcessor); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// CThumbAGAudioObserver +// --------------------------------------------------------------------------- +// +CThumbAGAudioObserver::CThumbAGAudioObserver(CThumbAGProcessor* aProcessor) + : iShutdownObserver(NULL), iMDSShutdownObserver(NULL), iMdESession(NULL), iProcessor(aProcessor) + { + // No implementation required + } + +// --------------------------------------------------------------------------- +// ConstructL +// --------------------------------------------------------------------------- +// +void CThumbAGAudioObserver::ConstructL() + { + TN_DEBUG1( "CThumbAGAudioObserver::ConstructL() - begin" ); + +#ifdef _DEBUG + iAddCounter = 0; + iModCounter = 0; +#endif + + InitializeL(); + + TN_DEBUG1( "CThumbAGAudioObserver::ConstructL() - end" ); + } + +// --------------------------------------------------------------------------- +// ~CThumbAGAudioObserver +// --------------------------------------------------------------------------- +// +void CThumbAGAudioObserver::InitializeL() + { + TN_DEBUG1( "CThumbAGAudioObserver::InitializeL() - begin" ); + + + TN_DEBUG1( "CThumbAGAudioObserver::InitializeL() - create observers" ); + + // create shutdown observer + if(iMDSShutdownObserver) + { + delete iMDSShutdownObserver; + iMDSShutdownObserver = NULL; + } + iMDSShutdownObserver = CTMShutdownObserver::NewL( *this, KMdSPSShutdown, KMdSShutdown, EFalse ); + + if(iShutdownObserver) + { + delete iShutdownObserver; + iShutdownObserver = NULL; + } + iShutdownObserver = CTMShutdownObserver::NewL( *this, KTAGDPSNotification, KShutdown, ETrue ); + iShutdown = EFalse; + + // MDS session reconnect timer + if (!iReconnect) + { + iReconnect = CPeriodic::NewL(CActive::EPriorityIdle); + } + + TN_DEBUG1( "CThumbAGAudioObserver::InitializeL() - connect to MDS" ); + + if(iMdESession) + { + TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); + TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); + + // connect to MDS + delete iMdESession; + iMdESession = NULL; + } + + iMdESession = CMdESession::NewL( *this ); + iSessionError = EFalse; + + TN_DEBUG1( "CThumbAGAudioObserver::InitializeL() - end" ); + } + +// --------------------------------------------------------------------------- +// ~CThumbAGAudioObserver +// --------------------------------------------------------------------------- +// +CThumbAGAudioObserver::~CThumbAGAudioObserver() + { + TN_DEBUG1( "CThumbAGAudioObserver::~CThumbAGAudioObserver() - begin" ); + + iShutdown = ETrue; + + Shutdown(); + + TN_DEBUG1( "CThumbAGAudioObserver::~CThumbAGAudioObserver() - end" ); + } + +void CThumbAGAudioObserver::Shutdown() + { + TN_DEBUG1( "CThumbAGAudioObserver::Shutdown()" ); + + delete iMDSShutdownObserver; + iMDSShutdownObserver = NULL; + delete iShutdownObserver; + iShutdownObserver = NULL; + + if(iReconnect) + { + iReconnect->Cancel(); + delete iReconnect; + iReconnect = NULL; + } + + if (iMdESession) + { + // 2 observers + TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); + TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); + + delete iMdESession; + iMdESession = NULL; + } + } + +// ----------------------------------------------------------------------------- +// CThumbAGAudioObserver::HandleSessionOpened +// ----------------------------------------------------------------------------- +// +void CThumbAGAudioObserver::HandleSessionOpened( CMdESession& /* aSession */, TInt aError ) + { + TN_DEBUG1( "CThumbAGAudioObserver::HandleSessionOpened"); + + if (aError == KErrNone) + { + TRAPD( err, AddObserversL() ); + if (err != KErrNone) + { + TN_DEBUG2( "CThumbAGAudioObserver::HandleSessionOpened, AddObserversL error == %d", err ); + } + } + else + { + TN_DEBUG2( "CThumbAGAudioObserver::HandleSessionOpened error == %d", aError ); + } + } + +// ----------------------------------------------------------------------------- +// CThumbAGAudioObserver::HandleSessionError +// ----------------------------------------------------------------------------- +// +void CThumbAGAudioObserver::HandleSessionError( CMdESession& /*aSession*/, TInt aError ) + { + TN_DEBUG2( "CThumbAGAudioObserver::HandleSessionError == %d", aError ); + if (aError != KErrNone && !iSessionError) + { + iSessionError = ETrue; + + if (!iShutdown) + { + if (!iReconnect->IsActive()) + { + iReconnect->Start( KMdEReconnect, KMdEReconnect, + TCallBack(ReconnectCallBack, this)); + + TN_DEBUG1( "CThumbAGAudioObserver::HandleSessionError() - reconnect timer started" ); + } + } + + } + } + +// ----------------------------------------------------------------------------- +// CThumbAGAudioObserver::HandleObjectNotification +// ----------------------------------------------------------------------------- +// +void CThumbAGAudioObserver::HandleObjectNotification( CMdESession& /*aSession*/, + TObserverNotificationType aType, + const RArray& aObjectIdArray ) + { + TN_DEBUG1( "CThumbAGAudioObserver::HandleObjectNotification() - begin" ); + + // no processor or shutting down + if ( iShutdown || !iProcessor) + { + return; + } + +#ifdef _DEBUG + if (aType == ENotifyAdd) + { + TN_DEBUG2( "CThumbAGAudioObserver::HandleObjectNotification() - ENotifyAdd %d", aObjectIdArray.Count() ); + iAddCounter = aObjectIdArray.Count(); + } + else if (aType == ENotifyModify) + { + TN_DEBUG2( "CThumbAGAudioObserver::HandleObjectNotification() - ENotifyModify %d", aObjectIdArray.Count() ); + iModCounter = aObjectIdArray.Count(); + } +#endif + + if ( (aType == ENotifyAdd || aType == ENotifyModify ) && (aObjectIdArray.Count() > 0) ) + { + TN_DEBUG1( "CThumbAGAudioObserver::HandleObjectNotification() - AddToQueueL" ); + + // Add event to processing queue by type and enable force run + RPointerArray dummyArray; + TRAPD(err, iProcessor->AddToQueueL(aType, EGenerationItemTypeAudio, aObjectIdArray, dummyArray, EFalse)); + if (err != KErrNone) + { + TN_DEBUG1( "CThumbAGAudioObserver::HandleObjectNotification() - error adding to queue" ); + } + } + else + { + TN_DEBUG1( "CThumbAGAudioObserver::HandleObjectNotification() - bad notification" ); + } + +#ifdef _DEBUG + TN_DEBUG3( "CThumbAGImageObserver::IN-COUNTERS---------- Add = %d Modify = %d", iAddCounter, iModCounter ); + iModCounter = 0; + iAddCounter = 0; +#endif + + TN_DEBUG1( "CThumbAGAudioObserver::HandleObjectNotification() - end" ); + } + +// ----------------------------------------------------------------------------- +// CThumbAGAudioObserver::ShutdownNotification +// ----------------------------------------------------------------------------- +// +void CThumbAGAudioObserver::ShutdownNotification() + { + TN_DEBUG1( "CThumbAGAudioObserver::ShutdownNotification()" ); + + if (!iShutdown) + { + TN_DEBUG1( "CThumbAGAudioObserver::ShutdownNotification() shutdown" ); + iShutdown = ETrue; + } + } + +// --------------------------------------------------------------------------- +// CThumbAGAudioObserver::AddObserversL +// --------------------------------------------------------------------------- +// +void CThumbAGAudioObserver::AddObserversL() + { + TN_DEBUG1( "CThumbAGAudioObserver::AddObserversL() - begin" ); + + CMdENamespaceDef& defaultNamespace = iMdESession->GetDefaultNamespaceDefL(); + CMdEObjectDef& audioDef = defaultNamespace.GetObjectDefL( MdeConstants::Audio::KAudioObject ); + + // set observing conditions + CMdELogicCondition* addCondition = CMdELogicCondition::NewLC( ELogicConditionOperatorAnd ); + addCondition->AddObjectConditionL( audioDef ); + CleanupStack::Pop( addCondition ); + + CMdELogicCondition* modifyCondition = CMdELogicCondition::NewLC( ELogicConditionOperatorAnd ); + modifyCondition->AddObjectConditionL( audioDef ); + CleanupStack::Pop( modifyCondition ); + + // add observer + iMdESession->AddObjectObserverL( *this, addCondition, ENotifyAdd ); + + // modify observer + iMdESession->AddObjectObserverL( *this, modifyCondition, ENotifyModify ); + + TN_DEBUG1( "CThumbAGAudioObserver::AddObserversL() - end" ); + } + +// --------------------------------------------------------------------------- +// CThumbAGAudioObserver::ReconnectCallBack() +// --------------------------------------------------------------------------- +// +TInt CThumbAGAudioObserver::ReconnectCallBack(TAny* aAny) + { + TN_DEBUG1( "CThumbAGAudioObserver::ReconnectCallBack() - reinitialize"); + + CThumbAGAudioObserver* self = static_cast( aAny ); + + self->iReconnect->Cancel(); + + // reconnect to MDS + TRAP_IGNORE( self->InitializeL() ); + + TN_DEBUG1( "CThumbAGAudioObserver::ReconnectCallBack() - done"); + + return KErrNone; + } + + +// End of file diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagcameraobserver.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagcameraobserver.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -0,0 +1,340 @@ +/* +* Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Thumbnail Auto Generate Daemon +* +*/ + + +#include +#include + +#include +#include +#include +#include + +#include "thumbagcameraobserver.h" +#include "thumbnaillog.h" +#include "thumbnailmanagerconstants.h" +#include "thumbnailmanagerprivatecrkeys.h" + + +// --------------------------------------------------------------------------- +// NewLC +// --------------------------------------------------------------------------- +// +CThumbAGCameraObserver* CThumbAGCameraObserver::NewLC(CThumbAGProcessor* aProcessor) + { + TN_DEBUG1( "CThumbAGCameraObserver::NewLC() - begin" ); + + CThumbAGCameraObserver* self = new (ELeave) CThumbAGCameraObserver(aProcessor); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// --------------------------------------------------------------------------- +// NewL +// --------------------------------------------------------------------------- +// +CThumbAGCameraObserver* CThumbAGCameraObserver::NewL(CThumbAGProcessor* aProcessor) + { + TN_DEBUG1( "CThumbAGCameraObserver::NewL() - begin" ); + + CThumbAGCameraObserver* self = CThumbAGCameraObserver::NewLC(aProcessor); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// CThumbAGCameraObserver +// --------------------------------------------------------------------------- +// +CThumbAGCameraObserver::CThumbAGCameraObserver(CThumbAGProcessor* aProcessor) + : iShutdownObserver(NULL), iMDSShutdownObserver(NULL), iMdESession(NULL), iProcessor(aProcessor) + { + // No implementation required + } + +// --------------------------------------------------------------------------- +// ConstructL +// --------------------------------------------------------------------------- +// +void CThumbAGCameraObserver::ConstructL() + { + TN_DEBUG1( "CThumbAGCameraObserver::ConstructL() - begin" ); + +#ifdef _DEBUG + iAddCounter = 0; + iModCounter = 0; +#endif + + InitializeL(); + + TN_DEBUG1( "CThumbAGCameraObserver::ConstructL() - end" ); + } + +// --------------------------------------------------------------------------- +// ~CThumbAGCameraObserver +// --------------------------------------------------------------------------- +// +void CThumbAGCameraObserver::InitializeL() + { + TN_DEBUG1( "CThumbAGCameraObserver::InitializeL() - begin" ); + + + TN_DEBUG1( "CThumbAGCameraObserver::InitializeL() - create observers" ); + + // create shutdown observer + if(iMDSShutdownObserver) + { + delete iMDSShutdownObserver; + iMDSShutdownObserver = NULL; + } + iMDSShutdownObserver = CTMShutdownObserver::NewL( *this, KMdSPSShutdown, KMdSShutdown, EFalse ); + + if(iShutdownObserver) + { + delete iShutdownObserver; + iShutdownObserver = NULL; + } + iShutdownObserver = CTMShutdownObserver::NewL( *this, KTAGDPSNotification, KShutdown, ETrue ); + iShutdown = EFalse; + + // MDS session reconnect timer + if (!iReconnect) + { + iReconnect = CPeriodic::NewL(CActive::EPriorityIdle); + } + + TN_DEBUG1( "CThumbAGCameraObserver::InitializeL() - connect to MDS" ); + + if(iMdESession) + { + TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); + TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); + + // connect to MDS + delete iMdESession; + iMdESession = NULL; + } + + iMdESession = CMdESession::NewL( *this ); + iSessionError = EFalse; + + TN_DEBUG1( "CThumbAGCameraObserver::InitializeL() - end" ); + } + +// --------------------------------------------------------------------------- +// ~CThumbAGCameraObserver +// --------------------------------------------------------------------------- +// +CThumbAGCameraObserver::~CThumbAGCameraObserver() + { + TN_DEBUG1( "CThumbAGCameraObserver::~CThumbAGCameraObserver() - begin" ); + + iShutdown = ETrue; + + delete iMDSShutdownObserver; + delete iShutdownObserver; + + if(iReconnect) + { + iReconnect->Cancel(); + delete iReconnect; + iReconnect = NULL; + } + + if (iMdESession) + { + // 2 observers + TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); + TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); + + delete iMdESession; + iMdESession = NULL; + } + + TN_DEBUG1( "CThumbAGCameraObserver::~CThumbAGCameraObserver() - end" ); + } + +// ----------------------------------------------------------------------------- +// CThumbAGCameraObserver::HandleSessionOpened +// ----------------------------------------------------------------------------- +// +void CThumbAGCameraObserver::HandleSessionOpened( CMdESession& /* aSession */, TInt aError ) + { + TN_DEBUG1( "CThumbAGCameraObserver::HandleSessionOpened"); + + if (aError == KErrNone) + { + TRAPD( err, AddObserversL() ); + if (err != KErrNone) + { + TN_DEBUG2( "CThumbAGCameraObserver::HandleSessionOpened, AddObserversL error == %d", err ); + } + } + else + { + TN_DEBUG2( "CThumbAGCameraObserver::HandleSessionOpened error == %d", aError ); + } + } + +// ----------------------------------------------------------------------------- +// CThumbAGCameraObserver::HandleSessionError +// ----------------------------------------------------------------------------- +// +void CThumbAGCameraObserver::HandleSessionError( CMdESession& /*aSession*/, TInt aError ) + { + TN_DEBUG2( "CThumbAGCameraObserver::HandleSessionError == %d", aError ); + if (aError != KErrNone && !iSessionError) + { + iSessionError = ETrue; + + if (!iShutdown) + { + if (!iReconnect->IsActive()) + { + iReconnect->Start( KMdEReconnect, KMdEReconnect, + TCallBack(ReconnectCallBack, this)); + + TN_DEBUG1( "CThumbAGCameraObserver::HandleSessionError() - reconnect timer started" ); + } + } + + } + } + +// ----------------------------------------------------------------------------- +// CThumbAGCameraObserver::HandleObjectNotification +// ----------------------------------------------------------------------------- +// +void CThumbAGCameraObserver::HandleObjectNotification( CMdESession& /*aSession*/, + TObserverNotificationType aType, + const RArray& aObjectIdArray ) + { + TN_DEBUG1( "CThumbAGCameraObserver::HandleObjectNotification() - begin" ); + + // no processor or shutting down + if ( iShutdown || !iProcessor) + { + return; + } + +#ifdef _DEBUG + if (aType == ENotifyAdd) + { + TN_DEBUG2( "CThumbAGCameraObserver::HandleObjectNotification() - ENotifyAdd %d", aObjectIdArray.Count() ); + iAddCounter = aObjectIdArray.Count(); + } + else if (aType == ENotifyModify) + { + TN_DEBUG2( "CThumbAGCameraObserver::HandleObjectNotification() - ENotifyModify %d", aObjectIdArray.Count() ); + iModCounter = aObjectIdArray.Count(); + } +#endif + + if ( (aType == ENotifyAdd || aType == ENotifyModify ) && (aObjectIdArray.Count() > 0) ) + { + TN_DEBUG1( "CThumbAGCameraObserver::HandleObjectNotification() - AddToQueueL" ); + + // Add event to processing queue by type and enable force run + RPointerArray dummyArray; + TRAPD(err, iProcessor->AddToQueueL(aType, EGenerationItemTypeCamera, aObjectIdArray, dummyArray, EFalse)); + if (err != KErrNone) + { + TN_DEBUG1( "CThumbAGCameraObserver::HandleObjectNotification() - error adding to queue" ); + } + } + else + { + TN_DEBUG1( "CThumbAGCameraObserver::HandleObjectNotification() - bad notification" ); + } + +#ifdef _DEBUG + TN_DEBUG3( "CThumbAGImageObserver::IN-COUNTERS---------- Add = %d Modify = %d", iAddCounter, iModCounter ); + iModCounter = 0; + iAddCounter = 0; +#endif + + TN_DEBUG1( "CThumbAGCameraObserver::HandleObjectNotification() - end" ); + } + +// ----------------------------------------------------------------------------- +// CThumbAGCameraObserver::ShutdownNotification +// ----------------------------------------------------------------------------- +// +void CThumbAGCameraObserver::ShutdownNotification() + { + TN_DEBUG1( "CThumbAGCameraObserver::ShutdownNotification()" ); + + if (!iShutdown) + { + TN_DEBUG1( "CThumbAGCameraObserver::ShutdownNotification() shutdown" ); + iShutdown = ETrue; + } + } + +// --------------------------------------------------------------------------- +// CThumbAGCameraObserver::AddObserversL +// --------------------------------------------------------------------------- +// +void CThumbAGCameraObserver::AddObserversL() + { + TN_DEBUG1( "CThumbAGCameraObserver::AddObserversL() - begin" ); + + CMdENamespaceDef& defaultNamespace = iMdESession->GetDefaultNamespaceDefL(); + CMdEObjectDef& objectDef = defaultNamespace.GetObjectDefL( MdeConstants::Object::KBaseObject ); + CMdEPropertyDef& originPropDef = objectDef.GetPropertyDefL( MdeConstants::Object::KOriginProperty ); + + // set observing conditions + CMdELogicCondition* addCondition = CMdELogicCondition::NewLC( ELogicConditionOperatorAnd ); + addCondition->AddPropertyConditionL( originPropDef, TMdEUintEqual(MdeConstants::Object::ECamera)); + CleanupStack::Pop( addCondition ); + + CMdELogicCondition* modifyCondition = CMdELogicCondition::NewLC( ELogicConditionOperatorAnd ); + modifyCondition->AddPropertyConditionL( originPropDef, TMdEUintEqual(MdeConstants::Object::ECamera)); + CleanupStack::Pop( modifyCondition ); + + // add observer + iMdESession->AddObjectObserverL( *this, addCondition, ENotifyAdd ); + + // modify observer + iMdESession->AddObjectObserverL( *this, modifyCondition, ENotifyModify ); + + TN_DEBUG1( "CThumbAGCameraObserver::AddObserversL() - end" ); + } + +// --------------------------------------------------------------------------- +// CThumbAGCameraObserver::ReconnectCallBack() +// --------------------------------------------------------------------------- +// +TInt CThumbAGCameraObserver::ReconnectCallBack(TAny* aAny) + { + TN_DEBUG1( "CThumbAGCameraObserver::ReconnectCallBack() - reinitialize"); + + CThumbAGCameraObserver* self = static_cast( aAny ); + + self->iReconnect->Cancel(); + + // reconnect to MDS + TRAP_IGNORE( self->InitializeL() ); + + TN_DEBUG1( "CThumbAGCameraObserver::ReconnectCallBack() - done"); + + return KErrNone; + } + + +// End of file diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagdaemon.cpp --- a/imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagdaemon.cpp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagdaemon.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -80,7 +80,6 @@ #ifdef _DEBUG iAddCounter = 0; - iModCounter = 0; iDelCounter = 0; #endif @@ -120,6 +119,7 @@ // create processor if(iProcessor) { + iProcessor->Shutdown(); delete iProcessor; iProcessor = NULL; } @@ -136,9 +136,7 @@ if(iMdESession) { - TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); - TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); - TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); + TRAP_IGNORE( iMdESession->RemoveObjectObserverWithUriL( *this ) ); TRAP_IGNORE( iMdESession->RemoveObjectPresentObserverL( * this )); // connect to MDS @@ -148,6 +146,22 @@ iMdESession = CMdESession::NewL( *this ); iSessionError = EFalse; + + delete iImageObserver; + iImageObserver = NULL; + iImageObserver = CThumbAGImageObserver::NewL(iProcessor); + + delete iCameraObserver; + iCameraObserver = NULL; + iCameraObserver = CThumbAGCameraObserver::NewL(iProcessor); + + delete iAudioObserver; + iAudioObserver = NULL; + iAudioObserver = CThumbAGAudioObserver::NewL(iProcessor); + + delete iVideoObserver; + iVideoObserver = NULL; + iVideoObserver = CThumbAGVideoObserver::NewL(iProcessor); } else { @@ -165,7 +179,19 @@ { TN_DEBUG1( "CThumbAGDaemon::~CThumbAGDaemon() - begin" ); - iShutdown = ETrue; + iShutdown = ETrue; + + delete iImageObserver; + iImageObserver = NULL; + + delete iCameraObserver; + iCameraObserver = NULL; + + delete iVideoObserver; + iVideoObserver = NULL; + + delete iAudioObserver; + iAudioObserver = NULL; delete iMDSShutdownObserver; delete iShutdownObserver; @@ -179,15 +205,13 @@ if (iProcessor) { + iProcessor->Shutdown(); delete iProcessor; iProcessor = NULL; } if (iMdESession) { - // 2 observers - TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); - #ifdef MDS_URI_OBSERVER // remove observer with uri TRAP_IGNORE( iMdESession->RemoveObjectObserverWithUriL( *this ) ); @@ -260,9 +284,9 @@ if (aError == KErrNone) { - iProcessor->SetMdESession(iMdESession); + TRAPD(err, iProcessor->SetMdESessionL(iMdESession)); - TRAPD( err, AddObserversL() ); + TRAP( err, AddObserversL() ); if (err != KErrNone) { TN_DEBUG2( "CThumbAGDaemon::HandleSessionOpened, AddObserversL error == %d", err ); @@ -281,26 +305,36 @@ void CThumbAGDaemon::HandleSessionError( CMdESession& /*aSession*/, TInt aError ) { TN_DEBUG2( "CThumbAGDaemon::HandleSessionError == %d", aError ); - if (aError != KErrNone && !iSessionError) + if (aError != KErrNone && !iShutdown && !iSessionError) { iSessionError = ETrue; + delete iImageObserver; + iImageObserver = NULL; + + delete iCameraObserver; + iCameraObserver = NULL; + + delete iVideoObserver; + iVideoObserver = NULL; + + delete iAudioObserver; + iAudioObserver = NULL; + // kill processor right away, because it also has MdESession if(iProcessor) { + iProcessor->Shutdown(); delete iProcessor; iProcessor = NULL; } - if (!iShutdown) + if (!iReconnect->IsActive()) { - if (!iReconnect->IsActive()) - { - iReconnect->Start( KMdEReconnect, KMdEReconnect, - TCallBack(ReconnectCallBack, this)); - - TN_DEBUG1( "CThumbAGDaemon::HandleSessionError() - reconnect timer started" ); - } + iReconnect->Start( KMdEReconnect, KMdEReconnect, + TCallBack(ReconnectCallBack, this)); + + TN_DEBUG1( "CThumbAGDaemon::HandleSessionError() - reconnect timer started" ); } } @@ -319,12 +353,18 @@ { TN_DEBUG1( "CThumbAGDaemon::HandleUriObjectNotification() - begin" ); + if(!iProcessor || iShutdown) + { + return; + } + if(aType == ENotifyRemove) { TN_DEBUG1( "CThumbAGDaemon::HandleUriObjectNotification() - removed"); TInt err(0); - TRAP(err, iProcessor->AddToQueueL(aType, aObjectIdArray, aObjectUriArray, EFalse)); + TRAP(err, iProcessor->AddToQueueL(aType, EGenerationItemTypeAny, aObjectIdArray, aObjectUriArray, EFalse)); __ASSERT_DEBUG((err==KErrNone), User::Panic(_L("CThumbAGDaemon::HandleUriObjectNotification()"), err)); + err = KErrNone; } TN_DEBUG1( "CThumbAGDaemon::HandleUriObjectNotification() - end" ); @@ -348,37 +388,23 @@ } #ifdef _DEBUG - if (aType == ENotifyAdd) - { - TN_DEBUG2( "CThumbAGDaemon::HandleObjectNotification() - ENotifyAdd %d", aObjectIdArray.Count() ); - iAddCounter = aObjectIdArray.Count(); - } - else if (aType == ENotifyModify) - { - TN_DEBUG2( "CThumbAGDaemon::HandleObjectNotification() - ENotifyModify %d", aObjectIdArray.Count() ); - iModCounter = aObjectIdArray.Count(); - } - else if (aType == ENotifyRemove) + if (aType == ENotifyRemove) { TN_DEBUG2( "CThumbAGDaemon::HandleObjectNotification() - ENotifyRemove %d", aObjectIdArray.Count() ); iDelCounter = aObjectIdArray.Count(); } #endif - if ( (aType == ENotifyAdd || aType == ENotifyModify || aType == ENotifyRemove) && - (aObjectIdArray.Count() > 0) ) + if ( aType == ENotifyRemove && aObjectIdArray.Count() > 0 ) { TN_DEBUG1( "CThumbAGDaemon::HandleObjectNotification() - AddToQueueL" ); // If delete event, remove IDs from Modify and Add queues - if ( aType == ENotifyRemove ) - { - iProcessor->RemoveFromQueues( aObjectIdArray, EFalse); - } + iProcessor->RemoveFromQueues( aObjectIdArray, EFalse); // Add event to processing queue by type and enable force run RPointerArray dummyArray; - TRAPD(err, iProcessor->AddToQueueL(aType, aObjectIdArray, dummyArray, EFalse)); + TRAPD(err, iProcessor->AddToQueueL(aType, EGenerationItemTypeAny, aObjectIdArray, dummyArray, EFalse)); if (err != KErrNone) { TN_DEBUG1( "CThumbAGDaemon::HandleObjectNotification() - error adding to queue" ); @@ -390,12 +416,8 @@ } #ifdef _DEBUG - TN_DEBUG4( "CThumbAGDaemon::IN-COUNTERS---------- Add = %d Modify = %d Delete = %d", - iAddCounter, iModCounter, iDelCounter ); - iModCounter = 0; + TN_DEBUG2( "CThumbAGDaemon::IN-COUNTERS---------- Delete = %d", iDelCounter ); iDelCounter = 0; - iAddCounter = 0; - #endif TN_DEBUG1( "CThumbAGDaemon::HandleObjectNotification() - end" ); @@ -425,10 +447,9 @@ { // do not force run of these items RPointerArray dummyArray; - TRAP(err, iProcessor->AddToQueueL(ENotifyAdd, aObjectIdArray, dummyArray, ETrue)); + TRAP(err, iProcessor->AddToQueueL(ENotifyAdd, EGenerationItemTypeUnknown, aObjectIdArray, dummyArray, ETrue)); - TN_DEBUG2( "CThumbAGDaemon::HandleObjectPresentNotification() - ENotifyAdd %d", aObjectIdArray.Count() ); - + TN_DEBUG2( "CThumbAGDaemon::HandleObjectPresentNotification() - ENotifyAdd unknown items %d", aObjectIdArray.Count() ); #ifdef _DEBUG iAddCounter = aObjectIdArray.Count(); if (err != KErrNone) @@ -460,11 +481,9 @@ } #ifdef _DEBUG - TN_DEBUG4( "CThumbAGDaemon::IN-COUNTERS---------- Add = %d Modify = %d Delete = %d", - iAddCounter, iModCounter, iDelCounter ); - iModCounter = 0; + TN_DEBUG3( "CThumbAGDaemon::IN-COUNTERS---------- Add = %d Delete = %d", iAddCounter, iDelCounter ); iDelCounter = 0; - iAddCounter = 0; + iAddCounter = 0; #endif TN_DEBUG1( "CThumbAGDaemon::HandleObjectPresentNotification() - end" ); @@ -493,31 +512,6 @@ { TN_DEBUG1( "CThumbAGDaemon::AddObserversL() - begin" ); - CMdENamespaceDef& defaultNamespace = iMdESession->GetDefaultNamespaceDefL(); - CMdEObjectDef& imageDef = defaultNamespace.GetObjectDefL( MdeConstants::Image::KImageObject ); - CMdEObjectDef& videoDef = defaultNamespace.GetObjectDefL( MdeConstants::Video::KVideoObject ); - CMdEObjectDef& audioDef = defaultNamespace.GetObjectDefL( MdeConstants::Audio::KAudioObject ); - - // set observing conditions - CMdELogicCondition* addCondition = CMdELogicCondition::NewLC( ELogicConditionOperatorOr ); - addCondition->AddObjectConditionL( imageDef ); - addCondition->AddObjectConditionL( videoDef ); - addCondition->AddObjectConditionL( audioDef ); - CleanupStack::Pop( addCondition ); - - CMdELogicCondition* modifyCondition = CMdELogicCondition::NewLC( ELogicConditionOperatorOr ); - modifyCondition->AddObjectConditionL( imageDef ); - modifyCondition->AddObjectConditionL( videoDef ); - modifyCondition->AddObjectConditionL( audioDef ); - CleanupStack::Pop( modifyCondition ); - - // add observer - iMdESession->AddObjectObserverL( *this, addCondition, ENotifyAdd ); - - // modify observer -#ifdef MDS_MODIFY_OBSERVER - iMdESession->AddObjectObserverL( *this, modifyCondition, ENotifyModify ); -#endif #ifdef MDS_URI_OBSERVER // remove observer with uri diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagimageobserver.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagimageobserver.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -0,0 +1,345 @@ +/* +* Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Thumbnail Auto Generate Daemon +* +*/ + + +#include +#include + +#include +#include +#include +#include + +#include "thumbagimageobserver.h" +#include "thumbnaillog.h" +#include "thumbnailmanagerconstants.h" +#include "thumbnailmanagerprivatecrkeys.h" + + +// --------------------------------------------------------------------------- +// NewLC +// --------------------------------------------------------------------------- +// +CThumbAGImageObserver* CThumbAGImageObserver::NewLC(CThumbAGProcessor* aProcessor) + { + TN_DEBUG1( "CThumbAGImageObserver::NewLC() - begin" ); + + CThumbAGImageObserver* self = new (ELeave) CThumbAGImageObserver(aProcessor); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// --------------------------------------------------------------------------- +// NewL +// --------------------------------------------------------------------------- +// +CThumbAGImageObserver* CThumbAGImageObserver::NewL(CThumbAGProcessor* aProcessor) + { + TN_DEBUG1( "CThumbAGImageObserver::NewL() - begin" ); + + CThumbAGImageObserver* self = CThumbAGImageObserver::NewLC(aProcessor); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// CThumbAGImageObserver +// --------------------------------------------------------------------------- +// +CThumbAGImageObserver::CThumbAGImageObserver(CThumbAGProcessor* aProcessor) + : iShutdownObserver(NULL), iMdESession(NULL), iProcessor(aProcessor) + { + // No implementation required + } + +// --------------------------------------------------------------------------- +// ConstructL +// --------------------------------------------------------------------------- +// +void CThumbAGImageObserver::ConstructL() + { + TN_DEBUG1( "CThumbAGImageObserver::ConstructL() - begin" ); + +#ifdef _DEBUG + iAddCounter = 0; + iModCounter = 0; +#endif + + InitializeL(); + + TN_DEBUG1( "CThumbAGImageObserver::ConstructL() - end" ); + } + +// --------------------------------------------------------------------------- +// ~CThumbAGImageObserver +// --------------------------------------------------------------------------- +// +void CThumbAGImageObserver::InitializeL() + { + TN_DEBUG1( "CThumbAGImageObserver::InitializeL() - begin" ); + + + TN_DEBUG1( "CThumbAGImageObserver::InitializeL() - create observers" ); + + // create shutdown observer + if(iMDSShutdownObserver) + { + delete iMDSShutdownObserver; + iMDSShutdownObserver = NULL; + } + iMDSShutdownObserver = CTMShutdownObserver::NewL( *this, KMdSPSShutdown, KMdSShutdown, EFalse ); + + if(iShutdownObserver) + { + delete iShutdownObserver; + iShutdownObserver = NULL; + } + iShutdownObserver = CTMShutdownObserver::NewL( *this, KTAGDPSNotification, KShutdown, ETrue ); + iShutdown = EFalse; + + // MDS session reconnect timer + if (!iReconnect) + { + iReconnect = CPeriodic::NewL(CActive::EPriorityIdle); + } + + TN_DEBUG1( "CThumbAGImageObserver::InitializeL() - connect to MDS" ); + + if(iMdESession) + { + TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); + TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); + + // connect to MDS + delete iMdESession; + iMdESession = NULL; + } + + iMdESession = CMdESession::NewL( *this ); + iSessionError = EFalse; + + TN_DEBUG1( "CThumbAGImageObserver::InitializeL() - end" ); + } + +// --------------------------------------------------------------------------- +// ~CThumbAGImageObserver +// --------------------------------------------------------------------------- +// +CThumbAGImageObserver::~CThumbAGImageObserver() + { + TN_DEBUG1( "CThumbAGImageObserver::~CThumbAGImageObserver() - begin" ); + + iShutdown = ETrue; + + delete iMDSShutdownObserver; + delete iShutdownObserver; + + if(iReconnect) + { + iReconnect->Cancel(); + delete iReconnect; + iReconnect = NULL; + } + + if (iMdESession) + { + // 2 observers + TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); + TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); + + delete iMdESession; + iMdESession = NULL; + } + + TN_DEBUG1( "CThumbAGImageObserver::~CThumbAGImageObserver() - end" ); + } + +// ----------------------------------------------------------------------------- +// CThumbAGImageObserver::HandleSessionOpened +// ----------------------------------------------------------------------------- +// +void CThumbAGImageObserver::HandleSessionOpened( CMdESession& /* aSession */, TInt aError ) + { + TN_DEBUG1( "CThumbAGImageObserver::HandleSessionOpened"); + + if (aError == KErrNone) + { + TRAPD( err, AddObserversL() ); + if (err != KErrNone) + { + TN_DEBUG2( "CThumbAGImageObserver::HandleSessionOpened, AddObserversL error == %d", err ); + } + } + else + { + TN_DEBUG2( "CThumbAGImageObserver::HandleSessionOpened error == %d", aError ); + } + } + +// ----------------------------------------------------------------------------- +// CThumbAGImageObserver::HandleSessionError +// ----------------------------------------------------------------------------- +// +void CThumbAGImageObserver::HandleSessionError( CMdESession& /*aSession*/, TInt aError ) + { + TN_DEBUG2( "CThumbAGImageObserver::HandleSessionError == %d", aError ); + if (aError != KErrNone && !iSessionError) + { + iSessionError = ETrue; + + if (!iShutdown) + { + if (!iReconnect->IsActive()) + { + iReconnect->Start( KMdEReconnect, KMdEReconnect, + TCallBack(ReconnectCallBack, this)); + + TN_DEBUG1( "CThumbAGImageObserver::HandleSessionError() - reconnect timer started" ); + } + } + + } + } + +// ----------------------------------------------------------------------------- +// CThumbAGImageObserver::HandleObjectNotification +// ----------------------------------------------------------------------------- +// +void CThumbAGImageObserver::HandleObjectNotification( CMdESession& /*aSession*/, + TObserverNotificationType aType, + const RArray& aObjectIdArray ) + { + TN_DEBUG1( "CThumbAGImageObserver::HandleObjectNotification() - begin" ); + + // no processor or shutting down + if (iShutdown || !iProcessor) + { + return; + } + +#ifdef _DEBUG + if (aType == ENotifyAdd) + { + TN_DEBUG2( "CThumbAGImageObserver::HandleObjectNotification() - ENotifyAdd %d", aObjectIdArray.Count() ); + iAddCounter = aObjectIdArray.Count(); + } + else if (aType == ENotifyModify) + { + TN_DEBUG2( "CThumbAGImageObserver::HandleObjectNotification() - ENotifyModify %d", aObjectIdArray.Count() ); + iModCounter = aObjectIdArray.Count(); + } +#endif + + if ( (aType == ENotifyAdd || aType == ENotifyModify) && aObjectIdArray.Count() > 0 ) + { + TN_DEBUG1( "CThumbAGImageObserver::HandleObjectNotification() - AddToQueueL" ); + + // Add event to processing queue by type and enable force run + RPointerArray dummyArray; + TRAPD(err, iProcessor->AddToQueueL(aType, EGenerationItemTypeImage, aObjectIdArray, dummyArray, EFalse)); + if (err != KErrNone) + { + TN_DEBUG1( "CThumbAGImageObserver::HandleObjectNotification() - error adding to queue" ); + } + } + else + { + TN_DEBUG1( "CThumbAGImageObserver::HandleObjectNotification() - bad notification" ); + } + +#ifdef _DEBUG + TN_DEBUG3( "CThumbAGImageObserver::IN-COUNTERS---------- Add = %d Modify = %d", iAddCounter, iModCounter ); + iModCounter = 0; + iAddCounter = 0; + +#endif + + TN_DEBUG1( "CThumbAGImageObserver::HandleObjectNotification() - end" ); + } + +// --------------------------------------------------------------------------- +// CThumbAGImageObserver::AddObserversL +// --------------------------------------------------------------------------- +// +void CThumbAGImageObserver::AddObserversL() + { + TN_DEBUG1( "CThumbAGImageObserver::AddObserversL() - begin" ); + + CMdENamespaceDef& defaultNamespace = iMdESession->GetDefaultNamespaceDefL(); + CMdEObjectDef& objectDef = defaultNamespace.GetObjectDefL( MdeConstants::Object::KBaseObject ); + CMdEPropertyDef& originPropDef = objectDef.GetPropertyDefL( MdeConstants::Object::KOriginProperty ); + CMdEObjectDef& imageDef = defaultNamespace.GetObjectDefL( MdeConstants::Image::KImageObject ); + + // set observing conditions + CMdELogicCondition* addCondition = CMdELogicCondition::NewLC( ELogicConditionOperatorAnd ); + addCondition->AddObjectConditionL( imageDef ); + addCondition->AddPropertyConditionL( originPropDef, TMdEUintNotEqual(MdeConstants::Object::ECamera)); + CleanupStack::Pop( addCondition ); + + CMdELogicCondition* modifyCondition = CMdELogicCondition::NewLC( ELogicConditionOperatorAnd ); + modifyCondition->AddObjectConditionL( imageDef ); + addCondition->AddPropertyConditionL( originPropDef, TMdEUintNotEqual(MdeConstants::Object::ECamera)); + CleanupStack::Pop( modifyCondition ); + + // add observers + iMdESession->AddObjectObserverL( *this, addCondition, ENotifyAdd ); + + // modify observer + iMdESession->AddObjectObserverL( *this, modifyCondition, ENotifyModify ); + + TN_DEBUG1( "CThumbAGImageObserver::AddObserversL() - end" ); + } + + +// ----------------------------------------------------------------------------- +// CThumbAGCameraObserver::ShutdownNotification +// ----------------------------------------------------------------------------- +// +void CThumbAGImageObserver::ShutdownNotification() + { + TN_DEBUG1( "CThumbAGImageObserver::ShutdownNotification()" ); + + if (!iShutdown) + { + TN_DEBUG1( "CThumbAGImageObserver::ShutdownNotification() shutdown" ); + iShutdown = ETrue; + } + } + +// --------------------------------------------------------------------------- +// CThumbAGImageObserver::ReconnectCallBack() +// --------------------------------------------------------------------------- +// +TInt CThumbAGImageObserver::ReconnectCallBack(TAny* aAny) + { + TN_DEBUG1( "CThumbAGImageObserver::ReconnectCallBack() - reinitialize"); + + CThumbAGImageObserver* self = static_cast( aAny ); + + self->iReconnect->Cancel(); + + // reconnect to MDS + TRAP_IGNORE( self->InitializeL() ); + + TN_DEBUG1( "CThumbAGImageObserver::ReconnectCallBack() - done"); + + return KErrNone; + } + + +// End of file diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagprocessor.cpp --- a/imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagprocessor.cpp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagprocessor.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -50,7 +50,8 @@ // CThumbAGProcessor::CThumbAGProcessor() // --------------------------------------------------------------------------- // -CThumbAGProcessor::CThumbAGProcessor(): CActive( CActive::EPriorityStandard ) +CThumbAGProcessor::CThumbAGProcessor(): CActive( CActive::EPriorityStandard ), iMMCHarvestingItemsLeftTemp(0), + iPHHarvestingItemsLeftTemp(0) { TN_DEBUG1( "CThumbAGProcessor::CThumbAGProcessor() - begin" ); @@ -65,6 +66,8 @@ { TN_DEBUG1( "CThumbAGProcessor::ConstructL() - begin" ); + iShutdown = EFalse; + iTMSession = CThumbnailManager::NewL( *this ); iTMSession->SetRequestObserver(*this); @@ -82,8 +85,9 @@ iPeriodicTimer = CPeriodic::NewL(CActive::EPriorityIdle); + iMountTimer = CPeriodic::NewL(CActive::EPriorityUserInput); + SetForceRun( EFalse ); - iActive = EFalse; iFormatObserver = CTMFormatObserver::NewL( *this ); @@ -94,7 +98,7 @@ iActivityManager = CTMActivityManager::NewL( this, KBackgroundGenerationIdle); - UpdatePSValues(ETrue); + UpdatePSValues(ETrue, ETrue); RProperty::Define(KTAGDPSNotification, KMPXHarvesting, RProperty::EInt); @@ -112,12 +116,29 @@ { TN_DEBUG1( "CThumbAGProcessor::~CThumbAGProcessor() - begin" ); + Shutdown(); + Cancel(); + if (iTMSession) + { + iTMSession->RemoveRequestObserver(); + delete iTMSession; + iTMSession = NULL; + } + + if(iMountTimer) + { + iMountTimer->Cancel(); + delete iMountTimer; + iMountTimer = NULL; + } + if(iPeriodicTimer) { iPeriodicTimer->Cancel(); delete iPeriodicTimer; + iPeriodicTimer = NULL; } if(iActivityManager) @@ -172,25 +193,32 @@ iCollectionUtility->Close(); iCollectionUtility = NULL; } - - iAddQueue.Close(); - iModifyQueue.Close(); - iRemoveQueue.ResetAndDestroy(); - iQueryQueue.Close(); - iPlaceholderQueue.Close(); - - i2ndRoundGenerateQueue.Close(); - if (iTMSession) + for(TInt i=0;iRemoveRequestObserver(); - delete iTMSession; - iTMSession = NULL; + delete iGenerationQueue[i].iUri; + iGenerationQueue[i].iUri = NULL; } + iGenerationQueue.Reset(); + iGenerationQueue.Close(); + + iQueryQueue.Close(); + TN_DEBUG1( "CThumbAGProcessor::~CThumbAGProcessor() - end" ); } +// --------------------------------------------------------------------------- +// CThumbAGProcessor::Shutdown() +// --------------------------------------------------------------------------- +// +void CThumbAGProcessor::Shutdown() + { + TN_DEBUG1( "CThumbAGProcessor::Shutdown()" ); + iShutdown = ETrue; + UpdatePSValues(EFalse, EFalse); + } + // ----------------------------------------------------------------------------- // CThumbAGProcessor::HandleQueryNewResults() // ----------------------------------------------------------------------------- @@ -200,6 +228,12 @@ const TInt aNewItemCount ) { // PH & AllItems query results are handled here + + if(iShutdown) + { + return; + } + if (aNewItemCount > 0) { if(&aQuery == iQueryPlaceholders) @@ -222,13 +256,19 @@ } // ignore if fails - iPlaceholderQueue.InsertInOrder(object->Id(), Compare); + TThumbnailGenerationItem item; + item.iItemId = object->Id(); + item.iPlaceholder = ETrue; + + SetGenerationItemType( item, object->Def().Id()); + + AppendProcessingQueue( item ); } } else if(&aQuery == iQueryAllItems) { TN_DEBUG2( "CThumbAGProcessor::HandleQueryNewResults - QueryAllItems, %d new", aNewItemCount); - + for(TInt i = aFirstNewItemIndex; i < iQueryAllItems->Count(); i++) { const CMdEObject* object = &iQueryAllItems->Result(i); @@ -237,13 +277,17 @@ { continue; } - - if (iAddQueue.FindInOrder(object->Id(), Compare) == KErrNotFound && - iModifyQueue.FindInOrder(object->Id(), Compare) == KErrNotFound ) - { - // ignore if fails - iAddQueue.InsertInOrder(object->Id(), Compare); - } + + TThumbnailGenerationItem item; + item.iItemId = object->Id(); + + SetGenerationItemType(item, object->Def().Id()); + + TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare); + + item.iPlaceholder = object->Placeholder(); + + AppendProcessingQueue( item ); } } } @@ -261,12 +305,15 @@ { TN_DEBUG3( "CThumbAGProcessor::HandleQueryCompleted, aError == %d Count== %d", aError, aQuery.Count()); + if(iShutdown) + { + return; + } + if(&aQuery == iQueryPlaceholders) { TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted - iQueryPlaceholders completed"); - iPlaceholderQueue.Reset(); - //free query delete iQueryPlaceholders; iQueryPlaceholders = NULL; @@ -304,60 +351,123 @@ { iProcessingCount = iQuery->Count(); - if(iProcessingCount != iQueryQueue.Count()) + if(iProcessingCount != iQueryQueue.Count() ) { TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted() some result items missing"); RArray queryQueueDelta; - TInt itemIndex(KErrNotFound); - - //search delta items which were queried, but not found - for(TInt queryItem =0; queryItem < iQueryQueue.Count();queryItem++) - { - TBool found(EFalse); - for(TInt queryResult = 0; queryResult < iQuery->Count(); queryResult++) - { - const CMdEObject* object = &iQuery->Result(queryResult); - - if( iQueryQueue[queryItem] == object->Id()) + //search delta items which were queried, but not found + for(TInt queryItem =0; queryItem < iQueryQueue.Count();queryItem++) + { + TBool found(EFalse); + for(TInt queryResult = 0; queryResult < iQuery->Count(); queryResult++) + { + const CMdEObject* object = &iQuery->Result(queryResult); + + if( iQueryQueue[queryItem] == object->Id()) + { + found = ETrue; + break; + } + } + + if(!found) + { + TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() %d missing from query results", iQueryQueue[queryItem] ); + + // ignore if fails + queryQueueDelta.InsertInOrder(iQueryQueue[queryItem], CompareId); + } + } + + TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() missing items found %d", queryQueueDelta.Count()); + //cleanup from previous queue it item is not found from MDS + while(queryQueueDelta.Count()) + { + TThumbnailGenerationItem item; + item.iItemId = queryQueueDelta[0]; + TInt itemIndex = iQueryQueue.FindInOrder(item.iItemId, CompareId); + + if(itemIndex >= 0) + { + TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove %d from iQueryQueue", queryQueueDelta[0]); + iQueryQueue.Remove( itemIndex ); + + //remove from procesing queue + itemIndex = iGenerationQueue.FindInOrder(item, Compare); + + if(itemIndex >= 0) + { + + if( iUnknown ) + { + TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() mark %d as EGenerationItemTypeNotFound in iGenerationQueue", queryQueueDelta[0]); + //mark to be removed, cleanup is done below + iGenerationQueue[itemIndex].iItemType = EGenerationItemTypeNotFound; + } + else + { + TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove %d from iGenerationQueue", queryQueueDelta[0]); + iGenerationQueue.Remove( itemIndex ); + } + } + } + queryQueueDelta.Remove(0); + } + queryQueueDelta.Close(); + } + + if(iUnknown) + { + for(TInt i = 0; i < iQuery->Count(); i++) + { + const CMdEObject* object = &iQuery->Result(i); + + if(!object) + { + continue; + } + + TThumbnailGenerationItem tempItem; + tempItem.iItemId = object->Id(); + TInt itemIndex = iGenerationQueue.FindInOrder(tempItem, Compare); + + if(itemIndex >= 0) { - found = ETrue; - break; + TThumbnailGenerationItem& item = iGenerationQueue[itemIndex]; + + if(iGenerationQueue[itemIndex].iItemType == EGenerationItemTypeNotFound) + { + TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove EGenerationItemTypeNotFound %d item from iGenerationQueue", item.iItemId); + iGenerationQueue.Remove(itemIndex); + continue; + } + + SetGenerationItemType(item, object->Def().Id()); + + if(item.iItemType == EGenerationItemTypeUnknown ) + { + TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove unknown item %d", item.iItemId); + iGenerationQueue.Remove(itemIndex); + continue; + } + + item.iPlaceholder = object->Placeholder(); + } } - - if(!found) - { - TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() missing from results item %d", iQueryQueue[queryItem] ); - - // ignore if fails - queryQueueDelta.InsertInOrder(iQueryQueue[queryItem], Compare); - } - } - - TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() missing items total count %d", queryQueueDelta.Count()); - //cleanup from previous queue it item is not found from MDS - while(queryQueueDelta.Count()) - { - itemIndex = iLastQueue->FindInOrder(queryQueueDelta[0], Compare); - - if(itemIndex >= 0) - { - TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove items %d", iQueryQueue[0]); - iLastQueue->Remove( itemIndex ); - } - queryQueueDelta.Remove(0); - } - queryQueueDelta.Close(); - } + + iQueryQueue.Reset(); + iProcessingCount = 0; + iUnknown = EFalse; + } // no results, reset query - if( !iProcessingCount) + if( !iProcessingCount ) { delete iQuery; iQuery = NULL; - iProcessingCount = 0; iModify = EFalse; } } @@ -389,7 +499,7 @@ } // ----------------------------------------------------------------------------- -// CThumbAGProcessor::ThumbnailReady() +// CThumbAGProcessor::ThumbnailReady()d // ----------------------------------------------------------------------------- // void CThumbAGProcessor::ThumbnailReady( TInt aError, MThumbnailData& /*aThumbnail*/, @@ -399,12 +509,6 @@ iActiveCount--; - if(iActiveCount <= 0) - { - iActiveCount = 0; - iActive = EFalse; - } - // TNM server died, delete session if( aError == KErrServerTerminated ) { @@ -442,12 +546,6 @@ iActiveCount--; - if(iActiveCount <= 0) - { - iActiveCount = 0; - iActive = EFalse; - } - ActivateAO(); } } @@ -456,7 +554,7 @@ // CThumbAGProcessor::SetMdESession() // --------------------------------------------------------------------------- // -void CThumbAGProcessor::SetMdESession( CMdESession* aMdESession ) +void CThumbAGProcessor::SetMdESessionL( CMdESession* aMdESession ) { TN_DEBUG1( "CThumbAGProcessor::SetMdESession() - begin" ); @@ -468,14 +566,22 @@ if (err != KErrNone) { TN_DEBUG2( "CThumbAGProcessor::SetMdESession() GetDefaultNamespaceDefL() err = %d", err ); + __ASSERT_DEBUG((iDefNamespace), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iDefNamespace "), KErrBadHandle)); } - - __ASSERT_DEBUG((iDefNamespace), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iDefNamespace "), KErrBadHandle)); - - //do async init - iInit = ETrue; - - ActivateAO(); + else + { + iImageObjectDef = &iDefNamespace->GetObjectDefL( MdeConstants::Image::KImageObject ); + __ASSERT_DEBUG((iImageObjectDef), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iDefNamespace "), KErrBadHandle)); + iVideoObjectDef = &iDefNamespace->GetObjectDefL( MdeConstants::Video::KVideoObject ); + __ASSERT_DEBUG((iVideoObjectDef), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iVideoObjectDef "), KErrBadHandle)); + iAudioObjectDef = &iDefNamespace->GetObjectDefL( MdeConstants::Audio::KAudioObject ); + __ASSERT_DEBUG((iAudioObjectDef), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iAudioObjectDef "), KErrBadHandle)); + + //do async init + iInit = ETrue; + + ActivateAO(); + } } // --------------------------------------------------------------------------- @@ -483,11 +589,13 @@ // --------------------------------------------------------------------------- // void CThumbAGProcessor::AddToQueueL( TObserverNotificationType aType, + TThumbnailGenerationItemType aItemType, const RArray& aIDArray, const RPointerArray& aObjectUriArray, TBool /*aPresent*/ ) { TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - begin" ); + // update queues if (aType == ENotifyAdd) @@ -496,12 +604,18 @@ for (int i=0; i= 0) { - TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - remove from placeholder queue"); - iPlaceholderQueue.Remove( itemIndex ); + TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - set as non-placeholder"); + iGenerationQueue[itemIndex].iPlaceholder = EFalse; } - - if(iAddQueue.FindInOrder(aIDArray[i], Compare) == KErrNotFound && - i2ndRoundGenerateQueue.FindInOrder(aIDArray[i], Compare) == KErrNotFound) + else { - TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append to add queue"); - User::LeaveIfError(iAddQueue.InsertInOrder(aIDArray[i], Compare)); + TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append"); + + item.iPlaceholder = EFalse; + SetGenerationItemType( item, 0 ); + AppendProcessingQueue( item ); } } } @@ -537,75 +655,89 @@ for (int i=0; i= 0) { - TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - placeholder modify, remove from placeholder queue"); - iPlaceholderQueue.Remove( itemIndex ); + if( iGenerationQueue[itemIndex].iPlaceholder ) + { + TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - placeholder modify"); + iGenerationQueue[itemIndex].iPlaceholder = EFalse; + } + else + { + TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - real modify"); + iGenerationQueue[itemIndex].iItemAction = EGenerationItemActionModify; + SetForceRun( ETrue ); + } } else { - TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - real modify"); - itemIndex = iAddQueue.FindInOrder(aIDArray[i], Compare); - - if (itemIndex >= 0) - { - TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - remove from add queue"); - iAddQueue.Remove( itemIndex ); - } - else - { - itemIndex = i2ndRoundGenerateQueue.FindInOrder(aIDArray[i], Compare); - - if (itemIndex >= 0) - { - TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - remove from 2nd round add queue"); - i2ndRoundGenerateQueue.Remove( itemIndex ); - } - } - - TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append to modify queue"); - User::LeaveIfError(iModifyQueue.InsertInOrder(aIDArray[i], Compare)); - - SetForceRun( ETrue ); - } + TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append"); + SetGenerationItemType( item, 0 ); + item.iPlaceholder = EFalse; + AppendProcessingQueue( item ); + } } } } - else if (aType == ENotifyRemove) + else if (aType == ENotifyRemove && aItemType == EGenerationItemTypeAny) { TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyRemove, remove IDs from all queues"); for (int i=0; i= 0) - { - iAddQueue.Remove(itemIndex); - } - - // ..and Modify Queue - itemIndex = iModifyQueue.FindInOrder(aIDArray[i], Compare); + TThumbnailGenerationItem item; + item.iItemId = aIDArray[i]; + + TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare); + if(itemIndex >= 0) { - iModifyQueue.Remove(itemIndex); + iGenerationQueue[itemIndex].iItemAction = EGenerationItemActionDelete; + delete iGenerationQueue[itemIndex].iUri; + iGenerationQueue[itemIndex].iUri = NULL; + + if( aObjectUriArray[i]) + { + iGenerationQueue[itemIndex].iUri = aObjectUriArray[i]->AllocL(); + } + else + { + //invalid URI remove from processing queue + iGenerationQueue.Remove(itemIndex); + } } - } - - TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyRemove append URIs to remove queue"); - for (int i=0; iAllocL(); - iRemoveQueue.Append( temp ); - TN_DEBUG2( "CThumbAGProcessor::AddToQueueL() - %S", temp); + else + { + TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append"); + item.iItemAction = EGenerationItemActionDelete; + delete item.iUri; + item.iUri = NULL; + + if( aObjectUriArray[i]) + { + item.iUri = aObjectUriArray[i]->AllocL(); + CleanupStack::PushL( item.iUri ); + User::LeaveIfError( iGenerationQueue.InsertInOrder(item, Compare) ); + CleanupStack::Pop(); + } + + //owned by item + item.iUri = NULL; + } + + TN_DEBUG2( "CThumbAGProcessor::AddToQueueL() - %S", aObjectUriArray[i]); } } #ifdef _DEBUG else { TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - should not come here" ); + __ASSERT_DEBUG((EFalse), User::Panic(_L("CThumbAGProcessor::AddToQueueL()"), KErrArgument)); User::Leave( KErrArgument ); } #endif @@ -635,8 +767,8 @@ TInt64 modifiedVal = 0; CMdEProperty* orientation = NULL; - CMdEObjectDef& imageObjectDef = iDefNamespace->GetObjectDefL( MdeConstants::Image::KImageObject ); - TInt orientErr = aObject->Property( imageObjectDef.GetPropertyDefL( MdeConstants::Image::KOrientationProperty ), orientation, 0 ); + + TInt orientErr = aObject->Property( iImageObjectDef->GetPropertyDefL( MdeConstants::Image::KOrientationProperty ), orientation, 0 ); if (orientErr == KErrNone) { @@ -661,6 +793,20 @@ //generate both if needed TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() EOptimizeForQuality "); iTMSession->SetQualityPreferenceL( CThumbnailManager::EOptimizeForQuality ); + + TN_DEBUG2( "CThumbAGProcessor::CreateThumbnailsL() - 2nd round add remove from queue", aObject->Id() ); + + TThumbnailGenerationItem item; + item.iItemId = aObject->Id(); + TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare); + + if(itemIndex >=0 ) + { + if(iGenerationQueue[itemIndex].iItemAction == EGenerationItemAction2ndAdd) + { + iGenerationQueue.Remove(itemIndex); + } + } } // 1st roung generation else @@ -669,27 +815,30 @@ TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() EOptimizeForQualityWithPreview"); iTMSession->SetQualityPreferenceL( CThumbnailManager::EOptimizeForQualityWithPreview ); - CMdEObjectDef& videoObjectDef = iDefNamespace->GetObjectDefL( MdeConstants::Video::KVideoObject ); + // add item to 2nd round queue + TN_DEBUG2( "CThumbAGProcessor::CreateThumbnailsL() - 1st round add/modify, append to 2nd round queue", aObject->Id() ); - // add item to 2nd round queue - if(iLastQueue == &iAddQueue || iLastQueue == &iModifyQueue) + TThumbnailGenerationItem item; + item.iItemId = aObject->Id(); + TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare); + + if(itemIndex >=0 ) { - TN_DEBUG2( "CThumbAGProcessor::CreateThumbnailsL() - 1st round add/modify, append to 2nd round queue", aObject->Id() ); - if(i2ndRoundGenerateQueue.FindInOrder(aObject->Id(), Compare) == KErrNotFound) + if(iGenerationQueue[itemIndex].iItemAction == EGenerationItemActionModify) { - // ignore if fails - i2ndRoundGenerateQueue.InsertInOrder(aObject->Id(), Compare); + iGenerationQueue.Remove(itemIndex); + } + //change 1st round item for 2nd round processing + //2nd round item can be deleted + else if(iGenerationQueue[itemIndex].iItemAction == EGenerationItemActionAdd) + { + iGenerationQueue[itemIndex].iItemAction = EGenerationItemAction2ndAdd; + } + else + { + iGenerationQueue.Remove(itemIndex); } } - - // Symbian^4 specific ---> - if( imageObjectDef.Id() != aObject->Def().Id() ) - { - TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() 1st round not image"); - ActivateAO(); - return; - } - //Symbian^4 specific <--- } // run as lower priority than getting but higher that creating thumbnails @@ -700,13 +849,11 @@ TN_DEBUG2( "CThumbAGProcessor::CreateThumbnailsL, iTMSession error == %d", err ); iSessionDied = ETrue; - iActive = EFalse; ActivateAO(); } else { iActiveCount++; - iActive = ETrue; } } else @@ -721,14 +868,14 @@ // CThumbAGProcessor::QueryL() // --------------------------------------------------------------------------- // -void CThumbAGProcessor::QueryL( RArray& aIDArray ) +void CThumbAGProcessor::QueryL(/*RArray& aIDArray*/TThumbnailGenerationItemAction aAction ) { TN_DEBUG1( "CThumbAGProcessor::QueryL() - begin" ); __ASSERT_DEBUG((iMdESession), User::Panic(_L("CThumbAGProcessor::QueryL() !iMdeSession "), KErrBadHandle)); __ASSERT_DEBUG((iDefNamespace), User::Panic(_L("CThumbAGProcessor::QueryL() !iDefNamespace "), KErrBadHandle)); - if(!iMdESession || !iDefNamespace) + if(!iMdESession || !iDefNamespace || iShutdown) { return; } @@ -736,7 +883,6 @@ //reset query queue iQueryQueue.Reset(); //set reference to current pprocessing queue - iLastQueue = &aIDArray; iQueryReady = EFalse; @@ -748,18 +894,64 @@ } //move ID from source queue to Query queue - TInt maxCount = aIDArray.Count(); + TInt maxCount = iGenerationQueue.Count(); - TN_DEBUG3( "CThumbAGProcessor::QueryL() - fill begin aIDArray == %d, iQueryQueue == %d", aIDArray.Count(), iQueryQueue.Count() ); + TN_DEBUG3( "CThumbAGProcessor::QueryL() - fill begin iGenerationQueue == %d, iQueryQueue == %d", iGenerationQueue.Count(), iQueryQueue.Count() ); + - for(TInt i=0; i < KMaxQueryItems && i < maxCount; i++) + TInt itemCount(0); + for(TInt i=0; itemCount < KMaxQueryItems && i < maxCount; i++) { - TN_DEBUG2( "CThumbAGProcessor::QueryL() - fill %d", aIDArray[0] ); - iQueryQueue.InsertInOrder(aIDArray[0], Compare); - aIDArray.Remove(0); + TInt itemIndex(KErrNotFound); + switch(aAction) + { + //1st round items + case EGenerationItemActionAdd: + if(iGenerationQueue[i].iItemAction == aAction ) + { + itemIndex = i; + } + break; + case EGenerationItemActionModify: + if( iGenerationQueue[i].iItemAction == aAction ) + { + itemIndex = i; + } + break; + case EGenerationItemAction2ndAdd: + if( iGenerationQueue[i].iItemAction == aAction ) + { + itemIndex = i; + } + break; + //unknown stuff + case EGenerationItemActionResolveType: + if( iGenerationQueue[i].iItemType == EGenerationItemTypeUnknown ) + { + itemIndex = i; + } + break; + default: + break; + }; + + if( itemIndex >= 0 ) + { + TN_DEBUG2( "CThumbAGProcessor::QueryL() - fill %d", iGenerationQueue[itemIndex].iItemId ); + iQueryQueue.InsertInOrder(iGenerationQueue[itemIndex].iItemId, CompareId); + itemCount++; + } } - TN_DEBUG3( "CThumbAGProcessor::QueryL() - fill end aIDArray == %d, iQueryQueue == %d", aIDArray.Count(), iQueryQueue.Count() ); + if(!itemCount) + { + TN_DEBUG1( "CThumbAGProcessor::QueryL() - empty query, cancel?!"); + iQueryActive = EFalse; + __ASSERT_DEBUG((iMdESession), User::Panic(_L("CThumbAGProcessor::QueryL() empty! "), KErrNotFound)); + return; + } + + TN_DEBUG3( "CThumbAGProcessor::QueryL() - fill end iGenerationQueue == %d, iQueryQueue == %d", iGenerationQueue.Count(), iQueryQueue.Count() ); CMdEObjectDef& objDef = iDefNamespace->GetObjectDefL( MdeConstants::Object::KBaseObject ); iQuery = iMdESession->NewObjectQueryL( *iDefNamespace, objDef, this ); @@ -774,7 +966,7 @@ CleanupStack::Pop( &iQueryQueue ); // add object type conditions - if (!iModify) + if (!(iModify || iUnknown)) { CMdELogicCondition& objDefCondition = rootCondition.AddLogicConditionL( ELogicConditionOperatorOr ); @@ -813,7 +1005,7 @@ __ASSERT_DEBUG((iMdESession), User::Panic(_L("CThumbAGProcessor::QueryPlaceholdersL() !iMdeSession "), KErrBadHandle)); __ASSERT_DEBUG((iDefNamespace), User::Panic(_L("CThumbAGProcessor::QueryPlaceholdersL() !iDefNamespace "), KErrBadHandle)); - if(!iMdESession || !iDefNamespace) + if(!iMdESession || !iDefNamespace || iShutdown) { return; } @@ -858,7 +1050,7 @@ audioPHObjectCondition.SetPlaceholderOnly( ETrue ); audioPHObjectCondition.SetNotPresent( ETrue ); - iQueryPlaceholders->FindL(KMaxTInt, KMaxQueryItems2); + iQueryPlaceholders->FindL(KMaxTInt, KMaxQueryBatchSize); TN_DEBUG1( "CThumbAGProcessor::QueryPlaceholdersL - end" ); } @@ -871,6 +1063,12 @@ void CThumbAGProcessor::RunL() { TN_DEBUG1( "CThumbAGProcessor::RunL() - begin" ); + + if(iShutdown) + { + TN_DEBUG1( "CThumbAGProcessor::RunL() - shutdown" ); + return; + } if (iSessionDied) { @@ -886,11 +1084,8 @@ iInit = EFalse; iInit2 = ETrue; - iAddQueue.Reset(); - iModifyQueue.Reset(); - iRemoveQueue.ResetAndDestroy(); + iGenerationQueue.Reset(); iQueryQueue.Reset(); - iPlaceholderQueue.Reset(); TRAP_IGNORE(QueryPlaceholdersL()); //query all items after PH query @@ -912,13 +1107,20 @@ err = iHarvesterClient.Connect(); TN_DEBUG2( "CThumbAGProcessor::RunL() iHarvesterClient connect err = %d", err); - __ASSERT_DEBUG((err==KErrNone), User::Panic(_L("CThumbAGProcessor::RunL(), !iHarvesterClient "), err)); + __ASSERT_DEBUG((err == KErrNone), User::Panic(_L("CThumbAGProcessor::RunL(), !iHarvesterClient "), err)); if( err == KErrNone ) { TN_DEBUG1( "CThumbAGProcessor::RunL() add iHarvesterClient observer"); - err = iHarvesterClient.AddHarvesterEventObserver( *this, EHEObserverTypeOverall | EHEObserverTypeMMC | EHEObserverTypePlaceholder, KMaxTInt ); + err = iHarvesterClient.AddHarvesterEventObserver( *this, EHEObserverTypeOverall | EHEObserverTypeMMC | EHEObserverTypePlaceholder, 10 ); TN_DEBUG2( "CThumbAGProcessor::RunL() iHarvesterClient observer err = %d", err); + + if( !err ) + { + TN_DEBUG1( "CThumbAGProcessor::RunL() add iHarvesterClient observer failed"); + // if we fail observer harvester, fake it + iHarvesterActivated = ETrue; + } __ASSERT_DEBUG((err==KErrNone), User::Panic(_L("CThumbAGProcessor::RunL(), !iHarvesterClient "), err)); } #endif @@ -942,7 +1144,6 @@ if (!iTMSession) { TN_DEBUG1( "CThumbAGProcessor::RunL() - open TNM session"); - iActive = EFalse; TRAPD( err, iTMSession = CThumbnailManager::NewL( *this ) ); if (err != KErrNone) @@ -959,19 +1160,11 @@ } // do not run if request is already issued to TNM server even if forced - if( iActive) + if(iActiveCount >= KMaxDaemonRequests) { - if(iActiveCount >= KMaxDaemonRequests) - { - TN_DEBUG1( "CThumbAGProcessor::RunL() - waiting for previous to complete, abort..." ); - return; - } + TN_DEBUG1( "CThumbAGProcessor::RunL() - waiting for previous to complete, abort..." ); + return; } - else - { - iActiveCount = 0; - } - //force run can proceed from this point #ifdef _DEBUG @@ -1029,21 +1222,16 @@ if ( object ) { - TInt itemIndex = iLastQueue->FindInOrder(object->Id(), Compare); - if(itemIndex >= 0) - { - iLastQueue->Remove(itemIndex); - } - //process one item at once //remove item from queryQueue when request is issued - itemIndex = iQueryQueue.FindInOrder(object->Id(), Compare); + + TInt itemIndex = iQueryQueue.FindInOrder(object->Id(), CompareId); if(itemIndex >= 0) { iQueryQueue.Remove(itemIndex); } - TRAP( err, CreateThumbnailsL(object) ); + TRAP( err, CreateThumbnailsL( object ) ); TN_DEBUG2( "CThumbAGProcessor::RunL(), CreateThumbnailsL error == %d", err ); __ASSERT_DEBUG((err==KErrNone), User::Panic(_L("CThumbAGProcessor::RunL(), CreateThumbnailsL() "), err)); } @@ -1071,7 +1259,7 @@ else if( iQueryActive ) { //state mismatch - if(iForceRun && !iModify) + if(iForceRun && !(iModify || iUnknown)) { //cancel query and move items back to original processing queue DeleteAndCancelQuery(ETrue); @@ -1082,10 +1270,20 @@ TN_DEBUG1( "CThumbAGProcessor::RunL() - waiting for query to complete, abort..." ); } } + else if ( iUnknownItemCount > 0 ) + { + TN_DEBUG1( "void CThumbAGProcessor::RunL() unknown items in queue"); + + i2ndRound = EFalse; + iModify = EFalse; + iUnknown = ETrue; + iQueryActive = ETrue; + QueryL( EGenerationItemActionResolveType ); + } // no items in query queue, start new // select queue to process, priority by type - else if ( iModifyQueue.Count() > 0 ) + else if ( iModifyItemCount > 0 ) { TN_DEBUG1( "void CThumbAGProcessor::RunL() update thumbnails"); @@ -1094,54 +1292,77 @@ // query for object info iQueryActive = ETrue; iModify = ETrue; - QueryL( iModifyQueue ); + iUnknown = EFalse; + QueryL( EGenerationItemActionModify ); } - else if ( iAddQueue.Count() > 0 ) + else if ( iAddItemCount > 0 ) { TN_DEBUG1( "void CThumbAGProcessor::RunL() update 1st round thumbnails"); i2ndRound = EFalse; - + iUnknown = EFalse; // query for object info iQueryActive = ETrue; - QueryL( iAddQueue ); + QueryL( EGenerationItemActionAdd ); } - else if ( iRemoveQueue.Count() > 0 ) + else if ( iDeleteItemCount > 0 ) { TN_DEBUG1( "void CThumbAGProcessor::RunL() delete thumbnails"); - i2ndRound = EFalse; - + iUnknown = EFalse; // delete thumbs by URI __ASSERT_DEBUG((iTMSession), User::Panic(_L("CThumbAGProcessor::RunL() !iTMSession "), KErrBadHandle)); if(iTMSession) { - HBufC* uri = iRemoveQueue[0]; - TN_DEBUG2( "void CThumbAGProcessor::RunL() delete %S", uri); - CThumbnailObjectSource* source = NULL; - TRAPD(err, source = CThumbnailObjectSource::NewL( *uri, KNullDesC)); - - if(err == KErrNone) - { - iTMSession->DeleteThumbnails( *source ); + TInt itemIndex(KErrNotFound); + + for(TInt i=0;i= 0) + { + if(!iGenerationQueue[itemIndex].iUri) + { + //URI is invalid + TN_DEBUG1( "void CThumbAGProcessor::RunL() unable to delete URI inbalid"); + iGenerationQueue.Remove( itemIndex ); + ActivateAO(); + return; + } + + TN_DEBUG2( "void CThumbAGProcessor::RunL() delete %S", iGenerationQueue[itemIndex].iUri); + CThumbnailObjectSource* source = NULL; + TRAPD(err, source = CThumbnailObjectSource::NewL( *iGenerationQueue[itemIndex].iUri, KNullDesC)); + + if(err == KErrNone) + { + iTMSession->DeleteThumbnails( *source ); + } + delete source; + + delete iGenerationQueue[itemIndex].iUri; + iGenerationQueue[itemIndex].iUri = NULL; + iGenerationQueue.Remove( itemIndex ); + + iActiveCount++; + } } } - else if( i2ndRoundGenerateQueue.Count() > 0) + else if( i2ndAddItemCount > 0) { TN_DEBUG1( "void CThumbAGProcessor::RunL() update 2nd round thumbnails"); // query for object info iQueryActive = ETrue; i2ndRound = ETrue; - QueryL( i2ndRoundGenerateQueue ); + iUnknown = EFalse; + QueryL( EGenerationItemAction2ndAdd ); } TN_DEBUG1( "CThumbAGProcessor::RunL() - end" ); @@ -1170,18 +1391,22 @@ //move remainig IDs in query queue back to original queue while(iQueryQueue.Count()) { - if(aRestoreItems && iLastQueue) + if(!aRestoreItems ) { - if(iLastQueue->FindInOrder(iQueryQueue[0], Compare) == KErrNotFound) + TThumbnailGenerationItem item; + item.iItemId = iQueryQueue[0]; + TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare); + + if(itemIndex >= 0) { - //ignore if fails - iLastQueue->InsertInOrder(iQueryQueue[0], Compare); + delete iGenerationQueue[itemIndex].iUri; + iGenerationQueue[itemIndex].iUri = NULL; + iGenerationQueue.Remove(itemIndex); } } iQueryQueue.Remove(0); } - iLastQueue = NULL; - + TN_DEBUG1( "CThumbAGProcessor::DeleteAndCancelQuery() out" ); } @@ -1197,10 +1422,20 @@ void CThumbAGProcessor::HarvestingUpdated( HarvesterEventObserverType aHEObserverType, HarvesterEventState aHarvesterEventState, - TInt /*aItemsLeft*/ ) + TInt aItemsLeft ) { - TN_DEBUG3( "CThumbAGProcessor::HarvestingUpdated -- start() aHEObserverType = %d, aHarvesterEventState = %d", aHEObserverType, aHarvesterEventState ); + TN_DEBUG4( "CThumbAGProcessor::HarvestingUpdated -- start() aHEObserverType = %d, aHarvesterEventState = %d, aItemsLeft = %d", aHEObserverType, aHarvesterEventState, aItemsLeft ); + + if(iShutdown) + { + return; + } + if(!iHarvesterActivated) + { + iHarvesterActivated = ETrue; + } + #ifdef _DEBUG if( aHEObserverType == EHEObserverTypePlaceholder) { @@ -1210,6 +1445,10 @@ { TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- type EHEObserverTypeOverall"); } + else if( aHEObserverType == EHEObserverTypeMMC) + { + TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- type EHEObserverTypeMMC"); + } #endif //placeholder harvesting @@ -1245,8 +1484,29 @@ { TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS placeholder harvesting finished"); TRAP_IGNORE(QueryPlaceholdersL()); + iPHHarvestingItemsLeftTemp = 0; } } + + //restart mount timout if PH item count is increasing durin MMC harvesting + if(iMMCHarvesting && iPHHarvesting && aItemsLeft > iPHHarvestingItemsLeftTemp) + { + //if items count increasing, restart mount timeout + TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- PH count increasing, restart mount timeout"); + + if(iMountTimer->IsActive()) + { + iMountTimer->Cancel(); + } + + iMountTimer->Start( KMountTimeout, KMountTimeout, TCallBack(MountTimerCallBack, this)); + } + + //we are interestead of only PHs during MMC harvesting + if( iMMCHarvesting ) + { + iPHHarvestingItemsLeftTemp = aItemsLeft; + } } //overall harvesting else if ( aHEObserverType == EHEObserverTypeOverall) @@ -1275,7 +1535,7 @@ if( iHarvesting ) { - TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS harvesterin started"); + TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS harvesting started"); CancelTimeout(); } else @@ -1283,6 +1543,11 @@ TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS harvesting finished "); // continue processing if needed StartTimeout(); + + if(iMountTimer->IsActive()) + { + iMountTimer->Cancel(); + } } } } @@ -1314,17 +1579,29 @@ if( iMMCHarvesting ) { TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS MMC harvesterin started"); - if(iPreviousItemsLeft != KErrNotReady) - { - iPreviousItemsLeft = KErrNotReady; - RProperty::Set(KTAGDPSNotification, KDaemonProcessing, iPreviousItemsLeft); - } + UpdatePSValues(EFalse, ETrue); + iMMCHarvestingItemsLeftTemp = 0; } else { TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS MMC harvesting finished "); } } + + //restart mount timout if MMC item count is still increasing + if(iMMCHarvesting && aItemsLeft > iMMCHarvestingItemsLeftTemp) + { + TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MMC count increasing, restart mount timeout"); + + if(iMountTimer->IsActive()) + { + iMountTimer->Cancel(); + } + + iMountTimer->Start( KMountTimeout, KMountTimeout, TCallBack(MountTimerCallBack, this)); + } + + iMMCHarvestingItemsLeftTemp = aItemsLeft; } TN_DEBUG4( "CThumbAGProcessor::HarvestingUpdated -- end() iHarvesting == %d, iPHHarvesting == %d iMMCHarvesting == %d ", iHarvesting, iPHHarvesting, iMMCHarvesting); @@ -1339,7 +1616,7 @@ TN_DEBUG1( "CThumbAGProcessor::StartTimeout()"); CancelTimeout(); - if(!iHarvesting && !iMPXHarvesting && !iPeriodicTimer->IsActive()) + if(!iHarvesting && !iMPXHarvesting && !iPeriodicTimer->IsActive() && !iShutdown) { iPeriodicTimer->Start( KHarvestingCompleteTimeout, KHarvestingCompleteTimeout, TCallBack(PeriodicTimerCallBack, this)); @@ -1370,16 +1647,10 @@ { TN_DEBUG2( "CThumbAGrocessor::RunError() %d", aError); - UpdatePSValues(); + UpdatePSValues(EFalse, EFalse); iActiveCount--; - if(iActiveCount <= 0) - { - iActiveCount = 0; - iActive = EFalse; - } - ActivateAO(); // nothing to do @@ -1392,23 +1663,17 @@ // void CThumbAGProcessor::ActivateAO() { -#ifdef _DEBUG - TN_DEBUG6( "CThumbAGProcessor::ActivateAO() items in queue Add = %d, Mod = %d, Del = %d, Query = %d, iPlaceholder = %d", iAddQueue.Count(), iModifyQueue.Count(), iRemoveQueue.Count(), iQueryQueue.Count(), iPlaceholderQueue.Count()); - TN_DEBUG2( "CThumbAGProcessor::ActivateAO() items in queue 2nd Add = %d", i2ndRoundGenerateQueue.Count()); - TN_DEBUG3( "CThumbAGProcessor::ActivateAO() iActive = %d, iActiveCount = %d", iActive, iActiveCount); - TN_DEBUG3( "CThumbAGProcessor::ActivateAO() iHarvesting == %d, iMPXHarvesting == %d", iHarvesting, iMPXHarvesting); - TN_DEBUG4( "CThumbAGProcessor::ActivateAO() iIdle = %d, timer = %d, iForceRun = %d", iIdle, iPeriodicTimer->IsActive(), iForceRun); - TN_DEBUG4( "CThumbAGProcessor::ActivateAO() iModify = %d, iQueryReady = %d, iProcessingCount = %d", iModify, iQueryReady, iProcessingCount); -#endif + UpdateItemCounts(); if(iFormatting) { TN_DEBUG1( "CThumbAGProcessor::ActivateAO() - FORMATTING - DAEMON ON PAUSE"); return; } + //check if forced run needs to continue - if (iModifyQueue.Count()) + if ( iModifyItemCount || iUnknownItemCount > 0 ) { SetForceRun( ETrue ); } @@ -1418,7 +1683,7 @@ SetForceRun( EFalse ); } - if( !IsActive() && ((!iActive && !iQueryActive) || iForceRun )) + if( !IsActive() && !iShutdown && ((iActiveCount == 0 && !iQueryActive) || iForceRun )) { TN_DEBUG1( "CThumbAGProcessor::ActivateAO() - Activated"); SetActive(); @@ -1426,7 +1691,7 @@ User::RequestComplete( statusPtr, KErrNone ); } - UpdatePSValues(); + UpdatePSValues(EFalse, EFalse); } // --------------------------------------------------------------------------- @@ -1515,60 +1780,33 @@ { TN_DEBUG2( "CThumbAGProcessor::RemoveFromQueues() aRemoveFromDelete == %d - begin", aRemoveFromDelete ); - TInt itemIndex = KErrNotFound; + TInt itemIndex(KErrNotFound); for (int i=0; i< aIDArray.Count(); i++) { + TThumbnailGenerationItem item; + item.iItemId = aIDArray[i]; TN_DEBUG2( "CThumbAGProcessor::RemoveFromQueues() - %d", aIDArray[i]); - itemIndex = iPlaceholderQueue.FindInOrder(aIDArray[i], Compare); - if(itemIndex >= 0) - { - iPlaceholderQueue.Remove(itemIndex); - TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iPlaceholderQueue" ); - } - - itemIndex = iAddQueue.FindInOrder(aIDArray[i], Compare); + itemIndex = iGenerationQueue.FindInOrder(item, Compare); if(itemIndex >= 0) { - iAddQueue.Remove(itemIndex); - TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iAddQueue" ); - } - - itemIndex = i2ndRoundGenerateQueue.FindInOrder(aIDArray[i], Compare); - if(itemIndex >= 0) - { - i2ndRoundGenerateQueue.Remove(itemIndex); - TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - i2ndRoundGenerateQueue" ); + delete iGenerationQueue[itemIndex].iUri; + iGenerationQueue[itemIndex].iUri = NULL; + iGenerationQueue.Remove(itemIndex); + TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iGenerationQueue" ); } - - itemIndex = iModifyQueue.FindInOrder(aIDArray[i], Compare); - if(itemIndex >= 0) - { - iModifyQueue.Remove(itemIndex); - TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iModifyQueue" ); - - if( iModifyQueue.Count() == 0) - { - SetForceRun( EFalse ); - } - } - - itemIndex = iQueryQueue.FindInOrder(aIDArray[i], Compare); + + itemIndex = iQueryQueue.FindInOrder(aIDArray[i], CompareId); if(itemIndex >= 0) { iQueryQueue.Remove(itemIndex); TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iQueryQueue" ); } - - itemIndex = iPlaceholderQueue.FindInOrder(aIDArray[i], Compare); - if(itemIndex >= 0) - { - iPlaceholderQueue.Remove(itemIndex); - TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iPlaceholderQueue" ); - } } + ActivateAO(); + TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - end" ); } @@ -1627,13 +1865,13 @@ CMdELogicCondition& rootCondition = iQueryAllItems->Conditions(); rootCondition.SetOperator( ELogicConditionOperatorOr ); - CMdEObjectCondition& imagePHObjectCondition = rootCondition.AddObjectConditionL(imageObjDef); + CMdEObjectCondition& imageObjectCondition = rootCondition.AddObjectConditionL(imageObjDef); - CMdEObjectCondition& videoPHObjectCondition = rootCondition.AddObjectConditionL(videoObjDef); + CMdEObjectCondition& videoObjectCondition = rootCondition.AddObjectConditionL(videoObjDef); - CMdEObjectCondition& audioPHObjectCondition = rootCondition.AddObjectConditionL(audioObjDef); + CMdEObjectCondition& audioObjectCondition = rootCondition.AddObjectConditionL(audioObjDef); - iQueryAllItems->FindL(KMaxTInt, KMaxQueryItems2); + iQueryAllItems->FindL(KMaxTInt, KMaxQueryBatchSize); TN_DEBUG1( "CThumbAGProcessor::QueryAllItemsL - end" ); } @@ -1646,7 +1884,7 @@ // void CThumbAGProcessor::HandleCollectionMessage( CMPXMessage* aMessage, TInt aError ) { - if ( aError != KErrNone || !aMessage ) + if ( aError != KErrNone || !aMessage || iShutdown ) { return; } @@ -1748,8 +1986,7 @@ { iIdle = ETrue; - if(iAddQueue.Count() + iModifyQueue.Count() + iRemoveQueue.Count() + - iQueryQueue.Count() + i2ndRoundGenerateQueue.Count() > 0 ) + if(iGenerationQueue.Count() > 0 ) { ActivateAO(); } @@ -1801,55 +2038,90 @@ // Update KItemsleft PS value if changed // --------------------------------------------------------------------------- // -void CThumbAGProcessor::UpdatePSValues(const TBool aDefine) +void CThumbAGProcessor::UpdatePSValues(const TBool aDefine, const TBool aForce) { - TInt itemsLeft = iModifyQueue.Count() + iAddQueue.Count(); - TBool daemonProcessing = EFalse; + TInt itemsLeft(KErrNotReady); + TBool daemonProcessing = ETrue; - if(itemsLeft + i2ndRoundGenerateQueue.Count() + iRemoveQueue.Count() > 0 ) + if(iShutdown) + { + RProperty::Set(KTAGDPSNotification, KDaemonProcessing, EFalse); + RProperty::Set(KTAGDPSNotification, KItemsleft, 0 ); + return; + } + + if(aDefine) { - daemonProcessing = ETrue; - } - - //adjust items left to containing also items not yet processed but removed from queue under processing - if((iLastQueue == &iModifyQueue || iLastQueue == &iAddQueue) && !i2ndRound) - { - itemsLeft +=iQueryQueue.Count(); + TInt ret = RProperty::Define(KTAGDPSNotification, KDaemonProcessing, RProperty::EInt); + + if( ret != KErrNone ) + { + TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() define KDaemonProcessing ret = %d", ret); + } + + ret = RProperty::Define(KTAGDPSNotification, KItemsleft, RProperty::EInt); + + if( ret != KErrNone ) + { + TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() define KItemsleft ret = %d", ret); + } } - //cancel 2nd round generarion when there is items in 1st round queues - if(itemsLeft && i2ndRound) - { - DeleteAndCancelQuery(ETrue); - i2ndRound = EFalse; - } - - TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() KItemsleft == %d", itemsLeft); + // set itemsleft = KErrNotReady (-18) and daemonProcessing = ETrue if + // - key is initalized + // - mount timer is pending + // - harvester observer is not yet activated + // - single unknown item exists in processing queue + // - forced + if( iMountTimer->IsActive() || aForce || aDefine || iUnknownItemCount + || !iHarvesterActivated ) + { + daemonProcessing = ETrue; + itemsLeft = KErrNotReady; + } + else + { + itemsLeft = iAddItemCount + iModifyItemCount; + } + + TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() KItemsleft == %d", itemsLeft); + + //cancel 2nd round generarion when there is items in 1st round queues + if(iAddItemCount && i2ndRound) + { + DeleteAndCancelQuery(ETrue); + i2ndRound = EFalse; + } - if(aDefine) - { - TN_DEBUG1( "CThumbAGProcessor::UpdatePSValues() define"); - RProperty::Define(KTAGDPSNotification, KDaemonProcessing, RProperty::EInt); - RProperty::Set(KTAGDPSNotification, KDaemonProcessing, 0); - daemonProcessing = EFalse; - RProperty::Define(KTAGDPSNotification, KItemsleft, RProperty::EInt); - RProperty::Set(KTAGDPSNotification, KItemsleft, 0); - iPreviousItemsLeft = 0; - } - - if( daemonProcessing != iPreviousDaemonProcessing) - { - TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() update KDaemonProcessing == %d", daemonProcessing); - iPreviousDaemonProcessing = daemonProcessing; - RProperty::Set(KTAGDPSNotification, KDaemonProcessing, daemonProcessing); - } - - if( itemsLeft != iPreviousItemsLeft) - { - TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() update KItemsleft == %d", itemsLeft); - iPreviousItemsLeft = itemsLeft; - RProperty::Set(KTAGDPSNotification, KItemsleft, itemsLeft ); - } + if( iGenerationQueue.Count() ) + { + daemonProcessing = ETrue; + } + + if( daemonProcessing != iPreviousDaemonProcessing) + { + TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() update KDaemonProcessing == %d", daemonProcessing); + iPreviousDaemonProcessing = daemonProcessing; + TInt ret = RProperty::Set(KTAGDPSNotification, KDaemonProcessing, daemonProcessing); + + if(ret != KErrNone ) + { + TN_DEBUG3( "CThumbAGProcessor::UpdatePSValues() set KDaemonProcessing %d failed %d", daemonProcessing, ret); + } + } + + if( itemsLeft != iPreviousItemsLeft) + { + TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() update KItemsleft == %d", itemsLeft); + iPreviousItemsLeft = itemsLeft; + TInt ret = RProperty::Set(KTAGDPSNotification, KItemsleft, itemsLeft ); + + if(ret != KErrNone ) + { + TN_DEBUG3( "CThumbAGProcessor::UpdatePSValues() set KItemsleft %d failed %d", itemsLeft, ret); + } + } + } // --------------------------------------------------------------------------- @@ -1857,10 +2129,189 @@ // Comparison function for logaritmic use of queue arrays // --------------------------------------------------------------------------- // -TInt CThumbAGProcessor::Compare(const TItemId& aLeft, const TItemId& aRight) + +TInt CThumbAGProcessor::Compare(const TThumbnailGenerationItem& aLeft, const TThumbnailGenerationItem& aRight) + { + return (aLeft.iItemId - aRight.iItemId); + } + +TInt CThumbAGProcessor::CompareId(const TItemId& aLeft, const TItemId& aRight) { return (aLeft - aRight); } +void CThumbAGProcessor::UpdateItemCounts() + { + TN_DEBUG1( "CThumbAGProcessor::UpdateItemCounts()"); + iModifyItemCount = 0; + iDeleteItemCount = 0; + iAddItemCount = 0; + iUnknownItemCount = 0; + i2ndAddItemCount = 0; + iPlaceholderItemCount=0; + iCameraItemCount =0; + iImageItemCount=0; + iVideoItemCount=0; + iAudioItemCount=0; + + for(TInt i=0; i < iGenerationQueue.Count(); i++) + { + TThumbnailGenerationItem& item = iGenerationQueue[i]; + + if(item.iItemAction == EGenerationItemActionModify) + { + iModifyItemCount++; + } + + if(item.iItemAction == EGenerationItemActionDelete) + { + iDeleteItemCount++; + } + + if(item.iItemType == EGenerationItemTypeUnknown) + { + iUnknownItemCount++; + } + if(item.iItemAction == EGenerationItemAction2ndAdd) + { + i2ndAddItemCount++; + } + if(item.iPlaceholder) + { + iPlaceholderItemCount++; + } + if(item.iItemType == EGenerationItemTypeCamera) + { + iCameraItemCount++; + } + if(item.iItemAction == EGenerationItemActionAdd ) + { + iAddItemCount++; + } + if(item.iItemType == EGenerationItemTypeAudio) + { + iAudioItemCount++; + } + if(item.iItemType == EGenerationItemTypeVideo) + { + iVideoItemCount++; + } + if(item.iItemType == EGenerationItemTypeImage) + { + iImageItemCount++; + } + } + + TN_DEBUG2( "CThumbAGProcessor::UpdateItemCounts() iActiveCount = %d", + iActiveCount); + TN_DEBUG5( "CThumbAGProcessor::UpdateItemCounts() iHarvesting == %d, iMMCHarvesting == %d, iPHHarvesting == %d, iMPXHarvesting == %d", + iHarvesting, iMMCHarvesting, iPHHarvesting, iMPXHarvesting); + TN_DEBUG5( "CThumbAGProcessor::UpdateItemCounts() iIdle = %d, iForegroundRun = %d, timer = %d, iForceRun = %d", + iIdle, iForegroundRun, iPeriodicTimer->IsActive(), iForceRun); + TN_DEBUG4( "CThumbAGProcessor::UpdateItemCounts() iModify = %d, iQueryReady = %d, iProcessingCount = %d", + iModify, iQueryReady, iProcessingCount); + TN_DEBUG2( "CThumbAGProcessor::UpdateItemCounts() iMountTimer = %d", iMountTimer->IsActive()); + TN_DEBUG3( "CThumbAGProcessor::UpdateItemCounts() ProcessingQueue = %d, iQueryQueue = %d", + iGenerationQueue.Count(), iQueryQueue.Count()); + TN_DEBUG5( "CThumbAGProcessor::UpdateItemCounts() iAddItemCount=%d, i2ndAddItemCount=%d, iModifyItemCount=%d, iDeleteItemCount=%d", + iAddItemCount, i2ndAddItemCount, iModifyItemCount, iDeleteItemCount ); + TN_DEBUG3( "CThumbAGProcessor::UpdateItemCounts() iUnknownItemCount=%d, iPlaceholderItemCount=%d", + iUnknownItemCount, iPlaceholderItemCount); + TN_DEBUG4( "CThumbAGProcessor::UpdateItemCounts() iAudioItemCount=%d, iVideoItemCount=%d, iImageItemCount=%d", + iAudioItemCount, iVideoItemCount, iImageItemCount); + TN_DEBUG2( "CThumbAGProcessor::UpdateItemCounts() iCameraItemCount=%d", iCameraItemCount); + } + + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::MountTimerCallBack() +// --------------------------------------------------------------------------- +// +TInt CThumbAGProcessor::MountTimerCallBack(TAny* aAny) + { + TN_DEBUG1( "CThumbAGProcessor::MountTimerCallBack()"); + CThumbAGProcessor* self = static_cast( aAny ); + + self->iMountTimer->Cancel(); + + return KErrNone; // Return value ignored by CPeriodic + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::SetGenerationItemAction() +// --------------------------------------------------------------------------- +// +void CThumbAGProcessor::SetGenerationItemAction( TThumbnailGenerationItem& aGenerationItem, TThumbnailGenerationItemType aItemType ) + { + switch( aItemType ) + { + case EGenerationItemTypeAudio: + aGenerationItem.iItemAction = EGenerationItemAction2ndAdd; + break; + case EGenerationItemTypeCamera: + aGenerationItem.iItemAction = EGenerationItemAction2ndAdd; + aGenerationItem.iPlaceholder = ETrue; + break; + case EGenerationItemTypeImage: + aGenerationItem.iItemAction = EGenerationItemActionAdd; + break; + case EGenerationItemTypeVideo: + //S^3 EGenerationItemActionAdd + //S^4 EGenerationItemAction2ndAdd + aGenerationItem.iItemAction = EGenerationItemAction2ndAdd; + break; + default: + aGenerationItem.iItemAction = EGenerationItemActionResolveType; + } + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::SetGenerationItemType() +// --------------------------------------------------------------------------- +// +void CThumbAGProcessor::SetGenerationItemType( TThumbnailGenerationItem& aGenerationItem, const TDefId aDefId ) + { + if(aDefId == iImageObjectDef->Id()) + { + aGenerationItem.iItemType = EGenerationItemTypeImage; + } + else if(aDefId == iAudioObjectDef->Id()) + { + aGenerationItem.iItemType = EGenerationItemTypeAudio; + } + else if(aDefId == iVideoObjectDef->Id()) + { + aGenerationItem.iItemType = EGenerationItemTypeVideo; + } + else + { + aGenerationItem.iItemType = EGenerationItemTypeUnknown; + } + + SetGenerationItemAction( aGenerationItem, aGenerationItem.iItemType ); + } + + +// ----------------------------------------------------------------------------- +// CThumbAGProcessor::AppendProcessingQueue() +// ----------------------------------------------------------------------------- +// +void CThumbAGProcessor::AppendProcessingQueue( TThumbnailGenerationItem& item ) + { + + TInt itemIndex = iGenerationQueue.FindInOrder( item, Compare ); + + if(itemIndex >= 0) + { + iGenerationQueue[itemIndex].iPlaceholder = item.iPlaceholder; + iGenerationQueue[itemIndex].iItemType = item.iItemType; + iGenerationQueue[itemIndex].iItemAction = item.iItemAction; + } + else + { + iGenerationQueue.InsertInOrder(item, Compare); + } + } + // End of file diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagvideoobserver.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagvideoobserver.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -0,0 +1,343 @@ +/* +* Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Thumbnail Auto Generate Daemon +* +*/ + + +#include +#include + +#include +#include +#include +#include + +#include "thumbagvideoobserver.h" +#include "thumbnaillog.h" +#include "thumbnailmanagerconstants.h" +#include "thumbnailmanagerprivatecrkeys.h" + + +// --------------------------------------------------------------------------- +// NewLC +// --------------------------------------------------------------------------- +// +CThumbAGVideoObserver* CThumbAGVideoObserver::NewLC(CThumbAGProcessor* aProcessor) + { + TN_DEBUG1( "CThumbAGVideoObserver::NewLC() - begin" ); + + CThumbAGVideoObserver* self = new (ELeave) CThumbAGVideoObserver(aProcessor); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// --------------------------------------------------------------------------- +// NewL +// --------------------------------------------------------------------------- +// +CThumbAGVideoObserver* CThumbAGVideoObserver::NewL(CThumbAGProcessor* aProcessor) + { + TN_DEBUG1( "CThumbAGVideoObserver::NewL() - begin" ); + + CThumbAGVideoObserver* self = CThumbAGVideoObserver::NewLC(aProcessor); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// CThumbAGVideoObserver +// --------------------------------------------------------------------------- +// +CThumbAGVideoObserver::CThumbAGVideoObserver(CThumbAGProcessor* aProcessor) + : iShutdownObserver(NULL), iMDSShutdownObserver(NULL), iMdESession(NULL), iProcessor(aProcessor) + { + // No implementation required + } + +// --------------------------------------------------------------------------- +// ConstructL +// --------------------------------------------------------------------------- +// +void CThumbAGVideoObserver::ConstructL() + { + TN_DEBUG1( "CThumbAGVideoObserver::ConstructL() - begin" ); + +#ifdef _DEBUG + iAddCounter = 0; + iModCounter = 0; +#endif + + InitializeL(); + + TN_DEBUG1( "CThumbAGVideoObserver::ConstructL() - end" ); + } + +// --------------------------------------------------------------------------- +// ~CThumbAGVideoObserver +// --------------------------------------------------------------------------- +// +void CThumbAGVideoObserver::InitializeL() + { + TN_DEBUG1( "CThumbAGVideoObserver::InitializeL() - begin" ); + + + TN_DEBUG1( "CThumbAGVideoObserver::InitializeL() - create observers" ); + + // create shutdown observer + if(iMDSShutdownObserver) + { + delete iMDSShutdownObserver; + iMDSShutdownObserver = NULL; + } + iMDSShutdownObserver = CTMShutdownObserver::NewL( *this, KMdSPSShutdown, KMdSShutdown, EFalse ); + + if(iShutdownObserver) + { + delete iShutdownObserver; + iShutdownObserver = NULL; + } + iShutdownObserver = CTMShutdownObserver::NewL( *this, KTAGDPSNotification, KShutdown, ETrue ); + iShutdown = EFalse; + + // MDS session reconnect timer + if (!iReconnect) + { + iReconnect = CPeriodic::NewL(CActive::EPriorityIdle); + } + + TN_DEBUG1( "CThumbAGVideoObserver::InitializeL() - connect to MDS" ); + + if(iMdESession) + { + TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); + TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); + + // connect to MDS + delete iMdESession; + iMdESession = NULL; + } + + iMdESession = CMdESession::NewL( *this ); + iSessionError = EFalse; + + TN_DEBUG1( "CThumbAGVideoObserver::InitializeL() - end" ); + } + +// --------------------------------------------------------------------------- +// ~CThumbAGVideoObserver +// --------------------------------------------------------------------------- +// +CThumbAGVideoObserver::~CThumbAGVideoObserver() + { + TN_DEBUG1( "CThumbAGVideoObserver::~CThumbAGVideoObserver() - begin" ); + + iShutdown = ETrue; + + delete iMDSShutdownObserver; + delete iShutdownObserver; + + if(iReconnect) + { + iReconnect->Cancel(); + delete iReconnect; + iReconnect = NULL; + } + + if (iMdESession) + { + // 2 observers + TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); + TRAP_IGNORE( iMdESession->RemoveObjectObserverL( *this ) ); + + delete iMdESession; + iMdESession = NULL; + } + + TN_DEBUG1( "CThumbAGVideoObserver::~CThumbAGVideoObserver() - end" ); + } + +// ----------------------------------------------------------------------------- +// CThumbAGVideoObserver::HandleSessionOpened +// ----------------------------------------------------------------------------- +// +void CThumbAGVideoObserver::HandleSessionOpened( CMdESession& /* aSession */, TInt aError ) + { + TN_DEBUG1( "CThumbAGVideoObserver::HandleSessionOpened"); + + if (aError == KErrNone) + { + TRAPD( err, AddObserversL() ); + if (err != KErrNone) + { + TN_DEBUG2( "CThumbAGVideoObserver::HandleSessionOpened, AddObserversL error == %d", err ); + } + } + else + { + TN_DEBUG2( "CThumbAGVideoObserver::HandleSessionOpened error == %d", aError ); + } + } + +// ----------------------------------------------------------------------------- +// CThumbAGVideoObserver::HandleSessionError +// ----------------------------------------------------------------------------- +// +void CThumbAGVideoObserver::HandleSessionError( CMdESession& /*aSession*/, TInt aError ) + { + TN_DEBUG2( "CThumbAGVideoObserver::HandleSessionError == %d", aError ); + if (aError != KErrNone && !iSessionError) + { + iSessionError = ETrue; + + if (!iShutdown) + { + if (!iReconnect->IsActive()) + { + iReconnect->Start( KMdEReconnect, KMdEReconnect, + TCallBack(ReconnectCallBack, this)); + + TN_DEBUG1( "CThumbAGVideoObserver::HandleSessionError() - reconnect timer started" ); + } + } + + } + } + +// ----------------------------------------------------------------------------- +// CThumbAGVideoObserver::HandleObjectNotification +// ----------------------------------------------------------------------------- +// +void CThumbAGVideoObserver::HandleObjectNotification( CMdESession& /*aSession*/, + TObserverNotificationType aType, + const RArray& aObjectIdArray ) + { + TN_DEBUG1( "CThumbAGVideoObserver::HandleObjectNotification() - begin" ); + + // no processor or shutting down + if ( iShutdown || !iProcessor) + { + return; + } + +#ifdef _DEBUG + if (aType == ENotifyAdd) + { + TN_DEBUG2( "CThumbAGVideoObserver::HandleObjectNotification() - ENotifyAdd %d", aObjectIdArray.Count() ); + iAddCounter = aObjectIdArray.Count(); + } + else if (aType == ENotifyModify) + { + TN_DEBUG2( "CThumbAGVideoObserver::HandleObjectNotification() - ENotifyModify %d", aObjectIdArray.Count() ); + iModCounter = aObjectIdArray.Count(); + } +#endif + + if ( (aType == ENotifyAdd || aType == ENotifyModify ) && (aObjectIdArray.Count() > 0) ) + { + TN_DEBUG1( "CThumbAGVideoObserver::HandleObjectNotification() - AddToQueueL" ); + + // Add event to processing queue by type and enable force run + RPointerArray dummyArray; + TRAPD(err, iProcessor->AddToQueueL(aType, EGenerationItemTypeAudio, aObjectIdArray, dummyArray, EFalse)); + if (err != KErrNone) + { + TN_DEBUG1( "CThumbAGVideoObserver::HandleObjectNotification() - error adding to queue" ); + } + } + else + { + TN_DEBUG1( "CThumbAGVideoObserver::HandleObjectNotification() - bad notification" ); + } + +#ifdef _DEBUG + TN_DEBUG3( "CThumbAGImageObserver::IN-COUNTERS---------- Add = %d Modify = %d", iAddCounter, iModCounter ); + iModCounter = 0; + iAddCounter = 0; +#endif + + TN_DEBUG1( "CThumbAGVideoObserver::HandleObjectNotification() - end" ); + } + +// ----------------------------------------------------------------------------- +// CThumbAGVideoObserver::ShutdownNotification +// ----------------------------------------------------------------------------- +// +void CThumbAGVideoObserver::ShutdownNotification() + { + TN_DEBUG1( "CThumbAGVideoObserver::ShutdownNotification()" ); + + if (!iShutdown) + { + TN_DEBUG1( "CThumbAGVideoObserver::ShutdownNotification() shutdown" ); + iShutdown = ETrue; + } + } + +// --------------------------------------------------------------------------- +// CThumbAGVideoObserver::AddObserversL +// --------------------------------------------------------------------------- +// +void CThumbAGVideoObserver::AddObserversL() + { + TN_DEBUG1( "CThumbAGVideoObserver::AddObserversL() - begin" ); + + CMdENamespaceDef& defaultNamespace = iMdESession->GetDefaultNamespaceDefL(); + CMdEObjectDef& objectDef = defaultNamespace.GetObjectDefL( MdeConstants::Object::KBaseObject ); + CMdEPropertyDef& originPropDef = objectDef.GetPropertyDefL( MdeConstants::Object::KOriginProperty ); + CMdEObjectDef& videoDef = defaultNamespace.GetObjectDefL( MdeConstants::Video::KVideoObject ); + + // set observing conditions + CMdELogicCondition* addCondition = CMdELogicCondition::NewLC( ELogicConditionOperatorAnd ); + addCondition->AddObjectConditionL( videoDef ); + addCondition->AddPropertyConditionL( originPropDef, TMdEUintNotEqual(MdeConstants::Object::ECamera)); + CleanupStack::Pop( addCondition ); + + CMdELogicCondition* modifyCondition = CMdELogicCondition::NewLC( ELogicConditionOperatorAnd ); + modifyCondition->AddObjectConditionL( videoDef ); + addCondition->AddPropertyConditionL( originPropDef, TMdEUintNotEqual(MdeConstants::Object::ECamera)); + CleanupStack::Pop( modifyCondition ); + + // add observer + iMdESession->AddObjectObserverL( *this, addCondition, ENotifyAdd ); + + // modify observer + iMdESession->AddObjectObserverL( *this, modifyCondition, ENotifyModify ); + + TN_DEBUG1( "CThumbAGVideoObserver::AddObserversL() - end" ); + } + +// --------------------------------------------------------------------------- +// CThumbAGVideoObserver::ReconnectCallBack() +// --------------------------------------------------------------------------- +// +TInt CThumbAGVideoObserver::ReconnectCallBack(TAny* aAny) + { + TN_DEBUG1( "CThumbAGVideoObserver::ReconnectCallBack() - reinitialize"); + + CThumbAGVideoObserver* self = static_cast( aAny ); + + self->iReconnect->Cancel(); + + // reconnect to MDS + TRAP_IGNORE( self->InitializeL() ); + + TN_DEBUG1( "CThumbAGVideoObserver::ReconnectCallBack() - done"); + + return KErrNone; + } + + +// End of file diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbnailclient/inc/thumbnailrequestactive.h --- a/imagehandlingutilities/thumbnailmanager/thumbnailclient/inc/thumbnailrequestactive.h Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/thumbnailclient/inc/thumbnailrequestactive.h Wed Jun 23 18:33:48 2010 +0300 @@ -471,6 +471,11 @@ // request already canceled by client TBool iCanceled; +#ifdef __RETRY_ON_SERVERCRASH + //request retry count + TUint iRetry; +#endif + #ifdef _DEBUG TTime iStartExecTime; #endif diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbnailclient/src/thumbnailmanagerimpl.cpp --- a/imagehandlingutilities/thumbnailmanager/thumbnailclient/src/thumbnailmanagerimpl.cpp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/thumbnailclient/src/thumbnailmanagerimpl.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -47,7 +47,11 @@ // CThumbnailManagerImpl::~CThumbnailManagerImpl() { - delete iRequestQueue; + TN_DEBUG1( "CThumbnailManagerImpl::~CThumbnailManagerImpl() - start" ); + + delete iRequestQueue; + iRequestQueue = NULL; + iSession.Close(); iFs.Close(); @@ -65,6 +69,8 @@ } delete iMimeTypeList; + + TN_DEBUG1( "CThumbnailManagerImpl::~CThumbnailManagerImpl() - end" ); } @@ -94,6 +100,7 @@ ( EOptimizeForQuality ), iRequestId( 0 ) { // No implementation required + TN_DEBUG1( "CThumbnailManagerImpl::CThumbnailManagerImpl()" ); } @@ -104,6 +111,8 @@ // void CThumbnailManagerImpl::ConstructL() { + TN_DEBUG1( "CThumbnailManagerImpl::ConstructL - start"); + User::LeaveIfError( iSession.Connect()); User::LeaveIfError( iFs.Connect()); User::LeaveIfError( iFs.ShareProtected()); @@ -129,11 +138,14 @@ { // Fbs connection was available in the beginning, no need to // increase the reference count + TN_DEBUG1( "CThumbnailManagerImpl::ConstructL - no need to update sessionCount"); } } // request processor iRequestQueue = CThumbnailRequestQueue::NewL(); + + TN_DEBUG1( "CThumbnailManagerImpl::ConstructL - end"); } diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbnailclient/src/thumbnailrequestactive.cpp --- a/imagehandlingutilities/thumbnailmanager/thumbnailclient/src/thumbnailrequestactive.cpp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/thumbnailclient/src/thumbnailrequestactive.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -48,11 +48,15 @@ iTimer->Cancel(); } delete iTimer; + iTimer = NULL; ReleaseServerBitmap(); delete iCallbackThumbnail; + iCallbackThumbnail = NULL; delete iParams.iBuffer; + iParams.iBuffer = NULL; delete iBitmap; + iBitmap = NULL; iFile.Close(); iMyFileHandle.Close(); } @@ -89,6 +93,9 @@ CActive( aPriority ), iSession( aThumbnailSession ), iParamsPckg( iParams ), iObserver( aObserver ), iRequestObserver( aRequestObserver ), iFs( aFs ), iBitmapHandle( 0 ), iRequestId( aId ), iRequestQueue( aQueue ), iCanceled( EFalse ) +#ifdef __RETRY_ON_SERVERCRASH + ,iRetry(0) +#endif { CActiveScheduler::Add( this ); TN_DEBUG2( "CThumbnaiRequestActive::CThumbnailRequestActive() AO's priority = %d", Priority()); @@ -572,9 +579,24 @@ { iError = KErrNotFound; } - - TN_DEBUG2( "CThumbnaiRequestActive::HandleError() - iObserver.ThumbnailReady %d", iParams.iRequestId ); - iObserver.ThumbnailReady( iError, *iCallbackThumbnail, iParams.iRequestId ); + +#ifdef __RETRY_ON_SERVERCRASH + if(iError == KErrServerTerminated ) + { + + if(iRetry < KMaxRequestRetryCount ) + { + iRetry++; + TN_DEBUG2( "CThumbnaiRequestActive::HandleError() - KErrServerTerminated, retry %d", iRetry); + iError = KErrNone; + TRAPD(err, StartL()); + return; + } + } +#endif + TN_DEBUG2( "CThumbnaiRequestActive::HandleError() - iObserver.ThumbnailReady %d", iParams.iRequestId ); + iObserver.ThumbnailReady( iError, *iCallbackThumbnail, iParams.iRequestId ); + } iError = KErrNone; diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbnailclient/src/thumbnailsession.cpp --- a/imagehandlingutilities/thumbnailmanager/thumbnailclient/src/thumbnailsession.cpp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/thumbnailclient/src/thumbnailsession.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -31,6 +31,7 @@ RThumbnailSession::RThumbnailSession(): RSessionBase() { // No implementation required + TN_DEBUG1( "RThumbnailSession::RThumbnailSession"); } @@ -40,6 +41,8 @@ // TInt RThumbnailSession::Connect() { + TN_DEBUG1( "RThumbnailSession::Connect - start"); + StartServer(); // special case @@ -54,12 +57,16 @@ // old server still alive, wait and try again while (retry <= 10 && err != KErrNone) { + TN_DEBUG1( "RThumbnailSession::Connect - retry"); + User::After(retry * 50000); StartServer(); err = CreateSession( KThumbnailServerName, Version(), KMessageSlots ); retry++; } + TN_DEBUG1( "RThumbnailSession::Connect - end"); + return err; } @@ -71,6 +78,8 @@ // void RThumbnailSession::Close() { + TN_DEBUG1( "RThumbnailSession::Close"); + RSessionBase::Close(); } @@ -94,23 +103,29 @@ // TInt RThumbnailSession::StartServer() { + TN_DEBUG1( "RThumbnailSession::StartServer - start"); + TInt res( KErrNone ); // create server - if one of this name does not already exist TFindServer findServer( KThumbnailServerName ); TFullName name; if ( findServer.Next( name ) != KErrNone ) - // we don't exist already + // we don't exist already { + TN_DEBUG1( "RThumbnailSession::StartServer - server process doesn't exist yet"); + RProcess server; // Create the server process // KNullDesC param causes server's E32Main() to be run res = server.Create( KThumbnailServerExe, KNullDesC ); if ( res != KErrNone ) - // thread created ok - now start it going { + TN_DEBUG2( "RThumbnailSession::StartServer - error creating process: %d", res); return res; } + + TN_DEBUG1( "RThumbnailSession::StartServer - process created"); // Process created successfully TRequestStatus status; @@ -122,13 +137,18 @@ if ( status != KErrNone ) { + TN_DEBUG2( "RThumbnailSession::StartServer - status: %d, closing", status.Int() ); + server.Close(); return status.Int(); } + // Server created successfully server.Close(); // we're no longer interested in the other process - } + + TN_DEBUG1( "RThumbnailSession::StartServer - end"); + return res; } diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbnailserver/group/thumbnailserver.mmp --- a/imagehandlingutilities/thumbnailmanager/thumbnailserver/group/thumbnailserver.mmp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/thumbnailserver/group/thumbnailserver.mmp Wed Jun 23 18:33:48 2010 +0300 @@ -82,6 +82,7 @@ LIBRARY centralrepository.lib LIBRARY platformenv.lib LIBRARY imageconversion.lib +LIBRARY iclextjpegapi.lib LIBRARY caf.lib LIBRARY cafutils.lib LIBRARY mdeclient.lib diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbnailserver/inc/thumbnailserver.h --- a/imagehandlingutilities/thumbnailmanager/thumbnailserver/inc/thumbnailserver.h Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/thumbnailserver/inc/thumbnailserver.h Wed Jun 23 18:33:48 2010 +0300 @@ -234,6 +234,14 @@ * @return Thumbnail provider. */ CThumbnailProvider* ResolveProviderL( const TDesC8& aMimeType ); + + /** + * Preload provider plugins + * + * @since S^3 + */ + void PreLoadProviders(); + /** * Add thumbnailtask to processor queue. @@ -538,6 +546,20 @@ */ static TInt ReconnectCallBack(TAny* aAny); + /** + * Start unmount timer + * + * @since S60 S^3 + */ + void StartUnmountTimeout( const TInt aDrive); + + /** + * Callback for unmount timer + * + * @since S60 S^3 + */ + static TInt UnmountCallBack(TAny* aAny); + private: /** @@ -690,6 +712,12 @@ // reconnect timer CPeriodic* iReconnect; + + // unmount timer + CPeriodic* iUnmount; + + // array of unmounte + RArray < TInt > iUnmountedDrives; #ifdef _DEBUG TUint32 iPlaceholderCounter; diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailfetchedchecker.cpp --- a/imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailfetchedchecker.cpp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailfetchedchecker.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -96,12 +96,15 @@ if( iNotFetched.Count() < KMaxStoredEntries ) { TInt err = iNotFetched.InsertInOrder( entry, CEntry::InsertCB ); - if ( err != KErrNone ) + if ( err == KErrNone ) { - delete entry; + entry = NULL; // owned by array now } } } + + delete entry; + entry = NULL; } } } diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailscaletask.cpp --- a/imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailscaletask.cpp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailscaletask.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -134,11 +134,15 @@ if ( !iCrop ) { + TN_DEBUG2( "CThumbnailScaleTask(0x%08x)::StartL() - cropping OFF", this ); + // target size at max, keep aspect ratio CalculateTargetSize(); } else { + TN_DEBUG2( "CThumbnailScaleTask(0x%08x)::StartL() - cropping ON", this ); + // exact target size, crop excess CalculateCropRectangle(); } diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailserver.cpp --- a/imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailserver.cpp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailserver.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -234,6 +234,9 @@ REComSession::ListImplementationsL( TUid::Uid( THUMBNAIL_PROVIDER_IF_UID ), iPluginInfoArray ); + //preload provide plugins + PreLoadProviders(); + CTMGetImei * imeiGetter = CTMGetImei::NewLC(); iImei = imeiGetter->GetIMEI(); @@ -252,10 +255,13 @@ iFormatting = EFalse; - //OpenStoresL(); + OpenStoresL(); AddUnmountObserversL(); iFetchedChecker = CThumbnailFetchedChecker::NewL(); + + // Unmount timeout timer + iUnmount = CPeriodic::NewL(CActive::EPriorityIdle); } @@ -269,6 +275,15 @@ iShutdown = ETrue; + if(iUnmount) + { + iUnmount->Cancel(); + delete iUnmount; + iUnmount = NULL; + } + + iUnmountedDrives.Close(); + delete iFetchedChecker; delete iShutdownObserver; delete iProcessor; @@ -318,9 +333,13 @@ // CThumbnailServer::HandleSessionOpened // ----------------------------------------------------------------------------- // +#ifdef _DEBUG +void CThumbnailServer::HandleSessionOpened( CMdESession& /* aSession */, TInt aError ) +#else void CThumbnailServer::HandleSessionOpened( CMdESession& /* aSession */, TInt /*aError*/ ) +#endif { - TN_DEBUG1( "CThumbnailServer::HandleSessionOpened"); + TN_DEBUG2( "CThumbnailServer::HandleSessionOpened error == %d", aError ); } // ----------------------------------------------------------------------------- @@ -444,12 +463,12 @@ if ( iSessionCount <= 0 ) { - // rename thread - User::RenameThread( KThumbnailServerShutdown ); - // server shutdown if (!iShutdown) { + // rename thread + User::RenameThread( KThumbnailServerShutdown ); + CActiveScheduler::Stop(); iShutdown = ETrue; } @@ -462,8 +481,10 @@ // void CThumbnailServer::ShutdownNotification() { + TN_DEBUG1( "CThumbnailServer::ShutdownNotification()"); if (!iShutdown) { + TN_DEBUG1( "CThumbnailServer::ShutdownNotification() shutdown"); CActiveScheduler::Stop(); iShutdown = ETrue; } @@ -775,6 +796,22 @@ // ----------------------------------------------------------------------------- +// CThumbnailServer::GetProviderL() +// ----------------------------------------------------------------------------- +// +void CThumbnailServer::PreLoadProviders( ) + { + TN_DEBUG1( "CThumbnailServer::PreLoadProvidersL()" ); + TInt err(KErrNone); + + for(TInt i=0; i< iPluginInfoArray.Count(); i++) + { + TRAP(err, GetProviderL( iPluginInfoArray[i]->ImplementationUid())); + } + } + + +// ----------------------------------------------------------------------------- // CThumbnailServer::QueueTaskL() // Adds thumbnailtask to processor queue. // ----------------------------------------------------------------------------- @@ -887,6 +924,13 @@ CThumbnailStore* CThumbnailServer::StoreForDriveL( const TInt aDrive ) { TN_DEBUG2( "CThumbnailServer::StoreForDriveL() drive=%d", aDrive ); + + if(iUnmountedDrives.Find( aDrive ) >= KErrNone) + { + TN_DEBUG1( "CThumbnailServer::StoreForDriveL() unmount in progress, skip!"); + User::Leave( KErrDisMounted ); + } + CThumbnailStore** resPtr = iStores.Find( aDrive ); CThumbnailStore* res = NULL; @@ -901,8 +945,10 @@ TN_DEBUG1( "CThumbnailServer::StoreForDriveL() - FORMATTING! - ABORT"); User::Leave( KErrNotSupported ); } + TVolumeInfo volumeInfo; TInt err = iFs.Volume( volumeInfo, aDrive ); + if ( err || volumeInfo.iDrive.iDriveAtt& KDriveAttRom || volumeInfo.iDrive.iDriveAtt& KDriveAttRemote || volumeInfo.iDrive.iMediaAtt& KMediaAttWriteProtected || @@ -912,14 +958,14 @@ // must be read-write and not locked. User::Leave( KErrAccessDenied); } - + res = CThumbnailStore::NewL( iFs, aDrive, iImei, this ); CleanupStack::PushL( res ); iStores.InsertL( aDrive, res ); res->SetPersistentSizes(iPersistentSizes); CleanupStack::Pop( res ); - for(TInt i = 0; iStartNotify(); } @@ -1002,6 +1048,8 @@ TN_DEBUG2( "CThumbnailServer::CloseStoreForDriveL drive=%d", aDrive); CThumbnailStore** store = iStores.Find( aDrive ); + StartUnmountTimeout( aDrive); + if (store) { delete *store; @@ -1098,15 +1146,44 @@ TInt err_drive = iFs.Drive(driveInfo, drive); // mount -- if removable drive, add new store - if (!err && !err_drive && driveInfo.iDriveAtt& KDriveAttRemovable) + if (!err && !err_drive + && driveInfo.iType != EMediaNotPresent + && driveInfo.iDriveAtt& KDriveAttRemovable ) { + TN_DEBUG2( "CThumbnailServer::MemoryCardStatusChangedL mount drive==%d", drive); + + CThumbnailStore** resPtr = iStores.Find( drive ); + + if ( resPtr ) + { + TN_DEBUG2( "CThumbnailServer::MemoryCardStatusChangedL() already mounted, skip %d", drive); + continue; + } + // ignore errors - //TRAP_IGNORE( StoreForDriveL( drive )); + TRAP_IGNORE( StoreForDriveL( drive )); + + TN_DEBUG2( "CThumbnailServer::MemoryCardStatusChangedL() update KItemsleft == %d", KErrNotReady); + RProperty::Set(KTAGDPSNotification, KItemsleft, KErrNotReady ); + + TInt index = iUnmountedDrives.Find( drive ); + + if(index >= KErrNone) + { + iUnmountedDrives.Remove( index ); + } + + if(!iUnmountedDrives.Count()&& iUnmount && iUnmount->IsActive()) + { + TN_DEBUG1( "CThumbnailServer::MemoryCardStatusChangedL() cancel unmount timer"); + iUnmount->Cancel(); + } } //dismount -- if removable drive, close store - else if(err && !err_drive && driveInfo.iDriveAtt& KDriveAttRemovable) + else if(err && !err_drive && driveInfo.iDriveAtt& KDriveAttRemovable ) { + TN_DEBUG2( "CThumbnailServer::MemoryCardStatusChangedL() unmount drive==%d", drive); CloseStoreForDriveL( drive); } } @@ -1665,3 +1742,48 @@ return ETrue; } +// --------------------------------------------------------------------------- +// CThumbnailServer::StartUnmount() +// --------------------------------------------------------------------------- +// +void CThumbnailServer::StartUnmountTimeout( const TInt aDrive) + { + TN_DEBUG2( "CThumbnailServer::StartUnmountTimeout(%d)", aDrive); + + if(iUnmount ) + { + if(iUnmountedDrives.Find( aDrive ) == KErrNotFound) + { + iUnmountedDrives.Append( aDrive ); + } + + if(iUnmount->IsActive()) + { + iUnmount->Cancel(); + } + + TN_DEBUG1( "CThumbnailServer::StartUnmountTimeout() start unmount timer"); + iUnmount->Start( KUnmountTimerTimeout, KUnmountTimerTimeout, TCallBack(UnmountCallBack, this)); + } + __ASSERT_DEBUG(( iUnmount ), ThumbnailPanic( EThumbnailNullPointer )); + } + + +// --------------------------------------------------------------------------- +// CThumbnailServer::ReconnectCallBack() +// --------------------------------------------------------------------------- +// +TInt CThumbnailServer::UnmountCallBack(TAny* aAny) + { + TN_DEBUG1( "CThumbnailServer::UnmountCallBack() - unmount finished"); + + CThumbnailServer* self = static_cast( aAny ); + + self->iUnmount->Cancel(); + + self->iUnmountedDrives.Reset(); + + TN_DEBUG1( "CThumbAGDaemon::UnmountCallBack() - done"); + + return KErrNone; + } diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailserversession.cpp --- a/imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailserversession.cpp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailserversession.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -444,6 +444,7 @@ const TThumbnailRequestParams& params = iRequestParams(); RFile64 file; + CleanupClosePushL(file); User::LeaveIfError( file.AdoptFromClient( aMessage, 2, 3 )); ResolveMimeTypeL(&file); @@ -461,9 +462,10 @@ if (params.iControlFlags == EThumbnailGeneratePersistentSizesOnly) { TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - EThumbnailGeneratePersistentSizesOnly" ); - CleanupClosePushL( file ); CreateGenerateTaskFromFileHandleL( &file ); - CleanupStack::Pop( &file ); + + // ownership of the file transferred + CleanupStack::Pop(&file); } // single thumbnail request else @@ -477,13 +479,16 @@ aMessage.Complete( err ); iMessage = RMessage2(); + + // close file + CleanupStack::PopAndDestroy(&file); } else if ( !err && iBitmap ) { TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - found existing thumbnail - bitmap " ); // Thumbnail already stored - file.Close(); + CleanupStack::PopAndDestroy(&file); TN_DEBUG1("CThumbnailServerSession::RequestThumbByFileHandleAsyncL - file handle closed"); ProcessBitmapL(); @@ -493,6 +498,9 @@ { TN_DEBUG1( "CThumbnailServerSession::RequestThumbByFileHandleAsyncL() - KErrNotFound & !EDoNotCreate" ); CreateGenerateTaskFromFileHandleL( &file); + + // ownership of the file transferred + CleanupStack::Pop(&file); } else if (!err && iBuffer) { @@ -511,7 +519,9 @@ //CThumbnailDecodeTask is responsible freeing iBuffer = NULL; - file.Close(); + + // close file + CleanupStack::PopAndDestroy(&file); TN_DEBUG1("CThumbnailServerSession::RequestThumbByFileHandleAsyncL - file handle closed"); } else @@ -520,6 +530,9 @@ aMessage.Complete( ConvertSqlErrToE32Err( err )); iMessage = RMessage2(); + + // close file + CleanupStack::PopAndDestroy(&file); } } } @@ -1099,16 +1112,6 @@ { TThumbnailRequestParams& params = iRequestParams(); - // in import case store bitmap - if ( params.iTargetUri != KNullDesC && params.iFileName != KNullDesC && - params.iFileName.CompareF(params.iTargetUri) != 0 ) - { - Server()->StoreThumbnailL( params.iTargetUri, iBitmap, iOriginalSize, - params.iFlags& CThumbnailManager::ECropToAspectRatio, - params.iThumbnailSize, params.iModified, - EFalse, EFalse); - } - if ( ClientThreadAlive() ) { TN_DEBUG2("CThumbnailServerSession::ProcessBitmapL(), iBitmap handle= 0x%08x", iBitmap->Handle()); diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailstore.cpp --- a/imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailstore.cpp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailstore.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -212,11 +212,6 @@ iMaintenanceTimer = NULL; } - if(!iServer->IsFormatting()) - { - FlushCacheTable( ETrue ); - } - CloseStatements(); iDatabase.Close(); @@ -571,7 +566,7 @@ stmt.Close(); - if(ret < 0) + if(rowStatus < 0) { #ifdef _DEBUG TPtrC errorMsg2 = iDatabase.LastErrorMessage(); @@ -596,7 +591,7 @@ stmt.Close(); - if(ret < 0) + if( rowStatus < 0) { #ifdef _DEBUG TPtrC errorMsg2 = iDatabase.LastErrorMessage(); @@ -648,7 +643,7 @@ stmt.Close(); - if(ret < 0 ) + if( rowStatus < 0 ) { #ifdef _DEBUG TPtrC errorMsg = iDatabase.LastErrorMessage(); @@ -699,7 +694,7 @@ stmt.Close(); - if(ret < 0 ) + if( rowStatus < 0 ) { #ifdef _DEBUG TPtrC errorMsg = iDatabase.LastErrorMessage(); @@ -1267,7 +1262,39 @@ HBufC8* data = NULL; CleanupStack::PushL( data ); - CImageEncoder* encoder = CImageEncoder::DataNewL( data, KJpegMime(), CImageEncoder::EOptionAlwaysThread ); + CImageEncoder* encoder = NULL; + TRAPD( decErr, encoder = CExtJpegEncoder::DataNewL( CExtJpegEncoder::EHwImplementation, data, CImageEncoder::EOptionAlwaysThread ) ); + if ( decErr != KErrNone ) + { + TN_DEBUG2( "CThumbnailStore::StoreThumbnailL( public ) - HW CExtJpegEncoder failed %d", decErr); + + TRAPD( decErr, encoder = CExtJpegEncoder::DataNewL( CExtJpegEncoder::ESwImplementation, data, CImageEncoder::EOptionAlwaysThread ) ); + if ( decErr != KErrNone ) + { + TN_DEBUG2( "CThumbnailStore::StoreThumbnailL( public ) - SW CExtJpegEncoder failed %d", decErr); + + TRAPD( decErr, encoder = CImageEncoder::DataNewL( data, KJpegMime(), CImageEncoder::EOptionAlwaysThread ) ); + if ( decErr != KErrNone ) + { + TN_DEBUG2( "CThumbnailStore::StoreThumbnailL( public ) - CImageEncoder failed %d", decErr); + + User::Leave(decErr); + } + else + { + TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( public ) - CImageEncoder created" ); + } + } + else + { + TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( public ) - SW CExtJpegEncoder created" ); + } + } + else + { + TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( public ) - HW CExtJpegEncoder created" ); + } + CleanupStack::Pop( data ); CleanupStack::PushL( encoder ); diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/tmcommon/src/tmactivitymanager.cpp --- a/imagehandlingutilities/thumbnailmanager/tmcommon/src/tmactivitymanager.cpp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/tmcommon/src/tmactivitymanager.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -53,12 +53,15 @@ { TN_DEBUG1( "CTMActivityManager::~CTMActivityManager()"); + iObserver = NULL; + Cancel(); + #ifdef MONITOR_LIGHTS delete iLight; iLight = NULL; #endif - - Cancel(); + + iTimer.Cancel(); iTimer.Close(); } diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/tmcommon/src/tmformatobserver.cpp --- a/imagehandlingutilities/thumbnailmanager/tmcommon/src/tmformatobserver.cpp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/tmcommon/src/tmformatobserver.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -81,6 +81,7 @@ } delete iBackupSession; + iBackupSession = NULL; } // --------------------------------------------------------------------------- diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/tmcommon/src/tmshutdownobserver.cpp --- a/imagehandlingutilities/thumbnailmanager/tmcommon/src/tmshutdownobserver.cpp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/tmcommon/src/tmshutdownobserver.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -20,6 +20,7 @@ #include "tmshutdownobserver.h" #include "thumbnailmanagerconstants.h" +#include "thumbnaillog.h" // --------------------------------------------------------------------------- // CTMShutdownObserver::NewL() @@ -60,19 +61,23 @@ // void CTMShutdownObserver::ConstructL() { + TN_DEBUG1( "CTMShutdownObserver::ConstructL()" ); // define P&S property types if (iDefineKey) { + TN_DEBUG1( "CTMShutdownObserver::ConstructL() define" ); RProperty::Define(iKeyCategory,iPropertyKey, RProperty::EInt,KAllowAllPolicy,KPowerMgmtPolicy); } // attach to the property TInt err = iProperty.Attach(iKeyCategory,iPropertyKey,EOwnerThread); + TN_DEBUG2( "CTMShutdownObserver::ConstructL() attach err = %d", err ); User::LeaveIfError(err); // wait for the previously attached property to be updated iProperty.Subscribe(iStatus); + TN_DEBUG1( "CTMShutdownObserver::ConstructL() subscribe" ); SetActive(); } @@ -82,6 +87,7 @@ // CTMShutdownObserver::~CTMShutdownObserver() { + TN_DEBUG1( "CTMShutdownObserver::~CTMShutdownObserver()" ); Cancel(); iProperty.Close(); } @@ -92,13 +98,16 @@ // void CTMShutdownObserver::RunL() { + TN_DEBUG2( "CTMShutdownObserver::RunL(%d)", iStatus.Int() ); // resubscribe before processing new value to prevent missing updates iProperty.Subscribe(iStatus); SetActive(); // retrieve the value TInt value = 0; - iProperty.Get(value); + TInt err = iProperty.Get(value); + + TN_DEBUG2( "CTMShutdownObserver::RunL() Get err = %d", err ); // observer callback if (value) @@ -113,6 +122,7 @@ // void CTMShutdownObserver::DoCancel() { + TN_DEBUG1( "CTMShutdownObserver::DoCancel()" ); iProperty.Cancel(); } diff -r cb86b71cae0a -r 4bdfb6b5c9b4 imagehandlingutilities/thumbnailmanager/tmiadrestart/src/tmiadrestart.cpp --- a/imagehandlingutilities/thumbnailmanager/tmiadrestart/src/tmiadrestart.cpp Fri Jun 11 13:58:45 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/tmiadrestart/src/tmiadrestart.cpp Wed Jun 23 18:33:48 2010 +0300 @@ -19,12 +19,14 @@ #include #include #include +#include "thumbnaillog.h" #include "thumbnailmanagerconstants.h" LOCAL_C void MainL() { // delay so that cenrep has time to read new config + TN_DEBUG1( "MainL() after" ); User::After(5000000); TInt res( KErrNone ); @@ -32,50 +34,66 @@ TFullName name; // find and terminate Thumb AG Daemon + TN_DEBUG1( "MainL() KTAGDaemonProcess find" ); TFindProcess findProcess( KTAGDaemonProcess ); + if ( findProcess.Next(name) == KErrNone ) { res = process.Open(name); + TN_DEBUG2( "MainL() KTAGDaemonProcess open res = %d", res ); // logon to get termination signal TRequestStatus status; + TN_DEBUG1( "MainL() KTAGDaemonProcess logon" ); process.Logon(status); - + // shutdown using P&S key - RProperty::Set(KTAGDPSNotification,KShutdown,1); - + TN_DEBUG2( "MainL() KTAGDaemonProcess Set = %d", res ); + res = RProperty::Set(KTAGDPSNotification,KShutdown,1); + // blocks here until thread is terminated - User::WaitForRequest(status); + TN_DEBUG1( "MainL() KTAGDaemonProcess wait" ); + User::WaitForRequest(status); // reset key - RProperty::Set(KTAGDPSNotification,KShutdown,0); + TN_DEBUG1( "MainL() KTAGDaemonProcess reset" ); + res = RProperty::Set(KTAGDPSNotification, KShutdown, 0); + TN_DEBUG1( "MainL() KTAGDaemonProcess close" ); process.Close(); } // find and terminate Thumbnail Server TFindProcess findProcess2( KThumbnailServerProcess ); + TN_DEBUG1( "MainL() KThumbnailServerProcess find" ); if ( findProcess2.Next(name) == KErrNone ) { res = process.Open(name); - + TN_DEBUG2( "MainL() KThumbnailServerProcess open res = %d", res ); + // logon to get termination signal TRequestStatus status; + TN_DEBUG1( "MainL() KThumbnailServerProcess logon" ); process.Logon(status); // shutdown using P&S key - RProperty::Set(KTMPSNotification,KShutdown,1); + TN_DEBUG2( "MainL() KThumbnailServerProcess Set res = %d", res ); + res = RProperty::Set(KTMPSNotification,KShutdown,1); // blocks here until thread is terminated - User::WaitForRequest(status); + TN_DEBUG1( "MainL() KThumbnailServerProcess wait" ); + User::WaitForRequest(status); // reset key - RProperty::Set(KTMPSNotification,KShutdown,0); - + TN_DEBUG2( "MainL() KThumbnailServerProcess reset res = %d", res ); + res = RProperty::Set(KTMPSNotification, KShutdown, 0); + + TN_DEBUG1( "MainL() KThumbnailServerProcess close" ); process.Close(); } // delay just in case old daemon hasn't died yet + TN_DEBUG1( "MainL() after" ); User::After(2500000); // start new ThumbAGDaemon @@ -84,29 +102,38 @@ // Create the server process // KNullDesC param causes server's E32Main() to be run + TN_DEBUG2( "MainL() KTAGDaemonExe create res = %d", res ); res = server.Create( KTAGDaemonExe, KNullDesC ); // try again 3 times if fails while ( res != KErrNone) { + TN_DEBUG1( "MainL() KTAGDaemonExe retry" ); if (retryCount > 2) { + TN_DEBUG1( "MainL() KTAGDaemonExe retry > 2" ); return; } + TN_DEBUG1( "MainL() after" ); User::After(2500000); + TN_DEBUG2( "MainL() KTAGDaemonExe create res = %d", res ); res = server.Create( KTAGDaemonExe, KNullDesC ); - retryCount++; } // Process created successfully TRequestStatus status; + TN_DEBUG1( "MainL() Rendezvous" ); server.Rendezvous( status ); + TN_DEBUG1( "MainL() Resume" ); server.Resume(); // start it going + // Wait until the completion of the server creation + TN_DEBUG1( "MainL() wait" ); User::WaitForRequest( status ); + TN_DEBUG1( "MainL() wait done" ); // Server created successfully server.Close(); // we're no longer interested in the other process