/*

* Copyright (c) 2007-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:  Metadata engine client session implementation*

*/

#include <etel3rdparty.h>

#include <e32property.h> 

#include "mdesessionimpl.h"

#include "mdesessionstartupao.h"

#include "mdcdef.h"

#include "mdcitem.h"

#include "mdcresult.h"

#include "mdeobjectdef.h"

#include "mderelationdef.h"

#include "mdeeventdef.h"

#include "mdeobject.h"

#include "mderelation.h"

#include "mdeevent.h"

#include "mdepanic.h"

#include "mdequeryimpl.h"

#include "mdenotifierao.h"

#include "mdeobjectdef.h"

#include "mdenamespacedef.h"

#include "mdccommon.pan"

#include "mdedatabuffer.h"

#include "mdcserializationbuffer.h"

#include "mdequerycriteriaserialization.h"

#include "mdelogiccondition.h"

#include "mdeobjectcondition.h"

#include "mdscommoninternal.h"

RMdESessionAsyncRequest::RMdESessionAsyncRequest( TRequestType aRequestType, 

	CMdCSerializationBuffer* aBuffer, CMdCSerializationBuffer& aResultBuffer,

	TRequestStatus& aRequestStatus) : 

	iRequestType(aRequestType), iBuffer(aBuffer), iResultBuffer(&aResultBuffer), 

	iRequestStatus(&aRequestStatus)

	{

	*iRequestStatus = KRequestPending;

	}

void RMdESessionAsyncRequest::Close()

	{

	if (iBuffer)

		{

		delete iBuffer;

		iBuffer = NULL;

		}

	}

void CMdESessionAsyncHandler::AddRequest( CMdCSerializationBuffer* aBuffer,

			CMdCSerializationBuffer& aResultBuffer, 

			TRequestStatus& aRequestStatus )

	{

	RMdESessionAsyncRequest request = RMdESessionAsyncRequest( 

			RMdESessionAsyncRequest::EAddRequest, 

			aBuffer, aResultBuffer, aRequestStatus );

	const TInt error = iRequests.Append(request);

    if( error != KErrNone )

        {

        return;

        }

	if( !IsActive() )

		{

		iEngineSession.DoAddItemsAsync( *aBuffer, aResultBuffer, 

				iStatus );

		SetActive();

		}

	}

void CMdESessionAsyncHandler::UpdateRequest( CMdCSerializationBuffer * aBuffer,

			CMdCSerializationBuffer& aResultBuffer,

			TRequestStatus& aRequestStatus )

	{

	RMdESessionAsyncRequest request = RMdESessionAsyncRequest( 

			RMdESessionAsyncRequest::EUpdateRequest,

			aBuffer, aResultBuffer, aRequestStatus);

	const TInt error = iRequests.Append(request);

    if( error != KErrNone )

        {

        return;

        }

	if( !IsActive() )

		{

		iEngineSession.DoUpdateItemsAsync(*aBuffer, aResultBuffer, 

				iStatus);

		SetActive();

		}

	}

void CMdESessionAsyncHandler::RemoveRequest( CMdCSerializationBuffer* aBuffer,

		CMdCSerializationBuffer& aResultBuffer,

		TRequestStatus& aRequestStatus )

	{

	RMdESessionAsyncRequest request = RMdESessionAsyncRequest( 

			RMdESessionAsyncRequest::ERemoveRequest, 

			aBuffer, aResultBuffer, aRequestStatus);

	const TInt error = iRequests.Append(request);

	if( error != KErrNone )

	    {

	    return;

	    }

	if( !IsActive() )

		{

		iEngineSession.DoRemoveItemsAsync( *aBuffer, aResultBuffer, 

				iStatus );	

		SetActive();

		}

	}

CMdESessionAsyncHandler* CMdESessionAsyncHandler::NewL(CMdESessionImpl& aSession, 

		RMdEEngineSession &aEngineSession)

	{

	CMdESessionAsyncHandler* self = CMdESessionAsyncHandler::NewLC(

			aSession, aEngineSession);

	CleanupStack::Pop(self);

	return self;

	}

