// Copyright (c) 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 <e32std.h>

#include <hal.h>

#include <u32hal.h>

#include <limits.h>

#include <e32const.h>

#include <graphics/surfaceupdateclient.h>

#include <graphics/suerror.h>

#include <graphics/wstestscreencapture.h>

#include <graphics/testscreencapture.h>

#include "surfaceupdatetest.h"

#include "tsurfaceupdateinteg.h"

#include "twindows.h"

#include "tredrawhandler.h"

#include "tsurfacehelper.h"

const TSize windowSize(160, 100);

const TSize windowHalfSize(windowSize.iWidth / 2, 100);

const TPoint windowTopLeft(10,10);

const TPoint windowTopMiddle(windowTopLeft.iX + windowSize.iWidth / 2, windowTopLeft.iY);

CTSurfaceUpdateInteg::CTSurfaceUpdateInteg(CTestStep* aStep) :

	CTGraphicsBase(aStep)

	{

	}

CTSurfaceUpdateInteg::~CTSurfaceUpdateInteg()

	{

	iWindows.ResetAndDestroy();

	iGroups.ResetAndDestroy();

	iWsDevs.ResetAndDestroy();

	iGcs.ResetAndDestroy();

	delete iRedrawHandler;

	iSurfaceUpdate.Close();

	delete iSurfaceHelper;

	iBitmaps.ResetAndDestroy();

	delete iGraphicsContext;

	delete iBitmapDevice;

	delete iRefBitmap;

	iWs.Close();

	}

/**

 * Create a screen device, drawing context and a window for each screen.

 * Create surfaces, open connection to the SUS.

 */

void CTSurfaceUpdateInteg::ConstructL()

	{

	INFO_PRINTF1(_L("Test case construction"));

	User::LeaveIfError(iWs.Connect());

	iNumOfScreens = iWs.NumberOfScreens();

	iSurfaceHelper = CSurfaceHelper::NewL();

	const TInt stride = windowSize.iWidth * 4;

	const TInt stride1 = windowHalfSize.iWidth * 4;

	iSurface = iSurfaceHelper->CreateSurfaceL(windowSize, EUidPixelFormatXRGB_8888, stride,1);

	iSurfaceDoubleBuffered = iSurfaceHelper->CreateSurfaceL(windowSize, EUidPixelFormatXRGB_8888, stride,2);

	iSurfaceAbove = iSurfaceHelper->CreateSurfaceL(windowHalfSize, EUidPixelFormatXRGB_8888, stride1, 1);

	iSurfaceAbove1 = iSurfaceHelper->CreateSurfaceL(windowSize, EUidPixelFormatXRGB_8888, stride, 1);

	INFO_PRINTF1(_L("The surfaces have been created"));

	iRefBitmap = new (ELeave)CFbsBitmap();

	User::LeaveIfError(iRefBitmap->Create(windowSize,EColor16MU));

	iBitmapDevice = CFbsBitmapDevice::NewL(iRefBitmap);

	User::LeaveIfError(iBitmapDevice->CreateContext(iGraphicsContext));

	//fill the whole surfaces with different color

	iSurfaceHelper->FillRectangleL(iSurfaceAbove, TPoint(), windowHalfSize, KRgbYellow);

	iSurfaceHelper->FillRectangleL(iSurfaceAbove1, TPoint(), windowSize, KRgbYellow);

	iSurfaceHelper->FillRectangleL(iSurface, TPoint(), windowSize, KRgbGreen);

	iSurfaceHelper->FillRectangleL(iSurfaceDoubleBuffered, TPoint(), windowSize, KRgbCyan);

	FillRefBitmap(KRgbGreen);

	INFO_PRINTF1(_L("The surfaces and a reference bitmap have been filled with color"));

	User::LeaveIfError(iSurfaceUpdate.Connect());

	iRedrawHandler = new (ELeave) CTRedrawHandler(iWs); //will deal with all redrawing command

	iRedrawHandler->Start();

	//create windows and assign surfaces to them

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

		{

		CWsScreenDevice* wsDev = new (ELeave) CWsScreenDevice(iWs);

		iWsDevs.AppendL(wsDev);

		User::LeaveIfError(wsDev->Construct(ii));

		CWindowGc* gc = NULL;

		User::LeaveIfError(wsDev->CreateContext(gc));

		iGcs.AppendL(gc);

		CTWindowGroup* defaultGroup = CreateGroupL(wsDev);

		CTWindow* windowSingle = CTWindow::NewL(iWs, *defaultGroup, *gc);

		RegisterWindowL(windowSingle);

		windowSingle->Window()->SetExtent(windowTopLeft, windowSize);

		windowSingle->Window()->SetBackgroundSurface(iSurface);

		windowSingle->Window()->Activate();

		CTWindow* windowDouble = CTWindow::NewL(iWs, *defaultGroup, *gc);

		RegisterWindowL(windowDouble);

		windowDouble->Window()->SetExtent(windowTopLeft, windowSize);

		windowDouble->Window()->SetBackgroundSurface(iSurfaceDoubleBuffered);

		windowDouble->Window()->SetVisible(EFalse);

		windowDouble->Window()->Activate();

		CTWindow* windowAbove = CTWindow::NewL(iWs, *iGroups[ii], *iGcs[ii]);

		RegisterWindowL(windowAbove);

		windowAbove->Window()->SetExtent(windowTopLeft, windowHalfSize);

		windowAbove->Window()->SetBackgroundSurface(iSurfaceAbove);

		windowAbove->Window()->SetVisible(EFalse);

		windowAbove->Window()->Activate();

		if(ii == 0)

			{

			iWindowAbove11 = CTWindow::NewL(iWs, *iGroups[ii], *iGcs[ii]);

			RegisterWindowL(iWindowAbove11);

			iWindowAbove11->Window()->SetExtent(windowTopLeft, windowSize);

			iWindowAbove11->Window()->SetBackgroundSurface(iSurfaceAbove1);

			iWindowAbove11->Window()->SetVisible(EFalse);

			iWindowAbove11->Window()->Activate();

			iWindowAbove1 = windowAbove;

			iWindowSingleBuffured1 = windowSingle;

			iWindowDoubleBuffured1 = windowDouble;

			}

		else

			{

			iWindowAbove2 = windowAbove;

			iWindowSingleBuffured2 = windowSingle;

			iWindowDoubleBuffured2 = windowDouble;

			}

	    TPixelsTwipsAndRotation sizeAndRotation;

	    iWsDevs[ii]->GetDefaultScreenSizeAndRotation(sizeAndRotation);

	    CFbsBitmap* bitmap = new (ELeave)CFbsBitmap();

	    iBitmaps.AppendL(bitmap);

	    User::LeaveIfError(bitmap->Create(sizeAndRotation.iPixelSize, EColor16MU));

        INFO_PRINTF4(_L("Bitmap with size: %d, %d was created to match the size of the screen %d"), sizeAndRotation.iPixelSize.iWidth, sizeAndRotation.iPixelSize.iHeight, ii);

		}

	INFO_PRINTF1(_L("The windows have been created"));

	iWs.Finish();

	}

