/*
* Copyright (c) 2004-2005 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 "CMIDImageLoader.h"
#include <jni.h>

const TInt KInitialBufferSize = 1024*32;    // 32kb

//
//
//
class CAsyncDecodeEvent : public CJavaEvent<CMIDImageLoader>
{
public:
    CAsyncDecodeEvent(jmethodID aMethod);

    void SetResult(jint aResult);
    void Dispatch(JNIEnv& aJni);

private:
    jmethodID   iMethod;
    jint        iResult;
};

CAsyncDecodeEvent::CAsyncDecodeEvent(jmethodID aMethod)
        : iMethod(aMethod)
        , iResult(KErrGeneral)
{
}

void CAsyncDecodeEvent::SetResult(jint aResult)
{
    iResult=aResult;
}

void CAsyncDecodeEvent::Dispatch(JNIEnv& aJni)
{
    jobject peerObject = aJni.NewLocalRef(Object().Peer());
    if (peerObject)
    {
        aJni.CallVoidMethod(peerObject, iMethod, iResult);
        aJni.DeleteLocalRef(peerObject);
    }
}

TInt CMIDImageLoader::New(JNIEnv& aJni, jobject aPeer, TJavaEventServer aServer, jint aToolkitHandle)
{
    TInt handle;
    TRAP(handle,
         TConstructor self(aJni);
         self->ConstructJniL(aJni,aPeer,aServer, JavaUnhand<CMIDToolkit>(aToolkitHandle));
         handle = self.GetHandle();
        );
    return handle;
}

CMIDImageLoader::CMIDImageLoader()
{
}

CMIDImageLoader::~CMIDImageLoader()
{
    ASSERT(NULL == iNotifyEvent);
    ASSERT(NULL == iDecoder);
    ASSERT(NULL == iBufferArray);
}

void CMIDImageLoader::ConstructJniL(JNIEnv& aJni, jobject aPeer, TJavaEventServer aServer, CMIDToolkit* aToolkit)
{
    CJavaEventSourceBase::ConstructL(aJni, aPeer, aServer);
    iBufferArray  = (TUint8*)User::AllocL(KInitialBufferSize);
    iBufferLength = KInitialBufferSize;
    iBufferCount  = 0;
    User::LeaveIfError(ExecuteTrap(InvokeConstructSvrL, this, aToolkit));
}

void CMIDImageLoader::InvokeConstructSvrL(CMIDImageLoader* aLoader, CMIDToolkit* aToolkit)
{
    aLoader->ConstructSvrL(*aToolkit);
}

void CMIDImageLoader::ConstructSvrL(CMIDToolkit& aToolkit)
{
    iDecoder = aToolkit.GraphicsFactory().NewImageDecoderL();
}

void CMIDImageLoader::FinalizeSvr()
{
    if (iDecoder)
    {
        iDecoder->Dispose();
        iDecoder = NULL;
    }
}

void CMIDImageLoader::FinalizeJni(JNIEnv& /*aJni*/)
{
    delete iNotifyEvent;
    iNotifyEvent = NULL;
    User::Free(iBufferArray);
    iBufferArray = NULL;
}

/**
 * Append data to decoder buffer. Currently we just extract the bytes from the java array
 * and do an ipc here for each block. We could choose buffer up client side until the buffer
 * is full and then flush. This would require keeping track of the byte count.
 */
TInt CMIDImageLoader::AppendJni(JNIEnv& aJni, jbyteArray aByteArray, jint aByteOffset, jint aByteCount)
{
    if (iBufferLength < aByteCount)
    {
        TUint8* array  = (TUint8*)User::ReAlloc(iBufferArray, aByteCount);
        if (array)
        {
            iBufferArray  = array;
            iBufferLength = aByteCount;
        }
        else
        {
            return KErrNoMemory;
        }
    }

    ASSERT(iBufferLength >= aByteCount);

    aJni.GetByteArrayRegion(aByteArray, aByteOffset, aByteCount, (jbyte*)(iBufferArray));

    //
    // No deferred flush yet.
    //
    ASSERT(iBufferCount == 0);
    iBufferCount = aByteCount;
    TInt err = ExecuteTrap(InvokeAppendSvrL, this);
    iBufferCount = 0;

    return err;
}

void CMIDImageLoader::AppendSvrL()
{
    TPtrC8 bufferPtr(iBufferArray, iBufferCount);
    iDecoder->AppendL(bufferPtr);
}

void CMIDImageLoader::InvokeAppendSvrL(CMIDImageLoader* aLoader)
{
    aLoader->AppendSvrL();
}

void CMIDImageLoader::InvokeAsyncDecodeSvrL(CMIDImageLoader* aLoader)
{
    aLoader->AsyncDecodeSvrL();
}

/**
 * Initiate asynchronous decode.
 */
TInt CMIDImageLoader::AsyncDecodeJni(JNIEnv& aJni)
{
    jobject peerObj = aJni.NewLocalRef(Peer());

    if (peerObj)
    {
        jclass    clazz  = aJni.GetObjectClass(peerObj);
        jmethodID method = aJni.GetMethodID(clazz,"signal","(I)V");
        aJni.DeleteLocalRef(peerObj);
        if (!iNotifyEvent)
        {
            iNotifyEvent = new CAsyncDecodeEvent(method);
        }
        if (!iNotifyEvent)
        {
            return KErrNoMemory;
        }
        return ExecuteTrap(InvokeAsyncDecodeSvrL, this);
    }
    return -1;
}

void CMIDImageLoader::AsyncDecodeSvrL()
{
    iDecoder->DecodeL(this);
}

/**
 *
 */
MMIDImageDecoder* CMIDImageLoader::Decoder()
{
    return iDecoder;
}

void CMIDImageLoader::DecodeComplete(TInt aError)
{
    CAsyncDecodeEvent* event = iNotifyEvent;
    iNotifyEvent = NULL;
    ASSERT(event);
    event->SetResult(aError);
    PostEvent(event,CJavaEventBase::ENotifyPriority);
}