/*
* 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