1 /*

     2 * Copyright (c) 2007-2008 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:  A class that represents a single item in a burst capture

    15 *

    16 * Copyright © 2007-2008 Nokia.  All rights reserved.

    17 *  This material, including documentation and any related computer

    18 *  programs, is protected by copyright controlled by Nokia.  All

    19 *  rights are reserved.  Copying, including reproducing, storing,

    20 *  adapting or translating, any or all of this material requires the

    21 *  prior written consent of Nokia.  This material also contains

    22 *  confidential information which may not be disclosed to others

    23 *  without the prior written consent of Nokia.

    24 

    25 *

    26 *

    27 */

    28 

    29 

    30 // INCLUDE FILES

    31 #include <fbs.h>

    32 #include <eikenv.h>

    33 #include <barsread.h>

    34 #include <AknUtils.h>

    35 

    36 #include <cameraapp.rsg>

    37 #include <vgacamsettings.rsg>

    38 

    39 #include "CamBurstCaptureArray.h"

    40 #include "CamImageSaveActive.h"

    41 #include "CamPanic.h"

    42 #include "camlogging.h"

    43 

    44 

    45 // CONSTANTS

    46 

    47 // ================= MEMBER FUNCTIONS =======================

    48 

    49 // -----------------------------------------------------------------------------

    50 // CCamBurstCaptureItem::NewLC

    51 // Two-phased constructor.

    52 // -----------------------------------------------------------------------------

    53 //

    54 CCamBurstCaptureArray::CCamBurstCaptureItem* CCamBurstCaptureArray::CCamBurstCaptureItem::NewLC()

    55     {

    56     CCamBurstCaptureItem* self = new( ELeave ) CCamBurstCaptureItem();

    57     CleanupStack::PushL( self );

    58     self->ConstructL();

    59     return self;

    60     }

    61 

    62 // ---------------------------------------------------------------------------

    63 // CCamBurstCaptureItem destructor

    64 // 

    65 // ---------------------------------------------------------------------------

    66 //

    67 CCamBurstCaptureArray::CCamBurstCaptureItem::~CCamBurstCaptureItem()

    68   {

    69   PRINT( _L("Camera => ~CCamBurstCaptureItem") );

    70   delete iFileName;

    71   delete iImageName;

    72   delete iSnapshot;

    73   PRINT( _L("Camera <= ~CCamBurstCaptureItem") );

    74   }

    75 

    76 // ---------------------------------------------------------------------------

    77 // CCamBurstCaptureItem::SetNameL

    78 // Sets the item's full file path and image name

    79 // ---------------------------------------------------------------------------

    80 //

    81 void CCamBurstCaptureArray::CCamBurstCaptureItem::SetNameL( const TDesC& aFullFileName, 

    82                                     const TDesC& aImageName )

    83     {

    84     delete iFileName;

    85     iFileName = NULL;

    86     delete iImageName;

    87     iImageName = NULL;

    88     iFileName = aFullFileName.AllocL();

    89     iImageName = aImageName.AllocL();

    90     }

    91 

    92 // ---------------------------------------------------------------------------

    93 // CCamBurstCaptureItem::SetSnapshotL

    94 // Stores the snapshot bitmap in the item

    95 // ---------------------------------------------------------------------------

    96 //

    97 void CCamBurstCaptureArray::CCamBurstCaptureItem::SetSnapshotL( const CFbsBitmap& aSnapshot ) 

    98     {

    99     delete iSnapshot;

   100     iSnapshot = NULL;

   101 

   102     // Create bitmap

   103     iSnapshot = new( ELeave ) CFbsBitmap();

   104     TInt createError = iSnapshot->Duplicate( aSnapshot.Handle() );

   105 

   106     if ( createError )

   107         {

   108         delete iSnapshot;

   109         iSnapshot = NULL;

   110         }

   111 

   112     User::LeaveIfError( createError );

   113     }

   114 

   115 // ---------------------------------------------------------------------------

   116 // CCamBurstCaptureItem::SetDeleted

   117 // Sets the item's deletion state

   118 // ---------------------------------------------------------------------------

   119 //

   120 void CCamBurstCaptureArray::CCamBurstCaptureItem::SetDeleted( TBool aDeleted ) 

   121     {

   122     iIsDeleted = aDeleted;

   123     }

   124 

   125 // ---------------------------------------------------------------------------

   126 // CCamBurstCaptureItem::FileName

   127 // Return a pointer to the full file path and name

   128 // ---------------------------------------------------------------------------

   129 //

   130 const TDesC& CCamBurstCaptureArray::CCamBurstCaptureItem::FileName() const

   131     {

   132     if( !iFileName )

   133       {

   134       return KNullDesC;

   135       }

   136     else

   137       {  

   138       return *iFileName;

   139       }

   140     }

   141 

   142 // ---------------------------------------------------------------------------

   143 // CCamBurstCaptureItem::ImageName

   144 // Return a pointer to the image name

   145 // ---------------------------------------------------------------------------

   146 //

   147 const TDesC& CCamBurstCaptureArray::CCamBurstCaptureItem::ImageName() const

   148     {

   149     return *iImageName;

   150     }

   151 

   152 // ---------------------------------------------------------------------------

   153 // CCamCaptureSetupListItem::Bitmap

   154 // Return a pointer to the bitmap

   155 // ---------------------------------------------------------------------------

   156 //

   157 const CFbsBitmap* CCamBurstCaptureArray::CCamBurstCaptureItem::Snapshot() const

   158     {

   159     return iSnapshot;

   160     }

   161 

   162 // ---------------------------------------------------------------------------

   163 // CCamBurstCaptureItem::IsDeleted

   164 // Whether or not the item has been marked for deletion

   165 // ---------------------------------------------------------------------------

   166 //

   167 TBool CCamBurstCaptureArray::CCamBurstCaptureItem::IsDeleted() const

   168     {

   169     return iIsDeleted;

   170     }

   171       

   172 // ---------------------------------------------------------------------------

   173 // CCamBurstCaptureArray::CCamBurstCaptureItem::ReplaceSnapshot

   174 // Replaces the bitmap.

   175 // ---------------------------------------------------------------------------

   176 // 

   177 TBool CCamBurstCaptureArray::CCamBurstCaptureItem::ReplaceSnapshot( 

   178     const CFbsBitmap* aBitmap )

   179     {

   180     if( !iSnapshot )

   181         {

   182         TRAPD( err, iSnapshot = new( ELeave ) CFbsBitmap() );

   183         if( err )

   184             {

   185             return EFalse;

   186             }

   187         }

   188     if ( iSnapshot->Duplicate( aBitmap->Handle() ) )

   189         {

   190         return EFalse;

   191         }

   192     return ETrue;

   193     } 

   194 

   195 // ---------------------------------------------------------------------------

   196 // CCamBurstCaptureItem::CCamBurstCaptureItem

   197 // C++ constructor

   198 // ---------------------------------------------------------------------------

   199 //

   200 CCamBurstCaptureArray::CCamBurstCaptureItem::CCamBurstCaptureItem()

   201     {

   202     }

   203 

   204 // ---------------------------------------------------------------------------

   205 // CCamBurstCaptureItem::ConstructL

   206 // Second phase construction

   207 // ---------------------------------------------------------------------------

   208 //

   209 void CCamBurstCaptureArray::CCamBurstCaptureItem::ConstructL()

   210     {

   211     }

   212 

   213 // -----------------------------------------------------------------------------

   214 // CCamBurstCaptureArray::NewLC

   215 // Two-phased constructor.

   216 // -----------------------------------------------------------------------------

   217 //

   218 CCamBurstCaptureArray* CCamBurstCaptureArray::NewL( CCamImageSaveActive& aImageSaveActive )

   219     {

   220     CCamBurstCaptureArray* self = new( ELeave ) CCamBurstCaptureArray( aImageSaveActive );

   221     CleanupStack::PushL( self );

   222     self->ConstructL();

   223     CleanupStack::Pop( self );

   224     return self;

   225     }

   226 

   227 // ---------------------------------------------------------------------------

   228 // CCamBurstCaptureArray destructor

   229 // 

   230 // ---------------------------------------------------------------------------

   231 //

   232 CCamBurstCaptureArray::~CCamBurstCaptureArray()

   233     {

   234     iBurstItems.ResetAndDestroy();

   235     iBurstItems.Close();

   236     }

   237 

   238 // ---------------------------------------------------------------------------

   239 // CCamBurstCaptureArray::SetNameL

   240 // Sets an item's full file path and image name

   241 // ---------------------------------------------------------------------------

   242 //

   243 void CCamBurstCaptureArray::SetNameL( const TDesC& aFullFileName, 

   244     const TDesC& aImageName, TInt aIndex )

   245     {

   246     PRINT1( _L("Camera => CCamBurstCaptureArray::SetNameL, name:[%S]"), &aFullFileName );  

   247     iBurstItems[aIndex]->SetNameL( aFullFileName, aImageName );

   248     PRINT( _L("Camera <= CCamBurstCaptureArray::SetNameL") );

   249     }

   250 

   251 // ---------------------------------------------------------------------------

   252 // CCamBurstCaptureArray::AlreadySavedFile

   253 // Returns whether a particular file has already been saved.

   254 // ---------------------------------------------------------------------------

   255 //

   256 TBool CCamBurstCaptureArray::AlreadySavedFile( const TDesC& aFilename )

   257     {

   258     return iImageSaveActive.AlreadySavedFile( aFilename );

   259     }

   260 

   261 // ---------------------------------------------------------------------------

   262 // CCamBurstCaptureArray::CurrentlySavingFile

   263 // Returns whether a particular file is in the process of being saved.

   264 // ---------------------------------------------------------------------------

   265 //

   266 TBool CCamBurstCaptureArray::CurrentlySavingFile( const TDesC& aFilename )

   267     {

   268     return iImageSaveActive.CurrentlySavingFile( aFilename );

   269     }

   270 

   271 // ---------------------------------------------------------------------------

   272 // CCamBurstCaptureArray::Count

   273 // Return the number of items in the array

   274 // ---------------------------------------------------------------------------

   275 //

   276 TInt CCamBurstCaptureArray::Count() const

   277     {

   278     return iBurstItems.Count();

   279     }

   280 

   281 // ---------------------------------------------------------------------------

   282 // CCamBurstCaptureArray::Reset

   283 // Delete unwanted items from the array

   284 // ---------------------------------------------------------------------------

   285 //

   286 void CCamBurstCaptureArray::Reset( TInt aRequiredCount )

   287     {

   288     PRINT1( _L("Camera => CCamBurstCaptureArray::Reset(%d)"), aRequiredCount );

   289     TInt count = iBurstItems.Count();

   290     // if the current count is less than the required count

   291     if ( aRequiredCount >= count )

   292         {

   293         return;

   294         }

   295     // if the required count is 0 or less, empty the array

   296     if ( aRequiredCount <= 0 )

   297         {

   298         iBurstItems.ResetAndDestroy();

   299         iNextSetName = 0;

   300         iNextGetName = 0;

   301         iNextSnapshot = 0;

   302         iImagesRemaining = 0;

   303         }

   304     // otherwise delete the unwanted items

   305     else

   306         {

   307         TInt index;

   308         // repeat for every extra item

   309         for ( index = count - 1; index >= aRequiredCount; index-- )

   310             {

   311             CCamBurstCaptureItem* item = iBurstItems[index];

   312             if ( !item->IsDeleted() )

   313                 {

   314                 iImagesRemaining--;

   315                 }

   316             iBurstItems.Remove( index );

   317             delete item;

   318             }

   319         // reset the accessing indexes if necessary

   320         count = iBurstItems.Count();

   321         iNextSetName = Min( iNextSetName, count );

   322         iNextSnapshot = Min( iNextSnapshot, count );

   323         }

   324     User::Heap().Compress();    

   325     PRINT( _L("Camera <= CCamBurstCaptureArray::Reset") );

   326     }

   327 

   328 // ---------------------------------------------------------------------------

   329 // CCamBurstCaptureArray::SetNextNameL

   330 // Set the item's full file path and image name

   331 // ---------------------------------------------------------------------------

   332 // 

   333 void CCamBurstCaptureArray::SetNextNameL( const TDesC& aFullFileName, const TDesC& aImageName )

   334     {

   335     PRINT1( _L("Camera => CCamBurstCaptureArray::SetNextNameL, name:[%S]"), &aFullFileName );

   336     CheckArraySizeL( iNextSetName );

   337     iBurstItems[iNextSetName]->SetNameL( aFullFileName, aImageName );

   338     iNextSetName++;

   339     PRINT( _L("Camera <= CCamBurstCaptureArray::SetNextNameL") );

   340     }

   341 

   342 // ---------------------------------------------------------------------------

   343 // CCamBurstCaptureArray::SetNextSnapshotL

   344 // Stores the snapshot bitmap in the item

   345 // ---------------------------------------------------------------------------

   346 //  

   347 void CCamBurstCaptureArray::SetNextSnapshotL( const CFbsBitmap& aSnapshot )

   348     {

   349     PRINT( _L("Camera => CCamBurstCaptureArray::SetNextSnapshotL") );

   350     CheckArraySizeL( iNextSnapshot );

   351     TInt nextIndex = iNextSnapshot;

   352     iNextSnapshot++;

   353     iBurstItems[nextIndex]->SetSnapshotL( aSnapshot );

   354     PRINT( _L("Camera <= CCamBurstCaptureArray::SetNextSnapshotL") );

   355     }

   356 

   357 // ---------------------------------------------------------------------------

   358 // CCamBurstCaptureArray::SetDeleted

   359 // Sets the items deletion state

   360 // ---------------------------------------------------------------------------

   361 //   

   362 TInt CCamBurstCaptureArray::SetDeleted( TInt aItemIndex, TBool aDeleted )

   363     {

   364     PRINT2( _L("Camera => CCamBurstCaptureArray::SetDeleted( index:%d, deleted:%d )"), aItemIndex, aDeleted );

   365     TInt ret = KErrNone;

   366 

   367     __ASSERT_DEBUG( aItemIndex < Count() && aItemIndex >= 0,

   368         CamPanic( ECamPanicBadIndex ) );

   369 

   370     if ( aDeleted == iBurstItems[aItemIndex]->IsDeleted() )

   371         {

   372         PRINT( _L("Camera <= CCamBurstCaptureArray::SetDeleted A") );

   373         return ret;

   374         }

   375    

   376     if ( aDeleted )

   377         {

   378         //iImagesRemaining--;

   379         TInt saveRequested = EFalse;

   380         // if the image save has already been requested

   381         if ( aItemIndex < iNextGetName )

   382             {

   383             saveRequested = ETrue;

   384             }

   385         iImageSaveActive.CancelThumbnail( aItemIndex );

   386         ret = iImageSaveActive.DeleteFile( iBurstItems[aItemIndex]->FileName(), saveRequested );

   387 

   388         PRINT1( _L("Camera <> CCamBurstCaptureArray::SetDeleted iImageSaveActive.DeleteFile() returned %d" ), ret );

   389         // file might have already been deleted and that's ok so ignore -NotFound errors

   390         if( ret == KErrNone || ret == KErrNotFound || ret == KErrPathNotFound )

   391             {

   392             iImagesRemaining--;

   393             }

   394         }

   395     else

   396         {

   397         iImagesRemaining++;

   398         }

   399     if( ret == KErrNone || ret == KErrNotFound || ret == KErrPathNotFound )

   400         {

   401         iBurstItems[aItemIndex]->SetDeleted( aDeleted );

   402         }

   403 

   404     PRINT( _L("Camera <= CCamBurstCaptureArray::SetDeleted B") );

   405     return ret;

   406     }

   407 

   408 // ---------------------------------------------------------------------------

   409 // CCamBurstCaptureArray::IsNextImageDeleted

   410 // Increments iNextGetName and returns ETrue if the next image is marked for 

   411 // deletion, otherwise returns EFalse 

   412 // ---------------------------------------------------------------------------

   413 // 

   414 TBool CCamBurstCaptureArray::IsNextImageDeleted()

   415   {

   416   PRINT( _L("Camera => CCamBurstCaptureArray::IsNextImageDeleted") );  

   417   TBool deleted( EFalse );

   418 

   419   if ( iNextGetName >= Count() )

   420     {

   421     PRINT2( _L("Camera <> index(%d) out of range(%d), return deleted"), iNextGetName, Count() );

   422     deleted = ETrue;

   423     }

   424   else if ( iBurstItems[iNextGetName]->IsDeleted() )

   425     {

   426     PRINT( _L("Camera <> next item marked deleted") );

   427     iNextGetName++;

   428     deleted = ETrue;

   429     }

   430   else

   431     {

   432     deleted = EFalse;

   433     }

   434 

   435   PRINT1( _L("Camera <= CCamBurstCaptureArray::IsNextImageDeleted, return: %d"), deleted );  

   436   return deleted;

   437     }

   438 

   439 // ---------------------------------------------------------------------------

   440 // CCamBurstCaptureArray::NextFileName

   441 // Returns a pointer to the full file path and name for the next image

   442 // ---------------------------------------------------------------------------

   443 //    

   444 const TDesC& CCamBurstCaptureArray::NextFileName()

   445     {

   446     PRINT( _L("Camera => CCamBurstCaptureArray::NextFileName") );  

   447     if ( iNextGetName >= Count() )

   448         {

   449         PRINT( _L("Camera <> Returning KNullDesC") );  

   450         return KNullDesC;

   451         }

   452 

   453     TInt itemIndex = iNextGetName;

   454     iNextGetName++;

   455 

   456     PRINT( _L("Camera <= CCamBurstCaptureArray::NextFileName") );  

   457     return iBurstItems[itemIndex]->FileName();

   458     }

   459 

   460 // ---------------------------------------------------------------------------

   461 // CCamBurstCaptureArray::NextFileIndex

   462 // Returns the index of the next image

   463 // ---------------------------------------------------------------------------

   464 // 

   465 TInt CCamBurstCaptureArray::NextFileIndex() const

   466     {

   467     return iNextGetName;

   468     }

   469 

   470 

   471 // ---------------------------------------------------------------------------

   472 // CCamBurstCaptureArray::FileName

   473 // Returns a pointer to the full file path and name

   474 // ---------------------------------------------------------------------------

   475 //   

   476 const TDesC& CCamBurstCaptureArray::FileName( TInt aItemIndex ) const

   477     {

   478     if ( aItemIndex >= Count() || aItemIndex < 0 )

   479         {

   480         return KNullDesC;

   481         }

   482     return iBurstItems[aItemIndex]->FileName();

   483     }

   484 

   485 // ---------------------------------------------------------------------------

   486 // CCamBurstCaptureArray::ImageName

   487 // Returns a pointer to the image name 

   488 // ---------------------------------------------------------------------------

   489 //  

   490 const TDesC& CCamBurstCaptureArray::ImageName( TInt aItemIndex ) const

   491     {

   492     if ( aItemIndex >= Count() || aItemIndex < 0 )

   493         {

   494         return KNullDesC;

   495         }

   496     return iBurstItems[aItemIndex]->ImageName();

   497     }

   498 

   499 // ---------------------------------------------------------------------------

   500 // CCamBurstCaptureArray::Snapshot

   501 // Returns a pointer to the snapshot image

   502 // ---------------------------------------------------------------------------

   503 // 

   504 const CFbsBitmap* CCamBurstCaptureArray::Snapshot( TInt aItemIndex ) const

   505     {

   506     if ( aItemIndex >= Count() || aItemIndex < 0 )

   507         {

   508         return NULL;

   509         }

   510     return iBurstItems[aItemIndex]->Snapshot();

   511     }

   512 

   513 // ---------------------------------------------------------------------------

   514 // CCamBurstCaptureArray::IsDeleted

   515 // Returns the item's deletion state

   516 // ---------------------------------------------------------------------------

   517 // 

   518 TBool CCamBurstCaptureArray::IsDeleted( TInt aItemIndex ) const

   519     {

   520     if ( aItemIndex >= Count() )

   521         {

   522         return ETrue;

   523         }

   524     return iBurstItems[aItemIndex]->IsDeleted();

   525     }

   526   

   527 // ---------------------------------------------------------------------------

   528 // CCamBurstCaptureArray::ReplaceSnapshot

   529 // Replaces the bitmap in the given index.

   530 // ---------------------------------------------------------------------------

   531 // 

   532 TBool CCamBurstCaptureArray::ReplaceSnapshot( 

   533     const CFbsBitmap* aBitmap, 

   534     TInt aItemIndex )

   535     {

   536     if ( ( iBurstItems.Count() > aItemIndex ) &&

   537         ( aItemIndex >= 0 ) )

   538         {

   539         return iBurstItems[aItemIndex]->ReplaceSnapshot( aBitmap );

   540         }

   541     return EFalse;

   542     } 

   543 

   544 // ---------------------------------------------------------------------------

   545 // CCamBurstCaptureArray::CCamBurstCaptureArray

   546 // C++ constructor

   547 // ---------------------------------------------------------------------------

   548 //   

   549 CCamBurstCaptureArray::CCamBurstCaptureArray( CCamImageSaveActive& aImageSaveActive )

   550 : iImageSaveActive( aImageSaveActive )

   551     {

   552     }

   553 

   554 // ---------------------------------------------------------------------------

   555 // CCamBurstCaptureArray::ConstructL

   556 // Second phase construction

   557 // ---------------------------------------------------------------------------

   558 //

   559 void CCamBurstCaptureArray::ConstructL()

   560     {

   561     }

   562 

   563 // ---------------------------------------------------------------------------

   564 // CCamBurstCaptureArray::CheckArraySizeL

   565 // Add extra items to the array if required

   566 // ---------------------------------------------------------------------------

   567 //

   568 void CCamBurstCaptureArray::CheckArraySizeL( TInt aRequiredIndex )

   569     {

   570     TInt count = Count();

   571     TInt i;

   572     for ( i = count; i <= aRequiredIndex; i++ )

   573         {

   574         CCamBurstCaptureItem* newItem = CCamBurstCaptureItem::NewLC();

   575         iBurstItems.AppendL( newItem );

   576         CleanupStack::Pop( newItem );

   577         iImagesRemaining++;

   578         }

   579     }

   580 

   581 //  End of File