/*
* Copyright (c) 2006-2007 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:  DRM Utility common functionality
*
*/


// INCLUDE FILES
#include <drmpermission.h>
#include <drmconstraint.h>

#include "drmutilitycommon.h"
#include "drmclockclient.h"
#include "drmpointerarray.h"

// ============================= LOCAL FUNCTIONS ===============================

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CDrmUtilityCommon::CDrmUtilityCommon
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
DRM::CDrmUtilityCommon::CDrmUtilityCommon()
    {
    }

// -----------------------------------------------------------------------------
// CDrmUtilityCommon::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void DRM::CDrmUtilityCommon::ConstructL()
    {
    User::LeaveIfError( iOmaClient.Connect() );
    }


// -----------------------------------------------------------------------------
// CDrmUtilityCommon::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C DRM::CDrmUtilityCommon* DRM::CDrmUtilityCommon::NewLC()
    {
    DRM::CDrmUtilityCommon* self( new( ELeave ) CDrmUtilityCommon() );
    
    CleanupStack::PushL( self );
    self->ConstructL();
    
    return self;
    }

// -----------------------------------------------------------------------------
// CDrmUtilityCommon::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C DRM::CDrmUtilityCommon* DRM::CDrmUtilityCommon::NewL()
    {
    DRM::CDrmUtilityCommon* self( NewLC() );
    
    CleanupStack::Pop( self );
    
    return self;
    }

// Destructor
DRM::CDrmUtilityCommon::~CDrmUtilityCommon()
    {
    iOmaClient.Close();
    }

// -----------------------------------------------------------------------------
// CDrmUtilityCommon::GetOmaRightsStatusL
//
// -----------------------------------------------------------------------------
//	
EXPORT_C DRM::TDrmRightsInfo DRM::CDrmUtilityCommon::GetOmaRightsStatusL( 
    HBufC8*& aContentUri,
    ContentAccess::TIntent aIntent,
    CDRMConstraint* aConstraint )
    {
    CDRMPointerArray<CDRMPermission>* uriList( NULL );
    CDRMPointerArray<HBufC8>* individuals( NULL );
    RDRMClockClient clockClient;
    DRMClock::ESecurityLevel secLevel( DRMClock::KInsecure );
    TTime drmTime( Time::NullTTime() );
    TBool possiblefuture( EFalse );
    CDRMConstraint* constraint( NULL );
    CDRMConstraint* toplevel( NULL );
    TUint32 retval( 0 );
    TInt r( KErrNone );          
        
    r = clockClient.Connect();
    CleanupClosePushL( clockClient );
    if ( !r )
        {
        TInt timeZone( 0 );        
        clockClient.GetSecureTime( drmTime, timeZone, secLevel );
        }
                                      
    uriList = CDRMPointerArray<CDRMPermission>::NewLC();
    uriList->SetAutoCleanup( ETrue );
    TRAP_IGNORE( iOmaClient.GetDBEntriesL( *aContentUri, *uriList ) );                                  
                                      
    if ( !uriList->Count() )
        {
        CleanupStack::PopAndDestroy( 2, &clockClient ); //clockClient, uriList
        return DRM::EURightsInfoMissing;
        }
    
    individuals = CDRMPointerArray<HBufC8>::NewLC();
    individuals->SetAutoCleanup( ETrue );
    TRAP_IGNORE( iOmaClient.GetSupportedIndividualsL( *individuals ) );    
    
    // Now we have the time, rights and the individual constraints do the
    // checking. The rights are never valid if we get here so we don't have
    // to check for that
    for ( TInt i( 0 ); i < uriList->Count() && !possiblefuture ; i++ )
        {
        toplevel = NULL;
        constraint = NULL;
        
        // If the toplevel constraint is defined, get it:
        toplevel = (*uriList)[i]->TopLevelConstraint();
        // If constraint for the intent is defined, get it
        constraint = (*uriList)[i]->ConstraintForIntent( aIntent );
        
        // Top level constraint and constraint for intent, merge them
        if ( toplevel && constraint )
            {
            constraint->Merge( *toplevel );
            }
        // Only constraint for intent, use it
        else if ( constraint )
            {
            }
        // Only top level constraint or no constraints at all, continue
        else 
            {
            continue;
            }
                    
        // If the constraint is rejected due to non time reasons or there is no
        // time it can't be future
        constraint->Valid( drmTime, *individuals, retval );
        if ( retval & EConstraintCounter ||
             retval & EConstraintAccumulated ||
             retval & EConstraintTimedCounter ||
             retval & EConstraintIndividual ||
             retval & EConstraintNullDrmTime )
            {
            continue;
            }
        
        drmTime.HomeTime();
        
        // If the constrain has active start time and it is not valid,
        // it must be future
        if ( constraint->iActiveConstraints & EConstraintStartTime )
            {
            possiblefuture = ETrue;
            if ( aConstraint )
                {
                aConstraint->DuplicateL( *constraint );                       
                }
            }
                
        // If the constrain has active interval and itīs start time is in 
        // future, it must be future
        else if ( constraint->iActiveConstraints & EConstraintInterval &&
                  constraint->iIntervalStart > drmTime )
            {
            possiblefuture = ETrue;
            if ( aConstraint )
                {
                aConstraint->DuplicateL( *constraint );                     
                }
            }
        } // End of for loop
        
	CleanupStack::PopAndDestroy( 3, &clockClient ); //individuals, urilist, 
                                                    //clockClient
	return possiblefuture ? DRM::EURightsInfoFuture : DRM::EURightsInfoExpired;
	}
	
//  End of File