/*

* Copyright (c) 2010 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:  IETF SIMPLE Protocol implementation for XIMP Framework

*

*/

#include <VPbkContactStoreUris.h>

#include <spsettings.h>

#include <spproperty.h>

#include <CVPbkContactManager.h>

#include <CVPbkContactStoreUriArray.h>

#include <TVPbkContactStoreUriPtr.h>

#include <MVPbkContactOperationBase.h>

#include <MVPbkContactStoreList.h>

#include <MVPbkContactLinkArray.h>

#include <MVPbkContactLink.h>

#include <MVPbkStoreContact.h>

#include <MVPbkContactFieldData.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkContactFieldUriData.h>

#include <CVPbkContactIdConverter.h>

#include <MVPbkStoreContactFieldCollection.h>

#include <CVPbkFieldTypeRefsList.h>

#include <VPbkEng.rsg>

#include "presenceplugincontacts.h" 

#include "presencelogger.h"

#include "presenceplugincontactsobs.h"

#include "presenceplugincontactstatehandler.h"

#include "presencepluginlocalstore.h"

// States

#include "presenceplugincontactstate.h"

#include "presenceplugincontactstateopen.h"

#include "presenceplugincontactstateresolve.h"

#include "presenceplugincontactstatesearch.h"

#include "presenceplugincontactstateend.h"

const TInt KSDMASPSMaxPropertyLength = 512;

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

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

// CPresencePluginContacts::CPresencePluginContacts()

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

//

CPresencePluginContacts::CPresencePluginContacts( TInt aServiceId,

    MPresencePluginContactsObs& aObserver )

    : CActive( CActive::EPriorityStandard ),

    iServiceId( aServiceId ),

    iObserver( &aObserver )

    {

    CActiveScheduler::Add(this);

    }

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

// CPresencePluginContacts::ConstructL()

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

//

void CPresencePluginContacts::ConstructL( const TDesC& aServiceName )

    {

    DP_SDA( "CPresencePluginContacts::ConstructL()" );

    iServiceName = aServiceName.AllocL();

    CVPbkContactStoreUriArray* uriArray = CVPbkContactStoreUriArray::NewLC();

    HBufC* storeName = ContactStoreNameL();

    if ( NULL != storeName )

        {

        DP_SDA2( "CPresencePluginContacts::ConstructL() %S", storeName );

        CleanupStack::PushL( storeName );

        uriArray->AppendL( TVPbkContactStoreUriPtr( *storeName ) );

        CleanupStack::PopAndDestroy( storeName );

        }

    else

        {

        DP_SDA( "CPresencePluginContacts::ConstructL() Use default contact store uri" );

        uriArray->AppendL( TVPbkContactStoreUriPtr(

            VPbkContactStoreUris::DefaultCntDbUri() ) );

        }

    iContactManager = CVPbkContactManager::NewL( *uriArray );

    CleanupStack::PopAndDestroy( uriArray );

    DP_SDA( "CPresencePluginContacts::ConstructL() -exit" );

    }

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

// CPresencePluginContacts::NewL()

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

//

