/*

* Copyright (c) 2002-2006 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 CDocumentHandler class.

*

*/

// INCLUDE FILES

#include "DocumentHandler.h"        // Class Declaration

#include "DocConstants.h"

// All special handlers and the default handler

#include "DocDefaultHandler.h"

#include "DocImageHandler.h"

#include "DocGameHandler.h"

#include "DocAppInstHandler.h"

//#include "DocMidletHandler.h"

#ifdef ENABLE_DRM

#include "DocDCFHandler.h"

#include <Oma2Agent.h>

#endif // ENABLE_DRM

#include <AiwGenericParam.h>

#include <featmgr.h>

#include <centralrepository.h>

#include <CommonUiInternalCRKeys.h>

#define LEAVEONERROR( error ) if( error != KUserCancel && error != KErrNone )\

                                   User::Leave( error )

const TInt KDocMaxCenRepBufLen = 1024;

const TInt KDocPDMaxMimeLen = 64;

const TInt KDocPDMaxUids = 24;

const TInt KDocPDMaxUidLen = 12;

const TInt KDocMaxDigitsInHexString = 8; // 32 bits.

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

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

// might leave.

// @since Series60 3.0

//

CDocumentHandler::CDocumentHandler()

    {

    }

// Two-phased constructor.

// @since Series60 3.0

EXPORT_C CDocumentHandler* CDocumentHandler::NewL( )

    {

    CDocumentHandler* self = NewLC( );

    CleanupStack::Pop();

    return self;

    }

// Two-phased constructor.

// @since Series60 3.0

EXPORT_C CDocumentHandler* CDocumentHandler::NewLC( )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// EPOC default constructor can leave.

void CDocumentHandler::ConstructL()

    {

    iApaLs = new ( ELeave ) RApaLsSession;

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

    FeatureManager::InitializeLibL();

    iTempFileName.Zero();

    }

// Two-phased constructor.

EXPORT_C CDocumentHandler* CDocumentHandler::NewL( CEikProcess* /*aProcess*/ )

    {

    CDocumentHandler* self = NewLC( );

    CleanupStack::Pop();

    return self;

    }

// Two-phased constructor.

EXPORT_C CDocumentHandler* CDocumentHandler::NewLC( CEikProcess* /*aProcess*/ )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor

EXPORT_C CDocumentHandler::~CDocumentHandler()

    {

    FeatureManager::UnInitializeLib();

    if ( iApaLs )

        {

        iApaLs->Close();

        delete iApaLs;

        }

    CloseSharableFS();

    // If we have temp file, we use iHandler services to delete this file

    if ( iTempFileName.Length() != 0 && iHandler )

        {

        iHandler->DeleteFile(iTempFileName);

        }

    delete iHandler;

    if ( iInParams )

        {

        delete iInParams;

        }

    #ifdef _DEBUG

    RDebug::Print( _L("DocumentHandler: CDocumentHandler instance destructed succesfully!"));

    #endif

    }

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

// RApaLsSession* CDocumentHandler::ApaLs()

// Returns Application list server object

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

RApaLsSession* CDocumentHandler::ApaLs()

    {

    return iApaLs;

    }

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

// CDocumentHandler::DocOperation()

// Returns CDocumentHandler::iOperation.

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

TDocOperation CDocumentHandler::DocOperation() const

    {

    return iOperation;

    }

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

// MApaEmbeddedDocObserver* CDocumentHandler::ExitObserver()

// Returns ExitObserver

// @since Series60 3.0

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

MAknServerAppExitObserver* CDocumentHandler::ServerAppExitObserver() const

    {

    return iServerAppExitObserver;

    }

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

// CDocumentHandler::SaveL

// Save content to the correct directory based on aDataType

// with a generated filename and attributes.

//

// This functions calls other SaveL version.

//

// Returns: KErrNone:           Everything went ok

//          KUserCancel:      The user cancelled the operation

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

//

EXPORT_C TInt CDocumentHandler::SaveL(

    const TDesC8& aContent,     // Content buffer

    TDataType& aDataType,       // Mime type of the content

    const TUint aAttr )         // Save with these attributes

    {

    #ifdef _DEBUG

    RDebug::Print( _L("DocumentHandler: CDocumentHandler::SaveL(aContent, aDataType, aAttr) Called"));

    TPtrC mimetype = aDataType.Des();

    RDebug::Print( _L("DocumentHandler: Parameters are: aDataType: %S "), &mimetype);

    #endif

    TFileName nullFileName;

    return SaveL(aContent, aDataType, nullFileName, aAttr);

    }

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

// CDocumentHandler::SaveL

// Save content to the correct directory based on aDataType

// with aFileName and attributes.

//

// We first save wile with SaveTempFileL command.

// After that we use MoveL command.

//

// Returns: KErrNone:           Everything went ok

//          KUserCancel:      The user cancelled the operation

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

//

