|
1 // Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // MTSR.H |
|
15 // |
|
16 /** |
|
17 @file |
|
18 @publishedAll |
|
19 @released |
|
20 */ |
|
21 #ifndef __MTSR_H__ |
|
22 #define __MTSR_H__ |
|
23 |
|
24 #include <e32base.h> |
|
25 #include <badesca.h> |
|
26 #include <msvstd.h> |
|
27 #include <msvreg.h> |
|
28 #include <tnonoperationmtmdata.h> |
|
29 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS |
|
30 #include "cinstalledmtmgroup.h" |
|
31 #endif |
|
32 |
|
33 // forward declarations |
|
34 class RWriteStream; |
|
35 class RReadStream; |
|
36 class RFs; |
|
37 class CDictionaryFileStore; |
|
38 class CInstalledMtmGroup; |
|
39 class CMsvServerEntry; |
|
40 class TMsvSystemProgress; |
|
41 class CInstalledMtmGroupArray; |
|
42 |
|
43 #if (defined SYMBIAN_USER_PROMPT_SERVICE) |
|
44 const TUint KUIDMsgClientThreadInfo = 0x10283090; |
|
45 #endif |
|
46 |
|
47 class CBaseServerMtm : public CActive |
|
48 /** Base class for Server-side MTM components. Server-side MTMs provide all message |
|
49 transport functionality for a particular messaging protocol. |
|
50 |
|
51 MTM implementers implement a derived class to provide such functionality for |
|
52 their message protocol. Writers of message client applications are never concerned |
|
53 with this class and its sub-classes, as these are only accessed by the Message |
|
54 Server. |
|
55 |
|
56 Each MTM interprets the generic commands in different ways. For example, a |
|
57 Fax MTM would transmit a fax when asked to copy a fax from a local folder |
|
58 to a fax service. For the same function, an IMAP MTM would create a copy of |
|
59 the message on the remote server and update the message index to show the |
|
60 copy of the message on the remote server. An important initial design task |
|
61 is to the map the functions to the functionality provided by the protocol. |
|
62 |
|
63 Server-side MTM functions are called by the Message Server as a result of |
|
64 a client request that requires some remote operation with the MTM's protocol. |
|
65 The following steps give a simplified view of the usual sequence of events: |
|
66 |
|
67 1. the Message Server instantiates a Server-side MTM object through the factory |
|
68 function |
|
69 |
|
70 2. the Message Server calls the appropriate asynchronous function on the Server-side |
|
71 MTM interface, passing a TRequestStatus argument |
|
72 |
|
73 3. the Server-side MTM function typically starts whatever asynchronous communications |
|
74 it requires and returns |
|
75 |
|
76 4. the Server-side MTM is signalled when the asynchronous communications complete, |
|
77 and handles the result |
|
78 |
|
79 5. the Server-side MTM signals the Message Server, through the TRequestStatus |
|
80 passed earlier |
|
81 |
|
82 6. the Message Server deletes the Server-side MTM object |
|
83 |
|
84 To qualify this somewhat: |
|
85 |
|
86 1. it is up to the Server-side MTM implementation to decide how to translate |
|
87 data back and forth between the formats used by Message Server (index entry, |
|
88 message store, binary files), and that required by the protocol; this is another |
|
89 important design task |
|
90 |
|
91 2. depending on the protocol being used, the communications sequence can be of |
|
92 considerable complexity; typically it requires division into a number of asynchronous |
|
93 steps |
|
94 |
|
95 3. for greater efficiency where further commands are shortly expected, deletion |
|
96 of the Server-side MTM object can be prevented |
|
97 |
|
98 For asynchronous requests, a Server-side MTM should always complete the TRequestStatus |
|
99 with KErrNone. Any errors should be returned in the progress information. |
|
100 |
|
101 Note the following significant groups of functions: |
|
102 |
|
103 1. Copy and move from remote functions: CopyToLocalL() and MoveToLocalL() are |
|
104 called by the Message Server to get a selection of entries from a remote location. |
|
105 For many protocols, this should be interpreted as message retrieval. For protocols |
|
106 where messages exist on a remote server, this function is typically used to |
|
107 download specific messages, after an initial connection has downloaded message |
|
108 headers. |
|
109 |
|
110 2. Copy and move to remote functions: CopyFromLocalL() and MoveFromLocalL() are |
|
111 called by the Message Server to copy/move a selection of entries to a remote |
|
112 location. For many protocols, this should be interpreted as message sending. |
|
113 |
|
114 3. Copy and move within remote functions: CopyWithinServiceL() and MoveWithinServiceL() |
|
115 are called by the Message Server to copy a selection of entries within a remote |
|
116 service. An example of their use might be for a user rearranging messages |
|
117 within remote folders. |
|
118 @publishedAll |
|
119 @released |
|
120 */ |
|
121 { |
|
122 public: |
|
123 IMPORT_C ~CBaseServerMtm(); |
|
124 // |
|
125 /** Copies a selection of entries from a remote location to a local location. This |
|
126 will only be meaningful for some protocols. |
|
127 |
|
128 Requirements: |
|
129 |
|
130 Implementations should provide this function if the messaging protocol supports |
|
131 retrieval of remote entries. If this is not supported, implementations should |
|
132 leave with KErrNotSupported. |
|
133 |
|
134 Implementations of this function have three fundamental steps: |
|
135 |
|
136 1. doing the transfer operation using the appropriate communications protocols |
|
137 |
|
138 2. converting protocol-specific data into the three-part storage format (index |
|
139 entry, message store, binary files) required by the Message Server |
|
140 |
|
141 3. updating entries in the Message Server |
|
142 |
|
143 @param aSelection The collection of message index entries for which the copy/moving |
|
144 is required. |
|
145 @param aDestination The entry ID to which the selection is to be copied |
|
146 @param aStatus Asynchronous completion word for the operation |
|
147 @leave KErrNotSupported The Server-side MTM does not support this operation |
|
148 @leave Other leave codes Dependent on implementation */ |
|
149 virtual void CopyToLocalL(const CMsvEntrySelection& aSelection,TMsvId aDestination, TRequestStatus& aStatus)=0; |
|
150 /** Copies a selection of entries from a local location to a remote location. |
|
151 |
|
152 Requirements: |
|
153 |
|
154 Implementations should provide this function if the messaging protocol supports |
|
155 retrieval of remote entries. If this is not supported, implementations should |
|
156 leave with KErrNotSupported. |
|
157 |
|
158 Implementations of this function have three fundamental steps: |
|
159 |
|
160 1. reading entry data |
|
161 |
|
162 2. converting entry data from the Message Server format into that required by |
|
163 the protocol |
|
164 |
|
165 3. doing the transfer operation using the appropriate communications protocols |
|
166 |
|
167 @param aSelection The collection of message index entries for which the copy |
|
168 is required |
|
169 @param aDestination The entry ID of the service by which the entries should |
|
170 be transferred |
|
171 @param aStatus Asynchronous completion word for the operation |
|
172 @leave KErrNotSupported The Server-side MTM does not support this operation |
|
173 @leave Other leave codes Dependent on implementation */ |
|
174 virtual void CopyFromLocalL(const CMsvEntrySelection& aSelection,TMsvId aDestination, TRequestStatus& aStatus)=0; |
|
175 /** Copies a selection of entries within a remote location. |
|
176 |
|
177 Requirements: |
|
178 |
|
179 Implementations should provide this function if the messaging protocol supports |
|
180 the ability to copy entries within a remote service. If this is not supported, |
|
181 implementations should leave with KErrNotSupported. |
|
182 |
|
183 @param aSelection The collection of message index entries for which the copy |
|
184 is required |
|
185 @param aDestination The server entry ID to which the selection is to be copied |
|
186 @param aStatus Asynchronous completion word for the operation |
|
187 @leave KErrNotSupported The Server-side MTM does not support this operation |
|
188 @leave Other leave codes Dependent on implementation */ |
|
189 virtual void CopyWithinServiceL(const CMsvEntrySelection& aSelection,TMsvId aDestination, TRequestStatus& aStatus)=0; |
|
190 /** Deletes each entry in the supplied selection when called by the message Server. |
|
191 If any of the entries in the selection is a parent entry, then all its children |
|
192 should also be deleted, recursively to the bottom of the ownership tree. |
|
193 |
|
194 Implementations should provide this function if the messaging protocol supports |
|
195 deletion of remote entries. If this is not supported, implementations should |
|
196 leave with KErrNotSupported. |
|
197 |
|
198 @param aSelection The collection of entries that are to be deleted. |
|
199 @param aStatus Asynchronous completion object. |
|
200 @leave KErrNotSupported The Server-side MTM does not support this operation |
|
201 @leave Other leave codes Dependent on implementation */ |
|
202 virtual void DeleteAllL(const CMsvEntrySelection& aSelection, TRequestStatus& aStatus)=0; |
|
203 /** Creates a new remote entry with relevant data when called by the Message Server. |
|
204 |
|
205 Implementations should provide this function if the messaging protocol supports |
|
206 creation of remote entries. If this is not supported, implementations should |
|
207 leave with KErrNotSupported. |
|
208 |
|
209 As with ChangeL(), the Server-side MTM implementation must decide what information |
|
210 in the TMsvEntry is relevant to the remote entry, and translate it appropriately |
|
211 for the specific protocol. Most of the data contained in the TMsvEntry is |
|
212 specific to the Message Server, and would probably have no direct correlation |
|
213 with the protocol's own storage format. For example, for a folder, probably |
|
214 only the name and parent are needed, so if the protocol supports creation |
|
215 of remote folders, the implementation could: |
|
216 |
|
217 1. check for a folder type entry |
|
218 |
|
219 2. get the folder name and parent details from aNewEntry |
|
220 |
|
221 3. initiate a protocol-specific action to create the remote folder |
|
222 |
|
223 @param aNewEntry Data by which to create entry |
|
224 @param aStatus Asynchronous completion word for the operation. |
|
225 @leave KErrNotSupported The Server-side MTM does not support this operation |
|
226 @leave Other leave codes Dependent on implementation */ |
|
227 virtual void CreateL(TMsvEntry aNewEntry, TRequestStatus& aStatus)=0; |
|
228 /** Updates a remote entry with relevant data when called by the Message Server. |
|
229 |
|
230 Implementations should provide this function if the messaging protocol supports |
|
231 updating of remote entries. If this is not supported, implementations should |
|
232 leave with KErrNotSupported. |
|
233 |
|
234 The Server-side MTM implementation must decide what information in the TMsvEntry |
|
235 is relevant to the remote entry, and translate it appropriately for the specific |
|
236 protocol. Most of the data contained in the TMsvEntry is specific to the Symbian |
|
237 OS Message Server, and would probably have no direct correlation with the |
|
238 protocol's own storage format. Some entry data may however be useful. For |
|
239 example, if the protocol supports remote renaming of folders, the implementation |
|
240 could: |
|
241 |
|
242 1. check for a folder type entry |
|
243 |
|
244 2. extract the folder name from aNewEntry.iDetails |
|
245 |
|
246 3. check if the folder name has changed by comparing the new name with iDetails |
|
247 in the index entry currently; if not, complete with KErrNone |
|
248 |
|
249 4. initiate a protocol-specific action to rename the remote folder |
|
250 |
|
251 The implementation should also always update the local Message Server index |
|
252 through CMsvServerEntry::ChangeL(). |
|
253 |
|
254 @param aNewEntry Data by which to update entry |
|
255 @param aStatus Asynchronous completion word for the operation. |
|
256 @leave KErrNotSupported The Server-side MTM does not support this operation |
|
257 @leave Other leave codes Dependent on implementation */ |
|
258 virtual void ChangeL(TMsvEntry aNewEntry, TRequestStatus& aStatus)=0; |
|
259 // |
|
260 /** Executes an MTM-specific operation on a selection of entries when called by |
|
261 the Message Server. |
|
262 |
|
263 The call is made as a response to a client program invoking an MTM-specific |
|
264 operation through CBaseMtm::InvokeSyncFunctionL()/InvokeAsyncFunctionL(). |
|
265 The aSelection, aCommand, and aParameter arguments pass the values of the |
|
266 original aSelection, aFunctionId, and aParameter respectively arguments from |
|
267 such a call. The use (if any) of the aSelection and aParameter arguments by |
|
268 the function depends on the command. |
|
269 |
|
270 @param aSelection A selection of message entries on which the command is to |
|
271 be executed |
|
272 @param aCommand The MTM-specific command to be carried out |
|
273 @param aParameter Command-specific parameters |
|
274 @param aStatus Asynchronous completion word for the operation */ |
|
275 virtual void StartCommandL(CMsvEntrySelection& aSelection, TInt aCommand, const TDesC8& aParameter, TRequestStatus& aStatus)=0; |
|
276 // |
|
277 /** Tests if the Server-side MTM object should be deleted when called by the Message |
|
278 Server |
|
279 |
|
280 It is useful to stop the MTM being deleted when more commands are expected |
|
281 shortly. This would be the case, for example, after receiving a command to |
|
282 go online. |
|
283 |
|
284 If there are no more commands expected by the Server-side MTM object, then |
|
285 the function should return EFalse, and the Message Server will delete it. |
|
286 |
|
287 @return ETrue: the MTM object should not be deleted EFalse: the MTM object |
|
288 can be deleted */ |
|
289 virtual TBool CommandExpected()=0; |
|
290 // |
|
291 /** This function is called by the Message Server to get progress information for |
|
292 the current asynchronous operation. |
|
293 |
|
294 The call is made as a response to a client program requesting progress information |
|
295 through CMsvOperation::ProgressL(). The packing format used in the TDesC8 |
|
296 is MTM-specific. Only the implementation of the User Interface MTM progress |
|
297 information functions need to understand the format. |
|
298 |
|
299 The progress buffer should have a maximum size of 256 bytes. |
|
300 |
|
301 @return Progress information on current asynchronous operation |
|
302 @see CBaseMtmUi::DisplayProgressSummary() |
|
303 @see CBaseMtmUi::GetProgress() */ |
|
304 virtual const TDesC8& Progress()=0; |
|
305 // |
|
306 /** Moves a selection of entries from a remote location to a local location. |
|
307 |
|
308 Requirements: |
|
309 |
|
310 Implementations should provide this function if the messaging protocol supports |
|
311 retrieval of remote entries. If this is not supported, implementations should |
|
312 leave with KErrNotSupported. |
|
313 |
|
314 Implementations of this function have three fundamental steps: |
|
315 |
|
316 1. doing the transfer operation using the appropriate communications protocols |
|
317 |
|
318 2. converting protocol-specific data into the three-part storage format (index |
|
319 entry, message store, binary files) required by the Message Server |
|
320 |
|
321 3. updating entries in the Message Server |
|
322 |
|
323 MoveToLocalL() should differ from CopyToLocalL() in additionally deleting |
|
324 the original remote data. |
|
325 |
|
326 @param aSelection The collection of message index entries for which the moving |
|
327 is required. |
|
328 @param aDestination The entry ID to which the selection is to be copied/moved |
|
329 @param aStatus Asynchronous completion word for the operation |
|
330 @leave KErrNotSupported The Server-side MTM does not support this operation |
|
331 @leave Other leave codes Dependent on implementation */ |
|
332 virtual void MoveToLocalL(const CMsvEntrySelection& aSelection,TMsvId aDestination, TRequestStatus& aStatus)=0; |
|
333 /** Moves a selection of entries from a local location to a remote location. |
|
334 |
|
335 Requirements: |
|
336 |
|
337 Implementations should provide this function if the messaging protocol supports |
|
338 retrieval of remote entries. If this is not supported, implementations should |
|
339 leave with KErrNotSupported. |
|
340 |
|
341 Implementations of this function have three fundamental steps: |
|
342 |
|
343 1. reading entry data |
|
344 |
|
345 2. converting entry data from the Message Server format into that required by |
|
346 the protocol |
|
347 |
|
348 3. doing the transfer operation using the appropriate communications protocols |
|
349 |
|
350 The implementation of MoveFromLocalL() should differ from CopyFromLocalL() |
|
351 in additionally deleting the original local data. |
|
352 |
|
353 @param aSelection The collection of message index entries for which the move |
|
354 is required |
|
355 @param aDestination The entry ID of the service by which the entries should |
|
356 be transferred |
|
357 @param aStatus Asynchronous completion word for the operation |
|
358 @leave KErrNotSupported The Server-side MTM does not support this operation |
|
359 @leave Other leave codes Dependent on implementation */ |
|
360 virtual void MoveFromLocalL(const CMsvEntrySelection& aSelection,TMsvId aDestination, TRequestStatus& aStatus)=0; |
|
361 /** Moves a selection of entries within a remote location. |
|
362 |
|
363 Requirements: |
|
364 |
|
365 Implementations should provide this function if the messaging protocol supports |
|
366 the ability to move entries within a remote service. If this is not supported, |
|
367 implementations should leave with KErrNotSupported. |
|
368 |
|
369 The implementation of MoveWithinServiceL() should differ from CopyWithinServiceL() |
|
370 in additionally deleting the original data. |
|
371 |
|
372 @param aSelection The collection of message index entries for which the move |
|
373 is required |
|
374 @param aDestination The server entry ID to which the selection is to be moved |
|
375 @param aStatus Asynchronous completion word for the operation |
|
376 @leave KErrNotSupported The Server-side MTM does not support this operation |
|
377 @leave Other leave codes Dependent on implementation */ |
|
378 virtual void MoveWithinServiceL(const CMsvEntrySelection& aSelection,TMsvId aDestination, TRequestStatus& aStatus)=0; |
|
379 |
|
380 IMPORT_C TInt SystemProgress(TMsvSystemProgress& aOutSysProg); |
|
381 #if (defined SYMBIAN_USER_PROMPT_SERVICE) |
|
382 TInt ClientThreadInfo(TThreadId aClientInfo, TBool aCapabilityCheck); |
|
383 #endif |
|
384 |
|
385 TInt GetNonOperationMtmData(TNonOperationMtmDataType& aMtmDataType, TPtrC8& aResultBuffer); |
|
386 |
|
387 protected: |
|
388 IMPORT_C CBaseServerMtm(CRegisteredMtmDll& aRegisteredMtmDll, CMsvServerEntry* aServerEntry); |
|
389 /** Handles the completion of any asynchronous requests that it makes. It is called |
|
390 from the base class RunL() . |
|
391 |
|
392 Note that any leaves made by this function result in DoComplete() being called |
|
393 with the leave code. */ |
|
394 virtual void DoRunL()=0; |
|
395 /** Called by the base class RunL() if DoRunL() leaves. |
|
396 |
|
397 It should be implemented to handle this error. For example, progress information |
|
398 could be updated to reflect the problem. |
|
399 |
|
400 @param aError The leave code given by DoRunL(). */ |
|
401 virtual void DoComplete(TInt aError)=0; |
|
402 // |
|
403 IMPORT_C TInt Extension_(TUint aExtensionId, TAny *&a0, TAny *a1); |
|
404 // |
|
405 private: |
|
406 // from CActive |
|
407 IMPORT_C void RunL(); |
|
408 IMPORT_C TInt RunError(TInt aError); |
|
409 // |
|
410 protected: |
|
411 /** The entry on which to operate. It is set in the constructor. |
|
412 |
|
413 The destructor deletes this member. */ |
|
414 CMsvServerEntry* iServerEntry; |
|
415 |
|
416 // Method used for extension: called by non virtual methods that need |
|
417 // to have a polymorphic behaviour. |
|
418 IMPORT_C virtual TAny* GetInterface(TUid aUid); |
|
419 // |
|
420 private: |
|
421 CRegisteredMtmDll& iRegisteredMtmDll; |
|
422 |
|
423 private: |
|
424 // Extra data member to allow for future extensions |
|
425 TAny* iExtensionData; |
|
426 }; |
|
427 |
|
428 |
|
429 class CServerMtmDllRegistry : public CMtmDllRegistry |
|
430 /** |
|
431 @publishedAll |
|
432 @released |
|
433 */ |
|
434 { |
|
435 friend class CMtmRegistryControl; |
|
436 public: |
|
437 IMPORT_C static CServerMtmDllRegistry* NewL(RFs& aFs,TTimeIntervalMicroSeconds32 aTimeoutMicroSeconds32=KMsvDefaultTimeoutMicroSeconds32); |
|
438 IMPORT_C ~CServerMtmDllRegistry(); |
|
439 IMPORT_C CBaseServerMtm* NewServerMtmL(TUid aMtmTypeUid, CMsvServerEntry* aInitialEntry); |
|
440 // |
|
441 protected: |
|
442 CServerMtmDllRegistry(RFs& aFs,TTimeIntervalMicroSeconds32 aTimeoutMicroSeconds32); |
|
443 // |
|
444 private: |
|
445 CBaseServerMtm* NewMtmL(const RLibrary& aLib, CMsvServerEntry* aServerEntry, CRegisteredMtmDll& aReg) const; |
|
446 }; |
|
447 |
|
448 //********************************** |
|
449 // CMsvMtmCache |
|
450 //********************************** |
|
451 |
|
452 |
|
453 //********************************** |
|
454 // CMtmRegistryControl |
|
455 //********************************** |
|
456 |
|
457 class CMtmRegistryControl : public CBase, public MRegisteredMtmDllObserver |
|
458 /** |
|
459 @publishedAll |
|
460 @released |
|
461 */ |
|
462 { |
|
463 public: |
|
464 IMPORT_C static CMtmRegistryControl* NewL(RFs& anFs,CServerMtmDllRegistry& aServerMtmDllRegistry); |
|
465 IMPORT_C ~CMtmRegistryControl(); |
|
466 |
|
467 IMPORT_C TInt InstallMtmGroup(const TDesC& aFullName,TUid& aMtmTypeUid); |
|
468 IMPORT_C TInt FullNameToMtmTypeUid(const TDesC& aFullName,TUid& aMtmTypeUid) const; |
|
469 IMPORT_C TInt DeInstallMtmGroup(TUid aMtmTypeUid); // returns error on storing registry |
|
470 |
|
471 IMPORT_C TInt UseMtmGroup(TUid aMtmTypeUid); |
|
472 IMPORT_C TInt ReleaseMtmGroup(TUid aMtmTypeUid); |
|
473 IMPORT_C TBool IsInUse(TUid aMtmTypeUid) const; |
|
474 |
|
475 IMPORT_C TInt FillRegisteredMtmDllArray(TUid aMtmDllTypeUid,CRegisteredMtmDllArray& aRegisteredMtmDllArray,TTimeIntervalMicroSeconds32 aTimeoutMicroSeconds32=0); // Fill array with Dlls whose second uid is aMtmDllTypeUid |
|
476 IMPORT_C CMtmGroupData* GetMtmGroupDataL(TUid aMtmTypeUid) const; |
|
477 const CMtmGroupData& GetMtmGroupDataReferenceL(TUid aMtmTypeUid) const; |
|
478 |
|
479 IMPORT_C void StoreRegistryL() const; |
|
480 IMPORT_C void RestoreRegistryL(); |
|
481 |
|
482 IMPORT_C void InternalizeL(RReadStream& aStream); |
|
483 IMPORT_C void ExternalizeL(RWriteStream& aStream) const; |
|
484 |
|
485 private: |
|
486 CMtmRegistryControl(RFs& anFs,CServerMtmDllRegistry& aServerMtmDllRegistry); |
|
487 void ConstructL(); |
|
488 TInt MtmTypeUidToIndex(TUid aMtmTypeUid) const; |
|
489 TInt UidTypeToIndex(TUidType aUidType) const; |
|
490 void DoInstallMtmGroupL(const TDesC& aFullName,TUid& aMtmTypeUid); |
|
491 CMtmGroupData* ReadDataFileStoreL(const TDesC& aFullName) const; |
|
492 void DoDeInstallMtmGroupL(TUid aMtmTypeUid); |
|
493 void DoInternalizeL(RReadStream& aStream); |
|
494 void AddInstalledMtmGroupL(CInstalledMtmGroup* aInstalledMtmGroup); |
|
495 void RemoveInstalledMtmGroup(TUid aMtmTypeUid); |
|
496 TBool IsResFileL(const TDesC& aFullName) const; |
|
497 TUid DoFindMtmTypeUidL(const TDesC& aFullName) const; |
|
498 |
|
499 CMtmGroupData *LoadMTMFileL(const TDesC& aFullName, TUid &aUid); |
|
500 CMtmGroupData *LoadDatFileL(const TDesC& aFullName, TUid &aUid); |
|
501 CMtmGroupData *LoadResFileL(const TDesC& aFullName, TUid &aUid); |
|
502 private: |
|
503 RFs& iFs; |
|
504 CInstalledMtmGroupArray* iInstalledMtmGroupArray; |
|
505 CServerMtmDllRegistry& iServerMtmDllRegistry; |
|
506 TPath iPathName; |
|
507 }; |
|
508 |
|
509 #endif // __MTSR_H__ |