/*

* 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:  This is the PS server client side interface implementation. 

*

*/

// INCLUDE FILES

#include "RPsSession.h"

#include "CPsData.h"

#include "CPcsDebug.h"

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

// StartServer

// Starts the server. Used only when the server is implemented as a transient.

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

TInt StartServer()

{

    PRINT ( _L("Enter RPsSession->StartServer") );

	RProcess server;

    server.Create ( KPcsServerExeName, KNullDesC );

    TRequestStatus status;

    server.Rendezvous(status);

    if ( status != KRequestPending )

    {

		server.Kill(0);

		server.Close();

		return KErrGeneral;

    }

    else 

    {

		server.Resume();

    }

    User::WaitForRequest(status);

    if ( status != KErrNone )

    {

    	server.Close();

		return status.Int();

    }

    PRINT ( _L("End RPsSession->StartServer") );

    return KErrNone;

}

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

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

// RPsSession::RPsSession

// Constructor

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

RPsSession::RPsSession() : RSessionBase(), 

                           iSearchQueryBufferPtr (0, 0),

                           iResultsBufferPtr (0, 0)

{

    PRINT ( _L("Enter RPsSession::RPsSession") );          

    PRINT ( _L("End RPsSession::RPsSession") );

}

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

// RPsSession::Connects to the search server

// Returns the version number 

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

TInt RPsSession::Connect()

{

    PRINT ( _L("Enter RPsSession::Connect") );

    TInt err = CreateSession( KPcsServerName, Version() );

    if ( err != KErrNone )

        {

        PRINT ( _L("Predictive Search server not running. Trying to start") );

        RMutex mutex;

        TInt errMutex = mutex.CreateGlobal( KPcsServerName );

        if ( errMutex == KErrAlreadyExists )

            {

            mutex.OpenGlobal( KPcsServerName );

            }

        mutex.Wait();

        err = CreateSession( KPcsServerName, Version() );

        if ( err != KErrNone )

            {

            err = StartServer();

            PRINT1( _L("Predictive Search Engine, StartServer(), Err = %d"), err );

            if ( err == KErrNone )

                {

                err = CreateSession( KPcsServerName, Version() );

                }

            }

        mutex.Signal();

        mutex.Close();

        }

    PRINT ( _L("End RPsSession::Connect") );

    return err;

}

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

// RPsSession::Version

// Returns the version number 

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

TVersion RPsSession::Version() const

{

    return ( TVersion ( KPcsServerMajorVersionNumber,

		                KPcsServerMinorVersionNumber,

		             	KPcsServerBuildVersionNumber ) );

}

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

// RPsSession::SearchL

// Initiate a search request.

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

void RPsSession::SetSearchSettingsL(const TDes8& aSettings)

{

    PRINT ( _L("Enter RPsSession::SetSearchSettingsL") );

    TIpcArgs args(&aSettings);

    // Send the search settings to the server. sync call

    TRequestStatus status;

	SendReceive(ESearchSettings, 

	            args,

	            status);

    User::WaitForRequest(status);	            

    PRINT ( _L("End RPsSession::SetSearchSettingsL") );

}

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

// RPsSession::SearchL

// Initiate a search request.

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

void RPsSession::SearchL(const TDes8& aSearchQuery,

                         TPtr8 aResultsBuffer,

                         TRequestStatus& aStatus)

{

    PRINT ( _L("Enter RPsSession::SearchL") );

    // Hold the pointer to buffers till the async request is complete

    iSearchQueryBufferPtr.Set(aSearchQuery);

    iResultsBufferPtr.Set(aResultsBuffer);     

    TIpcArgs args(&iSearchQueryBufferPtr, &iResultsBufferPtr);

    aStatus = KRequestPending;

    // Initiate the search request

	SendReceive(ESearch, 

	            args, 

	            aStatus );

    PRINT ( _L("End RPsSession::SearchL") );	            

}

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

// RPsSession::CancelSearch

// Send a request to cancel search. Synchronous.

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

void RPsSession::CancelSearch()

{

    PRINT ( _L("Enter RPsSession::CancelSearch") );

    TRequestStatus status;

	SendReceive(ECancelSearch, 

	            TIpcArgs(), 

	            status );

    User::WaitForRequest(status);	  

    PRINT ( _L("End RPsSession::CancelSearch") );          

}

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

// RPsSession::SearchL

// Initiate a search request.

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

void RPsSession::SearchL(const TDes8& aSearchQuery,

                         const TDes8& aSearchData,

                         TPtr8 aResultsBuffer)

