/*

* Copyright (c) 2006-2009 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:  Thread which actually performs the harvesting of the files*

*/

#include <e32svr.h>

#include <caf/caf.h>

#include <rlocationobjectmanipulator.h>

#include <placeholderdata.h>

#include <harvesterclientdata.h>

using namespace ContentAccess;

#include "harvesterao.h"

#include "harvesterlog.h"

#include "harvesterblacklist.h"

#include "mdeobject.h"

#include "mdsutils.h"

#include "mdeconstants.h"

#include "harvesterdata.h"

#include "ondemandao.h"

#include "harvestercommon.h"

#include "processoriginmapperinterface.h"

#include "mdeobjecthandler.h"

#include "harvestereventmanager.h"

#include "harvestercenreputil.h"

#include "restorewatcher.h"

#include "backupsubscriber.h"

// constants

const TInt32 KFileMonitorPluginUid = 0x20007186;  // file monitor plugin implementation uid

const TInt KPlaceholderQueueSize = 99;

const TInt KContainerPlaceholderQueueSize = 10;

const TInt KObjectDefStrSize = 20;

const TInt KCacheItemCountForEventCaching = 1;

_LIT( KTAGDaemonName, "ThumbAGDaemon" );

_LIT( KTAGDaemonExe, "thumbagdaemon.exe" );

_LIT(KInUse, "InUse");

CHarvesterAoPropertyDefs::CHarvesterAoPropertyDefs() : CBase()

	{

	}

void CHarvesterAoPropertyDefs::ConstructL(CMdEObjectDef& aObjectDef)

	{

	CMdENamespaceDef& nsDef = aObjectDef.NamespaceDef();

	// Common property definitions

	CMdEObjectDef& objectDef = nsDef.GetObjectDefL( MdeConstants::Object::KBaseObject );

	iCreationDatePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KCreationDateProperty );

	iLastModifiedDatePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KLastModifiedDateProperty );

	iSizePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KSizeProperty );

	iOriginPropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KOriginProperty );

	CMdEObjectDef& mediaDef = nsDef.GetObjectDefL( MdeConstants::MediaObject::KMediaObject );

	iPreinstalledPropertyDef = &mediaDef.GetPropertyDefL( MdeConstants::MediaObject::KPreinstalledProperty );

	}

CHarvesterAoPropertyDefs* CHarvesterAoPropertyDefs::NewL(CMdEObjectDef& aObjectDef)

	{

	CHarvesterAoPropertyDefs* self = 

		new (ELeave) CHarvesterAoPropertyDefs();

	CleanupStack::PushL( self );

	self->ConstructL( aObjectDef );

	CleanupStack::Pop( self );

	return self;

	}

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

// NewLC

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

//

