// Copyright (c) 1995-2010 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 <fbs.h>

#include "fbsdefs.h"

#include "UTILS.H"

#include "FBSVER.H"

#include "FbsRalc.h"

#include "fbshelper.h"

#include "FbsMessage.H"

#include <graphics/fbsoogmmessage.h>

#include "OstTraceDefinitions.h"

#include "fbstrace.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "SESSIONTraces.h"

#endif

GLDEF_C void Panic(TFbsPanic aPanic)

	{

	_LIT(KFBSERVClientPanicCategory,"FBSCLI");

	User::Panic(KFBSERVClientPanicCategory,aPanic);

	}

EXPORT_C TInt FbsStartup()

	{

	RChunk sharedchunk;

	TInt ret = sharedchunk.OpenGlobal(KFBSERVSharedChunkName,EFalse);

	if (ret == KErrNone)

		{

		sharedchunk.Close();

		return KErrNone;

		}

	RProcess fbs;

	_LIT(KFBSERVServerExe,"z:\\sys\\bin\\fbserv.exe");

	ret = fbs.Create(KFBSERVServerExe,KNullDesC);

	if (ret!=KErrNone)

		return ret;

	TRequestStatus stat;

	fbs.Rendezvous(stat);

	if (stat!=KRequestPending)

		fbs.Kill(0);		// abort startup

	else

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

	User::WaitForRequest(stat);		// wait for start or death

	// we can't use the 'exit reason' if the server panicked as this

	// is the panic 'reason' and may be '0' which cannot be distinguished

	// from KErrNone

	ret=(fbs.ExitType()==EExitPanic) ? KErrGeneral : stat.Int();

	fbs.Close();

	return ret;

	}

//

// Fontbitmap server client side session

//

/** 

@publishedAll 

@released

*/

EXPORT_C RFbsSession::RFbsSession():

	RSessionBase(),

	iConnections(0),

	iCallBack(),

	iSharedChunk(),

	iHelper(NULL),

	iRomFileAddrCache(NULL),

	iDecompressionBuffer(NULL),

	iScanLineBuffer(NULL),

	iSpare(NULL)

	{}

/** Creates a session with the Font and Bitmap server.

@param aFileServer A fuly constructed file server session

@return KErrNone, if successful; KErrNoMemory if there is not enough memory 

to create the session; otherwise another of the system-wide error codes. 

@publishedAll 

@released

*/

EXPORT_C TInt RFbsSession::Connect(RFs& aFileServer)

	{

    TInt ret = KErrNone;

	RFbsSession* thisptr = (RFbsSession*)Dll::Tls();

	FBS_OST(OstTrace1(GRAPHICS_CONTROL_FUNCTIONS, RFBSSESSION_CONNECT_ENTRY, "> this=0x%08x;", (TUint)thisptr);)

	if(thisptr)

		{

		thisptr->iConnections++;

		FBS_OST(OstTraceExt2(GRAPHICS_CONTROL_SEMANTICS, RFBSSESSION_CONNECT_INFO, "# Connected to existing session; this=0x%08x; iConnections=%d;", (TInt)thisptr, thisptr->iConnections);)

		}

	else

	    {

        ret = RFbsSession::DoAlloc(thisptr);

        if(ret!=KErrNone)

            {

            FBS_OST(OstTrace1(TRACE_ERROR, RFBSSESSION_CONNECT_ERROR, "! DoAlloc returned %d", ret);)

            }

        else

            {

            ret = thisptr->DoConnect(aFileServer);

            if(ret!=KErrNone)

                {

                FBS_OST(OstTraceExt2(TRACE_ERROR, RFBSSESSION_CONNECT_ERROR2, "! this=0x%08x; DoConnect returned %d", (TInt)thisptr, ret);)

                }

            }

	    }

	FBS_OST(OstTraceExt2(GRAPHICS_CONTROL_FUNCTIONS, RFBSSESSION_CONNECT_EXIT, "< this=0x%08x; ret=%d", (TUint)thisptr, ret);)

	return ret; 

	}

/** Creates a session with the Font and Bitmap server.

@return KErrNone, if successful; KErrNoMemory if there is not enough memory 

to create the session; otherwise another of the system-wide error codes. 

@publishedAll 

@released

*/

