/*
* 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:
*
*/

package com.nokia.microedition.media;

import java.io.IOException;
import java.io.InputStream;
import java.util.Vector;
import java.util.Enumeration;
import javax.microedition.media.protocol.DataSource;
import javax.microedition.media.TimeBase;
import javax.microedition.media.Player;
import javax.microedition.media.MediaException;
import com.nokia.mj.impl.rt.legacy.MIDEventServer;
import com.nokia.mj.impl.rt.legacy.ToolkitInvoker;
import com.nokia.mj.impl.rt.legacy.ToolkitObserver;
import com.nokia.mj.impl.rt.legacy.NativeError;
import com.nokia.microedition.media.protocol.ProtocolFactory;
import com.nokia.microedition.media.tone.PlayToneImpl;
import com.nokia.microedition.volumekeys.ForegroundListener;
import com.nokia.mj.impl.rt.support.Finalizer;

/**
 * ManagerImpl implements the functionality specified in
 * javax.microedition.media.Manager class.
 * This class is a singleton and instance can be got with getInstance method.
 */
public class ManagerImpl implements PlugIn
{
    // ManagerImpl native instance
    private static int sManagerHandle;

    // CMMAEventSource
    private static int sEventSourceHandle;

    // Static instance, can be got with getInstace method
    private static ManagerImpl sManager;

    private final TimeBase iSystemTimeBase = new SystemTimeBase();
    private final MIDEventServer iEventServer;
    private final Vector iPlugIns = new Vector();
    private final ProtocolFactory iProtocolFactory = new ProtocolFactory();
    private final ForegroundListener iForegroundListener;

    private Finalizer mFinalizer = new Finalizer()
    {
        public void finalizeImpl()
        {
            doFinalize();
        }
    };

    // Play tone implementation
    private PlayToneImpl iPlayToneImpl = new PlayToneImpl();

    static
    {
        // This is called when class is loaded for the first time
        sManager = new ManagerImpl();

        try
        {
            // Invoke external components
            Setup.setup(sEventSourceHandle);
        }
        catch (OutOfMemoryError oome)
        {
            // External setup failed clean MMA native resources and throw oome
            sManager.registeredFinalize();
            throw oome;
        }
    }

    /**
     * This private constructor can be called only from staic block.
     */
    private ManagerImpl()
    {
        com.nokia.mj.impl.rt.support.Jvm.loadSystemLibrary("javamobilemedia");

        // Event server contructor needs new String object,
        // otherwise it don't work..
        iEventServer = new MIDEventServer(new String("java-mma"));
        sEventSourceHandle = _createEventSource(iEventServer.getHandle());
        if (sEventSourceHandle < NativeError.KErrNone)
        {
            throw new OutOfMemoryError("SymbianOS error: " + sEventSourceHandle);
        }
        // Suite UID was fetched using deprecated MIDletSuiteAMS.getMIDletSuiteId.
        // Using hard coded value in here since MMAPI doesn't really use the
        // suite id even if it passes it to native.
        final int midletSuiteId = 1;
        sManagerHandle = _createManager(sEventSourceHandle, midletSuiteId);
        if (sManagerHandle < NativeError.KErrNone)
        {
            throw new OutOfMemoryError();
        }

        ToolkitInvoker ti = ToolkitInvoker.getToolkitInvoker();
        // register for destroy event
        ti.addObserver(ti.getToolkit(),  new ToolkitObserver()
        {
            public final void destroyNotify()
            {
                release();
            }
        });

        // ManagerImpl is also a PlugIn that getAllSupportedContentTypes,
        // getAllSupportedProtocols and createPlayer methods can be used
        // through PlugIn interface.
        iPlugIns.addElement(this);

        // support for device://tone and jts
        iPlugIns.addElement(
            new com.nokia.microedition.media.protocol.device.tone.Protocol());

        // Create foreground listener which listens the state of the midlet
        // This feature is a part of the media keys feature so it is flagged
        iForegroundListener = new ForegroundListener(sEventSourceHandle);
    }

    /**
     * Returns MMA event source handle
     */
    public static int getEventSource()
    {
        return sEventSourceHandle;
    }
    /**
     * Returns native handle to Manager
     */
    public static int getHandle()
    {
        return sManagerHandle;
    }

    /**
     * Return ManagerImpl instance
     */
    public static ManagerImpl getInstance()
    {
        return sManager;
    }

