|
1 /* |
|
2 * Copyright (c) 2008-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 the License "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 * Declares entry classes for Software Components Registry interface. |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 /** |
|
21 @file |
|
22 @publishedAll |
|
23 @released |
|
24 */ |
|
25 |
|
26 #ifndef SCRENTRIES_H |
|
27 #define SCRENTRIES_H |
|
28 |
|
29 #include <e32base.h> |
|
30 #include <s32strm.h> |
|
31 #include <f32file.h> |
|
32 #include <usif/usifcommon.h> |
|
33 |
|
34 namespace Usif |
|
35 { |
|
36 // CONSTANTS |
|
37 |
|
38 /** |
|
39 KUnspecifiedLocale means that the locale is not specified and locale resolving will be done by SCR. |
|
40 First, the current locale with its downgraded languages (@see BaflUtils::GetDowngradePathL) is tried |
|
41 by SCR. If no value is found, then non-localized values are searched for. |
|
42 */ |
|
43 static const TLanguage KUnspecifiedLocale = TLanguage(-1); |
|
44 |
|
45 /** |
|
46 KNonLocalized means that only non-localized values are looked up by SCR. |
|
47 */ |
|
48 static const TLanguage KNonLocalized = TLanguage(0); |
|
49 |
|
50 // CLASSES |
|
51 |
|
52 |
|
53 NONSHARABLE_CLASS(CGlobalComponentId) : public CBase |
|
54 /** |
|
55 Encapsulates the global software component identifier which is a named, component level and nullable string. |
|
56 that an installer may use to specify a deterministic identifier for the component that is unique within |
|
57 the context of that software type. This global component id would be the package UID for native applications |
|
58 or the midlet-names for Java etc |
|
59 |
|
60 The global component id is consistent and equal on all devices. It is used to state dependencies |
|
61 and to check for the presence of installed software components of arbitrary types without each installer having |
|
62 to be aware of every other installers naming scheme. |
|
63 */ |
|
64 { |
|
65 public: |
|
66 /** |
|
67 Creates an empty global software component ID object. |
|
68 @return A pointer to the newly allocated global software component ID object, if creation is successful. |
|
69 The pointer is also put onto the cleanup stack. |
|
70 */ |
|
71 IMPORT_C static CGlobalComponentId* NewLC(); |
|
72 |
|
73 /** |
|
74 Creates a global software component ID object. |
|
75 @param aGlobalIdName A deterministic identifier for the component that is unique within the context of that software type. |
|
76 @param aUniqueSwTypeName Non-localized unique software type name, such as @see Usif::KSoftwareTypeNative and @see Usif::KSoftwareTypeJava. |
|
77 @return A pointer to the newly allocated global software component ID object, if creation is successful. |
|
78 */ |
|
79 IMPORT_C static CGlobalComponentId* NewL(const TDesC& aGlobalIdName, const TDesC& aUniqueSwTypeName); |
|
80 |
|
81 /** |
|
82 Creates a global software component ID object. |
|
83 @param aGlobalIdName A deterministic identifier for the component that is unique within the context of that software type. |
|
84 @param aUniqueSwTypeName Non-localized unique software type name, such as @see Usif::KSoftwareTypeNative and @see Usif::KSoftwareTypeJava. |
|
85 @return A pointer to the newly allocated global software component ID object, if creation is successful. |
|
86 The pointer is also put onto the cleanup stack. |
|
87 */ |
|
88 IMPORT_C static CGlobalComponentId* NewLC(const TDesC& aGlobalIdName, const TDesC& aUniqueSwTypeName); |
|
89 |
|
90 /** |
|
91 Creates a global software component ID object from a stream. |
|
92 @param aStream The stream to read the software component entry object from |
|
93 @return A pointer to the newly allocated global software component ID object, if creation is successful. |
|
94 @internalComponent |
|
95 */ |
|
96 IMPORT_C static CGlobalComponentId* NewL(RReadStream& aStream); |
|
97 |
|
98 /** |
|
99 Externalises this CGlobalComponentId object to a write stream. |
|
100 @param aStream The stream to which the object is externalised. |
|
101 @internalComponent |
|
102 */ |
|
103 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
104 |
|
105 /** |
|
106 Internalises this CGlobalComponentId object from a read stream. |
|
107 @param aStream The stream from which the object is internalised. |
|
108 @internalComponent |
|
109 */ |
|
110 IMPORT_C void InternalizeL(RReadStream& aStream); |
|
111 |
|
112 /** @return The global id name part (@see CGlobalComponentId::NewLC) of the global component id.*/ |
|
113 IMPORT_C const TDesC& GlobalIdName() const; |
|
114 |
|
115 /** @return The software type name part (@see CGlobalComponentId::NewLC) of the global component id. */ |
|
116 IMPORT_C const TDesC& SoftwareTypeName() const; |
|
117 |
|
118 IMPORT_C ~CGlobalComponentId(); |
|
119 |
|
120 private: |
|
121 CGlobalComponentId(); |
|
122 void ConstructL(const TDesC& aGlobalIdName, const TDesC& aSoftwareTypeName); |
|
123 |
|
124 private: |
|
125 HBufC* iGlobalIdName; ///< The global id name part of the global component id. |
|
126 HBufC* iSoftwareTypeName; ///< The software type name part of the global component id. |
|
127 }; |
|
128 |
|
129 |
|
130 NONSHARABLE_CLASS(CVersionedComponentId) : public CBase |
|
131 /** |
|
132 Class that represents a continuous set of versions for a particular component. |
|
133 |
|
134 This class is used for specifying dependencies, where a dependant component requires |
|
135 specific version(s) of the supplier to be present on the system. The version information |
|
136 is optional, i.e. this class can be used to represent any version of a component. |
|
137 |
|
138 If this class is used to represent a dependant component, it specifies the range of versions |
|
139 of the dependency relationship defined by the dependant component. |
|
140 */ |
|
141 { |
|
142 public: |
|
143 |
|
144 /** |
|
145 Creates an empty version component identifier object. |
|
146 @return A pointer to the newly allocated version component identifier object, if creation is successful. |
|
147 The pointer is also put onto the cleanup stack. |
|
148 */ |
|
149 IMPORT_C static CVersionedComponentId* NewLC(); |
|
150 |
|
151 /** |
|
152 Creates a versioned component identifier object. |
|
153 |
|
154 N.B. The version parameters are optional and used to set the lower and upper limit of the version range. |
|
155 It is also possible to set only an upper limit or a lower limit or none. If only one version |
|
156 parameter is supplied then a lower limit will be set. In this case, there is no upper limit. |
|
157 If the first version parameter is upplied with KNullDesC, then the second version parameter |
|
158 will be used to set an upper limit. |
|
159 |
|
160 @param aGlobalId The global software component identifier. |
|
161 @param aVersionFrom The first version of the specified version range. |
|
162 @param aVersionTo The last version of the specified version range. |
|
163 |
|
164 @return A pointer to the newly allocated versioned component identifier object, if creation is successful. |
|
165 */ |
|
166 IMPORT_C static CVersionedComponentId* NewL(const CGlobalComponentId& aGlobalId, const TDesC* aVersionFrom=NULL, const TDesC* aVersionTo=NULL); |
|
167 |
|
168 /** |
|
169 Creates a versioned component identifier object. |
|
170 For more information about the version parameters look at @see CVersionedComponentId::NewLC(). |
|
171 |
|
172 @param aGlobalId The global software component identifier. |
|
173 @param aVersionFrom The first version of the specified version range. |
|
174 @param aVersionTo The last version of the specified version range. |
|
175 |
|
176 @return A pointer to the newly allocated versioned component identifier object, if creation is successful. |
|
177 The pointer is also put onto the cleanup stack. |
|
178 */ |
|
179 IMPORT_C static CVersionedComponentId* NewLC(const CGlobalComponentId& aGlobalId, const TDesC* aVersionFrom=NULL, const TDesC* aVersionTo=NULL); |
|
180 |
|
181 /** |
|
182 Creates a versioned component identifier object from a stream. |
|
183 @param aStream The stream to read the versioned component identifier object from |
|
184 @return A pointer to the newly allocated versioned component identifier object, if creation is successful. |
|
185 @internalComponent |
|
186 */ |
|
187 IMPORT_C static CVersionedComponentId* NewL(RReadStream& aStream); |
|
188 |
|
189 /** |
|
190 Internalises this CVersionedComponentId object from a read stream. |
|
191 @param aStream The stream from which the object is internalised. |
|
192 @internalComponent |
|
193 */ |
|
194 IMPORT_C void InternalizeL(RReadStream& aStream); |
|
195 |
|
196 /** |
|
197 Externalises this CVersionedComponentId object to a write stream. |
|
198 @param aStream The stream to which the object is externalised. |
|
199 @internalComponent |
|
200 */ |
|
201 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
202 |
|
203 /** @return The global id of the versioned component. */ |
|
204 IMPORT_C const CGlobalComponentId& GlobalId() const; |
|
205 |
|
206 /** @return The first version of the specified version range. NULL, if there is no lower limit for the version range. */ |
|
207 IMPORT_C const TDesC* VersionFrom() const; |
|
208 |
|
209 /** @return The last version of the specified version range. NULL, if there is no upper limit for the version range. */ |
|
210 IMPORT_C const TDesC* VersionTo() const; |
|
211 |
|
212 IMPORT_C ~CVersionedComponentId(); |
|
213 |
|
214 private: |
|
215 CVersionedComponentId(); |
|
216 void ConstructL(const CGlobalComponentId& aGlobalId, const TDesC* aVersionFrom, const TDesC* aVersionTo); |
|
217 |
|
218 private: |
|
219 CGlobalComponentId* iGlobalId; ///< The global id of the versioned component identifier. |
|
220 HBufC* iVersionFrom; ///< The first version of the specified version range. |
|
221 HBufC* iVersionTo; ///< The last version of the specified version range. |
|
222 }; |
|
223 |
|
224 |
|
225 class CComponentEntry : public CBase |
|
226 /** |
|
227 Class that represents a software component entry stored in the SCR. |
|
228 */ |
|
229 { |
|
230 friend class CScrRequestImpl; |
|
231 public: |
|
232 /** |
|
233 Creates an empty software component entry object. |
|
234 @return A pointer to the newly allocated software component object, if creation is successful. |
|
235 */ |
|
236 IMPORT_C static CComponentEntry* NewL(); |
|
237 |
|
238 /** |
|
239 Creates an empty software component entry object. |
|
240 @return A pointer to the newly allocated software component object, if creation is successful. |
|
241 The pointer is also put onto the cleanup stack. |
|
242 */ |
|
243 IMPORT_C static CComponentEntry* NewLC(); |
|
244 |
|
245 /** |
|
246 Creates a software component entry object from a stream. |
|
247 @param aStream The stream to read the software component entry object from |
|
248 @return A pointer to the newly allocated software component entry object, if creation is successful. |
|
249 @internalComponent |
|
250 */ |
|
251 IMPORT_C static CComponentEntry* NewL(RReadStream& aStream); |
|
252 |
|
253 /** |
|
254 Creates a software component entry object. |
|
255 |
|
256 @param aId The unique ID of the software component. |
|
257 @param aName The name of of the software component. |
|
258 @param aVendor The vendor name of the software component. |
|
259 @param aSwType The software type of the component. |
|
260 @param aGlobalId The globally unique identifier of the component. |
|
261 @param aRemovable Whether the component is removable. ETrue means the component is removable. |
|
262 @param aSize The total size of the component at installation time in bytes. |
|
263 @param aScomoState The SCOMO state of the component. |
|
264 @param aInstalledDrives The set of drives that files for the software component were installed to. |
|
265 @param aVersion The version identifier of the software component. |
|
266 @param aInstallTime The formatted install time string. The format is as following: YYYYMMDD:HHMMSS |
|
267 @param aDrmProtected Whether the component is DRM protected. ETrue means the component is DRM protected. |
|
268 @param aHidden Whether the component is displayed in the list of installed components. ETrue means the component is hidden. |
|
269 @param aKnownRevoked Whether the component has been revoked. ETrue means that a revocation check was |
|
270 performed during or after the installation and the component was found to be revoked. |
|
271 @param aOriginVerified Whether the installer has verified the originator of the component. ETrue means the installer |
|
272 has verified the originator of the software component by using appropriate checking mechanisms. |
|
273 @return A pointer to the newly allocated software component object, if creation is successful. |
|
274 @internalComponent |
|
275 */ |
|
276 IMPORT_C static CComponentEntry* NewL(const TComponentId& aId, const TDesC& aName, const TDesC& aVendor, const TDesC& aSwType, |
|
277 const TDesC& aGlobalId, TBool aRemovable, TInt64 aSize, const TScomoState& aScomoState, |
|
278 const TDriveList& aInstalledDrives, const TDesC& aVersion, const TDesC& aInstallTime, |
|
279 TBool aDrmProtected, TBool aHidden, TBool aKnownRevoked, TBool aOriginVerified); |
|
280 |
|
281 /** |
|
282 Creates a software component entry object. |
|
283 |
|
284 @param aId The unique ID of the software component. |
|
285 @param aName The name of of the software component. |
|
286 @param aVendor The vendor name of the software component. |
|
287 @param aSwType The software type of the component. |
|
288 @param aGlobalId The globally unique identifier of the component. |
|
289 @param aRemovable Whether the component is removable. ETrue means the component is removable. |
|
290 @param aSize The total size of the component at installation time in bytes. |
|
291 @param aScomoState The SCOMO state of the component. |
|
292 @param aInstalledDrives The set of drives that files for the software component were installed to. |
|
293 @param aVersion The version identifier of the software component. |
|
294 @param aInstallTime The formatted install time string. The format is as following: YYYYMMDD:HHMMSS |
|
295 @param aDrmProtected Whether the component is DRM protected. ETrue means the component is DRM protected. |
|
296 @param aHidden Whether the component is displayed in the list of installed components. ETrue means the component is hidden. |
|
297 @param aKnownRevoked Whether the component has been revoked. ETrue means that a revocation check was |
|
298 performed during or after the installation and the component was found to be revoked. |
|
299 @param aOriginVerified Whether the installer has verified the originator of the component. ETrue means the installer |
|
300 has verified the originator of the software component by using appropriate checking mechanisms. |
|
301 @return A pointer to the newly allocated software component object, if creation is successful. |
|
302 The pointer is also put onto the cleanup stack. |
|
303 @internalComponent |
|
304 */ |
|
305 IMPORT_C static CComponentEntry* NewLC(const TComponentId& aId, const TDesC& aName, const TDesC& aVendor, const TDesC& aSwType, |
|
306 const TDesC& aGlobalId, TBool aRemovable, TInt64 aSize, const TScomoState& aScomoState, |
|
307 const TDriveList& aInstalledDrives, const TDesC& aVersion, const TDesC& aInstallTime, |
|
308 TBool aDrmProtected, TBool aHidden, TBool aKnownRevoked, TBool aOriginVerified); |
|
309 |
|
310 IMPORT_C ~CComponentEntry(); |
|
311 |
|
312 /** |
|
313 Externalises this CComponentEntry object to a write stream. |
|
314 @param aStream The stream to which the object is externalised. |
|
315 @internalComponent |
|
316 */ |
|
317 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
318 |
|
319 /** |
|
320 Internalises this CComponentEntry object from a read stream. |
|
321 @param aStream The stream from which the object is internalised. |
|
322 @internalComponent |
|
323 */ |
|
324 IMPORT_C void InternalizeL(RReadStream& aStream); |
|
325 |
|
326 /** @return The unique ID of the software component. */ |
|
327 IMPORT_C const TComponentId& ComponentId() const; |
|
328 |
|
329 /** @return The name of the software component. */ |
|
330 IMPORT_C const TDesC& Name() const; |
|
331 |
|
332 /** @return The vendor name of the software component. */ |
|
333 IMPORT_C const TDesC& Vendor() const; |
|
334 |
|
335 /** @return The software type name of the software component, e.g @see Usif::KSoftwareTypeNative. */ |
|
336 IMPORT_C const TDesC& SoftwareType() const; |
|
337 |
|
338 /** @return Globally unique component identifier. */ |
|
339 IMPORT_C const TDesC& GlobalId() const; |
|
340 |
|
341 /** @return Whether the software component is removable. ETrue means it is removable. */ |
|
342 IMPORT_C TBool IsRemovable() const; |
|
343 |
|
344 /** @return The total size of the component at installation time in bytes. */ |
|
345 IMPORT_C TInt64 ComponentSize() const; |
|
346 |
|
347 /** @return The SCOMO state of the software component. @see Usif::TScomoState */ |
|
348 IMPORT_C const TScomoState& ScomoState() const; |
|
349 |
|
350 /** @return The set of drives that files for the software component were installed to. */ |
|
351 IMPORT_C const TDriveList& InstalledDrives() const; |
|
352 |
|
353 /** @return The version identifier of the software component. */ |
|
354 IMPORT_C const TDesC& Version() const; |
|
355 |
|
356 /** @return The install time of the component. */ |
|
357 IMPORT_C TTime InstallTimeL() const; |
|
358 |
|
359 /** @return Whether the component is DRM protected. ETrue means the component is DRM protected.*/ |
|
360 IMPORT_C TBool IsDrmProtected() const; |
|
361 |
|
362 /** @return Whether the component is hidden in the list of installed components. ETrue means the component is hidden. */ |
|
363 IMPORT_C TBool IsHidden() const; |
|
364 |
|
365 /** @return Whether the component has been revoked. ETrue means that a revocation check was performed |
|
366 during or after the installation and the component was found to be revoked. |
|
367 */ |
|
368 IMPORT_C TBool IsKnownRevoked() const; |
|
369 |
|
370 /** @return Whether the installer has verified the originator of the component. ETrue means the installer |
|
371 has verified the originator of the software component by using appropriate checking mechanisms. |
|
372 */ |
|
373 IMPORT_C TBool IsOriginVerified()const; |
|
374 |
|
375 private: |
|
376 CComponentEntry(); |
|
377 void ConstructL(const TComponentId& aId, const TDesC& aName, const TDesC& aVendor, const TDesC& aSwType, const TDesC& aGlobalId, TBool aRemovable, |
|
378 TInt64 aSize, const TScomoState& aScomoState, const TDriveList& aInstalledDrives, const TDesC& aVersion, const TDesC& aInstallTime, |
|
379 TBool aDrmProtected, TBool aHidden, TBool aKnownRevoked, TBool aOriginVerified); |
|
380 private: |
|
381 TComponentId iComponentId; ///< The unique id of the software component. |
|
382 HBufC* iName; ///< Name of the software component. |
|
383 HBufC* iVendor; ///< Vendor of the software component. |
|
384 HBufC* iSwType; ///< Software type name of the component. |
|
385 HBufC* iGlobalId; ///< Globally unique component identifier. |
|
386 TBool iRemovable; ///< Whether the component is removable. |
|
387 TInt64 iSize; ///< The total size of the component at installation time in bytes. |
|
388 TScomoState iScomoState; ///< SCOMO state of the component. |
|
389 TDriveList iInstalledDrives; ///< The set of drives that files for the software component were installed to. |
|
390 HBufC* iVersion; ///< Version identifier of the software component |
|
391 HBufC* iInstallTime; ///< The install time of the component. |
|
392 TBool iDrmProtected; ///< Whether the component is DRM protected. |
|
393 TBool iHidden; ///< Whether the component is hidden in the list of installed components. |
|
394 TBool iKnownRevoked; ///< Whether the component has been revoked. |
|
395 TBool iOriginVerified; ///< Whether the installer has verified the originator of the component. |
|
396 }; |
|
397 |
|
398 class CPropertyEntry : public CBase |
|
399 /** |
|
400 Abstract base class for a software component property entry. |
|
401 Specifies the type of a software component property. Before getting a property value, |
|
402 the base property object must be converted to a derived property object (e.g. CIntPropertyEntry). |
|
403 */ |
|
404 { |
|
405 public: |
|
406 /** |
|
407 Enumeration to indicate the type of the property. |
|
408 */ |
|
409 enum TPropertyType |
|
410 { |
|
411 EBinaryProperty = 1, ///< The property value is binary data. See @see CBinaryPropertyEntry. |
|
412 EIntProperty, ///< The property value is integer. See @see CIntPropertyEntry. |
|
413 ELocalizedProperty, ///< The property is a localizable string. See @see CLocalizablePropertyEntry. |
|
414 }; |
|
415 public: |
|
416 /** |
|
417 Creates a base software component property object from a stream. |
|
418 @param aStream The stream to read the software property object from. |
|
419 @return A pointer to the newly allocated software property object, if creation is successful. |
|
420 @internalComponent |
|
421 */ |
|
422 IMPORT_C static CPropertyEntry* NewL(RReadStream& aStream); |
|
423 |
|
424 /** @return The name of the property. */ |
|
425 IMPORT_C const TDesC& PropertyName() const; |
|
426 |
|
427 /** Virtual destructor for the component property object*/ |
|
428 IMPORT_C virtual ~CPropertyEntry(); |
|
429 |
|
430 /** |
|
431 Externalises a base/derived property object to a write stream. |
|
432 @param aStream The stream to which the object is externalised. |
|
433 @internalComponent |
|
434 */ |
|
435 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
436 |
|
437 /** @return The type of the property object. Implemented by derived classes. */ |
|
438 virtual CPropertyEntry::TPropertyType PropertyType() const = 0; |
|
439 |
|
440 protected: |
|
441 CPropertyEntry(); |
|
442 void ConstructL(const TDesC& aPropertyName); |
|
443 |
|
444 private: |
|
445 virtual void DoExternalizeL(RWriteStream &aStream) const = 0; |
|
446 virtual void DoInternalizeL(RReadStream& aStream) = 0; |
|
447 |
|
448 private: |
|
449 HBufC* iPropertyName; ///< The name of the property entry. |
|
450 }; |
|
451 |
|
452 class CIntPropertyEntry : public CPropertyEntry |
|
453 /** |
|
454 Class that represents an integer component property. |
|
455 */ |
|
456 { |
|
457 public: |
|
458 /** |
|
459 Creates an integer component property object. |
|
460 |
|
461 @param aPropertyName The name of the property. |
|
462 @param aPropertyValue The value of the property. |
|
463 @return A pointer to the newly allocated component property object, if creation is successful. |
|
464 */ |
|
465 IMPORT_C static CIntPropertyEntry* NewL(const TDesC& aPropertyName, TInt64 aPropertyValue); |
|
466 |
|
467 /** |
|
468 Creates an integer component property object. |
|
469 |
|
470 @param aPropertyName The name of the property. |
|
471 @param aPropertyValue The value of the property. |
|
472 @return A pointer to the newly allocated component property object, if creation is successful. |
|
473 The pointer is also put onto the cleanup stack. |
|
474 */ |
|
475 IMPORT_C static CIntPropertyEntry* NewLC(const TDesC& aPropertyName, TInt64 aPropertyValue); |
|
476 |
|
477 IMPORT_C ~CIntPropertyEntry(); |
|
478 |
|
479 /** |
|
480 The implementation of pure virtual function from @see Usif::CPropertyEntry. |
|
481 @return The type of the property object. |
|
482 */ |
|
483 IMPORT_C CPropertyEntry::TPropertyType PropertyType() const; |
|
484 |
|
485 /** @return The 32-bit integer value. */ |
|
486 IMPORT_C TInt IntValue(); |
|
487 |
|
488 /** @return The 64-bit integer value. */ |
|
489 IMPORT_C TInt64 Int64Value(); |
|
490 |
|
491 private: |
|
492 void DoExternalizeL(RWriteStream& aStream) const; |
|
493 void DoInternalizeL(RReadStream& aStream); |
|
494 |
|
495 CIntPropertyEntry(); |
|
496 CIntPropertyEntry(TInt64 aPropertyIntValue); |
|
497 void ConstructL(const TDesC& aPropertyName); |
|
498 static CIntPropertyEntry* NewLC(); |
|
499 friend CPropertyEntry* CPropertyEntry::NewL(RReadStream& aStream); |
|
500 |
|
501 private: |
|
502 TInt64 iIntValue; ///< The integer property value. |
|
503 }; |
|
504 |
|
505 class CBinaryPropertyEntry : public CPropertyEntry |
|
506 /** |
|
507 Class that represents a binary non-localizable 8-bit descriptor component property. |
|
508 */ |
|
509 { |
|
510 public: |
|
511 /** |
|
512 Creates a binary component property object. |
|
513 |
|
514 @param aPropertyName The name of the property. |
|
515 @param aPropertyValue The value of the property. |
|
516 @return A pointer to the newly allocated component property object, if creation is successful. |
|
517 */ |
|
518 IMPORT_C static CBinaryPropertyEntry* NewL(const TDesC& aPropertyName, const TDesC8& aPropertyValue); |
|
519 |
|
520 /** |
|
521 Creates a binary component property object. |
|
522 |
|
523 @param aPropertyName The name of the property. |
|
524 @param aPropertyValue The value of the property. |
|
525 @return A pointer to the newly allocated component property object, if creation is successful. |
|
526 The pointer is also put onto the cleanup stack. |
|
527 */ |
|
528 IMPORT_C static CBinaryPropertyEntry* NewLC(const TDesC& aPropertyName, const TDesC8& aPropertyValue); |
|
529 |
|
530 IMPORT_C ~CBinaryPropertyEntry(); |
|
531 |
|
532 /** |
|
533 The implementation of pure virtual function from @see Usif::CPropertyEntry. |
|
534 @return The type of the property object. |
|
535 */ |
|
536 IMPORT_C TPropertyType PropertyType() const; |
|
537 |
|
538 /** @return The binary property value. */ |
|
539 IMPORT_C const TDesC8& BinaryValue(); |
|
540 |
|
541 private: |
|
542 CBinaryPropertyEntry(); |
|
543 void ConstructL(const TDesC& aPropertyName, const TDesC8& aPropertyValue); |
|
544 void DoExternalizeL(RWriteStream& aStream) const; |
|
545 void DoInternalizeL(RReadStream& aStream); |
|
546 |
|
547 static CBinaryPropertyEntry* NewLC(); |
|
548 friend CPropertyEntry* CPropertyEntry::NewL(RReadStream& aStream); |
|
549 |
|
550 private: |
|
551 HBufC8* iValue; ///< The value of the binary property. |
|
552 }; |
|
553 |
|
554 NONSHARABLE_CLASS(CLocalizablePropertyEntry) : public CPropertyEntry |
|
555 /** |
|
556 Class that represents a localizable string component property. |
|
557 |
|
558 A localized component property is a string property which can have different values |
|
559 for different locales. A particular instance of a localized component property includes |
|
560 both the localized string value and the locale in question. |
|
561 */ |
|
562 { |
|
563 public: |
|
564 /** |
|
565 Creates a localizable component property object. |
|
566 |
|
567 @param aPropertyName The name of the property. |
|
568 @param aPropertyValue The value of the property. |
|
569 @param aLocale The locale of the property. |
|
570 @return A pointer to the newly allocated component property object, if creation is successful. |
|
571 */ |
|
572 IMPORT_C static CLocalizablePropertyEntry* NewL(const TDesC& aPropertyName, const TDesC& aPropertyValue, TLanguage aLocale); |
|
573 |
|
574 /** |
|
575 Creates a localizable component property object. |
|
576 |
|
577 @param aPropertyName The name of the property. |
|
578 @param aPropertyValue The value of the property. |
|
579 @param aLocale The locale of the property. |
|
580 @return A pointer to the newly allocated component property object, if creation is successful. |
|
581 The pointer is also put onto the cleanup stack. |
|
582 */ |
|
583 IMPORT_C static CLocalizablePropertyEntry* NewLC( const TDesC& aPropertyName, const TDesC& aPropertyValue, TLanguage aLocale); |
|
584 |
|
585 IMPORT_C ~CLocalizablePropertyEntry(); |
|
586 |
|
587 /** The locale of the localizable property object. */ |
|
588 IMPORT_C TLanguage LocaleL() const; |
|
589 |
|
590 /** |
|
591 The implementation of pure virtual function from @see Usif::CPropertyEntry. |
|
592 @return The type of the property object. |
|
593 */ |
|
594 IMPORT_C TPropertyType PropertyType() const; |
|
595 |
|
596 /** @return The string property value. */ |
|
597 IMPORT_C const TDesC& StrValue() const; |
|
598 |
|
599 private: |
|
600 CLocalizablePropertyEntry(); |
|
601 CLocalizablePropertyEntry(TLanguage aLocale); |
|
602 void DoExternalizeL(RWriteStream &aStream) const; |
|
603 void DoInternalizeL(RReadStream& aStream); |
|
604 static CLocalizablePropertyEntry* NewLC(); |
|
605 friend CPropertyEntry* CPropertyEntry::NewL(RReadStream& aStream); |
|
606 void ConstructL(const TDesC& aPropertyName, const TDesC& aPropertyValue); |
|
607 |
|
608 private: |
|
609 TLanguage iLocale; ///< The language code of the locale. |
|
610 HBufC* iStrValue; ///< The string value of the property |
|
611 }; |
|
612 |
|
613 NONSHARABLE_CLASS(CComponentFilter) : public CBase |
|
614 /** |
|
615 A filter class which is used to filter the software components stored in the SCR. |
|
616 An empty filter object is first created and then required filter keys are set separately. |
|
617 */ |
|
618 { |
|
619 friend class CScrRequestImpl; |
|
620 public: |
|
621 /** |
|
622 Creates an empty component filter object. |
|
623 @return A pointer to the newly allocated component filter object, if creation is successful. |
|
624 */ |
|
625 IMPORT_C static CComponentFilter* NewL(); |
|
626 |
|
627 /** |
|
628 Creates an empty component filter object. |
|
629 @return A pointer to the newly allocated component filter object, if creation is successful. |
|
630 The pointer is also put onto the cleanup stack. |
|
631 */ |
|
632 IMPORT_C static CComponentFilter* NewLC(); |
|
633 |
|
634 /** |
|
635 Creates a component filter object from a stream. |
|
636 @param aStream The stream to read the component filter object from |
|
637 @return A pointer to the newly allocated component filter object, if creation is successful. |
|
638 @internalComponent |
|
639 */ |
|
640 IMPORT_C static CComponentFilter* NewL(RReadStream& aStream); |
|
641 |
|
642 ~CComponentFilter(); |
|
643 |
|
644 /** |
|
645 Restricts the returned component names in the filter. |
|
646 Please note that wildcards are not supported and matching is case-sensitive. |
|
647 @param aName The name of the software component. |
|
648 */ |
|
649 IMPORT_C void SetNameL(const TDesC& aName); |
|
650 |
|
651 /** |
|
652 Restricts the returned component vendor names in the filter. |
|
653 Please note that wildcards are not supported and matching is case-sensitive. |
|
654 @param aVendor The vendor name of the software component. |
|
655 */ |
|
656 IMPORT_C void SetVendorL(const TDesC& aVendor); |
|
657 |
|
658 /** |
|
659 Restricts the returned component software types in the filter. |
|
660 @param aSwType The software type name of the software component (e.g. @see Usif::KSoftwareTypeNative and @see Usif::KSoftwareTypeJava). |
|
661 */ |
|
662 IMPORT_C void SetSoftwareTypeL(const TDesC& aSwType); |
|
663 |
|
664 /** |
|
665 Sets whether the software component which is being searched for is removable. |
|
666 @param aValue ETrue, if the software component is removable. Otherwise, EFalse. |
|
667 */ |
|
668 IMPORT_C void SetRemovable(TBool aValue); |
|
669 |
|
670 /** |
|
671 Sets whether the software component which is being searched for is DRM protected. |
|
672 @param aValue ETrue, if the software component is DRM protected. Otherwise, EFalse. |
|
673 */ |
|
674 IMPORT_C void SetDrmProtected(TBool aValue); |
|
675 |
|
676 /** |
|
677 Sets whether the software component which is being searched for is hidden. |
|
678 @param aValue ETrue, if the software component is hidden. Otherwise, EFalse. |
|
679 */ |
|
680 IMPORT_C void SetHidden(TBool aValue); |
|
681 |
|
682 /** |
|
683 Sets whether the software component which is being searched for is known-revoked. |
|
684 @param aValue ETrue, if the software component is known-revoked. Otherwise, EFalse. |
|
685 */ |
|
686 IMPORT_C void SetKnownRevoked(TBool aValue); |
|
687 |
|
688 /** |
|
689 Sets whether the software component which is being searched for is origin-verified. |
|
690 @param aValue ETrue, if the software component is origin-verified. Otherwise, EFalse. |
|
691 */ |
|
692 IMPORT_C void SetOriginVerified(TBool aValue); |
|
693 |
|
694 /** |
|
695 Restricts the returned component SCOMO states in the filter. |
|
696 See @see Usif::TScomoState for the list of SCOMO states. |
|
697 @param aScomoState The SCOMO state of the software component. |
|
698 */ |
|
699 IMPORT_C void SetScomoStateL(TScomoState aScomoState); |
|
700 |
|
701 /** |
|
702 Sets the set of drives that files of the software components were installed to. |
|
703 If more than one drive is supplied, all software components which files were installed to |
|
704 any of these drives are returned. |
|
705 */ |
|
706 IMPORT_C void SetInstalledDrivesL(const TDriveList& aDrives); |
|
707 |
|
708 /** |
|
709 Adds a localizable property to the filter. Only the software components having |
|
710 this property with the specified value are returned by the filter. It is possible to |
|
711 add more than one property. In this case, the software components possessing all provided |
|
712 properties with the specified values are returned by the filter. |
|
713 |
|
714 For more information about searching for current locale variant of properties look at |
|
715 @see RSoftwareComponentRegistry::GetComponentPropertyL. |
|
716 |
|
717 If the locale is provided, the component will be returned only if the property exists |
|
718 for the specified locale. If the locale is not provided, or is equal to KUnspecifiedLocale, |
|
719 then all software components which have the property with the specified value for any locale will |
|
720 match this condition. |
|
721 |
|
722 @param aName The name of the property. Please note that wildcards are not supported and matching is case-insensitive. |
|
723 @param aValue The value of the property. |
|
724 @param aLocale Optional. The language code of the property value. |
|
725 |
|
726 */ |
|
727 IMPORT_C void AddPropertyL(const TDesC& aName, const TDesC& aValue, TLanguage aLocale=KUnspecifiedLocale); |
|
728 |
|
729 /** |
|
730 Adds an integer property to the filter. The software components having this |
|
731 property with the specified value are enumerated. It is possible to add more than one property. |
|
732 In this case, the software components possessing all provided properties with the specified |
|
733 values are enumerated. |
|
734 |
|
735 @param aName The name of the property. Please note that wildcards are not supported and matching is case-insensitive. |
|
736 @param aValue The value of the property. |
|
737 */ |
|
738 IMPORT_C void AddPropertyL(const TDesC& aName, TInt64 aValue); |
|
739 |
|
740 /** |
|
741 Adds a binary 8-bit descriptor property to the filter. The software components having this |
|
742 property with the specified value are enumerated. It is possible to add more than one property. |
|
743 In this case, the software components possessing all provided properties with the specified |
|
744 values are enumerated. |
|
745 |
|
746 @param aName The name of the property. Please note that wildcards are not supported and matching is case-insensitive. |
|
747 @param aValue The value of the property. |
|
748 */ |
|
749 IMPORT_C void AddPropertyL(const TDesC& aName, const TDesC8& aValue); |
|
750 |
|
751 /** |
|
752 Sets a file name to filter the software components having registered this file. |
|
753 Please note that wildcards are not supported and matching is case-insensitive. |
|
754 |
|
755 N.B. This call can be invoked multiple times for the same filter in order to request components which register a particular set of files. |
|
756 @param aFile The fully qualified file path. |
|
757 */ |
|
758 IMPORT_C void SetFileL(const TDesC& aFile); |
|
759 |
|
760 /** |
|
761 Externalises a component filter object to a write stream. |
|
762 @param aStream The stream to which the object is externalised. |
|
763 @internalComponent |
|
764 */ |
|
765 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
766 |
|
767 private: |
|
768 CComponentFilter(); |
|
769 void ConstructL(); |
|
770 void InternalizeL(RReadStream& aStream); |
|
771 |
|
772 enum TFieldsFlag |
|
773 { |
|
774 EName = 0x0001, |
|
775 EVendor = 0x0002, |
|
776 ESoftwareType = 0x0004, |
|
777 ERemovable = 0x0008, |
|
778 EScomoState = 0x0010, |
|
779 EInstalledDrive = 0x0020, |
|
780 EProperty = 0x0040, |
|
781 EFile = 0x0080, |
|
782 EDrmProtected = 0x0100, |
|
783 EHidden = 0x0200, |
|
784 EKnownRevoked = 0x0400, |
|
785 EOriginVerified = 0x0800 |
|
786 }; |
|
787 |
|
788 private: |
|
789 TUint16 iSetFlag; ///< Flag variable that shows what fields have been set |
|
790 HBufC* iName; ///< Name for the software component |
|
791 HBufC* iVendor; ///< Vendor for the software component |
|
792 HBufC* iSwType; ///< Software type of the component. |
|
793 TBool iRemovable; ///< Whether the software component is removable |
|
794 TScomoState iScomoState; ///< SCOMO state for the software component |
|
795 TDriveList iInstalledDrives; ///< Installed drives for the software component |
|
796 RPointerArray<CPropertyEntry> iPropertyList; ///< The list of key properties |
|
797 HBufC* iFile; ///< The full name of the file owned by the component |
|
798 TBool iDrmProtected; ///< Whether the component is DRM protected. |
|
799 TBool iHidden; ///< Whether the component is displayed in the list of installed components. |
|
800 TBool iKnownRevoked; ///< Whether the component has been revoked. |
|
801 TBool iOriginVerified; ///< Whether the installer has verified the originator of the component. |
|
802 }; |
|
803 |
|
804 |
|
805 class CLocalizableCommonData : public CBase |
|
806 /** |
|
807 Base class which provides common functionality for localized information classes (e.g. CLocalizableComponentInfo). |
|
808 Please note that this class cannot be instantiated. |
|
809 */ |
|
810 { |
|
811 public: |
|
812 ~CLocalizableCommonData(); |
|
813 |
|
814 /** @return The locale of the data. */ |
|
815 IMPORT_C TLanguage Locale() const; |
|
816 |
|
817 protected: |
|
818 CLocalizableCommonData(); |
|
819 CLocalizableCommonData(TLanguage aLocale); |
|
820 |
|
821 void ExternalizeL(RWriteStream& aStream) const; |
|
822 void InternalizeL(RReadStream& aStream); |
|
823 |
|
824 private: |
|
825 TLanguage iLocale; ///< The language code of the locale. |
|
826 }; |
|
827 |
|
828 NONSHARABLE_CLASS(CLocalizableComponentInfo) : public CLocalizableCommonData |
|
829 /** |
|
830 This class contains the localizable information of a software component. |
|
831 Component names and vendor names are localizable names and transferred to the SCR |
|
832 with the objects of this class. |
|
833 */ |
|
834 { |
|
835 public: |
|
836 /** |
|
837 Creates a localizable component information object. |
|
838 @param aName The name of the component. |
|
839 @param aVendor The vendor of the component. |
|
840 @param aLocale The language code of the object's locale. |
|
841 @return A pointer to the newly allocated localizable component info object, if creation is successful. |
|
842 */ |
|
843 IMPORT_C static CLocalizableComponentInfo* NewL(const TDesC& aName, const TDesC& aVendor, TLanguage aLocale); |
|
844 |
|
845 /** |
|
846 Creates a localizable component information object. |
|
847 @param aName The name of the component. |
|
848 @param aVendor The vendor of the component. |
|
849 @param aLocale The language code of the object's locale. |
|
850 @return A pointer to the newly allocated component information object, if creation is successful. |
|
851 The pointer is also put onto the cleanup stack. |
|
852 */ |
|
853 IMPORT_C static CLocalizableComponentInfo* NewLC(const TDesC& aName, const TDesC& aVendor, TLanguage aLocale); |
|
854 |
|
855 /** |
|
856 Creates a localizable component information from a stream. |
|
857 @param aStream The stream to read the component information object from. |
|
858 @return A pointer to the newly allocated component information object, if creation is successful. |
|
859 @internalComponent |
|
860 */ |
|
861 IMPORT_C static CLocalizableComponentInfo* NewL(RReadStream& aStream); |
|
862 |
|
863 ~CLocalizableComponentInfo(); |
|
864 |
|
865 /** |
|
866 Externalises a localizable component information object to a write stream. |
|
867 @param aStream The stream to which the object is externalised. |
|
868 @internalComponent |
|
869 */ |
|
870 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
871 |
|
872 /** @return The localizable name of the component. */ |
|
873 IMPORT_C const TDesC& NameL() const; |
|
874 |
|
875 /** @return The localizable vendor name of the component. */ |
|
876 IMPORT_C const TDesC& VendorL() const; |
|
877 |
|
878 private: |
|
879 CLocalizableComponentInfo(); |
|
880 CLocalizableComponentInfo(TLanguage aLocale); |
|
881 void ConstructL(const TDesC& aName, const TDesC& aVendor); |
|
882 void InternalizeL(RReadStream& aStream); |
|
883 |
|
884 private: |
|
885 HBufC* iName; ///< The localizable component name. |
|
886 HBufC* iVendor; ///< The localizable component vendor name. |
|
887 }; |
|
888 |
|
889 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS |
|
890 NONSHARABLE_CLASS(CLocalizedSoftwareTypeName) : public CLocalizableCommonData |
|
891 /** |
|
892 This class contains localized software type names. |
|
893 Software type names are localizable names and transferred to the SCR |
|
894 with the objects of this class. |
|
895 |
|
896 @internalTechnology |
|
897 */ |
|
898 { |
|
899 public: |
|
900 /** |
|
901 Creates a localized software type name object. |
|
902 @param aName The name of the software type. |
|
903 @param aLocale The language code of the object's locale. |
|
904 @return A pointer to the newly allocated localized software type name object, if creation is successful. |
|
905 */ |
|
906 IMPORT_C static CLocalizedSoftwareTypeName* NewL(const TDesC& aName, TLanguage aLocale); |
|
907 |
|
908 /** |
|
909 Creates a localized software type name object. |
|
910 @param aName The name of the software type. |
|
911 @param aLocale The language code of the object's locale. |
|
912 @return A pointer to the newly allocated localized software type name object, if creation is successful. |
|
913 The pointer is also put onto the cleanup stack. |
|
914 */ |
|
915 IMPORT_C static CLocalizedSoftwareTypeName* NewLC(const TDesC& aName, TLanguage aLocale); |
|
916 |
|
917 /** |
|
918 Creates a localized software type name object from a stream. |
|
919 @param aStream The stream to read the localized software type name object from. |
|
920 @return A pointer to the newly allocated localized software type name object, if creation is successful. |
|
921 @internalComponent |
|
922 */ |
|
923 IMPORT_C static CLocalizedSoftwareTypeName* NewL(RReadStream& aStream); |
|
924 |
|
925 ~CLocalizedSoftwareTypeName(); |
|
926 |
|
927 /** |
|
928 Externalises a localized software type name object to a write stream. |
|
929 @param aStream The stream to which the object is externalised. |
|
930 @internalComponent |
|
931 */ |
|
932 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
933 |
|
934 /** @return The localized software type name. */ |
|
935 IMPORT_C const TDesC& NameL() const; |
|
936 |
|
937 private: |
|
938 CLocalizedSoftwareTypeName(); |
|
939 CLocalizedSoftwareTypeName(TLanguage aLocale); |
|
940 void ConstructL(const TDesC& aName); |
|
941 void InternalizeL(RReadStream& aStream); |
|
942 |
|
943 private: |
|
944 HBufC* iName; ///< The localized software type name. |
|
945 }; |
|
946 #endif //SYMBIAN_ENABLE_SPLIT_HEADERS |
|
947 |
|
948 enum TScrComponentOperationType |
|
949 /** |
|
950 The type of the operation being performed on an SCR component. |
|
951 */ |
|
952 { |
|
953 EScrCompInstall =0, ///< A new SCR component is added. |
|
954 EScrCompUnInstall, ///< A existing SCR component is removed. |
|
955 EScrCompUpgrade, ///< An existing SCR component is updated. |
|
956 EScrCompHidden ///< The component operation is hidden to the user. N.B. SCR doesn't save logs for this type of operation. |
|
957 }; |
|
958 |
|
959 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS |
|
960 NONSHARABLE_CLASS (CScrLogEntry) : public CBase |
|
961 /** |
|
962 Class that represents a software component log record generated by the SCR. |
|
963 */ |
|
964 { |
|
965 friend class CScrRequestImpl; |
|
966 public: |
|
967 /** |
|
968 Creates a log entry object. |
|
969 @param aComponentName The name of the component. |
|
970 @param aUniqueSwTypeName The non-localized, unique software type name, such as @see Usif::KSoftwareTypeNative and @see Usif::KSoftwareTypeJava. |
|
971 @param aGlobalId The global Id of the component. |
|
972 @param aVersion The version of the component. |
|
973 @param aCompOpType The type of the component operation. @see Usif::TScrComponentOperationType |
|
974 @return A pointer to the newly allocated log entry object, if creation is successful. |
|
975 @internalComponent |
|
976 */ |
|
977 IMPORT_C static CScrLogEntry* NewL(const TDesC& aComponentName, const TDesC& aUniqueSwTypeName, const TDesC& aGlobalId, const TDesC& aVersion, const TScrComponentOperationType aCompOpType); |
|
978 |
|
979 /** |
|
980 Creates a log entry object. |
|
981 @param aComponentName The name of the component. |
|
982 @param aUniqueSwTypeName The non-localized, unique software type name, such as @see Usif::KSoftwareTypeNative and @see Usif::KSoftwareTypeJava. |
|
983 @param aGlobalId The global Id of the component. |
|
984 @param aVersion The version of the component. |
|
985 @param aCompOpType The type of the component operation. @see Usif::TScrComponentOperationType |
|
986 @return A pointer to the newly allocated log entry object, if creation is successful. |
|
987 The pointer is also put onto the cleanup stack. |
|
988 @internalComponent |
|
989 */ |
|
990 IMPORT_C static CScrLogEntry* NewLC(const TDesC& aComponentName, const TDesC& aUniqueSwTypeName, const TDesC& aGlobalId, const TDesC& aVersion, const TScrComponentOperationType aCompOpType); |
|
991 |
|
992 /** |
|
993 Creates a log entry object from a stream. |
|
994 @param aStream The stream to read the log entry object from. |
|
995 @return A pointer to the newly allocated log entry object, if creation is successful. |
|
996 The pointer is also put onto the cleanup stack. |
|
997 @internalComponent |
|
998 */ |
|
999 IMPORT_C static CScrLogEntry* NewLC(RReadStream& aStream); |
|
1000 |
|
1001 ~CScrLogEntry(); |
|
1002 |
|
1003 /** |
|
1004 Write the object to a stream |
|
1005 |
|
1006 @param aStream The stream to write to |
|
1007 @internalComponent |
|
1008 */ |
|
1009 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
1010 |
|
1011 /** |
|
1012 Read the object from a stream |
|
1013 |
|
1014 @param aStream The stream to read from. |
|
1015 @internalComponent |
|
1016 */ |
|
1017 IMPORT_C void InternalizeL(RReadStream& aStream) ; |
|
1018 |
|
1019 /** |
|
1020 @return The name of the component for which the log was generated. |
|
1021 */ |
|
1022 IMPORT_C const TDesC& ComponentName() const; |
|
1023 |
|
1024 /** |
|
1025 @return The non-localized, unique software type name, such as @see Usif::KSoftwareTypeNative and @see Usif::KSoftwareTypeJava. |
|
1026 */ |
|
1027 IMPORT_C const TDesC& SoftwareTypeName() const; |
|
1028 |
|
1029 /** |
|
1030 The UID. |
|
1031 @return The global ID of the component. |
|
1032 */ |
|
1033 IMPORT_C const TDesC& GlobalId() const; |
|
1034 |
|
1035 /** |
|
1036 @return The version of the component. |
|
1037 */ |
|
1038 IMPORT_C const TDesC& ComponentVersion() const; |
|
1039 |
|
1040 /** |
|
1041 @return The time when the operation occured. |
|
1042 */ |
|
1043 IMPORT_C const TTime OperationTime() const; |
|
1044 |
|
1045 /** |
|
1046 @return The type of the component operation for the log record. |
|
1047 */ |
|
1048 IMPORT_C TScrComponentOperationType OperationType() const; |
|
1049 |
|
1050 /** |
|
1051 @return The component id of the log record. |
|
1052 @internalComponent |
|
1053 */ |
|
1054 IMPORT_C TComponentId ComponentId() const; |
|
1055 |
|
1056 private: |
|
1057 CScrLogEntry(); |
|
1058 void ConstructL(const TDesC& aComponentName, const TDesC& aUniqueSwTypeName, const TDesC& aGlobalId, const TDesC& aVersion, const TScrComponentOperationType aCompOpType); |
|
1059 |
|
1060 private: |
|
1061 HBufC* iComponentName ; |
|
1062 HBufC* iSwTypeName; |
|
1063 HBufC* iVersion; |
|
1064 TScrComponentOperationType iOpType ; |
|
1065 TTime iRecordTime ; |
|
1066 HBufC* iGlobalId; |
|
1067 TComponentId iComponentId; |
|
1068 }; |
|
1069 #endif //SYMBIAN_ENABLE_SPLIT_HEADERS |
|
1070 |
|
1071 } // End of namespace Usif |
|
1072 |
|
1073 #endif // SCRENTRIES_H |