--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omadrm/drmengine/ro/src/DrmRights.cpp Thu Dec 17 08:52:27 2009 +0200
@@ -0,0 +1,1519 @@
+/*
+* Copyright (c) 2002 - 2008 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 common DRM operations
+*
+*/
+
+
+// INCLUDE FILES
+
+#include "DrmAsset.h"
+#include "DrmRights.h"
+#include "DrmPermission.h"
+#include "DrmConstraint.h"
+
+// EXTERNAL DATA STRUCTURES
+
+// EXTERNAL FUNCTION PROTOTYPES
+
+// CONSTANTS
+
+// MACROS
+
+// LOCAL CONSTANTS AND MACROS
+
+_LIT(KNullDate,"00000000:000000.000000");
+
+// MODULE DATA STRUCTURES
+
+// LOCAL FUNCTION PROTOTYPES
+
+// FORWARD DECLARATIONS
+
+// ============================= LOCAL FUNCTIONS ===============================
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::CDRMRightsConstraints
+// Default constructor
+// -----------------------------------------------------------------------------
+EXPORT_C CDRMRightsConstraints::CDRMRightsConstraints(void)
+ {
+ iConstraint = NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::ConstructL
+// Symbian 2nd phase constructor can leave.
+// -----------------------------------------------------------------------------
+EXPORT_C void CDRMRightsConstraints::ConstructL(void)
+ {
+ iConstraint = CDRMConstraint::NewL();
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::NewL
+// Two-phased constructor.
+// -----------------------------------------------------------------------------
+EXPORT_C CDRMRightsConstraints* CDRMRightsConstraints::NewL(void)
+ {
+ CDRMRightsConstraints* self = new (ELeave) CDRMRightsConstraints;
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+// Destructor
+EXPORT_C CDRMRightsConstraints::~CDRMRightsConstraints(void)
+ {
+ if (iConstraint) delete iConstraint;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::FullRights
+// The FullRights function checks if the object contains any restrictions
+// or if usage is unconstrained.
+// -----------------------------------------------------------------------------
+EXPORT_C TBool CDRMRightsConstraints::FullRights(void)
+ {
+ return iConstraint->iActiveConstraints == EConstraintNone ? ETrue : EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::IsPreview
+// The function checks if the object represents a preview constraint.
+// -----------------------------------------------------------------------------
+EXPORT_C TBool CDRMRightsConstraints::IsPreview(void)
+ {
+ if ((iConstraint->iActiveConstraints & EConstraintCounter) &&
+ iConstraint->iOriginalCounter == 1)
+ {
+ return ETrue;
+ }
+ else
+ {
+ return EFalse;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::GetConstraintInfo
+// This function checks the expiration and the constraints of the object and
+// returns the prioryty value.
+// -----------------------------------------------------------------------------
+EXPORT_C void CDRMRightsConstraints::SetConstraint(CDRMConstraint& aConstraint)
+ {
+ TInt error = KErrNone;
+ if( !iConstraint )
+ {
+ TRAP( error, iConstraint = CDRMConstraint::NewL());
+ if( error )
+ {
+ return;
+ }
+ }
+ TRAP( error, iConstraint->DuplicateL( aConstraint ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::GetConstraintInfo
+// This function checks the expiration and the constraints of the object and
+// returns the prioryty value.
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRightsConstraints::GetConstraintInfo(
+ TUint32& aExpiration,
+ TUint32& aConstType)
+ {
+ TTime currentTime;
+ TTime time;
+ TTimeIntervalSeconds interval;
+ TTimeIntervalSeconds diff;
+ TInt result = KErrNone;
+ currentTime.HomeTime();
+ TUint32 counter = 0;
+ TUint32 originalCounter = 0;
+ TInt priorValue = 0;
+ aConstType = NULL;
+
+ aExpiration = CDRMRights::EValidRights;
+
+ if ( FullRights() )
+ {
+ aConstType = CDRMRights::ENoConstraints;
+ return ENoConstraints * aExpiration;
+ }
+
+ result = GetEndTime(time);
+ if (result == KErrNone)
+ {
+ aConstType |= CDRMRights::ETimeBased;
+ if ( time < currentTime )
+ {
+ aExpiration = CDRMRights::EExpiredRights;
+ }
+ }
+
+ result = GetStartTime(time);
+ if (result == KErrNone && aExpiration != CDRMRights::EExpiredRights)
+ {
+ aConstType |= CDRMRights::ETimeBased;
+ if ( time > currentTime )
+ {
+ aExpiration = CDRMRights::EFutureRights;
+ }
+ }
+
+ result = GetInterval(interval);
+ if(result == KErrNone && aExpiration != CDRMRights::EExpiredRights)
+ {
+ result = GetIntervalStart(time);
+ if(result == KErrNone)
+ {
+ aConstType |= CDRMRights::ETimeBased;
+ currentTime.SecondsFrom(time, diff);
+ if (diff.Int() < 0)
+ {
+ aExpiration = CDRMRights::EFutureRights;
+ }
+ else if ( interval < diff )
+ {
+ aExpiration = CDRMRights::EExpiredRights;
+ }
+ }
+ else
+ {
+ aConstType |= CDRMRights::EInActiveInterval;
+ }
+ }
+ result = GetCounters( counter , originalCounter );
+ if (result == KErrNone)
+ {
+ aConstType |= CDRMRights::ECountBased;
+ if ( counter == 0 )
+ {
+ aExpiration = CDRMRights::EExpiredRights;
+ }
+ }
+ result = GetTimedCounters( counter , originalCounter );
+ if (result == KErrNone)
+ {
+ aConstType |= CDRMRights::ECountBased;
+ if ( counter == 0 )
+ {
+ aExpiration = CDRMRights::EExpiredRights;
+ }
+ }
+ result = GetAccumulated(interval);
+ if(result == KErrNone && aExpiration != CDRMRights::EExpiredRights)
+ {
+ aConstType |= CDRMRights::ETimeBased | CDRMRights::ETimeIsAccumulatedTime;
+ if (interval.Int() == 0)
+ {
+ aExpiration = CDRMRights::EExpiredRights;
+ }
+ }
+ if (!aConstType)
+ {
+ return CDRMRights::EInvalidRights;
+ }
+
+ if ( (aConstType & CDRMRights::ECountBased) &&
+ !(aConstType & CDRMRights::EInActiveInterval) &&
+ !(aConstType & CDRMRights::ETimeBased) )
+ {
+ priorValue = ECount * aExpiration;
+ }
+ else if ( (aConstType & CDRMRights::ECountBased) &&
+ (aConstType & CDRMRights::EInActiveInterval) &&
+ !(aConstType & CDRMRights::ETimeBased) )
+ {
+ priorValue = EIntervalCount * aExpiration;
+ }
+ else if ( (aConstType & CDRMRights::ECountBased) &&
+ (aConstType & CDRMRights::EInActiveInterval) &&
+ (aConstType & CDRMRights::ETimeBased) )
+ {
+ priorValue = ETimeIntervalCount * aExpiration;
+ }
+ else if ( (aConstType & CDRMRights::ECountBased) &&
+ !(aConstType & CDRMRights::EInActiveInterval) &&
+ (aConstType & CDRMRights::ETimeBased) )
+ {
+ priorValue = ETimeCount * aExpiration;
+ }
+ else if ( !(aConstType & CDRMRights::ECountBased) &&
+ (aConstType & CDRMRights::EInActiveInterval) &&
+ !(aConstType & CDRMRights::ETimeBased) )
+ {
+ priorValue = EInterval * aExpiration;
+ }
+ else if ( !(aConstType & CDRMRights::ECountBased) &&
+ (aConstType & CDRMRights::EInActiveInterval) &&
+ (aConstType & CDRMRights::ETimeBased) )
+ {
+ priorValue = ETimeInterval * aExpiration;
+ }
+ else if ( !(aConstType & CDRMRights::ECountBased) &&
+ !(aConstType & CDRMRights::EInActiveInterval) &&
+ (aConstType & CDRMRights::ETimeBased) )
+ {
+ priorValue = ETime * aExpiration;
+ }
+
+ return priorValue;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::GetExpirationDetails
+// The function returns the end time and amount of counts left of the object.
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRightsConstraints::GetExpirationDetails(
+ TTime& aEndTime,
+ TInt& aCountsLeft)
+ {
+ TTime endTime;
+ endTime.Set(KNullDate);
+ TTimeIntervalSeconds interval;
+ TTime intervalStart;
+ intervalStart.Set(KNullDate);
+ TTime intervalEnd;
+ intervalEnd.Set(KNullDate);
+
+ TUint32 counter = 0;
+ TUint32 originalCounter = 0;
+
+ TBool isEndTime = EFalse;
+ TBool isInterval = EFalse;
+ TBool isCount = EFalse;
+
+ if (GetCounters(counter, originalCounter) == KErrNone)
+ {
+ isCount = ETrue;
+ aCountsLeft = counter;
+ }
+ else
+ {
+ aCountsLeft = -1;
+ }
+ if (GetEndTime(endTime) == KErrNone)
+ {
+ isEndTime = ETrue;
+ }
+ if (GetIntervalStart(intervalStart) == KErrNone)
+ {
+ isInterval = ETrue;
+ GetInterval(interval);
+ intervalEnd = intervalStart + interval;
+ }
+ if (isInterval && isEndTime)
+ {
+ if (intervalEnd > endTime)
+ {
+ aEndTime = endTime;
+ }
+ else
+ {
+ aEndTime = intervalEnd;
+ }
+ }
+ else if (isInterval)
+ {
+ aEndTime = intervalEnd;
+ }
+ else if (isEndTime)
+ {
+ aEndTime = endTime;
+ }
+ else if (!isCount)
+ {
+ // The object contains either a full or an inactive interval rights
+ aEndTime.Set(KNullDate);
+ aCountsLeft = -1;
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::GetCounters
+// This function returns the current value of the count restriction and
+// original value of the count restriction.
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRightsConstraints::GetCounters(
+ TUint32& aCounter,
+ TUint32& aOriginalCounter)
+ {
+ if (iConstraint->iActiveConstraints & EConstraintCounter)
+ {
+ aCounter = iConstraint->iCounter;
+ aOriginalCounter = iConstraint->iOriginalCounter;
+ return KErrNone;
+ }
+ else
+ {
+ return CDRMRights::ENoRights;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::GetCounters
+// This function returns the current value of the count restriction and
+// original value of the count restriction.
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRightsConstraints::GetTimedCounters(
+ TUint32& aCounter,
+ TUint32& aOriginalCounter)
+ {
+ if (iConstraint->iActiveConstraints & EConstraintTimedCounter)
+ {
+ aCounter = iConstraint->iTimedCounter;
+ aOriginalCounter = iConstraint->iOriginalCounter;
+ return KErrNone;
+ }
+ else
+ {
+ return CDRMRights::ENoRights;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::GetStartTime
+//
+// This function returns the time when the constraint becomes valid or has
+// become valid.
+//
+// Cases:
+// 1. If an active interval is present, that time is always the correct start
+// time
+// 2. If start time is defined that is the start time
+// 3. No active interval or start time defined CDRMRights::ENoRights
+//
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRightsConstraints::GetStartTime(
+ TTime& aStartTime)
+ {
+ // Activated interval is always the same or later than
+ // the start time of the start-end
+
+ if (iConstraint->iActiveConstraints & EConstraintInterval &&
+ (iConstraint->iIntervalStart != Time::NullTTime() ) )
+ {
+ aStartTime = iConstraint->iIntervalStart;
+ }
+ else if (iConstraint->iActiveConstraints & EConstraintStartTime)
+ {
+ aStartTime = iConstraint->iStartTime;
+ }
+ else
+ {
+ return CDRMRights::ENoRights;
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::GetEndTime
+//
+// This function returns the time when the constraint will become invalid
+//
+// Cases:
+// 1. If both end time and activated interval is present the one which is closer
+// to the present time will be chosen
+// 2. If only end time is available, that is returned
+// 3. If only activated interval is available, that is returned
+// 4. Otherwise CDRMRights::ENoRights
+//
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRightsConstraints::GetEndTime(
+ TTime& aEndTime)
+ {
+ // If both end time and interval have been activated
+ // take the one which is closer
+
+ if ((iConstraint->iActiveConstraints & EConstraintEndTime) &&
+ (iConstraint->iActiveConstraints & EConstraintInterval) &&
+ (iConstraint->iIntervalStart != Time::NullTTime() ) )
+ {
+ if( iConstraint->iEndTime <= (iConstraint->iIntervalStart +
+ iConstraint->iInterval) )
+ {
+ aEndTime = iConstraint->iEndTime;
+ }
+ else
+ {
+ aEndTime = (iConstraint->iIntervalStart +
+ iConstraint->iInterval);
+ }
+ }
+ else if (iConstraint->iActiveConstraints & EConstraintEndTime)
+ {
+ aEndTime = iConstraint->iEndTime;
+ }
+ else if (iConstraint->iActiveConstraints & EConstraintInterval &&
+ (iConstraint->iIntervalStart != Time::NullTTime() ) )
+ {
+ aEndTime = (iConstraint->iIntervalStart +
+ iConstraint->iInterval);
+ }
+ else
+ {
+ return CDRMRights::ENoRights;
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::GetInterval
+// This function returns the interval time constraint
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRightsConstraints::GetInterval(
+ TTimeIntervalSeconds& aInterval)
+ {
+ if (iConstraint->iActiveConstraints & EConstraintInterval)
+ {
+ aInterval = iConstraint->iInterval;
+ return KErrNone;
+ }
+ else
+ {
+ return CDRMRights::ENoRights;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::GetIntervalStart
+// This function returns the start of the interval time constraint
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRightsConstraints::GetIntervalStart(
+ TTime& aIntervalStart)
+ {
+ if (iConstraint->iActiveConstraints & EConstraintInterval &&
+ iConstraint->iIntervalStart != Time::NullTTime())
+ {
+ aIntervalStart = iConstraint->iIntervalStart;
+ return KErrNone;
+ }
+ else
+ {
+ return CDRMRights::ENoRights;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::GetAccumulated
+// This function returns the accumulated time constraint
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRightsConstraints::GetAccumulated(
+ TTimeIntervalSeconds& aAccumulated)
+ {
+ if (iConstraint->iActiveConstraints & EConstraintAccumulated)
+ {
+ aAccumulated = iConstraint->iAccumulatedTime;
+ return KErrNone;
+ }
+ else
+ {
+ return CDRMRights::ENoRights;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::GetCounters
+// This function returns the current value of the count restriction and
+// original value of the count restriction.
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRightsConstraints::SetCounters(
+ TUint32 aCounter,
+ TUint32 aOriginalCounter)
+ {
+ iConstraint->iCounter = aCounter;
+ iConstraint->iOriginalCounter = aOriginalCounter;
+ iConstraint->iActiveConstraints |= EConstraintCounter;
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::SetStartTime
+// This function sets the start time constraint
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRightsConstraints::SetStartTime(
+ TTime aStartTime)
+ {
+ iConstraint->iStartTime = aStartTime;
+ iConstraint->iActiveConstraints |= EConstraintStartTime;
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::SetEndTime
+// This function sets the end time constraint
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRightsConstraints::SetEndTime(
+ TTime aEndTime)
+ {
+ iConstraint->iEndTime = aEndTime;
+ iConstraint->iActiveConstraints |= EConstraintEndTime;
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::SetInterval
+// This function sets the interval time constraint
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRightsConstraints::SetInterval(
+ TTimeIntervalSeconds aInterval)
+ {
+ iConstraint->iInterval = aInterval;
+ iConstraint->iActiveConstraints |= EConstraintInterval;
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::SetIntervalStart
+// This function sets the start of the interval time constraint
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRightsConstraints::SetIntervalStart(
+ TTime aStartTime)
+ {
+ iConstraint->iIntervalStart = aStartTime;
+ iConstraint->iActiveConstraints |= EConstraintInterval;
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::GetConstraint
+// -----------------------------------------------------------------------------
+EXPORT_C CDRMConstraint& CDRMRightsConstraints::GetConstraint(void)
+ {
+ return *iConstraint;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRightsConstraints::operator=
+// Assignment operator.
+// -----------------------------------------------------------------------------
+EXPORT_C CDRMRightsConstraints& CDRMRightsConstraints::operator=(
+ CDRMRightsConstraints& aConstraint)
+ {
+ if (iConstraint)
+ {
+ delete iConstraint;
+ iConstraint = NULL;
+ }
+ TRAP_IGNORE( iConstraint = CDRMConstraint::NewL() );
+ if (iConstraint)
+ {
+ TRAP_IGNORE( iConstraint->DuplicateL( aConstraint.GetConstraint() ) );
+ }
+
+ return *this;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::CDRMRights
+// Default constructor.
+// -----------------------------------------------------------------------------
+EXPORT_C CDRMRights::CDRMRights(void):
+ iAsset(NULL),
+ iPermission(NULL)
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::ConstructL
+// Symbian 2nd phase constructor can leave.
+// -----------------------------------------------------------------------------
+EXPORT_C void CDRMRights::ConstructL(void)
+ {
+ iPermission = CDRMPermission::NewL();
+ iAsset = CDRMAsset::NewL();
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::NewL
+// Two-phased constructor.
+// -----------------------------------------------------------------------------
+EXPORT_C CDRMRights* CDRMRights::NewL(void)
+ {
+ CDRMRights* self = new (ELeave) CDRMRights;
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+// Destructor
+EXPORT_C CDRMRights::~CDRMRights(void)
+ {
+ delete iAsset;
+ delete iPermission;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::GetContentURI
+// This function returns the content URI of the object
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRights::GetContentURI(HBufC8*& aContentURI)
+ {
+ TInt r;
+
+ r = KErrNone;
+ if (iAsset && iAsset->iUid)
+ {
+ aContentURI = HBufC8::NewMax(iAsset->iUid->Size());
+ if (aContentURI)
+ {
+ *aContentURI = *iAsset->iUid;
+ }
+ else r = KErrNoMemory;
+ }
+ else
+ {
+ aContentURI = NULL;
+ }
+
+ return r;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::GetLocalID
+// This function returns the local ID of the object
+// -----------------------------------------------------------------------------
+EXPORT_C TUint32 CDRMRights::GetLocalID(void)
+ {
+ return iPermission->iUniqueID;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::GetAddTime
+// This function returns the time when the rights object was added to the
+// rights database.
+// -----------------------------------------------------------------------------
+EXPORT_C void CDRMRights::GetAddTime(TTime& aTime)
+ {
+ aTime = iPermission->iOriginalInsertTime;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::GetRightsInfo
+// This function checks the expiration and the constraints of the object and
+// retunrs the best constraint priority value.
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRights::GetRightsInfo(
+ TUint32 aConstraintSpec,
+ TRestriction& aRestriction,
+ TExpiration& aExpiration,
+ TUint32& aConstType)
+ {
+ TInt r = 0;
+ TBool noRights = ETrue;
+
+ TUint32 playConst = NULL;
+ TUint32 displayConst = NULL;
+ TUint32 exeConst = NULL;
+ TUint32 printConst = NULL;
+
+ TUint32 playExpir = EExpiredRights;
+ TUint32 displayExpir = EExpiredRights;
+ TUint32 printExpir = EExpiredRights;
+ TUint32 exeExpir = EExpiredRights;
+
+ TInt playValue = NULL;
+ TInt displayValue = NULL;
+ TInt exeValue = NULL;
+ TInt printValue = NULL;
+ TInt compareValue = NULL;
+
+ CDRMRightsConstraints* constraint = NULL;
+
+ r = GetPlayRight(constraint);
+ if (r && r != ENoRights)
+ {
+ return KErrNoMemory;
+ }
+ if (r == KErrNone &&
+ (aConstraintSpec == CDRMRights::EPlay || aConstraintSpec == 0 ) )
+ {
+ noRights = EFalse;
+ if (constraint->FullRights())
+ {
+ delete constraint;
+ constraint = NULL;
+ aExpiration = EValidRights;
+ aConstType = ENoConstraints;
+ aRestriction = EFullRights;
+ return EFullRights;
+ }
+ else
+ {
+ playValue = constraint->GetConstraintInfo(playExpir, playConst);
+ if (playValue > compareValue)
+ {
+ compareValue = playValue;
+ if(constraint->IsPreview())
+ {
+ aRestriction = EPreviewRights;
+ }
+ else
+ {
+ aRestriction = ERestrictedRights;
+ }
+ }
+ }
+ }
+
+ delete constraint;
+ constraint = NULL;
+
+ r = GetDisplayRight(constraint);
+ if (r && r != ENoRights)
+ {
+ return KErrNoMemory;
+ }
+ if (r == KErrNone &&
+ (aConstraintSpec == CDRMRights::EDisplay || aConstraintSpec == 0 ) )
+ {
+ noRights = EFalse;
+ if (constraint->FullRights())
+ {
+ delete constraint;
+ constraint = NULL;
+ aExpiration = EValidRights;
+ aConstType = ENoConstraints;
+ aRestriction = EFullRights;
+ return EFullRights;
+ }
+ else
+ {
+ displayValue = constraint->GetConstraintInfo(displayExpir, displayConst);
+ if (displayValue > compareValue)
+ {
+ compareValue = displayValue;
+ if(constraint->IsPreview())
+ {
+ aRestriction = EPreviewRights;
+ }
+ else
+ {
+ aRestriction = ERestrictedRights;
+ }
+ }
+ }
+ }
+
+ delete constraint;
+ constraint = NULL;
+
+ r = GetExecuteRight(constraint);
+ if (r && r != ENoRights)
+ {
+ return KErrNoMemory;
+ }
+ if (r == KErrNone &&
+ (aConstraintSpec == CDRMRights::EExecute || aConstraintSpec == 0 ) )
+ {
+ noRights = EFalse;
+ if (constraint->FullRights())
+ {
+ delete constraint;
+ constraint = NULL;
+ aExpiration = EValidRights;
+ aConstType = ENoConstraints;
+ aRestriction = EFullRights;
+ return EFullRights;
+ }
+ else
+ {
+ exeValue = constraint->GetConstraintInfo(exeExpir, exeConst);
+ if (exeValue > compareValue)
+ {
+ compareValue = exeValue;
+ if(constraint->IsPreview())
+ {
+ aRestriction = EPreviewRights;
+ }
+ else
+ {
+ aRestriction = ERestrictedRights;
+ }
+ }
+ }
+ }
+
+ delete constraint;
+ constraint = NULL;
+
+ r = GetPrintRight(constraint);
+ if (r && r != ENoRights)
+ {
+ return KErrNoMemory;
+ }
+ if (r == KErrNone &&
+ (aConstraintSpec == CDRMRights::EPrint || aConstraintSpec == 0 ) )
+ {
+ noRights = EFalse;
+ if (constraint->FullRights())
+ {
+ delete constraint;
+ constraint = NULL;
+ aExpiration = EValidRights;
+ aConstType = ENoConstraints;
+ aRestriction = EFullRights;
+ return EFullRights;
+ }
+ else
+ {
+ printValue = constraint->GetConstraintInfo(printExpir, printConst);
+ if (printValue > compareValue)
+ {
+ compareValue = exeValue;
+ if(constraint->IsPreview())
+ {
+ aRestriction = EPreviewRights;
+ }
+ else
+ {
+ aRestriction = ERestrictedRights;
+ }
+ }
+ }
+ }
+
+ delete constraint;
+ constraint = NULL;
+
+ if (noRights)
+ {
+ delete constraint;
+ constraint = NULL;
+ aExpiration = EExpiredRights;
+ return ENoRights;
+ }
+
+ if (aRestriction != ERestrictedRights)
+ {
+ aRestriction = EPreviewRights;
+ }
+
+ if (playExpir == EExpiredRights &&
+ displayExpir == EExpiredRights &&
+ printExpir == EExpiredRights &&
+ exeExpir == EExpiredRights)
+ {
+ aExpiration = EExpiredRights;
+ }
+
+ if (playExpir == EFutureRights ||
+ displayExpir == EFutureRights ||
+ printExpir == EFutureRights ||
+ exeExpir == EFutureRights)
+ {
+ aExpiration = EFutureRights;
+ }
+
+ if (playExpir == EValidRights ||
+ displayExpir == EValidRights ||
+ printExpir == EValidRights ||
+ exeExpir == EValidRights)
+ {
+ aExpiration = EValidRights;
+ }
+
+ if (compareValue == playValue) aConstType = playConst;
+ if (compareValue == displayValue) aConstType = displayConst;
+ if (compareValue == exeValue) aConstType = exeConst;
+ if (compareValue == printValue) aConstType = printConst;
+
+ return compareValue;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::GetExpirationDetails
+// The function returns the end time and amount of counts left of the object.
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRights::GetExpirationDetails(
+ TUint32 aConstraintSpec,
+ TTime& aEndTime,
+ TInt& aCountsLeft)
+ {
+ TInt r = 0;
+ CDRMRightsConstraints* constraint = NULL;
+
+ TTime playEndTime;
+ playEndTime.Set(KNullDate);
+ TTime displayEndTime;
+ displayEndTime.Set(KNullDate);
+ TTime executeEndTime;
+ executeEndTime.Set(KNullDate);
+ TTime printEndTime;
+ printEndTime.Set(KNullDate);
+ TTime compareTime;
+ compareTime.Set(KNullDate);
+
+ TInt playCounter = 0;
+ TInt displayCounter = 0;
+ TInt executeCounter = 0;
+ TInt printCounter = 0;
+
+ TBool noRights = ETrue;
+
+ aEndTime.Set(KNullDate);
+ aCountsLeft = 0;
+
+ r = GetPlayRight(constraint);
+ if (r == KErrNone &&
+ (aConstraintSpec == CDRMRights::EPlay || aConstraintSpec == 0 ) )
+ {
+ noRights = EFalse;
+ if (constraint->FullRights())
+ {
+ delete constraint;
+ constraint = NULL;
+ aEndTime.Set(KNullDate);
+ aCountsLeft = -1;
+ return KErrNone;
+ }
+ else
+ {
+ r = constraint->GetExpirationDetails(playEndTime, playCounter);
+ if(playEndTime == compareTime && playCounter == -1)
+ {
+ delete constraint;
+ constraint = NULL;
+ return KErrNone;
+ }
+ }
+ }
+
+ delete constraint;
+ constraint = NULL;
+
+ r = GetDisplayRight(constraint);
+ if (r == KErrNone &&
+ (aConstraintSpec == CDRMRights::EDisplay || aConstraintSpec == 0 ) )
+ {
+ noRights = EFalse;
+ if (constraint->FullRights())
+ {
+ delete constraint;
+ constraint = NULL;
+ aEndTime.Set(KNullDate);
+ aCountsLeft = -1;
+ return KErrNone;
+ }
+ else
+ {
+ r = constraint->GetExpirationDetails(displayEndTime, displayCounter);
+ if(displayEndTime == compareTime && displayCounter == -1)
+ {
+ delete constraint;
+ constraint = NULL;
+ return KErrNone;
+ }
+ }
+ }
+
+ delete constraint;
+ constraint = NULL;
+
+ r = GetExecuteRight(constraint);
+ if (r == KErrNone &&
+ (aConstraintSpec == CDRMRights::EExecute || aConstraintSpec == 0 ) )
+ {
+ noRights = EFalse;
+ if (constraint->FullRights())
+ {
+ delete constraint;
+ constraint = NULL;
+ aEndTime.Set(KNullDate);
+ aCountsLeft = -1;
+ return KErrNone;
+ }
+ else
+ {
+ r = constraint->GetExpirationDetails(executeEndTime, executeCounter);
+ if(executeEndTime == compareTime && executeCounter == -1)
+ {
+ delete constraint;
+ constraint = NULL;
+ return KErrNone;
+ }
+ }
+ }
+
+ delete constraint;
+ constraint = NULL;
+
+ r = GetPrintRight(constraint);
+ if (r == KErrNone &&
+ (aConstraintSpec == CDRMRights::EPrint || aConstraintSpec == 0 ) )
+ {
+ noRights = EFalse;
+ if (constraint->FullRights())
+ {
+ delete constraint;
+ constraint = NULL;
+ aEndTime.Set(KNullDate);
+ aCountsLeft = -1;
+ return KErrNone;
+ }
+ else
+ {
+ r = constraint->GetExpirationDetails(printEndTime, printCounter);
+ if(printEndTime == compareTime && printCounter == -1)
+ {
+ delete constraint;
+ constraint = NULL;
+ return KErrNone;
+ }
+ }
+ }
+
+ delete constraint;
+ constraint = NULL;
+
+ if (noRights)
+ {
+ aEndTime.Set(KNullDate);
+ aCountsLeft = -1;
+ return ENoRights;
+ }
+
+ compareTime.HomeTime();
+
+ if (playCounter > aCountsLeft)
+ {
+ aEndTime = playEndTime;
+ aCountsLeft = playCounter;
+ }
+ if (displayCounter > aCountsLeft)
+ {
+ aEndTime = displayEndTime;
+ aCountsLeft = displayCounter;
+ }
+ if (executeCounter > aCountsLeft)
+ {
+ aEndTime = executeEndTime;
+ aCountsLeft = executeCounter;
+ }
+ if (printCounter > aCountsLeft)
+ {
+ aEndTime = printEndTime;
+ aCountsLeft = printCounter;
+ }
+
+ if (aCountsLeft > 0 &&
+ playEndTime < compareTime && displayEndTime < compareTime &&
+ executeEndTime < compareTime && printEndTime < compareTime)
+ {
+ return KErrNone;
+ }
+
+ if (playEndTime > aEndTime)
+ {
+ aEndTime = playEndTime;
+ aCountsLeft = playCounter;
+ }
+ if (displayEndTime > aEndTime)
+ {
+ aEndTime = displayEndTime;
+ aCountsLeft = displayCounter;
+ }
+ if (executeEndTime > aEndTime)
+ {
+ aEndTime = executeEndTime;
+ aCountsLeft = executeCounter;
+ }
+ if (printEndTime > aEndTime)
+ {
+ aEndTime = printEndTime;
+ aCountsLeft = printCounter;
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::GetPlayRight
+// This function returns the constraints associated with the play right.
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRights::GetPlayRight(
+ CDRMRightsConstraints*& aConstraint)
+ {
+ TInt r = ENoRights;
+
+ aConstraint = NULL;
+ if (iPermission->iAvailableRights & ERightsPlay)
+ {
+ TRAP(r, aConstraint = CDRMRightsConstraints::NewL());
+ if (r == KErrNone)
+ {
+ aConstraint->SetConstraint(*iPermission->iPlay);
+ }
+ }
+ return r;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::GetDisplayRight
+// This function returns the constraints associated with the display right.
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRights::GetDisplayRight(
+ CDRMRightsConstraints*& aConstraint)
+ {
+ TInt r = ENoRights;
+
+ aConstraint = NULL;
+ if (iPermission->iAvailableRights & ERightsDisplay)
+ {
+ TRAP(r, aConstraint = CDRMRightsConstraints::NewL());
+ if (r == KErrNone)
+ {
+ aConstraint->SetConstraint(*iPermission->iDisplay);
+ }
+ }
+ return r;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::GetPrintRight
+// This function returns the constraints associated with the print right.
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRights::GetPrintRight(
+ CDRMRightsConstraints*& aConstraint)
+ {
+ TInt r = ENoRights;
+
+ aConstraint = NULL;
+ if (iPermission->iAvailableRights & ERightsPrint)
+ {
+ TRAP(r, aConstraint = CDRMRightsConstraints::NewL());
+ if (r == KErrNone)
+ {
+ aConstraint->SetConstraint(*iPermission->iPrint);
+ }
+ }
+ return r;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::GetExecuteRight
+// This function returns the constraints associated with the execute right.
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRights::GetExecuteRight(
+ CDRMRightsConstraints*& aConstraint)
+ {
+ TInt r = ENoRights;
+
+ aConstraint = NULL;
+ if (iPermission->iAvailableRights & ERightsExecute)
+ {
+ TRAP(r, aConstraint = CDRMRightsConstraints::NewL());
+ if (r == KErrNone)
+ {
+ aConstraint->SetConstraint(*iPermission->iExecute);
+ }
+ }
+ return r;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::SetContentURIAndLocalID
+// This function sets the content URI and local ID of the object
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRights::SetContentURIAndLocalID(
+ HBufC8* aContentURI,
+ TUint32 aLocalID)
+ {
+ TInt r = KErrNone;
+
+ if (!iAsset)
+ {
+ TRAP(r, iAsset = CDRMAsset::NewL());
+ }
+
+ if (iAsset)
+ {
+ if( iAsset->iUid )
+ {
+ delete iAsset->iUid;
+ }
+ iAsset->iUid = aContentURI;
+
+ if ( !iPermission )
+ {
+ TRAP(r, iPermission = CDRMPermission::NewL());
+ }
+
+ if ( iPermission )
+ {
+ iPermission->iUniqueID = aLocalID;
+ }
+ }
+
+ return r;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::SetContentURI
+// This function sets the content URI of the object
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRights::SetContentURI(
+ HBufC8* aContentURI)
+ {
+ if (iAsset)
+ {
+ delete iAsset->iUid;
+ iAsset->iUid = aContentURI;
+ }
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::SetLocalID
+// This function sets the content URI and local ID of the object
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRights::SetLocalID(
+ TUint32 aLocalID)
+ {
+ iPermission->iUniqueID = aLocalID;
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::GetAddTime
+// This function sets the time when the rights object was added to the
+// rights database.
+// -----------------------------------------------------------------------------
+EXPORT_C void CDRMRights::SetAddTime(
+ TTime aTime)
+ {
+ iPermission->iOriginalInsertTime = aTime;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::SetPlayRight
+// This function sets the constraints associated with the play right.
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRights::SetPlayRight(
+ CDRMRightsConstraints* aConstraint)
+ {
+ TInt error = KErrNone;
+
+ if( !iPermission )
+ {
+ TRAP( error, iPermission = CDRMPermission::NewL());
+ if( error )
+ {
+ return error;
+ }
+ }
+ else if( !iPermission->iPlay )
+ {
+ TRAP( error, iPermission->iPlay = CDRMConstraint::NewL() );
+ if( error )
+ {
+ return error;
+ }
+ }
+
+ TRAP( error, iPermission->iPlay->DuplicateL( aConstraint->GetConstraint() ) );
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::SetDisplayRight
+// This function sets the constraints associated with the display right.
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRights::SetDisplayRight(
+ CDRMRightsConstraints* aConstraint)
+ {
+ TInt error = KErrNone;
+
+ if( !iPermission )
+ {
+ TRAP( error, iPermission = CDRMPermission::NewL());
+ if( error )
+ {
+ return error;
+ }
+ }
+ else if( !iPermission->iDisplay )
+ {
+ TRAP( error, iPermission->iDisplay = CDRMConstraint::NewL() );
+ if( error )
+ {
+ return error;
+ }
+ }
+
+ TRAP( error, iPermission->iDisplay->DuplicateL( aConstraint->GetConstraint() ) );
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::SetPrintRight
+// This function sets the constraints associated with the print right.
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRights::SetPrintRight(
+ CDRMRightsConstraints* aConstraint)
+ {
+ TInt error = KErrNone;
+
+ if( !iPermission )
+ {
+ TRAP( error, iPermission = CDRMPermission::NewL());
+ if( error )
+ {
+ return error;
+ }
+ }
+ else if( !iPermission->iPrint )
+ {
+ TRAP( error, iPermission->iPrint = CDRMConstraint::NewL() );
+ if( error )
+ {
+ return error;
+ }
+ }
+
+ TRAP( error, iPermission->iPrint->DuplicateL( aConstraint->GetConstraint() ) );
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::SetExecuteRight
+// This function sets the constraints associated with the execute right.
+// -----------------------------------------------------------------------------
+EXPORT_C TInt CDRMRights::SetExecuteRight(
+ CDRMRightsConstraints* aConstraint)
+ {
+ TInt error = KErrNone;
+
+ if( !iPermission )
+ {
+ TRAP( error, iPermission = CDRMPermission::NewL());
+ if( error )
+ {
+ return error;
+ }
+ }
+ else if( !iPermission->iExecute )
+ {
+ TRAP( error, iPermission->iExecute = CDRMConstraint::NewL() );
+ if( error )
+ {
+ return error;
+ }
+ }
+
+ TRAP( error, iPermission->iExecute->DuplicateL( aConstraint->GetConstraint() ) );
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::GetPermission
+// -----------------------------------------------------------------------------
+EXPORT_C CDRMPermission& CDRMRights::GetPermission(void)
+ {
+ return *iPermission;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::SetPermissionL
+// -----------------------------------------------------------------------------
+EXPORT_C void CDRMRights::SetPermissionL(CDRMPermission& aRO)
+ {
+ delete iPermission;
+ iPermission = NULL;
+ iPermission = CDRMPermission::NewL();
+ iPermission->DuplicateL(aRO);
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::GetAsset
+// -----------------------------------------------------------------------------
+EXPORT_C CDRMAsset& CDRMRights::GetAsset(void)
+ {
+ return *iAsset;
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::SetAssetL
+// -----------------------------------------------------------------------------
+EXPORT_C void CDRMRights::SetAssetL(CDRMAsset& aAsset)
+ {
+ delete iAsset;
+ iAsset = NULL;
+ iAsset = CDRMAsset::NewL();
+ iAsset->DuplicateL(aAsset);
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::operator=
+// Assignment operator.
+// -----------------------------------------------------------------------------
+EXPORT_C CDRMRights& CDRMRights::operator=(
+ CDRMRights& aRight)
+ {
+ TInt r = KErrNone;
+
+ if (this == &aRight)
+ {
+ return *this;
+ }
+
+ TRAP(r, SetAssetL(aRight.GetAsset()));
+ TRAP(r, SetPermissionL(aRight.GetPermission()));
+
+ return* this;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDRMRights::ExternalizeL
+// -----------------------------------------------------------------------------
+EXPORT_C void CDRMRights::ExternalizeL(RWriteStream& aStream) const
+ {
+ iAsset->ExternalizeL(aStream);
+ iPermission->ExternalizeL(aStream);
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::InternalizeL
+// -----------------------------------------------------------------------------
+EXPORT_C void CDRMRights::InternalizeL(RReadStream& aStream)
+ {
+ delete iAsset;
+ iAsset = NULL;
+ delete iPermission;
+ iPermission=NULL;
+
+ iAsset = CDRMAsset::NewL();
+ iPermission = CDRMPermission::NewL();
+
+ iAsset->InternalizeL(aStream);
+ iPermission->InternalizeL(aStream);
+ }
+
+// -----------------------------------------------------------------------------
+// CDRMRights::Merge
+// -----------------------------------------------------------------------------
+EXPORT_C void CDRMRights::Merge(const CDRMRights& aRights)
+ {
+ iPermission->Merge(*aRights.iPermission);
+ }
+
+// End of file