/**

 * Create the window group for the given screen device and put it into the list.

 */

CTWindowGroup* CTSurfaceUpdateInteg::CreateGroupL(CWsScreenDevice* aScreenDevice)

	{

	CTWindowGroup* group = CTWindowGroup::NewL(iWs, aScreenDevice);

	CleanupStack::PushL(group);

	iGroups.AppendL(group);

	CleanupStack::Pop();

	return group;

	}

/**

 * Append a window into the list for retrawing it and destroying in the future.

 */

void CTSurfaceUpdateInteg::RegisterWindowL(CTWindowTreeNode* aWindow)

	{

	CleanupStack::PushL(aWindow);

	iWindows.AppendL(aWindow);

	CleanupStack::Pop(aWindow);

	}

/**

 * Go through all screens and compare the whole surface area with the reference bitmap.

 * 

 * @return ETrue, if the surface is exactly the same as the reference bitmap or EFalse otherwise. 

 */

TBool CTSurfaceUpdateInteg::CompareAllScreens()

	{

	TBool res = ETrue;

	TRect rc(windowTopLeft, windowSize);

	for(TInt ii = 0; (ii < iNumOfScreens) && res; ii++)

		{

		res = Compare(ii, rc, iRefBitmap);

		}

	return res;

	}

/**

 * Compare part of the screen with the reference bitmap.

 * 

 * @param aScreenNumber Screen number.

 * @param aRectSrc The area of the screen to be compared.

 * @param aRefBitmap Bitmap for comparison.

 * @return ETrue, if given part of the screen is exactly the same as the reference bitmap or EFalse otherwise. 

 */

TBool CTSurfaceUpdateInteg::Compare(TInt aScreenNumber, const TRect& aRectSrc, CFbsBitmap* aRefBitmap)

	{

	MTestScreenCapture* csc = static_cast<MTestScreenCapture*> (iWsDevs[aScreenNumber]->GetInterface(MTestScreenCapture::KUidTestScreenCaptureIf));

	if(!csc) //shouldn't happen, as we have checked this before

		{

		return EFalse;

		}

	TBool res = ETrue;

	TInt ret = csc->ComposeScreen(*(iBitmaps[aScreenNumber]));

	if(ret != KErrNone)

		{

		INFO_PRINTF2(_L("Composition screen failure, err = %d"), ret);

		res = EFalse;

		}

	//Go through all pixels in screen bitmap for specified area and check that they are 

	//identical to corresponding pixels in reference bitmap

	for(TInt ii = 0; (ii < aRectSrc.Height()) && res; ii++)

		{

		for(TInt jj = 0; (jj < aRectSrc.Width()) && res; jj++)

			{

			TRgb refCol;

			aRefBitmap->GetPixel(refCol, TPoint(jj, ii));

			TRgb col;

			(iBitmaps[aScreenNumber])->GetPixel(col, TPoint(jj, ii) + aRectSrc.iTl);

			if(refCol != col)

				{

				res = EFalse;

				}

			}

		}

	//useful for debugging

#ifdef TEST_COMPARE_PARTLY_UPDATED_SCREEN 	

	if(!res)

		{

		iBitmap->Save(_L("c:\\bitmap.mbm"));

		aRefBitmap->Save(_L("c:\\ref.mbm"));

		}

#endif

	return res;

	}

