/*

* Copyright (c) 2002 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 "CMIDBuffer.h"

#include "CMIDToolkit.h"

#ifdef RD_JAVA_NGA_ENABLED

#include "monitor.h"

#endif

#include <jdebug.h>

#if defined(_DEBUG) && defined(_TRACE)

#define TRACE(x) RDebug::Print(_L(x))

#else

#define TRACE(x)

#endif

enum TBufferPriority

{

    EBufferPriorityNormal=0,

    EBufferPriorityHigh=20,

    EBufferPriorityRedraw=50,    // == EActivePriorityRedrawEvents

    EBufferPriorityInput=100    // == EActivePriorityWsEvents -> could starve key events.

};

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

//

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

TInt CMIDBuffer::New(JNIEnv& aJni, jobject aPeer, TJavaEventServer aServer)

{

    TInt handle;

    TRAP(handle,

         TConstructor self(aJni);

         self->ConstructJniL(aJni,aPeer,aServer);

         handle = self.GetHandle();

        );

    return handle;

}

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

//

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

CMIDBuffer::CMIDBuffer()

        : iState(EClosed)

{

    iBufferEnd = &iBuffer[ KBufferSize ];

    iRead      = iBuffer;

    iReadEnd   = iBuffer;

    iProcEnd   = iBuffer;

    iState = EComplete;

}

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

//

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

CMIDBuffer::~CMIDBuffer()

{

#ifdef RD_JAVA_NGA_ENABLED

    delete iMonitor;

#endif

}

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

//

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

void CMIDBuffer::RequestProcess(JNIEnv& aEnv, jintArray aBuffer, TInt aCount)

{

    ASSERT(aCount <= Size());

    aEnv.GetIntArrayRegion(aBuffer, 0, aCount, reinterpret_cast<jint*>(iBuffer));

    iRead    = &iBuffer[0];

    iReadEnd = iRead + aCount;

    iProcEnd = iRead;

    iState   = ENewRequest;

#ifdef RD_JAVA_NGA_ENABLED

    TBool async = Execute(CMIDBuffer::DoProcess, this);

    if (async)

    {

        iMonitor->wait();

    }

#else

    ExecuteTrap(CMIDBuffer::DoProcessL, this);

#endif

}

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

//

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

#ifdef RD_JAVA_NGA_ENABLED

TBool CMIDBuffer::DoProcess(CMIDBuffer* aBuffer)

{

    TBool ret = EFalse;

    TRAPD(err, ret = aBuffer->ProcessL());

    if (err != KErrNone)

    {

        ret = EFalse;

    }

    return ret;

}

#else

void CMIDBuffer::DoProcessL(CMIDBuffer* aBuffer)

{

    aBuffer->ProcessL();

}

#endif

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

//

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

void CMIDBuffer::ConstructJniL(JNIEnv& aJni, jobject aPeer, TJavaEventServer aServer)

{

    CJavaEventSourceBase::ConstructL(aJni, aPeer, aServer);

#ifdef RD_JAVA_NGA_ENABLED

    try

    {

        iMonitor = java::util::Monitor::createMonitor();

    }

    catch (std::exception& e)

    {

        User::Leave(KErrNoMemory);

    }

#endif

}

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

//

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

void CMIDBuffer::FinalizeJni(JNIEnv& /*aEnv*/)

{

    ASSERT(iState == EComplete);

    iState = EClosed;

}

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

//

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

#ifdef RD_JAVA_NGA_ENABLED

TBool CMIDBuffer::ProcessL()

#else

void CMIDBuffer::ProcessL()

#endif

{

    iCycles = KTotalCycles;

#ifdef RD_JAVA_NGA_ENABLED

    TBool ret = EFalse;

#endif

    if (!iRead->IsActivate())

    {

        ELOG1(EJavaUI, "Buffer didn't start with header! %X", iRead->Header());

        User::Leave(KErrCorrupt);

    }

    while (iRead < iReadEnd)

    {

        const TMIDBufferOp* blockEnd = NULL;

        // Either setup a new buffer processor, or continue the current

        // processor after a defer, or a leave.

        if (iRead->IsActivate())

        {

            MMIDComponent* component = MIDUnhand<MMIDComponent>(iRead->Header()&0x7fffffff);

            iProcessor = component->Processor();

            // Skip activation header.

            ++iRead;

            const TInt words = *reinterpret_cast<const TInt*>(iRead);

            // Skip activation length

            ++iRead;

            blockEnd = iRead + words;

            iProcEnd = blockEnd;

            ASSERT(iProcEnd <= iReadEnd);

        }

        if (iRead < iReadEnd)

        {

#ifdef RD_JAVA_NGA_ENABLED

            // SYNC or SYNC_RECT op codes are sent to only one object at a time,

            // so it is safe to have only one boolean indicating async operation.

            // Currently only Canvas does asyncronous flush.

            TBool async = iProcessor->ProcessL(iRead, iProcEnd, iCycles, iMonitor);

            ret |= async;

#else

            iProcessor->ProcessL(iRead, iProcEnd, iCycles);

#endif

        }

        // Must have reached end of processor range.

        ASSERT(iRead == iProcEnd);

        // Next command must be an activate or we must have reached

        // the end of the buffer.

        ASSERT((iRead == iReadEnd) || iRead->IsActivate());

    }

    Complete();

#ifdef RD_JAVA_NGA_ENABLED

    return ret;

#endif

}

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

//

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

void CMIDBuffer::Cancel()

{

    //

    // Cancel any async operation a processor may be doing.

    //

    if (iState == EAsyncPending)

    {

        if (iProcessor)

        {

            iProcessor->AbortAsync();

        }

    }

    iState = ECancelled;

}

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

//

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

void CMIDBuffer::Complete()

{

    ASSERT(iRead == iReadEnd);

    iRead    = iBuffer;

    iReadEnd = iBuffer;

    iProcEnd = iBuffer;

    iState   = EComplete;

    iError   = KErrNone;

}

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

//

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

inline TInt CMIDBuffer::Size() const

{

    return iBufferEnd - iBuffer;

}