/*

* Copyright (c) 2008-2009 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 Composer plugin

*

*/

/**

 * @internal reviewed 12/07/2007 by Simon Brooks

 */

#include <e32base.h>

#include <MdELogicCondition.h>

#include <mdeconstants.h>

#include <mpxcollectionutility.h>

#include <mpxcollectionpath.h>

#include <mpxcollectionmessage.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcollectionframeworkdefs.h>

#include <glxassert.h>

#include <glxcollectionpluginall.hrh>

#include <glxthumbnailattributeinfo.h>

#include <glxbackgroundtnmessagedefs.h>

#include <glxmediaid.h>

#include <glxthumbnailinfo.h>

#include <glxfilterfactory.h>

#include <glxcommandfactory.h>

#include <glxtracer.h>

#include <hal.h>

#include "glxthumbnailcomposerplugin.h"

// This can be any number other than zero

const TUint KGlxBackgroundThumbnailAttributeId = 1;

const TInt KGlxThumbnailComposerInactivityTimeout = 30; // seconds

const TInt KGlxThumbnailComposerDelay = 10000; // microseconds

const TInt KGlxThumbnailComposerHarvestDelay = 5000000; // microseconds

const TInt KGlxThumbnailComposerLargeDelay = 30000000; // microseconds

const TInt KGlxDisplayStatusTimeOutDelay = 5000000; // 5 secs

// ---------------------------------------------------------------------------

// destructor

// ---------------------------------------------------------------------------

//

CGlxThumbnailCompeserInactivityTimer::~CGlxThumbnailCompeserInactivityTimer()

    {

    // no implementation

    }

// ---------------------------------------------------------------------------

// NewL

// ---------------------------------------------------------------------------

//

CGlxThumbnailCompeserInactivityTimer* CGlxThumbnailCompeserInactivityTimer::NewL(TInt aPriority, CGlxThumbnailComposerPlugin& aCallback)

    {

	TRACER("CGlxThumbnailCompeserInactivityTimer::NewL");

	CGlxThumbnailCompeserInactivityTimer* self = 

	                              new (ELeave) CGlxThumbnailCompeserInactivityTimer(aPriority, aCallback);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	CActiveScheduler::Add(self);

	return self;

    }

// ---------------------------------------------------------------------------

// After

// ---------------------------------------------------------------------------

//

void CGlxThumbnailCompeserInactivityTimer::After( TTimeIntervalMicroSeconds32 aInterval )

    {

    TRACER("CGlxThumbnailCompeserInactivityTimer::After");

    // Fix for ELLZ-7DBBDZ and JPKN-7M2AYJ: to prevent a KERN EXEC 15 panic that occurs 

    // if a timer request is made while one is already outstanding.

    Cancel();

    // Forward the call on to the base class.

    CTimer::After( aInterval );

    }

// ---------------------------------------------------------------------------

// constructor

// ---------------------------------------------------------------------------

//

CGlxThumbnailCompeserInactivityTimer::CGlxThumbnailCompeserInactivityTimer(TInt aPriority, CGlxThumbnailComposerPlugin& aCallback)

         : CTimer(aPriority), iCallback(aCallback)

        {

        // no implementation

        }

// ---------------------------------------------------------------------------

// RunL

// ---------------------------------------------------------------------------

//

void CGlxThumbnailCompeserInactivityTimer::RunL()

    {

	TRACER("CGlxThumbnailCompeserInactivityTimer::RunL");

    TInt dispState = KErrNotFound;

    TInt ret = HAL::Get(HALData::EDisplayState, dispState);

    GLX_DEBUG4("CGlxThumbnailCompeserInactivityTimer::RunL iCallback.iState = %d, ret=%d, dispState= %d", 

    																iCallback.iState, ret, dispState );

	if (iCallback.iState && ret == KErrNone && dispState)

		{

		iCallback.DelayDisplayStateCheck();

	    GLX_LOG_INFO("GlxThumbnailCompeser - DISPLAY ON - DO NOT PROCESS" );

		return;

		}

	GLX_LOG_INFO("GlxThumbnailCompeser - DISPLAY OFF - ALLOW TO PROCESS" );

	switch (iCallback.iState)

	    {

    	case CGlxThumbnailComposerPlugin::EStateFirstOpening:

    	case CGlxThumbnailComposerPlugin::EStateOpening:

    	    {

            iCallback.DoOpenCollectionL();

            break;

    	    }

        case CGlxThumbnailComposerPlugin::EStateActiveSmall:

        case CGlxThumbnailComposerPlugin::EStateActiveLarge:

            {

        	iCallback.DoRequestItemL();

        	break;

            }

        case CGlxThumbnailComposerPlugin::EStateClosing:

            {

            iCallback.CloseCollection();

            break;

            }

	    }

    }

