|
1 /* |
|
2 * Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: ?Description |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 // [INCLUDE FILES] - do not remove |
|
21 #include <e32svr.h> |
|
22 #include <StifParser.h> |
|
23 #include <Stiftestinterface.h> |
|
24 #include "DRM_CAF.h" |
|
25 #include <caf/caftypes.h> |
|
26 #include <caf/caf.h> |
|
27 #include <caf/data.h> |
|
28 #include <f32file.h> |
|
29 #include <BAUTILS.H> |
|
30 #include <TestclassAssert.h> |
|
31 using namespace ContentAccess; |
|
32 // LOCAL CONSTANTS AND MACROS |
|
33 |
|
34 #define NUM_ELEMENTS(x) (sizeof(x) / sizeof(x[0])) |
|
35 |
|
36 const TInt KAttributes[] = |
|
37 { |
|
38 EIsProtected, |
|
39 EIsForwardable, |
|
40 EIsModifyable, |
|
41 EIsCopyable, |
|
42 ECanPlay, |
|
43 ECanPrint, |
|
44 ECanExecute, |
|
45 ECanView, |
|
46 ERightsNone, |
|
47 ERightsPending, |
|
48 ERightsHaveExpired, |
|
49 EPreviewAvailable, |
|
50 EContentCDataInUse, |
|
51 ECanRewind, |
|
52 ECopyPaste, |
|
53 ERightsConsumable, |
|
54 ERightsStateless, |
|
55 ECanMove, |
|
56 ECanRename, |
|
57 ECanAutomaticConsume, |
|
58 EFileType, |
|
59 EPreviewType, |
|
60 ESilentRightsType |
|
61 }; |
|
62 |
|
63 const TInt KStringAttributes[] = |
|
64 { |
|
65 EEmbeddedRightsObject, |
|
66 EDomainRightsIssuerUrl, |
|
67 EDescription, |
|
68 EMimeType, |
|
69 ETitle, |
|
70 EAuthor, |
|
71 EIconURI, |
|
72 EPreviewURI, |
|
73 EContentURI, |
|
74 EContentID, |
|
75 EInfoURL, |
|
76 EPendingRightsETA, |
|
77 EInstantPreviewUri, |
|
78 EPreviewRightsUri, |
|
79 ERightsIssuerUrl, |
|
80 ESilentRightsUrl, |
|
81 ETransactionTrackingId, |
|
82 }; |
|
83 |
|
84 // Test logging macros(we only want line numbers) |
|
85 //#undef test |
|
86 //#undef __test |
|
87 |
|
88 //#define __test(x, l) test(x, l) |
|
89 //#define test(x) __test(x, __LINE__) |
|
90 |
|
91 //#define FuncCount( a ) ( sizeof( a ) / sizeof( TBatTestFunc ) ) |
|
92 |
|
93 |
|
94 |
|
95 #define RUNCHECKED(function) \ |
|
96 { \ |
|
97 TInt c = function; \ |
|
98 if (c != KErrNone) \ |
|
99 { \ |
|
100 STIF_ASSERT_TRUE(c); \ |
|
101 } \ |
|
102 else \ |
|
103 { \ |
|
104 GLastOk = __LINE__;\ |
|
105 } \ |
|
106 } |
|
107 |
|
108 #define RUNCHECKEDL(function) \ |
|
109 { \ |
|
110 TInt c = function; \ |
|
111 if (c != KErrNone) \ |
|
112 { \ |
|
113 STIF_ASSERT_TRUE(c); \ |
|
114 User::Leave(c); \ |
|
115 } \ |
|
116 else \ |
|
117 { \ |
|
118 GLastOk = __LINE__;\ |
|
119 } \ |
|
120 } |
|
121 |
|
122 |
|
123 #define RUN_TRAPPED(r, function) \ |
|
124 { \ |
|
125 r = KErrNone; TRAP(r, function); \ |
|
126 STIF_ASSERT_EQUALS( KErrNone, r )\ |
|
127 } |
|
128 |
|
129 //RTest test(_L("c:\\OMADRM2BC.log")); |
|
130 //#if 0 |
|
131 //RTest test(_L("c:\\OMADRM2BC.log")); |
|
132 //TInt GLastOk; |
|
133 //TInt GAllocatedCount; |
|
134 //TInt GAllocatedSize; |
|
135 |
|
136 //TBool flvariant; |
|
137 //#endif |
|
138 |
|
139 _LIT8(KROSimple, "<o-ex:rights xmlns:o-ex = \"http://odrl.net/1.1/ODRL-EX\" \ |
|
140 xmlns:o-dd = \"http://odrl.net/1.1/ODRL-DD\" \ |
|
141 xmlns:ds = \"http://www.w3.org/2000/09/xmldsig#/\">\ |
|
142 <o-ex:context><o-dd:version>1.0</o-dd:version></o-ex:context>\ |
|
143 <o-ex:agreement><o-ex:asset><o-ex:context>\ |
|
144 <o-dd:uid>cid:9999</o-dd:uid></o-ex:context></o-ex:asset><o-ex:permission>\ |
|
145 <o-dd:display/><o-dd:play/><o-dd:execute/><o-dd:print/>\ |
|
146 </o-ex:permission></o-ex:agreement></o-ex:rights>"); |
|
147 |
|
148 _LIT8(KDRCSimple, |
|
149 "\003\016\152\000\305\005\205\006\206\007\207\001\106\107\003\061\056\060\000\001\ |
|
150 \001\111\112\106\110\003\143\151\144\072\062\060\060\063\060\064\062\071\061\062\ |
|
151 \060\067\065\063\055\063\064\064\067\060\071\066\063\066\060\100\167\167\167\056\ |
|
152 \147\157\157\147\154\145\056\143\157\155\000\001\001\113\114\303\020\063\323\173\ |
|
153 \130\367\145\145\367\077\137\105\057\120\076\265\377\001\001\001\115\116\122\123\ |
|
154 \003\065\000\001\001\001\117\122\124\125\003\062\060\060\063\055\060\064\055\062\ |
|
155 \071\124\061\062\072\060\064\072\064\067\000\001\126\003\062\060\060\063\055\060\ |
|
156 \065\055\062\061\124\061\062\072\060\064\072\064\067\000\001\001\001\001\001\001\ |
|
157 \001"); |
|
158 _LIT8(KDMHead, "--boundary-1\r\nContent-Type: text/plain\r\n\ |
|
159 Content-Transfer-Encoding: 8bit\r\n\ |
|
160 \r\n"); |
|
161 |
|
162 _LIT8(KDMTail, "\r\n--boundary-1--"); |
|
163 |
|
164 _LIT8(KDMContent, "0123456789"); |
|
165 |
|
166 |
|
167 _LIT8(KDMSimple, "--boundary-1\r\nContent-Type: text/plain\r\n\ |
|
168 Content-Transfer-Encoding: 8bit\r\n\ |
|
169 \r\n\ |
|
170 012345678911234567892123456789312345678941234567895123456789\ |
|
171 612345678971234567898123456789912345678901234567891123456789\ |
|
172 212345678931234567894123456789512345678961234567897123456789\ |
|
173 812345678991234567890123456789112345678921234567893123456789\ |
|
174 412345678951234567896123456789712345678981234567899123456789\ |
|
175 \r\n--boundary-1--\r\n"); |
|
176 |
|
177 _LIT8(KDMCDCount, "--random78o6bP%[GB6b/8&/45&%*^'?vS\r\n\ |
|
178 Content-Type: application/vnd.oma.drm.rights+xml\r\n\ |
|
179 Content-Transfer-Encoding: binary\r\n\ |
|
180 \r\n\ |
|
181 <o-ex:rights\ |
|
182 xmlns:o-ex=\"http://odrl.net/1.1/ODRL-EX\"\ |
|
183 xmlns:o-dd=\"http://odrl.net/1.1/ODRL-DD\"\ |
|
184 xmlns:ds=\"http://www.w3.org/2000/09/xmldsig#/\"\ |
|
185 >\ |
|
186 <o-ex:context><o-dd:version>1.0</o-dd:version>\ |
|
187 </o-ex:context><o-ex:agreement><o-ex:asset>\ |
|
188 <o-ex:context><o-dd:uid>cid:20031217123451-8428794033@www.nokia.com</o-dd:uid>\ |
|
189 </o-ex:context></o-ex:asset>\ |
|
190 <o-ex:permission>\ |
|
191 <o-dd:display>\ |
|
192 <o-ex:constraint>\ |
|
193 <o-dd:count>3</o-dd:count>\ |
|
194 </o-ex:constraint>\ |
|
195 </o-dd:display>\ |
|
196 <o-dd:display>\ |
|
197 </o-ex:permission>\ |
|
198 </o-ex:agreement>\ |
|
199 </o-ex:rights>\r\n\ |
|
200 \r\n\ |
|
201 --random78o6bP%[GB6b/8&/45&%*^'?vS\r\n\ |
|
202 Content-Type: text/plain\r\n\ |
|
203 Content-ID: <20031217123451-8428794033@www.nokia.com>\r\n\ |
|
204 Content-Transfer-Encoding: binary\r\n\ |
|
205 \r\n\ |
|
206 Check:\r\n\ |
|
207 DbCnt: 109ms r:0\r\n\ |
|
208 Fixes:\r\n\ |
|
209 \r\n\ |
|
210 --random78o6bP%[GB6b/8&/45&%*^'?vS--"); |
|
211 |
|
212 _LIT(KOma1Content, "c:\\content.dcf"); |
|
213 _LIT(KOma2Content, "c:\\content.odf"); |
|
214 _LIT(KOma2ContentNoEnc, "c:\\content-noenc.odf"); |
|
215 _LIT(KOma2ContentNoEncTruncated, "c:\\content-noenc-trunc.odf"); |
|
216 |
|
217 _LIT(KEncryptedDir, "c:\\"); |
|
218 _LIT(KTempDcfName, "test.dcf"); |
|
219 _LIT(KTempDcfPathName, "c:\\test.dcf"); |
|
220 _LIT(KFVariantFile,"c:\\DrmCAFVarFile.txt"); |
|
221 |
|
222 |
|
223 // EXTERNAL DATA STRUCTURES |
|
224 //extern ?external_data; |
|
225 |
|
226 // EXTERNAL FUNCTION PROTOTYPES |
|
227 //extern ?external_function( ?arg_type,?arg_type ); |
|
228 |
|
229 // CONSTANTS |
|
230 //const ?type ?constant_var = ?constant; |
|
231 |
|
232 // MACROS |
|
233 //#define ?macro ?macro_def |
|
234 |
|
235 // LOCAL CONSTANTS AND MACROS |
|
236 //const ?type ?constant_var = ?constant; |
|
237 //#define ?macro_name ?macro_def |
|
238 |
|
239 // MODULE DATA STRUCTURES |
|
240 //enum ?declaration |
|
241 //typedef ?declaration |
|
242 |
|
243 // LOCAL FUNCTION PROTOTYPES |
|
244 //?type ?function_name( ?arg_type, ?arg_type ); |
|
245 |
|
246 // FORWARD DECLARATIONS |
|
247 //class ?FORWARD_CLASSNAME; |
|
248 |
|
249 // ============================= LOCAL FUNCTIONS =============================== |
|
250 |
|
251 |
|
252 class CActiveWaiter : public CActive |
|
253 { |
|
254 public: |
|
255 static CActiveWaiter* NewL(); |
|
256 |
|
257 void StartWait(); |
|
258 |
|
259 TRequestStatus& GetStatus(); |
|
260 |
|
261 ~CActiveWaiter(); |
|
262 protected: // from CActive |
|
263 /** |
|
264 * part of active object framework, provide default implementation |
|
265 */ |
|
266 void RunL(); |
|
267 |
|
268 /** |
|
269 * part of active object framework, provide default implementation |
|
270 */ |
|
271 void DoCancel(); |
|
272 |
|
273 /** |
|
274 * part of active object framework, provide default implementation |
|
275 */ |
|
276 TInt RunError(TInt aError); |
|
277 |
|
278 |
|
279 private: |
|
280 CActiveWaiter(); |
|
281 |
|
282 void ConstructL(); |
|
283 |
|
284 CActiveSchedulerWait iWait; |
|
285 }; |
|
286 |
|
287 |
|
288 CActiveWaiter::CActiveWaiter() : CActive(EPriorityStandard) |
|
289 { |
|
290 |
|
291 } |
|
292 |
|
293 CActiveWaiter::~CActiveWaiter() |
|
294 { |
|
295 Deque(); |
|
296 |
|
297 if( iWait.IsStarted() ) |
|
298 { |
|
299 iWait.AsyncStop(); |
|
300 } |
|
301 } |
|
302 |
|
303 CActiveWaiter* CActiveWaiter::NewL() { |
|
304 CActiveWaiter* self = new (ELeave) CActiveWaiter(); |
|
305 return self; |
|
306 } |
|
307 |
|
308 |
|
309 /** |
|
310 * part of active object framework, provide default implementation |
|
311 */ |
|
312 void CActiveWaiter::RunL() { |
|
313 iWait.AsyncStop(); |
|
314 } |
|
315 |
|
316 /** |
|
317 * part of active object framework, provide default implementation |
|
318 */ |
|
319 void CActiveWaiter::DoCancel(){ |
|
320 } |
|
321 |
|
322 /** |
|
323 * part of active object framework, provide default implementation |
|
324 */ |
|
325 TInt CActiveWaiter::RunError(TInt /*aError*/){ |
|
326 return KErrNone; |
|
327 } |
|
328 |
|
329 void CActiveWaiter::StartWait() { |
|
330 if(!IsAdded()) |
|
331 { |
|
332 CActiveScheduler::Add(this); |
|
333 } |
|
334 if(!IsActive()) |
|
335 { |
|
336 SetActive(); |
|
337 } |
|
338 |
|
339 iStatus = KRequestPending; |
|
340 |
|
341 iWait.Start(); |
|
342 } |
|
343 |
|
344 TRequestStatus& CActiveWaiter::GetStatus() |
|
345 { |
|
346 return iStatus; |
|
347 } |
|
348 |
|
349 |
|
350 |
|
351 LOCAL_C CRightsManager* GetOmaDrmRightsManagerL() |
|
352 { |
|
353 RArray<TAgent> agents; |
|
354 CRightsManager* rm = NULL; |
|
355 TInt i; |
|
356 TInt r; |
|
357 |
|
358 CManager* manager = CManager::NewLC(); |
|
359 //STIF_ASSERT_NOT_NULL( manager ); |
|
360 manager->ListAgentsL(agents); |
|
361 for (i = 0; rm == NULL && i < agents.Count(); i++) |
|
362 { |
|
363 if (agents[i].Name().Compare(KOmaDrm2AgentName) == 0) |
|
364 { |
|
365 TRAP(r, rm = manager->CreateRightsManagerL(agents[i])); |
|
366 } |
|
367 } |
|
368 agents.Close(); |
|
369 CleanupStack::PopAndDestroy(); |
|
370 return rm; |
|
371 } |
|
372 |
|
373 // ----------------------------------------------------------------------------- |
|
374 // ?function_name ?description. |
|
375 // ?description |
|
376 // Returns: ?value_1: ?description |
|
377 // ?value_n: ?description_line1 |
|
378 // ?description_line2 |
|
379 // ----------------------------------------------------------------------------- |
|
380 // |
|
381 /* |
|
382 ?type ?function_name( |
|
383 ?arg_type arg, // ?description |
|
384 ?arg_type arg) // ?description |
|
385 { |
|
386 |
|
387 ?code // ?comment |
|
388 |
|
389 // ?comment |
|
390 ?code |
|
391 } |
|
392 */ |
|
393 |
|
394 // ============================ MEMBER FUNCTIONS =============================== |
|
395 |
|
396 // ----------------------------------------------------------------------------- |
|
397 // CDRM_CAF::Delete |
|
398 // Delete here all resources allocated and opened from test methods. |
|
399 // Called from destructor. |
|
400 // ----------------------------------------------------------------------------- |
|
401 // |
|
402 void CDRM_CAF::Delete() |
|
403 { |
|
404 |
|
405 } |
|
406 |
|
407 // ----------------------------------------------------------------------------- |
|
408 // CDRM_CAF::RunMethodL |
|
409 // Run specified method. Contains also table of test mothods and their names. |
|
410 // ----------------------------------------------------------------------------- |
|
411 // |
|
412 TInt CDRM_CAF::RunMethodL( |
|
413 CStifItemParser& aItem ) |
|
414 { |
|
415 |
|
416 TStifFunctionInfo const KFunctions[] = |
|
417 { |
|
418 // Copy this line for every implemented function. |
|
419 // First string is the function name used in TestScripter script file. |
|
420 // Second is the actual implementation member function. |
|
421 ENTRY( "CSupplier_Oma1XmlRoL", CDRM_CAF::CSupplier_Oma1XmlRoL ), |
|
422 ENTRY( "CSupplier_Oma1WbxmlRoL", CDRM_CAF::CSupplier_Oma1WbxmlRoL ), |
|
423 ENTRY( "CData_NewL", CDRM_CAF::CData_NewL ), |
|
424 ENTRY( "CData_Read_DataSize_SeekL", CDRM_CAF::CData_Read_DataSize_SeekL ), |
|
425 ENTRY( "CData_Read2L", CDRM_CAF::CData_Read2L ), |
|
426 ENTRY( "CData_SetPropertyL", CDRM_CAF::CData_SetPropertyL ), |
|
427 ENTRY( "CData_EvaluateIntentL", CDRM_CAF::CData_EvaluateIntentL ), |
|
428 ENTRY( "CData_ExecuteIntentL", CDRM_CAF::CData_ExecuteIntentL ), |
|
429 ENTRY( "CData_GetAttributeL", CDRM_CAF::CData_GetAttributeL ), |
|
430 ENTRY( "CData_GetAttributeSetL", CDRM_CAF::CData_GetAttributeSetL ), |
|
431 ENTRY( "CData_GetStringAttributeL", CDRM_CAF::CData_GetStringAttributeL ), |
|
432 ENTRY( "CData_GetStringAttributeSetL", CDRM_CAF::CData_GetStringAttributeSetL ), |
|
433 ENTRY( "CContent_NewL", CDRM_CAF::CContent_NewL ), |
|
434 ENTRY( "CContent_OpenCloseContainerL", CDRM_CAF::CContent_OpenCloseContainerL ), |
|
435 ENTRY( "CContent_GetEmbeddedObjectsL", CDRM_CAF::CContent_GetEmbeddedObjectsL ), |
|
436 ENTRY( "CContent_SearchL", CDRM_CAF::CContent_SearchL ), |
|
437 ENTRY( "CContent_GetAttributeL", CDRM_CAF::CContent_GetAttributeL ), |
|
438 ENTRY( "CContent_GetAttributeSetL", CDRM_CAF::CContent_GetAttributeSetL ), |
|
439 ENTRY( "CContent_GetStringAttributeL", CDRM_CAF::CContent_GetStringAttributeL ), |
|
440 ENTRY( "CContent_GetStringAttributeSetL", CDRM_CAF::CContent_GetStringAttributeL ), |
|
441 ENTRY( "CContent_AgentSpecificCommandL", CDRM_CAF::CContent_AgentSpecificCommandL ), |
|
442 ENTRY( "CContent_NotifyStatusChangeL", CDRM_CAF::CContent_NotifyStatusChangeL ), |
|
443 ENTRY( "CContent_CancelNotifyStatusChangeL", CDRM_CAF::CContent_CancelNotifyStatusChangeL ), |
|
444 ENTRY( "CContent_RequestRightsL", CDRM_CAF::CContent_RequestRightsL ), |
|
445 ENTRY( "CContent_DisplayInfoL", CDRM_CAF::CContent_DisplayInfoL ), |
|
446 ENTRY( "CContent_SetPropertyL", CDRM_CAF::CContent_SetPropertyL ), |
|
447 ENTRY( "CContent_OpenContentL", CDRM_CAF::CContent_OpenContentL ), |
|
448 ENTRY( "CManager_FileOperationsL", CDRM_CAF::CManager_FileOperationsL ), |
|
449 ENTRY( "CManager_GetAttributeL", CDRM_CAF::CManager_GetAttributeL ), |
|
450 ENTRY( "CManager_GetAttributeSetL", CDRM_CAF::CManager_GetAttributeSetL ), |
|
451 ENTRY( "CManager_GetStringAttributeL", CDRM_CAF::CManager_GetStringAttributeL ), |
|
452 ENTRY( "CManager_GetStringAttributeSetL", CDRM_CAF::CManager_GetStringAttributeSetL ), |
|
453 ENTRY( "CManager_SetPropertyL", CDRM_CAF::CManager_SetPropertyL ), |
|
454 ENTRY( "CManager_DisplayInfoL", CDRM_CAF::CManager_DisplayInfoL ), |
|
455 ENTRY( "CManager_ListAgentsL", CDRM_CAF::CManager_ListAgentsL ), |
|
456 ENTRY( "CManager_AgentSpecificCommandL", CDRM_CAF::CManager_AgentSpecificCommandL ), |
|
457 ENTRY( "CManager_CreateRightsManagerL", CDRM_CAF::CManager_CreateRightsManagerL ), |
|
458 ENTRY( "CSupplier_IsImportSupportedL", CDRM_CAF::CSupplier_IsImportSupportedL ), |
|
459 ENTRY( "CSupplier_PrepareHTTPRequestHeadersL", CDRM_CAF::CSupplier_PrepareHTTPRequestHeadersL ), |
|
460 ENTRY( "CSupplier_SetOutputDirectory_ImportFileL", CDRM_CAF::CSupplier_SetOutputDirectory_ImportFileL ), |
|
461 ENTRY( "CImportFile_WriteData_WriteDataComplete_OutputFileCountL", CDRM_CAF::CImportFile_WriteData_WriteDataComplete_OutputFileCountL ), |
|
462 ENTRY( "CImportFile_OutputFileL_GetImportStatusL", CDRM_CAF::CImportFile_OutputFileL_GetImportStatusL ), |
|
463 ENTRY( "CImportFile_GetSuggestedOutputFileExtensionL", CDRM_CAF::CImportFile_GetSuggestedOutputFileExtensionL ), |
|
464 ENTRY( "CImportFile_GetSuggestedOutputFileNameL", CDRM_CAF::CImportFile_GetSuggestedOutputFileNameL ), |
|
465 ENTRY( "CImportFile_ContinueWithNewOutputFileL", CDRM_CAF::CImportFile_ContinueWithNewOutputFileL ), |
|
466 ENTRY( "CImportFile_ContentMimeTypeL", CDRM_CAF::CImportFile_ContentMimeTypeL ), |
|
467 ENTRY( "CRightsManager_ListRightsL", CDRM_CAF::CRightsManager_ListRightsL ), |
|
468 ENTRY( "CRightsManager_ListAllRightsL", CDRM_CAF::CRightsManager_ListAllRightsL ), |
|
469 ENTRY( "CRightsManager_ListContentL", CDRM_CAF::CRightsManager_ListContentL ), |
|
470 ENTRY( "CRightsManager_DeleteRightsObjectL", CDRM_CAF::CRightsManager_DeleteRightsObjectL ), |
|
471 ENTRY( "CRightsManager_DeleteAllRightsObjectsL", CDRM_CAF::CRightsManager_DeleteAllRightsObjectsL ), |
|
472 ENTRY( "CRightsManager_SetPropertyL", CDRM_CAF::CRightsManager_SetPropertyL ), |
|
473 ENTRY( "CDRMLicenseChecker_CheckLicenseL", CDRM_CAF::CDRMLicenseChecker_CheckLicenseL ), |
|
474 |
|
475 //ADD NEW ENTRY HERE |
|
476 // [test cases entries] - Do not remove |
|
477 |
|
478 }; |
|
479 |
|
480 const TInt count = sizeof( KFunctions ) / |
|
481 sizeof( TStifFunctionInfo ); |
|
482 |
|
483 return RunInternalL( KFunctions, count, aItem ); |
|
484 |
|
485 } |
|
486 |
|
487 TInt CDRM_CAF::CSupplier_Oma1XmlRoL() |
|
488 { |
|
489 |
|
490 CSupplier* supplier = CSupplier::NewLC(); |
|
491 CMetaDataArray* metaData = CMetaDataArray::NewLC(); |
|
492 CImportFile* file = supplier->ImportFileL(KOma1XmlRoContentType, |
|
493 *metaData); |
|
494 STIF_ASSERT_NOT_NULL( file ); |
|
495 CleanupStack::PushL(file); |
|
496 RUNCHECKEDL(file->WriteData(KROSimple)); |
|
497 RUNCHECKEDL(file->WriteDataComplete()); |
|
498 CleanupStack::PopAndDestroy(3); |
|
499 |
|
500 return KErrNone; |
|
501 } |
|
502 |
|
503 TInt CDRM_CAF::CSupplier_Oma1WbxmlRoL() |
|
504 { |
|
505 |
|
506 CSupplier* supplier = CSupplier::NewLC(); |
|
507 CMetaDataArray* metaData = CMetaDataArray::NewLC(); |
|
508 CImportFile* file = supplier->ImportFileL(KOma1WbxmlRoContentType, |
|
509 *metaData); |
|
510 STIF_ASSERT_NOT_NULL( file ); |
|
511 CleanupStack::PushL(file); |
|
512 RUNCHECKEDL(file->WriteData(KDRCSimple)); |
|
513 RUNCHECKEDL(file->WriteDataComplete()); |
|
514 CleanupStack::PopAndDestroy(3); |
|
515 |
|
516 return KErrNone; |
|
517 } |
|
518 |
|
519 |
|
520 TInt CDRM_CAF::CData_NewL() |
|
521 { |
|
522 CData* data; |
|
523 RFile file; |
|
524 |
|
525 TVirtualPathPtr dcf1(KOma1Content, KDefaultContentObject); |
|
526 TVirtualPathPtr dcf2(KOma2Content, KDefaultContentObject); |
|
527 TVirtualPathPtr dcf3(KOma2ContentNoEnc, KDefaultContentObject); |
|
528 |
|
529 |
|
530 data = CData::NewL(dcf1, EPeek, EContentShareReadOnly); |
|
531 STIF_ASSERT_NOT_NULL( data ); |
|
532 delete data; |
|
533 |
|
534 |
|
535 |
|
536 data = CData::NewL(dcf2, EPeek, EContentShareReadOnly); |
|
537 STIF_ASSERT_NOT_NULL( data ); |
|
538 delete data; |
|
539 |
|
540 |
|
541 |
|
542 data = CData::NewL(dcf3, EPeek, EContentShareReadOnly); |
|
543 STIF_ASSERT_NOT_NULL( data ); |
|
544 delete data; |
|
545 |
|
546 |
|
547 |
|
548 TInt err = file.Open(iFs, KOma1Content, EFileRead); |
|
549 CleanupClosePushL(file); |
|
550 data = CData::NewL(file, KDefaultContentObject, EPeek); |
|
551 STIF_ASSERT_NOT_NULL( data ); |
|
552 delete data; |
|
553 CleanupStack::PopAndDestroy(); |
|
554 |
|
555 |
|
556 |
|
557 err = file.Open(iFs, KOma2Content, EFileRead); |
|
558 CleanupClosePushL(file); |
|
559 data = CData::NewL(file, KDefaultContentObject, EPeek); |
|
560 STIF_ASSERT_NOT_NULL( data ); |
|
561 delete data; |
|
562 CleanupStack::PopAndDestroy(); |
|
563 |
|
564 |
|
565 |
|
566 err = file.Open(iFs, KOma2ContentNoEnc, EFileRead); |
|
567 CleanupClosePushL(file); |
|
568 data = CData::NewL(file, KDefaultContentObject, EPeek); |
|
569 STIF_ASSERT_NOT_NULL( data ); |
|
570 delete data; |
|
571 CleanupStack::PopAndDestroy(); |
|
572 |
|
573 |
|
574 |
|
575 err = file.Open(iFs, KOma2ContentNoEncTruncated, EFileRead); |
|
576 CleanupClosePushL(file); |
|
577 data = CData::NewL(file, KDefaultContentObject, EPeek); |
|
578 STIF_ASSERT_NOT_NULL( data ); |
|
579 delete data; |
|
580 CleanupStack::PopAndDestroy(); |
|
581 |
|
582 return KErrNone; |
|
583 } |
|
584 |
|
585 TInt CDRM_CAF::CData_Read_DataSize_SeekL() |
|
586 { |
|
587 CData* data = NULL; |
|
588 TFileName fileName; |
|
589 TBuf8<256> buffer; |
|
590 TInt size; |
|
591 TInt pos; |
|
592 TInt64 size64; |
|
593 TInt64 pos64; |
|
594 TInt r; |
|
595 fileName.Copy(KEncryptedDir); |
|
596 fileName.Append(KTempDcfName); |
|
597 TInt retval = KErrNone; |
|
598 TRequestStatus status; |
|
599 CActiveWaiter* waiter = CActiveWaiter::NewL(); |
|
600 CleanupStack::PushL(waiter); |
|
601 |
|
602 TVirtualPathPtr dcf1(fileName, KDefaultContentObject); |
|
603 TVirtualPathPtr dcf2(KOma2ContentNoEncTruncated, KDefaultContentObject); |
|
604 TVirtualPathPtr dcf3(KOma2ContentNoEnc, KDefaultContentObject); |
|
605 |
|
606 |
|
607 r=iFs.Delete(fileName); |
|
608 CSupplier* supplier = CSupplier::NewLC(); |
|
609 CMetaDataArray* metaData = CMetaDataArray::NewLC(); |
|
610 supplier->SetOutputDirectoryL(KEncryptedDir); |
|
611 CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType, |
|
612 *metaData, KTempDcfName); |
|
613 STIF_ASSERT_NOT_NULL( file ); |
|
614 CleanupStack::PushL(file); |
|
615 RUNCHECKEDL(file->WriteData(KDMSimple)); |
|
616 RUNCHECKEDL(file->WriteDataComplete()); |
|
617 STIF_ASSERT_EQUALS( 1, file->OutputFileCountL() ); |
|
618 CleanupStack::PopAndDestroy(3); |
|
619 |
|
620 |
|
621 |
|
622 data = CData::NewLC(dcf1, EView, EContentShareReadOnly); |
|
623 STIF_ASSERT_NOT_NULL( data ); |
|
624 data->DataSizeL(size); |
|
625 STIF_ASSERT_EQUALS( 300, size ); |
|
626 |
|
627 STIF_ASSERT_EQUALS( KErrAccessDenied, data->Read(buffer, 10) ); // Cannot decrypt with SDK |
|
628 CleanupStack::PopAndDestroy( data ); |
|
629 |
|
630 |
|
631 |
|
632 data = CData::NewLC(dcf2, EPlay, EContentShareReadOnly); |
|
633 STIF_ASSERT_NOT_NULL( data ); |
|
634 data->DataSizeL(size); |
|
635 CleanupStack::PopAndDestroy( data ); |
|
636 |
|
637 |
|
638 |
|
639 data = CData::NewLC(dcf3, EPlay, EContentShareReadOnly); |
|
640 STIF_ASSERT_NOT_NULL( data ); |
|
641 data->DataSizeL(size); |
|
642 |
|
643 RUNCHECKED(data->ExecuteIntent(EPlay)); |
|
644 RUNCHECKED(data->Read(buffer, 8)); |
|
645 STIF_ASSERT_EQUALS( 0, buffer.Compare(_L8("34567890"))); |
|
646 pos = 100; |
|
647 RUNCHECKED(data->Seek(ESeekStart, pos)); |
|
648 |
|
649 data->Read(buffer, 8, status); |
|
650 User::WaitForRequest(status); |
|
651 |
|
652 STIF_ASSERT_EQUALS( 0, buffer.Compare(_L8("00000000"))); |
|
653 data->Read(buffer, status); |
|
654 User::WaitForRequest(status); |
|
655 |
|
656 CleanupStack::PopAndDestroy( data ); |
|
657 |
|
658 data = CData::NewLC(dcf3, EPlay, EContentShareReadOnly); |
|
659 STIF_ASSERT_NOT_NULL( data ); |
|
660 data->DataSize64L(size64); |
|
661 |
|
662 RUNCHECKED(data->ExecuteIntent(EPlay)); |
|
663 pos64 = 100; |
|
664 RUNCHECKED(data->Seek64(ESeekStart, pos64)); |
|
665 |
|
666 data->Read(pos64, buffer, 8, waiter->GetStatus()); |
|
667 waiter->StartWait(); |
|
668 |
|
669 STIF_ASSERT_EQUALS( 0, buffer.Compare(_L8("00000000"))); |
|
670 |
|
671 CleanupStack::PopAndDestroy( data ); |
|
672 CleanupStack::PopAndDestroy( waiter ); |
|
673 |
|
674 return KErrNone; |
|
675 } |
|
676 |
|
677 TInt CDRM_CAF::CData_Read2L() |
|
678 { |
|
679 CData* data = NULL; |
|
680 TFileName fileName; |
|
681 TBuf8<256> buffer; |
|
682 TInt size; |
|
683 TInt pos; |
|
684 TInt r; |
|
685 CSupplier* supplier = NULL; |
|
686 CMetaDataArray* metaData = NULL; |
|
687 CImportFile* file = NULL; |
|
688 |
|
689 fileName.Copy(KEncryptedDir); |
|
690 fileName.Append(KTempDcfName); |
|
691 |
|
692 TVirtualPathPtr dcf1(fileName, KDefaultContentObject); |
|
693 TVirtualPathPtr dcf2(KOma2ContentNoEncTruncated, KDefaultContentObject); |
|
694 TVirtualPathPtr dcf3(KOma2ContentNoEnc, KDefaultContentObject); |
|
695 |
|
696 |
|
697 r = iFs.Delete(fileName); |
|
698 STIF_ASSERT_EQUALS( KErrNone, r); |
|
699 supplier = CSupplier::NewLC(); |
|
700 metaData = CMetaDataArray::NewLC(); |
|
701 supplier->SetOutputDirectoryL(KEncryptedDir); |
|
702 file = supplier->ImportFileL(KOma1DrmMessageContentType, |
|
703 *metaData, KTempDcfName); |
|
704 STIF_ASSERT_NOT_NULL( file ); |
|
705 CleanupStack::PushL(file); |
|
706 RUNCHECKEDL(file->WriteData(KDMHead)); |
|
707 for (pos = 0; pos < 500; pos++) |
|
708 { |
|
709 file->WriteData(KDMContent); |
|
710 } |
|
711 RUNCHECKEDL(file->WriteData(KDMTail)); |
|
712 RUNCHECKEDL(file->WriteDataComplete()); |
|
713 STIF_ASSERT_EQUALS( 1, file->OutputFileCountL()); |
|
714 CleanupStack::PopAndDestroy(3); |
|
715 |
|
716 |
|
717 |
|
718 data = CData::NewLC(dcf1, EView, EContentShareReadOnly); |
|
719 STIF_ASSERT_NOT_NULL( data ); |
|
720 data->DataSizeL(size); |
|
721 STIF_ASSERT_EQUALS( 5000, size); |
|
722 STIF_ASSERT_EQUALS( KErrAccessDenied, data->ExecuteIntent(EView) ); // Cannot decrypt with SDK |
|
723 CleanupStack::PopAndDestroy(); // data |
|
724 |
|
725 |
|
726 |
|
727 data = CData::NewLC(dcf1, EView, EContentShareReadOnly); |
|
728 STIF_ASSERT_NOT_NULL( data ); |
|
729 data->DataSizeL(size); |
|
730 STIF_ASSERT_EQUALS( 5000, size); |
|
731 CleanupStack::PopAndDestroy(); |
|
732 |
|
733 return KErrNone; |
|
734 } |
|
735 TInt CDRM_CAF::CData_SetPropertyL() |
|
736 { |
|
737 CData* data; |
|
738 TInt r; |
|
739 TBool r1 = EFalse; |
|
740 |
|
741 TVirtualPathPtr dcf2(KOma2Content, KDefaultContentObject); |
|
742 |
|
743 |
|
744 data = CData::NewLC(dcf2, EPeek, EContentShareReadOnly); |
|
745 STIF_ASSERT_NOT_NULL( data ); |
|
746 r = data->SetProperty(EAgentPropertyBufferSize, 1024); |
|
747 if(r == KErrCANotSupported || r == KErrNone) |
|
748 { |
|
749 r1 = ETrue; |
|
750 } |
|
751 STIF_ASSERT_TRUE(r1); |
|
752 r1 = EFalse; |
|
753 r = data->SetProperty(EAgentPropertyAgentUI, 1); |
|
754 if(r == KErrCANotSupported || r == KErrNone) |
|
755 { |
|
756 r1 = ETrue; |
|
757 } |
|
758 STIF_ASSERT_TRUE(r1); |
|
759 r1 = EFalse; |
|
760 r = data->SetProperty(EAgentPropertyMultipleSequence, 1); |
|
761 if(r == KErrCANotSupported || r == KErrNone) |
|
762 { |
|
763 r1 = ETrue; |
|
764 } |
|
765 STIF_ASSERT_TRUE(r1); |
|
766 CleanupStack::PopAndDestroy(); |
|
767 |
|
768 return KErrNone; |
|
769 } |
|
770 |
|
771 TInt CDRM_CAF::CData_EvaluateIntentL() |
|
772 { |
|
773 TFileName fileName; |
|
774 TInt r; |
|
775 TBool r1 = EFalse; |
|
776 TInt i; |
|
777 |
|
778 |
|
779 fileName.Copy(KFVariantFile); |
|
780 // Clearing file before first testcase |
|
781 iFs.Delete(fileName); |
|
782 |
|
783 fileName.Copy(KEncryptedDir); |
|
784 fileName.Append(KTempDcfName); |
|
785 r = iFs.Delete(fileName); |
|
786 STIF_ASSERT_EQUALS( KErrNone, r); |
|
787 CSupplier* supplier = CSupplier::NewLC(); |
|
788 CMetaDataArray* metaData = CMetaDataArray::NewLC(); |
|
789 supplier->SetOutputDirectoryL(KEncryptedDir); |
|
790 CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType, |
|
791 *metaData, KTempDcfName); |
|
792 STIF_ASSERT_NOT_NULL( file ); |
|
793 CleanupStack::PushL(file); |
|
794 r = file->WriteData(KDMCDCount); |
|
795 if (r == KErrNotSupported) |
|
796 { |
|
797 // Forward lock variant |
|
798 RFileWriteStream outFlV; |
|
799 outFlV.Create(iFs, KFVariantFile, EFileWrite ); |
|
800 outFlV.Close(); |
|
801 CleanupStack::PopAndDestroy(3); |
|
802 return KErrNone; |
|
803 } |
|
804 RUNCHECKEDL(file->WriteDataComplete()); |
|
805 STIF_ASSERT_EQUALS( 1, file->OutputFileCountL()); |
|
806 CleanupStack::PopAndDestroy(3); |
|
807 |
|
808 |
|
809 |
|
810 TVirtualPathPtr dcf(fileName, KDefaultContentObject); |
|
811 CData* data = CData::NewLC(dcf, EView, EContentShareReadOnly); |
|
812 STIF_ASSERT_NOT_NULL( data ); |
|
813 r = data->EvaluateIntent(EView); |
|
814 STIF_ASSERT_EQUALS( KErrNone, r); |
|
815 r = data->EvaluateIntent(EPause); |
|
816 STIF_ASSERT_EQUALS( KErrNone, r); |
|
817 r = data->EvaluateIntent(EContinue); |
|
818 STIF_ASSERT_EQUALS( KErrNone, r); |
|
819 r = data->EvaluateIntent(EStop); |
|
820 STIF_ASSERT_EQUALS( KErrNone, r); |
|
821 r = data->EvaluateIntent(EPeek); |
|
822 STIF_ASSERT_EQUALS( KErrNone, r); |
|
823 r = data->EvaluateIntent(EInstall); |
|
824 STIF_ASSERT_EQUALS( KErrNone, r); |
|
825 r = data->EvaluateIntent(EPlay); |
|
826 STIF_ASSERT_EQUALS( KErrCANoPermission, r); |
|
827 r = data->EvaluateIntent(EPrint); |
|
828 STIF_ASSERT_EQUALS( KErrCANoPermission, r); |
|
829 r = data->EvaluateIntent(EExecute); |
|
830 STIF_ASSERT_EQUALS( KErrCANoPermission, r); |
|
831 CleanupStack::PopAndDestroy(); |
|
832 |
|
833 |
|
834 |
|
835 data = CData::NewL(TVirtualPathPtr(KOma2ContentNoEnc, KDefaultContentObject), |
|
836 EPeek, EContentShareReadOnly); |
|
837 STIF_ASSERT_NOT_NULL( data ); |
|
838 STIF_ASSERT_EQUALS( KErrNone, data->EvaluateIntent(EPlay)); |
|
839 STIF_ASSERT_NOT_EQUALS(KErrNone ,data->EvaluateIntent(EView) ); |
|
840 STIF_ASSERT_NOT_EQUALS(KErrNone ,data->EvaluateIntent(EPrint) ); |
|
841 STIF_ASSERT_NOT_EQUALS(KErrNone ,data->EvaluateIntent(EExecute) ); |
|
842 STIF_ASSERT_EQUALS(KErrNone ,data->EvaluateIntent(EPause) ); |
|
843 STIF_ASSERT_EQUALS(KErrNone ,data->EvaluateIntent(EStop) ); |
|
844 STIF_ASSERT_EQUALS(KErrNone ,data->EvaluateIntent(EContinue) ); |
|
845 delete data; |
|
846 |
|
847 |
|
848 |
|
849 fileName.Copy(KEncryptedDir); |
|
850 fileName.Append(KTempDcfName); |
|
851 r = iFs.Delete(fileName); |
|
852 STIF_ASSERT_EQUALS(KErrNone ,r); |
|
853 supplier = CSupplier::NewLC(); |
|
854 metaData = CMetaDataArray::NewLC(); |
|
855 metaData->AddL(KOmaImportMimeTypeField, _L8("image/jpeg")); |
|
856 supplier->SetOutputDirectoryL(KEncryptedDir); |
|
857 file = supplier->ImportFileL(KOmaImportContentType, *metaData, KTempDcfName); |
|
858 STIF_ASSERT_NOT_NULL( file ); |
|
859 CleanupStack::PushL(file); |
|
860 for (i = 0; i < 10; i++) |
|
861 { |
|
862 RUNCHECKEDL(file->WriteData(KDMContent)); |
|
863 } |
|
864 RUNCHECKEDL(file->WriteDataComplete()); |
|
865 STIF_ASSERT_EQUALS(1 ,file->OutputFileCountL()); |
|
866 CleanupStack::PopAndDestroy(3); |
|
867 |
|
868 |
|
869 |
|
870 data = CData::NewL(TVirtualPathPtr(fileName, KDefaultContentObject), |
|
871 EPeek, EContentShareReadOnly); |
|
872 STIF_ASSERT_NOT_NULL( data ); |
|
873 |
|
874 r = data->EvaluateIntent(EPlay); |
|
875 iLog->Log(_L(" Evaluate intent returned: %d \r\n"), r); |
|
876 STIF_ASSERT_NOT_EQUALS(KErrNone , r); |
|
877 |
|
878 |
|
879 r = data->EvaluateIntent(EView); |
|
880 iLog->Log(_L(" Evaluate intent returned: %d \r\n"), r); |
|
881 if(r == -17452 || r == -17451 || r == 0) |
|
882 { |
|
883 r1 = ETrue; |
|
884 } |
|
885 STIF_ASSERT_TRUE(r1); |
|
886 r1 = EFalse; |
|
887 r = data->EvaluateIntent(EPrint); |
|
888 iLog->Log(_L(" Evaluate intent returned: %d \r\n"), r); |
|
889 if(r == -17452 || r == -17451 || r == 0) |
|
890 { |
|
891 r1 = ETrue; |
|
892 } |
|
893 STIF_ASSERT_TRUE(r1); |
|
894 |
|
895 r = data->EvaluateIntent(EExecute); |
|
896 iLog->Log(_L(" Evaluate intent returned: %d \r\n"), r); |
|
897 STIF_ASSERT_NOT_EQUALS(KErrNone , r); |
|
898 |
|
899 |
|
900 delete data; |
|
901 |
|
902 |
|
903 |
|
904 fileName.Copy(KEncryptedDir ); |
|
905 fileName.Append(KTempDcfName); |
|
906 r = iFs.Delete(fileName); |
|
907 STIF_ASSERT_EQUALS(KErrNone , r); |
|
908 supplier = CSupplier::NewLC(); |
|
909 metaData = CMetaDataArray::NewLC(); |
|
910 metaData->AddL(KOmaImportMimeTypeField, _L8("audio/mpeg")); |
|
911 supplier->SetOutputDirectoryL(KEncryptedDir); |
|
912 file = supplier->ImportFileL(KOmaImportContentType, *metaData, KTempDcfName); |
|
913 STIF_ASSERT_NOT_NULL( file ); |
|
914 CleanupStack::PushL(file); |
|
915 for (i = 0; i < 10; i++) |
|
916 { |
|
917 RUNCHECKEDL(file->WriteData(KDMContent)); |
|
918 } |
|
919 RUNCHECKEDL(file->WriteDataComplete()); |
|
920 STIF_ASSERT_EQUALS(1 , file->OutputFileCountL()); |
|
921 CleanupStack::PopAndDestroy(3); |
|
922 |
|
923 |
|
924 |
|
925 data = CData::NewL(TVirtualPathPtr(fileName, KDefaultContentObject), |
|
926 EPeek, EContentShareReadOnly); |
|
927 STIF_ASSERT_NOT_NULL( data ); |
|
928 r1 = EFalse; |
|
929 r = data->EvaluateIntent(EPlay); |
|
930 iLog->Log(_L(" Evaluate intent returned: %d \r\n"), r); |
|
931 if(r == -17452 || r == -17451 || r == 0) |
|
932 { |
|
933 r1 = ETrue; |
|
934 } |
|
935 STIF_ASSERT_TRUE(r1); |
|
936 |
|
937 STIF_ASSERT_NOT_EQUALS(KErrNone , data->EvaluateIntent(EView)); |
|
938 STIF_ASSERT_NOT_EQUALS(KErrNone , data->EvaluateIntent(EPrint)); |
|
939 STIF_ASSERT_NOT_EQUALS(KErrNone , data->EvaluateIntent(EExecute)); |
|
940 delete data; |
|
941 |
|
942 return KErrNone; |
|
943 } |
|
944 |
|
945 TInt CDRM_CAF::CData_ExecuteIntentL() |
|
946 { |
|
947 RFile fileFLV; |
|
948 |
|
949 TInt err = fileFLV.Open(iFs,KFVariantFile, EFileRead); |
|
950 if( err == 0 ) |
|
951 { |
|
952 iLog->Log(_L(" Skipped in FL variant \r\n" )); |
|
953 fileFLV.Close(); |
|
954 return KErrNone; |
|
955 } |
|
956 fileFLV.Close(); |
|
957 |
|
958 TFileName fileName; |
|
959 TInt r; |
|
960 TInt i; |
|
961 TBool r1 = EFalse; |
|
962 |
|
963 |
|
964 fileName.Copy(KEncryptedDir); |
|
965 fileName.Append(KTempDcfName); |
|
966 r = iFs.Delete(fileName); |
|
967 STIF_ASSERT_EQUALS(KErrNone , r); |
|
968 CSupplier* supplier = CSupplier::NewLC(); |
|
969 CMetaDataArray* metaData = CMetaDataArray::NewLC(); |
|
970 supplier->SetOutputDirectoryL(KEncryptedDir); |
|
971 CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType, |
|
972 *metaData, KTempDcfName); |
|
973 STIF_ASSERT_NOT_NULL( file ); |
|
974 CleanupStack::PushL(file); |
|
975 RUNCHECKEDL(file->WriteData(KDMCDCount)); |
|
976 RUNCHECKEDL(file->WriteDataComplete()); |
|
977 STIF_ASSERT_EQUALS(1 , file->OutputFileCountL()); |
|
978 CleanupStack::PopAndDestroy(3); |
|
979 |
|
980 |
|
981 // Start the tests |
|
982 |
|
983 TVirtualPathPtr dcf(fileName, KDefaultContentObject); |
|
984 CData* data = CData::NewLC(dcf, EView, EContentShareReadOnly); |
|
985 STIF_ASSERT_NOT_NULL( data ); |
|
986 |
|
987 |
|
988 // illegal: let's start with EPause |
|
989 r = data->ExecuteIntent(EPause); |
|
990 iLog->Log(_L(" Execute intent returned: %d \r\n"), r); |
|
991 STIF_ASSERT_EQUALS( KErrNotReady, r ); |
|
992 |
|
993 r = data->ExecuteIntent(EContinue); |
|
994 iLog->Log(_L(" Execute intent returned: %d \r\n"), r); |
|
995 STIF_ASSERT_EQUALS( KErrNotReady, r ); |
|
996 |
|
997 r = data->ExecuteIntent(EView); |
|
998 iLog->Log(_L(" Execute intent returned: %d \r\n"), r); |
|
999 STIF_ASSERT_EQUALS( KErrAccessDenied , r ); |
|
1000 |
|
1001 r = data->ExecuteIntent(EPause); |
|
1002 iLog->Log(_L(" Execute intent returned: %d \r\n"), r); |
|
1003 STIF_ASSERT_EQUALS( KErrNotReady , r); |
|
1004 |
|
1005 r = data->ExecuteIntent(EContinue); |
|
1006 iLog->Log(_L(" Execute intent returned: %d \r\n"), r); |
|
1007 STIF_ASSERT_EQUALS( KErrNotReady, r); |
|
1008 |
|
1009 r = data->ExecuteIntent(EStop); |
|
1010 iLog->Log(_L(" Execute intent returned: %d \r\n"), r); |
|
1011 STIF_ASSERT_EQUALS( KErrNone, r); |
|
1012 |
|
1013 r = data->ExecuteIntent(EPeek); |
|
1014 iLog->Log(_L(" Execute intent returned: %d \r\n"), r); |
|
1015 STIF_ASSERT_EQUALS( KErrAccessDenied, r); |
|
1016 |
|
1017 r = data->ExecuteIntent(EInstall); |
|
1018 iLog->Log(_L(" Execute intent returned: %d \r\n"), r); |
|
1019 STIF_ASSERT_EQUALS( KErrAccessDenied, r); |
|
1020 |
|
1021 r = data->ExecuteIntent(EPlay); |
|
1022 iLog->Log(_L(" Execute intent returned: %d \r\n"), r); |
|
1023 STIF_ASSERT_EQUALS( KErrCANoPermission, r); |
|
1024 |
|
1025 r = data->ExecuteIntent(EPrint); |
|
1026 iLog->Log(_L(" Execute intent returned: %d \r\n"), r); |
|
1027 STIF_ASSERT_EQUALS( KErrCANoPermission, r); |
|
1028 |
|
1029 r = data->ExecuteIntent(EExecute); |
|
1030 iLog->Log(_L(" Execute intent returned: %d \r\n"), r); |
|
1031 STIF_ASSERT_EQUALS( KErrCANoPermission, r); |
|
1032 |
|
1033 r = data->ExecuteIntent(EView); |
|
1034 iLog->Log(_L(" Execute intent returned: %d \r\n"), r); |
|
1035 STIF_ASSERT_EQUALS( KErrAccessDenied, r); |
|
1036 |
|
1037 CleanupStack::PopAndDestroy(); |
|
1038 |
|
1039 |
|
1040 |
|
1041 data = CData::NewL(TVirtualPathPtr(KOma2ContentNoEnc, KDefaultContentObject), |
|
1042 EPeek, EContentShareReadOnly); |
|
1043 STIF_ASSERT_NOT_NULL( data ); |
|
1044 STIF_ASSERT_EQUALS(KErrNone ,data->ExecuteIntent(EPlay) ); |
|
1045 STIF_ASSERT_NOT_EQUALS(KErrNone ,data->ExecuteIntent(EView) ); |
|
1046 STIF_ASSERT_NOT_EQUALS(KErrNone ,data->ExecuteIntent(EPrint) ); |
|
1047 STIF_ASSERT_NOT_EQUALS(KErrNone ,data->ExecuteIntent(EExecute) ); |
|
1048 STIF_ASSERT_EQUALS(KErrNone ,data->ExecuteIntent(EPause) ); |
|
1049 STIF_ASSERT_EQUALS(KErrNone ,data->ExecuteIntent(EStop) ); |
|
1050 STIF_ASSERT_EQUALS(KErrNone ,data->ExecuteIntent(EContinue) ); |
|
1051 delete data; |
|
1052 |
|
1053 |
|
1054 |
|
1055 fileName.Copy(KEncryptedDir); |
|
1056 fileName.Append(KTempDcfName); |
|
1057 r = iFs.Delete(fileName); |
|
1058 STIF_ASSERT_EQUALS(KErrNone ,r ); |
|
1059 supplier = CSupplier::NewLC(); |
|
1060 metaData = CMetaDataArray::NewLC(); |
|
1061 metaData->AddL(KOmaImportMimeTypeField, _L8("image/jpeg")); |
|
1062 supplier->SetOutputDirectoryL(KEncryptedDir); |
|
1063 file = supplier->ImportFileL(KOmaImportContentType, *metaData, KTempDcfName); |
|
1064 STIF_ASSERT_NOT_NULL( file ); |
|
1065 CleanupStack::PushL(file); |
|
1066 for (i = 0; i < 10; i++) |
|
1067 { |
|
1068 RUNCHECKEDL(file->WriteData(KDMContent)); |
|
1069 } |
|
1070 RUNCHECKEDL(file->WriteDataComplete()); |
|
1071 STIF_ASSERT_EQUALS(1 ,file->OutputFileCountL() ); |
|
1072 CleanupStack::PopAndDestroy(3); |
|
1073 |
|
1074 |
|
1075 |
|
1076 data = CData::NewL(TVirtualPathPtr(fileName, KDefaultContentObject), |
|
1077 EPeek, EContentShareReadOnly); |
|
1078 STIF_ASSERT_NOT_NULL( data ); |
|
1079 |
|
1080 STIF_ASSERT_NOT_EQUALS( KErrNone, data->ExecuteIntent(EPlay)); |
|
1081 r = data->ExecuteIntent(EView); |
|
1082 iLog->Log(_L(" Execute intent returned: %d \r\n"), r); |
|
1083 if(r == -17452 || r == -17451 || r == -21 ) |
|
1084 { |
|
1085 r1 = ETrue; |
|
1086 } |
|
1087 STIF_ASSERT_TRUE(r1); |
|
1088 |
|
1089 r1 = EFalse; |
|
1090 r = data->ExecuteIntent(EPrint); |
|
1091 iLog->Log(_L(" Execute intent returned: %d \r\n"), r); |
|
1092 if(r == -17452 || r == -17451 || r == -21 ) |
|
1093 { |
|
1094 r1 = ETrue; |
|
1095 } |
|
1096 STIF_ASSERT_TRUE(r1); |
|
1097 |
|
1098 STIF_ASSERT_NOT_EQUALS( KErrNone, data->ExecuteIntent(EExecute)); |
|
1099 delete data; |
|
1100 |
|
1101 |
|
1102 |
|
1103 fileName.Copy(KEncryptedDir); |
|
1104 fileName.Append(KTempDcfName); |
|
1105 r = iFs.Delete(fileName); |
|
1106 STIF_ASSERT_EQUALS( KErrNone, r); |
|
1107 supplier = CSupplier::NewLC(); |
|
1108 metaData = CMetaDataArray::NewLC(); |
|
1109 metaData->AddL(KOmaImportMimeTypeField, _L8("audio/mpeg")); |
|
1110 supplier->SetOutputDirectoryL(KEncryptedDir); |
|
1111 file = supplier->ImportFileL(KOmaImportContentType, *metaData, KTempDcfName); |
|
1112 STIF_ASSERT_NOT_NULL( file ); |
|
1113 CleanupStack::PushL(file); |
|
1114 for (i = 0; i < 10; i++) |
|
1115 { |
|
1116 RUNCHECKEDL(file->WriteData(KDMContent)); |
|
1117 } |
|
1118 RUNCHECKEDL(file->WriteDataComplete()); |
|
1119 STIF_ASSERT_EQUALS( 1, file->OutputFileCountL()); |
|
1120 CleanupStack::PopAndDestroy(3); |
|
1121 |
|
1122 |
|
1123 |
|
1124 data = CData::NewL(TVirtualPathPtr(fileName, KDefaultContentObject), |
|
1125 EPeek, EContentShareReadOnly); |
|
1126 |
|
1127 STIF_ASSERT_NOT_NULL( data ); |
|
1128 |
|
1129 r1 = EFalse; |
|
1130 r = data->ExecuteIntent(EPlay); |
|
1131 iLog->Log(_L(" Execute intent returned: %d \r\n"), r); |
|
1132 if(r == -17452 || r == -17451 || r == -21 ) |
|
1133 { |
|
1134 r1 = ETrue; |
|
1135 } |
|
1136 STIF_ASSERT_TRUE(r1); |
|
1137 |
|
1138 STIF_ASSERT_NOT_EQUALS( KErrNone, data->ExecuteIntent(EView)); |
|
1139 |
|
1140 |
|
1141 STIF_ASSERT_NOT_EQUALS( KErrNone, data->ExecuteIntent(EPrint)); |
|
1142 |
|
1143 |
|
1144 STIF_ASSERT_NOT_EQUALS( KErrNone, data->ExecuteIntent(EExecute)); |
|
1145 |
|
1146 delete data; |
|
1147 |
|
1148 return KErrNone; |
|
1149 } |
|
1150 |
|
1151 TInt CDRM_CAF::CData_GetAttributeL() |
|
1152 { |
|
1153 CData* data = NULL; |
|
1154 TVirtualPathPtr dcf1(KOma1Content, KDefaultContentObject); |
|
1155 TVirtualPathPtr dcf2(KOma2Content, KDefaultContentObject); |
|
1156 TVirtualPathPtr dcf3(KOma2ContentNoEnc, KDefaultContentObject); |
|
1157 TInt value; |
|
1158 TInt i; |
|
1159 |
|
1160 |
|
1161 data = CData::NewLC(dcf1, EPeek, EContentShareReadOnly); |
|
1162 STIF_ASSERT_NOT_NULL( data ); |
|
1163 RUNCHECKEDL(data->GetAttribute(EIsProtected, value)); |
|
1164 STIF_ASSERT_EQUALS( 1, value); |
|
1165 RUNCHECKEDL(data->GetAttribute(EFileType, value)); |
|
1166 STIF_ASSERT_EQUALS( 1, value); |
|
1167 for (i = 0; i < NUM_ELEMENTS(KAttributes); i++) |
|
1168 { |
|
1169 data->GetAttribute(KAttributes[i], value); |
|
1170 } |
|
1171 CleanupStack::PopAndDestroy(); |
|
1172 |
|
1173 |
|
1174 |
|
1175 data = CData::NewLC(dcf2, EPeek, EContentShareReadOnly); |
|
1176 STIF_ASSERT_NOT_NULL( data ); |
|
1177 RUNCHECKEDL(data->GetAttribute(EIsProtected, value)); |
|
1178 STIF_ASSERT_EQUALS( 1, value); |
|
1179 RUNCHECKEDL(data->GetAttribute(EFileType, value)); |
|
1180 STIF_ASSERT_EQUALS( 2, value); |
|
1181 for (i = 0; i < NUM_ELEMENTS(KAttributes); i++) |
|
1182 { |
|
1183 data->GetAttribute(KAttributes[i], value); |
|
1184 } |
|
1185 CleanupStack::PopAndDestroy(); |
|
1186 |
|
1187 |
|
1188 |
|
1189 data = CData::NewLC(dcf3, EPeek, EContentShareReadOnly); |
|
1190 STIF_ASSERT_NOT_NULL( data ); |
|
1191 RUNCHECKEDL(data->GetAttribute(EIsProtected, value)); |
|
1192 STIF_ASSERT_EQUALS( 0, value); |
|
1193 RUNCHECKEDL(data->GetAttribute(EFileType, value)); |
|
1194 STIF_ASSERT_EQUALS( 2, value); |
|
1195 for (i = 0; i < NUM_ELEMENTS(KAttributes); i++) |
|
1196 { |
|
1197 data->GetAttribute(KAttributes[i], value); |
|
1198 } |
|
1199 CleanupStack::PopAndDestroy(); |
|
1200 |
|
1201 return KErrNone; |
|
1202 } |
|
1203 |
|
1204 TInt CDRM_CAF::CData_GetAttributeSetL() |
|
1205 { |
|
1206 CData* data = NULL; |
|
1207 TVirtualPathPtr dcf1(KOma1Content, KDefaultContentObject); |
|
1208 TVirtualPathPtr dcf2(KOma2Content, KDefaultContentObject); |
|
1209 RAttributeSet attributes; |
|
1210 TInt value; |
|
1211 |
|
1212 attributes.AddL(EIsProtected); |
|
1213 attributes.AddL(EFileType); |
|
1214 |
|
1215 data = CData::NewLC(dcf1, EPeek, EContentShareReadOnly); |
|
1216 STIF_ASSERT_NOT_NULL( data ); |
|
1217 RUNCHECKEDL(data->GetAttributeSet(attributes)); |
|
1218 RUNCHECKEDL(attributes.GetValue(EIsProtected, value)); |
|
1219 STIF_ASSERT_EQUALS( 1, value); |
|
1220 RUNCHECKED(attributes.GetValue(EFileType, value)); |
|
1221 STIF_ASSERT_EQUALS( 1, value); |
|
1222 CleanupStack::PopAndDestroy(); |
|
1223 |
|
1224 |
|
1225 |
|
1226 data = CData::NewLC(dcf2, EPeek, EContentShareReadOnly); |
|
1227 STIF_ASSERT_NOT_NULL( data ); |
|
1228 RUNCHECKEDL(data->GetAttributeSet(attributes)); |
|
1229 RUNCHECKEDL(attributes.GetValue(EIsProtected, value)); |
|
1230 STIF_ASSERT_EQUALS( 1, value); |
|
1231 RUNCHECKED(attributes.GetValue(EFileType, value)); |
|
1232 STIF_ASSERT_EQUALS( 2, value); |
|
1233 CleanupStack::PopAndDestroy(); |
|
1234 |
|
1235 attributes.Close(); |
|
1236 return KErrNone; |
|
1237 } |
|
1238 |
|
1239 TInt CDRM_CAF::CData_GetStringAttributeL() |
|
1240 { |
|
1241 TVirtualPathPtr dcf1(KOma1Content, KDefaultContentObject); |
|
1242 TVirtualPathPtr dcf2(KOma2Content, KDefaultContentObject); |
|
1243 TVirtualPathPtr dcf3(KOma2Content, KDefaultContentObject); |
|
1244 CData* data = NULL; |
|
1245 HBufC* buffer = HBufC::NewLC(256000); |
|
1246 TPtr value(NULL, 0); |
|
1247 TInt i; |
|
1248 |
|
1249 value.Set(buffer->Des()); |
|
1250 |
|
1251 data = CData::NewLC(dcf1, EPeek, EContentShareReadOnly); |
|
1252 STIF_ASSERT_NOT_NULL( data ); |
|
1253 RUNCHECKEDL(data->GetStringAttribute(EMimeType, value)); |
|
1254 STIF_ASSERT_EQUALS( 0, value.Compare(_L("text/plain"))); |
|
1255 for (i = 0; i < NUM_ELEMENTS(KStringAttributes); i++) |
|
1256 { |
|
1257 data->GetStringAttribute(KStringAttributes[i], value); |
|
1258 } |
|
1259 CleanupStack::PopAndDestroy(); |
|
1260 |
|
1261 |
|
1262 |
|
1263 data = CData::NewLC(dcf2, EPeek, EContentShareReadOnly); |
|
1264 STIF_ASSERT_NOT_NULL( data ); |
|
1265 RUNCHECKEDL(data->GetStringAttribute(EMimeType, value)); |
|
1266 STIF_ASSERT_EQUALS( 0, value.Compare(_L("audio/wav"))); |
|
1267 for (i = 0; i < NUM_ELEMENTS(KStringAttributes); i++) |
|
1268 { |
|
1269 data->GetStringAttribute(KStringAttributes[i], value); |
|
1270 } |
|
1271 CleanupStack::PopAndDestroy(); |
|
1272 |
|
1273 |
|
1274 |
|
1275 data = CData::NewLC(dcf3, EPeek, EContentShareReadOnly); |
|
1276 STIF_ASSERT_NOT_NULL( data ); |
|
1277 RUNCHECKEDL(data->GetStringAttribute(EMimeType, value)); |
|
1278 STIF_ASSERT_EQUALS( 0, value.Compare(_L("audio/wav"))); |
|
1279 for (i = 0; i < NUM_ELEMENTS(KStringAttributes); i++) |
|
1280 { |
|
1281 data->GetStringAttribute(KStringAttributes[i], value); |
|
1282 } |
|
1283 CleanupStack::PopAndDestroy(); |
|
1284 |
|
1285 CleanupStack::PopAndDestroy(); |
|
1286 return KErrNone; |
|
1287 } |
|
1288 |
|
1289 TInt CDRM_CAF::CData_GetStringAttributeSetL() |
|
1290 { |
|
1291 RFile fileFLV; |
|
1292 |
|
1293 TInt err = fileFLV.Open(iFs,KFVariantFile, EFileRead); |
|
1294 if( err == 0 ) |
|
1295 { |
|
1296 iLog->Log(_L(" Skipped in FL variant \r\n" )); |
|
1297 fileFLV.Close(); |
|
1298 return KErrNone; |
|
1299 } |
|
1300 fileFLV.Close(); |
|
1301 |
|
1302 TVirtualPathPtr dcf1(KOma1Content, KDefaultContentObject); |
|
1303 TVirtualPathPtr dcf2(KOma2Content, KDefaultContentObject); |
|
1304 CData* data = NULL; |
|
1305 RStringAttributeSet attributes; |
|
1306 HBufC* buffer = HBufC::NewLC(256000); |
|
1307 TPtr value(NULL, 0); |
|
1308 TBool r1 = EFalse; |
|
1309 value.Set(buffer->Des()); |
|
1310 attributes.AddL(EMimeType); |
|
1311 attributes.AddL(ERightsIssuerUrl); |
|
1312 data = CData::NewLC(dcf1, EPeek, EContentShareReadOnly); |
|
1313 //CHECKL(data != NULL); |
|
1314 STIF_ASSERT_NOT_NULL( data ); |
|
1315 RUNCHECKEDL(data->GetStringAttributeSet(attributes)); |
|
1316 RUNCHECKEDL(attributes.GetValue(EMimeType, value)); |
|
1317 STIF_ASSERT_EQUALS(0 , value.Compare(_L("text/plain"))); |
|
1318 STIF_ASSERT_EQUALS(KErrCANotSupported , attributes.GetValue(ERightsIssuerUrl, value)); |
|
1319 CleanupStack::PopAndDestroy(); |
|
1320 |
|
1321 data = CData::NewLC(dcf2, EPeek, EContentShareReadOnly); |
|
1322 STIF_ASSERT_NOT_NULL( data ); |
|
1323 RUNCHECKEDL(data->GetStringAttributeSet(attributes)); |
|
1324 RUNCHECKEDL(attributes.GetValue(EMimeType, value)); |
|
1325 STIF_ASSERT_EQUALS( 0, value.Compare(_L("audio/wav"))); |
|
1326 TInt rr = attributes.GetValue(ERightsIssuerUrl, value); |
|
1327 if(rr == KErrCANotSupported || rr == KErrNone) |
|
1328 { |
|
1329 r1 = ETrue; |
|
1330 } |
|
1331 STIF_ASSERT_TRUE(r1); |
|
1332 r1 = EFalse; |
|
1333 if(value.Length() > 0) |
|
1334 { |
|
1335 r1 = ETrue; |
|
1336 } |
|
1337 STIF_ASSERT_TRUE(r1); |
|
1338 CleanupStack::PopAndDestroy(); |
|
1339 CleanupStack::PopAndDestroy(); |
|
1340 attributes.Close(); |
|
1341 return KErrNone; |
|
1342 } |
|
1343 TInt CDRM_CAF::CContent_NewL() |
|
1344 { |
|
1345 CContent* content = NULL; |
|
1346 RFile file; |
|
1347 |
|
1348 |
|
1349 content = CContent::NewL(KOma1Content); |
|
1350 STIF_ASSERT_NOT_NULL( content ); |
|
1351 delete content; |
|
1352 |
|
1353 |
|
1354 |
|
1355 content = CContent::NewL(KOma2Content); |
|
1356 STIF_ASSERT_NOT_NULL( content ); |
|
1357 delete content; |
|
1358 |
|
1359 |
|
1360 |
|
1361 content = CContent::NewL(KOma2ContentNoEnc); |
|
1362 STIF_ASSERT_NOT_NULL( content ); |
|
1363 delete content; |
|
1364 |
|
1365 |
|
1366 |
|
1367 TInt err = file.Open(iFs, KOma1Content, EFileRead); |
|
1368 CleanupClosePushL(file); |
|
1369 content = CContent::NewL(file); |
|
1370 STIF_ASSERT_NOT_NULL( content ); |
|
1371 delete content; |
|
1372 CleanupStack::PopAndDestroy(); |
|
1373 |
|
1374 |
|
1375 |
|
1376 err = file.Open(iFs, KOma2Content, EFileRead); |
|
1377 CleanupClosePushL(file); |
|
1378 content = CContent::NewL(file); |
|
1379 STIF_ASSERT_NOT_NULL( content ); |
|
1380 delete content; |
|
1381 CleanupStack::PopAndDestroy(); |
|
1382 |
|
1383 |
|
1384 |
|
1385 err = file.Open(iFs, KOma2ContentNoEnc, EFileRead); |
|
1386 err = err; |
|
1387 CleanupClosePushL(file); |
|
1388 content = CContent::NewL(file); |
|
1389 STIF_ASSERT_NOT_NULL( content ); |
|
1390 delete content; |
|
1391 CleanupStack::PopAndDestroy(); |
|
1392 |
|
1393 return KErrNone; |
|
1394 } |
|
1395 |
|
1396 TInt CDRM_CAF::CContent_OpenCloseContainerL() |
|
1397 { |
|
1398 CContent* content = NULL; |
|
1399 TInt r; |
|
1400 |
|
1401 |
|
1402 content = CContent::NewLC(KOma1Content); |
|
1403 STIF_ASSERT_NOT_NULL( content ); |
|
1404 RUNCHECKED(content->OpenContainer(KDefaultContentObject)); |
|
1405 RUNCHECKED(content->CloseContainer()); |
|
1406 |
|
1407 RUNCHECKED(content->OpenContainer(KDefaultContentObject)); |
|
1408 r = content->OpenContainer(KDefaultContentObject); |
|
1409 STIF_ASSERT_EQUALS( KErrNotFound, r); |
|
1410 RUNCHECKED(content->CloseContainer()); |
|
1411 |
|
1412 r = content->OpenContainer(_L("xyz")); |
|
1413 STIF_ASSERT_EQUALS( KErrNotFound, r); |
|
1414 |
|
1415 r = content->CloseContainer(); |
|
1416 STIF_ASSERT_EQUALS( KErrNotFound, r); |
|
1417 |
|
1418 CleanupStack::PopAndDestroy(); |
|
1419 |
|
1420 return KErrNone; |
|
1421 } |
|
1422 |
|
1423 TInt CDRM_CAF::CContent_GetEmbeddedObjectsL() |
|
1424 { |
|
1425 CContent* content = NULL; |
|
1426 RStreamablePtrArray<CEmbeddedObject> objects; |
|
1427 TInt i; |
|
1428 |
|
1429 CEmbeddedObject* item = NULL; |
|
1430 |
|
1431 |
|
1432 content = CContent::NewLC(KOma1Content); |
|
1433 STIF_ASSERT_NOT_NULL( content ); |
|
1434 content->GetEmbeddedObjectsL(objects); |
|
1435 STIF_ASSERT_EQUALS( 1, objects.Count()); |
|
1436 for (i = 0; i < objects.Count(); i++) |
|
1437 { |
|
1438 item = objects[i]; |
|
1439 } |
|
1440 objects.ResetAndDestroy(); |
|
1441 |
|
1442 content->GetEmbeddedObjectsL(objects, EContainerObject); |
|
1443 STIF_ASSERT_EQUALS( 0, objects.Count()); |
|
1444 |
|
1445 content->GetEmbeddedObjectsL(objects, EAgentSpecificObject); |
|
1446 STIF_ASSERT_EQUALS( 0, objects.Count()); |
|
1447 |
|
1448 content->GetEmbeddedObjectsL(objects, EContentObject); |
|
1449 STIF_ASSERT_EQUALS( 1, objects.Count()); |
|
1450 objects.ResetAndDestroy(); |
|
1451 objects.Close(); |
|
1452 CleanupStack::PopAndDestroy(); |
|
1453 |
|
1454 |
|
1455 |
|
1456 content = CContent::NewLC(KOma2Content); |
|
1457 STIF_ASSERT_NOT_NULL( content ); |
|
1458 content->GetEmbeddedObjectsL(objects); |
|
1459 STIF_ASSERT_EQUALS( 1, objects.Count()); |
|
1460 for (i = 0; i < objects.Count(); i++) |
|
1461 { |
|
1462 item = objects[i]; |
|
1463 } |
|
1464 objects.ResetAndDestroy(); |
|
1465 |
|
1466 content->GetEmbeddedObjectsL(objects, EContainerObject); |
|
1467 STIF_ASSERT_EQUALS( 0, objects.Count()); |
|
1468 |
|
1469 content->GetEmbeddedObjectsL(objects, EAgentSpecificObject); |
|
1470 STIF_ASSERT_EQUALS( 0, objects.Count()); |
|
1471 |
|
1472 content->GetEmbeddedObjectsL(objects, EContentObject); |
|
1473 STIF_ASSERT_EQUALS( 1, objects.Count()); |
|
1474 objects.ResetAndDestroy(); |
|
1475 objects.Close(); |
|
1476 |
|
1477 RUNCHECKEDL(content->OpenContainer(KDefaultContentObject)) |
|
1478 content->GetEmbeddedObjectsL(objects, EContentObject); |
|
1479 STIF_ASSERT_EQUALS( 0, objects.Count()); |
|
1480 objects.Close(); |
|
1481 RUNCHECKED(content->CloseContainer()) |
|
1482 CleanupStack::PopAndDestroy(); |
|
1483 |
|
1484 return KErrNone; |
|
1485 } |
|
1486 |
|
1487 TInt CDRM_CAF::CContent_SearchL() |
|
1488 { |
|
1489 CContent* content = NULL; |
|
1490 RStreamablePtrArray<CEmbeddedObject> objects; |
|
1491 |
|
1492 |
|
1493 content = CContent::NewLC(KOma1Content); |
|
1494 STIF_ASSERT_NOT_NULL( content ); |
|
1495 |
|
1496 RUNCHECKEDL(content->Search(objects, _L8("text/plain"), EFalse)); |
|
1497 STIF_ASSERT_EQUALS( 1, objects.Count()); |
|
1498 objects.ResetAndDestroy(); |
|
1499 |
|
1500 RUNCHECKEDL(content->Search(objects, _L8("audio/wav"), EFalse)); |
|
1501 STIF_ASSERT_EQUALS( 0, objects.Count()); |
|
1502 objects.ResetAndDestroy(); |
|
1503 |
|
1504 objects.Close(); |
|
1505 CleanupStack::PopAndDestroy(); |
|
1506 |
|
1507 |
|
1508 |
|
1509 content = CContent::NewLC(KOma2Content); |
|
1510 STIF_ASSERT_NOT_NULL( content ); |
|
1511 |
|
1512 RUNCHECKEDL(content->Search(objects, _L8("text/plain"), EFalse)); |
|
1513 STIF_ASSERT_EQUALS( 0, objects.Count()); |
|
1514 objects.ResetAndDestroy(); |
|
1515 |
|
1516 RUNCHECKEDL(content->Search(objects, _L8("audio/wav"), EFalse)); |
|
1517 STIF_ASSERT_EQUALS( 1, objects.Count()); |
|
1518 objects.ResetAndDestroy(); |
|
1519 objects.Close(); |
|
1520 |
|
1521 RUNCHECKEDL(content->OpenContainer(KDefaultContentObject)) |
|
1522 RUNCHECKEDL(content->Search(objects, _L8("text/plain"), EFalse)); |
|
1523 STIF_ASSERT_EQUALS( 0, objects.Count()); |
|
1524 objects.Close(); |
|
1525 RUNCHECKED(content->CloseContainer()); |
|
1526 |
|
1527 CleanupStack::PopAndDestroy(); |
|
1528 |
|
1529 return KErrNone; |
|
1530 } |
|
1531 |
|
1532 TInt CDRM_CAF::CContent_GetAttributeL() |
|
1533 { |
|
1534 CContent* content = NULL; |
|
1535 TInt value; |
|
1536 TInt i; |
|
1537 TInt re; |
|
1538 TBool r1 = EFalse; |
|
1539 |
|
1540 content = CContent::NewLC(KOma1Content); |
|
1541 STIF_ASSERT_NOT_NULL( content ); |
|
1542 RUNCHECKEDL(content->GetAttribute(EIsProtected, value)); |
|
1543 STIF_ASSERT_EQUALS( 1, value); |
|
1544 RUNCHECKEDL(content->GetAttribute(EFileType, value)); |
|
1545 STIF_ASSERT_EQUALS( 1, value); |
|
1546 re = content->GetAttribute(ECanPlay, value); |
|
1547 if(re == KErrCANotSupported || re == KErrNone) |
|
1548 { |
|
1549 r1 = ETrue; |
|
1550 } |
|
1551 STIF_ASSERT_TRUE(r1); |
|
1552 r1 = EFalse; |
|
1553 re = content->GetAttribute(ECanPlay, value); |
|
1554 if(re == KErrCANotSupported || re == KErrNone) |
|
1555 { |
|
1556 r1 = ETrue; |
|
1557 } |
|
1558 STIF_ASSERT_TRUE(r1); |
|
1559 r1 = EFalse; |
|
1560 re = content->GetAttribute(ECanView, value); |
|
1561 if(re == KErrCANotSupported || re == KErrNone) |
|
1562 { |
|
1563 r1 = ETrue; |
|
1564 } |
|
1565 STIF_ASSERT_TRUE(r1); |
|
1566 r1 = EFalse; |
|
1567 re = content->GetAttribute(ECanExecute, value); |
|
1568 if(re == KErrCANotSupported || re == KErrNone) |
|
1569 { |
|
1570 r1 = ETrue; |
|
1571 } |
|
1572 STIF_ASSERT_TRUE(r1); |
|
1573 r1 = EFalse; |
|
1574 re = content->GetAttribute(ECanPrint, value); |
|
1575 if(re == KErrCANotSupported || re == KErrNone) |
|
1576 { |
|
1577 r1 = ETrue; |
|
1578 } |
|
1579 STIF_ASSERT_TRUE(r1); |
|
1580 |
|
1581 for (i = 0; i < NUM_ELEMENTS(KAttributes); i++) |
|
1582 { |
|
1583 content->GetAttribute(KAttributes[i], value); |
|
1584 } |
|
1585 STIF_ASSERT_NOT_EQUALS( KErrNone, content->GetAttribute(EIsProtected, value, _L("xyz"))); |
|
1586 CleanupStack::PopAndDestroy(); |
|
1587 |
|
1588 |
|
1589 |
|
1590 content = CContent::NewLC(KOma2Content); |
|
1591 STIF_ASSERT_NOT_NULL( content ); |
|
1592 RUNCHECKEDL(content->GetAttribute(EIsProtected, value)); |
|
1593 STIF_ASSERT_EQUALS( 1, value); |
|
1594 RUNCHECKEDL(content->GetAttribute(EFileType, value)); |
|
1595 STIF_ASSERT_EQUALS( 2, value); |
|
1596 for (i = 0; i < NUM_ELEMENTS(KAttributes); i++) |
|
1597 { |
|
1598 content->GetAttribute(KAttributes[i], value); |
|
1599 } |
|
1600 STIF_ASSERT_NOT_EQUALS( KErrNone, content->GetAttribute(EIsProtected, value, _L("xyz"))); |
|
1601 CleanupStack::PopAndDestroy(); |
|
1602 |
|
1603 return KErrNone; |
|
1604 } |
|
1605 |
|
1606 TInt CDRM_CAF::CContent_GetAttributeSetL() |
|
1607 { |
|
1608 CContent* content = NULL; |
|
1609 RAttributeSet attributes; |
|
1610 TInt value; |
|
1611 |
|
1612 attributes.AddL(EIsProtected); |
|
1613 attributes.AddL(EFileType); |
|
1614 |
|
1615 content = CContent::NewLC(KOma1Content); |
|
1616 STIF_ASSERT_NOT_NULL( content ); |
|
1617 RUNCHECKEDL(content->GetAttributeSet(attributes)); |
|
1618 RUNCHECKEDL(attributes.GetValue(EIsProtected, value)); |
|
1619 STIF_ASSERT_EQUALS( 1, value); |
|
1620 RUNCHECKED(attributes.GetValue(EFileType, value)); |
|
1621 STIF_ASSERT_EQUALS( 1, value); |
|
1622 CleanupStack::PopAndDestroy(); |
|
1623 |
|
1624 |
|
1625 |
|
1626 content = CContent::NewLC(KOma2Content); |
|
1627 STIF_ASSERT_NOT_NULL( content ); |
|
1628 RUNCHECKEDL(content->GetAttributeSet(attributes)); |
|
1629 RUNCHECKEDL(attributes.GetValue(EIsProtected, value)); |
|
1630 STIF_ASSERT_EQUALS( 1, value); |
|
1631 RUNCHECKED(attributes.GetValue(EFileType, value)); |
|
1632 STIF_ASSERT_EQUALS( 2, value); |
|
1633 CleanupStack::PopAndDestroy(); |
|
1634 |
|
1635 attributes.Close(); |
|
1636 return KErrNone; |
|
1637 } |
|
1638 |
|
1639 TInt CDRM_CAF::CContent_GetStringAttributeL() |
|
1640 { |
|
1641 CContent* content = NULL; |
|
1642 RStreamablePtrArray<CEmbeddedObject> objects; |
|
1643 HBufC* buffer = HBufC::NewLC(256000); |
|
1644 TPtr value(NULL, 0); |
|
1645 TInt i; |
|
1646 |
|
1647 value.Set(buffer->Des()); |
|
1648 |
|
1649 content = CContent::NewLC(KOma1Content); |
|
1650 STIF_ASSERT_NOT_NULL( content ); |
|
1651 RUNCHECKEDL(content->GetStringAttribute(EMimeType, value)); |
|
1652 STIF_ASSERT_EQUALS( 0, value.Compare(_L("text/plain"))); |
|
1653 for (i = 0; i < NUM_ELEMENTS(KStringAttributes); i++) |
|
1654 { |
|
1655 content->GetStringAttribute(KStringAttributes[i], value); |
|
1656 } |
|
1657 STIF_ASSERT_NOT_EQUALS(KErrNone, content->GetStringAttribute(EMimeType, value, _L("xyz"))); |
|
1658 CleanupStack::PopAndDestroy(); |
|
1659 |
|
1660 |
|
1661 |
|
1662 content = CContent::NewLC(KOma2Content); |
|
1663 STIF_ASSERT_NOT_NULL( content ); |
|
1664 RUNCHECKEDL(content->Search(objects, _L8("audio/wav"), EFalse)); |
|
1665 STIF_ASSERT_EQUALS( 1, objects.Count()); |
|
1666 RUNCHECKEDL(content->GetStringAttribute(EMimeType, value, |
|
1667 objects[0]->UniqueId())); |
|
1668 STIF_ASSERT_EQUALS( 0, value.Compare(_L("audio/wav"))); |
|
1669 objects.ResetAndDestroy(); |
|
1670 objects.Close(); |
|
1671 for (i = 0; i < NUM_ELEMENTS(KStringAttributes); i++) |
|
1672 { |
|
1673 content->GetStringAttribute(KStringAttributes[i], value); |
|
1674 } |
|
1675 STIF_ASSERT_NOT_EQUALS( KErrNone,content->GetStringAttribute(EMimeType, value, _L("xyz"))); |
|
1676 CleanupStack::PopAndDestroy(); |
|
1677 |
|
1678 CleanupStack::PopAndDestroy(); |
|
1679 return KErrNone; |
|
1680 } |
|
1681 |
|
1682 TInt CDRM_CAF::CContent_GetStringAttributeSetL() |
|
1683 { |
|
1684 RFile fileFLV; |
|
1685 |
|
1686 TInt err = fileFLV.Open(iFs,KFVariantFile, EFileRead); |
|
1687 if( err == 0 ) |
|
1688 { |
|
1689 iLog->Log(_L(" Skipped in FL variant \r\n" )); |
|
1690 fileFLV.Close(); |
|
1691 TFileName fileFlVariant; |
|
1692 fileFlVariant.Copy(KFVariantFile); |
|
1693 // Clearing file after use |
|
1694 iFs.Delete(fileFlVariant); |
|
1695 return KErrNone; |
|
1696 } |
|
1697 fileFLV.Close(); |
|
1698 |
|
1699 CContent* content = NULL; |
|
1700 RStringAttributeSet attributes; |
|
1701 HBufC* buffer = HBufC::NewLC(256000); |
|
1702 TPtr value(NULL, 0); |
|
1703 TInt re; |
|
1704 TBool r1 = EFalse; |
|
1705 value.Set(buffer->Des()); |
|
1706 attributes.AddL(EMimeType); |
|
1707 attributes.AddL(ERightsIssuerUrl); |
|
1708 |
|
1709 content = CContent::NewLC(KOma1Content); |
|
1710 STIF_ASSERT_NOT_NULL( content ); |
|
1711 RUNCHECKEDL(content->GetStringAttributeSet(attributes)); |
|
1712 RUNCHECKEDL(attributes.GetValue(EMimeType, value)); |
|
1713 STIF_ASSERT_EQUALS( 0,value.Compare(_L("text/plain"))); |
|
1714 re = attributes.GetValue(ERightsIssuerUrl, value); |
|
1715 if(re == KErrCANotSupported || re == KErrNone) |
|
1716 { |
|
1717 r1 = ETrue; |
|
1718 } |
|
1719 STIF_ASSERT_TRUE(r1); |
|
1720 CleanupStack::PopAndDestroy(); |
|
1721 |
|
1722 |
|
1723 |
|
1724 content = CContent::NewLC(KOma2Content); |
|
1725 STIF_ASSERT_NOT_NULL( content ); |
|
1726 RUNCHECKEDL(content->GetStringAttributeSet(attributes)); |
|
1727 RUNCHECKEDL(attributes.GetValue(EMimeType, value)); |
|
1728 STIF_ASSERT_EQUALS( 0,value.Compare(_L("audio/wav"))); |
|
1729 RUNCHECKED(attributes.GetValue(ERightsIssuerUrl, value)); |
|
1730 if(value.Length() > 0) |
|
1731 { |
|
1732 r1 = ETrue; |
|
1733 } |
|
1734 STIF_ASSERT_TRUE(r1); |
|
1735 CleanupStack::PopAndDestroy(); |
|
1736 |
|
1737 attributes.Close(); |
|
1738 CleanupStack::PopAndDestroy(); |
|
1739 return KErrNone; |
|
1740 } |
|
1741 |
|
1742 TInt CDRM_CAF::CContent_AgentSpecificCommandL() |
|
1743 { |
|
1744 CContent* content = NULL; |
|
1745 TPtr8 ptr(NULL, 0, 0); |
|
1746 TRequestStatus status; |
|
1747 |
|
1748 |
|
1749 content = CContent::NewLC(KOma2Content); |
|
1750 STIF_ASSERT_NOT_NULL( content ); |
|
1751 RUNCHECKED(content->AgentSpecificCommand(EEmbedDomainRo, KNullDesC8, ptr)); |
|
1752 content->AgentSpecificCommand(EEmbedDomainRo, KNullDesC8, ptr, status); |
|
1753 User::WaitForRequest(status); |
|
1754 CleanupStack::PopAndDestroy(); |
|
1755 |
|
1756 content = CContent::NewLC(KOma1Content); |
|
1757 STIF_ASSERT_NOT_NULL( content ); |
|
1758 STIF_ASSERT_EQUALS( KErrArgument,content->AgentSpecificCommand(EEmbedDomainRo, KNullDesC8, ptr)); |
|
1759 CleanupStack::PopAndDestroy(); |
|
1760 |
|
1761 return KErrNone; |
|
1762 } |
|
1763 TInt CDRM_CAF::CContent_NotifyStatusChangeL() |
|
1764 { |
|
1765 _LIT(KSdkVersion31,"Z:\\System\\install\\Series60v3.1.sis"); |
|
1766 _LIT(KSdkVersion50,"Z:\\System\\install\\Series60v5.0.sis"); |
|
1767 RFs fs; |
|
1768 TBool found = EFalse; |
|
1769 User::LeaveIfError(fs.Connect ()); |
|
1770 CleanupClosePushL (fs); |
|
1771 if(BaflUtils::FileExists (fs, KSdkVersion31)) |
|
1772 { |
|
1773 found = ETrue; |
|
1774 } |
|
1775 else if(BaflUtils::FileExists (fs, KSdkVersion50)) |
|
1776 { |
|
1777 found = ETrue; |
|
1778 } |
|
1779 CContent* content = NULL; |
|
1780 TRequestStatus status = KRequestPending; |
|
1781 TInt r; |
|
1782 content = CContent::NewLC(KOma2Content); |
|
1783 STIF_ASSERT_NOT_NULL(content); |
|
1784 content->NotifyStatusChange(ERightsAvailable, status);//ERightsAvailable |
|
1785 if(found) |
|
1786 { |
|
1787 User::After(10000); |
|
1788 content->CancelNotifyStatusChange(status); |
|
1789 User::WaitForRequest(status); |
|
1790 } |
|
1791 else |
|
1792 { |
|
1793 User::WaitForRequest(status); |
|
1794 } |
|
1795 CleanupStack::PopAndDestroy(2); |
|
1796 return KErrNone; |
|
1797 } |
|
1798 |
|
1799 TInt CDRM_CAF::CContent_CancelNotifyStatusChangeL() |
|
1800 { |
|
1801 CContent* content = NULL; |
|
1802 TRequestStatus status; |
|
1803 TInt r; |
|
1804 content = CContent::NewLC(KOma2Content); |
|
1805 STIF_ASSERT_NOT_NULL(content); |
|
1806 content->CancelNotifyStatusChange(status); |
|
1807 User::WaitForRequest(status); |
|
1808 //r = status; |
|
1809 //STIF_ASSERT_EQUALS( KErrCANotSupported,r); |
|
1810 CleanupStack::PopAndDestroy(); |
|
1811 return KErrNone; |
|
1812 } |
|
1813 |
|
1814 TInt CDRM_CAF::CContent_RequestRightsL() |
|
1815 { |
|
1816 CContent* content = NULL; |
|
1817 TRequestStatus status; |
|
1818 TInt r; |
|
1819 content = CContent::NewLC(KOma2Content); |
|
1820 STIF_ASSERT_NOT_NULL(content); |
|
1821 content->RequestRights(status); |
|
1822 User::WaitForRequest(status); |
|
1823 //r = status; |
|
1824 #ifdef __SERIES60_ |
|
1825 //STIF_ASSERT_EQUALS( KErrNone,r); |
|
1826 #else |
|
1827 //STIF_ASSERT_EQUALS( KErrCANotSupported,r); |
|
1828 #endif |
|
1829 CleanupStack::PopAndDestroy(content); |
|
1830 return KErrNone; |
|
1831 } |
|
1832 |
|
1833 TInt CDRM_CAF::CContent_DisplayInfoL() |
|
1834 { |
|
1835 CContent* content = NULL; |
|
1836 TInt r; |
|
1837 TBool r1 = EFalse; |
|
1838 |
|
1839 |
|
1840 content = CContent::NewLC(KOma2Content); |
|
1841 STIF_ASSERT_NOT_NULL( content ); |
|
1842 TRAP(r, content->DisplayInfoL(EFileAndRights)); |
|
1843 if(r == KErrCANotSupported || r == KErrNone) |
|
1844 { |
|
1845 r1 = ETrue; |
|
1846 } |
|
1847 STIF_ASSERT_TRUE(r1); |
|
1848 CleanupStack::PopAndDestroy(); |
|
1849 |
|
1850 return KErrNone; |
|
1851 } |
|
1852 |
|
1853 TInt CDRM_CAF::CContent_SetPropertyL() |
|
1854 { |
|
1855 CContent* content = NULL; |
|
1856 TInt r; |
|
1857 TBool r1 = EFalse; |
|
1858 |
|
1859 content = CContent::NewLC(KOma2Content); |
|
1860 STIF_ASSERT_NOT_NULL( content ); |
|
1861 r = content->SetProperty(EAgentPropertyBufferSize, 1024); |
|
1862 if(r == KErrCANotSupported || r == KErrNone) |
|
1863 { |
|
1864 r1 = ETrue; |
|
1865 } |
|
1866 STIF_ASSERT_TRUE(r1); |
|
1867 r = content->SetProperty(EAgentPropertyAgentUI, 1); |
|
1868 if(r == KErrCANotSupported || r == KErrNone) |
|
1869 { |
|
1870 r1 = ETrue; |
|
1871 } |
|
1872 STIF_ASSERT_TRUE(r1); |
|
1873 |
|
1874 r = content->SetProperty(EAgentPropertyMultipleSequence, 1); |
|
1875 if(r == KErrCANotSupported || r == KErrNone) |
|
1876 { |
|
1877 r1 = ETrue; |
|
1878 } |
|
1879 STIF_ASSERT_TRUE(r1); |
|
1880 CleanupStack::PopAndDestroy(); |
|
1881 |
|
1882 return KErrNone; |
|
1883 } |
|
1884 |
|
1885 TInt CDRM_CAF::CContent_OpenContentL() |
|
1886 { |
|
1887 CContent* content = NULL; |
|
1888 CData* data = NULL; |
|
1889 RStreamablePtrArray<CEmbeddedObject> objects; |
|
1890 |
|
1891 |
|
1892 content = CContent::NewLC(KOma1Content); |
|
1893 STIF_ASSERT_NOT_NULL( content ); |
|
1894 data = content->OpenContentLC(EPeek); |
|
1895 STIF_ASSERT_NOT_NULL( data ); |
|
1896 CleanupStack::PopAndDestroy(2); |
|
1897 |
|
1898 |
|
1899 |
|
1900 content = CContent::NewLC(KOma2Content); |
|
1901 STIF_ASSERT_NOT_NULL( content ); |
|
1902 RUNCHECKEDL(content->Search(objects, _L8("audio/wav"), EFalse)); |
|
1903 STIF_ASSERT_EQUALS( 1,objects.Count()); |
|
1904 data = content->OpenContentLC(EPeek, objects[0]->UniqueId()); |
|
1905 STIF_ASSERT_NOT_NULL( data ); |
|
1906 objects.ResetAndDestroy(); |
|
1907 CleanupStack::PopAndDestroy(2); |
|
1908 |
|
1909 return KErrNone; |
|
1910 } |
|
1911 |
|
1912 TInt CDRM_CAF::CManager_FileOperationsL() |
|
1913 { |
|
1914 _LIT(KFile1, "c:\\private\\OMA DRM Agent\\file1.odf"); |
|
1915 _LIT(KFile2, "c:\\private\\OMA DRM Agent\\file2.odf"); |
|
1916 _LIT(KDir, "c:\\private\\OMA DRM Agent\\"); |
|
1917 _LIT(KDir1, "c:\\private\\OMA DRM Agent\\dir1\\"); |
|
1918 _LIT(KDir12, "c:\\private\\OMA DRM Agent\\dir1\\dir2\\"); |
|
1919 _LIT(KDir2, "c:\\private\\OMA DRM Agent\\dir2\\"); |
|
1920 CDir* dir; |
|
1921 TInt r; |
|
1922 |
|
1923 |
|
1924 CManager* manager = CManager::NewL(); |
|
1925 STIF_ASSERT_NOT_NULL( manager ); |
|
1926 r = manager->CopyFile(KOma2Content, KFile1); |
|
1927 STIF_ASSERT_EQUALS( KErrPermissionDenied,r); |
|
1928 r = manager->RenameFile(KFile1, KFile2); |
|
1929 STIF_ASSERT_EQUALS( KErrPermissionDenied,r); |
|
1930 r = manager->DeleteFile(KFile2); |
|
1931 STIF_ASSERT_EQUALS( KErrPermissionDenied,r); |
|
1932 r = manager->MkDirAll(KDir12); |
|
1933 STIF_ASSERT_EQUALS( KErrPermissionDenied,r); |
|
1934 r = manager->MkDir(KDir1); |
|
1935 STIF_ASSERT_EQUALS( KErrPermissionDenied,r); |
|
1936 r = manager->GetDir(KDir, KEntryAttNormal, ESortByName, dir); |
|
1937 STIF_ASSERT_EQUALS( KErrPermissionDenied,r); |
|
1938 r = manager->GetDir(KDir, KNullUid, ESortByName, dir); |
|
1939 STIF_ASSERT_EQUALS( KErrPermissionDenied,r); |
|
1940 r = manager->GetDir(KDir, KEntryAttNormal, ESortByName, dir, dir); |
|
1941 STIF_ASSERT_EQUALS( KErrPermissionDenied,r); |
|
1942 r = manager->RmDir(KDir12); |
|
1943 STIF_ASSERT_EQUALS( KErrPermissionDenied,r); |
|
1944 //CleanupStack::PopAndDestroy(); |
|
1945 |
|
1946 return KErrNone; |
|
1947 } |
|
1948 |
|
1949 TInt CDRM_CAF::CManager_GetAttributeL() |
|
1950 { |
|
1951 TVirtualPathPtr dcf1(KOma1Content, KNullDesC); |
|
1952 TVirtualPathPtr dcf2(KOma2Content, KNullDesC); |
|
1953 TInt value; |
|
1954 TInt i; |
|
1955 RFile dcf1file; |
|
1956 RFile dcf2file; |
|
1957 TInt error( KErrNone ); |
|
1958 |
|
1959 CManager* manager = CManager::NewLC(); |
|
1960 STIF_ASSERT_NOT_NULL( manager ); |
|
1961 RUNCHECKEDL(manager->GetAttribute(EIsProtected, value, dcf1)); |
|
1962 STIF_ASSERT_EQUALS( 0,value); |
|
1963 RUNCHECKEDL(manager->GetAttribute(EFileType, value, dcf1)); |
|
1964 STIF_ASSERT_EQUALS( 1,value); |
|
1965 for (i = 0; i < NUM_ELEMENTS(KAttributes); i++) |
|
1966 { |
|
1967 manager->GetAttribute(KAttributes[i], value, dcf1); |
|
1968 } |
|
1969 CleanupStack::PopAndDestroy( manager ); |
|
1970 |
|
1971 |
|
1972 |
|
1973 manager = CManager::NewLC(); |
|
1974 STIF_ASSERT_NOT_NULL( manager ); |
|
1975 RUNCHECKEDL(manager->GetAttribute(EIsProtected, value, dcf2)); |
|
1976 STIF_ASSERT_EQUALS( 0,value); |
|
1977 RUNCHECKEDL(manager->GetAttribute(EFileType, value, dcf2)); |
|
1978 STIF_ASSERT_EQUALS( 2,value); |
|
1979 for (i = 0; i < NUM_ELEMENTS(KAttributes); i++) |
|
1980 { |
|
1981 manager->GetAttribute(KAttributes[i], value, dcf2); |
|
1982 } |
|
1983 CleanupStack::PopAndDestroy( manager ); |
|
1984 |
|
1985 User::LeaveIfError(dcf1file.Open(iFs, KOma1Content, EFileRead)); |
|
1986 CleanupClosePushL(dcf1file); |
|
1987 User::LeaveIfError(dcf2file.Open(iFs, KOma2Content, EFileRead)); |
|
1988 CleanupClosePushL(dcf2file); |
|
1989 |
|
1990 manager = CManager::NewLC(); |
|
1991 STIF_ASSERT_NOT_NULL( manager ); |
|
1992 error = manager->GetAttribute(EIsProtected, value, dcf1file, KDefaultContentObject); |
|
1993 if ( !error ) |
|
1994 { |
|
1995 STIF_ASSERT_EQUALS( 0, value ); |
|
1996 } |
|
1997 else |
|
1998 { |
|
1999 STIF_ASSERT_EQUALS( KErrCANotSupported, error ); |
|
2000 } |
|
2001 |
|
2002 error = manager->GetAttribute(EFileType, value, dcf1file, KDefaultContentObject); |
|
2003 if ( !error ) |
|
2004 { |
|
2005 STIF_ASSERT_EQUALS( 1, value ); |
|
2006 } |
|
2007 else |
|
2008 { |
|
2009 STIF_ASSERT_EQUALS( KErrCANotSupported, error ); |
|
2010 } |
|
2011 |
|
2012 for (i = 0; i < NUM_ELEMENTS(KAttributes); i++) |
|
2013 { |
|
2014 manager->GetAttribute(KAttributes[i], value, dcf1file, KDefaultContentObject); |
|
2015 } |
|
2016 CleanupStack::PopAndDestroy( manager ); |
|
2017 |
|
2018 manager = CManager::NewLC(); |
|
2019 STIF_ASSERT_NOT_NULL( manager ); |
|
2020 error = manager->GetAttribute(EIsProtected, value, dcf2file, KDefaultContentObject); |
|
2021 if ( !error ) |
|
2022 { |
|
2023 STIF_ASSERT_EQUALS( 0, value ); |
|
2024 } |
|
2025 else |
|
2026 { |
|
2027 STIF_ASSERT_EQUALS( KErrCANotSupported, error ); |
|
2028 } |
|
2029 |
|
2030 error = manager->GetAttribute(EFileType, value, dcf2file, KDefaultContentObject); |
|
2031 if ( !error ) |
|
2032 { |
|
2033 STIF_ASSERT_EQUALS( 2, value ); |
|
2034 } |
|
2035 else |
|
2036 { |
|
2037 STIF_ASSERT_EQUALS( KErrCANotSupported, error ); |
|
2038 } |
|
2039 |
|
2040 for (i = 0; i < NUM_ELEMENTS(KAttributes); i++) |
|
2041 { |
|
2042 manager->GetAttribute(KAttributes[i], value, dcf2file, KDefaultContentObject); |
|
2043 } |
|
2044 CleanupStack::PopAndDestroy( manager ); |
|
2045 |
|
2046 // close files |
|
2047 CleanupStack::PopAndDestroy( 2 ); |
|
2048 |
|
2049 return KErrNone; |
|
2050 } |
|
2051 |
|
2052 TInt CDRM_CAF::CManager_GetAttributeSetL() |
|
2053 { |
|
2054 RAttributeSet attributes; |
|
2055 TInt value; |
|
2056 TVirtualPathPtr dcf2(KOma2Content, KNullDesC); |
|
2057 TInt error( KErrNone ); |
|
2058 RFile dcf2file; |
|
2059 |
|
2060 |
|
2061 attributes.AddL(EIsProtected); |
|
2062 attributes.AddL(EFileType); |
|
2063 CleanupClosePushL(attributes); |
|
2064 CManager* manager = CManager::NewLC(); |
|
2065 STIF_ASSERT_NOT_NULL( manager ); |
|
2066 RUNCHECKEDL(manager->GetAttributeSet(attributes, dcf2)); |
|
2067 RUNCHECKEDL(attributes.GetValue(EIsProtected, value)); |
|
2068 STIF_ASSERT_EQUALS( 0,value); |
|
2069 RUNCHECKED(attributes.GetValue(EFileType, value)); |
|
2070 STIF_ASSERT_EQUALS( 2,value); |
|
2071 |
|
2072 User::LeaveIfError(dcf2file.Open(iFs, KOma2Content, EFileRead)); |
|
2073 CleanupClosePushL(dcf2file); |
|
2074 |
|
2075 error = manager->GetAttributeSet(attributes, dcf2file, KDefaultContentObject); |
|
2076 if ( !error ) |
|
2077 { |
|
2078 RUNCHECKEDL(attributes.GetValue(EIsProtected, value)); |
|
2079 STIF_ASSERT_EQUALS( 0,value); |
|
2080 RUNCHECKED(attributes.GetValue(EFileType, value)); |
|
2081 STIF_ASSERT_EQUALS( 2,value); |
|
2082 } |
|
2083 else |
|
2084 { |
|
2085 STIF_ASSERT_EQUALS( KErrCANotSupported, error ); |
|
2086 } |
|
2087 |
|
2088 CleanupStack::PopAndDestroy(3); |
|
2089 |
|
2090 return KErrNone; |
|
2091 } |
|
2092 |
|
2093 TInt CDRM_CAF::CManager_GetStringAttributeL() |
|
2094 { |
|
2095 TBuf<256> value; |
|
2096 TVirtualPathPtr dcf1(KOma1Content, KNullDesC); |
|
2097 TVirtualPathPtr dcf2(KOma2Content, KNullDesC); |
|
2098 TInt i; |
|
2099 TInt error( KErrNone ); |
|
2100 RFile dcf1file; |
|
2101 RFile dcf2file; |
|
2102 |
|
2103 |
|
2104 CManager* manager = CManager::NewLC(); |
|
2105 STIF_ASSERT_NOT_NULL( manager ); |
|
2106 RUNCHECKED(manager->GetStringAttribute(EMimeType, value, dcf1)); |
|
2107 for (i = 0; i < NUM_ELEMENTS(KAttributes); i++) |
|
2108 { |
|
2109 manager->GetStringAttribute(KStringAttributes[i], value, dcf1); |
|
2110 } |
|
2111 CleanupStack::PopAndDestroy( manager ); |
|
2112 |
|
2113 |
|
2114 |
|
2115 manager = CManager::NewLC(); |
|
2116 STIF_ASSERT_NOT_NULL( manager ); |
|
2117 RUNCHECKED(manager->GetStringAttribute(EMimeType, value, dcf2)); |
|
2118 for (i = 0; i < NUM_ELEMENTS(KAttributes); i++) |
|
2119 { |
|
2120 manager->GetStringAttribute(KStringAttributes[i], value, dcf2); |
|
2121 } |
|
2122 CleanupStack::PopAndDestroy( manager ); |
|
2123 |
|
2124 User::LeaveIfError(dcf1file.Open(iFs, KOma1Content, EFileRead)); |
|
2125 CleanupClosePushL(dcf1file); |
|
2126 User::LeaveIfError(dcf2file.Open(iFs, KOma2Content, EFileRead)); |
|
2127 CleanupClosePushL(dcf2file); |
|
2128 |
|
2129 manager = CManager::NewLC(); |
|
2130 STIF_ASSERT_NOT_NULL( manager ); |
|
2131 error = manager->GetStringAttribute(EMimeType, value, dcf1file, KDefaultContentObject); |
|
2132 if ( error == KErrCANotSupported ) |
|
2133 { |
|
2134 error = KErrNone; |
|
2135 } |
|
2136 STIF_ASSERT_EQUALS( KErrNone, error ); |
|
2137 for (i = 0; i < NUM_ELEMENTS(KAttributes); i++) |
|
2138 { |
|
2139 manager->GetStringAttribute(KStringAttributes[i], value, dcf1file, KDefaultContentObject); |
|
2140 } |
|
2141 CleanupStack::PopAndDestroy( manager ); |
|
2142 |
|
2143 |
|
2144 |
|
2145 manager = CManager::NewLC(); |
|
2146 STIF_ASSERT_NOT_NULL( manager ); |
|
2147 error = manager->GetStringAttribute(EMimeType, value, dcf2file, KDefaultContentObject); |
|
2148 if ( error == KErrCANotSupported ) |
|
2149 { |
|
2150 error = KErrNone; |
|
2151 } |
|
2152 STIF_ASSERT_EQUALS( KErrNone, error ); |
|
2153 for (i = 0; i < NUM_ELEMENTS(KAttributes); i++) |
|
2154 { |
|
2155 manager->GetStringAttribute(KStringAttributes[i], value, dcf2file, KDefaultContentObject); |
|
2156 } |
|
2157 CleanupStack::PopAndDestroy( manager ); |
|
2158 |
|
2159 // close files |
|
2160 CleanupStack::PopAndDestroy( 2 ); |
|
2161 |
|
2162 return KErrNone; |
|
2163 } |
|
2164 |
|
2165 TInt CDRM_CAF::CManager_GetStringAttributeSetL() |
|
2166 { |
|
2167 RStringAttributeSet attributes; |
|
2168 TBuf<256> value; |
|
2169 TVirtualPathPtr dcf2(KOma2Content, KNullDesC); |
|
2170 RFile dcf2file; |
|
2171 TInt error( KErrNone ); |
|
2172 |
|
2173 attributes.AddL(EMimeType); |
|
2174 attributes.AddL(ERightsIssuerUrl); |
|
2175 CManager* manager = CManager::NewLC(); |
|
2176 STIF_ASSERT_NOT_NULL( manager ); |
|
2177 RUNCHECKEDL(manager->GetStringAttributeSet(attributes, dcf2)); |
|
2178 RUNCHECKED(attributes.GetValue(EMimeType, value)); |
|
2179 STIF_ASSERT_EQUALS( KErrCANotSupported,attributes.GetValue(ERightsIssuerUrl, value)); |
|
2180 STIF_ASSERT_EQUALS( 0,value.Length()); |
|
2181 CleanupStack::PopAndDestroy( manager ); |
|
2182 |
|
2183 User::LeaveIfError(dcf2file.Open(iFs, KOma2Content, EFileRead)); |
|
2184 CleanupClosePushL(dcf2file); |
|
2185 |
|
2186 manager = CManager::NewLC(); |
|
2187 STIF_ASSERT_NOT_NULL( manager ); |
|
2188 error = manager->GetStringAttributeSet(attributes, dcf2file, KDefaultContentObject); |
|
2189 if ( !error ) |
|
2190 { |
|
2191 RUNCHECKED(attributes.GetValue(EMimeType, value)); |
|
2192 STIF_ASSERT_EQUALS( KErrCANotSupported,attributes.GetValue(ERightsIssuerUrl, value)); |
|
2193 STIF_ASSERT_EQUALS( 0,value.Length()); |
|
2194 } |
|
2195 else |
|
2196 { |
|
2197 STIF_ASSERT_EQUALS( KErrCANotSupported, error ); |
|
2198 } |
|
2199 |
|
2200 CleanupStack::PopAndDestroy( 2 ); |
|
2201 |
|
2202 attributes.Close(); |
|
2203 |
|
2204 return KErrNone; |
|
2205 } |
|
2206 |
|
2207 TInt CDRM_CAF::CManager_SetPropertyL() |
|
2208 { |
|
2209 TInt r; |
|
2210 |
|
2211 TVirtualPathPtr dcf2(KOma2Content, KDefaultContentObject); |
|
2212 CManager* manager = CManager::NewLC(); |
|
2213 STIF_ASSERT_NOT_NULL( manager ); |
|
2214 r = manager->SetProperty(EAgentPropertyBufferSize, 1024); |
|
2215 STIF_ASSERT_EQUALS( KErrCANotSupported,r); |
|
2216 r = manager->SetProperty(EAgentPropertyAgentUI, 1); |
|
2217 STIF_ASSERT_EQUALS( KErrCANotSupported,r); |
|
2218 r = manager->SetProperty(EAgentPropertyMultipleSequence, 1); |
|
2219 STIF_ASSERT_EQUALS( KErrCANotSupported,r); |
|
2220 CleanupStack::PopAndDestroy(); |
|
2221 |
|
2222 return KErrNone; |
|
2223 } |
|
2224 |
|
2225 TInt CDRM_CAF::CManager_DisplayInfoL() |
|
2226 { |
|
2227 TInt r; |
|
2228 RFile file; |
|
2229 TVirtualPathPtr dcf2(KOma2Content, KDefaultContentObject); |
|
2230 CManager* manager = CManager::NewLC(); |
|
2231 STIF_ASSERT_NOT_NULL( manager ); |
|
2232 TRAP(r, manager->DisplayInfoL(EFileAndRights, dcf2)); |
|
2233 STIF_ASSERT_EQUALS( KErrCANotSupported,r); |
|
2234 |
|
2235 User::LeaveIfError(file.Open(iFs, KOma2Content, EFileRead)); |
|
2236 TRAP(r, manager->DisplayInfoL(EFileAndRights, file, KDefaultContentObject)); |
|
2237 STIF_ASSERT_EQUALS( KErrCANotSupported,r); |
|
2238 |
|
2239 file.Close(); |
|
2240 CleanupStack::PopAndDestroy( manager ); |
|
2241 |
|
2242 return KErrNone; |
|
2243 } |
|
2244 |
|
2245 TInt CDRM_CAF::CManager_ListAgentsL() |
|
2246 { |
|
2247 RArray<TAgent> agents; |
|
2248 TBool f = EFalse; |
|
2249 TInt i; |
|
2250 |
|
2251 |
|
2252 CManager* manager = CManager::NewLC(); |
|
2253 STIF_ASSERT_NOT_NULL( manager ); |
|
2254 manager->ListAgentsL(agents); |
|
2255 for (i = 0; i < agents.Count(); i++) |
|
2256 { |
|
2257 if (agents[i].Name().Compare(KOmaDrm2AgentName) == 0) |
|
2258 { |
|
2259 f = ETrue; |
|
2260 } |
|
2261 } |
|
2262 STIF_ASSERT_TRUE(f); |
|
2263 agents.Close(); |
|
2264 CleanupStack::PopAndDestroy(); |
|
2265 |
|
2266 return KErrNone; |
|
2267 } |
|
2268 |
|
2269 TInt CDRM_CAF::CManager_AgentSpecificCommandL() |
|
2270 { |
|
2271 TPtr8 ptr(NULL, 0, 0); |
|
2272 RArray<TAgent> agents; |
|
2273 TRequestStatus status; |
|
2274 TInt i; |
|
2275 TInt r; |
|
2276 HBufC8* data; |
|
2277 HBufC8* result; |
|
2278 HBufC8* buffer; |
|
2279 |
|
2280 r = iFs.Delete(_L("c:\\test.dcf")); |
|
2281 STIF_ASSERT_EQUALS( KErrNone,r); |
|
2282 |
|
2283 RFileWriteStream out; |
|
2284 out.Create(iFs, _L("c:\\test.dcf"), EFileWrite ); |
|
2285 |
|
2286 |
|
2287 out.Close(); |
|
2288 |
|
2289 |
|
2290 TInt size = 0; |
|
2291 RFile file; |
|
2292 User::LeaveIfError(file.Open(iFs, _L("c:\\test.dcf"), EFileRead)); |
|
2293 CleanupClosePushL(file); |
|
2294 User::LeaveIfError(file.Size(size)); |
|
2295 data = HBufC8::NewLC(size); |
|
2296 TPtr8 ptr1(data->Des()); |
|
2297 User::LeaveIfError(file.Read(ptr1, size)); |
|
2298 CleanupStack::Pop(); //data |
|
2299 CleanupStack::PopAndDestroy(); //file |
|
2300 |
|
2301 buffer = HBufC8::NewL(data->Length() + 1); |
|
2302 ptr.Set(buffer->Des()); |
|
2303 ptr.Append(EView); |
|
2304 ptr.Append(*data); |
|
2305 result = HBufC8::NewL(data->Length()); |
|
2306 ptr.Set(result->Des()); |
|
2307 |
|
2308 |
|
2309 TVirtualPathPtr dcf2(KOma2Content, KDefaultContentObject); |
|
2310 CManager* manager = CManager::NewLC(); |
|
2311 STIF_ASSERT_NOT_NULL( manager ); |
|
2312 manager->ListAgentsL(agents); |
|
2313 for (i = 0; i < agents.Count(); i++) |
|
2314 { |
|
2315 if (agents[i].Name().Compare(KOmaDrm2AgentName) == 0) |
|
2316 { |
|
2317 r = manager->AgentSpecificCommand(agents[i], |
|
2318 EEmbedDomainRo, KNullDesC8, ptr); |
|
2319 STIF_ASSERT_EQUALS( KErrCANotSupported,r); |
|
2320 manager->AgentSpecificCommand(agents[i], |
|
2321 EEmbedDomainRo, KNullDesC8, ptr, status); |
|
2322 User::WaitForRequest(status); |
|
2323 STIF_ASSERT_EQUALS( KErrCANotSupported,status.Int()); |
|
2324 |
|
2325 r = manager->AgentSpecificCommand(agents[i], |
|
2326 EBufferContainsOma1Dcf, KNullDesC8, ptr); |
|
2327 STIF_ASSERT_NOT_EQUALS( KErrNone,r); |
|
2328 |
|
2329 r = manager->AgentSpecificCommand(agents[i], |
|
2330 EBufferContainsOma1Dcf, _L8("012345"), ptr); |
|
2331 STIF_ASSERT_NOT_EQUALS( KErrNone,r); |
|
2332 |
|
2333 r = manager->AgentSpecificCommand(agents[i], |
|
2334 EDecryptOma1DcfBuffer, *buffer, ptr); |
|
2335 STIF_ASSERT_EQUALS( KErrArgument,r); |
|
2336 |
|
2337 } |
|
2338 } |
|
2339 agents.Close(); |
|
2340 CleanupStack::PopAndDestroy(); |
|
2341 |
|
2342 |
|
2343 delete buffer; |
|
2344 delete result; |
|
2345 delete data; |
|
2346 return KErrNone; |
|
2347 } |
|
2348 |
|
2349 |
|
2350 TInt CDRM_CAF::CManager_CreateRightsManagerL() |
|
2351 { |
|
2352 CRightsManager* rm = NULL; |
|
2353 rm = GetOmaDrmRightsManagerL(); |
|
2354 STIF_ASSERT_NOT_NULL(rm); |
|
2355 delete rm; |
|
2356 |
|
2357 return KErrNone; |
|
2358 } |
|
2359 |
|
2360 TInt CDRM_CAF::CSupplier_IsImportSupportedL() |
|
2361 { |
|
2362 |
|
2363 CSupplier* supplier = CSupplier::NewLC(); |
|
2364 STIF_ASSERT_TRUE(supplier->IsImportSupported(KOma1DrmMessageContentType)); |
|
2365 STIF_ASSERT_TRUE(supplier->IsImportSupported(KOma1XmlRoContentType)); |
|
2366 STIF_ASSERT_TRUE(supplier->IsImportSupported(KOma1WbxmlRoContentType)); |
|
2367 STIF_ASSERT_TRUE(supplier->IsImportSupported(KOma2RoContentType)); |
|
2368 STIF_ASSERT_FALSE(supplier->IsImportSupported(_L8("text/plain"))); |
|
2369 CleanupStack::PopAndDestroy(1); |
|
2370 |
|
2371 return KErrNone; |
|
2372 } |
|
2373 |
|
2374 TInt CDRM_CAF::CSupplier_PrepareHTTPRequestHeadersL() |
|
2375 { |
|
2376 return KErrNone; |
|
2377 } |
|
2378 |
|
2379 TInt CDRM_CAF::CSupplier_SetOutputDirectory_ImportFileL() |
|
2380 { |
|
2381 |
|
2382 CSupplier* supplier = CSupplier::NewLC(); |
|
2383 CMetaDataArray* metaData = CMetaDataArray::NewLC(); |
|
2384 supplier->SetOutputDirectoryL(KEncryptedDir); |
|
2385 CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType, |
|
2386 *metaData, KTempDcfName); |
|
2387 STIF_ASSERT_NOT_NULL( file ); |
|
2388 CleanupStack::PushL(file); |
|
2389 CleanupStack::PopAndDestroy(3); |
|
2390 |
|
2391 return KErrNone; |
|
2392 } |
|
2393 |
|
2394 TInt CDRM_CAF::CImportFile_WriteData_WriteDataComplete_OutputFileCountL() |
|
2395 { |
|
2396 TFileName fileName; |
|
2397 TRequestStatus status; |
|
2398 TInt i; |
|
2399 TInt r; |
|
2400 |
|
2401 fileName.Copy(KEncryptedDir); |
|
2402 fileName.Append(KTempDcfName); |
|
2403 r = iFs.Delete(fileName); |
|
2404 STIF_ASSERT_EQUALS(KErrNone , r); |
|
2405 |
|
2406 CSupplier* supplier = CSupplier::NewLC(); |
|
2407 CMetaDataArray* metaData = CMetaDataArray::NewLC(); |
|
2408 supplier->SetOutputDirectoryL(KEncryptedDir); |
|
2409 CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType, |
|
2410 *metaData, KTempDcfName); |
|
2411 STIF_ASSERT_NOT_NULL( file ); |
|
2412 CleanupStack::PushL(file); |
|
2413 RUNCHECKEDL(file->WriteData(KDMSimple)); |
|
2414 RUNCHECKEDL(file->WriteDataComplete()); |
|
2415 STIF_ASSERT_EQUALS(1 , file->OutputFileCountL()); |
|
2416 CleanupStack::PopAndDestroy(3); |
|
2417 |
|
2418 |
|
2419 fileName.Copy(KEncryptedDir); |
|
2420 fileName.Append(KTempDcfName); |
|
2421 r = iFs.Delete(fileName); |
|
2422 STIF_ASSERT_EQUALS(KErrNone , r); |
|
2423 |
|
2424 supplier = CSupplier::NewLC(); |
|
2425 metaData = CMetaDataArray::NewLC(); |
|
2426 supplier->SetOutputDirectoryL(KEncryptedDir); |
|
2427 file = supplier->ImportFileL(KOma1DrmMessageContentType, |
|
2428 *metaData, KTempDcfName); |
|
2429 STIF_ASSERT_NOT_NULL( file ); |
|
2430 CleanupStack::PushL(file); |
|
2431 file->WriteData(KDMSimple, status); |
|
2432 User::WaitForRequest(status); |
|
2433 STIF_ASSERT_EQUALS(KErrNone , status.Int()); |
|
2434 file->WriteDataComplete(status); |
|
2435 User::WaitForRequest(status); |
|
2436 STIF_ASSERT_EQUALS(KErrNone , status.Int()); |
|
2437 STIF_ASSERT_EQUALS(1 , file->OutputFileCountL()); |
|
2438 CleanupStack::PopAndDestroy(3); |
|
2439 |
|
2440 |
|
2441 fileName.Copy(KEncryptedDir); |
|
2442 fileName.Append(KTempDcfName); |
|
2443 r = iFs.Delete(fileName); |
|
2444 STIF_ASSERT_EQUALS(KErrNone , r); |
|
2445 |
|
2446 supplier = CSupplier::NewLC(); |
|
2447 metaData = CMetaDataArray::NewLC(); |
|
2448 metaData->AddL(KOmaImportMimeTypeField, _L8("text/plain")); |
|
2449 supplier->SetOutputDirectoryL(KEncryptedDir); |
|
2450 file = supplier->ImportFileL(KOmaImportContentType, |
|
2451 *metaData, KTempDcfName); |
|
2452 STIF_ASSERT_NOT_NULL( file ); |
|
2453 CleanupStack::PushL(file); |
|
2454 for (i = 0; i < 100; i++) |
|
2455 { |
|
2456 STIF_ASSERT_EQUALS(KErrNone , file->WriteData(KDMContent) ); |
|
2457 } |
|
2458 STIF_ASSERT_EQUALS(KErrNone , file->WriteDataComplete()); |
|
2459 STIF_ASSERT_EQUALS(1 , file->OutputFileCountL()); |
|
2460 CleanupStack::PopAndDestroy(3); |
|
2461 |
|
2462 return KErrNone; |
|
2463 } |
|
2464 |
|
2465 TInt CDRM_CAF::CImportFile_OutputFileL_GetImportStatusL() |
|
2466 { |
|
2467 TFileName fileName; |
|
2468 TInt r; |
|
2469 |
|
2470 |
|
2471 fileName.Copy(KEncryptedDir); |
|
2472 fileName.Append(KTempDcfName); |
|
2473 r = iFs.Delete(fileName); |
|
2474 STIF_ASSERT_EQUALS(KErrNone , r); |
|
2475 |
|
2476 CSupplier* supplier = CSupplier::NewLC(); |
|
2477 CMetaDataArray* metaData = CMetaDataArray::NewLC(); |
|
2478 supplier->SetOutputDirectoryL(KEncryptedDir); |
|
2479 CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType, |
|
2480 *metaData, KTempDcfName); |
|
2481 STIF_ASSERT_NOT_NULL( file ); |
|
2482 CleanupStack::PushL(file); |
|
2483 RUNCHECKEDL(file->WriteData(KDMSimple)); |
|
2484 RUNCHECKEDL(file->WriteDataComplete()); |
|
2485 RUNCHECKED(file->GetImportStatus() == EComplete); |
|
2486 STIF_ASSERT_EQUALS(1 , file->OutputFileCountL()); |
|
2487 CSupplierOutputFile& output = file->OutputFileL(0); |
|
2488 STIF_ASSERT_EQUALS(0 , output.MimeTypeL().CompareF(KOma1DcfContentType)); |
|
2489 CleanupStack::PopAndDestroy(3); |
|
2490 |
|
2491 return KErrNone; |
|
2492 } |
|
2493 |
|
2494 TInt CDRM_CAF::CImportFile_GetSuggestedOutputFileExtensionL() |
|
2495 { |
|
2496 TInt r; |
|
2497 TBuf<256> buffer; |
|
2498 |
|
2499 |
|
2500 CSupplier* supplier = CSupplier::NewLC(); |
|
2501 CMetaDataArray* metaData = CMetaDataArray::NewLC(); |
|
2502 supplier->SetOutputDirectoryL(KEncryptedDir); |
|
2503 CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType, |
|
2504 *metaData); |
|
2505 STIF_ASSERT_NOT_NULL( file ); |
|
2506 CleanupStack::PushL(file); |
|
2507 r = file->WriteData(KDMSimple); |
|
2508 STIF_ASSERT_EQUALS(KErrCANewFileHandleRequired , r); |
|
2509 RUNCHECKEDL(file->GetSuggestedOutputFileExtension(buffer)); |
|
2510 STIF_ASSERT_EQUALS(0 , buffer.CompareF(_L(".dcf"))); |
|
2511 CleanupStack::PopAndDestroy(3); |
|
2512 |
|
2513 return KErrNone; |
|
2514 } |
|
2515 |
|
2516 TInt CDRM_CAF::CImportFile_GetSuggestedOutputFileNameL() |
|
2517 { |
|
2518 TInt r; |
|
2519 TBuf<256> buffer; |
|
2520 |
|
2521 |
|
2522 CSupplier* supplier = CSupplier::NewLC(); |
|
2523 CMetaDataArray* metaData = CMetaDataArray::NewLC(); |
|
2524 supplier->SetOutputDirectoryL(KEncryptedDir); |
|
2525 CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType, |
|
2526 *metaData); |
|
2527 STIF_ASSERT_NOT_NULL( file ); |
|
2528 CleanupStack::PushL(file); |
|
2529 r = file->WriteData(KDMSimple); |
|
2530 STIF_ASSERT_EQUALS(KErrCANewFileHandleRequired , r); |
|
2531 buffer.Copy(_L("test")); |
|
2532 RUNCHECKEDL(file->GetSuggestedOutputFileName(buffer)); |
|
2533 STIF_ASSERT_EQUALS(0 , buffer.CompareF(_L("test.dcf"))); |
|
2534 CleanupStack::PopAndDestroy(3); |
|
2535 |
|
2536 return KErrNone; |
|
2537 } |
|
2538 |
|
2539 TInt CDRM_CAF::CImportFile_ContinueWithNewOutputFileL() |
|
2540 { |
|
2541 TFileName fileName; |
|
2542 RFile f; |
|
2543 TInt r; |
|
2544 |
|
2545 |
|
2546 fileName.Copy(KEncryptedDir); |
|
2547 fileName.Append(KTempDcfName); |
|
2548 iFs.SetSessionPath(KEncryptedDir); |
|
2549 r = iFs.Delete(fileName); |
|
2550 STIF_ASSERT_EQUALS(KErrNone , r); |
|
2551 CSupplier* supplier = CSupplier::NewLC(); |
|
2552 CMetaDataArray* metaData = CMetaDataArray::NewLC(); |
|
2553 supplier->SetOutputDirectoryL(KEncryptedDir); |
|
2554 CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType, |
|
2555 *metaData); |
|
2556 STIF_ASSERT_NOT_NULL( file ); |
|
2557 CleanupStack::PushL(file); |
|
2558 r = file->WriteData(KDMSimple); |
|
2559 STIF_ASSERT_EQUALS(KErrCANewFileHandleRequired , r); |
|
2560 RUNCHECKEDL(f.Create(iFs, fileName, EFileWrite | EFileStream)); |
|
2561 CleanupClosePushL(f); |
|
2562 file->ContinueWithNewOutputFile(f, fileName); |
|
2563 RUNCHECKEDL(file->WriteData(KDMSimple)); |
|
2564 RUNCHECKEDL(file->WriteDataComplete()); |
|
2565 CleanupStack::PopAndDestroy(4); |
|
2566 |
|
2567 return KErrNone; |
|
2568 } |
|
2569 |
|
2570 TInt CDRM_CAF::CImportFile_ContentMimeTypeL() |
|
2571 { |
|
2572 TInt err( KErrNone ); |
|
2573 TBool boolean( EFalse ); |
|
2574 CSupplier* supplier = CSupplier::NewLC(); |
|
2575 CMetaDataArray* metaData = CMetaDataArray::NewLC(); |
|
2576 supplier->SetOutputDirectoryL(KEncryptedDir); |
|
2577 CImportFile* file = supplier->ImportFileL(KOma1DrmMessageContentType, |
|
2578 *metaData); |
|
2579 CleanupStack::PushL( file ); |
|
2580 err = file->WriteData(KDMSimple); |
|
2581 STIF_ASSERT_EQUALS(err, KErrCANewFileHandleRequired); |
|
2582 TBuf8<KMaxDataTypeLength> contentMime; |
|
2583 TRAP(err, boolean = file->ContentMimeTypeL( contentMime )); |
|
2584 STIF_ASSERT_EQUALS(KErrCANotSupported, err); |
|
2585 CleanupStack::PopAndDestroy( 3, supplier ); //file, metaData, supplier |
|
2586 return KErrNone; |
|
2587 } |
|
2588 |
|
2589 TInt CDRM_CAF::CRightsManager_ListRightsL() |
|
2590 { |
|
2591 CRightsManager* rm = NULL; |
|
2592 RStreamablePtrArray<CRightsInfo> rights; |
|
2593 rm = GetOmaDrmRightsManagerL(); |
|
2594 STIF_ASSERT_NOT_NULL( rm ); |
|
2595 CleanupStack::PushL(rm); |
|
2596 rm->ListRightsL(rights, KTempDcfPathName); |
|
2597 rights.ResetAndDestroy(); |
|
2598 rights.Close(); |
|
2599 CleanupStack::PopAndDestroy(); |
|
2600 RFile dcfFile; |
|
2601 |
|
2602 User::LeaveIfError(dcfFile.Open(iFs, KTempDcfPathName, EFileRead)); |
|
2603 CleanupClosePushL(dcfFile); |
|
2604 |
|
2605 rm = GetOmaDrmRightsManagerL(); |
|
2606 STIF_ASSERT_NOT_NULL( rm ); |
|
2607 CleanupStack::PushL(rm); |
|
2608 TRAPD( err, rm->ListRightsL(rights, dcfFile, KDefaultContentObject) ); |
|
2609 if ( err != KErrCANotSupported ) |
|
2610 { |
|
2611 User::LeaveIfError( err ); |
|
2612 } |
|
2613 rights.ResetAndDestroy(); |
|
2614 rights.Close(); |
|
2615 CleanupStack::PopAndDestroy( 2 ); |
|
2616 |
|
2617 return KErrNone; |
|
2618 } |
|
2619 |
|
2620 TInt CDRM_CAF::CRightsManager_ListAllRightsL() |
|
2621 { |
|
2622 CRightsManager* rm = NULL; |
|
2623 RStreamablePtrArray<CRightsInfo> rights; |
|
2624 rm = GetOmaDrmRightsManagerL(); |
|
2625 STIF_ASSERT_NOT_NULL( rm ); |
|
2626 CleanupStack::PushL(rm); |
|
2627 rm->ListAllRightsL(rights); |
|
2628 rights.ResetAndDestroy(); |
|
2629 rights.Close(); |
|
2630 CleanupStack::PopAndDestroy(); |
|
2631 return KErrNone; |
|
2632 } |
|
2633 |
|
2634 |
|
2635 TInt CDRM_CAF::CRightsManager_ListContentL() |
|
2636 { |
|
2637 TInt r = 0; |
|
2638 CRightsManager* rm = NULL; |
|
2639 RStreamablePtrArray<CVirtualPath> files; |
|
2640 CData* data = NULL; |
|
2641 TBuf<256> id; |
|
2642 CRightsInfo* info = NULL; |
|
2643 |
|
2644 TBool r1 = EFalse; |
|
2645 rm = GetOmaDrmRightsManagerL(); |
|
2646 STIF_ASSERT_NOT_NULL( rm ); |
|
2647 CleanupStack::PushL(rm); |
|
2648 |
|
2649 data = CData::NewLC(TVirtualPathPtr(KOma1Content, KDefaultContentObject), |
|
2650 EPeek, EContentShareReadOnly); |
|
2651 |
|
2652 RUNCHECKEDL(data->GetStringAttribute(EContentID, id)); |
|
2653 |
|
2654 info = CRightsInfo::NewL(KNullDesC, id, ERightsTypeStateless, |
|
2655 ERightsStatusValid); |
|
2656 |
|
2657 |
|
2658 CleanupStack::PushL(info); |
|
2659 |
|
2660 TRAP(r, rm->ListContentL(files, *info)); |
|
2661 if(r == KErrNone || r == KErrNotFound) |
|
2662 { |
|
2663 r1 = ETrue; |
|
2664 } |
|
2665 STIF_ASSERT_TRUE(r1); |
|
2666 files.ResetAndDestroy(); |
|
2667 files.Close(); |
|
2668 CleanupStack::PopAndDestroy(3); // rm, data, info |
|
2669 |
|
2670 return KErrNone; |
|
2671 } |
|
2672 |
|
2673 TInt CDRM_CAF::CRightsManager_DeleteRightsObjectL() |
|
2674 { |
|
2675 CRightsManager* rm = NULL; |
|
2676 CData* data = NULL; |
|
2677 TBuf<256> id; |
|
2678 CRightsInfo* info = NULL; |
|
2679 TInt r; |
|
2680 TBool r1 = EFalse; |
|
2681 rm = GetOmaDrmRightsManagerL(); |
|
2682 |
|
2683 STIF_ASSERT_NOT_NULL( rm ); |
|
2684 CleanupStack::PushL(rm); |
|
2685 data = CData::NewLC(TVirtualPathPtr(KOma1Content, KDefaultContentObject), |
|
2686 EPeek, EContentShareReadOnly); |
|
2687 RUNCHECKEDL(data->GetStringAttribute(EContentID, id)); |
|
2688 info = CRightsInfo::NewL(KNullDesC, id, ERightsTypeStateless, |
|
2689 ERightsStatusValid); |
|
2690 CleanupStack::PushL(info); |
|
2691 r = rm->DeleteRightsObject(*info); |
|
2692 if(r == -21 || r == 0) |
|
2693 { |
|
2694 r1 = ETrue; |
|
2695 } |
|
2696 STIF_ASSERT_TRUE(r1); |
|
2697 CleanupStack::PopAndDestroy(3); |
|
2698 |
|
2699 return KErrNone; |
|
2700 } |
|
2701 |
|
2702 TInt CDRM_CAF::CRightsManager_DeleteAllRightsObjectsL() |
|
2703 { |
|
2704 CRightsManager* rm = NULL; |
|
2705 CData* data = NULL; |
|
2706 TInt r; |
|
2707 TBool r1 = EFalse; |
|
2708 rm = GetOmaDrmRightsManagerL(); |
|
2709 |
|
2710 STIF_ASSERT_NOT_NULL( rm ); |
|
2711 CleanupStack::PushL(rm); |
|
2712 r = rm->DeleteAllRightsObjects(TVirtualPathPtr(KOma1Content, KNullDesC)); |
|
2713 if(r == -21 || r == -1) |
|
2714 { |
|
2715 r1 = ETrue; |
|
2716 } |
|
2717 STIF_ASSERT_TRUE(r1); |
|
2718 RFile file; |
|
2719 r1 = EFalse; |
|
2720 User::LeaveIfError(file.Open(iFs, KOma1Content, EFileRead)); |
|
2721 r = rm->DeleteAllRightsObjects(file, KDefaultContentObject); |
|
2722 if(r == -21 || r == -1 || r == KErrCANotSupported ) |
|
2723 { |
|
2724 r1 = ETrue; |
|
2725 } |
|
2726 STIF_ASSERT_TRUE(r1); |
|
2727 file.Close(); |
|
2728 CleanupStack::PopAndDestroy( rm ); |
|
2729 |
|
2730 return KErrNone; |
|
2731 } |
|
2732 |
|
2733 TInt CDRM_CAF::CRightsManager_SetPropertyL() |
|
2734 { |
|
2735 CRightsManager* rm = NULL; |
|
2736 TInt r; |
|
2737 rm = GetOmaDrmRightsManagerL(); |
|
2738 |
|
2739 STIF_ASSERT_NOT_NULL( rm ); |
|
2740 CleanupStack::PushL(rm); |
|
2741 r = rm->SetProperty(EAgentPropertyBufferSize, 1024); |
|
2742 STIF_ASSERT_EQUALS(KErrCANotSupported , r); |
|
2743 CleanupStack::PopAndDestroy(); |
|
2744 |
|
2745 return KErrNone; |
|
2746 } |
|
2747 |
|
2748 TInt CDRM_CAF::CDRMLicenseChecker_CheckLicenseL() |
|
2749 { |
|
2750 CDRMLicenseChecker* lc = NULL; |
|
2751 TInt r; |
|
2752 TFileName fileName; |
|
2753 HBufC8* data = NULL; |
|
2754 |
|
2755 fileName.Copy(KEncryptedDir); |
|
2756 fileName.Append(KTempDcfName); |
|
2757 |
|
2758 |
|
2759 lc = CDRMLicenseChecker::NewL(); |
|
2760 STIF_ASSERT_NOT_NULL( lc ); |
|
2761 CleanupStack::PushL(lc); |
|
2762 r = lc->CheckLicense( fileName, data ); |
|
2763 STIF_ASSERT_EQUALS(KErrAccessDenied , r); // this does not work in SDK |
|
2764 //STIF_ASSERT_EQUALS(KErrNone , r); // this works in the new SDK's |
|
2765 delete data; |
|
2766 CleanupStack::PopAndDestroy(); |
|
2767 |
|
2768 return KErrNone; |
|
2769 } |
|
2770 |
|
2771 |
|
2772 // [End of File] - Do not remove |