/*

* 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:  Main class in Store manager component

*

*/

#include <e32property.h>

#include "upnpavdevice.h"

#include "upnpavcontroller.h"

#include "upnpavdevicelist.h"

#include <utf.h>

#include "cmserviceobserver.h"

#include "cmsmfilemngr.h"

#include "cmsmtransferengine.h"

#include "cmstorelistitem.h"

#include "cmdmmain.h"

#include "cmmmmain.h"

#include "cmsmmain.h"

#include "msdebug.h"

// One file transfered

const TInt KCmOneFile = 1;

const TInt KCmSmClfRefreshInterval = 15000000;

const TInt KCmSmOneSecond = 1000000;

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

// CCmSmMain::NewL

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

// 

CCmSmMain* CCmSmMain::NewL( 

    MCmServiceObserver* aObserver, CMdESession& aSession,

    CCmDmMain* aDBManager, CCmMmMain* aMemManager )

    {

    LOG(_L("[STORE MNGR]\t CCmSmMain::NewL() start"));

    CCmSmMain* self = CCmSmMain::NewLC( aObserver, aSession,

        aDBManager, aMemManager );

    CleanupStack::Pop( self );

    LOG(_L("[STORE MNGR]\t CCmSmMain::NewL() end")); 

    return self;         

    }

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

// CCmSmMain::NewLC

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

//  

CCmSmMain* CCmSmMain::NewLC(

    MCmServiceObserver* aObserver, CMdESession& aSession, 

    CCmDmMain* aDBManager, CCmMmMain* aMemManager )

    {

    LOG(_L("[STORE MNGR]\t CCmSmMain::NewLC() start"));    

    CCmSmMain* self = new ( ELeave ) CCmSmMain( aObserver, aDBManager, 

        aMemManager );

    CleanupStack::PushL( self );

    self->ConstructL( aSession, aDBManager );

    LOG(_L("[STORE MNGR]\t CCmSmMain::NewLC() end")); 

    return self;  

    }    

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

// CCmSmMain::~CCmSmMain

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

//

CCmSmMain::~CCmSmMain()

    {

    LOG(_L("[STORE MNGR]\t CCmSmMain::~CCmSmMain() start"));

    Cancel();

    delete iCmSmTransferEngine;

    delete iCmSmFileMngr;

    DeleteDevices();

    iItems.ResetAndDestroy();

    iItems.Close();

    iItemIds.Reset();

    iItemIds.Close();

    delete iPeriodic;            

    LOG(_L("[STORE MNGR]\t CCmSmMain::~CCmSmMain() end"));     

    }

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

// CCmSmMain::CCmSmMain

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

//    

CCmSmMain::CCmSmMain( MCmServiceObserver* aObserver, CCmDmMain* aDBManager,

    CCmMmMain* aMemManager  ) 

    : CActive( EPriorityStandard ), iObserver( aObserver ), 

        iMemManager( aMemManager ), iDbManager( aDBManager )

    {

    LOG(_L("[STORE MNGR]\t CCmSmMain::CCmSmMain"));

    CActiveScheduler::Add( this );

    }

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

// CCmSmMain::ConstructL

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

//

void CCmSmMain::ConstructL( CMdESession& aSession, CCmDmMain* aDBManager )

    {

    LOG(_L("[STORE MNGR]\t CCmSmMain::ConstructL() start"));

    iService = ECmServiceNone;

    iCmSmTransferEngine = 

        CCmSmTransferEngine::NewL( this, aDBManager, iItems, iItemIds );

    iCmSmFileMngr = 

        CCmSmFileMngr::NewL( this, aSession, aDBManager, iItems );

    LOG(_L("[STORE MNGR]\t CCmSmMain::ConstructL() end"));

    iProgressInfo.iService = ECmServiceStore;

    }     

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

// CCmSmMain::StartStoreL

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

//    

