/*

* 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 send contact command.

*

*/

#include "CPbk2SendContactCmd.h"

// Phonebook 2

#include "Pbk2SendCmdUtils.h"

#include "CPbk2vCardConverter.h"

#include <MPbk2CommandObserver.h>

#include <Pbk2Commands.rsg>

#include <Pbk2CmdExtRes.rsg>

#include <Pbk2ProcessDecoratorFactory.h>

#include <MPbk2ProcessDecorator.h>

#include <MPbk2ContactLinkIterator.h>

#include <CPbk2AttachmentFile.h>

#include <CPbk2DriveSpaceCheck.h>

#include <CPbk2AppUiBase.h>

#include <CPbk2ApplicationServices.h>

// Virtual Phonebook

#include <CVPbkContactManager.h>

#include <CVPbkContactLinkArray.h>

#include <CVPbkVCardEng.h>

#include <MVPbkContactOperationBase.h>

#include <MPbk2ContactUiControl.h>

#include <MVPbkStoreContactFieldCollection.h>

#include <MVPbkStoreContact.h>

#include <MVPbkFieldType.h>

#include <TVPbkFieldTypeMapping.h>

#include <VPbkEng.rsg>

// System includes

#include <txtrich.h>

#include <barsread.h>

#include <AknWaitDialog.h>

#include <sendui.h>

#include <TSendingCapabilities.h>

#include <MsgBioUids.h>

#include <SendUiConsts.h>

#include <eikenv.h>

#include <CMessageData.h>

#include <eikclb.h>

#include <aknPopup.h>

#include <featmgr.h>

// Debugging headers

#include <Pbk2Debug.h>

/// Unnamed namespace for local definitions

namespace {

const TUint KNoMenu = 0;

const TInt KGranularity( 4 );

struct TPbk2SelectionMapping

    {

    /// Maps to first selection

    TPbk2SendvCardChoiceItemEnumerations iStSelection;

    /// Maps to second selection

    TPbk2SendvCardChoiceItemEnumerations iNdSelection;

    /// Maps to third selection

    TPbk2SendvCardChoiceItemEnumerations iRdSelection;

    //// Resource id

    TInt iResId;

    };

enum TSelection

    {

    ESelectionLast = -1

    };

/// Maps listbox index selections to 'sending selected detail'

/// menu selections If command not supported selection is ECancel.

static const TPbk2SelectionMapping SelectionMapping[] =

    {

    {ESendCurrentItem, ESendAllData, ECancel,

        R_PBK2_CONTACTINFO_SEND_OPTIONS},

    {ESendCurrentItem, ESendAllDataWithoutPicture, ESendAllData,

        R_PBK2_CONTACTINFO_SEND_OPTIONS_SMS_THUMBNAIL},

    {ESendAllDataWithoutPicture, ESendAllData, ECancel,

        R_PBK2_CONTACTINFO_SEND_OPTIONS_SMS_THUMBNAIL_NO_FIELD},

    {ESendAllDataWithoutPicture, ESendAllData, ECancel,

        R_PHONEBOOK2_SEND_OPTIONS},

    {ECancel, ECancel, ECancel, ESelectionLast}

    };

/// Represents the different listbox index selections.

enum TPbk2ListBoxSelections

    {

    EFirstSelection = 0,

    ESecondSelection,

    EThirdSelection

    };

#if 0 // Not used in ECE

/**

    Function checks if the focused field is one of these fields.

    - Prefix

    - Suffix

    - Firstname

    JAPANESE.PRONOUNCIATION{

    - FirstnameReading

    }JAPANESE.PRONOUNCIATION

    - Middle name

    - Lastname

    JAPANESE.PRONOUNCIATION{

    - Last name Reading

    }JAPANESE.PRONOUNCIATION

    - Ringing tone

    CALL.OBJECT.DISPLAY{

    - Image

    }CALL.OBJECT.DISPLAY

    CALL.OBJECT.DISPLAY{

    - Text for call

    }CALL.OBJECT.DISPLAY

    - Synchronization

*/

TBool IsNameOrPropertyField( const MVPbkBaseContactField& aField )

