// 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, ®ion);
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, ®ion);
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, ®ion);
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, ¶m);
//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, ¶m);
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()
{
}