void CCmSmMain::StartStoreL()

    {

    LOG(_L("[STORE MNGR]\t CCmSmMain::StartStoreL()"));

    if( iService == ECmServiceAutomStoreListProcess )

        {

        iCmSmFileMngr->CancelOperation();

        }

    iCancelOnGoing = EFalse;

    iService = ECmServiceStore;

    iMemManager->SetObserver( *this );

    iDeviceIndex = KErrNone;

    iProgressInfo.iService = ECmServiceStore;

    iProgressInfo.iProcessedItems = KErrNone;

    iProgressInfo.iTotalItems = iCmSmFileMngr->StoreItemCount() + 

        iCmSmFileMngr->FillItemCount();

    SendProgressInfo( KErrNone );    

    ChangeState( ECmSmGetMediaServers );

    }

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

// CCmSmMain::CancelOperation

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

//

void CCmSmMain::CancelOperation()

    {

    LOG(_L("[STORE MNGR]\t CCmSmMain::CancelOperation()"));    

    // If some files need to be removed or shrinked do it now

    iCancelOnGoing = ETrue;

    iItems.ResetAndDestroy();

    iItems.Close();

    iItemIds.Reset();

    iItemIds.Close();

    iCmSmFileMngr->CancelOperation();    

    iCmSmTransferEngine->CancelOperation();              

    iObserver->ServiceExecuted( iService, KErrCancel );

    // Service finished. Reset progress info.

    iProgressInfo.iService = ECmServiceNone;

    iService = ECmServiceNone;

    SendProgressInfo( KErrNone );    

    }

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

// CCmSmMain::PreProcessLists

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

//

void CCmSmMain::PreProcessLists()

    {

    LOG(_L("[STORE MNGR]\t CCmSmMain::PreProcessLists"));

    iCancelOnGoing = EFalse;

    if( iService == ECmServiceAutomStoreListProcess )

        {

        iCmSmFileMngr->CancelOperation();

        iCmSmFileMngr->SetProcessingStatus( ECmSmProcessingFilesStarted );

        }    

    else

        {

        ChangeState( ECmSmStartFileProcessing );

        }

    iService = ECmServicePreProcessingStore;

    }

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

// CCmSmMain::GetColItemsL

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

//

void CCmSmMain::GetColItemsL( TCmMediaType aMedia, 

    CDesCArray& aArray )

    {

    LOG(_L("[STORE MNGR]\t CCmSmMain::GetColItemsL"));

    iCancelOnGoing = EFalse;

    if( iService == ECmServiceAutomStoreListProcess )

        {

        iCmSmFileMngr->CancelOperation();

        }    

    iService = ECmServiceGetStoreFields;

    iCmSmFileMngr->ProcessAlbumList( aMedia, aArray );

    }

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

// CCmSmMain::GetColItemsL

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

//

void CCmSmMain::GetColItemsL( TCmMediaType /*aMedia*/, 

    CCmSqlPropertyContainer& /*aPropertys*/ )

    {

    LOG(_L("[STORE MNGR]\t CCmSmMain::GetColItemsL"));

    iService = ECmServiceGetFillFields;

    ChangeState( ECmSmFinishing );

    }

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

// CCmSmMain::SetAvController

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

//    

void CCmSmMain::SetAvController( MUPnPAVController* aAVController )

    {

    LOG(_L("[STORE MNGR]\t CCmSmMain::SetAvController"));

    iCmSmTransferEngine->SetAvController(aAVController);

    }

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

// CCmSmMain::FileProcessingStatus

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

//    

