1 /* |
|
2 * Copyright (c) 2009-2010 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 @file |
|
21 @publishedAll |
|
22 @prototype |
|
23 */ |
|
24 |
|
25 #ifndef APPREGENTRIES_H |
|
26 #define APPREGENTRIES_H |
|
27 |
|
28 #include <e32base.h> |
|
29 #include <s32strm.h> |
|
30 #include <f32file.h> |
|
31 namespace Usif |
|
32 { |
|
33 |
|
34 class CScrRequestImpl; |
|
35 class CDataType; |
|
36 class CServiceInfo; |
|
37 class CLocalizableAppInfo; |
|
38 class CAppViewData; |
|
39 class CCaptionAndIconInfo; |
|
40 |
|
41 |
|
42 const TInt KSCRMaxAppGroupName=0x10; // Length of App's logical groupname |
|
43 typedef TBuf<KSCRMaxAppGroupName> TAppGroupName; |
|
44 |
|
45 NONSHARABLE_CLASS (TApplicationCharacteristics) |
|
46 /** |
|
47 Used to store application characteristics like its embeddabilty, group name etc. |
|
48 */ |
|
49 { |
|
50 public: |
|
51 /** |
|
52 Creates an empty TApplicationCharacteristics object. |
|
53 */ |
|
54 IMPORT_C TApplicationCharacteristics(); |
|
55 |
|
56 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
57 |
|
58 IMPORT_C void InternalizeL(RReadStream& aStream); |
|
59 |
|
60 public: |
|
61 /** |
|
62 Defines an application's support for embeddability. |
|
63 */ |
|
64 enum TAppEmbeddability { |
|
65 /** |
|
66 An application cannot be embedded. |
|
67 */ |
|
68 ENotEmbeddable=0, |
|
69 /** |
|
70 An application can be run embedded or standalone and can read/write embedded document-content. |
|
71 */ |
|
72 EEmbeddable=1, |
|
73 /** |
|
74 An application can only be run embedded and can read/write embedded document-content. |
|
75 */ |
|
76 EEmbeddableOnly=2, |
|
77 /** |
|
78 An application can be run embedded or standalone and cannot read/write embedded document-content. |
|
79 */ |
|
80 EEmbeddableUiOrStandAlone=5, |
|
81 /** |
|
82 An application can only be run embedded and cannot read/write embedded document-content. |
|
83 */ |
|
84 EEmbeddableUiNotStandAlone=6 |
|
85 }; |
|
86 /** |
|
87 Indicates the extent to which the application can be embedded. |
|
88 */ |
|
89 TAppEmbeddability iEmbeddability; |
|
90 /** |
|
91 Indicates whether the application is document-based and supports being asked |
|
92 to create a new file. |
|
93 */ |
|
94 TBool iSupportsNewFile; |
|
95 /** |
|
96 Indicates whether the existence of the application should be advertised to the |
|
97 user. If this is set to ETrue, the application does not appear on the Extras |
|
98 Bar (or equivalent). |
|
99 */ |
|
100 TBool iAppIsHidden; // not shown in the Shell etc. |
|
101 /** |
|
102 Allows the application to be launched in the foreground (when set to EFalse) |
|
103 or in the background (when set to ETrue). |
|
104 */ |
|
105 TBool iLaunchInBackground; // Series 60 extension to allow apps to be launched in the background |
|
106 /** |
|
107 Stores the application's logical group name. |
|
108 */ |
|
109 TAppGroupName iGroupName; // Series 60 extension to allow apps to be categorized according a logical group name, e.g. 'games' |
|
110 /** |
|
111 Indicates the application attributes. One or more values from TCapabilityAttribute may be specified. |
|
112 */ |
|
113 TUint iAttributes; |
|
114 }; |
|
115 |
|
116 class TEmbeddableFilter |
|
117 { |
|
118 public: |
|
119 /** Constructs an empty embeddability filter. |
|
120 */ |
|
121 IMPORT_C TEmbeddableFilter(); |
|
122 |
|
123 /** Adds aEmbeddability value to the EmbeddabilityFlag. |
|
124 */ |
|
125 IMPORT_C void AddEmbeddability(TApplicationCharacteristics::TAppEmbeddability aEmbeddability); |
|
126 |
|
127 /** Compares aEmbeddability with the filter. |
|
128 * @param aEmbeddability TAppEmbeddability value to compare. |
|
129 * @see TAppEmbeddability for more details. |
|
130 * @return True, if aEmbeddability is included in the filter; false, otherwise. |
|
131 */ |
|
132 IMPORT_C TBool MatchesEmbeddability(TApplicationCharacteristics::TAppEmbeddability aEmbeddability) const; |
|
133 |
|
134 /** Sets the value of aEmbeddability with EmbeddabilityFlag's value. |
|
135 */ |
|
136 void SetEmbeddabilityFlags(TUint aEmbeddabilityFlags); |
|
137 |
|
138 /** Return the value of iEmbeddability. |
|
139 */ |
|
140 IMPORT_C TUint EmbeddabilityFlags() const; |
|
141 private: |
|
142 TUint iEmbeddabilityFlags; |
|
143 }; |
|
144 |
|
145 |
|
146 NONSHARABLE_CLASS(CAppInfoFilter) : public CBase |
|
147 /** |
|
148 A filter class which is used to filter the Application registration Info stored in the SCR. |
|
149 An empty filter object is first created and then required filter keys are set separately. |
|
150 */ |
|
151 { |
|
152 friend class CScrRequestImpl; |
|
153 |
|
154 public: |
|
155 /** |
|
156 Creates an empty AppRegistrationInfo filter object. |
|
157 @return A pointer to the newly allocated AppRegistrationInfo filter object, if creation is successful. |
|
158 */ |
|
159 IMPORT_C static CAppInfoFilter* NewL(); |
|
160 |
|
161 /** |
|
162 Creates an empty AppRegistrationInfo filter object. |
|
163 @return A pointer to the newly allocated AppRegistrationInfo filter object, if creation is successful. |
|
164 The pointer is also put onto the cleanup stack. |
|
165 */ |
|
166 IMPORT_C static CAppInfoFilter* NewLC(); |
|
167 |
|
168 /** |
|
169 Creates a AppRegistrationInfo filter object from a stream. |
|
170 @param aStream The stream to read the AppRegistrationInfo filter object from |
|
171 @return A pointer to the newly allocated AppRegistrationInfo filter object, if creation is successful. |
|
172 @internalComponent |
|
173 */ |
|
174 IMPORT_C static CAppInfoFilter* NewL(RReadStream& aStream); |
|
175 |
|
176 IMPORT_C void SetAllApps(); |
|
177 IMPORT_C void SetAllApps(const TInt aScreenMode); |
|
178 |
|
179 IMPORT_C void SetEmbeddableApps(); |
|
180 IMPORT_C void SetEmbeddableApps(const TInt aScreenMode); |
|
181 |
|
182 IMPORT_C void SetEmbeddabilityFilter(TEmbeddableFilter& aEmbeddabilityFilter); |
|
183 IMPORT_C void SetEmbeddabilityFilterWithScreenMode(TEmbeddableFilter& aEmbeddabilityFilter, const TInt aScreenMode); |
|
184 |
|
185 IMPORT_C void SetCapabilityAttributeMaskAndValue(const TInt aCapabilityAttributeMask, const TInt aCapabilityAttributeValue); |
|
186 IMPORT_C void SetCapabilityAttributeMaskAndValue(const TInt aCapabilityAttributeMask, const TInt aCapabilityAttributeValue, const TInt aScreenMode ); |
|
187 |
|
188 IMPORT_C void SetServerApps(const TUid aServiceUid); |
|
189 IMPORT_C void SetServerApps(const TUid aServiceUid, const TInt aScreenMode); |
|
190 |
|
191 ~CAppInfoFilter(); |
|
192 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
193 void InternalizeL(RReadStream& aStream); |
|
194 |
|
195 private: |
|
196 CAppInfoFilter(); |
|
197 void ConstructL(); |
|
198 |
|
199 enum TAppRegInfoFlag |
|
200 { |
|
201 EAllApps = 0x0001, |
|
202 EAllAppsWithScreenMode = 0x0002, |
|
203 EGetEmbeddableApps = 0x0004, |
|
204 EGetEmbeddableAppsWithSreenMode = 0x0008, |
|
205 EGetFilteredAppsWithEmbeddabilityFilter = 0x0010, |
|
206 EGetFilteredAppsWithEmbeddabilityFilterWithScreenMode = 0x0020, |
|
207 EGetFilteredAppsWithCapabilityMaskAndValue = 0x0040, |
|
208 EGetFilteredAppsWithCapabilityMaskAndValueWithScreenMode = 0x0080, |
|
209 EGetServerApps = 0x0100, |
|
210 EGetServerAppsWithScreenMode = 0x0200, |
|
211 }; |
|
212 |
|
213 private: |
|
214 TUint16 iSetFlag; ///< Flag variable that shows what fields have been set |
|
215 TInt iScreenMode; ///< Sreen Mode of the application |
|
216 TEmbeddableFilter iEmbeddabilityFilter; ///< Embeddabilty Filter |
|
217 TUint iCapabilityAttributeMask; ///< Capability attribute bit mask |
|
218 TUint iCapabilityAttributeValue; ///< Capability attribute bit value |
|
219 TUid iServiceUid; ///< Service Uid |
|
220 TUid iAppUid; ///< Application Uid |
|
221 }; |
|
222 |
|
223 |
|
224 NONSHARABLE_CLASS(CAppServiceInfoFilter) : public CBase |
|
225 /* |
|
226 * A filter class that determines the information fields that need to be set before a GetServiceInfoL is invoked. |
|
227 * Initially an empty filter is created and subsequently the Set methods are used to set the filter based on the input parameters |
|
228 * with which the GetServiceInfoL query is made. |
|
229 */ |
|
230 { |
|
231 friend class CScrRequestImpl; |
|
232 |
|
233 public: |
|
234 |
|
235 /** |
|
236 Creates an empty CAppServiceInfoFilter filter object. |
|
237 @return A pointer to the newly allocated CAppServiceInfoFilter filter object, if creation is successful. |
|
238 */ |
|
239 IMPORT_C static CAppServiceInfoFilter* NewL(); |
|
240 |
|
241 /** |
|
242 Creates an empty CAppServiceInfoFilter filter object. |
|
243 @return A pointer to the newly allocated CAppServiceInfoFilter filter object, if creation is successful. |
|
244 The pointer is also put onto the cleanup stack. |
|
245 */ |
|
246 IMPORT_C static CAppServiceInfoFilter* NewLC(); |
|
247 |
|
248 /** |
|
249 Creates a CAppServiceInfoFilter filter object from a stream. |
|
250 @param aStream The stream to read the CAppServiceInfoFilter filter object from |
|
251 @return A pointer to the newly allocated CAppServiceInfoFilter filter object, if creation is successful. |
|
252 @internalComponent |
|
253 */ |
|
254 IMPORT_C static CAppServiceInfoFilter* NewL(RReadStream& aStream); |
|
255 |
|
256 IMPORT_C void SetAppUidForServiceInfo (const TUid aAppUid); |
|
257 IMPORT_C void SetServiceUidForServiceImplementations (const TUid aServiceUid); |
|
258 IMPORT_C void SetServiceUidAndDatatTypeForServiceImplementationsL (const TUid aServiceUid, const TDesC& aDataType); |
|
259 IMPORT_C void SetAppUidAndServiceUidForOpaqueData (const TUid aAppUid, const TUid aServiceUid); |
|
260 |
|
261 ~CAppServiceInfoFilter(); |
|
262 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
263 void InternalizeL(RReadStream& aStream); |
|
264 |
|
265 private: |
|
266 CAppServiceInfoFilter(); |
|
267 void ConstructL(); |
|
268 enum TServiceInfoFlag |
|
269 { |
|
270 EGetServiceInfoForApp = 0x0001, |
|
271 EGetServiceImplementationForServiceUid = 0x0002, |
|
272 EGetServiceImplementationForServiceUidAndDatatType = 0x0004, |
|
273 EGetOpaqueDataForAppWithServiceUid = 0x0008, |
|
274 }; |
|
275 |
|
276 private: |
|
277 TUint16 iSetFlag; |
|
278 TUid iAppUid; |
|
279 TUid iServiceUid; |
|
280 HBufC* iDataType; |
|
281 }; |
|
282 |
|
283 |
|
284 NONSHARABLE_CLASS(COpaqueData) : public CBase |
|
285 { |
|
286 friend class CScrRequestImpl; |
|
287 public: |
|
288 /** |
|
289 Creates an empty COpaqueData object. |
|
290 @return A pointer to the newly allocated COpaqueData object, if creation is successful. |
|
291 */ |
|
292 IMPORT_C static COpaqueData* NewL(); |
|
293 |
|
294 /** |
|
295 Creates an empty COpaqueData object. |
|
296 @return A pointer to the newly allocated COpaqueData object, if creation is successful. |
|
297 The pointer is also put onto the cleanup stack. |
|
298 */ |
|
299 IMPORT_C static COpaqueData* NewLC(); |
|
300 |
|
301 /** |
|
302 Creates an empty COpaqueData object. |
|
303 |
|
304 @param aOpaqueData A 8-bit buffer containing the opaque data. |
|
305 @param aLanguage The language associated with the opaque data. |
|
306 @return A pointer to the newly allocated COpaqueData object, if creation is successful. |
|
307 */ |
|
308 IMPORT_C static COpaqueData* NewL(TDesC8& aOpaqueData, TLanguage aLanguage); |
|
309 |
|
310 /** |
|
311 Creates an empty COpaqueData object. |
|
312 |
|
313 @param aOpaqueData A 8-bit buffer containing the opaque data. |
|
314 @param aLanguage The language associated with the opaque data. |
|
315 @return A pointer to the newly allocated COpaqueData object, if creation is successful. |
|
316 The pointer is also put onto the cleanup stack. |
|
317 */ |
|
318 IMPORT_C static COpaqueData* NewLC(TDesC8& aOpaqueData, TLanguage aLanguage); |
|
319 |
|
320 /** |
|
321 Creates a COpaqueData object from the stream. |
|
322 |
|
323 @param aStream The stream to read the COpaqueData object from. |
|
324 @return A pointer to the newly allocated COpaqueData object, if creation is successful. |
|
325 */ |
|
326 IMPORT_C static COpaqueData* NewL(RReadStream& aStream); |
|
327 |
|
328 /** |
|
329 @return The buffer containing the opaque data. |
|
330 */ |
|
331 IMPORT_C HBufC8& OpaqueData(); |
|
332 |
|
333 /** |
|
334 @return The language associated with the opaque data. |
|
335 */ |
|
336 IMPORT_C TLanguage Language(); |
|
337 |
|
338 ~COpaqueData(); |
|
339 |
|
340 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
341 |
|
342 IMPORT_C void InternalizeL(RReadStream& aStream); |
|
343 |
|
344 private: |
|
345 COpaqueData(); |
|
346 void ConstructL(const TDesC8& aOpaqueData, TLanguage aLanguage); |
|
347 |
|
348 private: |
|
349 HBufC8* iOpaqueData; |
|
350 TLanguage iLanguage; |
|
351 }; |
|
352 |
|
353 class CPropertyEntry; |
|
354 NONSHARABLE_CLASS(CApplicationRegistrationData) : public CBase |
|
355 /* |
|
356 * This contains the basic information of an application such as application's uid, filename, |
|
357 * attributes, embeddability, groupname, default screen number, opaque data, |
|
358 * an array of pointers to localizable info, properties, file ownership info etc. |
|
359 * |
|
360 * N.B. Mandatory fields associated to an application are AppUid and AppFile |
|
361 * AppFile should contain the abosulte file path, along with the drive and extension (if any) |
|
362 */ |
|
363 { |
|
364 friend class CScrRequestImpl; |
|
365 public: |
|
366 /** |
|
367 Creates an empty CApplicationRegistrationData object. |
|
368 @return A pointer to the newly allocated CApplicationRegistrationData object, if creation is successful. |
|
369 */ |
|
370 IMPORT_C static CApplicationRegistrationData* NewL(); |
|
371 |
|
372 /** |
|
373 Creates an empty CApplicationRegistrationData object. |
|
374 @return A pointer to the newly allocated CApplicationRegistrationData object, if creation is successful. |
|
375 The pointer is also put onto the cleanup stack. |
|
376 */ |
|
377 IMPORT_C static CApplicationRegistrationData* NewLC(); |
|
378 |
|
379 /** |
|
380 Creates a CApplicationRegistrationData object from the stream. |
|
381 |
|
382 @param aStream The stream to read the CApplicationRegistrationData object from. |
|
383 @return A pointer to the newly allocated CApplicationRegistrationData object, if creation is successful. |
|
384 */ |
|
385 IMPORT_C static CApplicationRegistrationData* NewL(RReadStream& aStream); |
|
386 |
|
387 /** |
|
388 Creates a CApplicationRegistrationData object. |
|
389 |
|
390 @param aOwnedFileArray An array of files owned by the application. The ownership is also transferred to CApplicationRegistrationData. |
|
391 @param aServiceArray An array of services related information associated with the application. The ownership is also transferred to CApplicationRegistrationData. |
|
392 @param aLocalizableAppInfoList An array of localizable information associated with the application. The ownership is also transferred to CApplicationRegistrationData. |
|
393 @param aAppPropertiesArray An array of properties associated with the application. The ownership is also transferred to CApplicationRegistrationData. |
|
394 @param aOpaqueDataArray An array of opaque data associated with the application. The ownership is also transferred to CApplicationRegistrationData. |
|
395 @param aAppUid The Uid of the application. |
|
396 @param aAppFile The executable file associated with the application. |
|
397 @param aCharacteristics The attributes associated with the application. @see Usif::TApplicationCharacteristics |
|
398 @param aDefaultScreenNumber |
|
399 @param aTypeId |
|
400 |
|
401 |
|
402 @return A pointer to the newly allocated CApplicationRegistrationData object, if creation is successful. |
|
403 */ |
|
404 IMPORT_C static CApplicationRegistrationData* NewL( |
|
405 RPointerArray<HBufC>& aOwnedFileArray, |
|
406 RPointerArray<Usif::CServiceInfo>& aServiceArray, |
|
407 RPointerArray<CLocalizableAppInfo>& aLocalizableAppInfoList, |
|
408 RPointerArray<CPropertyEntry>& aAppPropertiesArray, |
|
409 RPointerArray<COpaqueData>& aOpaqueDataArray, |
|
410 TUid aAppUid, const TDesC& aAppFile, |
|
411 TApplicationCharacteristics& aCharacteristics, |
|
412 TInt aDefaultScreenNumber, TInt aTypeId = 0); |
|
413 /** |
|
414 Creates a CApplicationRegistrationData object. |
|
415 |
|
416 @param aOwnedFileArray An array of files owned by the application. The ownership is also transferred to CApplicationRegistrationData. |
|
417 @param aServiceArray An array of services related information associated with the application. The ownership is also transferred to CApplicationRegistrationData. |
|
418 @param aLocalizableAppInfoList An array of localizable information associated with the application. The ownership is also transferred to CApplicationRegistrationData. |
|
419 @param aAppPropertiesArray An array of properties associated with the application. The ownership is also transferred to CApplicationRegistrationData. |
|
420 @param aOpaqueDataArray An array of opaque data associated with the application. The ownership is also transferred to CApplicationRegistrationData. |
|
421 @param aAppUid The Uid of the application. |
|
422 @param aAppFile The executable file associated with the application. |
|
423 @param aCharacteristics The attributes associated with the application. @see Usif::TApplicationCharacteristics |
|
424 @param aDefaultScreenNumber |
|
425 @param aTypeId |
|
426 |
|
427 |
|
428 @return A pointer to the newly allocated CApplicationRegistrationData object, if creation is successful. |
|
429 The pointer is also put onto the cleanup stack. |
|
430 */ |
|
431 IMPORT_C static CApplicationRegistrationData * NewLC( |
|
432 RPointerArray<HBufC>& aOwnedFileArray, |
|
433 RPointerArray<CServiceInfo>& aServiceArray, |
|
434 RPointerArray<CLocalizableAppInfo>& aLocalizableAppInfoList, |
|
435 RPointerArray<CPropertyEntry>& aAppPropertiesArray, |
|
436 RPointerArray<COpaqueData>& aOpaqueDataArray, |
|
437 TUid aAppUid, const TDesC& aAppFile, |
|
438 TApplicationCharacteristics& aCharacteristics, |
|
439 TInt aDefaultScreenNumber, TInt aTypeId = 0); |
|
440 |
|
441 /** |
|
442 Creates a CApplicationRegistrationData object. |
|
443 |
|
444 @param aOwnedFileArray An array of files owned by the application. The ownership is also transferred to CApplicationRegistrationData. |
|
445 @param aServiceArray An array of services related information associated with the application. The ownership is also transferred to CApplicationRegistrationData. |
|
446 @param aLocalizableAppInfoList An array of localizable information associated with the application. The ownership is also transferred to CApplicationRegistrationData. |
|
447 @param aAppPropertiesArray An array of properties associated with the application. The ownership is also transferred to CApplicationRegistrationData. |
|
448 @param aAppUid The Uid of the application. |
|
449 @param aAppFile The executable file associated with the application. |
|
450 |
|
451 |
|
452 @return A pointer to the newly allocated CApplicationRegistrationData object, if creation is successful. |
|
453 */ |
|
454 IMPORT_C static CApplicationRegistrationData* NewL(RPointerArray<HBufC>& aOwnedFileArray, RPointerArray<CServiceInfo>& aServiceArray, RPointerArray<CLocalizableAppInfo>& aLocalizableAppInfoList, |
|
455 RPointerArray<CPropertyEntry>& aAppPropertiesArray, TUid aAppUid, |
|
456 const TDesC& aAppFile); |
|
457 /** |
|
458 Creates a CApplicationRegistrationData object. |
|
459 |
|
460 @param aOwnedFileArray An array of files owned by the application. The ownership is also transferred to CApplicationRegistrationData. |
|
461 @param aServiceArray An array of services related information associated with the application. The ownership is also transferred to CApplicationRegistrationData. |
|
462 @param aLocalizableAppInfoList An array of localizable information associated with the application. The ownership is also transferred to CApplicationRegistrationData. |
|
463 @param aAppPropertiesArray An array of properties associated with the application. The ownership is also transferred to CApplicationRegistrationData. |
|
464 @param aAppUid The Uid of the application. |
|
465 @param aAppFile The executable file associated with the application. |
|
466 |
|
467 |
|
468 @return A pointer to the newly allocated CApplicationRegistrationData object, if creation is successful. |
|
469 The pointer is also put onto the cleanup stack. |
|
470 */ |
|
471 IMPORT_C static CApplicationRegistrationData* NewLC(RPointerArray<HBufC>& aOwnedFileArray, RPointerArray<CServiceInfo>& aServiceArray, RPointerArray<CLocalizableAppInfo>& aLocalizableAppInfoList, |
|
472 RPointerArray<CPropertyEntry>& aAppPropertiesArray, TUid aAppUid, |
|
473 const TDesC& aAppFile); |
|
474 ~CApplicationRegistrationData(); |
|
475 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
476 IMPORT_C void InternalizeL(RReadStream& aStream); |
|
477 |
|
478 IMPORT_C const TUid AppUid() const; |
|
479 IMPORT_C const TDesC& AppFile() const; |
|
480 IMPORT_C TInt TypeId() const; |
|
481 IMPORT_C TUint Attributes() const; |
|
482 IMPORT_C TBool Hidden() const; |
|
483 IMPORT_C TApplicationCharacteristics::TAppEmbeddability Embeddability() const; |
|
484 IMPORT_C TBool NewFile() const; |
|
485 IMPORT_C TBool Launch() const; |
|
486 IMPORT_C const TDesC& GroupName() const; |
|
487 IMPORT_C TInt DefaultScreenNumber() const; |
|
488 IMPORT_C const RPointerArray<HBufC>& OwnedFileArray() const; |
|
489 IMPORT_C const RPointerArray<CServiceInfo>& ServiceArray() const; |
|
490 IMPORT_C const RPointerArray<CLocalizableAppInfo>& LocalizableAppInfoList() const; |
|
491 IMPORT_C const RPointerArray<CPropertyEntry>& AppProperties() const; |
|
492 IMPORT_C const RPointerArray<COpaqueData>& AppOpaqueData() const; |
|
493 |
|
494 private: |
|
495 CApplicationRegistrationData(); |
|
496 void ConstructL(RPointerArray<HBufC>& aOwnedFileArray, |
|
497 RPointerArray<CServiceInfo>& aServiceArray, |
|
498 RPointerArray<CLocalizableAppInfo>& aLocalizableAppInfoList, |
|
499 RPointerArray<CPropertyEntry>& aAppPropertiesArray, |
|
500 RPointerArray<COpaqueData>& aOpaqueDataArray, TUid aAppUid, |
|
501 const TDesC& aAppFile, TApplicationCharacteristics& aCharacteristics, |
|
502 TInt aDefaultScreenNumber, TInt aTypeId); |
|
503 |
|
504 void ConstructL(RPointerArray<HBufC>& aOwnedFileArray, RPointerArray<CServiceInfo>& aServiceArray, |
|
505 RPointerArray<CLocalizableAppInfo>& aLocalizableAppInfoList, RPointerArray<CPropertyEntry>& aAppPropertiesArray, |
|
506 TUid aAppUid, const TDesC& aAppFile); |
|
507 |
|
508 void ConstructL(const TDesC& aAppFile); |
|
509 private: |
|
510 |
|
511 RPointerArray<HBufC> iOwnedFileArray; // FileOwnershipInfo |
|
512 RPointerArray<CServiceInfo> iServiceArray; // Service Info and Service Data Type |
|
513 RPointerArray<CLocalizableAppInfo> iLocalizableAppInfoList; //LocalizableAppInfo |
|
514 RPointerArray<CPropertyEntry> iAppPropertiesArray; // AppProperties |
|
515 RPointerArray<COpaqueData> iOpaqueDataArray; |
|
516 |
|
517 // AppRegistrationInfo Table |
|
518 TUid iAppUid; |
|
519 HBufC* iAppFile; |
|
520 TInt iTypeId; |
|
521 TApplicationCharacteristics iCharacteristics; |
|
522 TInt iDefaultScreenNumber; |
|
523 }; |
|
524 |
|
525 |
|
526 NONSHARABLE_CLASS(CDataType) : public CBase |
|
527 /* |
|
528 * It contains the priority and type information associated to each service provided by the application. |
|
529 */ |
|
530 { |
|
531 friend class CScrRequestImpl; |
|
532 public: |
|
533 /** |
|
534 Creates an empty CDataType object. |
|
535 @return A pointer to the newly allocated CDataType object, if creation is successful. |
|
536 */ |
|
537 IMPORT_C static CDataType* NewL(); |
|
538 |
|
539 /** |
|
540 Creates an empty CDataType object. |
|
541 @return A pointer to the newly allocated CDataType object, if creation is successful. |
|
542 The pointer is also put onto the cleanup stack. |
|
543 */ |
|
544 IMPORT_C static CDataType* NewLC(); |
|
545 |
|
546 /** |
|
547 Creates a CDataType object from the stream. |
|
548 |
|
549 @param aStream The stream to read the CDataType object from. |
|
550 @return A pointer to the newly allocated CDataType object, if creation is successful. |
|
551 */ |
|
552 IMPORT_C static CDataType* NewL(RReadStream& aStream); |
|
553 |
|
554 /** |
|
555 Creates a CDataType object. |
|
556 |
|
557 @param aPriority The priority to be associated with the service. |
|
558 @param aType The type information to be associated with the service. |
|
559 @return A pointer to the newly allocated CDataType object, if creation is successful. |
|
560 */ |
|
561 IMPORT_C static CDataType* NewL(TInt aPriority, const TDesC& aType); |
|
562 |
|
563 /** |
|
564 Creates a CDataType object. |
|
565 |
|
566 @param aPriority The priority to be associated with the service. |
|
567 @param aType The type information to be associated with the service. |
|
568 @return A pointer to the newly allocated CDataType object, if creation is successful. |
|
569 The pointer is also put onto the cleanup stack. |
|
570 */ |
|
571 IMPORT_C static CDataType* NewLC(TInt aPriority, const TDesC& aType); |
|
572 |
|
573 ~CDataType(); |
|
574 |
|
575 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
576 |
|
577 IMPORT_C void InternalizeL(RReadStream& aStream); |
|
578 |
|
579 /** |
|
580 @return The priority associated with the service. |
|
581 */ |
|
582 IMPORT_C TInt Priority() const; |
|
583 |
|
584 /** |
|
585 @return The type information associated with the service. |
|
586 */ |
|
587 IMPORT_C const TDesC& Type() const; |
|
588 private: |
|
589 CDataType(); |
|
590 void ConstructL(TInt aPriority, const TDesC& aType); |
|
591 private: |
|
592 TInt iPriority; |
|
593 HBufC* iType; |
|
594 }; |
|
595 |
|
596 |
|
597 NONSHARABLE_CLASS(CServiceInfo) : public CBase |
|
598 /* |
|
599 * This contains the service related information such as service Uid, opaque data and data type information associated with an applciation. |
|
600 */ |
|
601 { |
|
602 friend class CScrRequestImpl; |
|
603 public: |
|
604 /** |
|
605 Creates an empty CServiceInfo object. |
|
606 @return A pointer to the newly allocated CServiceInfo object, if creation is successful. |
|
607 */ |
|
608 IMPORT_C static CServiceInfo* NewL(); |
|
609 |
|
610 /** |
|
611 Creates an empty CServiceInfo object. |
|
612 @return A pointer to the newly allocated CServiceInfo object, if creation is successful. |
|
613 The pointer is also put onto the cleanup stack. |
|
614 */ |
|
615 IMPORT_C static CServiceInfo* NewLC(); |
|
616 |
|
617 /** |
|
618 Creates a CServiceInfo object from the stream. |
|
619 |
|
620 @param aStream The stream to read the CServiceInfo object from. |
|
621 @return A pointer to the newly allocated CServiceInfo object, if creation is successful. |
|
622 */ |
|
623 IMPORT_C static CServiceInfo* NewL(RReadStream& aStream); |
|
624 |
|
625 /** |
|
626 Creates a CServiceInfo object. |
|
627 @param aUid The Uid associated with the service. |
|
628 @param aOpaqueDataArray An array of opaque data associated with the service. The ownership is also transferred to |
|
629 the CServiceInfo object. |
|
630 @param aDataTypes An array of data types associated with the service. The ownership is also transferred to |
|
631 the CServiceInfo object. |
|
632 @return A pointer to the newly allocated CServiceInfo object, if creation is successful. |
|
633 */ |
|
634 IMPORT_C static CServiceInfo* NewL(const TUid aUid, RPointerArray<COpaqueData>& aOpaqueDataArray, RPointerArray<CDataType>& aDataTypes); |
|
635 |
|
636 /** |
|
637 Creates a CServiceInfo object. |
|
638 @param aUid The Uid associated with the service. |
|
639 @param aOpaqueDataArray An array of opaque data associated with the service. The ownership is also transferred to |
|
640 the CServiceInfo object. |
|
641 @param aDataTypes An array of data types associated with the service. The ownership is also transferred to |
|
642 the CServiceInfo object. |
|
643 @return A pointer to the newly allocated CServiceInfo object, if creation is successful. |
|
644 */ |
|
645 IMPORT_C static CServiceInfo* NewLC(const TUid aUid, RPointerArray<COpaqueData>& aOpaqueDataArray, RPointerArray<CDataType>& aDataTypes); |
|
646 ~CServiceInfo(); |
|
647 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
648 IMPORT_C void InternalizeL(RReadStream& aStream); |
|
649 |
|
650 /** |
|
651 @return The Uid associated with the service. |
|
652 */ |
|
653 IMPORT_C const TUid Uid() const; |
|
654 |
|
655 /** |
|
656 @return The array of data types associated with the service. |
|
657 */ |
|
658 IMPORT_C const RPointerArray<CDataType>& DataTypes() const; |
|
659 |
|
660 /** |
|
661 @return The array of opaque data associated with the service. |
|
662 */ |
|
663 IMPORT_C const RPointerArray<COpaqueData>& OpaqueData() const; |
|
664 private: |
|
665 CServiceInfo(); |
|
666 void ConstructL(const TUid aUid, RPointerArray<COpaqueData>& aOpaqueDataArray, RPointerArray<CDataType>& aDataTypes); |
|
667 private: |
|
668 TUid iUid; |
|
669 RPointerArray<CDataType> iDataTypes; |
|
670 RPointerArray<COpaqueData> iOpaqueDataArray; |
|
671 }; |
|
672 |
|
673 |
|
674 NONSHARABLE_CLASS(CLocalizableAppInfo) : public CBase |
|
675 /* |
|
676 * This contains localizable information associated with an application. |
|
677 */ |
|
678 { |
|
679 friend class CScrRequestImpl; |
|
680 public: |
|
681 /** |
|
682 Creates an empty CLocalizableAppInfo object. |
|
683 @return A pointer to the newly allocated CLocalizableAppInfo object, if creation is successful. |
|
684 */ |
|
685 IMPORT_C static CLocalizableAppInfo* NewL(); |
|
686 |
|
687 /** |
|
688 Creates an empty CLocalizableAppInfo object. |
|
689 @return A pointer to the newly allocated CLocalizableAppInfo object, if creation is successful. |
|
690 The pointer is also put onto the cleanup stack. |
|
691 */ |
|
692 IMPORT_C static CLocalizableAppInfo* NewLC(); |
|
693 |
|
694 /** |
|
695 Creates a CLocalizableAppInfo object from the stream. |
|
696 |
|
697 @param aStream The stream to read the CLocalizableAppInfo object from. |
|
698 @return A pointer to the newly allocated CLocalizableAppInfo object, if creation is successful. |
|
699 */ |
|
700 IMPORT_C static CLocalizableAppInfo* NewL(RReadStream& aStream); |
|
701 |
|
702 /** |
|
703 Creates a CLocalizableAppInfo object. |
|
704 |
|
705 @param aShortCaption A locale specific short caption associated with the application. |
|
706 @param aApplicationLanguage A language that the application is localized in. |
|
707 @param aGroupName A group name associated with the application. |
|
708 @param aCaptionAndIconInfo A locale specific caption and icon information associated with the application. The ownership is also transferred |
|
709 to the CLocalizableAppInfo object. |
|
710 @param aViewDataList An array of view information associated with the application. The ownership is also transferred |
|
711 to the CLocalizableAppInfo object. |
|
712 @return A pointer to the newly allocated CLocalizableAppInfo object, if creation is successful. |
|
713 */ |
|
714 IMPORT_C static CLocalizableAppInfo* NewL(const TDesC& aShortCaption, TLanguage aApplicationLanguage, const TDesC& aGroupName, CCaptionAndIconInfo* aCaptionAndIconInfo, RPointerArray<CAppViewData>& aViewDataList); |
|
715 |
|
716 /** |
|
717 Creates a CLocalizableAppInfo object. |
|
718 |
|
719 @param aShortCaption A locale specific short caption associated with the application. |
|
720 @param aApplicationLanguage A language that the application is localized in. |
|
721 @param aGroupName A group name associated with the application. |
|
722 @param aCaptionAndIconInfo A locale specific caption and icon information associated with the application. The ownership is also transferred |
|
723 to the CLocalizableAppInfo object. |
|
724 @param aViewDataList An array of view information associated with the application. The ownership is also transferred |
|
725 to the CLocalizableAppInfo object. |
|
726 @return A pointer to the newly allocated CLocalizableAppInfo object, if creation is successful. |
|
727 The pointer is also put onto the cleanup stack. |
|
728 */ |
|
729 IMPORT_C static CLocalizableAppInfo* NewLC(const TDesC& aShortCaption, TLanguage aApplicationLanguage, const TDesC& aGroupName, CCaptionAndIconInfo* aCaptionAndIconInfo, RPointerArray<CAppViewData>& aViewDataList); |
|
730 |
|
731 ~CLocalizableAppInfo(); |
|
732 |
|
733 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
734 |
|
735 IMPORT_C void InternalizeL(RReadStream& aStream); |
|
736 |
|
737 /** |
|
738 @return The short caption associated with the locale for the application. |
|
739 */ |
|
740 IMPORT_C const TDesC& ShortCaption() const; |
|
741 |
|
742 /** |
|
743 @return The language that the application is localized in. |
|
744 */ |
|
745 IMPORT_C TLanguage ApplicationLanguage() const; |
|
746 |
|
747 /** |
|
748 @return The group name associated with the application. |
|
749 */ |
|
750 IMPORT_C const TDesC& GroupName() const; |
|
751 |
|
752 /** |
|
753 @return The array of Application view information associated with the application. |
|
754 */ |
|
755 IMPORT_C const RPointerArray<CAppViewData>& ViewDataList() const; |
|
756 |
|
757 /** |
|
758 @return The locale specific caption and icon information associated with the application. |
|
759 */ |
|
760 IMPORT_C const CCaptionAndIconInfo* CaptionAndIconInfo() const; |
|
761 |
|
762 private: |
|
763 CLocalizableAppInfo(); |
|
764 |
|
765 void ConstructL(const TDesC& aShortCaption, TLanguage aApplicationLanguage, const TDesC& aGroupName, CCaptionAndIconInfo* aCaptionAndIconInfo, RPointerArray<Usif::CAppViewData> aViewDataList); |
|
766 |
|
767 void ConstructL(const TDesC& aShortCaption, const TDesC& aGroupName); |
|
768 |
|
769 private: |
|
770 HBufC* iShortCaption; |
|
771 TLanguage iApplicationLanguage; |
|
772 HBufC* iGroupName; |
|
773 CCaptionAndIconInfo* iCaptionAndIconInfo; |
|
774 RPointerArray<CAppViewData> iViewDataList; |
|
775 }; |
|
776 |
|
777 |
|
778 NONSHARABLE_CLASS(CCaptionAndIconInfo) : public CBase |
|
779 /* |
|
780 * This contains the caption and icon information associated to an application such as caption, icon filename and number of icons. |
|
781 * |
|
782 * N.B. Icon Filename, if present, should contain the absolute file path, along with the drive and extension (if any). |
|
783 */ |
|
784 { |
|
785 friend class CScrRequestImpl; |
|
786 |
|
787 public: |
|
788 /** |
|
789 Creates an empty CCaptionAndIconInfo object. |
|
790 @return A pointer to the newly allocated CCaptionAndIconInfo object, if creation is successful. |
|
791 */ |
|
792 IMPORT_C static CCaptionAndIconInfo* NewL(); |
|
793 |
|
794 /** |
|
795 Creates an empty CCaptionAndIconInfo object. |
|
796 @return A pointer to the newly allocated CCaptionAndIconInfo object, if creation is successful. |
|
797 The pointer is also put onto the cleanup stack. |
|
798 */ |
|
799 IMPORT_C static CCaptionAndIconInfo* NewLC(); |
|
800 |
|
801 /** |
|
802 Creates a CCaptionAndIconInfo object from the stream. |
|
803 |
|
804 @param aStream The stream to read the CCaptionAndIconInfo object from. |
|
805 @return A pointer to the newly allocated CCaptionAndIconInfo object, if creation is successful. |
|
806 */ |
|
807 IMPORT_C static CCaptionAndIconInfo* NewL(RReadStream& aStream); |
|
808 |
|
809 /** |
|
810 Creates a CCaptionAndIconInfo object. |
|
811 |
|
812 @param aCaption The caption associated with the application. The ownership is transferred to the CCaptionAndIconInfo object. |
|
813 @param aIconFileName The absolute filename of the icon file. The ownership is transferred to the CCaptionAndIconInfo object. |
|
814 @param aNumOfAppIcons The number of icons associated with the application. |
|
815 @return A pointer to the newly allocated CCaptionAndIconInfo object, if creation is successful. |
|
816 */ |
|
817 IMPORT_C static CCaptionAndIconInfo* NewL(const TDesC& aCaption, const TDesC& aIconFileName, TInt aNumOfAppIcons); |
|
818 |
|
819 /** |
|
820 Creates a CCaptionAndIconInfo object. |
|
821 |
|
822 @param aCaption The caption associated with the application. The ownership is transferred to the CCaptionAndIconInfo object. |
|
823 @param aIconFileName The absolute filename of the icon file. The ownership is transferred to the CCaptionAndIconInfo object. |
|
824 @param aNumOfAppIcons The number of icons associated with the application. |
|
825 @return A pointer to the newly allocated CCaptionAndIconInfo object, if creation is successful. |
|
826 The pointer is also put onto the cleanup stack. |
|
827 */ |
|
828 IMPORT_C static CCaptionAndIconInfo* NewLC(const TDesC& aCaption, const TDesC& aIconFileName, TInt aNumOfAppIcons); |
|
829 |
|
830 ~CCaptionAndIconInfo(); |
|
831 |
|
832 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
833 |
|
834 IMPORT_C void InternalizeL(RReadStream& aStream); |
|
835 |
|
836 /** |
|
837 @return The caption associated with the application. |
|
838 */ |
|
839 IMPORT_C const TDesC& Caption() const; |
|
840 |
|
841 /** |
|
842 @return The absolute name of the icon file associated with the application. |
|
843 */ |
|
844 IMPORT_C const TDesC& IconFileName() const; |
|
845 |
|
846 /** |
|
847 @return The number of icons associated with the application. |
|
848 */ |
|
849 IMPORT_C TInt NumOfAppIcons() const; |
|
850 private: |
|
851 CCaptionAndIconInfo(); |
|
852 void ConstructL(const TDesC& aCaption, const TDesC& aIconFileName, TInt aNumOfAppIcons); |
|
853 |
|
854 private: |
|
855 HBufC* iCaption; |
|
856 HBufC* iIconFileName; |
|
857 TInt iNumOfAppIcons; |
|
858 }; |
|
859 |
|
860 |
|
861 NONSHARABLE_CLASS(CAppViewData) : public CBase |
|
862 /* |
|
863 * This contains view information of an application such as screenmode and an array of caption and icon info associated with each view. |
|
864 */ |
|
865 { |
|
866 friend class CScrRequestImpl; |
|
867 |
|
868 public: |
|
869 /** |
|
870 Creates an empty CAppViewData object. |
|
871 @return A pointer to the newly allocated CAppViewData object, if creation is successful. |
|
872 */ |
|
873 IMPORT_C static CAppViewData* NewL(); |
|
874 |
|
875 /** |
|
876 Creates an empty CAppViewData object. |
|
877 @return A pointer to the newly allocated CAppViewData object, if creation is successful. |
|
878 The pointer is also put onto the cleanup stack. |
|
879 */ |
|
880 IMPORT_C static CAppViewData* NewLC(); |
|
881 |
|
882 /** |
|
883 Creates a CAppViewData object from the stream. |
|
884 |
|
885 @param aStream The stream to read the CAppViewData object from. |
|
886 @return A pointer to the newly allocated CAppViewData object, if creation is successful. |
|
887 */ |
|
888 IMPORT_C static CAppViewData* NewL(RReadStream& aStream); |
|
889 |
|
890 /** |
|
891 Creates a CAppViewData object. |
|
892 |
|
893 @param aUid The Uid of the application. |
|
894 @param aScreenMode The screen mode associated with the view. |
|
895 @param aCaptionAndIconInfo The caption and icon info associated with the view. The ownership is |
|
896 also transferred to the CAppViewData object. |
|
897 @return A pointer to the newly allocated CAppViewData object, if creation is successful. |
|
898 */ |
|
899 IMPORT_C static CAppViewData* NewL(TUid aUid, TInt aScreenMode, CCaptionAndIconInfo* aCaptionAndIconInfo); |
|
900 |
|
901 /** |
|
902 Creates a CAppViewData object. |
|
903 |
|
904 @param aUid The Uid of the application. |
|
905 @param aScreenMode The screen mode associated with the view. |
|
906 @param aCaptionAndIconInfo The caption and icon info associated with the view. The ownership is |
|
907 also transferred to the CAppViewData object. |
|
908 @return A pointer to the newly allocated CAppViewData object, if creation is successful. |
|
909 The pointer is also put onto the cleanup stack. |
|
910 */ |
|
911 IMPORT_C static CAppViewData* NewLC(TUid aUid, TInt aScreenMode, CCaptionAndIconInfo* aCaptionAndIconInfo); |
|
912 |
|
913 ~CAppViewData(); |
|
914 |
|
915 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
916 |
|
917 IMPORT_C void InternalizeL(RReadStream& aStream); |
|
918 |
|
919 /** |
|
920 @return The Uid of the application. |
|
921 */ |
|
922 IMPORT_C const TUid Uid() const; |
|
923 |
|
924 /** |
|
925 @return The screen mode associated with the view. |
|
926 */ |
|
927 IMPORT_C TInt ScreenMode() const; |
|
928 |
|
929 /** |
|
930 @return The caption and icon info associated with the view. |
|
931 */ |
|
932 IMPORT_C const CCaptionAndIconInfo* CaptionAndIconInfo() const; |
|
933 |
|
934 private: |
|
935 CAppViewData(); |
|
936 void ConstructL(TUid aUid, TInt aScreenMode, CCaptionAndIconInfo* aCaptionAndIconInfo); |
|
937 |
|
938 private: |
|
939 TUid iUid; |
|
940 TInt iScreenMode; |
|
941 CCaptionAndIconInfo* iCaptionAndIconInfo; |
|
942 }; |
|
943 |
|
944 |
|
945 NONSHARABLE_CLASS(CLauncherExecutable) : public CBase |
|
946 /** |
|
947 * This contains information regarding the executable used to launch the application. |
|
948 */ |
|
949 { |
|
950 friend class CScrRequestImpl; |
|
951 public: |
|
952 /** |
|
953 Creates an empty CLauncherExecutable object. |
|
954 @return A pointer to the newly allocated CLauncherExecutable object, if creation is successful. |
|
955 */ |
|
956 IMPORT_C static CLauncherExecutable* NewL(); |
|
957 |
|
958 /** |
|
959 Creates an empty CLauncherExecutable object. |
|
960 @return A pointer to the newly allocated CLauncherExecutable object, if creation is successful. |
|
961 The pointer is also put onto the cleanup stack. |
|
962 */ |
|
963 IMPORT_C static CLauncherExecutable* NewLC(); |
|
964 |
|
965 /** |
|
966 Creates a CLauncherExecutable object. |
|
967 |
|
968 @param aTypeId The Application type id. |
|
969 @param aLauncher The native executable used to launch the application |
|
970 @return A pointer to the newly allocated CLauncherExecutable object, if creation is successful. |
|
971 |
|
972 */ |
|
973 IMPORT_C static CLauncherExecutable* NewL(TInt aTypeId, const TDesC& aLauncher); |
|
974 |
|
975 /** |
|
976 Creates a CLauncherExecutable object. |
|
977 |
|
978 @param aTypeId The Application type id. |
|
979 @param aLauncher The native executable used to launch the application |
|
980 @return A pointer to the newly allocated CLauncherExecutable object, if creation is successful. |
|
981 The pointer is also put onto the cleanup stack. |
|
982 */ |
|
983 IMPORT_C static CLauncherExecutable* NewLC(TInt aTypeId, const TDesC& aLauncher); |
|
984 |
|
985 /** |
|
986 Creates a CLauncherExecutable object from the stream. |
|
987 |
|
988 @param aStream The stream to read the CLauncherExecutable object from. |
|
989 @return A pointer to the newly allocated CLauncherExecutable object, if creation is successful. |
|
990 */ |
|
991 IMPORT_C static CLauncherExecutable* NewL(RReadStream& aStream); |
|
992 |
|
993 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
994 |
|
995 IMPORT_C void InternalizeL(RReadStream& aStream); |
|
996 |
|
997 /** |
|
998 @return The Application type id. |
|
999 */ |
|
1000 IMPORT_C TInt TypeId() const; |
|
1001 |
|
1002 /** |
|
1003 @return The executable used to launch the application. |
|
1004 */ |
|
1005 IMPORT_C const TDesC& Launcher() const; |
|
1006 |
|
1007 IMPORT_C ~CLauncherExecutable(); |
|
1008 |
|
1009 private: |
|
1010 CLauncherExecutable(); |
|
1011 void ConstructL(TInt aTypeId, const TDesC& aLauncher); |
|
1012 |
|
1013 private: |
|
1014 TInt iTypeId; ///< Application type id (same as the software type id of the component) |
|
1015 HBufC* iLauncher; ///< The native executable used to launch the application |
|
1016 }; |
|
1017 |
|
1018 |
|
1019 } // End of USIF Namespace |
|
1020 |
|
1021 #endif // APPREGENTRIES_H |
|