/*

* 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 <placeholderdata.h>

#include <harvesterclientdata.h>

#include <pathinfo.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 "mdscommoninternal.h"

#include "processoriginmapperinterface.h"

#include "mdeobjecthandler.h"

#include "harvestereventmanager.h"

#include "harvestercenreputil.h"

#include "restorewatcher.h"

#include "backupsubscriber.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "harvesteraoTraces.h"

#endif

// constants

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

const TInt KPlaceholderQueueSize = 99;

const TInt KContainerPlaceholderQueueSize = 10;

const TInt KReadyPlaceholderQueueSize = 10;

const TInt KObjectDefStrSize = 20;

_LIT( KTAGDaemonName, "ThumbAGDaemon" );

_LIT( KTAGDaemonExe, "thumbagdaemon.exe" );

_LIT(KVideo, "Video");

_LIT(KInUse, "InUse");

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

	{

    SetByObjectDefL( aObjectDef );

	}

CHarvesterAoPropertyDefs* CHarvesterAoPropertyDefs::NewL()

    {

    CHarvesterAoPropertyDefs* self = 

        new (ELeave) CHarvesterAoPropertyDefs();

    return self;

    }

void CHarvesterAoPropertyDefs::SetByObjectDefL(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 );

    iDefaultFolderPropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KInDefaultFolder );

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

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

    }

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

// NewLC

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

//

CHarvesterAO* CHarvesterAO::NewLC()

    {

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

    OstTrace0( TRACE_NORMAL, CHARVESTERAO_NEWLC, "CHarvesterAO::NewLC" );    

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// NewL

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

//

CHarvesterAO* CHarvesterAO::NewL()

    {

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

    OstTrace0( TRACE_NORMAL, CHARVESTERAO_NEWL, "CHarvesterAO::NewL" );

    CHarvesterAO* self = CHarvesterAO::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CHarvesterAO

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

//

CHarvesterAO::CHarvesterAO() : CActive( KHarvesterPriorityHarvestingPlugin )

    {

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

    OstTrace0( TRACE_NORMAL, CHARVESTERAO_CHARVESTERAO, "CHarvesterAO::CHarvesterAO" );

    iServerPaused = ETrue;

    iNextRequest = ERequestIdle;

    iContextEngineInitialized = EFalse;

    iMdeSessionInitialized = EFalse;

    iRamFull = EFalse;

    iDiskFull = EFalse;

    iManualPauseEnabled = EFalse;

    iFastHarvestNeeded = EFalse;

    iHarvestingPlaceholders = EFalse;

    iUnmountDetected = EFalse;

    iPriorityInterruptDetected = EFalse;

    }

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

// ~CHarvesterAO

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

//

CHarvesterAO::~CHarvesterAO()

    {

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

    OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_CHARVESTERAO, "CHarvesterAO::~CHarvesterAO" );

    Cancel();

	iFs.Close();

	if (iCtxEngine)

		{

		iCtxEngine->ReleaseInstance();

		}

   	if (iHarvesterEventManager)

		{

		iHarvesterEventManager->ReleaseInstance();

		}

    StopMonitoring();

    DeleteMonitorPlugins();        

    StopComposers();

    DeleteComposers();

    delete iDiskFullNotifier;

    iDiskFullNotifier = NULL;

	delete iBackupSubscriber;

	iBackupSubscriber = NULL;

    if (iBlacklist)

		{

		iBlacklist->CloseDatabase();

		delete iBlacklist;

		iBlacklist = NULL;

		}

	delete iReHarvester;

	iReHarvester = NULL;

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

    iTempReadyPHArray.ResetAndDestroy();

    iTempReadyPHArray.Close();

	delete iHarvesterOomAO;

	iHarvesterOomAO = NULL;

    delete iRestoreWatcher;

    iRestoreWatcher = NULL;

	delete iOnDemandAO;

	iOnDemandAO = NULL;

	delete iMdEHarvesterSession;

	iMdEHarvesterSession = NULL;

	delete iMdESession;

	iMdESession = NULL;

	delete iQueue;

	iQueue = NULL;

	delete iHarvesterPluginFactory;

	iHarvesterPluginFactory = NULL;

	delete iMdeObjectHandler;

	iMdeObjectHandler = NULL;

	delete iUnmountHandlerAO;

	iUnmountHandlerAO = NULL;

	delete iPropDefs;

	iPropDefs = NULL;

	delete iCameraExtensionArray;

	iCameraExtensionArray = NULL;

    delete iPhoneImagesPath;

    iPhoneImagesPath = NULL;

    delete iMmcImagesPath;

    iMmcImagesPath = NULL;

    delete iPhoneVideosPath;

    iPhoneVideosPath = NULL;

    delete iMmcVideosPath;

    iMmcVideosPath = NULL;

    delete iPhoneSoundsPath;

    iPhoneSoundsPath = NULL;

    delete iMmcSoundsPath;

    iMmcSoundsPath = NULL;

	RMediaIdUtil::ReleaseInstance();

    REComSession::FinalClose();

    }

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

// ConstructL

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

//

void CHarvesterAO::ConstructL()

    {

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

    OstTrace0( TRACE_NORMAL, CHARVESTERAO_CONSTRUCTL, "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 );

    iPropDefs = CHarvesterAoPropertyDefs::NewL();

    iCameraExtensionArray = new ( ELeave ) CDesCArraySeg( 6 );

    iCameraExtensionArray->InsertIsqL( KExtensionMp4 );

    iCameraExtensionArray->InsertIsqL( KExtensionMpg4 );

    iCameraExtensionArray->InsertIsqL( KExtensionMpeg4 );

    iCameraExtensionArray->InsertIsqL( KExtension3gp );

    iCameraExtensionArray->InsertIsqL( KExtension3gpp );

    iCameraExtensionArray->InsertIsqL( KExtension3g2 );

    TFileName phoneRoot = PathInfo::PhoneMemoryRootPath();

    TFileName mmcRoot = PathInfo::MemoryCardRootPath();

    TFileName images = PathInfo::ImagesPath();

    TFileName phoneImagePath( phoneRoot );

    phoneImagePath.Append( images );

    iPhoneImagesPath = phoneImagePath.AllocL();

    TFileName mmcImagePath( mmcRoot );

    mmcImagePath.Append( images );

    iMmcImagesPath = mmcImagePath.Right( mmcImagePath.Length() - 1 ).AllocL();

    TFileName videos = PathInfo::VideosPath();

    TFileName phoneVideoPath( phoneRoot );

    phoneVideoPath.Append( videos );

    iPhoneVideosPath = phoneVideoPath.AllocL();

    TFileName mmcVideoPath( mmcRoot );

    mmcVideoPath.Append( videos );

    iMmcVideosPath = mmcVideoPath.Right( mmcVideoPath.Length() - 1 ).AllocL();

    TFileName sounds = PathInfo::SoundsPath();

    TFileName phoneSoundPath( phoneRoot );

    phoneSoundPath.Append( sounds );

    iPhoneSoundsPath = phoneSoundPath.AllocL();

    TFileName mmcSoundPath( mmcRoot );

    mmcSoundPath.Append( sounds );

    iMmcSoundsPath = mmcSoundPath.Right( mmcSoundPath.Length() - 1 ).AllocL();

    OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_CONSTRUCTL, "CHarvesterAO::ConstructL - end" );    

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

    }

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

// LoadMonitorPluginsL

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

//

void CHarvesterAO::LoadMonitorPluginsL()

    {

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

    OstTrace0( TRACE_NORMAL, CHARVESTERAO_LOADMONITORPLUGINSL, "CHarvesterAO::LoadMonitorPluginsL" );

    RImplInfoPtrArray infoArray;

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

    CleanupStack::PushL( cleanupItem );

    CMonitorPlugin::ListImplementationsL( infoArray );

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

            OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_LOADMONITORPLUGINSL, "CHarvesterAO::LoadMonitorPluginsL  - 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()" );

    OstTrace0( TRACE_NORMAL, CHARVESTERAO_DELETEMONITORPLUGINS, "CHarvesterAO::DeleteMonitorPlugins" );

    iMonitorPluginArray.ResetAndDestroy();

    iMonitorPluginArray.Close();

    OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_DELETEMONITORPLUGINS, "CHarvesterAO::DeleteMonitorPlugins - end" );    

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

    }

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

// StartMonitoring

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

//

void CHarvesterAO::StartMonitoring()

    {

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

    OstTrace0( TRACE_NORMAL, CHARVESTERAO_STARTMONITORING, "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()" );

    OstTrace0( TRACE_NORMAL, CHARVESTERAO_STOPMONITORING, "CHarvesterAO::StopMonitoring" );

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

        {

        iMonitorPluginArray[i]->StopMonitoring();

        }

    }

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

// PauseMonitoring

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

//

void CHarvesterAO::PauseMonitoring()

    {

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

    OstTrace0( TRACE_NORMAL, CHARVESTERAO_PAUSEMONITORING, "CHarvesterAO::PauseMonitoring" );

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

        {

        iMonitorPluginArray[i]->PauseMonitoring();

        }

    OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_PAUSEMONITORING, "CHarvesterAO::PauseMonitoring - end" );    

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

    }

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

// ResumeMonitoring

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

//

void CHarvesterAO::ResumeMonitoring()

    {

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

    OstTrace0( TRACE_NORMAL, CHARVESTERAO_RESUMEMONITORING, "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 )

	{