/*
* 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:   Screen buffer implementation
*
*/



#include <coemain.h>

#include "alflogger.h"
#include "alf/alfenv.h"
#include "alfclient.h"
#include "alf/alfstatic.h"
#include "alf/alfconstants.h"
#include "alfuids.h"
#include "alf/alfscreenbuffer.h"
#include "alf/alfsymbiansbdrawer.h"

#include <uiacceltk/HuiUtil.h>

// *** class CAlfScreenBufferEventFetcher

NONSHARABLE_CLASS(CAlfScreenBufferEventFetcher): public CActive
    {
public: // Struct
    
    struct TScreenBufferInfo
    	{
    	MAlfScreenBufferObserver* iObserver; // Observer for this screen buffer. Not owned
    	TUid iBufferUid; // Uid of the buffer to be observed.
    	TInt iPriority;  // Priority of the buffer. Not yet used.
    	TInt iBitmapHandle; // Handle to the shared CFbsBitmap that contains the buffer.
    	TInt iMaskHandle; // Mask handle
    	TRect iLastDisplayRect; // Display rect
    	TRect iLastDirtyRect; // Dirty rect  	
    	};

    
public: // New methods

    CAlfScreenBufferEventFetcher(RAlfClient& aClient, MAlfScreenBufferObserver& aScreenBufferObs)
        :CActive(CActive::EPriorityHigh), iClient(aClient), iEventAsDescriptor(iEvent)        
        {
        CAlfScreenBufferEventFetcher::TScreenBufferInfo info = {&aScreenBufferObs, KNullUid, 0, 0, 0, TRect(), TRect()};
        iBufferInfo = info;
        CActiveScheduler::Add(this);
        }

    ~CAlfScreenBufferEventFetcher()
        {
        Cancel();
        }

	// Request a new event
	void RequestBufferEvent()       
        {
        if(!IsActive())
            {
            SetActive();
        	iEvent.iBufferUid = iBufferInfo.iBufferUid;
        	iEvent.iEventId = 0;
        	iEvent.iDisplayRect = TRect();
        	iEvent.iDirtyRect = TRect();
    		iClient.SendAsyncCmd(EAlfSBufRequestEvent, iEventAsDescriptor, iStatus); 
            }
        }
        
    // Return buffer info    
    TScreenBufferInfo& ScreenBufferInfo()
    	{
    	return(iBufferInfo);
    	}

private: // From CActive
    
    void RunL()
        {
        if(iStatus.Int() != KErrNone)
           	{ 
           	USER_INVARIANT();            	
           	}
          	
        // Issue a new event request first             
        TAlfScreenBufferEvent event = iEvent;
		RequestBufferEvent();   
		
		// Handle event
		
		if (event.iEventId == MAlfScreenBufferObserver::ENone) // Buffer complete event    
			{
        	if (iBufferInfo.iObserver->BufferComplete(event.iBufferUid, event.iDisplayRect, event.iDirtyRect))
        		{
        		// Request next  buffer automatically
   			    TUid uidEvent = event.iBufferUid; 
    			TPckg<TUid> eventPckg(uidEvent);
    			iClient.SendSyncCmd(EAlfSBufRequestNextBuffer, eventPckg);
        		}
			}
		else     
			{
			if (event.iEventId == MAlfScreenBufferObserver::ECreated)
				{
		   		// Add this buffer observer again to the array in Alf Server to get valid bitmap handles in return. 
    			TAlfScreenBufferBitmaps addObserverEvent = {iBufferInfo.iBufferUid, iBufferInfo.iPriority, NULL, NULL}; 
    			TPckg<TAlfScreenBufferBitmaps> eventPckg(addObserverEvent);
    			iClient.SendSyncCmd(EAlfSBufAddObserver, eventPckg);
    			
    			// Update bitmap handles
    			iBufferInfo.iBitmapHandle = addObserverEvent.iBitmapHandle; 
    			iBufferInfo.iMaskHandle = addObserverEvent.iMaskHandle;			
				}
			else if (event.iEventId == MAlfScreenBufferObserver::EDeleted)
				{
    			// Invalidate bitmap handles
    			iBufferInfo.iBitmapHandle = NULL; 
    			iBufferInfo.iMaskHandle = NULL;							
				}
    			
        	iBufferInfo.iObserver->HandleScreenBufferEvent(event.iBufferUid, event.iEventId);			
			}
        }
        
    void DoCancel()
        {
    	// Remove this AO from the observer array in Alf Server
    	TAlfScreenBufferBitmaps event = {iBufferInfo.iBufferUid, 0, 0}; 
    	TPckg<TAlfScreenBufferBitmaps> eventPckg(event);
    	iClient.SendSyncCmd(EAlfSBufRemoveObserver, eventPckg);
        }

    TInt RunError(TInt /*aError*/)
        {
        // Ignore error
        return KErrNone;
        }

private: // Data

    RAlfClient& iClient;
    TAlfScreenBufferEvent iEvent; // Event data for pending buffer event. 
    TPckg<TAlfScreenBufferEvent> iEventAsDescriptor;
    
    CAlfScreenBufferEventFetcher::TScreenBufferInfo iBufferInfo; // Buffer information
    };



