/*

* 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:  Implementation of drm media OMA agent

*

*/

#include <caf/rightsinfo.h>

#ifdef CAMESE_IN_DRM_UTILITY

#include <drmuihandling.h>

#include <drmutility.h>

#include <drmrightsinfo.h>

#include <drmautomatedusage.h>

#include <caf/data.h>

#include <DRMRights.h>

#include <DRMCommon.h>

#else

#include <DRMHelper.h>

#endif

#include "mpxmedia.h"

#include "mpxmediadrmdefs.h"

#include "mpxdrmmediaomaagent.h"

#include "mpxlog.h"

// CONSTANTS

const TUint32 KMPXAboutToExpireCount = 3;

const TInt KMPXAboutToExpireTime = 7;

const TInt KMPXAboutToExpireAccTime = 15*60;    // 15 minutes

const TInt KMPXSecondsInDay = 86400;

#ifdef CAMESE_IN_DRM_UTILITY

const TInt KUrlMaxLen( 1024 ); // Same than in DRMHelper

#endif

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

// Two-phased constructor.

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

//

CMPXDrmMediaOmaAgent* CMPXDrmMediaOmaAgent::NewL()

    {

    MPX_FUNC("CMPXDrmMediaOmaAgent::NewL()");

    CMPXDrmMediaOmaAgent* p = CMPXDrmMediaOmaAgent::NewLC();

    CleanupStack::Pop(p);

    return p;

    }

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

// Two-phased constructor.

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

//

CMPXDrmMediaOmaAgent* CMPXDrmMediaOmaAgent::NewLC()

    {

    MPX_FUNC("CMPXDrmMediaOmaAgent::NewLC()");

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

    CleanupStack::PushL(p);

    p->ConstructL();

    return p;

    }

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

// Destructor

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

//

CMPXDrmMediaOmaAgent::~CMPXDrmMediaOmaAgent()

    {

    MPX_FUNC("CMPXDrmMediaOmaAgent::~CMPXDrmMediaOmaAgent()");

    Close();

#ifdef CAMESE_IN_DRM_UTILITY

    delete iDrmHandler;

    if ( iDRMCommon )

        {

        iDRMCommon->Disconnect();

        }

    delete iDRMCommon;

#else

    delete iDrmHelper;

#endif

    iFs.Close();

    }

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

// Default constructor

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

//

CMPXDrmMediaOmaAgent::CMPXDrmMediaOmaAgent()

    {

    MPX_FUNC("CMPXDrmMediaOmaAgent::CMPXDrmMediaOmaAgent()");

    }

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

// 2nd phase constructor.

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

//

void CMPXDrmMediaOmaAgent::ConstructL()

    {

    MPX_FUNC("CMPXDrmMediaOmaAgent::ConstructL()");

    User::LeaveIfError( iFs.Connect() );

#ifdef CAMESE_IN_DRM_UTILITY

    iDrmHandler = DRM::CDrmUiHandling::NewL();

    iDRMCommon = DRMCommon::NewL();

    User::LeaveIfError( iDRMCommon->Connect() );

#else

    iDrmHelper = CDRMHelper::NewL();

#endif

    }

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

// Initialize utility using a filename

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

//

void CMPXDrmMediaOmaAgent::InitL( const TDesC& aFileName )

    {

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

    Close();

    CreateMediaL();

    iData = CData::NewL(

        (TVirtualPathPtr) aFileName,

        EPeek,

        EContentShareReadOnly );

    User::LeaveIfError( iFile.Open( iFs, aFileName, EFileShareReadersOrWriters ));

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

    }

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

// Initialize utility using a file handle

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

//

void CMPXDrmMediaOmaAgent::InitL( RFile& aFile )

    {

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

    Close();

    CreateMediaL();

    iData = CData::NewL(

        aFile,

        KDefaultContentObject(),

        EPeek );

    User::LeaveIfError( iFile.Duplicate( aFile ) );

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

    }

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

// Gets media object with the given attributes

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

//

const CMPXMedia& CMPXDrmMediaOmaAgent::GetMediaL( TUint aAttributes )

    {

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

    if ( iMedia )

        {

        if ( aAttributes & KMPXMediaDrmProtected.iAttributeId )

            {

            GetProtectedL();

            }

        if (( aAttributes & KMPXMediaDrmRightsStatus.iAttributeId ) ||

            ( aAttributes & KMPXMediaDrmSendingAllowed.iAttributeId ))

            {

            GetRightsDetailsL();

            }

        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 )

            {

            GetIntervalStartTimeL();

            }

        if ( aAttributes & KMPXMediaDrmAccumulatedTime.iAttributeId )

            {

            GetAccumulatedTimeL();

            }

        if ( aAttributes & KMPXMediaDrmCanSetAutomated.iAttributeId )

            {

            GetCanSetAutomatedL();

            }

        if ( aAttributes & KMPXMediaDrmHasInfoUrl.iAttributeId )

            {

            GetHasInfoUrlL();

            }

        if ( aAttributes & KMPXMediaDrmHasPreviewUrl.iAttributeId )

            {

            GetHasPreviewUrlL();

            }

        if ( aAttributes & KMPXMediaDrmAboutToExpire.iAttributeId )

            {

            GetAboutToExpireL();

            }

        }

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

    return *iMedia;

    }

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

