/*

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

*           Postcard application's interface to contacts (Virtual Phonebook

*           and Phonebook2).

*

*/

// INCLUDE FILES

#include <s32file.h>

#include <aknenv.h>

#include <AiwServiceHandler.h>

#include <AiwContactSelectionDataTypes.h>

#include <CPbk2StoreConfiguration.h>

#include <VPbkContactStoreUris.h>

#include <CVPbkContactStoreUriArray.h>

#include <TVPbkContactStoreUriPtr.h>

#include <CVPbkContactLinkArray.h>

#include <TVPbkFieldVersitProperty.h>

#include <MVPbkStoreContact.h>

#include <contactmatcher.h>

#include <akninputblock.h>

#include <Postcard.rsg>

#include "PostcardContact.h"

#include "PostcardPanic.h"

// ================= Static Constant Data ===================

// Table to convert from TLocation to virtual phonebook field type parameter

const TVPbkFieldTypeParameter CPostcardContact::iLocToFieldTypeParam[] =

    {

    EVPbkVersitParamPREF,

    EVPbkVersitParamHOME,

    EVPbkVersitParamWORK

    };

// Table to convert from TAddressField to virtual phonebook subfield type

const TVPbkSubFieldType CPostcardContact::iAddrFieldToSubFieldType[] =

    {

    EVPbkVersitSubFieldStreet,

    EVPbkVersitSubFieldExtendedAddress,

    EVPbkVersitSubFieldPostalCode,

    EVPbkVersitSubFieldLocality,

    EVPbkVersitSubFieldRegion,

    EVPbkVersitSubFieldCountry

    };

// Table to convert from TPostcardControls to TAddressField

const CPostcardContact::TAddressField CPostcardContact::iControlIdToAddrField[] =

    {

    CPostcardContact::EAddressFieldExtendedAddress,

    CPostcardContact::EAddressFieldStreet,

    CPostcardContact::EAddressFieldPostalCode,

    CPostcardContact::EAddressFieldLocality,

    CPostcardContact::EAddressFieldRegion,

    CPostcardContact::EAddressFieldCountry

    };

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

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

//  Two-phased constructor

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

