/*

* 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;