1 /* |
|
2 * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "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: Thumbnail storage implementation |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 /** |
|
21 * @internal reviewed 31/07/2007 by Simon Brooks |
|
22 */ |
|
23 |
|
24 // INCLUDE FILES |
|
25 |
|
26 #include "glxtndatabase.h" |
|
27 |
|
28 #include <glxassert.h> |
|
29 #include <glxtracer.h> |
|
30 #include <pathinfo.h> |
|
31 |
|
32 #include "glxtnfileinfo.h" |
|
33 #include "glxtnvolumedatabase.h" |
|
34 |
|
35 // ============================ MEMBER FUNCTIONS =============================== |
|
36 |
|
37 // ----------------------------------------------------------------------------- |
|
38 // CGlxtnThumbnailDatabase::CGlxtnThumbnailDatabase |
|
39 // C++ default constructor can NOT contain any code, that might leave. |
|
40 // ----------------------------------------------------------------------------- |
|
41 // |
|
42 CGlxtnThumbnailDatabase::CGlxtnThumbnailDatabase() |
|
43 { |
|
44 TRACER("CGlxtnThumbnailDatabase::CGlxtnThumbnailDatabase()"); |
|
45 iInternalDrive = PathInfo::PhoneMemoryRootPath().Left( KMaxDriveName ); |
|
46 } |
|
47 |
|
48 // ----------------------------------------------------------------------------- |
|
49 // CGlxtnThumbnailDatabase::ConstructL |
|
50 // Symbian 2nd phase constructor can leave. |
|
51 // ----------------------------------------------------------------------------- |
|
52 // |
|
53 void CGlxtnThumbnailDatabase::ConstructL(const TDesC& aDbFilename, |
|
54 MGlxtnThumbnailStorageObserver* aStorageObserver) |
|
55 { |
|
56 TRACER("void CGlxtnThumbnailDatabase::ConstructL()"); |
|
57 User::LeaveIfError(iFs.Connect()); |
|
58 |
|
59 User::LeaveIfError(iFs.PrivatePath(iDatabasePath)); |
|
60 iDatabasePath.Append(aDbFilename); |
|
61 iStorageObserver = aStorageObserver; |
|
62 } |
|
63 |
|
64 // ----------------------------------------------------------------------------- |
|
65 // CGlxtnThumbnailDatabase::NewL |
|
66 // Two-phased constructor. |
|
67 // ----------------------------------------------------------------------------- |
|
68 // |
|
69 EXPORT_C CGlxtnThumbnailDatabase* CGlxtnThumbnailDatabase::NewL( |
|
70 const TDesC& aDbFilename, |
|
71 MGlxtnThumbnailStorageObserver* aStorageObserver) |
|
72 { |
|
73 TRACER("CGlxtnThumbnailDatabase* CGlxtnThumbnailDatabase::NewL()"); |
|
74 CGlxtnThumbnailDatabase* self = new (ELeave) CGlxtnThumbnailDatabase; |
|
75 |
|
76 CleanupStack::PushL(self); |
|
77 self->ConstructL(aDbFilename, aStorageObserver); |
|
78 CleanupStack::Pop( self ); |
|
79 |
|
80 return self; |
|
81 } |
|
82 |
|
83 // ----------------------------------------------------------------------------- |
|
84 // Destructor |
|
85 // ----------------------------------------------------------------------------- |
|
86 // |
|
87 CGlxtnThumbnailDatabase::~CGlxtnThumbnailDatabase() |
|
88 { |
|
89 TRACER("CGlxtnThumbnailDatabase::~CGlxtnThumbnailDatabase()"); |
|
90 iDatabaseArray.ResetAndDestroy(); |
|
91 iFs.Close(); |
|
92 } |
|
93 |
|
94 // ----------------------------------------------------------------------------- |
|
95 // LoadThumbnailDataL |
|
96 // ----------------------------------------------------------------------------- |
|
97 // |
|
98 void CGlxtnThumbnailDatabase::LoadThumbnailDataL(HBufC8*& aData, |
|
99 TGlxImageDataFormat& aFormat, const TGlxMediaId& aId, |
|
100 const CGlxtnFileInfo& aFileInfo, const TSize& aSize, |
|
101 TRequestStatus* aStatus) |
|
102 { |
|
103 TRACER("void CGlxtnThumbnailDatabase::LoadThumbnailDataL()"); |
|
104 if ( iClientStatus ) |
|
105 { |
|
106 User::Leave(KErrNotReady); |
|
107 } |
|
108 |
|
109 iCurrentOperation = ELoading; |
|
110 iLoadData = &aData; |
|
111 iLoadFormat = &aFormat; |
|
112 iMediaId = aId; |
|
113 iFileInfo = &aFileInfo; |
|
114 iSize = aSize; |
|
115 |
|
116 OpenDatabaseL( iInternalDrive )->GetThumbnailIdL( iMediaId ); |
|
117 |
|
118 iClientStatus = aStatus; |
|
119 *iClientStatus = KRequestPending; |
|
120 } |
|
121 |
|
122 // ----------------------------------------------------------------------------- |
|
123 // SaveThumbnailDataL |
|
124 // ----------------------------------------------------------------------------- |
|
125 // |
|
126 void CGlxtnThumbnailDatabase::SaveThumbnailDataL(const TDesC8& aData, |
|
127 TGlxImageDataFormat aFormat, const TGlxMediaId& aId, |
|
128 const CGlxtnFileInfo& aFileInfo, const TSize& aSize, |
|
129 TRequestStatus* aStatus) |
|
130 { |
|
131 TRACER("void CGlxtnThumbnailDatabase::SaveThumbnailDataL()"); |
|
132 if ( iClientStatus ) |
|
133 { |
|
134 User::Leave(KErrNotReady); |
|
135 } |
|
136 |
|
137 iCurrentOperation = ESaving; |
|
138 iSaveData.Set(aData); |
|
139 ASSERT(iSaveData.Length() == aData.Length()); |
|
140 iSaveFormat = aFormat; |
|
141 iMediaId = aId; |
|
142 iFileInfo = &aFileInfo; |
|
143 iSize = aSize; |
|
144 |
|
145 OpenDatabaseL( iInternalDrive )->GetThumbnailIdL( iMediaId ); |
|
146 |
|
147 iClientStatus = aStatus; |
|
148 *iClientStatus = KRequestPending; |
|
149 } |
|
150 |
|
151 // ----------------------------------------------------------------------------- |
|
152 // DeleteThumbnailsL |
|
153 // ----------------------------------------------------------------------------- |
|
154 // |
|
155 void CGlxtnThumbnailDatabase::DeleteThumbnailsL(const TGlxMediaId& aId, |
|
156 const CGlxtnFileInfo& aFileInfo, TRequestStatus* aStatus) |
|
157 { |
|
158 TRACER("void CGlxtnThumbnailDatabase::DeleteThumbnailsL()"); |
|
159 if ( iClientStatus ) |
|
160 { |
|
161 User::Leave(KErrNotReady); |
|
162 } |
|
163 iCurrentOperation = EDeleting; |
|
164 iMediaId = aId; |
|
165 iFileInfo = &aFileInfo; |
|
166 |
|
167 OpenDatabaseL( iInternalDrive )->GetThumbnailIdL( iMediaId ); |
|
168 |
|
169 iClientStatus = aStatus; |
|
170 *iClientStatus = KRequestPending; |
|
171 } |
|
172 |
|
173 // ----------------------------------------------------------------------------- |
|
174 // CleanupThumbnailsL |
|
175 // ----------------------------------------------------------------------------- |
|
176 // |
|
177 void CGlxtnThumbnailDatabase::CleanupThumbnailsL(TRequestStatus* aStatus) |
|
178 { |
|
179 TRACER("void CGlxtnThumbnailDatabase::CleanupThumbnailsL()"); |
|
180 if ( iClientStatus ) |
|
181 { |
|
182 User::Leave(KErrNotReady); |
|
183 } |
|
184 |
|
185 OpenDatabaseL( iInternalDrive ); |
|
186 GLX_ASSERT_ALWAYS( iDatabaseArray.Count() > 0, |
|
187 Panic( EGlxPanicLogicError ), "No databases to clean" ); |
|
188 |
|
189 iDatabaseIndex = 0; |
|
190 iDatabaseArray[iDatabaseIndex]->CleanupDatabaseL(); |
|
191 |
|
192 iClientStatus = aStatus; |
|
193 *iClientStatus = KRequestPending; |
|
194 } |
|
195 |
|
196 // ----------------------------------------------------------------------------- |
|
197 // IsThumbnailAvailableL |
|
198 // ----------------------------------------------------------------------------- |
|
199 // |
|
200 void CGlxtnThumbnailDatabase::IsThumbnailAvailableL(const TGlxMediaId& aId, |
|
201 const CGlxtnFileInfo& aFileInfo, |
|
202 const TSize& aSize, TRequestStatus* aStatus) |
|
203 { |
|
204 TRACER("void CGlxtnThumbnailDatabase::IsThumbnailAvailableL()"); |
|
205 if ( iClientStatus ) |
|
206 { |
|
207 User::Leave(KErrNotReady); |
|
208 } |
|
209 |
|
210 iCurrentOperation = ECheckingAvailable; |
|
211 iMediaId = aId; |
|
212 iFileInfo = &aFileInfo; |
|
213 iSize = aSize; |
|
214 |
|
215 OpenDatabaseL( iInternalDrive )->GetThumbnailIdL( iMediaId ); |
|
216 |
|
217 iClientStatus = aStatus; |
|
218 *iClientStatus = KRequestPending; |
|
219 } |
|
220 |
|
221 // ----------------------------------------------------------------------------- |
|
222 // StorageCancel |
|
223 // ----------------------------------------------------------------------------- |
|
224 // |
|
225 void CGlxtnThumbnailDatabase::StorageCancel() |
|
226 { |
|
227 TRACER("void CGlxtnThumbnailDatabase::StorageCancel()"); |
|
228 TInt count = iDatabaseArray.Count(); |
|
229 for ( TInt i = 0; i < count; i++ ) |
|
230 { |
|
231 iDatabaseArray[i]->Cancel(); |
|
232 } |
|
233 |
|
234 if ( iClientStatus ) |
|
235 { |
|
236 User::RequestComplete(iClientStatus, KErrCancel); |
|
237 } |
|
238 } |
|
239 |
|
240 // ----------------------------------------------------------------------------- |
|
241 // NotifyBackgroundError |
|
242 // ----------------------------------------------------------------------------- |
|
243 // |
|
244 void CGlxtnThumbnailDatabase::NotifyBackgroundError( |
|
245 const TGlxMediaId& aId, TInt aError ) |
|
246 { |
|
247 TRACER("void CGlxtnThumbnailDatabase::NotifyBackgroundError()"); |
|
248 if ( iStorageObserver ) |
|
249 { |
|
250 iStorageObserver->BackgroundThumbnailError(aId, aError); |
|
251 } |
|
252 } |
|
253 |
|
254 // ----------------------------------------------------------------------------- |
|
255 // HandleDatabaseError |
|
256 // ----------------------------------------------------------------------------- |
|
257 // |
|
258 void CGlxtnThumbnailDatabase::HandleDatabaseError(TInt aError) |
|
259 { |
|
260 TRACER("void CGlxtnThumbnailDatabase::HandleDatabaseError()"); |
|
261 __ASSERT_DEBUG(KErrNone != aError, Panic(EGlxPanicIllegalArgument)); |
|
262 __ASSERT_DEBUG(iClientStatus, Panic(EGlxPanicNotInitialised)); |
|
263 if ( iClientStatus ) |
|
264 { |
|
265 User::RequestComplete(iClientStatus, aError); |
|
266 } |
|
267 } |
|
268 |
|
269 // ----------------------------------------------------------------------------- |
|
270 // HandleThumbnailIdFromMediaIdL |
|
271 // ----------------------------------------------------------------------------- |
|
272 // |
|
273 void CGlxtnThumbnailDatabase::HandleThumbnailIdFromMediaIdL( |
|
274 const TGlxtnThumbnailId& aThumbId ) |
|
275 { |
|
276 TRACER("void CGlxtnThumbnailDatabase::HandleThumbnailIdFromMediaIdL()"); |
|
277 if ( aThumbId == KGlxIdNone ) |
|
278 { |
|
279 // Not found in Ids table - check the Items table |
|
280 OpenDatabaseL(iFileInfo->FilePath())->GetThumbnailIdL(iFileInfo); |
|
281 } |
|
282 else |
|
283 { |
|
284 iThumbId = aThumbId; |
|
285 if(iCurrentOperation == EDeleting) |
|
286 { |
|
287 OpenDatabaseL( iInternalDrive )->DeleteIdL( iMediaId ); |
|
288 } |
|
289 else |
|
290 { |
|
291 DoHandleThumbnailIdL(); |
|
292 } |
|
293 } |
|
294 } |
|
295 |
|
296 // ----------------------------------------------------------------------------- |
|
297 // HandleMediaIdDeletedL |
|
298 // ----------------------------------------------------------------------------- |
|
299 // |
|
300 void CGlxtnThumbnailDatabase::HandleMediaIdDeletedL() |
|
301 { |
|
302 TRACER("void CGlxtnThumbnailDatabase::HandleMediaIdDeletedL()"); |
|
303 OpenDatabaseL(iFileInfo->FilePath())->DeleteThumbnailsL(iThumbId); |
|
304 } |
|
305 |
|
306 // ----------------------------------------------------------------------------- |
|
307 // HandleThumbnailsDeletedL |
|
308 // ----------------------------------------------------------------------------- |
|
309 // |
|
310 void CGlxtnThumbnailDatabase::HandleThumbnailsDeletedL() |
|
311 { |
|
312 TRACER("void CGlxtnThumbnailDatabase::HandleThumbnailsDeletedL()"); |
|
313 OpenDatabaseL(iFileInfo->FilePath())->DeleteItemL(iThumbId); |
|
314 } |
|
315 |
|
316 // ----------------------------------------------------------------------------- |
|
317 // HandleItemsDeletedL |
|
318 // ----------------------------------------------------------------------------- |
|
319 // |
|
320 void CGlxtnThumbnailDatabase::HandleItemDeletedL() |
|
321 { |
|
322 TRACER("void CGlxtnThumbnailDatabase::HandleItemDeletedL()"); |
|
323 __ASSERT_DEBUG(iClientStatus, Panic(EGlxPanicNotInitialised)); |
|
324 if ( iClientStatus ) |
|
325 { |
|
326 User::RequestComplete(iClientStatus, KErrNone); |
|
327 } |
|
328 } |
|
329 |
|
330 // ----------------------------------------------------------------------------- |
|
331 // HandleThumbnailIdFromFilenameL |
|
332 // ----------------------------------------------------------------------------- |
|
333 // |
|
334 void CGlxtnThumbnailDatabase::HandleThumbnailIdFromFilenameL( |
|
335 const TGlxtnThumbnailId& aThumbId ) |
|
336 { |
|
337 TRACER("void CGlxtnThumbnailDatabase::HandleThumbnailIdFromFilenameL()"); |
|
338 iThumbId = aThumbId; |
|
339 if(iCurrentOperation == EDeleting) |
|
340 { |
|
341 GLX_LOG_INFO1("GlxtnThumbnailDatabase::HandleThumbnailIdFromFilenameL Current Operation Deleting. aThumbId = %d", aThumbId.Value()); |
|
342 OpenDatabaseL(iFileInfo->FilePath())->DeleteThumbnailsL(iThumbId); |
|
343 } |
|
344 else |
|
345 { |
|
346 GLX_LOG_INFO1("GlxtnThumbnailDatabase::HandleThumbnailIdFromFilenameL Current Operation NOT Deleting. aThumbId = %d", aThumbId.Value()); |
|
347 // Store thumbnail ID to speed up future lookups |
|
348 OpenDatabaseL( iInternalDrive )->StoreThumbnailIdL( |
|
349 iMediaId, iThumbId ); |
|
350 } |
|
351 } |
|
352 |
|
353 // ----------------------------------------------------------------------------- |
|
354 // HandleThumbnailIdStoredL |
|
355 // ----------------------------------------------------------------------------- |
|
356 // |
|
357 void CGlxtnThumbnailDatabase::HandleThumbnailIdStoredL() |
|
358 { |
|
359 TRACER("void CGlxtnThumbnailDatabase::HandleThumbnailIdStoredL()"); |
|
360 DoHandleThumbnailIdL(); |
|
361 } |
|
362 |
|
363 // ----------------------------------------------------------------------------- |
|
364 // HandleThumbnail |
|
365 // ----------------------------------------------------------------------------- |
|
366 // |
|
367 void CGlxtnThumbnailDatabase::HandleThumbnail( |
|
368 TGlxImageDataFormat aFormat, HBufC8* aData ) |
|
369 { |
|
370 TRACER("void CGlxtnThumbnailDatabase::HandleThumbnail()"); |
|
371 __ASSERT_DEBUG(iClientStatus, Panic(EGlxPanicNotInitialised)); |
|
372 if ( iClientStatus ) |
|
373 { |
|
374 *iLoadData = aData; |
|
375 *iLoadFormat = aFormat; |
|
376 User::RequestComplete(iClientStatus, KErrNone); |
|
377 } |
|
378 else |
|
379 { |
|
380 // Data loaded, but client doesn't want it (shouldn't ever happen) |
|
381 delete aData; |
|
382 } |
|
383 } |
|
384 |
|
385 // ----------------------------------------------------------------------------- |
|
386 // HandleThumbnailStored |
|
387 // ----------------------------------------------------------------------------- |
|
388 // |
|
389 void CGlxtnThumbnailDatabase::HandleThumbnailStored() |
|
390 { |
|
391 TRACER("void CGlxtnThumbnailDatabase::HandleThumbnailStored()"); |
|
392 if ( iStorageObserver ) |
|
393 { |
|
394 iStorageObserver->ThumbnailAvailable(iMediaId, iSize); |
|
395 } |
|
396 |
|
397 __ASSERT_DEBUG(iClientStatus, Panic(EGlxPanicNotInitialised)); |
|
398 if ( iClientStatus ) |
|
399 { |
|
400 User::RequestComplete(iClientStatus, KErrNone); |
|
401 } |
|
402 } |
|
403 |
|
404 // ----------------------------------------------------------------------------- |
|
405 // HandleAvailabilityChecked |
|
406 // ----------------------------------------------------------------------------- |
|
407 // |
|
408 void CGlxtnThumbnailDatabase::HandleAvailabilityChecked(TInt aResult) |
|
409 { |
|
410 TRACER("void CGlxtnThumbnailDatabase::HandleAvailabilityChecked()"); |
|
411 __ASSERT_DEBUG(iClientStatus, Panic(EGlxPanicNotInitialised)); |
|
412 if ( iClientStatus ) |
|
413 { |
|
414 User::RequestComplete(iClientStatus, aResult); |
|
415 } |
|
416 } |
|
417 |
|
418 // ----------------------------------------------------------------------------- |
|
419 // HandleDatabaseCleanedL |
|
420 // ----------------------------------------------------------------------------- |
|
421 // |
|
422 void CGlxtnThumbnailDatabase::HandleDatabaseCleanedL() |
|
423 { |
|
424 TRACER("void CGlxtnThumbnailDatabase::HandleDatabaseCleanedL()"); |
|
425 |
|
426 iDatabaseIndex++; |
|
427 if(iDatabaseIndex < iDatabaseArray.Count()) |
|
428 { |
|
429 // cleanup next database |
|
430 iDatabaseArray[iDatabaseIndex]->CleanupDatabaseL(); |
|
431 } |
|
432 else |
|
433 { |
|
434 // Finished cleanup |
|
435 __ASSERT_DEBUG(iClientStatus, Panic(EGlxPanicNotInitialised)); |
|
436 if ( iClientStatus ) |
|
437 { |
|
438 User::RequestComplete(iClientStatus, KErrNone); |
|
439 } |
|
440 } |
|
441 } |
|
442 |
|
443 // ----------------------------------------------------------------------------- |
|
444 // DoHandleThumbnailIdL |
|
445 // ----------------------------------------------------------------------------- |
|
446 // |
|
447 void CGlxtnThumbnailDatabase::DoHandleThumbnailIdL() |
|
448 { |
|
449 TRACER("void CGlxtnThumbnailDatabase::DoHandleThumbnailIdL()"); |
|
450 CGlxtnVolumeDatabase* db = OpenDatabaseL(iFileInfo->FilePath()); |
|
451 |
|
452 switch ( iCurrentOperation ) |
|
453 { |
|
454 case ELoading: |
|
455 db->GetThumbnailL(iThumbId, iSize); |
|
456 break; |
|
457 case ESaving: |
|
458 db->StoreThumbnailL(iThumbId, iSize, iSaveFormat, iSaveData); |
|
459 break; |
|
460 case ECheckingAvailable: |
|
461 db->CheckAvailableL(iThumbId, iSize); |
|
462 break; |
|
463 default: |
|
464 Panic(EGlxPanicIllegalState); |
|
465 break; |
|
466 } |
|
467 } |
|
468 |
|
469 // ----------------------------------------------------------------------------- |
|
470 // OpenDatabaseL |
|
471 // ----------------------------------------------------------------------------- |
|
472 // |
|
473 CGlxtnVolumeDatabase* CGlxtnThumbnailDatabase::OpenDatabaseL(const TDesC& aDrive) |
|
474 { |
|
475 TRACER("CGlxtnVolumeDatabase* CGlxtnThumbnailDatabase::OpenDatabaseL()"); |
|
476 TPtrC drive(aDrive.Left(KMaxDriveName)); |
|
477 |
|
478 TInt count = iDatabaseArray.Count(); |
|
479 for ( TInt i = 0; i < count; i++ ) |
|
480 { |
|
481 if ( 0 == drive.CompareF(iDatabaseArray[i]->Drive()) ) |
|
482 { |
|
483 return iDatabaseArray[i]; |
|
484 } |
|
485 } |
|
486 |
|
487 // Get path of DB on specified drive |
|
488 TFileName path(drive); |
|
489 path.Append(iDatabasePath); |
|
490 |
|
491 CGlxtnVolumeDatabase* database = CGlxtnVolumeDatabase::NewLC(*this, iFs, path); |
|
492 iDatabaseArray.AppendL(database); |
|
493 CleanupStack::Pop(database); |
|
494 |
|
495 return database; |
|
496 } |
|
497 |
|
498 |
|
499 // End of File |
|