/*

* Copyright (c) 2002-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:  Default Epoc-style content handler.

*

*/

#include <bautils.h>                // For NearestLanguageFile(..)

#include <eikdoc.h>                 // CEikDocument

#include <AknQueryDialog.h>         // CAknQueryDialog

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

#include <stringresourcereader.h>   // CStringResourceReader

#include <sysutil.h>                // For FFSSpaceBelowCriticalLevelL(..)

#include <uri16.h>                  // For url handling.

#include <avkon.rsg>                // Avkon ids

#include <documenthandlerui.rsg>    // Resource ids

#include "DocDefaultHandler.h"      // Class decration

#include "DocSaver.h"               // Saver util

#include "DocConstants.h"           // Documenthandler constants

#include "DocResourceFile.h"        // CDocResourceFile

#include <AiwGenericParam.h>        // Generic parameters

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>      //DriveInfo

#include <coemain.h>

#endif

#include "pathinfo.h"               // PathInfo

#include <featmgr.h>                // FeatureManager

#ifdef RD_CONTENTNOTIFICATION

#include <contentnotification.hrh>

#include <contentcreatedevent.h>

#include <contentnotification.h>

#endif

#ifdef ENABLE_DRM

#include <caf/caf.h>

#include <Oma2Agent.h>

#include <DcfEntry.h>               // CDcfEntry 

#include <DcfRep.h>                 // CDcfRep

#endif 

#ifdef __KEEP_DRM_CONTENT_ON_PHONE

#include <oem/distributablechecker.h>

#endif

#include <f32file.h>

using namespace ContentAccess;

_LIT( KFSName, "Fat" );

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

LOCAL_C inline TBool NeedsToReplaceDcf2Extension( TDes& aFileName )

    {

    TParsePtrC ptr( aFileName );

    if ( ptr.ExtPresent() )

        {

        TPtrC ext( ptr.Ext() );

        if( !KOma2DcfExtensionAudio().CompareF( ext ) ||

            !KOma2DcfExtensionVideo().CompareF( ext ) ||

            !KOma2DcfExtension().CompareF( ext ) )

            {

            // no need to replace extension.

            return EFalse;

            }

        }

    return ETrue;

    }

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

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

// might leave.

//

CDocDefaultHandler::CDocDefaultHandler(    

    const TDataType& aDataType,

    const TUid& aUid,

    CDocumentHandler* aDocDispatcher,

    TDocServiceMode aServiceMode ) : 

        iApaLs( aDocDispatcher->ApaLs() ),

        iDataType( aDataType ),

        iDocDispatcher( aDocDispatcher ),

        iFileManager( NULL ),

        iSavedAsTemp( EFalse ),

        iServiceMode( aServiceMode ),

        iStatus( KErrNone ),

        iUid( aUid ),

        iOpenService( NULL ),

        iMMCSaveAllowed ( ETrue )

    {

    }

// Destructor  

//

CDocDefaultHandler::~CDocDefaultHandler()

    {

    #ifdef _DEBUG        

    RDebug::Print( _L("DocumentHandler: CDocDefaultHandler::~CDocDefaultHandler"));

    #endif      

    iFs.Close();        // Close sessions

    if ( iOpenService )

    {

        delete iOpenService;

    }                            

    delete iFileManager; // Delete members  

    delete iAiwParams;

    delete iOutAiwParams;

    delete iMimeExtensions;

    delete iExtensions;

    delete iIdle;

    }

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

// Two-phased constructor. 

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

//

CDocDefaultHandler* CDocDefaultHandler::NewL(

    const TDataType& aDataType,

    const TUid& aUid,

    CDocumentHandler* aDocDispatcher,

    TDocServiceMode aServiceMode )

    {

    CDocDefaultHandler * self = NewLC( aDataType, aUid, 

                                       aDocDispatcher, aServiceMode );

    CleanupStack::Pop();

    return self;

    }

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

// Two-phased constructor. Leaves the contructed instance in to the 

// clean up stack.

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

//

CDocDefaultHandler* CDocDefaultHandler::NewLC(

    const TDataType& aDataType,

    const TUid& aUid,

    CDocumentHandler* aDocDispatcher,

    TDocServiceMode aServiceMode )

    {

    CDocDefaultHandler* self = 

        new ( ELeave ) CDocDefaultHandler( aDataType, aUid, 

                                           aDocDispatcher, aServiceMode );

    CleanupStack::PushL( self );

    self->BaseConstructL();

    return self;

    }

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

