/*

* Copyright (c) 2007-2009 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:  Active object that manages saving and deletion of images*

*/

// INCLUDE FILES

#include <badesca.h>

#include <eikenv.h>

#include <sysutil.h>

#include <AknProgressDialog.h>

#include <eikprogi.h>

#include <StringLoader.h>

#include <AknQueryDialog.h>

#include <pathinfo.h>

// includes to allow reporting to LifeBlog via publish and subscribe API

#include <e32property.h>

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include "CamImageSaveActive.h"

#include "CamPanic.h"

#include "CamUtility.h"

#include "CamPerformance.h"

#include "cambuffershare.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CamImageSaveActiveTraces.h"

#endif

#include "camuidconstants.h" // KPSUidCamcorderNotifier

#include "CameraappPrivateCRKeys.h"

#include "CamAppController.h"

#include "CameraUiConfigManager.h"

#include "CamBurstCaptureArray.h"

const TUint32 KCamLatestFilePath      = 0x00000001;

const TInt    KArrayGranularity       = 2;

const TInt    KCapturedAlbumId        = 2; 

// CONSTANTS

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

// -----------------------------------------------------------------------------

// CCamImageSaveActive::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CCamImageSaveActive* CCamImageSaveActive::NewL( MCamImageSaveObserver& aObserver,  

                                                CCamAppController&  aController )

    {

    PRINT( _L("Camera => CCamImageSaveActive::NewL") );

    CCamImageSaveActive* self = new( ELeave ) CCamImageSaveActive( aObserver, 

                                                                   aController );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    PRINT( _L("Camera <= CCamImageSaveActive::NewL") );

    return self;

    }

// -----------------------------------------------------------------------------

// CCamImageSaveActive::~CCamImageSaveActive

// Destructor

// -----------------------------------------------------------------------------

//

CCamImageSaveActive::~CCamImageSaveActive()

    {

    PRINT( _L("Camera => ~CCamImageSaveActive") );

    delete iSaveArray;

    delete iNameArray;

    iSnapArray.ResetAndDestroy();

    delete iManager;

    ReleaseAllAndDestroy( iImageArray );

    iImageArray.Close();

    iThumbnailRequests.Close();

    DoDismissProgressNote();

#if defined(RD_MDS_2_5) && !defined(__WINSCW__) && !defined(__WINS__)

    DeRegisterHarverterClientEvents();

#endif // defined(RD_MDS_2_5) && !defined(__WINSCW__) && !defined(__WINS__)

    PRINT( _L("Camera <= ~CCamImageSaveActive") );

    }

// -----------------------------------------------------------------------------

// CCamImageSaveActive::Cancel

// Cancel any current or pending actions

// -----------------------------------------------------------------------------

//

void CCamImageSaveActive::Cancel()

    {

    PRINT( _L( "Camera => CCamImageSaveActive::Cancel" ) );

    TBool storageOk( ETrue );

    if ( iController.SequenceCaptureInProgress() )

        {

        TCamMediaStorage storageLocation = static_cast<TCamMediaStorage> ( 

                iController.IntegerSettingValueUnfiltered(  

                        ECamSettingItemPhotoMediaStorage ) );

        if ( storageLocation == ECamMediaStorageCard )

            {

            // Avoid deleting and saving to drive which does not exist

            storageOk = CamUtility::MemoryCardStatus() == ECamMemoryCardInserted;

            PRINT1( _L( "Camera => CCamImageSaveActive::Cancel storageOk=%d" ), storageOk);

            }

        }

    // Since this function may be called in the destructor, we need to check

    // that iSaveArray is not null. 

    if(iSaveArray)

        {

        TInt count = iSaveArray->Count() - 1;

        TInt lowest = 0;

        if ( iSaveCurrent )

            {

            lowest = 1;

            }

        TInt i;

        // Delete all dummy files except any currently saving one

        for ( i = count; i >= lowest; i-- )

            {

            PRINT1( _L( "Camera Deleting file index %d" ), i );         

            if( storageOk )

                {

                DeleteFile( iSaveArray->MdcaPoint( i ), ETrue );  

                }

            }

        }

    // if a file is currently saving, delay cleanup till save completes

    // if ( iSaveCurrent )

    if ( IsActive() && storageOk )

        {

        PRINT( _L( "Camera File currently saving delay cleanup" ) );         

        iDoCancel = ETrue;

        if ( !iWait.IsStarted() )

          {

          iWait.Start();

          }

        }

    // otherwise, complete cleanup now

    else

        {

        PRINT( _L( "Camera No file saving cleanup now" ) );         

        DoDismissProgressNote();

        CActive::Cancel();

        if(iSaveArray)

            {

            iSaveArray->Reset();

            }

        ReleaseAllAndDestroy( iImageArray );

        }

    PRINT( _L( "Camera <= CCamImageSaveActive::Cancel" ) );         

    }

