/*

* Copyright (c) 2002-2005 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:  This class offers the search services

*

*/

// INCLUDE FILES

#include "CCARequest.h"

#include "CCARequestMapper.h"

#include "CCASearchData.h"

#include "CCASearchManager.h"

#include "MCASearchObserverInterface.h"

#include "PublicEngineDefinitions.h"

#include "PrivateEngineDefinitions.h"

#include "ImpsCSPAllErrors.h"

#include "MCAImpsFactory.h"

#include "ChatDebugPrint.h"

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

// Two-phased constructor.

CCASearchManager* CCASearchManager::NewL(

    MCAImpsFactory* aIMPSFactory,

    CCARequestMapper*   aRequestMapper )

    {

    CCASearchManager* self = new ( ELeave ) CCASearchManager(

        aIMPSFactory,

        aRequestMapper );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CCASearchManager::~CCASearchManager()

    {

    delete iOwnGrouplistCreatorId;

    delete iResults;

    delete iCreatedGroups;

    }

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

// CCASearchManager::SetSearchSupported

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

//

void CCASearchManager::SetSearchSupported( TBool aSearchSupported )

    {

    iSearchSupported = aSearchSupported;

    }

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

// CCASearchManager::StartSearchL

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

//

EXPORT_C TInt CCASearchManager::StartSearchL(

    const CSearchPairs& aPairs,

    TInt          aSearchLimit,

    MCASearchObserverInterface* aObserver )

    {

    CHAT_DP_TXT( "CCASearchManager::StartSearchL()...starts" );

    if ( !iSearchSupported )

        {

        User::Leave( ESearchNotSupported );

        }

    // Set data

    iSearchLimit = aSearchLimit;

    iState = ESearchStartRequested;

    // Create the request

    CHAT_DP_FUNC_DP( "StartSearchL", "Creating request" );

    TInt opId = iImpsFundClient->SearchFirstL( aPairs,

                                               aSearchLimit );

    CCARequest* request = iRequestMapper->CreateRequestL( opId, EFalse );

    // remember the observer (synchronous, so only one observer used)

    iObserver = aObserver;

    CHAT_DP_FUNC_DP( "StartSearchL", "Waiting for completion" );

    request->StartWait();

    // execution continues from here

    TInt errorCode( KErrNone );

    errorCode = request->ErrorCode();

    iRequestMapper->RemoveRequest( request );

    iObserver = NULL;

    CHAT_DP_TXT( "CCASearchManager::StartSearchL()...over" );

    return errorCode;

    }

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

// CCASearchManager::EndSearchL

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

//

EXPORT_C TInt CCASearchManager::EndSearchL()

    {

    CHAT_DP_TXT( "CCASearchManager::EndSearchL()...starts" );

    if ( !iSearchSupported )

        {

        User::Leave( ESearchNotSupported );

        }

    // Create the request and start waiting

    CCARequest* request = iRequestMapper->CreateRequestL(

                              iImpsFundClient->StopSearchL( iSearchID ),

                              EFalse );

    request->StartWait();

    TInt errorCode( KErrNone );

    // Execution continues from here

    errorCode = request->ErrorCode();

    CHAT_DP( D_CHAT_LIT( "EndSearchL() error code %d" ), errorCode );

    iRequestMapper->RemoveRequest( request );

    iObserver = NULL;

    CHAT_DP_TXT( "CCASearchManager::EndSearchL()...over" );

    return errorCode;

    }

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

// CCASearchManager::SearchNextL

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

//

EXPORT_C TInt CCASearchManager::SearchNextL( TInt aIndex,

                                             MCASearchObserverInterface* aObserver )

    {

    CHAT_DP_FUNC_ENTER( "SearchNextL" );

    CHAT_DP( D_CHAT_LIT( "SearchNextL index is %d" ), aIndex );

    if ( !iSearchSupported )

        {

        User::Leave( ESearchNotSupported );

        }

    if ( aIndex >= SearchDataInterface()->HowManyResultsAvailable() &&

         iResults->NoMoreResultsAvailable() )

        {

        CHAT_DP_TXT( "!!!NO MORE RESULTS!!!" );

        iObserver = NULL;

        User::Leave( ERequestedResultsButNotAvailable );

        }

    if ( iResults->WeHaveData( aIndex ) )

        {

        CHAT_DP_TXT( "   We have results" );

        CHAT_DP_FUNC_DONE( "SearchNextL" );

        iObserver = NULL;

        return KErrNone;

        }

    else

        {

        CHAT_DP_TXT( "   We do not have results" );

        CHAT_DP( D_CHAT_LIT( "Next index %d" ), iResults->NextSearchIndex() );

        // Start waiting

        TInt opId = iImpsFundClient->SearchNextL( iSearchID,

                                                  iResults->NextSearchIndex() );

        CCARequest* request = iRequestMapper->CreateRequestL( opId, EFalse );

        // remember the observer for this operation

        iObserver = aObserver;

        request->StartWait();

        // execution continues from here

        TInt errorCode( KErrNone );

        errorCode = request->ErrorCode();

        iRequestMapper->RemoveRequest( request );

        CHAT_DP_FUNC_DONE( "SearchNextL" );

        iObserver = NULL;

        return errorCode;

        }

    }

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

// CCASearchManager::SearchDataInterface

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

//

EXPORT_C MCASearchData* CCASearchManager::SearchDataInterface() const

    {

    return iResults;

    }

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

// CCASearchManager::HandleSearchL

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

//

void CCASearchManager::HandleSearchL( TInt aId,

                                      TInt aSearchId,

                                      TInt aIndex,

                                      TInt aResultsFound,

                                      TBool aCompleted,

                                      TImpsSearchResultType aType,

                                      MDesCArray* aResults ,

                                      TImpsCspIdentifier& /* aCspId */ )

    {

    // NOTES about response API

    // 1. After the search has been started 2nd search and from that point on

    //    the aSearchId is not available (see SCR)

    CHAT_DP_FUNC_ENTER( "HandleSearchL" );

    CHAT_DP( D_CHAT_LIT( "   aIndex = %d" ), aIndex );

    CHAT_DP( D_CHAT_LIT( "   aSearchId = %d" ), aSearchId );

    CHAT_DP( D_CHAT_LIT( "   iSearchID = %d" ), iSearchID );

    TInt leave( KErrNone );

    // Find the request

    CCARequest* request =

        const_cast<CCARequest*>( iRequestMapper->FindRequest( aId ) );

    if ( request )

        {

        if ( iState == ESearchStartRequested )

            {

            iResults->ClearResults();

            }

        iResults->UpdateMaximumPossibleResults( aResultsFound );

        TRAP( leave, SaveResultsL( aIndex, aCompleted, aType, aResults ) );

        if ( leave != KErrNone )

            {

            CHAT_DP_FUNC_DP( "HandleSearchL", "Got an error" );

            if ( iObserver )

                {

                iObserver->HandleSearchError( EECouldntSaveSearchResults );

                }

            }

        else

            {

            if ( iState == ESearchStartRequested )

                {

                // Update search ID for the first and only time

                iSearchID = aSearchId;

                // Update state

                iState = ESearchGoingOn;

                }

            }

        }

    // If code added/changed before HandleRequest, then make sure that

    // code does not Leave before HandleRequest, because request

    // response waiting does not stop (and waitnote) before calling

    // HandleRequest

    CHAT_DP_FUNC_DP( "HandleSearchL", "Handling request" );

    TInt status( KErrNone );

    if ( leave )

        {

        status = leave;

        }

    iRequestMapper->HandleRequest( aId, status );

    if ( iObserver )

        {

        CHAT_DP_FUNC_DP( "HandleSearchL", "Invoking observer" );

        iObserver->HandleSearchFinished();

        }

    // leave on system errors

    if ( leave > Imps_ERROR_BASE )

        {

        User::LeaveIfError( leave );

        }

    CHAT_DP_FUNC_DONE( "HandleSearchL" );

    }

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

// CCASearchManager::HandleSearchStoppedL

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

//

void CCASearchManager::HandleSearchStoppedL( TInt aId,

                                             TInt /* aSearchId */,

                                             TImpsCspIdentifier& /* aCspId */ )

    {

    CHAT_DP_FUNC_ENTER( "HandleSearchStoppedL" );

    iResults->ClearResults();

    iState = ENoActivity;

    // If code added/changed before HandleRequest, then make sure that

    // code does not Leave before HandleRequest, because request

    // response waiting does not stop (and waitnote) before calling

    // HandleRequest

    iRequestMapper->HandleRequest( aId, KErrNone );

    iObserver = NULL;

    CHAT_DP_FUNC_DONE( "HandleSearchStoppedL" );

    }

// C++ default constructor can NOT contain any code, that

// might leave.

//

CCASearchManager::CCASearchManager(

    MCAImpsFactory* aIMPSFactory,

    CCARequestMapper*   aRequestMapper )

        :   iImpsFactory( aIMPSFactory ),

        iState( ENoActivity ),

        iRequestMapper( aRequestMapper )

    {

    }

// Symbian OS default constructor can leave.

void CCASearchManager::ConstructL()

    {

    CHAT_DP_TXT( "CCASearchManager::ConstructL...starts" );

    iImpsFundClient = iImpsFactory->CreateFundClientL();

    iResults = CCASearchData::NewL();

    iCreatedGroups = new( ELeave ) CDesCArrayFlat( KArrayGranularity );

    CHAT_DP_TXT( "CCASearchManager::ConstructL...ends" );

    }

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

// CCASearchManager::SaveResultsL

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

//

void CCASearchManager::SaveResultsL( TInt aIndex,

                                     TBool aCompleted,

                                     TImpsSearchResultType aType,

                                     MDesCArray* aResults )

    {

    CHAT_DP_TXT( "CCASearchManager::SaveResultsL...starts" );

    iResults->UpdateDataL(

        aIndex,

        aCompleted,

        aType,

        aResults,

        iSearchLimit );

    CHAT_DP_TXT( "CCASearchManager::SaveResultsL...over" );

    }

//  End of File