// Epoc contructor

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

//  

void CDocDefaultHandler::BaseConstructL()

    {       

    User::LeaveIfError( iFs.Connect() ); // Connect to servers                      

    iFileManager = CFileMan::NewL( iFs );// Construct a filemanager   

    PopulateAppInfo();    

    }

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

// CDocDefaultHandler::SaveTempFileL()

// Save the content to the correct directory. 

// This method is used from CDocumentHandler::SaveTempFileL() 

// and CDocumentHandler::SaveL()

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

//

TInt CDocDefaultHandler::SaveTempFileL( 

    const TDesC8& aContent, 

    const TUint aAttr,

    TDes& aFileName)

    {

    #ifdef _DEBUG        

    RDebug::Print( _L("DocumentHandler: CDocDefaultHandler::SaveTempFileL(aContent, aAttr, aFileName) Called"));

    #endif 

    TInt error = KErrNone;              // Error code

    if ( aContent.Size() == 0 )         // Check if there is anything to save.

        {

        return SetAndReturnStatus( KNullContent );  

        }

    error = SaveChecksL(aContent);

    #ifdef _DEBUG        

    RDebug::Print( _L("DocumentHandler: CDocDefaultHandler::SaveTempFileL: error=%d after filename checks."), error);

    #endif 

    if ( error == KErrNone )

        {              

        #ifdef _DEBUG        

        RDebug::Print( _L("DocumentHandler: CDocDefaultHandler::SaveTempFileL: Trying to save the file..."));

        #endif 

        iFs.MkDirAll( iDestFile );

        RFile tempfile;

        User::LeaveIfError( tempfile.Replace( iFs, iDestFile, EFileShareAny | EFileWrite) );   

        HBufC* waitNoteText = HBufC::NewLC( KDocWaitNoteMaxLen );

        TPtr waitNoteTextPtr = waitNoteText->Des();  

        WaitNoteTextL( waitNoteTextPtr );              

        CDocAsyncSaver* asyncSaver = CDocAsyncSaver::NewLC();

        AddResourcesL();

        asyncSaver->WriteToFileL(

            aContent, 

            tempfile, 

            waitNoteTextPtr );

        RemoveResources();

        User::LeaveIfError( asyncSaver->Status().Int() );

        CleanupStack::PopAndDestroy( 2 ); // asyncSaver, waitNoteTextPtr

        User::LeaveIfError( tempfile.SetAtt( aAttr, 0 ) );

        tempfile.Close();

        // Put filename to aFileName

        aFileName.Copy(iDestFile);

        #ifdef _DEBUG        

        RDebug::Print( _L("DocumentHandler: CDocDefaultHandler::SaveTempFileL: File %S saved and closed!"), &iDestFile);

        #endif 

        }

    return SetAndReturnStatus( error );

    }

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

// CDocDefaultHandler::SaveChecksL()

// This method is called from SaveTempFileL.

// Check disk space for file and generate filename.

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

//

TInt CDocDefaultHandler::SaveChecksL(const TDesC8& aContent)

    {

    TInt error = KErrNone;   

    if (GenerateFileNameL( iUid, iDestFile, iDataType, aContent.Length() ) == KErrCancel)

        {

        return KUserCancel;

        }

    CheckDiskspaceL( aContent.Size() ); // Leave if not enough space to save.

    TBool done = EFalse;                // Try saving until done    

    do

        {

        TBool valid  = iFs.IsValidName( iDestFile );

        TBool exists = BaflUtils::FileExists( iFs, iDestFile );

        #ifdef _DEBUG        

        RDebug::Print( _L("DocumentHandler: CDocDefaultHandler::SaveChecksL: Filename valid=%d"), valid);

        RDebug::Print( _L("DocumentHandler: CDocDefaultHandler::SaveChecksL: Filename exists=%d"), exists);

        #endif 

        // If filename allready exists, generate new name without asking user 

        if ( exists || !valid )

            {

            GenerateTempFileNameL( iDestFile ,MaxNameLen() );

            }

        else

            {

            if ( error == KErrNone )

                {

                done = ETrue;

                }

            else

                {

                User::Leave( SetAndReturnStatus( error ) );

                }

            } // else

        }

    while ( !done ); 

    // If file is saved to temp place, DocumentHandler is responsible of deleting this file.

    if ( iSavedAsTemp ) 

        {

        iDocDispatcher->SetTempFile(iDestFile);

        }

    return error;

    }

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

