diff -r 000000000000 -r 95b198f216e5 commondrm/drmutility/src/DrmAutomatedUsageImpl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commondrm/drmutility/src/DrmAutomatedUsageImpl.cpp Thu Dec 17 08:52:27 2009 +0200 @@ -0,0 +1,1030 @@ +/* +* Copyright (c) 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 Automated Usage handling +* +*/ + + +// INCLUDE FILES +#include +#include +#include +#include +#include +#include +#include +#include + +#include "drmautomatedusageimpl.h" +#include "drmautomatedusagedata.h" +#include "drmutilityui.h" + +// CONSTANTS +_LIT( KAuClassificationRingingTone, "Ringtone" ); +_LIT( KAuClassificationVideoTone, "Videotone" ); + +const TInt KUrlMaxLen = 1024; +const TInt KTimeMarginal = 5000000; // 5 seconds + +// FORWARD DECLARATIONS +class CDRMConstraint; + +// ============================= LOCAL FUNCTIONS =============================== + +LOCAL_C TBool HasInterval( const CDRMConstraint *aConstraint ) + { + return aConstraint->iActiveConstraints & EConstraintInterval; + } + +LOCAL_C TBool HasEndTime( const CDRMConstraint *aConstraint ) + { + return aConstraint->iActiveConstraints & EConstraintEndTime; + } + +LOCAL_C TBool EndTimesEqual( const CDRMConstraint *aFirst, + const CDRMConstraint *aSecond ) + { + TBool equal( EFalse ); + TInt64 difference( aFirst->iEndTime.Int64() - aSecond->iEndTime.Int64() ); + if( -KTimeMarginal <= difference && difference <= KTimeMarginal ) + { + equal = ETrue; + } + return equal; + } + +LOCAL_C TBool IntervalsEqual( const CDRMConstraint *aFirst, + const CDRMConstraint *aSecond ) + { + TBool equal( EFalse ); + TInt64 startDifference( + aFirst->iIntervalStart.Int64() - aSecond->iIntervalStart.Int64() ); + + if( aFirst->iInterval == aSecond->iInterval && + -KTimeMarginal <= startDifference && + startDifference <= KTimeMarginal ) + { + equal = ETrue; + } + return equal; + } + + +LOCAL_C HBufC8* GetContentIdL( const ContentAccess::CData& aData ) + { + HBufC* uniqueId( NULL ); + HBufC8* uniqueId8( NULL ); + TPtr value( NULL, 0 ); + + uniqueId = HBufC::NewLC( ContentAccess::KMaxCafContentName ); + + value.Set( uniqueId->Des() ); + + User::LeaveIfError( aData.GetStringAttribute( ContentAccess::EContentID, + value ) ); + + uniqueId8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L( value ); + CleanupStack::PopAndDestroy( uniqueId ); + + return uniqueId8; + } + +LOCAL_C TBool HasCountOrAccumulated( const CDRMConstraint* aConstraint ) + { + // constraint has counters, timed counters or accumulated + if ( aConstraint->iActiveConstraints & ( EConstraintCounter | + EConstraintTimedCounter | + EConstraintAccumulated ) ) + { + return ETrue; + } + return EFalse; + } + +#pragma mark - +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::CDrmAutomatedUsageImpl +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +DRM::CDrmAutomatedUsageImpl::CDrmAutomatedUsageImpl( + CCoeEnv* aCoeEnv, + DRM::CDrmUtility* aDrmUtility ): CActive( EPriorityStandard ), + iAuObserver( NULL ), + iCoeEnv( aCoeEnv ), + iDrmUtility( aDrmUtility ) + { + + } + +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void DRM::CDrmAutomatedUsageImpl::ConstructL() + { + iDrmUtilityUi = DRM::CDrmUtilityUI::NewL( iCoeEnv ); + + iDrmQueue = CDrmQueue< DRM::CDrmAutomatedUsageData >::NewL(); + + User::LeaveIfError( iOmaClient.Connect() ); + + //User::LeaveIfError( iWmClient.Connect() ); + + User::LeaveIfError( iDrmHelperClient.Connect() ); + } + +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C DRM::CDrmAutomatedUsageImpl* DRM::CDrmAutomatedUsageImpl::NewL( + CCoeEnv* aCoeEnv, + DRM::CDrmUtility* aDrmUtility ) + { + DRM::CDrmAutomatedUsageImpl* self( + DRM::CDrmAutomatedUsageImpl::NewLC( aCoeEnv, + aDrmUtility ) ); + CleanupStack::Pop( self ); + return self; + } + + +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C DRM::CDrmAutomatedUsageImpl* DRM::CDrmAutomatedUsageImpl::NewLC( + CCoeEnv* aCoeEnv, DRM::CDrmUtility* aDrmUtility ) + { + DRM::CDrmAutomatedUsageImpl* self( + new( ELeave ) DRM::CDrmAutomatedUsageImpl( aCoeEnv, + aDrmUtility ) ); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + + +// Destructor +DRM::CDrmAutomatedUsageImpl::~CDrmAutomatedUsageImpl() + { + DRM::CDrmAutomatedUsageData* data( iDrmQueue->PopFront() ); + + // Empty the queue: + while ( data ) + { + // Complete the outstanding requestest with cancel + data->iObserver->OperationCompleted( data->iOperationId, KErrCancel ); + delete data; + data = iDrmQueue->PopFront(); + } + + delete iDrmQueue; + + delete iDrmUtilityUi; + + iDrmHelperClient.Close(); + + //iWmClient.Close(); + + iOmaClient.Close(); + + // Remove the object from active scheduler etc. + if ( IsAdded() ) + { + Deque(); + } + } + + +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::CanSetAutomated +// Implementation of file-based CanSetAutomated +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// + +EXPORT_C TBool DRM::CDrmAutomatedUsageImpl::CanSetAutomatedL( + RFile& aFile, + const ContentAccess::TIntent aIntent, + const DRM::TDrmAutomatedType aAutomatedType ) + { + TBool returnValue( EFalse ); + TPtrC drmAgent( KNullDesC ); + DRM::TDrmProtectionStatus protectedFile( DRM::EUUnknown ); + + returnValue = iDrmUtility->GetDrmInfoL( aFile, drmAgent, protectedFile ); + if ( !returnValue || protectedFile == DRM::EUUnprotected ) + { + // not DRM file at all or not protected DRM file. + // So can be set as automated. + return ETrue; + } + if ( drmAgent == DRM::KDrmWMAgentName ) + { + //WMDRM not supported as automated. So no need to continue. + return EFalse; + } + + ContentAccess::CData* data( + ContentAccess::CData::NewLC( aFile, + ContentAccess::KDefaultContentObject, + ContentAccess::EPeek ) ); + + returnValue = CanSetAutomatedL( *data, aIntent, aAutomatedType ); + CleanupStack::PopAndDestroy( data ); + return returnValue; + } + +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::CanSetAutomated +// Implementation of ContentAccess::CData-based CanSetAutomated +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// + +EXPORT_C TBool DRM::CDrmAutomatedUsageImpl::CanSetAutomatedL( + const ContentAccess::CData& aData, + const ContentAccess::TIntent aIntent, + const DRM::TDrmAutomatedType aAutomatedType ) + { + TInt err( 0 ); + TInt agentUid( 0 ); + HBufC8* uniqueId8( NULL ); + TBool canSetAutomated( EFalse ); + TBool protectedFile( EFalse ); + + User::LeaveIfError( aData.GetAttribute( ContentAccess::EIsProtected, + protectedFile ) ); + if ( !protectedFile ) + { + // not protected. So can be set as automated. + return ETrue; + } + + User::LeaveIfError( aData.GetAttribute( DRM::EDrmAgentUid, agentUid ) ); + + if ( agentUid == DRM::EDrmWmAgent ) + { + //WMDRM not supported as automated. So no need to continue. + return EFalse; + } + + uniqueId8 = GetContentIdL( aData ); + CleanupStack::PushL( uniqueId8 ); + + // now check whether there is OMA RO + // suitable for automated use + canSetAutomated = DoCanSetAutomatedL( *uniqueId8, aIntent, aAutomatedType ); + + if( canSetAutomated ) + { + TInt filetype( 0 ); + User::LeaveIfError( aData.GetAttribute( EFileType, filetype ) ); + if ( aIntent == ContentAccess::EPlay && filetype == EOma2Dcf ) + { + // If Content type == OMA2 && intent == Play + // let's look at classification info + TPtr value( NULL, 0 ); + HBufC* classificationInfo( HBufC::NewLC( KUrlMaxLen ) ); + value.Set( classificationInfo->Des() ); + + err = aData.GetStringAttribute( EClassificationInfo, value ); + if( err && err != KErrCANotSupported ) + { + User::Leave( err ); + } + + if ( classificationInfo-> + FindF( KAuClassificationRingingTone ) == KErrNotFound && + classificationInfo-> + FindF( KAuClassificationVideoTone ) == KErrNotFound ) + { + canSetAutomated = EFalse; + } + CleanupStack::PopAndDestroy( classificationInfo ); + } + } + + CleanupStack::PopAndDestroy( uniqueId8 ); + + return canSetAutomated; + } +#pragma mark - + +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::SetAutomatedL +// Implementation of file-based SetAutomated +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C void DRM::CDrmAutomatedUsageImpl::SetAutomatedL( + RFile& aFile, + const ContentAccess::TIntent aIntent, + const DRM::TDrmAutomatedType aAutomatedType, + const DRM::TDrmAutomatedServiceType aServiceType ) + { + ContentAccess::CData* data = + ContentAccess::CData::NewLC( aFile, + ContentAccess::KDefaultContentObject, + ContentAccess::EPeek ); + SetAutomatedL( *data, aIntent, aAutomatedType, aServiceType); + CleanupStack::PopAndDestroy( data ); + } + +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::SetAutomatedAsyncL +// Implementation of file-based SetAutomated +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt DRM::CDrmAutomatedUsageImpl::SetAutomatedAsyncL( + RFile& aFile, + const ContentAccess::TIntent aIntent, + const DRM::TDrmAutomatedType aAutomatedType, + DRM::MDrmAsyncObserver& aObserver, + const DRM::TDrmAutomatedServiceType aServiceType ) + { + TInt ret( KErrNone ); + + ContentAccess::CData* data = + ContentAccess::CData::NewLC( aFile, + ContentAccess::KDefaultContentObject, + ContentAccess::EPeek ); + + ret = SetAutomatedAsyncL( *data, aIntent, aAutomatedType, aObserver, aServiceType ); + + CleanupStack::PopAndDestroy( data ); + + return ret; + } + +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::SetAutomatedL +// Implementation of ContentAccess::CData-based SetAutomated +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C void DRM::CDrmAutomatedUsageImpl::SetAutomatedL( + const ContentAccess::CData& aData, + const ContentAccess::TIntent aIntent, + const DRM::TDrmAutomatedType aAutomatedType, + const DRM::TDrmAutomatedServiceType aServiceType ) + { + if ( !CanSetAutomatedL( aData, aIntent, aAutomatedType ) ) + { + User::Leave( KErrArgument ); + } + + DRM::CDrmAutomatedUsageData* data( + DRM::CDrmAutomatedUsageData::NewLC( + aData, + aIntent, + aAutomatedType, + NULL, + aServiceType, + DRM::CDrmAutomatedUsageData::ESetAutomated ) ); + + User::LeaveIfError ( DoSetAutomatedL( data ) ); + + CleanupStack::PopAndDestroy( data ); + } + +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::SetAutomatedAsyncL +// Implementation of ContentAccess::CData-based SetAutomated +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt DRM::CDrmAutomatedUsageImpl::SetAutomatedAsyncL( + const ContentAccess::CData& aData, + const ContentAccess::TIntent aIntent, + const DRM::TDrmAutomatedType aAutomatedType, + DRM::MDrmAsyncObserver& aObserver, + const DRM::TDrmAutomatedServiceType aServiceType ) + { + if ( !CanSetAutomatedL( aData, aIntent, aAutomatedType ) ) + { + User::Leave( KErrArgument ); + } + + DRM::CDrmAutomatedUsageData* data( + DRM::CDrmAutomatedUsageData::NewL( + aData, + aIntent, + aAutomatedType, + &aObserver, + aServiceType, + DRM::CDrmAutomatedUsageData::ESetAutomated ) ); + + iDrmQueue->AppendToQueueL( data ); + + TRequestStatus* status( &iStatus ); + + Activate( status ); + + return data->iOperationId; + } + +#pragma mark - +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::RemoveAutomated +// Removes content from automated use +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C void DRM::CDrmAutomatedUsageImpl::RemoveAutomatedL( + RFile& aFile, + const ContentAccess::TIntent aIntent, + const DRM::TDrmAutomatedType aAutomatedType, + const DRM::TDrmAutomatedServiceType aServiceType ) + { + ContentAccess::CData* data( + ContentAccess::CData::NewLC( aFile, + ContentAccess::KDefaultContentObject, + ContentAccess::EPeek ) ); + + RemoveAutomatedL( *data, aIntent, aAutomatedType, aServiceType ); + CleanupStack::PopAndDestroy( data ); + } + +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::RemoveAutomatedAsyncL +// Removes content from automated use +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt DRM::CDrmAutomatedUsageImpl::RemoveAutomatedAsyncL( + RFile& aFile, + const ContentAccess::TIntent aIntent, + const DRM::TDrmAutomatedType aAutomatedType, + DRM::MDrmAsyncObserver& aObserver, + const DRM::TDrmAutomatedServiceType aServiceType ) + { + TInt ret( KErrNone ); + + ContentAccess::CData* data( + ContentAccess::CData::NewLC( aFile, + ContentAccess::KDefaultContentObject, + ContentAccess::EPeek ) ); + + ret = RemoveAutomatedAsyncL( *data, + aIntent, + aAutomatedType, + aObserver, + aServiceType ); + + CleanupStack::PopAndDestroy( data ); + return ret; + } + +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::RemoveAutomatedL +// Removes content from automated use +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C void DRM::CDrmAutomatedUsageImpl::RemoveAutomatedL( + const ContentAccess::CData& aData, + const ContentAccess::TIntent aIntent, + const DRM::TDrmAutomatedType aAutomatedType, + const DRM::TDrmAutomatedServiceType aServiceType ) + { + DRM::CDrmAutomatedUsageData* data ( + DRM::CDrmAutomatedUsageData::NewLC( + aData, + aIntent, + aAutomatedType, + NULL, + aServiceType, + DRM::CDrmAutomatedUsageData::ERemoveAutomated ) ); + + User::LeaveIfError( DoRemoveAutomated( data ) ); + + CleanupStack::PopAndDestroy( data ); + } + +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::RemoveAutomatedAsyncL +// Removes content from automated use +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt DRM::CDrmAutomatedUsageImpl::RemoveAutomatedAsyncL( + const ContentAccess::CData& aData, + const ContentAccess::TIntent aIntent, + const DRM::TDrmAutomatedType aAutomatedType, + DRM::MDrmAsyncObserver& aObserver, + const DRM::TDrmAutomatedServiceType aServiceType ) + { + DRM::CDrmAutomatedUsageData* data( + DRM::CDrmAutomatedUsageData::NewL( + aData, + aIntent, + aAutomatedType, + &aObserver, + aServiceType, + DRM::CDrmAutomatedUsageData::ERemoveAutomated ) ); + + iDrmQueue->AppendToQueueL( data ); + + TRequestStatus* status( &iStatus ); + + Activate( status ); + + return data->iOperationId; + } + +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::RemoveAutomatedL +// Removes content from automated use +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C void DRM::CDrmAutomatedUsageImpl::RemoveAutomatedL( + const TDesC& aUniqueId, + const ContentAccess::TIntent aIntent, + const DRM::TDrmAutomatedType aAutomatedType, + const DRM::TDrmAutomatedServiceType aServiceType ) + { + DRM::CDrmAutomatedUsageData* data( + DRM::CDrmAutomatedUsageData::NewLC( + aUniqueId, + aIntent, + aAutomatedType, + NULL, + aServiceType, + DRM::CDrmAutomatedUsageData::ERemoveAutomated ) ); + + User::LeaveIfError( DoRemoveAutomated( data ) ); + + CleanupStack::PopAndDestroy( data ); + } + +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::RemoveAutomatedAsyncL +// Removes content from automated use +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt DRM::CDrmAutomatedUsageImpl::RemoveAutomatedAsyncL( + const TDesC& aUniqueId, + const ContentAccess::TIntent aIntent, + const TDrmAutomatedType aAutomatedType, + MDrmAsyncObserver& aObserver, + const TDrmAutomatedServiceType aServiceType ) + { + DRM::CDrmAutomatedUsageData* data( + DRM::CDrmAutomatedUsageData::NewL( + aUniqueId, + aIntent, + aAutomatedType, + &aObserver, + aServiceType, + DRM::CDrmAutomatedUsageData::ERemoveAutomated ) ); + + iDrmQueue->AppendToQueueL( data ); + + TRequestStatus* status( &iStatus ); + + Activate( status ); + + return data->iOperationId; + } + +#pragma mark - +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::RegisterEventObserverL +// Registers the client to listen for automated usage events +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C void DRM::CDrmAutomatedUsageImpl::RegisterEventObserverL( + DRM::MDrmAutomatedUsageObserver& aObserver ) + { + if ( iAuObserver ) + { + User::Leave( KErrInUse ); + } + iAuObserver = &aObserver; + } + +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::UnregisterEventObserverL +// Registers the client to listen for automated usage events +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C void DRM::CDrmAutomatedUsageImpl::UnregisterEventObserverL( + DRM::MDrmAutomatedUsageObserver& aObserver ) + { + if ( iAuObserver == &aObserver ) + { + iAuObserver=NULL; + } + } + +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::CancelOperation +// Cancels the async operation +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +EXPORT_C TInt DRM::CDrmAutomatedUsageImpl::CancelOperation( TInt aOperationId ) + { + TInt returnValue( KErrNotFound ); + DRM::CDrmAutomatedUsageData* data( iDrmQueue->PopItem( aOperationId ) ); + + if ( data ) + { + data->iObserver->OperationCompleted( aOperationId, KErrCancel ); + delete data; + returnValue = KErrNone; + } + + return returnValue; + } +#pragma mark - +// ----------------------------------------------------------------------------- +// ----------------------------------------------------------------------------- +EXPORT_C TInt DRM::CDrmAutomatedUsageImpl::HandleErrorAsyncL( + RFile& /* aFile */, + ContentAccess::TIntent /* aIntent */, + TInt /* aError */, + DRM::MDrmHandleErrorObserver& /* aObserver */ ) + { + User::Leave( KErrNotSupported ); + return KErrNotSupported; + } + +// ----------------------------------------------------------------------------- +// ----------------------------------------------------------------------------- +EXPORT_C void DRM::CDrmAutomatedUsageImpl::HandleErrorL( + RFile& /* aFile */, + ContentAccess::TIntent /* aIntent */, + TInt /* aError */, + DRM::MDrmHandleErrorObserver* /* aObserver */ ) + { + User::Leave( KErrNotSupported ); + } + +// ----------------------------------------------------------------------------- +// ----------------------------------------------------------------------------- +EXPORT_C TInt DRM::CDrmAutomatedUsageImpl::HandleErrorAsyncL( + ContentAccess::CData& /* aFile */, + ContentAccess::TIntent /* aIntent */, + TInt /* aError */, + DRM::MDrmHandleErrorObserver& /* aObserver */ ) + { + User::Leave( KErrNotSupported ); + return KErrNotSupported; + } + +// ----------------------------------------------------------------------------- +// ----------------------------------------------------------------------------- +EXPORT_C void DRM::CDrmAutomatedUsageImpl::HandleErrorL( + ContentAccess::CData& /* aFile */, + ContentAccess::TIntent /* aIntent */, + TInt /* aError */, + DRM::MDrmHandleErrorObserver* /* aObserver */ ) + { + } +#pragma mark - + +// ----------------------------------------------------------------------------- +// CDrmAutomatedUsageImpl::DoSetAutomatedL +// ----------------------------------------------------------------------------- +// +TInt DRM::CDrmAutomatedUsageImpl::DoSetAutomatedL( + DRM::CDrmAutomatedUsageData* aAutomatedUsageData ) + { + if ( DoCanSetAutomatedL( + aAutomatedUsageData->iUniqueId8->Des(), + aAutomatedUsageData->iIntent, + aAutomatedUsageData->iAutomatedType, + ETrue ) ) + { + return iDrmHelperClient.SetAutomated( + aAutomatedUsageData->iUniqueId8->Des(), + aAutomatedUsageData->iAutomatedType, + aAutomatedUsageData->iIntent, + aAutomatedUsageData->iServiceType ); + } + else + { + return KErrCancel; + } + } + +#pragma mark - + +// ----------------------------------------------------------------------------- +// CDrmAutomatedUsageImpl::DoCanSetAutomatedL +// ----------------------------------------------------------------------------- +// +TBool DRM::CDrmAutomatedUsageImpl::DoCanSetAutomatedL( + const TDesC8& aUniqueId8, + const ContentAccess::TIntent aIntent, + const DRM::TDrmAutomatedType aAutomatedType, + const TBool aUseQueries ) + { + TBool canSetAutomated( EFalse ); + CDRMPermission* activePermission( NULL ); + TUint32 rejection( KErrNone ); + CDRMConstraint* constraint( NULL ); + CDRMConstraint* toplevel( NULL ); + + // First, fetch active permission from rights server + activePermission = iOmaClient.GetActiveRightsL( + aIntent, aUniqueId8, rejection ); + + if ( !activePermission ) + { + // No permission found so not possible to set as automated + return EFalse; + } + + CleanupStack::PushL( activePermission ); + + toplevel = activePermission->TopLevelConstraint(); + constraint = activePermission->ConstraintForIntent( aIntent ); + + if ( toplevel ) + { + constraint->Merge( *toplevel ); + } + + // Active permission for given intent must have valid constraint + // and it must not be count or accumulated time based + canSetAutomated = !HasCountOrAccumulated( constraint ); + + if ( canSetAutomated && aAutomatedType == DRM::EAUAutomatedTypeTheme ) + { + // Automated type is theme so must check whether active RO suits + // for theme use + canSetAutomated = DoCanSetAutomatedThemeL( aUniqueId8 ); + } + + if ( canSetAutomated && aUseQueries ) + { + canSetAutomated = iDrmUtilityUi->SetAutomatedQueryL( constraint ); + } + CleanupStack::PopAndDestroy( activePermission ); + return canSetAutomated; + } + +// ----------------------------------------------------------------------------- +// CDrmAutomatedUsageImpl::DoCanSetAutomatedThemeL +// ----------------------------------------------------------------------------- +// +TBool DRM::CDrmAutomatedUsageImpl::DoCanSetAutomatedThemeL( + const TDesC8& aUniqueId8 ) + { + TBool canSetAutomatedTheme( ETrue ); + TUint32 rejection( KErrNone ); + CDRMPermission* playPermission( NULL ); + CDRMConstraint* playConstraint( NULL ); + CDRMConstraint* playToplevel( NULL ); + + CDRMPermission* displayPermission( NULL ); + CDRMConstraint* displayConstraint( NULL ); + CDRMConstraint* displayToplevel( NULL ); + + CDRMPermission* executePermission( NULL ); + CDRMConstraint* executeConstraint( NULL ); + CDRMConstraint* executeToplevel( NULL ); + + //Check are there active play rights + playPermission = iOmaClient.GetActiveRightsL( + ContentAccess::EPlay, aUniqueId8, rejection ); + + if( !playPermission ) + { + return EFalse; + } + + CleanupStack::PushL( playPermission ); + + //Check are there active view rights + displayPermission = iOmaClient.GetActiveRightsL( + ContentAccess::EView, aUniqueId8, rejection ); + + if( !displayPermission ) + { + CleanupStack::PopAndDestroy( playPermission ); + return EFalse; + } + + CleanupStack::PushL( displayPermission ); + + //Check are there active execute rights + executePermission = iOmaClient.GetActiveRightsL( + ContentAccess::EExecute, aUniqueId8, rejection ); + + if( !executePermission ) + { + CleanupStack::PopAndDestroy( 2 ); //playPermission, displayPermission + return EFalse; + } + + CleanupStack::PushL( executePermission ); + + //If Play, View and Execute rights are valid, test constraints + playConstraint = + playPermission->ConstraintForIntent( ContentAccess::EPlay ); + playToplevel = playPermission->TopLevelConstraint(); + if ( playToplevel ) + { + playConstraint->Merge( *playToplevel ); + } + + displayConstraint = + displayPermission->ConstraintForIntent( ContentAccess::EView ); + displayToplevel = displayPermission->TopLevelConstraint(); + if ( displayToplevel ) + { + displayConstraint->Merge( *displayToplevel ); + } + + executeConstraint = + executePermission->ConstraintForIntent( ContentAccess::EExecute ); + executeToplevel = executePermission->TopLevelConstraint(); + if ( executeToplevel ) + { + executeConstraint->Merge( *executeToplevel ); + } + + // Check that all the constraints are not statefull + // from stateful ROs, uncactivated interval is ok. + if ( HasCountOrAccumulated( playConstraint ) || + HasCountOrAccumulated( displayConstraint ) || + HasCountOrAccumulated( executeConstraint ) ) + { + canSetAutomatedTheme = EFalse; + } + + // For end time based, end times must match + if ( canSetAutomatedTheme && + ( HasEndTime( playConstraint ) || + HasEndTime( displayConstraint ) || + HasEndTime( executeConstraint ) ) ) + { + canSetAutomatedTheme = + HasEndTime( playConstraint ) && + HasEndTime( displayConstraint ) && + HasEndTime( executeConstraint ) && + EndTimesEqual( playConstraint, displayConstraint ) && + EndTimesEqual( playConstraint, executeConstraint ); + } + + // For Interval based, intervals and interval activation times must match + if ( canSetAutomatedTheme && + ( HasInterval( playConstraint ) || + HasInterval( displayConstraint ) || + HasInterval( executeConstraint ) ) ) + { + canSetAutomatedTheme = + HasInterval( playConstraint ) && + HasInterval( displayConstraint ) && + HasInterval( executeConstraint ) && + IntervalsEqual( playConstraint, displayConstraint ) && + IntervalsEqual( playConstraint, executeConstraint ); + } + + CleanupStack::PopAndDestroy( 3 ); //playPermission, viewPermission, + //executePermission + + return canSetAutomatedTheme; + } + +#pragma mark - + +// ----------------------------------------------------------------------------- +// CDrmAutomatedUsageImpl::DoRemoveAutomated +// ----------------------------------------------------------------------------- +// +TInt DRM::CDrmAutomatedUsageImpl::DoRemoveAutomated( + DRM::CDrmAutomatedUsageData* aAutomatedUsageData ) + { + return iDrmHelperClient.RemoveAutomated( + aAutomatedUsageData->iUniqueId8->Des(), + aAutomatedUsageData->iAutomatedType, + aAutomatedUsageData->iIntent, + aAutomatedUsageData->iServiceType ); + } + + + +// ----------------------------------------------------------------------------- +// CDrmAutomatedUsageImpl::DoCancel +// ----------------------------------------------------------------------------- +// +void DRM::CDrmAutomatedUsageImpl::DoCancel() + { + } + +// ----------------------------------------------------------------------------- +// CDrmAutomatedUsageImpl::RunL +// ----------------------------------------------------------------------------- +// +void DRM::CDrmAutomatedUsageImpl::RunL() + { + DRM::CDrmAutomatedUsageData* data( iDrmQueue->PopFront() ); + TRequestStatus *status( &iStatus ); + + if ( !data ) + { + return; + } + + CleanupStack::PushL( data ); + + // Take this into the "current" variable in case an error occurs + iObserver = data->iObserver; + iOperationId = data->iOperationId; + + TInt err( KErrNone ); + + switch ( data->iOperation ) + { + case DRM::CDrmAutomatedUsageData::ESetAutomated: + + err = DoSetAutomatedL( data ); + + break; + + case DRM::CDrmAutomatedUsageData::ERemoveAutomated: + + err = DoRemoveAutomated( data ); + + break; + + default: + + err = KErrArgument; + + break; + } + + iObserver->OperationCompleted( iOperationId, err ); + + CleanupStack::PopAndDestroy( data ); + + // Get ready for another round: + SetActive(); + + // complete internal request: + User::RequestComplete( status, KErrNone ); + } + +// ----------------------------------------------------------------------------- +// DRM::CDrmAutomatedUsageImpl::RunError +// ----------------------------------------------------------------------------- +// +TInt DRM::CDrmAutomatedUsageImpl::RunError( + TInt aError ) + { + iObserver->OperationCompleted( iOperationId, aError ); + iObserver = NULL; + iOperationId = NULL; + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CDrmAutomatedUsageImpl::Activate +// ----------------------------------------------------------------------------- +// +void DRM::CDrmAutomatedUsageImpl::Activate( TRequestStatus*& aStatus ) + { + if ( !IsAdded() ) + { + CActiveScheduler::Add( this ); + } + + if ( !IsActive() ) + { + SetActive(); + + // complete internal request: + User::RequestComplete( aStatus, KErrNone ); + } + } + +// End of File