apicompatanamdw/bcdrivers/mw/drm/oma_drm_caf_agent_api/DRM_CAF/src/DRM_CAFBlocks.cpp
New BC drivers added are - Phonebook, Speed dial utility control, MMS Client MTM, Plugin Bio control, Organizer,
Startup List Management, Flash viewer framework, Network Status, Profile engine wrapper, Drm helper, OMA Drm CAF Agent,
SIP, Connection settings & UI, BLID, Landmarks, Send UI, Media Fetch, WebServices, Cellular services, Device services,
Graphics, Kernel and OSSrv, XML Services, Multimedia.
/*
* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: ?Description
*
*/
// [INCLUDE FILES] - do not remove
#include <e32svr.h>
#include <StifParser.h>
#include <Stiftestinterface.h>
#include "DRM_CAF.h"
#include <caf/caftypes.h>
#include <caf/caf.h>
#include <caf/data.h>
#include <f32file.h>
#include <BAUTILS.H>
#include <TestclassAssert.h>
using namespace ContentAccess;
// LOCAL CONSTANTS AND MACROS
#define NUM_ELEMENTS(x) (sizeof(x) / sizeof(x[0]))
const TInt KAttributes[] =
{
EIsProtected,
EIsForwardable,
EIsModifyable,
EIsCopyable,
ECanPlay,
ECanPrint,
ECanExecute,
ECanView,
ERightsNone,
ERightsPending,
ERightsHaveExpired,
EPreviewAvailable,
EContentCDataInUse,
ECanRewind,
ECopyPaste,
ERightsConsumable,
ERightsStateless,
ECanMove,
ECanRename,
ECanAutomaticConsume,
EFileType,
EPreviewType,
ESilentRightsType
};
const TInt KStringAttributes[] =
{
EEmbeddedRightsObject,
EDomainRightsIssuerUrl,
EDescription,
EMimeType,
ETitle,
EAuthor,
EIconURI,
EPreviewURI,
EContentURI,
EContentID,
EInfoURL,
EPendingRightsETA,
EInstantPreviewUri,
EPreviewRightsUri,
ERightsIssuerUrl,
ESilentRightsUrl,
ETransactionTrackingId,
};
// Test logging macros(we only want line numbers)
//#undef test
//#undef __test
//#define __test(x, l) test(x, l)
//#define test(x) __test(x, __LINE__)
//#define FuncCount( a ) ( sizeof( a ) / sizeof( TBatTestFunc ) )
#define RUNCHECKED(function) \
{ \
TInt c = function; \
if (c != KErrNone) \
{ \
STIF_ASSERT_TRUE(c); \
} \
else \
{ \
GLastOk = __LINE__;\
} \
}
#define RUNCHECKEDL(function) \
{ \
TInt c = function; \
if (c != KErrNone) \
{ \
STIF_ASSERT_TRUE(c); \
User::Leave(c); \
} \
else \
{ \
GLastOk = __LINE__;\
} \
}
#define RUN_TRAPPED(r, function) \
{ \
r = KErrNone; TRAP(r, function); \
STIF_ASSERT_EQUALS( KErrNone, r )\
}
//RTest test(_L("c:\\OMADRM2BC.log"));
//#if 0
//RTest test(_L("c:\\OMADRM2BC.log"));
//TInt GLastOk;
//TInt GAllocatedCount;
//TInt GAllocatedSize;
//TBool flvariant;
//#endif
_LIT8(KROSimple, "<o-ex:rights xmlns:o-ex = \"http://odrl.net/1.1/ODRL-EX\" \
xmlns:o-dd = \"http://odrl.net/1.1/ODRL-DD\" \
xmlns:ds = \"http://www.w3.org/2000/09/xmldsig#/\">\
<o-ex:context><o-dd:version>1.0</o-dd:version></o-ex:context>\
<o-ex:agreement><o-ex:asset><o-ex:context>\
<o-dd:uid>cid:9999</o-dd:uid></o-ex:context></o-ex:asset><o-ex:permission>\
<o-dd:display/><o-dd:play/><o-dd:execute/><o-dd:print/>\
</o-ex:permission></o-ex:agreement></o-ex:rights>");
_LIT8(KDRCSimple,
"\003\016\152\000\305\005\205\006\206\007\207\001\106\107\003\061\056\060\000\001\
\001\111\112\106\110\003\143\151\144\072\062\060\060\063\060\064\062\071\061\062\
\060\067\065\063\055\063\064\064\067\060\071\066\063\066\060\100\167\167\167\056\
\147\157\157\147\154\145\056\143\157\155\000\001\001\113\114\303\020\063\323\173\
\130\367\145\145\367\077\137\105\057\120\076\265\377\001\001\001\115\116\122\123\
\003\065\000\001\001\001\117\122\124\125\003\062\060\060\063\055\060\064\055\062\
\071\124\061\062\072\060\064\072\064\067\000\001\126\003\062\060\060\063\055\060\
\065\055\062\061\124\061\062\072\060\064\072\064\067\000\001\001\001\001\001\001\
\001");
_LIT8(KDMHead, "--boundary-1\r\nContent-Type: text/plain\r\n\
Content-Transfer-Encoding: 8bit\r\n\
\r\n");
_LIT8(KDMTail, "\r\n--boundary-1--");
_LIT8(KDMContent, "0123456789");
_LIT8(KDMSimple, "--boundary-1\r\nContent-Type: text/plain\r\n\
Content-Transfer-Encoding: 8bit\r\n\
\r\n\
012345678911234567892123456789312345678941234567895123456789\
612345678971234567898123456789912345678901234567891123456789\
212345678931234567894123456789512345678961234567897123456789\
812345678991234567890123456789112345678921234567893123456789\
412345678951234567896123456789712345678981234567899123456789\
\r\n--boundary-1--\r\n");
_LIT8(KDMCDCount, "--random78o6bP%[GB6b/8&/45&%*^'?vS\r\n\
Content-Type: application/vnd.oma.drm.rights+xml\r\n\
Content-Transfer-Encoding: binary\r\n\
\r\n\
<o-ex:rights\
xmlns:o-ex=\"http://odrl.net/1.1/ODRL-EX\"\
xmlns:o-dd=\"http://odrl.net/1.1/ODRL-DD\"\
xmlns:ds=\"http://www.w3.org/2000/09/xmldsig#/\"\
>\
<o-ex:context><o-dd:version>1.0</o-dd:version>\
</o-ex:context><o-ex:agreement><o-ex:asset>\
<o-ex:context><o-dd:uid>cid:20031217123451-8428794033@www.nokia.com</o-dd:uid>\
</o-ex:context></o-ex:asset>\
<o-ex:permission>\
<o-dd:display>\
<o-ex:constraint>\
<o-dd:count>3</o-dd:count>\
</o-ex:constraint>\
</o-dd:display>\
<o-dd:display>\
</o-ex:permission>\
</o-ex:agreement>\
</o-ex:rights>\r\n\
\r\n\
--random78o6bP%[GB6b/8&/45&%*^'?vS\r\n\
Content-Type: text/plain\r\n\
Content-ID: <20031217123451-8428794033@www.nokia.com>\r\n\
Content-Transfer-Encoding: binary\r\n\
\r\n\
Check:\r\n\
DbCnt: 109ms r:0\r\n\
Fixes:\r\n\
\r\n\
--random78o6bP%[GB6b/8&/45&%*^'?vS--");
_LIT(KOma1Content, "c:\\content.dcf");
_LIT(KOma2Content, "c:\\content.odf");
_LIT(KOma2ContentNoEnc, "c:\\content-noenc.odf");
_LIT(KOma2ContentNoEncTruncated, "c:\\content-noenc-trunc.odf");
_LIT(KEncryptedDir, "c:\\");
_LIT(KTempDcfName, "test.dcf");
_LIT(KTempDcfPathName, "c:\\test.dcf");
_LIT(KFVariantFile,"c:\\DrmCAFVarFile.txt");
// EXTERNAL DATA STRUCTURES
//extern ?external_data;
// EXTERNAL FUNCTION PROTOTYPES
//extern ?external_function( ?arg_type,?arg_type );
// CONSTANTS
//const ?type ?constant_var = ?constant;
// MACROS
//#define ?macro ?macro_def
// LOCAL CONSTANTS AND MACROS
//const ?type ?constant_var = ?constant;
//#define ?macro_name ?macro_def
// MODULE DATA STRUCTURES
//enum ?declaration
//typedef ?declaration
// LOCAL FUNCTION PROTOTYPES
//?type ?function_name( ?arg_type, ?arg_type );
// FORWARD DECLARATIONS
//class ?FORWARD_CLASSNAME;
// ============================= LOCAL FUNCTIONS ===============================
class CActiveWaiter : public CActive
{
public:
static CActiveWaiter* NewL();
void StartWait();
TRequestStatus& GetStatus();
~CActiveWaiter();
protected: // from CActive
/**
* part of active object framework, provide default implementation
*/
void RunL();
/**
* part of active object framework, provide default implementation
*/
void DoCancel();
/**
* part of active object framework, provide default implementation
*/
TInt RunError(TInt aError);
private:
CActiveWaiter();
void ConstructL();
CActiveSchedulerWait iWait;
};
CActiveWaiter::CActiveWaiter() : CActive(EPriorityStandard)
{
}
CActiveWaiter::~CActiveWaiter()
{
Deque();
if( iWait.IsStarted() )
{
iWait.AsyncStop();
}
}
CActiveWaiter* CActiveWaiter::NewL() {
CActiveWaiter* self = new (ELeave) CActiveWaiter();
return self;
}
/**
* part of active object framework, provide default implementation
*/
void CActiveWaiter::RunL() {
iWait.AsyncStop();
}
/**
* part of active object framework, provide default implementation
*/
void CActiveWaiter::DoCancel(){
}
/**
* part of active object framework, provide default implementation
*/
TInt CActiveWaiter::RunError(TInt /*aError*/){
return KErrNone;
}
void CActiveWaiter::StartWait() {
if(!IsAdded())
{
CActiveScheduler::Add(this);
}
if(!IsActive())
{
SetActive();
}
iStatus = KRequestPending;
iWait.Start();
}
TRequestStatus& CActiveWaiter::GetStatus()
{
return iStatus;
}
LOCAL_C CRightsManager* GetOmaDrmRightsManagerL()
{
RArray<TAgent> agents;
CRightsManager* rm = NULL;
TInt i;
TInt r;
CManager* manager = CManager::NewLC();
//STIF_ASSERT_NOT_NULL( manager );
manager->ListAgentsL(agents);
for (i = 0; rm == NULL && i < agents.Count(); i++)
{
if (agents[i].Name().Compare(KOmaDrm2AgentName) == 0)
{
TRAP(r, rm = manager->CreateRightsManagerL(agents[i]));
}
}
agents.Close();
CleanupStack::PopAndDestroy();
return rm;
}
// -----------------------------------------------------------------------------
// ?function_name ?description.
// ?description
// Returns: ?value_1: ?description
// ?value_n: ?description_line1
// ?description_line2
// -----------------------------------------------------------------------------
//
/*
?type ?function_name(
?arg_type arg, // ?description
?arg_type arg) // ?description
{
?code // ?comment
// ?comment
?code
}
*/
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CDRM_CAF::Delete
// Delete here all resources allocated and opened from test methods.
// Called from destructor.
// -----------------------------------------------------------------------------
//
void CDRM_CAF::Delete()
{
}
// -----------------------------------------------------------------------------
// CDRM_CAF::RunMethodL
// Run specified method. Contains also table of test mothods and their names.
// -----------------------------------------------------------------------------
//
TInt CDRM_CAF::RunMethodL(
CStifItemParser& aItem )
{
TStifFunctionInfo const KFunctions[] =
{
// Copy this line for every implemented function.
// First string is the function name used in TestScripter script file.
// Second is the actual implementation member function.
ENTRY( "CSupplier_Oma1XmlRoL", CDRM_CAF::CSupplier_Oma1XmlRoL ),
ENTRY( "CSupplier_Oma1WbxmlRoL", CDRM_CAF::CSupplier_Oma1WbxmlRoL ),
ENTRY( "CData_NewL", CDRM_CAF::CData_NewL ),
ENTRY( "CData_Read_DataSize_SeekL", CDRM_CAF::CData_Read_DataSize_SeekL ),
ENTRY( "CData_Read2L", CDRM_CAF::CData_Read2L ),
ENTRY( "CData_SetPropertyL", CDRM_CAF::CData_SetPropertyL ),
ENTRY( "CData_EvaluateIntentL", CDRM_CAF::CData_EvaluateIntentL ),
ENTRY( "CData_ExecuteIntentL", CDRM_CAF::CData_ExecuteIntentL ),
ENTRY( "CData_GetAttributeL", CDRM_CAF::CData_GetAttributeL ),
ENTRY( "CData_GetAttributeSetL", CDRM_CAF::CData_GetAttributeSetL ),
ENTRY( "CData_GetStringAttributeL", CDRM_CAF::CData_GetStringAttributeL ),
ENTRY( "CData_GetStringAttributeSetL", CDRM_CAF::CData_GetStringAttributeSetL ),
ENTRY( "CContent_NewL", CDRM_CAF::CContent_NewL ),
ENTRY( "CContent_OpenCloseContainerL", CDRM_CAF::CContent_OpenCloseContainerL ),
ENTRY( "CContent_GetEmbeddedObjectsL", CDRM_CAF::CContent_GetEmbeddedObjectsL ),
ENTRY( "CContent_SearchL", CDRM_CAF::CContent_SearchL ),
ENTRY( "CContent_GetAttributeL", CDRM_CAF::CContent_GetAttributeL ),
ENTRY( "CContent_GetAttributeSetL", CDRM_CAF::CContent_GetAttributeSetL ),
ENTRY( "CContent_GetStringAttributeL", CDRM_CAF::CContent_GetStringAttributeL ),
ENTRY( "CContent_GetStringAttributeSetL", CDRM_CAF::CContent_GetStringAttributeL ),
ENTRY( "CContent_AgentSpecificCommandL", CDRM_CAF::CContent_AgentSpecificCommandL ),
ENTRY( "CContent_NotifyStatusChangeL", CDRM_CAF::CContent_NotifyStatusChangeL ),
ENTRY( "CContent_CancelNotifyStatusChangeL", CDRM_CAF::CContent_CancelNotifyStatusChangeL ),
ENTRY( "CContent_RequestRightsL", CDRM_CAF::CContent_RequestRightsL ),
ENTRY( "CContent_DisplayInfoL", CDRM_CAF::CContent_DisplayInfoL ),
ENTRY( "CContent_SetPropertyL", CDRM_CAF::CContent_SetPropertyL ),
ENTRY( "CContent_OpenContentL", CDRM_CAF::CContent_OpenContentL ),
ENTRY( "CManager_FileOperationsL", CDRM_CAF::CManager_FileOperationsL ),
ENTRY( "CManager_GetAttributeL", CDRM_CAF::CManager_GetAttributeL ),
ENTRY( "CManager_GetAttributeSetL", CDRM_CAF::CManager_GetAttributeSetL ),
ENTRY( "CManager_GetStringAttributeL", CDRM_CAF::CManager_GetStringAttributeL ),
ENTRY( "CManager_GetStringAttributeSetL", CDRM_CAF::CManager_GetStringAttributeSetL ),
ENTRY( "CManager_SetPropertyL", CDRM_CAF::CManager_SetPropertyL ),
ENTRY( "CManager_DisplayInfoL", CDRM_CAF::CManager_DisplayInfoL ),
ENTRY( "CManager_ListAgentsL", CDRM_CAF::CManager_ListAgentsL ),
ENTRY( "CManager_AgentSpecificCommandL", CDRM_CAF::CManager_AgentSpecificCommandL ),
ENTRY( "CManager_CreateRightsManagerL", CDRM_CAF::CManager_CreateRightsManagerL ),
ENTRY( "CSupplier_IsImportSupportedL", CDRM_CAF::CSupplier_IsImportSupportedL ),
ENTRY( "CSupplier_PrepareHTTPRequestHeadersL", CDRM_CAF::CSupplier_PrepareHTTPRequestHeadersL ),
ENTRY( "CSupplier_SetOutputDirectory_ImportFileL", CDRM_CAF::CSupplier_SetOutputDirectory_ImportFileL ),
ENTRY( "CImportFile_WriteData_WriteDataComplete_OutputFileCountL", CDRM_CAF::CImportFile_WriteData_WriteDataComplete_OutputFileCountL ),
ENTRY( "CImportFile_OutputFileL_GetImportStatusL", CDRM_CAF::CImportFile_OutputFileL_GetImportStatusL ),
ENTRY( "CImportFile_GetSuggestedOutputFileExtensionL", CDRM_CAF::CImportFile_GetSuggestedOutputFileExtensionL ),
ENTRY( "CImportFile_GetSuggestedOutputFileNameL", CDRM_CAF::CImportFile_GetSuggestedOutputFileNameL ),
ENTRY( "CImportFile_ContinueWithNewOutputFileL", CDRM_CAF::CImportFile_ContinueWithNewOutputFileL ),
ENTRY( "CImportFile_ContentMimeTypeL", CDRM_CAF::CImportFile_ContentMimeTypeL ),
ENTRY( "CRightsManager_ListRightsL", CDRM_CAF::CRightsManager_ListRightsL ),
ENTRY( "CRightsManager_ListAllRightsL", CDRM_CAF::CRightsManager_ListAllRightsL ),
ENTRY( "CRightsManager_ListContentL", CDRM_CAF::CRightsManager_ListContentL ),
ENTRY( "CRightsManager_DeleteRightsObjectL", CDRM_CAF::CRightsManager_DeleteRightsObjectL ),
ENTRY( "CRightsManager_DeleteAllRightsObjectsL", CDRM_CAF::CRightsManager_DeleteAllRightsObjectsL ),
ENTRY( "CRightsManager_SetPropertyL", CDRM_CAF::CRightsManager_SetPropertyL ),
ENTRY( "CDRMLicenseChecker_CheckLicenseL", CDRM_CAF::CDRMLicenseChecker_CheckLicenseL ),
//ADD NEW ENTRY HERE
// [test cases entries] - Do not remove
};
const TInt count = sizeof( KFunctions ) /
sizeof( TStifFunctionInfo );
return RunInternalL( KFunctions, count, aItem );
}
TInt CDRM_CAF::CSupplier_Oma1XmlRoL()
{
CSupplier* supplier = CSupplier::NewLC();
CMetaDataArray* metaData = CMetaDataArray::NewLC();
CImportFile* file = supplier->ImportFileL(KOma1XmlRoContentType,
*metaData);
STIF_ASSERT_NOT_NULL( file );
CleanupStack::PushL(file);
RUNCHECKEDL(file->WriteData(KROSimple));
RUNCHECKEDL(file->WriteDataComplete());
CleanupStack::PopAndDestroy(3);
return KErrNone;
}
TInt CDRM_CAF::CSupplier_Oma1WbxmlRoL()
{
CSupplier* supplier = CSupplier::NewLC();
CMetaDataArray* metaData = CMetaDataArray::NewLC();
CImportFile* file = supplier->ImportFileL(KOma1WbxmlRoContentType,
*metaData);
STIF_ASSERT_NOT_NULL( file );
CleanupStack::PushL(file);
RUNCHECKEDL(file->WriteData(KDRCSimple));
RUNCHECKEDL(file->WriteDataComplete());
CleanupStack::PopAndDestroy(3);
return KErrNone;
}
TInt CDRM_CAF::CData_NewL()
{
CData* data;
RFile file;
TVirtualPathPtr dcf1(KOma1Content, KDefaultContentObject);
TVirtualPathPtr dcf2(KOma2Content, KDefaultContentObject);
TVirtualPathPtr dcf3(KOma2ContentNoEnc, KDefaultContentObject);
data = CData::NewL(dcf1, EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
delete data;
data = CData::NewL(dcf2, EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
delete data;
data = CData::NewL(dcf3, EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
delete data;
TInt err = file.Open(iFs, KOma1Content, EFileRead);
CleanupClosePushL(file);
data = CData::NewL(file, KDefaultContentObject, EPeek);
STIF_ASSERT_NOT_NULL( data );
delete data;
CleanupStack::PopAndDestroy();
err = file.Open(iFs, KOma2Content, EFileRead);
CleanupClosePushL(file);
data = CData::NewL(file, KDefaultContentObject, EPeek);
STIF_ASSERT_NOT_NULL( data );
delete data;
CleanupStack::PopAndDestroy();
err = file.Open(iFs, KOma2ContentNoEnc, EFileRead);
CleanupClosePushL(file);
data = CData::NewL(file, KDefaultContentObject, EPeek);
STIF_ASSERT_NOT_NULL( data );
delete data;
CleanupStack::PopAndDestroy();
err = file.Open(iFs, KOma2ContentNoEncTruncated, EFileRead);
CleanupClosePushL(file);
data = CData::NewL(file, KDefaultContentObject, EPeek);
STIF_ASSERT_NOT_NULL( data );
delete data;
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CData_Read_DataSize_SeekL()
{
CData* data = NULL;
TFileName fileName;
TBuf8<256> buffer;
TInt size;
TInt pos;
TInt64 size64;
TInt64 pos64;
TInt r;
fileName.Copy(KEncryptedDir);
fileName.Append(KTempDcfName);
TInt retval = KErrNone;
TRequestStatus status;
CActiveWaiter* waiter = CActiveWaiter::NewL();
CleanupStack::PushL(waiter);
TVirtualPathPtr dcf1(fileName, KDefaultContentObject);
TVirtualPathPtr dcf2(KOma2ContentNoEncTruncated, KDefaultContentObject);
TVirtualPathPtr dcf3(KOma2ContentNoEnc, KDefaultContentObject);
r=iFs.Delete(fileName);
CSupplier* supplier = CSupplier::NewLC();
CMetaDataArray* metaData = CMetaDataArray::NewLC();
supplier->SetOutputDirectoryL(KEncryptedDir);
CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType,
*metaData, KTempDcfName);
STIF_ASSERT_NOT_NULL( file );
CleanupStack::PushL(file);
RUNCHECKEDL(file->WriteData(KDMSimple));
RUNCHECKEDL(file->WriteDataComplete());
STIF_ASSERT_EQUALS( 1, file->OutputFileCountL() );
CleanupStack::PopAndDestroy(3);
data = CData::NewLC(dcf1, EView, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
data->DataSizeL(size);
STIF_ASSERT_EQUALS( 300, size );
STIF_ASSERT_EQUALS( KErrAccessDenied, data->Read(buffer, 10) ); // Cannot decrypt with SDK
CleanupStack::PopAndDestroy( data );
data = CData::NewLC(dcf2, EPlay, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
data->DataSizeL(size);
CleanupStack::PopAndDestroy( data );
data = CData::NewLC(dcf3, EPlay, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
data->DataSizeL(size);
RUNCHECKED(data->ExecuteIntent(EPlay));
RUNCHECKED(data->Read(buffer, 8));
STIF_ASSERT_EQUALS( 0, buffer.Compare(_L8("34567890")));
pos = 100;
RUNCHECKED(data->Seek(ESeekStart, pos));
data->Read(buffer, 8, status);
User::WaitForRequest(status);
STIF_ASSERT_EQUALS( 0, buffer.Compare(_L8("00000000")));
data->Read(buffer, status);
User::WaitForRequest(status);
CleanupStack::PopAndDestroy( data );
data = CData::NewLC(dcf3, EPlay, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
data->DataSize64L(size64);
RUNCHECKED(data->ExecuteIntent(EPlay));
pos64 = 100;
RUNCHECKED(data->Seek64(ESeekStart, pos64));
data->Read(pos64, buffer, 8, waiter->GetStatus());
waiter->StartWait();
STIF_ASSERT_EQUALS( 0, buffer.Compare(_L8("00000000")));
CleanupStack::PopAndDestroy( data );
CleanupStack::PopAndDestroy( waiter );
return KErrNone;
}
TInt CDRM_CAF::CData_Read2L()
{
CData* data = NULL;
TFileName fileName;
TBuf8<256> buffer;
TInt size;
TInt pos;
TInt r;
CSupplier* supplier = NULL;
CMetaDataArray* metaData = NULL;
CImportFile* file = NULL;
fileName.Copy(KEncryptedDir);
fileName.Append(KTempDcfName);
TVirtualPathPtr dcf1(fileName, KDefaultContentObject);
TVirtualPathPtr dcf2(KOma2ContentNoEncTruncated, KDefaultContentObject);
TVirtualPathPtr dcf3(KOma2ContentNoEnc, KDefaultContentObject);
r = iFs.Delete(fileName);
STIF_ASSERT_EQUALS( KErrNone, r);
supplier = CSupplier::NewLC();
metaData = CMetaDataArray::NewLC();
supplier->SetOutputDirectoryL(KEncryptedDir);
file = supplier->ImportFileL(KOma1DrmMessageContentType,
*metaData, KTempDcfName);
STIF_ASSERT_NOT_NULL( file );
CleanupStack::PushL(file);
RUNCHECKEDL(file->WriteData(KDMHead));
for (pos = 0; pos < 500; pos++)
{
file->WriteData(KDMContent);
}
RUNCHECKEDL(file->WriteData(KDMTail));
RUNCHECKEDL(file->WriteDataComplete());
STIF_ASSERT_EQUALS( 1, file->OutputFileCountL());
CleanupStack::PopAndDestroy(3);
data = CData::NewLC(dcf1, EView, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
data->DataSizeL(size);
STIF_ASSERT_EQUALS( 5000, size);
STIF_ASSERT_EQUALS( KErrAccessDenied, data->ExecuteIntent(EView) ); // Cannot decrypt with SDK
CleanupStack::PopAndDestroy(); // data
data = CData::NewLC(dcf1, EView, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
data->DataSizeL(size);
STIF_ASSERT_EQUALS( 5000, size);
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CData_SetPropertyL()
{
CData* data;
TInt r;
TBool r1 = EFalse;
TVirtualPathPtr dcf2(KOma2Content, KDefaultContentObject);
data = CData::NewLC(dcf2, EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
r = data->SetProperty(EAgentPropertyBufferSize, 1024);
if(r == KErrCANotSupported || r == KErrNone)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
r1 = EFalse;
r = data->SetProperty(EAgentPropertyAgentUI, 1);
if(r == KErrCANotSupported || r == KErrNone)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
r1 = EFalse;
r = data->SetProperty(EAgentPropertyMultipleSequence, 1);
if(r == KErrCANotSupported || r == KErrNone)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CData_EvaluateIntentL()
{
TFileName fileName;
TInt r;
TBool r1 = EFalse;
TInt i;
fileName.Copy(KFVariantFile);
// Clearing file before first testcase
iFs.Delete(fileName);
fileName.Copy(KEncryptedDir);
fileName.Append(KTempDcfName);
r = iFs.Delete(fileName);
STIF_ASSERT_EQUALS( KErrNone, r);
CSupplier* supplier = CSupplier::NewLC();
CMetaDataArray* metaData = CMetaDataArray::NewLC();
supplier->SetOutputDirectoryL(KEncryptedDir);
CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType,
*metaData, KTempDcfName);
STIF_ASSERT_NOT_NULL( file );
CleanupStack::PushL(file);
r = file->WriteData(KDMCDCount);
if (r == KErrNotSupported)
{
// Forward lock variant
RFileWriteStream outFlV;
outFlV.Create(iFs, KFVariantFile, EFileWrite );
outFlV.Close();
CleanupStack::PopAndDestroy(3);
return KErrNone;
}
RUNCHECKEDL(file->WriteDataComplete());
STIF_ASSERT_EQUALS( 1, file->OutputFileCountL());
CleanupStack::PopAndDestroy(3);
TVirtualPathPtr dcf(fileName, KDefaultContentObject);
CData* data = CData::NewLC(dcf, EView, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
r = data->EvaluateIntent(EView);
STIF_ASSERT_EQUALS( KErrNone, r);
r = data->EvaluateIntent(EPause);
STIF_ASSERT_EQUALS( KErrNone, r);
r = data->EvaluateIntent(EContinue);
STIF_ASSERT_EQUALS( KErrNone, r);
r = data->EvaluateIntent(EStop);
STIF_ASSERT_EQUALS( KErrNone, r);
r = data->EvaluateIntent(EPeek);
STIF_ASSERT_EQUALS( KErrNone, r);
r = data->EvaluateIntent(EInstall);
STIF_ASSERT_EQUALS( KErrNone, r);
r = data->EvaluateIntent(EPlay);
STIF_ASSERT_EQUALS( KErrCANoPermission, r);
r = data->EvaluateIntent(EPrint);
STIF_ASSERT_EQUALS( KErrCANoPermission, r);
r = data->EvaluateIntent(EExecute);
STIF_ASSERT_EQUALS( KErrCANoPermission, r);
CleanupStack::PopAndDestroy();
data = CData::NewL(TVirtualPathPtr(KOma2ContentNoEnc, KDefaultContentObject),
EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
STIF_ASSERT_EQUALS( KErrNone, data->EvaluateIntent(EPlay));
STIF_ASSERT_NOT_EQUALS(KErrNone ,data->EvaluateIntent(EView) );
STIF_ASSERT_NOT_EQUALS(KErrNone ,data->EvaluateIntent(EPrint) );
STIF_ASSERT_NOT_EQUALS(KErrNone ,data->EvaluateIntent(EExecute) );
STIF_ASSERT_EQUALS(KErrNone ,data->EvaluateIntent(EPause) );
STIF_ASSERT_EQUALS(KErrNone ,data->EvaluateIntent(EStop) );
STIF_ASSERT_EQUALS(KErrNone ,data->EvaluateIntent(EContinue) );
delete data;
fileName.Copy(KEncryptedDir);
fileName.Append(KTempDcfName);
r = iFs.Delete(fileName);
STIF_ASSERT_EQUALS(KErrNone ,r);
supplier = CSupplier::NewLC();
metaData = CMetaDataArray::NewLC();
metaData->AddL(KOmaImportMimeTypeField, _L8("image/jpeg"));
supplier->SetOutputDirectoryL(KEncryptedDir);
file = supplier->ImportFileL(KOmaImportContentType, *metaData, KTempDcfName);
STIF_ASSERT_NOT_NULL( file );
CleanupStack::PushL(file);
for (i = 0; i < 10; i++)
{
RUNCHECKEDL(file->WriteData(KDMContent));
}
RUNCHECKEDL(file->WriteDataComplete());
STIF_ASSERT_EQUALS(1 ,file->OutputFileCountL());
CleanupStack::PopAndDestroy(3);
data = CData::NewL(TVirtualPathPtr(fileName, KDefaultContentObject),
EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
r = data->EvaluateIntent(EPlay);
iLog->Log(_L(" Evaluate intent returned: %d \r\n"), r);
STIF_ASSERT_NOT_EQUALS(KErrNone , r);
r = data->EvaluateIntent(EView);
iLog->Log(_L(" Evaluate intent returned: %d \r\n"), r);
if(r == -17452 || r == -17451 || r == 0)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
r1 = EFalse;
r = data->EvaluateIntent(EPrint);
iLog->Log(_L(" Evaluate intent returned: %d \r\n"), r);
if(r == -17452 || r == -17451 || r == 0)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
r = data->EvaluateIntent(EExecute);
iLog->Log(_L(" Evaluate intent returned: %d \r\n"), r);
STIF_ASSERT_NOT_EQUALS(KErrNone , r);
delete data;
fileName.Copy(KEncryptedDir );
fileName.Append(KTempDcfName);
r = iFs.Delete(fileName);
STIF_ASSERT_EQUALS(KErrNone , r);
supplier = CSupplier::NewLC();
metaData = CMetaDataArray::NewLC();
metaData->AddL(KOmaImportMimeTypeField, _L8("audio/mpeg"));
supplier->SetOutputDirectoryL(KEncryptedDir);
file = supplier->ImportFileL(KOmaImportContentType, *metaData, KTempDcfName);
STIF_ASSERT_NOT_NULL( file );
CleanupStack::PushL(file);
for (i = 0; i < 10; i++)
{
RUNCHECKEDL(file->WriteData(KDMContent));
}
RUNCHECKEDL(file->WriteDataComplete());
STIF_ASSERT_EQUALS(1 , file->OutputFileCountL());
CleanupStack::PopAndDestroy(3);
data = CData::NewL(TVirtualPathPtr(fileName, KDefaultContentObject),
EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
r1 = EFalse;
r = data->EvaluateIntent(EPlay);
iLog->Log(_L(" Evaluate intent returned: %d \r\n"), r);
if(r == -17452 || r == -17451 || r == 0)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
STIF_ASSERT_NOT_EQUALS(KErrNone , data->EvaluateIntent(EView));
STIF_ASSERT_NOT_EQUALS(KErrNone , data->EvaluateIntent(EPrint));
STIF_ASSERT_NOT_EQUALS(KErrNone , data->EvaluateIntent(EExecute));
delete data;
return KErrNone;
}
TInt CDRM_CAF::CData_ExecuteIntentL()
{
RFile fileFLV;
TInt err = fileFLV.Open(iFs,KFVariantFile, EFileRead);
if( err == 0 )
{
iLog->Log(_L(" Skipped in FL variant \r\n" ));
fileFLV.Close();
return KErrNone;
}
fileFLV.Close();
TFileName fileName;
TInt r;
TInt i;
TBool r1 = EFalse;
fileName.Copy(KEncryptedDir);
fileName.Append(KTempDcfName);
r = iFs.Delete(fileName);
STIF_ASSERT_EQUALS(KErrNone , r);
CSupplier* supplier = CSupplier::NewLC();
CMetaDataArray* metaData = CMetaDataArray::NewLC();
supplier->SetOutputDirectoryL(KEncryptedDir);
CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType,
*metaData, KTempDcfName);
STIF_ASSERT_NOT_NULL( file );
CleanupStack::PushL(file);
RUNCHECKEDL(file->WriteData(KDMCDCount));
RUNCHECKEDL(file->WriteDataComplete());
STIF_ASSERT_EQUALS(1 , file->OutputFileCountL());
CleanupStack::PopAndDestroy(3);
// Start the tests
TVirtualPathPtr dcf(fileName, KDefaultContentObject);
CData* data = CData::NewLC(dcf, EView, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
// illegal: let's start with EPause
r = data->ExecuteIntent(EPause);
iLog->Log(_L(" Execute intent returned: %d \r\n"), r);
STIF_ASSERT_EQUALS( KErrNotReady, r );
r = data->ExecuteIntent(EContinue);
iLog->Log(_L(" Execute intent returned: %d \r\n"), r);
STIF_ASSERT_EQUALS( KErrNotReady, r );
r = data->ExecuteIntent(EView);
iLog->Log(_L(" Execute intent returned: %d \r\n"), r);
STIF_ASSERT_EQUALS( KErrAccessDenied , r );
r = data->ExecuteIntent(EPause);
iLog->Log(_L(" Execute intent returned: %d \r\n"), r);
STIF_ASSERT_EQUALS( KErrNotReady , r);
r = data->ExecuteIntent(EContinue);
iLog->Log(_L(" Execute intent returned: %d \r\n"), r);
STIF_ASSERT_EQUALS( KErrNotReady, r);
r = data->ExecuteIntent(EStop);
iLog->Log(_L(" Execute intent returned: %d \r\n"), r);
STIF_ASSERT_EQUALS( KErrNone, r);
r = data->ExecuteIntent(EPeek);
iLog->Log(_L(" Execute intent returned: %d \r\n"), r);
STIF_ASSERT_EQUALS( KErrAccessDenied, r);
r = data->ExecuteIntent(EInstall);
iLog->Log(_L(" Execute intent returned: %d \r\n"), r);
STIF_ASSERT_EQUALS( KErrAccessDenied, r);
r = data->ExecuteIntent(EPlay);
iLog->Log(_L(" Execute intent returned: %d \r\n"), r);
STIF_ASSERT_EQUALS( KErrCANoPermission, r);
r = data->ExecuteIntent(EPrint);
iLog->Log(_L(" Execute intent returned: %d \r\n"), r);
STIF_ASSERT_EQUALS( KErrCANoPermission, r);
r = data->ExecuteIntent(EExecute);
iLog->Log(_L(" Execute intent returned: %d \r\n"), r);
STIF_ASSERT_EQUALS( KErrCANoPermission, r);
r = data->ExecuteIntent(EView);
iLog->Log(_L(" Execute intent returned: %d \r\n"), r);
STIF_ASSERT_EQUALS( KErrAccessDenied, r);
CleanupStack::PopAndDestroy();
data = CData::NewL(TVirtualPathPtr(KOma2ContentNoEnc, KDefaultContentObject),
EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
STIF_ASSERT_EQUALS(KErrNone ,data->ExecuteIntent(EPlay) );
STIF_ASSERT_NOT_EQUALS(KErrNone ,data->ExecuteIntent(EView) );
STIF_ASSERT_NOT_EQUALS(KErrNone ,data->ExecuteIntent(EPrint) );
STIF_ASSERT_NOT_EQUALS(KErrNone ,data->ExecuteIntent(EExecute) );
STIF_ASSERT_EQUALS(KErrNone ,data->ExecuteIntent(EPause) );
STIF_ASSERT_EQUALS(KErrNone ,data->ExecuteIntent(EStop) );
STIF_ASSERT_EQUALS(KErrNone ,data->ExecuteIntent(EContinue) );
delete data;
fileName.Copy(KEncryptedDir);
fileName.Append(KTempDcfName);
r = iFs.Delete(fileName);
STIF_ASSERT_EQUALS(KErrNone ,r );
supplier = CSupplier::NewLC();
metaData = CMetaDataArray::NewLC();
metaData->AddL(KOmaImportMimeTypeField, _L8("image/jpeg"));
supplier->SetOutputDirectoryL(KEncryptedDir);
file = supplier->ImportFileL(KOmaImportContentType, *metaData, KTempDcfName);
STIF_ASSERT_NOT_NULL( file );
CleanupStack::PushL(file);
for (i = 0; i < 10; i++)
{
RUNCHECKEDL(file->WriteData(KDMContent));
}
RUNCHECKEDL(file->WriteDataComplete());
STIF_ASSERT_EQUALS(1 ,file->OutputFileCountL() );
CleanupStack::PopAndDestroy(3);
data = CData::NewL(TVirtualPathPtr(fileName, KDefaultContentObject),
EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
STIF_ASSERT_NOT_EQUALS( KErrNone, data->ExecuteIntent(EPlay));
r = data->ExecuteIntent(EView);
iLog->Log(_L(" Execute intent returned: %d \r\n"), r);
if(r == -17452 || r == -17451 || r == -21 )
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
r1 = EFalse;
r = data->ExecuteIntent(EPrint);
iLog->Log(_L(" Execute intent returned: %d \r\n"), r);
if(r == -17452 || r == -17451 || r == -21 )
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
STIF_ASSERT_NOT_EQUALS( KErrNone, data->ExecuteIntent(EExecute));
delete data;
fileName.Copy(KEncryptedDir);
fileName.Append(KTempDcfName);
r = iFs.Delete(fileName);
STIF_ASSERT_EQUALS( KErrNone, r);
supplier = CSupplier::NewLC();
metaData = CMetaDataArray::NewLC();
metaData->AddL(KOmaImportMimeTypeField, _L8("audio/mpeg"));
supplier->SetOutputDirectoryL(KEncryptedDir);
file = supplier->ImportFileL(KOmaImportContentType, *metaData, KTempDcfName);
STIF_ASSERT_NOT_NULL( file );
CleanupStack::PushL(file);
for (i = 0; i < 10; i++)
{
RUNCHECKEDL(file->WriteData(KDMContent));
}
RUNCHECKEDL(file->WriteDataComplete());
STIF_ASSERT_EQUALS( 1, file->OutputFileCountL());
CleanupStack::PopAndDestroy(3);
data = CData::NewL(TVirtualPathPtr(fileName, KDefaultContentObject),
EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
r1 = EFalse;
r = data->ExecuteIntent(EPlay);
iLog->Log(_L(" Execute intent returned: %d \r\n"), r);
if(r == -17452 || r == -17451 || r == -21 )
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
STIF_ASSERT_NOT_EQUALS( KErrNone, data->ExecuteIntent(EView));
STIF_ASSERT_NOT_EQUALS( KErrNone, data->ExecuteIntent(EPrint));
STIF_ASSERT_NOT_EQUALS( KErrNone, data->ExecuteIntent(EExecute));
delete data;
return KErrNone;
}
TInt CDRM_CAF::CData_GetAttributeL()
{
CData* data = NULL;
TVirtualPathPtr dcf1(KOma1Content, KDefaultContentObject);
TVirtualPathPtr dcf2(KOma2Content, KDefaultContentObject);
TVirtualPathPtr dcf3(KOma2ContentNoEnc, KDefaultContentObject);
TInt value;
TInt i;
data = CData::NewLC(dcf1, EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
RUNCHECKEDL(data->GetAttribute(EIsProtected, value));
STIF_ASSERT_EQUALS( 1, value);
RUNCHECKEDL(data->GetAttribute(EFileType, value));
STIF_ASSERT_EQUALS( 1, value);
for (i = 0; i < NUM_ELEMENTS(KAttributes); i++)
{
data->GetAttribute(KAttributes[i], value);
}
CleanupStack::PopAndDestroy();
data = CData::NewLC(dcf2, EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
RUNCHECKEDL(data->GetAttribute(EIsProtected, value));
STIF_ASSERT_EQUALS( 1, value);
RUNCHECKEDL(data->GetAttribute(EFileType, value));
STIF_ASSERT_EQUALS( 2, value);
for (i = 0; i < NUM_ELEMENTS(KAttributes); i++)
{
data->GetAttribute(KAttributes[i], value);
}
CleanupStack::PopAndDestroy();
data = CData::NewLC(dcf3, EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
RUNCHECKEDL(data->GetAttribute(EIsProtected, value));
STIF_ASSERT_EQUALS( 0, value);
RUNCHECKEDL(data->GetAttribute(EFileType, value));
STIF_ASSERT_EQUALS( 2, value);
for (i = 0; i < NUM_ELEMENTS(KAttributes); i++)
{
data->GetAttribute(KAttributes[i], value);
}
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CData_GetAttributeSetL()
{
CData* data = NULL;
TVirtualPathPtr dcf1(KOma1Content, KDefaultContentObject);
TVirtualPathPtr dcf2(KOma2Content, KDefaultContentObject);
RAttributeSet attributes;
TInt value;
attributes.AddL(EIsProtected);
attributes.AddL(EFileType);
data = CData::NewLC(dcf1, EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
RUNCHECKEDL(data->GetAttributeSet(attributes));
RUNCHECKEDL(attributes.GetValue(EIsProtected, value));
STIF_ASSERT_EQUALS( 1, value);
RUNCHECKED(attributes.GetValue(EFileType, value));
STIF_ASSERT_EQUALS( 1, value);
CleanupStack::PopAndDestroy();
data = CData::NewLC(dcf2, EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
RUNCHECKEDL(data->GetAttributeSet(attributes));
RUNCHECKEDL(attributes.GetValue(EIsProtected, value));
STIF_ASSERT_EQUALS( 1, value);
RUNCHECKED(attributes.GetValue(EFileType, value));
STIF_ASSERT_EQUALS( 2, value);
CleanupStack::PopAndDestroy();
attributes.Close();
return KErrNone;
}
TInt CDRM_CAF::CData_GetStringAttributeL()
{
TVirtualPathPtr dcf1(KOma1Content, KDefaultContentObject);
TVirtualPathPtr dcf2(KOma2Content, KDefaultContentObject);
TVirtualPathPtr dcf3(KOma2Content, KDefaultContentObject);
CData* data = NULL;
HBufC* buffer = HBufC::NewLC(256000);
TPtr value(NULL, 0);
TInt i;
value.Set(buffer->Des());
data = CData::NewLC(dcf1, EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
RUNCHECKEDL(data->GetStringAttribute(EMimeType, value));
STIF_ASSERT_EQUALS( 0, value.Compare(_L("text/plain")));
for (i = 0; i < NUM_ELEMENTS(KStringAttributes); i++)
{
data->GetStringAttribute(KStringAttributes[i], value);
}
CleanupStack::PopAndDestroy();
data = CData::NewLC(dcf2, EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
RUNCHECKEDL(data->GetStringAttribute(EMimeType, value));
STIF_ASSERT_EQUALS( 0, value.Compare(_L("audio/wav")));
for (i = 0; i < NUM_ELEMENTS(KStringAttributes); i++)
{
data->GetStringAttribute(KStringAttributes[i], value);
}
CleanupStack::PopAndDestroy();
data = CData::NewLC(dcf3, EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
RUNCHECKEDL(data->GetStringAttribute(EMimeType, value));
STIF_ASSERT_EQUALS( 0, value.Compare(_L("audio/wav")));
for (i = 0; i < NUM_ELEMENTS(KStringAttributes); i++)
{
data->GetStringAttribute(KStringAttributes[i], value);
}
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CData_GetStringAttributeSetL()
{
RFile fileFLV;
TInt err = fileFLV.Open(iFs,KFVariantFile, EFileRead);
if( err == 0 )
{
iLog->Log(_L(" Skipped in FL variant \r\n" ));
fileFLV.Close();
return KErrNone;
}
fileFLV.Close();
TVirtualPathPtr dcf1(KOma1Content, KDefaultContentObject);
TVirtualPathPtr dcf2(KOma2Content, KDefaultContentObject);
CData* data = NULL;
RStringAttributeSet attributes;
HBufC* buffer = HBufC::NewLC(256000);
TPtr value(NULL, 0);
TBool r1 = EFalse;
value.Set(buffer->Des());
attributes.AddL(EMimeType);
attributes.AddL(ERightsIssuerUrl);
data = CData::NewLC(dcf1, EPeek, EContentShareReadOnly);
//CHECKL(data != NULL);
STIF_ASSERT_NOT_NULL( data );
RUNCHECKEDL(data->GetStringAttributeSet(attributes));
RUNCHECKEDL(attributes.GetValue(EMimeType, value));
STIF_ASSERT_EQUALS(0 , value.Compare(_L("text/plain")));
STIF_ASSERT_EQUALS(KErrCANotSupported , attributes.GetValue(ERightsIssuerUrl, value));
CleanupStack::PopAndDestroy();
data = CData::NewLC(dcf2, EPeek, EContentShareReadOnly);
STIF_ASSERT_NOT_NULL( data );
RUNCHECKEDL(data->GetStringAttributeSet(attributes));
RUNCHECKEDL(attributes.GetValue(EMimeType, value));
STIF_ASSERT_EQUALS( 0, value.Compare(_L("audio/wav")));
TInt rr = attributes.GetValue(ERightsIssuerUrl, value);
if(rr == KErrCANotSupported || rr == KErrNone)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
r1 = EFalse;
if(value.Length() > 0)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
attributes.Close();
return KErrNone;
}
TInt CDRM_CAF::CContent_NewL()
{
CContent* content = NULL;
RFile file;
content = CContent::NewL(KOma1Content);
STIF_ASSERT_NOT_NULL( content );
delete content;
content = CContent::NewL(KOma2Content);
STIF_ASSERT_NOT_NULL( content );
delete content;
content = CContent::NewL(KOma2ContentNoEnc);
STIF_ASSERT_NOT_NULL( content );
delete content;
TInt err = file.Open(iFs, KOma1Content, EFileRead);
CleanupClosePushL(file);
content = CContent::NewL(file);
STIF_ASSERT_NOT_NULL( content );
delete content;
CleanupStack::PopAndDestroy();
err = file.Open(iFs, KOma2Content, EFileRead);
CleanupClosePushL(file);
content = CContent::NewL(file);
STIF_ASSERT_NOT_NULL( content );
delete content;
CleanupStack::PopAndDestroy();
err = file.Open(iFs, KOma2ContentNoEnc, EFileRead);
err = err;
CleanupClosePushL(file);
content = CContent::NewL(file);
STIF_ASSERT_NOT_NULL( content );
delete content;
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CContent_OpenCloseContainerL()
{
CContent* content = NULL;
TInt r;
content = CContent::NewLC(KOma1Content);
STIF_ASSERT_NOT_NULL( content );
RUNCHECKED(content->OpenContainer(KDefaultContentObject));
RUNCHECKED(content->CloseContainer());
RUNCHECKED(content->OpenContainer(KDefaultContentObject));
r = content->OpenContainer(KDefaultContentObject);
STIF_ASSERT_EQUALS( KErrNotFound, r);
RUNCHECKED(content->CloseContainer());
r = content->OpenContainer(_L("xyz"));
STIF_ASSERT_EQUALS( KErrNotFound, r);
r = content->CloseContainer();
STIF_ASSERT_EQUALS( KErrNotFound, r);
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CContent_GetEmbeddedObjectsL()
{
CContent* content = NULL;
RStreamablePtrArray<CEmbeddedObject> objects;
TInt i;
CEmbeddedObject* item = NULL;
content = CContent::NewLC(KOma1Content);
STIF_ASSERT_NOT_NULL( content );
content->GetEmbeddedObjectsL(objects);
STIF_ASSERT_EQUALS( 1, objects.Count());
for (i = 0; i < objects.Count(); i++)
{
item = objects[i];
}
objects.ResetAndDestroy();
content->GetEmbeddedObjectsL(objects, EContainerObject);
STIF_ASSERT_EQUALS( 0, objects.Count());
content->GetEmbeddedObjectsL(objects, EAgentSpecificObject);
STIF_ASSERT_EQUALS( 0, objects.Count());
content->GetEmbeddedObjectsL(objects, EContentObject);
STIF_ASSERT_EQUALS( 1, objects.Count());
objects.ResetAndDestroy();
objects.Close();
CleanupStack::PopAndDestroy();
content = CContent::NewLC(KOma2Content);
STIF_ASSERT_NOT_NULL( content );
content->GetEmbeddedObjectsL(objects);
STIF_ASSERT_EQUALS( 1, objects.Count());
for (i = 0; i < objects.Count(); i++)
{
item = objects[i];
}
objects.ResetAndDestroy();
content->GetEmbeddedObjectsL(objects, EContainerObject);
STIF_ASSERT_EQUALS( 0, objects.Count());
content->GetEmbeddedObjectsL(objects, EAgentSpecificObject);
STIF_ASSERT_EQUALS( 0, objects.Count());
content->GetEmbeddedObjectsL(objects, EContentObject);
STIF_ASSERT_EQUALS( 1, objects.Count());
objects.ResetAndDestroy();
objects.Close();
RUNCHECKEDL(content->OpenContainer(KDefaultContentObject))
content->GetEmbeddedObjectsL(objects, EContentObject);
STIF_ASSERT_EQUALS( 0, objects.Count());
objects.Close();
RUNCHECKED(content->CloseContainer())
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CContent_SearchL()
{
CContent* content = NULL;
RStreamablePtrArray<CEmbeddedObject> objects;
content = CContent::NewLC(KOma1Content);
STIF_ASSERT_NOT_NULL( content );
RUNCHECKEDL(content->Search(objects, _L8("text/plain"), EFalse));
STIF_ASSERT_EQUALS( 1, objects.Count());
objects.ResetAndDestroy();
RUNCHECKEDL(content->Search(objects, _L8("audio/wav"), EFalse));
STIF_ASSERT_EQUALS( 0, objects.Count());
objects.ResetAndDestroy();
objects.Close();
CleanupStack::PopAndDestroy();
content = CContent::NewLC(KOma2Content);
STIF_ASSERT_NOT_NULL( content );
RUNCHECKEDL(content->Search(objects, _L8("text/plain"), EFalse));
STIF_ASSERT_EQUALS( 0, objects.Count());
objects.ResetAndDestroy();
RUNCHECKEDL(content->Search(objects, _L8("audio/wav"), EFalse));
STIF_ASSERT_EQUALS( 1, objects.Count());
objects.ResetAndDestroy();
objects.Close();
RUNCHECKEDL(content->OpenContainer(KDefaultContentObject))
RUNCHECKEDL(content->Search(objects, _L8("text/plain"), EFalse));
STIF_ASSERT_EQUALS( 0, objects.Count());
objects.Close();
RUNCHECKED(content->CloseContainer());
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CContent_GetAttributeL()
{
CContent* content = NULL;
TInt value;
TInt i;
TInt re;
TBool r1 = EFalse;
content = CContent::NewLC(KOma1Content);
STIF_ASSERT_NOT_NULL( content );
RUNCHECKEDL(content->GetAttribute(EIsProtected, value));
STIF_ASSERT_EQUALS( 1, value);
RUNCHECKEDL(content->GetAttribute(EFileType, value));
STIF_ASSERT_EQUALS( 1, value);
re = content->GetAttribute(ECanPlay, value);
if(re == KErrCANotSupported || re == KErrNone)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
r1 = EFalse;
re = content->GetAttribute(ECanPlay, value);
if(re == KErrCANotSupported || re == KErrNone)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
r1 = EFalse;
re = content->GetAttribute(ECanView, value);
if(re == KErrCANotSupported || re == KErrNone)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
r1 = EFalse;
re = content->GetAttribute(ECanExecute, value);
if(re == KErrCANotSupported || re == KErrNone)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
r1 = EFalse;
re = content->GetAttribute(ECanPrint, value);
if(re == KErrCANotSupported || re == KErrNone)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
for (i = 0; i < NUM_ELEMENTS(KAttributes); i++)
{
content->GetAttribute(KAttributes[i], value);
}
STIF_ASSERT_NOT_EQUALS( KErrNone, content->GetAttribute(EIsProtected, value, _L("xyz")));
CleanupStack::PopAndDestroy();
content = CContent::NewLC(KOma2Content);
STIF_ASSERT_NOT_NULL( content );
RUNCHECKEDL(content->GetAttribute(EIsProtected, value));
STIF_ASSERT_EQUALS( 1, value);
RUNCHECKEDL(content->GetAttribute(EFileType, value));
STIF_ASSERT_EQUALS( 2, value);
for (i = 0; i < NUM_ELEMENTS(KAttributes); i++)
{
content->GetAttribute(KAttributes[i], value);
}
STIF_ASSERT_NOT_EQUALS( KErrNone, content->GetAttribute(EIsProtected, value, _L("xyz")));
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CContent_GetAttributeSetL()
{
CContent* content = NULL;
RAttributeSet attributes;
TInt value;
attributes.AddL(EIsProtected);
attributes.AddL(EFileType);
content = CContent::NewLC(KOma1Content);
STIF_ASSERT_NOT_NULL( content );
RUNCHECKEDL(content->GetAttributeSet(attributes));
RUNCHECKEDL(attributes.GetValue(EIsProtected, value));
STIF_ASSERT_EQUALS( 1, value);
RUNCHECKED(attributes.GetValue(EFileType, value));
STIF_ASSERT_EQUALS( 1, value);
CleanupStack::PopAndDestroy();
content = CContent::NewLC(KOma2Content);
STIF_ASSERT_NOT_NULL( content );
RUNCHECKEDL(content->GetAttributeSet(attributes));
RUNCHECKEDL(attributes.GetValue(EIsProtected, value));
STIF_ASSERT_EQUALS( 1, value);
RUNCHECKED(attributes.GetValue(EFileType, value));
STIF_ASSERT_EQUALS( 2, value);
CleanupStack::PopAndDestroy();
attributes.Close();
return KErrNone;
}
TInt CDRM_CAF::CContent_GetStringAttributeL()
{
CContent* content = NULL;
RStreamablePtrArray<CEmbeddedObject> objects;
HBufC* buffer = HBufC::NewLC(256000);
TPtr value(NULL, 0);
TInt i;
value.Set(buffer->Des());
content = CContent::NewLC(KOma1Content);
STIF_ASSERT_NOT_NULL( content );
RUNCHECKEDL(content->GetStringAttribute(EMimeType, value));
STIF_ASSERT_EQUALS( 0, value.Compare(_L("text/plain")));
for (i = 0; i < NUM_ELEMENTS(KStringAttributes); i++)
{
content->GetStringAttribute(KStringAttributes[i], value);
}
STIF_ASSERT_NOT_EQUALS(KErrNone, content->GetStringAttribute(EMimeType, value, _L("xyz")));
CleanupStack::PopAndDestroy();
content = CContent::NewLC(KOma2Content);
STIF_ASSERT_NOT_NULL( content );
RUNCHECKEDL(content->Search(objects, _L8("audio/wav"), EFalse));
STIF_ASSERT_EQUALS( 1, objects.Count());
RUNCHECKEDL(content->GetStringAttribute(EMimeType, value,
objects[0]->UniqueId()));
STIF_ASSERT_EQUALS( 0, value.Compare(_L("audio/wav")));
objects.ResetAndDestroy();
objects.Close();
for (i = 0; i < NUM_ELEMENTS(KStringAttributes); i++)
{
content->GetStringAttribute(KStringAttributes[i], value);
}
STIF_ASSERT_NOT_EQUALS( KErrNone,content->GetStringAttribute(EMimeType, value, _L("xyz")));
CleanupStack::PopAndDestroy();
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CContent_GetStringAttributeSetL()
{
RFile fileFLV;
TInt err = fileFLV.Open(iFs,KFVariantFile, EFileRead);
if( err == 0 )
{
iLog->Log(_L(" Skipped in FL variant \r\n" ));
fileFLV.Close();
TFileName fileFlVariant;
fileFlVariant.Copy(KFVariantFile);
// Clearing file after use
iFs.Delete(fileFlVariant);
return KErrNone;
}
fileFLV.Close();
CContent* content = NULL;
RStringAttributeSet attributes;
HBufC* buffer = HBufC::NewLC(256000);
TPtr value(NULL, 0);
TInt re;
TBool r1 = EFalse;
value.Set(buffer->Des());
attributes.AddL(EMimeType);
attributes.AddL(ERightsIssuerUrl);
content = CContent::NewLC(KOma1Content);
STIF_ASSERT_NOT_NULL( content );
RUNCHECKEDL(content->GetStringAttributeSet(attributes));
RUNCHECKEDL(attributes.GetValue(EMimeType, value));
STIF_ASSERT_EQUALS( 0,value.Compare(_L("text/plain")));
re = attributes.GetValue(ERightsIssuerUrl, value);
if(re == KErrCANotSupported || re == KErrNone)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
CleanupStack::PopAndDestroy();
content = CContent::NewLC(KOma2Content);
STIF_ASSERT_NOT_NULL( content );
RUNCHECKEDL(content->GetStringAttributeSet(attributes));
RUNCHECKEDL(attributes.GetValue(EMimeType, value));
STIF_ASSERT_EQUALS( 0,value.Compare(_L("audio/wav")));
RUNCHECKED(attributes.GetValue(ERightsIssuerUrl, value));
if(value.Length() > 0)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
CleanupStack::PopAndDestroy();
attributes.Close();
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CContent_AgentSpecificCommandL()
{
CContent* content = NULL;
TPtr8 ptr(NULL, 0, 0);
TRequestStatus status;
content = CContent::NewLC(KOma2Content);
STIF_ASSERT_NOT_NULL( content );
RUNCHECKED(content->AgentSpecificCommand(EEmbedDomainRo, KNullDesC8, ptr));
content->AgentSpecificCommand(EEmbedDomainRo, KNullDesC8, ptr, status);
User::WaitForRequest(status);
CleanupStack::PopAndDestroy();
content = CContent::NewLC(KOma1Content);
STIF_ASSERT_NOT_NULL( content );
STIF_ASSERT_EQUALS( KErrArgument,content->AgentSpecificCommand(EEmbedDomainRo, KNullDesC8, ptr));
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CContent_NotifyStatusChangeL()
{
_LIT(KSdkVersion31,"Z:\\System\\install\\Series60v3.1.sis");
_LIT(KSdkVersion50,"Z:\\System\\install\\Series60v5.0.sis");
RFs fs;
TBool found = EFalse;
User::LeaveIfError(fs.Connect ());
CleanupClosePushL (fs);
if(BaflUtils::FileExists (fs, KSdkVersion31))
{
found = ETrue;
}
else if(BaflUtils::FileExists (fs, KSdkVersion50))
{
found = ETrue;
}
CContent* content = NULL;
TRequestStatus status = KRequestPending;
TInt r;
content = CContent::NewLC(KOma2Content);
STIF_ASSERT_NOT_NULL(content);
content->NotifyStatusChange(ERightsAvailable, status);//ERightsAvailable
if(found)
{
User::After(10000);
content->CancelNotifyStatusChange(status);
User::WaitForRequest(status);
}
else
{
User::WaitForRequest(status);
}
CleanupStack::PopAndDestroy(2);
return KErrNone;
}
TInt CDRM_CAF::CContent_CancelNotifyStatusChangeL()
{
CContent* content = NULL;
TRequestStatus status;
TInt r;
content = CContent::NewLC(KOma2Content);
STIF_ASSERT_NOT_NULL(content);
content->CancelNotifyStatusChange(status);
User::WaitForRequest(status);
//r = status;
//STIF_ASSERT_EQUALS( KErrCANotSupported,r);
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CContent_RequestRightsL()
{
CContent* content = NULL;
TRequestStatus status;
TInt r;
content = CContent::NewLC(KOma2Content);
STIF_ASSERT_NOT_NULL(content);
content->RequestRights(status);
User::WaitForRequest(status);
//r = status;
#ifdef __SERIES60_
//STIF_ASSERT_EQUALS( KErrNone,r);
#else
//STIF_ASSERT_EQUALS( KErrCANotSupported,r);
#endif
CleanupStack::PopAndDestroy(content);
return KErrNone;
}
TInt CDRM_CAF::CContent_DisplayInfoL()
{
CContent* content = NULL;
TInt r;
TBool r1 = EFalse;
content = CContent::NewLC(KOma2Content);
STIF_ASSERT_NOT_NULL( content );
TRAP(r, content->DisplayInfoL(EFileAndRights));
if(r == KErrCANotSupported || r == KErrNone)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CContent_SetPropertyL()
{
CContent* content = NULL;
TInt r;
TBool r1 = EFalse;
content = CContent::NewLC(KOma2Content);
STIF_ASSERT_NOT_NULL( content );
r = content->SetProperty(EAgentPropertyBufferSize, 1024);
if(r == KErrCANotSupported || r == KErrNone)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
r = content->SetProperty(EAgentPropertyAgentUI, 1);
if(r == KErrCANotSupported || r == KErrNone)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
r = content->SetProperty(EAgentPropertyMultipleSequence, 1);
if(r == KErrCANotSupported || r == KErrNone)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CContent_OpenContentL()
{
CContent* content = NULL;
CData* data = NULL;
RStreamablePtrArray<CEmbeddedObject> objects;
content = CContent::NewLC(KOma1Content);
STIF_ASSERT_NOT_NULL( content );
data = content->OpenContentLC(EPeek);
STIF_ASSERT_NOT_NULL( data );
CleanupStack::PopAndDestroy(2);
content = CContent::NewLC(KOma2Content);
STIF_ASSERT_NOT_NULL( content );
RUNCHECKEDL(content->Search(objects, _L8("audio/wav"), EFalse));
STIF_ASSERT_EQUALS( 1,objects.Count());
data = content->OpenContentLC(EPeek, objects[0]->UniqueId());
STIF_ASSERT_NOT_NULL( data );
objects.ResetAndDestroy();
CleanupStack::PopAndDestroy(2);
return KErrNone;
}
TInt CDRM_CAF::CManager_FileOperationsL()
{
_LIT(KFile1, "c:\\private\\OMA DRM Agent\\file1.odf");
_LIT(KFile2, "c:\\private\\OMA DRM Agent\\file2.odf");
_LIT(KDir, "c:\\private\\OMA DRM Agent\\");
_LIT(KDir1, "c:\\private\\OMA DRM Agent\\dir1\\");
_LIT(KDir12, "c:\\private\\OMA DRM Agent\\dir1\\dir2\\");
_LIT(KDir2, "c:\\private\\OMA DRM Agent\\dir2\\");
CDir* dir;
TInt r;
CManager* manager = CManager::NewL();
STIF_ASSERT_NOT_NULL( manager );
r = manager->CopyFile(KOma2Content, KFile1);
STIF_ASSERT_EQUALS( KErrPermissionDenied,r);
r = manager->RenameFile(KFile1, KFile2);
STIF_ASSERT_EQUALS( KErrPermissionDenied,r);
r = manager->DeleteFile(KFile2);
STIF_ASSERT_EQUALS( KErrPermissionDenied,r);
r = manager->MkDirAll(KDir12);
STIF_ASSERT_EQUALS( KErrPermissionDenied,r);
r = manager->MkDir(KDir1);
STIF_ASSERT_EQUALS( KErrPermissionDenied,r);
r = manager->GetDir(KDir, KEntryAttNormal, ESortByName, dir);
STIF_ASSERT_EQUALS( KErrPermissionDenied,r);
r = manager->GetDir(KDir, KNullUid, ESortByName, dir);
STIF_ASSERT_EQUALS( KErrPermissionDenied,r);
r = manager->GetDir(KDir, KEntryAttNormal, ESortByName, dir, dir);
STIF_ASSERT_EQUALS( KErrPermissionDenied,r);
r = manager->RmDir(KDir12);
STIF_ASSERT_EQUALS( KErrPermissionDenied,r);
//CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CManager_GetAttributeL()
{
TVirtualPathPtr dcf1(KOma1Content, KNullDesC);
TVirtualPathPtr dcf2(KOma2Content, KNullDesC);
TInt value;
TInt i;
RFile dcf1file;
RFile dcf2file;
TInt error( KErrNone );
CManager* manager = CManager::NewLC();
STIF_ASSERT_NOT_NULL( manager );
RUNCHECKEDL(manager->GetAttribute(EIsProtected, value, dcf1));
STIF_ASSERT_EQUALS( 0,value);
RUNCHECKEDL(manager->GetAttribute(EFileType, value, dcf1));
STIF_ASSERT_EQUALS( 1,value);
for (i = 0; i < NUM_ELEMENTS(KAttributes); i++)
{
manager->GetAttribute(KAttributes[i], value, dcf1);
}
CleanupStack::PopAndDestroy( manager );
manager = CManager::NewLC();
STIF_ASSERT_NOT_NULL( manager );
RUNCHECKEDL(manager->GetAttribute(EIsProtected, value, dcf2));
STIF_ASSERT_EQUALS( 0,value);
RUNCHECKEDL(manager->GetAttribute(EFileType, value, dcf2));
STIF_ASSERT_EQUALS( 2,value);
for (i = 0; i < NUM_ELEMENTS(KAttributes); i++)
{
manager->GetAttribute(KAttributes[i], value, dcf2);
}
CleanupStack::PopAndDestroy( manager );
User::LeaveIfError(dcf1file.Open(iFs, KOma1Content, EFileRead));
CleanupClosePushL(dcf1file);
User::LeaveIfError(dcf2file.Open(iFs, KOma2Content, EFileRead));
CleanupClosePushL(dcf2file);
manager = CManager::NewLC();
STIF_ASSERT_NOT_NULL( manager );
error = manager->GetAttribute(EIsProtected, value, dcf1file, KDefaultContentObject);
if ( !error )
{
STIF_ASSERT_EQUALS( 0, value );
}
else
{
STIF_ASSERT_EQUALS( KErrCANotSupported, error );
}
error = manager->GetAttribute(EFileType, value, dcf1file, KDefaultContentObject);
if ( !error )
{
STIF_ASSERT_EQUALS( 1, value );
}
else
{
STIF_ASSERT_EQUALS( KErrCANotSupported, error );
}
for (i = 0; i < NUM_ELEMENTS(KAttributes); i++)
{
manager->GetAttribute(KAttributes[i], value, dcf1file, KDefaultContentObject);
}
CleanupStack::PopAndDestroy( manager );
manager = CManager::NewLC();
STIF_ASSERT_NOT_NULL( manager );
error = manager->GetAttribute(EIsProtected, value, dcf2file, KDefaultContentObject);
if ( !error )
{
STIF_ASSERT_EQUALS( 0, value );
}
else
{
STIF_ASSERT_EQUALS( KErrCANotSupported, error );
}
error = manager->GetAttribute(EFileType, value, dcf2file, KDefaultContentObject);
if ( !error )
{
STIF_ASSERT_EQUALS( 2, value );
}
else
{
STIF_ASSERT_EQUALS( KErrCANotSupported, error );
}
for (i = 0; i < NUM_ELEMENTS(KAttributes); i++)
{
manager->GetAttribute(KAttributes[i], value, dcf2file, KDefaultContentObject);
}
CleanupStack::PopAndDestroy( manager );
// close files
CleanupStack::PopAndDestroy( 2 );
return KErrNone;
}
TInt CDRM_CAF::CManager_GetAttributeSetL()
{
RAttributeSet attributes;
TInt value;
TVirtualPathPtr dcf2(KOma2Content, KNullDesC);
TInt error( KErrNone );
RFile dcf2file;
attributes.AddL(EIsProtected);
attributes.AddL(EFileType);
CleanupClosePushL(attributes);
CManager* manager = CManager::NewLC();
STIF_ASSERT_NOT_NULL( manager );
RUNCHECKEDL(manager->GetAttributeSet(attributes, dcf2));
RUNCHECKEDL(attributes.GetValue(EIsProtected, value));
STIF_ASSERT_EQUALS( 0,value);
RUNCHECKED(attributes.GetValue(EFileType, value));
STIF_ASSERT_EQUALS( 2,value);
User::LeaveIfError(dcf2file.Open(iFs, KOma2Content, EFileRead));
CleanupClosePushL(dcf2file);
error = manager->GetAttributeSet(attributes, dcf2file, KDefaultContentObject);
if ( !error )
{
RUNCHECKEDL(attributes.GetValue(EIsProtected, value));
STIF_ASSERT_EQUALS( 0,value);
RUNCHECKED(attributes.GetValue(EFileType, value));
STIF_ASSERT_EQUALS( 2,value);
}
else
{
STIF_ASSERT_EQUALS( KErrCANotSupported, error );
}
CleanupStack::PopAndDestroy(3);
return KErrNone;
}
TInt CDRM_CAF::CManager_GetStringAttributeL()
{
TBuf<256> value;
TVirtualPathPtr dcf1(KOma1Content, KNullDesC);
TVirtualPathPtr dcf2(KOma2Content, KNullDesC);
TInt i;
TInt error( KErrNone );
RFile dcf1file;
RFile dcf2file;
CManager* manager = CManager::NewLC();
STIF_ASSERT_NOT_NULL( manager );
RUNCHECKED(manager->GetStringAttribute(EMimeType, value, dcf1));
for (i = 0; i < NUM_ELEMENTS(KAttributes); i++)
{
manager->GetStringAttribute(KStringAttributes[i], value, dcf1);
}
CleanupStack::PopAndDestroy( manager );
manager = CManager::NewLC();
STIF_ASSERT_NOT_NULL( manager );
RUNCHECKED(manager->GetStringAttribute(EMimeType, value, dcf2));
for (i = 0; i < NUM_ELEMENTS(KAttributes); i++)
{
manager->GetStringAttribute(KStringAttributes[i], value, dcf2);
}
CleanupStack::PopAndDestroy( manager );
User::LeaveIfError(dcf1file.Open(iFs, KOma1Content, EFileRead));
CleanupClosePushL(dcf1file);
User::LeaveIfError(dcf2file.Open(iFs, KOma2Content, EFileRead));
CleanupClosePushL(dcf2file);
manager = CManager::NewLC();
STIF_ASSERT_NOT_NULL( manager );
error = manager->GetStringAttribute(EMimeType, value, dcf1file, KDefaultContentObject);
if ( error == KErrCANotSupported )
{
error = KErrNone;
}
STIF_ASSERT_EQUALS( KErrNone, error );
for (i = 0; i < NUM_ELEMENTS(KAttributes); i++)
{
manager->GetStringAttribute(KStringAttributes[i], value, dcf1file, KDefaultContentObject);
}
CleanupStack::PopAndDestroy( manager );
manager = CManager::NewLC();
STIF_ASSERT_NOT_NULL( manager );
error = manager->GetStringAttribute(EMimeType, value, dcf2file, KDefaultContentObject);
if ( error == KErrCANotSupported )
{
error = KErrNone;
}
STIF_ASSERT_EQUALS( KErrNone, error );
for (i = 0; i < NUM_ELEMENTS(KAttributes); i++)
{
manager->GetStringAttribute(KStringAttributes[i], value, dcf2file, KDefaultContentObject);
}
CleanupStack::PopAndDestroy( manager );
// close files
CleanupStack::PopAndDestroy( 2 );
return KErrNone;
}
TInt CDRM_CAF::CManager_GetStringAttributeSetL()
{
RStringAttributeSet attributes;
TBuf<256> value;
TVirtualPathPtr dcf2(KOma2Content, KNullDesC);
RFile dcf2file;
TInt error( KErrNone );
attributes.AddL(EMimeType);
attributes.AddL(ERightsIssuerUrl);
CManager* manager = CManager::NewLC();
STIF_ASSERT_NOT_NULL( manager );
RUNCHECKEDL(manager->GetStringAttributeSet(attributes, dcf2));
RUNCHECKED(attributes.GetValue(EMimeType, value));
STIF_ASSERT_EQUALS( KErrCANotSupported,attributes.GetValue(ERightsIssuerUrl, value));
STIF_ASSERT_EQUALS( 0,value.Length());
CleanupStack::PopAndDestroy( manager );
User::LeaveIfError(dcf2file.Open(iFs, KOma2Content, EFileRead));
CleanupClosePushL(dcf2file);
manager = CManager::NewLC();
STIF_ASSERT_NOT_NULL( manager );
error = manager->GetStringAttributeSet(attributes, dcf2file, KDefaultContentObject);
if ( !error )
{
RUNCHECKED(attributes.GetValue(EMimeType, value));
STIF_ASSERT_EQUALS( KErrCANotSupported,attributes.GetValue(ERightsIssuerUrl, value));
STIF_ASSERT_EQUALS( 0,value.Length());
}
else
{
STIF_ASSERT_EQUALS( KErrCANotSupported, error );
}
CleanupStack::PopAndDestroy( 2 );
attributes.Close();
return KErrNone;
}
TInt CDRM_CAF::CManager_SetPropertyL()
{
TInt r;
TVirtualPathPtr dcf2(KOma2Content, KDefaultContentObject);
CManager* manager = CManager::NewLC();
STIF_ASSERT_NOT_NULL( manager );
r = manager->SetProperty(EAgentPropertyBufferSize, 1024);
STIF_ASSERT_EQUALS( KErrCANotSupported,r);
r = manager->SetProperty(EAgentPropertyAgentUI, 1);
STIF_ASSERT_EQUALS( KErrCANotSupported,r);
r = manager->SetProperty(EAgentPropertyMultipleSequence, 1);
STIF_ASSERT_EQUALS( KErrCANotSupported,r);
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CManager_DisplayInfoL()
{
TInt r;
RFile file;
TVirtualPathPtr dcf2(KOma2Content, KDefaultContentObject);
CManager* manager = CManager::NewLC();
STIF_ASSERT_NOT_NULL( manager );
TRAP(r, manager->DisplayInfoL(EFileAndRights, dcf2));
STIF_ASSERT_EQUALS( KErrCANotSupported,r);
User::LeaveIfError(file.Open(iFs, KOma2Content, EFileRead));
TRAP(r, manager->DisplayInfoL(EFileAndRights, file, KDefaultContentObject));
STIF_ASSERT_EQUALS( KErrCANotSupported,r);
file.Close();
CleanupStack::PopAndDestroy( manager );
return KErrNone;
}
TInt CDRM_CAF::CManager_ListAgentsL()
{
RArray<TAgent> agents;
TBool f = EFalse;
TInt i;
CManager* manager = CManager::NewLC();
STIF_ASSERT_NOT_NULL( manager );
manager->ListAgentsL(agents);
for (i = 0; i < agents.Count(); i++)
{
if (agents[i].Name().Compare(KOmaDrm2AgentName) == 0)
{
f = ETrue;
}
}
STIF_ASSERT_TRUE(f);
agents.Close();
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CManager_AgentSpecificCommandL()
{
TPtr8 ptr(NULL, 0, 0);
RArray<TAgent> agents;
TRequestStatus status;
TInt i;
TInt r;
HBufC8* data;
HBufC8* result;
HBufC8* buffer;
r = iFs.Delete(_L("c:\\test.dcf"));
STIF_ASSERT_EQUALS( KErrNone,r);
RFileWriteStream out;
out.Create(iFs, _L("c:\\test.dcf"), EFileWrite );
out.Close();
TInt size = 0;
RFile file;
User::LeaveIfError(file.Open(iFs, _L("c:\\test.dcf"), EFileRead));
CleanupClosePushL(file);
User::LeaveIfError(file.Size(size));
data = HBufC8::NewLC(size);
TPtr8 ptr1(data->Des());
User::LeaveIfError(file.Read(ptr1, size));
CleanupStack::Pop(); //data
CleanupStack::PopAndDestroy(); //file
buffer = HBufC8::NewL(data->Length() + 1);
ptr.Set(buffer->Des());
ptr.Append(EView);
ptr.Append(*data);
result = HBufC8::NewL(data->Length());
ptr.Set(result->Des());
TVirtualPathPtr dcf2(KOma2Content, KDefaultContentObject);
CManager* manager = CManager::NewLC();
STIF_ASSERT_NOT_NULL( manager );
manager->ListAgentsL(agents);
for (i = 0; i < agents.Count(); i++)
{
if (agents[i].Name().Compare(KOmaDrm2AgentName) == 0)
{
r = manager->AgentSpecificCommand(agents[i],
EEmbedDomainRo, KNullDesC8, ptr);
STIF_ASSERT_EQUALS( KErrCANotSupported,r);
manager->AgentSpecificCommand(agents[i],
EEmbedDomainRo, KNullDesC8, ptr, status);
User::WaitForRequest(status);
STIF_ASSERT_EQUALS( KErrCANotSupported,status.Int());
r = manager->AgentSpecificCommand(agents[i],
EBufferContainsOma1Dcf, KNullDesC8, ptr);
STIF_ASSERT_NOT_EQUALS( KErrNone,r);
r = manager->AgentSpecificCommand(agents[i],
EBufferContainsOma1Dcf, _L8("012345"), ptr);
STIF_ASSERT_NOT_EQUALS( KErrNone,r);
r = manager->AgentSpecificCommand(agents[i],
EDecryptOma1DcfBuffer, *buffer, ptr);
STIF_ASSERT_EQUALS( KErrArgument,r);
}
}
agents.Close();
CleanupStack::PopAndDestroy();
delete buffer;
delete result;
delete data;
return KErrNone;
}
TInt CDRM_CAF::CManager_CreateRightsManagerL()
{
CRightsManager* rm = NULL;
rm = GetOmaDrmRightsManagerL();
STIF_ASSERT_NOT_NULL(rm);
delete rm;
return KErrNone;
}
TInt CDRM_CAF::CSupplier_IsImportSupportedL()
{
CSupplier* supplier = CSupplier::NewLC();
STIF_ASSERT_TRUE(supplier->IsImportSupported(KOma1DrmMessageContentType));
STIF_ASSERT_TRUE(supplier->IsImportSupported(KOma1XmlRoContentType));
STIF_ASSERT_TRUE(supplier->IsImportSupported(KOma1WbxmlRoContentType));
STIF_ASSERT_TRUE(supplier->IsImportSupported(KOma2RoContentType));
STIF_ASSERT_FALSE(supplier->IsImportSupported(_L8("text/plain")));
CleanupStack::PopAndDestroy(1);
return KErrNone;
}
TInt CDRM_CAF::CSupplier_PrepareHTTPRequestHeadersL()
{
return KErrNone;
}
TInt CDRM_CAF::CSupplier_SetOutputDirectory_ImportFileL()
{
CSupplier* supplier = CSupplier::NewLC();
CMetaDataArray* metaData = CMetaDataArray::NewLC();
supplier->SetOutputDirectoryL(KEncryptedDir);
CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType,
*metaData, KTempDcfName);
STIF_ASSERT_NOT_NULL( file );
CleanupStack::PushL(file);
CleanupStack::PopAndDestroy(3);
return KErrNone;
}
TInt CDRM_CAF::CImportFile_WriteData_WriteDataComplete_OutputFileCountL()
{
TFileName fileName;
TRequestStatus status;
TInt i;
TInt r;
fileName.Copy(KEncryptedDir);
fileName.Append(KTempDcfName);
r = iFs.Delete(fileName);
STIF_ASSERT_EQUALS(KErrNone , r);
CSupplier* supplier = CSupplier::NewLC();
CMetaDataArray* metaData = CMetaDataArray::NewLC();
supplier->SetOutputDirectoryL(KEncryptedDir);
CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType,
*metaData, KTempDcfName);
STIF_ASSERT_NOT_NULL( file );
CleanupStack::PushL(file);
RUNCHECKEDL(file->WriteData(KDMSimple));
RUNCHECKEDL(file->WriteDataComplete());
STIF_ASSERT_EQUALS(1 , file->OutputFileCountL());
CleanupStack::PopAndDestroy(3);
fileName.Copy(KEncryptedDir);
fileName.Append(KTempDcfName);
r = iFs.Delete(fileName);
STIF_ASSERT_EQUALS(KErrNone , r);
supplier = CSupplier::NewLC();
metaData = CMetaDataArray::NewLC();
supplier->SetOutputDirectoryL(KEncryptedDir);
file = supplier->ImportFileL(KOma1DrmMessageContentType,
*metaData, KTempDcfName);
STIF_ASSERT_NOT_NULL( file );
CleanupStack::PushL(file);
file->WriteData(KDMSimple, status);
User::WaitForRequest(status);
STIF_ASSERT_EQUALS(KErrNone , status.Int());
file->WriteDataComplete(status);
User::WaitForRequest(status);
STIF_ASSERT_EQUALS(KErrNone , status.Int());
STIF_ASSERT_EQUALS(1 , file->OutputFileCountL());
CleanupStack::PopAndDestroy(3);
fileName.Copy(KEncryptedDir);
fileName.Append(KTempDcfName);
r = iFs.Delete(fileName);
STIF_ASSERT_EQUALS(KErrNone , r);
supplier = CSupplier::NewLC();
metaData = CMetaDataArray::NewLC();
metaData->AddL(KOmaImportMimeTypeField, _L8("text/plain"));
supplier->SetOutputDirectoryL(KEncryptedDir);
file = supplier->ImportFileL(KOmaImportContentType,
*metaData, KTempDcfName);
STIF_ASSERT_NOT_NULL( file );
CleanupStack::PushL(file);
for (i = 0; i < 100; i++)
{
STIF_ASSERT_EQUALS(KErrNone , file->WriteData(KDMContent) );
}
STIF_ASSERT_EQUALS(KErrNone , file->WriteDataComplete());
STIF_ASSERT_EQUALS(1 , file->OutputFileCountL());
CleanupStack::PopAndDestroy(3);
return KErrNone;
}
TInt CDRM_CAF::CImportFile_OutputFileL_GetImportStatusL()
{
TFileName fileName;
TInt r;
fileName.Copy(KEncryptedDir);
fileName.Append(KTempDcfName);
r = iFs.Delete(fileName);
STIF_ASSERT_EQUALS(KErrNone , r);
CSupplier* supplier = CSupplier::NewLC();
CMetaDataArray* metaData = CMetaDataArray::NewLC();
supplier->SetOutputDirectoryL(KEncryptedDir);
CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType,
*metaData, KTempDcfName);
STIF_ASSERT_NOT_NULL( file );
CleanupStack::PushL(file);
RUNCHECKEDL(file->WriteData(KDMSimple));
RUNCHECKEDL(file->WriteDataComplete());
RUNCHECKED(file->GetImportStatus() == EComplete);
STIF_ASSERT_EQUALS(1 , file->OutputFileCountL());
CSupplierOutputFile& output = file->OutputFileL(0);
STIF_ASSERT_EQUALS(0 , output.MimeTypeL().CompareF(KOma1DcfContentType));
CleanupStack::PopAndDestroy(3);
return KErrNone;
}
TInt CDRM_CAF::CImportFile_GetSuggestedOutputFileExtensionL()
{
TInt r;
TBuf<256> buffer;
CSupplier* supplier = CSupplier::NewLC();
CMetaDataArray* metaData = CMetaDataArray::NewLC();
supplier->SetOutputDirectoryL(KEncryptedDir);
CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType,
*metaData);
STIF_ASSERT_NOT_NULL( file );
CleanupStack::PushL(file);
r = file->WriteData(KDMSimple);
STIF_ASSERT_EQUALS(KErrCANewFileHandleRequired , r);
RUNCHECKEDL(file->GetSuggestedOutputFileExtension(buffer));
STIF_ASSERT_EQUALS(0 , buffer.CompareF(_L(".dcf")));
CleanupStack::PopAndDestroy(3);
return KErrNone;
}
TInt CDRM_CAF::CImportFile_GetSuggestedOutputFileNameL()
{
TInt r;
TBuf<256> buffer;
CSupplier* supplier = CSupplier::NewLC();
CMetaDataArray* metaData = CMetaDataArray::NewLC();
supplier->SetOutputDirectoryL(KEncryptedDir);
CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType,
*metaData);
STIF_ASSERT_NOT_NULL( file );
CleanupStack::PushL(file);
r = file->WriteData(KDMSimple);
STIF_ASSERT_EQUALS(KErrCANewFileHandleRequired , r);
buffer.Copy(_L("test"));
RUNCHECKEDL(file->GetSuggestedOutputFileName(buffer));
STIF_ASSERT_EQUALS(0 , buffer.CompareF(_L("test.dcf")));
CleanupStack::PopAndDestroy(3);
return KErrNone;
}
TInt CDRM_CAF::CImportFile_ContinueWithNewOutputFileL()
{
TFileName fileName;
RFile f;
TInt r;
fileName.Copy(KEncryptedDir);
fileName.Append(KTempDcfName);
iFs.SetSessionPath(KEncryptedDir);
r = iFs.Delete(fileName);
STIF_ASSERT_EQUALS(KErrNone , r);
CSupplier* supplier = CSupplier::NewLC();
CMetaDataArray* metaData = CMetaDataArray::NewLC();
supplier->SetOutputDirectoryL(KEncryptedDir);
CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType,
*metaData);
STIF_ASSERT_NOT_NULL( file );
CleanupStack::PushL(file);
r = file->WriteData(KDMSimple);
STIF_ASSERT_EQUALS(KErrCANewFileHandleRequired , r);
RUNCHECKEDL(f.Create(iFs, fileName, EFileWrite | EFileStream));
CleanupClosePushL(f);
file->ContinueWithNewOutputFile(f, fileName);
RUNCHECKEDL(file->WriteData(KDMSimple));
RUNCHECKEDL(file->WriteDataComplete());
CleanupStack::PopAndDestroy(4);
return KErrNone;
}
TInt CDRM_CAF::CImportFile_ContentMimeTypeL()
{
TInt err( KErrNone );
TBool boolean( EFalse );
CSupplier* supplier = CSupplier::NewLC();
CMetaDataArray* metaData = CMetaDataArray::NewLC();
supplier->SetOutputDirectoryL(KEncryptedDir);
CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType,
*metaData);
CleanupStack::PushL( file );
err = file->WriteData(KDMSimple);
STIF_ASSERT_EQUALS(err, KErrCANewFileHandleRequired);
TBuf8<KMaxDataTypeLength> contentMime;
TRAP(err, boolean = file->ContentMimeTypeL( contentMime ));
STIF_ASSERT_EQUALS(KErrCANotSupported, err);
CleanupStack::PopAndDestroy( 3, supplier ); //file, metaData, supplier
return KErrNone;
}
TInt CDRM_CAF::CRightsManager_ListRightsL()
{
CRightsManager* rm = NULL;
RStreamablePtrArray<CRightsInfo> rights;
rm = GetOmaDrmRightsManagerL();
STIF_ASSERT_NOT_NULL( rm );
CleanupStack::PushL(rm);
rm->ListRightsL(rights, KTempDcfPathName);
rights.ResetAndDestroy();
rights.Close();
CleanupStack::PopAndDestroy();
RFile dcfFile;
User::LeaveIfError(dcfFile.Open(iFs, KTempDcfPathName, EFileRead));
CleanupClosePushL(dcfFile);
rm = GetOmaDrmRightsManagerL();
STIF_ASSERT_NOT_NULL( rm );
CleanupStack::PushL(rm);
TRAPD( err, rm->ListRightsL(rights, dcfFile, KDefaultContentObject) );
if ( err != KErrCANotSupported )
{
User::LeaveIfError( err );
}
rights.ResetAndDestroy();
rights.Close();
CleanupStack::PopAndDestroy( 2 );
return KErrNone;
}
TInt CDRM_CAF::CRightsManager_ListAllRightsL()
{
CRightsManager* rm = NULL;
RStreamablePtrArray<CRightsInfo> rights;
rm = GetOmaDrmRightsManagerL();
STIF_ASSERT_NOT_NULL( rm );
CleanupStack::PushL(rm);
rm->ListAllRightsL(rights);
rights.ResetAndDestroy();
rights.Close();
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CRightsManager_ListContentL()
{
TInt r = 0;
CRightsManager* rm = NULL;
RStreamablePtrArray<CVirtualPath> files;
CData* data = NULL;
TBuf<256> id;
CRightsInfo* info = NULL;
TBool r1 = EFalse;
rm = GetOmaDrmRightsManagerL();
STIF_ASSERT_NOT_NULL( rm );
CleanupStack::PushL(rm);
data = CData::NewLC(TVirtualPathPtr(KOma1Content, KDefaultContentObject),
EPeek, EContentShareReadOnly);
RUNCHECKEDL(data->GetStringAttribute(EContentID, id));
info = CRightsInfo::NewL(KNullDesC, id, ERightsTypeStateless,
ERightsStatusValid);
CleanupStack::PushL(info);
TRAP(r, rm->ListContentL(files, *info));
if(r == KErrNone || r == KErrNotFound)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
files.ResetAndDestroy();
files.Close();
CleanupStack::PopAndDestroy(3); // rm, data, info
return KErrNone;
}
TInt CDRM_CAF::CRightsManager_DeleteRightsObjectL()
{
CRightsManager* rm = NULL;
CData* data = NULL;
TBuf<256> id;
CRightsInfo* info = NULL;
TInt r;
TBool r1 = EFalse;
rm = GetOmaDrmRightsManagerL();
STIF_ASSERT_NOT_NULL( rm );
CleanupStack::PushL(rm);
data = CData::NewLC(TVirtualPathPtr(KOma1Content, KDefaultContentObject),
EPeek, EContentShareReadOnly);
RUNCHECKEDL(data->GetStringAttribute(EContentID, id));
info = CRightsInfo::NewL(KNullDesC, id, ERightsTypeStateless,
ERightsStatusValid);
CleanupStack::PushL(info);
r = rm->DeleteRightsObject(*info);
if(r == -21 || r == 0)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
CleanupStack::PopAndDestroy(3);
return KErrNone;
}
TInt CDRM_CAF::CRightsManager_DeleteAllRightsObjectsL()
{
CRightsManager* rm = NULL;
CData* data = NULL;
TInt r;
TBool r1 = EFalse;
rm = GetOmaDrmRightsManagerL();
STIF_ASSERT_NOT_NULL( rm );
CleanupStack::PushL(rm);
r = rm->DeleteAllRightsObjects(TVirtualPathPtr(KOma1Content, KNullDesC));
if(r == -21 || r == -1)
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
RFile file;
r1 = EFalse;
User::LeaveIfError(file.Open(iFs, KOma1Content, EFileRead));
r = rm->DeleteAllRightsObjects(file, KDefaultContentObject);
if(r == -21 || r == -1 || r == KErrCANotSupported )
{
r1 = ETrue;
}
STIF_ASSERT_TRUE(r1);
file.Close();
CleanupStack::PopAndDestroy( rm );
return KErrNone;
}
TInt CDRM_CAF::CRightsManager_SetPropertyL()
{
CRightsManager* rm = NULL;
TInt r;
rm = GetOmaDrmRightsManagerL();
STIF_ASSERT_NOT_NULL( rm );
CleanupStack::PushL(rm);
r = rm->SetProperty(EAgentPropertyBufferSize, 1024);
STIF_ASSERT_EQUALS(KErrCANotSupported , r);
CleanupStack::PopAndDestroy();
return KErrNone;
}
TInt CDRM_CAF::CDRMLicenseChecker_CheckLicenseL()
{
CDRMLicenseChecker* lc = NULL;
TInt r;
TFileName fileName;
HBufC8* data = NULL;
fileName.Copy(KEncryptedDir);
fileName.Append(KTempDcfName);
lc = CDRMLicenseChecker::NewL();
STIF_ASSERT_NOT_NULL( lc );
CleanupStack::PushL(lc);
r = lc->CheckLicense( fileName, data );
STIF_ASSERT_EQUALS(KErrAccessDenied , r); // this does not work in SDK
//STIF_ASSERT_EQUALS(KErrNone , r); // this works in the new SDK's
delete data;
CleanupStack::PopAndDestroy();
return KErrNone;
}
// [End of File] - Do not remove