// Copyright (c) 1997-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:

//

#include "calclient.h"

#include <s32mem.h>

#include "agmallocator.h"

#include "agmattachment.h"

#include "agmentry.h"

#include "agmtlsproxy.h"

#include "agmtzrules.h"

#include "agmrptdef.h"

#include "agmcategory.h"

#include "agmcontent.h"

#include "agmserv.h"

#include "agssignal.h"

#include "calattachmentmanagerimpl.h"

#include "calinstance.h"

#include "calentryimpl.h"

#include "agmsortcriteria.h"

#include "calsessionimpl.h"

#include "calcalendarinfoimpl.h"

#include "agmfilechangenotification.h"

const TUint KDefaultMessageSlots = 3;

_LIT(KAgendaMutex, "AgnMutex");

//

// RAgendaServ

//

void RAgendaServ::AddSessionL(const CCalSessionImpl& aSession, TInt& aSessionId)

	{

	__ASSERT_DEBUG(FindSession(aSession) == -1, User::Invariant());

	iCalSessions.AppendL(&aSession);

	aSessionId = ++iLastSessionId;

	}

TBool RAgendaServ::RemoveSession(const CCalSessionImpl& aSession)

	{

	TInt pos = FindSession(aSession);

	if (pos != KErrNotFound)

	    {

	    iCalSessions.Remove(pos);

	    }

	return (iCalSessions.Count()>0)?ETrue:EFalse;

	}

TInt RAgendaServ::FindSession(const CCalSessionImpl& aSession)

	{

	const TInt count = iCalSessions.Count();

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

		{

		if(&aSession == iCalSessions[ii])

			{

			return ii;

			}

		}

	return -1;

	}

void RAgendaServ::IncreaseRef()

	{

	iReferenceCount++;

	}

TInt RAgendaServ::DecreaseRef()

	{

	iReferenceCount--;

	__ASSERT_ALWAYS( iReferenceCount >= 0, User::Invariant());

	return iReferenceCount;

	}

RAgendaServ* RAgendaServ::NewL()

/** Constructs a new RAgendaServ, initialising all member data to NULL.

@return A pointer to the client interface to the agenda server. */

	{

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

	TRAPD(err, self->ConstructL());

	if(err != KErrNone)

	    {

	    delete self;

	    User::Leave(err);

	    }

	return self;

	}

 // not derived from CBase, so have to set member data to NULL

RAgendaServ::RAgendaServ()

	: RSessionBase(), iBuffer(NULL),iLastSessionId(0)

	{

	}

void RAgendaServ::ConstructL()

	{

	iReferenceCount = 0;

	iSimpleEntryAllocator = 0;

	iSimpleEntryAllocator = new (ELeave) CAgnSimpleEntryAllocator;

	CAgnTlsProxy::CreateL(CAgnTlsProxy::TAgnTlsTzRulesType_Client);

    iBuffer = CBufFlat::NewL(KInitialBufferSize);

    iBuffer->ExpandL(0, KInitialBufferSize);

	}

RAgendaServ::~RAgendaServ()

/** The destructor frees all resources owned by the server, prior to its destruction. */

	{

	__ASSERT_ALWAYS( iReferenceCount == 0, User::Invariant());

	delete iBuffer;

	CAgnTlsProxy::Release(NULL);	

	delete iSimpleEntryAllocator;

	iCalSessions.Close();

	}

// Connect to the server

//

// CAgnServer

//

// Static function to create a new thread or process, depending upon the

// variant. For marm builds, the AGSVEXE.EXE program is run, which 

// creates the server objects in a new process

TInt RAgendaServ::StartServer()

	{

	TRequestStatus stat;

	TAgnSignal signal(stat);

	RProcess server;

	// Locate the server on all drives (Y-A, then Z)

	TInt ret = server.Create(KAgendaServerExe, signal.Command(), EOwnerThread);

	if (ret!=KErrNone)

		{

		return ret;

		}

	server.SetPriority(EPriorityForeground);

	server.Rendezvous(stat);

	if (stat!=KRequestPending)

		{

		server.Kill(0);		// abort startup

		}

	else

		{

		server.Resume();	// logon OK - start the server

		}

	User::WaitForRequest(stat);

	server.Close();

	return stat.Int();

	}

