/*

* Copyright (c) 2006 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:   Implements CNcdNodeCacheCleaner class

*

*/

#include "ncdnodecachecleaner.h"

#include "ncdnodeidentifierutils.h"

#include "ncdnodemanager.h"

#include "ncdnodedbmanager.h"

#include "ncdnodefactory.h"

#include "ncdnodeidentifiereditor.h"

#include "ncdnodeimpl.h"

#include "ncdnodefolder.h"

#include "ncdrootnode.h"

#include "ncdnodemetadataimpl.h"

#include "ncdnodelink.h"

#include "ncdnodeiconimpl.h"

#include "ncdnodescreenshotimpl.h"

#include "ncdnodeidentifier.h"

#include "ncdchildentity.h"

#include "catalogsconstants.h"

#include "ncdproviderdefines.h"

#include "catalogsutils.h"

#include "ncdgeneralmanager.h"

#include "catalogsdebug.h"

// Uncomment this if the node cache cleaner should be turned off.

// For example, when debugging other functionalities.

//#define NCD_NODE_CACHE_CLEANER_TURN_OFF

#ifdef CATALOGS_BUILD_CONFIG_DEBUG

// Uncomment this if the array prints should be printed when the

// debug mode is on. This is set optional because the array print

// may take a long time when data is written into the log file.

//#define NCD_NODE_CACHE_CLEANER_DEBUG_ARRAY_PRINT

#endif

// These priority values are used for this active object.

// The default value is used when normal cleaning is done

const CActive::TPriority KDefaultCleaningPriority( CActive::EPriorityIdle );

// This priority value is used if the database size has been exceeded

// and the cleaning should be done with the higher priority

const CActive::TPriority KIncreasedCleaningPriority( CActive::EPriorityLow );

// This priority value is used if the database size has been exceeded

// too much and the cleaning should be done with really high priority.

// This will slow down the other actions even more because cleaning

// takes more time.

const CActive::TPriority KMaxCleaningPriority( CActive::EPriorityStandard );

// The max db size value is divided by this number to get the

// value for the limit until which the db is freed after max size

// has been reached and cleaning started.

const TInt KMaxSizeDivider( 2 );

// If the db size is over double the accepted db size, then the max cleaning

// priority should be used. Because most likely the lower priority does not work

// efficiently enough

const TInt KMaxDbSizeRatio( 2 );

// The checking of the database should be done at least in some time intervals

// even if the db size has not been exceeded.

const TTimeIntervalMinutes KCheckPeriod( 60 );

CNcdNodeCacheCleaner* CNcdNodeCacheCleaner::NewL( CNcdGeneralManager& aGeneralManager,

                                                  CNcdNodeDbManager& aNodeDbManager,

                                                  TInt aDbDefaultMaxSize,                                                  

                                                  CNcdNodeFactory& aNodeFactory )

    {

    CNcdNodeCacheCleaner* self =   

        CNcdNodeCacheCleaner::NewLC( aGeneralManager, 

                                     aNodeDbManager, 

                                     aDbDefaultMaxSize,

                                     aNodeFactory );

    CleanupStack::Pop( self );

    return self;        

    }

CNcdNodeCacheCleaner* CNcdNodeCacheCleaner::NewLC( CNcdGeneralManager& aGeneralManager,

                                                   CNcdNodeDbManager& aNodeDbManager,

                                                   TInt aDbDefaultMaxSize,

                                                   CNcdNodeFactory& aNodeFactory )

    {

    CNcdNodeCacheCleaner* self = 

        new( ELeave ) CNcdNodeCacheCleaner( aGeneralManager, 

                                            aNodeDbManager,

                                            aDbDefaultMaxSize, 

                                            aNodeFactory );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;        

    }

CNcdNodeCacheCleaner::CNcdNodeCacheCleaner( CNcdGeneralManager& aGeneralManager,

                                            CNcdNodeDbManager& aNodeDbManager,

                                            TInt aDbDefaultMaxSize,

                                            CNcdNodeFactory& aNodeFactory )

: CActive( KDefaultCleaningPriority ),

  iGeneralManager( aGeneralManager ),

  iNodeManager( aGeneralManager.NodeManager() ),

  iNodeDbManager( aNodeDbManager ),

  iDbMaxSize( aDbDefaultMaxSize ),

  iNodeFactory( aNodeFactory ),

  // EFalse by default so that we don't clean anything even in error situations

  // for clients that don't allow it

  iAllowCleaning( EFalse ), 

  iIncreasePriority( KDefaultCleaningPriority ),

  iLastCleanupTime( 0 )

    {

    }

