/*

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

*

*/

package com.nokia.microedition.media.animation;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.util.Enumeration;

import java.util.Hashtable;

import javax.microedition.media.Control;

import javax.microedition.media.MediaException;

import javax.microedition.media.PlayerListener;

import javax.microedition.media.protocol.DataSource;

import org.eclipse.swt.SWT;

import org.eclipse.swt.SWTException;

import org.eclipse.swt.events.PaintEvent;

import org.eclipse.swt.events.PaintListener;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.graphics.ImageData;

import org.eclipse.swt.graphics.ImageLoader;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.widgets.Display;

import com.nokia.microedition.media.BufferDataSource;

import com.nokia.microedition.media.InputStreamDataSource;

import com.nokia.microedition.media.InputStreamSourceStream;

import com.nokia.microedition.media.PlayerBase;

import com.nokia.microedition.media.PlayerListenerImpl;

public class AnimationPlayer extends PlayerBase implements ESWTinitializeListener

{

    // GIF image information, array length will be equal to the number of frames in image

    protected ImageData [] iImageData;

    // number of times we need to repeat the animation

    // by default it's value is one

    private int iTotalLoopCount=1;

    // HashTable object which contains all control related to this player

    private Hashtable iControls= new Hashtable();

    // Current frame index of the Animation file

    private int iFrameIndex;

    // Current Loop Count

    private int iCurrentLoopCount;

    // Indicates if looping indefinitely

    private boolean iRepeatForeEver;

    // Current rate of the player, Used for RateControl

    // Currently only two mode are supported

    // paused and default rate

    private int iCurrentRate;

    // Display object of the eSWT API, creating this object will integrate the current java code with eSWT API.

    private Display iDisplay;

    // Control object of ESWT API, return from LCDUIInvoker.

    org.eclipse.swt.widgets.Control iControl;

    // Following constants are used for comparison of the string, throughout the class

    private static final String ANIMATION_CONTENT_TYPE      = "image/gif";

    private static final String fVideoControl               = VideoControl.class.getName();

    private static final String fFramePositioningControl    = FramePositioningControl.class.getName();

    private static final String fStopTimeControl            = StopTimeControl.class.getName();

    private static final String fRateControl                = RateControl.class.getName();

    /**

     * Default control package. Used when getting control with

     * getControl method which appends default control package if package is

     * not specified.

     */

    private static final String CONTROL_DEFAULT_PACKAGE =

        "javax.microedition.media.control.";

    //For Player listener

    protected PlayerListenerImpl iPlayerListenerImpl;

    //Image to be displayed, an object of eSWT API.

    protected Image iImage;

    // Actual dimension of the image, this should be initialized while creating the player

    // as user can change the size of the image later, in that case too, getSourceheight and getSourceWidth

    // of VideoControl should return the actual width and height of the image

    private Point iSourceDimension;

    // Current dimension of the image, MIDlet developer may change the size of VideoControl

    private Point iCurrentVideoDimension;

    // Total time taken so far to player the animation, it keeps updating as player moves

    private long iMediaTime;

    // Time at which, player should be stopped

    // This will set through StopTimeControl.setTime();

    // otherwise default time is Long.MAX_VALUE

    //private long iStopTime=Long.MAX_VALUE;

    AnimationObserver iAnimationObserver;

    // Display Location, of the image

    // there won't be any use of this, in case of Form(customItem)

    private Point iDisplayLocation= new Point(0,0);

    // in case of Canvas(USE_DIRECT_VIDEO) , it should be invisible by default

    // this is handled in initDisplayMode function, if the mode is USE_DIRECT_VIDEO, we are

    // changing it to false

    private boolean iIsControlVisible=true;

    // we keep the background pixel in it, used while taking the snapshot of the currentframe

    private int iBackgroundPixel=-1;

    // Total duration of the player

    private long iDuration=TIME_UNKNOWN;

    /**

     *

     * @param ds DataSource which contains the data to be displayed

     * @throws MediaException

     */

    public AnimationPlayer(DataSource ds) throws MediaException

