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

// INCLUDES
#include <httpdownloader.h>
#include <e32property.h>
#include <sysutil.h>
#include "upnpdeviceicondownloader.h"
#include "upnpconstantdefs.h"
#include "upnpaverrorhandler.h"

_LIT( KComponentLogfile, "upnpavcontrollerserver.txt");
#include "upnplog.h"

const TUint KBufferSize = 0x4000; // 16K
const TInt KParallerTransfers = 1;
_LIT( KIconFolder, "icons\\" );
_LIT( KIconTemp, "temp" );
_LIT( KIconExt, ".dat" );
const TInt KCleanupNeededKey = KMaxTInt;
const TInt KDefaultDiskSpaceNeeded = 0x8000; // 32K

// --------------------------------------------------------------------------
// FolderNameLC
// --------------------------------------------------------------------------
static HBufC* FolderNameLC( RFs& aFs )
    {
    HBufC* ret = HBufC::NewLC( KMaxPath );
    TPtr ptr( ret->Des() );
    aFs.PrivatePath( ptr );
    ptr.Insert( 0, TDriveUnit( RFs::GetSystemDrive() ).Name() );
    ptr.Append( KIconFolder );
    return ret;
    }

// --------------------------------------------------------------------------
// FileNameLC
// --------------------------------------------------------------------------
static HBufC* FileNameLC( RFs& aFs, const TDesC8& aDeviceUuid )
    {
    HBufC* ret = FolderNameLC( aFs );
    HBufC* uuid = HBufC::NewLC( aDeviceUuid.Length() );
    uuid->Des().Copy( aDeviceUuid );
    TPtr ptr( ret->Des() );
    ptr.Append( *uuid );
    ptr.Append( KIconExt );
    CleanupStack::PopAndDestroy( uuid );
    return ret;
    }

// --------------------------------------------------------------------------
// TempFileNameLC
// --------------------------------------------------------------------------
static HBufC* TempFileNameLC( RFs& aFs )
    {
    HBufC* ret = FolderNameLC( aFs );
    TPtr ptr( ret->Des() );
    ptr.Append( KIconTemp );
    ptr.Append( KIconExt );
    return ret;
    }

// --------------------------------------------------------------------------
// CompleteFileL
// --------------------------------------------------------------------------
static void CompleteFileL( RFs& aFs, const TDesC8& aDeviceUuid )
    {
    HBufC* src = TempFileNameLC( aFs );
    HBufC* tgt = FileNameLC( aFs, aDeviceUuid );
    User::LeaveIfError( aFs.Replace( *src, *tgt ) );
    CleanupStack::PopAndDestroy( tgt );
    CleanupStack::PopAndDestroy( src );
    }

// --------------------------------------------------------------------------
// PropertyCategory
// --------------------------------------------------------------------------
static TUid PropertyCategory()
    {
    RProcess process;
    TUid ret( TUid::Uid( process.SecureId().iId ) );
    process.Close();
    return ret;
    }