    {

    TBool res ( EFalse );

    const MVPbkFieldType* fieldType = aField.BestMatchingFieldType();

    if ( fieldType )

        {

        TInt resId( fieldType->FieldTypeResId() );

        if ( resId == R_VPBK_FIELD_TYPE_PREFIX ||

            resId == R_VPBK_FIELD_TYPE_SUFFIX ||

            resId == R_VPBK_FIELD_TYPE_FIRSTNAME ||

            resId == R_VPBK_FIELD_TYPE_FIRSTNAMEREADING ||

            resId == R_VPBK_FIELD_TYPE_MIDDLENAME ||

            resId == R_VPBK_FIELD_TYPE_LASTNAME ||

            resId == R_VPBK_FIELD_TYPE_LASTNAMEREADING ||

            resId == R_VPBK_FIELD_TYPE_RINGTONE ||

            resId == R_VPBK_FIELD_TYPE_CALLEROBJIMG ||

            resId == R_VPBK_FIELD_TYPE_CALLEROBJTEXT ||

            resId == R_VPBK_FIELD_TYPE_SYNCCLASS )

            {

            res = ETrue;

            }

        }

    return res;

    }

#endif // 0

#ifdef _DEBUG

enum TPanicCode

    {

    EPanicPreCond_SendvCardsL = 1,

    EPanicLogic_CmdSendContactDataL,

    EPanicLogic_MapSelection,

    EPanicLogic_ConversionDone,

    EPanicLogic_ReadFileTypeL,

    ERunL_OOB,

    EPanicPreCond_ErrArgument,

    EResetFindResult

    };

void Panic(TPanicCode aReason)

    {

    _LIT(KPanicText, "CPbk2SendContactCmd");

    User::Panic(KPanicText,aReason);

    }

#endif // _DEBUG

/**

 * Helper class for sending the vCard(s) in async callback.

 */

NONSHARABLE_CLASS(CVCardSender) : public CIdle

    {

    public: // Constructor

        /**

         * Creates a new instance of this object.

         *

         * @param aPriority     Desired priority.

         */

        static CVCardSender* NewL(

                TInt aPriority );

    private: // From CIdle

        void RunL();

        TInt RunError(

                TInt aError );

    private: // Implementation

        CVCardSender(

                TInt aPriority );

    };

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

// CVCardSender::CVCardSender

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

//

inline CVCardSender::CVCardSender( TInt aPriority ):

        CIdle( aPriority )

    {

    CActiveScheduler::Add( this );

    }

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

// CVCardSender::NewL

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

//

CVCardSender* CVCardSender::NewL( TInt aPriority )

    {

    return new ( ELeave ) CVCardSender( aPriority );

    }

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

// CVCardSender::RunL

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

//

void CVCardSender::RunL()

    {

    CIdle::RunL();

    // Destroy self.

    // If RunL (the callback) leaves RunError will handle the deletion.

    delete this;

    }

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

// CVCardSender::RunError

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

//

TInt CVCardSender::RunError( TInt aError)

    {

    delete this;

    // Forward all errors to the active scheduler

    return aError;

    }

/**

 * Creates a rich text object and packages contents of a file to it.

 * The file's data is not converted in any way except that characters

 * are widened to 16 bits.

 *

 * @param aEikEnv       EIKON environment.

 * @param aFileName     Name of the file to convert.

 * @return  A new rich text object with file's contents.

 *          The returned object is also left on top of the cleanup stack.

 */

CRichText* CreateRichTextFromFileLC

        (CEikonEnv& aEikEnv, const TDesC& aFileName)

