/*

* 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 WMA agent

*

*/

#include <caf/rightsinfo.h>

#include "mpxmedia.h"

#include "mpxmediadrmdefs.h"

#include "mpxdrmmediawmaagent.h"

#include "mpxlog.h"

// CONSTANTS

_LIT(KMPXWmaDrmDelLicensesType, "licensetype=");

_LIT(KMPXWmaDrmDelUnlimited, "unlimited");

_LIT(KMPXWmaDrmDelTime, "time");

_LIT(KMPXWmaDrmDelCount, "count");

_LIT(KMPXWmaDrmDelDuration, "duration");

_LIT(KMPXWmaDrmDelTimeCount, "time-count");

_LIT(KMPXWmaDrmDelDurationLeft, "duration=");

_LIT(KMPXWmaDrmDelCountLeft, "countleft=");

_LIT(KMPXWmaDrmDelStartTime, "starttime=");

_LIT(KMPXWmaDrmDelEndTime, "endtime=");

_LIT(KMPXWmaDrmDelColon, ":");

_LIT(KMPXWmaDrmDelSemiColon, ";");

_LIT(KMPXWmaDrmTimeFill, "0");

const TInt KMPXWmaDrmMaxLicenseTypeBufSize = 30;

const TInt KMPXWmaDrmDashCount = 2;

const TInt KMPXWmaDrmMaxTimeBufSize = 3;

const TInt KMPXWmaDrmMinutesHourMinSize = 2;

const TText KMPXWmaDrmSemiColonChar = ';';

const TText KMPXWmaDrmDashChar = '-';

const TText KMPXWmaDrmTChar = 'T';

const TText KMPXWmaDrmColonChar = ':';

const TText KMPXWmaDrmPeriodChar = '.';

const TText KMPXWmaDrmZChar = 'Z';

const TText KMPXWmaDrmPlusChar = '+';

// -----------------------------------------------------------------------------

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CMPXDrmMediaWmaAgent* CMPXDrmMediaWmaAgent::NewL()

    {

    MPX_FUNC("CMPXDrmMediaWmaAgent::NewL()");

    CMPXDrmMediaWmaAgent* p = CMPXDrmMediaWmaAgent::NewLC();

    CleanupStack::Pop(p);

    return p;

    }

// -----------------------------------------------------------------------------

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CMPXDrmMediaWmaAgent* CMPXDrmMediaWmaAgent::NewLC()

    {

    MPX_FUNC("CMPXDrmMediaWmaAgent::NewLC()");

    CMPXDrmMediaWmaAgent* p = new (ELeave) CMPXDrmMediaWmaAgent();

    CleanupStack::PushL(p);

    p->ConstructL();

    return p;

    }

// -----------------------------------------------------------------------------

// Destructor

// -----------------------------------------------------------------------------

//

CMPXDrmMediaWmaAgent::~CMPXDrmMediaWmaAgent()

    {

    MPX_FUNC("CMPXDrmMediaWmaAgent::~CMPXDrmMediaWmaAgent()");

    Close();

    delete iRightsManager;

    delete iManager;

    }

// -----------------------------------------------------------------------------

// Default constructor

// -----------------------------------------------------------------------------

//

CMPXDrmMediaWmaAgent::CMPXDrmMediaWmaAgent()

    {

    MPX_FUNC("CMPXDrmMediaWmaAgent::CMPXDrmMediaWmaAgent()");

    }

// ----------------------------------------------------------------------------

// 2nd phase constructor.

// ----------------------------------------------------------------------------

//

void CMPXDrmMediaWmaAgent::ConstructL()

    {

    MPX_FUNC("CMPXDrmMediaWmaAgent::ConstructL()");

    RArray< TAgent > agents;

    CleanupClosePushL( agents );

    iManager = CManager::NewL();

    iManager->ListAgentsL( agents );

    if ( agents.Count() > 0)

        {

        TInt i( 0 );

        for ( i = 0; i < agents.Count(); i++ )

            {

            // break if we find the agent we want

            // CAF UID

            const TDesC& name( agents[i].Name() );

            if ( name.Compare( KMPXWDRMCafAgentName ) == 0 ||

                 name.Compare( KMPXS60WMDRMCafAgent ) == 0 )

                {

                break;

                }

            }

        if ( i < agents.Count() )

            {

            // We found the CAF agent

            MPX_DEBUG2("CMPXDrmMediaWmaAgent::ConstructL(): CAF agent=%d", i);

            iRightsManager = iManager->CreateRightsManagerL( agents[i] );

            }

        }

    CleanupStack::PopAndDestroy( &agents );

    }

// ----------------------------------------------------------------------------