/**

 * Fill reference bitmap with color specified.

 * 

 */

void CTSurfaceUpdateInteg::FillRefBitmap(TRgb aColor)

	{

	TRect rect = TRect(iRefBitmap->SizeInPixels());

	iGraphicsContext->SetBrushColor(aColor);

	iGraphicsContext->SetPenColor(aColor);

	iGraphicsContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

	iGraphicsContext->DrawRect(rect);

	}

/**

  @SYMTestCaseID  GRAPHIC-SURFACEUPDATE-0026

  @SYMCR CR1650

  @SYMREQ REQ11596

  @SYMTestCaseDesc 

  	SubmitUpdate() to cope with Global Updates with surface on various 

  	screens when the dirty region to update may not be visible on all screens

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions The test consists of a single surface, visible on 

  screens A (master), B.

	1.	Submit a global update for the surface, passing a null dirty region.

	2.	Submit a global update for the surface, passing a dirty region 

	that is only visible on screens A  (that particular region for the 

	surface is not visible on B).

	3.	Submit a global update for the surface, passing a dirty region 

	that is only visible on screens B (that particular region for the 

	surface is not visible on A).

	4.	Submit a global update for the surface, passing a dirty 

	region that is not visible on any of the screens.

  @SYMTestExpectedResults 

  	1.	TRequestStatus signals KErrNone in all cases. Timestamps must 

  	be valid. The surface gets updated on all screens.

	2.	TRequestStatus signals KErrNone in all cases. Timestamps must 

	be valid. The surface gets updated only on screens A. Screen B is unchanged.

	3.	TRequestStatus signals KErrNone in all cases. Timestamps must 

	be valid. The surface gets updated only on screens B. 

	Screen A is unchanged.

	4.	SubmitUpdate() returns KErrNone.

*/

