/*

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

*

*/

#include "CHouseKeepingHandler.h"

#include "CHeartBeatTimer.h"

#include "CLogPlayerRecorder.h"

#include "CCPixAsyncronizer.h"

TBool CHouseKeepingHandler::iCallBackValid = EFalse;

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

// CHouseKeepingHandler::NewL

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

//

CHouseKeepingHandler* CHouseKeepingHandler::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

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

// CHouseKeepingHandler::~CHouseKeepingHandler

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

//

CHouseKeepingHandler::~CHouseKeepingHandler()

	{

	iCallBackValid = EFalse;

	delete iHeartBeatTimer;

	delete iAsyncronizer;

	}

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

// CHouseKeepingHandler::StartL

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

//

void CHouseKeepingHandler::StartL()

    {

    if ( !iHeartBeatTimer )

        {

        iHeartBeatTimer = CHeartBeatTimer::NewL(this);

        }

    }

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

// CHouseKeepingHandler::StopHouseKeeping()

// Stop housekeeping

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

//

void CHouseKeepingHandler::StopHouseKeeping()

    {

    iHeartBeatTimer->StopTimer();

    }

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

// CHouseKeepingHandler::ContinueHouseKeeping()

// Continue housekeeping

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

//

void CHouseKeepingHandler::ContinueHouseKeeping()

    {

    iHeartBeatTimer->ContinueTimer();

    }

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

// CHouseKeepingHandler::ForceHouseKeeping()

// Force housekeeping

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

//

void CHouseKeepingHandler::ForceHouseKeeping()

    {

    DoHouseKeeping();

    }

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

// CHouseKeepingHandler::StartL

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

//

void CHouseKeepingHandler::CompletionCallback(void *aCookie, cpix_JobId aJobId)

    {

    if ( !iCallBackValid )

        {

        // CPiX layer could call this callback function after CHouseKeepingHandler

        // is already deleted.

        return;

        }

    CHouseKeepingHandler* object = (CHouseKeepingHandler*)aCookie;

    // Sanity check

    if (!object || object->iPendingJobId != aJobId)

        {

        return;

        }

    // Call the asyncronizers completion code

    CCPixAsyncronizer* asyncronizer = object->iAsyncronizer;

    asyncronizer->CompletionCallback();

    }

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

// CSearchServer::HandleHeartBeatL()

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

//

void CHouseKeepingHandler::HandleHeartBeatL()

    {

    DoHouseKeeping();

    }

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

// CSearchServer::HandleAsyncronizerComplete()

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

//

void CHouseKeepingHandler::HandleAsyncronizerComplete(TCPixTaskType /*aType*/,

        TInt aError, const RMessage2& /*aMessage*/)

    {

    iIsPending = EFalse;

    if (aError == KErrNone)

        {

        cpix_Result result;

        cpix_asyncDoHousekeepingResults(&result, iPendingJobId);

        cpix_ClearError(&result);

        }

    }

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

// CHouseKeepingHandler::CHouseKeepingHandler

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

//

CHouseKeepingHandler::CHouseKeepingHandler()

	{

	iCallBackValid = ETrue;

	}

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

// CHouseKeepingHandler::ConstructL

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

//

void CHouseKeepingHandler::ConstructL()

	{

	iAsyncronizer = CCPixAsyncronizer::NewL();

	}

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

// CHouseKeepingHandler::DoHouseKeeping

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

//

void CHouseKeepingHandler::DoHouseKeeping()

    {

    if ( iIsPending )

        {

        // Sanity check. If previous house keeping operation is still 

        // ongoing just ignore house keeping this time.

        return;

        }

    cpix_Result result;

    iPendingJobId = cpix_asyncDoHousekeeping(&result, (void*)this, &CompletionCallback);

    TRAP_IGNORE( LOG_PLAYER_RECORD( CLogPlayerRecorder::LogHouseKeepL() ) );

    if ( cpix_Failed( &result ) )

        {

        // Clean error to avoid memory leaks.

        cpix_ClearError(&result);

        }

    else

        {

        iAsyncronizer->Start(ECPixTaskTypeHouseKeeping, this, iMessage);

        iIsPending = ETrue;

        }

    }