/*

* Copyright (c) 2005-2007 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: 

*        Attachment file handler

*

*/

// INCLUDES

#include    "CPbk2AttachmentFile.h"

// System includes

#include    <e32std.h>

/// Unnamed namespace for local definitions

namespace {

// LOCAL CONSTANTS

_LIT(KRamDrive, "d:");

_LIT(KPersistentDrive, "c:");

_LIT(KTempFilePath, "\\system\\temp\\");

_LIT(KInvalidFileNameChars, "?*<>/\"|\\:");

_LIT(KDefaultTempFileName, "TEMP.tmp");

const TInt KMaxDriveNameLength = 2;

const TInt KMaxNumberLength = 5;

const TInt KMaxFileNumber = 99999;

const TInt KFirstDuplicateNameIndex = 1;

#ifdef _DEBUG

enum TPanicCode

    {

    EPanicPostCond_Constructor = 1,

    EPanicPreCond_ConstructL,

    EPanicPostCond_ConstructL,

    EPanicPreCond_CreateFileL,

    EPanicPostCond_CreateFileL

    };

void Panic(TPanicCode aReason)

    {

    _LIT(KPanicText, "CPbk2AttachmentFile");

    User::Panic(KPanicText,aReason);

    }

#endif // _DEBUG

} // namespace

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

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

// CPbk2AttachmentFile::NewL

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

//

EXPORT_C CPbk2AttachmentFile* CPbk2AttachmentFile::NewL(

        const TDesC& aBaseName, 

        RFs& aRfs, 

        TUint aFileMode /*= EFileStream|EFileShareExclusive|EFileWrite*/)

    {

    CPbk2AttachmentFile* self = 

        CPbk2AttachmentFile::NewLC( aBaseName, aRfs, aFileMode );

    CleanupStack::Pop(self);  // self

    return self;

    }

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

// CPbk2AttachmentFile::NewLC

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

//

EXPORT_C CPbk2AttachmentFile* CPbk2AttachmentFile::NewLC(

        const TDesC& aBaseName, 

        RFs& aRfs, 

        TUint aFileMode /*= EFileStream|EFileShareExclusive|EFileWrite*/)

    {

    CPbk2AttachmentFile* self = 

        new(ELeave) CPbk2AttachmentFile( aRfs, aFileMode );

    CleanupStack::PushL( self );

    self->ConstructL( aBaseName );

    return self;

    }

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

// CPbk2AttachmentFile::~CPbk2AttachmentFile

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

//

CPbk2AttachmentFile::~CPbk2AttachmentFile()

    {

    DeleteFile();

    delete iFileName;

    delete iBaseName;

    }

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

// CPbk2AttachmentFile::FileName

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

//

EXPORT_C const TDesC& CPbk2AttachmentFile::FileName() const

    {

    if ( iFileName )

        {

        return *iFileName;

        }

    else

        {

        return KNullDesC;

        }

    }

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

// CPbk2AttachmentFile::File

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

//

EXPORT_C RFile& CPbk2AttachmentFile::File()

    {

    return iFile;

    }

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

// CPbk2AttachmentFile::Release

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

//

EXPORT_C void CPbk2AttachmentFile::Release()

    {

    iFile.Close();

    iOwnsFile = EFalse;

    }

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

// CPbk2AttachmentFile::SwitchDriveL

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

//

EXPORT_C void CPbk2AttachmentFile::SwitchDriveL()

    {

    TPtrC drive;

    if ( iFileName )

        {

        // File already created successfully: switch the drive

        TParsePtrC fileNameParser( *iFileName );

        drive.Set( fileNameParser.Drive()==KRamDrive ? KPersistentDrive : KRamDrive );

        }

    else

        {

        // Default is RAM drive in ConstructL

        drive.Set( KPersistentDrive );

        }

    // Create new file

    CreateFileL( drive, KTempFilePath, *iBaseName );

    }

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

// CPbk2AttachmentFile::CPbk2AttachmentFile

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

//

CPbk2AttachmentFile::CPbk2AttachmentFile(

        RFs& aRfs, 

        TUint aFileMode ) :

    iRfs( aRfs ),

    iFileMode( aFileMode )

    {

    // CBase::operator new will reset members

    __ASSERT_DEBUG(!iBaseName && !iFileName && iFile.SubSessionHandle()==KNullHandle, 

        Panic(EPanicPostCond_Constructor) );

    }

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

// CPbk2AttachmentFile::ConstructL

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

//