void CTSurfaceUpdateInteg::TestCase1L()

	{

	INFO_PRINTF1(_L("Global Submit Update with/without update region supplied"));

	const TInt bufferNumber = 0; 

	TRequestStatus status = KRequestPending;

	TRequestStatus status1 = KRequestPending;

	TRequestStatus status2 = KRequestPending;

	TUint64 timestampComposition = 0;

	TTimeStamp timeStamp; 

	//Fill the surface to different colour, submit update for the whole surface 

	//and check that screen is updated correctly

	INFO_PRINTF1(_L("Fill the surface with the blue color"));

	iSurfaceHelper->FillRectangleL(iSurface, TPoint(), windowSize, KRgbBlue);

	FillRefBitmap(KRgbBlue);

	INFO_PRINTF1(_L("Updating the whole area of the surface"));

	TUint64 timestampBefore = User::FastCounter();

	iSurfaceUpdate.NotifyWhenAvailable(status);	

	iSurfaceUpdate.NotifyWhenDisplayed(status1, timeStamp);	

	iSurfaceUpdate.NotifyWhenDisplayedXTimes(10, status2);

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, bufferNumber);

	User::WaitForRequest(status);

	User::WaitForRequest(status1);

	User::WaitForRequest(status2);

	User::After(TTimeIntervalMicroSeconds32(100000)); //useful for visual checking

	TUint64 timestampAfter = User::FastCounter();

	if(timestampAfter < timestampBefore)

		{

		timestampAfter += UINT_MAX;

		}

	timestampComposition = timeStamp();

	if(timestampComposition < timestampBefore)

		{

		timestampComposition += UINT_MAX;

		}

	TEST(status == KErrNone);

	TEST(status1 == KErrNone);

	TEST(status2 == KErrNone);

	TEST(timestampComposition != 0);

	TEST(timestampAfter >= timestampComposition);

	TEST(timestampBefore <= timestampComposition);

	TEST(CompareAllScreens());

	//Fill the surface to different colour; hide the part of the surface on 

	//the screen which is not a master, submit update for the area of the surface 

	//which is only visible on the master. Check that only master screen gets updated.

	INFO_PRINTF1(_L("Hide the part of the surface on the second screen"));

	iWindowAbove1->Window()->SetVisible(EFalse);

	iWindowAbove2->Window()->SetVisible(ETrue);

	iWs.Finish();

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, bufferNumber);

	User::After(TTimeIntervalMicroSeconds32(100000)); //useful for visual checking

	INFO_PRINTF1(_L("Fill the surface with the green color"));

	iSurfaceHelper->FillRectangleL(iSurface, TPoint(), windowSize, KRgbGreen);

	TRect rc(windowHalfSize);

	rc.Shrink(10, 10);

	RRegion region(1, &rc); //this area is hidden if the window above is visible

	timestampBefore = User::FastCounter();

	iSurfaceUpdate.NotifyWhenAvailable(status);	

	iSurfaceUpdate.NotifyWhenDisplayed(status1, timeStamp);	

	iSurfaceUpdate.NotifyWhenDisplayedXTimes(10, status2);

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, bufferNumber, &region);

	User::WaitForRequest(status);

	User::WaitForRequest(status1);

	User::WaitForRequest(status2);

	User::After(TTimeIntervalMicroSeconds32(1000000)); //useful for visual checking

	timestampAfter = User::FastCounter();

	if(timestampAfter < timestampBefore)

		{

		timestampAfter += UINT_MAX;

		}

	timestampComposition = timeStamp();

	if(timestampComposition < timestampBefore)

		{

		timestampComposition += UINT_MAX;

		}

	TEST(status == KErrNone);

	TEST(status1 == KErrNone);

	TEST(status2 == KErrNone);

	TEST(timestampComposition != 0);

	TEST(timestampAfter >= timestampComposition);

	TEST(timestampBefore <= timestampComposition);

	User::After(TTimeIntervalMicroSeconds32(100000)); //useful for visual checking

	//first screen should be updated, as the surface is visible here

	TRect rectSrc = rc;

	rectSrc.Move(windowTopLeft);

	FillRefBitmap(KRgbGreen);

	TEST(Compare(0, rectSrc, iRefBitmap));

	//check that second screen doesn't update visible part of the surface 

	FillRefBitmap(KRgbYellow);

	TEST(Compare(1, rectSrc, iRefBitmap));

	//Fill the surface to different colour; hide the part of the surface 

	//on the master screen, submit update for the area of the surface 

	//which is only visible on non-master. Check that only non-master screen gets updated.

	INFO_PRINTF1(_L("Hide the part of the surface on the first screen"));

	iWindowAbove1->Window()->SetVisible(ETrue);

	iWindowAbove2->Window()->SetVisible(EFalse);

	iWs.Finish();

	User::After(TTimeIntervalMicroSeconds32(100000)); //useful for visual checking

	INFO_PRINTF1(_L("Fill the surface with the blue color"));

	iSurfaceHelper->FillRectangleL(iSurface, TPoint(), windowSize, KRgbBlue);

	timestampBefore = User::FastCounter();

	iSurfaceUpdate.NotifyWhenAvailable(status);	

	iSurfaceUpdate.NotifyWhenDisplayed(status1, timeStamp);	

	iSurfaceUpdate.NotifyWhenDisplayedXTimes(10, status2);

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, bufferNumber, &region);

	User::WaitForRequest(status);

	User::WaitForRequest(status1);

	User::WaitForRequest(status2);

	User::After(TTimeIntervalMicroSeconds32(1000000)); //useful for visual checking

	timestampAfter = User::FastCounter();

	if(timestampAfter < timestampBefore)

		{

		timestampAfter += UINT_MAX;

		}

	timestampComposition = timeStamp();

	if(timestampComposition < timestampBefore)

		{

		timestampComposition += UINT_MAX;

		}

	TEST(status == KErrNone);

	TEST(status1 == KErrNone);

	TEST(status2 == KErrNone);

	TEST(timestampComposition != 0);

	TEST(timestampAfter >= timestampComposition);

	TEST(timestampBefore <= timestampComposition);

	//check that first screen doesn't update visible part of the surface 

	FillRefBitmap(KRgbYellow);

	TEST(Compare(0, rectSrc, iRefBitmap));

	//second screen should be updated, as the surface is visible here

	FillRefBitmap(KRgbBlue);

	TEST(Compare(1, rectSrc, iRefBitmap));

	//Fill the surface to different colour; hide the part of the surface on the master screen, 

	//submit update for the area of the surface which is not visible on any screen. 

	//Check that all screens have not been updated.

	INFO_PRINTF1(_L("Hide partly the surface on two screens"));

	iWindowAbove1->Window()->SetVisible(ETrue);

	iWindowAbove2->Window()->SetVisible(ETrue);

	iWs.Finish();

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, bufferNumber);

	User::After(TTimeIntervalMicroSeconds32(1000000)); //useful for visual checking

	INFO_PRINTF1(_L("Fill the surface with the green color"));

	iSurfaceHelper->FillRectangleL(iSurface, TPoint(), windowSize, KRgbGreen);

	FillRefBitmap(KRgbGreen);

	timestampBefore = User::FastCounter();

	iSurfaceUpdate.NotifyWhenAvailable(status);	

	iSurfaceUpdate.NotifyWhenDisplayed(status1, timeStamp);	

	iSurfaceUpdate.NotifyWhenDisplayedXTimes(10, status2);

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, bufferNumber, &region);

	User::WaitForRequest(status);

	User::WaitForRequest(status1);

	User::WaitForRequest(status2);

	User::After(TTimeIntervalMicroSeconds32(1000000)); //useful for visual checking

	timestampAfter = User::FastCounter();

	if(timestampAfter < timestampBefore)

		{

		timestampAfter += UINT_MAX;

		}

	timestampComposition = timeStamp();

	if(timestampComposition < timestampBefore)

		{

		timestampComposition += UINT_MAX;

		}

	TEST(status == KErrNone);

	TEST(status1 == KErrNone);

	TEST(status2 == KErrNone);

	TEST(timestampComposition != 0);

	TEST(timestampAfter >= timestampComposition);

	TEST(timestampBefore <= timestampComposition);

	User::After(TTimeIntervalMicroSeconds32(100000)); //useful for visual checking

	//both first and second screen shouldn't be updated, as the surface is not visible here

	FillRefBitmap(KRgbYellow);

	TEST(Compare(0, rectSrc, iRefBitmap));

	TEST(Compare(1, rectSrc, iRefBitmap));

	INFO_PRINTF1(_L("Return to the initial state"));

	iWindowAbove1->Window()->SetVisible(EFalse);

	iWindowAbove2->Window()->SetVisible(EFalse);

	iWs.Finish();

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, bufferNumber);

	User::After(TTimeIntervalMicroSeconds32(1000000)); //useful for visual checking

	FillRefBitmap(KRgbGreen);

	TEST(CompareAllScreens());

	}

