FCL/sf/mw/drm: comparison omadrm/drmengine/server/inc/drmconsume.h

equal deleted inserted replaced

--1:000000000000
+:95b198f216e5
+/*
+* 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