void CCamImageSaveActive::ForceCancel()

{

    CActive::Cancel();

}

// -----------------------------------------------------------------------------

// CCamImageSaveActive::AddToSave

// Add an image to the list of required saves, activate if needed

// -----------------------------------------------------------------------------

//

TBool CCamImageSaveActive::AddToSave( const TDesC&     aFilename, 

                                      CCamBufferShare* aImageData )

    {

    PRINT( _L("Camera => CCamImageSaveActive::AddToSave") );

    if( aImageData )

      {

      aImageData->Reserve();

      }

    // Keep note of how many items exist before we try to add a new one

    TInt count = iSaveArray->Count();

    TRAPD( err, iSaveArray->AppendL( aFilename ) );

    if ( !err )

        {

        TRAP( err, iImageArray.AppendL( aImageData ) );

        }

    // if any of the appends failed then clean out the partial item

    if ( err )

        {

        if ( iSaveArray->Count() > count )

            {

            iSaveArray->Delete( count );

            }

        if ( iImageArray.Count() > count )

            {

            iImageArray.Remove( count );

            if( aImageData )

              {

              aImageData->Release();

              }

            }

        PRINT( _L("Camera <= CCamImageSaveActive::AddToSave, error!") );

        return EFalse;

        }

    // the item is successfully added, start the save now if not currently saving

    if ( !IsActive() )

        {

        SetActiveAndCompleteRequest();

        }

    PRINT( _L("Camera <= CCamImageSaveActive::AddToSave, ok") );

    return ETrue;

    }

// -----------------------------------------------------------------------------

// CCamImageSaveActive::FileSize

// Returns the size of the data for the specified file

// -----------------------------------------------------------------------------

//    

TInt CCamImageSaveActive::FileSize( const TDesC& aFilename ) const

    {    

    TInt size = KErrNotFound;

    TInt count = iSaveArray->Count();

    TInt i;

    // Check to see if it is in the "to be saved" array

    for ( i = 0; i < count ; i++ )

        {

        TPtrC ptr = (*iSaveArray)[i];

        if ( aFilename.Compare( ptr ) == 0 )    

            {

            TRAP_IGNORE( size = iImageArray[i]->SharedBuffer()->DataL( 0 )->Size() );

            // size = iImageArray[i]->Size();

            return size;

            }

        }   

    // If we have got here, the requested file is NOT in the array

    // Check the file system to see if we have already saved it.

    RFs& fs = CEikonEnv::Static()->FsSession();

    RFile file;

    TInt ret = file.Open( fs, aFilename, EFileShareAny | EFileRead );    

    if ( ret == KErrNone )

        {

        file.Size( size );                

        }

    file.Close();        

    return size;

    }

// -----------------------------------------------------------------------------

// CCamImageSaveActive::DeleteFile

// Delete a file, cancelling any pending save

// -----------------------------------------------------------------------------

//

