/*

* Copyright (c) 2008 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: This file implements classes CIpsPlgSosBasePlugin, Plugin.

 *

*/

#include "emailtrace.h"

#include "ipsplgheaders.h"

// <qmail> FreestyleEmailUiConstants include removed

// <qmail>

#include "ipsplgsosbaseplugin.hrh"

#include "ipsplgmailstoreroperation.h"

#include "ipsplgmessagepartstoreroperation.h"

#include "BasePlugin.h" 

//</qmail>

// <cmail> S60 UID update

#define FREESTYLE_EMAIL_UI_SID 0x200255BA

// </cmail> S60 UID update

const TInt KOpGranularity = 2;

#ifdef __WINS__

_LIT( KEmulatorIMEI, "123456789012345" );

#endif // __WINS__

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

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

// <qmail> iSettingsApi removed

CIpsPlgSosBasePlugin::CIpsPlgSosBasePlugin( const TUint aFSPluginId ) :

    iFSPluginId( aFSPluginId ),

    iSession( NULL ),

    iMsgMapper( NULL ),

    iOperations( KOpGranularity ),

    iActivitytimers( KOpGranularity ),

    iSmtpService( NULL ),

    iCachedEntry( NULL ),

    iCachedEmailMessage( NULL ),

    iMruList( NULL ),

    iSearch( NULL ),

    iEventHandler( NULL ),

    iSessionOk( ETrue ),

    iBrandingId( NULL ),

    iIsUnderUiProcess( EFalse )

    {

    FUNC_LOG;

    }

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

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

// <qmail> iSettingsApi, iWait removed

CIpsPlgSosBasePlugin::~CIpsPlgSosBasePlugin()

    {

    FUNC_LOG;

    iOperations.ResetAndDestroy();

    iActivitytimers.ResetAndDestroy();

    iOperations.Close();

    iActivitytimers.Close();

    delete iSmtpService;

    delete iMruList;

    if ( iEventHandler )

        {

        iEventHandler->UnRegisterPropertyObserver( iSyncStateHandler );

        }

    delete iEventHandler;

    delete iCachedEntry;

    delete iCachedEmailMessage;

    delete iMsgMapper;

    delete iSearch;

    delete iSyncStateHandler;

    delete iSession;

    delete iBrandingId;

    }

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

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

void CIpsPlgSosBasePlugin::BaseConstructL()

    {

    FUNC_LOG;

    iEventHandler = CIpsPlgEventHandler::NewL( *this );

    iSession = CMsvSession::OpenAsyncL( *iEventHandler );

    iMsgMapper = CIpsPlgMsgMapper::NewL( *iSession, *this );

    iSmtpService = CIpsPlgSmtpService::NewL( *iSession, *this );

    iMruList = CIpsPlgMruList::NewL( );

    iSearch = CIpsPlgSearch::NewL( *iSession, *this );

	// <qmail> iSettingsApi removed

    iSyncStateHandler = CIpsPlgSyncStateHandler::NewL(

            *iSession, *this, iOperations );

    iEventHandler->RegisterPropertyObserverL( iSyncStateHandler );

    RProcess process;

    if ( process.SecureId() == FREESTYLE_EMAIL_UI_SID )

        {

        iIsUnderUiProcess = ETrue;

        }

    else

        {

        iIsUnderUiProcess = EFalse;

        }

#ifndef RD_101_EMAIL

    RAlwaysOnlineClientSession aosession;

    TInt err = aosession.Connect();

    if ( err == KErrNone )

        {

        TBuf8<1> dummyBuf;

        TRAP( err, aosession.RelayCommandL(

                EServerAPIEmailDisableAOEmailPlugin,

                dummyBuf ) );

        }

    aosession.Close();

#endif    

    }

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

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

void CIpsPlgSosBasePlugin::CompleteConstructL()

    {

    FUNC_LOG;

    iSessionOk = ETrue;

    iEventHandler->CompleteConstructL( iSession );

    }

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

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