CHarvesterAO* CHarvesterAO::NewLC()

    {

    WRITELOG( "CHarvesterAO::NewLC() - begin" );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// NewL

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

//

CHarvesterAO* CHarvesterAO::NewL()

    {

    WRITELOG( "CHarvesterAO::NewL() - begin" );

    CHarvesterAO* self = CHarvesterAO::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CHarvesterAO

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

//

CHarvesterAO::CHarvesterAO() : CActive( CActive::EPriorityStandard )

    {

    WRITELOG( "CHarvesterAO::CHarvesterAO() - begin" );

    iServerPaused = ETrue;

    iNextRequest = ERequestIdle;

    iContextEngineInitialized = EFalse;

    iMdeSessionInitialized = EFalse;

    iHarvesting = EFalse;

    }

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

// ~CHarvesterAO

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

//

CHarvesterAO::~CHarvesterAO()

    {

    WRITELOG( "CHarvesterAO::~CHarvesterAO()" );

    Cancel();

	iFs.Close();

	if (iCtxEngine)

		{

		iCtxEngine->ReleaseInstance();

		}

   	if (iHarvesterEventManager)

		{

		iHarvesterEventManager->ReleaseInstance();

		}

    StopMonitoring();

    DeleteMonitorPlugins();        

    StopComposers();

    DeleteComposers();

	delete iBackupSubscriber;

    if (iBlacklist)

		{

		iBlacklist->CloseDatabase();

		delete iBlacklist;

		}

	delete iReHarvester;

    if ( iHarvestFileMessages.Count() > 0 )

        {

        for ( TInt i = iHarvestFileMessages.Count()-1; i >= 0; --i )

            {

            RMessage2& msg = iHarvestFileMessages[i].iMessage;

            if (!msg.IsNull())

            	{

            	msg.Complete( KErrCancel );

            	}

            iHarvestFileMessages.Remove( i );

            }

        }

    iHarvestFileMessages.Close();

    iMonitorPluginArray.ResetAndDestroy();

    iMonitorPluginArray.Close();

    iPHArray.ResetAndDestroy();

    iPHArray.Close();

   	iReadyPHArray.ResetAndDestroy();

    iReadyPHArray.Close();

    iContainerPHArray.ResetAndDestroy();

    iContainerPHArray.Close();

    delete iRestoreWatcher;

	delete iOnDemandAO;

	delete iMdEHarvesterSession;

	delete iMdESession;

	delete iQueue;

	delete iHarvesterPluginFactory;

	delete iMdeObjectHandler;

	delete iUnmountHandlerAO;

	delete iPropDefs;

	RMediaIdUtil::ReleaseInstance();

    REComSession::FinalClose();

    }

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

// ConstructL

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

//

void CHarvesterAO::ConstructL()

    {

    WRITELOG( "CHarvesterAO::ConstructL() - begin" );

    CActiveScheduler::Add( this );

	User::LeaveIfError( iFs.Connect() );

    // Setting up MdE Session

	iMdESession = CMdESession::NewL( *this );

    RProcess process;

 	process.SetPriority( EPriorityBackground );

 	process.Close();

    // Setting up context Engine (initialization is ready when ContextInitializationStatus -callback is called)

    iCtxEngine = CContextEngine::GetInstanceL( this ); // Create the context engine

    iBackupSubscriber = CBackupSubscriber::NewL( *this );

	iUnmountHandlerAO = CUnmountHandlerAO::NewL( *this );

	iUnmountHandlerAO->WaitForUnmountL();

	iHarvesterEventManager = CHarvesterEventManager::GetInstanceL();

	iRestoreWatcher = CRestoreWatcher::NewL();

	iHarvesterOomAO = CHarvesterOomAO::NewL( *this );

	iMediaIdUtil = &RMediaIdUtil::GetInstanceL();

    iBlacklist = CHarvesterBlacklist::NewL();

    iBlacklist->OpenDatabase();

    // Setting up Harvester queue

    iQueue = CHarvesterQueue::NewL( this, iBlacklist );

    // Setting up reharvester

    iReHarvester = CReHarvesterAO::NewL();

    iReHarvester->SetHarvesterQueue( iQueue );

    iHarvesterPluginFactory = CHarvesterPluginFactory::NewL();

    iHarvesterPluginFactory->SetBlacklist( *iBlacklist );

    WRITELOG( "CHarvesterAO::ConstructL() - end" );

    }

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

// LoadMonitorPluginsL

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

//

void CHarvesterAO::LoadMonitorPluginsL()

    {

    WRITELOG( "CHarvesterAO::LoadMonitorPluginsL()" );

    RImplInfoPtrArray infoArray;

    TCleanupItem cleanupItem( MdsUtils::CleanupEComArray, &infoArray );

    CleanupStack::PushL( cleanupItem );

    CMonitorPlugin::ListImplementationsL( infoArray );

    TInt count( 0 );

    count = infoArray.Count();

    CMonitorPlugin* plugin = NULL;

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

        {

        TUid uid = infoArray[i]->ImplementationUid();    // Create the plug-ins

        plugin = NULL;

        TRAPD( err, plugin = CMonitorPlugin::NewL( uid ) );

        if ( err == KErrNone && plugin )

            {

            CleanupStack::PushL( plugin );

            iMonitorPluginArray.AppendL( plugin ); // and add them to array

            CleanupStack::Pop( plugin );

            if ( uid.iUid == KFileMonitorPluginUid )

                {

                void* ptr = plugin;

                iProcessOriginMapper = STATIC_CAST( MProcessOriginMapperInterface*, ptr );

                }

            }

        else

            {

            WRITELOG( "CHarvesterAO::LoadMonitorPlugins() - Failed to load a monitor plugin!" );

            delete plugin;

            plugin = NULL;

            }

        }

    CleanupStack::PopAndDestroy( &infoArray ); // infoArray, results in a call to CleanupEComArray

    }

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

// DeleteMonitorPlugins

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

//

void CHarvesterAO::DeleteMonitorPlugins()

    {

    WRITELOG( "CHarvesterAO::DeleteMonitorPlugins()" );

    iMonitorPluginArray.ResetAndDestroy();

    }

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

// StartMonitoring

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

//

void CHarvesterAO::StartMonitoring()

    {

    WRITELOG( "CHarvesterAO::StartMonitoring()" );

    TInt count( iMonitorPluginArray.Count() );  

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

        {

        iMonitorPluginArray[i]->StartMonitoring( *iQueue, iMdESession, NULL, 

        		iHarvesterPluginFactory );

        }

    }

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

// StopMonitoring

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

//

void CHarvesterAO::StopMonitoring()

    {

    WRITELOG( "CHarvesterAO::StopMonitoring()" );

    TInt count( iMonitorPluginArray.Count() );

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

        {

        iMonitorPluginArray[i]->StopMonitoring();

        }

    }

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

// PauseMonitoring

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

//

void CHarvesterAO::PauseMonitoring()

    {

    WRITELOG( "CHarvesterAO::PauseMonitoring()" );

    TInt count( iMonitorPluginArray.Count() );

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

        {

        iMonitorPluginArray[i]->PauseMonitoring();

        }

    WRITELOG( "CHarvesterAO::PauseMonitoring() - end" );

    }

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

// ResumeMonitoring

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

//

void CHarvesterAO::ResumeMonitoring()

    {

    WRITELOG( "CHarvesterAO::ResumeMonitoring()" );

    TInt count( iMonitorPluginArray.Count() );

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

        {

        iMonitorPluginArray[i]->ResumeMonitoring( *iQueue, iMdESession, NULL,

        		iHarvesterPluginFactory );

        }

    WRITELOG( "CHarvesterAO::ResumeMonitoring() - end" );

    }

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

// HandleUnmount

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

//

void CHarvesterAO::HandleUnmount( TUint32 aMediaId )

	{

	WRITELOG1( "CHarvesterAO::HandleUnmount(%d)", aMediaId );

    TUint32 mediaId(0);

    TUint removed(0);

    TInt err(0);

    CHarvesterData* hd = NULL;

#ifdef _DEBUG

    WRITELOG1( "CHarvesterAO::HandleUnmount() iReadyPHArray.Count() = %d", iReadyPHArray.Count() );

#endif

	if( iReadyPHArray.Count() > 0 )

		{

		TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypePlaceholder, iReadyPHArray.Count() ) );

		TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, iReadyPHArray.Count()) );

		iReadyPHArray.ResetAndDestroy();

		}