CPostcardContact* CPostcardContact::NewL( RFs& aFs )

    {

    CPostcardContact* self = new (ELeave) CPostcardContact( aFs );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

//  Default destructor

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

CPostcardContact::~CPostcardContact()

    {

    delete iStoreContact;

    delete iContactMatcher;

    delete iUriArray;

    delete iAiwServiceHandler;

    }

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

// CPostcardContact

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

CPostcardContact::CPostcardContact( RFs& aFs ) : iFs( aFs )

    {

    }

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

// ConstructL

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

void CPostcardContact::ConstructL( )

    {

#ifdef __WINS__

    // Use default contact database store 

    iUriArray = CVPbkContactStoreUriArray::NewL();

    TVPbkContactStoreUriPtr uriPtr(VPbkContactStoreUris::DefaultCntDbUri());

    iUriArray->AppendL(uriPtr);

#else

    // Get store configuration from phonebook2

    CPbk2StoreConfiguration* storeConfiguration =

        CPbk2StoreConfiguration::NewL();

    CleanupStack::PushL(storeConfiguration);

    iUriArray = storeConfiguration->CurrentConfigurationL();

    CleanupStack::PopAndDestroy( storeConfiguration ); // storeConfiguration

#endif

    // Create contact matcher

    iContactMatcher = CContactMatcher::NewL( &iFs );

    iContactMatcher->OpenStoreL(*iUriArray);

    iShutdown = EFalse;

    }

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

// HasLocationL

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

TBool CPostcardContact::HasLocationL(TLocation aLocation) const

    {

    // A small buffer to see if the contact has any fields

    // defined for the location aLocation

    const TInt KBufLen = 8;

    TBuf<KBufLen> contactString;

    GetContactStringL(contactString, aLocation);

    return contactString.Length() > 0;

    }

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

// GetContactStringL

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

void CPostcardContact::GetContactStringL(TDes& aBuffer,

    TLocation aAddressLocation) const

    {

    static const TAddressField addrFields[] =

        {

        EAddressFieldStreet,

        EAddressFieldExtendedAddress,

        EAddressFieldPostalCode,

        EAddressFieldLocality,

        EAddressFieldRegion,

        EAddressFieldCountry

        };

    const TInt KNumAddrFields = sizeof(addrFields) / sizeof(addrFields[0]);

    _LIT(KPostcardAddressSelectionSeparator, ", ");

    TPtrC fieldSeparator(KPostcardAddressSelectionSeparator);

    aBuffer.Zero();

    TInt bufferRemaining = aBuffer.MaxLength();

    // Read address fields from the contact. Add field to buffer if there

    // is space for the separator and at least one more character.

    for(TInt i = 0; i < KNumAddrFields && bufferRemaining > fieldSeparator.Length(); i++)

        {

        HBufC* fieldText = GetAddressFieldLC(aAddressLocation, addrFields[i]);

        if (fieldText->Length() > 0)

            {

            // Add the separator if this is not the first non-empty field

            if (aBuffer.Length() > 0)

                {

                aBuffer.Append(fieldSeparator);

                bufferRemaining -= fieldSeparator.Length();

                }

            if (bufferRemaining > fieldText->Length())

                {

                aBuffer.Append(*fieldText);

                }

            else

                {

                aBuffer.Append(fieldText->Left(bufferRemaining));

                }

            bufferRemaining = aBuffer.MaxLength() - aBuffer.Length();

            }

        CleanupStack::PopAndDestroy( fieldText );  // fieldText

        }

    }

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

// GetAddressFieldLC

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

HBufC* CPostcardContact::GetAddressFieldLC(TLocation aLocation,

    TAddressField aAddressField) const

    {

    return GetContactFieldLC(EVPbkVersitNameADR,

        AddrFieldToSubFieldType(aAddressField),

        LocToFieldTypeParam(aLocation));

    }

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

// FetchContactL

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

void CPostcardContact::FetchContactL()

    {

    // Fetch contact from Phonebook using AIW

    if (!iAiwServiceHandler)

        {

        // Create AIW service handler

        iAiwServiceHandler = CAiwServiceHandler::NewL();

        iAiwServiceHandler->AttachL(R_POSTCARD_SINGLE_ENTRY_FETCH_INTEREST);

        }

    // A new contact is selected. Delete contact in case FetchContactL()

    // was called before.

    delete iStoreContact;

    iStoreContact = NULL;

    CAiwGenericParamList& inList = iAiwServiceHandler->InParamListL();

    InitAiwContactFetchParamL( inList );

    iAiwServiceHandler->ExecuteServiceCmdL( KAiwCmdSelect, inList,

        iAiwServiceHandler->OutParamListL(), 0, this);

    // Assign an input blocker, which will call cancel to phonebook

    // e.g. if Postcard is closed via FSW.

    CAknInputBlock* inputBlock = CAknInputBlock::NewCancelHandlerLC( this );

    iActSchedWait.Start(); // wait ExecuteServiceCmdL() to complete

    CleanupStack::PopAndDestroy( inputBlock );

    if ( iShutdown )

        {

        // This leave will be catched in AppUi's DoEditAddressL function.

        User::Leave( KLeaveExit );

        }

    }

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

// FetchContactL

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

void CPostcardContact::FetchContactL(RFile& aFile)

    {

    __ASSERT_DEBUG( !iStoreContact, Panic(EPostcardPanicCoding));

    // Using streams would be more elegant but Phonebook2 impletes it this

    // way. Writes the descriptor to a file directly without a length.

    TInt fileSize;

    User::LeaveIfError( aFile.Size( fileSize ) );

    HBufC8* buf = HBufC8::NewLC( fileSize );

    TPtr8 ptr = buf->Des();

    User::LeaveIfError( aFile.Read( ptr ) );

    CVPbkContactLinkArray* linkArray = CVPbkContactLinkArray::NewLC(

        *buf, iContactMatcher->GetContactStoresL());

    if( linkArray->Count() == 0 )

        {

        User::Leave( KErrNotFound );

        }

    iContactMatcher->GetStoreContactL( linkArray->At( 0 ), &iStoreContact );

    CleanupStack::PopAndDestroy( 2, buf ); // linkArray, buf

    }

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

// HandleNotifyL

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

TInt CPostcardContact::HandleNotifyL(TInt /*aCmdId*/, TInt aEventId,

    CAiwGenericParamList& aEventParamList,

    const CAiwGenericParamList& /*aInParamList*/)

    {

    switch(aEventId)

        {

        case KAiwEventOutParamCheck: // fall through

        case KAiwEventQueryExit:// fall through

            // It is always ok for us to exit. Edited postcard will be

            // saved to drafts.

            return ETrue;

        case KAiwEventCompleted:

            // Fetch completed with or without a contact

            TRAP_IGNORE(HandleAiwEventCompletedL(aEventParamList));

            // Leave in HandleAiwEventCompletedL() is not progated further.

            // After that the Postcard wouldn't respond to UI events. Even when

            // AsyncStop() is called. Maybe Phonebook cannot handle a leave

            // from here properly.

            // Fallthrough

        case KAiwEventCanceled:

            // Fetch was cancelled by user or red key pressed

            // Fallthrough

        case KAiwEventError:

            // Fetch is complete, there was an error

            if (iActSchedWait.IsStarted())

                {

                // End nested active scheduler loop

                iActSchedWait.AsyncStop();

                }

            break;

        default:

            Panic(EPostcardPanicAiwEvent);

        }

    return KErrNone;

    }

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

// HandleAiwEventCompleted

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

void CPostcardContact::HandleAiwEventCompletedL(

    CAiwGenericParamList& aEventParamList)

    {

    // Single item fetch. The result should be a contact link array with

    // 1 contact links and one contact field.

    __ASSERT_ALWAYS(aEventParamList.Count() == 2,

        Panic(EPostcardPanicAiwEventParam));

    const TAiwGenericParam& param = aEventParamList[0];

    __ASSERT_ALWAYS(param.SemanticId() == EGenericParamContactLinkArray,

        Panic(EPostcardPanicAiwEventParam));

    __ASSERT_DEBUG(param.Value().TypeId() == EVariantTypeDesC8,

        Panic(EPostcardPanicAiwEventParam));

    TPtrC8 contactLinks = param.Value().AsData();

    CVPbkContactLinkArray* linkArray = CVPbkContactLinkArray::NewLC(

        contactLinks, iContactMatcher->GetContactStoresL() );

    TInt linkCount = linkArray->Count();

    __ASSERT_DEBUG(linkCount <= 1, Panic(EPostcardPanicAiwEventParam));

    if (linkCount)  // user selected a contact

        {

        iContactMatcher->GetStoreContactL( linkArray->At( 0 ), &iStoreContact );

        }

    CleanupStack::PopAndDestroy( linkArray );  // linkArray

    }

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

// InitAiwContactFetchParamL

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

void CPostcardContact::InitAiwContactFetchParamL(

    CAiwGenericParamList& aParamList ) const

    {

    TAiwGenericParam param( EGenericParamContactSelectionData );

    TAiwSingleEntrySelectionDataV1 selectionData;

    param.Value().Set( TAiwSingleEntrySelectionDataV1Pckg( selectionData ) );

    aParamList.AppendL( param );

    param.Reset();

    param.SetSemanticId( EGenericParamContactStoreUriArray );

    param.Value().Set( *iUriArray->PackLC() );

    aParamList.AppendL( param );

    CleanupStack::PopAndDestroy(); // packed uriArray

    }

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

// GetNameLC()

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

HBufC* CPostcardContact::GetNameLC() const

    {

    // GetNameL() returns NULL if the contact has no name defined

    HBufC* nameText = iContactMatcher->GetNameL(iStoreContact->Fields());

    if (nameText)

        {

        CleanupStack::PushL(nameText);        

        }

    else

        {

        nameText = HBufC::NewLC(0);

        }

    return nameText;

    }

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

// GetContactFieldLC

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

HBufC* CPostcardContact::GetContactFieldLC(TVPbkFieldTypeName aFieldType,

    TVPbkSubFieldType aSubFieldType,

    TVPbkFieldTypeParameter aFieldTypeParameter) const

    {

    TVPbkFieldVersitProperty prop;

    prop.SetName(aFieldType);

    prop.SetSubField(aSubFieldType);

    TVPbkFieldTypeParameters fieldTypeParameters;

    fieldTypeParameters.Add(aFieldTypeParameter);

    prop.SetParameters(fieldTypeParameters);

    // Doesn't take ownership

    const MVPbkFieldType* fieldType =

        iContactMatcher->FieldTypes().FindMatch(prop, 0);

    if (fieldType)

        {

	    TPtrC src =

            iContactMatcher->GetFieldDataTextL(*iStoreContact, *fieldType);

        HBufC *data = HBufC::NewLC(src.Length());

        *data = src;

        data->Des().Trim();

        return data;

        }

    else

        {

        return HBufC::NewLC(0);

        }

    }

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

// AknInputBlockCancel

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

void CPostcardContact::AknInputBlockCancel()

    {

    if ( iActSchedWait.IsStarted() )

        {

        // Cancels currently outstanding AIW request to phonebook.

        TRAPD( error, iAiwServiceHandler->ExecuteServiceCmdL( KAiwCmdSelect, 

                                                   iAiwServiceHandler->InParamListL(), 

                                                   iAiwServiceHandler->OutParamListL(),

                                                   KAiwOptCancel,

                                                   this ) );

        if ( error == KErrNone )

            {

            iShutdown = ETrue;

            }

        }

    }

// End of File