/*

* 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 "drmlog.h"

#ifdef RD_DRM_METERING

#include "drmmeteringdb.h"

#include "drmmeteringdbdata.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* >( \

#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 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" ) );

    }

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

// CDRMConsume::~CDRMConsume

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

//

CDRMConsume::~CDRMConsume()

    {

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

    TInt error( KErrNone );

        {

        }

    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 ),

    {

    }

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

// CDRMConsume::ConstructL

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

//

void CDRMConsume::ConstructL( const TDesC8& aURI,

                              const TDesC8* aParentId )

    {

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

    CTimer::ConstructL();

    iURI = aURI.AllocL();

    if( aParentId )

        {

        }

    }

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

// 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;

        }

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

    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. */

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

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

        {

        if ( iParentId )

            {

            iParentId = parent;

            }

        delete iChild;

        iChild = child;

        {

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

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

        if ( iChild )

            {

            delete iChild;

            iChild = NULL;

            }

        if ( iCombined )

            {

            delete iCombined;

            iCombined = NULL;

            }

            {

            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

//

// 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 )

        {

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

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

        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.

     // 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 );

            }

                  ( TInt )iCurrentDelay );

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

        After( TTimeIntervalMicroSeconds32( iCurrentDelay * 1000000 ) );

        iTime = current;

        //SETBIT( iMask, KConsumeHasSecureTime );

        }

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

        {

        iCurrentDelay = KConsumeDefaultTimer;

        iTime = aTrustedTime;

        if ( !IsAdded() )

            {

            CActiveScheduler::Add( this );

            }

                  ( TInt )iCurrentDelay );

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

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

        {

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

    }

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

// CDRMConsume:: Consume

//

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

// 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.

    if ( iChild->TopLevelConstraint() )

        {

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

                                  ISSET( iCounters, KChildToplevelCount ) ),

                                aInitInterval,

                                         KChildToplevelCount ) ),

                                aElapsedTime,