/*

* 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:  Contanct handler implementation

*

*/

#include "emailtrace.h"

#include <AknQueryDialog.h>

#include <aknlists.h>

#include <StringLoader.h>

//Virtual Phonebook 

#include <CVPbkContactManager.h>

#include <CVPbkContactStoreUriArray.h>

#include <VPbkContactStoreUris.h>       // VPbkContactStoreUris

#include <TVPbkContactStoreUriPtr.h>    // TVPbkContactStoreUriPtr

#include <MVPbkContactOperationBase.h>

#include <MVPbkStoreContact.h>

#include <MVPbkFieldType.h>

#include <VPbkEng.rsg>

#include <CVPbkContactFieldIterator.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkContactStoreList.h>

// CCA Launcher view

#include <mccaparameter.h>

#include <ccafactory.h>

#include <ccapbkcontextlauncher.h>

// Phonebook 2

#include <CPbk2SortOrderManager.h>

#include <MPbk2ContactNameFormatter.h>

// Send UI

#include <sendui.h>

#include <SendUiConsts.h>

#include <CMessageData.h>

#include <aiwdialdataext.h>

#include <MVPbkContactLink.h>

#include <MPbkGlobalSetting.h> // Global setting data 

#include <PbkGlobalSettingFactory.h>

// Aiw launcher

#include <AiwDialDataTypes.h>

#include <AiwContactAssignDataTypes.h>

#include <AiwContactSelectionDataTypes.h>

#include <AiwServiceHandler.h>

// FS Email framework

#include "cfsmailbox.h"

#include <FreestyleEmailUi.rsg>

#include "FreestyleEmailUiContactHandler.h"

#include "FreestyleEmailUiCLSListsHandler.h"

#include "FreestyleEmailUiUtilities.h"

#include "FreestyleEmailUiLiterals.h"

#include "FreestyleEmailUiContactHandlerObserver.h"

#include "FreestyleEmailUiCLSItem.h"

//Constants

const TInt KInternetCallPreferred = 1;

CFSEmailUiContactHandler* CFSEmailUiContactHandler::NewL( RFs& aSession )

    {

    FUNC_LOG;

    CFSEmailUiContactHandler* self = CFSEmailUiContactHandler::NewLC( aSession );

    CleanupStack::Pop(self);

    return self;

    }

CFSEmailUiContactHandler* CFSEmailUiContactHandler::NewLC( RFs& aSession )

    {

    FUNC_LOG;

    CFSEmailUiContactHandler* self = new (ELeave) CFSEmailUiContactHandler( aSession );

    CleanupStack::PushL(self);

    self->ConstructL( aSession );

    return self;

    }

CFSEmailUiContactHandler::~CFSEmailUiContactHandler()

    {

    FUNC_LOG;

    delete iContactForMsgCreation;

    if (iPersistentSetting)

        {

        iPersistentSetting->Close();

        delete iPersistentSetting;

        }          

    delete iClsListHandler;

    delete iContactManager;

    delete iServiceHandler;

    ResetFieldIds();

    delete iPreviousEmailAddress;

    delete iSearchMatch;

    iContactObjects.ResetAndDestroy();

    delete iLinksSet;

    delete iLinkOperation;

    delete iLinkOperationFetch;

    delete iCurrentLink;

    delete iLastClsItem;

    if ( iConnection )

        {

        iConnection->Close();

        }

    }

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

// CFSEmailUiContactHandler::AddToContactL

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

void CFSEmailUiContactHandler::AddToContactL( const TDesC& aDes, 

                                                    TContactUpdateType aUpdateType,

                                                    TAddToContactsType aAddToContactsType,

                                                    MFSEmailUiContactHandlerObserver* aObserver )

    {

    FUNC_LOG;

    if ( iState == EContactHandlerIdle ) //Check that there are no other request on going

        {

        iState = EContactHandlerAddToContacts;

        iHandlerObserver = aObserver; //Can be null

        TUint assignFlags = 0;

        if ( aAddToContactsType == EContactHandlerCreateNewContact )

            {

            // In case of EUpdateExisting, we don't have to do anything as default is updateexisting

            assignFlags = AiwContactAssign::ECreateNewContact;

            }

        CAiwGenericParamList& inParamList =

        iServiceHandler->InParamListL();

        inParamList.AppendL(

                TAiwGenericParam(

                        EGenericParamContactAssignData,

                        TAiwVariant(AiwContactAssign::TAiwSingleContactAssignDataV1Pckg(

                                AiwContactAssign::TAiwSingleContactAssignDataV1().SetFlags(assignFlags)))));

        TGenericParamIdValue updateType;

        if ( aUpdateType == EContactUpdateEmail )

            {

            updateType = EGenericParamEmailAddress;

            }

        else // EContactUpdateNumber

            {

            updateType = EGenericParamPhoneNumber;

            }

        inParamList.AppendL(

                TAiwGenericParam(

                        updateType,

                        TAiwVariant(aDes)

                ));

        //Async call, CallBack is HandleNotify

        iServiceHandler->ExecuteServiceCmdL(

                KAiwCmdAssign,

                inParamList,

                iServiceHandler->OutParamListL(),

                0,

                this);

        }

    }

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