    /**
     * Adds new PlugIn to PlugIns array.
     * @param aPlugIn New PlugIn.
     */
    public void addPlugIn(PlugIn aPlugIn)
    {
        iPlugIns.addElement(aPlugIn);
    }

    private void doFinalize()
    {
        if (mFinalizer != null)
        {
            registeredFinalize();
            mFinalizer = null;
        }
    }

    /**
     * This will be called when object is finalized.
     */
    synchronized final void registeredFinalize()
    {
        _dispose(sEventSourceHandle);
        sEventSourceHandle = 0;
    }

    /**
     * This method is called in Toolkit's destroyNotify call.
     * This will release convenient native resources. All native resource
     * will be deleted in registeredFinalize() method.
     */
    synchronized final void release()
    {
        _release(sEventSourceHandle);
    }

    /**
     * Create String array from Vector and remove String duplicates.
     * @param aVector Vector containing String objects.
     */
    private String[] createStringArray(Vector aVector)
    {
        // remove all duplicates from the vector
        for (int i = 0; i < aVector.size(); i++)
        {
            String element = (String)aVector.elementAt(i);
            for (int j = i + 1; j < aVector.size();)
            {
                if (element.equals((String)aVector.elementAt(j)))
                {
                    aVector.removeElementAt(j);
                }
                else
                {
                    j++;
                }
            }
        }

        // Create new array for vector elements and copy elements
        String[] s = new String[ aVector.size()];
        aVector.copyInto(s);
        return s;
    }

    /**
     * Return the list of supported content types for the given protocol.
     * <p>
     * See <a href="#content-type">content types</a> for the syntax
     * of the content types returned.
     * See <a href="#media-protocol">protocol name</a> for the syntax
     * of the protocol used.
     * <p>
     * For example, if the given <code>protocol</code>
     * is <code>"http"</code>,
     * then the supported content types that can be played back
     * with the <code>http</code> protocol will be returned.
     * <p>
     * If <code>null</code> is passed in as the <code>protocol</code>,
     * all the supported content types for this implementation
     * will be returned.  The returned array must be non-empty.
     * <p>
     * If the given <code>protocol</code> is an invalid or
     * unsupported protocol, then an empty array will be returned.
     *
     * @param aProtocol The input protocol for the supported content types.
     * @return The list of supported content types for the given protocol.
     */
    public String[] getAllSupportedContentTypes(String aProtocol)
    {
        if ((aProtocol != null) && (aProtocol.length() == 0))
        {
            // No supported types for 0 length string.
            return new String[ 0 ];
        }
        Vector contentTypes = new Vector();

        Enumeration plugIns = iPlugIns.elements();

        // go through all plugins and get content types
        while (plugIns.hasMoreElements())
        {
            PlugIn plugIn = (PlugIn)plugIns.nextElement();
            String[] types = plugIn.getSupportedContentTypes(aProtocol);

            // Add all types to vector
            for (int i = 0; i < types.length; i++)
            {
                contentTypes.addElement(types[ i ]);
            }
        }
        return createStringArray(contentTypes);
    }

    /**
     * Return the list of supported protocols given the content
     * type.  The protocols are returned
     * as strings which identify what locators can be used for creating
     * <code>Player</code>'s.
     * <p>
     * See <a href="#media-protocol">protocol name</a> for the syntax
     * of the protocols returned.
     * See <a href="#content-type">content types</a> for the syntax
     * of the content type used.
     * <p>
     * For example, if the given <code>content_type</code>
     * is <code>"audio/x-wav"</code>, then the supported protocols
     * that can be used to play back <code>audio/x-wav</code>
     * will be returned.
     * <p>
     * If <code>null</code> is passed in as the
     * <code>content_type</code>,
     * all the supported protocols for this implementation
     * will be returned.  The returned array must be non-empty.
     * <p>
     * If the given <code>content_type</code> is an invalid or
     * unsupported content type, then an empty array will be returned.
     *
     * @param aContentType The content type for the supported protocols.
     * @return The list of supported protocols for the given content type.
     */
    public String[] getAllSupportedProtocols(String aContentType)
    {
        String contentType = aContentType;
        if ((contentType != null) &&  contentType.equals(""))
        {
            return new String[ 0 ];
        }

        Vector protocols = new Vector();
        Enumeration plugIns = iPlugIns.elements();
        while (plugIns.hasMoreElements())
        {
            PlugIn plugIn = (PlugIn)plugIns.nextElement();
            String[] types = plugIn.getSupportedProtocols(aContentType);
            for (int i = 0; i < types.length; i++)
            {
                protocols.addElement(types[ i ]);
            }
        }
        return createStringArray(protocols);
    }

