/*

* 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:  VideoControl is used to control the display of video.

*

*/

package com.nokia.microedition.media.control;

import javax.microedition.lcdui.Canvas;

import javax.microedition.lcdui.Display;

import javax.microedition.lcdui.Displayable;

import javax.microedition.media.MediaException;

import javax.microedition.media.Player;

import javax.microedition.midlet.MIDlet;

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

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

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

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

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

import com.nokia.mj.impl.utils.Logger;

public class VideoControl

        extends ControlImpl

        implements javax.microedition.media.control.VideoControl

{

    private static final String GUI_OBJECT_CLASS_NAME =

        "javax.microedition.lcdui.Item";

    private static final int NOT_INITIALIZED = -1;

    private static final int ERROR_ARGUMENT = -6; // KErrArgument

    // use contans to avoid making native methods

    // which has same prototypes

    // getter constants for native side

    private static final int PROPERTY_DISPLAY_WIDTH = 1;

    private static final int PROPERTY_DISPLAY_HEIGHT = 2;

    private static final int PROPERTY_DISPLAY_X = 3;

    private static final int PROPERTY_DISPLAY_Y = 4;

    private static final int PROPERTY_SOURCE_WIDTH = 5;

    private static final int PROPERTY_SOURCE_HEIGHT = 6;

    // setter constants for native side

    private static final int SET_DISPLAY_SIZE = 20;

    private static final int SET_DISPLAY_LOCATION = 21;

    private static final int SET_DISPLAY_VISIBLE_TRUE = 22;

    private static final int SET_DISPLAY_VISIBLE_FALSE = 23;

    private static final int SET_DISPLAY_FULLSCREEN_TRUE = 24;

    private static final int SET_DISPLAY_FULLSCREEN_FALSE = 25;

    // MMA API defines return values like 'return value is undefined'

    // then UNDEFINED_RETURN_VALUE is returned

    private static final int UNDEFINED_RETURN_VALUE = 0;

    // String to be passed to Security.ensurePermission method

    // when getting snapshot.

    private static final String PERMISSION =

        "javax.microedition.media.control.VideoControl.getSnapshot";

    private static final String PERM_ARGS[] = { "" };

    // class name used with dynamic display mode initialization

    private static String GUI_FACTORY_CLASS_NAME = ".Factory";

    // lcdui package used with UiToolkitRegister

    private static String LCDUI_PACKAGE =

        "javax.microedition.lcdui";

    // eswt package used with UiToolkitRegister

    private static String ESWT_PACKAGE = "org.eclipse.swt.widgets";

    // ToolkitRegister class name used with eswt and lcdui

    private static String DISPLAY = ".Display";

    // class name used to check if eswt is included

    private static String LISTENER = ".Listener";

    // class name used to check if eswt is included

    private static String ESWT_CONTROL = ".control";

    protected int iStatus = NOT_INITIALIZED;

    // Needed for getting native handle from lcdui components

    ToolkitInvoker iToolkitInvoker;

    private VideoItem iVideoItem;

    private Canvas iVideoCanvas;

    private Display iDisplay = null;

    // error code used asynchronous native calls

    private int iError;

    // used in asynchronous getSnapshot method

    private byte[] iImageData;

    private int iToolkitHandle = 0;

    private Finalizer mFinalizer = new Finalizer()

    {

        public void finalizeImpl()

        {

            doFinalize();

        }

    };

    public VideoControl()

    {

        iToolkitInvoker = ToolkitInvoker.getToolkitInvoker();

    }

    private void doFinalize()

    {

        if (mFinalizer != null)

        {

            registeredFinalize();

            mFinalizer = null;

        }

    }

    final void registeredFinalize()

    {

        if (iVideoItem != null)

        {

            iPlayer.removePlayerListener(iVideoItem);

            iVideoItem.iNativeHandle = 0;

        }

    }

    public void setHandles(Player aPlayer, int aEventSource, int aControlHandle)

    {

        iPlayer = aPlayer;

        iEventSource = aEventSource;

        iControlHandle = aControlHandle;

        if (!_isESWT())

        {

            // LCDUI midlet running

            // for mobitv fix

            try

            {

                iToolkitHandle = iToolkitInvoker.toolkitGetHandle(iToolkitInvoker.getToolkit());

            }

            catch (Exception e)

            {

                //iToolKitHandle = 0;

            }

        }

        else

        {

            // eSWT midlet running

            // Foreground status of the eSWT midlet is always set to 1 so midlet recieves volume key events even in background.

            // This is a minor problem to be fixed in future

            iToolkitHandle = 0;

        }

        int error = _construct(iControlHandle,

                               aEventSource,

                               iToolkitHandle);

        NativeError.check(error);

    }

    /**

     * from Interface VideoControl

     *

     */

    public void setDisplaySize(int aWidth, int aHeight) throws MediaException

    {

        checkState();

        if (iStatus == NOT_INITIALIZED)

        {

            throw new IllegalStateException(

                "VideoControl.initDisplayMode() not called yet");

        }

        if (aWidth <= 0 || aHeight <= 0)

        {

            throw new IllegalArgumentException(

                "Width and height must be positive");

        }

        int ret = setDisplayProperty(aWidth, aHeight, SET_DISPLAY_SIZE);

        if (ret < 0)

        {

            throw new MediaException("setDisplaySize() failed, SymbianOS error: "

                                     + ret);

        }

        if (iStatus == USE_GUI_PRIMITIVE &&

                iVideoItem != null)  // with dynamic display mode item can be null

        {

            iVideoItem.privateInvalidate();

        }

    }

    /**

     * from Interface VideoControl

     *

     */

    public void setDisplayFullScreen(boolean aFullScreenMode) throws MediaException

    {

        checkState();

        if (iStatus == NOT_INITIALIZED)

        {

            throw new IllegalStateException(

                "VideoControl.initDisplayMode() not called yet");

        }

        int ret;

        if (aFullScreenMode)

        {

            ret = setDisplayProperty(SET_DISPLAY_FULLSCREEN_TRUE);

        }

        else

        {

            ret = setDisplayProperty(SET_DISPLAY_FULLSCREEN_FALSE);

        }

        if (ret < 0)

        {

            throw new MediaException();

        }

    }

    /**

     * from Interface VideoControl

     *

     */

    public void setDisplayLocation(int aX, int aY)

    {

        checkState();

        if (iStatus == USE_GUI_PRIMITIVE)

        {

            // In USE_GUI_PRIMITIVE mode, this call will be ignored.

            return;

        }

        if (iStatus != USE_DIRECT_VIDEO)

        {

            // This method only works when the USE_DIRECT_VIDEO mode is set.

            throw new IllegalStateException();

        }

        // cannot fail -> ignore return value

        setDisplayProperty(aX, aY, SET_DISPLAY_LOCATION);

    }

    /**

     * from Interface VideoControl

     *

     */

    public void setVisible(boolean aVisible)

    {

        checkState();

        if (iStatus == NOT_INITIALIZED)

        {

            throw new IllegalStateException(

                "VideoControl.initDisplayMode() not called yet");

        }

        if (aVisible)

        {

            // Update the foreground or background state of the midlet before

            // setting the visibility of the control

            updateForeground();

            // cannot fail -> ignore return value

            setDisplayProperty(SET_DISPLAY_VISIBLE_TRUE);

        }

        else

        {

            // cannot fail -> ignore return value

            setDisplayProperty(SET_DISPLAY_VISIBLE_FALSE);

        }

    }

    /**

     * from Interface VideoControl

     *

     */

    public int getDisplayWidth()

    {

        checkState();

        if (iStatus == NOT_INITIALIZED)

        {

            throw new IllegalStateException(

                "VideoControl.initDisplayMode() not called yet");

        }

        int width = getControlProperty(PROPERTY_DISPLAY_WIDTH);

        return width;

    }

    /**

     * from Interface VideoControl

     *

     */

    public int getDisplayHeight()

    {

        checkState();

        if (iStatus == NOT_INITIALIZED)

        {

            throw new IllegalStateException(

                "VideoControl.initDisplayMode() not called yet");

        }

        int height = getControlProperty(PROPERTY_DISPLAY_HEIGHT);

        return height;

    }

    /**

     * from Interface VideoControl

     *

     */

    public int getDisplayX()

    {

        checkState();

        if (iStatus == NOT_INITIALIZED)

        {

            return UNDEFINED_RETURN_VALUE;

        }

        int x = getControlProperty(PROPERTY_DISPLAY_X);

        return x;

    }

    /**

     * from Interface VideoControl

     *

     */

    public int getDisplayY()

    {

        checkState();

        if (iStatus == NOT_INITIALIZED)

        {

            return UNDEFINED_RETURN_VALUE;

        }

        int y = getControlProperty(PROPERTY_DISPLAY_Y);

        return y;

    }

    /**

     * from Interface VideoControl

     *

     */

    public int getSourceWidth()

    {

        checkState();

        int width = getControlProperty(PROPERTY_SOURCE_WIDTH);

        if (width <= 0)

        {

            width = 1;

        }

        return width;

    }

    /**

     * from Interface VideoControl

     *

     */

    public int getSourceHeight()

    {

        checkState();

        int height = getControlProperty(PROPERTY_SOURCE_HEIGHT);

        if (height <= 0)

        {

            height = 1;

        }

        return height;

    }

    /**

     * from Interface VideoControl

     *

     */

    synchronized public byte[] getSnapshot(String aImageType) throws MediaException

    {

        checkState();

        if (iStatus == NOT_INITIALIZED)

        {

            throw new IllegalStateException(

                "VideoControl.initDisplayMode() not called yet");

        }

        // starts native side. Native will release wait lock if

        // _getSnapshot doesn't leave.

        int error = _getSnapshot(iControlHandle,

                                 iEventSource, aImageType);

        if (error == ERROR_ARGUMENT)

        {

            throw new MediaException("Unsupported image type: " + aImageType);

        }

        else if (error < 0)

        {

            throw new MediaException("getSnapshot() failed, Symbian OS error: " + error);

        }

        synchronized (this)

        {

            try

            {

                // wait native side

                wait();

            }

            catch (Exception  e)

            {

                throw new MediaException("" + e);

            }

        }

        if (iError < 0)

        {

            throw new MediaException("Symbian OS error: " + iError);

        }

        // Check the permission here, so 'the moment' is not lost?

        Security.ensurePermission(PERMISSION, PERMISSION, PERM_ARGS);

    }

    /**

     * from Interface VideoControl

     *

     */

    public Object initDisplayMode(int aMode, Object aArg)

    {

        checkState();

        if (iStatus != NOT_INITIALIZED)

        {

            // IllegalStateException - Thrown if initDisplayMode is

            // called again after it has previously been called successfully.

            throw new IllegalStateException(

                "initDisplayMode() already called successfully");

        }

        if (aMode == USE_GUI_PRIMITIVE)

        {

            Object guiObject = null;

            if (aArg == null)

            {

                guiObject = initNullMode();

            }

            else

            {

                if (aArg.equals(GUI_OBJECT_CLASS_NAME))

                {

                    guiObject = initLCDUI();

                }

                else // try load dynamic display mode

                {

                    guiObject = initDynamicDisplayMode(aArg);

                }

            }

            iStatus = USE_GUI_PRIMITIVE;

            return guiObject;

        }

        else if (aMode == USE_DIRECT_VIDEO)

        {

            if (aArg != null)

            {

                if (!(aArg instanceof javax.microedition.lcdui.Canvas))

                {

                    throw new java.lang.IllegalArgumentException(

                        "For USE_DIRECT_VIDEO mode argument should be of type Canvas");

                }

            }

            else

            {

                throw new java.lang.IllegalArgumentException(

                    "For USE_DIRECT_VIDEO mode argument should not be null");

            }

            iVideoCanvas = (Canvas)aArg;

            initNativeDisplay(iVideoCanvas,

                              iToolkitInvoker.getDisplayableHandle(

                                  (javax.microedition.lcdui.Displayable)aArg));

            iStatus = USE_DIRECT_VIDEO;

            try

            {

                this.setVisible(false);

            }

            catch (IllegalStateException ex) { }

            return null;

        }

        else

        {

            // java.lang.IllegalArgumentException - Thrown if the mode is invalid.

            throw new java.lang.IllegalArgumentException(

                "Mode not supported or invalid, " +

                "valid modes are USE_DIRECT_VIDEO and USE_GUI_PRIMITIVE");

        }

    }

    /**

     * Initializes native display.

     *

     */

    private int initNativeDisplay(Object aGuiObject, int aComponentNativeHandle)

    {

        int handle = _initDisplayMode(iControlHandle,

                                      iEventSource,

                                      aComponentNativeHandle,

                                      aGuiObject);

        NativeError.check(handle);

        return handle;

    }

    /**

     * Gets control property from native side.

     * @param aPropertyType One of the types defined in this class

     *

     */

    private int getControlProperty(int aPropertyType)

    {

        return _getControlProperty(iControlHandle,

                                   iEventSource,

                                   aPropertyType);

    }

    /**

     * Sets two properties to native side.

     *

     * @param aParamA Specific parameter A for property type.

     * @param aParamB Specific parameter B for property type.

     * @param aPropertyType One of the types defined in this class

     */