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