/*

* Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  Implements storage functionality in the DownloadManager

*

*/

// INCLUDE FILES

#include <bldvariant.hrh>

#include <browser_platform_variant.hrh>

#include "FileExt.h"

#include "HttpClientApp.h"

#include "HttpDownload.h"

#include "HttpStorage.h"

#include "HttpDownloadManagerServerEngine.h"

#include "HttpDownloadMgrLogger.h"

#include "HeaderField.h"

#include "BuffStorage.h"

#include <SysUtil.h>

#include <DocumentHandler.h>

#include <APMSTD.H>

#ifdef __SYNCML_DM_FOTA

#include <fotaengine.h>

#endif

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif //RD_MULTIPLE_DRIVE

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

//const ?type ?constant_var = ?constant;

const TInt KDefaultStorageBufferSize = 128 * 1024;

const TInt KFileNameExtensionMaxSize = 5; // practical maximum length of filename extension for renamed downloads

const TInt KDefaultStorageBufferSizePD = 16 * 1024;

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

//Music Store Warning Level Feature Flag

#ifdef DOWNLOADMGR_WARNINGLEVEL_ENABLED_FF

#include <uiklafinternalcrkeys.h>

#include <centralrepository.h>

//Beside the OOD threshold value, we need to reserve extra disk space

//for harvest server do the harvest, set this as 1M

const TInt KFreeSpaceExtraReserved(1024*1024);

static TBool CheckFreeSpaceWarningThreshold( RFs& aFs, TInt aBytesToWrite, TInt aDrive )

    {

    TBool isSpace = EFalse;

    CRepository* repository = NULL;

    TInt64 thresholdValue( 0 );

    TVolumeInfo volumeInfo;

    TInt err = aFs.Volume( volumeInfo, aDrive );

    if ( err == KErrNone ) // get warning threshold

        {

        TRAP( err, repository = CRepository::NewL( KCRUidUiklaf ) );

        }

    if ( err == KErrNone )

        {

        if ( volumeInfo.iDrive.iDriveAtt & KDriveAttRemovable ) // for E and F

            {

            TInt warningValue( 0 );

            err = repository->Get( KUikOODDiskFreeSpaceWarningNoteLevelMassMemory, warningValue );

            if ( err == KErrNone )

                {

                thresholdValue = warningValue + KFreeSpaceExtraReserved;

                }

            }

        else

            {

            TInt warningUsagePercent( 0 );

            err = repository->Get( KUikOODDiskFreeSpaceWarningNoteLevel, warningUsagePercent );

            if ( err == KErrNone )

                {

                thresholdValue = ( ( volumeInfo.iSize * ( 100 - warningUsagePercent ) ) / 100 )

                    + KFreeSpaceExtraReserved;

                }

            }

        delete repository;

        }

    if ( err == KErrNone ) // Check warning threshold

        {

        isSpace = volumeInfo.iFree > thresholdValue + aBytesToWrite;

        }

    return isSpace;

    }

#endif

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

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

// CHttpStorage::CHttpStorage

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CHttpStorage::CHttpStorage( CHttpDownload* aDownload )

    :iDownload( aDownload )

    ,iProgressiveDownload( EFalse )

    ,iLength( KDefaultContentLength )

    ,iStorageMethod( EStoreFile )

    ,iBufferingEnabled( EFalse )

    ,iBufferSize( KDefaultStorageBufferSize )

    ,iPartialLength( KDefaultContentLength )

    {

    CLOG_WRITE_1( "Storage created: 0x%x", this );

    }

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

// CHttpStorage::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CHttpStorage::ConstructL()

    {

    iStorage = CBuffStorage::NewL(this);

    }

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

// CHttpStorage::NewL

// Two-phased constructor.

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

//

