/*

* Copyright (c) 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:   SendUI sending service provider that manages all MTM based

*                sending services.

*

*/

#include <smsclnt.h>

#include <mtclreg.h>                         // CClientMtmRegistry

#include <msvids.h>

#include <StringLoader.h>

#include <coemain.h>

#include <mtmuibas.h>                        // CBaseMtmUi

#include <mtmuidef.hrh>

#include <mtuireg.h>                 // MTM UI registery

#include <MuiuMsvUiServiceUtilities.h> 

#include <muiumsvuiserviceutilitiesinternal.h> 

#include <s32mem.h>

#include <f32file.h>

#include <MtmExtendedCapabilities.hrh>

#include <mtmuids.h>

#include <eiksrv.h>

#include <PhCltTypes.h>   

#include <btcmtm.h>

#include <AiwCommon.hrh>

#include <AiwServiceHandler.h>

#include <AknWaitDialog.h>          // CAknWaitDialog

#include <AknGlobalNote.h>

#include <AknQueryDialog.h>

#include <AknsUtils.h>

#include <e32property.h>

#include <telremotepartyinformationpskeys.h>

#include <mtudcbas.h>

#include <Sendnorm.rsg>

#include <MsgBioUids.h>             // KMsgBioUidVCard, KMsgBioUidVCalendar

#include <mtudreg.h>

#include <mtud.hrh>                // EMtudCommandSendAs

#include <featmgr.h>               // Feature Manager

#include <unieditorconsts.h>

#include <unimsventry.h>

#include <mcesettingsemailsel.h>

#include <CSendingServiceInfo.h>

#include <SendUiConsts.h>

#include <CMessageData.h>

#include <TSendingCapabilities.h>

#include <senduisingleton.h>

#include <messaginginternalpskeys.h>

#include "SendUiOperationWait.h"

#include "SendUiLog.h"              // Logging

#include "genericmtmplugin.h"

#include "SendUiFileRightsEngine.h"

#include "SendUiDummyMtm.h"

#include "CSendUiAttachment.h"

#include "GenericMtmPluginUids.hrh"

const TInt KSendUiProgressStringSize = 256;

const TInt KSendUiRichTextStoreGranularity = 512;

// For address information separation (start)

const TUint KSendUiMsgAddressStartChar         ('<');

// For address information separation (end)

const TUint KSendUiMsgAddressEndChar           ('>');

const TUint KSendUiFeatureSFI           = 0x2;

const TUint KSendUiFeatureMMS           = 0x4;

const TUint KSendUiFeatureSelectableEmail	= 0x8;

const TUint KSeconds = 1000000;

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

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

// Two-phased constructor.

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

//

