/*

* Copyright (c) 2005-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:  Phonebook 2 MMC UI extension copy to MMC command.

*

*/

#include "cpmucopytommccmd.h"

// Phonebook 2

#include <mpbk2contactuicontrol.h>

#include <mpbk2applicationservices.h>

#include <mpbk2appui.h>

#include <mpbk2contactnameformatter.h>

#include <mpbk2commandobserver.h>

#include <pbk2processdecoratorfactory.h>

#include <mpbk2processdecorator.h>

#include <tpbk2copycontactsresults.h>

#include <pbk2mmcuires.rsg>

// Virtual Phonebook

#include <mvpbkcontactoperationbase.h>

#include <mvpbkstorecontact.h>

#include <cvpbkvcardeng.h>

#include <cvpbkcontactmanager.h>

#include <cvpbkcontactlinkarray.h>

// System includes

#include <pathinfo.h>

#include <stringloader.h>

#include <aknnotewrappers.h>

/// Unnamed namespace for local definitions

namespace {

_LIT( KPbk2VCardFileExtension, ".vcf" );

_LIT( KInvalidFileNameChars, "?*<>/\"|\\:" );

_LIT( KNumberFormat, "%d" );

_LIT( KOpeningParenthesis, "(" );

_LIT( KClosingParenthesis, ")" );

_LIT( KZero, "0" );

const TInt KOneContact = 1;

/**

 * Removes invalid characters from given descriptor.

 *

 * @param aPtr  The descriptor to inspect.

 */

void RemoveInvalidCharacters( TPtr& aPtr )

    {

    for ( TInt i = aPtr.Length() - 1; i >= 0; --i )

        {

        TChar ch = aPtr[i];

        if ( KInvalidFileNameChars().Locate( ch ) != KErrNotFound )

            {

            aPtr.Delete( i, 1 ); // ch is not a valid character

            }

        }

    }

enum TPmuCopyToMmcCmdState

    {

    EPmuCopyToMmcCmdStartProcess,

    EPmuCopyToMmcCmdDeleteOldEntries,

    EPmuCopyToMmcCmdRun,

    EPmuCopyToMmcCmdComplete,

    EPmuCopyToMmcCmdCancel

    };

#ifdef _DEBUG

enum TPanicCode

    {

    EPanic_CopyNextL_OOB = 1,

    EPanic_OperationComplete_PreCond,

    EPanic_ShowResultsL_PreCond

    };

void Panic( TPanicCode aPanic )

    {

    _LIT( KPanicCat, "CPmuCopyToMmcCmd" );

    User::Panic( KPanicCat(), aPanic );

    }

#endif // _DEBUG

} /// namespace

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

// CPmuCopyToMmcCmd::CPmuCopyToMmcCmd

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

//

CPmuCopyToMmcCmd::CPmuCopyToMmcCmd( MPbk2ContactUiControl& aUiControl ) :

        CActive( EPriorityStandard ),

        iUiControl( &aUiControl )

    {

    CActiveScheduler::Add( this );

    }

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

// CPmuCopyToMmcCmd::~CPmuCopyToMmcCmd

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

//

CPmuCopyToMmcCmd::~CPmuCopyToMmcCmd()

    {

    Cancel();

    if ( iUiControl )

        {

        iUiControl->RegisterCommand( NULL );

        }

    iWriteStream.Close();

    delete iFileMan;

    delete iDecorator;

    delete iStoreContact;

    delete iPreviousContact;

    delete iContactLinks;

    delete iVCardEngine;

    }

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

// CPmuCopyToMmcCmd::NewL

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

//

