/*

* Copyright (c) 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:  

*       CPostcardOperationOpen

*

*/

// ========== INCLUDE FILES ================================

#include <AknsConstants.h>

#include <data_caging_path_literals.hrh> 

#include <apmstd.h>  // TDataType

#include <gulicon.h> // CGulIcon

#include <txtetext.h> // For TDocumentStorage

#include <MsgMediaInfo.h>

#include <MsgMedia.hrh>

#include <MsgImageInfo.h>

#include <MsgMediaResolver.h>		// for CMmsMediaResolver

#include <MsgTextInfo.h>

#include <msgtextutils.h>

#include <MsgMimeTypes.h>

#include <IHLImageFactory.h>

#include <IHLViewerFactory.h>

#include <MIHLFileImage.h>

#include <MIHLBitmap.h>

#include <MIHLImageViewer.h>

#include <mmsvattachmentmanager.h>		// AttachmentManager

#include <mmsvattachmentmanagersync.h>	// AttachmentManagerSync

#include <cmsvmimeheaders.h>		// MimeHeaders

#include <mmsclient.h>

#include <vprop.h>	// VCardPropertyValue

#include <cntitem.h>

#include <vcard.h>

#include <cntfldst.h> // CContactTextField

#include <StringLoader.h>			// for StringLoader

#include <Postcard.rsg>       	// for Postcard resources

#include "PostcardLaf.h"

#include "PostcardUtils.h"

#include "Postcard.hrh"

#include "PostcardOperationOpen.h"

#include "PostcardRecipientWrapper.h"

#include "PostcardContact.h"

#include "PostcardPrivateCRKeys.h"  // cenrep keys

#include "PostcardCenRep.h"

// ========== EXTERNAL DATA STRUCTURES =====================

// ========== EXTERNAL FUNCTION PROTOTYPES =================

// ========== CONSTANTS ====================================

// ========== MACROS =======================================

// ========== LOCAL CONSTANTS AND MACROS ===================

// This was "FN" in 3.0-3.1 but OMA says it should be "N". Accept

// both when opening and be compatible with both.

_LIT8(KPostcardVCardName, "N");

_LIT8(KPostcardVCardNameFN, "FN");

_LIT8(KPostcardVCardAddr, "ADR");

// ========== MODULE DATA STRUCTURES =======================

// ========== LOCAL FUNCTION PROTOTYPES ====================

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

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

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

// CPostcardOperationOpen::NewL

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