// Consumes the rights for the current media according

// to the specified consume type

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

//

void CMPXDrmMediaOmaAgent::ConsumeL( TDrmConsumeType aType )

    {

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

#ifdef CAMESE_IN_DRM_UTILITY

    // ConsumeL is not used at the moment

    ASSERT(0);

    User::Leave( KErrNotSupported );

#else

    if ( iMedia )

        {

        CDRMHelper::TDRMHelperConsumeAction action( CDRMHelper::EStart );

        switch ( aType )

            {

            case ( EMPXDrmConsumeStart ):

            {

            action = CDRMHelper::EStart;

            break;

            }

            case ( EMPXDrmConsumePause ):

            {

            action = CDRMHelper::EPause;

            break;

            }

            case ( EMPXDrmConsumeContinue ):

            {

            action = CDRMHelper::EContinue;

            break;

            }

            case ( EMPXDrmConsumeFinish ):

            {

            action = CDRMHelper::EFinish;

            break;

            }

            default:

                {

                break;

                }

            }

        User::LeaveIfError( iDrmHelper->ConsumeFile2(

                iFile,

                ContentAccess::EPlay,

                action ));

        }

#endif 

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

    }

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

// Closes and uninitializes the agent and cleans up member variables

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

//

void CMPXDrmMediaOmaAgent::Close()

    {

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

    CMPXDrmMediaAgent::Close();

    delete iRightsConstraints;

    iRightsConstraints = NULL;

    iFile.Close();

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

    }

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

// Creates a new media object

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

//

void CMPXDrmMediaOmaAgent::CreateMediaL()

    {

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

    CMPXDrmMediaAgent::CreateMediaL();

    // Set the type to OMA

    iMedia->SetTObjectValueL( KMPXMediaDrmType, EMPXDrmTypeOMA );

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

    }

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

// Gets the rights details

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

//

void CMPXDrmMediaOmaAgent::GetRightsDetailsL()

    {

    MPX_DEBUG1("CXMPXDrmMediaOmaAgent::GetRightsDetailsL() entering");

    if ( !iMedia->IsSupported( KMPXMediaDrmRightsStatus ) ||

         !iMedia->IsSupported( KMPXMediaDrmSendingAllowed ))

        {

#ifdef CAMESE_IN_DRM_UTILITY

        TBool expired( EFalse );

        TBool sendingAllowed( ETrue );

        HBufC* contentURI = NULL;

        HBufC8* contentURI8 = NULL;

        CDRMRights* activeRights = NULL;

        // Get forwardable status from CAF

        User::LeaveIfError( iData->GetAttribute( EIsForwardable, sendingAllowed ) ) ;

        // Get constraints. Copied from CDRMHelper::GetRightsDetailsL 

        contentURI = HBufC::NewLC( KUrlMaxLen );

        TPtr ptr = contentURI->Des();

        User::LeaveIfError( iData->GetStringAttribute( EContentID, ptr ) );

        contentURI8 = HBufC8::NewLC( contentURI->Length() );

        contentURI8->Des().Copy( contentURI->Des() );

        // GetActiveRights returns negative value if rights are not valid

        if ( iDRMCommon->GetActiveRights( *contentURI8, ContentAccess::EPlay, activeRights ) > 0 )

            {

            // rights are valid

            activeRights->GetPlayRight( iRightsConstraints );

            }

        else 

        	{

        	expired = ETrue;        

        	}

        CleanupStack::PopAndDestroy( 2 ); // contentURI8, contentURI

#else

        TInt error( KErrNone );

        TBool expired( EFalse );

        TBool sendingAllowed( ETrue );

        CDRMHelperRightsConstraints* ignore1( NULL );

        CDRMHelperRightsConstraints* ignore2( NULL );

        CDRMHelperRightsConstraints* ignore3( NULL );

        delete iRightsConstraints;

        iRightsConstraints = NULL;

        TRAP( error, iDrmHelper->GetRightsDetailsL(

                iFile,

                ContentAccess::EPlay,

                expired,

                sendingAllowed,

                iRightsConstraints,

                ignore1,

                ignore2,

                ignore3 ));

        delete ignore1;

        delete ignore2;

        delete ignore3;

#endif  

        if ( expired )

            {

            iMedia->SetTObjectValueL( KMPXMediaDrmRightsStatus,

                                      EMPXDrmRightsExpired );

            }

        else if ( iRightsConstraints )

            {

            if ( iRightsConstraints->IsPreview() )

                {

                iMedia->SetTObjectValueL( KMPXMediaDrmRightsStatus,

                                          EMPXDrmRightsPreview );

                }

            else if ( iRightsConstraints->FullRights() )

                {

                iMedia->SetTObjectValueL( KMPXMediaDrmRightsStatus,

                                          EMPXDrmRightsFull );

                }

            else

                {

                iMedia->SetTObjectValueL( KMPXMediaDrmRightsStatus,

                                          EMPXDrmRightsRestricted );

                }

            }

        else

            {

            // Not expired, no constraints object obtainable,

            // so check if it's protected

            if ( !iMedia->IsSupported( KMPXMediaDrmProtected ))

                {

                GetProtectedL();

                }

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

            if ( prot )

                {

                iMedia->SetTObjectValueL( KMPXMediaDrmRightsStatus,

                                          EMPXDrmRightsMissing );

                }

            else

                {

                iMedia->SetTObjectValueL( KMPXMediaDrmRightsStatus,

                                          EMPXDrmRightsFull );

                }

            }

        iMedia->SetTObjectValueL( KMPXMediaDrmSendingAllowed,

                                  sendingAllowed );

        }

    MPX_DEBUG1("CXMPXDrmMediaOmaAgent::GetRightsDetailsL() exiting");

    }

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

