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

 	}