void CNcdNodeCacheCleaner::ConstructL()

    {

    // These values have to be set. 

    // These types will be removed from the db.

    // iNodeCleanupTypes are used to search the node items from db.

    // This array is only for node type. So, it contains only one value.

    iNodeCleanupTypes.AppendL( NcdNodeClassIds::ENcdNode );

    // Meta cleanup types are also removed from the db.

    // These types use the metadata identifier to remove the items

    // from db

    iMetaCleanupTypes.AppendL( NcdNodeClassIds::ENcdMetaData );

    // These types should be permanent info 

    // or not to be removed by this cleaner for some other reason.

    // Uncomment these if specifications change.

    //iMetaCleanupTypes.Append( NcdNodeClassIds::ENcdNodeUserData );

    //iMetaCleanupTypes.Append( NcdNodeClassIds::ENcdSubscriptionsData );

    // Special cleanup types are removed from the db.

    // But node or metadata ids cannot be directly used for these.

    // They require special handling to get the right ids.

    iIconCleanupTypes.AppendL( NcdNodeClassIds::ENcdIconData );

    iScreenshotCleanupTypes.AppendL( NcdNodeClassIds::ENcdScreenshotData );

    // These namespaces should not be cleaned by this cleaner

    iDoNotCleanNameSpaces = new(ELeave) CPtrCArray( KListGranularity );

    iDoNotCleanNameSpaces->AppendL( 

        NcdProviderDefines::KDownloadNamespace() );

    iDoNotCleanNameSpaces->AppendL( 

        NcdProviderDefines::KSubscriptionNamespace() );

    iDoNotCleanNameSpaces->AppendL( 

        NcdProviderDefines::KPreviewStorageNamespace() );

    // Because this is an active object, we need to inform

    // scheduler about it.    

    CActiveScheduler::Add( this );    

    }

CNcdNodeCacheCleaner::~CNcdNodeCacheCleaner()

    {

    DLTRACEIN((""));

    // It is always safe to call Cancel for active object

    // when destructor is called.

    Cancel();

    // This object is automatically removed from the active scheduler when

    // this object is deleted.

    // Delete member variables that are owned by this class object here.

    iNodeCleanupTypes.Reset();

    iMetaCleanupTypes.Reset();

    iIconCleanupTypes.Reset();

    iScreenshotCleanupTypes.Reset();

    iCleanupIdentifiers.ResetAndDestroy();

    iAllDbStorageNodeItems.ResetAndDestroy();

    iAllDbIconItems.ResetAndDestroy();

    iAllDbScreenshotItems.ResetAndDestroy();

    iDbMetaIdentifiers.ResetAndDestroy();

    iWaitingIdentifiers.ResetAndDestroy();

    iWaitingParentIdentifiers.ResetAndDestroy();

    iDoNotRemoves.ResetAndDestroy();

    iRootChildren.ResetAndDestroy();

    iBundleChildren.ResetAndDestroy();

    // Notice that this delete also deletes the objects owned by the array.

    delete iDoNotCleanNameSpaces;

    DLTRACEOUT((""));

    }        