CPostcardOperationOpen* CPostcardOperationOpen::NewL(

            MPostcardOperationObserver& aObserver,

            CPostcardDocument& aDocument,

            CPostcardAppUi& aAppUi,

            RFs& aFs )

    {

    CPostcardOperationOpen* self = 

        new ( ELeave ) CPostcardOperationOpen( aObserver, aDocument, aAppUi, aFs );

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPostcardOperationOpen::CPostcardOperationOpen

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

CPostcardOperationOpen::CPostcardOperationOpen(

            MPostcardOperationObserver& aObserver,

            CPostcardDocument& aDocument,

            CPostcardAppUi& aAppUi,

            RFs& aFs ) :

    CPostcardOperation( aObserver, aDocument, aAppUi, aFs ),

    iSpecialFormat( aAppUi.CenRep().GetString( KPocaKeyServiceSpecialFormat ) ),

    iSeparatorChar( aAppUi.CenRep().GetString( KPocaKeyServiceSeparator ) )

    {

    }

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

// CPostcardOperationOpen::CPostcardOperationOpen

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

CPostcardOperationOpen::~CPostcardOperationOpen( )

    {

    if( iEditFile )

    	{

    	iEditFile->Close();

    	delete iEditFile;

    	}

    delete iImageInfo;

    delete iImageProcessor;

    }

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

// CPostcardOperationOpen::Start

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

void CPostcardOperationOpen::Start( TInt /*aArgument*/ )

    {

    ToState( EPostcardOpenInitializing );

    }

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

// CPostcardOperationOpen::Launch

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

void CPostcardOperationOpen::DoLaunchStepL()

    {

    iFlags &= ~EPostcardOpenRequestActive;

    switch ( iLaunchState )

        {

        case EPostcardOpenInitializing:

            {

            InitL( );

            iDocument.InitializeL( iFs );

            ToState( EPostcardOpenCheckAttas );

            break;

            }

        case EPostcardOpenCheckAttas:

            {

            if( !CheckAttasL( ) )

            	{ // If there was error, this has been completed already

	            ToState( EPostcardOpenHandleImage );            		

            	}

            else

                {

                iLaunchState = EPostcardOpenError;

                }

            break;

            }

        case EPostcardOpenHandleImage:

            {

            DoHandleImageL( );

            break;

            }

        case EPostcardOpenProcessImage:

            {

            DoStartProcessImageL( );

            break;

            }

        case EPostcardOpenHandleText:

            {

            DoHandleTextL( );

            break;

            }

        case EPostcardOpenHandleRecipient:

            {

            DoHandleRecipientL( );

            ToState( EPostcardOpenFinished );

            break;

            }

        case EPostcardOpenFinished:

            {

            UnInitL( );

            iObserver.PostcardOperationEvent(

                EPostcardOperationOpen,

                EPostcardOperationComplete ); 

            break;

            }

        default:

            UnInitL( );

            iObserver.PostcardOperationEvent(

                EPostcardOperationOpen,

                EPostcardOperationError ); 

            break;

        }

    }

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

// DoHandleL

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

void CPostcardOperationOpen::DoHandleImageL( )

    {

    if ( iImage != 0 )

        {

        if( iDocument.MessageType( ) == EPostcardSendAs )

        	{ // SendAs -> Lets see what's inside

			RFile imageFile = iManager->GetAttachmentFileL( iImage );

            CleanupClosePushL( imageFile );

			iImageInfo = iDocument.MediaResolver()->CreateMediaInfoL( imageFile );

			iDocument.MediaResolver()->ParseInfoDetailsL( iImageInfo, imageFile );

            // Lets first check if the file seems to be ok for inserting

            if( iImageInfo->Protection( ) )

                {

                CleanupStack::PopAndDestroy( &imageFile ); // imageFile

				ToErrorState( R_POSTCARD_CANNOT_SEND_PROTECTED );

				return;

                }

            if( iImageInfo->Corrupt( ) )

		        {

		        // Corrupt is set to only supported media types

                CleanupStack::PopAndDestroy( &imageFile ); // imageFile

				ToErrorState( R_POSTCARD_OBJECT_CORRUPTED );

				return;

		        }

		    else if ( !iDocument.IsImage( iImageInfo->MimeType( ) ) )

		        {

                CleanupStack::PopAndDestroy( &imageFile ); // imageFile

				ToErrorState( R_POSTCARD_FORMAT_NOT_SUPPORTED );

				return;

		        }

		    else if ( iImageInfo->MediaType() != EMsgMediaImage )

		        {

                CleanupStack::PopAndDestroy( &imageFile ); // imageFile

				ToErrorState( R_POSTCARD_FORMAT_NOT_SUPPORTED );

				return;

		        }

		    else if ( static_cast<CMsgImageInfo*>(iImageInfo)->IsAnimation( ) )

		        {

                CleanupStack::PopAndDestroy( &imageFile ); // imageFile

				ToErrorState( R_POSTCARD_FORMAT_NOT_SUPPORTED );

				return;

		        }

			TSize dimensions = static_cast<CMsgImageInfo*>(iImageInfo)->Dimensions( );

			TInt imageWidth = dimensions.iWidth>dimensions.iHeight?dimensions.iWidth:dimensions.iHeight;

			TInt imageHeight = dimensions.iWidth>dimensions.iHeight?dimensions.iHeight:dimensions.iWidth;

            TSize maxSize = iDocument.MaxImageDimensions( );

            // OK, it seems to be pretty ok, now lets see what we can do

            if( ( 	iImageInfo->MimeType( ).CompareF( KMsgMimeImagePng ) == 0 ) 

            	||  ( 		( imageWidth > maxSize.iWidth || imageHeight > maxSize.iHeight ) 

            			&&	iImageInfo->FileSize( ) > iDocument.MaxImageSize( ) ) )

                { // This is PNG or it's a too wide JPEG file

			    iEditFile = new ( ELeave ) RFile;

			    CMsvAttachment* attachment = CMsvAttachment::NewL( CMsvAttachment::EMsvFile );

    			CleanupStack::PushL( attachment );

			    attachment->SetAttachmentNameL( KPostcardFilenameScaled );

		        iManager->CreateAttachmentL( KPostcardFilenameScaled, *iEditFile, attachment, iStatus );

                iFlags |= EPostcardOpenRequestActive;                

		        CleanupStack::Pop( attachment );    // attachment

			    iEditAtta = attachment;

				iLaunchState = EPostcardOpenProcessImage;	

				SetActive();                

                CleanupStack::PopAndDestroy( &imageFile ); // imagefile

                return;

                }

			else if( iImageInfo->FileSize( ) > iDocument.MaxImageSize( ) )

		    	{ // Image is too big, but not too wide -> create empty attachment for now

			    iEditFile = new ( ELeave ) RFile;

			    CMsvAttachment* attachment = CMsvAttachment::NewL( CMsvAttachment::EMsvFile );

    			CleanupStack::PushL( attachment );

			    attachment->SetAttachmentNameL( KPostcardFilenameCompressed );

		        iManager->CreateAttachmentL( KPostcardFilenameCompressed, *iEditFile, attachment, iStatus );

                iFlags |= EPostcardOpenRequestActive;

		        CleanupStack::Pop( attachment );    // attachment

			    iEditAtta = attachment;

				iLaunchState = EPostcardOpenProcessImage;	

				SetActive();	        

                CleanupStack::PopAndDestroy( &imageFile ); // imagefile

                return;

				}

			else

			    { // OK, the file is ok, we just need to update the MsvHeaders

			    DoUpdateSendasAttachmentL( iImageInfo->MimeType( ) );

			    }

            CleanupStack::PopAndDestroy( ); // imagefile

        	}

        // Either this is not sendas or the image did not need conversion or compression

		RFile imageFile = iManager->GetAttachmentFileL( iImage );

        CleanupClosePushL( imageFile );

        // Scale image to bitmap to be drawn on the screen

        iSourceImage = IHLImageFactory::OpenFileImageL( imageFile );

        iDestinationBitmap = IHLBitmap::CreateL();        

        iImageHandler = IHLViewerFactory::CreateImageViewerL( PostcardLaf::Image( ).Size( ), 

                                                        *iSourceImage, 

                                                        *iDestinationBitmap, 

                                                        *this, 

                                                        TUint32( 0 ) );

        User::LeaveIfError( iImageHandler->SetSourceRectPosition( TPoint( 0, 0 ) ) );

	    CleanupStack::PopAndDestroy( &imageFile );   // imageFile

        }

    else

        {

        ToState( EPostcardOpenHandleText );

        }

    }

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

// DoStartProcessImageL

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

void CPostcardOperationOpen::DoStartProcessImageL( )

	{

	RFile sourceFile = iManager->GetAttachmentFileL( iImage );

	CleanupClosePushL( sourceFile );	

	if( !iImageProcessor )

	    {

        iImageProcessor = new (ELeave) CUniImageProcessor( this );	    

	    }

	TSize maxDimensions = iDocument.MaxImageDimensions( );

	TSize origDimensions = static_cast<CMsgImageInfo*>(iImageInfo)->Dimensions( );

	if( origDimensions.iWidth < origDimensions.iHeight )

		{ // It's portrait so swap max dimensions

		origDimensions = maxDimensions;

		maxDimensions.iWidth = origDimensions.iHeight;

		maxDimensions.iHeight = origDimensions.iWidth;

		}

    iImageProcessor->ProcessImageL( 	sourceFile, 

    									*iEditFile, 

    									maxDimensions,

    									KMsgMimeImageJpeg, 

    									ETrue,

    									iDocument.MaxImageSize( ) );

    CleanupStack::PopAndDestroy(); // sourceFile

	}

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

// DoUpdateSendasAttachmentL

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

void CPostcardOperationOpen::DoUpdateSendasAttachmentL( const TDataType& aMimeType )

    {

	CMsvMimeHeaders* headers = CMsvMimeHeaders::NewLC( );

	if( aMimeType.Des8( ).CompareF( KMsgMimeImageGif ) == 0  )

	    { // Image is gif

    	headers->SetContentLocationL( KPostcardFilenameNoOpGif);

	    }

	else

	    {

    	headers->SetContentLocationL( KPostcardFilenameNoOp );		    	    

	    }

	headers->SetContentTypeL( aMimeType.Des8( ) );

    // As this function is called only when in SendAs

    // there's certainly just one attachment so we index it directly

    CMsvAttachment* attachment = iManager->GetAttachmentInfoL( 0 );

    CleanupStack::PushL( attachment );

	headers->StoreL( *attachment );

    attachment->SetMimeTypeL( aMimeType.Des8( ) );

    iStore->AttachmentManagerExtensionsL( ).ModifyAttachmentInfoL( attachment );

    CleanupStack::Pop( attachment );

	CleanupStack::PopAndDestroy( headers ); 

	iStore->Commit( );

    // Lets check again (to get right AttachmentIds)

	CheckAttasL( );        

    }

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

// ImageProcessingReady

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

void CPostcardOperationOpen::ImageProcessingReady( TSize aBitmapSize, TInt aFileSize, TBool /*aCompressed*/ )

	{

    if( iEditFile )

        {

        iEditFile->Close();

        delete iEditFile;

        iEditFile = NULL;            

        }

	TBool imageFits = EFalse;

	TSize maxDimensions = iDocument.MaxImageDimensions( );

	if( aBitmapSize.iWidth <= maxDimensions.iWidth && 

		aBitmapSize.iHeight <= maxDimensions.iHeight )

		{

		imageFits = ETrue;

		}

	else if( aBitmapSize.iWidth <= maxDimensions.iHeight && 

		aBitmapSize.iHeight <= maxDimensions.iWidth )

		{

		imageFits = ETrue;

		}

	if( !imageFits || aFileSize > iDocument.MaxImageSize( ) )

		{ // The process was not successful

		ToErrorState( R_POSTCARD_PROCESS_NOT_SUCCESSFUL );

		return;

		}

    // Call this to start scaling to screen (deletes the previous image etc..)

    TRAPD( err, StartScalingToScreenL( ) );

    if( err )

        {

        ToErrorState( R_POSTCARD_FORMAT_NOT_SUPPORTED );

        }

	}

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

// StartScalingToScreenL

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

void CPostcardOperationOpen::StartScalingToScreenL( )

    {

    TInt oldImage =  TMsvIdToIndexL( iImage );

    iStore->AttachmentManagerExtensionsL( ).RemoveAttachmentL( oldImage );

	iStore->Commit( );

    DoUpdateSendasAttachmentL( iImageInfo->MimeType( ) );

    // Lets add headers

	RFile imageFile = iManager->GetAttachmentFileL( iImage );

	CleanupClosePushL( imageFile );

    iSourceImage = IHLImageFactory::OpenFileImageL( imageFile );

    iDestinationBitmap = IHLBitmap::CreateL();

    iImageHandler = IHLViewerFactory::CreateImageViewerL( PostcardLaf::Image( ).Size( ), 

                                                    *iSourceImage, 

                                                    *iDestinationBitmap, 

                                                    *this, 

                                                    TUint32( 0 ) );

    User::LeaveIfError( iImageHandler->SetSourceRectPosition( TPoint( 0, 0 ) ) );

    CleanupStack::PopAndDestroy( &imageFile ); // imageFile

    }

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

// ViewerBitmapChangedL

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

void CPostcardOperationOpen::ViewerBitmapChangedL()

    {

    CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

    CFbsBitmap* mask = NULL;

    bitmap->Duplicate( iDestinationBitmap->Bitmap().Handle( ) );

    if ( iDestinationBitmap->HasMask() )

        {

        mask = new (ELeave) CFbsBitmap;

        mask->Duplicate( iDestinationBitmap->Mask().Handle( ) );

        }

    delete iDestinationBitmap;

    iDestinationBitmap = NULL;

    delete iSourceImage;

    iSourceImage = NULL;

    delete iImageHandler;

    iImageHandler = NULL;

    iLaunchState = EPostcardOpenHandleText;

    CGulIcon* icon = NULL;

    TRAPD( err, icon = CGulIcon::NewL( bitmap, mask ) );

    if( err )

        { // Lets nullify it if there was an error

        icon = NULL;

        }

	iAppUi.SetImage( icon );

	CompleteSelf( KErrNone );        

    }

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

// ViewerError

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

void CPostcardOperationOpen::ViewerError( TInt /*aError*/ )

    {

	ToErrorState( R_POSTCARD_FORMAT_NOT_SUPPORTED );

    }

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

// DoHandleTextL

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

void CPostcardOperationOpen::DoHandleTextL( )

    {

/*    if ( iText != 0 )

        { // Lets externalize the text itself

        RFile file = iManager->GetAttachmentFileL( iText );

		CMmsTextInfo* info = static_cast<CMmsTextInfo*>(iDocument.MediaResolver()->ResolveFileTransferInfoL( file ));

		CleanupStack::PushL( info );

        TUint attaCharset = info->CharacterSet();

        CleanupStack::PopAndDestroy( info );

        RFileReadStream input_stream( file );

        CPlainText::TImportExportParam param;

        param.iForeignEncoding = attaCharset; //charconvCharsetID;

        param.iOrganisation = CPlainText::EOrganiseByParagraph; 

        CPlainText::TImportExportResult result;

        TRAPD( error, text->ImportTextL( 0, input_stream, param, result) );

        input_stream.Close( );

        file.Close( );

        }

*/

    TPostcardMsgType type = iDocument.MessageType( );

    if( iText > 0 && type == EPostcardSendAs )

        { // If type is SendAs and file is from Phonebook -> Handle this case first

        CMsvAttachment* atta = iManager->GetAttachmentInfoL( iText );

        CleanupStack::PushL( atta );

        if( atta->AttachmentName( ).Find( _L("X-Nokia-PhonebookId_") ) != -1  )