void CIpsPlgSosBasePlugin::SessionTerminated()

    {

    FUNC_LOG;

    iSessionOk = EFalse;

    }

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

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

void CIpsPlgSosBasePlugin::OpCompleted(

	CIpsPlgSingleOpWatcher& aOpWatcher,

	TInt aCompletionCode )

    {

    FUNC_LOG;

    // Get valid operation count in each, some operations could have been

    // deleted in array

    TInt opId = aOpWatcher.Operation().Id();

    for ( TInt i = iOperations.Count()-1; i >= 0; i-- )

        {

        CMsvOperation& oper = iOperations[i]->Operation();

        if ( oper.Id() == opId )

            {

            DeleteAndRemoveOperation( i, aCompletionCode );

            }

// <qmail> iWait removed

        }

    }

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

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

 TFSMailBoxStatus CIpsPlgSosBasePlugin::GetMailBoxStatus(

    const TFSMailMsgId&  aMailBoxId  )

    {

    FUNC_LOG;

    TMsvEntry tEntry;

    TMsvId service;

    TFSMailBoxStatus status;

    if( iSessionOk )

        {

        iSession->GetEntry( aMailBoxId.Id(), service, tEntry );

        if ( tEntry.Connected() )

            {

            status = EFSMailBoxOnline;

            }

        else if ( ConnOpRunning( aMailBoxId ) )

            {

            status = EFSMailBoxOnline;

            }

        else

            {

            status = EFSMailBoxOffline;

            }

        }

    else

        {

        status = EFSMailBoxOffline;

        }

    return status;

    }

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

// CIpsPlgSosBasePlugin::SpecifiedSendingMailbox

// Returns 'null' ID, because the method is not relevant with IPS protocols

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

 TFSMailMsgId CIpsPlgSosBasePlugin::SpecifiedSendingMailbox()

     {

    FUNC_LOG;

     return TFSMailMsgId();

     }

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

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

void CIpsPlgSosBasePlugin::ListMailBoxesL( RArray<TFSMailMsgId>& aMailboxes )

	{

    FUNC_LOG;

	if( !iSessionOk )

        {

        User::Leave( KErrNotReady );

        }

	CMsvEntry* cEntry = iSession->GetEntryL( KMsvRootIndexEntryId );

    CleanupStack::PushL( cEntry );

    CMsvEntrySelection* childEntries = cEntry->ChildrenWithMtmL( MtmId() );

    CleanupStack::PushL( childEntries );

    TInt count( childEntries->Count() );

    for ( TInt i(0); i < count; i++)

        {

      	TFSMailMsgId mailboxId;

    	TMsvEntry tEntry;

    	TMsvId serviceId;

    	TDriveUnit driveUnit = EDriveC;

        iSession->GetEntry( childEntries->At(i), serviceId, tEntry );

        if( iIMEI.Compare( tEntry.iDescription ) == 0 )

            {

            mailboxId.SetPluginId( TUid::Uid( PluginId() ) );

            mailboxId.SetId( childEntries->At(i) );

            aMailboxes.AppendL( mailboxId );

            }

        else

            {

            TRAPD( err, driveUnit = iSession->CurrentDriveL() );

            if ( err == KErrNone && driveUnit == EDriveC )

                {

                // When memory card restored to another phone mailbox

                // should be visible

                mailboxId.SetPluginId( TUid::Uid( PluginId() ) );

                mailboxId.SetId( childEntries->At(i) );

                StoreIMEIToMailboxL( mailboxId.Id() );

                aMailboxes.AppendL( mailboxId );

                }

            }

        }

    CleanupStack::PopAndDestroy( 2, cEntry ); // childEntries

	}

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

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

