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

//

/**

 @file

*/

#include <e32std.h>

#include <imageconversion.h>

#include "surfaceutility.h"

CSurfaceUtility::CSurfaceUtility(CSurfaceUtility* aClone)

	:	iSurfaces(aClone?&(aClone->iSurfaces):NULL)

	{

	}

CSurfaceUtility* CSurfaceUtility::NewL(CSurfaceUtility* aClone/*=NULL*/)

	{

	CSurfaceUtility* utility = new (ELeave)CSurfaceUtility(aClone);

	CleanupStack::PushL(utility);

	utility->ConstructL();

	CleanupStack::Pop(utility);

	return utility;

	}

void CSurfaceUtility::ConstructL()

	{

	TInt r = iManager.Open();

	if (r != KErrNone)

		{

		LOG(("Surface manager failed to open: %d", r));

		User::Leave(r);

		}

	r = iSurfaceUpdateSession.Connect();

	if (r != KErrNone)

		{

		LOG(("Failed to connect to update server: %d", r));

		User::Leave(r);

		}

	}

CSurfaceUtility::~CSurfaceUtility()

	{

	DestroyAll();

	iSurfaces.Close();

	iManager.Close();

	iSurfaceUpdateSession.Close();

	}

TBool CSurfaceUtility::DestroyAll()

	{

	TInt err = 	KErrNone;

	TInt jj = iSurfaces.Count() - 1;

	if (jj<0)

		return EFalse;

	for (; jj >= 0; jj--)

		{

		err = iManager.CloseSurface(iSurfaces[jj]);

		if (err!=KErrNone)

			{

			LOG(("Error closing surface: 0x%X\n", err));

			}

		}

	iSurfaces.Reset();

	return ETrue;

	}

/***************************************

 * The aim of the THeapSurfaceArray is to locally switch in the specified heap for any array operation

 ***************************************/

CSurfaceUtility::RHeapSurfaceArray::RHeapSurfaceArray(RHeapSurfaceArray* aUseExternalArray)

	:	iUseArray(aUseExternalArray?aUseExternalArray->iUseArray:&this->iLocalArray),

	iExternalHeapRef(aUseExternalArray?aUseExternalArray->iExternalHeapRef:User::Heap())

	{

	}

/************************************

 * The following methods have been used by the surfaceutility... some require the heap wrapping, and some don't

 * I actually need three different startegies (count em) for 7 methods...

 * Some methods only read the existing objects, so don't need a heap swap at all

 * Leaving methods have to use PopAndDestroy strategy to restore the heap on leaving or success

 * Non-leaving methods must not call PushL, so directly make SwitchHeap calls!

 ************************************/

// PopAndDestroy method to restore the heap

/*static*/ void	CSurfaceUtility::RHeapSurfaceArray::PopHeap(void* aHeapPtr)

	{

	RHeap* heapPtr=(RHeap*)aHeapPtr;

	User::SwitchHeap(heapPtr);

	}

// Switches and pushes the previous heap so it can be restored with PopAndDestroy

/*static*/ void CSurfaceUtility::RHeapSurfaceArray::SwitchHeapLC(RHeap* aNewHeap)

	{

	CleanupStack::PushL(TCleanupItem(PopHeap,NULL));

	CleanupStack::PushL(TCleanupItem(PopHeap,NULL));

	CleanupStack::PushL(TCleanupItem(PopHeap,NULL));

	CleanupStack::Pop(3);

	RHeap* oldHeap=User::SwitchHeap(aNewHeap);

	delete new char;

	CleanupStack::PushL(TCleanupItem(PopHeap,oldHeap));

	}

TSurfaceId& CSurfaceUtility::RHeapSurfaceArray::operator[](TUint aIndex)

	{

	return iUseArray->operator[](aIndex);

	}

// Close only closes the local array, while Reset resets the active array (may be external)

void CSurfaceUtility::RHeapSurfaceArray::Close()

	{

	iLocalArray.Close();

	}

TInt CSurfaceUtility::RHeapSurfaceArray::Count() const

	{

	return iUseArray->Count();

	}

// Close only closes the local array, while Reset resets the active array (may be external)