EXPORT_C TInt RFbsSession::Connect()

	{

    TInt ret = KErrNone;

	RFbsSession* thisptr = (RFbsSession*)Dll::Tls();

	FBS_OST(OstTrace1(GRAPHICS_CONTROL_FUNCTIONS, RFBSSESSION_CONNECT2_ENTRY, "> this=0x%08x;", (TUint)thisptr);)

	if(thisptr)

		{

		thisptr->iConnections++;

	    FBS_OST(OstTraceExt2(GRAPHICS_CONTROL_SEMANTICS, RFBSSESSION_CONNECT2_INFO, "# Connected to existing session; this=0x%08x; iConnections=%d;", (TInt)thisptr, thisptr->iConnections);)

		}

	else

	    {

        TInt ret = RFbsSession::DoAlloc(thisptr);

        if (ret!=KErrNone)

            {

            FBS_OST(OstTrace1(TRACE_ERROR, RFBSSESSION_CONNECT2_ERROR, "! DoAlloc returned %d", ret);)

            goto end;

            }

        ret = thisptr->iFileServer.Connect();

        if(ret!=KErrNone)

            {

            thisptr->Disconnect();

            FBS_OST(OstTraceExt2(TRACE_ERROR, RFBSSESSION_CONNECT2_ERROR2, "! this=0x%08x; RFs::Connect() returned %d", (TInt)thisptr, ret);)

            goto end;

            }

        ret = thisptr->DoConnect(thisptr->iFileServer);

        if(ret!=KErrNone)

            {

            FBS_OST(OstTraceExt2(TRACE_ERROR, RFBSSESSION_CONNECT2_ERROR3, "! this=0x%08x; DoConnect returned %d", (TInt)thisptr, ret);)

            }

	    }

end:

	FBS_OST(OstTraceExt2(GRAPHICS_CONTROL_FUNCTIONS, RFBSSESSION_CONNECT2_EXIT, "< this=0x%08x; ret=%d", (TUint)thisptr, ret);)

	return ret;

	}

/** Closes the session with the Font and Bitmap server. 

@publishedAll 

@released

*/

EXPORT_C void RFbsSession::Disconnect()

	{

	RFbsSession* thisptr=(RFbsSession*)Dll::Tls();

    FBS_OST(OstTrace1(GRAPHICS_CONTROL_FUNCTIONS, RFBSSESSION_DISCONNECT_ENTRY, "> this=0x%08x;", (TUint)thisptr);)

	if(thisptr)

	    {

        TInt tempServerSessionHandle = thisptr->ServerSessionHandle();

        if(thisptr->iConnections>0)

            {

            thisptr->iCallBack.iPtr=NULL;

            thisptr->iCallBack.CallBack();

            // Destructor of CFbsSessionHelper may call SendCommand to cancel an

            // outstanding request, therefore destruction must be done before

            // iConnections is 0 to avoid an assertion going off.

            if(thisptr->iConnections==1)

                {

                delete thisptr->iHelper;

                }

            thisptr->iConnections--;

            }

        if(thisptr->iConnections==0)

            {

            thisptr->iSharedChunk.Close();

            thisptr->iLargeBitmapChunk.Close();

            // Call close on the iFileServer regardless of whether this session owns it: 

            // if we don't own it, close will do nothing if there are still open files, 

            // so always calling close introduces extra safety

            thisptr->iFileServer.Close();

            delete thisptr->iRomFileAddrCache; 

            delete thisptr->iScanLineBuffer;

            delete thisptr->iDecompressionBuffer;

            thisptr->Close();

            delete thisptr;

            Dll::FreeTls();	

            }

        FBS_OST(OstTraceExt3(GRAPHICS_CONTROL_SEMANTICS, RFBSSESSION_DISCONNECT_INFO, "# Disconnected from session; this=0x%08x; iConnections=%d; iSSH=0x%08x", (TInt)thisptr, thisptr->iConnections, tempServerSessionHandle);)

	    }

	FBS_OST(OstTrace1(GRAPHICS_CONTROL_FUNCTIONS, RFBSSESSION_DISCONNECT_EXIT2, "< this=0x%08x;", (TUint)thisptr);)

	}

