/*

* 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 "mdesession.h"

#include "mdesessionimpl.h"

#include "mdeobjectdef.h"

#include "mdeobjectquery.h"

#include "mderelationdef.h"

#include "mdeeventdef.h"

#include "mdeobject.h"

#include "mderelation.h"

#include "mdeevent.h"

#include "mdeobjectdef.h"

#include "mdenamespacedef.h"

#include "mdedatabuffer.h"

#include "mdelogiccondition.h"

#include "mdeobjectcondition.h"

#include "VcxMyVideosMdsDbTest.h"

// for CleanupResetAndDestroyPushL

#include <mmf/common/mmfcontrollerpluginresolver.h>

CMdESessionAsyncHandler* CMdESessionAsyncHandler::NewL(MMdESessionObserver& aObserver)

    {

    CMdESessionAsyncHandler* self = new CMdESessionAsyncHandler( aObserver );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

void CMdESessionAsyncHandler::ConstructL()

    {

    CTimer::ConstructL();

    }   

CMdESessionAsyncHandler::~CMdESessionAsyncHandler()

	{

	Cancel();

	}		

void CMdESessionAsyncHandler::RunL()

	{

	iObserver.HandleSessionOpened(*(CMdESession*) 0  ,test->mdssessionasyncerror);

	}

CMdESessionAsyncHandler::CMdESessionAsyncHandler(MMdESessionObserver& aObserver)

	: CTimer( CActive::EPriorityStandard ), iObserver( aObserver )

	{

	CActiveScheduler::Add(this);

	}

CMdESessionImpl::CMdESessionImpl(MMdESessionObserver& aObserver)

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

	  iSchemaBuffer( NULL ), iNextQueryId( 0 )

	{

    iTimer = CMdESessionAsyncHandler::NewL( aObserver );

    iTimer->After( 1000 );

	}

CMdESessionImpl::~CMdESessionImpl()

	{

    delete iTimer;

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

    iSessionObserver = NULL;

	delete iSchemaBuffer;

	iNotifiers.ResetAndDestroy();

	iNotifiers.Close();

	iSchemaChunk.Close();

	iNamespaceDefs.ResetAndDestroy();

	iNamespaceDefs.Close();

	delete iSessionStartupAO;

	}

void CMdESessionImpl::ConstructL()

	{

    }

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

	{

	}

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)

    {

    }

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

    {

    }

TItemId CMdESessionImpl::CancelObjectL(CMdEObject& aObject)

    {

    }

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

										      TItemId aRightObjectId, TInt32 aParameter )

	{

	}

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

										     TItemId aRightObjectId, TInt32 aParameter )

	{

	}

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

	{

	}

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

	{

	}

void CMdESessionImpl::AddSchemaObserverL(MMdESchemaObserver& aObserver)

	{

	}

void CMdESessionImpl::RemoveSchemaObserverL(MMdESchemaObserver& aObserver)

	{

	}

void CMdESessionImpl::NotifySessionOpened(TInt aError)

	{

	}

void CMdESessionImpl::NotifyError(TInt aError)

	{

	if(iSessionObserver)

		{

		iSessionObserver->HandleSessionError(*this, aError);

		}

	iSessionState = EMdESessionClosed;

	}

void CMdESessionImpl::LoadSchemaL()

	{

	DoLoadSchemaL();

	}

void CMdESessionImpl::DoLoadSchemaL()

    {    }

void CMdESessionImpl::AddRelationDefL( const CMdENamespaceDef &aNamespaceDef, const TDesC &aName )

	{

	}

void CMdESessionImpl::AddEventDefL( const CMdENamespaceDef &aNamespaceDef, const TDesC &aName )

	{

	}

CMdEObject* CMdESessionImpl::GetObjectL( const TItemId aId, CMdENamespaceDef* aNamespaceDef )

	{}

CMdEObject* CMdESessionImpl::GetFullObjectL( const TItemId aId, CMdENamespaceDef* aNamespaceDef )

	{

	}

CMdEObject* CMdESessionImpl::GetObjectL( const TItemId aId, CMdEObjectDef& aObjectDef )

	{

    if( test->mdsoperationleaves )

        {

        User::Leave( test->mdsoperationleaves );

        }

    if ( test->mdsoperationreturns )

        {

        return NULL;

        }

    else

        {

        CMdEObject* object = CMdEObject::NewL( aObjectDef, KNullDesC(), aId );

        return object;

        }

	}

CMdEObject* CMdESessionImpl::GetObjectL( const TInt64 aGuidHigh, const TInt64 aGuidLow, CMdENamespaceDef* aNamespaceDef )

	{}

CMdEObject* CMdESessionImpl::GetFullObjectL( const TInt64 aGuidHigh, const TInt64 aGuidLow, CMdENamespaceDef* aNamespaceDef )

	{}

CMdEObject* CMdESessionImpl::GetObjectL( const TInt64 aGuidHigh, const TInt64 aGuidLow, CMdEObjectDef& aObjectDef )

	{}

CMdEObject* CMdESessionImpl::OpenObjectL( const TItemId aId, CMdENamespaceDef* aNamespaceDef )

	{}

CMdEObject* CMdESessionImpl::OpenFullObjectL( const TItemId aId, CMdENamespaceDef* aNamespaceDef )

	{}

CMdEObject* CMdESessionImpl::OpenObjectL( const TItemId aId, CMdEObjectDef& aObjectDef )

    {

    if( test->mdsoperationleaves )

        {

        User::Leave( test->mdsoperationleaves );

        }

    if ( test->mdsoperationreturns )

        {

        return NULL;

        }

    else

        {

        CMdEObject* object = CMdEObject::NewL( aObjectDef, KNullDesC(), aId );

        return object;

        }

    }

CMdEObject* CMdESessionImpl::OpenObjectL( const TInt64 aGuidHigh, const TInt64 aGuidLow, CMdENamespaceDef* aNamespaceDef )

	{}

CMdEObject* CMdESessionImpl::OpenFullObjectL( const TInt64 aGuidHigh, const TInt64 aGuidLow, CMdENamespaceDef* aNamespaceDef )

	{}

CMdEObject* CMdESessionImpl::OpenObjectL( const TInt64 aGuidHigh, const TInt64 aGuidLow, CMdEObjectDef& aObjectDef )

    { }

EXPORT_C CMdEObject* CMdESessionImpl::GetObjectL( const TDesC& aUri, CMdENamespaceDef* aNamespaceDef )

	{}

CMdEObject* CMdESessionImpl::GetFullObjectL( const TDesC& aUri, CMdENamespaceDef* aNamespaceDef )

	{}

CMdEObject* CMdESessionImpl::GetObjectL( const TDesC& aUri, CMdEObjectDef& aObjectDef )

    { }

CMdEObject* CMdESessionImpl::OpenObjectL( const TDesC& aUri, CMdENamespaceDef* aNamespaceDef )

	{}

CMdEObject* CMdESessionImpl::OpenFullObjectL( const TDesC& aUri, CMdENamespaceDef* aNamespaceDef )

	{}

CMdEObject* CMdESessionImpl::OpenObjectL( const TDesC& aUri, CMdEObjectDef& aObjectDef )

    { 

    CMdEObject* object = CMdEObject::NewLC( aObjectDef, aUri, 0 );

    return object;

    }

void CMdESessionImpl::CheckObjectL( TMdEObject& aObject, const TDesC& aUri, 

		CMdENamespaceDef* aNamespaceDef )

	{}

void CMdESessionImpl::CheckObjectL( TMdEObject& aObject, TItemId aId, 

		CMdENamespaceDef* aNamespaceDef )

	{}

void CMdESessionImpl::CheckObjectL( RArray<TMdEObject>& aObjects, 

		const RArray<TItemId>& aIds, CMdENamespaceDef* aNamespaceDef )

	{}

CMdERelation* CMdESessionImpl::GetRelationL(TItemId aId, CMdENamespaceDef* aNamespaceDef)

    { }

CMdEEvent* CMdESessionImpl::GetEventL(TItemId aId, 

		CMdENamespaceDef* aNamespaceDef)

    {}

CMdCSerializationBuffer* CMdESessionImpl::RemoveCommonL( 

		CMdENamespaceDef& aNamespaceDef, const RArray<TItemId>* aObjects,

		const RArray<TItemId>* aEvents, const RArray<TItemId>* aRelations )

	{}

CMdCSerializationBuffer* CMdESessionImpl::RemoveCommonL( 

		CMdENamespaceDef& aNamespaceDef, 

		const RPointerArray<TDesC16>* aObjects,

		const RArray<TItemId>* aEvents, const RArray<TItemId>* aRelations )

	{

	}

TInt CMdESessionImpl::DeserializeIdsL( RMdEDataBuffer& aSerializedItemIds, 

		RArray<TItemId>* aResultObjects, RArray<TItemId>* aResultEvents, 

		RArray<TItemId>* aResultRelations )

	{}

TItemId CMdESessionImpl::RemoveObjectL( TItemId aId, 

		CMdENamespaceDef* aNamespaceDef )

    {

    if ( test->mdsoperationleaves )

        {

        User::Leave( test->mdsoperationleaves );

        }

    else if ( test->mdsoperationreturns )

        {

        return 0;

        }

    else

        {

        return 1;

        }

    }

TItemId CMdESessionImpl::RemoveObjectL( const TDesC& aUri, 

		CMdENamespaceDef* aNamespaceDef )

    { }

TInt CMdESessionImpl::RemoveObjectsL( const RArray<TItemId>& aId, 

		RArray<TItemId>& aResult, CMdENamespaceDef* aNamespaceDef )

	{}

TInt CMdESessionImpl::RemoveObjectsL( const RPointerArray<TDesC>& aUri, 

		RArray<TItemId>& aResult, CMdENamespaceDef* aNamespaceDef )

	{}

void CMdESessionImpl::RemoveObjectsAsyncL( 

		const RArray<TItemId>& aId, TRequestStatus& aStatus, 

		RMdEDataBuffer& aSerializedObjectIds, 

		CMdENamespaceDef* aNamespaceDef )

	{}

void CMdESessionImpl::RemoveObjectsAsyncL( 

		const RPointerArray<TDesC>& aUri, TRequestStatus& aStatus, 

		RMdEDataBuffer& aSerializedObjectIds, 

		CMdENamespaceDef* aNamespaceDef )

	{}

TItemId CMdESessionImpl::RemoveRelationL(TItemId aId, 

		CMdENamespaceDef* aNamespaceDef)

    {}

TInt CMdESessionImpl::RemoveRelationsL(const RArray<TItemId>& aId, 

		RArray<TItemId>& aSuccessful, CMdENamespaceDef* aNamespaceDef)

	{}

void CMdESessionImpl::RemoveRelationsAsyncL(

		const RArray<TItemId>& aId, TRequestStatus& aStatus, 

		RMdEDataBuffer& aSerializedRelationIds, 

		CMdENamespaceDef* aNamespaceDef)

	{}

/**

* Add methods

*/