    /**
     * From PlugIn. Get MMA supported protocols.
     */
    public String[] getSupportedProtocols(String aContentType)
    {
        String[] protocols = _getSupportedProtocols(sEventSourceHandle,
                             sManagerHandle,
                             aContentType);
        NativeError.checkOOM(protocols);
        return protocols;
    }

    /**
     * From PlugIn. Get MMA supported types.
     */
    public String[] getSupportedContentTypes(String aProtocol)
    {
        String[] types = _getSupportedContentTypes(sEventSourceHandle,
                         sManagerHandle,
                         aProtocol);
        NativeError.checkOOM(types);
        return types;
    }

    /**
     * From PlugIn.
     */
    public InternalPlayer createPlayer(DataSource aSource)
    throws MediaException, IOException
    {
        InternalPlayer player = null;
        if (aSource.getContentType() != null)
        {
            // Create player from content type
            if (isValidContentType(aSource.getContentType()))
            {
                player = NativePlayerFactory.createPlayer(aSource.getContentType(),
                         aSource);
            }
            else
            {
                throw new MediaException(
                    "Content type not supported: " + aSource.getContentType());
            }
        }

        if ((player == null) &&
                (aSource.getLocator() != null))
        {
            // Create player from locator
            player = NativePlayerFactory.createPlayer(
                         new Locator(aSource.getLocator()),
                         aSource);
        }

        if (player == null)
        {
            // Could not create player from content-type or locator,
            // try to create player from header data
            player = NativePlayerFactory.createPlayer(
                         ((BufferDataSource)aSource).getHeader(),
                         aSource);
        }

        return player;
    }

    /**
     * From PlugIn. Empty implemation.
     */
    public void preparePlayer(InternalPlayer aPlayer) throws MediaException
    {
    }

    /**
     * This method calls preparePlayer to all PlugIns.
     */
    private void pluginsPreparePlayer(InternalPlayer aPlayer)
    throws MediaException
    {
        // Call preparePlayer to all plugins
        Enumeration plugins = iPlugIns.elements();
        while (plugins.hasMoreElements())
        {
            ((PlugIn)plugins.nextElement()).preparePlayer(aPlayer);
        }
    }

    /**
     * Create a <code>Player</code> from an input locator.
     *
     * @param aLocator A locator string in URI syntax that describes
     * the media content.
     * @return A new <code>Player</code>.
     * @exception IllegalArgumentException Thrown if <code>locator</code>
     * is <code>null</code>.
     * @exception MediaException Thrown if a <code>Player</code> cannot
     * be created for the given locator.
     * @exception IOException Thrown if there was a problem connecting
     * with the source pointed to by the <code>locator</code>.
     * @exception SecurityException Thrown if the caller does not
     * have security permission to create the <code>Player</code>.
     */
    public Player createPlayer(String aLocator)
    throws IOException, MediaException
    {
        if (aLocator == null)
        {
            throw new IllegalArgumentException("Locator is null.");
        }
        InternalPlayer player = iProtocolFactory.createPlayer(
                                    new Locator(aLocator));
        if (player == null)
        {
            throw new MediaException("Locator not supported: " +
                                     aLocator);
        }
        pluginsPreparePlayer(player);
        return player;
    }

