/*

* Copyright (c) 2005 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 the class CDRMConsume.

*

*/

// INCLUDE FILES

#include "drmconsume.h"

#include "drmenginetypedefs.h"

#include "drmrightsdb.h"

#include "DRMRightsServer.h"

#include "DRMDbSession.h"

#include "drmlog.h"

#include "DRMEventModify.h"

#include "DRMNotifier.h"

#ifdef RD_DRM_METERING

#include "drmmeteringdb.h"

#include "drmmeteringdbdata.h"

#include "RoapStorageClient.h"

#include "DRMRIContext.h"

#endif

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

#define NOTIFIER static_cast< CDRMRightsServer* >( const_cast< CServer2* >( \

           iSession.Server() ) )->Notifier()

#define DB static_cast< CDRMRightsServer* >( const_cast< CServer2* >( \

           iSession.Server() ) )->Database()

#define SECURETIME( a ) static_cast< CDRMRightsServer* >\

           ( const_cast< CServer2* >( \

           iSession.Server() ) )->GetSecureTime( a )

#define SERVER static_cast< CDRMRightsServer* >( const_cast< CServer2* >( \

           iSession.Server() ) )

#ifdef RD_DRM_METERING

#define METERINGDB static_cast< CDRMRightsServer* >( const_cast< CServer2* >( \

           iSession.Server() ) )->MeteringDatabase()

#endif

#define SETBIT( a, b ) ( a ) |= ( b )

#define CLRBIT( a, b ) ( a ) &= ~( 0xff & b )

#define ISSET( a, b ) ( ( a ) & ( b ) )

// LOCAL CONSTANTS AND MACROS

// Keeps track about modified permissions for UpdateDBL().

//static const TUint8 KConsumeParentModified =   0x01;

static const TUint8 KConsumeChildModified =    0x02;

static const TUint8 KConsumeHasSecureTime =    0x08;

// These keep track whether to decrease timed counters when consuming time

// based stuff (iTimedCounts member). A used timed count bit is set to zero.

// In the beginning all of these are set to one.

//static const TUint8 KParentToplevelCount =     0x01;

//static const TUint8 KParentPermCount     =     0x02;

static const TUint8 KChildToplevelCount  =     0x04;

static const TUint8 KChildPermCount      =     0x08;

static const TUint16 KConsumeDefaultTimer = 300; // 5mins

// LOCAL FUNCTION PROTOTYPES

static inline void PickSmaller( TTime& aFirst,

                                const TTime& aSecond );

// ============================= LOCAL FUNCTIONS ==========================

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

// PickSmaller (overloaded)

//

// Set the smaller one to aFirst

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

//

void PickSmaller( TTime& aFirst,

                  const TTime& aSecond )

    {

    if ( aSecond < aFirst )

        {

        aFirst = aSecond;

        }

    }

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

// PickSmaller (overloaded)

//

// Set the smaller one to aFirst

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

//

void PickSmaller( TTimeIntervalSeconds& aFirst,

                  const TTimeIntervalSeconds& aSecond )

    {

    if ( aSecond < aFirst )

        {

        aFirst = aSecond;

        }

    }

// ============================ MEMBER FUNCTIONS ==========================

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

// CDRMConsume::NewLC

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

//

CDRMConsume* CDRMConsume::NewLC( CDRMDbSession& aSession,

                                 const TDesC8& aURI,

                                 const TDesC8* aParentId )

    {

    DRMLOG( _L( "CDRMConsume::NewLC" ) );

    CDRMConsume* self = new( ELeave ) CDRMConsume( aSession );

    CleanupStack::PushL( self );

    self->ConstructL( aURI, aParentId );

    DRMLOG( _L( "CDRMConsume::NewLC ok" ) );

    return self;

    }

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

// CDRMConsume::~CDRMConsume

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

//

CDRMConsume::~CDRMConsume()

    {

    DRMLOG( _L( "CDRMConsume::~" ) );

    TInt error( KErrNone );

    if( IsActive() )

        {

        Cancel();

        }

    else

        {

        TRAP( error, DoCancelL() );

        }

    #ifdef RD_DRM_METERING

        // Update metering count and metering accumulated time to the database.

        TRAP( error, UpdateMeteringDbL() );

    #endif

    // ignore errors

    //TRAP( error, UpdateDBL() );

    delete iURI; iURI = NULL;

    delete iParentId; iParentId = NULL;

    delete iChild; iChild = NULL;

    delete iCombined; iCombined = NULL;

    DRMLOG( _L( "CDRMConsume::~ ok" ) );

    }

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

// CDRMConsume::CDRMConsume

//

// The internal state members iTimedCounts and iCounters are by default

// set to 00001111b, and the appropriate bits are lowered when something

// changes.

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

//

