/*
* Copyright (c) 2006 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:  EXPORT_C implementation of drm media utility
*
*/


#include <bautils.h>
#include <mpxmedia.h>
#include "mpxdrmmediautility.h"
#include "mpxdrmmediaomaagent.h"
#include "mpxdrmmediawmaagent.h"
#include "mpxmediadrmdefs.h"
#include "mpxlog.h"

// -----------------------------------------------------------------------------
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CMPXDrmMediaUtility* CMPXDrmMediaUtility::NewL()
    {
    MPX_FUNC("CMPXDrmMediaUtility::NewL()");
    CMPXDrmMediaUtility* p = new (ELeave) CMPXDrmMediaUtility();
    CleanupStack::PushL(p);
    p->ConstructL();
    CleanupStack::Pop(p);
    return p;
    }

// -----------------------------------------------------------------------------
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CMPXDrmMediaUtility* CMPXDrmMediaUtility::NewLC()
    {
    MPX_FUNC("CMPXDrmMediaUtility::NewLC()");
    CMPXDrmMediaUtility* p = new (ELeave) CMPXDrmMediaUtility();
    CleanupStack::PushL(p);
    p->ConstructL();
    return p;
    }

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
EXPORT_C CMPXDrmMediaUtility::~CMPXDrmMediaUtility()
    {
    MPX_FUNC("CMPXDrmMediaUtility::~CMPXDrmMediaUtility()");
    iAgents.ResetAndDestroy();
    iAgents.Close();
    delete iDefaultMedia;
    iFs.Close();
    }

// -----------------------------------------------------------------------------
// Default constructor
// -----------------------------------------------------------------------------
//
CMPXDrmMediaUtility::CMPXDrmMediaUtility()
    {
    MPX_FUNC("CMPXDrmMediaUtility::CMPXDrmMediaUtility()");
    }

// ----------------------------------------------------------------------------
// 2nd phase constructor.
// ----------------------------------------------------------------------------
//
void CMPXDrmMediaUtility::ConstructL()
    {
    MPX_FUNC("CMPXDrmMediaUtility::ConstructL()");

    // Create the OMA Agent
    CMPXDrmMediaOmaAgent* omaAgent = CMPXDrmMediaOmaAgent::NewLC();
    iAgents.Insert( omaAgent, EOmaDrmAgent );
    CleanupStack::Pop( omaAgent );

    // Create the WMA Agent
    CMPXDrmMediaWmaAgent* wmaAgent = CMPXDrmMediaWmaAgent::NewLC();
    iAgents.Insert( wmaAgent, EWmaDrmAgent );
    CleanupStack::Pop( wmaAgent );

    // Create a default media
    RArray<TInt> supportedIds;
    CleanupClosePushL( supportedIds );
    supportedIds.AppendL(KMPXMediaIdDrm);
    iDefaultMedia = CMPXMedia::NewL( supportedIds.Array() );
    CleanupStack::PopAndDestroy( &supportedIds );
    iDefaultMedia->SetTObjectValueL( KMPXMediaDrmProtected,
                                     EFalse );

    // Create file system session
    User::LeaveIfError( iFs.Connect() );
    }


// ----------------------------------------------------------------------------
// Initialize utility using a filename
// ----------------------------------------------------------------------------
//
EXPORT_C void CMPXDrmMediaUtility::InitL( const TDesC& aFileName )
    {
    MPX_DEBUG2("CMPXDrmMediaUtility::InitL(%S) entering", &aFileName );

    Close();

    if ( BaflUtils::FileExists( iFs, aFileName ))
        {
        CContent* content( CContent::NewLC( aFileName, EContentShareReadWrite ));
        FindAgent( *content );
        if ( iCurrentAgent )
            {
            iCurrentAgent->InitL( aFileName );
            }
        CleanupStack::PopAndDestroy( content );
        }
    iConsumeStarted = EFalse;

    MPX_DEBUG1("CMPXDrmMediaUtility::InitL() exiting" );
    }

// ----------------------------------------------------------------------------
// Initialize utility using a file handle
// ----------------------------------------------------------------------------
//
EXPORT_C void CMPXDrmMediaUtility::InitL( RFile& aFile )
    {
    MPX_DEBUG1("CMPXDrmMediaUtility::InitL(RFile) entering" );

    Close();
    CContent* content = CContent::NewLC( aFile );
    FindAgent( *content );
    if ( iCurrentAgent )
        {
        iCurrentAgent->InitL( aFile );
        }
    CleanupStack::PopAndDestroy( content );
    iConsumeStarted = EFalse;

    MPX_DEBUG1("CMPXDrmMediaUtility::InitL(RFile) exiting" );
    }