    /**
     * Create a <code>InternalPlayer</code> for a <code>DataSource</code>.
     */
    public InternalPlayer createInternalPlayer(DataSource aSource)
    throws IOException, MediaException
    {
        // Throw IllegalArgumentException if source  is null.
        if (aSource == null)
        {
            throw new IllegalArgumentException("DataSource is null.");
        }
        aSource.connect(); // Ensure that external source is connected.
        if (aSource.getStreams() == null ||
                aSource.getStreams().length == 0)
        {
            // There must be atleast one stream in the DataSource
            throw new MediaException(
                "There must be at least one stream in datasource");
        }

        BufferDataSource bdc = null;
        if (aSource instanceof BufferDataSource)
        {
            bdc = (BufferDataSource)aSource;
        }
        else
        {
            bdc = new BufferDataSource(aSource);
        }

        InternalPlayer player = null;
        Enumeration plugins = iPlugIns.elements();
        // Loop through all plugins, stop if player was created
        while (plugins.hasMoreElements() &&
                (player == null))
        {
            PlugIn tmp = (PlugIn)plugins.nextElement();
            player = tmp.createPlayer(bdc);
        }

        if (player == null)
        {
            // MMA or plugins could not create player
            bdc.disconnect();

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

        return player;
    }

    /**
     * Create a <code>Player</code> to play back media from an
     * <code>InputStream</code>.
     * <p>
     * The <code>type</code> argument
     * specifies the content-type of the input media.  If
     * <code>null</code> is given, <code>Manager</code> will
     * attempt to determine the type.  However, since determining
     * the media type is non-trivial for some media types, it
     * may not be feasible in some cases.  The
     * <code>Manager</code> may throw a <code>MediaException</code>
     * to indicate that.
     *
     * @param aStream The <code>InputStream</code> that delivers the
     * input media.
     * @param aType The <code>ContentType</code> of the media.
     * @return A new <code>Player</code>.
     * @exception IllegalArgumentException Thrown if <code>stream</code>
     * is <code>null</code>.
     * @exception MediaException Thrown if a <code>Player</code> cannot
     * be created for the given stream and type.
     * @exception IOException Thrown if there was a problem reading data
     * from the <code>InputStream</code>.
     * @exception SecurityException Thrown if the caller does not
     * have security permission to create the <code>Player</code>.
     */
    public Player createPlayer(InputStream aStream, String aType)
    throws IOException, MediaException
    {
        if (aStream == null)
        {
            throw new IllegalArgumentException("InputStream is null.");
        }

        InputStreamSourceStream sourceStream =
            new InputStreamSourceStream(aStream);

        // Create data source without locator.
        DataSource dataSource = new InputStreamDataSource(sourceStream,
                aType);
        InternalPlayer player = createInternalPlayer(dataSource);

        if (player != null)
        {
            // Call preparePlayer to all plugins
            pluginsPreparePlayer(player);
        }

        return player;
    }

    /**
     * Play back a tone as specified by a note and its duration.
     * A note is given in the range of 0 to 127 inclusive.  The frequency
     * of the note can be calculated from the following formula:
     * <pre>
     *     SEMITONE_CONST = 17.31234049066755 = 1/(ln(2^(1/12)))
     *     note = ln(freq/8.176)*SEMITONE_CONST
     *     The musical note A = MIDI note 69 (0x45) = 440 Hz.
     * </pre>
     * This call is a non-blocking call. Notice that this method may
     * utilize CPU resources significantly on devices that don't
     * have hardware support for tone generation.
     *
     * @param aNote Defines the tone of the note as specified by the
     * above formula.
     * @param aDuration The duration of the tone in milli-seconds.
     * Duration must be positive.
     * @param aVolume Audio volume range from 0 to 100.  100 represents
     * the maximum
     * volume at the current hardware level.  Setting the volume to a
     * value less
     * than 0 will set the volume to 0.  Setting the volume to greater than
     * 100 will set the volume to 100.
     *
     * @exception IllegalArgumentException Thrown if the given note or
     * duration is out of range.
     * @exception MediaException Thrown if the tone cannot be played
     * due to a device-related problem.
     */
    public void playTone(int aNote, int aDuration, int aVolume)
    throws MediaException
    {
        iPlayToneImpl.playTone(aNote, aDuration, aVolume);
    }

    /**
     * Get the time-base object for the system.
     * @return The system time base.
     */
    public TimeBase getSystemTimeBase()
    {
        return iSystemTimeBase;
    }

    public boolean isValidContentType(String contentType)
    {
        for (int i=0; i < contentType.length(); i++)
        {
            if ((contentType.charAt(i) >= 0 && contentType.charAt(i) <= 31) || contentType.charAt(i) == 127)
                return false;
        }
        return true;
    }

    private native int _createManager(int aEventSourceHandle,
                                      int aMIDletSuiteID);
    private native int _createEventSource(int aEventServerHandle);
    private native void _dispose(int aEventSourceHandle);

    /**
     * Releases native resources.
     * @param aEventSourceHandle Handle to native CMMAEventSource instance.
     */
    private native void _release(int aEventSourceHandle);

    private static native String[] _getSupportedContentTypes(int aEventSourceHandle,
            int aManagerHandle,
            String aContentType);

    private static native String[] _getSupportedProtocols(int aEventSourceHandle,
            int aManagerHandle,
            String aProtocol);
}

// End of File