void CCmSmMain::FileProcessingStatus( TCmSmFileProcessingStatus aStatus )

    {

    LOG(_L("[STORE MNGR]\t CCmSmMain::FileProcessingStatus()"));

    CancelMdETimer();

    switch(aStatus)

        {

        case ECmSmProcessingFilesStarted:

            {

            if( iService == ECmServicePreProcessingStore )

                {

                ChangeState( ECmSmStartFileProcessing );

                }

            break;

            }

        case ECmSmProcessingFilesReady:

            {

            break;

            }

        case ECmSmProcessingCanceled:

            {           

            break;

            }

        case ECmSmNoStoreRulesSelected:

            {

            if( iService == ECmServiceAutomStoreListProcess )

                {

                // Do not complete message

                }

            else

                {

                ChangeState( ECmSmFinishing );

                }                                        

            break;

            }

        case ECmSmPreProcessingReady:

            {

            if( iService == ECmServiceAutomStoreListProcess )

                {

                // Do not complete message

                }

            else

                {

                iObserver->ServiceExecuted( iService, KErrNone );

                }

            iService = ECmServiceNone;                    

            break;

            }

        case ECmSmRefreshError:

            {

            if( iService == ECmServiceAutomStoreListProcess )

                {

                // Do not complete message

                }

            else

                {

                iObserver->ServiceExecuted( iService, 

                    KErrGeneral );

                }

            iService = ECmServiceNone;                                

            break;

            }

        case ECmSmAlbumProcessingReady:

            {

            if( iService == ECmServiceAutomStoreListProcess )

                {

                // Do not complete message

                }

            else

                {

                iObserver->ServiceExecuted( iService, KErrNone );

                }

            iService = ECmServiceNone;                                  

            break;

            }

        case ECmSmContentChanged:

            {

            // If timer start up fails => wait next content change event

            TRAPD( err, StartMdETimerL() );

            if( err )

                {

                TRACE(Print(_L("[STORE MNGR]\t StartMdETimerL err = %d"), 

                    err ));

                }           

            break;

            }

        default:

            {

            break;

            }    

        }

    }

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

// CCmSmMain::TransferStatus

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

//    

void CCmSmMain::TransferStatus( TCmSmTransferStatus aStatus )    

    {

    LOG(_L("[STORE MNGR]\t CCmSmMain::TransferStatus()"));

    switch( aStatus )

        {

        case ECmSmTransferCompleted:

            {

            TTime storeFinished;

            storeFinished.HomeTime();

            TTimeIntervalMicroSeconds usecsFrom = 

                storeFinished.MicroSecondsFrom(iStoreStarted);

            TInt64 timeinsecs((TInt64)( usecsFrom.Int64() / KCmSmOneSecond ));

            TRACE(Print(_L("[STORE MNGR]\t Store took = %ld seconds"), 

                timeinsecs ));                        

            iCmSmFileMngr->UpdateTransferHistoryData( timeinsecs, 

                iCmSmTransferEngine->DataAmount(), (TUint8)iId );            

            ChangeState( ECmSmManageFiles );

            break;

            }

        case ECmSmAborted:

            {

            ChangeState( ECmSmStartCopying );            

            break;

            }

        case ECmSmTransferCanceled:

            {           

            break;

            }

        case ECmSmFileTransferred:

            {

            SendProgressInfo( KCmOneFile );

            break;

            }

        case ECmSmFileTransferFailed:

            {

            // File transferring failed => skip file

            SendProgressInfo( KCmOneFile );

            break;

            }

        case ECmSmWlanLost:

            {

            if( iDevices )

                {

                iDevices->ResetAndDestroy();

                delete iDevices;

                iDevices = NULL;                

                }

            iItemIds.Reset();

            iItemIds.Close();

            iCmSmFileMngr->ResetArrays();    

            iObserver->ServiceExecuted( iService, KErrGeneral );

            iProgressInfo.iService = ECmServiceNone;

            iService = ECmServiceNone;

            SendProgressInfo( KErrNone );

            break;

            }

        case ECmSmTransferContinued:

            {

            ChangeState( ECmSmContinueCopying ); 

            break;

            }

        default:

            {

            break;

            }                

        }

    }

#ifdef _DEBUG 

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

// CCmSmMain::LogServers

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

//

