126 // |
125 // |
127 void CMPXMetadataScanner::Reset() |
126 void CMPXMetadataScanner::Reset() |
128 { |
127 { |
129 iNewFiles.ResetAndDestroy(); |
128 iNewFiles.ResetAndDestroy(); |
130 iModifiedFiles.ResetAndDestroy(); |
129 iModifiedFiles.ResetAndDestroy(); |
131 if(iNewFileProps) |
130 iTargetProps->Reset(); |
132 { |
|
133 iNewFileProps->Reset(); |
|
134 } |
|
135 if(iModifiedFileProps) |
|
136 { |
|
137 iModifiedFileProps->Reset(); |
|
138 } |
|
139 } |
131 } |
140 |
132 |
141 // --------------------------------------------------------------------------- |
133 // --------------------------------------------------------------------------- |
142 // Starts the metadata extraction process |
134 // Starts the metadata extraction process |
143 // --------------------------------------------------------------------------- |
135 // --------------------------------------------------------------------------- |
144 // |
136 // |
145 void CMPXMetadataScanner::Start() |
137 void CMPXMetadataScanner::Start() |
146 { |
138 { |
147 MPX_DEBUG1("MPXMetadataScanner::StartL <---"); |
139 MPX_FUNC("MPXMetadataScanner::StartL()"); |
148 if( !IsActive() ) |
140 if( !IsActive() ) |
149 { |
141 { |
150 // Setup |
142 // Setup |
151 iAryPos = 0; |
143 iAryPos = 0; |
152 iExtractType = ENewFiles; |
144 iExtractType = ENewFiles; |
153 iExtracting = ETrue; |
145 iExtracting = ETrue; |
154 |
146 iTargetProps->Reset(); |
|
147 |
155 // Set Active |
148 // Set Active |
156 iStatus = KRequestPending; |
149 iStatus = KRequestPending; |
157 SetActive(); |
150 SetActive(); |
158 TRequestStatus* status = &iStatus; |
151 TRequestStatus* status = &iStatus; |
159 User::RequestComplete( status, KErrNone ); |
152 User::RequestComplete( status, KErrNone ); |
160 MPX_DEBUG1("MPXMetadataScanner::StartL --->"); |
|
161 } |
153 } |
162 } |
154 } |
163 // --------------------------------------------------------------------------- |
155 // --------------------------------------------------------------------------- |
164 // Stops the metadata extraction process |
156 // Stops the metadata extraction process |
165 // --------------------------------------------------------------------------- |
157 // --------------------------------------------------------------------------- |
166 // |
158 // |
167 void CMPXMetadataScanner::Stop() |
159 void CMPXMetadataScanner::Stop() |
168 { |
160 { |
169 MPX_DEBUG1("MPXMetadataScanner::Stop <---"); |
161 MPX_FUNC("MPXMetadataScanner::Stop()"); |
170 DoCancel(); |
162 DoCancel(); |
171 MPX_DEBUG1("MPXMetadataScanner::Stop --->"); |
|
172 } |
163 } |
173 |
164 |
174 // --------------------------------------------------------------------------- |
165 // --------------------------------------------------------------------------- |
175 // Add a file to the scanning list |
166 // Add a file to the scanning list |
176 // --------------------------------------------------------------------------- |
167 // --------------------------------------------------------------------------- |
177 // |
168 // |
178 void CMPXMetadataScanner::AddNewFileToScanL( const TDesC& aFile ) |
169 void CMPXMetadataScanner::AddNewFileToScanL( const TDesC& aFile ) |
179 { |
170 { |
|
171 MPX_FUNC("MPXMetadataScanner::AddNewFileToScanL()"); |
180 HBufC* file = aFile.AllocLC(); |
172 HBufC* file = aFile.AllocLC(); |
181 iNewFiles.AppendL( file ); |
173 iNewFiles.AppendL( file ); |
182 CleanupStack::Pop( file ); |
174 CleanupStack::Pop( file ); |
183 } |
175 } |
184 |
176 |
224 // RunL function |
220 // RunL function |
225 // --------------------------------------------------------------------------- |
221 // --------------------------------------------------------------------------- |
226 // |
222 // |
227 void CMPXMetadataScanner::RunL() |
223 void CMPXMetadataScanner::RunL() |
228 { |
224 { |
|
225 MPX_FUNC("CMPXMetadataScanner::RunL()"); |
229 if ( iExtracting ) |
226 if ( iExtracting ) |
230 { |
227 { |
231 TBool done(EFalse); |
228 TRAPD( err, DoExtractL() ); |
232 TRAPD( err, done = DoExtractL() ); |
229 if ( err ) |
233 if ( !iExtracting ) |
230 { |
234 { |
231 MetadataScannerComplete( err ); |
235 // If DoCancel() was called during DoExtractL(), do nothing. |
|
236 MPX_DEBUG1("CMPXMetadataScanner::RunL - Cancel during RunL"); |
|
237 } |
|
238 else if( KErrNone != err || done ) |
|
239 { |
|
240 // Callback to observer |
|
241 TRAP_IGNORE( iStateObserver.HandleScanStateCompleteL( MMPXFileScanStateObserver::EScanMetadata, |
|
242 err ) ); |
|
243 iExtracting = EFalse; |
|
244 } |
|
245 else |
|
246 { |
|
247 MPX_DEBUG1("CMPXMetadataScanner::RunL -- Run again"); |
|
248 iStatus = KRequestPending; |
|
249 SetActive(); |
|
250 TRequestStatus* status = &iStatus; |
|
251 User::RequestComplete( status, KErrNone ); |
|
252 } |
232 } |
253 } |
233 } |
254 } |
234 } |
255 |
235 |
256 // --------------------------------------------------------------------------- |
236 // --------------------------------------------------------------------------- |
257 // Extract metadata |
237 // Extract metadata |
258 // --------------------------------------------------------------------------- |
238 // --------------------------------------------------------------------------- |
259 // |
239 // |
260 TBool CMPXMetadataScanner::DoExtractL() |
240 void CMPXMetadataScanner::DoExtractL() |
261 { |
241 { |
262 MPX_DEBUG1("CMPXMetadataScanner::DoExtractL <---"); |
242 MPX_FUNC("CMPXMetadataScanner::DoExtractL()"); |
263 TBool done(EFalse); |
243 |
|
244 RPointerArray<HBufC>* source = GetSource(); |
|
245 if ( source->Count() ) |
|
246 { |
|
247 // Call asynchronous CreateMedia to get metadata. |
|
248 iExtractor->CreateMediaAsyncL( *(*source)[iAryPos], this ); |
|
249 } |
|
250 else |
|
251 { |
|
252 // Source array is empty, go to next array. |
|
253 MPX_DEBUG2("CMPXMetadataScanner::DoExtractL Source array is empty ExtractType = %d.", iExtractType); |
|
254 iAryPos = 0; |
|
255 iExtractType++; |
|
256 RunAgain(); |
|
257 } |
|
258 } |
|
259 |
|
260 // --------------------------------------------------------------------------- |
|
261 // Callback for CreateMediaAsyncL |
|
262 // --------------------------------------------------------------------------- |
|
263 // |
|
264 void CMPXMetadataScanner::HandleCreateMediaComplete( CMPXMedia* aMedia, TInt aError ) |
|
265 { |
|
266 MPX_FUNC("CMPXMetadataScanner::HandleCreateMediaComplete()"); |
|
267 MPX_DEBUG2("CMPXMetadataScanner::HandleCreateMediaComplete error = %d", aError); |
|
268 TInt err = KErrNone; |
|
269 |
|
270 // Scanning cancelled |
|
271 if ( !iExtracting ) |
|
272 { |
|
273 delete aMedia; |
|
274 return; |
|
275 } |
|
276 |
|
277 // Add media to target array. |
|
278 if ( ( aError == KErrNone ) && |
|
279 ( aMedia != NULL ) ) |
|
280 { |
|
281 TRAP( err, iTargetProps->AppendL( aMedia ) ); |
|
282 if ( err ) |
|
283 { |
|
284 delete aMedia; |
|
285 } |
|
286 } |
|
287 |
|
288 iAryPos++; |
|
289 if( iAryPos >= GetSource()->Count() ) |
|
290 { |
|
291 // Finished with this array, go to the next array. |
|
292 iAryPos = 0; |
|
293 TRAP( err, AddToCollectionL() ); |
|
294 if ( err ) |
|
295 { |
|
296 MetadataScannerComplete( err ); |
|
297 } |
|
298 iExtractType++; |
|
299 } |
|
300 else |
|
301 { |
|
302 // Batch update collection DBs. |
|
303 if ( iTargetProps->Count() >= KLoopCount ) |
|
304 { |
|
305 TRAP( err, AddToCollectionL() ); |
|
306 if ( err ) |
|
307 { |
|
308 MetadataScannerComplete( err ); |
|
309 } |
|
310 } |
|
311 } |
|
312 |
|
313 RunAgain(); |
|
314 } |
|
315 |
|
316 // --------------------------------------------------------------------------- |
|
317 // Get source array |
|
318 // --------------------------------------------------------------------------- |
|
319 // |
|
320 RPointerArray<HBufC>* CMPXMetadataScanner::GetSource() |
|
321 { |
|
322 MPX_FUNC("CMPXMetadataScanner::GetSource()"); |
264 TExtractType curType = (TExtractType) iExtractType; |
323 TExtractType curType = (TExtractType) iExtractType; |
265 |
324 |
266 // Pointer re-direction to generalize extraction |
|
267 RPointerArray<HBufC>* source; |
|
268 CMPXMediaArray* mptarget; |
|
269 if( curType == ENewFiles ) |
325 if( curType == ENewFiles ) |
270 { |
326 { |
271 source = &iNewFiles; |
327 return &iNewFiles; |
272 mptarget = iNewFileProps; |
|
273 } |
328 } |
274 else if( curType == EModFiles ) |
329 else if( curType == EModFiles ) |
275 { |
330 { |
276 source = &iModifiedFiles; |
331 return &iModifiedFiles; |
277 mptarget = iModifiedFileProps; |
332 } |
278 } |
333 else |
279 else // All done! |
334 return NULL; |
280 { |
335 } |
281 return ETrue; |
336 |
282 } |
337 // --------------------------------------------------------------------------- |
283 |
338 // Is metadata scanner done |
284 // Process at most KLoopCount number of files |
339 // --------------------------------------------------------------------------- |
285 // |
340 // |
286 mptarget->Reset(); |
341 TBool CMPXMetadataScanner::IsDone() |
287 if( source->Count() != 0 ) |
342 { |
288 { |
343 MPX_FUNC("CMPXMetadataScanner::IsDone()"); |
289 for( TInt i=0; i<KLoopCount; ++i ) |
344 TExtractType curType = (TExtractType) iExtractType; |
290 { |
345 |
291 CMPXMedia* media(NULL); |
346 TBool done = EFalse; |
292 |
347 if ( curType >= EMaxFile ) |
293 // TRAP to keep scanning if 1 file fails |
348 { |
294 TRAPD( err, iExtractor->CreateMediaL( *(*source)[iAryPos], media ) ); |
349 done = ETrue; |
295 if ( !iExtracting ) |
350 } |
|
351 return done; |
|
352 } |
|
353 |
|
354 // --------------------------------------------------------------------------- |
|
355 // Run Active Object again |
|
356 // --------------------------------------------------------------------------- |
|
357 // |
|
358 void CMPXMetadataScanner::RunAgain() |
|
359 { |
|
360 MPX_FUNC("CMPXMetadataScanner::RunAgain()"); |
|
361 if ( IsDone() ) |
|
362 { |
|
363 MetadataScannerComplete( KErrNone ); |
|
364 } |
|
365 else |
|
366 { |
|
367 MPX_DEBUG1("CMPXMetadataScanner::RunAgain -- Run again"); |
|
368 iStatus = KRequestPending; |
|
369 SetActive(); |
|
370 TRequestStatus* status = &iStatus; |
|
371 User::RequestComplete( status, KErrNone ); |
|
372 } |
|
373 } |
|
374 |
|
375 // --------------------------------------------------------------------------- |
|
376 // Add metadata to collection |
|
377 // --------------------------------------------------------------------------- |
|
378 // |
|
379 void CMPXMetadataScanner::AddToCollectionL() |
|
380 { |
|
381 MPX_FUNC("CMPXMetadataScanner::AddToCollectionL()"); |
|
382 TExtractType curType = (TExtractType) iExtractType; |
|
383 |
|
384 switch( curType ) |
|
385 { |
|
386 case ENewFiles: |
|
387 { |
|
388 if( iTargetProps->Count() ) |
296 { |
389 { |
297 // In case DoCancel() was called while processing iExtractor->CreateMediaL |
390 iObserver.AddFilesToCollectionL( *iTargetProps ); |
298 MPX_DEBUG1("CMPXMetadataScanner::DoExtractL - Cancel during CreateMediaL"); |
|
299 delete media; |
|
300 return ETrue; |
|
301 } |
|
302 |
|
303 if( err == KErrNone ) |
|
304 { |
|
305 CleanupStack::PushL( media ); |
|
306 mptarget->AppendL( media ); |
|
307 CleanupStack::Pop( media ); |
|
308 } |
|
309 |
|
310 iAryPos++; |
|
311 if( iAryPos == source->Count() ) |
|
312 { |
|
313 iAryPos = 0; |
|
314 iExtractType++; |
|
315 break; |
|
316 } |
|
317 } |
|
318 } |
|
319 else // No item in the array |
|
320 { |
|
321 iAryPos = 0; |
|
322 iExtractType++; |
|
323 } |
|
324 |
|
325 // After extraction, get observer to add files to the collection |
|
326 // |
|
327 switch( curType ) |
|
328 { |
|
329 case ENewFiles: |
|
330 { |
|
331 if( iNewFileProps->Count() ) |
|
332 { |
|
333 iObserver.AddFilesToCollectionL( *iNewFileProps ); |
|
334 } |
391 } |
335 break; |
392 break; |
336 } |
393 } |
337 case EModFiles: |
394 case EModFiles: |
338 { |
395 { |
339 if( iModifiedFileProps->Count() ) |
396 if( iTargetProps->Count() ) |
340 { |
397 { |
341 iObserver.UpdatesFilesInCollectionL( *iModifiedFileProps ); |
398 iObserver.UpdatesFilesInCollectionL( *iTargetProps ); |
342 } |
399 } |
343 break; |
400 break; |
344 } |
401 } |
345 case EMaxFile: // All done. |
|
346 done = ETrue; |
|
347 break; |
|
348 default: |
402 default: |
349 ASSERT(0); |
403 ASSERT(0); |
350 } |
404 } |
351 |
405 iTargetProps->Reset(); |
352 MPX_DEBUG1("CMPXMetadataScanner::DoExtractL --->"); |
406 } |
353 return done; |
407 |
354 } |
408 // --------------------------------------------------------------------------- |
|
409 // Complete metadata scanner |
|
410 // --------------------------------------------------------------------------- |
|
411 // |
|
412 void CMPXMetadataScanner::MetadataScannerComplete( TInt aError ) |
|
413 { |
|
414 MPX_FUNC("CMPXMetadataScanner::MetadataScannerCompleteL()"); |
|
415 MPX_DEBUG2("CMPXMetadataScanner::MetadataScannerCompleteL error = %d", aError); |
|
416 |
|
417 // Callback to observer |
|
418 TRAP_IGNORE( iStateObserver.HandleScanStateCompleteL( MMPXFileScanStateObserver::EScanMetadata, aError ) ); |
|
419 iExtracting = EFalse; |
|
420 Reset(); |
|
421 } |