// Gets the rights type attribute if not already obtained

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

//

void CMPXDrmMediaOmaAgent::GetRightsTypeL()

    {

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

    if ( !iMedia->IsSupported( KMPXMediaDrmRightsType ))

        {

        // Check if it's protected or not first

        if ( !iMedia->IsSupported( KMPXMediaDrmProtected ))

            {

            GetProtectedL();

            }

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

        if ( !prot )

            {

            iMedia->SetTObjectValueL( KMPXMediaDrmRightsType,

                                      EMPXDrmRightsTypeNoRestriction );

            }

        else

            {

            // Else it's a protected file, so get the rights constraints

            if ( !iRightsConstraints )

                {

                GetRightsDetailsL();

                }

            // Check if it's a count based rights

            GetCountL();

            if ( !iMedia->IsSupported( KMPXMediaDrmCount ))

                {

                // Check if it's time based

                GetStartTimeL();

                if ( !iMedia->IsSupported( KMPXMediaDrmStartTime ))

                    {

                    // Check if it's interval based

                    GetIntervalL();

                    if ( !iMedia->IsSupported( KMPXMediaDrmInterval ))

                        {

                        // Check if it's accumulated time based

                        GetAccumulatedTimeL();

                        if ( !iMedia->IsSupported( KMPXMediaDrmAccumulatedTime ))

                            {

                            // not have any of the restriction types

                            iMedia->SetTObjectValueL(

                                KMPXMediaDrmRightsType,

                                EMPXDrmRightsTypeNoRestriction );

                            }   // else not accumulated time

                        }   // else not interval

                    }   // else not time based

                }   // else not count based

            }   // else protected file

        }

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

    }

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

// Gets the count attribute if not already obtained

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

//

void CMPXDrmMediaOmaAgent::GetCountL()

    {

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

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

    // just overwrite the old value if possible

    if ( !iRightsConstraints )

        {

        GetRightsDetailsL();

        }

    if ( iRightsConstraints )

        {

        TUint32 countLeft( 0 );

        TUint32 originalCount( 0 );

        TUint32 timedCount( 0 );

#ifdef CAMESE_IN_DRM_UTILITY

        // Logic copied from CDRMHelperRightsConstraints

        TInt error1 = iRightsConstraints->GetCounters( countLeft, originalCount );

        TBool timedCounter = EFalse;

        if ( ( iRightsConstraints->GetConstraint()).iActiveConstraints &

        	EConstraintTimedCounter )

            {

            timedCount = ( iRightsConstraints->GetConstraint()).iTimedCounter;

            timedCounter = ETrue;

            }

        if ( timedCounter )

            {

            iMedia->SetTObjectValueL( KMPXMediaDrmRightsType,

                                      EMPXDrmRightsTypeTimeCount );

            if ( error1 != DRMCommon::ENoRights )

                {

                countLeft = Min( countLeft, timedCount );

                }

            else

                {