/*

* Copyright (c) 2009 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:                                                         

*

*/

#ifndef XQSERVICECLIENT_H

#define XQSERVICECLIENT_H

#include <QtCore/qobject.h>

#include <xqserviceipcobserver.h>

#include <xqrequestinfo.h>

namespace QtService {

class MServiceIPCObserver;

class ServiceIPCRequest;

class ServiceFwIPCServer;

class ServiceFwIPC;

}

using namespace QtService;

#include <QtCore/qshareddata.h>

#include <QtCore/qregexp.h>

class QEventLoop;

class XQServiceChannel;

class XQServiceRequestCompletedAsync;

class XQServiceProvider;

#define	XQServiceCmd_Send		        	1

#define XQServiceCmd_ReturnValueDelivered   2

class XQServiceIpcClient : public QObject,

                           public MServiceIPCObserver

{

    Q_OBJECT

public:

    XQServiceIpcClient(const QString& ipcConName, bool isServer, 

                       bool isSync, XQServiceRequestCompletedAsync* rc,

                       const void *userData);

    ~XQServiceIpcClient();

    bool listen();

    bool connectToServer();

    bool sendChannelCommand(int cmd, const QString& ch);

    bool send(const QString& ch, const QString& msg, const QByteArray& data, QByteArray &retData,

              int cmd = XQServiceCmd_Send);

    bool cancelPendingSend(const QString& ch);

    bool isServer() const { return server; }

    int setCurrentRequest(ServiceIPCRequest* request);

    int setCurrentRequestAsync();

    bool completeRequest(int index, const QVariant& retValue);

    bool cancelRequest(ServiceIPCRequest* request);

    XQRequestInfo requestInfo() const;

    bool setRequestInfo(XQRequestInfo &info);

signals:

public slots:

    void disconnected();

private slots:

    // ServiceFwIPC error

    void clientError(int);

    void readyRead();

    void readDone();

private: // from MServiceIPCObserver

    bool handleRequest(ServiceIPCRequest *aRequest);

    void handleCancelRequest(ServiceIPCRequest* aRequest);

    void handleDeleteRequest(ServiceIPCRequest* aRequest);

    bool isEmbedded();

private:    

    void wait(int msec);

    ServiceIPCRequest *requestPtr(int index) const; 

private:

    bool server;

    bool synchronous;

    int retryCount;

    QEventLoop* sendSyncLoop;

    QString mIpcConName ;

    ServiceFwIPC* serviceIpc;

    ServiceFwIPCServer* serviceIpcServer;    

    static const int minPacketSize = 256;

    static const int retryToServerMax = 50;

    char outBuffer[minPacketSize];

    XQServiceRequestCompletedAsync* callBackRequestComplete;

    QObject* plugin;

    XQServiceProvider* localProvider;

	QByteArray iRetData;

    const void *mUserData;

    int lastId;

    QHash<int, ServiceIPCRequest*> requestsMap;

};

#endif