/*

* 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:  Implementation for PC Search Interface

*

*/

// INCLUDE FILES

#include "CCASearchInterfacePC.h"

#include "MCASearchBackgroundObserverPC.h"

#include "MCASearchInterface.h"

#include "MCASearchObserverInterfacePC.h"

#include "MCAStoredContacts.h"

#include "CCAStorageManagerFactory.h"

#include "MCAGroupManagerInterface.h"

#include "MCAExtendedStoredGroup.h"

#include "MCAGroupOperations.h"

#include "MCAStoredGroups.h"

#include "ImpsCSPAllErrors.h"

#include "TEnumsPC.h"

#include "MCAServerContactsArrayPC.h"

#include "CCAServerContactsArrayPC.h"

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

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

// CCASearchInterfacePC: Constructor

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

//

CCASearchInterfacePC::CCASearchInterfacePC( MCASearchInterface* aSearchInterface,

                                            MCABackgroundInterface& aBackgroundInterface,

                                            MCAGroupManagerInterface& aGroupMgrInterface )

        : iSearchInterface( aSearchInterface ),

        iBackgroundInterface( aBackgroundInterface ),

        iGroupMgrInterface( aGroupMgrInterface )

    {

    }

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

// CCASearchInterfacePC: ConstructL

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

//

void CCASearchInterfacePC::ConstructL(  )

    {

    iStoredGroupsInterface = CCAStorageManagerFactory::GroupListInterfaceL();

    }

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

// CCASearchInterfacePC: NewL

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

//

