|
1 /* |
|
2 * Copyright (c) 2005-2006 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: stores update package to filesystem |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 // INCLUDE FILES |
|
21 #include <ecom.h> |
|
22 #include <implementationproxy.h> |
|
23 #include <centralrepository.h> |
|
24 #include <sysutil.h> |
|
25 #include "fotadiskstoragePrivateCRKeys.h" |
|
26 #include "fotaDiskStorage.h" |
|
27 #include "fotadebug.h" |
|
28 |
|
29 // CONSTANTS |
|
30 // System Critical Level (128KB) plus 5KB for fota operations. |
|
31 const TInt KSystemCriticalWorkingspace = 136192; |
|
32 |
|
33 // MACROS |
|
34 #ifdef __EABI__ |
|
35 #ifndef IMPLEMENTATION_PROXY_ENTRY |
|
36 typedef TAny* TProxyNewLPtr; |
|
37 #define IMPLEMENTATION_PROXY_ENTRY(aUid, aFuncPtr) {{aUid},(TProxyNewLPtr)(aFuncPtr)} |
|
38 #endif |
|
39 #endif |
|
40 |
|
41 // ============================ MEMBER FUNCTIONS ============================= |
|
42 |
|
43 // --------------------------------------------------------------------------- |
|
44 // CFotaDiskStorage::CFotaDiskStorage() |
|
45 // --------------------------------------------------------------------------- |
|
46 // |
|
47 CFotaDiskStorage::CFotaDiskStorage () |
|
48 { |
|
49 } |
|
50 |
|
51 // --------------------------------------------------------------------------- |
|
52 // CFotaDiskStorage::NewL() |
|
53 // --------------------------------------------------------------------------- |
|
54 // |
|
55 CFotaDiskStorage* CFotaDiskStorage::NewL() |
|
56 { |
|
57 FLOG(_L("CFotaDiskStorage::NewL()")); |
|
58 CFotaDiskStorage* self = new ( ELeave ) CFotaDiskStorage; |
|
59 FLOG(_L(" CFotaDiskStorage created at %X "), self); |
|
60 CleanupStack::PushL( self ); |
|
61 self->ConstructL(); |
|
62 CleanupStack::Pop( self ); |
|
63 return self; |
|
64 } |
|
65 |
|
66 // --------------------------------------------------------------------------- |
|
67 // CFotaDiskStorage::ConstructL() |
|
68 // --------------------------------------------------------------------------- |
|
69 // |
|
70 void CFotaDiskStorage::ConstructL() |
|
71 { |
|
72 FLOG(_L("CFotaDiskStorage::ConstructL() >>")); |
|
73 TInt err; |
|
74 User::LeaveIfError ( iFs.Connect() ); |
|
75 |
|
76 // Ensures that fotaserver private dir exists |
|
77 err = iFs.MkDirAll(KDummyFilePath); |
|
78 if ( err!=KErrAlreadyExists && err != KErrNone ) |
|
79 { |
|
80 FLOG(_L(" created priv dir err %d"),err); |
|
81 User::Leave ( err ) ; |
|
82 } |
|
83 FLOG(_L("CFotaDiskStorage::ConstructL() sessionpath to %S") |
|
84 , &KDummyFilePath,err); |
|
85 User::LeaveIfError ( iFs.SetSessionPath ( KDummyFilePath ) ); |
|
86 |
|
87 // newdummy remains should not exist now. safety. |
|
88 err = iFs.Delete ( _L("newdummy") ) ; |
|
89 if ( err!=KErrNone && err!= KErrNotFound ) User::Leave (err); |
|
90 |
|
91 // Get write limit |
|
92 TInt writelimit( KFileReservationDefaultSize ); |
|
93 TInt chunksize ( iChunkSize ); |
|
94 CRepository* centrep( NULL); |
|
95 TRAP(err, centrep = CRepository::NewL( KCRUidFotaDiskStorage ) ); |
|
96 if ( centrep ) |
|
97 { |
|
98 err = centrep->Get( KFotaDiskSpaceReservationKey, writelimit ); |
|
99 err = centrep->Get( KFotaDiskSpaceReservationChunkKey, chunksize ); |
|
100 } |
|
101 iDummySize = writelimit; |
|
102 iChunkSize = chunksize; |
|
103 delete centrep; |
|
104 |
|
105 AdjustDummyStorageL(); |
|
106 FLOG(_L("CFotaDiskStorage::ConstructL() <<")); |
|
107 } |
|
108 |
|
109 // --------------------------------------------------------------------------- |
|
110 // CFotaDiskStorage::~CFotaDiskStorage () |
|
111 // --------------------------------------------------------------------------- |
|
112 // |
|
113 CFotaDiskStorage::~CFotaDiskStorage () |
|
114 { |
|
115 FLOG(_L("CFotaDiskStorage::~CFotaDiskStorage ()")); |
|
116 iFileWriteStream.Close(); |
|
117 iFs.Close(); |
|
118 } |
|
119 |
|
120 |
|
121 // --------------------------------------------------------------------------- |
|
122 // CFotaDiskStorage::IsPackageStoreSizeAvailableL |
|
123 // does the pkg fit to reservation or filesystem |
|
124 // --------------------------------------------------------------------------- |
|
125 // |
|
126 CFotaStorage::TFreeSpace CFotaDiskStorage::IsPackageStoreSizeAvailableL(TInt& aSize) |
|
127 { |
|
128 CFotaStorage::TFreeSpace isavailable; |
|
129 TInt swupdSize(0); |
|
130 TInt dummySize(0); |
|
131 SpaceAllocatedBySWUPDFilesL( swupdSize, dummySize); |
|
132 |
|
133 if ( aSize <= dummySize ) |
|
134 { |
|
135 // fits to reservation |
|
136 isavailable = CFotaStorage::EFitsToReservation; |
|
137 } |
|
138 else |
|
139 { |
|
140 // doesnt fit to reservation, does it fit to filesystem? |
|
141 TInt sizeNeededFromFS = aSize - dummySize ; |
|
142 if ( sizeNeededFromFS < 0 ) sizeNeededFromFS = 0; |
|
143 TBool critical = SysUtil::FFSSpaceBelowCriticalLevelL( &iFs, sizeNeededFromFS ); |
|
144 if ( critical ) |
|
145 { |
|
146 // how much space would be needed |
|
147 TVolumeInfo vi; |
|
148 iFs.Volume(vi,EDriveC); |
|
149 |
|
150 TInt neededspace = sizeNeededFromFS - vi.iFree + KSystemCriticalWorkingspace; |
|
151 FLOG(_L("neededspace = %d vi.iFree = %d "), neededspace , vi.iFree); |
|
152 FLOG(_L(" neededspace = sizeNeededFromFS - vi.iFree + KSystemCriticalWorkingspace;") ); |
|
153 //= aSize - vi.iFree; |
|
154 aSize = neededspace; |
|
155 isavailable = CFotaStorage::EDoesntFitToFileSystem; |
|
156 } |
|
157 else |
|
158 { |
|
159 isavailable = CFotaStorage::EFitsToFileSystem; |
|
160 } |
|
161 } |
|
162 FLOG(_L("CFotaDiskStorage::IsPackageStoreSizeAvailableL %d<%d (sz vs dummy) => fitstodummy:%d fitstoFS:%d DoesntFitToFS:%d") |
|
163 ,aSize,dummySize,isavailable==CFotaStorage::EFitsToReservation?1:0,isavailable==CFotaStorage::EFitsToFileSystem?1:0,isavailable==CFotaStorage::EDoesntFitToFileSystem?1:0 |
|
164 ); |
|
165 |
|
166 return isavailable; |
|
167 } |
|
168 |
|
169 |
|
170 // --------------------------------------------------------------------------- |
|
171 // CFotaDiskStorage::AdjustDummyStorageL() |
|
172 // Ensure that total of iDummySize bytes are reserved by .swupd files and |
|
173 // dummy file. |
|
174 // --------------------------------------------------------------------------- |
|
175 // |
|
176 TInt CFotaDiskStorage::AdjustDummyStorageL ( ) |
|
177 { |
|
178 FLOG(_L("CFotaDiskStorage::AdjustDummyStorageL >>")); |
|
179 // Count size reserved by .swupd files |
|
180 // CDir* list; |
|
181 TInt err; |
|
182 TInt swupdSize(0); |
|
183 TInt dummySize(0); |
|
184 RFile dummy; |
|
185 |
|
186 TRAP(err,SpaceAllocatedBySWUPDFilesL( swupdSize, dummySize)); |
|
187 |
|
188 // Calculate space for dummy file |
|
189 TInt targetsize = iDummySize - swupdSize; |
|
190 if ( targetsize<0 ) |
|
191 { |
|
192 targetsize=0; |
|
193 } |
|
194 |
|
195 // Reduce dummy file size |
|
196 if ( dummySize != targetsize || dummySize ==0 ) |
|
197 { |
|
198 FLOG(_L(" dummy new size %d (old %d)"), targetsize,dummySize); |
|
199 |
|
200 err = dummy.Open(iFs, KDummyFileName, EFileWrite|EFileShareExclusive); |
|
201 |
|
202 if (err == KErrNotFound ) |
|
203 { |
|
204 User::LeaveIfError(dummy.Replace(iFs, KDummyFileName |
|
205 , EFileWrite|EFileShareExclusive)); |
|
206 } |
|
207 else |
|
208 if ( err!=KErrNone) User::LeaveIfError (err); |
|
209 |
|
210 CleanupClosePushL(dummy); |
|
211 TInt err= dummy.SetSize (targetsize); |
|
212 if (err!=KErrNone) |
|
213 { |
|
214 FLOG(_L("Error while creating reserved space: %d "),err ); |
|
215 } |
|
216 CleanupStack::PopAndDestroy(1); // dummy |
|
217 } |
|
218 FLOG(_L("CFotaDiskStorage::AdjustDummyStorageL, reserved file size = %d <<"),targetsize); |
|
219 return 0; |
|
220 } |
|
221 |
|
222 // --------------------------------------------------------------------------- |
|
223 // CFotaDiskStorage::OpenUpdatePackageStore |
|
224 // Open upd pkg store for writing (writes to dummy file). |
|
225 // --------------------------------------------------------------------------- |
|
226 TInt CFotaDiskStorage::OpenUpdatePackageStoreL(const TInt aPkgId,TInt aNewDummySize |
|
227 , RWriteStream*& aPkgStore) |
|
228 { |
|
229 FLOG(_L("CFotaDiskStorage::OpenUpdatePackageStore")); |
|
230 TInt err (KErrNone); |
|
231 |
|
232 // Remove reserved memory |
|
233 RFile tmp; |
|
234 err = tmp.Open(iFs, KDummyFileName, EFileWrite|EFileShareExclusive); |
|
235 CleanupClosePushL(tmp); |
|
236 if ( !err ) |
|
237 { |
|
238 FLOG(_L("Removing the reserved memory as download has started"), iDummySize); |
|
239 tmp.SetSize( KErrNone ); |
|
240 } |
|
241 CleanupStack::PopAndDestroy( &tmp ); |
|
242 // flexible mem handling: increase dummy size to receive over sized package |
|
243 if (iDummySize < aNewDummySize) |
|
244 iDummySize = aNewDummySize; |
|
245 FLOG(_L("Newer dummy size = %d"),iDummySize); |
|
246 |
|
247 TBuf<KMaxFileName> swupd; |
|
248 |
|
249 swupd.AppendNum(aPkgId); |
|
250 swupd.Append(_L(".swupd")); |
|
251 err = iFileWriteStream.Open(iFs, swupd, EFileWrite) ; |
|
252 if (err == KErrNotFound ) |
|
253 { |
|
254 User::LeaveIfError(iFileWriteStream.Replace(iFs, swupd |
|
255 , EFileWrite)); |
|
256 } |
|
257 else |
|
258 if ( err!=KErrNone) User::LeaveIfError (err); |
|
259 |
|
260 //Positioning the seek if the file is already present (in case of resume) |
|
261 TEntry entry; |
|
262 TInt size (KErrNone); |
|
263 err = iFs.Entry(swupd,entry); |
|
264 if (!err) |
|
265 size = entry.iSize; |
|
266 if (size) |
|
267 { |
|
268 MStreamBuf* x = iFileWriteStream.Sink(); |
|
269 TStreamPos pos(0); |
|
270 TRAPD(err2, pos = x->TellL(MStreamBuf::EWrite)); |
|
271 |
|
272 pos+=size; |
|
273 TRAP(err2, x->SeekL(MStreamBuf::EWrite,pos )); |
|
274 } |
|
275 aPkgStore = &iFileWriteStream; |
|
276 return err; |
|
277 } |
|
278 |
|
279 // --------------------------------------------------------------------------- |
|
280 // CFotaDiskStorage::GetDownloadedUpdatePackageSizeL |
|
281 // Gets the downloaded update package size in bytes |
|
282 // --------------------------------------------------------------------------- |
|
283 |
|
284 void CFotaDiskStorage::GetDownloadedUpdatePackageSizeL(const TInt aPkgId, TInt& aSize) |
|
285 { |
|
286 FLOG(_L("CFotaDiskStorage::GetDownloadedUpdatePackageSizeL >>")); |
|
287 aSize = 0; |
|
288 |
|
289 TBuf<KMaxFileName> swupd; |
|
290 |
|
291 swupd.AppendNum(aPkgId); |
|
292 swupd.Append(_L(".swupd")); |
|
293 |
|
294 TInt err(KErrNone); |
|
295 TEntry entry; |
|
296 err = iFs.Entry(swupd,entry); |
|
297 if (!err) |
|
298 aSize = entry.iSize; |
|
299 FLOG(_L("CFotaDiskStorage::GetDownloadedUpdatePackageSizeL,err = %d, aSize = %d <<"),err, aSize); |
|
300 } |
|
301 |
|
302 |
|
303 // --------------------------------------------------------------------------- |
|
304 // CFotaDiskStorage::UpdatePackageDownloadComplete |
|
305 // closes the stream and frees resources |
|
306 // --------------------------------------------------------------------------- |
|
307 void CFotaDiskStorage::UpdatePackageDownloadCompleteL(const TInt aPkgId) |
|
308 { |
|
309 FLOG(_L("CFotaDiskStorage::UpdatePackageDownloadComplete(const TInt aPkgId)")); |
|
310 RFile fswupd; |
|
311 TBuf<KMaxFileName> fn; |
|
312 TInt err; |
|
313 iFileWriteStream.Close(); |
|
314 if(iBytesWritten<1) |
|
315 { |
|
316 FLOG(_L(" no bytes received!")); |
|
317 // User::Leave(KErrNotFound); |
|
318 return; |
|
319 } |
|
320 TBuf<KMaxFileName> swupd; |
|
321 |
|
322 swupd.AppendNum(aPkgId); |
|
323 swupd.Append(_L(".swupd")); |
|
324 |
|
325 // open swupd file for reading |
|
326 err = fswupd.Open(iFs, swupd, EFileWrite|EFileShareExclusive); |
|
327 FLOG(_L(" open err %d"),err); |
|
328 if (err == KErrNotFound ) |
|
329 { |
|
330 FLOG(_L("swupd not found, creaeting")); |
|
331 User::LeaveIfError(fswupd.Replace(iFs, swupd |
|
332 ,EFileWrite|EFileShareExclusive)); |
|
333 } |
|
334 else |
|
335 if ( err!=KErrNone) User::LeaveIfError (err); |
|
336 CleanupClosePushL(fswupd); |
|
337 |
|
338 RFile ND; |
|
339 User::LeaveIfError ( ND.Replace ( iFs, KDummyFileName, EFileWrite ) ); |
|
340 CleanupClosePushL ( ND); |
|
341 CleanupStack::PopAndDestroy(2); // dummies |
|
342 AdjustDummyStorageL(); |
|
343 } |
|
344 |
|
345 // --------------------------------------------------------------------------- |
|
346 // CFotaDiskStorage::GetUpdatePackageLocation |
|
347 // Gets update package location, that is , path. |
|
348 // --------------------------------------------------------------------------- |
|
349 void CFotaDiskStorage::GetUpdatePackageLocationL(const TInt aPkgId |
|
350 , TDes8& aPath ) |
|
351 { |
|
352 TBuf8<20> fn; |
|
353 fn.AppendNum(aPkgId); |
|
354 fn.Append(_L8(".swupd")); |
|
355 TInt pathlength = ((TDesC16)KDummyFilePath).Length(); |
|
356 HBufC8* path = HBufC8::NewLC( pathlength ); |
|
357 path->Des().Copy( KDummyFilePath ); |
|
358 |
|
359 aPath.Append( path->Des() ); |
|
360 aPath.Append(fn); |
|
361 CleanupStack::PopAndDestroy( path ); |
|
362 } |
|
363 |
|
364 // --------------------------------------------------------------------------- |
|
365 // CFotaDiskStorage::GetUpdatePackageIds |
|
366 // getupdate package ids |
|
367 // --------------------------------------------------------------------------- |
|
368 void CFotaDiskStorage::GetUpdatePackageIdsL(TDes16& aPackageIdList) |
|
369 { |
|
370 FLOG(_L("CFotaDiskStorage::GetUpdatePackageIds")); |
|
371 // Read all .swupd files and parse pkg ids from filenames |
|
372 TInt err; |
|
373 CDir* list; |
|
374 err=iFs.GetDir (_L("*.swupd"), KEntryAttNormal ,ESortByName, list ); |
|
375 for(int i=0; i<list->Count() ;++i ) |
|
376 { |
|
377 TEntry t = (*list)[i]; |
|
378 TParse p; |
|
379 TInt16 pkgid; |
|
380 p.Set(t.iName,NULL,NULL); |
|
381 TLex lex(p.Name()); |
|
382 err = lex.Val(pkgid); |
|
383 FLOG(_L(" %S"),&t.iName); |
|
384 if(err==KErrNone) |
|
385 { |
|
386 TPtrC filename(p.Name()); |
|
387 FLOG(_L(" pkig found: %d"), pkgid); |
|
388 TDateTime d = t.iModified.DateTime(); |
|
389 aPackageIdList.Append (pkgid); |
|
390 } |
|
391 } |
|
392 delete list; |
|
393 } |
|
394 |
|
395 // --------------------------------------------------------------------------- |
|
396 // CFotaDiskStorage::DeleteUpdatePackageL |
|
397 // --------------------------------------------------------------------------- |
|
398 void CFotaDiskStorage::DeleteUpdatePackageL (const TInt aPkgId) |
|
399 { |
|
400 FLOG(_L("CFotaDiskStorage::DeleteUpdatePackageL %d >>"),aPkgId); |
|
401 RFile dummy; |
|
402 TInt err= dummy.Open(iFs, KDummyFileName , EFileWrite|EFileShareExclusive); |
|
403 FLOG(_L("Error opening the reserved file...%d"),err); |
|
404 CleanupClosePushL ( dummy ); |
|
405 TRAP(err, DoDeleteUpdatePackageL ( dummy, aPkgId, 0 )); |
|
406 CleanupStack::PopAndDestroy(1); |
|
407 AdjustDummyStorageL(); |
|
408 |
|
409 FLOG(_L("CFotaDiskStorage::DeleteUpdatePackageL %d, err = %d <<"),aPkgId, err); |
|
410 } |
|
411 |
|
412 // --------------------------------------------------------------------------- |
|
413 // CFotaDiskStorage::DoDeleteUpdatePackageL |
|
414 // Delete swupd by chunking data to dummy (param) file. Will grow dummy |
|
415 // independently, but takes already allocated bytes into account. |
|
416 // --------------------------------------------------------------------------- |
|
417 void CFotaDiskStorage::DoDeleteUpdatePackageL ( RFile& dummy, TInt aPkgId |
|
418 , TInt aAlreadyAllocated) |
|
419 { |
|
420 // Open swupd file |
|
421 TInt err; |
|
422 TBuf8<KMaxFileName> swupdpath; |
|
423 TBuf<KMaxFileName> swupdpath16; |
|
424 GetUpdatePackageLocationL ( aPkgId, swupdpath) ; |
|
425 swupdpath16.Copy ( swupdpath ); |
|
426 RFile swupd; |
|
427 err = swupd.Open( iFs, swupdpath16, EFileWrite ); |
|
428 if ( err == KErrNotFound ) return; // no need to delete |
|
429 if ( err != KErrNone ) User::Leave ( err ); |
|
430 CleanupClosePushL ( swupd ); |
|
431 |
|
432 // Reduce dummy size |
|
433 TInt dummytargetsize = iDummySize - aAlreadyAllocated; |
|
434 for ( TInt p=0; p<10000 ; ++p ) |
|
435 { |
|
436 TInt dsize; |
|
437 TInt swupdsize(0); |
|
438 User::LeaveIfError( dummy.Size( dsize ) ); |
|
439 User::LeaveIfError( swupd.Size( swupdsize) ); |
|
440 TInt chunk = swupdsize > iChunkSize ? iChunkSize : swupdsize; |
|
441 |
|
442 // Ensure that dummy dosnt get oversized |
|
443 if ( dsize <= dummytargetsize && dsize + chunk >= dummytargetsize ) |
|
444 chunk = dummytargetsize - dsize; |
|
445 |
|
446 // Safety |
|
447 if ( dsize >= dummytargetsize ) break; |
|
448 |
|
449 FLOG(_L(" deleting swupd: dummy %d\t swupd %d\t chunk%d"),dsize |
|
450 ,swupdsize,chunk); |
|
451 if (chunk>0) |
|
452 { |
|
453 User::LeaveIfError( dummy.SetSize( dsize + chunk ) ); |
|
454 User::LeaveIfError( swupd.SetSize( swupdsize - chunk ) ); |
|
455 } |
|
456 else |
|
457 break; |
|
458 } |
|
459 CleanupStack::PopAndDestroy(1); // swupd |
|
460 |
|
461 // Delete swupd (dummy file is big enough now) |
|
462 err = iFs.Delete ( swupdpath16 ) ; |
|
463 FLOG(_L("CFotaDiskStorage::DoDeleteUpdatePackageL deleted ,err %d"),err); |
|
464 if ( err != KErrNone && err != KErrNotFound ) |
|
465 { |
|
466 User::Leave ( err ); |
|
467 } |
|
468 } |
|
469 |
|
470 // --------------------------------------------------------------------------- |
|
471 // CFotaDiskStorage::SpaceAllocatedBySWUPDFilesL |
|
472 // Counts space allocated by swupd files |
|
473 // --------------------------------------------------------------------------- |
|
474 void CFotaDiskStorage::SpaceAllocatedBySWUPDFilesL( TInt& aSwupdSize, TInt& aDummySize ) |
|
475 { |
|
476 CDir* list; |
|
477 TInt err; |
|
478 // TInt (0); |
|
479 aSwupdSize = 0; |
|
480 aDummySize = 0; |
|
481 err = iFs.GetDir (_L("*.swupd"), KEntryAttNormal ,ESortByName, list ); |
|
482 User::LeaveIfError(err); |
|
483 CleanupStack::PushL ( list ); |
|
484 |
|
485 // get sizes of swupd files |
|
486 for(int i=0; i<list->Count() ;++i ) |
|
487 { |
|
488 TEntry t = (*list)[i]; |
|
489 TParse p; |
|
490 TInt16 pkgid; |
|
491 |
|
492 p.Set(t.iName,NULL,NULL); |
|
493 TLex lex(p.Name()); |
|
494 err = lex.Val(pkgid); |
|
495 if(err==KErrNone) |
|
496 { |
|
497 TPtrC filename(p.Name()); |
|
498 aSwupdSize += t.iSize; |
|
499 } |
|
500 } |
|
501 CleanupStack::PopAndDestroy( list ); |
|
502 |
|
503 // get size of dummyfile |
|
504 err = iFs.GetDir (KDummyFileName, KEntryAttNormal ,ESortByName, list ); |
|
505 User::LeaveIfError(err); |
|
506 CleanupStack::PushL ( list ); |
|
507 if ( list->Count() >0 ) |
|
508 { |
|
509 TEntry t = (*list)[0]; |
|
510 aDummySize = t.iSize; |
|
511 } |
|
512 CleanupStack::PopAndDestroy( list ); |
|
513 FLOG(_L("CFotaDiskStorage::SpaceAllocatedBySWUPDFilesL dummy:%d swupd:%d") |
|
514 ,aDummySize,aSwupdSize); |
|
515 } |
|
516 |
|
517 // --------------------------------------------------------------------------- |
|
518 // Global implementation uid array |
|
519 // Define the Implementation UIDs for JP2K decoder. |
|
520 // (other items were commented in a header). |
|
521 // --------------------------------------------------------------------------- |
|
522 // |
|
523 const TImplementationProxy ImplementationTable[] = |
|
524 { |
|
525 // implementation_uid |
|
526 IMPLEMENTATION_PROXY_ENTRY( 0x10207385 , CFotaDiskStorage::NewL ) |
|
527 }; |
|
528 |
|
529 // ========================== OTHER EXPORTED FUNCTIONS ========================= |
|
530 |
|
531 // --------------------------------------------------------------------------- |
|
532 // ImplementationGroupProxy Implements proxy interface for ECom |
|
533 // Exported proxy for instantiation method resolution. |
|
534 // --------------------------------------------------------------------------- |
|
535 // |
|
536 EXPORT_C const TImplementationProxy* ImplementationGroupProxy( //lint !e714 Used by ECom |
|
537 TInt& aTableCount ) // Number of tables |
|
538 { |
|
539 aTableCount = sizeof( ImplementationTable ) / sizeof( |
|
540 TImplementationProxy ); |
|
541 return ImplementationTable; |
|
542 } |