inline void CSurfaceUtility::RHeapSurfaceArray::Reset()

	{

	iUseArray->Reset();

	}

void CSurfaceUtility::RHeapSurfaceArray::AppendL(const TSurfaceId &anEntry)

	{

	iUseArray->AppendL(anEntry);

	}

TInt CSurfaceUtility::RHeapSurfaceArray::Find(const TSurfaceId &anEntry) const

	{

	return iUseArray->Find(anEntry);

	}

void CSurfaceUtility::RHeapSurfaceArray::Remove(TInt anIndex)

	{

	iUseArray->Remove(anIndex);

	}

/**

Cleanup stack helper object, holding references to both utility and surface, so

that the standard Close() semantics can be used.

*/

class TSurfaceCleanup

	{

public:

	TSurfaceCleanup(CSurfaceUtility& aUtility, TSurfaceId& aSurface)

		: iUtility(aUtility), iSurface(aSurface)

		{}

	void Close()

		{

		// Removes the surface from the list of surfaces to clean up, and closes

		// the surface reference.

		iUtility.DestroySurface(iSurface);

		}

private:

	CSurfaceUtility& iUtility;

	TSurfaceId& iSurface;

	};

/**

Get the size of a surface.

@param aSurface The surface to get the size for.

@return The size in pixels, or empty on failure.

*/

TSize CSurfaceUtility::SurfaceSize(const TSurfaceId& aSurface)

	{

	RSurfaceManager::TInfoBuf infoBuf;

	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

	if (iManager.SurfaceInfo(aSurface, infoBuf) == KErrNone)

		{

		return info.iSize;

		}

	return TSize();

	}

/**

Create a surface using the surface manager.

Stores the ID for tear down, as well as returning it.

@param aSize Dimensions of the surface.

@param aPixelFormat	UID of the pixel format.

@param aStride	Stride value for the surface (usually bytes per pixel * width)

@leave May leave due to lack of memory.

@return New surface's ID.

*/

TSurfaceId CSurfaceUtility::CreateSurfaceL(const TSize& aSize, TUidPixelFormat aPixelFormat, TInt aStride, TInt aBuffers)

	{

	RSurfaceManager::TSurfaceCreationAttributesBuf bf;

	RSurfaceManager::TSurfaceCreationAttributes& b = bf();

	if (aStride<aSize.iWidth*BytesPerPixelL(aPixelFormat))

	    {

	    User::Leave(KErrOverflow);

	    }

	b.iSize.iWidth = aSize.iWidth;

	b.iSize.iHeight = aSize.iHeight;

	b.iBuffers = aBuffers;				// number of buffers in the surface

	b.iPixelFormat = aPixelFormat;

	b.iStride = aStride;		// Number of bytes between start of one line and start of next

	b.iOffsetToFirstBuffer = 0;	// way of reserving space before the surface pixel data

	b.iAlignment = 4;			// alignment, 1,2,4,8 byte aligned

	b.iContiguous = EFalse;

	b.iMappable = ETrue;

	TSurfaceId surface = TSurfaceId::CreateNullId();

	User::LeaveIfError(iManager.CreateSurface(bf, surface));

	iSurfaces.AppendL(surface);

	return surface;

	}

/**

A helper function that returns the bytes per pixel for a given pixel format uid

@param aPixelFormat Pixel format UID to convert

@return The bytes per pixel

*/

TInt CSurfaceUtility::BytesPerPixelL(TUidPixelFormat aPixelFormat)

	{

	TInt bytesPerPixel = 0;

	switch (aPixelFormat)

		{

		case EUidPixelFormatXRGB_8888:

		case EUidPixelFormatARGB_8888:

		case EUidPixelFormatARGB_8888_PRE:

			{

			bytesPerPixel = 4;

			break;

			}

		case EUidPixelFormatXRGB_4444:

		case EUidPixelFormatARGB_4444:

		case EUidPixelFormatRGB_565:

			{

			bytesPerPixel = 2;

			break;

			}

		default:

			{

			User::Leave(KErrNotSupported);

			break;

			}

		}

	return bytesPerPixel;

	}

/**

Fill the given surface with a color.

@param aSurface	The surface to be filled.

@param aColor	The color to fill it with.

*/