CHttpStorage* CHttpStorage::NewL( CHttpDownload* aDownload )

    {

    CHttpStorage* self = new( ELeave ) CHttpStorage( aDownload );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CHttpStorage::~CHttpStorage()

    {

    delete iLocalFilename;

    delete iDestFilename;

    delete iDdFilename;

	if(iStorage)

		{

		delete iStorage;

		iStorage = NULL;	

		}

    if( iFile )

        {

        iFile->Close();

        delete iFile;

        }

#ifdef __SYNCML_DM_FOTA        

    if( iFotaEngine )

        {

        iFotaEngine->UpdatePackageDownloadComplete( iDownload->iFotaPckgId);

        iFotaStream = NULL;

        iFotaEngine->Close();

        delete iFotaEngine; iFotaEngine = NULL;

        }

#endif // __SYNCML_DM_FOTA

    CLOG_WRITE_1( "Storage destroy: (0x%x)", this );

    }

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

// CHttpStorage::SetStorageMethod

// 

// iDownloadedSize comes from the destination file size.

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

//

void CHttpStorage::SetStorageMethod( TStorageMethod aMethod )

    {

    iStorageMethod = aMethod;

    }

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

// CHttpStorage::CheckContentFileIntegrityL

// 

// iDownloadedSize comes from the destination file size.

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

//

TBool CHttpStorage::CheckContentFileIntegrityL()

    {

    LOGGER_ENTERFN( "CheckContentFileIntegrityL" );

    TBool retVal = ETrue;

    if( iDestFilename && iDestFilename->Length() )

        {

        if( iDriveId == GetDestinationDriveId() )

            // this is not the same drive as where content file was

            // previously saved

            {

            TEntry entry;

            RFs& fs = iDownload->ClientApp()->Engine()->Fs();

            if( fs.Entry( *iDestFilename, entry ) == KErrNone )

                {

                //Check if PD was on and if the file was being downloaded to MMC when last time we exited the session

                //Use the Downloaded size as stored in info file 

                //because when we exited from prev session

                //size was not set back to downloaded size from total size

                //

                if( !iProgressiveDownload && !iDownload->iNoMedia)

                    {

                    iDownloadedSize = entry.iSize;

                    } 

                else 

                    {

                    iFile = new (ELeave) RFile;

                    TInt err = iFile->Open( fs , 

                                          *iLocalFilename, 

                                          EFileShareAny | 

                                          EFileStream | 

                                           EFileWrite );

                    if( !err )

                        {

                        iFile->SetSize( iDownloadedSize );

                        iProgressiveDownload = EFalse; 

                        iFile->Close();

                        delete iFile; iFile = NULL;       

                        }

                        iDownload->iNoMedia = EFalse;

                    }                    

                CLOG_WRITE_2( "Length: %d, size: %d", iLength, iDownloadedSize );

                // if full size is unknown, we can't decide

                // if the content file integrity is ok, or wrong.

                // Let's assume that it is ok.

                if( iLength != KDefaultContentLength )

                    // Full size is known

                    {

                    if( !((iDownload->iDlState == EHttpDlMultipleMOCompleted &&

                        (iDownload->iProgState == EHttpProgContentFileMoved || 

                        iDownload->iProgState == EHttpProgContentFileMovedAndDestFNChanged ||

                        iLength == iDownloadedSize)) ||

                        (iDownload->iDlState != EHttpDlMultipleMOCompleted &&

                        iLength > iDownloadedSize)) )

                        {

                        CLOG_WRITE8( "Wrong file size" );

                        retVal = EFalse;

                        }

                    }

                }

            else

                // Entry failed but we can still assume that there's no problem

                {

                CLOG_WRITE8( "Unknown size" );

                }

            }

        else

            {

            CLOG_WRITE8_1( "Different drive: %d", iDriveId );

            // MMC removed.

            iDownload->MediaRemoved( (TUint)KErrNotFound, ETrue );

            }

        }

    else

        {

        CLOG_WRITE( "No dest filename");

         iDownload->iNoMedia = EFalse; 

        }

    return retVal;

    }

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

// CHttpStorage::CreateDestinationFileL

// ?implementation_description

// (other items were commented in a header).

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

//

void CHttpStorage::CreateDestinationFileL()

    {

    LOGGER_ENTERFN( "CreateDestinationFileL" );

    TInt err( KErrNone );

    if( iStorageMethod == EStoreFota )

        {

#ifdef __SYNCML_DM_FOTA        

        iFotaEngine = new (ELeave) RFotaEngineSession;

        iFotaEngine->OpenL();

        User::LeaveIfError( iFotaEngine->OpenUpdatePackageStore( iDownload->iFotaPckgId, 

                                                                 iFotaStream ) );

        CLOG_WRITE( "FOTA -> no file" );

#else   // __SYNCML_DM_FOTA

        DMPanic( KErrNotSupported );

#endif  // __SYNCML_DM_FOTA   

        }

    else

        {

        if( iRFileSetByClient )

            {

            CLOG_WRITE( "RFile is adopted from client" );

            TBuf<KMaxFileName> tempFileName; 

            iFile->FullName(tempFileName);           

            ReallocateStringL( iLocalFilename, tempFileName, KMaxPath );

            TBuf8<KMaxContentTypeLength> contentType;

            contentType.Copy( *iDownload->iDDType );

            if( (0 == contentType.Compare( KCodMimeType() )) ||

            	(0 == contentType.Compare( KDdMimeType() ))	 ||

            	(0 == contentType.Compare( KDd2MimeType() )) ||

            	(0 == contentType.Compare( KMultiPartMimeType() )) )

            	{

            	iDdFilename = iLocalFilename->Des().AllocL();

            	}            

            // check how many bytes are already persisted

            iFile->Size( (TInt&)iDownloadedSize );

            CLOG_WRITE_1( "iDownloadedSize: %d", iDownloadedSize );

            return;

            }

        CLOG_WRITE8_1( "iDownloadedSize: %d", iDownloadedSize );

        __ASSERT_DEBUG( !iFile, DMPanic( KErrInUse) );

        CreateDestinationFilenameL();

        iFile = new (ELeave) RFile;

        for( TInt i = 0; i < 2; ++i )

            {

            if( !iDownloadedSize )

                // nothing persisted yet. If there's a file with the same name,

                // delete it.

                {

                err = iFile->Replace( iDownload->ClientApp()->Engine()->Fs(), 

                                       *iLocalFilename, 

                                       EFileShareAny | 

                                       EFileStream | 

#ifdef BRDO_RFILE_WRITE_DIRECT_IO_FF

                                       EFileWrite |

                                       EFileWriteDirectIO );

#else

                                       EFileWrite );

#endif

                }

            else

                {

                err = iFile->Open( iDownload->ClientApp()->Engine()->Fs(), 

                                   *iLocalFilename, 

                                   EFileShareAny | 

                                   EFileStream | 

#ifdef BRDO_RFILE_WRITE_DIRECT_IO_FF

                                   EFileWrite |

                                   EFileWriteDirectIO );

#else

                                   EFileWrite );

#endif

                if( !err )

                    {

                    // append new chunks to the file

                    TInt pos( 0 );

                    iFile->Seek( ESeekEnd, pos );

                    }

                }

            if( err == KErrPathNotFound )

                {

                TPath folder;

                folder.Copy( *iLocalFilename );

                TInt slash = folder.LocateReverse( '\\' );

                if( slash != KErrNotFound )

                    {

                    folder.SetLength( slash+1 );

                    iDownload->ClientApp()->Engine()->Fs().MkDirAll( folder );

                    }

                }

            else 

                {

                break;

                }

            }

        }

    CLOG_WRITE8_1( "CreateDestinationFileL: %d", err );

    if( !err )

        {

        if( iFile && iLength != KDefaultContentLength && iProgressiveDownload )

            {

            iFile->SetSize( iLength );

            }

        }

    else

        {

        iDownload->OnError( err, EDestFileInUse );

        User::Leave( err );

        }

    }

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