    {

        iPlayerListenerImpl= new PlayerListenerImpl(this);

        //TODO check if we can do it in better way

        // this is temporary solution

        // for this I have written two functions getDataSource and getInputStream function

        BufferDataSource bds =(BufferDataSource)ds;

        InputStreamDataSource isds=(InputStreamDataSource)bds.getDataSource();

        InputStreamSourceStream isss=(InputStreamSourceStream)isds.getStreams()[0];

        InputStream is = isss.getInputStream();

        if (is!=null)

        {

            ImageLoader imageLoader= new ImageLoader();

            // If it is any other format other than the image(jpeg, png and gif),

            // following line will throw the SWT exception

            iImageData=imageLoader.load(is);

            // If the image is loaded properly, we need to check whether it is GIF image or not.

            // It can be PNG and JPEG as well

            if (iImageData[0].type!=SWT.IMAGE_GIF)

                throw new MediaException("Could not create player");

            try

            {

                is.close();

            }

            catch (IOException e)

            {

                e.printStackTrace();

            }

            iSourceDimension= new Point(imageLoader.logicalScreenWidth, imageLoader.logicalScreenHeight);

            iCurrentVideoDimension= new Point(imageLoader.logicalScreenWidth, imageLoader.logicalScreenHeight);

            iBackgroundPixel= imageLoader.backgroundPixel;

        }

        populateControl();

    }

    /**

     *

     * @param locator

     * @throws SWTException

     */

    public AnimationPlayer(String locator) throws SWTException, MediaException

    {

        ImageLoader imageLoader= new ImageLoader();

        // If it is any other format other than the image(jpeg, png and gif),

        // following line will throw the SWT exception

        iImageData=imageLoader.load(locator);

        // If the image is loaded properly, we need to check whether it is GIF image or not.

        // It can be PNG and JPEG as well

        if (iImageData[0].type!=SWT.IMAGE_GIF)

            throw new MediaException("Could not create player");

        iPlayerListenerImpl= new PlayerListenerImpl(this);

        iSourceDimension= new Point(imageLoader.logicalScreenWidth, imageLoader.logicalScreenHeight);

        iCurrentVideoDimension= new Point(imageLoader.logicalScreenWidth, imageLoader.logicalScreenHeight);

        iBackgroundPixel= imageLoader.backgroundPixel;

        populateControl();

    }

    /**

     * Moved the player to close state and releases all resources, called from PlayerBase class

     */

    protected void doClose()

    {

        // state is already changed in playerbase.close() method

        //      changePlayerState(CLOSED);

        iPlayerListenerImpl.postEvent(PlayerListener.CLOSED, null);

    }

    /**

     * Called from the PlayerBase class if the Player is in pre-fetched state

     *

     */

    protected void doDeallocate()

    {

        //when the player is in pre-fetched state, calling this

        //function should change the state of the player to RELAIZED state

        changePlayerState(REALIZED);

    }

    protected void doPrefetch() throws MediaException

    {

        changePlayerState(PREFETCHED);

        iDuration= getMediaTimeForFrame(getTotalNumberFrames());

    }

    protected void doRealize() throws MediaException

    {

        changePlayerState(REALIZED);

    }

    /**

     *

     */

    protected void doStop() throws MediaException

    {

        // since after stopping the player the player state will move to pre-fetched state

        changePlayerState(PREFETCHED);

        //iPlayerListenerImpl.postEvent(PlayerListener.STOPPED, new Long(iMediaTime * 10000));

        iPlayerListenerImpl.postEvent(PlayerListener.STOPPED, new Long(iMediaTime));

    }

    /**

     * Function of InternalPlayer interface

     */

    public void addControl(Control aControl, String aControlType)

    {

        iControls.put(aControlType, aControl);

    }

    /**

     *

     */

    public void addPlayerListener(PlayerListener aPlayerListener)

    {

        closeCheck();

        iPlayerListenerImpl.addPlayerListener(aPlayerListener);

    }

    /**

     * Returns the Content type("image/GIF") supported for by this player,

     */

