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

// surface manager API

// 

//

#ifndef __SHARED_H__

#define __SHARED_H__

#include <e32base.h>

#include <e32cmn.h>

#include <graphics/surface.h>

#include <graphics/surfacemanager.h>

#include <test/tgraphicsharness.h>

struct TLeaveInfo

	{

	RSurfaceManager iSurfaceManager;

	TSurfaceId iSurfaceId;

	};

static void CloseSurfaceWhenLeave(TAny* aInfo)

	{

	TInt err = ((TLeaveInfo*)aInfo)->iSurfaceManager.CloseSurface(((TLeaveInfo*)aInfo)->iSurfaceId);

	if (err != KErrNone)

		RDebug::Print(_L("Error closing surface = %d\n"),err);	

	};

/**

Enum for the slots for inter-process communication

*/

enum TIPCSlot

	{

	EMultiProcessFirstSlot = 0,

	EMultiProcessSecondSlot,

	EMultiProcessThirdSlot,

	EMultiProcessFourthSlot,

	};

/**

Enums for passing between the test process and the second process used in testing,

used to define which test should be run on the side of the second process.

*/

enum TMultiProcessTestCase

	{

	// Second process opcodes

	ETestOpenReceivedSurface,

	ETestInfoReceivedSurface,

	ETestOpenSurfaceInvalidParams,

	ECreateWaitKill,

	EOpenClose,

	EMapSurfaceInfoCantAccess,

	EOpenWaitMap,

	EReadFromBuffer,

	ECheckHandle,

	ESyncOperation,

	ETestChannelMultiProcess1,

	ETestChannelMultiProcess2,

	EGetSurfaceHint,

	ESetSurfaceHint,

	EAddSurfaceHint,

	ECheckOutofMemory,

	// Third process opcodes

	ECloseSurface = 0x00010000,

	EOpenWaitCloseOpen,

	EOpenSurface,

	ESurfaceInfo

	};

/**

Enums for panics between my testing process and my second process

*/

enum TCrossProcessPanics

	{

	EInvalidTestCase,

	};

/**

Enums for the test results

*/

enum TTestResult

	{

	EFirstTestPassed = 0x00000001,

	ESecondTestPassed = 0x00000002,

	EThirdTestPassed = 0x00000004,

	EFourthTestPassed = 0x00000008,

	EFifthTestPassed = 0x00000010,

	ESixthTestPassed = 0x00000020,

	ESeventhTestPassed = 0x00000040,

	EEighthTestPassed = 0x00000080,

	ENinthTestPassed = 0x00000100,

	ETenthTestPassed = 0x00000200,

	};

_LIT(KMultiProcessSemaphore, "Multi Process Semaphore");

_LIT(KMultiProcessSemaphore2, "Multi Process Semaphore 2");

_LIT(KMultiProcessSemaphore3, "Multi Process Semaphore 3");

_LIT(KMultiProcessSemaphore4, "Multi Process Semaphore 4");

_LIT(KSharedChunkName, "Surfaces test shared chunk");

const TInt KSharedChunkSize = ((4 * sizeof(TUint32)) + (2 * sizeof(TInt)));

/**

Wraps a shared chunk for communication between the processes

*/

class CChunkWrapper : public CBase

	{

public:

	~CChunkWrapper();

	static CChunkWrapper* CreateL(const TDesC& aName, TInt aSize, TInt aMaxSize);

	void CreateConstructL(const TDesC& aName, TInt aSize, TInt aMaxSize);

	static CChunkWrapper* OpenL(const TDesC& aName, TBool aIsReadOnly);

	void OpenConstructL(const TDesC& aName, TBool aIsReadOnly);

	void SetSecondProcessResults(TInt aResult);

	TInt GetSecondProcessResults();

	void SetThirdProcessResults(TInt aResult);

	TInt GetThirdProcessResults();

	void SetId(const TSurfaceId& aId);

	TSurfaceId GetId();

	void CloseD();

private:	

	CChunkWrapper();

private:

	RChunk iChunk;

	};

class CTestDriver : public CBase

	{

public:

	CTestDriver();

	virtual ~CTestDriver();

	void ConstructL();

protected:

	RSurfaceManager iSurfaceManager;

	CChunkWrapper* iChunkWrapper;

	TInt iTestResult;

	};

#endif