/*

* Copyright (c) 2006 - 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:  Implementation of the Manager Interface

*

*/

// INCLUDE FILES

#include <caf.h>

#include <http.h>

#include <http/rhttpheaders.h>

#include <stringpool.h>

#include <w32std.h>

#include <apparc.h>

#include <apgtask.h>

#include <apgcli.h>

#include <apaserverapp.h>

#include <sysutil.h>

#include <wmdrmagent.h>

#include "wmdrmclient.h"

#include "wmdrmagentmanager.h"

#include "wmdrmagentattributes.h"

#include "asf.h"

#include "logfn.h"

using namespace ContentAccess;

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

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

// CWmDrmAgentManager::CWmDrmAgentManager

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

// might leave.

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

//

CWmDrmAgentManager::CWmDrmAgentManager()

    {

    LOGFN( "CWmDrmAgentManager::CWmDrmAgentManager" );

    }

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

// CWmDrmAgentManager::NewL

// Two-phased constructor.

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

//

CWmDrmAgentManager* CWmDrmAgentManager::NewL()

    {

    LOGFN( "CWmDrmAgentManager::NewL" );

    CWmDrmAgentManager* self=new(ELeave) CWmDrmAgentManager();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CWmDrmAgentManager::NewLC

// Two-phased constructor.

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

//

CWmDrmAgentManager* CWmDrmAgentManager::NewLC()

    {

    LOGFN( "CWmDrmAgentManager::NewLC" );

    CWmDrmAgentManager* self=new(ELeave) CWmDrmAgentManager();

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CWmDrmAgentManager::~CWmDrmAgentManager

// Destructor

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

//

CWmDrmAgentManager::~CWmDrmAgentManager()

    {

    LOGFN( "CWmDrmAgentManager::~CWmDrmAgentManager" );

    delete iFileMan;

    iFs.Close();

    }

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

// CWmDrmAgentManager::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CWmDrmAgentManager::ConstructL()

    {

    LOGFN( "CWmDrmAgentManager::ConstructL" );

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

    }

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

// CWmDrmAgentManager::DeleteFile

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

//

TInt CWmDrmAgentManager::DeleteFile(const TDesC& aFileName)

    {

    LOGFN( "CWmDrmAgentManager::DeleteFile" );

    return iFs.Delete(aFileName);

    }

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

// CWmDrmAgentManager::CopyFile

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

//

TInt CWmDrmAgentManager::CopyFile(const TDesC& aSource,

    const TDesC& aDestination)

    {

    LOGFN( "CWmDrmAgentManager::CopyFile" );

    TInt driveNumber = 0;

    TChar drive( aDestination[0] );

    RFile file;

    TInt size = 0;

    TInt result = KErrNone;

    TInt r = KErrNone;

    TBool retval(EFalse);

    // Check the destination drive letter

    result = iFs.CharToDrive(drive,driveNumber);

    if( result )

        {

        return result;

        }

    // open the file to read the size

    result = file.Open(iFs, aSource, EFileShareReadersOrWriters|EFileRead);

    if( result )

        {

        return result;

        }

    // read the size

    result = file.Size( size );

    // close the file

    file.Close();

    if( result )

        {

        return result;

        }

    // check that the drive has enough space for the copy operation

    TRAP(r, retval = SysUtil::DiskSpaceBelowCriticalLevelL( &iFs,

                                                             size,

                                                             driveNumber ) );

    if( retval )

        {

        return KErrDiskFull;

        }

    result = SetFileMan();

    if( result )

        {

        return result;

        }

    return iFileMan->Copy(aSource, aDestination);

    }

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

// CWmDrmAgentManager::CopyFile

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

//

TInt CWmDrmAgentManager::CopyFile(RFile& aSource,

    const TDesC& aDestination)

    {

    LOGFN( "CWmDrmAgentManager::CopyFile (2)" );

    TInt driveNumber = 0;

    TChar drive( aDestination[0] );

    TInt size = 0;

    TInt result = KErrNone;

    RFile output;

    TFileName fileName;

    TInt r = KErrNone;

    TBool retval(EFalse);

    // Same file, do not even try to copy

    // And since they are the same don't return an error

    aSource.FullName( fileName );

    if( !aDestination.CompareF( fileName ) )

        {

        return KErrNone;

        }

    // Check the destination drive letter

    result = iFs.CharToDrive(drive,driveNumber);

    if( result )

        {

        return result;

        }

    // read the size

    result = aSource.Size( size );

    if( result )

        {

        return result;

        }

    // check that the drive has enough space for the copy operation

    TRAP(r, retval = SysUtil::DiskSpaceBelowCriticalLevelL( &iFs,

                                                            size,

                                                            driveNumber ) );

    if( retval )

        {

        return KErrDiskFull;

        }

    // Perform the copy:

    // Rewind just in case:

    size = 0;

    result = aSource.Seek(ESeekStart, size);

    if( !result )

        {

        result = SetFileMan();

        if( result )

            {

            return result;

            }

        result = iFileMan->Copy(aSource, aDestination);

        }

    return result;

    }

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

// CWmDrmAgentManager::RenameFile

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

//

TInt CWmDrmAgentManager::RenameFile(const TDesC& aSource,

    const TDesC& aDestination)

    {

    LOGFN( "CWmDrmAgentManager::RenameFile" );

    TInt driveNumber = 0;

    TChar drive( aDestination[0] );

    RFile file;

    TInt size = 0;

    TInt result = KErrNone;

    TInt r = KErrNone;

    TBool retval(EFalse);

    result = SetFileMan();

    if( result )

        {

        return result;

        }

    result = iFileMan->Rename(aSource, aDestination);

    // If the files are on a different drive, Rename will fail

    // Therefore we simulate the Move by doing a Copy, followed by Delete

    if ( result != KErrNone )

        {

        // Check the destination drive letter

        result = iFs.CharToDrive(drive,driveNumber);

        if( result )

            {

            return result;

            }

        // open the file to read the size

        result = file.Open(iFs, aSource, EFileShareReadersOrWriters|EFileRead);

        if( result )

            {

            return result;

            }

        // read the size

        result = file.Size( size );

        // close the file

        file.Close();

        if( result )

            {

            return result;

            }

        // check that the drive has enough space for the copy operation

        TRAP(r, retval = SysUtil::DiskSpaceBelowCriticalLevelL( &iFs,

                                                                size,

                                                                driveNumber ) );

        if( retval )

            {

            return KErrDiskFull;

            }

        result = iFileMan->Copy(aSource,aDestination);

        if (result == KErrNone)

            {

            // If the copy was successful try and delete the original

            result = iFileMan->Delete(aSource);

            if (result != KErrNone)

                {

                // Delete failed so try to cleanup the destination file

                // as we're going to exit with an error

                // We can safely ignore any error from this as the previous error

                // is more important to propagate, since this is just cleanup

                iFileMan->Delete(aDestination);

                }

            }

        }

    return result;

    }

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

// CWmDrmAgentManager::MkDir

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

//

TInt CWmDrmAgentManager::MkDir(const TDesC& aPath)

    {

    LOGFN( "CWmDrmAgentManager::MkDir" );

    return iFs.MkDir( aPath );

    }

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

// CWmDrmAgentManager::MkDirAll

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

//

TInt CWmDrmAgentManager::MkDirAll(const TDesC& aPath)

    {

    LOGFN( "CWmDrmAgentManager::MkDirAll" );

    return iFs.MkDirAll( aPath );

    }

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

// CWmDrmAgentManager::RmDir

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

//

TInt CWmDrmAgentManager::RmDir(const TDesC& aPath)

    {

    LOGFN( "CWmDrmAgentManager::RmDir" );

    TInt result = KErrNone;

    result = SetFileMan();

    if( result )

        {

        return result;

        }

    return iFileMan->RmDir( aPath );

    }

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

// CWmDrmAgentManager::GetDir

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

//

TInt CWmDrmAgentManager::GetDir(const TDesC& aName, TUint aEntryAttMask,

    TUint aEntrySortKey, CDir*& aEntryList) const

    {

    LOGFN( "CWmDrmAgentManager::GetDir" );

    return iFs.GetDir( aName, aEntryAttMask, aEntrySortKey, aEntryList );

    }

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

// CWmDrmAgentManager::GetDir

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

//

TInt CWmDrmAgentManager::GetDir(const TDesC& aName,TUint aEntryAttMask,

    TUint aEntrySortKey, CDir*& aEntryList,CDir*& aDirList) const

    {

    LOGFN( "CWmDrmAgentManager::GetDir (2)" );

    return iFs.GetDir( aName, aEntryAttMask, aEntrySortKey, aEntryList, aDirList );

    }

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

// CWmDrmAgentManager::GetDir

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

//

TInt CWmDrmAgentManager::GetDir(const TDesC& aName,

    const TUidType& aEntryUid,TUint aEntrySortKey,

    CDir*& aFileList) const

    {

    LOGFN( "CWmDrmAgentManager::GetDir (3)" );

    return iFs.GetDir( aName, aEntryUid, aEntrySortKey, aFileList );

    }

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

// CWmDrmAgentManager::GetAttribute

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

//

TInt CWmDrmAgentManager::GetAttribute(TInt aAttribute, TInt& aValue,

    const TVirtualPathPtr& aVirtualPath)

    {

    TInt r = KErrNone;

    TInt err = KErrNone;

    LOGFN( "CWmDrmAgentManager::GetAttribute" );

    TRAP(err, r = CWmDrmAgentManager::GetAttributeCreateFileL(

            aAttribute, aValue, aVirtualPath));

    if(err != KErrNone)

        {

        return err;

        }

    return r;

    }

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

// CWmDrmAgentManager::GetAttributeCreateFileL

//

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

//

TInt CWmDrmAgentManager::GetAttributeCreateFileL(TInt aAttribute, TInt& aValue,

    const TVirtualPathPtr& aVirtualPath)

    {

    TInt r = KErrNone;

    CAsf *asfFile = CAsf::NewL(aVirtualPath.URI());

    CleanupStack::PushL(asfFile);

    r = TWmDrmAgentAttributes::GetAttributeL(asfFile,

        aAttribute, aValue, aVirtualPath);

    CleanupStack::PopAndDestroy();

    return r;

    }

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

// CWmDrmAgentManager::GetAttributeSet

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

//

TInt CWmDrmAgentManager::GetAttributeSet(RAttributeSet& aAttributeSet,

    const TVirtualPathPtr& aVirtualPath)

    {

    TInt r = KErrNone;

    TInt err = KErrNone;

    LOGFN( "CWmDrmAgentManager::GetAttributeSet" );

    TRAP(err, r = CWmDrmAgentManager::GetAttributeSetCreateFileL(

            aAttributeSet, aVirtualPath));

    if(err != KErrNone)

        {

        return err;

        }

    return r;

    }

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

// CWmDrmAgentManager::GetAttributeSetCreateFileL

//

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

TInt CWmDrmAgentManager::GetAttributeSetCreateFileL(

    RAttributeSet& aAttributeSet, const TVirtualPathPtr& aVirtualPath)

    {

    TInt r = KErrNone;

    CAsf *asfFile = CAsf::NewL(aVirtualPath.URI());

    CleanupStack::PushL(asfFile);

    r = TWmDrmAgentAttributes::GetAttributeSetL(asfFile,

        aAttributeSet, aVirtualPath);

    CleanupStack::PopAndDestroy();

    return r;

    }

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

// CWmDrmAgentManager::GetStringAttributeSet

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

//

TInt CWmDrmAgentManager::GetStringAttributeSet(

    RStringAttributeSet& aAttributeSet, const TVirtualPathPtr& aVirtualPath)

    {

    TInt r = KErrNone;

    TInt err = KErrNone;

    RFile file;

    LOGFN( "CWmDrmAgentManager::GetStringAttributeSet" );

    TRAP(err, r = CWmDrmAgentManager::GetStringAttributeSetCreateFileL(

            aAttributeSet, aVirtualPath ));

    if(err != KErrNone)

        {

        return err;

        }

    return r;

    }

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

// CWmDrmAgentManager::GetStringAttributeSetCreateFileL

//

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

//

TInt CWmDrmAgentManager::GetStringAttributeSetCreateFileL(

    RStringAttributeSet& aAttributeSet, const TVirtualPathPtr& aVirtualPath)

    {

    TInt r = KErrNone;

    CAsf *asfFile = CAsf::NewL(aVirtualPath.URI());

    CleanupStack::PushL(asfFile);

    r = TWmDrmAgentAttributes::GetStringAttributeSetL(

              asfFile, aAttributeSet, aVirtualPath);

    CleanupStack::PopAndDestroy();

    return r;

    }

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

// CWmDrmAgentManager::GetStringAttribute

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