// Initialize utility using a filename

// ----------------------------------------------------------------------------

//

void CMPXDrmMediaWmaAgent::InitL( const TDesC& aFileName )

    {

    MPX_DEBUG2("CMPXDrmMediaWmaAgent::InitL(%S) entering", &aFileName );

    MPX_DEBUG_THREAD("CMPXDrmMediaWmaAgent::InitL(aFileName)");

    Close();

    CreateMediaL();

    iData = CData::NewL(

        (TVirtualPathPtr) aFileName,

        EPeek,

        EContentShareReadOnly );

    iFileName = aFileName.AllocL();

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::InitL() exiting" );

    }

// ----------------------------------------------------------------------------

// Initialize utility using a file handle

// ----------------------------------------------------------------------------

//

void CMPXDrmMediaWmaAgent::InitL( RFile& aFile )

    {

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::InitL(RFile) entering" );

    MPX_DEBUG_THREAD("CMPXDrmMediaWmaAgent::InitL(aFile)");

    Close();

    CreateMediaL();

    iData = CData::NewL(

        aFile,

        KDefaultContentObject(),

        EPeek );

    TFileName filename;

    aFile.FullName( filename );

    iFileName = filename.AllocL();

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::InitL(RFile) exiting" );

    }

// ----------------------------------------------------------------------------

// Gets media object with the given attributes

// ----------------------------------------------------------------------------

//

const CMPXMedia& CMPXDrmMediaWmaAgent::GetMediaL( TUint aAttributes )

    {

    MPX_DEBUG2("CMPXDrmMediaWmaAgent::GetMediaL(%d) entering", aAttributes );

    MPX_DEBUG_THREAD("CMPXDrmMediaWmaAgent::GetRightsTypeL()");

    if ( iMedia )

        {

        if ( aAttributes & KMPXMediaDrmProtected.iAttributeId )

            {

            GetProtectedL();

            }

        if ( aAttributes & KMPXMediaDrmRightsStatus.iAttributeId )

            {

            GetRightsStatusL();

            }

        if ( aAttributes & KMPXMediaDrmRightsType.iAttributeId )

            {

            GetRightsTypeL();

            }

        if ( aAttributes & KMPXMediaDrmCount.iAttributeId )

            {

            GetCountL();

            }

        if ( aAttributes & KMPXMediaDrmStartTime.iAttributeId )

            {

            GetStartTimeL();

            }

        if ( aAttributes & KMPXMediaDrmEndTime.iAttributeId )

            {

            GetEndTimeL();

            }

        if ( aAttributes & KMPXMediaDrmInterval.iAttributeId )

            {

            GetIntervalL();

            }

        if ( aAttributes & KMPXMediaDrmIntervalStartTime.iAttributeId )

            {

            // Not Supported for WMA DRM

            }

        if ( aAttributes & KMPXMediaDrmAccumulatedTime.iAttributeId )

            {

            // Not Supported for WMA DRM

            }

        if ( aAttributes & KMPXMediaDrmSendingAllowed.iAttributeId )

            {

            GetSendingAllowedL();

            }

        if ( aAttributes & KMPXMediaDrmCanSetAutomated.iAttributeId )

            {

            GetCanSetAutomatedL();

            }

        if ( aAttributes & KMPXMediaDrmHasInfoUrl.iAttributeId )

            {

            // Not Supported for WMA DRM

            }

        if ( aAttributes & KMPXMediaDrmHasPreviewUrl.iAttributeId )

            {

            // Not Supported for WMA DRM

            }

        if ( aAttributes & KMPXMediaDrmAboutToExpire.iAttributeId )

            {

            GetAboutToExpireL();

            }

        }

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetMediaL() exiting" );

    return *iMedia;

    }

// ----------------------------------------------------------------------------

// Consumes the rights for the current media according

// to the specified consume type

// ----------------------------------------------------------------------------

//

void CMPXDrmMediaWmaAgent::ConsumeL(TDrmConsumeType /*aType*/)

    {

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::ConsumeL() entering");

    // WMA DRM does not have ability to manually control consumption

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::ConsumeL() exiting" );

    }

// ----------------------------------------------------------------------------

// Cleans up member variables

// ----------------------------------------------------------------------------

//

void CMPXDrmMediaWmaAgent::Close()

    {

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::Close() entering");

    CMPXDrmMediaAgent::Close();

    delete iFileName;

    iFileName = NULL;

    delete iRightsDescription;

    iRightsDescription = NULL;

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::Close() exiting");

    }

// ----------------------------------------------------------------------------

// Creates a new media object

// ----------------------------------------------------------------------------

//