CCASearchInterfacePC* CCASearchInterfacePC::NewL( MCASearchInterface* aSearchInterface,

                                                  MCABackgroundInterface& aBackgroundInterface,

                                                  MCAGroupManagerInterface& aGroupMgrInterface )

    {

    CCASearchInterfacePC* self = new ( ELeave ) CCASearchInterfacePC( aSearchInterface,

                                                                      aBackgroundInterface,

                                                                      aGroupMgrInterface );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCASearchInterfacePC: Destructor

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

//

CCASearchInterfacePC::~CCASearchInterfacePC()

    {

    if ( iBackgroundObserver )

        {

        iBackgroundInterface.UnRegisterBackgroundObserver( this );

        }

    // delete searchpairs

    if ( iSearchPairs )

        {

        iSearchPairs->ResetAndDestroy();

        delete iSearchPairs;

        iSearchPairs = NULL;

        }

    }

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

// CCASearchInterfacePC: StartSearchL

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

//

TInt CCASearchInterfacePC::StartSearchL( TInt aSearchLimit,

                                         MCASearchObserverInterfacePC* aObserver, CSearchPairs* aSearchPairs )

    {

    //This code is not yet useful for the existing chat.

    //the current calls for searching to the engine are synchronous calls.

    AddObserver( aObserver );

    //For the existing chat application with synchronous calls

    //to search, pass NULL as the observer

    if ( !aSearchPairs )

        {

        aSearchPairs = SearchPairs();

        }

    return iSearchInterface->StartSearchL( *aSearchPairs, aSearchLimit, NULL );

    }

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

// CCASearchInterfacePC: EndSearchL

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

//

TInt CCASearchInterfacePC::EndSearchL()

    {

    RemoveObserver();

    return iSearchInterface->EndSearchL();

    }

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

// CCASearchInterfacePC: SearchNextL

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

//

TInt CCASearchInterfacePC::SearchNextL( TInt aIndex, MCASearchObserverInterfacePC* aObserver )

    {

    //This code is not yet useful for the existing chat.

    //the current calls for searching to the engine are synchronous calls.

    AddObserver( aObserver );

    //For the existing chat application with synchronous calls

    //to search, pass NULL as the observer

    return iSearchInterface->SearchNextL( aIndex, NULL );

    }

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

// CCASearchInterfacePC: AddObserver

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

//

void CCASearchInterfacePC::AddObserver( MCASearchObserverInterfacePC* aObserver )

    {

    iSearchObserverPC = aObserver;

    }

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

// CCASearchInterfacePC: RemoveObserver

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

//

void CCASearchInterfacePC::RemoveObserver()

    {

    //Not the owner of observer. so dont delete

    iSearchObserverPC = NULL;

    }

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

// CCASearchInterfacePC: HandleSearchError

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

//

void CCASearchInterfacePC::HandleSearchError( TInt aErrorCode )

    {

    if ( iSearchObserverPC )

        {

        iSearchObserverPC->HandleSearchError( aErrorCode );

        }

    }

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

// CCASearchInterfacePC: HandleSearchFinished

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

//

void CCASearchInterfacePC::HandleSearchFinished( )

    {

    if ( iSearchObserverPC )

        {

        iSearchObserverPC->HandleSearchFinished();

        }

    }

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

// CCASearchInterfacePC::BackgroundTaskStatus

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

//

TInt CCASearchInterfacePC::BackgroundTaskStatus( TEnumsPC::TCABackgroundTasks aTaskID )

    {

    MCABackgroundInterface::TCABackgroundTasks eventSource = ConvertToTCABackgroundTasks( aTaskID );

    return iBackgroundInterface.BackgroundTaskStatus( eventSource );

    }

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

// CCASearchInterfacePC::RegisterBackgroundObserver

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

//

TInt CCASearchInterfacePC::RegisterBackgroundObserver(

    MCASearchBackgroundObserverPC* aBackgroundObserver,

    TInt aTaskMask,

    TInt aEventMask	)

    {

    iBackgroundObserver = aBackgroundObserver;

    TInt status = iBackgroundInterface.RegisterBackgroundObserver( this,

                                                                   aTaskMask, aEventMask );

    ASSERT( aBackgroundObserver );

    return status;

    }

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

// CCASearchInterfacePC::UnRegisterBackgroundObserver

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

//

void CCASearchInterfacePC::UnRegisterBackgroundObserver(

    MCASearchBackgroundObserverPC* aBackgroundObserver )

    {

    if ( iBackgroundObserver == aBackgroundObserver )

        {

        iBackgroundInterface.UnRegisterBackgroundObserver( this );

        }

    }

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

// CCASearchInterfacePC::HandleBackgroundEvent

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

//

void CCASearchInterfacePC::HandleBackgroundEvent(

    MCABackgroundInterface::TCABackgroundTasks aEventSource,

    MCABackgroundInterface::TCABackgroundStatus aStatus,

    TInt aSubTaskNumber,

    TInt aLeaveCode

)

    {

    TEnumsPC::TCABackgroundTasks eventSource = ConvertTCABackgroundTasksToTEnumsPC( aEventSource );

    TEnumsPC::TCABackgroundStatus status = ConvertTCABackgroundStatus( aStatus );

    iBackgroundObserver->HandleBackgroundEventPC( eventSource,

                                                  status, aSubTaskNumber, aLeaveCode );

    }

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

// CCASearchInterfacePC::ConvertToTCABackgroundTasks

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

//

MCABackgroundInterface::TCABackgroundTasks CCASearchInterfacePC::

ConvertToTCABackgroundTasks( TEnumsPC::TCABackgroundTasks aSource )

    {

    MCABackgroundInterface::TCABackgroundTasks eventSource;

    switch ( aSource )

        {

        case TEnumsPC::EGroupFetch:

            {

            eventSource = MCABackgroundInterface::EGroupFetch;

            break;

            }

        case TEnumsPC::EPresenceTask:

            {

            eventSource = MCABackgroundInterface::EPresence;

            break;

            }

        case TEnumsPC::EWhisperSync:

            {

            eventSource = MCABackgroundInterface::EWhisperSync;

            break;

            }

        case TEnumsPC::EBlockGrantListFetch:

        default:

            {

            eventSource = MCABackgroundInterface::EBlockGrantListFetch;

            break;

            }

        }

    return eventSource;

    }

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

// CCASearchInterfacePC::ConvertTCABackgroundTasksToTEnumsPC

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

//

TEnumsPC::TCABackgroundTasks CCASearchInterfacePC::ConvertTCABackgroundTasksToTEnumsPC

( MCABackgroundInterface::TCABackgroundTasks aEventSource )

    {

    TEnumsPC::TCABackgroundTasks eventSource;

    switch ( aEventSource )

        {

        case MCABackgroundInterface::EGroupFetch:

            {

            eventSource = TEnumsPC::EGroupFetch;

            break;

            }

        case MCABackgroundInterface::EPresence:

            {

            eventSource = TEnumsPC::EPresenceTask;

            break;

            }

        case MCABackgroundInterface::EWhisperSync:

            {

            eventSource = TEnumsPC::EWhisperSync;

            break;

            }

        case MCABackgroundInterface::EBlockGrantListFetch:

            {

            eventSource = TEnumsPC::EBlockGrantListFetch;

            break;

            }

        default:

            {

            eventSource = TEnumsPC::EFailed;

            break;

            }

        }

    return eventSource;

    }

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

// CCASearchInterfacePC::ConvertTCABackgroundStatus

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

//

TEnumsPC::TCABackgroundStatus CCASearchInterfacePC::ConvertTCABackgroundStatus

( MCABackgroundInterface::TCABackgroundStatus aStatus )

    {

    TEnumsPC::TCABackgroundStatus status;

    switch ( aStatus )

        {

        case MCABackgroundInterface::EUnknown:

            {

            status = TEnumsPC::EUnknownStatus;

            break;

            }

        case MCABackgroundInterface::EIdleStarted:

            {

            status = TEnumsPC::EIdleStarted;

            break;

            }

        case MCABackgroundInterface::EStarting:

            {

            status = TEnumsPC::EStarting;

            break;

            }

        case MCABackgroundInterface::EWaiting:

            {

            status = TEnumsPC::EWaiting;

            break;

            }

        case MCABackgroundInterface::ECompleted:

            {

            status = TEnumsPC::ECompleted;

            break;

            }

        case MCABackgroundInterface::ECancelled:

            {

            status = TEnumsPC::ECancelled;

            break;

            }

        case MCABackgroundInterface::EFailed:

        default:

            {

            status = TEnumsPC::EFailedStatus;

            break;

            }

        }

    return status;

    }

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

// CCASearchInterfacePC::SetRequestL

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

//

void CCASearchInterfacePC::SetRequestL(  RArray<TEnumsPC::TSearchCriteria>&  aSearchCriteriaArray,

                                         CDesCArray& aSearchStringArray )

    {

    TInt count = aSearchCriteriaArray.Count();

    ASSERT( count );

    SetSearchPairsL( count );

    for ( TInt i( 0 ); i < count; i++ )

        {

        CImpsSearchRequest* request = CImpsSearchRequest::NewL();

        CleanupStack::PushL( request );

        request->SetRequestL( ConvertToTImpsSearchElement(

                                  aSearchCriteriaArray[i] ), aSearchStringArray[i] );

        iSearchPairs->AppendL( request ); //Takes the ownership

        CleanupStack::Pop( request );

        }

    }

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

// CCASearchInterfacePC::ConvertToTImpsSearchElement

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

//

TImpsSearchElement CCASearchInterfacePC::

ConvertToTImpsSearchElement( TEnumsPC::TSearchCriteria aElement )

    {

    TImpsSearchElement searchElement( EImpsUserID );

    switch ( aElement )

        {

        case TEnumsPC::ESearchGroupName:

            {

            searchElement = EImpsGroupName;

            break;

            }

        case TEnumsPC::ESearchGroupTopic:

            {

            searchElement = EImpsGroupTopic;

            break;

            }

        case TEnumsPC::ESearchGroupUserIDJoined:

            {

            searchElement = EImpsGroupUserIDJoined;

            break;

            }

        case TEnumsPC::ESearchUserName:

            {

            searchElement = EImpsUserFirstName;

            break;

            }

        case TEnumsPC::ESearchUserLastName:

            {

            searchElement = EImpsUserLastName;

            break;

            }

        case TEnumsPC::ESearchUserID:

            {

            searchElement = EImpsUserID;

            break;

            }

        case TEnumsPC::ESearchUserMobileNumber:

            {

            searchElement = EImpsUserMobileNumber;

            break;

            }

        case TEnumsPC::ESearchUserEmailAddress:

            {

            searchElement = EImpsUserEmailAddress;

            break;

            }

        default:

            {

            break;

            }

        }

    return searchElement;

    }

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

// CCASearchInterfacePC::SearchPairs

// (other items were commented in a header).

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

//

CSearchPairs* CCASearchInterfacePC::SearchPairs()

    {

    return iSearchPairs;

    }

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

// CCASearchInterfacePC::SetSearchPairsL

// (other items were commented in a header).

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

//

void CCASearchInterfacePC::SetSearchPairsL( TInt aCount )

    {

    if ( iSearchPairs )

        {

        iSearchPairs->ResetAndDestroy();

        delete iSearchPairs;

        iSearchPairs = NULL;

        }

    if ( aCount > 0 )

        {

        iSearchPairs = new ( ELeave ) CSearchPairs( aCount );

        }

    }

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

// CCASearchInterfacePC::IsSearchPairsSet

// (other items were commented in a header).

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

//

TBool CCASearchInterfacePC::IsSearchPairsSet()

    {

    if ( SearchPairs() )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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