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