/** @file

* Copyright (c) 2008-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:  Media Server icon's manager

*

*/

// INCLUDE FILES

#include "upnpiconmanager.h"

#include "upnpicon.h"

#include "upnpmediaserverglobals.h"

#include "upnpcons.h"

#include "upnpdeviceimplementation.h"

#include "upnpstring.h"

#include "upnpmediaserverdescriptionprovider.h"

#include <upnpdevicedescriptionstore.h>

_LIT8( KIconDir, "/mediaserver1/icon/") ;

_LIT( KPathC, "C:" );

_LIT( KFileSpec,"*" );

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

// CUpnpIconManager::NewL

// Two-phased constructor.

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

//

CUpnpIconManager* CUpnpIconManager::NewL( CUpnpDeviceDescriptionStore& aDescriptionStore,

                              CUpnpMediaServerDescriptionProvider& aDescriptionProvider )

    {

    CUpnpIconManager* self = CUpnpIconManager::NewLC( aDescriptionStore, 

                                                      aDescriptionProvider );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpIconManager::NewLC

// Two-phased constructor.

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

//

CUpnpIconManager* CUpnpIconManager::NewLC( CUpnpDeviceDescriptionStore& aDescriptionStore,

                               CUpnpMediaServerDescriptionProvider& aDescriptionProvider )

    {

    CUpnpIconManager* self= new (ELeave) CUpnpIconManager( aDescriptionStore, 

                                                           aDescriptionProvider );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CUpnpIconManager::~CUpnpIconManager

// Destructor

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

//

CUpnpIconManager::~CUpnpIconManager()

    {

    iFileSession.Close();

    iIconList.ResetAndDestroy();

    }

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

// CUpnpIconManager::AddIconL

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

//

void CUpnpIconManager::AddIconL( const TDesC8& aIconDes )

    {

    CUpnpIcon* icon = CUpnpIcon::NewL();

    CleanupStack::PushL( icon );

    RDesReadStream stream( aIconDes );

    CleanupClosePushL( stream );

    stream >> *icon;

    TPtrC8 iconUrl;

    TPtrC8 iconName8;

    TInt iconNameTemp;

    TInt iconNameInt(0);

    if ( iIconList.Count() != 0 )

        {

        for ( TInt i(0); i < iIconList.Count(); i++ )

            {

            iconUrl.Set( iIconList[ i ]->Url() );

            iconName8.Set( iconUrl.Mid( KIconDir().Length() ) );

            TLex8 lexer( iconName8 );

            lexer.Val( iconNameTemp );

            if ( iconNameInt < iconNameTemp )

                iconNameInt = iconNameTemp;

            }

        iconNameInt++;

        }

    TBufC<UpnpString::KMaxTUintLength> iconNameBuff;

    iconNameBuff.Des().Num( iconNameInt );

    HBufC8* iconUrl8 = HBufC8::NewLC( KIconDir().Length() + iconNameBuff.Length() );

    iconUrl8->Des().Append( KIconDir() );

    iconUrl8->Des().Append( iconNameBuff );

    icon->SetUrlL( *iconUrl8 );

    HBufC* iconPath = GetIconPathLC();

    HBufC16* destinationPath = HBufC16::NewLC( iconPath->Length() + UpnpString::KMaxTUintLength );

    destinationPath->Des().Append( *iconPath );

    destinationPath->Des().Append( iconNameBuff );

    CopyIconToPrivateL( icon , *destinationPath );

    iDescriptionStore.AddIconL( *icon );

    iIconList.AppendL( icon );

    iDescriptionProvider.AddUriToFileMapL( *iconUrl8, *destinationPath );

    CleanupStack::PopAndDestroy( destinationPath );

    CleanupStack::PopAndDestroy( iconPath );

    CleanupStack::PopAndDestroy( iconUrl8 );

    CleanupStack::PopAndDestroy( &stream );

    CleanupStack::Pop( icon );

    }

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

// CUpnpIconManager::UpdateIconL

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

//    

void CUpnpIconManager::UpdateIconL( const TDesC8& aNewIconDes, const TDesC8& aUrl )

    {

    HBufC16* url = UpnpString::ToUnicodeL( aUrl );

    CleanupStack::PushL( url );

    HBufC16* iconName = GetIconNameLC( aUrl );

    HBufC8* iconUrl = HBufC8::NewLC( KIconDir().Length() + iconName->Length() );

    iconUrl->Des().Append( KIconDir() );

    iconUrl->Des().Append( *iconName );

    CUpnpIcon* icon = CUpnpIcon::NewL();

    CleanupStack::PushL( icon );

    RDesReadStream stream( aNewIconDes );

    CleanupClosePushL( stream );

    stream >> *icon;

    icon->SetUrlL( *iconUrl );

    User::LeaveIfError( FindIcon( *iconUrl ) );

    HBufC* iconPath = GetIconPathLC();

    HBufC16* destinationPath = HBufC16::NewLC( iconPath->Length() + 

                                               iconName->Length() );

    destinationPath->Des().Append( *iconPath );

    destinationPath->Des().Append( *iconName );

    HBufC* backupName = PrepareIconToRollbackLC( *destinationPath );

    TRAPD( err , DoUpdateIconL( icon , *destinationPath ) );

    if ( err )

        {

        TUint att;

        if( ! iFileSession.Att( *backupName , att ) )

            {

            iFileSession.Delete( *destinationPath );

            iFileSession.Rename( *backupName , *destinationPath );         

            }

        else

            {

            RestoreFromOrginalPathL( aUrl );

            }

        DeleteIconFile( *backupName );

        User::Leave( err );

        }

    DeleteIconFile( *backupName );

    CleanupStack::PopAndDestroy( backupName );

    CleanupStack::PopAndDestroy( destinationPath );

    CleanupStack::PopAndDestroy( iconPath );

    CleanupStack::PopAndDestroy( &stream );

    CleanupStack::Pop( icon );

    CleanupStack::PopAndDestroy( iconUrl );

    CleanupStack::PopAndDestroy( iconName );

    CleanupStack::PopAndDestroy( url );

    }

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

// CUpnpIconManager::RemoveIconL

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

//  

void CUpnpIconManager::RemoveIconL( const TDesC8& aUrl )

    {

    HBufC16* url = UpnpString::ToUnicodeL( aUrl );

    CleanupStack::PushL( url );

    HBufC16* iconName16 = GetIconNameLC( aUrl );    

    HBufC8* iconName8 = UpnpString::FromUnicodeL( *iconName16 );

    CleanupStack::PushL( iconName8 );

    HBufC8* iconUrl = HBufC8::NewLC( KIconDir().Length() 

                                    + iconName8->Length() );  

    iconUrl->Des().Append( KIconDir() );

    iconUrl->Des().Append( *iconName8 );

    HBufC* iconDirectory = GetIconPathLC();

    HBufC* iconFullPath = HBufC::NewLC( iconDirectory->Length() 

                                        + iconName16->Length() );

    iconFullPath->Des().Append( *iconDirectory );

    iconFullPath->Des().Append( *iconName16 );

    TInt iconIdx = FindIcon( *iconUrl );

    User::LeaveIfError( iconIdx );

    User::LeaveIfError( DeleteIconFile( *iconFullPath ) );

    TRAPD( error, iDescriptionStore.RemoveIconL( *iconUrl ) );

    if ( error != KErrNotFound )

        {

        User::LeaveIfError( error );  

        }

    delete iIconList[ iconIdx ];

    iIconList.Remove( iconIdx );

    iDescriptionProvider.RemoveUriToFileMapL( *iconUrl );

    CleanupStack::PopAndDestroy( iconFullPath );

    CleanupStack::PopAndDestroy( iconDirectory );

    CleanupStack::PopAndDestroy( iconUrl ); 

    CleanupStack::PopAndDestroy( iconName8 );

    CleanupStack::PopAndDestroy( iconName16 );    

    CleanupStack::PopAndDestroy( url );      

    }

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

// CUpnpIconManager::RemoveIconsL

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

//      

void CUpnpIconManager::RemoveIconsL()

    {

    for ( TInt i = 0; i < iIconList.Count(); i++ )

        {

        iDescriptionProvider.RemoveUriToFileMapL( iIconList[ i ]->Url() );

        }

    TRAPD( error, iDescriptionStore.RemoveIconsL() );

    if ( error != KErrNotFound )

        {

        User::LeaveIfError( error );  

        }

    iIconList.ResetAndDestroy();

    HBufC* iconPath = GetIconPathLC();

    HBufC* fileSpec = HBufC::NewLC( iconPath->Length() + KFileSpec().Length() );

    fileSpec->Des().Append( *iconPath );

    fileSpec->Des().Append( KFileSpec() );

    CDir* dirList;

    User::LeaveIfError( iFileSession.GetDir( *fileSpec , 

                                             KEntryAttMaskSupported, 

                                             ESortByName, dirList) );

    CleanupStack::PushL( dirList );    

    TBuf<UpnpString::KMaxTUintLength> fileName;

    for ( TInt i(0); i < dirList->Count(); i++)

        {

        fileName = (*dirList)[i].iName;

        HBufC* totalPath = HBufC::NewLC( iconPath->Length() + fileName.Length() );

        totalPath->Des().Append( *iconPath );

        totalPath->Des().Append( fileName );

        DeleteIconFile( *totalPath );

        CleanupStack::PopAndDestroy( totalPath );

        }

    CleanupStack::PopAndDestroy( dirList );

    CleanupStack::PopAndDestroy( fileSpec );

    CleanupStack::PopAndDestroy( iconPath );

    }

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

// CUpnpIconManager::GetIconPathLC

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

//

HBufC* CUpnpIconManager::GetIconPathLC()

    {

    TFileName privatePath;

    iFileSession.PrivatePath( privatePath );

    HBufC* iconPath = HBufC::NewLC( KPathC().Length() + privatePath.Length() 

                                  + KIconDest().Length());

    iconPath->Des().Append( KPathC() );

    iconPath->Des().Append( privatePath );

    iconPath->Des().Append( KIconDest() );

    return iconPath;

    }

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

// CUpnpMediaServer::GetIconNameLC

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

//

HBufC* CUpnpIconManager::GetIconNameLC( const TDesC8& aPath )

    {

    _LIT16( KIcon, "icon" );

    const TInt KSlashesOffset( 1 );

    HBufC* iconPath = HBufC::NewLC( aPath.Length() );

    iconPath->Des().Copy( aPath );

    iconPath->Des() = iconPath->Mid( 

                   User::LeaveIfError( iconPath->FindF( KIcon() ) ) 

                                     + KIcon().Length()

                                     + KSlashesOffset );

    HBufC* iconName = HBufC::NewL( iconPath->Length() );

    iconName->Des().Append( *iconPath );

    CleanupStack::PopAndDestroy( iconPath );

    CleanupStack::PushL( iconName );

    TLex iconLex( *iconName );

    TInt iconNum;

    TInt err( iconLex.Val( iconNum ) );

    if ( err )

        {

        User::Leave( KErrNotFound );

        }

    return iconName;

    }

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

// CUpnpIconManager::CopyIconToPrivateL

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

//

void CUpnpIconManager::CopyIconToPrivateL( const CUpnpIcon* aIcon , 

                                           const TDesC& aDestinationPath 

                                         )

    {   

    CFileMan* fM = CFileMan::NewL( iFileSession );

    CleanupStack::PushL( fM );

    TInt err( fM->Copy( aIcon->BitmapFilename(), aDestinationPath ) );

    if( err == KErrAccessDenied )

        {

        fM->Attribs( aDestinationPath ,KEntryAttNormal , KEntryAttReadOnly|

                                                         KEntryAttHidden|

                                                         KEntryAttSystem , 0 );

        User::LeaveIfError( fM->Copy( aIcon->BitmapFilename(), aDestinationPath ) );

        }

    else

        {

        User::LeaveIfError( err );

        }

    User::LeaveIfError( fM->Attribs( aDestinationPath , 

                                     KEntryAttNormal , KEntryAttReadOnly|

                                                       KEntryAttHidden|

                                                       KEntryAttSystem , 0 ) );

    CleanupStack::PopAndDestroy( fM );    

    }

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

// CUpnpMediaServer::PrepareIconToRollbackLC

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

//   

HBufC* CUpnpIconManager::PrepareIconToRollbackLC( const TDesC& aPath )

    {

    _LIT( KBeckupExt, ".beckup" );

    HBufC* beckupName = HBufC::NewLC( aPath.Length() + KBeckupExt().Length() );//on cleanupstack

    beckupName->Des().Append( aPath );

    beckupName->Des().Append( KBeckupExt() );

    iFileSession.Delete( *beckupName );

    iFileSession.Rename( aPath , *beckupName );

    return beckupName;

    }

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

// CUpnpMediaServer::DoUpdateIconL

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

//      

void CUpnpIconManager::DoUpdateIconL( CUpnpIcon* aIcon, const TDesC& aDestinationPath )

    {

    CopyIconToPrivateL( aIcon , aDestinationPath );

    iDescriptionStore.UpdateIconL( *aIcon );

    TInt idx = FindIcon( aIcon->Url() );

    if ( idx > KErrNotFound )

        {

        delete iIconList[ idx ];

        iIconList.Remove( idx );

        iIconList.AppendL( aIcon );

        }

    }

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

// CUpnpMediaServer::DeleteIconFile

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

//  

TInt CUpnpIconManager::DeleteIconFile( const TDesC& aPath )

    {

    TInt err( iFileSession.Delete( aPath ) );  

    if( err == KErrAccessDenied )

        {

        iFileSession.SetAtt( aPath ,KEntryAttNormal , KEntryAttReadOnly|

                                                     KEntryAttHidden|

                                                     KEntryAttSystem );

        err = iFileSession.Delete( aPath );

        }

    else if ( err == KErrNotFound )

        {

        err = KErrNone;

        }

    return err;

    }

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

// CUpnpMediaServer::RestoreFromOrginalPathL

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

//  

void CUpnpIconManager::RestoreFromOrginalPathL( const TDesC8& aUrl )

    {

    for ( TInt i(0) ; i< iIconList.Count() ; i++ )

        {

        if ( !iIconList[ i ]->Url().CompareF( aUrl ) )

            {

            HBufC* iconPath = GetIconPathLC();

            HBufC* iconName = GetIconNameLC( aUrl );

            HBufC* destinationPath = HBufC16::NewLC( iconPath->Length() +

                                                     UpnpString::KMaxTUintLength );

            destinationPath->Des().Append( *iconPath );

            destinationPath->Des().Append( *iconName );

            CopyIconToPrivateL( iIconList[ i ] , *destinationPath );

            CleanupStack::PopAndDestroy( destinationPath );

            CleanupStack::PopAndDestroy( iconName );

            CleanupStack::PopAndDestroy( iconPath );

            return;

            }

        }

    }

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

// CUpnpMediaServer::FindIcon

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

// 

TInt CUpnpIconManager::FindIcon( const TDesC8& aUrl )

    {

    for ( TInt i(0) ; i< iIconList.Count() ; i++ )

        {

        if ( !iIconList[i]->Url().CompareF( aUrl ) )

            {

            return i;

            }

        }

    return KErrNotFound;

    }

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

// CUpnpIconManager::AddIconsToDescriptionPropoertyMapL

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

//

void CUpnpIconManager::AddIconsToDescriptionPropertyMapL()

    {

    HBufC* iconPath = GetIconPathLC();

    for ( TInt i = 0; i < iIconList.Count(); i++ )

        {

        TPtrC8 url = iIconList[ i ]->Url();

        HBufC* iconName = GetIconNameLC( url );

        HBufC* path = HBufC::NewLC( iconPath->Length() + iconName->Length() );

        path->Des().Copy( iconPath->Des() );

        path->Des().Append( iconName->Des() );

        iDescriptionProvider.AddUriToFileMapL( url, path->Des() );

        CleanupStack::PopAndDestroy( path );

        CleanupStack::PopAndDestroy( iconName );

        }

    CleanupStack::PopAndDestroy( iconPath );

    }

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

// CUpnpIconManager::ConstructL

// Two-phase constructor

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

//

void CUpnpIconManager::ConstructL()

    {

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

    iIconList = iDescriptionStore.IconListL();

    AddIconsToDescriptionPropertyMapL();

    }

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

// CUpnpIconManager::CUpnpIconManager

// Constructor

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

//    

CUpnpIconManager::CUpnpIconManager( CUpnpDeviceDescriptionStore& aDescriptionStore,

                                    CUpnpMediaServerDescriptionProvider& aDescriptionProvider )

     : iDescriptionProvider( aDescriptionProvider ), iDescriptionStore( aDescriptionStore )

    {