/*

* Copyright (c) 2002-2007 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 is used for creating MMF-based players.

*

*/

//  INCLUDE FILES

#include <badesca.h>

#include <logger.h>

#ifndef RD_JAVA_OMA_DRM_V2

#include <DRMCommon.h>

#endif // RD_JAVA_OMA_DRM_V2

#include "cmmammfplayerfactory.h"

#include "cmmammfresolver.h"

// CONSTANTS

// Granularity used to create initial arrays.

const TInt KGranularity = 8;

_LIT(KContentTypePacketSrcNotIncluded, "application/x-ext-packetsrc");

EXPORT_C CMMAMMFPlayerFactory::CMMAMMFPlayerFactory()

{

}

EXPORT_C CMMAMMFPlayerFactory::~CMMAMMFPlayerFactory()

{

}

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

{

    return CreatePlayerL(aContentType, NULL);

}

CMMAPlayer* CMMAMMFPlayerFactory::CreatePlayerL(const TDesC& aContentType,

        const TDesC* aFileName)

{

    LOG1( EJavaMMAPI, EInfo, "MMA::CMMAMMFPlayerFactory::CreatePlayerL content type = %S",

              aContentType.Ptr());

    CMMFFormatSelectionParameters* fSelect =

        CMMFFormatSelectionParameters::NewLC();

    // MMF needs 8bit data

    HBufC8* contentType = HBufC8::NewLC(aContentType.Length());

    contentType->Des().Copy(aContentType);

    // Match to mime/content type

    fSelect->SetMatchToMimeTypeL(*contentType);

    CMMAPlayer* player = CreatePlayerL(fSelect, aFileName);

    CleanupStack::PopAndDestroy(contentType);

    CleanupStack::PopAndDestroy(fSelect);

    LOG( EJavaMMAPI, EInfo, "MMA::CMMAMMFPlayerFactory::CreatePlayerL content type ok");

    return player;

}

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

        const TDesC& aMiddlePart,

        const TDesC&)

{

    LOG1( EJavaMMAPI, EInfo, "MMA::CMMAMMFPlayerFactory::CreatePlayerL aMiddlePart = %S",

              aMiddlePart.Ptr());

    CMMFFormatSelectionParameters* fSelect =

        CMMFFormatSelectionParameters::NewLC();

    // Match to file name, using only middle part of the locator

    fSelect->SetMatchToFileNameL(aMiddlePart);

    CMMAPlayer* player = NULL;

    if (aProtocol == KMMAFileProtocol)

    {

        LOG( EJavaMMAPI, EInfo, "MMA:CMMAMMFPlayerFactory::CreatePlayerL creating file player");

        player = CreatePlayerL(fSelect, &aMiddlePart);

#ifndef RD_JAVA_OMA_DRM_V2

        // if opening is failed, it might be DRM file, trying it

        if (!player)

        {

            player = TryOpenDRMFileL(aMiddlePart);

        }

#endif // RD_JAVA_OMA_DRM_V2

    }

    else

    {

        player = CreatePlayerL(fSelect, NULL);

    }

    CleanupStack::PopAndDestroy(fSelect);

    LOG( EJavaMMAPI, EInfo, "MMA::CMMAMMFPlayerFactory::CreatePlayerL aMiddlePart ok");

    return player;

}

#ifndef RD_JAVA_OMA_DRM_V2

CMMAPlayer* CMMAMMFPlayerFactory::TryOpenDRMFileL(const TDesC& aFileName)

{

    // we are most likely going to play this file

    ContentAccess::TIntent intent = ContentAccess::EPlay;

    CContent* contentObj = CContent::NewL(aFileName);

    CleanupStack::PushL(contentObj);

    CData* dataObj = contentObj->OpenContentL(intent);

    CleanupStack::PushL(dataObj);

    User::LeaveIfError(dataObj->EvaluateIntent(intent));

    TBuf8<KMaxName> mimeType;

    CMMAPlayer* player = NULL;

    if (dataObj->GetMimeTypeL(mimeType))

    {

        // we use 16bit mimeType

        HBufC* mimeTypeBuf = HBufC::NewLC(mimeType.Length());

        mimeTypeBuf->Des().Copy(mimeType);

        player = CreatePlayerL(*mimeTypeBuf, &aFileName);

        CleanupStack::PopAndDestroy(mimeTypeBuf);

    }

    CleanupStack::PopAndDestroy(2); //dataObj, contentObj

    return player;

}

#endif // RD_JAVA_OMA_DRM_V2

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

{

    LOG( EJavaMMAPI, EInfo, "MMA::CMMAMMFPlayerFactory::CreatePlayerL header data +");

    CMMFFormatSelectionParameters* fSelect =

        CMMFFormatSelectionParameters::NewLC();

    // Match to header data

    fSelect->SetMatchToHeaderDataL(aHeaderData);

    CMMAPlayer* player = CreatePlayerL(fSelect);

    CleanupStack::PopAndDestroy(fSelect);

    LOG( EJavaMMAPI, EInfo, "MMA::CMMAMMFPlayerFactory::CreatePlayerL header data -");

    return player;

}

