219 // ----------------------------------------------------------------------------- |
220 // ----------------------------------------------------------------------------- |
220 // CHttpCacheEntry::Internalize |
221 // CHttpCacheEntry::Internalize |
221 // |
222 // |
222 // ----------------------------------------------------------------------------- |
223 // ----------------------------------------------------------------------------- |
223 // |
224 // |
224 TInt CHttpCacheEntry::Internalize( RFileReadStream& aReadStream ) |
225 TInt CHttpCacheEntry::Internalize( RReadStream& aReadStream, const TDesC& aDirectory ) |
|
226 { |
|
227 TRAPD( err, InternalizeL( aReadStream, aDirectory ) ); |
|
228 return err; |
|
229 } |
|
230 |
|
231 // ----------------------------------------------------------------------------- |
|
232 // CHttpCacheEntry::InternalizeL |
|
233 // |
|
234 // ----------------------------------------------------------------------------- |
|
235 // |
|
236 void CHttpCacheEntry::InternalizeL( RReadStream& aReadStream, const TDesC& aDirectory ) |
225 { |
237 { |
226 // url length |
238 // url length |
227 TRAPD( err, |
239 TInt len; |
228 TInt len; |
240 len = aReadStream.ReadInt32L(); |
229 |
241 delete iUrl; |
230 // url length |
242 iUrl=NULL; |
231 len = aReadStream.ReadInt32L(); |
243 iUrl = HBufC8::NewL( len ); |
232 delete iUrl; |
244 TPtr8 ptr8( iUrl->Des() ); |
233 iUrl=NULL; |
245 // url |
234 iUrl = HBufC8::NewL( len ); |
246 aReadStream.ReadL( ptr8, len ); |
235 TPtr8 ptr8( iUrl->Des() ); |
247 |
236 // url |
248 // calculate full path and filename length |
237 aReadStream.ReadL( ptr8, len ); |
249 // aDirectory/ + "x/xxxxxxxx" : note aDirectory has trailing '/' |
238 |
250 len = aDirectory.Length() + KSubdirNameLength + KFilenameLength; |
239 // filename length |
251 HBufC* filename = HBufC::NewLC( len ); |
240 len = aReadStream.ReadInt32L(); |
252 TPtr ptr( filename->Des() ); |
241 HBufC* filename = HBufC::NewLC( len ); |
253 |
242 TPtr ptr( filename->Des() ); |
254 // Read max char length of filename. |
243 // url |
255 // NOTE: The filename and filename length is calculated by the code in |
244 aReadStream.ReadL( ptr, len ); |
256 // HttpCacheUtil::GenerateNameLC. The sub directory is the same as the |
245 // |
257 // last char of the filename, e.g. ..\A\0123DCBA |
246 SetFileNameL( filename->Des() ); |
258 TBuf<KFilenameLength> uniqueFilename; |
247 // |
259 aReadStream.ReadL( uniqueFilename , KFilenameLength ); |
248 CleanupStack::PopAndDestroy(); // filename |
260 TPtrC uniqueSubDir = uniqueFilename.Right(1); |
249 // la |
261 |
250 TReal64 la; |
262 // assemble path and filename |
251 la = aReadStream.ReadReal64L(); |
263 ptr.Format(_L("%S%S\\%S"), &aDirectory, &uniqueSubDir, &uniqueFilename); |
252 iLastAccessed = la; |
264 // |
253 // ref |
265 SetFileNameL( filename->Des() ); |
254 iRef = aReadStream.ReadUint32L(); |
266 // |
255 // size |
267 CleanupStack::PopAndDestroy(); // filename |
256 iBodySize = aReadStream.ReadUint32L( ); |
268 // la |
257 // size |
269 TReal64 la; |
258 iHeaderSize = aReadStream.ReadUint32L( ); |
270 la = aReadStream.ReadReal64L(); |
259 // protected |
271 iLastAccessed = la; |
260 iProtected = aReadStream.ReadInt32L(); |
272 // ref |
261 // |
273 iRef = aReadStream.ReadUint32L(); |
262 SetState( ECacheComplete ); |
274 // size |
263 ); // end of TRAPD |
275 iBodySize = aReadStream.ReadUint32L( ); |
264 |
276 // size |
|
277 iHeaderSize = aReadStream.ReadUint32L( ); |
|
278 // protected |
|
279 iProtected = aReadStream.ReadInt32L(); |
|
280 // header data |
|
281 delete iHeaderBuffer; |
|
282 iHeaderBuffer = NULL; |
|
283 len = aReadStream.ReadInt32L(); |
|
284 iHeaderBuffer = HBufC8::NewL(len); |
|
285 TPtr8 header_ptr( iHeaderBuffer->Des() ); |
|
286 aReadStream.ReadL( header_ptr, len ); |
|
287 // |
|
288 SetState( ECacheComplete ); |
|
289 } |
|
290 |
|
291 // ----------------------------------------------------------------------------- |
|
292 // CHttpCacheEntry::Externalize |
|
293 // |
|
294 // ----------------------------------------------------------------------------- |
|
295 // |
|
296 TInt CHttpCacheEntry::Externalize( RWriteStream& aWriteStream, const TDesC& aDirectory ) |
|
297 { |
|
298 TRAPD( err, ExternalizeL( aWriteStream, aDirectory ) ); |
265 return err; |
299 return err; |
266 } |
300 } |
267 |
301 |
268 // ----------------------------------------------------------------------------- |
302 // ----------------------------------------------------------------------------- |
269 // CHttpCacheEntry::Externalize |
303 // CHttpCacheEntry::Externalize |
270 // |
304 // |
271 // ----------------------------------------------------------------------------- |
305 // ----------------------------------------------------------------------------- |
272 // |
306 // |
273 TInt CHttpCacheEntry::Externalize( RFileWriteStream& aWriteStream ) |
307 void CHttpCacheEntry::ExternalizeL( RWriteStream& aWriteStream, const TDesC& aDirectory ) |
274 { |
308 { |
275 TRAPD( err, |
309 // check directory matches filename |
276 // url length |
310 ASSERT(aDirectory.CompareF(iFileName->Left(aDirectory.Length())) == 0); |
277 aWriteStream.WriteInt32L( iUrl->Length() ); |
311 |
278 // url |
312 // url length |
279 aWriteStream.WriteL( iUrl->Des() ); |
313 aWriteStream.WriteInt32L( iUrl->Length() ); |
280 // filename length |
314 // url |
281 aWriteStream.WriteInt32L( iFileName->Length() ); |
315 aWriteStream.WriteL( iUrl->Des() ); |
282 // filename |
316 // filename |
283 aWriteStream.WriteL( iFileName->Des() ); |
317 // know that filenames are 8 chars and no extension. Can reconstruct on |
284 // la |
318 // import from directory and last char. See HttpCacheUtil::GenerateNameLC. |
285 aWriteStream.WriteReal64L( iLastAccessed ); |
319 aWriteStream.WriteL( iFileName->Des().Right( KFilenameLength ) ); |
286 // ref |
320 // la |
287 aWriteStream.WriteUint32L( iRef ); |
321 aWriteStream.WriteReal64L( iLastAccessed ); |
288 // size |
322 // ref |
289 aWriteStream.WriteUint32L( iBodySize ); |
323 aWriteStream.WriteUint32L( iRef ); |
290 // size |
324 // size |
291 aWriteStream.WriteUint32L( iHeaderSize ); |
325 aWriteStream.WriteUint32L( iBodySize ); |
292 // protected |
326 // size |
293 aWriteStream.WriteInt32L( iProtected ); |
327 aWriteStream.WriteUint32L( iHeaderSize ); |
294 ); // end of TRAPD |
328 // protected |
295 |
329 aWriteStream.WriteInt32L( iProtected ); |
296 return err; |
330 // header data length |
|
331 aWriteStream.WriteInt32L( iHeaderBuffer->Length() ); |
|
332 // header data |
|
333 aWriteStream.WriteL( iHeaderBuffer->Des() ); |
297 } |
334 } |
298 |
335 |
299 // ----------------------------------------------------------------------------- |
336 // ----------------------------------------------------------------------------- |
300 // CHttpCacheEntry::Accessed |
337 // CHttpCacheEntry::Accessed |
301 // |
338 // |
318 #endif // __CACHELOG__ |
355 #endif // __CACHELOG__ |
319 |
356 |
320 } |
357 } |
321 |
358 |
322 // ----------------------------------------------------------------------------- |
359 // ----------------------------------------------------------------------------- |
323 // CHttpCacheEntry::SetCacheFilesOpened |
360 // CHttpCacheEntry::SetCacheBufferL |
324 // |
|
325 // ----------------------------------------------------------------------------- |
|
326 // |
|
327 void CHttpCacheEntry::SetCacheFilesOpened( TBool aCacheFilesOpened ) |
|
328 { |
|
329 // Set our files open flag |
|
330 iCacheFilesOpened = aCacheFilesOpened; |
|
331 } |
|
332 |
|
333 // ----------------------------------------------------------------------------- |
|
334 // CHttpCacheEntry::CacheBuffer |
|
335 // NOTE: Cache buffer is created on: |
361 // NOTE: Cache buffer is created on: |
336 // 1. Normal content entrypoint into CacheManager |
362 // 1. Normal content entrypoint into CacheManager |
337 // CacheManager::ReceivedResponseHeadersL -> CacheHandler::ReceivedResponseHeadersL -> |
363 // CacheManager::ReceivedResponseHeadersL -> CacheHandler::ReceivedResponseHeadersL -> |
338 // CacheHandler::HandleResponseOkL (calls method - SetCacheBuffer, needed to |
364 // CacheHandler::HandleResponseOkL (calls method - SetCacheBuffer, needed to |
339 // accumulate body content on multiple CacheHandler::ReceivedBodyDataL calls) |
365 // accumulate body content on multiple CacheHandler::ReceivedBodyDataL calls) |
340 // 2. Multipart content entrypoint into CacheManager |
366 // 2. Multipart content entrypoint into CacheManager |
341 // CacheManager::SaveL -> CacheHandler::SaveL -> CacheHandler::SaveBuffer -> |
367 // CacheManager::SaveL -> CacheHandler::SaveL -> CacheHandler::SaveBuffer -> |
342 // CacheStreamHandler::SaveBodyData (calls this method - CacheBuffer, needed |
368 // CacheStreamHandler::SaveBodyData (calls this method - SetCacheBufferL, needed |
343 // because cacheBuffer=null and single call made, no accumulation of body data) |
369 // because cacheBuffer=null and single call made, no accumulation of body data) |
344 // ----------------------------------------------------------------------------- |
|
345 // |
|
346 TPtr8 CHttpCacheEntry::CacheBuffer() |
|
347 { |
|
348 if ( iCacheBuffer == NULL ) |
|
349 { |
|
350 // Create the cache buffer, if needed |
|
351 iCacheBuffer = HBufC8::New( KBufferSize32k ); |
|
352 if ( iCacheBuffer == NULL ) |
|
353 { |
|
354 // OOM, return empty cache buffer |
|
355 TPtr8 emptyCacheBuffer( NULL, 0, 0 ); |
|
356 return emptyCacheBuffer; |
|
357 } |
|
358 } |
|
359 |
|
360 return iCacheBuffer->Des(); |
|
361 } |
|
362 |
|
363 // ----------------------------------------------------------------------------- |
|
364 // CHttpCacheEntry::SetCacheBufferL |
|
365 // |
|
366 // ----------------------------------------------------------------------------- |
370 // ----------------------------------------------------------------------------- |
367 // |
371 // |
368 void CHttpCacheEntry::SetCacheBufferL( TInt aCacheBufferSize ) |
372 void CHttpCacheEntry::SetCacheBufferL( TInt aCacheBufferSize ) |
369 { |
373 { |
370 if ( aCacheBufferSize > 0 && iCacheBuffer == NULL ) |
374 // Delete cacheBuffer and null, a way to zero buffer and handle if NewL leave |
371 { |
375 delete iCacheBuffer; |
372 iCacheBuffer = HBufC8::NewL( aCacheBufferSize ); |
376 iCacheBuffer = NULL; |
373 } |
377 |
374 else if ( aCacheBufferSize <= 0 ) |
378 if ( aCacheBufferSize > 0 ) |
375 { |
379 { |
376 delete iCacheBuffer; |
380 iCacheBuffer = CSegmentedHeapBuffer::NewL( aCacheBufferSize, KBufferGranularity4k ); |
377 iCacheBuffer = NULL; |
381 } |
378 } |
382 } |
379 } |
383 |
|
384 // ----------------------------------------------------------------------------- |
|
385 // CHttpCacheEntry::CreateHeaderBufferL |
|
386 // |
|
387 // ----------------------------------------------------------------------------- |
|
388 // |
|
389 void CHttpCacheEntry::CreateHeaderBufferL( TInt aHeaderBufferSize ) |
|
390 { |
|
391 // Delete cacheBuffer and null, a way to zero buffer and handle if NewL leave |
|
392 delete iHeaderBuffer; |
|
393 iHeaderBuffer = NULL; |
|
394 |
|
395 if ( aHeaderBufferSize > 0 ) |
|
396 { |
|
397 iHeaderBuffer = HBufC8::NewL( aHeaderBufferSize ); |
|
398 } |
|
399 SetHeaderSize( aHeaderBufferSize ); |
|
400 } |
|
401 |
|
402 // ----------------------------------------------------------------------------- |
|
403 // CHttpCacheEntry::CreateHeaderBufferL |
|
404 // |
|
405 // ----------------------------------------------------------------------------- |
|
406 // |
|
407 void CHttpCacheEntry::CreateHeaderBufferL( const TDesC8& aHeaderData ) |
|
408 { |
|
409 // Delete cacheBuffer and null, a way to zero buffer and handle if NewL leave |
|
410 delete iHeaderBuffer; |
|
411 iHeaderBuffer = NULL; |
|
412 |
|
413 TInt aHeaderBufferSize = aHeaderData.Length(); |
|
414 if ( aHeaderBufferSize > 0 ) |
|
415 { |
|
416 iHeaderBuffer = aHeaderData.AllocL(); |
|
417 } |
|
418 SetHeaderSize( aHeaderBufferSize ); |
|
419 } |
|
420 |
|
421 // ----------------------------------------------------------------------------- |
|
422 // CHttpCacheEntry::BodyData |
|
423 // |
|
424 // ----------------------------------------------------------------------------- |
|
425 // |
|
426 CSegmentedHeapBuffer& CHttpCacheEntry::BodyData() |
|
427 { |
|
428 return *iCacheBuffer; |
|
429 } |
|
430 |
|
431 // ----------------------------------------------------------------------------- |
|
432 // CHttpCacheEntry::BodyFile |
|
433 // |
|
434 // ----------------------------------------------------------------------------- |
|
435 // |
|
436 RFile& CHttpCacheEntry::BodyFile() |
|
437 { |
|
438 return iBodyFile; |
|
439 } |
|
440 |
|
441 // ----------------------------------------------------------------------------- |
|
442 // CHttpCacheEntry::HeaderData |
|
443 // |
|
444 // ----------------------------------------------------------------------------- |
|
445 // |
|
446 TDesC8& CHttpCacheEntry::HeaderData() |
|
447 { |
|
448 return *iHeaderBuffer; |
|
449 } |
|
450 |
|
451 // ----------------------------------------------------------------------------- |
|
452 // CHttpCacheEntry::BodyWriteInProgress |
|
453 // |
|
454 // ----------------------------------------------------------------------------- |
|
455 // |
|
456 void CHttpCacheEntry::BodyWriteInProgress() |
|
457 { |
|
458 SetBodyDataPartiallyWritten( ETrue ); |
|
459 } |
|
460 |
|
461 // ----------------------------------------------------------------------------- |
|
462 // CHttpCacheEntry::BodyWriteComplete |
|
463 // |
|
464 // ----------------------------------------------------------------------------- |
|
465 // |
|
466 void CHttpCacheEntry::BodyWriteComplete() |
|
467 { |
|
468 iCacheBuffer->Reset(); |
|
469 SetBodyDataPartiallyWritten( EFalse ); |
|
470 SetBodyDataCached( EFalse ); |
|
471 } |
|
472 |
|
473 // ----------------------------------------------------------------------------- |
|
474 // CHttpCacheEntry::WriteBodyDataAsync |
|
475 // |
|
476 // ----------------------------------------------------------------------------- |
|
477 // |
|
478 void CHttpCacheEntry::WriteBodyDataAsync(TRequestStatus& aStatus) |
|
479 { |
|
480 delete iWriteHelper; |
|
481 iWriteHelper = NULL; |
|
482 TRAP_IGNORE( iWriteHelper = CHttpCacheEntryAsyncWriteHelper::NewL( this, aStatus ) ); |
|
483 } |
|
484 |
|
485 // ----------------------------------------------------------------------------- |
|
486 // CHttpCacheEntry::CancelBodyWrite |
|
487 // |
|
488 // ----------------------------------------------------------------------------- |
|
489 // |
|
490 void CHttpCacheEntry::CancelBodyWrite() |
|
491 { |
|
492 if ( BodyDataPartiallyWritten() && iWriteHelper ) |
|
493 { |
|
494 iWriteHelper->Cancel(); |
|
495 } |
|
496 } |
|
497 |
380 // End of File |
498 // End of File |