    public String getContentType()

    {

        closeCheck();

        unrealizedCheck();

        return ANIMATION_CONTENT_TYPE;

    }

    /**

     * This function will return total time in microseconds, this player can be played

     */

    public long getDuration()

    {

        closeCheck();

        return iDuration;

    }

    /**

     * This returns the total time taken, till now, to play the video.

     */

    public long getMediaTime()

    {

        closeCheck();

        return iMediaTime;

    }

    public int getState()

    {

        return iState;

    }

    /**

     * Removes the specified playerListner from this player

     */

    public void removePlayerListener(PlayerListener aPlayerListener)

    {

        closeCheck();

        iPlayerListenerImpl.removePlayerListener(aPlayerListener);

    }

    /**

     *

     */

    GC gc = null;

    public void start() throws MediaException

    {

        final String DEBUG_STR = "AnimationPlayer::start()";

//        final long inTime = System.currentTimeMillis();

        prefetch();

        // Only prefetched player may be started. If player is already started

        // this method returns silently.

        if (getState() == PREFETCHED)

        {

            //initialize();

            changePlayerState(STARTED);

            Thread thread = new Thread("Animation")

            {

                int loopCount = iCurrentLoopCount;

                public void run()

                {

                    //changePlayerState(STARTED);

                    final int noOfFrames = iImageData.length;

                    while (iState == STARTED)

                    {

                        final int delayTimeForNextFrame = iImageData[iFrameIndex].delayTime*10000 ;

                        // Since we are going to display first frame, notify all

                        // PlayerListener that Player has started

                        if (iFrameIndex == 0)

                        {

                            iMediaTime=0;

                            iPlayerListenerImpl.postEvent(

                                PlayerListener.STARTED, new Long(0));

                        }

                        if (iDisplay != null)

                        {

                            iDisplay.syncExec(new Runnable()

                            {

                                public void run()

                                {

                                    // For out of memory issue in case of full screen, we are scaling the image

                                    // while displaying it.

                                    ImageData tempImageData =iImageData[iFrameIndex] ;

                                    if (iSourceDimension.x!=iCurrentVideoDimension.x || iSourceDimension.x!=iCurrentVideoDimension.x)

                                    {

                                        tempImageData = iImageData[iFrameIndex].scaledTo(iCurrentVideoDimension.x , iCurrentVideoDimension.y);

                                    }

                                    Image tempImage = new Image(iDisplay,tempImageData);

                                    //Image tempImage = new Image(iDisplay,iImageData[iFrameIndex]);

                                    gc.drawImage(tempImage, 0, 0);

                                    tempImage.dispose();

                                    iFrameIndex = (iFrameIndex + 1) % noOfFrames;

                                    if (iControl != null)

                                    {

                                        iControl.redraw();

                                    }

                                    iMediaTime += delayTimeForNextFrame;

                                }

                            });

                        }

                        else// if the initDisplayMode is not called yet

                        {

                            iFrameIndex = (iFrameIndex + 1) % noOfFrames;

                            iMediaTime += delayTimeForNextFrame;

                        }

                        try

                        {

                            Thread.sleep(delayTimeForNextFrame / 1000);

                        }

                        catch (InterruptedException e)

                        {

                            e.printStackTrace();

                        }

                        // post EOM event

                        if (iFrameIndex == 0)

                        {

                            loopCount++;

                            if (!(iRepeatForeEver || (loopCount < iTotalLoopCount)))

                            {

                                // when this loop is getting braked, we need to change the state to pre-fetched

                                //TODO Player should change it's state in doStop();

                                changePlayerState(PREFETCHED);

                            }

                            // send the END_OF_MEDIA event to all

                            // listener

                            iPlayerListenerImpl.postEvent(

                                PlayerListener.END_OF_MEDIA,

                                new Long(iMediaTime));

                        }

                        if (iAnimationObserver!=null)

                        {

                            iAnimationObserver.animationAdvanced(iMediaTime);

                        }

                    }// end of while loop

                    iCurrentLoopCount = loopCount;

                }

            };

            thread.start();

        }

    }

