diff -r 61bc0f252b2b -r bac7acad7cb3 camerauis/cameraapp/generic/src/CamBurstCaptureArray.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/camerauis/cameraapp/generic/src/CamBurstCaptureArray.cpp Wed Sep 01 12:30:54 2010 +0100 @@ -0,0 +1,588 @@ +/* +* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: A class that represents a single item in a burst capture +* +* Copyright © 2007-2008 Nokia. All rights reserved. +* This material, including documentation and any related computer +* programs, is protected by copyright controlled by Nokia. All +* rights are reserved. Copying, including reproducing, storing, +* adapting or translating, any or all of this material requires the +* prior written consent of Nokia. This material also contains +* confidential information which may not be disclosed to others +* without the prior written consent of Nokia. + +* +* +*/ + + +// INCLUDE FILES +#include +#include +#include +#include + +#include +#include + +#include "CamBurstCaptureArray.h" +#include "CamImageSaveActive.h" +#include "CamPanic.h" +#include "camlogging.h" + + +// CONSTANTS + +// ================= MEMBER FUNCTIONS ======================= + +// ----------------------------------------------------------------------------- +// CCamBurstCaptureItem::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CCamBurstCaptureArray::CCamBurstCaptureItem* CCamBurstCaptureArray::CCamBurstCaptureItem::NewLC() + { + CCamBurstCaptureItem* self = new( ELeave ) CCamBurstCaptureItem(); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureItem destructor +// +// --------------------------------------------------------------------------- +// +CCamBurstCaptureArray::CCamBurstCaptureItem::~CCamBurstCaptureItem() + { + PRINT( _L("Camera => ~CCamBurstCaptureItem") ); + delete iFileName; + delete iImageName; + delete iSnapshot; + PRINT( _L("Camera <= ~CCamBurstCaptureItem") ); + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureItem::SetNameL +// Sets the item's full file path and image name +// --------------------------------------------------------------------------- +// +void CCamBurstCaptureArray::CCamBurstCaptureItem::SetNameL( const TDesC& aFullFileName, + const TDesC& aImageName ) + { + delete iFileName; + iFileName = NULL; + delete iImageName; + iImageName = NULL; + iFileName = aFullFileName.AllocL(); + iImageName = aImageName.AllocL(); + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureItem::SetSnapshotL +// Stores the snapshot bitmap in the item +// --------------------------------------------------------------------------- +// +void CCamBurstCaptureArray::CCamBurstCaptureItem::SetSnapshotL( const CFbsBitmap& aSnapshot ) + { + delete iSnapshot; + iSnapshot = NULL; + + // Create bitmap + iSnapshot = new( ELeave ) CFbsBitmap(); + TInt createError = iSnapshot->Duplicate( aSnapshot.Handle() ); + + if ( createError ) + { + delete iSnapshot; + iSnapshot = NULL; + } + + User::LeaveIfError( createError ); + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureItem::SetDeleted +// Sets the item's deletion state +// --------------------------------------------------------------------------- +// +void CCamBurstCaptureArray::CCamBurstCaptureItem::SetDeleted( TBool aDeleted ) + { + iIsDeleted = aDeleted; + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureItem::FileName +// Return a pointer to the full file path and name +// --------------------------------------------------------------------------- +// +const TDesC& CCamBurstCaptureArray::CCamBurstCaptureItem::FileName() const + { + if( !iFileName ) + { + return KNullDesC; + } + return *iFileName; + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureItem::ImageName +// Return a pointer to the image name +// --------------------------------------------------------------------------- +// +const TDesC& CCamBurstCaptureArray::CCamBurstCaptureItem::ImageName() const + { + if( !iImageName ) + { + return KNullDesC; + } + return *iImageName; + } + +// --------------------------------------------------------------------------- +// CCamCaptureSetupListItem::Bitmap +// Return a pointer to the bitmap +// --------------------------------------------------------------------------- +// +const CFbsBitmap* CCamBurstCaptureArray::CCamBurstCaptureItem::Snapshot() const + { + return iSnapshot; + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureItem::IsDeleted +// Whether or not the item has been marked for deletion +// --------------------------------------------------------------------------- +// +TBool CCamBurstCaptureArray::CCamBurstCaptureItem::IsDeleted() const + { + return iIsDeleted; + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::CCamBurstCaptureItem::ReplaceSnapshot +// Replaces the bitmap. +// --------------------------------------------------------------------------- +// +TBool CCamBurstCaptureArray::CCamBurstCaptureItem::ReplaceSnapshot( + const CFbsBitmap* aBitmap ) + { + if( !iSnapshot ) + { + TRAPD( err, iSnapshot = new( ELeave ) CFbsBitmap() ); + if( err ) + { + return EFalse; + } + } + if ( iSnapshot->Duplicate( aBitmap->Handle() ) ) + { + return EFalse; + } + return ETrue; + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureItem::CCamBurstCaptureItem +// C++ constructor +// --------------------------------------------------------------------------- +// +CCamBurstCaptureArray::CCamBurstCaptureItem::CCamBurstCaptureItem() + { + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureItem::ConstructL +// Second phase construction +// --------------------------------------------------------------------------- +// +void CCamBurstCaptureArray::CCamBurstCaptureItem::ConstructL() + { + } + +// ----------------------------------------------------------------------------- +// CCamBurstCaptureArray::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CCamBurstCaptureArray* CCamBurstCaptureArray::NewL( CCamImageSaveActive& aImageSaveActive ) + { + CCamBurstCaptureArray* self = new( ELeave ) CCamBurstCaptureArray( aImageSaveActive ); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray destructor +// +// --------------------------------------------------------------------------- +// +CCamBurstCaptureArray::~CCamBurstCaptureArray() + { + iBurstItems.ResetAndDestroy(); + iBurstItems.Close(); + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::SetNameL +// Sets an item's full file path and image name +// --------------------------------------------------------------------------- +// +void CCamBurstCaptureArray::SetNameL( const TDesC& aFullFileName, + const TDesC& aImageName, TInt aIndex ) + { + PRINT1( _L("Camera => CCamBurstCaptureArray::SetNameL, name:[%S]"), &aFullFileName ); + iBurstItems[aIndex]->SetNameL( aFullFileName, aImageName ); + PRINT( _L("Camera <= CCamBurstCaptureArray::SetNameL") ); + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::AlreadySavedFile +// Returns whether a particular file has already been saved. +// --------------------------------------------------------------------------- +// +TBool CCamBurstCaptureArray::AlreadySavedFile( const TDesC& aFilename ) + { + return iImageSaveActive.AlreadySavedFile( aFilename ); + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::CurrentlySavingFile +// Returns whether a particular file is in the process of being saved. +// --------------------------------------------------------------------------- +// +TBool CCamBurstCaptureArray::CurrentlySavingFile( const TDesC& aFilename ) + { + return iImageSaveActive.CurrentlySavingFile( aFilename ); + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::Count +// Return the number of items in the array +// --------------------------------------------------------------------------- +// +TInt CCamBurstCaptureArray::Count() const + { + return iBurstItems.Count(); + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::Reset +// Delete unwanted items from the array +// --------------------------------------------------------------------------- +// +void CCamBurstCaptureArray::Reset( TInt aRequiredCount ) + { + PRINT1( _L("Camera => CCamBurstCaptureArray::Reset(%d)"), aRequiredCount ); + TInt count = iBurstItems.Count(); + // if the current count is less than the required count + if ( aRequiredCount >= count ) + { + return; + } + // if the required count is 0 or less, empty the array + if ( aRequiredCount <= 0 ) + { + iBurstItems.ResetAndDestroy(); + iNextSetName = 0; + iNextGetName = 0; + iNextSnapshot = 0; + iImagesRemaining = 0; + } + // otherwise delete the unwanted items + else + { + TInt index; + // repeat for every extra item + for ( index = count - 1; index >= aRequiredCount; index-- ) + { + CCamBurstCaptureItem* item = iBurstItems[index]; + if ( !item->IsDeleted() ) + { + iImagesRemaining--; + } + iBurstItems.Remove( index ); + delete item; + } + // reset the accessing indexes if necessary + count = iBurstItems.Count(); + iNextSetName = Min( iNextSetName, count ); + iNextSnapshot = Min( iNextSnapshot, count ); + } + User::Heap().Compress(); + PRINT( _L("Camera <= CCamBurstCaptureArray::Reset") ); + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::SetNextNameL +// Set the item's full file path and image name +// --------------------------------------------------------------------------- +// +void CCamBurstCaptureArray::SetNextNameL( const TDesC& aFullFileName, const TDesC& aImageName ) + { + PRINT1( _L("Camera => CCamBurstCaptureArray::SetNextNameL, name:[%S]"), &aFullFileName ); + CheckArraySizeL( iNextSetName ); + iBurstItems[iNextSetName]->SetNameL( aFullFileName, aImageName ); + iNextSetName++; + PRINT( _L("Camera <= CCamBurstCaptureArray::SetNextNameL") ); + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::SetNextSnapshotL +// Stores the snapshot bitmap in the item +// --------------------------------------------------------------------------- +// +void CCamBurstCaptureArray::SetNextSnapshotL( const CFbsBitmap& aSnapshot ) + { + PRINT( _L("Camera => CCamBurstCaptureArray::SetNextSnapshotL") ); + CheckArraySizeL( iNextSnapshot ); + TInt nextIndex = iNextSnapshot; + iNextSnapshot++; + iBurstItems[nextIndex]->SetSnapshotL( aSnapshot ); + PRINT( _L("Camera <= CCamBurstCaptureArray::SetNextSnapshotL") ); + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::SetDeleted +// Sets the items deletion state +// --------------------------------------------------------------------------- +// +TInt CCamBurstCaptureArray::SetDeleted( TInt aItemIndex, TBool aDeleted ) + { + PRINT2( _L("Camera => CCamBurstCaptureArray::SetDeleted( index:%d, deleted:%d )"), aItemIndex, aDeleted ); + TInt ret = KErrNone; + + __ASSERT_DEBUG( aItemIndex < Count() && aItemIndex >= 0, + CamPanic( ECamPanicBadIndex ) ); + + if ( aDeleted == iBurstItems[aItemIndex]->IsDeleted() ) + { + PRINT( _L("Camera <= CCamBurstCaptureArray::SetDeleted A") ); + return ret; + } + + if ( aDeleted ) + { + //iImagesRemaining--; + TInt saveRequested = EFalse; + // if the image save has already been requested + if ( aItemIndex < iNextGetName ) + { + saveRequested = ETrue; + } + iImageSaveActive.CancelThumbnail( aItemIndex ); + ret = iImageSaveActive.DeleteFile( iBurstItems[aItemIndex]->FileName(), saveRequested ); + + PRINT1( _L("Camera <> CCamBurstCaptureArray::SetDeleted iImageSaveActive.DeleteFile() returned %d" ), ret ); + if ( ret == KErrInUse ) + { + User::After( 700000 ); + ret = iImageSaveActive.DeleteFile( iBurstItems[aItemIndex]->FileName(), saveRequested ); + PRINT1( _L("Camera <> CCamBurstCaptureArray::SetDeleted iImageSaveActive.DeleteFile() Retry Delete returned %d" ), ret ); + } + // file might have already been deleted and that's ok so ignore -NotFound errors + if( ret == KErrNone || ret == KErrNotFound || ret == KErrPathNotFound ) + { + iImagesRemaining--; + } + } + else + { + iImagesRemaining++; + } + if( ret == KErrNone || ret == KErrNotFound || ret == KErrPathNotFound ) + { + iBurstItems[aItemIndex]->SetDeleted( aDeleted ); + } + + PRINT( _L("Camera <= CCamBurstCaptureArray::SetDeleted B") ); + return ret; + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::IsNextImageDeleted +// Increments iNextGetName and returns ETrue if the next image is marked for +// deletion, otherwise returns EFalse +// --------------------------------------------------------------------------- +// +TBool CCamBurstCaptureArray::IsNextImageDeleted() + { + PRINT( _L("Camera => CCamBurstCaptureArray::IsNextImageDeleted") ); + TBool deleted( EFalse ); + + if ( iNextGetName >= Count() ) + { + PRINT2( _L("Camera <> index(%d) out of range(%d), return deleted"), iNextGetName, Count() ); + deleted = ETrue; + } + else if ( iBurstItems[iNextGetName]->IsDeleted() ) + { + PRINT( _L("Camera <> next item marked deleted") ); + iNextGetName++; + deleted = ETrue; + } + else + { + deleted = EFalse; + } + + PRINT1( _L("Camera <= CCamBurstCaptureArray::IsNextImageDeleted, return: %d"), deleted ); + return deleted; + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::NextFileName +// Returns a pointer to the full file path and name for the next image +// --------------------------------------------------------------------------- +// +const TDesC& CCamBurstCaptureArray::NextFileName() + { + PRINT( _L("Camera => CCamBurstCaptureArray::NextFileName") ); + if ( iNextGetName >= Count() ) + { + PRINT( _L("Camera <> Returning KNullDesC") ); + return KNullDesC; + } + + TInt itemIndex = iNextGetName; + iNextGetName++; + + PRINT( _L("Camera <= CCamBurstCaptureArray::NextFileName") ); + return iBurstItems[itemIndex]->FileName(); + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::NextFileIndex +// Returns the index of the next image +// --------------------------------------------------------------------------- +// +TInt CCamBurstCaptureArray::NextFileIndex() const + { + return iNextGetName; + } + + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::FileName +// Returns a pointer to the full file path and name +// --------------------------------------------------------------------------- +// +const TDesC& CCamBurstCaptureArray::FileName( TInt aItemIndex ) const + { + if ( aItemIndex >= Count() || aItemIndex < 0 ) + { + return KNullDesC; + } + return iBurstItems[aItemIndex]->FileName(); + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::ImageName +// Returns a pointer to the image name +// --------------------------------------------------------------------------- +// +const TDesC& CCamBurstCaptureArray::ImageName( TInt aItemIndex ) const + { + if ( aItemIndex >= Count() || aItemIndex < 0 ) + { + return KNullDesC; + } + return iBurstItems[aItemIndex]->ImageName(); + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::Snapshot +// Returns a pointer to the snapshot image +// --------------------------------------------------------------------------- +// +const CFbsBitmap* CCamBurstCaptureArray::Snapshot( TInt aItemIndex ) const + { + if ( aItemIndex >= Count() || aItemIndex < 0 ) + { + return NULL; + } + return iBurstItems[aItemIndex]->Snapshot(); + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::IsDeleted +// Returns the item's deletion state +// --------------------------------------------------------------------------- +// +TBool CCamBurstCaptureArray::IsDeleted( TInt aItemIndex ) const + { + if ( aItemIndex >= Count() ) + { + return ETrue; + } + return iBurstItems[aItemIndex]->IsDeleted(); + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::ReplaceSnapshot +// Replaces the bitmap in the given index. +// --------------------------------------------------------------------------- +// +TBool CCamBurstCaptureArray::ReplaceSnapshot( + const CFbsBitmap* aBitmap, + TInt aItemIndex ) + { + if ( ( iBurstItems.Count() > aItemIndex ) && + ( aItemIndex >= 0 ) ) + { + return iBurstItems[aItemIndex]->ReplaceSnapshot( aBitmap ); + } + return EFalse; + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::CCamBurstCaptureArray +// C++ constructor +// --------------------------------------------------------------------------- +// +CCamBurstCaptureArray::CCamBurstCaptureArray( CCamImageSaveActive& aImageSaveActive ) +: iImageSaveActive( aImageSaveActive ) + { + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::ConstructL +// Second phase construction +// --------------------------------------------------------------------------- +// +void CCamBurstCaptureArray::ConstructL() + { + } + +// --------------------------------------------------------------------------- +// CCamBurstCaptureArray::CheckArraySizeL +// Add extra items to the array if required +// --------------------------------------------------------------------------- +// +void CCamBurstCaptureArray::CheckArraySizeL( TInt aRequiredIndex ) + { + TInt count = Count(); + TInt i; + for ( i = count; i <= aRequiredIndex; i++ ) + { + CCamBurstCaptureItem* newItem = CCamBurstCaptureItem::NewLC(); + iBurstItems.AppendL( newItem ); + CleanupStack::Pop( newItem ); + iImagesRemaining++; + } + } + +// End of File