/*
* Copyright (c) 2006-2010 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 UI Handling implementation class
*
*/
// INCLUDE FILES
// connection
#include <cmconnectionmethod.h>
#include <cmdestination.h>
#include <cmconnectionmethoddef.h>
#include <cmmanager.h>
#include <sacls.h>
#include <utf.h>
// publish & subscribe
#include <e32property.h>
#include <PSVariables.h>
#include <centralrepository.h>
// coeenv
#include <coemain.h>
#include <apgtask.h>
#include <avkon.hrh>
#include <aknenv.h>
// browser
#ifdef __SERIES60_NATIVE_BROWSER
#include <browseruisdkcrkeys.h>
#endif
// caf
#include <caf/data.h>
#include <caf/caftypes.h>
// launching embedded details view
#include <AknLaunchAppService.h>
#include <AiwGenericParam.h>
#include <apgcli.h>
// DCF repository
#include <DcfRep.h>
#include <DcfEntry.h>
// character conversions
#include <utf.h>
// handling urls
#include <schemehandler.h>
// resources
#include <data_caging_path_literals.hrh>
#include <drmutility.rsg>
// drm
#include <Oma2Agent.h>
#include <drmagents.h>
#include <DrmPermission.h>
#include <DrmConstraint.h>
#include <DRMRightsClient.h>
#include <drmutility.h>
#include <drmutilitytypes.h>
#include <drmasyncobserver.h>
#include <drmhandleerrorobserver.h>
#ifdef _DEBUG
#include <e32debug.h>
#endif
#include "drmutilitycommon.h"
#include "drmutilityui.h"
#include "DrmUiHandlingImpl.h"
#include "drmuihandlingdata.h"
#include "DrmUtilityDownloadManager.h"
#include "drmutilityinternaltypes.h"
#include "drmuicheckrightsobserver.h"
#include "drmutilitywmdrm.h"
#include "drmutilitywmdrmwrapper.h"
#include "RoapStorageClient.h"
#include "DRMTypes.h"
#include "drmsettingsplugininternalcrkeys.h"
#include "DRMRIContext.h"
#include "DRMDomainContext.h"
#include "DrmUtilityInternalcrkeys.h" // Cenrep extension for OmaBased
// CONSTANTS
const TInt KCommandHandleErrorFile( 1 );
const TInt KCommandHandleErrorData( 2 );
const TInt KCommandCheckRightsAmountFile( 3 );
const TInt KCommandCheckRightsAmountData( 4 );
const TInt KCommandShowDetailsViewFile( 5 );
const TInt KCommandShowDetailsViewData( 6 );
const TInt KCommandHandleUrlFile( 7 );
const TInt KCommandHandleUrlData( 8 );
const TInt KCommandAvailableUrlsFile( 9 );
const TInt KCommandAvailableUrlsData( 10 );
// browser
#ifndef __SERIES60_NATIVE_BROWSER
const TUid KCRUidBrowser =
{0x10008D39};
const TUint32 KBrowserDefaultAccessPoint = 0x0000000E;
const TUint32 KBrowserAccessPointSelectionMode = 0x0000001E;
const TUint32 KBrowserNGDefaultSnapId = 0x00000053;
#endif
_LIT( KEncryptedRightsIssuerMatchString, "flk*" );
// buffer sizes
const TInt KDRMMaxETABufSize( 11 );
const TInt KUrlMaxLen( 1024 );
const TInt KIntegerMaxLen( 10 );
// constant sizes
const TInt KOmaDomainGenerationLength( 3 );
// masks for constraint existence
const TInt KDRMOmaConstraintCount( 1 );
const TInt KDRMOmaConstraintTime( 2 );
const TInt KDRMOmaConstraintAccumulated( 4 );
const TInt KCenRepDataLength( 50 );
const TInt KresOmaBasedBuf( 512 );
const TInt KNameBuf( 256 );
#ifdef _DEBUG
// debug panic
_LIT( KDRMUtilityDebugPanicMessage, "DrmUiHandlingDebugPanic" );
const TInt KDRMUtilityDebugPanicCode( 1 );
#endif
// ============================= LOCAL FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// MapToCallError
// -----------------------------------------------------------------------------
//
LOCAL_C inline TInt CheckAndMapToCallError(
RDRMRightsClient& aOmaClient,
ContentAccess::TIntent aIntent,
const TDesC8& aContentUri )
{
TUint32 rr( KErrNone );
TInt err( aOmaClient.CheckRights( aIntent, aContentUri, rr ) );
return err ? KErrCANoRights : KErrNone;
}
// -----------------------------------------------------------------------------
// IapIdOfDefaultSnapL
// for trapping purposes only
// -----------------------------------------------------------------------------
//
LOCAL_C TUint32 IapIdOfDefaultSnapL(
RCmManager& aCmManager,
const TUint32 aDefaultSnap )
{
RCmDestination dest( aCmManager.DestinationL( aDefaultSnap ) );
CleanupClosePushL( dest );
TUint32 iapIdOfDest( 0 );
if ( dest.ConnectionMethodCount() <= 0 )
{
User::Leave( KErrNotFound );
}
RCmConnectionMethod cMeth( dest.ConnectionMethodL( 0 ) );
CleanupClosePushL( cMeth );
iapIdOfDest = cMeth.GetIntAttributeL( CMManager::ECmIapId );
CleanupStack::PopAndDestroy( &cMeth );
CleanupStack::PopAndDestroy( &dest );
return iapIdOfDest;
}
// ---------------------------------------------------------
// UpdateDCFRepositoryL()
// Update saved file to DCFRepository
// ---------------------------------------------------------
LOCAL_C void UpdateDCFRepositoryL( TDesC& aFullFileName )
{
CDcfEntry* dcfEntry( NULL );
CDcfRep* dcfRep( NULL );
dcfEntry = CDcfEntry::NewL();
CleanupStack::PushL( dcfEntry );
dcfRep = CDcfRep::NewL();
CleanupStack::PushL( dcfRep );
dcfEntry->SetLocationL( aFullFileName, 0 );
dcfRep->UpdateL( dcfEntry );
CleanupStack::PopAndDestroy( dcfRep );
CleanupStack::PopAndDestroy( dcfEntry );
}
// ---------------------------------------------------------
// FindFullFileNameAndUpdateDCFRepositoryL()
// Find full file name for the content and update saved
// file to DCFRepository
// ---------------------------------------------------------
LOCAL_C void FindFullFileNameAndUpdateDCFRepositoryL(
const RFile& aFileHandle )
{
HBufC* fullPath( NULL );
TPtr fullPathPtr( NULL, 0 );
fullPath = HBufC::NewLC( KUrlMaxLen );
fullPathPtr.Set( fullPath->Des() );
aFileHandle.FullName( fullPathPtr );
UpdateDCFRepositoryL( fullPathPtr );
CleanupStack::PopAndDestroy( fullPath );
}
// ---------------------------------------------------------
// FindFullFileNameAndUpdateDCFRepositoryL()
// Find full file name for the content and update saved
// file to DCFRepository
// ---------------------------------------------------------
LOCAL_C void FindFullFileNameAndUpdateDCFRepositoryL(
const ContentAccess::CData& aFileData )
{
HBufC* fullPath( NULL );
TPtr fullPathPtr( NULL, 0 );
fullPath = HBufC::NewLC( KUrlMaxLen );
fullPathPtr.Set( fullPath->Des() );
aFileData.GetStringAttribute( DRM::EDrmFullName,
fullPathPtr );
UpdateDCFRepositoryL( fullPathPtr );
CleanupStack::PopAndDestroy( fullPath );
}
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CDrmUiHandlingImpl
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
DRM::CDrmUiHandlingImpl::CDrmUiHandlingImpl(
DRM::CDrmUtility* aDrmUtility,
CCoeEnv* aCoeEnv ) :
CActive( EPriorityStandard ), iCoeEnv( aCoeEnv ), iDrmUtility(
aDrmUtility )
{
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::ConstructL()
{
TInt err( KErrNone );
iDrmUtilityCommon = DRM::CDrmUtilityCommon::NewL();
iDrmUtilityUi = DRM::CDrmUtilityUI::NewL( iCoeEnv );
User::LeaveIfError( iOmaClient.Connect() );
User::LeaveIfError( iSemaphore.CreateLocal( 1 ) );
TRAP_IGNORE( iWrapperLoader = DRM::CDrmUtilityWMDrm::NewL( iCoeEnv ) );
if ( iWrapperLoader )
{
iWmClient = iWrapperLoader->GetWrapper();
}
TRAP(err, GetOmaBasedInfoL() );
if ( err )
{
if ( iOmaBasedAgentName )
{
delete iOmaBasedAgentName;
}
iOmaBasedAgentName = NULL;
iOmaBasedUid = 0;
if ( iOmaBasedMimeType )
{
delete iOmaBasedMimeType;
}
iOmaBasedMimeType = NULL;
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::GetOmaBasedInfoL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::GetOmaBasedInfoL()
{
TInt err = KErrNone;
CRepository* repository( NULL );
RBuf bOmaBasedAgentName;
RBuf bOmaBasedMimeType;
CleanupClosePushL( bOmaBasedAgentName );
CleanupClosePushL( bOmaBasedMimeType );
bOmaBasedAgentName.CreateL( KCenRepDataLength );
bOmaBasedMimeType.CreateL( KCenRepDataLength );
TRAP( err, repository = CRepository::NewL( KCRUidOmaBased ) );
if ( !err )
{
CleanupStack::PushL( repository );
err = repository->Get( KDrmOmaBasedName, bOmaBasedAgentName );
if ( !err )
{
iOmaBasedAgentName = bOmaBasedAgentName.AllocL();
}
err = repository->Get( KDrmOmaBasedUID, iOmaBasedUid );
err = repository->Get( KOmaBasedMimeType, bOmaBasedMimeType );
if ( !err )
{
iOmaBasedMimeType = CnvUtfConverter::ConvertFromUnicodeToUtf8L(
bOmaBasedMimeType );
}
CleanupStack::PopAndDestroy( repository );
}
CleanupStack::PopAndDestroy( 2, &bOmaBasedAgentName );
User::LeaveIfError( err );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C DRM::CDrmUiHandlingImpl* DRM::CDrmUiHandlingImpl::NewL(
DRM::CDrmUtility* aDrmUtility,
CCoeEnv* aCoeEnv )
{
DRM::CDrmUiHandlingImpl* self( NewLC( aDrmUtility, aCoeEnv ) );
CleanupStack::Pop( self );
return self;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C DRM::CDrmUiHandlingImpl* DRM::CDrmUiHandlingImpl::NewLC(
DRM::CDrmUtility* aDrmUtility,
CCoeEnv* aCoeEnv )
{
DRM::CDrmUiHandlingImpl* self( new ( ELeave ) CDrmUiHandlingImpl(
aDrmUtility, aCoeEnv ) );
CleanupStack::PushL( self );
self->ConstructL();
return self;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::~CDrmUiHandlingImpl()
// Destructor
// -----------------------------------------------------------------------------
//
DRM::CDrmUiHandlingImpl::~CDrmUiHandlingImpl()
{
DRM::CDrmUiHandlingData* data( PopFront() );
// reset the current observer
// it may already be deleted so don't do any calls to it.
iObserver = NULL;
// Empty the queue:
while ( data )
{
// Complete the outstanding requestest with cancel
data->iObserver->OperationCompleted( data->iOperationId, KErrCancel );
delete data;
data = PopFront();
}
delete iDrmUtilityCommon;
delete iDrmUtilityUi;
delete iSchemeHandler;
delete iWrapperLoader;
delete iOmaBasedAgentName;
delete iOmaBasedMimeType;
iOmaClient.Close();
// Close the semaphone
iSemaphore.Close();
// Remove the object from active scheduler etc.
if ( IsAdded() )
{
Deque();
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CheckRightsAmountAsyncL
// Check how much rights there are left for the content.
// -----------------------------------------------------------------------------
//
EXPORT_C TInt DRM::CDrmUiHandlingImpl::CheckRightsAmountAsyncL(
RFile& aFile,
ContentAccess::TIntent aIntent,
DRM::MDrmUiCheckRightsObserver& aObserver )
{
TRequestStatus* status( &iStatus );
// Create data object:
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iObserver = &aObserver;
data->iOperationId = reinterpret_cast<TInt> ( data );
data->iOperation = KCommandCheckRightsAmountFile;
data->iFile = &aFile;
data->iIntent = aIntent;
data->iCheckRightsObserver = &aObserver;
// Add it to the queue:
AppendToQueue( data );
// Pop it from the cleanup stack
CleanupStack::Pop( data );
Activate( status );
return data->iOperationId;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CheckRightsAmountL
// Check how much rights there are left for the content.
// -----------------------------------------------------------------------------
//
EXPORT_C void DRM::CDrmUiHandlingImpl::CheckRightsAmountL(
RFile& aFile,
ContentAccess::TIntent aIntent,
DRM::MDrmUiCheckRightsObserver* aObserver )
{
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iOperationId = 0; // operation id zero for a syncronous operation
data->iFile = &aFile;
data->iIntent = aIntent;
data->iCheckRightsObserver = aObserver;
PerformCheckRightsAmountFileL( *data );
CleanupStack::PopAndDestroy( data );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CheckRightsAmountAsyncL
// Check how much rights there are left for the content.
// -----------------------------------------------------------------------------
//
EXPORT_C TInt DRM::CDrmUiHandlingImpl::CheckRightsAmountAsyncL(
ContentAccess::CData& aFile,
ContentAccess::TIntent aIntent,
DRM::MDrmUiCheckRightsObserver& aObserver )
{
TRequestStatus* status( &iStatus );
// create data object:
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iObserver = &aObserver;
data->iOperationId = reinterpret_cast<TInt> ( data );
data->iOperation = KCommandCheckRightsAmountData;
data->iFileData = &aFile;
data->iIntent = aIntent;
data->iCheckRightsObserver = &aObserver;
// Add it to the queue:
AppendToQueue( data );
// Pop it from the cleanup stack
CleanupStack::Pop( data );
Activate( status );
return data->iOperationId;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CheckRightsAmountL
// Check how much rights there are left for the content.
// -----------------------------------------------------------------------------
//
EXPORT_C void DRM::CDrmUiHandlingImpl::CheckRightsAmountL(
ContentAccess::CData& aFile,
ContentAccess::TIntent aIntent,
DRM::MDrmUiCheckRightsObserver* aObserver )
{
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iOperationId = 0; // operation id zero for a syncronous operation
data->iFileData = &aFile;
data->iIntent = aIntent;
data->iCheckRightsObserver = aObserver;
PerformCheckRightsAmountDataL( *data );
CleanupStack::PopAndDestroy( data );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::ShowDetailsViewAsyncL
// Shows DRM specific details
// -----------------------------------------------------------------------------
//
EXPORT_C TInt DRM::CDrmUiHandlingImpl::ShowDetailsViewAsyncL(
RFile& aFile,
DRM::MDrmAsyncObserver& aObserver )
{
TRequestStatus* status( &iStatus );
// create data object:
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iObserver = &aObserver;
data->iOperationId = reinterpret_cast<TInt> ( data );
data->iOperation = KCommandShowDetailsViewFile;
data->iFile = &aFile;
// Add it to the queue:
AppendToQueue( data );
// Pop it from the cleanup stack
CleanupStack::Pop( data );
Activate( status );
return data->iOperationId;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::ShowDetailsViewL
// Shows DRM specific details
// -----------------------------------------------------------------------------
//
EXPORT_C void DRM::CDrmUiHandlingImpl::ShowDetailsViewL( RFile& aFile )
{
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iOperationId = 0; // operation id zero for a syncronous operation
data->iFile = &aFile;
PerformShowDetailsViewFileL( *data );
CleanupStack::PopAndDestroy( data );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::ShowDetailsViewAsyncL
// Shows DRM specific details
// -----------------------------------------------------------------------------
//
EXPORT_C TInt DRM::CDrmUiHandlingImpl::ShowDetailsViewAsyncL(
ContentAccess::CData& aFile,
DRM::MDrmAsyncObserver& aObserver )
{
TRequestStatus* status( &iStatus );
// create data object:
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iObserver = &aObserver;
data->iOperationId = reinterpret_cast<TInt> ( data );
data->iOperation = KCommandShowDetailsViewData;
data->iFileData = &aFile;
// Add it to the queue:
AppendToQueue( data );
// Pop it from the cleanup stack
CleanupStack::Pop( data );
Activate( status );
return data->iOperationId;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::ShowDetailsViewL
// Shows DRM specific details.
// -----------------------------------------------------------------------------
//
EXPORT_C void DRM::CDrmUiHandlingImpl::ShowDetailsViewL(
ContentAccess::CData& aFile )
{
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iOperationId = 0; // operation id zero for a syncronous operation
data->iFileData = &aFile;
PerformShowDetailsViewDataL( *data );
CleanupStack::PopAndDestroy( data );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::HandleUrlAsyncL
// Handles a specific url defined by the file, such as InfoUrl
// -----------------------------------------------------------------------------
//
EXPORT_C TInt DRM::CDrmUiHandlingImpl::HandleUrlAsyncL(
RFile& aFile,
DRM::TDrmUiUrlType aType,
DRM::MDrmAsyncObserver& aObserver )
{
TRequestStatus* status( &iStatus );
// create data object:
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iObserver = &aObserver;
data->iOperationId = reinterpret_cast<TInt> ( data );
data->iOperation = KCommandHandleUrlFile;
data->iFile = &aFile;
data->iTypeParam = aType;
// Add it to the queue:
AppendToQueue( data );
// Pop it from the cleanup stack
CleanupStack::Pop( data );
Activate( status );
return data->iOperationId;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::HandleUrlL
// Handles a specific url defined by the file, such as InfoUrl
// -----------------------------------------------------------------------------
//
EXPORT_C void DRM::CDrmUiHandlingImpl::HandleUrlL(
RFile& aFile,
DRM::TDrmUiUrlType aType )
{
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iOperationId = 0; // operation id zero for a syncronous operation
data->iFile = &aFile;
data->iTypeParam = aType;
PerformHandleUrlFileL( *data );
CleanupStack::PopAndDestroy( data );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::HandleUrlAsyncL
// Handles the specific url defined by the file, such as InfoUrl
// -----------------------------------------------------------------------------
//
EXPORT_C TInt DRM::CDrmUiHandlingImpl::HandleUrlAsyncL(
ContentAccess::CData& aFile,
DRM::TDrmUiUrlType aType,
DRM::MDrmAsyncObserver& aObserver )
{
TRequestStatus* status( &iStatus );
// create data object:
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iObserver = &aObserver;
data->iOperationId = reinterpret_cast<TInt> ( data );
data->iOperation = KCommandHandleUrlData;
data->iFileData = &aFile;
data->iTypeParam = aType;
// Add it to the queue:
AppendToQueue( data );
// Pop it from the cleanup stack
CleanupStack::Pop( data );
Activate( status );
return data->iOperationId;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::HandleUrlL
// Handles the specific url defined by the file, such as InfoUrl
// -----------------------------------------------------------------------------
//
EXPORT_C void DRM::CDrmUiHandlingImpl::HandleUrlL(
ContentAccess::CData& aFile,
DRM::TDrmUiUrlType aType )
{
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iOperationId = 0; // operation id zero for a syncronous operation
data->iFileData = &aFile;
data->iTypeParam = aType;
PerformHandleUrlDataL( *data );
CleanupStack::PopAndDestroy( data );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::AvailableUrlsAsyncL
// Gets information of the available urls
// -----------------------------------------------------------------------------
//
EXPORT_C TInt DRM::CDrmUiHandlingImpl::AvailableUrlsAsyncL(
RFile& aFile,
DRM::TDrmUiUrlType& aType,
DRM::MDrmAsyncObserver& aObserver )
{
TRequestStatus* status( &iStatus );
// create data object:
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iObserver = &aObserver;
data->iOperationId = reinterpret_cast<TInt> ( data );
data->iOperation = KCommandAvailableUrlsFile;
data->iFile = &aFile;
data->iType = &aType;
// Add it to the queue:
AppendToQueue( data );
// Pop it from the cleanup stack
CleanupStack::Pop( data );
Activate( status );
return data->iOperationId;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::AvailableUrlsL
// Gets information of the available urls
// -----------------------------------------------------------------------------
//
EXPORT_C void DRM::CDrmUiHandlingImpl::AvailableUrlsL(
RFile& aFile,
DRM::TDrmUiUrlType& aType )
{
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iOperationId = 0; // operation id zero for a syncronous operation
data->iFile = &aFile;
data->iType = &aType;
PerformAvailableUrlsFileL( *data );
CleanupStack::PopAndDestroy( data );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::AvailableUrlsAsyncL
// Gets information of the available urls
// -----------------------------------------------------------------------------
//
EXPORT_C TInt DRM::CDrmUiHandlingImpl::AvailableUrlsAsyncL(
ContentAccess::CData& aFile,
DRM::TDrmUiUrlType& aType,
DRM::MDrmAsyncObserver& aObserver )
{
TRequestStatus* status( &iStatus );
// create data object:
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iObserver = &aObserver;
data->iOperationId = reinterpret_cast<TInt> ( data );
data->iOperation = KCommandAvailableUrlsData;
data->iFileData = &aFile;
data->iType = &aType;
// Add it to the queue:
AppendToQueue( data );
// Pop it from the cleanup stack
CleanupStack::Pop( data );
Activate( status );
return data->iOperationId;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::AvailableUrlsL
// Gets information of the available urls
// -----------------------------------------------------------------------------
//
EXPORT_C void DRM::CDrmUiHandlingImpl::AvailableUrlsL(
ContentAccess::CData& aFile,
DRM::TDrmUiUrlType& aType )
{
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iOperationId = 0; // operation id zero for a syncronous operation
data->iFileData = &aFile;
data->iType = &aType;
PerformAvailableUrlsDataL( *data );
CleanupStack::PopAndDestroy( data );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::HandleErrorAsyncL
// Handles DRM specific error
// -----------------------------------------------------------------------------
//
EXPORT_C TInt DRM::CDrmUiHandlingImpl::HandleErrorAsyncL(
RFile& aFile,
ContentAccess::TIntent aIntent,
TInt aError,
DRM::MDrmHandleErrorObserver& aObserver )
{
TRequestStatus* status( &iStatus );
// create data object:
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iObserver = &aObserver;
data->iOperationId = reinterpret_cast<TInt> ( data );
data->iOperation = KCommandHandleErrorFile;
data->iFile = &aFile;
data->iIntent = aIntent;
data->iError = aError;
data->iErrorObserver = &aObserver;
// Add it to the queue:
AppendToQueue( data );
// Pop it from the cleanup stack
CleanupStack::Pop( data );
Activate( status );
return data->iOperationId;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::HandleError
// Handles DRM specific error
// -----------------------------------------------------------------------------
//
EXPORT_C void DRM::CDrmUiHandlingImpl::HandleErrorL(
RFile& aFile,
ContentAccess::TIntent aIntent,
TInt aError,
DRM::MDrmHandleErrorObserver* aObserver )
{
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iOperationId = 0; // operation id zero for a syncronous operation
data->iFile = &aFile;
data->iIntent = aIntent;
data->iError = aError;
data->iErrorObserver = aObserver;
PerformHandleErrorFileL( *data );
CleanupStack::PopAndDestroy( data );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::HandleErrorAsyncL
// Handles DRM specific error
// -----------------------------------------------------------------------------
//
EXPORT_C TInt DRM::CDrmUiHandlingImpl::HandleErrorAsyncL(
ContentAccess::CData& aFile,
ContentAccess::TIntent aIntent,
TInt aError,
DRM::MDrmHandleErrorObserver& aObserver )
{
TRequestStatus* status( &iStatus );
// create data object:
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iObserver = &aObserver;
data->iOperationId = reinterpret_cast<TInt> ( data );
data->iOperation = KCommandHandleErrorData;
data->iFileData = &aFile;
data->iIntent = aIntent;
data->iError = aError;
data->iErrorObserver = &aObserver;
// Add it to the queue:
AppendToQueue( data );
// Pop it from the cleanup stack
CleanupStack::Pop( data );
Activate( status );
return data->iOperationId;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::HandleError
// Handles DRM specific error
// -----------------------------------------------------------------------------
//
EXPORT_C void DRM::CDrmUiHandlingImpl::HandleErrorL(
ContentAccess::CData& aFile,
ContentAccess::TIntent aIntent,
TInt aError,
DRM::MDrmHandleErrorObserver* aObserver )
{
DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );
data->iOperationId = 0; // operation id zero for a syncronous operation
data->iFileData = &aFile;
data->iIntent = aIntent;
data->iError = aError;
data->iErrorObserver = aObserver;
PerformHandleErrorDataL( *data );
CleanupStack::PopAndDestroy( data );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CancelOperation
// Cancels the operation
// -----------------------------------------------------------------------------
//
EXPORT_C TInt DRM::CDrmUiHandlingImpl::CancelOperation( TInt aOperationId )
{
// Critical area start:
iSemaphore.Wait();
TBool found( EFalse );
DRM::CDrmUiHandlingData* previousData( NULL );
DRM::CDrmUiHandlingData* currentData( iFirst );
while ( currentData )
{
if ( currentData->iOperationId == aOperationId )
{
found = ETrue;
//Update the previous link
if ( previousData )
{
previousData->iNext = currentData->iNext;
}
else
{
iFirst = currentData->iNext;
}
//If the current is the only one, set iLast NULL
if ( !iFirst )
{
iLast = NULL;
}
//If only one left,set it also to be the iLast
else if ( iFirst && !currentData->iNext )
{
iLast = iFirst;
}
//Delete the cancelled operation
currentData->iObserver->OperationCompleted(
currentData->iOperationId, KErrCancel );
delete currentData;
currentData = NULL;
}
else
{
previousData = currentData;
currentData = currentData->iNext;
}
}
if ( !found )
{
// Critical Area End
iSemaphore.Signal();
return KErrNotFound;
}
// Critical Area End
iSemaphore.Signal();
return KErrNone;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::DoCancel()
// From CActive Cancels async request.
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::DoCancel()
{
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::RunL()
// From CActive Called when async request completes.
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::RunL()
{
DRM::CDrmUiHandlingData* data( 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;
switch ( data->iOperation )
{
case KCommandHandleErrorFile:
// Perform the operation
PerformHandleErrorFileL( *data );
break;
case KCommandHandleErrorData:
// Perform the operation
PerformHandleErrorDataL( *data );
break;
case KCommandCheckRightsAmountFile:
// Perform the operation
PerformCheckRightsAmountFileL( *data );
break;
case KCommandCheckRightsAmountData:
// Perform the operation
PerformCheckRightsAmountDataL( *data );
break;
case KCommandShowDetailsViewFile:
// Perform the operation
PerformShowDetailsViewFileL( *data );
break;
case KCommandShowDetailsViewData:
// Perform the operation
PerformShowDetailsViewDataL( *data );
break;
case KCommandHandleUrlFile:
// Perform the operation
PerformHandleUrlFileL( *data );
break;
case KCommandHandleUrlData:
// Perform the operation
PerformHandleUrlDataL( *data );
break;
case KCommandAvailableUrlsFile:
// Perform the operation
PerformAvailableUrlsFileL( *data );
break;
case KCommandAvailableUrlsData:
// Perform the operation
PerformAvailableUrlsDataL( *data );
break;
default:
break;
}
// if the observer exists and it has not been deleted, call complete
// for the operation and get ready for another round
// this should prevent crashes in case the class is deleted before
// and operation finihes.
if( iObserver && reinterpret_cast<TInt>(iObserver) != 0xDEDEDEDE )
{
// Complete the client request
iObserver->OperationCompleted( iOperationId, KErrNone );
// Get ready for another round:
SetActive();
// complete internal request:
User::RequestComplete( status, KErrNone );
}
// destroy the object:
CleanupStack::PopAndDestroy( data );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::RunError()
// -----------------------------------------------------------------------------
//
TInt DRM::CDrmUiHandlingImpl::RunError( TInt aError )
{
iObserver->OperationCompleted( iOperationId, aError );
iObserver = NULL;
iOperationId = NULL;
return KErrNone;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::Activate
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::Activate( TRequestStatus*& aStatus )
{
if ( !IsAdded() )
{
CActiveScheduler::Add( this );
}
if ( !IsActive() )
{
SetActive();
// complete internal request:
User::RequestComplete( aStatus, KErrNone );
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::PerformCheckRightsAmountFileL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::PerformCheckRightsAmountFileL(
DRM::CDrmUiHandlingData& aData )
{
TPtrC agent( KNullDesC );
IsProtectedL( *aData.iFile, agent );
ContentAccess::CData* content = ContentAccess::CData::NewLC(
*aData.iFile, ContentAccess::KDefaultContentObject,
ContentAccess::EPeek );
if ( !agent.Compare( DRM::KDrmOmaAgentName ) )
{
CheckOmaRightsAmountL( *content, aData.iIntent,
aData.iCheckRightsObserver, aData.iOperationId );
}
else if ( iOmaBasedAgentName && ( !agent.Compare( *iOmaBasedAgentName ) ) )
{
CheckOmaBasedRightsAmountL( *content, aData.iIntent,
aData.iCheckRightsObserver, aData.iOperationId );
}
else if ( !agent.Compare( DRM::KDrmWMAgentName ) && iWmClient )
{
iWmClient->CheckWmRightsAmountL( *content, aData.iIntent,
aData.iCheckRightsObserver, aData.iOperationId );
}
CleanupStack::PopAndDestroy( content );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::PerformCheckRightsAmountDataL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::PerformCheckRightsAmountDataL(
DRM::CDrmUiHandlingData& aData )
{
DRM::TDrmAgentUid agentUid( DRM::EDrmOmaAgent );
IsProtectedL( aData.iFileData, agentUid );
switch ( agentUid )
{
case DRM::EDrmOmaAgent:
CheckOmaRightsAmountL( *aData.iFileData, aData.iIntent,
aData.iCheckRightsObserver, aData.iOperationId );
break;
case DRM::EDrmWmAgent:
if ( iWmClient )
{
iWmClient->CheckWmRightsAmountL( *aData.iFileData,
aData.iIntent, aData.iCheckRightsObserver,
aData.iOperationId );
}
break;
default:
break;
}
if ( agentUid == iOmaBasedUid )
{
CheckOmaBasedRightsAmountL( *aData.iFileData, aData.iIntent,
aData.iCheckRightsObserver, aData.iOperationId );
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::PerformShowDetailsViewFileL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::PerformShowDetailsViewFileL(
DRM::CDrmUiHandlingData& aData )
{
HBufC* fullPath( NULL );
TPtr pathPtr( NULL, 0 );
TPtrC agent( KNullDesC );
IsProtectedL( *aData.iFile, agent );
ContentAccess::CData* content = ContentAccess::CData::NewLC(
*aData.iFile, ContentAccess::KDefaultContentObject,
ContentAccess::EPeek );
HBufC8* contentId( NULL );
fullPath = HBufC::NewLC( KUrlMaxLen );
pathPtr.Set( fullPath->Des() );
User::LeaveIfError( aData.iFile->FullName( pathPtr ) );
if ( !agent.Compare( DRM::KDrmOmaAgentName ) )
{
GetContentIdLC( *content, contentId );
ShowDetailsViewL( contentId, fullPath );
CleanupStack::PopAndDestroy( contentId );
}
else if ( !agent.Compare( DRM::KDrmWMAgentName ) && iWmClient )
{
// Show details view for WMDRM file needs full path name
ShowDetailsViewL( fullPath );
}
CleanupStack::PopAndDestroy( fullPath );
CleanupStack::PopAndDestroy( content ); // content
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::PerformShowDetailsViewDataL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::PerformShowDetailsViewDataL(
DRM::CDrmUiHandlingData& aData )
{
DRM::TDrmAgentUid agentUid( DRM::EDrmOmaAgent );
IsProtectedL( aData.iFileData, agentUid );
HBufC* fullPath( NULL );
HBufC8* contentId( NULL );
// For OMA and WM DRM, the full path is needed, not just the Content Id
GetContentLocationLC( *aData.iFileData, fullPath );
switch ( agentUid )
{
case DRM::EDrmOmaAgent:
GetContentIdLC( *aData.iFileData, contentId );
ShowDetailsViewL( contentId, fullPath );
CleanupStack::PopAndDestroy( contentId );
break;
case DRM::EDrmWmAgent:
if ( iWmClient )
{
// For WM DRM, the full path is needed, not just the Content Id
ShowDetailsViewL( fullPath );
}
break;
default:
break;
}
if ( agentUid == iOmaBasedUid )
{
User::Leave( KErrNotSupported );
}
CleanupStack::PopAndDestroy( fullPath );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::PerformHandleUrlFileL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::PerformHandleUrlFileL(
DRM::CDrmUiHandlingData& aData )
{
TPtrC agent( KNullDesC );
IsProtectedL( *aData.iFile, agent );
ContentAccess::CData* content = ContentAccess::CData::NewLC(
*aData.iFile, ContentAccess::KDefaultContentObject,
ContentAccess::EPeek );
if ( !agent.Compare( DRM::KDrmOmaAgentName ) )
{
DoHandleOmaUrlL( *content, aData.iTypeParam );
}
else if ( !agent.Compare( DRM::KDrmWMAgentName ) && iWmClient )
{
//*** WMDRM does not support URL:s like that thus leaving with not supported
User::Leave( KErrNotSupported );
}
CleanupStack::PopAndDestroy( content );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::PerformHandleUrlDataL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::PerformHandleUrlDataL(
DRM::CDrmUiHandlingData& aData )
{
DRM::TDrmAgentUid agentUid( DRM::EDrmOmaAgent );
IsProtectedL( aData.iFileData, agentUid );
// *** WMDRM
switch ( agentUid )
{
case DRM::EDrmOmaAgent:
DoHandleOmaUrlL( *aData.iFileData, aData.iTypeParam );
break;
case DRM::EDrmWmAgent:
if ( iWmClient )
{
User::Leave( KErrNotSupported );
}
break;
default:
break;
}
if ( agentUid == iOmaBasedUid )
{
User::Leave( KErrNotSupported );
}
// *** WMDRM
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::PerformAvailableUrlsFileL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::PerformAvailableUrlsFileL(
DRM::CDrmUiHandlingData& aData )
{
TPtrC agent( KNullDesC );
IsProtectedL( *aData.iFile, agent );
ContentAccess::CData* content = ContentAccess::CData::NewLC(
*aData.iFile, ContentAccess::KDefaultContentObject,
ContentAccess::EPeek );
if ( !agent.Compare( DRM::KDrmOmaAgentName ) )
{
GetAvailableOmaUrlsL( *content, *aData.iType );
}
else if ( !agent.Compare( DRM::KDrmWMAgentName ) && iWmClient )
{
//*** WMDRM does not support URL:s like that thus leaving with not supported
User::Leave( KErrNotSupported );
}
CleanupStack::PopAndDestroy( content );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::PerformAvailableUrlsDataL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::PerformAvailableUrlsDataL(
DRM::CDrmUiHandlingData& aData )
{
DRM::TDrmAgentUid agentUid( DRM::EDrmOmaAgent );
IsProtectedL( aData.iFileData, agentUid );
// *** WMDRM
switch ( agentUid )
{
case DRM::EDrmOmaAgent:
GetAvailableOmaUrlsL( *aData.iFileData, *aData.iType );
break;
case DRM::EDrmWmAgent:
if ( iWmClient )
{
User::Leave( KErrNotSupported );
}
break;
default:
break;
}
if ( agentUid == iOmaBasedUid )
{
User::Leave( KErrNotSupported );
}
// *** WMDRM
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::PerformHandleErrorFileL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::PerformHandleErrorFileL(
DRM::CDrmUiHandlingData& aData )
{
TPtrC agent( KNullDesC );
IsProtectedL( *aData.iFile, agent );
IsProperErrorL( aData.iError );
ContentAccess::CData* content = ContentAccess::CData::NewLC(
*aData.iFile, ContentAccess::KDefaultContentObject,
ContentAccess::EPeek );
if ( ( !agent.Compare( DRM::KDrmOmaAgentName ) ) || ( iOmaBasedAgentName
&& !agent.Compare( *iOmaBasedAgentName ) ) )
{
// To embed Domain RO in superdistribution case, register the content
TRAP_IGNORE( FindFullFileNameAndUpdateDCFRepositoryL( *aData.iFile ) );
HandleOmaErrorL( *content, aData.iIntent, aData.iError,
aData.iErrorObserver, aData.iOperationId );
}
else if ( !agent.Compare( DRM::KDrmWMAgentName ) && iWmClient )
{
// *** WMDRM
iWmClient->HandleWmErrorL( *content, aData.iIntent, aData.iError,
aData.iErrorObserver, aData.iOperationId );
}
CleanupStack::PopAndDestroy( content );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::PerformHandleErrorDataL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::PerformHandleErrorDataL(
DRM::CDrmUiHandlingData& aData )
{
DRM::TDrmAgentUid agentUid( DRM::EDrmOmaAgent );
IsProtectedL( aData.iFileData, agentUid );
IsProperErrorL( aData.iError );
// *** WMDRM
switch ( agentUid )
{
case DRM::EDrmOmaAgent:
// To embed Domain RO in superdistribution case, register the content
TRAP_IGNORE( FindFullFileNameAndUpdateDCFRepositoryL(
*aData.iFileData ) );
HandleOmaErrorL( *aData.iFileData, aData.iIntent, aData.iError,
aData.iErrorObserver, aData.iOperationId );
break;
case DRM::EDrmWmAgent:
if ( iWmClient )
{
iWmClient->HandleWmErrorL( *aData.iFileData, aData.iIntent,
aData.iError, aData.iErrorObserver, aData.iOperationId );
}
break;
default:
break;
}
if ( agentUid == iOmaBasedUid )
{
HandleOmaErrorL( *aData.iFileData, aData.iIntent, aData.iError,
aData.iErrorObserver, aData.iOperationId );
}
// *** WMDRM
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::IsProtectedL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::IsProtectedL( RFile& aFile, TPtrC& aAgent )
{
DRM::TDrmProtectionStatus drmProtected( DRM::EUUnknown );
TInt ret( 0 );
ret = iDrmUtility->GetDrmInfoL( aFile, aAgent, drmProtected );
if ( !ret || !drmProtected ) // do nothing if non-DRM file
{
User::Leave( KErrArgument );
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::IsProtectedL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::IsProtectedL(
ContentAccess::CData* aContent,
DRM::TDrmAgentUid& aAgentUid )
{
TInt drmProtected( 0 );
User::LeaveIfError( aContent->GetAttribute( EIsProtected, drmProtected ) );
if ( !drmProtected ) // do nothing if non-DRM file
{
User::Leave( KErrArgument );
}
TInt temp( 0 );
HBufC* nameString = HBufC::NewLC( KNameBuf );
TPtr namePtr( nameString->Des() );
User::LeaveIfError( aContent->GetStringAttribute( DRM::EDrmAgentName,
namePtr ) );
if ( iOmaBasedAgentName && ( !namePtr.CompareF( *iOmaBasedAgentName ) ) )
{
aAgentUid = static_cast<DRM::TDrmAgentUid> ( iOmaBasedUid );
}
else
{
User::LeaveIfError( aContent->GetAttribute( DRM::EDrmAgentUid, temp ) );
aAgentUid = static_cast<DRM::TDrmAgentUid> ( temp );
}
CleanupStack::PopAndDestroy( nameString );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::IsProperErrorL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::IsProperErrorL( TInt aError )
{
if ( aError != ENoPermission && aError != ENoRights && aError
!= EPendingRights )
{
User::Leave( aError );
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CheckOmaRightsAmountL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::CheckOmaRightsAmountL(
ContentAccess::CData& aContent,
ContentAccess::TIntent aIntent,
DRM::MDrmUiCheckRightsObserver* aObserver,
TInt aOperationId )
{
HBufC8* contentId( NULL );
HBufC8* silentUrl( NULL );
HBufC* riUrl( NULL );
HBufC* domainRiUrl( NULL );
DRM::TDrmUiUrlType urlType( DRM::EUHRightsIssuerUrl );
// To embed Domain RO in superdistribution case, register the content
TRAP_IGNORE( FindFullFileNameAndUpdateDCFRepositoryL( aContent ) );
User::LeaveIfError( GetContentIdLC( aContent, contentId ) );
GetOmaSilentRightsUrlLC( aContent, silentUrl );
GetOmaRightsIssuerLC( aContent, riUrl );
GetOmaDomainRightsIssuerLC( aContent, domainRiUrl );
SelectOmaRightsUrlL( aContent, domainRiUrl, urlType );
DoCheckOmaRightsAmountL( aContent, contentId, aIntent, urlType
== DRM::EUHRightsIssuerUrl ? riUrl : domainRiUrl, urlType, silentUrl,
aObserver, aOperationId );
CleanupStack::PopAndDestroy( domainRiUrl );
CleanupStack::PopAndDestroy( riUrl );
CleanupStack::PopAndDestroy( silentUrl );
CleanupStack::PopAndDestroy( contentId );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::DoCheckOmaRightsAmountL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::DoCheckOmaRightsAmountL(
ContentAccess::CData& aContent,
HBufC8*& aContentUri,
ContentAccess::TIntent aIntent,
const HBufC* aRightsUrl,
DRM::TDrmUiUrlType aUrlType,
const HBufC8* aSilentUrl,
DRM::MDrmUiCheckRightsObserver* aObserver,
TInt aOperationId )
{
TInt omaError( KErrNone );
CDRMPermission* permission( NULL );
CDRMConstraint* constraint( NULL );
CDRMConstraint* toplevel( NULL );
DRM::TDrmRightsInfo status( DRM::EURightsInfoMissing );
DRM::TCheckRightsStatus rightsStatus( DRM::EUHCheckRightsNoRights );
TTime now( Time::NullTTime() ); // current time
TTime endTime( Time::NullTTime() ); // end time of time-based rights
TInt mask( 0 ); // tells if object has count or time based rights
TUint32 reason( 0 );
TBool unlimited( EFalse );
TUint32 countsLeft( 0 ); // number of counts left
TTimeIntervalSeconds secondsLeft( 0 ); // seconds to end of time based rights
TTimeIntervalSeconds accumulatedSecondsLeft( 0 ); // seconds to end of
// accumulated time rights
// Check rights
omaError = iOmaClient.CheckRights( aIntent, *aContentUri, reason );
// valid rights
if ( !omaError )
{
permission = iOmaClient.GetActiveRightsL( aIntent, *aContentUri,
reason );
if( !permission )
{
User::Leave( KErrCANoPermission); //coverity check
}
CleanupStack::PushL( permission );
toplevel = permission->TopLevelConstraint();
constraint = permission->ConstraintForIntent( aIntent );
// if top level constraint exists, merge it to constraint for intent
if ( toplevel )
{
constraint->Merge( *toplevel );
}
// find out type of constraint
mask = GetOmaConstraintInfo( constraint, countsLeft, endTime );
// get the current time
now.HomeTime();
// calculate days left in case of time
// and accumulated time constraints
if ( mask & KDRMOmaConstraintTime )
{
endTime.SecondsFrom( now, secondsLeft );
}
if ( mask & KDRMOmaConstraintAccumulated )
{
endTime.SecondsFrom( now, accumulatedSecondsLeft );
}
// if no count or time based constraint, then unlimited
if ( !mask )
{
unlimited = ETrue;
}
CallRightsLeftL( aObserver, aOperationId, unlimited, secondsLeft,
countsLeft, accumulatedSecondsLeft, aContentUri, aRightsUrl,
aSilentUrl, aContent, aIntent );
CleanupStack::PopAndDestroy( permission );
}
// Not valid rights
else
{
constraint = CDRMConstraint::NewLC();
// No rights at all
if ( omaError == KErrCANoRights )
{
rightsStatus = DRM::EUHCheckRightsNoRights;
}
else
{
// rights expired or future for given content URI
status = iDrmUtilityCommon->GetOmaRightsStatusL( aContentUri,
aIntent, constraint );
if ( status == DRM::EURightsInfoFuture )
{
rightsStatus = DRM::EUHCheckRightsFutureRights;
}
else if ( status == DRM::EURightsInfoExpired )
{
rightsStatus = DRM::EUHCheckRightsExpiredRights;
}
}
CallRightsNotValidL( aObserver, aOperationId, rightsStatus, reason,
aContent, aContentUri, constraint, aRightsUrl, aUrlType,
aSilentUrl, aIntent );
CleanupStack::PopAndDestroy( constraint );
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::HandleOmaErrorL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::HandleOmaErrorL(
ContentAccess::CData& aContent,
ContentAccess::TIntent aIntent,
TInt aError,
DRM::MDrmHandleErrorObserver* aObserver,
TInt aOperationId )
{
TInt omaError( KErrNone );
HBufC8* contentId( NULL );
HBufC* riUrl( NULL );
HBufC* domainRiUrl( NULL );
HBufC* previewUrl( NULL );
HBufC8* silentUrl( NULL );
CDRMConstraint* constraint( NULL );
DRM::TDrmRightsInfo rightsStatus( DRM::EURightsInfoValid );
DRM::TDrmUiUrlType urlType( DRM::EUHRightsIssuerUrl );
TInt previewType( ContentAccess::ENoPreview );
TUint32 reason( 0 );
TBool handled( EFalse );
User::LeaveIfError( GetContentIdLC( aContent, contentId ) );
// Check that this really is an error situation
omaError = iOmaClient.CheckRights( aIntent, *contentId, reason );
// Show that only reason for error was rejected metering.
TBool onlyMeteringRejection( reason == DRM::EURejectionMetering );
if ( onlyMeteringRejection )
{
iDrmUtilityUi->DisplayQueryWithIdL( R_DRM_QUERY_METERING_DISABLED,
R_DRMUTILITY_WAITING_RIGHTS_CONFIRMATION_QUERY );
CleanupStack::PopAndDestroy( contentId );
return;
}
if ( omaError )
{
// Get rights status
constraint = CDRMConstraint::NewLC();
rightsStatus = iDrmUtilityCommon->GetOmaRightsStatusL( contentId,
aIntent, constraint );
// Try to get all needed urls
GetOmaPreviewInfoLC( aContent, previewUrl, previewType );
GetOmaSilentRightsUrlLC( aContent, silentUrl );
GetOmaRightsIssuerLC( aContent, riUrl );
GetOmaDomainRightsIssuerLC( aContent, domainRiUrl );
SelectOmaRightsUrlL( aContent, domainRiUrl, urlType );
// If content has EmbeddedPreviewUrl, PreviewRightsUrl or
// SilentRightsUrl, handle it
if ( previewType == ContentAccess::EInstantPreview )
{
handled = ETrue;
CallEmbeddedPreviewAvailableL( aObserver, aOperationId, aContent,
previewUrl, rightsStatus, reason, urlType
== DRM::EUHRightsIssuerUrl ? riUrl : domainRiUrl,
contentId, aIntent );
}
else if ( previewType == ContentAccess::EPreviewRights )
{
handled = ETrue;
CallPreviewRightsUrlAvailableL( aObserver, aOperationId,
aContent, previewUrl, rightsStatus, reason, urlType
== DRM::EUHRightsIssuerUrl ? riUrl : domainRiUrl,
contentId, aIntent );
}
else if ( silentUrl )
{
handled = ETrue;
CallSilentRightsUrlAvailableL( aObserver, aOperationId,
silentUrl, rightsStatus, reason, urlType
== DRM::EUHRightsIssuerUrl ? riUrl : domainRiUrl,
contentId, aIntent );
}
// Check if rights were retrieved in earlier url handling
if ( handled )
{
omaError = iOmaClient.CheckRights( aIntent, *contentId, reason );
}
if ( omaError )
{
// No rights available
// Perform this even if no rights issuer url found
CallRightsUrlAvailableL( aObserver, aOperationId, rightsStatus,
reason, constraint, aContent, contentId, urlType
== DRM::EUHRightsIssuerUrl ? riUrl : domainRiUrl,
urlType, aIntent, aError );
}
CleanupStack::PopAndDestroy( domainRiUrl );
CleanupStack::PopAndDestroy( riUrl );
CleanupStack::PopAndDestroy( silentUrl );
CleanupStack::PopAndDestroy( previewUrl );
CleanupStack::PopAndDestroy( constraint );
}
else
{
User::Leave( KErrArgument );
}
CleanupStack::PopAndDestroy( contentId );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::ShowOmaDetailsViewL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::ShowDetailsViewL(
const HBufC8* aContentId,
const HBufC* aFullPath )
{
__ASSERT_DEBUG( aContentId, User::Panic( KDRMUtilityDebugPanicMessage,
KDRMUtilityDebugPanicCode ) );
__ASSERT_DEBUG( aFullPath, User::Panic( KDRMUtilityDebugPanicMessage,
KDRMUtilityDebugPanicCode ) );
// For OMA DRM
HBufC* launchParam( NULL );
// create parameter string
CreateLaunchParamL( aContentId, launchParam, aFullPath );
CleanupStack::PushL( launchParam );
// show details
LaunchRightsManagerUiL( *launchParam );
CleanupStack::PopAndDestroy( launchParam );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CheckOmaBasedRightsAmountL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::CheckOmaBasedRightsAmountL(
ContentAccess::CData& aContent,
ContentAccess::TIntent aIntent,
DRM::MDrmUiCheckRightsObserver* aObserver,
TInt aOperationId )
{
HBufC8* contentId( NULL );
HBufC* riUrl( NULL );
DRM::TDrmUiUrlType urlType( DRM::EUHRightsIssuerUrl );
User::LeaveIfError( GetContentIdLC( aContent, contentId ) );
DoCheckOmaBasedRightsAmountL( aContent, contentId, aIntent, riUrl,
urlType, aObserver, aOperationId );
CleanupStack::PopAndDestroy( contentId );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::DoCheckOmaBasedRightsAmountL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::DoCheckOmaBasedRightsAmountL(
ContentAccess::CData& aContent,
const HBufC8* aContentUri,
ContentAccess::TIntent aIntent,
const HBufC* aRightsUrl,
DRM::TDrmUiUrlType aUrlType,
DRM::MDrmUiCheckRightsObserver* aObserver,
TInt aOperationId )
{
TInt canPlay( KErrNone );
CDRMConstraint* constraint( NULL );
DRM::TCheckRightsStatus rightsStatus( DRM::EUHCheckRightsNoRights );
TTime now( Time::NullTTime() ); // current time
TTime endTime( Time::NullTTime() ); // end time of time-based rights
TUint32 reason( EConstraintEndTime );
TBool unlimited( EFalse );
TUint32 countsLeft( 0 ); // number of counts left
TTimeIntervalSeconds secondsLeft( 0 ); // seconds to end of time based rights
TTimeIntervalSeconds accumulatedSecondsLeft( 0 ); // seconds to end of
// accumulated time rights
// Check rights
User::LeaveIfError( aContent.GetAttribute( ECanPlay, canPlay ) );
GetOmaBasedEndTimeL( aContent, endTime );
// valid rights
if ( canPlay ) // check the CAF parameters
{
// get the current time
now.HomeTimeSecure();
endTime.SecondsFrom( now, secondsLeft );
CallRightsLeftL( aObserver, aOperationId, unlimited, secondsLeft,
countsLeft, accumulatedSecondsLeft, aContentUri, aRightsUrl,
NULL, aContent, aIntent );
}
// Not valid rights
else
{
constraint = CDRMConstraint::NewLC();
rightsStatus = DRM::EUHCheckRightsExpiredRights;
constraint->iActiveConstraints |= EConstraintEndTime;
constraint->iEndTime = endTime;
CallRightsNotValidL( aObserver, aOperationId, rightsStatus, reason,
aContent, aContentUri, constraint, aRightsUrl, aUrlType, NULL,
aIntent );
CleanupStack::PopAndDestroy( constraint );
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::GetOmaBasedEndTimeL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::GetOmaBasedEndTimeL(
ContentAccess::CData& aData,
TTime& aEndTime )
{
TInt err = KErrNone;
RFs fileSession;
RFile file;
TBuf8<KIntegerMaxLen> lenTxt;
TInt readStart = 0;
TInt headerLen = 0;
TInt tempVal = 0;
__UHEAP_MARK;
User::LeaveIfError( fileSession.Connect() );
CleanupClosePushL( fileSession );
CleanupClosePushL( file );
HBufC* filename = HBufC::NewLC( KNameBuf );
TPtr resOmaBased( const_cast<TUint16*> ( filename->Ptr() ), 0,
KresOmaBasedBuf );
err = aData.GetStringAttribute( DRM::EDrmFullName, resOmaBased );
if ( file.Open( fileSession, resOmaBased, EFileShareReadersOrWriters
| EFileRead ) == KErrNone )
{
/* Read content type and uri lengths */
err = file.Read( 1, lenTxt, 2 );
if ( err == KErrNone && lenTxt.Length() == 2 )
{
readStart = lenTxt[0] + lenTxt[1];
}
if ( readStart > 0 )
{
/* Add the length of version and length informations */
const TInt KReadSkip( 3 );
readStart += KReadSkip;
/* Read header length information (exact length not known
since it is Uintvar, so read plentily) */
err = file.Read( readStart, lenTxt, lenTxt.MaxLength() );
if ( err == KErrNone && lenTxt.Length() > 0 )
{
TBool cont = ETrue;
/* Start reading the header length */
TInt i = 0;
while ( i < lenTxt.Length() && cont )
{
tempVal = lenTxt[i];
i++;
if ( !( tempVal & 0x80 ) )
{ /* Highest bit not set, it's the last value */
cont = EFalse;
}
else
{ /* Clear the highest bit */
tempVal &= ~( 0x80 );
}
headerLen = ( ( headerLen << 0x07 ) | tempVal );
}
if ( cont != EFalse )
{ /* Reading the length failed */
headerLen = 0;
}
else
{
/* Continue to read past the content length */
cont = ETrue;
while ( i < lenTxt.Length() && cont )
{
tempVal = lenTxt[i];
i++;
if ( !( tempVal & 0x80 ) )
{ /* Highest bit not set, it's the last value */
cont = EFalse;
}
}
if ( cont != EFalse )
{ /* Reading the length failed */
headerLen = 0;
}
else
{
/* Increase read start index past length
informations */
readStart += i;
}
}
}
}
if ( headerLen > 0 )
{
HBufC8 *header = HBufC8::NewLC( headerLen );
/* Read header */
TPtr8 headerPtr( header->Des() );
err = file.Read( readStart, headerPtr, headerLen );
if ( err == KErrNone && headerPtr.Length() == headerLen )
{
// seperate function call from here
OmaBasedHeaderParserL( tempVal, headerPtr, aEndTime );
}
/* Pop and destroy header */
CleanupStack::PopAndDestroy( header );
}
}
CleanupStack::PopAndDestroy( filename );
CleanupStack::PopAndDestroy( &file );
CleanupStack::PopAndDestroy( &fileSession );
__UHEAP_MARKEND;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::OmaBasedHeaderParserL
// -----------------------------------------------------------------------------
//
TInt DRM::CDrmUiHandlingImpl::OmaBasedHeaderParserL(
TInt aOffset,
TPtr8 aHeaderPtr,
TTime& aEndTime )
{
TInt err = KErrNone;
TTime *time = NULL;
_LIT8( KEndTimeStr, "Time-Not-After/" );
_LIT( KZero, "0" );
/* Get the time */
TInt pos = aHeaderPtr.FindF( KEndTimeStr );
if ( pos != KErrNotFound )
{
TPtrC8 endTimeStr( aHeaderPtr.Mid( pos + KEndTimeStr().Length() ) );
pos = endTimeStr.Locate( ',' );
if ( pos != KErrNotFound )
{
endTimeStr.Set( endTimeStr.Left( pos ) );
/* Check if it contains timezone information */
pos = endTimeStr.Locate( 'Z' );
if ( pos != KErrNotFound )
{ /* Cut the time zone information "Zxxx" */
endTimeStr.Set( endTimeStr.Left( pos ) );
}
pos = endTimeStr.Locate( '+' );
if ( pos != KErrNotFound )
{ /* Cut the time zone information "+xx" */
endTimeStr.Set( endTimeStr.Left( pos ) );
}
pos = endTimeStr.Locate( '-' );
if ( pos != KErrNotFound )
{ /* Cut the time zone information "-xx" */
endTimeStr.Set( endTimeStr.Left( pos ) );
}
/* Allocate new buffer with length enough
for adding needed ':' character between date and time */
const TInt KPlaceOfColon( 8 );
HBufC16* dateTimeBuf = HBufC16::NewLC( endTimeStr.Length() + 1 );
/* Copy provides sufficient 8bit -> 16bit conversion here */
dateTimeBuf->Des().Copy( endTimeStr );
dateTimeBuf->Des().Insert( KPlaceOfColon, _L16 ( ":" ) );
/* Decrease 1 from month and day, cause
TTime::FormatL expects them to start from 0 */
TPtrC16 tempPtr( dateTimeBuf->Des().Mid( 4, 2 ) );
TLex16 lex( dateTimeBuf->Des().Mid( 4, 2 ) );
TBuf<2> replace;
err = lex.Val( aOffset );
if ( err == KErrNone )
{
replace.Num( ( aOffset - 1 ) );
if ( replace.Length() == 1 )
{ /* Insert the '0' needed by TTime */
replace.Insert( 0, KZero );
}
dateTimeBuf->Des().Replace( 4, 2, replace );
lex.Assign( dateTimeBuf->Des().Mid( 6, 2 ) );
TBuf<2> replace;
err = lex.Val( aOffset );
if ( err == KErrNone )
{
replace.Num( ( aOffset - 1 ) );
if ( replace.Length() == 1 )
{ /* Insert the '0' needed by TTime */
replace.Insert( 0, KZero );
}
dateTimeBuf->Des().Replace( 6, 2, replace );
time = new ( ELeave ) TTime( dateTimeBuf->Des() );
CleanupStack::PushL( time );
aEndTime = *time;
/* Pop and destroy time */
CleanupStack::PopAndDestroy( time );
}
}
/* Pop and destroy dateTimeBuf */
CleanupStack::PopAndDestroy( dateTimeBuf );
}
}
else
{
return KErrNotFound;
}
return KErrNone;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::ShowDetailsViewL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::ShowDetailsViewL( const HBufC* aFullPath )
{
__ASSERT_DEBUG( aFullPath, User::Panic( KDRMUtilityDebugPanicMessage,
KDRMUtilityDebugPanicCode ) );
// For WM DRM
HBufC* launchParam( NULL );
// create parameter string
CreateLaunchParamL( aFullPath, launchParam );
CleanupStack::PushL( launchParam );
// show details
LaunchRightsManagerUiL( *launchParam );
CleanupStack::PopAndDestroy( launchParam );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::DoHandleOmaUrlL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::DoHandleOmaUrlL(
ContentAccess::CData& aContent,
DRM::TDrmUiUrlType aType )
{
HBufC* url( NULL );
HBufC8* url8( NULL );
TInt previewType( 0 );
switch ( aType )
{
// handle RightsIssuerUrl
case DRM::EUHRightsIssuerUrl:
GetOmaRightsIssuerLC( aContent, url );
if ( !url )
{
User::Leave( KErrNotFound );
}
LaunchBrowserL( url );
CleanupStack::PopAndDestroy( url );
break;
// handle PreviewUrl
case DRM::EUHPreviewRightsUrl:
GetOmaPreviewInfoLC( aContent, url, previewType );
if ( !url )
{
User::Leave( KErrNotFound );
}
#ifdef RD_DRM_PREVIEW_RIGHT_FOR_AUDIO
if ( previewType == ContentAccess::EPreviewRights )
{
url8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L( *url );
CleanupStack::PushL( url8 );
GetSilentRightsL( *url8, ETrue );
CleanupStack::PopAndDestroy( url8 );
}
#endif // RD_DRM_PREVIEW_RIGHT_FOR_AUDIO
CleanupStack::PopAndDestroy( url );
break;
// handle SilentRightsUrl
case DRM::EUHSilentRightsUrl:
GetOmaSilentRightsUrlLC( aContent, url8 );
if ( !url8 )
{
User::Leave( KErrNotFound );
}
GetSilentRightsL( *url8, ETrue );
CleanupStack::PopAndDestroy( url8 );
break;
// handle InfoUrl
case DRM::EUHInfoUrl:
GetOmaInfoUrlLC( aContent, url );
if ( !url )
{
User::Leave( KErrNotFound );
}
LaunchBrowserL( url );
CleanupStack::PopAndDestroy( url );
break;
// handle DomainRightsIssuerUrl
case DRM::EUHDomainRiUrl:
GetOmaDomainRightsIssuerLC( aContent, url );
if ( !url )
{
User::Leave( KErrNotFound );
}
LaunchBrowserL( url );
CleanupStack::PopAndDestroy( url );
break;
default:
User::Leave( KErrNotSupported );
break;
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::GetAvailableOmaUrlsL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::GetAvailableOmaUrlsL(
ContentAccess::CData& aContent,
DRM::TDrmUiUrlType& aType )
{
HBufC* riUrl( NULL );
HBufC* previewUrl( NULL );
HBufC8* silentUrl( NULL );
HBufC* infoUrl( NULL );
HBufC* domainRiUrl( NULL );
TInt dummy( 0 );
TInt temp( 0 );
// Try to get all Urls
GetOmaRightsIssuerLC( aContent, riUrl );
if ( riUrl )
{
temp |= DRM::EUHRightsIssuerUrl;
}
CleanupStack::PopAndDestroy( riUrl );
riUrl = NULL;
GetOmaPreviewInfoLC( aContent, previewUrl, dummy );
if ( previewUrl )
{
temp |= DRM::EUHPreviewRightsUrl;
}
CleanupStack::PopAndDestroy( previewUrl );
previewUrl = NULL;
GetOmaSilentRightsUrlLC( aContent, silentUrl );
if ( silentUrl )
{
temp |= DRM::EUHSilentRightsUrl;
}
CleanupStack::PopAndDestroy( silentUrl );
silentUrl = NULL;
GetOmaInfoUrlLC( aContent, infoUrl );
if ( infoUrl )
{
temp |= DRM::EUHInfoUrl;
}
CleanupStack::PopAndDestroy( infoUrl );
infoUrl = NULL;
GetOmaDomainRightsIssuerLC( aContent, domainRiUrl );
if ( domainRiUrl )
{
temp |= DRM::EUHDomainRiUrl;
}
CleanupStack::PopAndDestroy( domainRiUrl );
domainRiUrl = NULL;
// Return a bit mask of available urls
aType = static_cast<TDrmUiUrlType> ( temp );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::GetContentIdLC
// -----------------------------------------------------------------------------
//
TInt DRM::CDrmUiHandlingImpl::GetContentIdLC(
const ContentAccess::CData& aContent,
HBufC8*& aId )
{
__ASSERT_DEBUG( !aId, User::Panic( KDRMUtilityDebugPanicMessage,
KDRMUtilityDebugPanicCode ) );
TInt error( KErrNone );
TInt currentLength( KUrlMaxLen );
HBufC* contentId( NULL );
TPtr idPtr( NULL, 0 );
contentId = HBufC::NewLC( currentLength );
idPtr.Set( contentId->Des() );
error = aContent.GetStringAttribute( ContentAccess::EContentID, idPtr );
while ( error == KErrOverflow )
{
currentLength += currentLength;
CleanupStack::PopAndDestroy( contentId );
contentId = HBufC::NewLC( currentLength );
idPtr.Set( contentId->Des() );
error
= aContent.GetStringAttribute( ContentAccess::EContentID, idPtr );
}
if ( !error && idPtr.Length() )
{
aId = CnvUtfConverter::ConvertFromUnicodeToUtf8L( idPtr );
}
CleanupStack::PopAndDestroy( contentId );
CleanupStack::PushL( aId );
return error;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::GetOmaRightsIssuerLC
// -----------------------------------------------------------------------------
//
TInt DRM::CDrmUiHandlingImpl::GetOmaRightsIssuerLC(
const ContentAccess::CData& aContent,
HBufC*& aIssuer )
{
__ASSERT_DEBUG( !aIssuer, User::Panic( KDRMUtilityDebugPanicMessage,
KDRMUtilityDebugPanicCode ) );
TInt error( KErrNone );
TInt currentLength( KUrlMaxLen );
HBufC* decodedIssuer( NULL );
HBufC* rightsIssuer( NULL );
TPtr riPtr( NULL, 0 );
rightsIssuer = HBufC::NewLC( currentLength );
riPtr.Set( rightsIssuer->Des() );
// Get value of riUrl
error = aContent.GetStringAttribute( ContentAccess::ERightsIssuerUrl,
riPtr );
while ( error == KErrOverflow )
{
currentLength += currentLength;
CleanupStack::PopAndDestroy( rightsIssuer );
rightsIssuer = HBufC::NewLC( currentLength );
riPtr.Set( rightsIssuer->Des() );
error = aContent.GetStringAttribute( ContentAccess::ERightsIssuerUrl,
riPtr );
}
if ( !error && riPtr.Length() )
{
riPtr.TrimLeft();
// check if rights issuer is encrypted
if ( riPtr.MatchF( KEncryptedRightsIssuerMatchString )
!= KErrNotFound )
{
HBufC8* input( NULL );
HBufC8* output( NULL );
input = CnvUtfConverter::ConvertFromUnicodeToUtf8L( riPtr );
CleanupStack::PushL( input );
// encrypted, decrypt
User::LeaveIfError( iOmaClient.DecodeRightsIssuerField( *input,
output ) );
CleanupStack::PopAndDestroy( input );
CleanupStack::PushL( output );
decodedIssuer = CnvUtfConverter::ConvertToUnicodeFromUtf8L(
*output );
CleanupStack::PopAndDestroy( output );
CleanupStack::PushL( decodedIssuer );
riPtr.Set( decodedIssuer->Des() );
aIssuer = riPtr.AllocL();
CleanupStack::PopAndDestroy( decodedIssuer );
}
else
{
aIssuer = riPtr.AllocL();
}
}
CleanupStack::PopAndDestroy( rightsIssuer );
CleanupStack::PushL( aIssuer );
return error;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::GetOmaDomainRightsIssuerLC
// -----------------------------------------------------------------------------
//
TInt DRM::CDrmUiHandlingImpl::GetOmaDomainRightsIssuerLC(
const ContentAccess::CData& aContent,
HBufC*& aIssuer )
{
__ASSERT_DEBUG( !aIssuer, User::Panic( KDRMUtilityDebugPanicMessage,
KDRMUtilityDebugPanicCode ) );
TInt error( KErrNone );
TInt currentLength( KUrlMaxLen );
HBufC* rightsIssuer( NULL );
TPtr riPtr( NULL, 0 );
rightsIssuer = HBufC::NewLC( currentLength );
riPtr.Set( rightsIssuer->Des() );
// Get value of domainRIUrl
error = aContent.GetStringAttribute(
ContentAccess::EDomainRightsIssuerUrl, riPtr );
while ( error == KErrOverflow )
{
currentLength += currentLength;
CleanupStack::PopAndDestroy( rightsIssuer );
rightsIssuer = HBufC::NewLC( currentLength );
riPtr.Set( rightsIssuer->Des() );
error = aContent.GetStringAttribute(
ContentAccess::EDomainRightsIssuerUrl, riPtr );
}
if ( !error && riPtr.Length() )
{
aIssuer = riPtr.AllocL();
}
CleanupStack::PopAndDestroy( rightsIssuer );
CleanupStack::PushL( aIssuer );
return error;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::GetOmaPreviewInfoLC
// -----------------------------------------------------------------------------
TInt DRM::CDrmUiHandlingImpl::GetOmaPreviewInfoLC(
const ContentAccess::CData& aContent,
HBufC*& aPreviewUrl,
TInt& aPreviewType )
{
__ASSERT_DEBUG( !aPreviewUrl, User::Panic( KDRMUtilityDebugPanicMessage,
KDRMUtilityDebugPanicCode ) );
TInt error( KErrNone );
TInt currentLength( KUrlMaxLen );
HBufC* preview( NULL );
TPtr previewPtr( NULL, 0 );
aPreviewType = ContentAccess::ENoPreview;
preview = HBufC::NewLC( currentLength );
previewPtr.Set( preview->Des() );
error = aContent.GetAttribute( ContentAccess::EPreviewType, aPreviewType );
switch ( aPreviewType )
{
case ContentAccess::EInstantPreview:
// get URI of embedded preview
error = aContent.GetStringAttribute(
ContentAccess::EInstantPreviewUri, previewPtr );
while ( error == KErrOverflow )
{
currentLength += currentLength;
CleanupStack::PopAndDestroy( preview );
preview = HBufC::NewLC( currentLength );
previewPtr.Set( preview->Des() );
error = aContent.GetStringAttribute(
ContentAccess::EInstantPreviewUri, previewPtr );
}
if ( !error && previewPtr.Length() )
{
aPreviewUrl = previewPtr.AllocL();
}
else
{
aPreviewType = ContentAccess::ENoPreview;
}
break;
case ContentAccess::EPreviewRights:
// get URI of preview rights
error = aContent.GetStringAttribute(
ContentAccess::EPreviewRightsUri, previewPtr );
while ( error == KErrOverflow )
{
currentLength += currentLength;
CleanupStack::PopAndDestroy( preview );
preview = HBufC::NewLC( currentLength );
previewPtr.Set( preview->Des() );
error = aContent.GetStringAttribute(
ContentAccess::EPreviewRightsUri, previewPtr );
}
if ( !error && previewPtr.Length() )
{
aPreviewUrl = previewPtr.AllocL();
}
else
{
aPreviewType = ContentAccess::ENoPreview;
}
break;
default:
// no preview
break;
}
CleanupStack::PopAndDestroy( preview );
CleanupStack::PushL( aPreviewUrl );
return error;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::GetOmaSilentRightsUrlLC
// -----------------------------------------------------------------------------
TInt DRM::CDrmUiHandlingImpl::GetOmaSilentRightsUrlLC(
const ContentAccess::CData& aContent,
HBufC8*& aSilentUrl )
{
__ASSERT_DEBUG( !aSilentUrl, User::Panic( KDRMUtilityDebugPanicMessage,
KDRMUtilityDebugPanicCode ) );
TInt error( KErrNone );
TInt currentLength( KUrlMaxLen );
Roap::RRoapStorageClient storage;
HBufC8* silent8( NULL );
HBufC* silent( NULL );
TPtr silentPtr( NULL, 0 );
silent = HBufC::NewLC( currentLength );
silentPtr.Set( silent->Des() );
// get SilentRightsUrl
error = aContent.GetStringAttribute( ContentAccess::ESilentRightsUrl,
silentPtr );
while ( error == KErrOverflow )
{
currentLength += currentLength;
CleanupStack::PopAndDestroy( silent );
silent = HBufC::NewLC( currentLength );
silentPtr.Set( silent->Des() );
error = aContent.GetStringAttribute( ContentAccess::ESilentRightsUrl,
silentPtr );
}
if ( !error && silentPtr.Length() )
{
silentPtr.TrimLeft();
silent8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L( silentPtr );
TPtr8 silentPtr8( silent8->Des() );
CleanupStack::PushL( silent8 );
User::LeaveIfError( storage.Connect() );
CleanupClosePushL( storage );
// check that SilentRightsUrl is on the white list
// URL is not searched from pre-configured white list
TBool fromPreConfiguredWhiteList( EFalse );
if ( storage.WhiteListURLExistsL( *silent8,
fromPreConfiguredWhiteList ) )
{
aSilentUrl = silentPtr8.AllocL();
}
CleanupStack::PopAndDestroy( 2, silent8 ); //storage, silent8
}
CleanupStack::PopAndDestroy( silent );
CleanupStack::PushL( aSilentUrl );
return error;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::GetOmaInfoUrlLC
// -----------------------------------------------------------------------------
//
TInt DRM::CDrmUiHandlingImpl::GetOmaInfoUrlLC(
const ContentAccess::CData& aContent,
HBufC*& aInfoUrl )
{
__ASSERT_DEBUG( !aInfoUrl, User::Panic( KDRMUtilityDebugPanicMessage,
KDRMUtilityDebugPanicCode ) );
TInt error( KErrNone );
TInt currentLength( KUrlMaxLen );
HBufC* info( NULL );
TPtr infoPtr( NULL, 0 );
info = HBufC::NewLC( currentLength );
infoPtr.Set( info->Des() );
// get InfoUrl
error = aContent.GetStringAttribute( ContentAccess::EInfoURL, infoPtr );
while ( error == KErrOverflow )
{
currentLength += currentLength;
CleanupStack::PopAndDestroy( info );
info = HBufC::NewLC( currentLength );
infoPtr.Set( info->Des() );
error
= aContent.GetStringAttribute( ContentAccess::EInfoURL, infoPtr );
}
if ( !error && infoPtr.Length() )
{
aInfoUrl = infoPtr.AllocL();
}
CleanupStack::PopAndDestroy( info );
CleanupStack::PushL( aInfoUrl );
return error;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::GetOmaPendingRightsInfoLC
// -----------------------------------------------------------------------------
//
TInt DRM::CDrmUiHandlingImpl::GetOmaPendingRightsInfoLC(
const ContentAccess::CData& aContent,
HBufC*& aEta )
{
__ASSERT_DEBUG( !aEta, User::Panic( KDRMUtilityDebugPanicMessage,
KDRMUtilityDebugPanicCode ) );
TInt error( KErrNone );
HBufC* eta( NULL );
TPtr etaPtr( NULL, 0 );
eta = HBufC::NewLC( KDRMMaxETABufSize );
etaPtr.Set( eta->Des() );
// get eta info
error = aContent.GetStringAttribute( EPendingRightsETA, etaPtr );
if ( !error && etaPtr.Length() )
{
aEta = etaPtr.AllocL();
}
CleanupStack::PopAndDestroy( eta );
CleanupStack::PushL( aEta );
return error;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::GetContentLocationLC
// -----------------------------------------------------------------------------
//
TInt DRM::CDrmUiHandlingImpl::GetContentLocationLC(
const ContentAccess::CData& aContent,
HBufC*& aPath )
{
__ASSERT_DEBUG( !aPath, User::Panic( KDRMUtilityDebugPanicMessage,
KDRMUtilityDebugPanicCode ) );
TInt error( KErrNone );
TInt currentLength( KUrlMaxLen );
TPtr pathPtr( NULL, 0 );
aPath = HBufC::NewLC( currentLength );
pathPtr.Set( aPath->Des() );
error = aContent.GetStringAttribute( DRM::EDrmFullName, pathPtr );
while ( error == KErrOverflow )
{
currentLength += currentLength;
CleanupStack::PopAndDestroy( aPath );
aPath = HBufC::NewLC( currentLength );
pathPtr.Set( aPath->Des() );
error = aContent.GetStringAttribute( DRM::EDrmFullName, pathPtr );
}
return error;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CheckOmaDomainStatusL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::CheckOmaDomainStatusL(
const ContentAccess::CData& aContent,
const HBufC* aDomainRiUrl,
TInt& aIsRegistered,
TInt& aIsJoined )
{
Roap::RRoapStorageClient storage;
CDRMRIContext* riContext( NULL );
CDRMDomainContext* domainContext( NULL );
HBufC* riId( NULL );
HBufC8* riId8( NULL );
HBufC* domainId( NULL );
HBufC8* domainId8( NULL );
TInt error( KErrNone );
TPtr ptr( NULL, 0 );
aIsJoined = EFalse;
aIsRegistered = EFalse;
riId = HBufC::NewLC( KUrlMaxLen );
domainId = HBufC::NewLC( KUrlMaxLen );
// create attribute set
RStringAttributeSet stringAttributeSet;
CleanupClosePushL( stringAttributeSet );
// add the attributes we are interested in
stringAttributeSet.AddL( EDomainId );
stringAttributeSet.AddL( EDomainRightsIssuerId );
User::LeaveIfError( aContent.GetStringAttributeSet( stringAttributeSet ) );
// pass on values of string attributes
ptr.Set( domainId->Des() );
error = stringAttributeSet.GetValue( EDomainId, ptr );
if ( !error )
{
ptr.Set( riId->Des() );
stringAttributeSet.GetValue( EDomainRightsIssuerId, ptr );
if ( !error )
{
riId8 = HBufC8::NewLC( riId->Length() );
riId8->Des().Copy( riId->Des() );
domainId8 = HBufC8::NewLC( domainId->Length() );
domainId8->Des().Copy( domainId->Des() );
if ( riId8 && riId8->Length() && aDomainRiUrl
&& aDomainRiUrl->Length() )
{
// Check if we have domain RO
User::LeaveIfError( storage.Connect() );
CleanupClosePushL( storage );
riContext = storage.GetRIContextL( *riId8 );
if ( riContext )
{
aIsRegistered = ETrue;
delete riContext;
if ( domainId8 && domainId8->Length() )
{
domainContext
= storage.GetDomainContextL( *domainId8 );
if ( domainContext )
{
// last three digits presents
// the domain generation
TInt generation( 0 );
TLex8 lex( domainId8->Right(
KOmaDomainGenerationLength ) );
lex.Val( generation );
if ( domainContext->DomainGeneration()
>= generation )
{
aIsJoined = ETrue;
}
delete domainContext;
}
}
}
CleanupStack::PopAndDestroy( &storage );
}
CleanupStack::PopAndDestroy( 2, riId8 ); // domainId8, riId8
}
}
CleanupStack::PopAndDestroy( &stringAttributeSet );
CleanupStack::PopAndDestroy( 2, riId ); // domainId, riId
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CallRightsNotValidL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::CallRightsNotValidL(
DRM::MDrmUiCheckRightsObserver* aObserver,
TInt aOperationId,
DRM::TCheckRightsStatus aRightsStatus,
TUint32 aReason,
ContentAccess::CData& aContent,
const HBufC8* aContentUri,
CDRMConstraint* aConstraint,
const HBufC* aRightsUrl,
DRM::TDrmUiUrlType aUrlType,
const HBufC8* aSilentUrl,
ContentAccess::TIntent aIntent )
{
DRM::TCheckRightsAction rightsAction( DRM::EUHCheckRightsActionDefault );
if ( aObserver )
{
// call given CheckRightsObserver
rightsAction = aObserver->RightsNotValid( aOperationId,
aRightsStatus, RejectReason( aReason ) );
}
switch ( rightsAction )
{
case DRM::EUHCheckRightsActionDefault:
{
if ( RejectReason( aReason ) == DRM::EURejectionMetering )
{
// Show that only reason for error was rejected metering.
iDrmUtilityUi->DisplayQueryWithIdL(
R_DRM_QUERY_METERING_DISABLED,
R_DRMUTILITY_WAITING_RIGHTS_CONFIRMATION_QUERY );
}
else
{
if ( !GetSilentAndCallL( aObserver, aOperationId, aIntent,
aContentUri, aSilentUrl, ETrue ) )
{
// Silent URL not present or silent retrieval failed
// show appropriate notes
if ( ShowNoRightsNoteL( aContent, RightsInfoStatus(
aRightsStatus ), aReason, aConstraint, aRightsUrl,
aUrlType, ENoRights ) )
{
GetRightsAndCallL( aObserver, aOperationId, aIntent,
aContentUri, aRightsUrl );
}
}
}
}
break;
case DRM::EUHCheckRightsActionOpenDetailsView:
{
HBufC* fullPath( NULL );
GetContentLocationLC( aContent, fullPath );
ShowDetailsViewL( aContentUri, fullPath );
CleanupStack::PopAndDestroy( fullPath );
}
break;
case DRM::EUHCheckRightsActionAcquireNewRights:
{
if ( !GetSilentAndCallL( aObserver, aOperationId, aIntent,
aContentUri, aSilentUrl, EFalse ) )
{
GetRightsAndCallL( aObserver, aOperationId, aIntent,
aContentUri, aRightsUrl );
if ( !aRightsUrl )
{
User::Leave( KErrArgument );
}
}
}
break;
case DRM::EUHCheckRightsActionIgnore:
// do nothing
break;
default:
break;
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CallRightsLeftL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::CallRightsLeftL(
DRM::MDrmUiCheckRightsObserver* aObserver,
TInt aOperationId,
TBool aUnconstrained,
TTimeIntervalSeconds aTime,
TInt aCounts,
TTimeIntervalSeconds aAccumulated,
const HBufC8* aContentUri,
const HBufC* aRightsUrl,
const HBufC8* aSilentUrl,
ContentAccess::CData& aContent,
ContentAccess::TIntent aIntent )
{
DRM::TCheckRightsAction rightsAction( DRM::EUHCheckRightsActionDefault );
HBufC* fullPath( NULL );
if ( aObserver )
{
// call given CheckRightsObserver
rightsAction = aObserver->RightsLeft( aOperationId, aUnconstrained,
aTime, aCounts, aAccumulated );
}
switch ( rightsAction )
{
case DRM::EUHCheckRightsActionDefault:
{
// show appropriate notes, none at the moment
}
break;
case DRM::EUHCheckRightsActionOpenDetailsView:
{
GetContentLocationLC( aContent, fullPath );
ShowDetailsViewL( aContentUri, fullPath );
CleanupStack::PopAndDestroy( fullPath );
}
break;
case DRM::EUHCheckRightsActionAcquireNewRights:
{
if ( !GetSilentAndCallL( aObserver, aOperationId, aIntent,
aContentUri, aSilentUrl, EFalse ) )
{
if ( !aRightsUrl )
{
User::Leave( KErrArgument );
}
// launch browser to get new rights
LaunchBrowserL( aRightsUrl );
}
}
break;
case DRM::EUHCheckRightsActionIgnore:
// do nothing
break;
default:
break;
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CallEmbeddedPreviewAvailableL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::CallEmbeddedPreviewAvailableL(
DRM::MDrmHandleErrorObserver* aObserver,
TInt aOperationId,
#ifdef RD_DRM_PREVIEW_RIGHT_FOR_AUDIO
ContentAccess::CData& aContent,
#else
ContentAccess::CData& /*aContent*/,
#endif
const HBufC* aPreviewUrl,
DRM::TDrmRightsInfo aRightsStatus,
TUint32 aReason,
const HBufC* aRightsUrl,
const HBufC8* aContentUri,
ContentAccess::TIntent aIntent )
{
DRM::TEmbeddedPreviewAction embeddedPreviewAction(
DRM::EUEmbeddedPreviewActionDefault );
#ifdef RD_DRM_PREVIEW_RIGHT_FOR_AUDIO
TInt buttonCode( 0 );
#endif // RD_DRM_PREVIEW_RIGHT_FOR_AUDIO
if ( aObserver )
{
// call given HandleErrorObserver
embeddedPreviewAction
= aObserver->EmbeddedPreviewAvailable( aOperationId,
*aPreviewUrl, aRightsStatus, RejectReason( aReason ) );
}
switch ( embeddedPreviewAction )
{
case DRM::EUEmbeddedPreviewActionDefault:
case DRM::EUEmbeddedPreviewActionDefaultAudio:
case DRM::EUEmbeddedPreviewActionDefaultVideo:
{
#ifdef RD_DRM_PREVIEW_RIGHT_FOR_AUDIO
buttonCode = iDrmUtilityUi->DisplayPopupWindowsForPreviewL(
aContent, ContentAccess::EInstantPreview,
embeddedPreviewAction );
switch ( buttonCode )
{
case 1: // Normal Rights
{
GetRightsAndCallL( aObserver, aOperationId, aIntent,
aContentUri, aRightsUrl );
}
break;
case 2: // Play Preview
CallPlayEmbeddedPreviewSelected( aObserver, aOperationId,
aPreviewUrl );
break;
default:
break;
}
#endif // RD_DRM_PREVIEW_RIGHT_FOR_AUDIO
}
break;
case DRM::EUEmbeddedPreviewActionFetchRights:
{
GetRightsAndCallL( aObserver, aOperationId, aIntent, aContentUri,
aRightsUrl );
}
break;
case DRM::EUEmbeddedPreviewActionPlayPreview:
// do nothing (observer plays the preview)
case DRM::EUEmbeddedPreviewActionIgnore:
// do nothing
break;
default:
break;
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CallPreviewRightsUrlAvailableL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::CallPreviewRightsUrlAvailableL(
DRM::MDrmHandleErrorObserver* aObserver,
TInt aOperationId,
#ifdef RD_DRM_PREVIEW_RIGHT_FOR_AUDIO
ContentAccess::CData& aContent,
#else
ContentAccess::CData& /*aContent*/,
#endif
const HBufC* aPreviewUrl,
DRM::TDrmRightsInfo aRightsStatus,
TUint32 aReason,
const HBufC* aRightsUrl,
const HBufC8* aContentUri,
ContentAccess::TIntent aIntent )
{
DRM::TPreviewRightsAction previewRightsAction(
DRM::EUPreviewRightsActionDefault );
#ifdef RD_DRM_PREVIEW_RIGHT_FOR_AUDIO
TInt buttonCode( 0 );
HBufC8* url8( NULL );
#endif // RD_DRM_PREVIEW_RIGHT_FOR_AUDIO
if ( aObserver )
{
// call given HandleErrorObserver
previewRightsAction
= aObserver->PreviewRightsUrlAvailable( aOperationId,
*aPreviewUrl, aRightsStatus, RejectReason( aReason ) );
}
switch ( previewRightsAction )
{
case DRM::EUPreviewRightsActionDefault:
case DRM::EUPreviewRightsActionDefaultAudio:
case DRM::EUPreviewRightsActionDefaultVideo:
{
#ifdef RD_DRM_PREVIEW_RIGHT_FOR_AUDIO
buttonCode = iDrmUtilityUi->DisplayPopupWindowsForPreviewL(
aContent, ContentAccess::EPreviewRights, previewRightsAction );
switch ( buttonCode )
{
case 1: // Normal rights
{
GetRightsAndCallL( aObserver, aOperationId, aIntent,
aContentUri, aRightsUrl );
}
break;
case 2: // Preview rights
{
TInt callError( KErrNotFound );
if ( aPreviewUrl )
{
url8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L(
*aPreviewUrl );
CleanupStack::PushL( url8 );
GetSilentRightsL( *url8, ETrue );
CleanupStack::PopAndDestroy( url8 );
// check if rights exist now
callError = CheckAndMapToCallError( iOmaClient,
aIntent, *aContentUri );
}
CallPreviewRightsAvailable( aObserver, aOperationId,
callError );
}
break;
default:
break;
}
#endif // RD_DRM_PREVIEW_RIGHT_FOR_AUDIO
}
break;
case DRM::EUPreviewRightsActionFetchRights:
{
GetRightsAndCallL( aObserver, aOperationId, aIntent, aContentUri,
aRightsUrl );
}
break;
case DRM::EUPreviewRightsActionFetchPreviewRights:
// do nothing (observer fetches preview rights)
case DRM::EUPreviewRightsActionIgnore:
// do nothing
break;
default:
break;
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CallSilentRightsUrlAvailableL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::CallSilentRightsUrlAvailableL(
DRM::MDrmHandleErrorObserver* aObserver,
TInt aOperationId,
const HBufC8* aSilentUrl,
DRM::TDrmRightsInfo aRightsStatus,
TUint32 aReason,
const HBufC* aRightsUrl,
const HBufC8* aContentUri,
ContentAccess::TIntent aIntent )
{
DRM::TSilentRightsAction silentRightsAction(
DRM::EUSilentRightsActionDefault );
TInt callError( KErrNotFound );
HBufC * silent16(
CnvUtfConverter::ConvertToUnicodeFromUtf8L( *aSilentUrl ) );
if ( aObserver )
{
// call given HandleErrorObserver
silentRightsAction = aObserver->SilentRightsUrlAvailable(
aOperationId, *silent16, aRightsStatus, RejectReason( aReason ) );
}
delete silent16;
switch ( silentRightsAction )
{
case DRM::EUSilentRightsActionDefault:
{
GetSilentRightsL( *aSilentUrl, ETrue );
// check if rights exist now
callError = CheckAndMapToCallError( iOmaClient, aIntent,
*aContentUri );
CallSilentRightsAvailable( aObserver, aOperationId, callError );
}
break;
case DRM::EUSilentRightsActionFetchRights:
{
GetRightsAndCallL( aObserver, aOperationId, aIntent, aContentUri,
aRightsUrl );
}
break;
case DRM::EUSilentRightsActionFetchSilentRights:
// do nothing (observer fetches silent rights)
case DRM::EUSilentRightsActionIgnore:
// do nothing
break;
default:
break;
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CallRightsUrlAvailableL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::CallRightsUrlAvailableL(
DRM::MDrmHandleErrorObserver* aObserver,
TInt aOperationId,
DRM::TDrmRightsInfo aRightsStatus,
TUint32 aReason,
CDRMConstraint* aConstraint,
ContentAccess::CData& aContent,
const HBufC8* aContentUri,
const HBufC* aRightsUrl,
DRM::TDrmUiUrlType aUrlType,
ContentAccess::TIntent aIntent,
TInt aError )
{
DRM::TRightsAction rightsAction( DRM::EURightsActionDefault );
if ( aObserver && aRightsUrl )
{
// call given HandleErrorObserver
rightsAction = aObserver->RightsUrlAvailable( aOperationId,
*aRightsUrl, aRightsStatus, RejectReason( aReason ), aUrlType );
}
switch ( rightsAction )
{
case DRM::EURightsActionDefault:
{
if ( ShowNoRightsNoteL( aContent, aRightsStatus, aReason,
aConstraint, aRightsUrl, aUrlType, aError ) )
{
GetRightsAndCallL( aObserver, aOperationId, aIntent,
aContentUri, aRightsUrl );
}
}
break;
case DRM::EURightsActionFetchRights:
{
GetRightsAndCallL( aObserver, aOperationId, aIntent, aContentUri,
aRightsUrl );
}
break;
case DRM::EURightsActionIgnore:
// do nothing
break;
default:
break;
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CallPreviewRightsAvailable
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::CallPreviewRightsAvailable(
DRM::MDrmHandleErrorObserver* aObserver,
TInt aOperationId,
TInt aError )
{
if ( aObserver )
{
// call given HandleErrorObserver
aObserver->PreviewRightsAvailable( aOperationId, aError );
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CallSilentRightsAvailable
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::CallSilentRightsAvailable(
DRM::MDrmHandleErrorObserver* aObserver,
TInt aOperationId,
TInt aError )
{
if ( aObserver )
{
// call given HandleErrorObserver
aObserver->SilentRightsAvailable( aOperationId, aError );
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CallRightsAvailable
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::CallRightsAvailable(
DRM::MDrmHandleErrorObserver* aObserver,
TInt aOperationId,
TInt aError )
{
if ( aObserver )
{
// call given HandleErrorObserver
aObserver->RightsAvailable( aOperationId, aError );
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CallPlayEmbeddedPreviewSelected
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::CallPlayEmbeddedPreviewSelected(
DRM::MDrmHandleErrorObserver* aObserver,
TInt aOperationId,
const HBufC* aPreviewUrl )
{
if ( aObserver )
{
// call given HandleErrorObserver
aObserver->PlayEmbeddedPreviewSelected( aOperationId, *aPreviewUrl );
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::ShowNoRightsNoteL
// -----------------------------------------------------------------------------
//
TBool DRM::CDrmUiHandlingImpl::ShowNoRightsNoteL(
ContentAccess::CData& aContent,
DRM::TDrmRightsInfo aRightsStatus,
TUint32 aReason,
CDRMConstraint* aConstraint,
const HBufC* aRightsUrl,
DRM::TDrmUiUrlType aUrlType,
TInt aError )
{
HBufC* etaBuf( NULL );
TBool isRegistered( EFalse );
TBool isJoined( EFalse );
TInt ret( 0 );
TInt err( KErrNone );
TInt eta( 0 );
TFileName fileName;
TBool rightsRenewalWanted( EFalse );
if ( aError != EPendingRights && aRightsStatus == DRM::EURightsInfoFuture )
{
iDrmUtilityUi->ShowFutureRightsNoteL( aConstraint );
}
else
{
// check if rights are expected to arrive
GetOmaPendingRightsInfoLC( aContent, etaBuf );
if ( etaBuf )
{
TLex lexer( *etaBuf );
err = lexer.Val( eta );
}
CleanupStack::PopAndDestroy( etaBuf );
if ( !err && aError == EPendingRights && eta == -1 )
{
// rights should have come already
if ( aRightsUrl )
{
ret = iDrmUtilityUi->DisplayQueryWithIdL(
R_DRMUTILITY_RIGHTS_SHOULD_HAVE_COME,
R_DRMUTILITY_CONFIRMATION_QUERY );
}
else
{
// no rights issuer
iDrmUtilityUi->DisplayQueryWithIdL(
R_DRMUTILITY_RIGHTS_SHOULD_HAVE_COME_NO_RI,
R_DRMUTILITY_WAITING_RIGHTS_CONFIRMATION_QUERY );
}
}
else if ( !eta || err || eta == -1 )
{
// rights not expected to arrive
if ( aUrlType == DRM::EUHDomainRiUrl )
{
CheckOmaDomainStatusL( aContent, aRightsUrl, isRegistered,
isJoined );
}
if ( aRightsUrl && isRegistered && !isJoined ) // Domain ro case
{
ret = iDrmUtilityUi->DisplayQueryWithIdL(
R_DRMUTILITY_ACTIVATE_ACCOUNT,
R_DRMUTILITY_CONFIRMATION_QUERY );
}
else if ( aRightsUrl ) // Device ro case
{
if ( aReason & EConstraintIndividual )
{
ret = iDrmUtilityUi->DisplayQueryWithIdL(
R_DRMUTILITY_INVALID_SIM,
R_DRMUTILITY_CONFIRMATION_QUERY );
}
else
{
// get filename
User::LeaveIfError( aContent.GetStringAttribute(
EFileName, fileName ) );
ret = iDrmUtilityUi->DisplayQueryL(
R_DRM_QUERY_EXPIRED_OR_NO_RO, fileName );
}
}
else // no rights issuer
{
if ( aReason & EConstraintIndividual )
{
iDrmUtilityUi->DisplayNoteL( R_DRM_INFO_SIM_NOT_ALLOWED );
}
else
{
iDrmUtilityUi->DisplayNoteL( R_DRM_INFO_EXPIRED_OR_NO_RO );
}
}
}
else
{
// rights expected to arrive
if ( eta != KErrCAPendingRights )
{
// rights expected to arrive in eta seconds
iDrmUtilityUi->DisplayQueryWithIdL(
R_DRMUTILITY_WAITING_FOR_RIGHTS,
R_DRMUTILITY_WAITING_RIGHTS_CONFIRMATION_QUERY );
}
else
{
// rights should have come
if ( aRightsUrl )
{
ret = iDrmUtilityUi->DisplayQueryWithIdL(
R_DRMUTILITY_RIGHTS_SHOULD_HAVE_COME,
R_DRMUTILITY_CONFIRMATION_QUERY );
}
else
{
// no rights issuer
iDrmUtilityUi->DisplayQueryWithIdL(
R_DRMUTILITY_RIGHTS_SHOULD_HAVE_COME_NO_RI,
R_DRMUTILITY_WAITING_RIGHTS_CONFIRMATION_QUERY );
}
}
}
}
if ( ret == EAknSoftkeyYes || ret == EAknSoftkeyOk )
{
rightsRenewalWanted = ETrue;
}
return rightsRenewalWanted;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::GetOmaConstraintInfo
// -----------------------------------------------------------------------------
//
TInt DRM::CDrmUiHandlingImpl::GetOmaConstraintInfo(
CDRMConstraint* aConstraint,
TUint32& aCountsLeft,
TTime& aEndTime )
{
__ASSERT_DEBUG( aConstraint, User::Panic( KDRMUtilityDebugPanicMessage,
KDRMUtilityDebugPanicCode ) );
TInt ret( 0 );
TTime start( Time::NullTTime() );
aCountsLeft = 0;
aEndTime = Time::NullTTime();
if ( aConstraint->iActiveConstraints & EConstraintCounter )
{
ret |= KDRMOmaConstraintCount;
aCountsLeft = aConstraint->iCounter;
}
if ( aConstraint->iActiveConstraints & EConstraintTimedCounter )
{
ret |= KDRMOmaConstraintCount;
if ( aConstraint->iTimedCounter > aCountsLeft )
{
aCountsLeft = aConstraint->iTimedCounter;
}
}
if ( aConstraint->iActiveConstraints & EConstraintEndTime )
{
ret |= KDRMOmaConstraintTime;
aEndTime = aConstraint->iEndTime;
}
if ( aConstraint->iActiveConstraints & EConstraintInterval )
{
start = aConstraint->iIntervalStart;
if ( start == Time::NullTTime() )
{
start.HomeTime();
}
aEndTime = start + aConstraint->iInterval;
ret |= KDRMOmaConstraintTime;
}
if ( aConstraint->iActiveConstraints & EConstraintAccumulated )
{
if ( aEndTime != Time::NullTTime() && aEndTime
+ aConstraint->iAccumulatedTime > aEndTime || aEndTime
== Time::NullTTime() )
{
aEndTime.HomeTime();
aEndTime = aEndTime + aConstraint->iAccumulatedTime;
ret |= KDRMOmaConstraintAccumulated;
}
}
return ret;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::RejectReason
// -----------------------------------------------------------------------------
//
TInt DRM::CDrmUiHandlingImpl::RejectReason( TUint32 aReason )
{
TInt ret( DRM::EURejectionNone );
if ( aReason & EConstraintStartTime )
{
ret |= DRM::EURejectionStartTime;
}
if ( aReason & EConstraintEndTime )
{
ret |= DRM::EURejectionEndTime;
}
if ( aReason & EConstraintInterval )
{
ret |= DRM::EURejectionInterval;
}
if ( aReason & EConstraintCounter )
{
ret |= DRM::EURejectionCounter;
}
if ( aReason & EConstraintTopLevel )
{
ret |= DRM::EURejectionTopLevel;
}
if ( aReason & EConstraintTimedCounter )
{
ret |= DRM::EURejectionTimedCounter;
}
if ( aReason & EConstraintAccumulated )
{
ret |= DRM::EURejectionAccumulated;
}
if ( aReason & EConstraintIndividual )
{
ret |= DRM::EURejectionIndividual;
}
if ( aReason & EConstraintSystem )
{
ret |= DRM::EURejectionSystem;
}
if ( aReason & EConstraintVendor )
{
ret |= DRM::EURejectionVendor;
}
if ( aReason & EConstraintSoftware )
{
ret |= DRM::EURejectionSoftware;
}
if ( aReason & EConstraintMetering )
{
ret |= DRM::EURejectionMetering;
}
if ( aReason & EConstraintNullDrmTime )
{
ret |= DRM::EURejectionDrmTime;
}
return ret;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::RightsInfoStatus
// -----------------------------------------------------------------------------
//
DRM::TDrmRightsInfo DRM::CDrmUiHandlingImpl::RightsInfoStatus(
DRM::TCheckRightsStatus aStatus )
{
DRM::TDrmRightsInfo ret( DRM::EURightsInfoValid );
if ( aStatus == DRM::EUHCheckRightsExpiredRights )
{
ret = DRM::EURightsInfoExpired;
}
else if ( aStatus == DRM::EUHCheckRightsNoRights )
{
ret = DRM::EURightsInfoMissing;
}
else if ( aStatus == DRM::EUHCheckRightsFutureRights )
{
ret = DRM::EURightsInfoFuture;
}
return ret;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::SelectOmaRightsUrlL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::SelectOmaRightsUrlL(
const ContentAccess::CData& aContent,
const HBufC* aDomainRiUrl,
DRM::TDrmUiUrlType& aUrlType )
{
Roap::RRoapStorageClient storage;
CDRMRIContext* riContext( NULL );
CDRMDomainContext* domainContext( NULL );
HBufC* riId( NULL );
HBufC8* riId8( NULL );
HBufC* domainId( NULL );
HBufC8* domainId8( NULL );
TInt error( KErrNone );
TPtr ptr( NULL, 0 );
TBool isJoined( EFalse );
TBool isRegistered( EFalse );
aUrlType = DRM::EUHRightsIssuerUrl;
riId = HBufC::NewLC( KUrlMaxLen );
domainId = HBufC::NewLC( KUrlMaxLen );
// create attribute set
RStringAttributeSet stringAttributeSet;
CleanupClosePushL( stringAttributeSet );
// add the attributes we are interested in
stringAttributeSet.AddL( EDomainId );
stringAttributeSet.AddL( EDomainRightsIssuerId );
User::LeaveIfError( aContent.GetStringAttributeSet( stringAttributeSet ) );
// pass on values of string attributes
ptr.Set( domainId->Des() );
error = stringAttributeSet.GetValue( EDomainId, ptr );
if ( !error )
{
ptr.Set( riId->Des() );
stringAttributeSet.GetValue( EDomainRightsIssuerId, ptr );
if ( !error )
{
riId8 = HBufC8::NewLC( riId->Length() );
riId8->Des().Copy( riId->Des() );
domainId8 = HBufC8::NewLC( domainId->Length() );
domainId8->Des().Copy( domainId->Des() );
if ( riId8 && riId8->Length() && aDomainRiUrl
&& aDomainRiUrl->Length() )
{
// Check if we have domain RO
User::LeaveIfError( storage.Connect() );
CleanupClosePushL( storage );
riContext = storage.GetRIContextL( *riId8 );
if ( riContext )
{
isRegistered = ETrue;
delete riContext;
if ( domainId8 && domainId8->Length() )
{
domainContext
= storage.GetDomainContextL( *domainId8 );
if ( domainContext )
{
// last three digits presents
// the domain generation
TInt generation( 0 );
TLex8 lex( domainId8->Right(
KOmaDomainGenerationLength ) );
lex.Val( generation );
if ( domainContext->DomainGeneration()
>= generation )
{
isJoined = ETrue;
}
delete domainContext;
}
}
}
CleanupStack::PopAndDestroy( &storage );
if ( aDomainRiUrl && aDomainRiUrl->Length()
&& ( !isRegistered | !isJoined ) )
{
aUrlType = DRM::EUHDomainRiUrl;
}
}
CleanupStack::PopAndDestroy( 2, riId8 ); // domainId8, riId8
}
}
CleanupStack::PopAndDestroy( &stringAttributeSet );
CleanupStack::PopAndDestroy( 2, riId ); // domainId, riId
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::LaunchRightsManagerUiL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::LaunchRightsManagerUiL( const TDesC& aParam16 )
{
const TUid KUidDRMUI =
{
0x101f85c7
};
if ( iCoeEnv )
{
CAiwGenericParamList* paramList( CAiwGenericParamList::NewLC() );
TAiwVariant variantObject( aParam16 );
TAiwGenericParam param( EGenericParamFile, variantObject );
paramList->AppendL( param );
CAknLaunchAppService* launchAppService( CAknLaunchAppService::NewL(
KUidDRMUI, this, paramList ) );
CleanupStack::PushL( launchAppService );
iWait.Start();
CleanupStack::PopAndDestroy( 2, paramList );
}
else
{
// no UI to embed, launch Rights Manager UI stand-alone
// check if Rights Manager UI is already running
RWsSession wsSession;
User::LeaveIfError( wsSession.Connect() );
CleanupClosePushL( wsSession );
TApaTaskList tasklist( wsSession );
TApaTask task( tasklist.FindApp( KUidDRMUI ) );
if ( task.Exists() )
{
// Rights Manager UI is already running
HBufC8* param8( HBufC8::NewLC( aParam16.Length() ) );
TPtr8 parametersPtr( param8->Des() );
parametersPtr.Copy( aParam16 );
task.SendMessage( TUid::Uid( KUidApaMessageSwitchOpenFileValue ),
*param8 );
CleanupStack::PopAndDestroy( param8 );
}
else
{
RApaLsSession appArcSession;
User::LeaveIfError( appArcSession.Connect() );
CleanupClosePushL( appArcSession );
TThreadId id;
appArcSession.StartDocument( aParam16, KUidDRMUI, id );
CleanupStack::PopAndDestroy( &appArcSession );
}
CleanupStack::PopAndDestroy( &wsSession );
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CreateLaunchParamL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::CreateLaunchParamL(
const HBufC8* aUrl,
HBufC*& aLaunchParam,
const HBufC* aFullPath )
{
__ASSERT_DEBUG( !aLaunchParam && aUrl && aFullPath,
User::Panic( KDRMUtilityDebugPanicMessage,
KDRMUtilityDebugPanicCode ) );
_LIT( KMarker, "\x00" );
TPtr ptr( NULL, 0 );
TInt localId( 0 );
// MaxInt will fit into 10 characters
HBufC* localIDBuf( HBufC::NewLC( KIntegerMaxLen ) );
ptr.Set( localIDBuf->Des() );
ptr.AppendNum( localId );
// length of startparam and drm protection scheme are always 1 and
// 5 markers are needed
const TInt KMarkersForParams( 5 );
TInt length( 1 + aUrl->Length() + ptr.Length() + aFullPath->Length()
+ KMarkersForParams + 1 );
aLaunchParam = HBufC::NewLC( length );
ptr.Set( aLaunchParam->Des() );
// Start parameter is 3 or 4 for launching details view embedded or standalone from
// DRM Utility, respectively, with full path name included as a parameter. Values 1
// and 2 are for launching details view from DRM Helper.
if ( iCoeEnv )
{
ptr.AppendNum( EDrmLaunchParamEmbeddedUtility );
}
else
{
ptr.AppendNum( EDrmLaunchParamStandAloneUtility );
}
ptr.Append( KMarker );
ptr.Append( *localIDBuf );
ptr.Append( KMarker );
HBufC* contentUrl( CnvUtfConverter::ConvertToUnicodeFromUtf8L( *aUrl ) );
ptr.Append( *contentUrl );
ptr.Append( KMarker );
// OMA DRM protection scheme
ptr.AppendNum( EDrmSchemeOmaDrm );
ptr.Append( KMarker );
ptr.Append( *aFullPath );
ptr.Append( KMarker );
delete contentUrl;
CleanupStack::Pop( aLaunchParam );
CleanupStack::PopAndDestroy( localIDBuf );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::CreateLaunchParamL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::CreateLaunchParamL(
const HBufC* aUrl,
HBufC*& aLaunchParam )
{
__ASSERT_DEBUG( !aLaunchParam && aUrl,
User::Panic( KDRMUtilityDebugPanicMessage,
KDRMUtilityDebugPanicCode ) );
_LIT( KZero, "0" );
_LIT( KMarker, "\x00" );
TPtr ptr( NULL, 0 );
// Length of startparam and drm protection scheme and zero local id
// are always 1 and total of 4 markers are needed
TInt length( 1 + aUrl->Length() + 1 + 4 + 1 );
aLaunchParam = HBufC::NewLC( length );
ptr.Set( aLaunchParam->Des() );
// Start parameter is 3 or 4 for launching details view embedded or standalone from
// DRM Utility, respectively, with full path name included as a parameter. Values 1
// and 2 are for launching details view from DRM Helper.
if ( iCoeEnv )
{
ptr.AppendNum( EDrmLaunchParamEmbeddedUtility );
}
else
{
ptr.AppendNum( EDrmLaunchParamStandAloneUtility );
}
ptr.Append( KMarker );
// Default value 0 for localId in case of WM DRM file
ptr.Append( KZero );
ptr.Append( KMarker );
ptr.Append( *aUrl );
ptr.Append( KMarker );
// WM DRM protection scheme
ptr.AppendNum( EDrmSchemeWmDrm );
ptr.Append( KMarker );
CleanupStack::Pop( aLaunchParam );
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::LaunchBrowserL
// Launches browser embedded with given URL
// -----------------------------------------------------------------------------
//
TBool DRM::CDrmUiHandlingImpl::LaunchBrowserL( const HBufC8* aUrl )
{
__ASSERT_DEBUG( aUrl, User::Panic( KDRMUtilityDebugPanicMessage,
KDRMUtilityDebugPanicCode ) );
// URL needs to be unicode
HBufC* parameters( HBufC::NewLC( aUrl->Length() ) );
parameters->Des().Copy( *aUrl );
TBool embeddedLaunch( LaunchBrowserL( parameters ) );
CleanupStack::PopAndDestroy( parameters );
return embeddedLaunch;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::LaunchBrowserL
// Launches browser embedded with given URL
// -----------------------------------------------------------------------------
//
TBool DRM::CDrmUiHandlingImpl::LaunchBrowserL( const HBufC* aUrl )
{
__ASSERT_DEBUG( aUrl, User::Panic( KDRMUtilityDebugPanicMessage,
KDRMUtilityDebugPanicCode ) );
HBufC* newUrl( NULL );
TPtrC ptrc( NULL, 0 );
ptrc.Set( *aUrl );
TBool embeddedLaunch( EFalse );
// if no scheme exists, use http as default scheme
_LIT( KColon, ":" );
if ( ptrc.Find( KColon ) == KErrNotFound )
{
_LIT( KHttp, "http://" );
const TInt KHttpLen( 7 );
newUrl = HBufC::NewLC( KHttpLen + aUrl->Length() );
TPtr ptr( newUrl->Des() );
ptr.Append( KHttp );
ptr.Append( *aUrl );
ptrc.Set( *newUrl );
}
CSchemeHandler* schemeHandler( CSchemeHandler::NewL( ptrc ) );
CleanupStack::PushL( schemeHandler );
if ( iCoeEnv )
{
embeddedLaunch = ETrue;
// launch embedded
schemeHandler->Observer( this );
schemeHandler->HandleUrlEmbeddedL();
CleanupStack::Pop( schemeHandler );
iSchemeHandler = schemeHandler;
iWait.Start();
}
else
{
// no CoeEnv, launch standalone with scheme app
schemeHandler->HandleUrlStandaloneL();
CleanupStack::PopAndDestroy( schemeHandler );
}
schemeHandler = NULL;
// delete newUrl if needed
if ( newUrl )
{
CleanupStack::PopAndDestroy( newUrl );
}
return embeddedLaunch;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::GetSilentRightsL
// -----------------------------------------------------------------------------
//
TInt DRM::CDrmUiHandlingImpl::GetSilentRightsL(
const TDesC8& aUrl,
const TBool aShowNotes )
{
TInt r( KErrCancel );
TInt buttonCode( EAknSoftkeyYes );
HBufC8* url( NULL );
if ( !SilentRightsAllowedL() )
{
buttonCode = EAknSoftkeyNo;
if ( aShowNotes )
{
buttonCode = iDrmUtilityUi->DisplayQueryWithIdL(
R_DRM_QRY_CONNECT_TO_ACTIVATE,
R_DRMUTILITY_CONFIRMATION_QUERY );
}
}
else if ( !BrowserAPDefinedL() )
{
buttonCode = EAknSoftkeyNo;
if ( aShowNotes )
{
buttonCode = iDrmUtilityUi->DisplayQueryWithIdL(
R_DRM_QRY_CONNECT_TO_ACTIVATE,
R_DRMUTILITY_CONFIRMATION_QUERY );
}
}
if ( buttonCode == EAknSoftkeyYes || buttonCode == EAknSoftkeyOk )
{
TInt APs( APCountL() );
if ( !APs )
{
// No AP defined
if ( aShowNotes )
{
iDrmUtilityUi->DisplayNoteL( R_DRM_WARN_NO_CONN_DEFINED );
}
r = KErrCANoRights;
}
else
{
// ok to start download
CDrmUtilityDownloadManager* dlMgr(
CDrmUtilityDownloadManager::NewL() );
CleanupStack::PushL( dlMgr );
url = aUrl.AllocLC();
if ( iCoeEnv && aShowNotes )
{
TRAP( r, dlMgr->DownloadAndHandleRoapTriggerL( url,
*iCoeEnv ) );
}
else
{
TRAP( r, dlMgr->DownloadAndHandleRoapTriggerL( url ) );
}
CleanupStack::PopAndDestroy( url );
if ( r )
{
// rights were tried to get only if
// the user hasn't cancelled
if ( r != KErrCancel )
{
if ( r == KErrCouldNotConnect )
{
// Connection failed with selected AP
if ( aShowNotes )
{
iDrmUtilityUi->DisplayNoteL(
R_DRM_WARN_INVALID_OR_NO_AP );
}
r = KErrCANoRights;
}
else
{
if ( aShowNotes )
{
// get error url
HBufC8* errorUrl( dlMgr->GetErrorUrlL() );
CleanupStack::PushL( errorUrl );
// error url is got only if temporary roap error
if ( errorUrl )
{
// ask user whether error url should be opened
buttonCode
= iDrmUtilityUi->DisplayQueryWithIdL(
R_DRM_QUERY_OPEN_ERROR_URL,
R_DRMUTILITY_CONFIRMATION_QUERY );
if ( buttonCode == EAknSoftkeyYes
|| buttonCode == EAknSoftkeyOk )
{
// Launch browser
LaunchBrowserL( errorUrl );
}
}
else
{
iDrmUtilityUi->DisplayNoteL(
R_DRM_ERR_OPENING_FAIL_PERM );
}
CleanupStack::PopAndDestroy( errorUrl );
}
}
}
}
CleanupStack::PopAndDestroy( dlMgr );
}
}
return r;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::SilentRightsAllowedL
// -----------------------------------------------------------------------------
//
TBool DRM::CDrmUiHandlingImpl::SilentRightsAllowedL()
{
TInt value( KErrNone );
CRepository* repository( CRepository::NewL( KCRUidDRMSettings ) );
repository->Get( KDRMSettingsSilentRightsAcquisition, value );
delete repository;
return !value ? EFalse : ETrue;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::BrowserAPDefinedL
// -----------------------------------------------------------------------------
//
TBool DRM::CDrmUiHandlingImpl::BrowserAPDefinedL()
{
const TInt KDestinationSelectionMode( 2 );
TInt err( KErrNone );
TInt ap( 0 );
TInt alwaysAsk( 0 );
TInt defaultSnap( 0 );
CRepository* repository( CRepository::NewL( KCRUidBrowser ) );
repository->Get( KBrowserDefaultAccessPoint, ap );
repository->Get( KBrowserAccessPointSelectionMode, alwaysAsk );
repository->Get( KBrowserNGDefaultSnapId, defaultSnap );
delete repository;
if ( ap <= KErrNotFound && defaultSnap <= KErrNotFound )
{
alwaysAsk = ETrue;
}
else
{
RCmManager cmManager;
CleanupClosePushL( cmManager );
cmManager.OpenL();
if ( !alwaysAsk )
{
TRAP( err, cmManager.GetConnectionMethodInfoIntL(
ap, CMManager::ECmIapId ) );
}
else if ( alwaysAsk == KDestinationSelectionMode )
{
TRAP( err, IapIdOfDefaultSnapL( cmManager, defaultSnap ) );
}
CleanupStack::PopAndDestroy( &cmManager );
if ( !err && ( !alwaysAsk || alwaysAsk == KDestinationSelectionMode ) )
{
return ETrue;
}
}
return EFalse;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::APCountL
// -----------------------------------------------------------------------------
//
TInt DRM::CDrmUiHandlingImpl::APCountL()
{
TInt apCount( 0 );
RCmManager cmManager;
CleanupClosePushL( cmManager );
cmManager.OpenL();
RArray<TUint32> aps;
CleanupClosePushL( aps );
cmManager.ConnectionMethodL( aps, EFalse, EFalse, ETrue );
apCount = aps.Count();
CleanupStack::PopAndDestroy( 2, &cmManager ); //aps, cmManager
return apCount;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::HandleServerAppExit
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::HandleServerAppExit( TInt aReason )
{
if ( aReason == EAknCmdExit && !iSchemeHandler )
{
CAknEnv::RunAppShutter();
}
if ( iSchemeHandler )
{
delete iSchemeHandler;
iSchemeHandler = NULL;
}
if ( iWait.IsStarted() )
{
iWait.AsyncStop();
}
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::AppendToQueue
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::AppendToQueue( DRM::CDrmUiHandlingData* aData )
{
__ASSERT_DEBUG( aData, User::Panic( KDRMUtilityDebugPanicMessage,
KDRMUtilityDebugPanicCode ) );
// Critical area start:
iSemaphore.Wait();
if ( !iLast )
{
iFirst = aData;
iLast = iFirst;
}
else
{
iLast->iNext = aData;
iLast = aData;
}
// Critical area end
iSemaphore.Signal();
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::PopFront
// -----------------------------------------------------------------------------
//
DRM::CDrmUiHandlingData* DRM::CDrmUiHandlingImpl::PopFront()
{
DRM::CDrmUiHandlingData* data( NULL );
// If there is nothing in the queue return NULL
if ( !iFirst )
{
return data;
}
// Critical area start:
iSemaphore.Wait();
data = iFirst;
// Set the first and the next
iFirst = iFirst->iNext;
// reset the pointer on data
data->iNext = NULL;
// if there is no next in iFirst, this is the last or if there is no iFirst
if ( !iFirst || !iFirst->iNext )
{
iLast = iFirst;
}
// Critical Area End
iSemaphore.Signal();
return data;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::GetSilentAndCallL
// -----------------------------------------------------------------------------
//
TBool DRM::CDrmUiHandlingImpl::GetSilentAndCallL(
MDrmHandleErrorObserver* aObserver,
TInt aOperationId,
const ContentAccess::TIntent aIntent,
const HBufC8* aContentUri,
const HBufC8* aSilentUrl,
const TBool aShowNotes )
{
TInt callError( KErrNotFound );
if ( aSilentUrl )
{
GetSilentRightsL( *aSilentUrl, aShowNotes );
callError
= CheckAndMapToCallError( iOmaClient, aIntent, *aContentUri );
CallSilentRightsAvailable( aObserver, aOperationId, callError );
}
return callError == KErrNone;
}
// -----------------------------------------------------------------------------
// CDrmUiHandlingImpl::GetRightsAndCallL
// -----------------------------------------------------------------------------
//
void DRM::CDrmUiHandlingImpl::GetRightsAndCallL(
MDrmHandleErrorObserver* aObserver,
TInt aOperationId,
const ContentAccess::TIntent aIntent,
const HBufC8* aContentUri,
const HBufC* aRightsUrl )
{
TInt callError( KErrNotFound );
TBool embeddedLaunch( EFalse );
if ( aRightsUrl && LaunchBrowserL( aRightsUrl ) )
{
embeddedLaunch = ETrue;
// Browser launched in embedded mode.
// Check if rights exist now.
callError
= CheckAndMapToCallError( iOmaClient, aIntent, *aContentUri );
}
// Inform status to observer if possible
if ( embeddedLaunch || !aRightsUrl )
{
CallRightsAvailable( aObserver, aOperationId, callError );
}
}
// End of File