void CMPXDrmMediaWmaAgent::CreateMediaL()

    {

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::CreateMediaL() entering");

    CMPXDrmMediaAgent::CreateMediaL();

    // Set the type to WMA

    iMedia->SetTObjectValueL( KMPXMediaDrmType,

                              EMPXDrmTypeWMA );

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::CreateMediaL() exiting");

    }

// ----------------------------------------------------------------------------

// Gets the rights status

// ----------------------------------------------------------------------------

//

void CMPXDrmMediaWmaAgent::GetRightsStatusL()

    {

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetRightsStatusL() entering");

    MPX_DEBUG_THREAD("CMPXDrmMediaWmaAgent::GetRightsStatusL()");

    if ( !iMedia->IsSupported( KMPXMediaDrmRightsStatus ))

        {

        // Check to make sure it's protected first

        if ( !iMedia->IsSupported( KMPXMediaDrmProtected ))

            {

            GetProtectedL();

            }

        TBool prot( iMedia->ValueTObjectL<TBool>( KMPXMediaDrmProtected ));

        MPX_DEBUG2("CMPXDrmMediaWmaAgent::GetRightsStatusL(): prot = %d", prot);

        TInt rightsStatus( EMPXDrmRightsFull );

        if ( prot )

            {

            TBool canPlay( ETrue );

#ifndef _DEBUG

            User::LeaveIfError( iData->GetAttribute( ECanPlay, canPlay ));

#else

            MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetRightsStatusL(): Getting ECanPlay");

            TInt playErr( iData->GetAttribute( ECanPlay, canPlay ));

            MPX_DEBUG3("CMPXDrmMediaWmaAgent::GetRightsStatusL(): err = %d, canPlay = %d", playErr, canPlay );

            User::LeaveIfError( playErr );

#endif

            if ( !canPlay )

                {

                rightsStatus = EMPXDrmRightsExpired;

                }

            else

                {

                TBool rightsStateless( ETrue );

                TBool rightsConsumable( EFalse );

#ifndef _DEBUG

                User::LeaveIfError( iData->GetAttribute(

                                        ERightsStateless,

                                        rightsStateless ));

                User::LeaveIfError( iData->GetAttribute(

                                        ERightsConsumable,

                                        rightsConsumable ));

#else

                MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetRightsStatusL(): Getting ERightsStateless");

                TInt statusErr( iData->GetAttribute(

                                    ERightsStateless,

                                    rightsStateless ));

                MPX_DEBUG3("CMPXDrmMediaWmaAgent::GetRightsStatusL(): err = %d, rightsStateless = %d", statusErr, rightsStateless );

                User::LeaveIfError( statusErr );

                MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetRightsStatusL(): Getting ERightsConsumable");

                TInt conumeableErr( iData->GetAttribute(

                                        ERightsConsumable,

                                        rightsConsumable ));

                MPX_DEBUG3("CMPXDrmMediaWmaAgent::GetRightsStatusL(): err = %d, rightsConsumable = %d", conumeableErr, rightsConsumable );

                User::LeaveIfError( conumeableErr );

#endif

                if ( !rightsStateless || rightsConsumable )

                    {

                    rightsStatus = EMPXDrmRightsRestricted;

                    }

                else

                    {

                    if ( !iMedia->IsSupported( KMPXMediaDrmRightsType ))

                        {

                        GetRightsTypeL();

                        }

                    TInt rightsType( iMedia->ValueTObjectL<TInt>(

                        KMPXMediaDrmRightsType ));

                    if ( EMPXDrmRightsTypeNoRestriction == rightsType )

                        {

                        rightsStatus = EMPXDrmRightsFull;

                        }

                    else

                        {

                        rightsStatus = EMPXDrmRightsRestricted;

                        }

                    }

                }

            }

        iMedia->SetTObjectValueL( KMPXMediaDrmRightsStatus,

                                  rightsStatus );

        MPX_DEBUG2("CMPXDrmMediaWmaAgent::GetRightsStatusL(): setting status = %d", rightsStatus);

        }

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetRightsStatusL() exiting");

    }

// ----------------------------------------------------------------------------

// Gets the rights type attribute if not already obtained

// ----------------------------------------------------------------------------

//