CDRMConsume::CDRMConsume( CDRMDbSession& aSession ):

    CTimer( EPriorityHigh ),

    iSession( aSession ),

    iIntent( ContentAccess::EUnknown ),

    iURI( NULL ),

    iParentId( NULL ),

    iTimedCounts( 0xf ),

    iCounters( 0xf ),

    iCountConstraintActive( EFalse ),

    iExpired( EFalse ),

    iCumulativeDelayTop( 0 ),

    iCumulativeDelayChild( 0 ),

    iTotalCumulativeTime( 0 ),

    iUsingTimedCount( 0 )

    {

    }

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

// CDRMConsume::ConstructL

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

//

void CDRMConsume::ConstructL( const TDesC8& aURI,

                              const TDesC8* aParentId )

    {

    DRMLOG( _L( "CDRMConsume::ConstructL" ) );

    CTimer::ConstructL();

    iURI = aURI.AllocL();

    if( aParentId )

        {

        iParentId = aParentId->AllocL();

        }

    }

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

// CDRMConsume::HandleL

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

//

void CDRMConsume::HandleL( ContentAccess::TIntent aIntent )

    {

    DRMLOG( _L( "CDRMConsume::HandleL" ) );

    TTime time;

    TBool secure( SECURETIME( time ) );

    InitializeL( aIntent, secure, time );

    DRMLOG( _L( "CDRMConsume::HandleL ok" ) );

    }

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

// CDRMConsume:: Pause

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

//

void CDRMConsume::Pause()

    {

    DRMLOG( _L( "CDRMConsume::Pause" ) );

    Cancel();

    DRMLOG( _L( "CDRMConsume::Pause ok" ) );

    }

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

// CDRMConsume:: ContinueL

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

//

void CDRMConsume::ContinueL()

    {

    DRMLOG( _L( "CDRMConsume::ContinueL" ) );

    Cancel();

    TInt error = KErrNone;

    TUint32 reason = 0;

    CDRMPermission* child = NULL;

    HBufC8* parent = NULL;

    // This got removed by Pause()

    if( iCountConstraintActive )

        {

        SERVER->AddActiveCountConstraintL( *iURI );

        DoContinueL();

        return;

        }

    /* Fetch the RO again in order to manage a situation when another

       instance has used the same RO (content has been consumed) while the

       other instance has not been used (player is paused) but will be

       used again (content consumption is to be continued). */

    error = iSession.FindRightsObject( iIntent, *iURI, child, parent, reason );

    /* Check if the RO found from the database matches with the one that was used

       in the original consumption of the content. If the ROs match, use the

       (possibly updated) one from the database. */

    if ( !error && child && iChild &&

         ( iChild->iUniqueID == child->iUniqueID ) &&

         ( iChild->iOriginalInsertTime == child->iOriginalInsertTime ) )

        {

        if ( iParentId )

            {

            delete iParentId;

            iParentId = parent;

            }

        delete iChild;

        iChild = child;

        }

    else

        {

        /* The original RO was not found. Delete temporary objects and also

           delete the iChild and iCombined because the RO is no longer valid and

           need to be re-fetched using InitializeL method (in DoContinueL).

           (in DoContinueL). */

        if ( iChild )

            {

            delete iChild;

            iChild = NULL;

            }

        if ( iCombined )

            {

            delete iCombined;

            iCombined = NULL;

            }

        if ( child )

            {

            delete child;

            child = NULL;

            }

        if ( parent )

            {

            delete parent;

            parent = NULL;

            }

        }

    DoContinueL();

    //HandleL( iIntent );

    DRMLOG( _L( "CDRMConsume::ContinueL ok" ) );

    }

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

// CDRMConsume:: Stop

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

//

void CDRMConsume::Stop()

    {

    DRMLOG( _L( "CDRMConsume::Stop" ) );

    Cancel();

    DRMLOG( _L( "CDRMConsume::Stop ok" ) );

    }

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

// CDRMConsume:: ActivateL

//

// Calculate the smallest end time based on interval, end time,

// accumulated time & timed count.

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

//