CGenericMtmPlugin* CGenericMtmPlugin::NewL( TSendingServiceParams* aParams )

    {

    CGenericMtmPlugin* self = new(ELeave) CGenericMtmPlugin( aParams->iCoeEnv, aParams->iSingleton ); 

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Destructor

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

//

CGenericMtmPlugin::~CGenericMtmPlugin()

    {

    iServiceArray.ResetAndDestroy();

    iServiceArray.Close();

    delete iMtmUi;

    delete iClientMtm;      

    delete iStore;      

    }

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

// CGenericMtmPlugin::InitializeSendingL

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

//

TBool CGenericMtmPlugin::InitializeSendingL( )

    {

    LOGTEXT(_L8("CGenericMtmPlugin::InitializeSendingL >>"));

    if ( iIsSending )

        {

        LOGTEXT(_L8("CGenericMtmPlugin::Sending canceled, previous sending in progress."));

        return EFalse;

        }

    // Check if MMC mounted or switched to another MMC

    TDriveUnit currentDrive = iSingleton.MsvSessionL().CurrentDriveL();

    if ( currentDrive != EDriveC )

        {

        TBool storeOnMMC( EFalse );

        TRAPD ( error, storeOnMMC = iSingleton.MsvSessionL().MessageStoreDrivePresentL( ) );

        if ( !iSingleton.MsvSessionL().DriveContainsStoreL( currentDrive ) || !storeOnMMC || error )

            {

            //Change message store to phones internal memory(EDriveC)

            MsvUiServiceUtilitiesInternal::ChangeMessageStoreToPhoneL( iSingleton.MsvSessionL() );

            }

        }

    LOGTEXT(_L8("CGenericMtmPlugin::InitializeSendingL <<"));

    return ETrue;

    }

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

// Populates given list with the services provided by this plugin.

// The ownership of the pointed objects remains.

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

//

void CGenericMtmPlugin::PopulateServicesListL(

    RPointerArray<CSendingServiceInfo>& aList )

    {

    ScanMtmsL( iServiceArray );

    TInt i = iServiceArray.Count();

    while( i-- )

        {

        aList.Append( iServiceArray[i]);

        }

    }

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

// CGenericMtmPlugin::CreateAndSendMessageL

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

//

void CGenericMtmPlugin::CreateAndSendMessageL(

    TUid                            aMtmUid,

    const CMessageData*             aMessageData,

    TBool                           aLaunchEditorEmbedded )

    {

    LOGTEXT(_L8("CGenericMtmPlugin::CreateAndSendMessageL >>"));

    if ( aMtmUid != KSenduiMtmBtUid &&

     MsvUiServiceUtilities::DiskSpaceBelowCriticalLevelL(

        iSingleton.MsvSessionL(), 0 ) )

	    {

	    User::Leave(KErrDiskFull);

	    }

    TUid tempUid( KNullUid );

    if ( aMtmUid == KSenduiMtmSmsUid ||

         aMtmUid == KSenduiMtmMmsUid )

        {

        tempUid = aMtmUid;

        aMtmUid = KSenduiMtmUniMessageUid;

        // TODO: Use original MTM for checking attachments?

        // TODO: Use original MTM for "InitializeSending" (does some

        //       SmartMessaging checks)?

        }

    TMsvId service;

    TBool onlineSharing = EFalse;

    TBool doContinue = EFalse;

    iClientMtm = iSingleton.ClientMtmRegistryL().NewMtmL( aMtmUid );

    iMtmUi = iSingleton.MtmUiRegistryL().NewMtmUiL( *iClientMtm );

    if ( IsSupported( KSendUiFeatureSelectableEmail ) )

    	{

    	// from OnlineMtm.rss, mtm_type_uid

    	onlineSharing = ( aMtmUid == KSenduiMtmOnlineAlbumUid) ? 

    					ETrue : EFalse;

    	service = GetAndValidateServiceL( aMtmUid, aLaunchEditorEmbedded,

    									  doContinue );

    	if( service == KMsvUnkownServiceIndexEntryIdValue &&

    		!onlineSharing )

    		{

    		// cancel pressed on "selecta email account" query

    		return;

    		}

    	}

    TInt cleanupItems(0);

    if ( !InitializeSendingL( ) )

        {

        return;

        }

    CArrayPtrFlat<CSendUiAttachment>* attachments = NULL;

    // Get attachments

    if ( aMessageData )

    	{

   	    attachments = CSendUiAttachment::InitAttachmentArrayLCC( 

	        aMessageData->AttachmentArray(), 

	        aMessageData->AttachmentHandleArray(),

	        iCoeEnv.FsSession() );

    	cleanupItems += 2;

    	}

    // Ensures proper sending state if leave happens.

    iIsSending = ETrue;

    CleanupStack::PushL(TCleanupItem(ResetIsSending, (TAny*)&iIsSending));

    cleanupItems++;

    //iClientMtm = iSingleton.ClientMtmRegistryL().NewMtmL( aMtmUid );

    //iMtmUi = iSingleton.MtmUiRegistryL().NewMtmUiL( *iClientMtm );

    CBaseMtmUiData* mtmUiData = iSingleton.MtmUiDataRegistryL().NewMtmUiDataLayerL( aMtmUid );

    CleanupStack::PushL( mtmUiData );

    cleanupItems++;

    if ( aMessageData &&

         !ValidateAttachmentsL(

                aMtmUid,

                *mtmUiData,

                attachments ))

        {

        // User canceled sending.

        CleanupStack::PopAndDestroy( cleanupItems ); // TCleanupItem

        return;

        }

    // Show wait note if needed

    TBool showWaitNote = EFalse;

    if ( aMessageData )

        {

        showWaitNote = 

        IsWaitNoteNeededL( aMtmUid, *aMessageData, attachments->Count() );

        if ( showWaitNote )

            {

            ShowWaitNoteLC();

            cleanupItems++;

            }

        }

        TBool success = EFalse;

    if ( IsSupported( KSendUiFeatureSelectableEmail ) )

    	{

    	if ( !onlineSharing )

    		{

    		if ( doContinue )

    			{

    			CreateMessageL( aMtmUid, service );

    			//If doContinue, service already validated to be launched 

    			//embedded

    			success = ETrue; 

    			}

    		} 

    	else	

    		{

    	    success = CreateMessageL( aMtmUid, aLaunchEditorEmbedded );

    	    }       	

    	}

    else

        {

        success = CreateMessageL( aMtmUid, aLaunchEditorEmbedded );

        }

    if ( success && tempUid != KNullUid )

        {

        TMsvEntry entry = iClientMtm->Entry().Entry();

        TUniMsvEntry::SetCurrentMessageType(

            entry,

            tempUid == KSenduiMtmSmsUid

                ? EUniMessageCurrentTypeSms

                : EUniMessageCurrentTypeMms );

        TUniMsvEntry::SetMessageTypeLocked( entry, ETrue );

        iClientMtm->Entry().ChangeL( entry );

        }

    // Set message data

    if ( aMessageData && success)

        {

        SetRecipientsL( aMtmUid, *aMessageData );

        SetBodyL( *mtmUiData, *aMessageData, attachments );

        if ( attachments->Count() > 0 )

            {

            if ( aMtmUid == KSenduiMtmBtUid )

                {

                // Bluetooth sending over AIW

                SendBtMessageL( attachments );

                CleanupStack::PopAndDestroy( cleanupItems ); // TCleanupItem

                return;

                }

            else

                {

                success = AddAttachmentsL( *mtmUiData, attachments );

                }

            }

        if ( success && ( aMtmUid == KSenduiMtmSmtpUid ||

             aMtmUid == KSenduiMtmMmsUid ||

             aMtmUid == KSenduiMtmUniMessageUid ))

            {

            HBufC* subject = aMessageData->Subject().AllocLC();

            cleanupItems++;

            iClientMtm->SetSubjectL( *subject );

            }

        }

     if ( aMtmUid == KSenduiMtmBtUid )

        {

        success = EFalse; // bluetooth can launch editor only from SendBtMessageL                

        }

    if ( success )

        {

        TInt attachmentsCount = attachments ? attachments->Count(): 0;

        LaunchEditorL( attachmentsCount, aLaunchEditorEmbedded );

        }

    CleanupStack::PopAndDestroy( cleanupItems ); // TCleanupItem, attachments

    LOGTEXT(_L8("CGenericMtmPlugin::CreateAndSendMessageL <<"));

    }

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

// CGenericMtmPlugin::ServiceProviderId

// Returns the id of the service provider.

// (other items were commented in a header).

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

//

TUid CGenericMtmPlugin::ServiceProviderId() const

    {

    return KGenericMtmPlugin;

    }

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

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

// might leave.

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

//

CGenericMtmPlugin::CGenericMtmPlugin( CCoeEnv& aCoeEnv, CSendUiSingleton& aSingleton ) : 

    CSendingService( aCoeEnv, aSingleton ),

    iSendUiFeatureFlags(0)

    {

    }

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

// ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CGenericMtmPlugin::ConstructL()

    {

    iStore = CBufStore::NewL(KSendUiRichTextStoreGranularity);

    FeatureManager::InitializeLibL();

    if ( FeatureManager::FeatureSupported( KFeatureIdSendFileInCall ) )

        {

        iSendUiFeatureFlags |= KSendUiFeatureSFI;

        }

    if ( FeatureManager::FeatureSupported( KFeatureIdMMS ) )

        {

        iSendUiFeatureFlags |= KSendUiFeatureMMS;

        }

    if ( FeatureManager::FeatureSupported( KFeatureIdSelectableEmail ) )

    	{

    	iSendUiFeatureFlags |= KSendUiFeatureSelectableEmail;

    	}

    FeatureManager::UnInitializeLib();

    }

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

// Start asyncronous MTM scanning

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

//

void CGenericMtmPlugin::ScanMtmsL( RPointerArray<CSendingServiceInfo>& aList )

    {

    TInt regMtmIndex = 0;

    TInt err;

    TInt count( iSingleton.MtmUiDataRegistryL().NumRegisteredMtmDlls() );

    while ( regMtmIndex < count )

        {

        TUid mtmUid = iSingleton.MtmUiDataRegistryL().MtmTypeUid(regMtmIndex);

        LOGTEXT3(_L("Loading MTM index %d, id %d"), regMtmIndex, mtmUid );

        TRAP( err, LoadMtmL( iSingleton.MtmUiDataRegistryL().MtmTypeUid(regMtmIndex), aList ) );

        LOGTEXT2( _L("Loading MTM done, code %d"), err );

        regMtmIndex++;

        }

    }

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

// ValidateAttachmentsL

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

//

TBool CGenericMtmPlugin::ValidateAttachmentsL(

    TUid                    aMtmUid,

    CBaseMtmUiData&         aMtmUiData,    

    CArrayPtrFlat<CSendUiAttachment>* aAttachments )

    {

    LOGTEXT(_L8("CGenericMtmPlugin::ValidateAttachmentsL >>"));

    TBool continueSending = ETrue;

	// Validate attachments and show query and error note if needed.

    if ( aAttachments->Count() > 0 )

        { 

        CSendUiFileRightsEngine* fileRightsEngine =

            CSendUiFileRightsEngine::NewLC( iCoeEnv.FsSession() );

        if ( aMtmUid == KSenduiMtmPostcardUid &&

            IsPostcardContactLink( aAttachments ) )

            {

            // Postcard special case. ConfirmDrmFileRightsL() fails for contact

            // link file sent from Phonebook to Postcard. Therefore the check

            // is bypassed. Postcard treats the special file as a contact link.

            // Therefore bypassing drm check in this case is not a

            // vulnerability.

            }

        else

            {

            fileRightsEngine->ConfirmDrmFileRightsL( aAttachments );

            }

        // Confirm and filter away non-MMS files, if sending via MMS.

        if ( aMtmUid == KSenduiMtmMmsUid ||

             aMtmUid == KSenduiMtmAudioMessageUid ||

             ( aMtmUid == KSenduiMtmUniMessageUid &&

               IsSupported( KSendUiFeatureMMS ) ) )

            {

            fileRightsEngine->ConfirmMmsValidityL( aAttachments );

            }

        continueSending = fileRightsEngine->ShowDrmAndMmsInfoL();

        if ( aAttachments->Count() <= 0 )

            {

            continueSending = EFalse; // No files to send after filtering.

            }

        if ( continueSending )

            {

            TInt messageSize = 0;

            TUid uidQuery = { KUidMsvMtmQuerySupportLinks };

            TInt supportsLinks = 0;

            aMtmUiData.QueryCapability( uidQuery, supportsLinks );

            messageSize = fileRightsEngine->CalculateTotalSizeOfFiles(

                aAttachments,

                supportsLinks );

            if ( aMtmUid != KSenduiMtmBtUid &&

                 MsvUiServiceUtilities::DiskSpaceBelowCriticalLevelL(

                    iSingleton.MsvSessionL(), messageSize ) )

                {

                User::Leave(KErrDiskFull);

                }

            }

        CleanupStack::PopAndDestroy( fileRightsEngine );

        }

    LOGTEXT(_L8("CGenericMtmPlugin::ValidateAttachmentsL <<"));

    return continueSending;

    }

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

// IsWaitNoteNeededL

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

//

TBool CGenericMtmPlugin::IsWaitNoteNeededL(

    TUid                    aMtmUid,

    const CMessageData&     aMessageData,

    TInt                    aAttachmentCount )

    {

    LOGTEXT(_L8("CGenericMtmPlugin::IsWaitNoteNeededL >>"));

    if ( aMtmUid != KSenduiMtmIrUid && aMtmUid != KSenduiMtmBtUid )

        {

        return ETrue;       

        }

    const CRichText* bodyText = aMessageData.BodyText();

    const CMessageAddressArray& toAddresses = aMessageData.ToAddressArray();

    if ( aAttachmentCount > 0 ||

       ( bodyText && bodyText->DocumentLength() ) ||

       ( toAddresses.Count() > 2 ) )

        {

        LOGTEXT(_L8("CGenericMtmPlugin::IsWaitNoteNeededL <<"));

        return ETrue;

        }

    LOGTEXT(_L8("CGenericMtmPlugin::IsWaitNoteNeededL <<"));

    return EFalse;

    }

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

// CGenericMtmPlugin::ShowWaitNoteLC

//

// (other items were commented in a header).

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

//

void CGenericMtmPlugin::ShowWaitNoteLC()

    {

    LOGTEXT(_L8("CGenericMtmPlugin::ShowWaitNoteLC >>"));

    delete iWaitDialog;

    iWaitDialog = NULL;