/*

* Copyright (c) 2002-2005 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 DCF handler class.

*

*/

#include <e32std.h>

#include <s32mem.h>

#include <coemain.h>

#include <DRMCommon.h>

#include <DRMHelper.h>

#include <AiwGenericParam.h>

#include <AknQueryDialog.h>         // CAknQueryDialog

#include <documenthandlerui.rsg>    // Resource ids

#include <StringLoader.h>           // For loading resource strings

#include <stringresourcereader.h>   // CStringResourceReader

#include "DocDCFHandler.h"

#include "DocDefaultHandler.h"

#include "DocResourceFile.h"

#include "DocSaver.h" 

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

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

// might leave.

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

//

CDocDCFHandler::CDocDCFHandler( 

    const TDataType& aDataType,

    TDocOperation aOperation,

    const TUid& aUid,

    CDocumentHandler* aDocDispatcher): 

        CDocDefaultHandler( aDataType, aUid, aDocDispatcher, EDocOpenAndSave ),

        iEntryFunc( aOperation )

    {

    }

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

// Two-phased constructor. 

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

//

CDocDCFHandler* CDocDCFHandler::NewL(

    const TDataType& aDataType,

    TDocOperation aOperation, 

    const TUid& aUid,

    CDocumentHandler* aDocDispatcher)

    {

    CDocDCFHandler *self = new (ELeave) CDocDCFHandler( aDataType, aOperation, aUid, aDocDispatcher );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// Epoc contructor

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

//  

void CDocDCFHandler::ConstructL()

    {

    BaseConstructL();

    iDRMCommon = DRMCommon::NewL();

    }

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

// Destructor  

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

//

CDocDCFHandler::~CDocDCFHandler()

    {

    delete iDRMCommon;

    delete iDocHandler;

    }

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

// CDocDCFHandler::SetDataTypeL()

// Set the data type (iDataType)

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

//  

void CDocDCFHandler::SetDataTypeL(HBufC8* MIMEType)

    {               

    TPtr8 ptr = MIMEType->Des();

    ptr.Copy(*MIMEType);               

    iDataType = TDataType( ptr );

    #ifdef _DEBUG        

    TPtrC mimetype = iDataType.Des();  

    RDebug::Print( _L("DocumentHandler: CDocDCFHandler::SetDataTypeL: iDataType: %S "), &mimetype);

    #endif 

    }

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

// CDocDCFHandler::GetPath()

// Return the path where the content was saved/copied

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

//  

void CDocDCFHandler::GetPath( TDes& aPath ) const

    {

    if ( iDocHandler )

        {

        iDocHandler->GetPath( aPath );

        }

    else

        {

        aPath.Zero();

        }

    }

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

// CDocDCFHandler::HandlerAppUid()

// Returns handler application Uid.

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

// 

void CDocDCFHandler::HandlerAppUid( TUid& aUid ) const

    {

    if ( iDocHandler  )

        {

        iDocHandler->HandlerAppUid( aUid );

        }

    }

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

// CDocDCFHandler::CanOpen()

// Is the handler capable of opening the mime type

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

//   

TBool CDocDCFHandler::CanOpen() const

    {

    return ETrue;

    }

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

// CDocDCFHandler::CanSave()

// Is the handler capable of saving the mime type

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

//   

TBool CDocDCFHandler::CanSave() const

    {

    return ETrue;

    }

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

// CDocDCFHandler::ConvertErrorCode()

// Converts DRM error code to more generic one

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

//   

TInt CDocDCFHandler::ConvertErrorCode(TInt aDrmError)

    {

    switch (aDrmError)

        {

        case DRMCommon::EOk:

            return KErrNone;    

        case DRMCommon::EGeneralError:

            return KErrGeneral;

        case DRMCommon::EUnknownMIME:

            return KMimeNotSupported;

        case DRMCommon::EVersionNotSupported:

            return  KDRMErrInvalidVersion;

        case DRMCommon::ESessionError:

            return KDRMErrSession;

        case DRMCommon::ENoRights:

            return KDRMErrNoRights;

        case DRMCommon::ERightsDBCorrupted:

            return  KDRMErrRightsDBCorrupted;

        case DRMCommon::EUnsupported:

            return KErrNotSupported;                

        default:

            break;

        }

    // It is possible that DRM error is normal errorcode

    // those are passed without conversion.

    return aDrmError;     

    }

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

// CDocDCFHandler::OpenFileL( )

// Calls OpenDCFFileL.

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

//       

TInt CDocDCFHandler::OpenFileL(RFile& aFileHandle)

    {

    #ifdef _DEBUG        

    RDebug::Print( _L("DocumentHandler : CDocDCFHandler::OpenFileL called."));

    #endif   

    return OpenDCFFileL( aFileHandle );

    }

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

// CDocDCFHandler::OpenFileEmbeddedL( )

// Calls OpenDCFFileL.

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

//      

TInt CDocDCFHandler::OpenFileEmbeddedL(RFile& aFileHandle)

    {

    #ifdef _DEBUG        

    RDebug::Print( _L("DocumentHandler : CDocDCFHandler::OpenFileEmbeddedL called."));

    #endif       

    return OpenDCFFileL( aFileHandle );

    }

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

// CDocDCFHandler::CopyOrMoveL( )

// Calls CopyDCFFileL.

// CopyL & MoveL & SilentMoveL is supported

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

//  

TInt CDocDCFHandler::CopyOrMoveL( const TUint aAttr)

    {

    #ifdef _DEBUG        

    RDebug::Print( _L("DocumentHandler : CDocDCFHandler::CopyOrMoveL called."));

    #endif   

    RFile tempHandle; // This is only temporary, not used to anything

    TInt retValue = CopyDCFFileL(EFalse, tempHandle, aAttr);     

    tempHandle.Close();

    return retValue;  

    }

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

// CDocDCFHandler::CopyOrMoveL( )

// Calls CopyDCFFileL.

// CopyL is supported

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

//  

TInt CDocDCFHandler::CopyHandleL( const RFile& aSourceFile, const TUint aAttr )

    {

    // CopyL (with filehandle) is supported

    #ifdef _DEBUG        

    RDebug::Print( _L("DocumentHandler : CDocDCFHandler::CopyHandleL called."));

    #endif   

    return CopyDCFFileL(ETrue, const_cast<RFile&>(aSourceFile), aAttr);    

    }

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

// CDocDCFHandler::OpenDCFFileL( )

// Check DRM rights and create new CDocumentHandler instance

// for handling actual operation with payload MIME-type.

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

//  

TInt CDocDCFHandler::OpenDCFFileL(RFile& aFileHandle)

    {

    TUint bufLength;

    DRMCommon::TContentProtection protection;

    HBufC8* MIMEType = NULL;

    HBufC8* contentURI = NULL;

    TInt error;

    error = iDRMCommon->GetFileInfo(aFileHandle,

        protection,

        MIMEType,

        contentURI,

        bufLength); 

    if (error != DRMCommon::EOk)

        {

        #ifdef _DEBUG        

        RDebug::Print( _L("DocumentHandler : CDocDCFHandler::OpenDCFFileL: GetFileInfo returned=%d"), error);

        #endif 

        return ConvertErrorCode(error);

        }

    else 

        {

        error = KErrNone;    

        }

    // Errorcode from iDRMCommon cannot be trusted. Check here params first.

    if (!MIMEType || !contentURI)

        {

        if (MIMEType)

            delete MIMEType;

        if (contentURI)

            delete contentURI;

        return KDRMErrInvalidVersion; // This is one possible reason

        }

    CleanupStack::PushL( MIMEType );

    CleanupStack::PushL( contentURI );

    if ( MIMEType->FindF( KDataTypeDCF ) != KErrNotFound )

        {

        CleanupStack::PopAndDestroy(2);  // MIMEType, contentURI

        return KBadMimeType;

        }

    SetDataTypeL( MIMEType );  

    CDRMRights* rightsObject = NULL;

    TInt rights = iDRMCommon->GetActiveRights(*contentURI, 0, rightsObject);

    delete rightsObject;

    CleanupStack::PopAndDestroy(2);  // MIMEType, contentURI

    #ifdef _DEBUG        

    RDebug::Print( _L("DocumentHandler : CDocDCFHandler::OpenDCFFileL: Rights of file are=%d"), rights);

    #endif 

    // Check if file is empty (rights must exist before we can trust bufLength)

    if (rights != DRMCommon::ENoRights  && bufLength == 0)

        {

        return KNullContent;

        }

    if ( !iDocHandler )

        {

        iDocHandler = CDocumentHandler::NewL( ); 

        if (iDocDispatcher->ServerAppExitObserver())

            {

            iDocHandler->SetExitObserver(iDocDispatcher->ServerAppExitObserver());

            }

        }

    if (rights == DRMCommon::ENoRights)

        {

        return KDRMErrNoRights;

        }

    switch ( iEntryFunc )

        {

        case EDocOpenFileEmb:

            error = iDocHandler->OpenFileEmbeddedL( aFileHandle, iDataType, *iAiwParams );              

            break;

        case EDocOpenFile:

            error = iDocHandler->OpenFileL( aFileHandle, iDataType ); 

            break;         

        default:

            User::Leave( KErrNotSupported );

        }

    iStatus = error;

    return error;

    }

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

// CDocDCFHandler::CopyDCFFileL( )

// Check DRM rights and create new CDocumentHandler instance

// for handling actual operation with payload MIME-type.

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

//  

TInt CDocDCFHandler::CopyDCFFileL(TBool aUseHandle, RFile& aFileHandle, const TUint aAttr)

    {

    TUint bufLength;

    DRMCommon::TContentProtection protection;

    HBufC8* MIMEType = NULL;

    HBufC8* contentURI = NULL;

    TInt error;  

    if (aUseHandle) // Filehandle version

        {

        error = iDRMCommon->GetFileInfo(aFileHandle,

        protection,

        MIMEType,

        contentURI,

        bufLength); 

        }

    else            // FileName version   

        {

        error = iDRMCommon->GetFileInfo(iSourceFile,

        protection,

        MIMEType,

        contentURI,

        bufLength);  

        }    

    if (error != DRMCommon::EOk)

        {

        #ifdef _DEBUG        

        RDebug::Print( _L("DocumentHandler : CDocDCFHandler::CopyDCFFileL: GetFileInfo returned=%d"), error);

        #endif 

        return ConvertErrorCode(error);

        }

    else 

        {

        error = KErrNone;    

        }

    // Errorcode from iDRMCommon cannot be trusted. Check here params first.

    if (!MIMEType || !contentURI)

        {

        if (MIMEType)

            delete MIMEType;

        if (contentURI)

            delete contentURI;

        return KDRMErrInvalidVersion; // This is one possible reason

        }

    CleanupStack::PushL( MIMEType );

    CleanupStack::PushL( contentURI );

    if ( MIMEType->FindF( KDataTypeDCF ) != KErrNotFound )

        {

        CleanupStack::PopAndDestroy(2);  // MIMEType, contentURI

        return KBadMimeType;

        }

    SetDataTypeL( MIMEType );  

    CDRMRights* rightsObject = NULL;

    TInt rights = iDRMCommon->GetActiveRights(*contentURI, 0, rightsObject);  

    delete rightsObject;

    CleanupStack::PopAndDestroy(2);  // MIMEType, contentURI

    #ifdef _DEBUG        

    RDebug::Print( _L("DocumentHandler : CDocDCFHandler::CopyDCFFileL: Rights of file are=%d"), rights);

    #endif 

    // Check if file is empty (rights must exist before we can trust bufLength)

    if (rights != DRMCommon::ENoRights  && bufLength == 0)

        {

        return KNullContent;

        }

    // Check if file is with PreviewRights (preview file is not allowed to save)

    if (rights == CDRMRights::EPreviewRights && protection == DRMCommon::EForwardLocked)

        {

        return KDRMErrPreviewRights;

        }

    if ( !iDocHandler )

        {

        iDocHandler = CDocumentHandler::NewL( ); 

        if (iDocDispatcher->ServerAppExitObserver())

            {

            iDocHandler->SetExitObserver(iDocDispatcher->ServerAppExitObserver());

            }

        }

    switch ( iEntryFunc )

        {  

        case EDocCopy:         

            if (aUseHandle) // Filehandle version

                {

                error = iDocHandler->CopyL( aFileHandle, iDestFile, iDataType, aAttr );

                }                     

            else            // FileName version   

                {

                error = iDocHandler->CopyL( iSourceFile, iDestFile, iDataType, aAttr );

                }

            break;   

        case EDocMove:

            error = iDocHandler->MoveL( iSourceFile, iDestFile, iDataType, aAttr );

            break;         

        case EDocSilentMove:

            error = iDocHandler->SilentMoveL( iSourceFile, iDestFile, iRootPath, iDataType, aAttr );

            break;  

        default:

            User::Leave( KErrNotSupported );

        }

    iStatus = error;

    return error;  

    }

//  End of File