/*

* Copyright (c) 2008 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:      Cds Sync Active Object

*

*/

#include "mcmsqlmain.h"

#include "cmsqlbaseitem.h"

#include "cmsqlgenericitem.h"

#include "cdssyncsqlao.h"

#include "cdssyncimplsql.h"

#include "msdebug.h"

// CONSTANTS

const TInt KCdsSyncMaxImageItemCount = 15000;

const TInt KCdsSyncMaxVideoItemCount = 5000;

const TInt KCdsSyncMaxItemCount      = 40000;

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

// CCdsSyncSqlAo::NewL

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

//

CCdsSyncSqlAo* CCdsSyncSqlAo::NewL( 

    MCmSqlMain& aSqlDb,

    CCdsSyncImpl& aSync,

    RPointerArray<CCmSqlGenericItem>& aItemsToAdd,

    RPointerArray<CCmSqlBaseItem>& aItemsToDelete,

    TInt aAddGranularity )

    {    

    CCdsSyncSqlAo* self = CCdsSyncSqlAo::NewLC(

        aSqlDb,

        aSync,

        aItemsToAdd,

        aItemsToDelete,

        aAddGranularity );

    CleanupStack::Pop( self );

    return self;

    }

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

// CCdsSyncSqlAo::NewLC

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

//    

CCdsSyncSqlAo* CCdsSyncSqlAo::NewLC( 

    MCmSqlMain& aSqlDb,

    CCdsSyncImpl& aSync,

    RPointerArray<CCmSqlGenericItem>& aItemsToAdd,

    RPointerArray<CCmSqlBaseItem>& aItemsToDelete,

    TInt aAddGranularity )

    {    

    LOG(_L("[Cds Sync]\t CCdsSyncSqlAo::NewLC"));    

    CCdsSyncSqlAo* self = new (ELeave) CCdsSyncSqlAo( 

        aSqlDb, aSync, aItemsToAdd, aItemsToDelete, aAddGranularity  

        ); 

    CleanupStack::PushL( self );

    self->ConstructL(); 

    return self;

    }    

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

// CCdsSyncSqlAo::~CCdsSyncSqlAo

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

CCdsSyncSqlAo::~CCdsSyncSqlAo()

    {

    LOG(_L("[Cds Sync]\t CCdsSyncSqlAo::~CCdsSyncSqlAo"));    

    if ( IsActive() )

        {

        Cancel();

        }

    }

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

// CCdsSyncSqlAo::CCdsSyncSqlAo

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

CCdsSyncSqlAo::CCdsSyncSqlAo( MCmSqlMain& aSqlDb,

                              CCdsSyncImpl& aSync,

                              RPointerArray<CCmSqlGenericItem>& aItemsToAdd,

                              RPointerArray<CCmSqlBaseItem>& aItemsToDelete,

                              TInt aAddGranularity ) :

    CActive( CActive::EPriorityIdle ),

    iState( ECdsSyncSqlAoIdle ),

    iSqlDb( aSqlDb ),

    iSync( aSync ),

    iItemsToAdd( aItemsToAdd ),

    iItemsToDelete( aItemsToDelete ),

    iAddGranularity( aAddGranularity ),    

    iSourceDataComplete( EFalse )

    {

    }

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

// CCdsSyncSqlAo::ConstructL

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

void CCdsSyncSqlAo::ConstructL() 

    {

    LOG(_L("[Cds Sync]\t CCdsSyncSqlAo::ConstructL"));    

    CActiveScheduler::Add( this );

    }

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

// CCdsSyncSqlAo::NotifyItemsAddedL

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

void CCdsSyncSqlAo::NotifyItemsAddedL( TBool aSourceDataComplete )

    {

    LOG(_L("[Cds Sync]\t CCdsSyncSqlAo::NotifyItemsAddedL"));

    // Source data is complete

    if ( aSourceDataComplete )

        {

        iSourceDataComplete = ETrue;

        }

    TRACE( Print( _L("[Cds Sync]\t addarray has %d items, srccomplete %d"), 

        iItemsToAdd.Count(), iSourceDataComplete ));

    if ( iState == ECdsSyncSqlAoIdle )

        {

        if ( iItemsToAdd.Count() >= iAddGranularity || 

           ( iSourceDataComplete && iItemsToAdd.Count() ) )

            {

            // add more items

            iStatus = KRequestPending;

            iItemsInAddition = iItemsToAdd.Count();

        #ifdef _DEBUG

            iOperationTime.HomeTime();

        #endif

            TRACE( Print( _L("[Cds Sync]\t starting to add %d items"),

                 iItemsInAddition ));

            iSqlDb.AsyncBatchAdd( iItemsToAdd, iStatus );

            SetActive();    

            iState = ECdsSyncSqlAoAdding;

            }

        else if ( iSourceDataComplete )

            {

            // all done, start deleting

       #ifdef _DEBUG

            iOperationTime.HomeTime();

       #endif

            iSqlDb.AsyncBatchDelete( iItemsToDelete, iStatus );

            SetActive();

            iState = ECdsSyncSqlAoDeleting;

           }

        }

    }

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

// CCdsSyncSqlAo::Activate()

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

void CCdsSyncSqlAo::Activate()

    {

    SetActive();

    }

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