// CDocDefaultHandler::CopyChecksAndQueriesL()   

// This method is called from CopyOrMoveL and CopyHandleL. 

// Check disk space for file, generate filename and

// and show save as query to user.

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

//

TInt CDocDefaultHandler::CopyChecksAndQueriesL(TInt aDataSize)

    {

    TInt error = KErrNone;      // Error code

    #ifdef _DEBUG      

    RDebug::Print( _L("DocumentHandler: CDocDefaultHandler::CopyChecksAndQueriesL: Enter, aDataSize = %d"), aDataSize);

    #endif

    if (GenerateFileNameL( iUid, iDestFile, iDataType, aDataSize) == KErrCancel)

        {

        return KUserCancel;

        }

    CheckDiskspaceL( aDataSize ); // Leave if not enough space to save.

    // Make destination directories

    error = iFs.MkDirAll( iDestFile );

    if ( error != KErrAlreadyExists && error != KErrNone )

        {

        User::Leave( error );   // Something unexpected happend

        }

    TBool done = EFalse;        // Try until done    

    do 

        {

        TBool valid  = iFs.IsValidName( iDestFile );

        TBool exists = BaflUtils::FileExists( iFs, iDestFile );

        #ifdef _DEBUG      

        RDebug::Print( _L("DocumentHandler: CDocDefaultHandler::CopyChecksAndQueriesL: Filename = %S"), &iDestFile);

        RDebug::Print( _L("DocumentHandler: CDocDefaultHandler::CopyChecksAndQueriesL: Filename valid=%d"), valid);

        RDebug::Print( _L("DocumentHandler: CDocDefaultHandler::CopyChecksAndQueriesL: Filename exists=%d"), exists);

        #endif 

        // If filename allready exists, generate new name without asking 

        // user in case of SilentMove

        if ( (DocOperation() == EDocSilentMove) &&

             (exists || !valid) )

            {

            GenerateTempFileNameL( iDestFile ,MaxNameLen() );

            }

        else if ( !valid || (exists && !iSavedAsTemp) )

            {

            switch ( SaveAsQueryL( iDestFile ) )

                {

                case EDocFileCancelWrite:

                    done = ETrue;  

                    iDestFile.Zero();

                    error = KUserCancel;

                    HandleServerAppExit(0);

                    break;

                case EDocFileOverWrite:

                    done = ETrue;

                    error = KErrNone;

                    break;

                case EDocFileRenameNew:  

                    CheckFileNameExtensionL( iDestFile, iDataType );

                    break;

                default:

                    User::Leave( SetAndReturnStatus( KErrUnknown ) );

                } // switch

            } // if

        else  // if

            {

             done = ETrue;

             error = KErrNone;

            }

        } while ( !done );// while

    // If file is saved to temp place, DocumentHandler is responsible of deleting this file.

    if ( iSavedAsTemp ) 

        {

        iDocDispatcher->SetTempFile(iDestFile);

        }

    #ifdef _DEBUG      

    RDebug::Print( _L("DocumentHandler: CDocDefaultHandler::CopyChecksAndQueriesL: Finished, error = %d"), error);

    #endif

    return error;

    }

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

// CDocDefaultHandler::CopyOrMoveL()    

// Copy/Move file to the correct directory. DocOperation() 

// tells what we do (copy/move/silentmove)

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

//   