void CSurfaceUtility::FillSurfaceL(TSurfaceId& aSurface, const TRgb& aColor)

	{

	RSurfaceManager::TInfoBuf infoBuf;

	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

	User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));

	TUint32 color = 0;

	TBool use16 = EFalse;

	if (info.iSize.iHeight<0 || info.iSize.iWidth<0 || info.iStride<0)

		{

		User::Leave(KErrCorrupt);

		}

	if (info.iSize.iHeight==0 || info.iSize.iWidth==0 || info.iStride==0)

		{

		User::Leave(KErrNotReady);

		}

	switch (info.iPixelFormat)

		{

		case EUidPixelFormatXRGB_8888:

			{

			color = aColor.Color16MU();

#ifdef ALPHA_FIX_24BIT

			color |= ((ALPHA_FIX_24BIT)&0xff)<<24;

#endif

			break;

			}

		case EUidPixelFormatARGB_8888:

			{

			color = aColor.Color16MA();

			break;

			}

		case EUidPixelFormatARGB_8888_PRE:

			{

			color = aColor.Color16MAP();

			break;

			}

		case EUidPixelFormatXRGB_4444:

		case EUidPixelFormatARGB_4444:

			{

			color = aColor.Color4K();

			use16 = ETrue;

			break;

			}

		case EUidPixelFormatRGB_565:

			{

			color = aColor.Color64K();

			use16 = ETrue;

			break;

			}

		default:

			{

			User::Leave(KErrNotSupported);

			break;

			}

		}

	RChunk chunk;

	User::LeaveIfError(iManager.MapSurface(aSurface, chunk));

	CleanupClosePushL(chunk);

	TInt offsetToFirstBuffer;

	User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));

	TUint8* surfacePtr = chunk.Base() + offsetToFirstBuffer;

	TUint8* linePtr = surfacePtr;

	if (use16)

		{

		if ( info.iSize.iWidth*2>info.iStride)

			{

			User::Leave(KErrOverflow);

			}

		TUint16* ptr = reinterpret_cast<TUint16*>(surfacePtr);

		// Fill first line

		for (TInt xx = 0; xx < info.iSize.iWidth; xx++)

			{

			ptr[xx] = (TUint16)color;

			}

		}

	else

		{

		if ( info.iSize.iWidth*4>info.iStride)

			{

			User::Leave(KErrOverflow);

			}

		TUint32* ptr = reinterpret_cast<TUint32*>(surfacePtr);

		// Fill first line

		for (TInt xx = 0; xx < info.iSize.iWidth; xx++)

			{

			ptr[xx] = color;

			}

		}

	// Now copy that to the other lines

	for (TInt yy = 1; yy < info.iSize.iHeight; yy++)

		{

		linePtr += info.iStride;

		Mem::Copy(linePtr, surfacePtr, info.iSize.iWidth * BytesPerPixelL(info.iPixelFormat));

		}

	TInt err = SubmitUpdate(KAllScreens, aSurface, 0, NULL);

	if (err!=KErrNone)

		LOG(("Error submitting update: 0x%X\n", err));

	CleanupStack::PopAndDestroy(/* chunk */);

	}

/**

Fill the given surface with a color.

@param aSurface	The surface to be filled.

@param aBuffer 	The buffer to fill.

@param aColor	The color to fill it with.

*/