/**  Gets the current Font and Bitmap server session.

@return  A pointer to the current session or NULL if Connect() has not been 

called yet. 

@publishedAll 

@released

*/

EXPORT_C RFbsSession* RFbsSession::GetSession()

    {

	return((RFbsSession*)Dll::Tls());

	}

/** Triggers the most recently registered callback. This is mainly called by 

bitmaps when their twips size changes and when any FBSERV objects are closed 

to notify clients of a change that may affect their operation. 

@publishedAll 

@released

*/

EXPORT_C void RFbsSession::CallBack()

    {

	iCallBack.CallBack();

	iCallBack.iPtr=NULL;

	}

void RFbsSession::SetCallBackPtr(TInt* aBitmapHandle)const

	{

	iCallBack.iPtr=aBitmapHandle;

	}

/** Sets the callback.

@param aCallBack callback object to be called by CallBack(). Only one may be 

in use at a time and subsequent calls will displace previous calls. 

@publishedAll 

@released

*/	

EXPORT_C void RFbsSession::SetCallBack(TCallBack aCallBack)

    {

	iCallBack=aCallBack;

	}

/** Resets the callback. 

@publishedAll 

@released

*/	

EXPORT_C void RFbsSession::ResetCallBack()

	{

	TCallBack cb(NULL);

	iCallBack=cb;

	}

/**  Returns the number of Font and Bitmap Server objects currently in 

use by this session.

@return The number of resources in use: bitmaps, fonts, typeface stores. 

@publishedAll 

@released

*/	

EXPORT_C TInt RFbsSession::ResourceCount()

    {

	return(SendCommand(EFbsMessResourceCount));

	}

/** Utility function for passing commands to the server.

@param aMessage Integer code for the message to pass - see TFbsMessage.

@param aInt0 Parameter 0 for the message.

@param aInt1 Parameter 1 for the message.

@param aInt2 Parameter 2 for the message.

@param aInt3 Parameter 3 for the message.

@return Return code from RSessionBase::SendReceive(). 

@internalComponent

*/

EXPORT_C TInt RFbsSession::SendCommand(TInt aMessage,TInt aInt0,TInt aInt1,TInt aInt2,TInt aInt3) const

   {

	__ASSERT_ALWAYS(iConnections>0,Panic(EFbsPanicBadConnection));

	switch(aMessage)

		{

	case EFbsMessShutdown:

	case EFbsMessClose:

		SetCallBackPtr(aMessage==EFbsMessClose ? &aInt1 : 0);

		iCallBack.CallBack();

	default:

		break;

		}

	TInt ret = SendReceive(aMessage, TIpcArgs(aInt0,aInt1,aInt2,aInt3));

	return(ret);

	}

TInt RFbsSession::SendCommand(TInt aMessage, const TIpcArgs& aArgs) const

	{

	__ASSERT_ALWAYS(iConnections>0,Panic(EFbsPanicBadConnection));

	return SendReceive(aMessage,aArgs);

	}

void RFbsSession::SendCommand(TInt aMessage, const TIpcArgs& aArgs, TRequestStatus &aStatus) const

	{

	__ASSERT_ALWAYS(iConnections>0,Panic(EFbsPanicBadConnection));

	SendReceive(aMessage,aArgs,aStatus);

	}

/** Gets the current Font and Bitmap server version.

@return The current version of the server. 

@publishedAll 

@released

*/

EXPORT_C TVersion RFbsSession::Version()

	{

	TVersion v(KFbsMajorVersionNumber,KFbsMinorVersionNumber,KFbsBuildVersionNumber);

	return(v);

	}

/** Gets the address of first location in the global shared heap containing 

fonts and bitmaps.

@return Pointer to the base of the shared heap. 

@publishedAll 

@released

*/	

EXPORT_C TUint8* RFbsSession::HeapBase() const

	{

	return(iSharedChunk.Base());

	}

TBool RFbsSession::LookupBitmapInROM(const TDesC& aFilename, TAny*& aAddr)

	{

	aAddr = iRomFileAddrCache->Lookup(aFilename);

	if (aAddr)

		return ETrue;

	return EFalse;

   	}