TInt CNcdNodeCacheCleaner::NodeIdentifierArraySortById( const CNcdNodeIdentifier& aNodeId1,

                                                        const CNcdNodeIdentifier& aNodeId2 )

    {

    //DLTRACEIN((""));

    TInt depth1( 0 );

    TInt depth2( 0 );

    TInt trapError1( KErrNone );

    TInt trapError2( KErrNone );

    TRAP( trapError1, depth1 = NcdNodeIdentifierEditor::NodeDepthL( aNodeId1 ) );

    TRAP( trapError2, depth2 = NcdNodeIdentifierEditor::NodeDepthL( aNodeId2 ) );

    // Decide the order according to the depth. If the identifier is not

    // an actual nodeidentifier. Then insert it to the beginning of the array

    // and sort those identifiers by their lengths.

    if ( trapError1 == KErrNone && trapError2 == KErrNone )

        {

        // Both of the given identifiers were for the node.

        // This function returns zero if depths are equal and lengths are equal.

        TInt order( depth1 - depth2 );

        if ( depth1 == depth2 )

            {

            // Depths are equal. So, check if the id lengths differ.

            // If nodeid1 is shorter, then it should be first in the array.

            // If they are equal length then the order does not matter.

            // If the node1 is longer, then node2 should be first.

            order = aNodeId1.NodeId().Length() - aNodeId2.NodeId().Length();

            }

        // Negative number if depth1 is smaller.

        // Positive number if id1 is greater.

        return order;        

        }

    else if ( trapError1 != KErrNone && trapError2 != KErrNone )

        {

        // Because neither was not a node, use the id length to get the

        // order. This way the shortest will be the first one etc.

        DLERROR(("Neither was node"));

        DASSERT( trapError1 == KErrArgument );

        DASSERT( trapError2 == KErrArgument );

        return aNodeId1.NodeId().Length() - aNodeId2.NodeId().Length();

        }

    else if ( trapError1 != KErrNone )

        {

        // Here we should get only the KErrArgument that informs that the

        // aNodeId1 was not an actual node id. It is most likely some metadata id.

        // Insert these in the beginning of the array. So, return negative number

        DLERROR(("aNodeId1 not node"));

        DASSERT( trapError1 == KErrArgument );

        return -1;

        }        

    else

        {

        DLERROR(("aNodeId2 not node"));

        // Here we should get only the KErrArgument that informs that the

        // aNodeId2 was not an actual node id. It is most likely some metadata id.

        // Insert these in the beginning of the array. So, return positive number

        DASSERT( trapError2 == KErrArgument );

        return 1;

        }

    }

const TUid& CNcdNodeCacheCleaner::ClientUid() const

    {

    return iGeneralManager.FamilyId();

    }

CNcdNodeCacheCleaner::TCleanupState CNcdNodeCacheCleaner::CleanupState() const

    {

    return iCleanupState;

    }

void CNcdNodeCacheCleaner::SetAllowCleaning( TBool aAllow )

    {

    DLTRACEIN((""));

    if ( aAllow != AllowCleaning()

         && !aAllow )

        {

        DLINFO(("Cancel on going operation because cleaning is not allowed anymore."))

        Cancel();        

        }

    iAllowCleaning = aAllow;

    }

TBool CNcdNodeCacheCleaner::AllowCleaning() const

    {

    return iAllowCleaning;

    }

void CNcdNodeCacheCleaner::StartCleanupL()

    {

    DLTRACEIN((""));

    // Set the last cleanup time here. So, next automatic start will

    // occure after the specified period.

    iLastCleanupTime.HomeTime();

    #ifdef NCD_NODE_CACHE_CLEANER_TURN_OFF

    // Nothing to do here. Because cleaning should not be done.

    DLWARNING(("*** CNcdNodeCacheCleaner turned off ***"));

    #warning *** CNcdNodeCacheCleaner turned off ***

    return;

    #endif

    if ( !AllowCleaning() )

        {

        DLINFO(("Cleaning is not allowed."));

        return;

        }

    if ( CleanupState() != ENotStarted

         || IsActive() )

        {

        DLINFO(("Cleaning already started"));

        return;

        }

    if ( iResetPriority )

        {

        // The priority may have been increased before. 

        // But it has been marked to be resetted when possible.

        // So, reset it here. We come here only if Cancel was

        // called when the object was active.

        SetPriority( KDefaultCleaningPriority );

        iResetPriority = EFalse;

        }

    // Update the node items list. 

    // This is an initial list that will be used when the nodes are examined.

    // The node items list should not be updated anywhere else but here or

    // in the start clean excess function. If the array is updated somewhere else, it

    // may result an infinite loop if some deepest nodes cannot be removed when

    // excess cleaning is done and those nodes are in the end of the list all the time.

    // Notice, that it does not matter if all the nodes are not check this time. They

    // will be checked next time cleaning is started. Also, if some nodes are missing

    // in the list, wrong nodes will not be deleted because parent and child checks 

    // are done by using the other array such as do not remove and wait arrays.

    SetAllDbStorageNodeItemsL();

    // Cleaning special cases is the first thing to do when cleanup is started.        

    iCleanupState = ECleaningSpecialCases;

    // Mark this active object to be ready for action.

    // Instead of using some other class object to do the job,

    // this active object handles everything itself. New job

    // is started everytime when the RunL is called until there is

    // nothing to be done. Or, until user cancels or stops the action.

    iStatus = KRequestPending;

    // Let the active object know that RunL can be called when the

    // action is completed.

    SetActive();

    // Because there is not anything special to be done here.

    // Set the action complete. So, the RunL will be called.

    TRequestStatus* ptrStatus = &iStatus;

    User::RequestComplete( ptrStatus, KErrNone );

    DLTRACEOUT((""));

    }