// --------------------------------------------------------------------------
// GetIntPropertyL
// --------------------------------------------------------------------------
static void GetIntPropertyL( const TUid& aCategory, TInt aKey, TInt& aValue )
    {
    TInt initValue( aValue );
    TInt err( RProperty::Get( aCategory, aKey, aValue ) );
    if ( err == KErrNotFound )
        {
        err = RProperty::Define( aCategory, aKey, RProperty::EInt );
        aValue = initValue;
        }
    __LOG3( "CUpnpDeviceIconDownloader - GetIntPropertyL - err: %d key: %d value: %d",
            err, aKey, aValue );
    User::LeaveIfError( err );
    }

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

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::NewL
// --------------------------------------------------------------------------
CUpnpDeviceIconDownloader* CUpnpDeviceIconDownloader::NewL(
        MUpnpDeviceIconDownloadObserver& aObserver, TUint aIap )
    {
    CUpnpDeviceIconDownloader* self = new ( ELeave ) CUpnpDeviceIconDownloader( 
            aObserver, aIap );
    CleanupStack::PushL( self );           
    self->ConstructL();
    CleanupStack::Pop();
    return self;
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::~CUpnpDeviceIconDownloader
// --------------------------------------------------------------------------
CUpnpDeviceIconDownloader::~CUpnpDeviceIconDownloader()
    {
    iQueue.ResetAndDestroy();
    delete iDownloader;
    delete iCurrent;
    if ( iCleanupOnShutdown )
        {
        TRAP_IGNORE( CleanupFilesL() );
        }
    iFs.Close();
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::TransferProgress
// --------------------------------------------------------------------------
void CUpnpDeviceIconDownloader::TransferProgress( TAny* /*aKey*/, TInt /*aBytes*/,
        TInt /*aTotalBytes*/ )
    {
    __LOG( "CUpnpDeviceIconDownloader::TransferProgress" );
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::ReadyForTransferL
// --------------------------------------------------------------------------
void CUpnpDeviceIconDownloader::ReadyForTransferL( TAny* /*aKey*/ )
    {
    __LOG( "CUpnpDeviceIconDownloader::ReadyForTransferL" );
    if ( iCurrent )
        {
        iDownloader->StartTransferL( iCurrent );
        }
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::TransferCompleted
// --------------------------------------------------------------------------
void CUpnpDeviceIconDownloader::TransferCompleted( TAny* /*aKey*/, TInt aStatus )
    {
    __LOG( "CUpnpDeviceIconDownloader::TransferCompleted" );
    if ( iCurrent )
        {
        TInt err( UPnPAVErrorHandler::ConvertToSymbianErrorCode( aStatus, EUPnPHTTPError ) );
        __LOG2( "CUpnpDeviceIconDownloader::TransferCompleted - Http: %d Err: %d",
                aStatus, err );
        TPtrC8 uuid( iCurrent->DeviceUuid() );
        if ( err == KErrNone )
            {
            TRAP_IGNORE( CompleteFileL( iFs, uuid ) );
            }
        TRAP_IGNORE( iObserver.DeviceIconDownloadedL( uuid, err ) );
        delete iCurrent;
        iCurrent = NULL;
        }
    DownloadNext();
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::StartDownloadL
// --------------------------------------------------------------------------
void CUpnpDeviceIconDownloader::StartDownloadL(
        const TDesC8& aDeviceUuid, const TDesC8& aDeviceIconUrl )
    {
    __LOG( "CUpnpDeviceIconDownloader::StartDownloadL" );
    CleanupFilesIfNeededL();
    if( !FileExistsL( aDeviceUuid ) && !InProgress( aDeviceUuid ) )
        {
        if ( !iDownloader )
            {
            iDownloader = CHttpDownloader::NewL( *this, iIap, KBufferSize,
                KParallerTransfers );
            }
        CEntry* entry = CEntry::NewLC( aDeviceUuid, aDeviceIconUrl );
        iQueue.AppendL( entry );
        CleanupStack::Pop( entry );
        DownloadNext();
        }
    else
        {
        __LOG( "CUpnpDeviceIconDownloader::StartDownloadL - Skipped" );
        }
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::CancelDownload
// --------------------------------------------------------------------------
void CUpnpDeviceIconDownloader::CancelDownload( const TDesC8& aDeviceUuid )
    {
    __LOG( "CUpnpDeviceIconDownloader::CancelDownload" );
    if ( iCurrent && !iCurrent->DeviceUuid().Compare( aDeviceUuid ) )
        {
        iDownloader->CancelTransfer( iCurrent );
        delete iCurrent;
        iCurrent = NULL;
        }
    else
        {
        TInt pos( iQueue.Find( aDeviceUuid, CEntry::Compare ) );
        if ( pos >= 0 && pos < iQueue.Count() )
            {
            delete iQueue[ pos ];
            iQueue.Remove( pos );
            }
        }
    DownloadNext();
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::TransferFileToClientL
// --------------------------------------------------------------------------
void CUpnpDeviceIconDownloader::TransferFileToClientL( const RMessage2& aMessage,
        TInt aSlot, const TDesC8& aDeviceUuid )
    {
    if ( InProgress( aDeviceUuid ) )
        {
        User::Leave( KErrNotReady );
        }
    HBufC* filename = FileNameLC( iFs, aDeviceUuid );
    __LOG1( "CUpnpDeviceIconDownloader::TransferFileToClientL - %S", filename );
    RFile file;
    CleanupClosePushL( file );
    User::LeaveIfError( file.Open( iFs, *filename, EFileShareReadersOnly | EFileRead ) );
    User::LeaveIfError( file.TransferToClient( aMessage, aSlot ) );
    CleanupStack::PopAndDestroy( &file );
    CleanupStack::PopAndDestroy( filename );
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::CEntry::NewLC
// --------------------------------------------------------------------------
CUpnpDeviceIconDownloader::CEntry* CUpnpDeviceIconDownloader::CEntry::NewLC(
        const TDesC8& aDeviceUuid, const TDesC8& aDeviceIconUrl )
    {
    CEntry* self = new ( ELeave ) CEntry();
    CleanupStack::PushL( self );
    self->ConstructL( aDeviceUuid, aDeviceIconUrl );
    return self;
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::CEntry::~CEntry
// --------------------------------------------------------------------------
CUpnpDeviceIconDownloader::CEntry::~CEntry()
    {
    delete iDeviceUuid;
    delete iDeviceIconUrl;
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::CEntry::Compare
// --------------------------------------------------------------------------
TInt CUpnpDeviceIconDownloader::CEntry::Compare( const TDesC8* aDeviceUuid,
        const CUpnpDeviceIconDownloader::CEntry& aEntry )
    {
    return !aEntry.iDeviceUuid->Compare( *aDeviceUuid );
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::CEntry::ConstructL
// --------------------------------------------------------------------------
void CUpnpDeviceIconDownloader::CEntry::ConstructL( const TDesC8& aDeviceUuid,
        const TDesC8& aDeviceIconUrl )
    {
    iDeviceUuid = aDeviceUuid.AllocL();
    iDeviceIconUrl = aDeviceIconUrl.AllocL();
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::CUpnpDeviceIconDownloader
// --------------------------------------------------------------------------
CUpnpDeviceIconDownloader::CUpnpDeviceIconDownloader( 
        MUpnpDeviceIconDownloadObserver& aObserver, TUint aIap ) :
    iObserver( aObserver ), iIap( aIap ) 
    {
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::ConstructL
// --------------------------------------------------------------------------
void CUpnpDeviceIconDownloader::ConstructL()
    {
    __LOG1( "CUpnpDeviceIconDownloader::ConstructL - IAP %d", iIap );
    User::LeaveIfError( iFs.Connect() );
    User::LeaveIfError( iFs.ShareProtected() );
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::DownloadNext
// --------------------------------------------------------------------------
void CUpnpDeviceIconDownloader::DownloadNext()
    {
    while( !iCurrent && iQueue.Count() > 0  )
        {
        iCurrent = iQueue[ 0 ];
        iQueue.Remove( 0 );
        TRAPD( err, DownloadNextL( *iCurrent ) );
        if ( err != KErrNone )
            {
            __LOG1( "CUpnpDeviceIconDownloader::DownloadNext - Error: %d", err );
            TRAP_IGNORE( iObserver.DeviceIconDownloadedL( iCurrent->DeviceUuid(), err ) );
            delete iCurrent;
            iCurrent = NULL;
            }
        }
    __LOG1( "CUpnpDeviceIconDownloader::DownloadNext - Waiting: %d", iQueue.Count() );
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::DownloadNextL
// --------------------------------------------------------------------------
void CUpnpDeviceIconDownloader::DownloadNextL( CEntry& aNext )
    {
    CheckDiskSpaceL();
    HBufC* fileName = TempFileNameLC( iFs );
    iFs.Delete( *fileName ); // Delete previous, ignore error
    iFs.MkDirAll( *fileName ); // Ensure folder exists, ignore error
    iDownloader->DownloadFileL( aNext.DeviceIconUrl(), *fileName, &aNext );
    CleanupStack::PopAndDestroy( fileName );
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::CleanupFilesL
// --------------------------------------------------------------------------

void CUpnpDeviceIconDownloader::CleanupFilesL()
    {
    HBufC* folderName = FolderNameLC( iFs );    
    __LOG1( "CUpnpDeviceIconDownloader::CleanupFilesL - %S", folderName );
    CFileMan* fileMan = CFileMan::NewL( iFs );
    CleanupStack::PushL( fileMan );
    fileMan->RmDir( *folderName ); // Ignore error
    CleanupStack::PopAndDestroy( fileMan );
    CleanupStack::PopAndDestroy( folderName );
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::FileExistsL
// --------------------------------------------------------------------------
TBool CUpnpDeviceIconDownloader::FileExistsL( const TDesC8& aDeviceUuid )
    {
    HBufC* filename = FileNameLC( iFs, aDeviceUuid );
    TEntry entry;
    TBool ret( iFs.Entry( *filename, entry ) == KErrNone );
    __LOG2( "CUpnpDeviceIconDownloader::FileExistsL - %S %d", filename, ret );
    CleanupStack::PopAndDestroy( filename );
    return ret;
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::CleanupFilesIfNeededL
// --------------------------------------------------------------------------
void CUpnpDeviceIconDownloader::CleanupFilesIfNeededL()
    {
    TInt cleanupNeeded( ETrue );
    TUid category( PropertyCategory() );
    GetIntPropertyL( category, KCleanupNeededKey, cleanupNeeded );
    if ( cleanupNeeded )
        {
        CleanupFilesL();
        User::LeaveIfError( RProperty::Set( category, KCleanupNeededKey, EFalse ) );
        }
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::CheckDiskSpaceL
// --------------------------------------------------------------------------
void CUpnpDeviceIconDownloader::CheckDiskSpaceL()
    {
    if ( SysUtil::DiskSpaceBelowCriticalLevelL( &iFs, KDefaultDiskSpaceNeeded,
            RFs::GetSystemDrive() ) )
        {
        iCleanupOnShutdown = ETrue;
        User::Leave( KErrDiskFull );
        }
    }

// --------------------------------------------------------------------------
// CUpnpDeviceIconDownloader::InProgress
// --------------------------------------------------------------------------
TBool CUpnpDeviceIconDownloader::InProgress( const TDesC8& aDeviceUuid )
    {
    return ( ( iCurrent && !iCurrent->DeviceUuid().Compare( aDeviceUuid ) ) ||
             iQueue.Find( aDeviceUuid, CEntry::Compare ) != KErrNotFound );
    }

// end of file