void CMMAMMFPlayerFactory::GetSupportedContentTypesL(const TDesC& aProtocol,

        CDesC16Array& aMimeTypeArray)

{

    // check that this is supported protocol

    if (!IsSupportedProtocolL(aProtocol))

    {

        return;

    }

    CMMFFormatSelectionParameters* fSelect =

        CMMFFormatSelectionParameters::NewLC();

    CMMAMMFResolver* cSelect =

        CMMAMMFResolver::NewLC();

    PreparePluginSelectionParametersL(cSelect, fSelect);

    // Set the media ids

    RArray<TUid> mediaIds;

    CleanupClosePushL(mediaIds);

    MediaIdsL(mediaIds);

    cSelect->SelectionParameters()->SetMediaIdsL(mediaIds, MediaIdMatchType());

    cSelect->GetSupportedContentTypesL(aMimeTypeArray);

    // Content type application/x-ext-packetsrc must not be supported,

    // thus it is removed from the list of supported content types

    TInt position(0);

    TInt err = aMimeTypeArray.Find(KContentTypePacketSrcNotIncluded, position);

    if (err == KErrNone)

    {

        aMimeTypeArray.Delete(position);

        aMimeTypeArray.Compress();

    }

    CleanupStack::PopAndDestroy(); // mediaIds

    CleanupStack::PopAndDestroy(cSelect);

    CleanupStack::PopAndDestroy(fSelect);

}

EXPORT_C CMMAPlayer* CMMAMMFPlayerFactory::CreatePlayerL(CMMFFormatSelectionParameters* aFormatSelect,

        const TDesC* aFileName)

{

    CMMAMMFResolver* cSelect =

        CMMAMMFResolver::NewLC();

    cSelect->SetFileNameL(aFileName);

    PreparePluginSelectionParametersL(cSelect,

                                      aFormatSelect);

    // Set the media ids

    RArray<TUid> mediaIds;

    CleanupClosePushL(mediaIds);

    MediaIdsL(mediaIds);

    cSelect->SelectionParameters()->SetMediaIdsL(

        mediaIds, MediaIdMatchType());

    cSelect->ListImplementationsL();

    CMMAPlayer* player = NULL;

    // check that did we get any hits

    if (cSelect->Implementations()->Count() > 0)

    {

        // Call actual factory to create player

        player = CreatePlayerL(cSelect);

    }

    CleanupStack::PopAndDestroy(); // mediaIds

    CleanupStack::PopAndDestroy(cSelect);

    return player;

}

void CMMAMMFPlayerFactory::GetSupportedProtocolsL(const TDesC& aContentType,

        CDesC16Array& aProtocolArray)

{

    // Check that this is supported content type

    if (!IsSupportedContentTypeL(aContentType))

    {

        return;

    }

    aProtocolArray.AppendL(KMMAHttpProtocol);

    aProtocolArray.AppendL(KMMAHttpsProtocol);

    aProtocolArray.AppendL(KMMAFileProtocol);

}

TBool CMMAMMFPlayerFactory::IsSupportedProtocolL(const TDesC& aProtocol)

{

    // With null desc we are getting all

    if (aProtocol == KNullDesC)

    {

        return ETrue;

    }

    CDesC16ArraySeg* protocols = new(ELeave) CDesC16ArraySeg(KGranularity);

    CleanupStack::PushL(protocols);

    GetSupportedProtocolsL(KNullDesC, *protocols);

    TInt pos = KErrNotFound;

    // Find returns 0 if there contentType is found

    TBool retValue = (protocols->Find(aProtocol, pos) == 0);

    CleanupStack::PopAndDestroy(protocols);

    return retValue;

}

TBool CMMAMMFPlayerFactory::IsSupportedContentTypeL(const TDesC& aContentType)

{

    // With null desc we are getting all

    if (aContentType == KNullDesC)

    {

        return ETrue;

    }

    // Content type application/x-ext-packetsrc

    // must not be supported at the moment.

    if (aContentType == KContentTypePacketSrcNotIncluded)

    {

        return EFalse;

    }

    CDesC16ArraySeg* contentTypes = new(ELeave) CDesC16ArraySeg(KGranularity);

    CleanupStack::PushL(contentTypes);

    GetSupportedContentTypesL(KNullDesC, *contentTypes);

    TInt pos = KErrNotFound;

    // Find returns 0 if there contentType is found

    TBool retValue = (contentTypes->Find(aContentType, pos) == 0);

    CleanupStack::PopAndDestroy(contentTypes);

    return retValue;

}

EXPORT_C void CMMAMMFPlayerFactory::PreparePluginSelectionParametersL(

    CMMAMMFResolver* aResolver,

    CMMFFormatSelectionParameters* aFormatSelection)

{

    // Play type is default

    aResolver->SetRequiredPlayFormatSupportL(*aFormatSelection);

}

CMMFPluginSelectionParameters::TMediaIdMatchType

CMMAMMFPlayerFactory::MediaIdMatchType()

{

    // We are now getting only Audio Controllers

    return CMMFPluginSelectionParameters::EAllowOnlySuppliedMediaIds;

}

//  END OF FILE