/*

* 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:   Handles serializing of data and sending it to alf streamer server.

*

*/

// Maybe...

// - EAlfCancelClippingRect is many times followed by EAlfSetClippingRect. Could the EAlfCancelClippingRect be ignored?

// - EAlfSetBrushStyle (etc. other non drawing commands) are followed by AlfReset and no drawing is done. Could the Set

//   commands be ignored.

// Can ignoring be done faster than executing useless commands?

#include <barsread.h>

#include <barsc.h>

#include <e32std.h>

#include <alfstreamerconsts.h>

#include <huiwscanvascommands.h>

#include <uiacceltk/HuiUtil.h>

#include <alfdecoderserverclient.h>

#include <alflogger.h>

#include "alf/alfcompositionclient.h"

#include "alfrssendbuffer.h"

#include "alfrenderstage.h"

#include "alfcommanddebug.h"

#include <alfnonsupportedwscommands.rsg>

#include <data_caging_path_literals.hrh>

_LIT( KRendererSupportedCommands,"alfnonsupportedwscommands.rsc" );

const TInt KFrameHeaderSizeWhenCacheChunks = 500;

const TInt KFrameHeaderSize = 5000;

const TInt KFrameOffsetTemplate = 12345678;

const TInt KCacheChunkMinSize = 50000;

const TUint8 KDivisibleByX = 8;

const TInt KWindowFrameHeader1 = 6; // bytes

const TInt KWindowFrameHeader2 = 18 + 10; // bytes // TP +10 

const TInt KAllRenderersMask = 63;

const TInt KPossiblePerformanceProblemInWindow = 64;

const TInt KPossiblePerformanceProblemInWindowThreshold = 1000;

enum TPatternSearchStates

    {

    ESeekSetClippingRegion = 0,

    ESeekBitBlit = 1,

    ESeekResetClipping = 2,

    ESeekBrushStyle1 = 3,

    ESeekBrushStyle2 = 4

    };

#ifdef _OPTIMIZE_WS_COMMANDS_ADVANCED_

const TInt TSearchPatternBitBlit[2][3] = { 

                // Search command           // state                // alternative command in this state

                { EAlfSetClippingRegion,    ESeekSetClippingRegion, KErrNotFound },

                { EAlfBitBltMasked,         ESeekBitBlit,           EAlfBitBltRect }};

#else

const TInt TSearchPatternBitBlit[5][3] = { 

				// Search command			// state				// alternative command in this state

        		{ EAlfSetClippingRegion, 	ESeekSetClippingRegion, KErrNotFound },

        		{ EAlfBitBltMasked, 		ESeekBitBlit, 			EAlfBitBltRect },

        		{ EAlfResetClippingRegion, 	ESeekResetClipping, 	KErrNotFound },

        		{ EAlfSetBrushStyle, 		ESeekBrushStyle1, 		KErrNotFound },

        		{ EAlfSetBrushStyle, 		ESeekBrushStyle2, 		EAlfSetPenStyle} };

#endif

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

// class CAlfObserver

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

//

