/*

* 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:  Processor 

*

*/

#include <e32base.h>

#include <mdeconstants.h>

#include <centralrepository.h>

#include <mpxcollectionutility.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcollectionmessage.h>

#include <coreapplicationuisdomainpskeys.h> 

#include "thumbagprocessor.h"

#include "thumbnaillog.h"

#include "thumbnailmanagerconstants.h"

#include "thumbnailmanagerprivatecrkeys.h"

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

// CThumbAGProcessor::NewL()

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

//

CThumbAGProcessor* CThumbAGProcessor::NewL()

    {

    TN_DEBUG1( "CThumbAGProcessor::NewL() - begin" );

    CThumbAGProcessor* self = new( ELeave )CThumbAGProcessor();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CThumbAGProcessor::CThumbAGProcessor()

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

//

CThumbAGProcessor::CThumbAGProcessor(): CActive( CActive::EPriorityStandard )

    {

    TN_DEBUG1( "CThumbAGProcessor::CThumbAGProcessor() - begin" );

    CActiveScheduler::Add( this );

    }

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

// CThumbAGProcessor::ConstructL()

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

//

void CThumbAGProcessor::ConstructL()

    {

    TN_DEBUG1( "CThumbAGProcessor::ConstructL() - begin" );

    iTMSession = CThumbnailManager::NewL( *this );

    iQueryAllItems = NULL;

    iQueryPlaceholders = NULL;

    iQuery = NULL;

    iQueryActive = EFalse;

    iModify = EFalse;

    iProcessingCount = 0;

    iActiveCount = 0;

    // set auto create values from cenrep

    CheckAutoCreateValuesL();

    iPeriodicTimer = CPeriodic::NewL(CActive::EPriorityIdle);

    SetForceRun( EFalse );    

    iActive = EFalse;

    iFormatObserver = CTMFormatObserver::NewL( *this );

    iFormatting = EFalse;     

    iSessionDied = EFalse;

    iCollectionUtility = NULL;

    iActivityManager = CTMActivityManager::NewL( this, KBackgroundGenerationIdle);

    UpdatePSValues(ETrue);

    if(iForegroundGenerationObserver)

      {

      delete iForegroundGenerationObserver;

      iForegroundGenerationObserver = NULL;

      }

    RProperty::Define(KTAGDPSNotification, KMPXHarvesting, RProperty::EInt);

	//start foreground generation observer

    iForegroundGenerationObserver = CTMRPropertyObserver::NewL( *this, KTAGDPSNotification, KForceBackgroundGeneration, ETrue );  

    TN_DEBUG1( "CThumbAGProcessor::ConstructL() - end" );

    }

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

// CThumbAGProcessor::~CThumbAGProcessor()

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

//

CThumbAGProcessor::~CThumbAGProcessor()

    {

    TN_DEBUG1( "CThumbAGProcessor::~CThumbAGProcessor() - begin" );

    if(iForegroundGenerationObserver)

      {

      delete iForegroundGenerationObserver;

      iForegroundGenerationObserver = NULL;

      }

    if(iActivityManager)

        {

        delete iActivityManager;

        iActivityManager = NULL;

        }

    if (iInactivityTimer)

        {

        iInactivityTimer->Cancel();

        delete iInactivityTimer;

        iInactivityTimer = NULL;

        }

    if(iPeriodicTimer)

        {

        iPeriodicTimer->Cancel();

        delete iPeriodicTimer;

        }

    if (!iInit)

        {

        iHarvesterClient.RemoveHarvesterEventObserver(*this);

        }

    if ( iCollectionUtility )

        {

        iCollectionUtility->Close();

        iCollectionUtility = NULL;

        }

    Cancel();

    if(iQueryPlaceholders)

        {

        iQueryPlaceholders->Cancel();

        delete iQueryPlaceholders;

        iQueryPlaceholders = NULL;

        }

    if (iQuery)

        {

        iQuery->Cancel();

        delete iQuery;

        iQuery = NULL;

        }

    if (iQueryAllItems)

       {

       iQueryAllItems->Cancel();

       delete iQueryAllItems;

       iQueryAllItems = NULL;

       }

    iAddQueue.Close();

    iModifyQueue.Close();

    iRemoveQueue.ResetAndDestroy();

    iQueryQueue.Close();

    iPlaceholderQueue.Close();

    i2ndRoundGenerateQueue.Close();

    if (iTMSession)

        {

        delete iTMSession;

        iTMSession = NULL;

        }

    delete iFormatObserver;

    TN_DEBUG1( "CThumbAGProcessor::~CThumbAGProcessor() - end" );

    }

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

// CThumbAGProcessor::HandleQueryNewResults()

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

//

void CThumbAGProcessor::HandleQueryNewResults( CMdEQuery& /*aQuery*/,

                                               const TInt /*aFirstNewItemIndex*/,

                                               const TInt /*aNewItemCount*/ )

    {

    // No implementation required

    }

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

// CThumbAGProcessor::HandleQueryCompleted()

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

//

void CThumbAGProcessor::HandleQueryCompleted( CMdEQuery& aQuery, const TInt aError )

    {

    TN_DEBUG3( "CThumbAGProcessor::HandleQueryCompleted, aError == %d Count== %d", aError, aQuery.Count());

    if(&aQuery == iQueryPlaceholders)

        {

        TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted - iQueryPlaceholders completed");

        iPlaceholderQueue.Reset();

        // if no errors in query

        if (aError == KErrNone )

            {

            for(TInt i = 0; i < iQueryPlaceholders->Count(); i++)

               {    

               const CMdEObject* object = &iQueryPlaceholders->Result(i);

               if(!object)

                   {

                   continue;

                   }

               if(!object->Placeholder())

                   {

                   TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted %d not placeholder", object->Id());

                   continue;

                   }

               /*if (iPlaceholderQueue.Find( object->Id() ) == KErrNotFound)

                   {

                   TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted %d added to placeholder queue", object->Id());*/

                   TRAP_IGNORE( iPlaceholderQueue.AppendL( object->Id() )); 

                 //}

               }

           }

           delete iQueryPlaceholders;

           iQueryPlaceholders = NULL;

        }

    else if(&aQuery == iQueryAllItems)

        {

        TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted - QueryAllItems completed");

        // if no errors in query

        if (aError == KErrNone )

            {

            for(TInt i = 0; i < iQueryAllItems->Count(); i++)

                {    

                const CMdEObject* object = &iQueryAllItems->Result(i);

                if(!object)

                    {

                    continue;

                    }

                if (iAddQueue.Find( object->Id() ) == KErrNotFound && iModifyQueue.Find( object->Id()) == KErrNotFound  )

                    {

                    TRAP_IGNORE( iAddQueue.AppendL( object->Id() ));

                    }

                }

#ifdef _DEBUG

TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted IN-COUNTERS---------- Amount: %d, Add",iQueryAllItems->Count());

#endif

            }

            //free query

            delete iQueryAllItems;

            iQueryAllItems = NULL;

        }

    else if(&aQuery == iQuery )

        {

        TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted - Query completed");

        if(iQueryActive)

            {

            iQueryReady = ETrue;

            iQueryActive = EFalse;

            }

        // if no errors in query

        if (aError == KErrNone && iQuery)

            {

            iProcessingCount = iQuery->Count();

            if( !iProcessingCount)

                {

                delete iQuery;

                iQuery = NULL;

                iProcessingCount = 0;

                iModify = EFalse;

                }

            }

        else

            {

            TInt itemIndex(KErrNotFound);

            //cleanup current queue

            while(iQueryQueue.Count())

                {

                itemIndex = iLastQueue->Find(iQueryQueue[0]);

                if(itemIndex >= 0)

                    {

                    iLastQueue->Remove( itemIndex );

                    }

                iQueryQueue.Remove(0);

                }

            delete iQuery;

            iQuery = NULL;

            iProcessingCount = 0;

            TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted() Query FAILED!");   

            }

        }

    else

        {

        TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted() - NO QUERY ACTIVE"); 

        __ASSERT_DEBUG((EFalse), User::Panic(_L("CThumbAGProcessor::HandleQueryCompleted()"), -1));

        }

    ActivateAO();

    }

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

// CThumbAGProcessor::ThumbnailPreviewReady()

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

//

void CThumbAGProcessor::ThumbnailPreviewReady( MThumbnailData& /*aThumbnail*/, 

                                               TThumbnailRequestId /*aId*/)

    {

    TN_DEBUG1( "CThumbAGProcessor::ThumbnailPreviewReady()");

    // No implementation required

    }

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

// CThumbAGProcessor::ThumbnailReady()

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

//

void CThumbAGProcessor::ThumbnailReady( TInt aError, MThumbnailData& /*aThumbnail*/,

                                        TThumbnailRequestId /*aId*/ )

    {

    TN_DEBUG2( "CThumbAGProcessor::ThumbnailReady() aError == %d", aError );

    iActiveCount--;

    if(iActiveCount <= 0)

        {

        iActiveCount = 0;

        iActive = EFalse;

        }

    // TNM server died, delete session

    if( aError == KErrServerTerminated )

        {

        TN_DEBUG1( "CThumbAGProcessor::ThumbnailReady() - **** THUMBNAIL SERVER DIED ****" );

        iSessionDied = ETrue;

        if( !iPeriodicTimer->IsActive())

            {

            StartTimeout();

			}

        //reset PS idle so that RunL() can startup reopen TNM session and proceed

        TInt ret = RProperty::Set(KServerIdle, KIdle, ETrue);

        TN_DEBUG2( "CThumbAGProcessor::ThumbnailReady() set Idle ret = %d", ret );

        return;

        }

    ActivateAO();

    TN_DEBUG1( "CThumbAGProcessor::ThumbnailReady() - end" );

    }

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

// CThumbAGProcessor::SetMdESession()

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

//

void CThumbAGProcessor::SetMdESession( CMdESession* aMdESession )

    {

    TN_DEBUG1( "CThumbAGProcessor::SetMdESession() - begin" );

    iMdESession = aMdESession;

    __ASSERT_DEBUG((iMdESession), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iMdESession "), KErrBadHandle));

    TRAPD( err, iDefNamespace = &iMdESession->GetDefaultNamespaceDefL() );

    if (err != KErrNone)

        {

        TN_DEBUG2( "CThumbAGProcessor::SetMdESession() GetDefaultNamespaceDefL() err = %d", err );

        }

    __ASSERT_DEBUG((iDefNamespace), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iDefNamespace "), KErrBadHandle));

    //do async init

    iInit = ETrue;

	ActivateAO();

    }

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

// CThumbAGProcessor::AddToQueue()

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

//

void CThumbAGProcessor::AddToQueueL( TObserverNotificationType aType, 

                                    const RArray<TItemId>& aIDArray, 

                                    const RPointerArray<HBufC>& aObjectUriArray,

                                    TBool /*aPresent*/ )

    {

    TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - begin" );

    // update queues

    if (aType == ENotifyAdd)

        {

        TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyAdd" );

        for (int i=0; i<aIDArray.Count(); i++)

            {

            // do not to append to Add queue if exist already in Add or 2nd Add queue (just processed)     

            if (iAddQueue.Find( aIDArray[i] ) == KErrNotFound && i2ndRoundGenerateQueue.Find( aIDArray[i] ) == KErrNotFound)

                {

                iAddQueue.AppendL(aIDArray[i]);

                }

            }

        }

    else if (aType == ENotifyModify)

        {

        TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyModify" );

        if(iPHHarvesting)

            {

            TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - PH  harvesting active, treat like add" );

            for (int i=0; i<aIDArray.Count(); i++)

                {

                TInt itemIndex = iPlaceholderQueue.Find( aIDArray[i] );

                if (itemIndex >= 0)

                    {

                    TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - remove from placeholder queue");

                    iPlaceholderQueue.Remove( itemIndex );

                    }