// CCdsSyncSqlAo::IfOverLimitDeleteMediaItems() 

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

void CCdsSyncSqlAo::IfOverLimitDeleteMediaItems() 

    {

    LOG(_L("[Cds Sync]\t CCdsSyncSqlAo::IfOverLimitDeleteMediaItems START"));

    TInt64 musicCount( KErrNone );

    TInt64 videoCount( KErrNone );

    TInt64 imageCount( KErrNone );

    TRAP_IGNORE( iSqlDb.GetMediaCountL( musicCount, ECmAudio ) );

    TRAP_IGNORE( iSqlDb.GetMediaCountL( videoCount, ECmVideo ) );

    TRAP_IGNORE( iSqlDb.GetMediaCountL( imageCount, ECmImage ) );

    TRACE( Print( _L("[Cds Sync]\t Amout of music items %ld"), musicCount ));

    TRACE( Print( _L("[Cds Sync]\t Amout of image items %ld"), imageCount ));

    TRACE( Print( _L("[Cds Sync]\t Amout of video items %ld"), videoCount ));

    if( KCdsSyncMaxImageItemCount < imageCount )

        {

        TRAP_IGNORE( iSqlDb.DeleteOldestMediaItemsL( ECmImage, 

            imageCount - KCdsSyncMaxImageItemCount ) );

        TRACE( Print( _L("[Cds Sync]\t deleted %ld image items"), 

            ( imageCount - KCdsSyncMaxImageItemCount )));           

        TRAP_IGNORE( iSqlDb.GetMediaCountL( imageCount, ECmImage ) );

        }

    if( KCdsSyncMaxVideoItemCount < videoCount )

        {

        TRAP_IGNORE( iSqlDb.DeleteOldestMediaItemsL( ECmVideo, 

            videoCount - KCdsSyncMaxVideoItemCount ) );

        TRACE( Print( _L("[Cds Sync]\t deleted %ld video items"), 

            ( videoCount - KCdsSyncMaxVideoItemCount )));              

        TRAP_IGNORE( iSqlDb.GetMediaCountL( videoCount, ECmVideo ) );

        }

    if( KCdsSyncMaxItemCount < ( imageCount + videoCount + musicCount ) )

        {

        TRAP_IGNORE( iSqlDb.DeleteOldestMediaItemsL( ECmAudio, 

            ( imageCount + videoCount + musicCount ) - 

            KCdsSyncMaxItemCount ) );

        TRACE( Print( _L("[Cds Sync]\t deleted %ld music items"), 

            ( ( imageCount + videoCount + musicCount ) - 

            KCdsSyncMaxItemCount )));                     

        }

    LOG(_L("[Cds Sync]\t CCdsSyncSqlAo::IfOverLimitDeleteMediaItems END"));

    }

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

// CCdsSyncSqlAo::RunL() 

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

void CCdsSyncSqlAo::RunL() 

    {

    TRACE( Print( _L("[Cds Sync]\t CCdsSyncSqlAo::RunL, iStatus %d"), 

        iStatus.Int() ));

    if ( iState == ECdsSyncSqlAoAdding )

        {

        iState = ECdsSyncSqlAoIdle;

    #ifdef _DEBUG

        TTime timeAfter;

        timeAfter.HomeTime();

        TRACE( Print( 

          _L("[Cds Sync]\t added %d, took %ld microsec, err %d"),

          iItemsToAdd.Count(), 

          timeAfter.MicroSecondsFrom( iOperationTime ).Int64(),

          iStatus.Int() ));

        TRACE( Print( _L("[Cds Sync]\t array has %d items"), 

           iItemsToAdd.Count() ));

    #endif

        TInt itemCount( iItemsToAdd.Count() );

        for ( TInt i = 0; i < itemCount; i++ )

            {

            delete iItemsToAdd[ 0 ];

            iItemsToAdd.Remove( 0 );

            }

        // check if there's more to add

        NotifyItemsAddedL();

        }

    else if ( iState == ECdsSyncSqlAoInitializing )

        {

        iSync.OperationsCompleteL( KErrNone );

        }

    else // ECdsSyncSqlAoDeleting

        {

    #ifdef _DEBUG

        TTime timeAfter;

        timeAfter.HomeTime();

        TRACE( Print( 

          _L("[Cds Sync]\t removed %d, took %ld microsec, err %d"),

          iItemsToDelete.Count(), 

          timeAfter.MicroSecondsFrom( iOperationTime ).Int64(),

          iStatus.Int() ));

    #endif

        iItemsToDelete.ResetAndDestroy();

        LOG(_L("[Cds Sync]\t Checking if too much media..."));

        IfOverLimitDeleteMediaItems();

        LOG(_L("[Cds Sync]\t Checked!"));

        LOG(_L("[Cds Sync]\t Deleting unused propertys"));

        iSqlDb.DeleteUnusedPropertys( );

        iState = ECdsSyncSqlAoIdle;

        iSync.OperationsCompleteL( KErrNone );

        }

    }

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

// CCdsSyncSqlAo::DoCancel()

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

void CCdsSyncSqlAo::DoCancel()

    {

    LOG(_L("[Cds Sync]\t CCdsSyncSqlAo::DoCancel"));    

    }