CPmuCopyToMmcCmd* CPmuCopyToMmcCmd::NewL( MPbk2ContactUiControl& aUiControl )

    {

    CPmuCopyToMmcCmd* self = new ( ELeave ) CPmuCopyToMmcCmd( aUiControl );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPmuCopyToMmcCmd::ConstructL

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

//

inline void CPmuCopyToMmcCmd::ConstructL()

    {

    iVCardEngine = CVPbkVCardEng::NewL

        ( Phonebook2::Pbk2AppUi()->ApplicationServices().ContactManager() );

    iContactLinks = iUiControl->SelectedContactsOrFocusedContactL();

    iDecorator = Pbk2ProcessDecoratorFactory::CreateProgressDialogDecoratorL

        ( R_PMU_COPY_PROGRESS_NOTE, ETrue );

    iDecorator->SetObserver( *this );

    iUiControl->RegisterCommand( this );

    // set the default contacts path

    iContactsPath = PathInfo::MemoryCardContactsPath();

    }

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

// CPmuCopyToMmcCmd::RunL

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

//

void CPmuCopyToMmcCmd::RunL()

    {

    switch( iState )

        {

        case EPmuCopyToMmcCmdStartProcess:

            {

            iDecorator->ProcessStartedL(iContactLinks->Count());

            if ( iDeleteOldEntries )

                {

                iState = EPmuCopyToMmcCmdDeleteOldEntries;

                IssueRequest();

                }

            else

                {

                Phonebook2::Pbk2AppUi()->ApplicationServices().ContactManager().

                    FsSession().MkDirAll( iContactsPath );

                iState = EPmuCopyToMmcCmdRun;

                IssueRequest();

                }

            break;

            }

        case EPmuCopyToMmcCmdDeleteOldEntries:

            {

            DeleteOldEntriesL();

            Phonebook2::Pbk2AppUi()->ApplicationServices().ContactManager().

                FsSession().MkDirAll( iContactsPath );

            break;

            }

        case EPmuCopyToMmcCmdRun:

            {

            if (iFileMan)

                {

                delete iFileMan;

                iFileMan = NULL;

                }

            if (iStoreContact)

                {

                HBufC* fileName = CreateFileNameLC(*iStoreContact);

                User::LeaveIfError( 

                    iWriteStream.Create(

                        Phonebook2::Pbk2AppUi()->ApplicationServices().

                            ContactManager().FsSession(),

                                *fileName, EFileWrite ));

                iExportOperation = iVCardEngine->ExportVCardForSyncL(

                    iWriteStream, *iStoreContact, *this );

                CleanupStack::PopAndDestroy(fileName);

                }

            else if (iCurrentIndex < iContactLinks->Count())

                {

                CopyNextL();

                }

            else

                {

                iState = EPmuCopyToMmcCmdComplete;

                IssueRequest();

                }

            break;

            }

        case EPmuCopyToMmcCmdComplete:

            {

            // Copy complete, decorator calls processdismissed

            iDecorator->ProcessStopped();

            break;

            }

        default:

            {

            }

        }

    }

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

// CPmuCopyToMmcCmd::DoCancel

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

//

void CPmuCopyToMmcCmd::DoCancel()

    {

    iState = EPmuCopyToMmcCmdCancel;

    delete iRetrieveOperation;

    iRetrieveOperation = NULL;

    delete iExportOperation;

    iExportOperation = NULL;

    }

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

// CPmuCopyToMmcCmd::RunError

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

//

TInt CPmuCopyToMmcCmd::RunError( TInt /*aError*/ )

    {

    delete iRetrieveOperation;

    iRetrieveOperation = NULL;

    delete iExportOperation;

    iExportOperation = NULL;

    if ( iDecorator )

        {

        iDecorator->ProcessStopped();

        }

    return KErrNone;

    }

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

// CPmuCopyToMmcCmd::ExecuteLD

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

//

void CPmuCopyToMmcCmd::ExecuteLD()

    {

    CleanupStack::PushL( this );

    ShowConfirmationQueryL();

    CleanupStack::Pop( this );

    }

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

// CPmuCopyToMmcCmd::AddObserver

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

//

void CPmuCopyToMmcCmd::AddObserver( MPbk2CommandObserver& aObserver )

    {

    iCommandObserver = &aObserver;

    }

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

// CPmuCopyToMmcCmd::ResetUiControl

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

//

void CPmuCopyToMmcCmd::ResetUiControl( MPbk2ContactUiControl& aUiControl )

    {

    if ( iUiControl == &aUiControl )

        {

        iUiControl = NULL;

        }

    }

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

// CPmuCopyToMmcCmd::ProcessDismissed

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

//

void CPmuCopyToMmcCmd::ProcessDismissed( TInt /*aCancelCode*/ )

    {

    Cancel();

    delete iRetrieveOperation;

    iRetrieveOperation = NULL;

    delete iExportOperation;

    iExportOperation = NULL;

    // It is a not big deal if result note is not shown to user

    TRAP_IGNORE( ShowResultsL() );

    if ( iUiControl )

        {

        iUiControl->UpdateAfterCommandExecution();

        }

    iCommandObserver->CommandFinished( *this );

    }

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

// CPmuCopyToMmcCmd::VPbkSingleContactOperationComplete

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

//

void CPmuCopyToMmcCmd::VPbkSingleContactOperationComplete

        ( MVPbkContactOperationBase& aOperation,

          MVPbkStoreContact* aContact )

    {

    __ASSERT_DEBUG( iDecorator, Panic( EPanic_OperationComplete_PreCond ));

    if ( &aOperation == iRetrieveOperation )

        {

        delete iRetrieveOperation;

        iRetrieveOperation = NULL;

        iStoreContact = aContact;

        }

    else if ( &aOperation == iExportOperation )

        {

        delete iExportOperation;

        iExportOperation = NULL;

        // After the copying take the contact pointer,

        // because if this was last contact we need it in result note

        delete iPreviousContact;

        iPreviousContact = iStoreContact; // iPreviousContact takes ownership

        iStoreContact = NULL;

        iWriteStream.Close();

        // Copy next and update progressbar

        ++iCurrentIndex;

        ++iCountOfContacts;

        iDecorator->ProcessAdvance( 1 );

        }

    IssueRequest();

    }

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

// CPmuCopyToMmcCmd::VPbkSingleContactOperationFailed

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

//

void CPmuCopyToMmcCmd::VPbkSingleContactOperationFailed

        ( MVPbkContactOperationBase& aOperation, TInt /*aError*/ )

    {

    if (&aOperation == iRetrieveOperation)

        {

        delete iRetrieveOperation;

        iRetrieveOperation = NULL;

        }

    else if (&aOperation == iExportOperation)

        {

        delete iExportOperation;

        iExportOperation = NULL;

        delete iStoreContact;

        iStoreContact = NULL;

        }

    // Copy next

    ++iCurrentIndex;

    IssueRequest();

    }

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

// CPmuCopyToMmcCmd::NotifyFileManStarted

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

//    

MFileManObserver::TControl CPmuCopyToMmcCmd::NotifyFileManStarted()

    {

    if ( iState == EPmuCopyToMmcCmdCancel )

        {

        return MFileManObserver::EAbort;

        }

    return MFileManObserver::EContinue;

    }

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

// CPmuCopyToMmcCmd::NotifyFileManOperation

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

//

MFileManObserver::TControl CPmuCopyToMmcCmd::NotifyFileManOperation()

    {

    if ( iState == EPmuCopyToMmcCmdCancel )

        {

        return MFileManObserver::EAbort;

        }

    return MFileManObserver::EContinue;

    }

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

// CPmuCopyToMmcCmd::CopyNextL

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

//

void CPmuCopyToMmcCmd::CopyNextL()

    {

    __ASSERT_DEBUG( iContactLinks->Count() > iCurrentIndex,

         EPanic_CopyNextL_OOB );

    iRetrieveOperation = Phonebook2::Pbk2AppUi()->ApplicationServices().

            ContactManager().RetrieveContactL

                ( iContactLinks->At( iCurrentIndex ), *this );

    }

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

// CPmuCopyToMmcCmd::IssueRequest

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

//

void CPmuCopyToMmcCmd::IssueRequest()

    {

    if ( !IsActive() )

        {

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

        SetActive();

        }

    }

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

// CPmuCopyToMmcCmd::CreateFileNameLC

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

//

HBufC* CPmuCopyToMmcCmd::CreateFileNameLC

        ( const MVPbkStoreContact& aContact ) const

    {

    HBufC* title = Phonebook2::Pbk2AppUi()->ApplicationServices().

        NameFormatter().GetContactTitleL( aContact.Fields(), 0 );

    CleanupStack::PushL(title);

    TPtr titlePtr = title->Des();

    RemoveInvalidCharacters(titlePtr);

    TBool fileNameFound = EFalse;

    TInt number = 0;

    TFileName fileName;

    while (!fileNameFound)

        {

        fileName.Zero();

        fileName.Append( iContactsPath );

        fileName.Append(titlePtr);

        if (number > 0)

            {

            fileName.Append(KOpeningParenthesis);

            if (number < 10)

                {

                fileName.Append(KZero);

                }

            fileName.AppendFormat(KNumberFormat, number);

            fileName.Append(KClosingParenthesis);

            }

        fileName.Append(KPbk2VCardFileExtension);

        TEntry entry;

        TInt err = Phonebook2::Pbk2AppUi()->ApplicationServices().

            ContactManager().FsSession().Entry(fileName, entry);

        if (err == KErrNotFound)

            {

            fileNameFound = ETrue;

            }

        else

            {

            User::LeaveIfError( err );

            ++number;

            }

        }

    CleanupStack::PopAndDestroy(title);

    return fileName.AllocLC();

    }

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

// CPmuCopyToMmcCmd::DeleteOldEntriesL

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

//

void CPmuCopyToMmcCmd::DeleteOldEntriesL()

    {

    iFileMan = CFileMan::NewL

        (Phonebook2::Pbk2AppUi()->ApplicationServices().ContactManager().

            FsSession(), this);

    User::LeaveIfError( iFileMan->Delete(

            iContactsPath,

            CFileMan::ERecurse, iStatus ) );

    iState = EPmuCopyToMmcCmdRun;

    SetActive();

    }

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

// CPmuCopyToMmcCmd::ShowConfirmationQueryL

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

//

void CPmuCopyToMmcCmd::ShowConfirmationQueryL()

    {

    HBufC* prompt = StringLoader::LoadLC(R_QTN_PHOB_QUERY_COPY_MMC_ALL);

    CAknQueryDialog* dlg = CAknQueryDialog::NewL();