/*

* Copyright (c) 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:  Fetches the presentity id for a certain contact link.

*

*/

#include <s32mem.h>

//for service settings table

#include <spsettings.h>

#include <spentry.h>

#include <spproperty.h>

#include <spdefinitions.h>

//Virtual Phonebook

#include <TVPbkContactStoreUriPtr.h>

#include <CVPbkContactManager.h>

#include <CVPbkContactStoreUriArray.h>

#include <MVPbkContactStoreList.h>

#include <MVPbkContactStore.h>

#include <MVPbkContactLink.h>

#include <CVPbkFieldTypeRefsList.h>    

#include <MVPbkStoreContact.h>    

#include <MVPbkContactFieldData.h>

#include <CVPbkContactFieldIterator.h>

#include <MVPbkContactOperationBase.h>    

#include <CVPbkContactLinkArray.h>

#include <MVPbkContactFieldUriData.h>

#include "clogsextpresentityidfetcher.h"

#include "mlogsextpresentityidfetcherobserver.h"

#include "logsextconsts.h"

#include "simpledebug.h"

_LIT( KAt, "@" );

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

// NewL

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

//

CLogsExtPresentityIdFetcher* CLogsExtPresentityIdFetcher::NewL(

        const TUint32 aServiceId,

        const TDesC8& aCntLink,

        const TLogId aLogId,

        MLogsExtPresentityIdFetcherObserver& aObserver)

    {    

    CLogsExtPresentityIdFetcher* self = 

        CLogsExtPresentityIdFetcher::NewLC( aServiceId, 

                                            aCntLink, 

                                            aLogId, 

                                            aObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// NewLC

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

//

CLogsExtPresentityIdFetcher* CLogsExtPresentityIdFetcher::NewLC(

        const TUint32 aServiceId,

        const TDesC8& aCntLink,

        const TLogId aLogId, 

        MLogsExtPresentityIdFetcherObserver& aObserver )

    {

    _LOG("CLogsExtPresentityIdFetcher::NewLC(): begin" )

    CLogsExtPresentityIdFetcher* self = 

        new( ELeave ) CLogsExtPresentityIdFetcher( aServiceId, 

                                                   aLogId, 

                                                   aObserver );

    CleanupStack::PushL( self );

    self->ConstructL( aCntLink );

    _LOG("CLogsExtPresentityIdFetcher::NewLC(): end" )

    return self;

    }

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

// Constructor

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

//

CLogsExtPresentityIdFetcher::CLogsExtPresentityIdFetcher(

    const TUint32 aServiceId,

    const TLogId aLogId,    

    MLogsExtPresentityIdFetcherObserver& aObserver) : 

        iServiceId( aServiceId ),

        iFieldTypeResId( R_VPBK_FIELD_TYPE_IMPP ),

        iLogId( aLogId ),

        iObserver( &aObserver ),

        iCntStore( NULL ),

        iPresentityId( NULL ),

        iContactStoreId( NULL ),

        iContactManager( NULL ),

        iContactLinkArray( NULL ),

        iContactOperationBase( NULL )

    {    

    }

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

// ConstructL 

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

//

void CLogsExtPresentityIdFetcher::ConstructL( const TDesC8& aCntLink )

    {

    iCntLink = aCntLink.AllocL();

    }

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

// Destructor

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

//

CLogsExtPresentityIdFetcher::~CLogsExtPresentityIdFetcher()

    {

    _LOG("CLogsExtPresentityIdFetcher::~CLogsExtPresenceIdFetcher(): begin" )

    if ( iCntStore )

        {

        // its safe to close the store even if it was never opened before

        iCntStore->Close( *this );

        }

    delete iCntLink;

    delete iPresentityId;

    delete iContactStoreId;    

    delete iContactLinkArray;

    delete iContactOperationBase;

    delete iContactManager;

    _LOG("CLogsExtPresentityIdFetcher::~CLogsExtPresenceIdFetcher(): end" )

    }

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

// Starts the fetching process.

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

//

TInt CLogsExtPresentityIdFetcher::Fetch()

    {

    _LOG("CLogsExtPresentityIdFetcher::Fetch: begin" )   

    TInt error;

    TRAP( error, DoPresenceIdFetchL() );

    _LOGP("CLogsExtPresentityIdFetcher::Fetch: end returns=%d", error )

    return error;   

    }

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

// Initiates the actual fetching.

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

//

void CLogsExtPresentityIdFetcher::DoPresenceIdFetchL()

    {

    _LOG("CLogsExtPresentityIdFetcher::DoPresenceIdFetchL(): begin" )

    CSPSettings* spSettings = CSPSettings::NewLC();

    // get the contactstoreid from the service provider settings table

    GetContactStoreIdL( *spSettings );

    CleanupStack::PopAndDestroy( spSettings );

    spSettings = NULL;        

    CVPbkContactStoreUriArray* contactStoreUriArray = 

        CVPbkContactStoreUriArray::NewLC();

    const TVPbkContactStoreUriPtr storeUri( *iContactStoreId );          

    contactStoreUriArray->AppendL( storeUri ); 

    iContactManager = CVPbkContactManager::NewL( *contactStoreUriArray );

    iContactLinkArray = iContactManager->CreateLinksLC( iCntLink->Des() );

    CleanupStack::Pop(); // iContactLinkArray

    CleanupStack::PopAndDestroy( contactStoreUriArray );

    contactStoreUriArray = NULL;

    iContactManager->LoadContactStoreL( storeUri );    

    iCntStore = iContactManager->ContactStoresL().Find( storeUri );

    if ( iCntStore )

        {

        _LOG("this::DoPresenceIdFetchL(): open contact store" )

        // remember to call close when finished/cancelled/deleted! 

        iCntStore->OpenL( *this );   

        }

    else

        {

        _LOG("CLogsExtPresentityIdFetcher::DoPresenceIdFetchL(): error=-1" )

        User::Leave( KErrNotFound );

        }

    _LOG("CLogsExtPresentityIdFetcher::DoPresenceIdFetchL(): end" )

    }

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

// Gets the contact store id of a certain service from the SPSettings Table.

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

//

void CLogsExtPresentityIdFetcher::GetContactStoreIdL(

        CSPSettings& aSPSettings )

    {

    _LOG("CLogsExtPresentityIdFetcher::GetContactStoreIdL: begin")

    delete iContactStoreId;

    iContactStoreId = NULL;

    iContactStoreId = HBufC::NewL( KSPMaxDesLength );

    CSPProperty* spProperty = CSPProperty::NewLC();

    User::LeaveIfError( 

        aSPSettings.FindPropertyL( 

            ServiceId(),

            EPropertyContactStoreId,

            *spProperty ) );

    User::LeaveIfNull( spProperty );

    TPtr contactStoreIdPtr( iContactStoreId->Des() );

    User::LeaveIfError( spProperty->GetValue( contactStoreIdPtr ) );

    CleanupStack::PopAndDestroy( spProperty );

    spProperty = NULL;

    _LOG("CLogsExtPresentityIdFetcher::GetContactStoreIdL: end")

    }

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

// Gets the contact store id of a certain service from the SPSettings Table.

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

//

void CLogsExtPresentityIdFetcher::GetPresentityIDFieldTypeL(

        CSPSettings& aSPSettings )

    {

    _LOG("CLogsExtPresentityIdFetcher::GetPresentityIDFieldTypeL: begin")

    CSPProperty* spProperty = CSPProperty::NewLC();

    User::LeaveIfError( 

        aSPSettings.FindPropertyL( 

            ServiceId(),

            ESubPropertyPresencePresentityIDFieldType,

            *spProperty ) );

    User::LeaveIfNull( spProperty );  

    User::LeaveIfError( spProperty->GetValue( iFieldTypeResId ) );

    CleanupStack::PopAndDestroy( spProperty );

    spProperty = NULL;

    _LOG("CLogsExtPresentityIdFetcher::GetPresentityIDFieldTypeL: end")

    }

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

// Called when the operation is completed.

//

// A client has the operation as a member and it can delete the operation

// instance in this function call. If the implementation of the store

// calls the function from the operation instance it must not handle

// any member data after calling it.

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

//    

void CLogsExtPresentityIdFetcher::VPbkSingleContactOperationComplete(

        MVPbkContactOperationBase& /*aOperation*/,

        MVPbkStoreContact* aContact )

    {

    _LOG("CLogsExtPresentityIdFetcher::VPbkSingleContactOperationComplete...")

    _LOG("...begin")

    // delete the operation, since it is completed

    delete iContactOperationBase;

    iContactOperationBase = NULL;

    // Handles the retrieved contact

    TRAP_IGNORE( HandleRetrievedContactL( aContact ) )  

    _LOG("... VPbkSingleContactOperationComplete: end")

    }

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

// Handles the completion of an operation.

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

//

void CLogsExtPresentityIdFetcher::HandleRetrievedContactL(

        MVPbkStoreContact* aContact )

    {

    _LOG("CLogsExtPresentityIdFetcher::HandleRetrievedContactL: begin")

    aContact->PushL(); //Ownership transferred

    const MVPbkFieldType* fieldType = 

        iContactManager->FieldTypes().Find( iFieldTypeResId );

    if ( fieldType )

        {        

        _LOG("CLogsExtPresentityIdFetcher::HandleRetrievedContactL...")

        _LOG("...fieldType exists.")

        TPtrC fieldData( KNullDesC );

        CVPbkBaseContactFieldTypeIterator* itr = 

            CVPbkBaseContactFieldTypeIterator::NewLC( *fieldType, 

                aContact->Fields() );

        // If several fields with same fieldId: 

        // use the first with right prefix

        TBool found( EFalse );

        while( itr->HasNext() && !found )

            {

            _LOG("CLogsExtPresentityIdFetcher::HandleRetrievedContactL...")

            _LOG("...field exists.")

            const MVPbkBaseContactField* field = itr->Next();

            // Check field type before casting.

            const MVPbkContactFieldData& contactFieldData = field->FieldData();

            if ( EVPbkFieldStorageTypeUri == contactFieldData.DataType() )

                {

                // get field data

                const MVPbkContactFieldUriData& data = 

                    MVPbkContactFieldUriData::Cast( contactFieldData );

                fieldData.Set( data.Uri() );

                CSPEntry* entry = CSPEntry::NewLC();

                CSPSettings* settings = CSPSettings::NewLC();

                TInt err = settings->FindEntryL( iServiceId, *entry );

                if ( err )

                    {

                    // If service name not found leave with error code

                    User::Leave( err );

                    }

                const TDesC& serviceName = entry->GetServiceName();

                if ( 0 == fieldData.Find( serviceName ) )

                    {

					// Service name found from position 0

                    found = ETrue;

                    delete iPresentityId;

                    iPresentityId = NULL;

                    iPresentityId = fieldData.AllocL();

                    _LIT( KSkypeServiceName, "Skype" );

                    if ( KErrNotFound == iPresentityId->Find( KAt ) &&

                         serviceName.Compare( KSkypeServiceName ) )

                        {

                        // TODO: This "if ()" branch can be removed when meco automatically

                        // completes domain part

                        CSPProperty* property = CSPProperty::NewLC();

                        User::LeaveIfError( settings->FindPropertyL( 

                                                ServiceId(),

                                                ESubPropertyPresenceAddrScheme,

                                                *property ) );        

                        User::LeaveIfNull( property );

                        // property was found, read the value    

                        HBufC* domain = HBufC::NewLC( KSPMaxDesLength );

                        TPtr domainPtr( domain->Des() );

                        User::LeaveIfError( property->GetValue( domainPtr ) );

                        iPresentityId = iPresentityId->ReAllocL( 

                            iPresentityId->Length() + 

                            KAt().Length() + 

                            domain->Length() );

                        iPresentityId->Des().Append( KAt );

                        iPresentityId->Des().Append( *domain );

                        CleanupStack::PopAndDestroy( domain );

                        CleanupStack::PopAndDestroy( property );

                        }

                    _LOG("...presentityId==(nextline)")

                    _LOGDES(PresentityId())

                    iObserver->PresentityIdFetchDoneL( ServiceId(), 

                                                       PresentityId(), 

                                                       LogId() );

                    }

                CleanupStack::PopAndDestroy( settings );

                CleanupStack::PopAndDestroy( entry );

                }

            }

        if ( !found )

            {            

            User::Leave( KErrNotFound );

            }

        CleanupStack::PopAndDestroy( itr );

        itr = NULL;

        } 

    else

        {        

        User::Leave( KErrNotFound ); 

        } 

    CleanupStack::PopAndDestroy( aContact ); // aContact

    aContact = NULL;

    _LOG("CLogsExtPresentityIdFetcher::HandleRetrievedContactL: end")

    }

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

// Called if the operation fails.

//

// A client has the operation as a member and it can delete the operation

// instance in this function call. If the implementation of the store

// calls the function from the operation instance it must not handle

// any member data after calling it.

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

//

void CLogsExtPresentityIdFetcher::VPbkSingleContactOperationFailed(

            MVPbkContactOperationBase& /*aOperation*/, 

            TInt aError )

    {

    _LOG("CLogsExtPresentityIdFetcher::VPbkSingleContactOperationFailed...")

    _LOGP("...begin : aError = %d", aError)

    // delete the operation, since it is completed

    delete iContactOperationBase;

    iContactOperationBase = NULL;

    _LOG("CLogsExtPresentityIdFetcher::VPbkSingleContactOperationFailed: end ")

    }

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

// Called when a contact store is ready to use.

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

//     

void CLogsExtPresentityIdFetcher::StoreReady( 

        MVPbkContactStore& /*aContactStore*/ )

    {

    _LOG("CLogsExtPresentityIdFetcher::StoreReady: begin")

    const MVPbkContactLink& contactLink = iContactLinkArray->At( 0 );

    delete iContactOperationBase;

    iContactOperationBase = NULL;

    TRAP_IGNORE( iContactOperationBase = 

        iContactManager->RetrieveContactL( contactLink, *this ); )

    _LOG("CLogsExtPresentityIdFetcher::StoreReady: end")

    }

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

// Called when a contact store becomes unavailable.

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

//    

void CLogsExtPresentityIdFetcher::StoreUnavailable( 

        MVPbkContactStore& /*aContactStore*/, 

        TInt /*aReason*/ )

    {

    _LOG("CLogsExtPresentityIdFetcher::StoreUnavailable: begin")

    _LOG("CLogsExtPresentityIdFetcher::StoreUnavailable: end")

    }

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

// Called when changes occur in the contact store.

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

//    

void CLogsExtPresentityIdFetcher::HandleStoreEventL(

            MVPbkContactStore& /*aContactStore*/, 

            TVPbkContactStoreEvent /*aStoreEvent*/ )

    {

    _LOG("CLogsExtPresentityIdFetcher::HandleStoreEventL: begin")

    _LOG("CLogsExtPresentityIdFetcher::HandleStoreEventL: end")

    }

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

// Returns the Service id.

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

//  

TUint32 CLogsExtPresentityIdFetcher::ServiceId()

    {    

    _LOGP("CLogsExtPresentityIdFetcher::ServiceId = %d", iServiceId)

    return iServiceId;

    }

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

// Returns the unique log event id,which the presentity id is fetched for.

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

//

TLogId CLogsExtPresentityIdFetcher::LogId()

    {    

    _LOGP("CLogsExtPresentityIdFetcher::logid = %d", iLogId)

    return iLogId;

    }

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

// Returns the presentity id.

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

//

const TDesC& CLogsExtPresentityIdFetcher::PresentityId()

    {    

    if( iPresentityId )

        {

         _LOGDES( *iPresentityId )

         return *iPresentityId;

        }    

    _LOG("CLogsExtPresentityIdFetcher::iPresentityId end")

    return KNullDesC();

    }