/**

  @SYMTestCaseID GRAPHIC-SURFACEUPDATE-0031

  @SYMCR CR1650

  @SYMREQ REQ11598

  @SYMTestCaseDesc NotifyWhenAvailable() to deal with global updates and be signalled 

 	correctly when screen is unplugged.

  @SYMTestPriority 	High

  @SYMTestStatus Implemented

  @SYMTestActions 

 	The test consists of a double-buffered surface, visible on screens A 

 	(master) and B,

	1	Make global submit update with notify when available for the buffer 1.

	2	Unplug screen A (notification is still in a progress )

	3	Make global submit update with notify when available for the 

	buffer 2 to trigger notification.

	4	Make global submit update with notify when available for the 

	buffer 1.

	5	Plug in screen A. (notification is still in a progress )

	6	Make global submit update with notify when available for 

	the buffer 2.

  @SYMTestExpectedResults 

  	After step 3, notification is received with KErrNone (this is 

  	triggered by the Receiver for screen B).

	After step 6, notification is received with KErrNone (this is 

	triggered by the Receiver for screen A).

*/

void CTSurfaceUpdateInteg::TestCase2L()

	{

	INFO_PRINTF1(_L("Exercising NotifyWhenAvailable while some screens are disconnected."));

	//hide single-buffered surface and show a double buffered-surface

	iWindowSingleBuffured1->Window()->SetVisible(EFalse);

	iWindowSingleBuffured2->Window()->SetVisible(EFalse);

	iWindowDoubleBuffured1->Window()->SetVisible(ETrue);

	iWindowDoubleBuffured2->Window()->SetVisible(ETrue);

	iWs.Finish();

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, 0);

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurfaceDoubleBuffered, 0);

	FillRefBitmap(KRgbCyan);

	TEST(CompareAllScreens());

	User::After(TTimeIntervalMicroSeconds32(100000)); //useful for visual checking

	INFO_PRINTF1(_L("Fill the surface with the blue color"));

	iSurfaceHelper->FillRectangleL(iSurfaceDoubleBuffered, TPoint(), windowSize, KRgbBlue);

	INFO_PRINTF1(_L("Disconnect the screen while notify when available request is still in a progress")); 

	TRequestStatus status;

	TSwitchDisplayAndReleaseBuffer param;

	param.iBuffer = 0;

	param.iScreen = 0;

	param.iSurfaceId=iSurfaceDoubleBuffered;

	CCommandDispatcher commandDispatcher(CCommandDispatcher::EDisconnectDisplayAndReleaseBuffer, &param);

	//Command dispatcher will be running in the separate thread. 

	//The requirement for this caused by the fact that for dubble-buffered surfaces 

	//the content update receiver will postpone completion of the request for availability until 

	//client sends SubmitUpdate for another buffer. 

	iSurfaceUpdate.NotifyWhenAvailable(status);	

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurfaceDoubleBuffered, 1);

	TInt res = commandDispatcher.Start();  //kickoff another thread, which SubmitUpdate 

											//for buffer 1 and disconnects the first screen

	TEST(res == KErrNone);

	User::WaitForRequest(status);//At that point we are blocked until command dispatcher sends SubmitUpdate for the buffer number 1

	TEST(status == KErrNone);

	//connect the screen

	INFO_PRINTF1(_L("Connect the screen while notify when available request is still in a progress")); 

	CCommandDispatcher commandDispatcher1(CCommandDispatcher::EConnectDisplayAndReleaseBuffer, &param);

	iSurfaceUpdate.NotifyWhenAvailable(status);	

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurfaceDoubleBuffered, 0);

	res = commandDispatcher.Start();//kickoff another thread, which SubmitUpdate 

										//for buffer 1 and connects the first screen

	TEST(res == KErrNone);

	User::WaitForRequest(status);

	TEST(status == KErrNone);

	//restore the original state

	iWindowSingleBuffured1->Window()->SetVisible(ETrue);

	iWindowSingleBuffured2->Window()->SetVisible(ETrue);

	iWindowDoubleBuffured1->Window()->SetVisible(EFalse);

	iWindowDoubleBuffured2->Window()->SetVisible(EFalse);

	iWs.Finish();

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, 0);

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurfaceDoubleBuffered, 0);

	FillRefBitmap(KRgbGreen);

	TEST(CompareAllScreens());

	}

