/*

* 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.

     */

    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>.

     */

    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