void CSurfaceUtility::FillSurfaceL(TSurfaceId& aSurface, TInt aBuffer, const TRgb& aColor)

	{

	RSurfaceManager::TInfoBuf infoBuf;

	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

	User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));

	TUint32 color = 0;

	TBool use16 = EFalse;

	TInt numBuffers = info.iBuffers;

	if (aBuffer < 0 || aBuffer >= numBuffers)

		{

		User::Leave(KErrArgument);

		}

	if (info.iSize.iHeight<0 || info.iSize.iWidth<0 || info.iStride<0)

		{

		User::Leave(KErrCorrupt);

		}

	if (info.iSize.iHeight==0 || info.iSize.iWidth==0 || info.iStride==0)

		{

		User::Leave(KErrNotReady);

		}

	switch (info.iPixelFormat)

		{

		case EUidPixelFormatXRGB_8888:

			{

			color = aColor.Color16MU();

#ifdef ALPHA_FIX_24BIT

			color |= ((ALPHA_FIX_24BIT)&0xff)<<24;

#endif

			break;

			}

		case EUidPixelFormatARGB_8888:

			{

			color = aColor.Color16MA();

			break;

			}

		case EUidPixelFormatARGB_8888_PRE:

			{

			color = aColor.Color16MAP();

			break;

			}

		case EUidPixelFormatXRGB_4444:

		case EUidPixelFormatARGB_4444:

			{

			color = aColor.Color4K();

			use16 = ETrue;

			break;

			}

		case EUidPixelFormatRGB_565:

			{

			color = aColor.Color64K();

			use16 = ETrue;

			break;

			}

		default:

			{

			User::Leave(KErrNotSupported);

			break;

			}

		}

	RChunk chunk;

	User::LeaveIfError(iManager.MapSurface(aSurface, chunk));

	CleanupClosePushL(chunk);

	TInt offsetToBuffer;

	User::LeaveIfError(iManager.GetBufferOffset(aSurface, aBuffer, offsetToBuffer));

	TUint8* surfacePtr = chunk.Base() + offsetToBuffer;

	TUint8* linePtr = surfacePtr;

	if (use16)

		{

		if ( info.iSize.iWidth*2>info.iStride)

			{

			User::Leave(KErrOverflow);

			}

		TUint16* ptr = reinterpret_cast<TUint16*>(surfacePtr);

		// Fill first line

		for (TInt xx = 0; xx < info.iSize.iWidth; xx++)

			{

			ptr[xx] = (TUint16)color;

			}

		}

	else

		{

		if ( info.iSize.iWidth*4>info.iStride)

			{

			User::Leave(KErrOverflow);

			}

		TUint32* ptr = reinterpret_cast<TUint32*>(surfacePtr);

		// Fill first line

		for (TInt xx = 0; xx < info.iSize.iWidth; xx++)

			{

			ptr[xx] = color;

			}

		}

	// Now copy that to the other lines

	for (TInt yy = 1; yy < info.iSize.iHeight; yy++)

		{

		linePtr += info.iStride;

		Mem::Copy(linePtr, surfacePtr, info.iSize.iWidth * BytesPerPixelL(info.iPixelFormat));

		}

	TInt err = SubmitUpdate(KAllScreens, aSurface, 0, NULL);

	if (err!=KErrNone)

		LOG(("Error submitting update: 0x%X\n", err));

	CleanupStack::PopAndDestroy(/* chunk */);

	}

/**

Destroy a surface.

As well as destroying the surface, it is removed from the set held for

destruction during tear down.

@param aSurface	The surface to be destroyed.

*/

void CSurfaceUtility::DestroySurface(TSurfaceId& aSurface)

	{

	TInt index = iSurfaces.Find(aSurface);

	if (index != KErrNotFound)

		{

		iSurfaces.Remove(index);

		}

	TInt err = iManager.CloseSurface(aSurface);

	if (err!=KErrNone)

		LOG(("Error closing surfaces: 0x%X\n", err));

	}

/**

Submit an update to a surface to the update server.

@param aScreenNumber	The screen to be updated where the surface is shown.

@param aSurface	The surface which has been updated.

@param aRegion	The area of the surface affected, or NULL for all of it.

*/

TInt CSurfaceUtility::SubmitUpdate(TInt /* aScreenNumber */, const TSurfaceId& aSurface,TInt aBufferNumber, TInt aNullRegion)

    {

    if (aNullRegion==0)

        {

        return SubmitUpdate(KAllScreens, aSurface, aBufferNumber);

        }

    else

        if (aBufferNumber==0)

            {

            return SubmitUpdate(KAllScreens, aSurface, aNullRegion);

            }

        else

            {

            return KErrNotSupported;

            }

    }

TInt CSurfaceUtility::SubmitUpdate(TInt /* aScreenNumber */, const TSurfaceId& aSurface, const TRegion* aRegion,TInt aBufferNumber)

    {

    return SubmitUpdate(KAllScreens, aSurface, aBufferNumber, aRegion);

    }

