|
1 /* |
|
2 * Copyright (c) 2002 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: Declaration of class DrmRights for accessing common |
|
15 * DRM functions |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 #ifndef DRMRIGHTS_H |
|
21 #define DRMRIGHTS_H |
|
22 |
|
23 #include <e32base.h> |
|
24 #include <caf/caf.h> |
|
25 #include "DcfCommon.h" |
|
26 #include "DrmAsset.h" |
|
27 #include "DrmPermission.h" |
|
28 #include "DrmConstraint.h" |
|
29 |
|
30 using namespace ContentAccess; |
|
31 // TEST DEFINITION |
|
32 |
|
33 // FORWARD DECLARATIONS |
|
34 |
|
35 // CLASS DECLARATION |
|
36 |
|
37 /** |
|
38 * CDRMRightsConstraints: Encapsulates rights constaints for a specific right. |
|
39 * |
|
40 * @lib DrmRights.dll |
|
41 * @since 2.5 |
|
42 */ |
|
43 class CDRMRightsConstraints: public CBase |
|
44 { |
|
45 public: // Data Types |
|
46 enum TConstraintPriority |
|
47 { |
|
48 ENoConstraints = 8, |
|
49 ETime = 7, |
|
50 ETimeInterval = 6, |
|
51 ETimeIntervalCount = 5, |
|
52 ETimeCount = 4, |
|
53 EInterval = 3, |
|
54 EIntervalCount = 2, |
|
55 ECount = 1 |
|
56 }; |
|
57 public: // Constructors and destructor |
|
58 |
|
59 /** |
|
60 * Two-phased constructor. |
|
61 */ |
|
62 IMPORT_C static CDRMRightsConstraints* NewL(void); |
|
63 |
|
64 /** |
|
65 * Destructor. |
|
66 */ |
|
67 IMPORT_C virtual ~CDRMRightsConstraints(void); |
|
68 |
|
69 public: // New functions |
|
70 |
|
71 /** |
|
72 * FullRights |
|
73 * |
|
74 * The FullRights function checks if the object contains any restrictions |
|
75 * or if usage is unconstrained. |
|
76 * |
|
77 * @since 2.5 |
|
78 * @return ETrue if this object represents unconstrained rights, EFalse if |
|
79 * there are some constraints set |
|
80 */ |
|
81 IMPORT_C TBool FullRights(void); |
|
82 |
|
83 /** |
|
84 * IsPreview |
|
85 * |
|
86 * The function checks if the object represents a preview constraint. |
|
87 * |
|
88 * @since 2.5 |
|
89 * @return ETrue if this object represents a preview constraint, EFalse |
|
90 * otherwise |
|
91 */ |
|
92 IMPORT_C TBool IsPreview(void); |
|
93 |
|
94 /** |
|
95 * GetConstraintInfo |
|
96 * |
|
97 * The fucntion retunrs expiration and constraint details of the object |
|
98 * |
|
99 * @since 2.5 |
|
100 * @param aExpiration: return parameter for the expiration detail of the |
|
101 * object. EValid, EExpired, EFuture |
|
102 * @param aConstType: return parameter for the constraint details of the |
|
103 * object. A bitmask combination of ETimeBased, EInActiveInterval, |
|
104 * ECountBased. Or only ENoConstraints |
|
105 * @return Priority value of the object, if the details were returned |
|
106 * succesfully. Priority value defines, which constraint is used |
|
107 * during decryption. The highest one is consumed first. |
|
108 * EInvalidRights if details cannot be retrieved. |
|
109 */ |
|
110 IMPORT_C TInt GetConstraintInfo( |
|
111 TUint32& aExpiration, |
|
112 TUint32& aConstType); |
|
113 |
|
114 /** |
|
115 * GetExpirationDetails |
|
116 * |
|
117 * The function returns the end time and amount of counts left of the object. |
|
118 * |
|
119 * @since 2.5 |
|
120 * @param aEndTime: return parameter for the end time value of the object. |
|
121 * If end time restriction is not defined, parameter is set to 0. |
|
122 * @param aCountsLeft: return parameter for amount of counts left. If count |
|
123 * restriction is not defined, parameter is set to -1. |
|
124 * @return EOk if details were retrieved successfully. |
|
125 * |
|
126 */ |
|
127 IMPORT_C TInt GetExpirationDetails( |
|
128 TTime& aEndTime, |
|
129 TInt& aCountsLeft); |
|
130 |
|
131 /** |
|
132 * GetCounters |
|
133 * |
|
134 * This function returns the current value of the count restriction and |
|
135 * original value of the count restriction(value when the rights object |
|
136 * was added to the rights database) |
|
137 * |
|
138 * @since 2.5 |
|
139 * @param aCounter: out parameter for the current counter value |
|
140 * @param aOriginalCounter: out parameter for the original counter value |
|
141 * @return EOk if the counters were returned successfully, ENoRights if |
|
142 * the object does not contain count based restrictions |
|
143 */ |
|
144 IMPORT_C TInt GetCounters( |
|
145 TUint32& aCounter, |
|
146 TUint32& aOriginalCounter); |
|
147 |
|
148 /** |
|
149 * GetTimedCounters |
|
150 * |
|
151 * This function returns the current value of the timed count restriction and |
|
152 * original value of the count restriction(value when the rights object |
|
153 * was added to the rights database) |
|
154 * |
|
155 * @since 3.0 |
|
156 * @param aCounter: out parameter for the current timed counter value |
|
157 * @param aOriginalCounter: out parameter for the original counter value |
|
158 * @return EOk if the counters were returned successfully, ENoRights if |
|
159 * the object does not contain count based restrictions |
|
160 */ |
|
161 IMPORT_C TInt GetTimedCounters( |
|
162 TUint32& aCounter, |
|
163 TUint32& aOriginalCounter); |
|
164 |
|
165 /** |
|
166 * GetStartTime |
|
167 * |
|
168 * This function returns the start time constraint. |
|
169 * |
|
170 * @since 2.5 |
|
171 * @param aStartTime: out parameter for the start time restriction |
|
172 * @return EOk if the time restriction were returned successfully, |
|
173 * ENoRights if the object does not contain a start time |
|
174 * restrictions |
|
175 */ |
|
176 IMPORT_C TInt GetStartTime( |
|
177 TTime& aStartTime); |
|
178 |
|
179 /** |
|
180 * GetEndTime |
|
181 * |
|
182 * This function returns the end time constraint. |
|
183 * |
|
184 * @since 2.5 |
|
185 * @param aEndTime: out parameter for the end time restriction |
|
186 * @return EOk if the time restriction were returned successfully, |
|
187 * ENoRights if the object does not contain an end time |
|
188 * restrictions |
|
189 */ |
|
190 IMPORT_C TInt GetEndTime( |
|
191 TTime& aEndTime); |
|
192 |
|
193 /** |
|
194 * GetInterval |
|
195 * |
|
196 * This function returns interval time constraint |
|
197 * |
|
198 * @since 2.5 |
|
199 * @param anInterval: out parameter for the interval restriction |
|
200 * @return EOk if the interval time restriction was returned successfully, |
|
201 * ENoRights if the object does not contain interval based restrictions |
|
202 */ |
|
203 IMPORT_C TInt GetInterval( |
|
204 TTimeIntervalSeconds& anInterval); |
|
205 |
|
206 /** |
|
207 * GetIntervalStart |
|
208 * |
|
209 * This function returns the start time of an activated interval |
|
210 * |
|
211 * @since 2.5 |
|
212 * @param anInterval: out parameter for the start of an activated interval |
|
213 * @return EOk if the interval start time was returned successfully, |
|
214 * ENoRights if the interval has not been started yet |
|
215 */ |
|
216 IMPORT_C TInt GetIntervalStart( |
|
217 TTime& aStartTime); |
|
218 |
|
219 /** |
|
220 * GetAccumulated |
|
221 * |
|
222 * This function returns accumulated time constraint |
|
223 * |
|
224 * @since 3.0 |
|
225 * @param aAccumulated: out parameter for the accumulated time restriction |
|
226 * @return EOk if the accumulated time restriction was returned successfully, |
|
227 * ENoRights if the object does not contain accumulated time based restrictions |
|
228 */ |
|
229 IMPORT_C TInt GetAccumulated( |
|
230 TTimeIntervalSeconds& anInterval); |
|
231 |
|
232 /** |
|
233 * SetCounters |
|
234 * |
|
235 * Sets the counter instance variables of the rights constraint |
|
236 * |
|
237 * @since 2.5 |
|
238 * @param aCounter: the current counter value |
|
239 * @param aOriginalCounter: the original counter value |
|
240 * @return EOk if the counters were set successfully |
|
241 */ |
|
242 IMPORT_C TInt SetCounters( |
|
243 TUint32 aCounter, |
|
244 TUint32 aOriginalCounter); |
|
245 |
|
246 /** |
|
247 * SetStartTime |
|
248 * |
|
249 * Sets the start time constraint. |
|
250 * |
|
251 * @since 2.5 |
|
252 * @param aStartTime: the start time restriction |
|
253 * @return EOk if the time restriction was set successfully, |
|
254 * ENoRights if the object does not contain a start time |
|
255 * restrictions |
|
256 */ |
|
257 IMPORT_C TInt SetStartTime( |
|
258 TTime aStartTime); |
|
259 |
|
260 /** |
|
261 * SetEndTime |
|
262 * |
|
263 * Sets the end time constraint. |
|
264 * |
|
265 * @since 2.5 |
|
266 * @param aEndTime: the end time restriction |
|
267 * @return EOk if the time restriction was set successfully, |
|
268 */ |
|
269 IMPORT_C TInt SetEndTime( |
|
270 TTime aEndTime); |
|
271 |
|
272 /** |
|
273 * SetInterval |
|
274 * |
|
275 * Sets the interval time constraint |
|
276 * |
|
277 * @since 2.5 |
|
278 * @param anInterval: the interval restriction |
|
279 * @return EOk if the interval time restriction was set successfully. |
|
280 */ |
|
281 IMPORT_C TInt SetInterval( |
|
282 TTimeIntervalSeconds anInterval); |
|
283 |
|
284 /** |
|
285 * SetIntervalStart |
|
286 * |
|
287 * Sets the interval start time constraint |
|
288 * |
|
289 * @since 2.5 |
|
290 * @param anInterval: the interval start restriction |
|
291 * @return EOk if the interval start restriction was set successfully. |
|
292 */ |
|
293 IMPORT_C TInt SetIntervalStart( |
|
294 TTime aStartTime); |
|
295 |
|
296 /** |
|
297 * |
|
298 * @since 3.0 |
|
299 * @param |
|
300 * @return |
|
301 */ |
|
302 IMPORT_C CDRMConstraint& GetConstraint(void); |
|
303 |
|
304 /** |
|
305 * |
|
306 * @since 3.0 |
|
307 * @param |
|
308 * @return |
|
309 */ |
|
310 IMPORT_C void SetConstraint(CDRMConstraint&); |
|
311 |
|
312 /** |
|
313 * operator= |
|
314 * |
|
315 * Assignment operator. |
|
316 * |
|
317 * @since 2.5 |
|
318 * @param aConstraint: constraint to copy data from |
|
319 * @return a copy of the aConstraint parameter. |
|
320 */ |
|
321 IMPORT_C CDRMRightsConstraints& operator=( |
|
322 CDRMRightsConstraints& aConstraint); |
|
323 |
|
324 protected: |
|
325 |
|
326 /** |
|
327 * Default constructor. |
|
328 */ |
|
329 IMPORT_C CDRMRightsConstraints(void); |
|
330 |
|
331 /** |
|
332 * 2nd phase constructor. |
|
333 */ |
|
334 IMPORT_C void ConstructL(void); |
|
335 |
|
336 |
|
337 protected: // Data |
|
338 |
|
339 CDRMConstraint* iConstraint; |
|
340 }; |
|
341 |
|
342 // CLASS DECLARATION |
|
343 |
|
344 /** |
|
345 * CDRMRights: Encapsulates a single rights object. |
|
346 * |
|
347 * @lib DrmRights.dll |
|
348 * @since 2.5 |
|
349 */ |
|
350 class CDRMRights: public CBase, public MAgentRightsBase |
|
351 { |
|
352 public: // Data Types |
|
353 enum TExpiration |
|
354 { |
|
355 EValidRights = 100, |
|
356 EFutureRights = 10, |
|
357 EExpiredRights = 1 |
|
358 }; |
|
359 |
|
360 enum TConstraintType |
|
361 { |
|
362 ENoConstraints = 0x0001, |
|
363 ETimeBased = 0x0002, |
|
364 EInActiveInterval = 0x0004, |
|
365 ECountBased = 0x0008, |
|
366 ETimeIsAccumulatedTime = 0x0010 |
|
367 }; |
|
368 |
|
369 enum TRestriction |
|
370 { |
|
371 EFullRights = 1, |
|
372 ERestrictedRights, |
|
373 EPreviewRights |
|
374 }; |
|
375 |
|
376 enum |
|
377 { |
|
378 EPlay = ContentAccess::EPlay, |
|
379 EDisplay = ContentAccess::EView, |
|
380 EExecute = ContentAccess::EExecute, |
|
381 EPrint = ContentAccess::EPrint, |
|
382 EInstall = ContentAccess::EInstall, |
|
383 }; |
|
384 |
|
385 enum TConsumeAction |
|
386 { |
|
387 EStart, |
|
388 EFinish, |
|
389 }; |
|
390 |
|
391 enum |
|
392 { |
|
393 EOk = KErrNone, |
|
394 EGeneralError = -30100, |
|
395 EUnknownMIME = -30101, |
|
396 EVersionNotSupported = -30102, |
|
397 ESessionError = -30103, |
|
398 ENoRights = KErrCANoRights, |
|
399 ERightsDBCorrupted = -30105, |
|
400 EUnsupported = KErrCANotSupported, |
|
401 ERightsExpired = KErrCANoPermission, |
|
402 EInvalidRights = -30108 |
|
403 }; |
|
404 |
|
405 enum |
|
406 { |
|
407 EForwardLock = 0x0001, |
|
408 ECombinedDelivery = 0x0002, |
|
409 ESeparateDelivery = 0x0004, |
|
410 ESuperDistribution = 0x0008 |
|
411 }; |
|
412 |
|
413 public: // Constructors and destructor |
|
414 |
|
415 /** |
|
416 * Two-phased constructor. |
|
417 */ |
|
418 IMPORT_C static CDRMRights* NewL(void); |
|
419 |
|
420 /** |
|
421 * Destructor. |
|
422 */ |
|
423 IMPORT_C virtual ~CDRMRights(void); |
|
424 |
|
425 public: // New functions |
|
426 |
|
427 /** |
|
428 * GetContentURI |
|
429 * |
|
430 * This function returns the content URI of the object |
|
431 * |
|
432 * @since 2.5 |
|
433 * @param aContentURI: out parameter for the content URI. |
|
434 * @return EOk if the URI was returned successfully. |
|
435 */ |
|
436 IMPORT_C TInt GetContentURI( |
|
437 HBufC8*& aContentURI); |
|
438 |
|
439 /** |
|
440 * GetLocalID |
|
441 * |
|
442 * This function returns the local ID of the object |
|
443 * |
|
444 * @since 2.5 |
|
445 * @return the local ID. |
|
446 */ |
|
447 IMPORT_C TUint32 GetLocalID(void); |
|
448 |
|
449 /** |
|
450 * GetAddTime |
|
451 * |
|
452 * This function returns the time when the rights object was added to the |
|
453 * rights database |
|
454 * |
|
455 * @since 2.5 |
|
456 * @param aTime: out parameter for the time. |
|
457 */ |
|
458 IMPORT_C void GetAddTime( |
|
459 TTime& aTime); |
|
460 |
|
461 /** |
|
462 * GetRightsInfo |
|
463 * |
|
464 * This function returns the restriction details associated with given |
|
465 * permission. |
|
466 * |
|
467 * @since 2.5 |
|
468 * @param aConstraintSpec: The permissions to be checked defined as a |
|
469 * bitmask combination of EPlay, EDisplay, EExecute and EPrint |
|
470 * @param aRestriction: return paramer for the restriction detail of the |
|
471 * object: EFullRights, ERestrictedRights or EPreviewRights |
|
472 * @param aExpiration: return parameter for the expiration detail of the |
|
473 * object: EValid, EExpired, EFuture |
|
474 * @param aConstType: return parameter for the constraint details of the |
|
475 * object. ETimeBased, EInActiveInterval, ECountBased or ENoConstraints |
|
476 * @return Priority value of the object, if the details were returned |
|
477 * succesfully. Priority value defines, which object is used |
|
478 * during decryption. The value is calculated with formula: |
|
479 * TConstraintPriority * TRightsExpiration. |
|
480 * ENoRights if no rights for given permissions. |
|
481 */ |
|
482 IMPORT_C TInt GetRightsInfo( |
|
483 TUint32 aConstraintSpec, |
|
484 TRestriction& aRestriction, |
|
485 TExpiration& aExpiration, |
|
486 TUint32& aConstType); |
|
487 |
|
488 /** |
|
489 * GetExpirationDetails |
|
490 * |
|
491 * The function returns the end time and amount of counts left of the object |
|
492 * associated with given permission. The use of this method is only recommended |
|
493 * for objects, which contain a end time or a count restriction. The constraint |
|
494 * type information can be retrieved with e.g. GetRightsInfo -function. |
|
495 * In cases of full rights and inactive interval rights the aEndTime is set to |
|
496 * 0 and the aCountsLeft is set to < 0. |
|
497 * |
|
498 * @since 2.5 |
|
499 * @param aConstraintSpec: The permissions to be checked defined as a |
|
500 * bitmask combination of EPlay, EDisplay, EExecute and EPrint. |
|
501 * @param aEndTime: return parameter for the end time value of the object. |
|
502 * If end time restriction is not defined, parameter is set to 0. |
|
503 * @param aCountsLeft: return parameter for amount of counts left. If count |
|
504 * restriction is not defined, parameter is set to -1. |
|
505 * @return EOk if details were retrieved successfully. ENoRights if no rights |
|
506 * for given permissions. |
|
507 */ |
|
508 IMPORT_C TInt GetExpirationDetails( |
|
509 TUint32 aConstraintSpec, |
|
510 TTime& aEndTime, |
|
511 TInt& aCountsLeft); |
|
512 |
|
513 /** |
|
514 * GetPlayRight |
|
515 * |
|
516 * This function returns the constraints associated with the play right. |
|
517 * |
|
518 * @since 2.5 |
|
519 * @param aConstraint: out parameter for the constraints associated with |
|
520 * this right. It must be deleted by the caller. |
|
521 * @return EOk if the right exists and the associated restrictions were |
|
522 * returned successfully, ENoRights if the object does not contain |
|
523 * the given right. |
|
524 */ |
|
525 IMPORT_C TInt GetPlayRight( |
|
526 CDRMRightsConstraints*& aConstraint); |
|
527 |
|
528 /** |
|
529 * GetDisplayRight |
|
530 * |
|
531 * This function returns the constraints associated with the display right. |
|
532 * |
|
533 * @since 2.5 |
|
534 * @param aConstraint: out parameter for the constraints associated with |
|
535 * this right. It must be deleted by the caller. |
|
536 * @return EOk if the right exists and the associated restrictions were |
|
537 * returned successfully, ENoRights if the object does not contain |
|
538 * the given right. |
|
539 */ |
|
540 IMPORT_C TInt GetDisplayRight( |
|
541 CDRMRightsConstraints*& aConstraint); |
|
542 |
|
543 /** |
|
544 * GetPrintRight |
|
545 * |
|
546 * This function returns the constraints associated with the print right. |
|
547 * |
|
548 * @since 2.5 |
|
549 * @param aConstraint: out parameter for the constraints associated with |
|
550 * this right. It must be deleted by the caller. |
|
551 * @return EOk if the right exists and the associated restrictions were |
|
552 * returned successfully, ENoRights if the object does not contain |
|
553 * the given right. |
|
554 */ |
|
555 IMPORT_C TInt GetPrintRight( |
|
556 CDRMRightsConstraints*& aConstraint); |
|
557 |
|
558 /** |
|
559 * GetExecuteRight |
|
560 * |
|
561 * This function returns the constraints associated with the execute right. |
|
562 * |
|
563 * @since 2.5 |
|
564 * @param aConstraint: out parameter for the constraints associated with |
|
565 * this right. It must be deleted by the caller. |
|
566 * @return EOk if the right exists and the associated restrictions were |
|
567 * returned successfully, ENoRights if the object does not contain |
|
568 * the given right. |
|
569 */ |
|
570 IMPORT_C TInt GetExecuteRight( |
|
571 CDRMRightsConstraints*& aConstraint); |
|
572 |
|
573 /** |
|
574 * GetContentURIAndLocalID |
|
575 * |
|
576 * This function sets the content URI and local ID of the object. |
|
577 * |
|
578 * @since 2.5 |
|
579 * @param aContentURI: the new content URI. |
|
580 * @param aLocalID: the new local ID. |
|
581 * @return EOk if the values were set successfully. |
|
582 */ |
|
583 IMPORT_C TInt SetContentURIAndLocalID( |
|
584 HBufC8* aContentURI, |
|
585 TUint32 aLocalID); |
|
586 |
|
587 IMPORT_C TInt SetContentURI( |
|
588 HBufC8* aContentURI); |
|
589 |
|
590 IMPORT_C TInt SetLocalID( |
|
591 TUint32 aLocalID); |
|
592 |
|
593 /** |
|
594 * SetAddTime |
|
595 * |
|
596 * Sets the add time of the object. |
|
597 * |
|
598 * @since 2.5 |
|
599 * @param aTime: the new add time. |
|
600 * @return EOk if the value was set successfully. |
|
601 */ |
|
602 IMPORT_C void SetAddTime( |
|
603 TTime aTime); |
|
604 |
|
605 /** |
|
606 * SetPlayRight |
|
607 * |
|
608 * This function sets the play constraints. |
|
609 * |
|
610 * @since 2.5 |
|
611 * @param aConstraint: the constraints associated with the play right. |
|
612 * It must be deleted by the caller. |
|
613 * @return EOk if the restrictions were set successfully |
|
614 */ |
|
615 IMPORT_C TInt SetPlayRight( |
|
616 CDRMRightsConstraints* aConstraint); |
|
617 |
|
618 /** |
|
619 * SetDisplayRight |
|
620 * |
|
621 * This function sets the constraints. |
|
622 * |
|
623 * @since 2.5 |
|
624 * @param aConstraint: the constraints associated with the display right. |
|
625 * It must be deleted by the caller. |
|
626 * @return EOk if the restrictions were set successfully |
|
627 */ |
|
628 IMPORT_C TInt SetDisplayRight( |
|
629 CDRMRightsConstraints* aConstraint); |
|
630 |
|
631 /** |
|
632 * SetPrintRight |
|
633 * |
|
634 * This function sets the print constraints. |
|
635 * |
|
636 * @since 2.5 |
|
637 * @param aConstraint: the constraints associated with the print right. |
|
638 * It must be deleted by the caller. |
|
639 * @return EOk if the restrictions were set successfully |
|
640 */ |
|
641 IMPORT_C TInt SetPrintRight( |
|
642 CDRMRightsConstraints* aConstraint); |
|
643 |
|
644 /** |
|
645 * SetExecuteRight |
|
646 * |
|
647 * This function sets the execute constraints. |
|
648 * |
|
649 * @since 2.5 |
|
650 * @param aConstraint: the constraints associated with the execute right. |
|
651 * It must be deleted by the caller. |
|
652 * @return EOk if the restrictions were set successfully |
|
653 */ |
|
654 IMPORT_C TInt SetExecuteRight( |
|
655 CDRMRightsConstraints* aConstraint); |
|
656 |
|
657 /** |
|
658 * operator= |
|
659 * |
|
660 * Assignment operator. |
|
661 * |
|
662 * @since 2.5 |
|
663 * @param aRight: object to copy data from |
|
664 * @return a copy of the aRight parameter. |
|
665 */ |
|
666 IMPORT_C CDRMRights& operator=( |
|
667 CDRMRights& aRight); |
|
668 |
|
669 /** |
|
670 * |
|
671 * |
|
672 * @since 3.0 |
|
673 * @param |
|
674 * @return |
|
675 */ |
|
676 IMPORT_C CDRMPermission& GetPermission(void); |
|
677 |
|
678 /** |
|
679 * Permission needs to be freed, doesn't take control |
|
680 * |
|
681 * @since 3.0 |
|
682 * @param |
|
683 * @return |
|
684 */ |
|
685 IMPORT_C void SetPermissionL(CDRMPermission& aPermission); |
|
686 |
|
687 /** |
|
688 * |
|
689 * |
|
690 * @since 3.0 |
|
691 * @param |
|
692 * @return |
|
693 */ |
|
694 IMPORT_C CDRMAsset& GetAsset(void); |
|
695 |
|
696 /** |
|
697 * Asset needs to be freed, doesn't take control |
|
698 * |
|
699 * @since 3.0 |
|
700 * @param |
|
701 * @return |
|
702 */ |
|
703 IMPORT_C void SetAssetL(CDRMAsset& aAsset); |
|
704 |
|
705 /** |
|
706 * |
|
707 * |
|
708 * @since 3.0 |
|
709 * @param |
|
710 * @return |
|
711 */ |
|
712 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
713 |
|
714 /** |
|
715 * |
|
716 * |
|
717 * @since 3.0 |
|
718 * @param |
|
719 * @return |
|
720 */ |
|
721 IMPORT_C void InternalizeL(RReadStream& aStream); |
|
722 |
|
723 /** |
|
724 * Merge with another rights object |
|
725 * |
|
726 * @since 3.0 |
|
727 * @param |
|
728 * @return |
|
729 */ |
|
730 IMPORT_C void Merge(const CDRMRights& aRights); |
|
731 |
|
732 protected: |
|
733 |
|
734 /** |
|
735 * Default constructor. |
|
736 */ |
|
737 IMPORT_C CDRMRights(void); |
|
738 |
|
739 /** |
|
740 * 2nd phase constructor. |
|
741 */ |
|
742 IMPORT_C void ConstructL(void); |
|
743 |
|
744 |
|
745 protected: // Data |
|
746 |
|
747 CDRMAsset* iAsset; |
|
748 CDRMPermission* iPermission; |
|
749 }; |
|
750 |
|
751 #endif // DRMRIGHTS_H |
|
752 |
|
753 // End of File |