/*

* Copyright (c) 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:  This is Metadata engine server session file

*

*/

// INCLUDE FILES

#include "mdsserversession.h"

#include "mdcresult.h"

#include "mdslogger.h"

#include "mdcserializationbuffer.h"

#include "mdsserver.h"

#include "mdsmanipulationengine.h"

#include "mdsmaintenanceengine.h"

#include "mdsfindengine.h"

#include "mdsobjectlocklist.h"

#include "mdsnotifier.h"

#include "mdsschema.h"

#include "mdcresult.h"

#include "mdcitem.h"

#include "mdsutils.h"

__USES_LOGGER

// ========================= MEMBER FUNCTIONS ==================================

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

// NewL

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

//

CMdSServerSession* CMdSServerSession::NewL( CMdSServer& aServer )

    {

    CMdSServerSession* self = CMdSServerSession::NewLC( aServer );

    CleanupStack::Pop( self );

    return self;

    }

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

// NewLC

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

//

CMdSServerSession* CMdSServerSession::NewLC( CMdSServer& aServer )

    {

    CMdSServerSession* self = new ( ELeave ) CMdSServerSession( aServer );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// ConstructL

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

//

void CMdSServerSession::ConstructL()

    {

    iServer.IncrementSessions();

    }

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

// Default constructor

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

//

CMdSServerSession::CMdSServerSession( CMdSServer& aServer )

	: iServer( aServer ) 

    {

    }

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

// Destructor

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

//

CMdSServerSession::~CMdSServerSession()

    {

    iFindEngines.ResetAndDestroy();

    iFindEngines.Close();

	iServer.LockList().UnlockBySession( *this );

	iServer.Notifier().RemoveEntriesBySession( *this );

    iServer.DecrementSessions();

    // purge any pending notifications

	iNotificationCache.ResetAndDestroy();

    iNotificationCache.Close();

    }

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

// Service the server message 

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

//

void CMdSServerSession::ServiceL( const RMessage2& aMessage )

    {

    __LOG2( ELogServer, "ServiceL message: %d uid: %.8x", 

    		aMessage.Function(),

    		aMessage.Identity());

	if( iServer.BackupOrRestoreRunning() )

		{

		aMessage.Complete( KErrServerBusy );

		return;

		}

    TRAPD( err, ServiceFunctionL( aMessage ) );

    if( err != KErrNone )

        {

        aMessage.Complete( err );

        }

    }

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

// ServiceFunctionL

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

//

void CMdSServerSession::ServiceFunctionL( const RMessage2& aMessage )

    {

    TInt complete(KErrNone);

    switch ( aMessage.Function() )

        {

        // Add items 

        case EAdd:

            {

            AddL( aMessage );

            break;

            }

        // Add relation def

        case EAddRelationDef:

        	{

        	AddRelationDefL(aMessage);

        	iServer.Notifier().NotifySchemaAddedL();

        	break;

        	}

        // Add event def

        case EAddEventDef:

        	{

        	AddEventDefL(aMessage);

        	iServer.Notifier().NotifySchemaAddedL();

        	break;

        	}        	

        // Remove items

        case ERemove:

            {

            RemoveL( aMessage );

            break;

            }

        // Find items

        case EFind:

            {

            TRAPD( err, FindL( aMessage ) );

            if ( err != KErrNone )

                {

                if ( err != KErrNotReady )

                    {

                    FindCancel( aMessage, err );

                    return;

                    }

	            complete = err;

                }

            break;

            }

        case EAsyncFind:

            {

            TRAPD( err, FindAsyncL( aMessage ) );

            if ( err != KErrNone)

            	{

            	if(err != KErrNotReady)

	                {

	                FindCancel( aMessage, err );

	                return;

	                }

	    		complete = err;

            	}

            else 

            	{

            	// if no error don't complete message

            	return;

            	}

            break;

            }

        case EContinueAsyncFind:

            {

            TRAPD( err, FindContinueAsyncL( aMessage ) );

            if ( err != KErrNone )

                {

                FindCancel( aMessage, err );

                }

            // if no error don't complete message

            return;

            }

        case ECancelFind:

            {

            FindCancel( aMessage, KErrNone );

            return;

            }

        case ECheckObject:

            {

            CheckObjectL( aMessage );

            break;

            }

        case EGetData:

            {

            GetDataL( aMessage );

            break;

            }

        case ECancelObject:

            {

            CancelObjectL( aMessage );

            break;

            }

        case EUpdate:

            {

            UpdateL( aMessage );

            break;

            }

        case ERegister:

            {

            RegisterL( aMessage );

            break;

            }

        case EListen:

            {

            ListenL( aMessage );

            // if no error don't complete message

            return;

            }

        case EUnregister:

            {

            UnregisterL( aMessage );

            break;

            }

        case EShutdown:

            {

            ShutdownL( aMessage );

            break;

            }

        case EImportMetadata:

        case EAsyncImportMetadata:

            {

            ImportMetadataL( aMessage );

            break;

            }

        case EExportMetadata:

        case EAsyncExportMetadata:

            {

            ExportMetadataL( aMessage );

            break;

            }

        case EImportSchema:

            {

            TRAPD( err, ImportSchemaL( aMessage ) );

            if(err != KErrNone && err != KErrAccessDenied)

            	{

            	// Map all other errors to KErrCorrupt

            	err = KErrCorrupt;

            	}

            if(!err)

            	{

            	iServer.Notifier().NotifySchemaAddedL();

            	}

			complete = err;

            break;

            }

        case EAddMemoryCard:

        	{

        	AddMemoryCardL( aMessage );

        	break;

        	}

    	case EGetMemoryCard:

        	{

        	GetMemoryCardL( aMessage );

        	break;

        	}

    	case ECheckMemoryCard:

        	{

        	CheckMemoryCardL( aMessage );

        	break;

        	}

    	case ESetMedia:

    		{

    		SetMediaL( aMessage );

    		break;

    		}

    	case EGetMedia:

    		{

    		GetMediaL( aMessage );

    		break;

    		}

    	case EGetPresentMedias:

    		{

    		GetPresentMediasL( aMessage );

    		break;

    		}

    	case ESetFileToPresent:

        	{

        	complete = KErrNotSupported;

        	break;

        	}

    	case ESetFilesToPresent:

        	{

        	SetFilesToPresentL(aMessage);

        	break;

        	}        	

    	case ESetFilesToNotPresent:

        	{

        	SetFilesToNotPresentL(aMessage);

        	break;

        	}

    	case ERemoveFilesNotPresent:

        	{

        	RemoveFilesNotPresentL(aMessage);

        	break;

        	}

    	case EGetSchemaVersion:

        	{

        	GetSchemaVersionL(aMessage);

        	break;

        	}

    	case ESetObjectToPresentByGuid:

    		{

    		SetObjectToPresentByGuidL(aMessage);

    		break;

    		}

        case EResetDB:

        	{

			#ifdef _DEBUG

        	iServer.ResetDBL();

			#else

        	User::Leave( KErrNotSupported );

			#endif

        	break;

        	}

        case ESetHarvestingPrioritizationChunk:

        	{

        	iServer.SetHarvestingPrioritizationChunkL( aMessage, 0 );

        	break;

        	}

        case EAddHarvestingPrioritizationObserver:

        	{

            User::LeaveIfError( iServer.AddHarvestingPrioritizationObserver( aMessage ) );

            // if no error don't complete message

        	return;

        	}

        case ECancelHarvestingPrioritizationObserver:

        	{

        	User::LeaveIfError( iServer.CancelHarvestingPrioritizationObserver() );

        	break;

        	}

        case EChangePath:

        	{

        	ChangePathL( aMessage );

        	break;

        	}

        case EChangeMediaId:

        	{

        	ChangeMediaIdL( aMessage );

        	break;

        	}	

        case ESetPending:

        	{

        	SetPendingL( aMessage );

        	}

        	break;

        case EResetPending:

        	{

        	ResetPendingL( aMessage );

        	}

        	break;

        case EGetPendingCount:

        	{

        	complete = GetPendingCountL( aMessage );

        	}

        	break;

        case EGetPending:

        	{

        	complete = GetPendingL( aMessage );

        	}

        	break;

        default:

            iServer.PanicClient( aMessage, EBadRequest );

        }

    aMessage.Complete(complete);

    }

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

// QueriesCompleteL

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

//

void CMdSServerSession::QueriesCompleteL()

	{

	// check if all queries are complete

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

    	{

    	CMdSFindEngine* fe = iFindEngines[i];

    	if( !fe->IsComplete() )

        	{

    	    User::Leave( KErrNotReady );

			}

    	}		

	}

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

// AddL

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

//

void CMdSServerSession::AddL( const RMessage2& aMsg )

    {

	if ( iServer.DiskFull() )

		{

		User::Leave( KErrDiskFull );

		}

	TInt resultLength = aMsg.GetDesLengthL( 1 );

	CMdCSerializationBuffer* buffer = CMdCSerializationBuffer::NewLC( aMsg, 0 );	

	CMdCSerializationBuffer* resultBuf = CMdCSerializationBuffer::NewLC( resultLength );

    iServer.Manipulate().AddL( *buffer, *resultBuf, this );

	aMsg.WriteL(1, resultBuf->Buffer() );

	CleanupStack::PopAndDestroy( resultBuf );

	CleanupStack::PopAndDestroy( buffer );

    }

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

// AddRelationDefL

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

//	

void CMdSServerSession::AddRelationDefL(const RMessage2 &aMsg)	

	{

	TDefId namespaceId = aMsg.Int0();

	TInt nameLength = aMsg.GetDesLength( EAddDefArgDefName );

	if ( nameLength < 0 )

		{

		User::Leave( KErrBadDescriptor );

		}

	HBufC* namebuf = HBufC::NewLC( nameLength );

	TPtr bufdes = namebuf->Des();

	aMsg.ReadL( EAddDefArgDefName, bufdes );

	iServer.Manipulate().AddRelationDefL( namespaceId, *namebuf );

	iServer.Schema().SerializeToSharedMemoryL();

	CleanupStack::PopAndDestroy( namebuf );

	}

void CMdSServerSession::AddEventDefL(const RMessage2 &aMsg)	

	{

	TDefId namespaceId = aMsg.Int0();

	TInt nameLength = aMsg.GetDesLength( EAddDefArgDefName );

	if ( nameLength < 0 )

		{

		User::Leave( KErrBadDescriptor );

		}

	HBufC* namebuf = HBufC::NewLC( nameLength );

	TPtr bufdes = namebuf->Des();

	aMsg.ReadL( EAddDefArgDefName, bufdes );

	iServer.Manipulate().AddEventDefL( namespaceId, *namebuf );

	iServer.Schema().SerializeToSharedMemoryL();

	CleanupStack::PopAndDestroy( namebuf );

	}