diff -r 000000000000 -r 95b198f216e5 omadrm/drmengine/server/inc/drmconsume.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/omadrm/drmengine/server/inc/drmconsume.h Thu Dec 17 08:52:27 2009 +0200 @@ -0,0 +1,438 @@ +/* +* 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 +#include + +// 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