/*

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

 *

 */

#include "cmrcmailremoteattachmentplugindownloader.h"

#include "mcalremoteattachmentoperationobserver.h"

#include "ccalremoteattachment.h"

#include "esmrhelper.h"

#include "cfsmailclient.h"

#include "cfsmailmessage.h"

#include <coemain.h>

#include "emailtrace.h"

// Unnamed namespace for local definitions

namespace { // codescanner::namespace

// Preferred byte count definition

const TInt KPreferredByteCount(0);

// Percentage for progress calculation

const TInt KPercentage( 100 );

// Literal for temporary path

_LIT( KTempPath, "temp\\" );

}

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

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

// CMRCmailRemoteAttachmentDownloader::CMRCmailRemoteAttachmentDownloader

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

//

CMRCmailRemoteAttachmentDownloader::CMRCmailRemoteAttachmentDownloader(

        CFSMailClient& aMailClient,

        MCalRemoteAttachmentOperationObserver& aObserver )

:   CActive( EPriorityStandard ),

    iMailClient( aMailClient ),

    iObserver( aObserver )

    {

    CActiveScheduler::Add( this );

    FUNC_LOG;

    }

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

// CMRCmailRemoteAttachmentDownloader::CMRCmailRemoteAttachmentDownloader

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

//

CMRCmailRemoteAttachmentDownloader::~CMRCmailRemoteAttachmentDownloader()

    {

    FUNC_LOG;

    if( IsActive() )

    	{

		Cancel();

    	}

    else

    	{

		DoCancel();

    	}

    delete iMailMessage;

    delete iUri;

    iAttachmentFile.Close();

    delete iRemoteAttachment;

    }

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

// CMRCmailRemoteAttachmentDownloader::CMRCmailRemoteAttachmentDownloader

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

//

CMRCmailRemoteAttachmentDownloader*

        CMRCmailRemoteAttachmentDownloader::NewL(

                CFSMailClient& aMailClient,

                MCalRemoteAttachmentOperationObserver& aObserver,

                const TDesC& aUri )

    {

    FUNC_LOG;

    CMRCmailRemoteAttachmentDownloader* self =

            new (ELeave) CMRCmailRemoteAttachmentDownloader(

                    aMailClient,

                    aObserver );

    CleanupStack::PushL( self );

    self->ConstructL( aUri );

    CleanupStack::Pop( self );

    return self;

    }

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

// CMRCmailRemoteAttachmentDownloader::CMRCmailRemoteAttachmentDownloader

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

//

void CMRCmailRemoteAttachmentDownloader::ConstructL(

        const TDesC& aUri )

    {

    FUNC_LOG;

    iUri = aUri.AllocL();

    TInt error = iMailIdParser.Parse( *iUri );

    User::LeaveIfError( error );

    // Fetch message structure and construct attachment information

    iMailMessage = iMailClient.GetMessageByUidL(

            iMailIdParser.iMailboxUid,

            iMailIdParser.iFolderUid,

            iMailIdParser.iMessageUid,

            EFSMsgDataStructure );

    CFSMailMessagePart* attachment =

        iMailMessage->ChildPartL( iMailIdParser.iMessagepartUid );

    CleanupStack::PushL( attachment );

    TPtrC attachmentName( attachment->AttachmentNameL() );

    TInt attachmentSize( attachment->ContentSize() );

    MCalRemoteAttachment::TCalRemoteAttachmentState attachmentState(

            MCalRemoteAttachment::EAttachmentStateNotDownloaded );

    if ( EFSFull == attachment->FetchLoadState() )

        {

        attachmentState = MCalRemoteAttachment::EAttachmentStateDownloaded;

        }

    iRemoteAttachment = CCalRemoteAttachment::NewL(

                                aUri,

                                attachmentName,

                                attachmentSize,

                                attachmentState );

    CleanupStack::PopAndDestroy( attachment );

    // Trigger asynchronous request

    IssueRequest();

    }

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

// CMRCmailRemoteAttachmentDownloader::DoCancel

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

//

void CMRCmailRemoteAttachmentDownloader::DoCancel()

    {

    FUNC_LOG;

    TRAP_IGNORE( DoCancelL() );

    }

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

// CMRCmailRemoteAttachmentDownloader::RunL

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

//

void CMRCmailRemoteAttachmentDownloader::RunL()

    {

    FUNC_LOG;

    // We first check whether attachment is already downloaded to device or not

    CFSMailMessagePart* attachment =

        iMailMessage->ChildPartL( iMailIdParser.iMessagepartUid );

    CleanupStack::PushL( attachment );

    if ( EFSFull == attachment->FetchLoadState() )

        {

        // Attachment is fecthed to device --> Trigger completion

        NotifyCompletionL( *attachment );

        }

    else

        {

        // Attachment is not fetched --> Start fetching attachment

        iFSMailOperationId =

                attachment->FetchMessagePartL(

                            iMailIdParser.iMessagepartUid,

                            *this,

                            KPreferredByteCount );

        }

    CleanupStack::PopAndDestroy( attachment );

    }

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

// CMRCmailRemoteAttachmentDownloader::RunError

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