TInt CDocDefaultHandler::CopyOrMoveL( const TUint aAttr )

    {

    TInt error = KErrNone;      // Error code

    TEntry fileEntry;           // File entry

    IsMMCSaveAllowedL(iSourceFile);

    User::LeaveIfError( iFs.Entry( iSourceFile, fileEntry ) );

    error = CopyChecksAndQueriesL(fileEntry.iSize);

    if ( error == KErrNone )

        {             

        HBufC* waitNoteText = HBufC::NewLC( KDocWaitNoteMaxLen );

        TPtr waitNoteTextPtr = waitNoteText->Des();  

        CDocAsyncSaver* asyncSaver = CDocAsyncSaver::NewLC();

		if (DocOperation() == EDocSilentMove)    

            {

            asyncSaver->MoveFileL(

                iFileManager,

                iSourceFile, 

                iDestFile, 

                ETrue,                 

                waitNoteTextPtr,

                ETrue );

            }

		else 

			{

			WaitNoteTextL( waitNoteTextPtr );                

			// This function is called either from MoveL or CopyL or SilentMoveL

			if (DocOperation() == EDocMove)

    			{

           	 	AddResourcesL();

           	 	asyncSaver->MoveFileL(

           		   iFileManager,

           	 	   iSourceFile, 

       			   iDestFile, 

       			   ETrue,                

   		    	   waitNoteTextPtr,

          	 	   EFalse );

           	 	RemoveResources();

    			}

   		 	else

   		 		{

   		 		AddResourcesL();

            	asyncSaver->CopyFileL(

       		 		iFileManager,

       		 		iSourceFile, 

       		 		iDestFile, 

           			ETrue,                 

           	 		waitNoteTextPtr );

           		 RemoveResources();

           		 }

			}

        error = asyncSaver->Status().Int();   

        User::LeaveIfError( error );

        User::LeaveIfError( iFileManager->Attribs( iDestFile, aAttr, 0, TTime( 0 ), 0 ) );

        if(asyncSaver->ShowDialog() && IsConfNoteAllowed())

            {

            HBufC* confNoteText = HBufC::NewLC( KDocConfNoteMaxLen );

            TPtr confNoteTextPtr = confNoteText->Des();  

            ConfirmationNoteTextL( confNoteTextPtr );  

            CDocSaver::ConfNoteL( confNoteTextPtr, ETrue );

            CleanupStack::PopAndDestroy( 1 ); // confNoteTextPtr

            }

        CleanupStack::PopAndDestroy( 2 ); // asyncSaver, waitNoteTextPtr

        // Notify MediaGallery that its content may have been changed

        TRAP_IGNORE(UpdateMediaGalleryIfNeededL());

        // Notify DCFRepository about new file

        // DcfRepository leaves if file is not-DRM file, so this call needs to be TRAPPED

        TRAP_IGNORE(UpdateDCFRepositoryL());

        }

    return SetAndReturnStatus( error );

    }

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

// CDocDefaultHandler::CopyHandleL()    

// Copy file to the correct directory. 

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

//   

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

    {

    TInt error = KErrNone;      // Error code    

    TInt fileSize;

    IsMMCSaveAllowedL(aSourceFile);

    User::LeaveIfError( aSourceFile.Size(fileSize) );

    error = CopyChecksAndQueriesL(fileSize);

    if ( error == KErrNone )

        {

        HBufC* waitNoteText = HBufC::NewLC( KDocWaitNoteMaxLen );

        TPtr waitNoteTextPtr = waitNoteText->Des();  

        WaitNoteTextL( waitNoteTextPtr );              

        CDocAsyncSaver* asyncSaver = CDocAsyncSaver::NewLC();

        AddResourcesL();

        asyncSaver->CopyFileL(

            iFileManager, 

            aSourceFile, 

            iDestFile, 

            ETrue, 

            waitNoteTextPtr );

        RemoveResources();

        error = asyncSaver->Status().Int();   

        User::LeaveIfError( error );

        User::LeaveIfError( iFileManager->Attribs( iDestFile, aAttr, 0, TTime( 0 ), 0 ) );       

        if(asyncSaver->ShowDialog() && IsConfNoteAllowed())

            {

            HBufC* confNoteText = HBufC::NewLC( KDocConfNoteMaxLen );

            TPtr confNoteTextPtr = confNoteText->Des();  

            ConfirmationNoteTextL( confNoteTextPtr );

            CDocSaver::ConfNoteL( confNoteTextPtr, ETrue );

            CleanupStack::PopAndDestroy( 1 ); // confNoteTextPtr

            }

        CleanupStack::PopAndDestroy( 2 ); // asyncSaver, waitNoteTextPtr

        // Notify MediaGallery that its content may have been changed

        TRAP_IGNORE(UpdateMediaGalleryIfNeededL());

        // Notify DCFRepository about new file

        // DcfRepository leaves if file is not-DRM file, so this call needs to be TRAPPED

        TRAP_IGNORE(UpdateDCFRepositoryL());

        }

    return SetAndReturnStatus( error );

    }