// ----------------------------------------------------------------------------
// Gets media object with the given attributes
// ----------------------------------------------------------------------------
//
EXPORT_C const CMPXMedia* CMPXDrmMediaUtility::GetMediaL( TUint aAttributes )
    {
    MPX_DEBUG2("CMPXDrmMediaUtility::GetMediaL(%d) entering", aAttributes );

    const CMPXMedia* media( NULL );
    if ( iCurrentAgent )
        {
        media = &( iCurrentAgent->GetMediaL( aAttributes ));
        }
    else
        {
        MPX_DEBUG1("CMPXDrmMediaUtility::GetMediaL(): Returning default media");
        media = iDefaultMedia;
        }

    MPX_DEBUG1("CMPXDrmMediaUtility::GetMediaL() exiting" );
    return media;
    }


// ----------------------------------------------------------------------------
// Consumes the rights for the current media according
// to the specified consume type
// ----------------------------------------------------------------------------
//
EXPORT_C void CMPXDrmMediaUtility::ConsumeL( TDrmConsumeType aType )
    {
    MPX_DEBUG1("CMPXDrmMediaUtility::ConsumeL() entering");

    if ( iCurrentAgent )
        {
        TDrmConsumeType type( EMPXDrmConsumeNone );
        const CMPXMedia& media( iCurrentAgent->GetMediaL( EMPXMediaDrmProtected ));
        if ( media.ValueTObjectL<TBool>( KMPXMediaDrmProtected ))
            {
            switch ( aType )
                {
                case EMPXDrmConsumeStart:
                    {
                    type = aType;
                    iConsumeStarted = ETrue;
                    break;
                    }
                case EMPXDrmConsumePause:
                case EMPXDrmConsumeContinue:
                case EMPXDrmConsumeFinish:
                    {
                    if ( iConsumeStarted )
                        {
                        type = aType;
                        if ( EMPXDrmConsumeFinish == aType )
                            {
                            iConsumeStarted = EFalse;
                            }
                        }
                    break;
                    }
                case EMPXDrmConsumeStartOrContinue:
                    {
                    if ( iConsumeStarted )
                        {
                        type = EMPXDrmConsumeContinue;
                        }
                    else
                        {
                        type = EMPXDrmConsumeStart;
                        iConsumeStarted = ETrue;
                        }
                    break;
                    }
                default:
                    {
                    type = EMPXDrmConsumeNone;
                    iConsumeStarted = EFalse;
                    break;
                    }
                }

            if ( EMPXDrmConsumeNone != type )
                {
                iCurrentAgent->ConsumeL( type );
                }
            }
        else
            {
            iConsumeStarted = EFalse;
            }
        }

    MPX_DEBUG1("CMPXDrmMediaUtility::ConsumeL() exiting" );
    }

// ----------------------------------------------------------------------------
// Closes and unitializes the utility
// ----------------------------------------------------------------------------
//
EXPORT_C void CMPXDrmMediaUtility::Close()
    {
    MPX_DEBUG1("CMPXDrmMediaUtility::Close() entering" );

    if ( iCurrentAgent )
        {
        iCurrentAgent->Close();
        iCurrentAgent = NULL;
        }

    MPX_DEBUG1("CMPXDrmMediaUtility::Close() exiting" );
    }

// ----------------------------------------------------------------------------
// Finds an agent to handle the content
// ----------------------------------------------------------------------------
//
void CMPXDrmMediaUtility::FindAgent( CContent& aContent )
    {
    MPX_DEBUG1("CMPXDrmMediaUtility::FindAgent() entering" );

    TAgent agent( aContent.Agent() );
    if ( agent.Name() == KMPXWDRMCafAgentName ||
         agent.Name() == KMPXS60WMDRMCafAgent )
        {
        iCurrentAgent = iAgents[EWmaDrmAgent];
        }
    else if ( agent.Name() == KMPXOMACafAgentName )
        {
        iCurrentAgent = iAgents[EOmaDrmAgent];
        }
    else
        {
        iCurrentAgent = NULL;
        }
    MPX_DEBUG1("CMPXDrmMediaUtility::FindAgent() exiting" );
    }