//

TInt CMRCmailRemoteAttachmentDownloader::RunError( TInt aError )

    {

    FUNC_LOG;

    NotifyError( aError );

    return KErrNone;

    }

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

// CMRCmailRemoteAttachmentDownloader::CMRCmailRemoteAttachmentDownloader

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

//

TInt CMRCmailRemoteAttachmentDownloader::Progress() const

    {

    FUNC_LOG;

    TInt progress( 0 );

    TRAP_IGNORE( progress = ProgressL() );

    return progress;

    }

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

// CMRCmailRemoteAttachmentDownloader::CMRCmailRemoteAttachmentDownloader

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

//

const MCalRemoteAttachment&

        CMRCmailRemoteAttachmentDownloader::AttachmentInformation() const

    {

    FUNC_LOG;

    return *iRemoteAttachment;

    }

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

// CMRCmailRemoteAttachmentDownloader::CMRCmailRemoteAttachmentDownloader

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

//

void CMRCmailRemoteAttachmentDownloader::RequestResponseL(

        TFSProgress aEvent,

        TInt aRequestId )

    {

    FUNC_LOG;

    // Make sure that correct notification is received from mail framework

    ASSERT( aRequestId == iFSMailOperationId );

    if ( aRequestId == iFSMailOperationId )

        {

        // Fetching message structure

        switch ( aEvent.iProgressStatus )

            {

            case TFSProgress::EFSStatus_RequestComplete:

                {

                // Fetch attachment part and notify completion

                CFSMailMessagePart* attachment =

                    iMailMessage->ChildPartL( iMailIdParser.iMessagepartUid );

                CleanupStack::PushL( attachment );

                NotifyCompletionL( *attachment );

                CleanupStack::PopAndDestroy( attachment );

                }

                break;

            case TFSProgress::EFSStatus_Status:

                {

                // Notify progress about downloading

                TInt progress = ( KPercentage * aEvent.iCounter ) / aEvent.iMaxCount;

                iObserver.Progress( this, progress );

                }

                break;

            case TFSProgress::EFSStatus_RequestCancelled:

                {

                // Error occured during fetch operation

                NotifyError( KErrCancel );

                }

                break;

            default:

                break;

            }

        }

    }

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

// CMRCmailRemoteAttachmentDownloader::CMRCmailRemoteAttachmentDownloader

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

//

void CMRCmailRemoteAttachmentDownloader::IssueRequest()

    {

    FUNC_LOG;

    SetActive();

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    }

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

// CMRCmailRemoteAttachmentDownloader::CMRCmailRemoteAttachmentDownloader

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

//

void CMRCmailRemoteAttachmentDownloader::NotifyCompletionL(

        CFSMailMessagePart& aAttachment )

    {

    FUNC_LOG;

    // Make sure that file server can share files between processes

    RFs& fs = CCoeEnv::Static()->FsSession();

    fs.ShareProtected();

    // Construct filename for attachment

    TFileName fileName( KTempPath );

    fileName.Append( iRemoteAttachment->AttachmentLabel() );

    User::LeaveIfError(

            ESMRHelper::CreateAndAppendOthersDirToFileName( fileName ) );

    // Copy attachment from mail storage to file system

    aAttachment.CopyContentFileL( fileName );

    // Open file handle to attachment

    User::LeaveIfError( iAttachmentFile.Open(

                        fs,

                        fileName,

                        EFileRead | EFileShareReadersOnly ) );

    // Notify observer about completion

    iRemoteAttachment->SetAttachmentState(

            MCalRemoteAttachment::EAttachmentStateDownloaded );

    iObserver.OperationCompleted( this, iAttachmentFile );

    }

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

// CMRCmailRemoteAttachmentDownloader::NotifyError

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

//

void CMRCmailRemoteAttachmentDownloader::NotifyError( TInt aError )

    {

    FUNC_LOG;

    iObserver.OperationError( this, aError );

    }

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

// CMRCmailRemoteAttachmentDownloader::ProgressL

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

//

TInt CMRCmailRemoteAttachmentDownloader::ProgressL() const

    {

    FUNC_LOG;

    TInt progress( 0 );

    CFSMailMessagePart* attachment =

        iMailMessage->ChildPartL( iMailIdParser.iMessagepartUid );

    CleanupStack::PushL( attachment );

    TInt fetchedContent( attachment->FetchedContentSize() );

    TInt contentSize( attachment->ContentSize() );

    progress = ( KPercentage * fetchedContent ) / contentSize;

    CleanupStack::PopAndDestroy( attachment );

    return progress;

    }

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

// CMRCmailRemoteAttachmentDownloader::DoCancelL

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

//

void CMRCmailRemoteAttachmentDownloader::DoCancelL()

    {

    FUNC_LOG;

    CFSMailMessagePart* attachment =

        iMailMessage->ChildPartL( iMailIdParser.iMessagepartUid );

    CleanupStack::PushL( attachment );

    if ( EFSFull != attachment->FetchLoadState() )

        {

        iMailClient.CancelL( iFSMailOperationId );

        }

    CleanupStack::PopAndDestroy( attachment );

    }

// EOF