TInt RFbsSession::DoAlloc(RFbsSession*& aNewSession)

	{

	aNewSession = (RFbsSession*)User::Alloc(sizeof(RFbsSession));

	if(!aNewSession) 

		return KErrNoMemory;

	new(aNewSession) RFbsSession;

	aNewSession->iConnections = 1;

	TInt ret = Dll::SetTls(aNewSession);

	if(ret!=KErrNone)

		{

		delete aNewSession;

		aNewSession = NULL;

		}

	return ret;

	}

/**  

Do actual connect as common to both Connect() and Connect(RFs& aFileServer). Store fully constructed

file server session to iSpare member variable

@see Connect()

@return KErrNone, if successful; KErrNoMemory if there is not enough memory 

to create the session; otherwise another of the system-wide error codes. 

@internalComponent

*/

TInt RFbsSession::DoConnect(RFs& aFileServer)

	{

	//Allow this session to be accessed by other process to lead bitmap in server

	TInt ret = aFileServer.ShareProtected();

	if (ret!=KErrNone)

		{

		Disconnect();

		return ret;

		}

	iRomFileAddrCache = CFbsRalCache::New(4, aFileServer);

	if (!iRomFileAddrCache)

		{

		Disconnect();

		return KErrNoMemory;

		}

	ret = CreateSession(KFBSERVGlobalThreadName,Version(),-1);

	if(ret!=KErrNone)

		{

		Disconnect();

		return ret;

		}

	const TInt serverAssignedHandle = SendReceive(EFbsMessInit);

	if(serverAssignedHandle <= 0)

		{

		Disconnect();

		return serverAssignedHandle;

		}

	ret = iSharedChunk.OpenGlobal(KFBSERVSharedChunkName,EFalse);

	if(ret!=KErrNone) 

		Panic(EFbsPanicChunkError);

	iHelper = new CFbsSessionHelper(*this);

	if (!iHelper)

		{

		Disconnect();

		return KErrNoMemory;

		}

	iHelper->iServerSessionHandle = serverAssignedHandle;

	ret = iLargeBitmapChunk.OpenGlobal(KFBSERVLargeChunkName,EFalse);

	if(ret!=KErrNone) 

		Panic(EFbsPanicChunkError);

	iSpare = (TUint32*)&aFileServer;

    FBS_OST(OstTraceExt2(GRAPHICS_CONTROL_SEMANTICS, RFBSSESSION_DOCONNECT_INFO, "# New FBS Session created; this=0x%08x; iSSH=0x%08x;", (TInt)this, serverAssignedHandle);)

	return KErrNone;

	}

/**  

Allocates the buffer for decoding compressed rom bitmaps.

Internal use only.

@param 	aSize Minimum size of the buffer required.  

		If the buffer is too small an attempt to resize it will be made.

@return KErrNone if successful, 

		KErrNoMemory if the buffer was too small and could 

		not be expanded.

@publishedAll 

@released

*/

TInt RFbsSession::AllocScanLineBuffer(TInt aSize)

    {

	if (iScanLineBuffer && iScanLineBuffer->Des().MaxSize() >= aSize)

		{

		return KErrNone;

		}

	HBufC8* newBuffer = HBufC8::New(aSize);

	if (newBuffer)

		{

		delete iScanLineBuffer;

		iScanLineBuffer = newBuffer;

		return KErrNone;

		}

	return KErrNoMemory;

	}

/**  

Gets a reference to the buffer currently in use for decoding

compressed rom bitmaps. 

Internal use only.

@return  The buffer area currently in use,

@publishedAll 

@released

*/

HBufC8* RFbsSession::GetScanLineBuffer()

    {

	return iScanLineBuffer;

	}

/**  

Gets a pointer to the buffer currently in use for decoding

compressed mask bitmaps. 

Internal use only.

@param 	aSize Minimum size of the buffer required.  

		If the buffer is too small an attempt to resize it will be made.

@return  The buffer area currently in use or NULL if there is no memory.

@internalComponent 

*/

HBufC8* RFbsSession::GetDecompressionBuffer(TInt aSize)

	{

	if (iDecompressionBuffer)

		{

		if (iDecompressionBuffer->Des().MaxSize() < aSize)

			{

			HBufC8* tempBuffer = iDecompressionBuffer->ReAlloc(aSize);

			if (!tempBuffer)

				{

				return NULL;

				}

			iDecompressionBuffer = tempBuffer;

			}

		}

	else

		{

		iDecompressionBuffer = HBufC8::New(aSize);

		}

	return iDecompressionBuffer;

	}

