/*
* 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::GetAdaptiveGridL
// Initiate the Adaptive Grid request.
// ----------------------------------------------------------------------------
void RPsSession::GetAdaptiveGridL( const TDesC8& aURIs,
                                   const TBool aCompanyName,
                                   TDes& aResultsBuffer )
{
    PRINT ( _L("Enter RPsSession::GetAdaptiveGrid") );

    TIpcArgs args( &aURIs, aCompanyName, &aResultsBuffer );

    TRequestStatus status;

    // Initiate the Adaptive Grid request
    SendReceive( EGetAdaptiveGrid,
                 args,
                 status );

    User::WaitForRequest(status);

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

// ----------------------------------------------------------------------------
// 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