// *** Array item for CAlfScreenBuffer

struct TAlfScreenBufferHandlerItem
	{
	TAlfScreenBufferHandlerItem( TInt aId, CAlfScreenBufferEventFetcher* aAoPtr) 
		:iId( aId ), iAoPtr( aAoPtr )
		{};
	TInt iId; // Buffer uid
	CAlfScreenBufferEventFetcher* iAoPtr; // Pointer to the active object that handles buffer events. Owned.
	};
		

// *** Private data for CAlfScreenBuffer

NONSHARABLE_CLASS(CAlfScreenBuffer::CPrivateData):public CBase
    {
    public:
    ~CPrivateData()
        {
        iScreenBufferHandlers.Close();
        if (iIsAlfEnvOwned)
        	{
        	delete(iEnv);
        	}
        }
        
    CAlfEnv* iEnv;   
    TBool iIsAlfEnvOwned; 
    RArray<TAlfScreenBufferHandlerItem> iScreenBufferHandlers; // List of all buffer observer Active Objects
    };


// *** class CAlfScreenBuffer

EXPORT_C CAlfScreenBuffer* CAlfScreenBuffer::NewL()
	{
	// Create own aAlf env if it does not exist.
	TBool isAlfEnvOwned = EFalse; 
	CAlfEnv* env = CAlfEnv::Static();
	if (!env)
		{
		isAlfEnvOwned = ETrue;
		env = CAlfEnv::NewL();
		}
	
	// Create object	
    CAlfScreenBuffer* self = new( ELeave ) CAlfScreenBuffer();
    CleanupStack::PushL( self );        
    self->ConstructL(env, isAlfEnvOwned);
    CleanupStack::Pop( self );
    return self;	
	};

EXPORT_C CAlfScreenBuffer* CAlfScreenBuffer::NewL(CAlfEnv& aEnv)
	{
    CAlfScreenBuffer* self = new( ELeave ) CAlfScreenBuffer();
    CleanupStack::PushL( self );        
    self->ConstructL(&aEnv, EFalse);
    CleanupStack::Pop( self );
    return self;	
	};


CAlfScreenBuffer::CAlfScreenBuffer()
	{	
	}

// @deprecated
EXPORT_C CAlfScreenBuffer::CAlfScreenBuffer(CAlfEnv& /*aEnv*/) 
	{	
	}


EXPORT_C CAlfScreenBuffer::~CAlfScreenBuffer()
	{
    for (TInt i = iData->iScreenBufferHandlers.Count()-1; i >= 0 ; i--)
   		{
        RemoveObserver(iData->iScreenBufferHandlers[i].iAoPtr->ScreenBufferInfo().iBufferUid);
        }

    delete iData;
	}

// @deprecated
EXPORT_C void CAlfScreenBuffer::ConstructL()
    {
    // Not used, preserved for BC
    }
    
void CAlfScreenBuffer::ConstructL(CAlfEnv* aEnv, TBool aIsAlfEnvOwned)
    {
    //@todo : should I check that only one instance is created per alf client? 
    // Create private data
    iData = new (ELeave) CPrivateData; 
    iData->iEnv = aEnv;
    iData->iIsAlfEnvOwned = aIsAlfEnvOwned;
    }


EXPORT_C MAlfBufferDrawer* CAlfScreenBuffer::GetDrawingInterface(TUid aInterfaceUid, TUid aBufferUid)
	{
	// Symbian IF
	if (aInterfaceUid == KAlfSymbianBufferDrawerUid)
	    {
	    TAlfScreenBufferHandlerItem item( aBufferUid.iUid, NULL );
	    TInt index;
	    if ( iData->iScreenBufferHandlers.FindInSignedKeyOrder( item, index ) == KErrNone )
		    {
		    if (iData->iScreenBufferHandlers[index].iAoPtr->ScreenBufferInfo().iBitmapHandle)
		    	{
       	    	CAlfSymbianBufferDrawer* drawer = NULL;
       	    	TRAPD(err, drawer = CAlfSymbianBufferDrawer::NewL());
       	    	if (!err)
       	    		{
                	TRAP(err,drawer->SetBufferL(
                		iData->iScreenBufferHandlers[index].iAoPtr->ScreenBufferInfo().iBitmapHandle,
                		iData->iScreenBufferHandlers[index].iAoPtr->ScreenBufferInfo().iMaskHandle));
                	if (err)
                		{
                		delete drawer;
                		return NULL;
                		}
                	else
                		{
                		return drawer;
                		}	
            		}   
		    	}
	        }
	    }
	return NULL;	            
	}
	

