/*

* Copyright (c) 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:

*

*/

package javax.microedition.lcdui;

import java.io.InputStream;

import com.nokia.mj.impl.rt.legacy.NativeError;

import com.nokia.mj.impl.rt.legacy.ToolkitObserver;

import com.nokia.mj.impl.rt.support.Finalizer;

class ImageLoader

{

    final Toolkit iToolkit;

    private ToolkitObserver iObserver;

    private int iHandle;

    private AsyncCall iStatus;

    private Finalizer mFinalizer;

    ImageLoader(Toolkit aToolkit)

    {

        iToolkit = aToolkit;

        iStatus  = new AsyncCall();

        //

        // Initialize cleanup: Register this object with the finalizer and with

        // the toolkit.

        //

        iObserver = new ToolkitObserver()

        {

            public void destroyNotify()

            {

                dispose();

            }

        };

        iToolkit.addObserver(iObserver);

        mFinalizer = new Finalizer()

        {

            public void finalizeImpl()

            {

                doFinalize();

            }

        };

        synchronized (iToolkit)

        {

            iHandle = NativeError.check(_create(iToolkit.getEventServerHandle(), iToolkit.getHandle()));

        }

    }

    synchronized boolean append(byte[] aByteArray, int aOffset, int aCount)

    {

        if (iHandle == 0)

            return false;

        synchronized (this)

        {

            NativeError.check(_append(iHandle, aByteArray, aOffset, aCount));

        }

        return true;

    }

    /**

     * Blocking decode, streams encoded data to native decoder.

     */

    void decode()

    {

        synchronized (iStatus)

        {

            synchronized (this)

            {

                synchronized (iToolkit)

                {

                    NativeError.check(_decode(iHandle));

                }

                iStatus.request();

            }

            NativeError.check(iStatus.waitForRequest());

        }

    }

    /**

     * WARNING - converters may be disposed on toolkit shutdown.

     * Handle could become invalid unless toolkit is locked down

     * over duration of use.

     */

    int getHandle()

    {

        return iHandle;

    }

    private void doFinalize()

    {

        if (mFinalizer != null)

        {

            registeredFinalize();

            mFinalizer = null;

        }

    }

    private void registeredFinalize()

    {

        dispose();

    }

    synchronized void dispose()

    {

        if (iStatus.isPending())

        {

            iStatus.complete(-1);   // unblock waiting thread(s)

        }

        if (iObserver != null)

        {

            iToolkit.removeObserver(iObserver); // never throws

            iObserver = null;

        }

        final int handle = iHandle;

        iHandle = 0;

        if (0 != handle)

        {

            _destroy(handle);

        }

    }

    /**

     * upcall.

     */

    private void signal(int aError)

    {

        iStatus.complete(aError);

    }

    private native int  _create(int aEventServer, int aToolkitHandle);

    private native void _destroy(int aHandle);

    private native int  _append(int aHandle, byte[] aArray, int aOffset, int aCount);

    private native int  _decode(int aHandle);

}