// CHttpStorage::CloseDestinationFile

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

//

void CHttpStorage::CloseDestinationFile( TFileCloseOperation aOperation )

    {

    LOGGER_ENTERFN( "CloseDestinationFile" );

    CLOG_WRITE_2( "iFile: %x, iRFileSetByClient: %d", iFile, iRFileSetByClient );

    if( iFile )

        // RFile received from client is not close only in

        // destructor, because there's no way to reopen it.

        {

        CLOG_WRITE( "HttpStorage: Writing final data and deallocating buffer" );

        // Make sure everything is written on the file

        TRAP_IGNORE(iStorage->FlushBuffersL()); // Might be good to somehow relay error somewhere?

        if( iProgressiveDownload && iDownloadedSize >= 0 )

                {

                iFile->SetSize( iDownloadedSize );

                }

        // Free up memory

        iStorage->ResetBuffers();

        iStorage->ClearErrors();

        if( iDownload->iDlState == EHttpDlMultipleMOCompleted || !iRFileSetByClient )

            // do not close file of a progressive download,

            // only on complete.

            {

            iFile->Close();

            delete iFile; iFile = NULL;

            }

        }

#ifdef __SYNCML_DM_FOTA        

    if( iFotaEngine )

        {

        iFotaEngine->UpdatePackageDownloadComplete( iDownload->iFotaPckgId);

        iFotaStream = NULL;

        iFotaEngine->Close();

        delete iFotaEngine; iFotaEngine = NULL;

        }

#endif  // __SYNCML_DM_FOTA

    if( iLocalFilename )

        {

        if( aOperation == EDeleteFile )

            {

            CLOG_WRITE_1( "Delete: %S", iLocalFilename );

            iDownload->ClientApp()->Engine()->Fs().Delete( *iLocalFilename );

            iDownloadedSize = 0;

            }

        else if( aOperation == EReplaceFile )

            {

            CLOG_WRITE_1( "Replace: %S", iLocalFilename );

            RFile file;

            file.Replace( iDownload->ClientApp()->Engine()->Fs(), *iLocalFilename, EFileWrite );

            file.Close();

            iDownloadedSize = 0;

            }

        }

    if( iDestFilename )

        {

        if( aOperation == EDeleteFile )

            {

            CLOG_WRITE_1( "Delete: %S", iDestFilename );

            iDownload->ClientApp()->Engine()->Fs().Delete( *iDestFilename );

            }

        else if( aOperation == EReplaceFile )

            {

            CLOG_WRITE_1( "Replace: %S", iDestFilename );

            RFile file;

            file.Replace( iDownload->ClientApp()->Engine()->Fs(), *iDestFilename, EFileWrite );

            file.Close();  

            }

        }

    }