    {

    PBK2_DEBUG_PRINT

        (PBK2_DEBUG_STRING("CreateRichTextFromFileLC (%S)"), &aFileName);

    // Common allocation granularity and buffer size for rich text and

    // file reading

    const TInt KBufSize = CEditableText::EDefaultTextGranularity;

    // Create a rich text object with default formatting

    CRichText* richText = CRichText::NewL(

        aEikEnv.SystemParaFormatLayerL(),

        aEikEnv.SystemCharFormatLayerL(),

        CEditableText::ESegmentedStorage,

        KBufSize  // Allocation granularity

        );

    CleanupStack::PushL(richText);

    // Open the file for reading

    RFile file;

    User::LeaveIfError(file.Open

        (aEikEnv.FsSession(), aFileName,

        EFileRead|EFileStream|EFileShareReadersOnly));

    CleanupClosePushL(file);

    // Create two buffers: 8-bit for reading from file and 16-bit for

    // converting to 16-bit format

    HBufC8* buf8 = HBufC8::NewLC(KBufSize);

    TPtr8 ptr8 = buf8->Des();

    HBufC16* buf16 = HBufC16::NewLC(ptr8.MaxLength());

    TPtr16 ptr16 = buf16->Des();

    // Read, convert and append to rich text until the file ends

    for (TInt err = file.Read(ptr8);

        ptr8.Length() > 0;

        err = file.Read(ptr8))

        {

        User::LeaveIfError(err);

        ptr16.Copy(ptr8);

        richText->InsertL(richText->DocumentLength(), ptr16);

        }

    // Cleanup and return

    CleanupStack::PopAndDestroy(3);  // buf16, buf8, file

    PBK2_DEBUG_PRINT

        (PBK2_DEBUG_STRING("CreateRichTextFromFileLC, end"));

    return richText;

    }

}  /// namespace

/**

 * Sending parameters.

 */

class TPbk2SendingParams

    {

    public: // Construction and destruction

        /**

         * Constructor.

         *

         * @param aMtmFilter    MTM filter

         * @param aCapabilities Sending capabilities.

         */

        TPbk2SendingParams(

                CArrayFixFlat<TUid>* aMtmFilter,

                TSendingCapabilities aCapabilities );

    public: // Data

        /// Ref: MTM filter

        CArrayFixFlat<TUid>* iMtmFilter;

        /// Own: Sending capabilities

        TSendingCapabilities iCapabilities;

    };

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

// TPbk2SendingParams::TPbk2SendingParams

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

//

inline TPbk2SendingParams::TPbk2SendingParams

            ( CArrayFixFlat<TUid>* aMtmFilter,

              TSendingCapabilities aCapabilities ) :

                iMtmFilter( aMtmFilter ), iCapabilities( aCapabilities )

    {

    }

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

// CPbk2SendContactCmd::CPbk2SendContactCmd

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

//

inline CPbk2SendContactCmd::CPbk2SendContactCmd(

        MPbk2ContactUiControl& aUiControl ) :

    CActive(EPriorityIdle),

    iUiControl(&aUiControl)

    {

    }

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

// CPbk2SendContactCmd::~CPbk2SendContactCmd

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

//

CPbk2SendContactCmd::~CPbk2SendContactCmd()

    {

    PBK2_DEBUG_PRINT

        (PBK2_DEBUG_STRING("CPbk2SendContactCmd, destructor (0x%x)"), this);

    Cancel();

    if( iUiControl )

        {

        iUiControl->RegisterCommand( NULL );

        }

    delete iSelectedContacts;

    delete iConverter;

    delete iVCardSender;

    delete iVCardEngine;

    iStoreContacts.ResetAndDestroy();

    iStoreContacts.Close();

    delete iRetrieveOperation;

    delete iDecorator;

    delete iCntIterator;

    delete iSendUi;

    Release( iAppServices );

    }

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

// CPbk2SendContactCmd::NewL

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

//

CPbk2SendContactCmd* CPbk2SendContactCmd::NewL

    (MPbk2ContactUiControl& aUiControl)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CPbk2SendContactCmd::ConstructL

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

//