void CMPXDrmMediaWmaAgent::GetRightsTypeL()

    {

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetRightsTypeL() entering");

    MPX_DEBUG_THREAD("CMPXDrmMediaWmaAgent::GetRightsTypeL()");

    if ( !iMedia->IsSupported( KMPXMediaDrmRightsType ))

        {

        TInt rightsType( EMPXDrmRightsTypeNoRestriction );

        if ( GetWmdrmRightsDescriptionL() == KErrNone )

            {

            TPtr strPtr( iRightsDescription->Des() );

            TInt end( strPtr.FindF( KMPXWmaDrmDelSemiColon ));

            HBufC* licensetype( HBufC::NewLC( KMPXWmaDrmMaxLicenseTypeBufSize ));

            TPtr licensetypePtr( licensetype->Des());

            licensetypePtr = strPtr.Mid(

                                KMPXWmaDrmDelLicensesType().Length(),

                                end - KMPXWmaDrmDelLicensesType().Length() );

            if ( licensetypePtr == KMPXWmaDrmDelUnlimited )

                {

                rightsType = EMPXDrmRightsTypeNoRestriction;

                }

            else if ( licensetypePtr == KMPXWmaDrmDelTime )

                {

                rightsType = EMPXDrmRightsTypeTime;

                }

            else if ( licensetypePtr == KMPXWmaDrmDelCount )

                {

                rightsType = EMPXDrmRightsTypeCount;

                }

            else if ( licensetypePtr == KMPXWmaDrmDelDuration )

                {

                rightsType = EMPXDrmRightsTypeInterval;

                }

            else if ( licensetypePtr == KMPXWmaDrmDelTimeCount )

                {

                rightsType = EMPXDrmRightsTypeTimeCount;

                }

            CleanupStack::PopAndDestroy( licensetype );

            }

        iMedia->SetTObjectValueL( KMPXMediaDrmRightsType,

                                  rightsType );

        MPX_DEBUG2("CMPXDrmMediaWmaAgent::GetRightsTypeL() setting type = %d", rightsType);

        }

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetRightsTypeL() exiting");

    }

// ----------------------------------------------------------------------------

// Gets the count attribute if not already obtained

// ----------------------------------------------------------------------------

//

void CMPXDrmMediaWmaAgent::GetCountL()

    {

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetCountL() entering");

    // Do not need to check if it already supported, we

    // just overwrite the old value if possible

    TUint32 count( 0 );

    if ( GetWmdrmRightsDescriptionL() == KErrNone )

        {

        TPtr strPtr( iRightsDescription->Des() );

        if ( strPtr.FindF( KMPXWmaDrmDelLicensesType ) == KErrNone )

            {

            TInt begin( strPtr.FindF( KMPXWmaDrmDelCountLeft ));

            if ( begin != KErrNotFound )

                {

                TPtrC countPtr( strPtr.Mid( begin ));

                TInt semiLoc( countPtr.Locate( KMPXWmaDrmSemiColonChar ));

                TInt countLen( KMPXWmaDrmDelCountLeft().Length() );

                TLex lex( strPtr.MidTPtr( begin + countLen, semiLoc - countLen ) );

                User::LeaveIfError( lex.Val( count, EDecimal ) );

                iMedia->SetTObjectValueL( KMPXMediaDrmCount,

                                          count );

                MPX_DEBUG2("CMPXDrmMediaWmaAgent::GetCountL(): setting count = %d", count);

                }

            }

        }

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetCountL() exiting");

    }

// ----------------------------------------------------------------------------

// Gets the start time attribute if not already obtained

// ----------------------------------------------------------------------------

//

void CMPXDrmMediaWmaAgent::GetStartTimeL()

    {

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetStartTimeL() entering");

    if ( !iMedia->IsSupported( KMPXMediaDrmStartTime ))

        {

        TTime startTime;

        if ( GetWmdrmTimeL( KMPXWmaDrmDelStartTime, startTime ) ==

             KErrNone )

            {

            iMedia->SetTObjectValueL( KMPXMediaDrmStartTime,

                                      startTime.Int64() );

            MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetStartTimeL(): setting start time");

            }

        }

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetStartTimeL() exiting");

    }

// ----------------------------------------------------------------------------

// Gets the end time attribute if not already obtained

// ----------------------------------------------------------------------------

//

void CMPXDrmMediaWmaAgent::GetEndTimeL()

    {

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetEndTimeL() entering");

    if ( !iMedia->IsSupported( KMPXMediaDrmEndTime ))

        {

        TTime endTime;

        if ( GetWmdrmTimeL( KMPXWmaDrmDelEndTime, endTime ) ==

             KErrNone )

            {

            iMedia->SetTObjectValueL( KMPXMediaDrmEndTime,

                                      endTime.Int64() );

            MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetEndTimeL(): setting end time");

            }

        }

    MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetEndTimeL() exiting");

    }

// ----------------------------------------------------------------------------

// Gets the interval attribute if not already obtained

// ----------------------------------------------------------------------------

//

void CMPXDrmMediaWmaAgent::GetIntervalL()

    {