/*

* 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:  Interface for the consume operations. This class handles all

*                operations regarding rights consumption in DRM5.

*

*/

#ifndef DRMCONSUME_H

#define DRMCONSUME_H

// INCLUDES

#include <e32base.h>

#include <caf/caftypes.h>

// CONSTANTS

// MACROS

// DATA TYPES

// FORWARD DECLARATIONS

class CDRMDbSession;

class RMessage2;

class CDRMPermission;

class CDRMConstraint;

// TYPE DEFINITIONS

// FUNCTION PROTOTYPES

// CLASS DECLARATION

/**

*  CDRMConsume acts as content consumer in DRM5 Rights Server. It is accessed

*  by CDRMDbSession. Content consumption is initiated via HandleL() method

*  in the beginning of the consumption, and later on the class can be

*  controlled through Pause(), Continue() and Stop(). Destructor calls

*  the Cancel() method.

*  

*  @lib RightsServer.exe

*  @since 3.0

*/

NONSHARABLE_CLASS( CDRMConsume ) : public CTimer

    {

    public: // Constructors and destructor.

        /**

        * NewLC

        *

        * Two-phase constructor.

        *

        * @since    3.0

        * @param    aParent Callback handle to the session

        *                   owning this instance.

        * @param    aURI    Content-ID.

        * @return   A pointer to newly created object.

        */

        static CDRMConsume* NewLC( CDRMDbSession& aParent, 

                                   const TDesC8& aURI,

                                   const TDesC8* aParentId );

        /**

        * Destructor.

        */

        virtual ~CDRMConsume();

    public: // New functions.

        /**

        * HandleL

        *

        * Starts the content consumption.

        *   

        * Whenever this method is called, rights database also gets

        * updated if related permissions are stateful. When calling HandleL

        * several times for the same class instance instance, the permissions 

        * are consumed only once if the related permissions returned by 

        * CDRMDbSession::FindRightsObjectL() are the same returned earlier.

        *

        * @since    3.0

        * @param    aIntent Usage intent.        

        */

        void HandleL( ContentAccess::TIntent aIntent );

        /**

        * Pause

        *

        * Pauses the content consumption.

        *

        * Content consuption can be resumed via ContinueL() and HandleL(). 

        * See comments in HandleL() method for information about permission 

        * consumption.

        *

        * @since    3.0

        */

        void Pause();

        /**

        * ContinueL

        *

        * Continues the content consumption.

        *

        * This method works similarily to HandleL.

        *

        * @since    3.0

        */

        void ContinueL();

        /**

        * Stop

        *

        * Stops the content consumption.

        *

        * This method works similarily to Pause()

        *

        * @since    3.0 

        */

        void Stop();

        /**

        * CountConstraintActive

        *

        * Checks whether a count constraint was used earlier

        *

        * @since    3.0 

        * @return   ETrue if a count constraint was used earlier,

        *           EFalse otherwise

        */

        TBool CountConstraintActive();

        /**

        * IsExpired

        *

        * Returns ETrue if the last consumption lead to expired rights

        *

        * @since    3.0 

        * @return   ETrue if the rights are expired,

        *           EFalse otherwise

        */

        TBool IsExpired();

        /**

        * Returns the current child permission

        *

        * @since    3.0 

        * @return   the permission

        */

        CDRMPermission& GetChild();

    protected: // from base class CActive

        /**

        * RunL

        * 

        * Handles the completed asynchronous request.

        */

        void RunL();

        /**

        * RunError

        *

        * Handles errors happened during RunL().

        *

        * At the moment this method does nothing.

        * 

        * @since    3.0

        * @param    Error code

        * @return   KErrNone if the error could be handled. Otherwise an

        *           error code is returned.

        */

        TInt RunError( TInt aError );

    protected: // New Functions

        /**

        * Constructor

        * 

        * Constructs the class instance.

        * 

        * @since    3.0

        * @param    aSession Callback session to the CDRMDbSession owning

        *           this instance.

        */

        CDRMConsume( CDRMDbSession& aSession );

        /**

        * Second phase constructor

        * 

        * Finalizes the construction of the class instance.

        *

        * @since    3.0

        * @param    aURI Content-ID

        */

        void ConstructL( const TDesC8& aURI,

                         const TDesC8* aParentId );

    private: // From base class CActive

        /**

        * DoCancel

        *

        * Handles the cancelling operations.

        * This method updates timed constraints of the permission found

        * earlier (if such constraints exist). Calls DoCancelL() in trap

        * harness.

        *

        * @since    3.0

        */

        void DoCancel(); 

    private: // New functions

        /**

        * InitializeL

        * 

        * This method finds the proper permissions (child & parent) for the 

        * given intent and previously set content-ID.

        *

        * @since    3.0

        * @param    aIntent Consumption intent

        * @param    aSecureTime Whether the given time is secure or not

        * @param    aTrustedTime Current time.

        */

        void InitializeL( ContentAccess::TIntent aIntent,

                          TBool aSecureTime,

                          const TTime& aTrustedTime );

        /**

        * ActivateL

        *

        * In case of time based or interval based constraints, this method 

        * activates the internal timer to monitor delay.

        *

        * @since    3.0

        * @aParam   aSecureTime Whether the given time is secure or not.

        * @aParam   aTrustedTime Current time.

        */

        void ActivateL( TBool aSecureTime,

                        const TTime& aTrustedTime );

        /**

        * Consume

        *

        * This method consumes the internally stored permissions according to

        * the given parameters. If a(ny) internally stored permission is

        * changed, the internal status masks iTimedCounts and iTimedCounts.

        *

        * @since    3.0

        * @param    aUpdateCounter Whether to consume counter constraint.

        * @param    aInitInterval  Whether to initialize (possibly) 

        *                          uninialized interval.

        * @param    aUpdateTimedCount Whether to update timed counter.

        * @param    aElapsedTime How much time has elapsed since initialization

        * @param    aSecureTime Whether the given time is secure or not.

        * @param    aTrustedTime Current time.

        */

        void Consume( TBool aUpdateCounter,

                      TBool aInitInterval,

                      TBool aUpdateTimedCount,

                      const TTimeIntervalSeconds& aElapsedTime,

                      TBool aSecureTime,

                      const TTime& aTrustedTime );

        /**

        * CombinePermissionsL

        * 

        * Combines internal iParent and iChild into iCombined.

        *

        * @since    3.0

        */

        void CombinePermissionsL();

        /**

        * UpdateDBL

        *

        * Commits the internal iChild & iParent to the database in case

        * they have changed.

        */

        void UpdateDBL();

        /**

        * ConsumeConstraint

        * 

        * Consumes the given constraint by the given parameters.

        * 

        * @since    3.0

        @ @param    aConstraint Constraint to be consumed.

        * @param    aUpdateCounter Whether to decrease the counter constraint.

        * @param    aInitInterval Whether to initialize (possibly)

        *                         uninitialized interval.

        * @param    aUpdateTimedCount Whether to decrease timed counter.

        * @param    aElapsedTime How much time has elapsed since initialization

        * @param    aSecureTime Whether the given time is secure or not.

        * @param    aCumulativeTime The time that has elapsed cumulatively 

        *                           from the start of a timed counter

        * @param    aTrustedTime Current time.

        */

        TBool ConsumeConstraint( CDRMConstraint& aConstraint,

                                 TBool aUpdateCounter,

                                 TBool aInitInterval,

                                 TBool aUpdateTimedCount,

                                 const TTimeIntervalSeconds& aElapsedTime,

                                 TBool aSecureTime,

                                 const TTime& aTrustedTime,

                                 TTimeIntervalSeconds& aCumulativeTime );

        /**

        * ConsumeTimedItemsL

        * 

        * Consumes timed items.

        *

        * @since    3.0

        * @param    aDelay The delay between timer initialization and this 

        *                  moment.

        * @param    aSecureTime Whether the given time is secure or not.

        * @param    aTrustedTime Current time.

        */

        void ConsumeTimedItemsL( TTimeIntervalSeconds aDelay,

                                 TBool aSecureTime,

                                 const TTime& aTrustedTime );

        /**

        * DoContinueL

        * 

        * Handles the operations of RunL() method when timer goes off.

        * 

        * @since    3.0

        */        

        void DoContinueL();

        /** 

        * SecurityLevelChanged

        * 

        * Checks whether the secure time is now insecure or vice versa, 

        * compared to the situation when ActivateL() was called.

        *

        * @since    3.0

        * @param    aSecureTime Current time security level.

        * @return   Whether the security level of the time is different.

        */

        TBool SecurityLevelChanged( TBool aSecureTime ) const;

        /**

        * DoCancelL

        *

        * Updates time based constraints of internally stored permissions

        * in case of cancel operation.

        * 

        * @since    3.0

        */

        void DoCancelL();

        /**

        *

        * Updates the metering count, defines the metering accumulated time

        * and updates the metering database if there was metered content. 

        * 

        * @since S60 3.2

        */

        void UpdateMeteringDbL();

        /**

        *

        * Creates a Rights Issuer Context to Roap storage and checks the rights 

        * of the Rights Issuer to use metering.

        *

        * @since S60 3.2

        * @param aRiId

        * @return Whether metering can be allowed base on the Rights Issuer Id or not

        */

        TBool CheckRiContextRightsL( const TDesC8& aRiId );

    private: // New functions.

        /**

        * Default constructor.

        * 

        * Prohibited.

        */

        CDRMConsume(); 

    public:     // Data

    protected:  // Data

    private:    // Data

        // Callback handle.

        CDRMDbSession& iSession;

        // Usage intent when the consumption was initialized.

        ContentAccess::TIntent iIntent;

        // Content-id

        HBufC8* iURI;

        // id of the parent, if this exists we are using a parent RO

        HBufC8* iParentId;

        // The child permission used in the consumption operation.

        CDRMPermission* iChild;

        // A constraint combined from iChild & iParent.

        CDRMConstraint* iCombined;

        // The time when CTimer went active.

        TTime iTime;

        // Tells how much the waiting time was when initialized.

        TInt16 iCurrentDelay;

        // Internal state.

        TUint8 iMask;

        // Internal state to check whether timed counters have been modified.

        TUint8 iTimedCounts;

        // Internal state to check whether counters have been modified.

        TUint8 iCounters;

        // Set to ETrue if a count constraint was used

        TBool iCountConstraintActive;

        // Set to ETrue if the last consumption lead to expired rights

        TBool iExpired;

        // Tells how much time has been actually spent rendering

        TTimeIntervalSeconds iCumulativeDelayTop;

        TTimeIntervalSeconds iCumulativeDelayChild;

        //  Tells the total cumulative time. It is needed when calculating

        //  accumulated time for metering purposes. 

        TTimeIntervalSeconds iTotalCumulativeTime;

        // Bit to tell if we use timed count

        TBool iUsingTimedCount;      

    };

#endif // DRMCONSUME_H

// EOF