/*

* Copyright (c) 2010 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:  MDE object queuemanager for indexing scheduling

 *

*/

#include "mdeobjectqueuemanager.h"

#include "harvesterserverlogger.h"

// DEFINES

#define INDEXING_QUEUE_MAX 300 // Maximum number of objects in the queue

#define INDEXING_DELAY 3000000 // Nano seconds to delay the monitored object

#define MAX_RETRY_COUNT    3   //maximum number of retry on not found object

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

// CCPixIndexerUtils::NewL()

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

//

CMdeObjectQueueManager* CMdeObjectQueueManager::NewL(MMediaObjectHandler* aHandler)

    {

    CMdeObjectQueueManager* self = CMdeObjectQueueManager::NewLC(aHandler);

    CleanupStack::Pop();

    return self;

    }

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

// CCPixIndexerUtils::NewLC()

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

//

CMdeObjectQueueManager* CMdeObjectQueueManager::NewLC(MMediaObjectHandler* aHandler)

    {

    CMdeObjectQueueManager* self = new (ELeave) CMdeObjectQueueManager(aHandler);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CCPixIndexerUtils::~CMdeObjectQueueManager()

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

//

CMdeObjectQueueManager::~CMdeObjectQueueManager()

    {

    Cancel();

    iTimer.Close();

    }

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

// CCPixIndexerUtils::CMdeObjectQueueManager()

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

//

CMdeObjectQueueManager::CMdeObjectQueueManager(MMediaObjectHandler* aHandler):

                        CActive(CActive::EPriorityStandard),

                        iState(EStateNone),

                        iMdeObjectHandler(aHandler)

    {

    }

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

// CCPixIndexerUtils::ConstructL()

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

//

void CMdeObjectQueueManager::ConstructL()

    {

    CActiveScheduler::Add(this);

    User::LeaveIfError(iTimer.CreateLocal());

    iHState = EStateResume;

    }

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

// CCPixIndexerUtils::AddMdeItemToQueueL()

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

//

void CMdeObjectQueueManager::AddMdeItemToQueueL( TItemId aMsgId, 

                                                 TCPixActionType aActionType)

    {

    OverWriteOrAddToQueueL(aMsgId,aActionType);    

    ActivateAO();

    }

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

// CCPixIndexerUtils::OverWriteOrAddToQueueL()

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

//

void CMdeObjectQueueManager::OverWriteOrAddToQueueL( TItemId aObjId, 

                                                     TCPixActionType aActionType)

    {

    // Overwrite or add the index to the queue

    TMdeActionRecord object;

    object.iObjectId = aObjId;

    object.iAction = aActionType;

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

    {

        if (iJobQueue[i].iObjectId ==aObjId)

        {

            // Older version found

            iJobQueue[i] = object;

            return;

        }

    }

    // older not found, append

    iJobQueue.AppendL(object);    

    }

void CMdeObjectQueueManager::ActivateAO()

    {

    // Proceed only if the plugin is not in pause state 

    if ( iHState == EStateResume )

        {

        // Check the size against maximum queue size

        if (iJobQueue.Count() > INDEXING_QUEUE_MAX)

            {

            // Maximum is exceeded, force the write immediately

            if (iState == EStateWaiting)

                {

                }

            else if (iState == EStateNone)

                {

                }

            }

        else

            {

            // Maximum is not exceeded, keep waiting

            if (iState == EStateNone)

                {

                }

            }

        }

    }

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

// CCPixIndexerUtils::RunL()

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

//

void CMdeObjectQueueManager::RunL()

    {

    CPIXLOGSTRING("START CMdeObjectQueueManager::RunL");

    if ( iHState == EStatePause )

        {

        iState = EStateNone;

        CPIXLOGSTRING("END CMdeObjectQueueManager::RunL as Harvester in Pause state");  

        return;          

        }

        {

        TMdeActionRecord object = iJobQueue[0];

        //iJobQueue.Remove(0);

        //Let the indexer handle this object TRAP it as it can leave

        TRAPD(err,iMdeObjectHandler->HandleMdeItemL(object.iObjectId, object.iAction));

        /*Process the Item for three time maximum if in case not able to be found from

          MDS*/

        if(KErrNone == err)

            {

            iJobQueue.Remove(0);

            }

        else if(KErrNotFound == err && object.iRetryCount < MAX_RETRY_COUNT)

                {

                iJobQueue.Remove(0); //remove existing and add new one 

                object.iRetryCount++;

                iJobQueue.AppendL(object);

                CPIXLOGSTRING3("CMdeObjectQueueManager::RunL HandleMdeItemL Item Not found err = %d, iRetry = %d",err,object.iRetryCount); 

                }

        else

            {

            iJobQueue.Remove(0);  //retry count exceeded remove it

            }

        }

#ifdef __PERFORMANCE_DATA

        iMdeObjectHandler->UpdateLogL();

#endif

        // Everything is indexed no need to be waiting anymore

        CPIXLOGSTRING("END CMdeObjectQueueManager::RunL");    

    }

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

// CCPixIndexerUtils::DoCancel()

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

//

void CMdeObjectQueueManager::DoCancel()

    {

    iTimer.Cancel();

    iState = EStateNone; 

    }

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

// CCPixIndexerUtils::RunError()

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

//

TInt CMdeObjectQueueManager::RunError()

    {

    return KErrNone;

    }

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

// CCPixIndexerUtils::PauseL()

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

//

void CMdeObjectQueueManager::PauseL()

    {

    iHState = EStatePause;

    }

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

// CCPixIndexerUtils::ResumeL()

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

//

void CMdeObjectQueueManager::ResumeL()

    {

    iHState = EStateResume;

    ActivateAO();       

    }

//End of file