// ---------------------------------------------------------------------------

// DoCancel

// ---------------------------------------------------------------------------

//

void CGlxThumbnailCompeserInactivityTimer::DoCancel()

    {

    // no implementation

    }

// ---------------------------------------------------------------------------

// RunError

// ---------------------------------------------------------------------------

//

TInt CGlxThumbnailCompeserInactivityTimer::RunError(TInt /*aError*/)

    {

	TRACER("CGlxThumbnailCompeserInactivityTimer::RunError");

    iCallback.ReturnToIdle();

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// NewL

// ---------------------------------------------------------------------------

//

CGlxThumbnailComposerPlugin* CGlxThumbnailComposerPlugin::NewL()

	{

	TRACER("CGlxThumbnailComposerPlugin::NewL");

	CGlxThumbnailComposerPlugin* self = 

	                              new (ELeave) CGlxThumbnailComposerPlugin();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

// ---------------------------------------------------------------------------

// ~CGlxThumbnailComposerPlugin

// ---------------------------------------------------------------------------

//

CGlxThumbnailComposerPlugin::~CGlxThumbnailComposerPlugin()

	{

	delete iPath;

    if (iCollectionUtility)

        {

        iCollectionUtility->Close();

        }

	if ( iInactivityTimer )

	    {

    	iInactivityTimer->Cancel();

	    }

	delete iInactivityTimer;

	}

// ---------------------------------------------------------------------------

// CGlxThumbnailComposerPlugin

// ---------------------------------------------------------------------------

//

CGlxThumbnailComposerPlugin::CGlxThumbnailComposerPlugin() : iLastError(KErrNone)

	{

	}

// ---------------------------------------------------------------------------

// ConstructL

// ---------------------------------------------------------------------------

//

void CGlxThumbnailComposerPlugin::ConstructL()

	{

	TRACER("CGlxThumbnailComposerPlugin::ConstructL");

	iInactivityTimer = CGlxThumbnailCompeserInactivityTimer::NewL(CActive::EPriorityIdle, *this);

	}

// ---------------------------------------------------------------------------

// SetObservers

// ---------------------------------------------------------------------------

//

void CGlxThumbnailComposerPlugin::SetObservers()

	{

	TRAPD(err, SetObserversL());

    GLX_ASSERT_ALWAYS( KErrNone == err, Panic( EGlxPanicEnvironment ),

                        "CGlxThumbnailComposerPlugin cannot set observers, reset Harvester server" );

	}

// ---------------------------------------------------------------------------

// SetObserversL

// ---------------------------------------------------------------------------

//

void CGlxThumbnailComposerPlugin::SetObserversL()

	{

	TRACER("CGlxThumbnailComposerPlugin::SetObserversL");

	if ( iSession )

		{

		CMdELogicCondition* condition = 

		            CMdELogicCondition::NewLC( ELogicConditionOperatorOr );

#ifdef RD_MDS_2_0

		CMdENamespaceDef* defaultNamespace = 

		               iSession->GetDefaultNamespaceDefL();

    	CMdEObjectDef* imageDef = defaultNamespace->GetObjectDefL(

    	                                MdeConstants::Image::KImageObject );

		condition->AddObjectConditionL( *imageDef );

    	CMdEObjectDef* videoDef = defaultNamespace->GetObjectDefL(

    	                                MdeConstants::Video::KVideoObject );

		condition->AddObjectConditionL( *videoDef );

#else

		CMdENamespaceDef& defaultNamespace = 

		               iSession->GetDefaultNamespaceDefL();

    	CMdEObjectDef& imageDef = defaultNamespace.GetObjectDefL(

    	                                MdeConstants::Image::KImageObject );

		condition->AddObjectConditionL( imageDef );

    	CMdEObjectDef& videoDef = defaultNamespace.GetObjectDefL(

    	                                MdeConstants::Video::KVideoObject );

		condition->AddObjectConditionL( videoDef );

#endif

		iSession->AddObjectObserverL( *this, condition );

    	CleanupStack::Pop( condition );

        if ( iState == EStateIdle )

            {

            iState = EStateFirstOpening;

            iInactivityTimer->After(KGlxThumbnailComposerLargeDelay);

            }

		}

	}

// ---------------------------------------------------------------------------

// RemoveObservers

// ---------------------------------------------------------------------------

//

void CGlxThumbnailComposerPlugin::RemoveObservers()

	{

	if ( iSession )

		{

#ifdef RD_MDS_2_0

		iSession->RemoveObjectObserver( *this );

#else

		TRAP_IGNORE(iSession->RemoveObjectObserverL( *this ));

#endif

		}

	}

// ---------------------------------------------------------------------------

// IsComposingComplete

// ---------------------------------------------------------------------------

//

TBool CGlxThumbnailComposerPlugin::IsComposingComplete()

	{

	TRACER("CGlxThumbnailComposerPlugin::IsComposingComplete");

	// Need to stop background thumbnail generation activity

	// when harvester requests to pause. 

	    if (iState != EStateIdle)

	        {

	        iState = EStateClosing;

	        if ( iInactivityTimer )

	            {

	            iInactivityTimer->Cancel();

	            }

	        if (iCollectionUtility)

	            {

	            iCollectionUtility->Close();

	            iCollectionUtility = NULL;

	            }

	        iState = EStateIdle;

	        }

	    return ETrue ; //( iState == EStateIdle );

	}

#ifdef RD_MDS_2_0

// ---------------------------------------------------------------------------

// HandleObjectAdded

// ---------------------------------------------------------------------------

//

void CGlxThumbnailComposerPlugin::HandleObjectAdded(

        CMdESession& /*aSession*/, const RArray<TItemId>& /*aObjectIdArray*/ )

	{

	TRACER("CGlxThumbnailComposerPlugin::HandleObjectAdded");

    if ( ( iState == EStateIdle ) || ( iState == EStateFirstOpening ) || ( iState == EStateClosing ) )

        {

        iInactivityTimer->Cancel();

        iState = EStateOpening;

        iInactivityTimer->After(20000000);

        }

    else

        {

        iLastError = 1;

        iState = EStateActiveLarge;

        }

	}

// ---------------------------------------------------------------------------

// HandleObjectModified

// ---------------------------------------------------------------------------

//

void CGlxThumbnailComposerPlugin::HandleObjectModified(

                                    CMdESession& /*aSession*/, 

                                    const RArray<TItemId>& /*aObjectIdArray*/)

	{

	//no implemention needed

	}

// ---------------------------------------------------------------------------

// HandleObjectRemoved

// ---------------------------------------------------------------------------

//

void CGlxThumbnailComposerPlugin::HandleObjectRemoved(

                                    CMdESession& /*aSession*/, 

                                    const RArray<TItemId>& /*aObjectIdArray*/)

	{

	//no implemention needed

	}

#else

void CGlxThumbnailComposerPlugin::HandleObjectNotification(CMdESession& /*aSession*/, 

					TObserverNotificationType aType,

					const RArray<TItemId>& /*aObjectIdArray*/)

	{

	TRACER("CGlxThumbnailComposerPlugin::HandleObjectNotification");

    if (aType == ENotifyAdd)

    	{

			if ( iState == EStateIdle )

		        {

		        iState = EStateOpening;

		        iInactivityTimer->After(KGlxThumbnailComposerLargeDelay);

		        }

		    else

		        {

		        iLastError = 1;

		        iState = EStateActiveLarge;

		        iInactivityTimer->After(KGlxThumbnailComposerLargeDelay);

		        }

    	}

	}

#endif

// ---------------------------------------------------------------------------

// HandleCollectionMediaL

// ---------------------------------------------------------------------------

//

void CGlxThumbnailComposerPlugin::HandleCollectionMediaL(

                                const CMPXMedia& /*aMedia*/, TInt aError )

    {

	TRACER("CGlxThumbnailComposerPlugin::HandleCollectionMediaL");

    if ( iPath && KErrNone != aError )

        {

        GLX_LOG_WARNING1( "Error %d getting media", aError );

        // Error generating thumbnails, try the next item

        iLastError = aError;

        iCurrentIndex++;

        RequestItemL();

        }

    }

// ---------------------------------------------------------------------------

// HandleCollectionMessageL

// ---------------------------------------------------------------------------

//

void CGlxThumbnailComposerPlugin::HandleCollectionMessage(

                                        CMPXMessage* aMsg, TInt /*aErr*/ )

    {

	TRACER("CGlxThumbnailComposerPlugin::HandleCollectionMessage");

    if ( iState != EStateIdle && aMsg )

        {

        TRAPD( err, DoHandleCollectionMessageL( *aMsg ) );

        if ( KErrNone != err )

            {

            GLX_LOG_WARNING1( "Error %d handling message", err );

            ReturnToIdle();

            }

        }

    }

// ---------------------------------------------------------------------------

// HandleOpenL

// ---------------------------------------------------------------------------

//

void CGlxThumbnailComposerPlugin::HandleOpenL( const CMPXMedia& /*aEntries*/,

                          TInt /*aIndex*/, TBool /*aComplete*/, TInt aError )

    {

	TRACER("CGlxThumbnailComposerPlugin::HandleOpenL");

    if ( KErrNone != aError )

        {

        GLX_LOG_WARNING1( "Error %d opening collection", aError );

        ReturnToIdle();

        }

    }

// ---------------------------------------------------------------------------

// HandleOpenL

// ---------------------------------------------------------------------------

//

void CGlxThumbnailComposerPlugin::HandleOpenL(

            const CMPXCollectionPlaylist& /*aPlaylist*/, TInt /*aError*/ )

    {

	// No implemention needed

    }

// ---------------------------------------------------------------------------

// HandleCommandComplete

// ---------------------------------------------------------------------------

//

void CGlxThumbnailComposerPlugin::HandleCommandComplete(

                        CMPXCommand* /*aCommandResult*/, TInt /*aError*/ )

    {

	TRACER("CGlxThumbnailComposerPlugin::HandleCommandComplete");

    if( EStateCleanup == iState )

        {

        ReturnToIdle();

        }

    else

        {

        iInactivityTimer->After(0);

        }

    }

// ---------------------------------------------------------------------------

// DoOpenCollectionL

// ---------------------------------------------------------------------------

//

void CGlxThumbnailComposerPlugin::DoOpenCollectionL()

    {

	TRACER("CGlxThumbnailComposerPlugin::HandleCollectionMediaL");

    if ( !iCollectionUtility )

        {

        // Open isolated collection utility

        iCollectionUtility = MMPXCollectionUtility::NewL(

                                                this, KMcModeIsolated );

        }

    CMPXFilter* filter = CMPXFilter::NewL();

    CleanupStack::PushL(filter);

    filter->SetTObjectValueL<TGlxFilterSortDirection>(KGlxFilterGeneralSortDirection, EGlxFilterSortDirectionDescending);        

    iCollectionUtility->Collection().SetFilterL(filter);

    CleanupStack::PopAndDestroy(filter);

    CMPXCollectionPath* path = CMPXCollectionPath::NewL();

    CleanupStack::PushL( path );

    // argument  path  all collection id

   	path->AppendL( KGlxCollectionPluginAllImplementationUid );

	iCollectionUtility->Collection().OpenL( *path );

 	CleanupStack::PopAndDestroy( path );

    iState = EStateActiveSmall;                    

    }

// ---------------------------------------------------------------------------

// DoHandleCollectionMessageL

// ---------------------------------------------------------------------------

//

void CGlxThumbnailComposerPlugin::DoHandleCollectionMessageL(

                                                 const CMPXMessage& aMsg )

    {

	TRACER("CGlxThumbnailComposerPlugin::DoHandleCollectionMessageL");

    if ( aMsg.IsSupported( KMPXMessageGeneralId ) )

        {

        TInt messageId = aMsg.ValueTObjectL<TInt>( KMPXMessageGeneralId );

	    // Is it a background thumbnail message