177 iDatabases.AppendL( dB ); |
170 iDatabases.AppendL( dB ); |
178 CleanupStack::Pop( dB ); |
171 CleanupStack::Pop( dB ); |
179 } |
172 } |
180 else |
173 else |
181 { |
174 { |
|
175 MPX_DEBUG2("CMPXHarvesterDatabaseManager::OpenAllDatabasesL: opening failed, error=%d, removing database", openError); |
182 CleanupStack::PopAndDestroy( dB ); |
176 CleanupStack::PopAndDestroy( dB ); |
183 } |
177 } |
184 } |
178 } |
185 else if( check == KErrNone ) |
179 else |
186 { |
180 { |
187 TRAPD(openError, GetDatabaseL(static_cast<TDriveNumber>(driveNum)).OpenL() ); |
181 CMPXHarvesterDB* dB = iDatabases[index]; |
|
182 TRAPD(openError, rtn |= dB->OpenL() ); //lint !e665 |
188 if(openError != KErrNone) |
183 if(openError != KErrNone) |
189 { |
184 { |
190 TRAP_IGNORE( RemoveDatabaseL(static_cast<TDriveNumber>(driveNum))); |
185 MPX_DEBUG2("CMPXHarvesterDatabaseManager::OpenAllDatabasesL: opening failed, error=%d, removing database", openError); |
|
186 iDatabases.Remove ( index ); |
|
187 delete dB; |
191 } |
188 } |
192 } |
189 } |
193 } |
190 } |
194 } |
191 } |
195 #else |
|
196 TInt check(KErrNone); |
|
197 TRAP( check, GetDatabaseL(EDriveC) ); |
|
198 if( check == KErrNotFound ) |
|
199 { |
|
200 CMPXHarvesterDB* dB = CMPXHarvesterDB::NewL( EDriveC, iFs ); |
|
201 CleanupStack::PushL( dB ); |
|
202 iDatabases.AppendL( dB ); |
|
203 CleanupStack::Pop( dB ); |
|
204 TRAP_IGNORE( rtn = dB->OpenL() ); //lint !e665 |
|
205 } |
|
206 else if( check == KErrNone ) |
|
207 { |
|
208 TRAPD(openError, GetDatabaseL(EDriveC).OpenL() ); |
|
209 if(openError != KErrNone) |
|
210 { |
|
211 TRAP_IGNORE( RemoveDatabaseL(EDriveC)); |
|
212 } |
|
213 } |
|
214 TRAP( check, GetDatabaseL(EDriveE) ); //lint !e961 |
|
215 if( check == KErrNotFound ) |
|
216 { |
|
217 CMPXHarvesterDB* dB = CMPXHarvesterDB::NewL( EDriveE, iFs ); |
|
218 CleanupStack::PushL( dB ); |
|
219 TRAPD(openError, rtn |= dB->OpenL() ); //lint !e665 |
|
220 if(openError == KErrNone) |
|
221 { |
|
222 iDatabases.AppendL( dB ); |
|
223 CleanupStack::Pop( dB ); |
|
224 } |
|
225 else |
|
226 { |
|
227 CleanupStack::PopAndDestroy( dB ); |
|
228 } |
|
229 } |
|
230 else if( check == KErrNone ) |
|
231 { |
|
232 TRAPD(openError,GetDatabaseL(EDriveE).OpenL() ); |
|
233 if(openError != KErrNone) |
|
234 { |
|
235 TRAP_IGNORE( RemoveDatabaseL(EDriveE)); |
|
236 } |
|
237 } |
|
238 #endif // RD_MULTIPLE_DRIVE |
|
239 |
|
240 MPX_DEBUG1("CMPXHarvesterDatabaseManager::OpenAllDatabasesL --->"); //lint !e961 |
192 MPX_DEBUG1("CMPXHarvesterDatabaseManager::OpenAllDatabasesL --->"); //lint !e961 |
241 return rtn; |
193 return rtn; |
242 } |
194 } |
243 |
195 |
244 // --------------------------------------------------------------------------- |
196 // --------------------------------------------------------------------------- |
245 // CMPXHarvesterDatabaseManager::OpenDatabaseL |
197 // CMPXHarvesterDatabaseManager::OpenDatabaseL |
246 // --------------------------------------------------------------------------- |
198 // --------------------------------------------------------------------------- |
247 // |
199 // |
248 void CMPXHarvesterDatabaseManager::OpenDatabaseL( TDriveNumber aDrive ) |
200 void CMPXHarvesterDatabaseManager::OpenDatabaseL( TDriveNumber aDrive ) |
249 { |
201 { |
250 MPX_DEBUG1("CMPXHarvesterDatabaseManager::OpenDatabaseL <---"); |
202 MPX_DEBUG2("CMPXHarvesterDatabaseManager::OpenDatabaseL %d <---", aDrive); |
251 |
203 |
252 // Re-open a specific database |
204 if ( ! IsLocalDrive( aDrive ) ) |
253 // |
205 { |
254 if (!IsRemoteDrive(aDrive)) |
206 MPX_DEBUG1("CMPXHarvesterDatabaseManager::OpenDatabaseL drive not available -->"); |
255 { |
207 return; |
256 TInt count( iDatabases.Count() ); |
208 } |
257 for( TInt i=0; i<count; ++i ) |
209 |
258 { |
210 CMPXHarvesterDB * db = NULL; |
259 CMPXHarvesterDB* db = (CMPXHarvesterDB*) iDatabases[i]; |
211 TInt index = FindDatabaseIndex ( aDrive ); |
260 if( db->GetDbDrive() == aDrive ) |
212 if ( index == KErrNotFound ) |
261 { |
213 { |
262 db->OpenL(); |
214 db = CMPXHarvesterDB::NewL( aDrive, iFs ); |
263 break; |
215 CleanupStack::PushL( db ); |
264 } |
216 iDatabases.AppendL( db ); |
265 } |
217 CleanupStack::Pop( db ); |
|
218 } |
|
219 else |
|
220 { |
|
221 db = iDatabases[index]; |
|
222 } |
|
223 |
|
224 // TRAPD(openError, rtn |= dB->OpenL() ); //lint !e665 |
|
225 TRAPD( openError, db->OpenL() ); |
|
226 if( openError != KErrNone ) |
|
227 { |
|
228 MPX_DEBUG2("CMPXHarvesterDatabaseManager::OpenAllDatabasesL: opening failed, error=%d", openError); |
|
229 iDatabases.Remove(index); |
|
230 delete db; |
266 } |
231 } |
267 MPX_DEBUG1("CMPXHarvesterDatabaseManager::OpenDatabaseL --->"); |
232 MPX_DEBUG1("CMPXHarvesterDatabaseManager::OpenDatabaseL --->"); |
268 } |
233 } |
269 |
234 |
270 // --------------------------------------------------------------------------- |
235 // --------------------------------------------------------------------------- |
271 // CMPXHarvesterDatabaseManager::CloseAllDatabase |
236 // CMPXHarvesterDatabaseManager::CloseAllDatabases |
272 // --------------------------------------------------------------------------- |
237 // --------------------------------------------------------------------------- |
273 // |
238 // |
274 void CMPXHarvesterDatabaseManager::CloseAllDatabase() |
239 void CMPXHarvesterDatabaseManager::CloseAllDatabases() |
275 { |
240 { |
276 // Close all databases for shutdown |
241 // Close all databases for shutdown |
277 iDatabases.ResetAndDestroy(); |
242 iDatabases.ResetAndDestroy(); |
278 } |
243 } |
279 |
244 |
|
245 |
|
246 // --------------------------------------------------------------------------- |
|
247 // CMPXHarvesterDatabaseManager::CloseMassStorageDatabases |
|
248 // --------------------------------------------------------------------------- |
|
249 // |
|
250 void CMPXHarvesterDatabaseManager::CloseMassStorageDatabases() |
|
251 { |
|
252 MPX_FUNC("CMPXHarvesterDatabaseManager::CloseMassStorageDatabases"); |
|
253 for (TInt i = 0; i < iDatabases.Count();) |
|
254 { |
|
255 CMPXHarvesterDB * db =iDatabases [i]; |
|
256 TDriveNumber drive = db->GetDbDrive(); |
|
257 if ( drive != EDriveC ) |
|
258 { |
|
259 MPX_DEBUG2("CMPXHarvesterDatabaseManager::CloseMassStorageDatabases closing DB on drive %d", drive); |
|
260 db->Close(); |
|
261 #ifdef __RAMDISK_PERF_ENABLE |
|
262 if( iRAMDiskPerfEnabled && db->IsUseRamDrive() ) |
|
263 { |
|
264 MPX_DEBUG1("CMPXHarvesterDatabaseManager::CloseDatabase DB is on RAM"); |
|
265 db->SetRamDriveInfo( iRAMDrive, EFalse ); |
|
266 TInt err = DoCopyDBFromRam (drive); |
|
267 if ( err ) |
|
268 { |
|
269 MPX_DEBUG2("CMPXHarvesterDatabaseManager::CloseDatabase DB copy error=%d", err); |
|
270 RemoveDummyFile( drive ); |
|
271 } |
|
272 } |
|
273 #endif |
|
274 delete db; |
|
275 iDatabases.Remove(i); |
|
276 } |
|
277 else |
|
278 { |
|
279 ++i; |
|
280 } |
|
281 } |
|
282 } |
|
283 |
280 // --------------------------------------------------------------------------- |
284 // --------------------------------------------------------------------------- |
281 // CMPXHarvesterDatabaseManager::CloseDatabase |
285 // CMPXHarvesterDatabaseManager::CloseDatabase |
282 // --------------------------------------------------------------------------- |
286 // --------------------------------------------------------------------------- |
283 // |
287 // |
284 void CMPXHarvesterDatabaseManager::CloseDatabase( TDriveNumber aDrive ) |
288 void CMPXHarvesterDatabaseManager::CloseDatabase( TDriveNumber aDrive ) |
285 { |
289 { |
286 if (!IsRemoteDrive(aDrive)) |
290 MPX_DEBUG2("-->CMPXHarvesterDatabaseManager::CloseDatabase drive %d", aDrive ); |
287 { |
291 TInt index = FindDatabaseIndex( aDrive ); |
288 MPX_DEBUG2("CMPXHarvesterDatabaseManager::CloseDatabase drive %d <---", aDrive ); |
292 if ( index != KErrNotFound ) |
289 TInt count = iDatabases.Count(); |
293 { |
290 for ( TInt i=0; i<count; ++i) |
294 CMPXHarvesterDB * db =iDatabases[index]; |
291 { |
295 db->Close(); |
292 CMPXHarvesterDB* db = (CMPXHarvesterDB*) iDatabases[i]; |
296 #ifdef __RAMDISK_PERF_ENABLE |
293 if ( db->GetDbDrive() == aDrive) |
297 if( iRAMDiskPerfEnabled && db->IsUseRamDrive() ) |
294 { |
298 { |
295 db->Close(); |
299 MPX_DEBUG1("CMPXHarvesterDatabaseManager::CloseDatabase DB is on RAM"); |
296 break; |
300 db->SetRamDriveInfo( iRAMDrive, EFalse ); |
297 } |
301 TInt err = DoCopyDBFromRam(aDrive); |
298 } |
302 if ( err ) |
299 } |
303 { |
300 MPX_DEBUG1("CMPXHarvesterDatabaseManager::CloseDatabase --->"); |
304 MPX_DEBUG2("CMPXHarvesterDatabaseManager::CloseDatabase DB copy error=%d", err); |
301 } |
305 RemoveDummyFile( aDrive ); |
302 |
306 } |
303 // --------------------------------------------------------------------------- |
307 } |
304 // CMPXHarvesterDatabaseManager::GetDatabase |
308 #endif |
305 // --------------------------------------------------------------------------- |
309 delete db; |
306 // |
310 iDatabases.Remove(index); |
307 CMPXHarvesterDB& CMPXHarvesterDatabaseManager::GetDatabaseL( TDriveNumber aDrive ) |
311 } |
308 { |
312 MPX_DEBUG1("<--CMPXHarvesterDatabaseManager::CloseDatabase"); |
309 CMPXHarvesterDB* db( NULL ); |
313 } |
310 |
314 |
311 // Find the database |
315 // --------------------------------------------------------------------------- |
|
316 // CMPXHarvesterDatabaseManager::DropDatabase |
|
317 // --------------------------------------------------------------------------- |
|
318 // |
|
319 void CMPXHarvesterDatabaseManager::DropDatabase( TDriveNumber aDrive ) |
|
320 { |
|
321 MPX_DEBUG2("CMPXHarvesterDatabaseManager::DropDatabase drive %d <---", aDrive ); |
|
322 TInt index = FindDatabaseIndex( aDrive ); |
|
323 if ( index != KErrNotFound ) |
|
324 { |
|
325 CMPXHarvesterDB * db =iDatabases[index]; |
|
326 #ifdef __RAMDISK_PERF_ENABLE |
|
327 if( iRAMDiskPerfEnabled && db->IsUseRamDrive() ) |
|
328 { |
|
329 MPX_DEBUG1("CMPXHarvesterDatabaseManager::DropDatabase DB is on RAM"); |
|
330 db->Close(); |
|
331 // delete db on ram drive. |
|
332 TFileName src = GenerateHarvesterDbName( TDriveUnit(aDrive), ETrue ); |
|
333 BaflUtils::DeleteFile(iFs, src); |
|
334 } |
|
335 #endif |
|
336 delete db; |
|
337 iDatabases.Remove(index); |
|
338 } |
|
339 MPX_DEBUG1("CMPXHarvesterDatabaseManager::DropDatabase --->"); |
|
340 } |
|
341 // --------------------------------------------------------------------------- |
|
342 // CMPXHarvesterDatabaseManager::FindDatabaseIndex |
|
343 // --------------------------------------------------------------------------- |
|
344 // |
|
345 TInt CMPXHarvesterDatabaseManager::FindDatabaseIndex ( TDriveNumber aDrive ) |
|
346 { |
312 TInt count = iDatabases.Count(); |
347 TInt count = iDatabases.Count(); |
313 for( TInt i=0; i<count; ++i ) |
348 for( TInt i=0; i<count; ++i ) |
314 { |
349 { |
315 CMPXHarvesterDB* tmp = (CMPXHarvesterDB*) iDatabases[i]; |
350 CMPXHarvesterDB* db = (CMPXHarvesterDB*) iDatabases[i]; |
316 if( tmp->GetDbDrive() == aDrive ) |
351 if( db->GetDbDrive() == aDrive ) |
317 { |
352 { |
318 db = tmp; |
353 MPX_DEBUG3("CMPXHarvesterDatabaseManager::FindDatabaseIndex drive=%d returns index %d ", aDrive, i); |
319 break; |
354 return i; |
320 } |
355 } |
321 } |
356 } |
322 |
357 MPX_DEBUG2("CMPXHarvesterDatabaseManager::FindDatabaseIndex drive=%d returns KErrNotFound", aDrive); |
323 // Not found, so we leave |
358 return KErrNotFound; |
324 if( db == NULL ) |
359 } |
325 { |
360 |
326 User::Leave( KErrNotFound ); |
361 // --------------------------------------------------------------------------- |
327 } |
362 // CMPXHarvesterDatabaseManager::DataaseIsOpen |
328 return *db; |
363 // --------------------------------------------------------------------------- |
329 } |
364 // |
330 |
365 TBool CMPXHarvesterDatabaseManager::DatabaseIsOpen( TDriveNumber aDrive ) |
331 // --------------------------------------------------------------------------- |
366 { |
332 // CMPXHarvesterDatabaseManager::RemoveDatabase |
367 return FindDatabaseIndex( aDrive ) != KErrNotFound; |
333 // --------------------------------------------------------------------------- |
368 } |
334 // |
369 |
335 void CMPXHarvesterDatabaseManager::RemoveDatabaseL( TDriveNumber aDrive ) |
370 // --------------------------------------------------------------------------- |
336 { |
371 // CMPXHarvesterDatabaseManager::GetDatabase |
337 |
372 // --------------------------------------------------------------------------- |
338 TBool bFound(EFalse); |
373 // |
339 // Find the database |
374 CMPXHarvesterDB& CMPXHarvesterDatabaseManager::GetDatabaseL( TDriveNumber aDrive ) |
340 TInt count = iDatabases.Count(); |
375 { |
341 for(TInt index=0; index<count; ++index ) |
376 TInt index = FindDatabaseIndex( aDrive ); |
342 { |
377 User::LeaveIfError (index); // Not found, so we leave |
343 if((iDatabases[index]!=NULL) && ( iDatabases[index]->GetDbDrive() == aDrive )) |
378 return *iDatabases[index]; |
344 { |
|
345 bFound = ETrue; |
|
346 delete iDatabases[index]; |
|
347 iDatabases.Remove(index); |
|
348 break; |
|
349 } |
|
350 } |
|
351 |
|
352 // Not found, so we leave |
|
353 if( !bFound ) |
|
354 { |
|
355 User::Leave( KErrNotFound ); |
|
356 } |
|
357 } |
379 } |
358 |
380 |
359 // --------------------------------------------------------------------------- |
381 // --------------------------------------------------------------------------- |
360 // CMPXHarvesterDatabaseManager::Count |
382 // CMPXHarvesterDatabaseManager::Count |
361 // --------------------------------------------------------------------------- |
383 // --------------------------------------------------------------------------- |
603 |
649 |
604 // Set the UseRamDrive bool to False. |
650 // Set the UseRamDrive bool to False. |
605 iDatabases[i]->SetRamDriveInfo( iRAMDrive, EFalse ); |
651 iDatabases[i]->SetRamDriveInfo( iRAMDrive, EFalse ); |
606 // Get the db state in order to restore it later. |
652 // Get the db state in order to restore it later. |
607 TDbState dbState = iDatabases[i]->GetDbState(); |
653 TDbState dbState = iDatabases[i]->GetDbState(); |
608 iDatabases[i]->SetDbStateL(EDbClose); |
654 TRAP( err, iDatabases[i]->SetDbStateL(EDbClose) ); |
609 TRAP( err, DoCopyDBFromRamL(drive) ); |
655 if ( err == KErrNone ) |
|
656 { |
|
657 err = DoCopyDBFromRam(drive); |
|
658 } |
|
659 else |
|
660 { |
|
661 // Error closing db on RAM drive, try to delete it. |
|
662 TFileName ramDB; |
|
663 ramDB = GenerateHarvesterDbName( drive, ETrue ); |
|
664 BaflUtils::DeleteFile(iFs, ramDB); |
|
665 } |
|
666 |
610 if ( err ) |
667 if ( err ) |
611 { |
668 { |
612 MPX_DEBUG2("CMPXHarvesterDatabaseManager::CopyDBsFromRamL copy error=%d", err); |
669 MPX_DEBUG2("CMPXHarvesterDatabaseManager::CopyDBsFromRamL copy error=%d", err); |
613 //anyting wrong, delete the temp file. |
670 //anyting wrong, delete the temp file. |
614 RemoveDummyFile(i); |
671 RemoveDummyFile( (TDriveNumber)(TInt)drive ); |
615 } |
672 } |
616 |
673 |
617 // Restore the db state. |
674 // Restore the db state. |
618 iDatabases[i]->SetDbStateL( dbState ); |
675 TRAPD( error, iDatabases[i]->SetDbStateL( dbState ) ); |
619 } |
676 if ( error && !leaveError ) |
620 } |
677 { |
621 } |
678 leaveError = error; |
622 |
679 } |
623 // --------------------------------------------------------------------------- |
680 } |
624 // CMPXHarvesterDatabaseManager::DoCopyDBFromRamL |
681 User::LeaveIfError( leaveError ); |
625 // --------------------------------------------------------------------------- |
682 } |
626 // |
683 } |
627 void CMPXHarvesterDatabaseManager::DoCopyDBFromRamL(TDriveUnit aDriveUnit) |
684 |
628 { |
685 // --------------------------------------------------------------------------- |
629 MPX_FUNC("CMPXHarvesterDatabaseManager::DoCopyDBFromRamL"); |
686 // CMPXHarvesterDatabaseManager::DoCopyDBFromRam |
|
687 // --------------------------------------------------------------------------- |
|
688 // |
|
689 TInt CMPXHarvesterDatabaseManager::DoCopyDBFromRam(TDriveUnit aDriveUnit) |
|
690 { |
|
691 MPX_FUNC("CMPXHarvesterDatabaseManager::DoCopyDBFromRam"); |
630 TFileName dst; |
692 TFileName dst; |
631 TFileName src; |
693 TFileName src; |
632 TInt err = KErrNone; |
694 TInt err = KErrNone; |
633 |
695 |
634 dst = GenerateHarvesterDbName( aDriveUnit ); |
696 dst = GenerateHarvesterDbName( aDriveUnit ); |
635 src = GenerateHarvesterDbName( aDriveUnit, ETrue ); |
697 src = GenerateHarvesterDbName( aDriveUnit, ETrue ); |
636 MPX_DEBUG3("CMPXHarvesterDatabaseManager::DoCopyDBFromRamL from %S to %S", &src, &dst ); |
698 MPX_DEBUG3("CMPXHarvesterDatabaseManager::DoCopyDBFromRam from %S to %S", &src, &dst ); |
637 |
699 |
638 // Rename the temp file into real Db name |
|
639 TFileName dummyDbFileName = GenerateDummyDbName( aDriveUnit ); |
700 TFileName dummyDbFileName = GenerateDummyDbName( aDriveUnit ); |
640 |
701 |
641 //Copy Db from RAM to replace dummy file |
702 //Copy Db from RAM to replace dummy file |
642 err = BaflUtils::CopyFile(iFs, src, dummyDbFileName); |
703 err = BaflUtils::CopyFile(iFs, src, dummyDbFileName); |
643 MPX_DEBUG2("CMPXHarvesterDatabaseManager::DoCopyDBFromRamL database copied from ram drive err=%d.", err); |
704 MPX_DEBUG2("CMPXHarvesterDatabaseManager::DoCopyDBFromRam database copied from ram drive err=%d.", err); |
644 |
705 |
645 // delete db in ram drive. |
706 // delete db on ram drive. |
646 TInt delErr = BaflUtils::DeleteFile(iFs, src); |
707 TInt delErr = BaflUtils::DeleteFile(iFs, src); |
647 MPX_DEBUG3("CMPXHarvesterDatabaseManager::DoCopyDBFromRamL db on ram drive deleted file=%S, err=%d", &src, delErr); |
708 MPX_DEBUG3("CMPXHarvesterDatabaseManager::DoCopyDBFromRam db on ram drive deleted file=%S, err=%d", &src, delErr); |
648 |
709 |
649 // Make sure we del db from ram drive before leaving. |
710 // Make sure we del db from ram drive before returning. |
650 User::LeaveIfError( err ); |
711 if (err != KErrNone) |
651 |
712 { |
652 // Delete existing DB on drive |
713 return err; |
653 delErr = BaflUtils::DeleteFile(iFs, dst); |
714 } |
654 MPX_DEBUG2("CMPXHarvesterDatabaseManager::DoCopyDBFromRamL destination file deleted err=%d", delErr); |
715 |
655 |
716 err = iFs.Replace(dummyDbFileName, dst); |
656 // rename dummy file to real db name |
717 MPX_DEBUG2("CMPXHarvesterDatabaseManager::DoCopyDBFromRam dummy file replaced, err=%d.", err); |
657 User::LeaveIfError( BaflUtils::RenameFile(iFs, dummyDbFileName, dst) ); |
718 return err; |
658 MPX_DEBUG1("CMPXHarvesterDatabaseManager::DoCopyDBFromRamL dummy file renamed."); |
|
659 } |
719 } |
660 |
720 |
661 // --------------------------------------------------------------------------- |
721 // --------------------------------------------------------------------------- |
662 // CMPXHarvesterDatabaseManager::GetRAMDiskPath |
722 // CMPXHarvesterDatabaseManager::GetRAMDiskPath |
663 // --------------------------------------------------------------------------- |
723 // --------------------------------------------------------------------------- |