TInt RAgendaServ::Connect()

/** Connects the client process to the agenda server. 

This function must be called before the server can be used.

@return An error code. KErrNone if successful. */

	{

	RMutex mutex;

	TInt ret = mutex.CreateGlobal(KAgendaMutex);

	if(ret != KErrNone && ret != KErrAlreadyExists)

		{

		return ret;

		}

	ret = mutex.OpenGlobal(KAgendaMutex);	

	if (ret != KErrNone && ret != KErrAlreadyExists)

		{

		return ret;

		}

	mutex.Wait();

	TInt r = DoConnect();

	if (r==KErrNotFound || r==KErrServerTerminated)

		{

		r=StartServer();

		if(r==KErrNone || r==KErrAlreadyExists)

			{

			r=DoConnect();

			}

		}

	mutex.Signal();

	mutex.Close();

	return r;

	}

TInt RAgendaServ::DoConnect()

	{

	return CreateSession(KAgendaServerName,Version(), KDefaultMessageSlots);

	}

// Return the client side version no.

TVersion RAgendaServ::Version() const

	{

	return (TVersion(KAgnServerMajorVersion,KAgnServerMinorVersion,KAgnServerBuildVersion));

	}

//

// Server Utility Functions

void RAgendaServ::Panic(TAgnClientPanic aPanic) const

	{

	_LIT(KAgendaClient,"AgendaClient");

	User::Panic(KAgendaClient, aPanic);

	}

/** 

Checks the size of the incoming buffer, and if it is larger

than the size of the buffer already defined, allocates enough

space in aBuffer, and transfers the data from the server

@capability ReadUserData

*/

CBufFlat* RAgendaServ::CreateTransmitBufferL(TInt aBufferSize) const

	{

	CBufFlat* buffer = NULL;

	if (aBufferSize > KInitialBufferSize)

		{

		// Create a buffer with granularity of aBufferSize

		buffer = CBufFlat::NewL(aBufferSize);

		CleanupStack::PushL(buffer);

		// Extends the size of the bufferr by the required size

		buffer->ExpandL(0,aBufferSize);

		// Transfer the data from the server

		TPtr8 bufptr = buffer->Ptr(0);

		TIpcArgs args(&bufptr);

		User::LeaveIfError(SendReceive(ETransmitBuffer,args));

		CleanupStack::Pop(buffer);

		}

	return buffer;

	}

void RAgendaServ::ExternalizeFilterL(const TAgnFilter& aFilter, RWriteStream& aStream) const

	{

	aFilter.ExternalizeL(aStream);

	}

CAgnSimpleEntry* RAgendaServ::InternalizeSimpleEntryL(RReadStream& aStream) const

	{

	CCalEntry::TType entryType = static_cast<CCalEntry::TType>( aStream.ReadUint32L() );

	CAgnSimpleEntry* entry = iSimpleEntryAllocator->CreateSimpleEntryL(entryType);

	//to cleanup CAgnSortEntry pointer, if a leave happens during internalize.

	TCleanSimpleEntry simpleEntryCleanupItem(*entry, *iSimpleEntryAllocator);

	CleanupStack::PushL(TCleanupItem(TCleanSimpleEntry::DestroySimpleEntry,&simpleEntryCleanupItem));

	entry->InternalizeL(aStream, ETrue);

    CleanupStack::Pop(&simpleEntryCleanupItem);

	return ( entry );

	}

/**

@capability None

*/