CFSMailBox* CIpsPlgSosBasePlugin::GetMailBoxByUidL(

    const TFSMailMsgId& aMailBoxId)

	{

    FUNC_LOG;

    CFSMailBox* result( NULL );

    TMsvEntry tEntry;

    TMsvId    serviceId;

    TInt      status;

    HBufC*    address( NULL );

    if( !iSessionOk )

        {

        User::Leave( KErrNotReady );

        }

    status = iSession->GetEntry( aMailBoxId.Id(), serviceId, tEntry );

    if ( status == KErrNone )

        {

        result = CFSMailBox::NewL( aMailBoxId );

        CleanupStack::PushL( result );   // << result

        result->SetName( tEntry.iDetails );

        result->SetSettingsUid( TUid::Uid( IPS_SET_ECOM_IMPLEMENTATION_UID ) );

// <qmail>

        CEmailAccounts* acc = CEmailAccounts::NewLC();

        TSmtpAccount smtpAcc;

        acc->GetSmtpAccountL( tEntry.iRelatedId , smtpAcc );

        CImSmtpSettings* smtpSet = new (ELeave) CImSmtpSettings();

        CleanupStack::PushL( smtpSet );

        acc->LoadSmtpSettingsL( smtpAcc, *smtpSet );

        address = smtpSet->EmailAddress().AllocL();

        CleanupStack::PopAndDestroy( 2, acc );

// </qmail>

        CleanupStack::PushL( address ); // << address

        CFSMailAddress* fsAddress = CFSMailAddress::NewLC();    // << fsAddress

        fsAddress->SetEmailAddress( *address );

        result->SetOwnMailAddressL( fsAddress );

        CleanupStack::Pop( fsAddress ); // >> fsAddress

        CleanupStack::PopAndDestroy( address ); // >>> address

        CleanupStack::Pop( result );    // >> result

        }

    return result;

	}

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

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

void CIpsPlgSosBasePlugin::DeleteMailBoxByUidL(

    const TFSMailMsgId& aMailBoxId,

    MFSMailRequestObserver& aOperationObserver,

    const TInt aRequestId )

    {

    FUNC_LOG;

    TMsvEntry tEntry;

    TMsvId service;

    if( !iSessionOk )

        {

        User::Leave( KErrNotReady );

        }

// <qmail> RAlwaysOnlineClientSession - related code removed

    // Prepare the parameters to be forwarded to AO-server

    TPckg<TMsvId> param = aMailBoxId.Id();

    // delete MRU list from cen rep

    iMruList->ClearDataL( aMailBoxId );

    iSyncStateHandler->NotifyMailboxRemove( aMailBoxId.Id() );

// <qmail> CancelAllOnlineOperations function call removed

    iSession->GetEntry( aMailBoxId.Id(), service, tEntry );

    if ( tEntry.Connected() )

        {

        DisconnectL( aMailBoxId, aOperationObserver, aRequestId, ETrue );

        // remove activity timer from array here but leave the actual delete

        // to the disconnect operation. This is because the disconnect op

        // sometimes tries to use the timer after it was deleted here.

        TInt timerCount = iActivitytimers.Count();

        for ( TInt j = 0; j < timerCount; j++ )

            {

            if ( iActivitytimers[j]->FSMailboxId() == aMailBoxId )

                {

                iActivitytimers.Remove( j );

                timerCount--;

                j--;

                }

            }

        }

    else

        {

// <qmail> iSettingsApi removed

        TFSProgress progress = { TFSProgress::EFSStatus_Waiting, 0, 0, KErrNone };

        progress.iProgressStatus = TFSProgress::EFSStatus_RequestComplete;

        progress.iError = KErrNone;

        TInt requestId = aRequestId;

        aOperationObserver.RequestResponseL( progress, requestId );

        DeleteActivityTimer( aMailBoxId  );

        }

    }

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

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

TDesC& CIpsPlgSosBasePlugin::GetBrandingIdL( const TFSMailMsgId& aMailBoxId )

    {

    FUNC_LOG;

    if( !iSessionOk )

        {

        User::Leave( KErrNotReady );

        }

    CMsvEntry* mboxEntry = iSession->GetEntryL( aMailBoxId.Id() );

    CleanupStack::PushL( mboxEntry );

// <qmail> iSettingsApi removed, iBrandingId removed

    CleanupStack::PopAndDestroy( mboxEntry );

    return *iBrandingId;

    }

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

