/*

* 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 <driveinfo.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;

_LIT( KTAGDaemonName, "ThumbAGDaemon" );

_LIT( KTAGDaemonExe, "thumbagdaemon.exe" );

_LIT(KVideo, "Video");

_LIT(KInUse, "InUse");

_LIT(KUndefinedMime, " ");

_LIT( KExtensionMp4,   "mp4" );

_LIT( KExtensionMpg4,  "mpg4" );

_LIT( KExtensionMpeg4, "mpeg4" );

_LIT( KExtension3gp,   "3gp" );

_LIT( KExtension3gpp,  "3gpp" );

_LIT( KExtension3g2,   "3g2" );

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 );

	iItemTypePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KItemTypeProperty );

	iTitlePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KTitleProperty );

	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( KHarvesterPriorityHarvestingPlugin )

    {

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

    iServerPaused = ETrue;

    iNextRequest = ERequestIdle;

    iContextEngineInitialized = EFalse;

    iMdeSessionInitialized = EFalse;

    iRamFull = EFalse;

    iDiskFull = EFalse;

    iManualPauseEnabled = EFalse;

    iFastHarvestNeeded = EFalse;

    iHarvestingPlaceholders = EFalse;

    }

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

// ~CHarvesterAO

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

//

CHarvesterAO::~CHarvesterAO()

    {

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

    Cancel();

	iFs.Close();

	if (iCtxEngine)

		{

		iCtxEngine->ReleaseInstance();

		}

   	if (iHarvesterEventManager)

		{

		iHarvesterEventManager->ReleaseInstance();

		}

    StopMonitoring();

    DeleteMonitorPlugins();        

    StopComposers();

    DeleteComposers();

    delete iDiskFullNotifier;

	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();

    iPHArray.ResetAndDestroy();

    iPHArray.Close();

   	iReadyPHArray.ResetAndDestroy();

    iReadyPHArray.Close();

    iContainerPHArray.ResetAndDestroy();

    iContainerPHArray.Close();

	delete iHarvesterOomAO;

    delete iRestoreWatcher;

	delete iOnDemandAO;

	delete iMdEHarvesterSession;

	delete iMdESession;

	delete iQueue;

	delete iHarvesterPluginFactory;

	delete iMdeObjectHandler;

	delete iUnmountHandlerAO;

	delete iPropDefs;

	delete iCameraExtensionArray;

	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 );

    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 );

    // Reset harvesting status for clients in case blacklisted file was handled

    iHarvesterPluginFactory->SendHarvestingStatusEventL( EFalse );

    iCameraExtensionArray = new ( ELeave ) CDesCArraySeg( 6 );

    iCameraExtensionArray->InsertIsqL( KExtensionMp4 );

    iCameraExtensionArray->InsertIsqL( KExtensionMpg4 );

    iCameraExtensionArray->InsertIsqL( KExtensionMpeg4 );

    iCameraExtensionArray->InsertIsqL( KExtension3gp );

    iCameraExtensionArray->InsertIsqL( KExtension3gpp );

    iCameraExtensionArray->InsertIsqL( KExtension3g2 );

    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();

    iMonitorPluginArray.Close();

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

    }

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

// StartMonitoring

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

//

void CHarvesterAO::StartMonitoring()

    {

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

    const 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()" );

    const TInt count( iMonitorPluginArray.Count() );

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

        {

        iMonitorPluginArray[i]->StopMonitoring();

        }

    }

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

// PauseMonitoring

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

//

void CHarvesterAO::PauseMonitoring()

    {

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

    const 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()" );

    const 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 );    

    if( !iServerPaused )

        {

        // Stop harvesting for unmount

        PauseMonitoring();

        PauseHarvester();

        }

    TUint32 mediaId( 0 );

    TUint removed( 0 );

    CHarvesterData* hd = NULL;

    TInt err( KErrNone );

#ifdef _DEBUG

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

#endif

	TInt arrayCount( iReadyPHArray.Count() );

	if( arrayCount > 0 )

        {

        for( TInt i=arrayCount-1; i>= 0; i--)

            {

            hd = iReadyPHArray[i];

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

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

                {

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

                delete hd;

                hd = NULL;

                iReadyPHArray.Remove( i );

                removed++;

                arrayCount--;

                }

            }

        if( iReadyPHArray.Count() == 0 )

            {

            iReadyPHArray.Compress();

            }

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

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

        }

   removed = 0;

#ifdef _DEBUG

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

#endif

	arrayCount = iPHArray.Count();

   if( arrayCount > 0 )

        {

        for( TInt i=arrayCount-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++;

                arrayCount--;

                }

            }

        if( iPHArray.Count() == 0 )

            {

            iPHArray.Compress();

            }

        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

   arrayCount = iContainerPHArray.Count();

   if( arrayCount > 0 )

        {

        for( TInt i=arrayCount-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++;

                arrayCount--;

                }

            }

        if( iContainerPHArray.Count() == 0 )

            {

            iContainerPHArray.Compress();

            }

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

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

        }

   removed = 0;