/**

  @SYMTestCaseID GRAPHIC-SURFACEUPDATE-0032

  @SYMCR CR1650

  @SYMREQ REQ11599, REQ11600, REQ11601

  @SYMTestCaseDesc NotifyWhenDisplayedXTimes() to deal with global 

  updates and be signalled correctly when screen is unplugged.

  @SYMTestPriority 	High

  @SYMTestStatus Implemented

  @SYMTestActions 

  	The test consists of a single-buffered surface, S1, visible on 

  	screens A (master) and B.

	Screens are ordered in the following priority: A > B

		1	Make global submit update for surface S1 with notify 

		when notify when displayed X times. X should be approximately 10 

		seconds.

		2	Unplug screen A while display XTimes is still in progress.

		3	After receiving notification, plug in screen A

		4	Make global submit update with notify when displayed X times. 

		X should be approximately 10 seconds.

		5	Make global submit update for surface S1, with notify when 

		displayed X times. X should be approximately 10 seconds.

		6	Unplug screen B while display XTimes is still in progress.

        7   Make global submit update for surface S1, with notify when 

        displayed X times. X should be approximately 10 seconds.		

		8	Unplug screen A as well whilst display XTimes is still in progress.

		9   Reconnect both screens

  @SYMTestExpectedResults

  	After the 10 seconds have elapsed from step 1, notification is 

  	received (step 3) with KErrNone (this is triggered by the Receiver 

  	for screen B).

	After 10 seconds have elapsed from step 4, notification is received 

	with KErrNone (this is triggered by the Receiver for screen A).

	After step 8 (which must occur before 10 seconds) notification will 

	be received with KErrNotVisible (ie. The surface is not visible on 

	any screen).

*/

void CTSurfaceUpdateInteg::TestCase3()

	{

	INFO_PRINTF1(_L("Exercising NotifyWhenDisplayedXTimes while some screen is disconnected."));

	TRequestStatus status;

	TInt count = 100 * 2; 

	iSurfaceUpdate.NotifyWhenDisplayedXTimes(count, status);	

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, 0);

	INFO_PRINTF1(_L("Disconnect the screen when notification when displayed X times request is still in a progress")); 

	TInt displayState = EDisconnect;

	TInt disconnectedScreenNo = 0;

	TInt res = UserSvr::HalFunction(EHalGroupDisplay | (disconnectedScreenNo<<16), EDisplayHalSetDisplayState, &displayState, NULL);

	TEST(res == KErrNone);

	User::WaitForRequest(status); //The content update receiver will complete notification when “count” number of display refreshes has occurred.  

									//We are not blocked here indefinitely, so there is no point to use a command dispatcher

	TEST(status == KErrNone);

	//restore the first screen 

	INFO_PRINTF1(_L("Connect the screen when notification when displayed X times request is still in a progress")); 

	displayState = ENormalResolution;

	res = UserSvr::HalFunction(EHalGroupDisplay | (disconnectedScreenNo<<16), EDisplayHalSetDisplayState, &displayState, NULL);

	TEST(res == KErrNone);

	iSurfaceUpdate.NotifyWhenDisplayedXTimes(count, status);	

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, 0);

	User::WaitForRequest(status);

	TEST(status == KErrNone);

	// Make sure other surface is not visible

	iWindowAbove11->Window()->SetVisible(EFalse);

	iWs.Finish();

	User::After(TTimeIntervalMicroSeconds32(100000)); //useful for visual checking

	// above1 surface should not be visible because window is not visible

	TTimeStamp timeStamp; 

	iSurfaceUpdate.NotifyWhenDisplayed(status, timeStamp);	

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurfaceAbove1, 0);

	User::WaitForRequest(status);

	TEST(status == KErrNotVisible);

	//disconnect the secondary screen - surface still visible on primary

	INFO_PRINTF1(_L("Disconnect the secondary screen - surface still visible on primary")); 

	displayState = EDisconnect;

	disconnectedScreenNo = 1;

	iSurfaceUpdate.NotifyWhenDisplayedXTimes(count, status);	

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, 0);

	res = UserSvr::HalFunction(EHalGroupDisplay | (disconnectedScreenNo<<16), EDisplayHalSetDisplayState, &displayState, NULL);

	TEST(res == KErrNone);

	User::WaitForRequest(status);

	TEST(status == KErrNone);

	User::After(TTimeIntervalMicroSeconds32(100000)); //useful for visual checking

   //disconnect the primary screen - surface now not visible on any screen

    INFO_PRINTF1(_L("Disconnect the primary screen - surface not visible on any screen")); 

    displayState = EDisconnect;

    disconnectedScreenNo = 0;

    iSurfaceUpdate.NotifyWhenDisplayedXTimes(count, status);    

    iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, 0);

    res = UserSvr::HalFunction(EHalGroupDisplay | (disconnectedScreenNo<<16), EDisplayHalSetDisplayState, &displayState, NULL);

    TEST(res == KErrNone);

    User::WaitForRequest(status);

    TEST(status == KErrNotVisible); // not visible raised if primary is disconnected

    User::After(TTimeIntervalMicroSeconds32(100000)); //useful for visual checking

    //restore initial state 

    disconnectedScreenNo = 0;

    displayState = ENormalResolution;

    res = UserSvr::HalFunction(EHalGroupDisplay | (disconnectedScreenNo<<16), EDisplayHalSetDisplayState, &displayState, NULL);

    TEST(res == KErrNone);

    disconnectedScreenNo = 1;

    res = UserSvr::HalFunction(EHalGroupDisplay | (disconnectedScreenNo<<16), EDisplayHalSetDisplayState, &displayState, NULL);

    TEST(res == KErrNone);

	iWs.Finish();	

	iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurface, 0);

	User::After(TTimeIntervalMicroSeconds32(100000)); //useful for visual checking

	TEST(CompareAllScreens());

	}