CPresencePluginContacts* CPresencePluginContacts::NewL( TInt aServiceId,

    const TDesC& aServiceName, MPresencePluginContactsObs& aObserver )

    {

    CPresencePluginContacts* self =

        CPresencePluginContacts::NewLC( aServiceId, aServiceName, aObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPresencePluginContacts::NewLC()

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

//

CPresencePluginContacts* CPresencePluginContacts::NewLC( TInt aServiceId,

        const TDesC& aServiceName, MPresencePluginContactsObs& aObserver )

    {

    CPresencePluginContacts* self =

        new( ELeave ) CPresencePluginContacts( aServiceId, aObserver );

    CleanupStack::PushL( self );

    self->ConstructL( aServiceName );

    return self;

    }

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

// CPresencePluginContacts::~CPresencePluginContacts()

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

//

CPresencePluginContacts::~CPresencePluginContacts()

    {

    DP_SDA("CPresencePluginContacts::~CPresencePluginContacts");

    delete iServiceName;

    delete iSearchText;

    delete iContactOperation;

    iStoreContactArray.ResetAndDestroy();

    delete iStateHandler;

    delete iFieldTypeRefList;

    delete iContactLinkArray;

    if( iContactManager )

        {

        TRAP_IGNORE( iContactManager->ContactStoresL().CloseAll( *this ) );

        }

    delete iContactManager;

    iClientStatus = NULL;

    }

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

// CPresencePluginContacts::PresenceIdStoredL

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

//

void CPresencePluginContacts::IsPresenceIdStoredL(

    const TDesC16& aPresenceId, TRequestStatus& aStatus )

    {

    DP_SDA( "CPresencePluginContacts::IsPresenceIdStoredL -Enter" );

    iOperation = EOperationIsPresenceStoredToContacts;

    aStatus = KRequestPending;

    iClientStatus = &aStatus;

    iSearchText = HBufC::NewL(

        iServiceName->Length() + aPresenceId.Length() + 1 );

    TPtr searchTextPtr = iSearchText->Des();

    searchTextPtr.Copy( *iServiceName );

    searchTextPtr.Append( ':' );

    searchTextPtr.Append( aPresenceId );

    iFieldTypeRefList = CVPbkFieldTypeRefsList::NewL();

    iFieldTypeRefList->AppendL(

        *iContactManager->FieldTypes().Find( R_VPBK_FIELD_TYPE_IMPP  ) );

    iStateHandler = CPresencePluginContactStateHandler::NewL();

    iStateHandler->AddStateL( new( ELeave ) CPresencePluginContactStateOpen(

        *this, *iStateHandler ) );

    iStateHandler->AddStateL( new( ELeave ) CPresencePluginContactStateSearch(

        *this, *iStateHandler ) );

    iStateHandler->AddStateL( new( ELeave ) CPresencePluginContactStateResolve(

        *this, *iStateHandler ) );

    iStateHandler->AddStateL( new( ELeave ) CPresencePluginContactStateEnd(

        *this, *iStateHandler ) );

    iStateHandler->Start( &iStatus );

    SetActive();

    DP_SDA( "CPresencePluginContacts::IsPresenceIdStoredL - exit" );

    }

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

// CPresencePluginContacts::ContactStoreNameL

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

//

HBufC* CPresencePluginContacts::ContactStoreNameL()

    {

    DP_SDA( "CPresencePluginContacts::ContactStoreNameL()" );

    HBufC* storeName = NULL;

    CSPSettings* spSettings = CSPSettings::NewLC();

    CSPProperty* property = CSPProperty::NewLC();

    TInt err = spSettings->FindPropertyL( iServiceId,

                                EPropertyContactStoreId,      

                                *property );

    if ( KErrNone == err )

        {

        storeName = HBufC::NewL( KSDMASPSMaxPropertyLength );

        TPtr16 storeNamePtr = storeName->Des();

        err = property->GetValue( storeNamePtr );

        }

    CleanupStack::PopAndDestroy( property );

    CleanupStack::PopAndDestroy( spSettings );

    return storeName;

    }

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

// From class MPresenceContactsContextBase. 

// CPresencePluginContacts::Open

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

//

void CPresencePluginContacts::OpenL()

    {

    DP_SDA( "CPresencePluginContacts::Open()" );

    iContactManager->ContactStoresL().OpenAllL( *this );

    }

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

// From class MPresenceContactsContextBase.

// CPresencePluginContacts::Search

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

//

void CPresencePluginContacts::SearchL()

    {

    DP_SDA( "CPresencePluginContacts::Search()" );

    iContactOperation = iContactManager->FindL(

        *iSearchText, *iFieldTypeRefList, *this );

    }

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

// From class MPresenceContactsContextBase. 

// CPresencePluginContacts::ContactLinkArray

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

//

const MVPbkContactLinkArray& CPresencePluginContacts::ContactLinkArrayL()

    {

    if ( NULL == iContactLinkArray )

        {

        User::Leave( KErrNotReady );

        }

    return *iContactLinkArray;

    }

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

// From class MPresenceContactsContextBase.

//CPresencePluginContacts::RetrieveContactL

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

//

void CPresencePluginContacts::RetrieveContactL(

    const MVPbkContactLink& aContactLink )

    {

    DP_SDA( "CPresencePluginContacts::RetrieveContactL()" );

    iContactOperation =

        iContactManager->RetrieveContactL( aContactLink, *this );

    }

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

// From class MVPbkContactStoreListObserver.

// CPresencePluginContacts::OpenComplete

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

//

void CPresencePluginContacts::OpenComplete()

    {

    DP_SDA( "CPresencePluginContacts::OpenComplete()" );

    iStateHandler->State()->Complete();

    }

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

// From class MVPbkContactStoreObserver.

// CPresencePluginContacts::StoreReady

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

// 

void CPresencePluginContacts::StoreReady(

    MVPbkContactStore& /*aContactStore*/ )

     {

     DP_SDA( "CPresencePluginContacts::StoreReady()" );

     }

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

// From class MVPbkContactStoreObserver.

// CPresencePluginContacts::StoreUnavailable

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

//

void CPresencePluginContacts::StoreUnavailable(

    MVPbkContactStore& /*aContactStore*/, TInt /*aReason*/ )

    {

    DP_SDA( "CPresencePluginContacts::StoreUnavailable()" );

    }

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

// From class MVPbkContactStoreObserver.

// CPresencePluginContacts::HandleStoreEventL

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

//

void CPresencePluginContacts::HandleStoreEventL(

         MVPbkContactStore& /*aContactStore*/, 

         TVPbkContactStoreEvent /*aStoreEvent*/ )

    {

    DP_SDA( "CPresencePluginContacts::HandleStoreEventL()" );

    }

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

// From class MVPbkContactFindObserver.

// CPresencePluginContacts::FindCompleteL

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

//

void CPresencePluginContacts::FindCompleteL( MVPbkContactLinkArray* aResults )

    {

    DP_SDA( "CPresencePluginContacts::FindCompleteL()" );

    delete iContactLinkArray;

    iContactLinkArray = NULL;

    iContactLinkArray = aResults;

    delete iContactOperation;

    iContactOperation = NULL;

    iStateHandler->State()->Complete();

    }

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

// From class MVPbkContactFindObserver.

// CPresencePluginContacts::FindFailed

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

//

void CPresencePluginContacts::FindFailed( TInt aError )

    {

    DP_SDA( "CPresencePluginContacts::FindFailed()" );

    delete iContactOperation;

    iContactOperation = NULL;

    iStateHandler->State()->Error( aError );

    }

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

// From class MVPbkSingleContactOperationObserver.

// CPresencePluginContacts::VPbkSingleContactOperationComplete

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

//

void CPresencePluginContacts::VPbkSingleContactOperationComplete(

        MVPbkContactOperationBase& aOperation,

        MVPbkStoreContact* aContact )

    {

    DP_SDA( "CPresencePluginContacts::VPbkSingleContactOperationComplete()" );

    if ( iContactOperation == &aOperation )

        {

        delete iContactOperation;

        iContactOperation = NULL;

        }

    TInt error = iStoreContactArray.Append( aContact );

    if ( KErrNone != error )

        {

        delete aContact;

        aContact = NULL;

        iStateHandler->State()->Error( error );

        }

    else

        {

        iStateHandler->State()->Complete();

        }

    }

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

// From class MVPbkSingleContactOperationObserver.

// CPresencePluginContacts::VPbkSingleContactOperationFailed

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

//

void CPresencePluginContacts::VPbkSingleContactOperationFailed(

        MVPbkContactOperationBase& aOperation, 

        TInt aError )

    {

    DP_SDA( "CPresencePluginContacts::VPbkSingleContactOperationFailed()" );

    if ( iContactOperation == &aOperation )

        {

        delete iContactOperation;

        iContactOperation = NULL;

        }

    iStateHandler->State()->Error( aError);

    }

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

// From class CActive.

// CPresencePluginContacts::RunL

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

//

void CPresencePluginContacts::RunL()

    {

    DP_SDA2( "CPresencePluginContacts::RunL - status %d", iStatus.Int() );

    TBool result( EFalse );

    TBool found( EFalse );

    CPresencePluginLocalstore* localStore = NULL;

    TInt error = iStatus.Int();

    switch( iOperation )

        {

        case EOperationIsPresenceStoredToContacts:

            DP_SDA( "CPresencePluginContacts::RunL -EOperationIsPresenceStoredToContacts" );

            if ( KErrNone == error )

                {

                localStore = CPresencePluginLocalstore::NewLC( *iServiceName );

                for ( TInt i( 0 ); ( i < iStoreContactArray.Count() ) && !found; i++ )

                    {

                    MVPbkContactLink* link = iStoreContactArray[ i ]->CreateLinkLC();

                    CVPbkContactIdConverter* converter =

                        CVPbkContactIdConverter::NewL( link->ContactStore() );

                    CleanupStack::PushL( converter );

                    TInt32 id = converter->LinkToIdentifier( *link );

                    if ( localStore->SeekRowAtContactColL( id ) )

                        {

                        found = ETrue;

                        result = ETrue;

                        }

                    CleanupStack::PopAndDestroy( converter );

                    CleanupStack::PopAndDestroy(); // link

                    }

                CleanupStack::PopAndDestroy( localStore );

                }

            if ( KErrNotFound == error )

                {

                error = KErrNone;

                }

            iObserver->RequestComplete( &result, iOperation, error );

            break;

        default:

            break;

        }

    // Operation completed.

    // State handler not needet anymore

    delete iStateHandler;

    iStateHandler = NULL;

    // Close contact stores

    iContactManager->ContactStoresL().CloseAll( *this );

    User::RequestComplete( iClientStatus, error );

    }

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

// From class CActive.

// CPresencePluginContacts::DoCancel

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

//

void CPresencePluginContacts::DoCancel()

    {

    if ( iClientStatus && *iClientStatus == KRequestPending )

        {

        User::RequestComplete( iClientStatus, KErrCancel );

        }

    iStateHandler->Complete( KErrCancel );

    }

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

// From class CActive.

// CPresencePluginContacts::RunError

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

//

TInt CPresencePluginContacts::RunError( TInt aError )

    {

    DP_SDA2( "CPresencePluginContacts::RunError - status %d", aError );

    User::RequestComplete( iClientStatus, aError );

    return KErrNone;

    }

// End of file