void RAgendaServ::OpenAgendaL(const CCalSessionImpl& aSession, const TDesC& aFileName, CalCommon::TCalFileVersionSupport& aStatus, TInt64& aFileId, TCalCollectionId& aCallectionId)

	{

    CBufFlat* streamBuffer = CBufFlat::NewL(aFileName.Size()+ sizeof(TUint8));

    CleanupStack::PushL(streamBuffer);

    RBufWriteStream bufStream;

    bufStream.Open(*streamBuffer);

    CleanupClosePushL(bufStream);

    bufStream << aFileName;

    bufStream.WriteInt32L(aSession.SessionId());

    CleanupStack::PopAndDestroy(&bufStream);

    TPtr8 readPtr = streamBuffer->Ptr(0);

    TPckgBuf<CalCommon::TCalFileVersionSupport> statusPckg(aStatus);

    TPckgBuf<TInt64> fileId(aFileId);

    TPckgBuf<TCalCollectionId> shortFileId(aCallectionId);

    TIpcArgs args(&readPtr, &statusPckg, &fileId, &shortFileId);  

    TInt err = SendReceive(EOpenAgenda,args);

    CleanupStack::PopAndDestroy(streamBuffer);

    if(err != KErrAlreadyExists)

        {

        aStatus = statusPckg();

        User::LeaveIfError(err);

        aFileId = fileId();

        aCallectionId = shortFileId();

        }

	}

void RAgendaServ::WaitUntilLoadedL(TCalCollectionId aCallectionId)

	{

	TIpcArgs args(0, aCallectionId);//0 argument means not to report the progess

	TRequestStatus status = KRequestPending;

	SendReceive(EStartBuildIndex, args, status);

	User::WaitForRequest(status);

	User::LeaveIfError(status.Int());

	}

/** 

Closes the file that is open in the current agenda server session. 

@capability None

*/

void RAgendaServ::CloseAgenda(TInt aSessionId)

	{

	TIpcArgs args(aSessionId);

	SendReceive(ECloseAgenda, args);

	}

/** 

Fetches a complete entry from the server

@capability ReadUserData

*/

CAgnEntry* RAgendaServ::FetchEntryL(TAgnEntryId& aId, TInt64 aFileId) const

	{

	TPckg<TAgnEntryId> entryId(aId);

	TPckgBuf<TInt> size;

	TPtr8 ptr = iBuffer->Ptr(0);

	if (aId.IsNullId())

		{

		return NULL;

		}

	TPckgBuf<TInt64> fileId(aFileId);

	TIpcArgs args(&ptr, &entryId, &size, &fileId);

	User::LeaveIfError(SendReceive(EFetchEntry,args));

	return ReadEntryFromServerSessionL(size());	

	}

/** Fetches a complete entry from the server

@capability ReadUserData

*/

CAgnEntry* RAgendaServ::FetchEntryL(TCalLocalUid aId, TInt64 aFileId) const

	{

	TPckg<TCalLocalUid> entryId(aId);

	TPckgBuf<TInt> size;

	TPtr8 ptr = iBuffer->Ptr(0);

	TPckgBuf<TInt64> fileId(aFileId);

	TIpcArgs args(&ptr, &entryId, &size, &fileId);

	User::LeaveIfError(SendReceive(EFetchEntryByUID,args));

	return ReadEntryFromServerSessionL(size());

	}

/* Internalize agenda entry from buffer 

@capability ReadUserData

@param aBufferSize size of buffer 

@return agenda entry internalized from buffer

*/

CAgnEntry* RAgendaServ::ReadEntryFromServerSessionL(TInt aBufferSize) const

	{

	if (aBufferSize==0) // if size = 0, there entry has already been deleted

		{

		return NULL;

		}

	RBufReadStream readStream;

	// Create a transfer buffer, and set where to read the data from

	CBufFlat* buffer = CreateTransmitBufferL(aBufferSize);

	if (buffer)

		{

		readStream.Open(*buffer);

		}

	else

		{

		readStream.Open(*iBuffer);

		}

	CleanupStack::PushL(buffer);

	CAgnEntry* entry = CreateEntryFromBufferStreamL(readStream);

	readStream.Close();

	CleanupStack::PopAndDestroy(buffer);

	return entry;

	}

