/*

* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, version 2.1 of the License.

* 

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not, 

* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

*

* Description:  IPC Client side implementation

*

*/

#include "xqservicelog.h"

#include "xqserviceipc.h"

#include "xqserviceipc_p.h"

#include "xqserviceipcfactory.h"

namespace QtService

{

/*!

    \class ServiceFwIPC

    \brief Public interface class for IPC operations

*/

/*!

    Destructor

*/

ServiceFwIPC::~ServiceFwIPC()

{

    XQSERVICE_DEBUG_PRINT("ServiceFwIPC::~ServiceFwIPC");

    delete d;

}

/*!

    Constructor.

    \param aParent Parent to this QObject

    \param aBackend IPC backend to use

*/

ServiceFwIPC::ServiceFwIPC(QObject* aParent, TServiceIPCBackends aBackend) :

                           QObject(aParent), iAsyncRequestPending(false)

{

    XQSERVICE_DEBUG_PRINT("ServiceFwIPC::ServiceFwIPC");

    // Private implementation pattern

    //

    d = ServiceFwIPCFactory::createBackend(aBackend);

    d->q = this;

}

/*!

    Connect to the server.

    \param aServerName name of the server to connect to.

    \return true if connected, false if not.

*/

bool ServiceFwIPC::connect(const QString& aServerName)

{

    XQSERVICE_DEBUG_PRINT("ServiceFwIPC::connect");

    return d->connect(aServerName);

}

/*!

    Disconnect from the server.

*/

void ServiceFwIPC::disconnect()

{

    XQSERVICE_DEBUG_PRINT("ServiceFwIPC::disconnect");

    d->disconnect();

}

/*!

    Starts the service.

    \param aServerName Name of the server.

    \param aExeName Executable of the server.

    \return true if connected.

*/

bool ServiceFwIPC::startServer(const QString& aServerName,

                                  const QString& aExeName,

                                  quint64& processId,

                                  ServiceIPCStartServerOptions options)

{

    XQSERVICE_DEBUG_PRINT("ServiceFwIPC::startServer");

    return d->startServer(aServerName, aExeName, processId, options);

}

/*!

    Send a request synchronously.

    \param aRequestType Name of the request.

    \param aData Data to send.

    \return true if sent successful, otherwise false.

*/

bool ServiceFwIPC::sendSync(const QString& aRequestType,

                            const QByteArray& aData)

{

    XQSERVICE_DEBUG_PRINT("ServiceFwIPC::sendSync");

#ifdef _DEBUG

    Q_ASSERT_X( aRequestType.contains(";") == false, "", "aRequestType cannot contain semicolons!" );

#endif // _DEBUG

    bool sent = d->sendSync(aRequestType, aData);

    if (sent) {

        sent = waitForRead();

    }

    return sent;

}

/*!

    Send a request asynchronously.

    \param aRequestType Name of the request.

    \param aData Data to send.

    \note Errors will be emitted via error() signal.

*/

void ServiceFwIPC::sendAsync(const QString& aRequestType,

                             const QByteArray& aData)

{

    XQSERVICE_DEBUG_PRINT("ServiceFwIPC::sendAsync");

#ifdef _DEBUG

    Q_ASSERT_X( aRequestType.contains(";") == false, "", "aRequestType cannot contain semicolons!" );

#endif // _DEBUG

    d->sendAsync(aRequestType, aData);

    iAsyncRequestPending = true;

}

/*!

    Asynchronous read.

    \param aArray Array where read data will be put.

*/

void ServiceFwIPC::readAll(QByteArray& aArray)

{

    XQSERVICE_DEBUG_PRINT("ServiceFwIPC::readAll(1)");

    d->readAll(aArray);

}

/*!

    Synchronous read.

    \return Array which where read data is put.

*/

QByteArray ServiceFwIPC::readAll()

{

    XQSERVICE_DEBUG_PRINT("ServiceFwIPC::readAll(2)");

    return d->readAll();

}

/*!

    Waits until data is available for reading.

    \return true if data is available for reading.

*/

bool ServiceFwIPC::waitForRead()

{

    XQSERVICE_DEBUG_PRINT("ServiceFwIPC::waitForRead");

    return d->waitForRead();

}

/*!

    Check if an async request is already pending.

    \return true if an async request is pending,

            false otherwise.

*/

bool ServiceFwIPC::requestPending()

{

    XQSERVICE_DEBUG_PRINT("ServiceFwIPC::requestPending");

    return iAsyncRequestPending;

}

void ServiceFwIPC::setUserData(const void *data)

{

    XQSERVICE_DEBUG_PRINT("ServiceFwIPC::setUserData: %x", (int)data);

    d->setUserData(data);

}

}

/*!

    \fn QtService::ServiceFwIPC::error( int aError )

    Signal emitted to handle any errors.

    \param aError error code

    \note For local socket implementation, the error can be interpreted 

          as QLocalSocket::LocalSocketError

*/

/*!

    \fn QtService::ServiceFwIPC::readyRead()

    Handle when a reply has been received for async requests.

    Emitted when the entire data packet has been received

*/

/*!

    \fn QtService::ServiceFwIPC::ReadDone()

    Emitted when reading has completed.

*/

// END OF FILE