/*

* Copyright (c) 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:      Utility for working with files in upnp context

*

*/

// INCLUDE FILES

// System

#include <e32std.h>

#include <upnpelement.h>

#include <caf/content.h>                // CAF (WM-DRM check)

#include <caf/agent.h>                  // CAF (WM-DRM check)

#include <caf/rightsinfo.h>

#include <DRMCommon.h>         // OEM-DRM

#include <pathinfo.h>               // PathInfo

// dlnasrv / avcontroller helper api

#include "upnpitemutility.h"        // FindAttributeByName

#include "upnpconstantdefs.h"       // KAttributeSize

#include "upnpfileutility.h"

// dlnasrv / internal api's

#include "upnpsettingsengine.h"     // get target drive

_LIT( KComponentLogfile, "upnpavcontrollerhelper.txt");

#include "upnplog.h"

// CONSTANTS

_LIT( KWmDrmAgentName,     "PV WMA CAF Agent" );

_LIT( K60WmDrmAgentName,   "WM DRM Agent" );

const TInt64 KPhoneMemoryThreshold    = 1048576; //1MB

// ============================ LOCAL FUNCTIONS =============================

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

// UPnPFileUtility::IsFileDrmProtectedL

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

EXPORT_C TBool UPnPFileUtility::IsFileProtectedL(

    const TDesC& aFilePath )

    {

    __LOG( "FileUtility:IsFileDrmProtectedL( aFileName )" );

    TBool isProtected = ETrue;

    // Check if the file is OEM-DRM protected

    DRMCommon* drmCommon = DRMCommon::NewL();

    CleanupStack::PushL( drmCommon );

    User::LeaveIfError( drmCommon->Connect() );

    User::LeaveIfError( drmCommon->IsProtectedFile(

        aFilePath, isProtected ) );

    CleanupStack::PopAndDestroy( drmCommon );

    drmCommon = NULL;

    // If not OEM-DRM protected, check if the file is WM-DRM protected

    if( !isProtected )

        {

        CContent* content = CContent::NewLC( aFilePath );

        TAgent agent = content->Agent();

        // Check if .wma file

        if( agent.Name().CompareF( KWmDrmAgentName ) == 0 ||

            agent.Name().CompareF( K60WmDrmAgentName ) == 0 )

            {

            __LOG( "FileUtility:IsFileDrmProtectedL: .wma file " );

            CData* data = CData::NewL( (TVirtualPathPtr) aFilePath,

                EPeek, EContentShareReadOnly );

            data->GetAttribute( EIsProtected, isProtected );

            delete data;

            }

        CleanupStack::PopAndDestroy( content );

        content = NULL;

        }

    return isProtected;

    }

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

// UPnPFileUtility::FitsInMemory

// see UPnPFileUtility.h

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

EXPORT_C TBool UPnPFileUtility::FitsInMemory(

    const CUpnpElement& aResource )

    {

    TBool result( ETrue );

    //it will always return ETrue if Leave

    TRAP_IGNORE( result = FitsInMemoryL( aResource ) );

    return result;

    }

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

// UPnPFileUtility::FitsInMemory

// see UPnPFileUtility.h

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

TBool UPnPFileUtility::FitsInMemoryL( const CUpnpElement& aResource )

    {

    __LOG( "UPnPFileUtility::FitsInMemoryL" );

    // 1. get object size

    TInt fileSize = -1;

    const CUpnpAttribute* attr =

        UPnPItemUtility::FindAttributeByName( aResource, KAttributeSize );

    //if "file size" not found, straightly go for downloading

    if( !attr )   

        {

        __LOG( "UPnPFileUtility::size not found" );

        return ETrue;

        }

    // 2. convert size to integer

    TLex8 sizeconvert( attr->Value() );

    sizeconvert.Val( fileSize );

    if( fileSize < 0)

        {

        __LOG1( "UPnPFileUtility::file size %d", fileSize );

        return ETrue;

        }

    // 3. check the copy target configuration

    CUPnPSettingsEngine* engine = NULL;

    engine = CUPnPSettingsEngine::NewL();

    CleanupStack::PushL( engine );

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

    TPtr locationPtr( location->Des() );

    TBool isPhoneMemory;

    engine->GetCopyLocationL( locationPtr, isPhoneMemory );

    // 4. check bytes available in the drive

    RFs fileServer;

    CleanupClosePushL( fileServer );

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

    TVolumeInfo freeVol;

    User::LeaveIfError( fileServer.SetSessionPath( locationPtr ) );

    User::LeaveIfError( fileServer.Volume( freeVol ) );

    CleanupStack::PopAndDestroy(); // close fileServer;

    CleanupStack::PopAndDestroy(); // delete location

    CleanupStack::PopAndDestroy( engine ); // not needed anymore

    __LOG1( "UPnPFileUtility::free space: %d", freeVol.iFree );

    TInt64 freeSize = 0;

    // 5. result

    // With phone memory a threshold is used. 

    if( isPhoneMemory )

        {

        freeSize = freeVol.iFree - KPhoneMemoryThreshold;

        }

    else

        {

        freeSize = freeVol.iFree;

        }

    if( freeSize >= fileSize )

        {

        __LOG( "UPnPFileUtility::FitsInMemoryL -TRUE" );

        return ETrue;

        }

    else

        {

        __LOG( "UPnPFileUtility::FitsInMemoryL -FALSE" );

        return EFalse;

        }

    }