TInt CCamImageSaveActive::DeleteFile( const TDesC& aFilename, 

                                      TBool aSaveRequested )

    {

    RFs& fs = CEikonEnv::Static()->FsSession();

    if ( aSaveRequested )

        {

        TInt index;

        if ( iSaveArray->Find( aFilename, index ) == 0 )

            {

            // if the file is currently being saved

            if ( index == 0 && iSaveCurrent )

                {

                iDeleteCurrent = ETrue;

                return ETrue;

                }

            else

                {

                iSaveArray->Delete( index );

                iSaveArray->Compress();

                CCamBufferShare* item = iImageArray[index];

                iImageArray.Remove( index );

                if( item )

                  {

                  item->Release();

                  item = NULL;

                  }

                iImageArray.Compress();

                }

            } 

        }

    // Dummy files are read only for protection, make sure the file is writable

    fs.SetAtt( aFilename, 0, KEntryAttReadOnly );

    TInt ret = fs.Delete( aFilename );  

    ReportToObserver( ECamSaveEventDeleted );

    return ret;

    }

// ---------------------------------------------------------------------------

// CCamImageSaveActive::AlreadySavedFile

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

// ---------------------------------------------------------------------------

//

TBool CCamImageSaveActive::AlreadySavedFile( const TDesC& aFilename ) const

    {

    TInt index;

    return iSaveArray->Find( aFilename, index );

    }

// ---------------------------------------------------------------------------

// CCamImageSaveActive::CurrentlySavingFile

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

// ---------------------------------------------------------------------------

//

TBool CCamImageSaveActive::CurrentlySavingFile( const TDesC& aFilename ) const

    {

    TInt index;

    if ( iSaveCurrent && ( iSaveArray->Find( aFilename, index ) == 0 ) &&

        ( index == 0 ) )

        {

        return ETrue;

        }

    return EFalse;

    }

// -----------------------------------------------------------------------------

// CCamImageSaveActive::DisplayProgressNote

// Display the saving progress note until cancelled or completed

// -----------------------------------------------------------------------------

//

void CCamImageSaveActive::DisplayProgressNote( TInt aExpectedImages )

    {

    __ASSERT_DEBUG( !iDismissNote, CamPanic( ECamPanicInvalidState ) );

    // Initialise for a new burst set

    iSaveProgressCount = 0;

    iExpectedImages = aExpectedImages;

    iShowNote = ETrue;

    if ( !IsActive() )

        {

        SetActiveAndCompleteRequest();

        }

    }

// -----------------------------------------------------------------------------

// CCamImageSaveActive::DismissProgressNote

// Dismiss the saving progress note when completed

// -----------------------------------------------------------------------------

//

void CCamImageSaveActive::DismissProgressNote()

    {

    // if the progress note is still pending

    if ( iShowNote )

        {

        // the burst has completed already

        iShowNote = EFalse;

        ReportToObserver( ECamSaveEventBurstComplete );

        }

    // No saves are pending, dismiss the note now

    if ( !IsActive() )

        {

        DoDismissProgressNote();

        }

    else // otherwise, wait till all the saves complete

        {

        iDismissNote = ETrue;

        }

    }

// -----------------------------------------------------------------------------

// CCamImageSaveActive::SetAddImageToAlbum

// Set the "Add to album" feature on or off for photos

// -----------------------------------------------------------------------------

//

void CCamImageSaveActive::SetAddImageToAlbum( const TBool aAdding, 

                                              const TUint32 aDefaultAlbumId )

    {

    iAddImageToAlbum = aAdding;

    iDefaultAlbumId = aDefaultAlbumId;

    }

// -----------------------------------------------------------------------------

// CCamImageSaveActive::AddToAlbum

// Add the specified photo or video to the default capture album

// -----------------------------------------------------------------------------

//

#if defined(RD_MDS_2_5) && !defined(__WINSCW__) && !defined(__WINS__)