void CTSurfaceUpdateInteg::RunTestCaseL(TInt aCurTestCase)

	{

	((CTSurfaceUpdateIntegStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

	switch(aCurTestCase)

		{

	case 1:

		{

		if((static_cast <CTSurfaceUpdateIntegStep*> (iStep)) -> IsScreenCaptureSupported()  && (iNumOfScreens > 1))

			{

			((CTSurfaceUpdateIntegStep*)iStep)->SetTestStepID(_L("GRAPHIC-SURFACEUPDATE-0026"));

			INFO_PRINTF1(_L("TestCase1"));

			TestCase1L();

			}

		else

			{

			((CTSurfaceUpdateIntegStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

			INFO_PRINTF3(_L("The test will be skipped as the environment is not ready: Number of screen : %d, Is screen capture supported: %d"), 

					iNumOfScreens, (static_cast <CTSurfaceUpdateIntegStep*> (iStep)) -> IsScreenCaptureSupported());

			TestComplete();		

			}	

		break;

		}

#ifdef __WINS__

	case 2:

		{

		((CTSurfaceUpdateIntegStep*)iStep)->SetTestStepID(_L("GRAPHIC-SURFACEUPDATE-0031"));

		INFO_PRINTF1(_L("TestCase2"));

		TestCase2L();

		break;

		}

	case 3:

		{

		((CTSurfaceUpdateIntegStep*)iStep)->SetTestStepID(_L("GRAPHIC-SURFACEUPDATE-0032"));

		INFO_PRINTF1(_L("TestCase3"));

		TestCase3();

		break;

		}

#endif		

	default:

		((CTSurfaceUpdateIntegStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

		((CTSurfaceUpdateIntegStep*)iStep)->CloseTMSGraphicsStep();

		TestComplete();		

		break;

		}

	((CTSurfaceUpdateIntegStep*)iStep)->RecordTestResultL();

	}

//--------------

_LIT(KCommandDispatcher, "CommandDispatcher");

const TUint KDefaultHeapSize=0x10000;

/**

 * Launch the command thread.

 */

TInt CCommandDispatcher::Start()

	{

	RThread commandThread;

	TInt res = KErrGeneral;

	TBuf<64> commandThreadName;

	TBuf<64> commandThreaMask;

	// Guarantee uniqueness of thread name by using timestamp

	TTime tm;

	TBuf<32> timeStamp;

	tm.UniversalTime();

	TRAP(res, tm.FormatL(timeStamp, _L("_%H%T%S%C")));

	if(res != KErrNone)

		{

		return res;

		}

	commandThreadName.Append(KCommandDispatcher);

	commandThreadName.Append(timeStamp);

	commandThreaMask = commandThreadName;

	commandThreaMask.Insert(0, _L("*"));

	TFindThread findThread(commandThreaMask);

	TFullName name;

	  // Need to check that the thread exists.

	if (findThread.Next(name)!=KErrNone)

		{

		  // Create the thread for the server.

		res = commandThread.Create(commandThreadName,

			CCommandDispatcher::ThreadFunction,

			KDefaultStackSize,

			KDefaultHeapSize,

			KDefaultHeapSize,

			this

			);

          // The thread has been created OK so get it started - however

          // we need to make sure that it has started before we continue.

		if (res==KErrNone)

			{

			TRequestStatus rendezvousStatus;

			commandThread.SetPriority(EPriorityNormal);

			commandThread.Rendezvous(rendezvousStatus);

			commandThread.Resume();

			}

		}

	commandThread.Close();

	return res;

	}

TInt CCommandDispatcher::ThreadFunction(TAny* aAny)

	{

	  // get clean-up stack

	CTrapCleanup* cleanup=CTrapCleanup::New();

	CCommandDispatcher* commandDispatcher = (CCommandDispatcher*) aAny;

	TRAPD(res, commandDispatcher->ExecuteCommandL());

	delete cleanup; 

	return res;

	}

/**

 * Run commands in a thread different to the thread where the instance 

 * of the class was initialized.

 */

void CCommandDispatcher::ExecuteCommandL()

	{

	switch(iCommandName)

		{

	case EDisconnectDisplayAndReleaseBuffer:

		{

		RSurfaceUpdateSession surfaceUpdate;

		User::LeaveIfError(surfaceUpdate.Connect());

		CleanupClosePushL(surfaceUpdate);

		TSwitchDisplayAndReleaseBuffer* param = static_cast<TSwitchDisplayAndReleaseBuffer*>(iParam); 

		if(!param)

			{

			User::Leave(KErrArgument);

			}

		TInt displayState = EDisconnect;

		TInt screenNumber = param->iScreen;

		TInt bufferNumber = param->iBuffer;

		User::LeaveIfError(UserSvr::HalFunction(EHalGroupDisplay | (screenNumber<<16), EDisplayHalSetDisplayState, &displayState, NULL));

		//Submit Update to unblock the main client thread 

		User::LeaveIfError(surfaceUpdate.SubmitUpdate(KAllScreens, param->iSurfaceId, bufferNumber));

		CleanupStack::PopAndDestroy(&surfaceUpdate);

		break;

		}

	case EConnectDisplayAndReleaseBuffer:

		{

		RSurfaceUpdateSession surfaceUpdate;

		User::LeaveIfError(surfaceUpdate.Connect());

		CleanupClosePushL(surfaceUpdate);

		TSwitchDisplayAndReleaseBuffer* param = static_cast<TSwitchDisplayAndReleaseBuffer*>(iParam); 

		if(!param)

			{

			User::Leave(KErrArgument);

			}

		TInt displayState = ENormalResolution;

		TInt screenNumber = param->iScreen;

		TInt bufferNumber = param->iBuffer;

		User::LeaveIfError(UserSvr::HalFunction(EHalGroupDisplay | (screenNumber<<16), EDisplayHalSetDisplayState, &displayState, NULL));

		//Submit Update to unblock the main client thread 

		User::LeaveIfError(surfaceUpdate.SubmitUpdate(KAllScreens, param->iSurfaceId, bufferNumber));

		CleanupStack::PopAndDestroy(&surfaceUpdate);

		break;

		}

	default:

		User::Leave(KErrNotSupported);

		break;

		}

	}

//--------------

__CONSTRUCT_STEP__(SurfaceUpdateInteg)

/**

 * Retrieve screen capturing plug-in, if succeed set a flag.

 */

void CTSurfaceUpdateIntegStep::TestSetupL()

	{

//	check if the screen capture plug-in presents in the system

	RWsSession ws;

	User::LeaveIfError(ws.Connect());

	CleanupClosePushL(ws);

	TInt numOfScreens = ws.NumberOfScreens();

	if(numOfScreens < 2)

		{

		ERR_PRINTF2(_L("Environment is not ready, the number of the screens in the system for this test should be 2 or more, the current number is: %d"), numOfScreens);

		User::Leave(KErrNotReady);

		}

	CWsScreenDevice* wsDev = new (ELeave) CWsScreenDevice(ws);

	CleanupStack::PushL(wsDev);

	User::LeaveIfError(wsDev->Construct(0));

	TDisplayMode dispMode = wsDev->DisplayMode();

	INFO_PRINTF2(_L("Screen device display mode is: %d."), dispMode);

	MTestScreenCapture* csc = static_cast<MTestScreenCapture*> (wsDev->GetInterface(MTestScreenCapture::KUidTestScreenCaptureIf));

	if(csc)

		{

		INFO_PRINTF1(_L("Screen capture plug-in presents in the system."));

		iScreenCapture = ETrue;

		}

	else

		{

		INFO_PRINTF1(_L("Screen capture plug-in is not installed in the system, to make automated checking screen capture rendering stage is required, \

see graphics\\wserv_std_plugins\\screencapture"));

		}

	CleanupStack::PopAndDestroy(2, &ws); //ws, wsDev

	}

void CTSurfaceUpdateIntegStep::TestClose()

	{

	}