CMdESessionAsyncHandler* CMdESessionAsyncHandler::NewLC( CMdESessionImpl& aSession, 

		RMdEEngineSession &aEngineSession )

	{

	CMdESessionAsyncHandler *self = new (ELeave) CMdESessionAsyncHandler(

			aSession, aEngineSession);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CMdESessionAsyncHandler::~CMdESessionAsyncHandler()

	{

	Cancel();

	const TInt count = iRequests.Count();

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

		{

		iRequests[i].Close();

		}

	iRequests.Close();		

	}		

void CMdESessionAsyncHandler::RunL()

	{

	//Remove first from array	

	RMdESessionAsyncRequest& request = iRequests[0];

	iRequests.Remove(0);

	const TInt status = iStatus.Int();

	User::RequestComplete( request.iRequestStatus, status );

	request.Close();

	if (iRequests.Count() > 0)

		{

		request = iRequests[0];

		iStatus = KRequestPending;

		switch( request.iRequestType )

			{

			case RMdESessionAsyncRequest::EAddRequest:

				iEngineSession.DoAddItemsAsync( *(request.iBuffer),

					*(request.iResultBuffer), iStatus);

				break;

			case RMdESessionAsyncRequest::EUpdateRequest:

				iEngineSession.DoUpdateItemsAsync( *(request.iBuffer),

					*(request.iResultBuffer), iStatus);

				break;

			case RMdESessionAsyncRequest::ERemoveRequest:

				iEngineSession.DoRemoveItemsAsync( *(request.iBuffer),

					*(request.iResultBuffer), iStatus);

				break;

			default:

			    break;

			}

		SetActive();			

		}						

	}

TInt CMdESessionAsyncHandler::RunError(TInt aError)

	{

	if( aError == KErrServerTerminated )

		{

		iSession.NotifyError( aError );

		return KErrNone;

		}

	else

		{

		return aError;

		}

	}

void CMdESessionAsyncHandler::DoCancel()

	{

	}

CMdESessionAsyncHandler::CMdESessionAsyncHandler(CMdESessionImpl& aSession, 

		RMdEEngineSession &aEngineSession)

	: CActive( CActive::EPriorityStandard ), iSession( aSession ), 

	iEngineSession(aEngineSession)

	{

	}

void CMdESessionAsyncHandler::ConstructL()		

	{

	CActiveScheduler::Add(this);

	}

CMdESessionImpl::CMdESessionImpl(MMdESessionObserver& aObserver)

	: iSessionStartupAO( NULL ), iSessionObserver(&aObserver), 

	  iSchemaBuffer( NULL ), iAsyncHandler(NULL), iNextQueryId( 0 ),

	  iSession( *this )

	{

	}

CMdESessionImpl::~CMdESessionImpl()

	{

    // No session errors should be sent during deconstruction to avoid possible double deletion

    iSessionObserver = NULL;

	delete iSchemaBuffer;

	iNotifiers.ResetAndDestroy();

	iNotifiers.Close();

	iSession.Shutdown();

	iSession.Close();

	iSchemaChunk.Close();

	iNamespaceDefs.ResetAndDestroy();

	iNamespaceDefs.Close();

	delete iSessionStartupAO;

	delete iAsyncHandler;

	}

void CMdESessionImpl::ConstructL()

	{

    iSessionStartupAO = CMdESessionStartupAO::NewL( *this, iSession );

    iAsyncHandler = CMdESessionAsyncHandler::NewL( *this, iSession );    

    }

void CMdESessionImpl::Close()

	{

	}

TInt CMdESessionImpl::NamespaceDefCount() const

	{

	return iNamespaceDefs.Count();

	}

CMdENamespaceDef& CMdESessionImpl::NamespaceDefL( TInt aIndex )

	{

	return *iNamespaceDefs[aIndex];

	}

CMdENamespaceDef& CMdESessionImpl::GetNamespaceDefL( const TDesC& aName )

	{

	const TInt KNamespaceCount = iNamespaceDefs.Count();

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

		{

		if ( !aName.Compare( iNamespaceDefs[i]->Name() ) )

			{

			return NamespaceDefL( i );

			}

		}

	User::Leave( KErrNotFound );

	return NamespaceDefL( -1 ); // never reached

	}

CMdENamespaceDef& CMdESessionImpl::GetNamespaceDefL(TDefId aId)

	{

	const TInt KNamespaceCount = iNamespaceDefs.Count();

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

		{

		if ( iNamespaceDefs[i]->Id() == aId )

			{

			return NamespaceDefL( i );

			}

		}

	User::Leave( KErrNotFound );

	return NamespaceDefL( -1 ); // never reached

	}

CMdENamespaceDef& CMdESessionImpl::GetDefaultNamespaceDefL()

	{

	return GetNamespaceDefL( KDefaultNamespaceDefId );

	}

CMdEObject* CMdESessionImpl::NewObjectL( CMdEObjectDef& aDef, const TDesC& aUri, TUint32 aMediaId )

	{

	CMdEObject* object = NewObjectLC( aDef, aUri, aMediaId );

	CleanupStack::Pop(object);

	return object;

	}

CMdEObject* CMdESessionImpl::NewObjectLC( CMdEObjectDef& aDef, const TDesC& aUri, TUint32 aMediaId )

	{

	CMdEObject* object = CMdEObject::NewLC( aDef, aUri, aMediaId );

	return object;

	}

void CMdESessionImpl::CommitObjectL(CMdEObject& aObject)

    {

	// check state

	// check that object is open for modifications

	if (!aObject.OpenForModifications())

		{

		User::Leave( KErrMdENotLocked );

		}

	RPointerArray<CMdEInstanceItem> items;

	CleanupClosePushL( items );

	items.AppendL( &aObject );

	UpdateItemsL( items );

	CleanupStack::PopAndDestroy( &items );	

    }

void CMdESessionImpl::CommitObjectsL(RPointerArray<CMdEObject>& aObjects)

    {

	// check state

	// check that object is open for modifications

    RPointerArray<CMdEInstanceItem> items;

    CleanupClosePushL( items );

    const TInt objectsCount = aObjects.Count();

    items.ReserveL( objectsCount );    

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

    	{

    	CMdEObject* obj = aObjects[i];

    	if ( !obj->OpenForModifications() )

    		{

    		User::Leave( KErrMdENotLocked );

    		}

		items.Append( obj );

    	}

    UpdateItemsL(items);

    items.Reset();

    CleanupStack::PopAndDestroy( &items );

    }

TItemId CMdESessionImpl::CancelObjectL(CMdEObject& aObject)

    {

    // check that object is open for modifications

    if( !aObject.OpenForModifications() || !aObject.BelongsToSession() )

    	{

    	User::Leave( KErrMdENotLocked );

    	}

	CMdCSerializationBuffer* buffer = CMdCSerializationBuffer::NewLC( 

			sizeof(TMdCItemIds) + 

			CMdCSerializationBuffer::KRequiredSizeForTItemId );

	TMdCItemIds itemIds;

	itemIds.iNamespaceDefId = aObject.Def().NamespaceDef().Id();

	itemIds.iObjectIds.iPtr.iCount = 1;

	itemIds.iObjectIds.iPtr.iOffset = sizeof(TMdCItemIds);

	itemIds.SerializeL( *buffer );

	buffer->InsertL( aObject.Id() );

    iSession.DoCancelObjectL( *buffer );

    TItemId result;

    buffer->PositionL( KNoOffset );

    itemIds.DeserializeL( *buffer );

	buffer->PositionL( itemIds.iObjectIds.iPtr.iOffset );

	buffer->ReceiveL( result );

	CleanupStack::PopAndDestroy( buffer ); // buffer

	if (result == KNoId)

		{

		User::Leave( KErrNotFound );

		}

	aObject.SetNotOpenForModifications();

	return result;

    }

CMdERelation* CMdESessionImpl::NewRelationLC( CMdERelationDef& aDef, TItemId aLeftObjectId, 

										      TItemId aRightObjectId, TInt32 aParameter )

	{

	return CMdERelation::NewLC(aDef, aLeftObjectId, aRightObjectId, aParameter);

	}

CMdERelation* CMdESessionImpl::NewRelationL( CMdERelationDef& aDef, TItemId aLeftObjectId, 

										     TItemId aRightObjectId, TInt32 aParameter )

	{

	CMdERelation* rel = NewRelationLC( aDef, aLeftObjectId, aRightObjectId, aParameter );

	CleanupStack::Pop( rel );

	return rel;

	}

CMdEEvent* CMdESessionImpl::NewEventLC(CMdEEventDef& aDef, TItemId aObjectId, TTime aTime, const TDesC* aSource, const TDesC* aParticipant)

	{

	return CMdEEvent::NewLC(aDef, aObjectId, aTime, aSource, aParticipant );

	}

CMdEEvent* CMdESessionImpl::NewEventL(CMdEEventDef& aDef, TItemId aObjectId, TTime aTime, const TDesC* aSource, const TDesC* aParticipant)

	{

	CMdEEvent* event = NewEventLC( aDef, aObjectId, aTime, aSource, aParticipant );

	CleanupStack::Pop( event );

	return event;

	}

void CMdESessionImpl::AddSchemaObserverL(MMdESchemaObserver& aObserver)

	{

	CheckOpened();

	CMdENamespaceDef& defaultNamespaceDef = GetDefaultNamespaceDefL();

	TInt err = FindNotifier( ESchemaModify, &aObserver, defaultNamespaceDef );

    if ( err != KErrNotFound )

    	{

    	if ( err >= 0 )

    		{

    		return;

    		}

    	User::LeaveIfError( err );

    	}

    CMdENotifierAO* notifier = CMdENotifierAO::NewLC( *this, iSession );

    notifier->RegisterL( ESchemaModify, &aObserver, NULL, defaultNamespaceDef );

    User::LeaveIfError(iNotifiers.Append( notifier ));

    CleanupStack::Pop( notifier );

	}

void CMdESessionImpl::RemoveSchemaObserverL(MMdESchemaObserver& aObserver)

	{

	CheckOpened();

	CMdENamespaceDef& defaultNamespaceDef = GetDefaultNamespaceDefL();

    const TInt index = FindNotifier( ESchemaModify, &aObserver, defaultNamespaceDef );

    if ( index != KErrNotFound )

        {

	    iNotifiers[index]->Cancel();

	    delete iNotifiers[index];

	    iNotifiers[index] = NULL;

	    iNotifiers.Remove( index );

        }

    else

    	{

       	User::Leave( KErrNotFound );

    	}

	}

void CMdESessionImpl::NotifySessionOpened(TInt aError)

	{

	__ASSERT_DEBUG(iSessionObserver != 0,

				    TMdEPanic::Panic(TMdEPanic::EInternal));

	if(!aError)

		{

		iSessionState = EMdESessionOpen;

		}

    if( iSessionObserver )

        {

        iSessionObserver->HandleSessionOpened(*this, aError);

        }

	}

void CMdESessionImpl::NotifyError(TInt aError)

	{

	if(iSessionObserver)

		{

		iSessionObserver->HandleSessionError(*this, aError);

		}

	iSessionState = EMdESessionClosed;

	}

void CMdESessionImpl::LoadSchemaL()

	{

	DoLoadSchemaL();

	}

RMdEEngineSession& CMdESessionImpl::EngineSession()

	{

	return iSession;

	}

void CMdESessionImpl::DoLoadSchemaL()

    {

    TInt handle( 0 );

    iSession.DoLoadSchemaL( handle );

   	TBuf<32> name( KSchemaChunkName );

	name.AppendNum( handle );

	iSchemaChunk.Close();

	User::LeaveIfError( iSchemaChunk.OpenGlobal( name, ETrue ) );

	CMdCSerializationBuffer* schemaBuffer = 

		CMdCSerializationBuffer::NewLC( iSchemaChunk.Base(), iSchemaChunk.Size() );

	if ( schemaBuffer->Size() == 0 )