// Pop3 has no implementation for this virtual

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

void CIpsPlgSosBasePlugin::MoveMessagesL(

    const TFSMailMsgId& aMailBoxId,

    const RArray<TFSMailMsgId>& aMessageIds,

    const TFSMailMsgId& aSourceFolderId,

    const TFSMailMsgId& aDestinationFolderId )

	{

    FUNC_LOG;

	// Pop3 has no implementation for this virtual

	if( aDestinationFolderId.Id() == KMsvDraftEntryId  )

	    {

	    MoveMessagesToDraftL(

	        aMailBoxId,

	        aMessageIds,

	        aSourceFolderId,

	        aDestinationFolderId );

	    }

	}

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

// asynchronic version from move messages function, pop3 plugin not implent

// this virtual fucntion.

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

TInt CIpsPlgSosBasePlugin::MoveMessagesL(

    const TFSMailMsgId& aMailBoxId,

    const RArray<TFSMailMsgId>& aMessageIds,

    const TFSMailMsgId& aSourceFolderId,

    const TFSMailMsgId& aDestinationFolderId,

    MFSMailRequestObserver& aOperationObserver,

    TInt aRequestId )

    {

    FUNC_LOG;

    TInt ret = KErrNotSupported;

    if( aDestinationFolderId.Id() == KMsvDraftEntryId  )

        {

        MoveMessagesToDraftL(

            aMailBoxId,

            aMessageIds,

            aSourceFolderId,

            aDestinationFolderId );

        ret = KErrNone;

        }

    ret = KErrNotSupported;

    TFSProgress progress = { 

            TFSProgress::EFSStatus_RequestComplete, 0, 0, ret };

    aOperationObserver.RequestResponseL(

            progress, aRequestId );

    return ret;

    }

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

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

void CIpsPlgSosBasePlugin::MoveMessagesToDraftL(

    const TFSMailMsgId& /*aMailBoxId*/,

    const RArray<TFSMailMsgId>& aMessageIds,

    const TFSMailMsgId& aSourceFolderId,

    const TFSMailMsgId& aDestinationFolderId )

    {

    FUNC_LOG;

    TInt count( aMessageIds.Count() );

    if ( !count )

        {

        User::Leave( KErrArgument );

        }

    if( !iSessionOk )

        {

        User::Leave( KErrNotReady );

        }

    TMsvId msgService;

    TMsvEntry tEntry;

    CMsvEntrySelection* sel = new(ELeave) CMsvEntrySelection;

    CleanupStack::PushL(sel);

    CMsvEntry* msgEntry = iSession->GetEntryL( aMessageIds[0].Id() );

    CleanupStack::PushL( msgEntry );

	for( TInt i(0); i < count; i++ )

        {

        iSession->GetEntry( aMessageIds[i].Id(), msgService, tEntry );

        if( aSourceFolderId.Id() == KMsvGlobalOutBoxIndexEntryIdValue )

            {

            if( tEntry.SendingState() != KMsvSendStateSending )

                {

                // Set all states in outbox to suspended

                tEntry.SetSendingState( KMsvSendStateSuspended );

                msgEntry->ChangeL( tEntry );

                sel->AppendL( tEntry.Id() );

                }

            else

                {

                // Not possible to move when sending, what to do???

                // Probably some note back to UI, but we leave..

                User::Leave( KErrNotSupported );

                }

            }

        else

            {

            sel->AppendL( tEntry.Id() );

            }

        }

    if( sel->Count() )

        {

        if( !aSourceFolderId.IsNullId() )

            {

            CMsvEntry* cEntry = iSession->GetEntryL( aSourceFolderId.Id() );

            CleanupStack::PushL( cEntry );

            CleanupStack::PopAndDestroy( cEntry );

            }

        else

            {

            // Message is in editing state, we can't use parent as entry

            // because it's equal to destination.

            TMsvId parent = msgEntry->Entry().Parent();

            msgEntry->SetEntryL( parent );