/*
* Copyright (c) 2006 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:
*
*/
#ifndef __ALFCOMPOSITIONCLIENT_H__
#define __ALFCOMPOSITIONCLIENT_H__
#include <e32hashtab.h>
#include <alf/alfcompositionutility.h>
const TInt KAlfCompositionControllerIfUid(0x2002bcfc);
/** Interface for class that actually controls the composition singleton **/
class MAlfCompositionController: public MAlfCompositionControl
{
public:
virtual TInt CreateTargetL(TInt aTarget, TInt aClientHandle, TInt aGrpHandle ) = 0;
virtual void SetTargetL(TInt aTarget) = 0;
virtual void SetExtentSurfaceId(const TSurfaceId& aSurfaceId) = 0;
virtual TInt SetOrder(TInt aTarget, TInt aTop, TBool aAbove, TBool aCombineTargets) =0;
virtual void DeleteTarget(TInt aTarget)=0;
virtual void LowOnGraphicsMemory()=0;
virtual void GraphicsMemoryGood(){}
virtual void AlfBridgeCallback(TInt, TAny*){};
};
/** Wrapper class IPC <-> MAlfCompositionController **/
NONSHARABLE_CLASS(CAlfCompositionCntrlClient): public CAlfCompositionClientBase
{
public:
CAlfCompositionCntrlClient(MAlfCompositionController* aController):iController(aController){}
IMPORT_C static CAlfCompositionCntrlClient* NewL(RAlfBridgerClient* aClient, MAlfCompositionController* aController);
IMPORT_C ~CAlfCompositionCntrlClient();
// From base
void HandleEventL(TInt aEventType, TAny* aEventData);
// from CActive
TInt RunError(TInt aError);
private:
MAlfCompositionController* iController;
RHashMap<TInt, TInt> iHostBindingsHash;
RHashMap<TInt, TInt32> iHostPermittedOpsHash;
};
/**
Example1:
* // to set target from other app semitransparent
* CAlfCompositionHost* me = CAlfCompositionHost::NewL(tokenFromSource, myCompositionKey);
* me->EnableAlpha();
* me->SetOpacity(0.5f);
* //...
**/
class CAlfCompositionHost: public CAlfCompositionSource
{
public:
/**
* Constructor for application that wishes modify
* composition information for some other process, see CreatePermissionToken()
*
* Leaves using KErrNotFound, if token is not valid
*
* If the binded target layer is destroyed by its owner, any Set operations
* will have no effect.
*/
IMPORT_C static CAlfCompositionHost* NewL(TInt aToken, TInt aKey);
void ConstructL(TInt aToken, TInt aKey);
//private: // data
// class CAlfCompositionHostData;
// CAlfCompositionHostData* iData;
};
// ================ Posting like SW interface ============================================
//
// =======================================================================================
/** Inferface for the pixel buffer provider to provide information, frames and get events concerning context events **/
class MAlfBufferProvider
{
public:
enum TBufferFormat
{
ESourceFormatRGB_565 = 0,
ESourceFormatXRGB_8888 = 1,
ESourceFormatARGB_8888 = 2,
ESourceFormatARGB_8888_PRE = 3
};
struct TBufferCreationAttributes
{
/*
* Buffer size
*/
TInt iWidth;
TInt iHeight;
/**
* iStride should be at least bytes * width.
* iStride may still be adjusted by CAlfCompositionPixelSource for the target HW driver implementation
* Client should always use iStride value available after CAlfCompositionPixelSource::ActivateL call.
**/
TInt iStride;
TInt iAlignment;
TBufferFormat iFormat;
};
/**
* Called by framework when the next buffer is ready and available for the client to draw.
* @param aVisibleRegion is currently visible surface region
*
* @return ETrue to continue drawing of frames. EFalse to pause drawing.
* After pausing drawing client needs to call CAlfCompositionPixelSource::ActivateL to
* continue drawing of frames
**/
virtual TBool ProduceNewFrameL(const TRegion& aVisibleRegion, TUint8*& aBuffer) = 0;
/**
* Called by framework when new buffer is been created. Client should provide desired creation attributes.
**/
virtual TBufferCreationAttributes& BufferAttributes() = 0;
/**
* Notification from FW
**/
virtual void ContextAboutToSuspend() =0;
virtual void OnActivation() = 0;
};
/**
* Example1:
* // to draw frames with CAlfCompositionPixelSource API
* class CMyClass: public CBase, public MAlfBufferProvider
* {
* private:
* CAlfCompositionPixelSource* iAlfCompositionPixelSource;
* MAlfBufferProvider::TBufferCreationAttributes iAttributes;
* public:
*
* CMyClass() {}
*
* ConstructL()
* {
* // ...
* iAttributes.iWidth = width;
* iAttributes.iHeight = height;
* iAttributes.iFormat = MAlfBufferProvider::ESourceFormatARGB_8888;
* iAttributes.iStride = iAttributes.iWidth * 4;
* iAttributes.iAlignment = 32;
*
* iAlfCompositionPixelSource = CAlfCompositionPixelSource::NewL(*this, iMyDrawableWindow);
* iAlfCompositionPixelSource->iActivateL()
* }
*
* TBool ProduceNewFrameL(const TRegion& aVisibleRegion, TUint8*& aBuffer)
* {
* // ...
* // copy pixel data to aBuffer
* TUint8* from = (TUint8*)bitmap->DataAddress();
* TUint bytes = bitmap->SizeInPixels()*4;
* for (TInt y = bitmap->SizeInPixels().iHeight; y > 0; y--)
* {
* Mem::Copy(aBuffer, from, bytes);
* aBuffer += iAttributes.iStride;
* from += bitmap->DataStride();
* }
* // ...
* return ETrue; // to continue getting ProduceNewFrameL callbacks
* };
*
* MAlfBufferProvider::TBufferCreationAttributes& BufferAttributes() { return iAttributes };
*
* void ContextAboutToSuspend() {};
* void OnActivation() {};
* // ...
* }
*
* Example2:
* // client may want or need to adjust ProduceNewFrameL-callbacks inverval
* class CMyClass: public CActive, public MAlfBufferProvider
* {
* private:
* CAlfCompositionPixelSource* iAlfCompositionPixelSource;
* MAlfBufferProvider::TBufferCreationAttributes iAttributes;
* TBool iDrawNext;
* TTimeIntervalMicroSeconds32 iWaitTime;
* RTimer iTimer;
* public:
*
* CMyClass() {}
*
* ConstructL()
* {
* // ...
* iDrawNext = ETrue;
* iWaitTime = 25*1000;
* // ...
* }
*
* void RunL()
* {
* if( iStatus.Int() != KErrNone )
* {
* iDrawNext = ETrue;
* iAlfCompositionPixelSource->ActivateL();
* }
* }
* // ...
* TBool ProduceNewFrameL(const TRegion& aVisibleRegion, TUint8*& aBuffer)
* {
* if( iDrawNext )
* {
* iDrawNext = EFalse;
* }
* else
* {
* iTimer.After( iStatus, iWaitTime );
* return EFalse;
* }
* // ...
* // copy pixel data to aBuffer
* // ...
* return ETrue; // to continue getting ProduceNewFrameL callbacks
* };
* // ...
* }
*
* Example3:
* // API can be used withou the actual window
* class CMyClass: public CBase, public MAlfBufferProvider
* {
* private:
* CAlfCompositionPixelSource* iAlfCompositionPixelSource;
* MAlfBufferProvider::TBufferCreationAttributes iAttributes;
* public:
*
* CMyClass() {}
*
* ConstructL()
* {
* // ...
* iAttributes.iWidth = width;
* iAttributes.iHeight = height;
* iAttributes.iFormat = MAlfBufferProvider::ESourceFormatARGB_8888;
* iAttributes.iStride = iAttributes.iWidth * 4;
* iAttributes.iAlignment = 32;
*
* iAlfCompositionPixelSource = CAlfCompositionPixelSource::NewL(*this, NULL);
* iAlfCompositionPixelSource->SetExtent(TRect(0,0,600,300),0,1);
* iAlfCompositionPixelSource->iActivateL();
* }
* // ...
* TBool ProduceNewFrameL(const TRegion& aVisibleRegion, TUint8*& aBuffer)
* {
* // ...
* // copy pixel data to aBuffer
* // ...
* return ETrue; // to continue getting ProduceNewFrameL callbacks
* };
* // ...
*
* // Notice: When activating Composition pixel source after being suspended, SetExtent needs to be called again.
* void ContinueAfterSuspendL()
* {
* iAlfCompositionPixelSource->SetExtent(TRect(0,0,600,300),0,1);
* iAlfCompositionPixelSource->iActivateL();
* }
* }
**/
class CAlfCompositionPixelSource: public CAlfCompositionSource
{
public:
/**
* Constructor
**/
IMPORT_C static CAlfCompositionPixelSource* NewL(MAlfBufferProvider& aProvider, RWindow* aWindow = NULL);
/**
* Activate drawing for the first time or continue drawing if it is being paused or suspended
**/
IMPORT_C void ActivateL();
/**
* Suspend drawing
**/
IMPORT_C void Suspend();
IMPORT_C ~CAlfCompositionPixelSource();
/**
* From base class
* Defines extent of the composition target on a defined screen
* Does not affect on hit testing, keyboard focus etc. but is just additional information for composition
**/
IMPORT_C TInt SetExtent(const TRect& aRect, TInt aScreen);
/**
* Internal
* For drawing one frame
**/
TBool DrawFrameL(TRequestStatus& aStatus, TInt aBufferNumber = 0);
protected:
/**
* Internal
* From base class
**/
void HandleEventL(TInt aEventType, TAny* aEventData);
private: // Internal / utils
void ConstructL(MAlfBufferProvider& aProvider, RWindow* aWindow);
void ConstructSurfaceL(MAlfBufferProvider::TBufferCreationAttributes& aCreationAttributes);
void FreeSurface();
TUint8* Buffer(TInt aBufferNumber);
private: // data
class CAlfCompositionPixelSourceData;
CAlfCompositionPixelSourceData* iData;
};
#endif // #define __ALFCOMPOSITIONCLIENT_H__