FCL/sf/mw/drm: comparison commondrm/drmutility/src/drmutilitywmdrmutilities.cpp

equal deleted inserted replaced

-:79d62d1d7957
+:493788a4a8a4
 #include <e32std.h>
 #include <DRMRights.h>
-#include "drmclockclient.h"
+#include "DRMClockClient.h"
 #include "drmutilitywmdrmutilities.h"
-#include "drmrights.h"
+#include "DRMRights.h"
 // CONSTANTS
 _LIT( KLicenseType, "licensetype=" );
 _LIT( KTime, "time" );
 _LIT( KCount, "count" );
 LOCAL_C TBool ParseString( TChar aChar, TLex& aLex, TPtrC16& aPtr )
 {
 TBool found( EFalse );
 aLex.Mark();
 while ( !aLex.Eos() && found == EFalse )
 {
 TChar ch;
 ch = aLex.Get();
 if ( ch == aChar )
 // Remove char from the token string and read it from the lex.
 aLex.UnGet();
 aPtr.Set( aLex.MarkedToken() );
 aLex.Get();
 }
 else
 {
 aPtr.Set( aLex.MarkedToken() );
 }
 found = ETrue;
 }
 TPtrC16 token( NULL, 0 );
 TUint8 times( 0 );
 TTime localTime( Time::NullTTime() );
 TTime universalTime( Time::NullTTime() );
 TTimeIntervalSeconds timeDifference( 0 ); // local time - secure time
 TInt years, months, days, hours, minutes, secs;
 TChar ch;
 TLex lex;
 TTime drmTime;
 TInt timeZone;
 DRMClock::ESecurityLevel secLevel = DRMClock::KInsecure;
 // The format of the start and end time strings is the following:
 // "starttime=yy-mm-ddThh:mins:ssZ
 // "endtime=yy-mm-ddThh:mins:ssZ
 // where yy = years, mm = months, dd = days, hh = hours,
 // mins = minutes and ss = seconds, "-", "T", ":" and "Z"
 // are separators.
 while ( !aLex.Eos() && ( aLex.Peek() != 0 ) )
 {
 // The next string should be start time, end time or then
 // it does not exist.
 ParseString( '=', aLex, token );
 if ( token.CompareF( KStartTime ) == 0 )
 {
 times |= KFoundStartTime;
 }
 else if ( token.CompareF( KEndTime ) == 0 )
 {
 times |= KFoundEndTime;
 }
 else
 {
 // No start time ("starttime=") or end time ("endtime=")
 // string was found -> return
 return;
 }
 if ( ( times & KFoundStartTime ) || ( times & KFoundEndTime ) )
 {
 // Search for years, months, days, hours, minutes, secs
 if ( ParseString( '-', aLex, token ) )
 {
 TLex lexYear( token );
 User::LeaveIfError( lexYear.Val( years ) );
 }
 else
 {
 User::Leave( KErrNotFound );
 }
 if ( ParseString( '-', aLex, token ) )
 {
 TLex lexMonths( token );
 User::LeaveIfError( lexMonths.Val( months ) );
 }
 else
 {
 User::Leave( KErrNotFound );
 }
 if ( ParseString( 'T', aLex, token ) )
 {
 TLex lexDays( token );
 User::LeaveIfError( lexDays.Val( days ) );
 }
 else
 {
 User::Leave( KErrNotFound );
 }
 if( ParseString( ':', aLex, token ) )
 {
 TLex lexHours( token );
 User::LeaveIfError( lexHours.Val( hours ) );
 }
 else
 {
 User::Leave( KErrNotFound );
 }
 if ( ParseString( ':', aLex, token ) )
 {
 TLex lexMinutes( token );
 User::LeaveIfError( lexMinutes.Val( minutes ) );
 }
 else
 {
 User::Leave( KErrNotFound );
 }
 if( ParseString( 'Z', aLex, token ) )
 {
 TLex lexSeconds( token );
 User::LeaveIfError( lexSeconds.Val( secs ) );
 }
 else
 {
 User::Leave( KErrNotFound );
 }
 ParseString( ';', aLex, token );
 token.Set( NULL, 0 );
 TDateTime date( years, (TMonth)( months - 1 ), days - 1, hours,
 minutes, secs, 0 );
 TTime dateTime( date );
 // Get secure time from DRM clock
 RDRMClockClient client;
 User::LeaveIfError( client.Connect() );
 client.GetSecureTime( drmTime, timeZone, secLevel );
 client.Close();
-			localTime.HomeTime();
+localTime.HomeTime();
-	if ( secLevel == DRMClock::KSecure )
+if ( secLevel == DRMClock::KSecure )
-		{
+{
-				// Calculate the difference between local time and secure time
+// Calculate the difference between local time and secure time
-	localTime.SecondsFrom( drmTime, timeDifference );
+localTime.SecondsFrom( drmTime, timeDifference );
-	}
+}
-			else
+else
-				{
+{
-				// Calculate the difference between local and universal time
+// Calculate the difference between local and universal time
-				universalTime.UniversalTime();
+universalTime.UniversalTime();
-				localTime.SecondsFrom( universalTime, timeDifference );
+localTime.SecondsFrom( universalTime, timeDifference );
-				}
+}
-			dateTime += timeDifference;
+dateTime += timeDifference;
 if ( times & KFoundStartTime )
 {
 aStartTime = dateTime;
 times &= ~KFoundStartTime;
 }
 //
 EXPORT_C TBool DrmUtilityWmDrmUtilities::ParseWmDrmCountRightsL( TLex& aLex,
 TUint32& aCounts )
 {
 TPtrC16 token( NULL, 0 );
 TInt counts( 0 );
 TChar ch;
 TLex lex;
 ParseString( '=', aLex, token );
 if ( token.CompareF( KCountLeft ) == 0 )
 {
 ParseString( ';', aLex, token );
 TLex lexCount( token );
 User::LeaveIfError( lexCount.Val( counts ) );
 aCounts = counts;
 return ETrue;
 }
 else
 {
 // No counts left ("countleft=") string was found.
 // -> No count information was found, return EFalse
 return EFalse;
 }
 // ----------------------------------------------------------------------------
 // DrmUtilityWmDrmUtilities::ParseWmDrmDurationRightsL
 // ----------------------------------------------------------------------------
 //
 EXPORT_C TBool DrmUtilityWmDrmUtilities::ParseWmDrmDurationRightsL( TLex& aLex,
 TTimeIntervalSeconds& aDuration )
 {
 TPtrC16 token( NULL, 0 );
 TChar ch;
 TInt duration( 0 );
 ParseString( '=', aLex, token );
 if ( token.CompareF( KDurationLeft ) == 0 )
 {
 ParseString( ';', aLex, token );
 TLex lexDuration( token );
 User::LeaveIfError( lexDuration.Val( duration ) );
 aDuration = duration;
 return ETrue;
 }
 else
 {
 // No duration left ("durationleft=") string was found.
 // -> No duration information was found, return EFalse
 return EFalse;
 }
 }
 // ----------------------------------------------------------------------------
 // DrmUtilityWmDrmUtilities::ParseWmDrmStringL
 // ----------------------------------------------------------------------------
 //
 EXPORT_C void DrmUtilityWmDrmUtilities::ParseWmDrmStringL(
 ContentAccess::CRightsInfo& aRights,
 CDRMRightsConstraints*& aRightsConstraint )
 {
 __ASSERT_DEBUG( !aRightsConstraint,
 User::Panic( KWmDrmUtilitiesDebugPanicMessage,
 KWmDrmUtilitiesDebugPanicCode ) );
 TChar ch;
 TTime startTime( Time::NullTTime() );
 TTime endTime( Time::NullTTime() );
 TTimeIntervalSeconds duration( 0 );
 TUint32 counter( 0 );
 TPtrC16 token( NULL, 0 );
 // Parse the WM DRM rights string
 TLex lex( aRights.Description() );
 // First, find the license type format string ("licensetype=")
 ParseString( '=', lex, token );
 if ( token.CompareF( KLicenseType ) != 0 )
 {
 // License type format string was not found
 User::Leave( KErrArgument );
 }
 // Peek for the end of string (eos) in case of (licensetype="")
 ch = lex.Peek();
 if ( ch == 0 )
 {
 return;
 }
 // Check the license type
 ParseString( ';', lex, token );
 aRightsConstraint = CDRMRightsConstraints::NewL();
 CleanupStack::PushL( aRightsConstraint );
 // Check what kind of rights are in question by parsing the string
 // onward. The possible rights are date time (start time and/or end time),
 // count, duration, time count (count and/or date time) and unlimited
 // rights. The substrings for certain rights are further parsed in
 // specific methods.
 if ( token.CompareF( KTime ) == 0 )
 {
 ParseWmDrmTimeRightsL( lex, startTime, endTime );
 if ( Time::NullTTime() != startTime )
 {
 aRightsConstraint->SetEndTime( endTime );
 }
 }
 else if ( token.CompareF( KUnlimited ) != 0 )
 {
 // Unknown license type
 User::Leave( KErrArgument );
 }
 CleanupStack::Pop( aRightsConstraint );
 }
 // -----------------------------------------------------------------------------
 // DrmUtilityWmDrmUtilities::CheckWmDrmRightsL
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void DrmUtilityWmDrmUtilities::CheckWmDrmRightsL( TBool& aUnconstrained,
 TTimeIntervalSeconds& aTime,
 TInt& aCounts,
 ContentAccess::CRightsInfo& aRights )
 {
 TChar ch;
 TPtrC16 token( NULL, 0 );
 TInt constraints( 0 );
 TInt error( KErrNone );
 TTime startTime( Time::NullTTime() );
 TUint32 counter( 0 );
 TTime now( Time::NullTTime() ); // current time
 // End time of rights when duration is taken into account.
 TTime durationEndTime( Time::NullTTime() );
 TTimeIntervalSeconds secondsLeft( 0 ); // seconds to end of time based rights
 // Parse WM DRM rights string
 TLex lex( aRights.Description() );
 // First, find the license type format string ("licensetype=")
 ParseString( '=', lex, token );
 if ( token.CompareF( KLicenseType ) != 0 )
 {
 // License type format string was not found
 User::Leave( KErrArgument );
 }
 // Peek for the end of string (Eos) in case of (licensetype="")
 ch = lex.Peek();
 if ( ch == 0 )
 {
 return;
 }
 // Check the license type
 ParseString( ';', lex, token );
 // Check what kind of rights are in question by parsing the string
 // onward. The possible rights are date time (start time and/or end time),
 // count, duration, time count (count and/or date time) and unlimited
 // rights. The substrings for certain rights are further parsed in
 // specific methods.
 if ( token.CompareF( KTime ) == 0 )
 {
 ParseWmDrmTimeRightsL( lex, startTime, endTime );
 if ( Time::NullTTime() != startTime )
 {
 {
 if ( ParseWmDrmCountRightsL( lex, counter ) )
 {
 aCounts = counter;
 constraints |= KWmDrmConstraintCount;
 }
 }
 else if ( token.CompareF( KDuration ) == 0 )
 {
 if ( ParseWmDrmDurationRightsL( lex, aTime ) )
 {
 }
 if ( Time::NullTTime() != endTime )
 {
 constraints |= KWmDrmConstraintEndTime;
 }
 }
 else if ( token.CompareF( KUnlimited ) == 0 )
 {
 aUnconstrained = ETrue;
 return;
 }
 else
 {
 // Unknown license type
 User::Leave( KErrArgument );
 }
 // Get current time
 now.HomeTime();
 // The rights are not constrained
 if ( !constraints )
 {
 aUnconstrained = ETrue;
 }
 if ( constraints & KWmDrmConstraintStartTime )
 {
 // The start time is in the past or the current time
 if ( ( now >= startTime ) &&
 !( constraints & KWmDrmConstraintEndTime ) &&
 !( constraints & KWmDrmConstraintCount ) )
 {
 aUnconstrained = ETrue;
 }
 // This use case is unclear and should be specified later.
 // There are counts for the content, but the start time has
 // not been reached.
 if ( ( constraints & KWmDrmConstraintCount ) &&
 ( now < startTime ) )
 {
 aCounts = 0;
 }
 }
 // Find out the amount of time that the rights have left in
 // case the rights have end time constraint.
 if ( constraints & KWmDrmConstraintEndTime )
 {
 error = endTime.SecondsFrom( now, secondsLeft );
 // The difference between current time and the end time does not
 // fit to 32-bit number, the start time has been reached and there
 // are no count constraints defined.
 if ( ( error == KErrOverflow ) &&
 ( !( constraints & KWmDrmConstraintStartTime ) ||
 ( now >= startTime ) ) && !( constraints & KWmDrmConstraintCount ) )
 {
 aUnconstrained = ETrue;
 }
 // End time has not been reached and start time has been reached
 if ( ( secondsLeft > (TTimeIntervalSeconds)0 ) && ( now >= startTime ) )
 {
 aTime = secondsLeft;
 }
 // This use case is unclear and should be specified later.
 // There are counts for the content, but the end time has
 // been reached.
 if ( ( constraints & KWmDrmConstraintCount ) &&
 ( now > endTime ) )
 {
 aCounts = 0;
 }
 }
 return;
 }
 // End of File

changeset 23	493788a4a8a4
parent 0	95b198f216e5