    /**

     * State of the player should be changed from this function only.

     * @param aState

     */

    private synchronized void  changePlayerState(int aState)

    {

        iState=aState;

    }

    /**

     * On each repaint event, control is getting disposed and created each time,

     * So we need to call each time the Control is available

     * @param aControl

     */

    private void addPaintListener(org.eclipse.swt.widgets.Control aControl)

    {

        iControl=aControl;

        if (iControl != null)

        {

            iDisplay.syncExec(new Runnable()

            {

                public void run()

                {

                    iControl.addPaintListener(new PaintListener()

                    {

                        public void paintControl(PaintEvent pe)

                        {

                            if (iImage != null && iIsControlVisible)

                            {

                                pe.gc.drawImage(iImage, iDisplayLocation.x,

                                                iDisplayLocation.y);

                            }

                        }

                    });

                }

            });

        }

    }

    /**

     * This returns player Control.

     *

     * @param controlType - the class name of the Control. The class name should be given either

     * as the fully-qualified name of the class; or if the package of the class is not given, the

     * package javax.microedition.media.control is assumed.

     *

     *  @return the object that implements the control, or null.

     */

    public Control getControl(String aControlType)

    {

        if (aControlType == null)

        {

            throw new IllegalArgumentException("argument is null");

        }

        closeCheck();

        unrealizedCheck();

        String controlType = aControlType;

        // check if package name exists

        if (controlType.indexOf(".") == -1)

        {

            // add package name

            controlType = CONTROL_DEFAULT_PACKAGE + aControlType;

        }

        Control control = (Control)iControls.get(controlType);

        // If control does not exists with default name, check if there is

        // is a control with same type ( extends the given class name ).

        if (control == null)

        {

            try

            {

                // try to create class for control

                Class controlClass = Class.forName(controlType);

                Enumeration elements = iControls.elements();

                // search if any control is same type that requested control

                while (elements.hasMoreElements())

                {

                    Control tmpControl = (Control) elements.nextElement();

                    if (controlClass.isInstance(tmpControl))

                    {

                        // control is found

                        control = tmpControl;

                    }

                }

            }

            catch (ClassNotFoundException cnfe) // the class could not be

                // found

            {

                // Exception is ignored and null is returned from this method

            }

            catch (Error e) // the function failed for any other reason.

            {

                // Error is ignored and null is returned from this method

            }

        }

        return control;

    }

    /**

     * Returns all the control associated with this player

     */

    public Control[] getControls()

    {

        closeCheck();

        unrealizedCheck();

        Control control[]= new Control[iControls.size()];

        Enumeration enumeration= iControls.elements();

        byte index=0;

        while (enumeration.hasMoreElements())

        {

            control[index++]=(Control)enumeration.nextElement();

        }

        return control;

    }

    /**

     *

     */

    public void setLoopCount(int aCount)

    {

        iRepeatForeEver = (aCount == -1);

        super.setLoopCount(aCount);

        iTotalLoopCount=aCount;

    }

    /**

     * From PlayerBase

     * Here iFrameIndex variable will be updated according to the argument(aNow) supplied

     * We are updating the iFrameIndex variable, which is being used in the start function

     *

     * @see PlayerBase

     */

    public long setMediaTime(long aNow) throws MediaException

    {

        long now = super.setMediaTime(aNow);

        if (iDuration == TIME_UNKNOWN)

            iDuration=getMediaTimeForFrame(getTotalNumberFrames());

        if (now >= iDuration)

        {

            iFrameIndex=getTotalNumberFrames()-1;

            iMediaTime = iDuration;

        }

        else

        {

            iFrameIndex = findFrame(now);

            iMediaTime= getMediaTimeForFrame(iFrameIndex);

        }

        return iMediaTime ;

    }

    //////////////////////////////////////////////////////////////////////////////////////

    // Following functions are for internal use, and not exposed to MIDlet developer//////

    /////////////////////////////////////////////////////////////////////////////////////