NONSHARABLE_CLASS(CAlfObserver):public CActive

    {

    public:

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

        // SetL

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

        //

        static void SetL(CAlfRsSendBuffer* aHost, TBool aStartServer )

             {

             CAlfObserver* me = new (ELeave)  CAlfObserver(aHost, aStartServer);

             me->SetActive();

             // breahe one cycle to allow wserv kick its server object alive

             TRequestStatus* status = &me->iStatus; 

             User::RequestComplete(status, KErrNone);   

             }

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

        // NewL

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

        //

        CAlfObserver(CAlfRsSendBuffer* aHost, TBool aStartServer):CActive(2*EPriorityHigh),

            iHost(aHost), iStartServer(aStartServer),  iBreathe(ETrue)

            {

            CActiveScheduler::Add(this);

            iTimer.CreateLocal();

            }

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

        // RunL

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

        //

        void RunL()

            {

            if (iBreathe && iStartServer)

                {

                iBreathe = EFalse;

                SetActive();

                TRAPD(err, AlfServerStarter::StartL(iStatus, EFalse));

                if (err)

                    {

                    // Important, and thus enabled even in release builds. Other option would be letting leave to fall through 

                    // render stage stack and let window server panic the boot

                    RDebug::Print(_L("********* Error occurred when starting alf: %d"),err);

                    }

                else

                    {

                    return;

                    }

                }

            else

                {

                if( !iHost->ConnectL() ) // if connecting fails, try again a bit later

                    {

                    SetActive();

                    if( iStartServer )

                        {

                        iTimer.After( iStatus, 250000); // primary display is more important

                        }

                    else

                        {

                        iTimer.After( iStatus, 1000000);

                        }

                    }

                else

                    {

                    __ALFLOGSTRING("********************FLUSHING WSERV");    

					TRAP_IGNORE(iHost->PrepareBufferL());

					TRAP_IGNORE(iHost->SendL( NULL ));

                    iTimer.Close();

                    delete this;

                    }

                }

            }

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

        // DoCancel

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

        //

        void DoCancel()

            {

            // not applicable atm

            }

    private: // Data

        CAlfRsSendBuffer* iHost;

        TBool iStartServer;

        TBool iBreathe;

        RTimer iTimer;

    };

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

// doFlushBuffer

// Local function

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

//

TInt doFlushBuffer( TAny* aPtr )

    {

    ((CAlfRsSendBuffer*)aPtr)->FlushBuffer();

    return 0; // must return something

    }

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

// NewL

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

//

