/*

* 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:                                                         

*

*/

#include "xqservicelog.h"

#include <xqserviceprovider.h>

#include <qmetaobject.h>

#include <QByteArray>

#include <xqserviceadaptor.h>

//#include <xqserviceservice.h>

#include <xqserviceutil.h>

/*!

    \class XQServiceProvider

    \inpublicgroup QtBaseModule

    \brief The XQServiceProvider class provides an interface to messages on a XQService service

    which simplifies remote slot invocations

    Service messages consist of a service name, a message name, and a list of parameter values.

    Qt extension extension dispatches service messages to the applications associated with the service

    name, on the application's \c{QPE/Application/appname} channel, where

    \c{appname} is the application's name.

    The use of XQServiceProvider will be demonstrated using the \c{Time}

    service.  This has a single message called \c{editTime()} which asks

    the service to pop up a dialog allowing the user to edit the current time.

    \code

    class TimeService : public XQServiceProvider

    {

        Q_OBJECT

    public:

        TimeService( QObject *parent = 0 );

    public slots:

        void editTime(QTime time);

    };

    TimeService::TimeService( QObject *parent )

        : XQServiceProvider( "Time", parent )

    {

        publishAll();

    }

    \endcode

    The call to publishAll() causes all public slots within \c{TimeService}

    to be automatically registered as Service messages.  This can be

    useful if the service has many message types.

    The client can send a request to the service using QtopiaServiceRequest:

    \code

    XQServiceRequest req( "Time", "editTime()" );

    req << QTime::currentTime();

    req.send();

    \endcode

*/

class ServiceAdaptorProxy : public XQServiceAdaptor

{

    Q_OBJECT

public:

    ServiceAdaptorProxy(const QString &channel, QObject *parent=0);

    virtual ~ServiceAdaptorProxy() ;

    QString memberToMessage( const QByteArray& member );

};

ServiceAdaptorProxy::ServiceAdaptorProxy(const QString &channel, QObject *parent) :

        XQServiceAdaptor(channel, parent) 

{

    XQSERVICE_DEBUG_PRINT("ServiceAdaptorProxy::ServiceAdaptorProxy");

    XQSERVICE_DEBUG_PRINT("channel: %s", qPrintable(channel));

}

ServiceAdaptorProxy::~ServiceAdaptorProxy()

{

    XQSERVICE_DEBUG_PRINT("ServiceAdaptorProxy::~ServiceAdaptorProxy");

}

QString ServiceAdaptorProxy::memberToMessage( const QByteArray& member )

{

    XQSERVICE_DEBUG_PRINT("ServiceAdaptorProxy::memberToMessage");

    XQSERVICE_DEBUG_PRINT("member: %s", member.constData());

// TO BE CHECKED

//    return m_channel + "::" + XQServiceAdaptor::memberToMessage( member );

    return XQServiceAdaptor::memberToMessage( member );

}

class XQServiceProvider_Private

{

public:

    XQServiceProvider_Private(const QString &service);

    ~XQServiceProvider_Private();

    XQServiceAdaptor *m_adaptor;

    QString m_service;

    bool m_publishAllCalled;

    QObject* plugin;

};

XQServiceProvider_Private::XQServiceProvider_Private(const QString &service) :

        m_adaptor(NULL),

        m_service(service),

        m_publishAllCalled(false),

		plugin(NULL)

{

    XQSERVICE_DEBUG_PRINT("XQServiceProvider_Private::XQServiceProvider_Private");

    XQSERVICE_DEBUG_PRINT("service: %s", qPrintable(service));

    m_adaptor = new ServiceAdaptorProxy(service);

}

XQServiceProvider_Private::~XQServiceProvider_Private()

{

    XQSERVICE_DEBUG_PRINT("XQServiceProvider_Private::~XQServiceProvider_Private");

    delete m_adaptor;

}

/*!

    Construct a remote service object for \a service and attach it to \a parent.

*/

XQServiceProvider::XQServiceProvider( const QString& service, QObject *parent )

    : QObject( parent )

{

    XQSERVICE_DEBUG_PRINT("XQServiceProvider::XQServiceProvider");

    XQSERVICE_DEBUG_PRINT("service: %s", qPrintable(service));

    m_data = new XQServiceProvider_Private(service);

    connect(m_data->m_adaptor, SIGNAL(returnValueDelivered()), this, SIGNAL(returnValueDelivered())); 

    connect(m_data->m_adaptor, SIGNAL(clientDisconnected()), this, SIGNAL(clientDisconnected())); 

}

/*!

    Destroy this service handling object.

*/

XQServiceProvider::~XQServiceProvider()

{

    XQSERVICE_DEBUG_PRINT("XQServiceProvider::~XQServiceProvider");

    if (m_data)

        delete m_data;

}

void XQServiceProvider::SetPlugin(QObject* impl_plugin)

    {

    m_data->plugin=impl_plugin;

    }

/*!

    Publishes all slots on this object within subclasses of XQServiceProvider.

    This is typically called from a subclass constructor.

*/

void XQServiceProvider::publishAll()

{

    XQSERVICE_DEBUG_PRINT("XQServiceProvider::publishAll");

	if (!m_data->plugin) {

	    m_data->m_adaptor->publishAll(this,XQServiceProvider::staticMetaObject.methodCount(),XQServiceAdaptor::Slots);

	}

    else {

        m_data->m_adaptor->publishAll(m_data->plugin, 0, XQServiceAdaptor::Slots);

    } 

}

/*!

*   Sets current request to asynchronous mode so that provider can complete the

*   request later via the completeRequest() call. 

*   \return Request ID which shall be used in the completeRequest() call.

*/

int XQServiceProvider::setCurrentRequestAsync()

{

    XQSERVICE_DEBUG_PRINT("XQServiceProvider::setCurrentRequestAsync");

    return m_data->m_adaptor->setCurrentRequestAsync();

}

/*!

*   Completes the asynchronous request with the given value

*   \param index Request ID got from the setCurrentRequestAsync call.

*   \param retValue The value

*   \return true on success, false if index points to non-existing request.

*/

bool XQServiceProvider::completeRequest(int index, const QVariant& retValue)

{

    XQSERVICE_DEBUG_PRINT("XQServiceProvider::completeRequest");

    XQSERVICE_DEBUG_PRINT("index: %d, retValue: %s", index, qPrintable(retValue.toString()));

    return m_data->m_adaptor->completeRequest(index, retValue);

}

/*!

*   Return additional request information attached to  request

*   \return Request info

*/

XQRequestInfo XQServiceProvider::requestInfo() const

{

    return m_data->m_adaptor->requestInfo();

}

#include "xqserviceprovider.moc"