/*

* 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:  This class uses player factories to generate different players

*

*/

//  INCLUDE FILES

#include <logger.h>

#include <ecam.h>

#include "cmmamanager.h"

#include "cmmaaudioplayerfactory.h"

#include "cmmavideoplayerfactory.h"

#include "cmmaaudiorecorderfactory.h"

#include "cmmacameraplayerfactory.h"

#include "cmmamidiplayerfactory.h"

#include "cmmavideourlplayerfactory.h"

#include "cmmaaudiostreamplayerfactory.h"

//#include "cmmaanimationplayerfactory.h"

#ifdef RD_JAVA_OMA_DRM_V2

#include "cmmadrmplayerfactory.h"

#endif // RD_JAVA_OMA_DRM_V2

// index of CMMAAudioStreamPlayerFactory in iPlayerFactories

// if CMMAAudioStreamPlayerFactory is moved in iPlayerFactories

// this constant should be updated accordingly

const TInt KAudioStreamPlayerFactoryIndex = 2;

CMMAManager::~CMMAManager()

{

    iPlayerFactories.ResetAndDestroy();

    iPlayerFactories.Close();

}

CMMAManager::CMMAManager()

{

}

void CMMAManager::ConstructL(TInt aMIDletSuiteID)

{

    //

    // Create and insert known player factories

    //

    CMMAVideoUrlPlayerFactory* videoUrlPlayerFactory = CMMAVideoUrlPlayerFactory::NewLC();

    AddPlayerFactoryL(videoUrlPlayerFactory);

    CleanupStack::Pop(); // videoUrlPlayerFactory

    CMMAMIDIPlayerFactory* midiPlayerFactory = CMMAMIDIPlayerFactory::NewLC();

    AddPlayerFactoryL(midiPlayerFactory);

    CleanupStack::Pop(); // midiPlayerFactory

    CMMAAudioStreamPlayerFactory* audioStreamPlayerFactory =

        CMMAAudioStreamPlayerFactory::NewLC();

    AddPlayerFactoryL(audioStreamPlayerFactory);

    CleanupStack::Pop(); // audioStreamPlayerFactory

    CMMAVideoPlayerFactory* videoPlayerFactory = CMMAVideoPlayerFactory::NewLC();

    AddPlayerFactoryL(videoPlayerFactory);

    CleanupStack::Pop(); // videoPlayerFactory

    CMMAAudioPlayerFactory* audioPlayerFactory = CMMAAudioPlayerFactory::NewLC();

    AddPlayerFactoryL(audioPlayerFactory);

    CleanupStack::Pop(); // audioPlayerFactory

    CMMAAudioRecorderFactory* audioRecorderFactory =

        CMMAAudioRecorderFactory::NewLC(aMIDletSuiteID);

    AddPlayerFactoryL(audioRecorderFactory);

    CleanupStack::Pop(); // audioRecorderFactory

    // Add camera playerfactory only if there is a camera

    if (CCamera::CamerasAvailable() > 0)

    {

        CMMACameraPlayerFactory* cameraPlayerFactory =

            CMMACameraPlayerFactory::NewLC();

        AddPlayerFactoryL(cameraPlayerFactory);

        CleanupStack::Pop(); // cameraPlayerFactory

    }

#ifdef RD_JAVA_OMA_DRM_V2

    CMMADRMPlayerFactory* drmPlayerFactory =

        CMMADRMPlayerFactory::NewLC(videoPlayerFactory);

    AddPlayerFactoryL(drmPlayerFactory);

    CleanupStack::Pop(); // drmPlayerFactory

#endif // RD_JAVA_OMA_DRM_V2

}

void CMMAManager::StaticCreateManagerL(CMMAManager** aManager,

                                       TInt aMIDletSuiteID)

{

    CMMAManager* self = new(ELeave) CMMAManager();

    CleanupStack::PushL(self);

    self->ConstructL(aMIDletSuiteID);

    CleanupStack::Pop();

    *aManager = self;

}

/**

 * Use factories to create a player from content type

 *

 */

CMMAPlayer* CMMAManager::CreatePlayerL(const TDesC& aContentType)

{

    // Try all factories, in order

    TInt factoryCount = iPlayerFactories.Count();

    for (TInt i = 0; i < factoryCount; i++)

    {

        CMMAPlayer* player = iPlayerFactories[ i ]->CreatePlayerL(aContentType);

        if (player)

        {

            return player;

        }

    }

    // No PlayerFactory accepted the content type

    return NULL;

}

/**

 * Use factories to create a player from locator

 *

 */

CMMAPlayer* CMMAManager::CreatePlayerL(const TDesC& aProtocol,

                                       const TDesC& aMiddlePart,

                                       const TDesC& aParameters)

{

    // Try all factories, in order

    TInt factoryCount = iPlayerFactories.Count();

    for (TInt i = 0; i < factoryCount; i++)

    {

        CMMAPlayer* player = iPlayerFactories[ i ]->CreatePlayerL(aProtocol,

                             aMiddlePart,

                             aParameters);

        if (player)

        {

            return player;

        }

    }

    // No PlayerFactory accepted the content type

    return NULL;

}

/**

 * Use factories to create a player from header data

 *

 */

CMMAPlayer* CMMAManager::CreatePlayerL(const TDesC8& aHeaderData)

{

    // Try all factories, in order

    TInt factoryCount = iPlayerFactories.Count();

    for (TInt i = 0; i < factoryCount; i++)

    {

        CMMAPlayer* player = iPlayerFactories[ i ]->CreatePlayerL(aHeaderData);

        if (player)

        {

            return player;

        }

    }

    // No PlayerFactory accepted the content type

    return NULL;

}

/**

 * From MMMAPlayerFactory. Get all supported protocols

 */

void CMMAManager::GetSupportedProtocolsL(

    const TDesC& aContentType,

    CDesC16Array& aSupportedProtocols)

{

    // Query supported protocols from all player factories

    for (TInt i = 0; i < iPlayerFactories.Count(); i++)

    {

        iPlayerFactories[ i ]->GetSupportedProtocolsL(aContentType,

                aSupportedProtocols);

    }

}

/**

 * From MMMAPlayerFactory. Get all supported content types

 */

void CMMAManager::GetSupportedContentTypesL(

    const TDesC& aProtocol,

    CDesC16Array& aContentTypes)

{

    // Get all supported content types from PlayerFactories

    for (TInt i = 0; i < iPlayerFactories.Count(); i++)

    {

        iPlayerFactories[ i ]->GetSupportedContentTypesL(aProtocol,

                aContentTypes);

    }

}

EXPORT_C void CMMAManager::AddPlayerFactoryL(MMMAPlayerFactory* aPlayerFactory)

{

    User::LeaveIfError(iPlayerFactories.Append(aPlayerFactory));

}

void CMMAManager::SetSourceInfoL(const TUint8* aHeader, TInt aLength)

{

    if (iPlayerFactories.Count() > KAudioStreamPlayerFactoryIndex)

    {

        // assumption - iPlayerFactories[KAudioStreamPlayerFactoryIndex] is CMMAAudioStreamPlayerFactory

        CMMAAudioStreamPlayerFactory* audiostreamplayerfactory =

            static_cast<CMMAAudioStreamPlayerFactory*>(iPlayerFactories[ KAudioStreamPlayerFactoryIndex ]);

        audiostreamplayerfactory->SetSourceInfoL(aHeader, aLength);

    }

}

//  END OF FILE