// CFSEmailUiContactHandler::AddToContactsQueryL

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

TBool CFSEmailUiContactHandler::AddtoContactsQueryL( TAddToContactsType& aType )

    {

    FUNC_LOG;

    // create popup list dialog asking new/update

    // Costruct listbox and popup list

    CEikTextListBox* listbox = new ( ELeave ) CAknSinglePopupMenuStyleListBox();

    CleanupStack::PushL( listbox );

    CAknPopupList* popupList = CAknPopupList::NewL( listbox, 

            R_AVKON_SOFTKEYS_SELECT_BACK );

    CleanupStack::PushL( popupList );

    listbox->ConstructL( popupList, CEikListBox::ELeftDownInViewRect );

    listbox->CreateScrollBarFrameL(ETrue);

    listbox->ScrollBarFrame()->SetScrollBarVisibilityL(

            CEikScrollBarFrame::EOff,

            CEikScrollBarFrame::EAuto );

    // Get list item array and put all removable theme names in it.

    MDesCArray* itemList = listbox->Model()->ItemTextArray();

    CDesCArray* listitems = static_cast< CDesCArray* >( itemList );

    // Load title for popup list.

    HBufC* resource = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_VIEWER_ADD_TO_CONTACTS );

    popupList->SetTitleL( *resource );

    CleanupStack::PopAndDestroy( resource );            

    // Load and append actual selection lines

    resource = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_VIEWER_CREATE_NEW_CONTACT );

    listitems->AppendL( *resource );

    CleanupStack::PopAndDestroy( resource );            

    resource = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_VIEWER_UPDATE_EXISTING );

    listitems->AppendL( *resource );

    CleanupStack::PopAndDestroy( resource );            

    TBool returnValue = EFalse;

    // Execute popup list.

    if ( popupList->ExecuteLD() )

        {

        if ( !listbox->CurrentItemIndex() )

            {

            aType = EContactHandlerCreateNewContact;

            }

        else

            {

            //UpdateExisting is "default" so no flags are needed

            aType = EContactHandlerUpdateExisting;

            }

        returnValue = ETrue; //User pressed OK

        }

    CleanupStack::Pop( popupList ); 

    CleanupStack::PopAndDestroy( listbox ); 

    return returnValue;

    }

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

// CFSEmailUiContactHandler::FindAndCallToContactByEmailL

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

//

void CFSEmailUiContactHandler::FindAndCallToContactByEmailL(

    const TDesC& aEmailAddress, CFSMailBox* aMailBox,

    MFSEmailUiContactHandlerObserver* aObserver, TBool aUseSenderText )

    {

    FUNC_LOG;

    if ( iOpenComplete && (iState == EContactHandlerIdle) ) //If contact stores all ready

        {

        iState = EContactHandlerCallToContactByEmail;

        iHandlerObserver = aObserver;

        iUseSenderText = aUseSenderText;

        iMailBox = aMailBox;

        FindContactLinkL( aEmailAddress );

        }

    }

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

// CFSEmailUiContactHandler::FindAndCreateMsgToContactByEmailL

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

void CFSEmailUiContactHandler::FindAndCreateMsgToContactByEmailL( const TDesC& aEmailAddress,

                                                                  CFSMailBox* aMailBox )

    {

    FUNC_LOG;

    if ( iOpenComplete && (iState == EContactHandlerIdle) ) //If contact stores all ready

        {

        iState = EContactHandlerCreateMessage;

        iMailBox = aMailBox;        

        FindContactLinkL( aEmailAddress );

        }

    }

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

// Searches for the contact if necessary and shows the contact details.

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

//

void CFSEmailUiContactHandler::ShowContactDetailsL( const TDesC& aAddress, 

    TContactUpdateType /*aType*/, MFSEmailUiContactHandlerObserver* aObserver )

    {

    FUNC_LOG;

    iHandlerObserver = aObserver;

    iState = EContactHandlerShowContactDetails;

    FindContactLinkL( aAddress );

    }