TInt CSurfaceUtility::SubmitUpdate(TInt /* aScreenNumber */, const TSurfaceId& aSurface,TInt aBufferNumber, const TRegion* aRegion)

	{

	if (!iSurfaceUpdateSession.Handle())

	    {

	    iSurfaceUpdateSession.Connect();

	    }

    if (!iSurfaceUpdateSession.Handle())

        {

        LOG(("Error - SUS client not started!"));

        return KErrNotReady;

        }

    else

        {

        TInt err =iSurfaceUpdateSession.SubmitUpdate(KAllScreens, aSurface, aBufferNumber, aRegion); 

        if (err!=KErrNone)

            LOG(("Error submitting update: 0x%X\n", err));

        return err;

        }

	}

void CSurfaceUtility::FillNativeStreamSurfaceL(TSurfaceId& aSurface, TUint8* aBufferPtr, const TRgb& aColor)

	{

	RSurfaceManager::TInfoBuf infoBuf;

	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

	User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));

	TUint32 color = 0;

	TBool use16 = EFalse;

	if (info.iSize.iHeight<0 || info.iSize.iWidth<0 || info.iStride<0)

		{

		User::Leave(KErrCorrupt);

		}

	if (info.iSize.iHeight==0 || info.iSize.iWidth==0 || info.iStride==0)

		{

		User::Leave(KErrNotReady);

		}

	switch (info.iPixelFormat)

		{

		case EUidPixelFormatXRGB_8888:

			{

			color = aColor.Color16MU();

#ifdef ALPHA_FIX_24BIT

			color |= ((ALPHA_FIX_24BIT)&0xff)<<24;

#endif

			break;

			}

		case EUidPixelFormatARGB_8888:

			{

			color = aColor.Color16MA();

			break;

			}

		case EUidPixelFormatARGB_8888_PRE:

			{

			color = aColor.Color16MAP();

			break;

			}

		case EUidPixelFormatXRGB_4444:

		case EUidPixelFormatARGB_4444:

			{

			color = aColor.Color4K();

			use16 = ETrue;

			break;

			}

		case EUidPixelFormatRGB_565:

			{

			color = aColor.Color64K();

			use16 = ETrue;

			break;

			}

		default:

			{

			User::Leave(KErrNotSupported);

			break;

			}

		}

	TUint8* surfacePtr = aBufferPtr;

	TUint8* linePtr = surfacePtr;

	if (use16)

		{

		if ( info.iSize.iWidth*2>info.iStride)

			{

			User::Leave(KErrOverflow);

			}

		TUint16* ptr = reinterpret_cast<TUint16*>(surfacePtr);

		// Fill first line

		for (TInt xx = 0; xx < info.iSize.iWidth; xx++)

			{

			ptr[xx] = (TUint16)color;

			}

		}

	else

		{

		if ( info.iSize.iWidth*4>info.iStride)

			{

			User::Leave(KErrOverflow);

			}

		TUint32* ptr = reinterpret_cast<TUint32*>(surfacePtr);

		// Fill first line

		for (TInt xx = 0; xx < info.iSize.iWidth; xx++)

			{

			ptr[xx] = color;

			}

		}

	// Now copy that to the other lines

	for (TInt yy = 1; yy < info.iSize.iHeight; yy++)

		{

		linePtr += info.iStride;

		Mem::Copy(linePtr, surfacePtr, info.iSize.iWidth * BytesPerPixelL(info.iPixelFormat));

		}	

	}

