// 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:

//

#include <e32uid.h>

#include "sgdriver.h"

#include "sgresourceadapter.h"

/**

Function pointer type used to instantiate the Graphics Resource Adapter singleton.

*/

typedef TInt (*TSgDriverCreateFunction)(MSgDriverAdapter*&);

XSgDriverPls::XSgDriverPls()

	{

	iError = iMutex.CreateLocal();

	iOpenCount = 0;

	iDriver = NULL;

	}

#ifndef __WINS__

XSgDriverPls gPls;

#endif

/**

@publishedPartner

@prototype

@deprecated

Opens the Graphics Resource driver in the context of the calling process.

This function must be called by any process using the Graphics Resource API before

any other function in the API. When finished the process should call Close(). If

Open() has already been called from the same process then calling it again just

increments a process-local open count. Each successful call to Open() must be

balanced by a corresponding call to Close() later on.

Note that, in a multi-threaded process, it is not necessary for each thread to call

this function. A possible strategy is therefore for the main thread to call

SgDriver::Open() at the beginning and SgDriver::Close() at the end, while the rest

of the threads do not call either of these but simply use the Graphics Resource API.

@pre None.

@post The Graphics Resource driver is initialised for use in the context of the

      calling process and the process-local open count is incremented by one.

@return KErrNone if successful.

@return KErrNotSupported if no implementation of the Graphics Resource API is present.

@return KErrNoMemory if there is not enough system memory.

@see SgDriver::Close()

*/

EXPORT_C TInt SgDriver::Open()

	{

	if (gPls.iError != KErrNone)

		{

		return gPls.iError;

		}

	gPls.iMutex.Wait();

	if (gPls.iDriver)

		{

		++gPls.iOpenCount;

		gPls.iMutex.Signal();

		return KErrNone;

		}

#ifdef __WINS__

	const TUidType KSgResourceAdapterLibraryUidType(KDynamicLibraryUid, KSharedLibraryUid, KSgResourceAdapterLibraryUid);

	RLibrary lib;

	TInt err = lib.Load(KSgResourceAdapterLibraryName, KSgResourceAdapterLibraryUidType);

	if (err != KErrNone)

		{

		if (err == KErrNotFound)

			{

			err = KErrNotSupported;

			}

		gPls.iMutex.Signal();

		return err;

		}

	gPls.iLibrary = lib;

	err = gPls.iLibrary.Duplicate(RThread()); // Get a process-wide handle

	lib.Close();

	if (err != KErrNone)

		{

		gPls.iMutex.Signal();

		return err;

		}

	TSgDriverCreateFunction create = reinterpret_cast<TSgDriverCreateFunction>(gPls.iLibrary.Lookup(1));

	err = create(gPls.iDriver);

	if (err != KErrNone)

		{

		gPls.iLibrary.Close();

		gPls.iMutex.Signal();

		return err;

		}

#else

	TInt err = MSgDriverAdapter::New(gPls.iDriver);

	if (err != KErrNone)

		{

		gPls.iMutex.Signal();

		return err;

		}

#endif

	gPls.iOpenCount = 1;

	gPls.iMutex.Signal();

	return KErrNone;

	}

/**

@publishedPartner

@prototype

@deprecated

Closes the Graphics Resource driver in the context of the calling process.

This function must be called by a process when finished using the Graphics Resource

API. It decrements the process-local open count and, when the count becomes zero,

it carries out termination tasks needed to release the internal resources allocated

for the calling process.

Each call to Close() must correspond to a prior successful call to Open(). Note that,

in a multi-threaded process, it is not generally safe to call Close() regardless of

whether the corresponding call to Open() succeeded or failed, since too many calls to

Close() from a thread could have an unexpected effect on all the other threads in the

process. The following example demonstrates how to open and close the Graphics

Resource driver safely from a worker thread.

@code

	// Open Graphics Resource driver

	TBool isDriverOpen = EFalse;

	if (SgDriver::Open() == KErrNone)

		{

		isDriverOpen = ETrue;

		}

	// Do some work in this thread

	DoThreadWork();

	// Close Graphics Resource driver

	if (isDriverOpen)

		{

		SgDriver::Close();

		}

@endcode

@pre If the process-local open count is one then there are no open handles to graphics

     resources in the calling process.

@post The process-local open count is decremented by one if greater than zero. If the

      count becomes zero, then the calling process is not able to use the Graphics

      Resource API any longer.

@panic SGRES 1 in debug builds if there still are any open handles to graphics resources

       in the calling process when the process termination tasks are carried out.

@see SgDriver::Open()

*/

EXPORT_C void SgDriver::Close()

	{

	if (gPls.iError != KErrNone)

		{

		return;

		}

	gPls.iMutex.Wait();

	if (gPls.iOpenCount > 0 && --gPls.iOpenCount == 0)

		{

		gPls.iDriver->Delete();

		gPls.iDriver = NULL;

#ifdef __WINS__

		gPls.iLibrary.Close();

#endif

		}

	gPls.iMutex.Signal();

	}

/**

@internalComponent

@test

*/

EXPORT_C TInt SgDriver::ResourceCount()

	{

#ifdef _DEBUG

	gPls.iMutex.Wait();

	__ASSERT_DEBUG(gPls.iDriver, Panic(ESgPanicNoDriver));

#endif

	TInt count = gPls.iDriver->ResourceCount();

#ifdef _DEBUG

	gPls.iMutex.Signal();

#endif

	return count;

	}

/**

@internalComponent

@test

*/

EXPORT_C void SgDriver::AllocMarkStart()

	{

#ifdef _DEBUG

	gPls.iMutex.Wait();

	__ASSERT_DEBUG(gPls.iDriver, Panic(ESgPanicNoDriver));

#endif

	gPls.iDriver->AllocMarkStart();

#ifdef _DEBUG

	gPls.iMutex.Signal();

#endif

	}

/**

@internalComponent

@test

*/

EXPORT_C void SgDriver::AllocMarkEnd(TInt aCount)

	{

#ifdef _DEBUG

	gPls.iMutex.Wait();

	__ASSERT_DEBUG(gPls.iDriver, Panic(ESgPanicNoDriver));

#endif

	gPls.iDriver->AllocMarkEnd(aCount);

#ifdef _DEBUG

	gPls.iMutex.Signal();

#endif

	}

/**

@internalComponent

@test

*/

EXPORT_C void SgDriver::SetAllocFail(RAllocator::TAllocFail aType, TInt aRate)

	{

#ifdef _DEBUG

	gPls.iMutex.Wait();

	__ASSERT_DEBUG(gPls.iDriver, Panic(ESgPanicNoDriver));

#endif

	gPls.iDriver->SetAllocFail(aType, aRate);

#ifdef _DEBUG

	gPls.iMutex.Signal();

#endif

	}