/*

* Copyright (c) 2005-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:  Phonebook 2 compress policy manager.

*

*/

#include "CPbk2CompressPolicyManager.h"

// Phonebook 2

#include "CPbk2CompressPolicyTimer.h"

#include "CPbk2CompressPolicyDiskSpace.h"

#include <MPbk2StoreObservationRegister.h>

// Virtual Phonebook

#include <CVPbkContactManager.h>

#include <MVPbkContactOperationBase.h>

// System includes

#include <systemwarninglevels.hrh>

// Debugging headers

#include <Pbk2Debug.h>

/// Unnamed namespace for local definitions

namespace {

 /// Time (in seconds) to wait after last database event before starting

 /// compression. The timeout tries to prevent compression from starting

 /// if there is a lot of database activity.

const TInt KIntervalInSeconds(10);

#ifdef _DEBUG

enum TPanic

    {

    EPreCondPanic_OperationComplete = 1,

    EPreCondPanic_AlreadyExist

    };

_LIT(KPanicCat, "CPbk2CompressPolicyManager");

void Panic(TPanic aPanic)

    {

    User::Panic(KPanicCat, aPanic);

    }

#endif // _DEBUG

} /// namespace

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

// CPbk2CompressPolicyManager::CPbk2CompressPolicyManager

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

//

CPbk2CompressPolicyManager::CPbk2CompressPolicyManager

        ( MPbk2StoreObservationRegister& aStoreObservationRegister,

          CVPbkContactManager& aContactManager ) :

            iStoreObservationRegister( aStoreObservationRegister ),

            iContactManager( aContactManager )

    {

    }

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

// CPbk2CompressPolicyManager::~CPbk2CompressPolicyManager

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

//

CPbk2CompressPolicyManager::~CPbk2CompressPolicyManager()

    {

    iPolicyArray.ResetAndDestroy();

    delete iCompressOperation;

    }

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

// CPbk2CompressPolicyManager::NewL

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

//

CPbk2CompressPolicyManager* CPbk2CompressPolicyManager::NewL

        ( MPbk2StoreObservationRegister& aStoreObservationRegister,

          CVPbkContactManager& aContactManager )

    {

    CPbk2CompressPolicyManager* self =

        new ( ELeave ) CPbk2CompressPolicyManager

            ( aStoreObservationRegister, aContactManager );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CPbk2CompressPolicyManager::ConstructL

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

//

void CPbk2CompressPolicyManager::ConstructL()

    {

    ConstructPoliciesL();

    }

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

// CPbk2CompressPolicyManager::CompressStores

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

//

void CPbk2CompressPolicyManager::CompressStores()

    {

    __ASSERT_DEBUG( !iCompressOperation, Panic(EPreCondPanic_AlreadyExist));

    TRAPD( err,

        iCompressOperation = iContactManager.CompressStoresL( *this ) );

    if (err != KErrNone)

        {

        // if error occured here, restart all policies

        StartAllPolicies();

        }

    }

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

// CPbk2CompressPolicyManager::CancelCompress

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

//

void CPbk2CompressPolicyManager::CancelCompress()

    {

    delete iCompressOperation;

    iCompressOperation = NULL;

    }

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

// CPbk2CompressPolicyManager::StartAllPolicies

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

//

void CPbk2CompressPolicyManager::StartAllPolicies()

    {

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

        {

        MPbk2CompressPolicy* policy = iPolicyArray[i];

        policy->Start();

        }

    }

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

// CPbk2CompressPolicyManager::StopAllPolicies

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

//

void CPbk2CompressPolicyManager::StopAllPolicies()

    {

    CancelCompress();

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

        {

        iPolicyArray[i]->Stop();

        }

    }

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

// CPbk2CompressPolicyManager::StepComplete

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

//

void CPbk2CompressPolicyManager::StepComplete

        ( MVPbkContactOperationBase& /*aOperation*/, TInt /*aStepSize*/ )

    {

    // Do nothing

    }

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

// CPbk2CompressPolicyManager::StepFailed

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

//

TBool CPbk2CompressPolicyManager::StepFailed

        ( MVPbkContactOperationBase& /*aOperation*/, TInt /*aStepSize*/,

          TInt /*aError*/ )

    {

    // The process should be stopped

    return EFalse;

    }

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

// CPbk2CompressPolicyManager::OperationComplete

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

//

void CPbk2CompressPolicyManager::OperationComplete

        ( MVPbkContactOperationBase& PBK2_DEBUG_ONLY( aOperation ) )

    {

    __ASSERT_DEBUG(iCompressOperation == &aOperation,

        Panic(EPreCondPanic_OperationComplete));

    delete iCompressOperation;

    iCompressOperation = NULL;

    // After compress operation complete, restart the policies

    StartAllPolicies();

    }

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

// CPbk2CompressPolicyManager::ConstructPoliciesL

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

//

void CPbk2CompressPolicyManager::ConstructPoliciesL()

    {

    // Timer policy

    CPbk2CompressPolicyTimer* timerPolicy = CPbk2CompressPolicyTimer::NewL

        ( iStoreObservationRegister, *this, KIntervalInSeconds );

    CleanupStack::PushL(timerPolicy);

    iPolicyArray.AppendL(timerPolicy);

    CleanupStack::Pop(timerPolicy);

    // Disk space policy

    CPbk2CompressPolicyDiskSpace* diskspacePolicy =

        CPbk2CompressPolicyDiskSpace::NewL

            ( *this, iContactManager.FsSession(), KDRIVECCRITICALTHRESHOLD );

    CleanupStack::PushL(diskspacePolicy);

    iPolicyArray.AppendL(diskspacePolicy);

    CleanupStack::Pop(diskspacePolicy);

    }

// End of File