/*

* 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:  Composer Image Plug-in

*

*/

#include <e32base.h>

#include "mdelogiccondition.h"

#include "mdenamespacedef.h"

#include "composerimageplugin.h"

#include "harvesterlog.h"

#include "mdeconstants.h"

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

// NewL

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

//

CComposerImagePlugin* CComposerImagePlugin::NewL()

    {

    WRITELOG( "CComposerImagePlugin::NewL()" );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// ~CComposerImagePlugin

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

//

CComposerImagePlugin::~CComposerImagePlugin() // destruct

    {   

    WRITELOG( "CComposerImagePlugin::~CComposerImagePlugin()" );

    delete iImageComposerAO;

    delete iLocationRelationObserver;

    delete iImagePresentObserver;

    delete iMdEHarvesterSession;

    }

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

// CComposerImagePlugin

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

//

CComposerImagePlugin::CComposerImagePlugin() : // first-phase C++ constructor

    iImageComposerAO( NULL ), iLocationRelationObserver( NULL ),

    iImagePresentObserver( NULL ), iMdEHarvesterSession( NULL )

    {

    WRITELOG( "CComposerImagePlugin::CComposerImagePlugin()" );

    }

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

// ConstructL

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

//

void CComposerImagePlugin::ConstructL() // second-phase constructor

    {

    WRITELOG( "CComposerImagePlugin::ConstructL()" );

    iImageComposerAO = CImageComposerAO::NewL();

    iLocationRelationObserver = NULL;

    }

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

// SetObservers

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

//

void CComposerImagePlugin::SetObservers()

    {

    WRITELOG( "CComposerImagePlugin::SetObservers()" );

    TRAPD( err, SetObserversL() );

    if ( err != KErrNone )

        {

        WRITELOG1( "CComposerImagePlugin::SetObservers Error: %d", err );

        }

    }

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

// SetObserversL

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

//

void CComposerImagePlugin::SetObserversL()

    {

    if ( iSession )

        {

        iImageComposerAO->SetSession( iSession );

        CMdELogicCondition* condition = CMdELogicCondition::NewL( ELogicConditionOperatorAnd );

        CleanupStack::PushL( condition );

        CMdENamespaceDef& defaultNamespace = iSession->GetDefaultNamespaceDefL();

        CMdEObjectDef& imageDef = 

        	defaultNamespace.GetObjectDefL( MdeConstants::Image::KImageObject );

        condition->AddObjectConditionL( imageDef );

        CleanupStack::Pop( condition );

        iSession->AddObjectObserverL( *this, condition, ENotifyModify, &defaultNamespace );

        if ( iLocationRelationObserver )

            {

            delete iLocationRelationObserver;

            iLocationRelationObserver = NULL;

            }

        iLocationRelationObserver = CLocationRelationObserver::NewL( iSession, this );

        if ( iMdEHarvesterSession )

        	{

        	delete iMdEHarvesterSession;

        	iMdEHarvesterSession = NULL;

        	}

        iMdEHarvesterSession = CMdEHarvesterSession::NewL ( *iSession );

        if ( iImagePresentObserver )

        	{

        	delete iImagePresentObserver;

        	iImagePresentObserver = NULL;

        	}

        iImagePresentObserver = CImagePresentObserver::NewL( iSession, this, iMdEHarvesterSession );

        }

    }

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

// RemoveObservers

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

//

void CComposerImagePlugin::RemoveObservers()

    {

    if ( iSession )

        {

        TRAP_IGNORE( iSession->RemoveObjectObserverL( *this ) );

        iImageComposerAO->RemoveSession();

        delete iImagePresentObserver;

        iImagePresentObserver = NULL;

        delete iLocationRelationObserver;

        iLocationRelationObserver = NULL;

        }

    }

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

// IsComposingComplete

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

//

TBool CComposerImagePlugin::IsComposingComplete()

    {

    WRITELOG( "CComposerImagePlugin::IsComposingComplete()" );

    return iImageComposerAO->IsComposingComplete();

    }

/** 

 * Handle object modifications

 */

void CComposerImagePlugin::HandleObjectNotification(CMdESession& /*aSession*/, 

		TObserverNotificationType aType,

		const RArray<TItemId>& aObjectIdArray)

	{

    if ( aType == ENotifyModify )

    	{

#ifdef _DEBUG

        WRITELOG1( "CComposerImagePlugin::HandleObjectNotification() objects: %d", aObjectIdArray.Count() );

#endif

        TRAP_IGNORE( iMdEHarvesterSession->SetPendingL( aObjectIdArray ) );

    	iImageComposerAO->AddToQueue( aObjectIdArray, EFalse );

    	}

	}

void CComposerImagePlugin::WriteGPSTagsL( TItemId aObjectId, TItemId locationId )

	{

	RArray<TItemId> objectId;

	CleanupClosePushL( objectId );

	objectId.Append( aObjectId );

	iMdEHarvesterSession->SetPendingL( objectId );

	CMdENamespaceDef& defaultNamespace = iSession->GetDefaultNamespaceDefL();

    CMdEObjectDef& imageObjDef = defaultNamespace.GetObjectDefL( MdeConstants::Image::KImageObject );

    CMdEObjectDef& locationObjDef = defaultNamespace.GetObjectDefL( MdeConstants::Location::KLocationObject );

	CMdEObject* object = iSession->GetObjectL( aObjectId, imageObjDef );

	CleanupStack::PushL( object );

	CMdEObject* location = iSession->GetObjectL( locationId, locationObjDef );

	CleanupStack::PushL( location );

	if( object && location )

		{

		TRAPD( err, iImageComposerAO->DoWriteExifL( object, location ) );

		if ( err == KErrNone )

			{

			iMdEHarvesterSession->ResetPendingL( objectId );

			}

		}

	CleanupStack::PopAndDestroy( 3, &objectId );

	}

void CComposerImagePlugin::HandlePendingObjects( const RArray<TItemId>& aObjectIdArray )

	{

	iImageComposerAO->AddToQueue( aObjectIdArray, ETrue);

	}