TItemId CMdESessionImpl::AddItemL( CMdEInstanceItem& aItem )

	{}

CMdCSerializationBuffer* CMdESessionImpl::SerializeItemsL( 

		RPointerArray<CMdEInstanceItem>& aItems )

    { }

void CMdESessionImpl::DeserializeQueryResultL( 

		CMdCSerializationBuffer& aBuffer, 

		RPointerArray<CMdEInstanceItem>& aItems )

	{}

TItemId CMdESessionImpl::AddObjectL( CMdEObject& aObject )

    {

    if( test->mdsoperationleaves )

        {

        User::Leave( test->mdsoperationleaves );

        }

    if ( test->mdsoperationreturns )

        {

        return 0;

        }

    else

        {

        return 1;

        }

    }

TInt CMdESessionImpl::AddObjectsL( RPointerArray<CMdEObject>& aObjects )

    {

    }

TItemId CMdESessionImpl::AddRelationL( CMdERelation& aRelation ) 

    {

    }

TItemId CMdESessionImpl::UpdateRelationL( CMdERelation& aRelation ) 

    {

    }

TInt CMdESessionImpl::AddItemsL( RPointerArray<CMdEInstanceItem>& aItems )

    {    

    }

void CMdESessionImpl::AddItemsAsyncL( 

		RPointerArray<CMdEInstanceItem>& aItems, TRequestStatus& aStatus, 

		RMdEDataBuffer& aSerializedItemIds )

    {    

    }