TBool CSurfaceUtility::CompareSurfacesL(TSurfaceId& aSurface, TInt aBuffer, TSurfaceId& aStreamSurface, TUint8* aBufferPtr)

	{

	RSurfaceManager::TInfoBuf infoBuf1;

	RSurfaceManager::TSurfaceInfoV01& info1 = infoBuf1();

	RSurfaceManager::TInfoBuf infoBuf2;

	RSurfaceManager::TSurfaceInfoV01& info2 = infoBuf2();	

	User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf1));

	User::LeaveIfError(iManager.SurfaceInfo(aStreamSurface, infoBuf2));

	TBool use16 = EFalse;

	if (aBuffer < 0 || aBuffer >= info1.iBuffers)

		{

		User::Leave(KErrArgument);

		}

	if (info1.iPixelFormat != info2.iPixelFormat)

		{

		User::Leave(KErrArgument);

		}	

	if ((info1.iSize.iHeight<0 || info1.iSize.iWidth<0 || info1.iStride<0) ||

		(info2.iSize.iHeight<0 || info2.iSize.iWidth<0 || info2.iStride<0))

		{

		User::Leave(KErrCorrupt);

		}

	if ((info1.iSize.iHeight==0 || info1.iSize.iWidth==0 || info1.iStride==0) ||

		(info2.iSize.iHeight==0 || info2.iSize.iWidth==0 || info2.iStride==0))

		{

		User::Leave(KErrNotReady);

		}

	if (info1.iSize != info2.iSize)

		{

		User::Leave(KErrArgument);

		}

	switch (info1.iPixelFormat)

		{

		case EUidPixelFormatXRGB_8888:

		case EUidPixelFormatARGB_8888:

		case EUidPixelFormatARGB_8888_PRE:

			{

			break;

			}

		case EUidPixelFormatXRGB_4444:

		case EUidPixelFormatARGB_4444:

		case EUidPixelFormatRGB_565:

			{

			use16 = ETrue;

			break;

			}

		default:

			{

			User::Leave(KErrNotSupported);

			break;

			}

		}

	// Surface

	RChunk chunk;

	User::LeaveIfError(iManager.MapSurface(aSurface, chunk));

	CleanupClosePushL(chunk);

	TInt offsetToBuffer;

	User::LeaveIfError(iManager.GetBufferOffset(aSurface, aBuffer, offsetToBuffer));

	TUint8* surfacePtr1 = chunk.Base() + offsetToBuffer;

	// Native stream

	TUint8* surfacePtr2 = aBufferPtr;

	TUint32 color1 = 0;

	TUint32 color2 = 0;

	if (use16)

		{

		if ((info1.iSize.iWidth*2>info1.iStride) ||

			(info2.iSize.iWidth*2>info2.iStride))

			{

			User::Leave(KErrOverflow);

			}

		TUint16* ptr1 = reinterpret_cast<TUint16*>(surfacePtr1);

		TUint16* ptr2 = reinterpret_cast<TUint16*>(surfacePtr2);

		// Fill first line

		for (TInt xx = 0; xx < info1.iSize.iWidth; xx++)

			{

			for (TInt yy = 0; yy < info1.iSize.iHeight; yy++)

				{

				color1 = (TUint16)ptr1[xx];

				color2 = (TUint16)ptr2[xx];

				if (color1 != color2)

					{

					return EFalse;

					}

				}

			}

		}

	else

		{

		if ((info1.iSize.iWidth*4>info1.iStride) ||

			(info2.iSize.iWidth*4>info2.iStride))

			{

			User::Leave(KErrOverflow);

			}

		TUint32* ptr1 = reinterpret_cast<TUint32*>(surfacePtr1);

		TUint32* ptr2 = reinterpret_cast<TUint32*>(surfacePtr2);		

		// Fill first line

		for (TInt xx = 0; xx < info1.iSize.iWidth; xx++)

			{

			for (TInt yy = 0; yy < info1.iSize.iHeight; yy++)

				{

				color1 = ptr1[xx];

				color2 = ptr2[xx];

				if (color1 != color2)

					{

					CleanupStack::PopAndDestroy(/* chunk */);

					return EFalse;

					}

				}

			}

		}	

	CleanupStack::PopAndDestroy(/* chunk */);

	return ETrue;

	}

void CSurfaceUtility::NotifyWhenDisplayed(TRequestStatus& aStatusDisplayed, TTimeStamp& aTimeStamp)

    {

    iSurfaceUpdateSession.NotifyWhenDisplayed(aStatusDisplayed, aTimeStamp);

    }

void CSurfaceUtility::NotifyWhenDisplayedXTimes(TInt aCount, TRequestStatus& aStatusDisplayedX)

    {

    iSurfaceUpdateSession.NotifyWhenDisplayedXTimes(aCount, aStatusDisplayedX);

    }

void CSurfaceUtility::NotifyWhenAvailable(TRequestStatus& aStatusAvailable)

    {

    iSurfaceUpdateSession.NotifyWhenAvailable(aStatusAvailable);

    }