EXPORT_C MAlfBufferGc* CAlfScreenBuffer::GetGraphicsContext(TUid /*aInterfaceUid*/, TUid /*aBufferUid*/)  
	{	
	return ((MAlfBufferGc*)NULL);
	}
      
        
EXPORT_C void CAlfScreenBuffer::AddObserverL(TUid aBufferId, MAlfScreenBufferObserver* aObserver, TInt aPriority) 
	{
	AddObserverL(aBufferId, CAlfScreenBuffer::EFlagNone, aObserver, aPriority); 
	}

	
EXPORT_C void CAlfScreenBuffer::AddObserverL(TUid aBufferId, TUint aFlags, MAlfScreenBufferObserver* aObserver, TInt aPriority) 
	{    
    // Add to the observer array in Alf Server, and get bitmap handles in return. 
    TAlfScreenBufferBitmaps event = {aBufferId, aPriority, aFlags, NULL, NULL}; 
    TPckg<TAlfScreenBufferBitmaps> eventPckg(event);
    User::LeaveIfError(iData->iEnv->Client().SendSyncCmd(EAlfSBufAddObserver, eventPckg)); 
    
  	// Append the handler to the client list
   	CAlfScreenBufferEventFetcher* eventFetcher =  new (ELeave) CAlfScreenBufferEventFetcher(iData->iEnv->Client(), *aObserver);
   	CAlfScreenBufferEventFetcher::TScreenBufferInfo info = {eventFetcher->ScreenBufferInfo().iObserver, event.iBufferUid, aPriority, event.iBitmapHandle, event.iMaskHandle, TRect(), TRect()};
   	eventFetcher->ScreenBufferInfo() = info;    
   	// Transfers ownership of eventFetcher
    TInt err = iData->iScreenBufferHandlers.InsertInUnsignedKeyOrder(TAlfScreenBufferHandlerItem(aBufferId.iUid, eventFetcher)); 

    if (err)
    	{
    	delete eventFetcher;
    	RemoveObserver(aBufferId); 
    	User::Leave(err);
    	}
    else
    	{
    	// Start observing any event 
    	eventFetcher->RequestBufferEvent(); 
    	}	
	}
	
	
// Note: This can be also called to already removed observers. In that case it has no effect. 
EXPORT_C void CAlfScreenBuffer::RemoveObserver(TUid aBufferId) 
	{	
    // Remove from the observer array in Alf Server
    TAlfScreenBufferBitmaps event = {aBufferId, 0, 0}; 
    TPckg<TAlfScreenBufferBitmaps> eventPckg(event);
    iData->iEnv->Client().SendSyncCmd(EAlfSBufRemoveObserver, eventPckg); 
     
  	// Remove the handler from the client list
   	TAlfScreenBufferHandlerItem item( aBufferId.iUid, NULL );
	TInt index;
	if ( iData->iScreenBufferHandlers.FindInSignedKeyOrder( item, index ) == KErrNone )
		{
		delete(iData->iScreenBufferHandlers[index].iAoPtr);
		iData->iScreenBufferHandlers.Remove(index);
		}
	}


EXPORT_C void CAlfScreenBuffer::RequestNextBuffer(TUid aBufferId)       
	{
   	TAlfScreenBufferHandlerItem item( aBufferId.iUid, NULL );
	TInt index;
	if ( iData->iScreenBufferHandlers.FindInSignedKeyOrder( item, index ) == KErrNone )
		{
	    TUid event = aBufferId; 
    	TPckg<TUid> eventPckg(event);
    	iData->iEnv->Client().SendSyncCmd(EAlfSBufRequestNextBuffer, eventPckg);
		}
	else
		{
		// I am not a listener for this buffer 
		__ALFLOGSTRING1( "CAlfScreenBuffer::RequestNextBuffer(). Observer not found for uid %x", aBufferId.iUid );
		}
	}
    
    
EXPORT_C void CAlfScreenBuffer::RequestBufferDraw(TUid aBufferId)       
	{
   	TAlfScreenBufferHandlerItem item( aBufferId.iUid, NULL );
	TInt index;
	if ( iData->iScreenBufferHandlers.FindInSignedKeyOrder( item, index ) == KErrNone )
		{
	    TUid event = aBufferId; 
    	TPckg<TUid> eventPckg(event);
    	iData->iEnv->Client().SendSyncCmd(EAlfSBufRequestBufferDraw, eventPckg);
		}
	else
		{
		// I am not a listener for this buffer 
		__ALFLOGSTRING1( "CAlfScreenBuffer::RequestNextBuffer(). Observer not found for uid %x", aBufferId.iUid );
		}
	}