EXPORT_C TInt CDocumentHandler::SaveL(

    const TDesC8& aContent,     // Content buffer

    TDataType& aDataType,       // Mime type of the content

    const TDesC& aName,         // Save with this name

    const TUint aAttr )         // Save with these attributes

    {

    #ifdef _DEBUG

    RDebug::Print( _L("DocumentHandler: CDocumentHandler::SaveL(aContent, aDataType, aFileName, aAttr) Called"));

    TPtrC mimetype = aDataType.Des();

    RDebug::Print( _L("DocumentHandler: Parameters are: aDataType: %S -- aFileName: %S  "), &mimetype, &aName);

    #endif

    TUid uid = { 0 };

    TInt error;

    if (aDataType.Des8().FindF( KDummyMimeType ) != KErrNotFound)

        {

        return KErrNone;

        }

    TFileName tempFileName;

    iOperation = EDocSaveTemp; // First save temp file

    // Use Default Handler for saving whatever mimetype actually is

    delete iHandler;            // delete the old handler

    iHandler = NULL;

    iHandler = CDocDefaultHandler::NewL( aDataType,

                                             uid, this, EDocSaveOnly );

    error = iHandler->SetDestName( aName );     // Save with this file name

    // Close if existing sharable RFs and create new for sharing purposes.

    if ( error == KErrNone )

        {

        CloseSharableFS();

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

        iSharableFS.ShareProtected();

        }

    if ( error == KErrNone )

        {

        error = iHandler->SaveTempFileL( aContent, KEntryAttNormal, tempFileName);

        }

    iOperation = EDocMove; // Move temp file to correct folder

    if ( error == KErrNone )

        {

        RecognizeAndCheckFileL( tempFileName, aDataType, uid );

        TRAP( error, FindHandlerL( aDataType, uid ) ); // allow unsupported.

        if ( error == KMimeNotSupported )

            {

            iHandler = CDocDefaultHandler::NewL( aDataType, uid, this, EDocSaveOnly );

            error = KErrNone;

            }

        else

            {

            User::LeaveIfError( error );

            }

        }

    if ( !iHandler->CanSave() )

        {

        User::Leave( KErrNotSupported );

        }

    if ( error == KErrNone )

        {

        error = iHandler->SetSrcFileName( tempFileName );

        }

    if ( error == KErrNone )

        {

        error = iHandler->SetDestName( aName );

        }

    // We use CopyOrMoveL-function, iOperation is checked there

    if ( error == KErrNone )

        {

        error = iHandler->CopyOrMoveL( aAttr );

        }

    #ifdef _DEBUG

    RDebug::Print( _L("DocumentHandler: CDocumentHandler::SaveL: finished with error=%d."), error);

    #endif

    LEAVEONERROR( error );

// Because DCF files are not tried to be recognized we return empty

// type here. Normally the return value has the type which was used

// when handler was selected.

#ifdef ENABLE_DRM

#ifdef __DRM_OMA2

    if ( aDataType.Des8().FindF( KOma1DcfContentType ) != KErrNotFound ||

         aDataType.Des8().FindF( KOma2DcfContentType ) != KErrNotFound )

#else // __DRM_OMA2

    if ( aDataType.Des8().FindF( KOma1DcfContentType ) != KErrNotFound )

#endif // __DRM_OMA2

        {

        TDataType emptyDataType;

        aDataType = emptyDataType;

        }

#endif // ENABLE_DRM

    return error;

    }

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

// CDocumentHandler::CopyL

// Copy file to the correct directory based on it's mime type.

//

// Returns: KErrNone:           Everything went ok

//          KUserCancel:      The user cancelled the operation

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

//

EXPORT_C TInt CDocumentHandler::CopyL(

    const TDesC& aFileNameOld,  // copy data from this file

    const TDesC& aFileNameNew,  // using this filename

    TDataType& aDataType,       // Mime type of data

    const TUint aAttr )         // use these attributes

    {

    #ifdef _DEBUG

    RDebug::Print( _L("DocumentHandler: CDocumentHandler::CopyL(aFileNameOld, aFileNameNew, aDataType, aAttr) Called"));

    TPtrC mimetype = aDataType.Des();

    RDebug::Print( _L("DocumentHandler: Parameters are: aDataType: %S -- aFileNameOld: %S -- aFileNameNew: %S"), &mimetype, &aFileNameOld, &aFileNameNew);

    #endif

    TInt error = KErrNone;

    TUid uid = { 0 };

    if (aDataType.Des8().FindF( KDummyMimeType ) != KErrNotFound)

        {

        return KErrNone;

        }

    iOperation = EDocCopy;

    RecognizeAndCheckFileL( aFileNameOld, aDataType, uid );

    TRAP( error, FindHandlerL( aDataType, uid ) ); // allow unsupported.

    if ( error == KMimeNotSupported )

        {

        iHandler = CDocDefaultHandler::NewL( aDataType, uid, this, EDocSaveOnly );

        error = KErrNone;

        }

    else

        {

        User::LeaveIfError( error );

        }

    if ( !iHandler->CanSave() )

        {

        User::Leave( KErrNotSupported );

        }

    error = iHandler->SetSrcFileName( aFileNameOld );

    if ( error == KErrNone )

        {

        // If aFileNameNew is not set, use source file name

        if (aFileNameNew.Length() != 0)

            {

            error = iHandler->SetDestName( aFileNameNew );

            }

        else

            {

            error = iHandler->SetDestName( aFileNameOld );

            }

        }

    // We use CopyOrMoveL-function, iOperation is checked there

    if ( error == KErrNone )

        {

        error = iHandler->CopyOrMoveL( aAttr );

        }

    #ifdef _DEBUG

    RDebug::Print( _L("DocumentHandler: CDocumentHandler::CopyL: finished with error=%d."), error);

    #endif

    LEAVEONERROR( error );

    return error;

    }

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