#ifdef _DEBUG

	WRITELOG1( "CHarvesterAO::HandleUnmount() iPHArray.Count() = %d", iPHArray.Count() );

#endif

   if( iPHArray.Count() > 0 )

        {

        for( TInt i=iPHArray.Count()-1; i>= 0; i--)

            {

            hd = iPHArray[i];

            err = iMediaIdUtil->GetMediaId( hd->Uri(), mediaId );

            if( err == KErrNone && mediaId == aMediaId )

                {

                WRITELOG1( "CHarvesterAO::HandleUnmount() remove iPHArray %d", i);

                delete hd;

				hd = NULL;

                iPHArray.Remove( i );

                removed++;

                }

            }

        WRITELOG1( "CHarvesterAO::HandleUnmount() DecreaseItemCountL iPHArray %d", removed);

        TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypePlaceholder, removed) );

        }

   removed = 0;

#ifdef _DEBUG

   WRITELOG1( "CHarvesterAO::HandleUnmount() iContainerPHArray.Count() = %d", iContainerPHArray.Count() );

#endif

   if( iContainerPHArray.Count() > 0 )

        {

        for( TInt i=iContainerPHArray.Count()-1; i>= 0; i--)

            {

            hd = iContainerPHArray[i];

            err = iMediaIdUtil->GetMediaId( hd->Uri(), mediaId );

            if( err == KErrNone && mediaId == aMediaId )

                {

                WRITELOG1( "CHarvesterAO::HandleUnmount() remove iContainerPHArray %d", i);

                delete hd;

				hd = NULL;

                iContainerPHArray.Remove( i );

                removed++;

                }

            }

        WRITELOG1( "CHarvesterAO::HandleUnmount() DecreaseItemCountL iContainerPHArray %d", removed);

        TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypePlaceholder, removed) );

        }

	TUint count = iQueue->ItemsInQueue();

	WRITELOG1( "CHarvesterAO::HandleUnmount() iQueue.Count() = %d", count );

	if( count > 0 )

	    {

	    WRITELOG( "CHarvesterAO::HandleUnmount() remove iQueue" );

	    TUint removed = iQueue->RemoveItems( aMediaId );

	    WRITELOG1( "CHarvesterAO::HandleUnmount() removed iQueue = %d", removed );

	    TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypePlaceholder, removed ) );

        TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, removed ) );

	    }

	iMediaIdUtil->RemoveMediaId( aMediaId );

	removed = 0;

	RPointerArray<CHarvesterPluginInfo>& hpiArray = iHarvesterPluginFactory->GetPluginInfos();

	if( hpiArray.Count() > 0 )

		{

		RArray<TItemId> placeholders;

		TUint32 mediaId(0);

		TInt err(0);

		for( TInt i = hpiArray.Count(); --i >= 0; )

			{

			CHarvesterPluginInfo* hpi = hpiArray[i];

			for( TInt j = hpi->iQueue.Count(); --j >= 0; )

				{

				CHarvesterData* hd = hpi->iQueue[j];

				CMdEObject& mdeobj = hd->MdeObject();

				err = iMediaIdUtil->GetMediaId( mdeobj.Uri(), mediaId );

				if( mdeobj.Placeholder() && ( aMediaId == mediaId || err != KErrNone ))

					{

					removed++;

					TItemId id = mdeobj.Id();

					placeholders.Append( id );

					TRAP_IGNORE( iMdESession->CancelObjectL( mdeobj ) );

					delete hd;

					hd = NULL;

					hpi->iQueue.Remove(j);

					if( hpi->iQueue.Count() == 0 )

						{

						hpi->iQueue.Compress();

						}

					}

				}

			}

		if( removed )

		    {

            WRITELOG1( "CHarvesterAO::HandleUnmount() remove from plugins = %d", removed);

            TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypePlaceholder, removed ) );

            TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, removed ) );

		    }

		RArray<TItemId> results;

		TRAP_IGNORE( iMdESession->RemoveObjectsL( placeholders, results, NULL ) );

		results.Close();

		placeholders.Close();

		}

	}

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

// StartComposersL

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

//

void CHarvesterAO::StartComposersL()

    {

    WRITELOG( "CHarvesterAO::StartComposersL()" );

    RImplInfoPtrArray infoArray;