void CDRMConsume::ActivateL( TBool aSecureTime,

                             const TTime& aTrustedTime  )

    {

    DRMLOG( _L( "CDRMConsume::ActivateL" ) );

    __ASSERT_DEBUG( iChild && iCombined, User::Invariant() );

    TTime endTime( Time::MaxTTime() );

    TTimeIntervalSeconds timed( KMaxTInt32 );

    TBool timeUsed( EFalse );

    TBool endTimeUsed( EFalse );

    iCurrentDelay = 0;

    if ( iCombined->iActiveConstraints & EConstraintTimedCounter )

        {

        // Take this, even if timed counts have been updated.

        // This might cause unnecessary RunL's to be called, but it

        // ensures both child & parent will be consumed when needed.

        // If e.g. it would be checked that iTimedCounts == 0xf,

        // either one (child or parent) might not get updated in case of

        // "Child expired, but parent didn't -> find new child".

        PickSmaller( timed, iCombined->iTimedInterval );

        timeUsed = ETrue;

        }

    if ( iCombined->iActiveConstraints & EConstraintAccumulated )

        {

        PickSmaller( timed, iCombined->iAccumulatedTime );

        timeUsed = ETrue;

        }

    if ( iCombined->iActiveConstraints & EConstraintInterval )

        {

        if ( iCombined->iIntervalStart != Time::NullTTime() )

            {

            endTime = iCombined->iIntervalStart;

            endTime += iCombined->iInterval;

            endTimeUsed = ETrue;

            }

        else

            {

            TInt64 tmp( iCombined->iInterval.Int() );

            PickSmaller( timed, tmp );

            timeUsed = ETrue;

            }

        }

    if ( iCombined->iActiveConstraints & EConstraintEndTime )

        {

        PickSmaller( endTime, iCombined->iEndTime );

        endTimeUsed = ETrue;

        }

    // Put the "smallest time" information to "endTime".

    if ( timeUsed )

        {

        TTime current( aTrustedTime );

        current += timed;

        PickSmaller( endTime, current );

        endTimeUsed = ETrue;

        }

     // Interval gets initialised immediately, and so do count constraints.

     // Timed/accumulated won't: those are consumed after the

     // interval if secure time exists.

     Consume( ETrue, ETrue, EFalse, 0,

              aSecureTime,

              aTrustedTime );

     // In case something was modified, update the db also.

     UpdateDBL();

     if ( endTimeUsed )

        {

        // Something exists.

        TTimeIntervalSeconds secs( 0 );

        TTime current( aTrustedTime );

        TInt err( KErrNone );

        // SecondsFrom returns an error if the difference is too great.

        err = endTime.SecondsFrom( current, secs );

        if ( err )

            {

            iCurrentDelay = KConsumeDefaultTimer;

            }

        else if ( secs.Int() < 0 )

            {

            iCurrentDelay = 0; // Already expired.

            }

        else if ( secs.Int() < KConsumeDefaultTimer )

            {

            iCurrentDelay = secs.Int();

            }

        else

            {

            iCurrentDelay = KConsumeDefaultTimer;

            }

        if ( !IsAdded() )

            {

            CActiveScheduler::Add( this );

            }

        DRMLOG2( _L( "CDRMConsume::ActivateL: using interval %d" ),

                  ( TInt )iCurrentDelay );

        // secs -> microsecs. The method sets the AO active.

        After( TTimeIntervalMicroSeconds32( iCurrentDelay * 1000000 ) );

        iTime = current;

        // If we see timed things here, we also have secure time.

        //SETBIT( iMask, KConsumeHasSecureTime );

        }

    else    // For metering we always need to have this:

        {

        iCurrentDelay = KConsumeDefaultTimer;

        iTime = aTrustedTime;

        if ( !IsAdded() )

            {

            CActiveScheduler::Add( this );

            }

        DRMLOG2( _L( "CDRMConsume::ActivateL: using interval %d" ),

                  ( TInt )iCurrentDelay );

        // secs -> microsecs. The method sets the AO active.

        After( TTimeIntervalMicroSeconds32( iCurrentDelay * 1000000 ) );

        }

    // If we see timed things here, we also have secure time.

    if( aTrustedTime != Time::NullTTime())

        {

        SETBIT( iMask, KConsumeHasSecureTime );

        }

    DRMLOG( _L( "CDRMConsume::ActivateL ok" ) );

    }

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

// CDRMConsume:: Consume

//

// Consume child & parent. Whether to consume parent's explicit

// usage permission: the information is returned earlier by

// FindRightsObjectL.

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

//

void CDRMConsume::Consume( TBool aUpdateCounter,

                           TBool aInitInterval,

                           TBool aUpdateTimedCount,

                           const TTimeIntervalSeconds& aElapsedTime,

                           TBool aSecureTime,

                           const TTime& aTrustedTime )

    {

    DRMLOG( _L( "CDRMConsume::Consume" ) );

    __ASSERT_DEBUG( iChild && iCombined, User::Invariant() );

    // Decrease timed counters & regular counters only once.

    // In the beginning the bitmasks are both 0xF.

    if ( iChild->TopLevelConstraint() )

        {

        if ( ConsumeConstraint( *( iChild->TopLevelConstraint() ),

                                ( aUpdateCounter &&

                                  ISSET( iCounters, KChildToplevelCount ) ),

                                aInitInterval,

                                ( aUpdateTimedCount &&

                                  ISSET( iTimedCounts,

                                         KChildToplevelCount ) ),

                                aElapsedTime,