/**  

Gets a pointer to an extra buffer for general use. 

Internal use only.

@param 	aSize Minimum size of the buffer required.  

		If the buffer is too small an attempt to resize it will be made.

@return  The buffer area currently in use or NULL if there is no memory.

@internalComponent 

*/

HBufC8* RFbsSession::GetExtraBuffer(TInt aSize)

	{

	if (iHelper->iExtraBuffer)

		{

		if (iHelper->iExtraBuffer->Des().MaxSize() < aSize)

			{

			HBufC8* tempBuffer = iHelper->iExtraBuffer->ReAlloc(aSize);

			if (!tempBuffer)

				{

				return NULL;

				}

			iHelper->iExtraBuffer = tempBuffer;

			}

		}

	else

		{

		iHelper->iExtraBuffer = HBufC8::New(aSize);

		}

	return iHelper->iExtraBuffer;

	}

/**

Returns a handle assigned to this session by the server upon connection.

This method should be used instead of SessionHandle() when passing a session 

handle to FbServ APIs that require Session handles. 

@return A handle representing this session on the server. 

@pre The session has successfully connected to the server.

 */

TInt RFbsSession::ServerSessionHandle() const

	{

	__ASSERT_ALWAYS(iConnections>0,Panic(EFbsPanicBadConnection));

	return iHelper->iServerSessionHandle;

	}

EXPORT_C TInt RFbsSession::GetGlyphCacheMetrics( TGlyphCacheMetrics& aGlyphCacheMetrics )

    {

    TPckgBuf<TGlyphCacheMetrics> metrics;

    TIpcArgs args( &metrics );

    TInt ret = SendReceive( EFbsMessGetGlyphCacheMetrics, args );

    aGlyphCacheMetrics = metrics();

    return ret;

    }

/**

 Perform the IPC to convey the desired OoGM action to the glyph atlas.

 @return KErrNone if IPC was successful. One of the system-wide error

         codes, as described for RSessionBase::SendReceive(), if not.

 @note The server-side platform security policy applied to this method is such that it is only useable by the GOoM framework.

 @param aOogmMessage. A reference to the class encapsulating the OoGM action required of the glyph atlas.

*/

EXPORT_C TInt RFbsSession::ConveyOogmMessage( TFbsOogmMessage& aOogmMessage )

    {

    TPckgBuf<TFbsOogmMessage> oogmMessage;

    oogmMessage() = aOogmMessage;

    TIpcArgs args( &oogmMessage );

    return SendReceive( EFbsMessOogmNotification, args );

    }

/**

Returns the current sizes of the FBServ default heap, the heap for large bitmaps, 

and the heap for small bitmaps.

Not supported in release builds.

@internalComponent

@test

@param aDefaultHeapSize A reference to an integer supplied by the caller. On return from this function, contains the size of the FBServ default heap.

@param aSmallBmpHeapSize A reference to an integer supplied by the caller. On return from this function, contains the size of the FBServ heap for small bitmaps

@param aBigBmpHeapSize A reference to an integer supplied by the caller. On return from this function, contains the size of the FBServ heap for large bitmaps

@return KErrNone or one of the system wide error codes in debug mode, or KErrNotSupported in release mode.

*/

#ifdef _DEBUG

EXPORT_C TInt RFbsSession::GetHeapSizes(TInt& aDefaultHeapSize, TInt& aSmallBmpHeapSize, TInt& aBigBmpHeapSize)

 	{

 	TPckgBuf<THeapSizes> data;

 	TIpcArgs args(&data);

 	TInt ret = SendReceive(EFbsMessGetHeapSizes, args);

 	if(ret == KErrNone)

 		{

 		aDefaultHeapSize = data().iDefault;

 		aSmallBmpHeapSize = data().iSmall;

 		aBigBmpHeapSize = data().iBig;

 		}

 	return ret;

 	}

#else

EXPORT_C TInt RFbsSession::GetHeapSizes(TInt&, TInt&, TInt&)

	{

	return KErrNotSupported;

	}

#endif