CAlfRsSendBuffer* CAlfRsSendBuffer::NewL(CAlfRenderStage& aParent, TInt aScreenNumber )

	{

	CAlfRsSendBuffer* self = new(ELeave) CAlfRsSendBuffer( aParent, aScreenNumber );

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

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

// Destructor

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

//

CAlfRsSendBuffer::~CAlfRsSendBuffer()

    {

    if ( iAlfBridgerClient )

        {

        iAlfBridgerClient->Close();

        delete iAlfBridgerClient;

        iAlfBridgerClient = NULL;

        delete iAlfCompositionCntrlClient;

        }

#ifdef _OLD_STREAM    

    if ( iBufStream )

        {

        iBufStream->Close();

        delete iBufStream;

        iBufStream = NULL;

        }

#endif    

    iChunk.Close();

    }

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

// ConstructL

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

//

void CAlfRsSendBuffer::ConstructL()

    {

    // If this is not the primary screen (0) do not send any commands to Alf server

    iDisabled = (iScreenNumber != 0);

    ReadNonSupportedCommandsL();

    iChunkInUse = 0;

    iBooting = ETrue;

#ifdef _ALF_PRINT_WS_COMMANDS_

    iLog = 0;

    iCommandDebugger = CAlfCommandDebug::NewL();

#endif

    TBool runInsideWserv = ETrue; // EFalse;

    if( runInsideWserv )

        {

        TBool startServer = ETrue;

        if (iScreenNumber != 0) // we need one instance only

            {

            startServer = EFalse;

            }

        CAlfObserver::SetL(this, startServer);

        }

    else

        {

        CAlfObserver::SetL(this, EFalse);

        }

    MAlfCompositionController* compcntrl = (MAlfCompositionController*)iParent.ResolveObjectInterface(KAlfCompositionControllerIfUid);

    if (compcntrl)

      {

      compcntrl->AlfBridgeCallback(MAlfBridge::EAlfBridgeCreated, (MAlfBridge*)this);  

      }

    }

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

// ReadNonSupportedCommandsL

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

//

void CAlfRsSendBuffer::ReadNonSupportedCommandsL()

    {

    RFs fs;

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

    CleanupClosePushL(fs);

    RResourceFile resFile;    

    TInt result;

    // resolve the absolute path

    // Read unsupported command resource

    TFileName resourceFileName;

    TPtrC driveLetter = TParsePtrC( RProcess().FileName() ).Drive();

    resourceFileName.Copy( driveLetter );  

    resourceFileName.Append( KDC_ECOM_RESOURCE_DIR );

    resourceFileName.Append( KRendererSupportedCommands );

    TRAP( result, resFile.OpenL(fs,resourceFileName); );

    if ( result == KErrNone )

        {

        CleanupClosePushL(resFile);

        resFile.ConfirmSignatureL(0); // offset value.

        TInt resId = R_ALF_NON_SUPPORTED_COMMANDS_ARRAY;

        HBufC8* readData = resFile.AllocReadL(resId);

        // now first get rid of RResourceFile and RFs as they are not needed any more

        CleanupStack::PopAndDestroy(); // resFile

        CleanupStack::PopAndDestroy(); // fs

        CleanupStack::PushL(readData);

        // now parse it and store the values in cmdTextArray

        TResourceReader reader;

        reader.SetBuffer(readData);

        const TInt count = reader.ReadInt16();

        TInt8 command;

        TInt8 value;

        TInt nonSupportedParameterCount = 0;

        // resource file contains only non supported commands by renderers. Patch them to the iSupportedCommands

        TInt supportedParameterIndex = 0;

        for ( TInt i = 0; i < count ; i++ )

            {

            command = reader.ReadInt8();

            value = ConvertToBitsL( 7, &reader );

            nonSupportedParameterCount = reader.ReadInt16();

            if ( nonSupportedParameterCount > 0 )

                {

                iSupportedCommandParameters[command][0] = supportedParameterIndex;

                for ( TInt l = 0 ; l < nonSupportedParameterCount ; l ++ )

                    {

                    TInt8 parameterValue = reader.ReadInt8();

                    iSupportedParameters[supportedParameterIndex][0] = parameterValue;

                    TInt8 value2 = ConvertToBitsL( 6, &reader  );

                    iSupportedParameters[supportedParameterIndex][1] = value2;

                    supportedParameterIndex++;

                    }

                iSupportedCommandParameters[command][1] = supportedParameterIndex;

                }

            iNonSupportedCommands[command] = value;

            }

        CleanupStack::PopAndDestroy(readData);

        }

    else

        {

        __ALFLOGSTRING1("CAlfRsSendBuffer::ConstructL - WARNING! Failed to read unsupported commands from resource file: %S! Error code:st %d.", &resourceFileName );

        CleanupStack::PopAndDestroy(); // fs

        }

    }

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

// ConvertToBitsL

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

//

TUint8 CAlfRsSendBuffer::ConvertToBitsL( TInt aCount, TResourceReader* aReader )

    {

#ifdef _DEBUG    

    if ( aCount > 7 )

        {

        __ALFLOGSTRING("CAlfRsSendBuffer::ConvertToBitsL - Can convert only 7 sequantial bytes to one byte");

        USER_INVARIANT(); //

        }

#endif    

    TInt8 value = 0;

    TInt8 notSupported[7];

    aReader->Read( notSupported, aCount );

    TUint8 mask = 1;

    for (TInt j = 0; j < aCount ; j ++)

        {

        if ( notSupported[j] ){ value |= mask ; }

        mask = mask << 1;

        }

    return value;

    }

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

// RunL

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

//

void CAlfRsSendBuffer::RunL()

    {

    switch( iState )

        {

        case EWaitingAck:

            {

            if ( iStatus == EAlfBridgerAsyncronousData || iStatus < 0 )

                {

                TInt chunkIndex = 0;

                // The following is written to the last created chunk.

                TInt cacheChunkCount = iCacheChunks.Count();

                if ( cacheChunkCount > 0 )

                    {

                    // request destruction of all temporary chunks

                    while ( chunkIndex < cacheChunkCount )

                        {

                        WriteInt8L( EAlfDestroyChunk );

                        WriteInt8L( 0 ); // screen number, not used.

                        WriteInt32L( iCacheChunks[chunkIndex].Handle() );

                        WriteInt8L( EAlfCommandEndMarker );

                        chunkIndex++;

                        }

                    if ( !iBooting )

                        {

                        // This is not necessary in the first boot, because jump 

                        // request has been already created in PrepareBufferL

                        JumpToAnotherChunkL( 0, iPrimaryChunkMaxSize );

                        OpenPrimaryChunkForWritingL();

                        SeekL(0); // rewind stream to the beginning

                        WriteInt8L( EAlfCommandEndMarker );

                        CommitL();

                        FlushBuffer();

                        }

                    // destroy renderstage side handles to the chunk. alfhierarchy

                    // has still open handles for a while.

                    while( iCacheChunks.Count() )    

                        {

                        iCacheChunks[ 0 ].Close();

                        iCacheChunks.Remove( 0 );

                        }

                    }

                iUsedChunkMaxSize = iPrimaryChunkMaxSize - sizeof( TChunkHeader);

                iChunkInUse = 0;

                iBooting = EFalse; // alf has acknowledged the first frame

                iParent.EndCallBack( iQuedStatus );

                iState = EIdle;

                }

            break;

            }

        case EWaitingHandle:

            {

            break;

            }

        case EIdle:

            {

            break;

            }

        default:;

        }

    }

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

// DoCancel

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

//

void CAlfRsSendBuffer::DoCancel()

    {

    // TODO

    }

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

// WriteFlagsL

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

//

void CAlfRsSendBuffer::WriteFlagsL( )

    {

    if (iDisabled) // return if this send buffer is not in use

        {

        return;

        }

    // space has been reserved for us

    WriteInt8L( EAlfFrameFlags ); 

    WriteInt32L( iFlags);

    WriteInt8L( EAlfCommandEndMarker );

    }

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

// WriteCommandL

// writes 1 TInt value to the stream

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

//

void CAlfRsSendBuffer::WriteCommandL( const TUint8& aCommand, TInt aSize )

    {

    if (iDisabled) // return if this send buffer is not in use

        {

        return;

        }

    if ( 

#ifdef _OLD_STREAM

            iBufStream->Sink() && 

#endif

            aCommand == EAlfPacketReady )

        {

        iReceivingDrawingCommands = EFalse;

        // if offscreen content has not been flushed, we'll keep the frame in not completed state.

        // it will be delivered to CHuiCanvasVisual, but not processed until finished packet arrives.

        // make sure, that frame flags (iFlags) follow this command.

        }

    if (! InitCommandL( aCommand, aSize)){ return;}

#ifdef _ALF_PRINT_WS_COMMANDS_  

    if ( !iReceivingDrawingCommands )

        {

        aSize += sizeof(TUint8);

        }

    iCommandDebugger->SetDescriptionAndSize( aCommand, aSize, R_ALF_COMMAND_DESCRIPTION_ARRAY  );

    iCommandDebugger->Print();

#endif   

    if ( !iReceivingDrawingCommands )

        {

        WriteInt8L( EAlfCommandEndMarker ); 

        }

    if ( aCommand == EAlfPacketReady )

        {

        iReceivingDrawingCommands = EFalse;

        iWrappingFrame = EFalse;

#ifdef _ALF_PRINT_WS_COMMANDS_    

        iCommandDebugger->PrintStatistic();

        iCommandDebugger->EndFrame();

#endif

        }

    }

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

// WriteIntsL

// writes aCount amount of variables to the stream and updates stream index.

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

//

// @todo Reference to Tint parameter was removed, because it did not pass armv5 compiler

void CAlfRsSendBuffer::WriteIntsL( const TUint8& aCommand, TInt aCount, TRefByValue<const TInt> aFirst,... )

    {

    if (iDisabled) // return if this send buffer is not in use

        {

        return;

        }

    const TInt size = sizeof(TInt32) * aCount;

    if (! InitCommandL( aCommand, size )){ return;}

#ifdef _ALF_PRINT_WS_COMMANDS_    

    iCommandDebugger->SetDescriptionAndSize( aCommand, size, R_ALF_COMMAND_DESCRIPTION_ARRAY  );