void CNcdNodeCacheCleaner::StopCleanup()

    {

    DLTRACEIN((""));

    if ( CleanupState() != ENotStarted

         || IsActive() )

        {

        DLINFO(("Stop cleanup"));

        Cancel();

        }

    DLTRACEOUT((""));

    }

void CNcdNodeCacheCleaner::CheckDbSizeL()

    {

    DLTRACEIN((""));

    // If the db size has been exceeded, then

    // start the cleaning operation.

    // This function may be called for example 

    // when new nodes have been added to the db.

    TInt dbSize( 

        NodeDbManager().StorageSizeL( ClientUid(),

                                      *iDoNotCleanNameSpaces ) );

    TTime currentTime;

    currentTime.HomeTime();    

    TBool timePassed( EFalse );

    if ( iLastCleanupTime + KCheckPeriod < currentTime  )

        {

        timePassed = ETrue;

        }

    // Start cleaning if the database size is too large

    // or if it is too long time from the last cleanup.

    if ( DbMaxSize() < dbSize )

        {

        DLINFO(("Too much data in db: %d", dbSize));

        // Because the db size has been exceeded we want to clean

        // the db with higher priority than usually.

        // When the cleanup finishes, the priority should be set back

        // to lower level.

        if ( IsActive() )

            {

            if ( DbMaxSize() * KMaxDbSizeRatio < dbSize )

                {

                DLINFO(("Highest priority should be used db size is way too big"));

                // Set the priority to max, the next time RunL is called

                // because the cleaner is not doing its work efficiently enough

                iIncreasePriority = KMaxCleaningPriority;

                }

            else

                {

                DLINFO(("Increased priority should be used"));

                // Set the priority higher, the next time

                // RunL is called. The db size is too large but does not

                // exceed the "panic" level.

                iIncreasePriority = KIncreasedCleaningPriority;                

                }

            }

        else if ( DbMaxSize() * KMaxDbSizeRatio < dbSize )

            {

            DLINFO(("Not active. Max priority set"));

            SetPriority( KMaxCleaningPriority );

            }

        else

            {

            DLINFO(("Not active. Increased priority set"));

            SetPriority( KIncreasedCleaningPriority );            

            }

        // To be sure that the cleanup does not reset the priority.

        // No need to reset it because new values have been given above.

        iResetPriority = EFalse;

        // Start the actual cleaning.

        StartCleanupL();

        }

    else if ( timePassed )

        {

        DLINFO(("Time passed"));

        // Start the actual cleaning but no need to increase the priority.

        StartCleanupL();        

        }

    DLTRACEOUT((""));

    }

void CNcdNodeCacheCleaner::AddCleanupIdentifiersL( const RPointerArray<CNcdNodeIdentifier>& aIdentifiers )

    {

    DLTRACEIN((""));

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

        {

        AddCleanupIdentifierL( *aIdentifiers[ i ] );

        }

    DLTRACEOUT((""));

    }

void CNcdNodeCacheCleaner::AddCleanupIdentifierL( const CNcdNodeIdentifier& aIdentifier )

    {

    DLTRACEIN((""));

    DLNODEID(( aIdentifier ));

    if ( ContainsIdentifier( aIdentifier, iDoNotRemoves ) )

        {

        // Do not remove list already contains the given identifier.

        // So, insert the given identifier to the wait list.

        // Notice that identifier should be left also into the do not remove list.

        AddIdentifierL( aIdentifier, iWaitingIdentifiers );

        }

    else if ( !NcdNodeIdentifierUtils::ContainsIdentifier(

              aIdentifier, iWaitingIdentifiers ) &&

              !NcdNodeIdentifierUtils::ContainsIdentifier(

              aIdentifier, iWaitingParentIdentifiers ) )

        {

        // Just insert the given identifier into the cleanup list unless

        // it already existed in some waiting array or in do not remove list.

        AddIdentifierL( aIdentifier, iCleanupIdentifiers );

        }

    // No need to check the waiting parents, because it will be checked when items

    // are going to be removed.

    DLTRACEOUT((""));

    }

void CNcdNodeCacheCleaner::RemoveCleanupIdentifiers( const RPointerArray<CNcdNodeIdentifier>& aIdentifiers )

    {

    DLTRACEIN((""));

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

        {

        RemoveCleanupIdentifier( *aIdentifiers[ i ] );

        }