void CPbk2AttachmentFile::ConstructL( const TDesC& aBaseName )

    {

    __ASSERT_DEBUG(!iBaseName && !iFileName && 

                    iFile.SubSessionHandle()==KNullHandle, 

                        Panic(EPanicPreCond_ConstructL));

    // Call this to ensure that we create session handle that can be passed 

    // via IPC. We are sharing RFile handles with SendUi.

    iRfs.ShareProtected();

    // Clean up aBaseName

    const TInt maxLength = 

        KMaxFileName - 

        KMaxDriveNameLength - 

        KTempFilePath().Length() - 

        KMaxNumberLength;

    iBaseName = HBufC::NewL( maxLength );

    TPtr baseName = iBaseName->Des();

    for ( TInt i=0; i < aBaseName.Length() && i < maxLength; ++i )

        {

        TChar ch = aBaseName[i];

        if ( KInvalidFileNameChars().Locate( ch ) == KErrNotFound )

            {

            baseName.Append( ch );

            }

        }

    baseName.TrimAll();

    if ( baseName.Length() == 0 )

        {

        baseName = KDefaultTempFileName;

        }

    // Try to create the file

    TRAPD( err, CreateFileL( KRamDrive, KTempFilePath, baseName ) );

    if ( err != KErrNone )

        {

        // Try on different drive

        SwitchDriveL();

        }

    __ASSERT_DEBUG( iBaseName && iFileName, Panic(EPanicPostCond_ConstructL) );

    }

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

// CPbk2AttachmentFile::CreateFileL

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

//

void CPbk2AttachmentFile::CreateFileL(

        const TDesC& aDrive, 

        const TDesC& aDir, 

        const TDesC& aBaseName )

    {

    __ASSERT_DEBUG(iBaseName && iRfs.Handle()!=KNullHandle, 

        Panic(EPanicPreCond_CreateFileL));

    // Create and init a local buffer for the file name

    HBufC* fileNameBuf = HBufC::NewLC( KMaxFileName );

    TPtr fileName = fileNameBuf->Des();

    fileName = aDrive;

    fileName.Append( aDir );

    // Create directory

    TInt error = iRfs.MkDirAll( fileName );

    if ( error != KErrAlreadyExists )

        {

        User::LeaveIfError( error );

        }

    fileName.Append( aBaseName );

    TInt number = KFirstDuplicateNameIndex;

    FOREVER

        {

        RFile file;

        const TInt error = file.Create( iRfs, fileName, iFileMode );

        if ( error == KErrNone )

            {

            // File created succesfully: switch state

            DeleteFile();  // Delete previous file

            iFile = file;

            delete iFileName;

            iFileName = fileNameBuf;

            iOwnsFile = ETrue;

            CleanupStack::Pop();  // fileNameBuf

            __ASSERT_DEBUG(iFileName && iFile.SubSessionHandle()!=KNullHandle, 

                Panic(EPanicPostCond_CreateFileL));

            return;

            }

        else if ( error != KErrAlreadyExists )

            {

            User::Leave( error );

            }

        // File name was reserved: append number to basename to make it unique

        fileName = aDrive;

        fileName.Append( aDir );

        TParsePtrC baseNameParser( aBaseName );

        fileName.Append( baseNameParser.Name() );

        fileName.AppendNum( number );

        fileName.Append( baseNameParser.Ext() );

        if ( ++number > KMaxFileNumber )

            {

            User::Leave( KErrTooBig );

            }

        }

    }

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

// CPbk2AttachmentFile::DeleteFile

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

//

void CPbk2AttachmentFile::DeleteFile()

    {

    iFile.Close();

    if ( iFileName && iOwnsFile )

        {

        // Delete the file. If the deletion fails for some reason trust that the

        // system will delete the file when it cleans up temp file directories.

        iRfs.Delete( *iFileName );

        }

    }

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

// CPbk2AttachmentFileArray::CPbk2AttachmentFileArray

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

//

EXPORT_C CPbk2AttachmentFileArray::CPbk2AttachmentFileArray( TInt aGranularity )

    : CArrayPtrFlat<CPbk2AttachmentFile>( aGranularity )

    {

    }

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

// CPbk2AttachmentFileArray::~CPbk2AttachmentFileArray

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

//

CPbk2AttachmentFileArray::~CPbk2AttachmentFileArray()

    {

    // Delete all objects in the array

    ResetAndDestroy();

    }

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

// CPbk2AttachmentFileArray::MdcaCount

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

//

TInt CPbk2AttachmentFileArray::MdcaCount() const

    {

    return Count();

    }

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

// CPbk2AttachmentFileArray::MdcaPoint

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

//

TPtrC CPbk2AttachmentFileArray::MdcaPoint( TInt aIndex ) const

    {

    return At( aIndex )->FileName();

    }

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

// CPbk2AttachmentFileArray::FileHandleAt

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

//    

RFile& CPbk2AttachmentFileArray::FileHandleAt( TInt aIndex )

    {

    return At( aIndex )->File();

    }

// End of File