void CCamImageSaveActive::AddToAlbum( const TDesC& aFilename,

                                      const TBool aAddToAlbum,

                                      const TUint32 aDefaultAlbumId )

    {

    OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMIMAGESAVEACTIVE_ADDTOALBUM, "e_CCamImageSaveActive_AddToAlbum 1" );

    PRINT( _L("Camera => CCamImageSaveActive::AddToAlbum") );

    TInt err = KErrNone;

    RArray<TUint32> harvestAlbumIds;

    TUint32 harvestAlbumId;

    err = harvestAlbumIds.Append( KCapturedAlbumId ); 

    /*

    * NOTE: The default value of album Id defined as per CenRep key is 0, so 

    *       we add the any other album other than the default one as above

    *       Secondly, if there is no album set as default album from the 

    *       precapture settings views then we pass empty array to the harvester

    *       and MDS harvests the file to camera album directly i.e. captured.

    */

    if ( aAddToAlbum && aDefaultAlbumId > 0 )

       {

       harvestAlbumId = aDefaultAlbumId;

       err = harvestAlbumIds.Append( harvestAlbumId );

       }

    if ( !iHarvesterClientConnected )

        {

        PRINT( _L("Camera <> calling iHarvesterClient.Connect") );

        err = iHarvesterClient.Connect();

        if ( !err )

            {

            iHarvesterClientConnected = ETrue;

            }

        PRINT1( _L("Camera <> iHarvesterClient.Connect returned %d"), err );

        }

    if ( KErrNone == err )

        {

        RegisterForHarvesterEvents();

        PRINT( _L("Camera <> calling iHarvesterClient.HarvestFile") );

#ifdef RD_MDS_2_5   

        if ( iController.UiConfigManagerPtr() && iController.UiConfigManagerPtr()->IsLocationSupported() )

            {

            TBool location = iController.IntegerSettingValue( ECamSettingItemRecLocation );

			//Never save location information in second camera

            iHarvesterClient.HarvestFile( aFilename,

                                          harvestAlbumIds,

                                          location );

            }

        else

            {

            iHarvesterClient.HarvestFile( aFilename,

                                          harvestAlbumIds,

                                          EFalse );

            }

#else // RD_MDS_2_5

        iHarvesterClient.HarvestFile( aFilename,

                                      harvestAlbumIds );

#endif // RD_MDS_2_5

        PRINT( _L("Camera <> iHarvesterClient.HarvestFile returned") );

        }

    harvestAlbumIds.Close();

    PRINT( _L("Camera <= CCamImageSaveActive::AddToAlbum") );

    OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMIMAGESAVEACTIVE_ADDTOALBUM, "e_CCamImageSaveActive_AddToAlbum 0" );

    }

#else // defined(RD_MDS_2_5) && !defined(__WINSCW__) && !defined(__WINS__)

void CCamImageSaveActive::AddToAlbum( const TDesC&  /*aFilename*/,

                                      const TBool   /*aAddToAlbum*/,

                                      const TUint32 /*aDefaultAlbumId*/ )

    {

    }

#endif // defined(RD_MDS_2_5) && !defined(__WINSCW__) && !defined(__WINS__)

// -----------------------------------------------------------------------------

// CCamImageSaveActive::Count

// The number of items in the saving array

// -----------------------------------------------------------------------------

//

TInt CCamImageSaveActive::Count() const

    {

    return iSaveArray->Count();

    }

// -----------------------------------------------------------------------------

// CCamImageSaveActive::CCamImageSaveActive

// C++ constructor

// -----------------------------------------------------------------------------

//

CCamImageSaveActive::CCamImageSaveActive( MCamImageSaveObserver& aObserver,         

                                          CCamAppController&  aController )

    : CActive( EPriorityStandard ), iObserver( aObserver ), 

    iController( aController ),

    iFlushing( EFalse )

    {

    }

// -----------------------------------------------------------------------------

// CCamImageSaveActive::ConstructL

// 2nd phase construction

// -----------------------------------------------------------------------------

//

void CCamImageSaveActive::ConstructL()

    {

    PRINT( _L("Camera => CCamImageSaveActive::ConstructL") );

    iSaveArray = new( ELeave ) CDesCArraySeg( KArrayGranularity );

    iNameArray = new( ELeave ) CDesCArraySeg( KArrayGranularity );

    CActiveScheduler::Add( this );

    PRINT( _L("Camera <= CCamImageSaveActive::ConstructL") );

    }

// -----------------------------------------------------------------------------

// CCamImageSaveActive::SetActiveAndCompleteRequest

// Schedule to run immediately

// -----------------------------------------------------------------------------

//

void CCamImageSaveActive::SetActiveAndCompleteRequest()