void CCmSmMain::LogServers()

    {

    LOG(_L("[STORE MNGR]\t CCmSmMain::LogServers"));

    for( TInt i = 0; i < iDevices->Count(); i++ )

        {

        TBuf<KMaxName>temp;

        if((*iDevices)[i])

            {

            if( &(*iDevices)[i]->Uuid() )

                {

                if( (*iDevices)[i]->Uuid().Length() < KMaxName )

                    {

                    temp.Copy( (*iDevices)[i]->Uuid() );

                    TRACE(Print(_L("[STORE MNGR]\t FOUND DEVICE %d = %S"), 

                        i+1, &temp ));        

                    }

                temp.Zero();                

                }            

            }        

        }            

    }

#endif

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

// CCmSmMain::SendProgressInfo

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

//

void CCmSmMain::SendProgressInfo( TInt aProgress ) 

    {

    TRACE( Print( _L(

        "[STORE MNGR]\t CCmSmMain::SendProgressInfo( %d )"), 

        aProgress));

    iProgressInfo.iProcessedItems += aProgress;

    TRAPD( error, iCmSmFileMngr->GetStoreFileCountNoDuplicatesL( 

        iProgressInfo.iItemsToTransferPerService ) );

    if ( error ) 

        {

        TRACE( Print( _L( "[STORE MNGR]\t GetStoreFileCountNoDuplicatesL \

            failed with error %d"), error ) );

        }

    TCmProgressInfoPckg progressPckg( iProgressInfo );

    TRACE( Print( _L(

        "[STORE MNGR]\t processed: %d total %d"), 

        iProgressInfo.iProcessedItems, iProgressInfo.iTotalItems));

    TInt err = RProperty::Set( KCmPropertyCat, KCmProperty, progressPckg );

    TRACE( Print( _L("[STORE MNGR]\t RProperty::Set returned %d"), err));

    }

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

// CCmSmMain::ManageFileL

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

//

void CCmSmMain::ManageFileL()

    {

    LOG(_L("[STORE MNGR]\t CCmSmMain::ManageFileL"));

    if( KErrNone < iCmSmTransferEngine->FilesToBeRemoved().Count() )

        {

        iMemManager->DeleteFilesL( iCmSmTransferEngine->FilesToBeRemoved() );

        }

    else if ( KErrNone < iCmSmTransferEngine->FilesToBeShrinked().Count() )

        {

        TRAPD( err, iMemManager->ShrinkImagesL( 

            iCmSmTransferEngine->FilesToBeShrinked() ) );

        if( err )

            {

            ChangeState( ECmSmStartCopying );

            }

        }

    else if( iCancelOnGoing )

        {

        ChangeState( ECmSmFinishCanceling );      

        }

    else

        {

        // Store to next server...        

        ChangeState( ECmSmStartCopying );  

        }    

    }

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

// CCmSmMain::DeleteCompleteL

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

//

void CCmSmMain::DeleteCompleteL( TInt /*aErr*/ )

    {

    LOG(_L("[STORE MNGR]\t CCmSmMain::DeleteCompleteL"));

    iCmSmTransferEngine->DeleteToBeRemoved();

    ManageFileL();

    }

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

// CCmSmMain::ShrinkCompleteL

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

//    

void CCmSmMain::ShrinkCompleteL( TInt /*aErr*/ )

    {

    LOG(_L("[STORE MNGR]\t CCmSmMain::ShrinkCompleteL"));

    iCmSmTransferEngine->DeleteToBeShrinked();

    ManageFileL();    

    }

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

// CCmSmMain::ChangeState

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

// 

void CCmSmMain::ChangeState( 

    TCmSmMainSequencer aStatus )

    {

    LOG(_L("[STORE MNGR]\t CCmSmMain::ChangeState"));

    __ASSERT_DEBUG(!IsActive(),\

        User::Panic( KCmSmManager, KErrInUse ));          

    SetActive();

    TRequestStatus* pStatus = &iStatus;

    User::RequestComplete( pStatus, aStatus );

    }