// CDocumentHandler::CopyL

// Copy file to the correct directory based on it's mime type.

//

// Returns: KErrNone:           Everything went ok

//          KUserCancel:      The user cancelled the operation

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

//

EXPORT_C TInt CDocumentHandler::CopyL(

    const RFile& aFileOld,      // copy data from this file

    const TDesC& aFileNameNew,  // using this filename

    TDataType& aDataType,       // Mime type of data

    const TUint aAttr )         // use these attributes

    {

    #ifdef _DEBUG

    RDebug::Print( _L("DocumentHandler: CDocumentHandler::CopyL(aFileOld, aFileNameNew, aDataType, aAttr) Called"));

    TPtrC mimetype = aDataType.Des();

    TFileName fileNameOld;

    aFileOld.FullName(fileNameOld);

    RDebug::Print( _L("DocumentHandler: Parameters are: aDataType: %S -- aFileOld (name): %S -- aFileNameNew: %S"), &mimetype, &fileNameOld, &aFileNameNew);

    #endif

    TInt error = KErrNone;

    TUid uid = { 0 };

    if (aDataType.Des8().FindF( KDummyMimeType ) != KErrNotFound)

        {

        return KErrNone;

        }

    iOperation = EDocCopy;

    RecognizeAndCheckFileL( const_cast<RFile&>(aFileOld), aDataType, uid );

    TRAP( error, FindHandlerL( aDataType, uid ) ); // allow unsupported.

    if ( error == KMimeNotSupported )

        {

        iHandler = CDocDefaultHandler::NewL( aDataType, uid, this, EDocSaveOnly );

        error = KErrNone;

        }

    else

        {

        User::LeaveIfError( error );

        }

    if ( !iHandler->CanSave() )

        {

        User::Leave( KErrNotSupported );

        }

	TFileName filenameold;

    aFileOld.FullName( filenameold );

    iHandler->SetSrcFileName( filenameold );

    iHandler->SetSrcFile( aFileOld );

    // If aFileNameNew is not set, use source file name

    if (aFileNameNew.Length() != 0)

        {

        error = iHandler->SetDestName( aFileNameNew );

        }

    else

        {

        aFileOld.Name( filenameold );

        error = iHandler->SetDestName( filenameold );

        }

    // Let's do actual copying using CopyHandleL method

    if ( error == KErrNone )

        {

        error = iHandler->CopyHandleL( aFileOld, aAttr );

        }

    #ifdef _DEBUG

    RDebug::Print( _L("DocumentHandler: CDocumentHandler::CopyL: finished with error=%d."), error);

    #endif

    LEAVEONERROR( error );

    return error;

    }

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

// CDocumentHandler::MoveL

// Move file to the correct directory based on it's mime type.

//

// Returns: KErrNone:           Everything went ok

//          KUserCancel:      The user cancelled the operation

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

//

EXPORT_C TInt CDocumentHandler::MoveL(

    const TDesC& aFileNameOld,  // Move this file ...

    const TDesC& aFileNameNew,  // ...to this filename

    TDataType& aDataType,       // Mime type of data

    const TUint aAttr )         // use these attributes to new file

    {

    #ifdef _DEBUG

    RDebug::Print( _L("DocumentHandler: CDocumentHandler::MoveL(aFileNameOld, aFileNameNew, aDataType, aAttr) Called"));

    TPtrC mimetype = aDataType.Des();

    RDebug::Print( _L("DocumentHandler: Parameters are: aDataType: %S -- aFileNameOld: %S -- aFileNameNew: %S"), &mimetype, &aFileNameOld, &aFileNameNew);

    #endif

    TInt error = KErrNone;

    TUid uid = { 0 };

    if (aDataType.Des8().FindF( KDummyMimeType ) != KErrNotFound)

        {

        return KErrNone;

        }

    iOperation = EDocMove;

    RecognizeAndCheckFileL( aFileNameOld, aDataType, uid );

    TRAP( error, FindHandlerL( aDataType, uid ) ); // allow unsupported.

    if ( error == KMimeNotSupported )

        {

        iHandler = CDocDefaultHandler::NewL( aDataType, uid, this, EDocSaveOnly );

        error = KErrNone;

        }

    else

        {

        User::LeaveIfError( error );

        }

    if ( !iHandler->CanSave() )

        {

        User::Leave( KErrNotSupported );

        }

    error = iHandler->SetSrcFileName( aFileNameOld );

    if ( error == KErrNone )

        {