CAgnEntry* RAgendaServ::CreateEntryFromBufferStreamL(RReadStream& aReadStream) const

	{

	CCalEntry::TType entryType = (CCalEntry::TType)aReadStream.ReadUint32L();

	CAgnEntry* entry = CAgnEntry::NewL(entryType);

	CleanupStack::PushL(entry);

	entry->InternalizeFromBufferL(aReadStream);

	CleanupStack::Pop(entry);

	return entry;

	}

/** 

Get a lite entry from the server

(Lite-entries are just time information, with no text, etc)

@capability ReadUserData

*/

CAgnSimpleEntry* RAgendaServ::GetSimpleEntryL(const TAgnEntryId& aId, TCalCollectionId aCallectionId) const

	{

	TPckgBuf<TInt> size;

	TPtr8 ptr = iBuffer->Ptr(0);

	if (aId.IsNullId())

		{

		return NULL;

		}

	CBufFlat* streamBuffer = CBufFlat::NewL(sizeof(TAgnInstance));

	CleanupStack::PushL(streamBuffer);

	RBufWriteStream bufStream;

	bufStream.Open(*streamBuffer);

	CleanupClosePushL(bufStream);

	bufStream << aId;

	CleanupStack::PopAndDestroy(&bufStream);

	TPtr8 readPtr = streamBuffer->Ptr(0);

	TIpcArgs args(&ptr, &readPtr, &size, aCallectionId);

	User::LeaveIfError(SendReceive(EFetchSimpleEntry,args));

	CleanupStack::PopAndDestroy(streamBuffer);

	if (size() == 0)

		{

		User::Leave(KErrNotFound);

		}

	RBufReadStream readStream;

	CBufFlat* buffer = CreateTransmitBufferL(size());

	if (buffer)

		{

		readStream.Open(*buffer);

		}

	else

		{

		readStream.Open(*iBuffer);

		}

	CleanupStack::PushL(buffer);

	CAgnSimpleEntry* entry = NULL;

	if (readStream.ReadUint8L())

		{

		entry = InternalizeSimpleEntryL(readStream);

		entry->SetCollectionId(aCallectionId);

		}

	readStream.Close();

	CleanupStack::PopAndDestroy(buffer);

	// Don't leave here for a NULL entry could be a race with an entry delete

	return entry;

	}

/** 

Get a lite entry from the server

(Lite-entries are just time information, with no text, etc)

@capability ReadUserData

*/

CAgnSimpleEntry* RAgendaServ::GetSimpleEntryL(TCalCollectionId aCallectionId, TUint32 aId) const

	{

//	TPckg<TAgnEntryId> entryId(aId);

	TPckgBuf<TInt> size;

	TPtr8 ptr = iBuffer->Ptr(0);

	if (aId == 0)

		{

		return NULL;

		}

	CBufFlat* streamBuffer = CBufFlat::NewL(sizeof(TUint8)+sizeof(TUint32));

	CleanupStack::PushL(streamBuffer);

	RBufWriteStream bufStream;

	bufStream.Open(*streamBuffer);

	CleanupClosePushL(bufStream);

	bufStream << aId;

	CleanupStack::PopAndDestroy(&bufStream);

	TPtr8 readPtr = streamBuffer->Ptr(0);

	TIpcArgs args(&ptr, &readPtr, &size, aCallectionId);

	User::LeaveIfError(SendReceive(EFetchSimpleEntryByUID,args));

	CleanupStack::PopAndDestroy(streamBuffer);

	if (size() == 0)

		{

		User::Leave(KErrNotFound);

		}

	RBufReadStream readStream;

	CBufFlat* buffer = CreateTransmitBufferL(size());

	if (buffer)

		{

		readStream.Open(*buffer);

		}

	else

		{

		readStream.Open(*iBuffer);

		}

	CleanupStack::PushL(buffer);

	CAgnSimpleEntry* entry = NULL;

	if (readStream.ReadUint8L())

		{

		entry = InternalizeSimpleEntryL(readStream);

		entry->SetCollectionId(aCallectionId);

		}

	readStream.Close();

	CleanupStack::PopAndDestroy(buffer);

	// Don't leave here for a NULL entry could be a race with an entry delete

	return entry;