/*

* Copyright (c) 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:  Image saver implementation

*

*/

#include "cphsrvimagesaver.h"

#include "mphsrvimagesaverobserver.h"

#include <imageconversion.h>

#include <f32file.h>

#include <bitmaptransforms.h>

// primary file name for VT image

_LIT( KPhSrvPrimaryVtImageFileName, "vtstillimage1" );

// file name used if primary file is in use while save occurs

_LIT( KPhSrvAlternateVtImageFileName, "vtstillimage2" );

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

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

// 1st constructor

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

//

CPhSrvImageSaver* CPhSrvImageSaver::NewL( 

        RFs& aFs,

        const TFileName& aPrivatePath, 

        MPhSrvImageSaverObserver& aObserver )

    {

    CPhSrvImageSaver* saver = new ( ELeave ) CPhSrvImageSaver( 

        aFs, aPrivatePath, aObserver );

    CleanupStack::PushL( saver );

    saver->ConstructL();

    CleanupStack::Pop();

    return saver;

    }

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

// destructor

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

//

CPhSrvImageSaver::~CPhSrvImageSaver()

    {

    delete iImageDecoder;

    delete iFileManager;

    delete iScaler;

    }

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

// Saves image

// 1) decode from file

// 2a) scale (for single frame images) and save to phone server private dir, or

// 2b) multiframe image - copy file as is to phone server private directory

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

//

void CPhSrvImageSaver::SaveImageL( const TDesC& aFileName )

    {

    if ( IsActive() )

        {

        User::Leave( KErrInUse );

        }

    iImageDecoder = CImageDecoder::FileNewL( iFs, aFileName );

    const TInt frameCount = iImageDecoder->FrameCount();

    if ( frameCount > 1 )

        {

        // decoder not needed because image is copied as is

        delete iImageDecoder;

        iImageDecoder = NULL;

        CopyImageL( aFileName );

        }

    else if ( frameCount == 1 )

        {

        ScaleImageL();

        }

    else

        {

        // invalid image?

        User::Leave( KErrCorrupt );

        }

    }

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

// Copies the file

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

//

void CPhSrvImageSaver::CopyImageL( const TDesC& aFileName )

    {

    TName targetFileName;

    ConstructVtFileSaveName( aFileName, targetFileName );

    iFileManager = CFileMan::NewL( iFs );

    iFileManager->Copy( aFileName, targetFileName, 

        CFileMan::EOverWrite, iStatus );    

    }

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

// ScaleImageL

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

//

void CPhSrvImageSaver::ScaleImageL()

    {

    }

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

// Checks if primary file is in use.

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

//

TInt CPhSrvImageSaver::IsPrimaryFileInUse( TBool& aIsInUse )

    {

    CDir* entries = NULL;

    TInt res = iFs.GetDir( iPath, KEntryAttNormal, EDirsLast, entries );

    if ( res == KErrNone && entries )

        {

        const TInt entryCount( entries->Count() );

        for ( TInt index = 0; index < entryCount; index++ )

            {

            const TEntry& entry = ( *entries )[index];            

            if ( entry.iName.Compare( KPhSrvPrimaryVtImageFileName() ) >= 0 )

                {

                // primary file name matches with directory entry (extension

                // depends on file format)

                res = iFs.IsFileOpen( entry.iName, aIsInUse );

                index = entryCount; // break loop

                }

            }

        }

    delete entries;

    return res;

    }

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

// Constructs target file name for VT still image. Alternate name is used if

// file with primary name is open.

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

//

TInt CPhSrvImageSaver::ConstructVtFileSaveName(

    const TDesC& aSourceFileName, 

    TName& aTargetFileName )

    {

    TBool inUse( EFalse );

    TInt res( IsPrimaryFileInUse( inUse ) );

    if ( res == KErrNone )

        {

        TParse sourceName;

        sourceName.Set( aSourceFileName, NULL, NULL );

        aTargetFileName = iPath;        

        if ( inUse )

            {

            // primary file in use (open), use alternalte name

            aTargetFileName.Append( KPhSrvAlternateVtImageFileName() );

            }

        else

            {

            aTargetFileName.Append( KPhSrvPrimaryVtImageFileName() );

            }

        aTargetFileName.Append( sourceName.Ext() );

        }

    return res;

    }

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

// CPhSrvImageSaver::RunL

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

//

void CPhSrvImageSaver::RunL()

    {

    iObserver.ImageSaved( iStatus.Int() );

    }

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

// CPhSrvImageSaver::DoCancel

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

//

void CPhSrvImageSaver::DoCancel()

    {

    iObserver.ImageSaved( KErrCancel );

    }

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

// CPhSrvImageSaver::ConstructL

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

//

void CPhSrvImageSaver::ConstructL()

    {

    User::Leave( KErrNotSupported );

    }

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

// c++ constructor

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

//

CPhSrvImageSaver::CPhSrvImageSaver( RFs& aFs, const TFileName& aPrivatePath,

    MPhSrvImageSaverObserver& aObserver) 

    : CActive( CActive::EPriorityStandard ), 

    iFs( aFs ), 

    iPath( aPrivatePath ),

    iObserver( aObserver )

    {

    }