/*

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

*

*/

#include "musuifileutil.h"

#include "muslogger.h" // debug logging

#include "musuidefinitions.h"

#include "musuidialogutil.h"

#include "mussettings.h"

#include <musui.rsg>

#include <f32file.h>

#include <StringLoader.h>

#include <AknGlobalNote.h>

#include <apparc.h>

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

//

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

//

TBool MusUiFileUtil::FileExists( const TDesC& aFullFileName )

    {

    MUS_LOG( "mus: [MUSUI ]  -> MusUiFileUtil::FileExists" );

    TBool fileExists( EFalse );

    RFs fs;    

    if ( fs.Connect() == KErrNone )

        {

        TUint att;

        fileExists = ( fs.Att( aFullFileName, att ) != KErrNotFound );

        fs.Close();

        }

    MUS_LOG( "mus: [MUSUI ]  <- MusUiFileUtil::FileExists" );

    return fileExists;

    }

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

//

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

//

void MusUiFileUtil::VideoFilePathExistsL( const TDesC& aVideoFilePath)

    {

    MUS_LOG( "mus: [MUSUI ]  -> MusUiFileUtil::VideoFilePathExistsL" );

    RFs fs;

    User::LeaveIfError( fs.Connect() );

    CleanupClosePushL( fs );

    TInt error = fs.MkDirAll( aVideoFilePath );

    CleanupStack::PopAndDestroy( &fs );

    MUS_LOG1( "mus: [MUSUI ]  <- MusUiFileUtil::VideoFilePathExistsL,%d",error );

    User::Leave(error);

    }

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

//

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

//

void MusUiFileUtil::CreateVideoFileNameL( const TDesC& aVideoFilePath, 

                                          TFileName& aFileName )

    {

    MUS_LOG( "mus: [MUSUI ]  -> MusUiFileUtil::CreateVideoFileNameL" );

    RFs fs;

    TParse parse;

    TFileName fullFileName;

    TUint att;

    User::LeaveIfError( fs.Connect() );

    CleanupClosePushL( fs );

    if ( fs.Att( aVideoFilePath, att ) == KErrNone )

        {

        if ( MultimediaSharingSettings::OperatorVariantSettingL() == 

             MusSettingsKeys::EStandard )

            {

            HBufC* temp = StringLoader::LoadLC( R_MUS_VIEW_SAVED_FILENAME );

            User::LeaveIfError( parse.Set( aVideoFilePath, temp, NULL ) );

            CleanupStack::PopAndDestroy( temp );

            fullFileName = parse.FullName();

            fullFileName.Append( KMusVideoFileNameExtension );

            User::LeaveIfError( 

                CApaApplication::GenerateFileName( fs, fullFileName ) );

            User::LeaveIfError( parse.Set( fullFileName, NULL, NULL ) );

            }

        else    // operator specific case

            {

            RBuf newName;

            newName.CreateL( KMaxFileName );

            CleanupClosePushL( newName );

            TEntry entry;

            TInt i = 1;

            // path + 'VS' + date + 'V' + counter + extension

            _LIT( KFormatStringOne, "%S%S%S%S%02d%S" );

            _LIT( KFormatStringTwo, "%S%S%S%S%d%S" );

            TBuf<16> format;

            format = KFormatStringOne;

            // get current date

            _LIT( KDateFormat, "%F%M%D%*Y" );

            TTime time;

            time.UniversalTime();

            TBuf<6> dateString;

            time.FormatL( dateString, KDateFormat );

            // generate a valid filename that doesn't already exist...

            do

                {

                TPtrC driveAndPath = aVideoFilePath;

                TPtrC date = dateString;  

                newName.Format( format, 

                                &driveAndPath, &KMusVideoFileNameBegining, 

                                &date, &KMusVideoFileNameVersion, 

                                i++, &KMusVideoFileNameExtension );

                if ( newName.Length() > KMaxFileName )

                    {

                    User::Leave( KErrOverflow );

                    }

                if ( i >= 100 )

                    {

                    format = KFormatStringTwo;

                    }        			

                }       // Continue until DoesNotExist

            while ( fs.Entry( newName, entry ) == KErrNone ); 

            fullFileName.Copy( newName );

            User::LeaveIfError( parse.Set( newName, NULL, NULL ) );

            CleanupStack::PopAndDestroy( &newName );            

            }

        RFile file;

        CleanupClosePushL( file );

        User::LeaveIfError( 

            file.Create( fs, fullFileName, EFileWrite | EFileShareExclusive ) );

        CleanupStack::PopAndDestroy( &file );

        }

    CleanupStack::PopAndDestroy( &fs );

    aFileName = parse.Name();

    MUS_LOG( "mus: [MUSUI ] < - MusUiFileUtil::CreateVideoFileNameL" );

    }

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

//

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

//

void MusUiFileUtil::DeleteFileL( const TDesC& aFileName )

    {

    RFs fs;

    User::LeaveIfError( fs.Connect() );

    CleanupClosePushL( fs );

    TInt error = fs.Delete( aFileName );

    if ( ( error != KErrNone ) && ( error != KErrNotFound ) )

        {

        User::Leave( error );

        }

    CleanupStack::PopAndDestroy( &fs );

    }

// end of file