void CFSEmailUiContactHandler::MakeAiwCallL(MVPbkContactLink* aContactLink,

                                            const TDesC& aContactNumber,

                                            TBool aVoipOverride )

    {

    FUNC_LOG;

    CAiwDialDataExt* dialData = CAiwDialDataExt::NewLC();

    dialData->SetWindowGroup( CCoeEnv::Static()->RootWin().Identifier() );

    HBufC8* linkBuffer(NULL);

    if( aContactLink )

        {

        linkBuffer = aContactLink->PackLC();

        dialData->SetContactLinkL( *linkBuffer );

        // Contact link exists, check if voip is preferred

        // Create iPersistentSetting here only when needed for the first time

        if ( !iPersistentSetting )

            {

            iPersistentSetting = 

                PbkGlobalSettingFactory::CreatePersistentSettingL();

            iPersistentSetting->

                ConnectL(MPbkGlobalSetting::ERichCallSettingsCategory);     

            } 

        if ( aVoipOverride || SelectBetweenCsAndVoip() == EAiwVoIPCall )

            {

            dialData->SetCallType( CAiwDialData::EAIWVoiP );            

            }

        // <cmail> video call

        else if ( iVideoCall )

            {

            iVideoCall = EFalse;

            dialData->SetCallType( CAiwDialData::EAIWForcedVideo );

            }

        // </cmail>

        else

            {

            dialData->SetCallType( CAiwDialData::EAIWVoice );           

            }                           

        }

    else

        {

        if ( aVoipOverride )

            {

            dialData->SetCallType( CAiwDialData::EAIWVoiP );            

            }

        // <cmail> video call

        else if ( iVideoCall ) 

            {

            iVideoCall = EFalse;

            dialData->SetCallType( CAiwDialData::EAIWForcedVideo );

            }

        // </cmail>

        else

            {

            dialData->SetCallType( CAiwDialData::EAIWVoice );           

            }   

        dialData->SetPhoneNumberL( aContactNumber );

        }

    CAiwGenericParamList& inParamList = iServiceHandler->InParamListL();

    dialData->FillInParamListL( inParamList );    

    if( aContactLink )

        {

        CleanupStack::PopAndDestroy( linkBuffer );

        }

    CleanupStack::PopAndDestroy( dialData );

    iServiceHandler->ExecuteServiceCmdL(

        KAiwCmdCall,

        inParamList,

        iServiceHandler->OutParamListL(),

        0,

        NULL );

    if ( iHandlerObserver )

        {

        RPointerArray<CFSEmailUiClsItem> emptyArray;

        iHandlerObserver->OperationCompleteL( EFindAndCallToContactByEmailL, emptyArray );

        emptyArray.Close();

        iHandlerObserver = NULL;

        }

    iState = EContactHandlerIdle;

    } 

TInt CFSEmailUiContactHandler::SelectBetweenCsAndVoip() const

    {

    FUNC_LOG;

    // Default to voice call

    TInt ret = EAiwVoice;

    TInt preferred = KErrNotFound;

    if ( iPersistentSetting )

        {

        iPersistentSetting->Get

            (MPbkGlobalSetting::EPreferredTelephony, preferred);    

        }

    // VoIP type is preferred only if the setting is,

    // KInternetCallPreferred. In other cases, like when the setting

    // is not found, voice call is preferred.

    switch (preferred)

        {

        case KInternetCallPreferred:

            {

            ret = EAiwVoIPCall;

            break;

            }

        default:

            {

            break;

            }

        }

    return ret;

    }

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

// Searches contacts matching the given address

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

//

void CFSEmailUiContactHandler::SearchMatchesL( const TDesC& aText, 

    MFSEmailUiContactHandlerObserver* aObserver, CFSMailBox* aMailBox )

    {

    FUNC_LOG;

    if ( (iState == EContactHandlerIdle) ||

         (iState == EContactHandlerSearchMatches)  )

        {

        iState = EContactHandlerSearchMatches;

        iHandlerObserver = aObserver;

        iClsListHandler->SetCurrentMailboxL( aMailBox );

        //Async call, CallBack is ArrayUpdatedL (when error: OperationErrorL)

        iClsListHandler->SearchMatchesL( aText );

        }

    }

TBool CFSEmailUiContactHandler::IsLanguageSupportedL()

    {

    FUNC_LOG;

    return iClsListHandler->IsLanguageSupportedL();

    }

CVPbkContactManager* CFSEmailUiContactHandler::GetContactManager()

    {

    FUNC_LOG;

    return iContactManager;

    }

void CFSEmailUiContactHandler::GetAddressesFromPhonebookL(

    MFSEmailUiContactHandlerObserver* aObserver )

    {

    FUNC_LOG;

    if ( iState == EContactHandlerIdle )

        {

        if ( !aObserver )

            {

            //Request can't be fulfilled without observer

            return;

            }

        iHandlerObserver = aObserver;

        iState = EContactHandlerGetAddressesFromPhonebook;

        TUint fetchFlags = 0;

        iContactObjects.ResetAndDestroy();

        CAiwGenericParamList& inParamList = iServiceHandler->InParamListL();

        inParamList.AppendL(

                TAiwGenericParam(

                        EGenericParamContactSelectionData,

                        TAiwVariant(TAiwMultipleItemSelectionDataV1Pckg(

                                TAiwMultipleItemSelectionDataV1().

                                SetAddressSelectType(EAiwEMailSelect).

                                SetFlags( fetchFlags )))));

        //Async call, CallBack is HandleNotify

        iServiceHandler->ExecuteServiceCmdL(

                KAiwCmdSelect,

                inParamList,

                iServiceHandler->OutParamListL(),

                0,

                this);  

        }

    }

// <cmail> video call

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

// Enables/disables video call.

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

//

void CFSEmailUiContactHandler::SetVideoCall( TBool aState )

    {

    iVideoCall = aState;

    }

// </cmail>

/////////////////////////////////////////////////////////////////////////////

// CFSEmailUiContactHandler::GetSmsAddressFromPhonebookAndSendL