{

    PRINT ( _L("Enter RPsSession::SearchL") );  

    TIpcArgs args(&aSearchQuery, &aSearchData, &aResultsBuffer);

    TRequestStatus status;

    // Initiate the search request

	SendReceive(ESearchInput, 

	            args, 

	            status );

    User::WaitForRequest(status);	  	            

    PRINT ( _L("End RPsSession::SearchL") );	            

}

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

// RPsSession::SearchMatchStringL

// Initiate a search request.

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

void RPsSession::SearchMatchStringL(const TDes8& aSearchQuery,

                         const TDes8& aSearchData,

                         TDes& aResultsBuffer)

{

    PRINT ( _L("Enter RPsSession::SearchMatchStringL") );  

    TIpcArgs args(&aSearchQuery, &aSearchData, &aResultsBuffer);

    TRequestStatus status;

    // Initiate the search request

    SendReceive(ESearchMatchString, 

                args, 

                status );

    User::WaitForRequest(status);                   

    PRINT ( _L("End RPsSession::SearchMatchStringL") );                

}

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

// RPsSession::SendNewBufferL

// Send a new buffer to recover the search results.

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

void RPsSession::SendNewBufferL(TPtr8 aResultsBuffer,

                                TRequestStatus& aStatus)

{

    PRINT ( _L("Enter RPsSession::SendNewBufferL") );

	iResultsBufferPtr.Set(aResultsBuffer);     

	aStatus = KRequestPending;

    // Search command is reused here. Hence there is no need to fill

    // the search query.

    TIpcArgs args(TIpcArgs::ENothing, 

                  &iResultsBufferPtr);

	SendReceive(ESearch, 

	            args, 

	            aStatus);     

    PRINT ( _L("Enter RPsSession::SendNewBufferL") );	            

}

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

// RPsSession::IsLanguageSupportedL()

// Checks if the language variant is supported by 

// the predictive search engine.

// Synchronous

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

void RPsSession::IsLanguageSupportedL(const TDes8& aLanguage,

                                      TPtr8 aResultsBuffer)

{

	PRINT ( _L("Enter RPsSession::IsLanguageSupportedL") );

	TIpcArgs args(&aLanguage, &aResultsBuffer);

	TRequestStatus status;

	// initiate the request

	SendReceive(ELangSupport, 

				args,

				status);

	User::WaitForRequest(status);

	PRINT ( _L("End RPsSession::IsLanguageSupportedL") );

}

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

// RPsSession::GetDataOrderL

// Send a request to the PS server to recover data fields supported by a store.

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

void RPsSession::GetDataOrderL(const TDes8& aURI,

                               TPtr8 aResultsBuffer)

{

    PRINT ( _L("Enter RPsSession::GetDataOrderL") );

    TIpcArgs args(&aURI, &aResultsBuffer);

    TRequestStatus status;

    // Initiate the request

	SendReceive(EGetDataOrder, 

	            args, 

	            status );

    User::WaitForRequest(status); 

    PRINT ( _L("End RPsSession::GetDataOrderL") );	            

}

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

// RPsSession::GetSortOrderL

// Send a request to the PS server to recover sort order supported by a store.

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

void RPsSession::GetSortOrderL(const TDes8& aURI,

                               TPtr8 aResultsBuffer)

{

    PRINT ( _L("Enter RPsSession::GetSortOrderL") );

    TIpcArgs args(&aURI, &aResultsBuffer);

    TRequestStatus status;

    // Initiate the request

	SendReceive(EGetSortOrder, 

	            args, 

	            status );

    User::WaitForRequest(status); 

    PRINT ( _L("End RPsSession::GetSortOrderL") );	            

}

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

// RPsSession::ChangeSortOrderL

// Send a request to the PS server to set sort order for a store.

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

void RPsSession::ChangeSortOrderL(const TDes8& aInput)

{

    PRINT ( _L("Enter RPsSession::ChangeSortOrderL") );

    TIpcArgs args(&aInput);

    TRequestStatus status;

    // Initiate the request

	SendReceive(ESetSortOrder, 

	            args, 

	            status );

    User::WaitForRequest(status); 

    PRINT ( _L("End RPsSession::ChangeSortOrderL") );	            

}

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

// RPsSession::ShutdownServerL

// Shutsdown the PS Server. Synchronous.

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

void RPsSession::ShutdownServerL()

{

    PRINT ( _L("Enter RPsSession::ShutdownServerL") );

    TIpcArgs args;

    TRequestStatus status;

    SendReceive(EShutdown, args, status );

    User::WaitForRequest(status);

    PRINT ( _L("End RPsSession::ShutdownServerL") );    

}

// End of File