TInt CMdESessionImpl::UpdateItemsL( RPointerArray<CMdEInstanceItem>& aItems )

    {    }

void CMdESessionImpl::UpdateItemsAsyncL( 

		RPointerArray<CMdEInstanceItem>& aItems, TRequestStatus& aStatus,

		RMdEDataBuffer& aSerializedItemIds )

    {

    }

TInt CMdESessionImpl::DeserializeItemsL( RMdEDataBuffer& aSerializedItems, 

		RPointerArray<CMdEInstanceItem>& aItems )

	{

	}

TItemId CMdESessionImpl::AddEventL( CMdEEvent& aEvent )

    {

    }

TItemId CMdESessionImpl::RemoveEventL( TItemId aId, 

		CMdENamespaceDef* aNamespaceDef )

    {

    }

TInt CMdESessionImpl::RemoveEventsL( const RArray<TItemId>& aId, 

		RArray<TItemId>& aSuccessful, CMdENamespaceDef* aNamespaceDef )

	{

	}    

void CMdESessionImpl::RemoveEventsAsyncL( 

		const RArray<TItemId>& aId, TRequestStatus& aStatus, 

		RMdEDataBuffer& aSerializedEventIds, 

		CMdENamespaceDef* aNamespaceDef )

	{

	}

// Query 

CMdEObjectQuery* CMdESessionImpl::NewObjectQueryL(

		CMdENamespaceDef& aNamespaceDef, CMdEObjectDef& aObjectDef, 

		MMdEQueryObserver* aObserver)

    {    

    return new CMdEObjectQuery();

    }

CMdEObjectQuery* CMdESessionImpl::NewObjectQueryL(

		CMdEObjectDef& aObjectDef, RPointerArray<CMdEObjectDef>* aObjectDefs, 

		MMdEQueryObserver* aObserver)

	{

	}

CMdERelationQuery* CMdESessionImpl::NewRelationQueryL(

		CMdENamespaceDef& aNamespaceDef, MMdEQueryObserver* aObserver)

    {}

CMdEEventQuery* CMdESessionImpl::NewEventQueryL(

		CMdENamespaceDef& aNamespaceDef, MMdEQueryObserver* aObserver)

    {}

void CMdESessionImpl::AddObjectObserverL( MMdEObjectObserver& aObserver,

    									  CMdELogicCondition* aCondition,