void CPbk2SendContactCmd::ConstructL()

    {

    PBK2_DEBUG_PRINT

        (PBK2_DEBUG_STRING("CPbk2SendContactCmd::ConstructL(0x%x)"), this);

    CActiveScheduler::Add(this);

    CPbk2DriveSpaceCheck* driveSpaceCheck = CPbk2DriveSpaceCheck::NewL

        ( CCoeEnv::Static()->FsSession() );

    CleanupStack::PushL( driveSpaceCheck );

    // check FFS situation

    driveSpaceCheck->DriveSpaceCheckL();

    CleanupStack::PopAndDestroy( driveSpaceCheck );

    iEikEnv = CEikonEnv::Static();

    iAppServices = CPbk2ApplicationServices::InstanceL();

    iVCardEngine = CVPbkVCardEng::NewL( iAppServices->ContactManager() );

    iConverter = CPbk2vCardConverter::NewL(

        iEikEnv->FsSession(),

        iAppServices->ContactManager(),

        *iVCardEngine,

        iAppServices->NameFormatter() );

    iVCardSender = CVCardSender::NewL(CActive::EPriorityIdle);

    iSendUi = CSendUi::NewL();

    if( iUiControl )

        {

        // Use iterator to make sure that OOM situation does not occur

        // if multiple contacts selected.

        iCntIterator = iUiControl->SelectedContactsIteratorL();

        if ( !iCntIterator )

            {

            // If no iterator, there is no selected contacts.

            // Only one contact is returned.

            iSelectedContacts = iUiControl->SelectedContactsOrFocusedContactL();

            }

        iFocusedField = iUiControl->FocusedField();

        iUiControl->RegisterCommand( this );

        }

    PBK2_DEBUG_PRINT

        (PBK2_DEBUG_STRING("CPbk2SendContactCmd::ConstructL, end"));

    }

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

// CPbk2SendContactCmd::ExecuteLD

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

//

void CPbk2SendContactCmd::ExecuteLD()

    {

    PBK2_DEBUG_PRINT

        (PBK2_DEBUG_STRING("CPbk2SendContactCmd::ExecuteLD(0x%x)"), this);

    CleanupStack::PushL(this);

    iCurrentContactLinkIndex = 0;

    iState = EShowingSendQuery;

    IssueRequest();

    CleanupStack::Pop(this);

    PBK2_DEBUG_PRINT

        (PBK2_DEBUG_STRING("CPbk2SendContactCmd::ExecuteLD, end"), this);

    }

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

// CPbk2SendContactCmd::AddObserver

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

//

void CPbk2SendContactCmd::AddObserver(MPbk2CommandObserver& aObserver)

    {

    iCommandObserver = &aObserver;

    }

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

// CPbk2SendContactCmd::ResetUiControl

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

//

void CPbk2SendContactCmd::ResetUiControl(

        MPbk2ContactUiControl& aUiControl)

    {

    if (iUiControl == & aUiControl)

        {

        iUiControl = NULL;

        }

    }

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

// CPbk2SendContactCmd::RunL

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

//

void CPbk2SendContactCmd::RunL()

    {

    switch (iState)

        {

        case EShowingSendQuery:

            {

            iMtmUid = ShowSendQueryL();

            if (iMtmUid == KNullUid)

                {

                iState = ECancelling;

                }

            else

                {

                iState = ERetrievingContact;

                }

            IssueRequest();

            break;

            }

        case ERetrievingContact:

            {

            if ( iSelectedContacts )

                {

                __ASSERT_DEBUG( iSelectedContacts->Count() >

                        iCurrentContactLinkIndex, Panic( ERunL_OOB ) );

                RetrieveContactL(iSelectedContacts->At

                    (iCurrentContactLinkIndex));

                }

            else

                {

                iState = ESelectingSentData;

                IssueRequest();

                }

            break;

            }

        case ESelectingSentData:

            {

            TInt selection(ESendAllData);

            if ( iSelectedContacts )