/**

   This file is part of CWRT package **

   Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). **

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

*/

#include "serviceipclocalsocketsession.h"

#include "serviceipcserverlocalsocket_p.h"

#include "serviceipcserver.h"

#include <QLocalSocket>

#include <QLocalServer>

#include <serviceipcdefs.h>

#include <clientinfo.h>

namespace WRT

{

/*!

 \class ServiceFwIPCServerLocalSocket

 Service Framework IPC Server using QLocalSocket

 */

/*!

 Constructor

 @param aParent parent to this object

 */

ServiceFwIPCServerLocalSocket::ServiceFwIPCServerLocalSocket(QObject* aParent) 

    : QObject(aParent)

    , m_Listener(NULL)

{

    m_Listener = new QLocalServer(this);

    QObject::connect(m_Listener, SIGNAL(newConnection()),

    this, SLOT(handleNewConnection()) );

    m_isValidSession = true;

    m_isKeepServer = false;

    m_sessionIdTable = new SessionIdTable();

}

/*!

 Destructor

 */

ServiceFwIPCServerLocalSocket::~ServiceFwIPCServerLocalSocket()

{

    m_Listener->close();

    if(m_isValidSession){

        char* data = (char*) m_SharedMem.data();

        if (data) {

            strcpy(data, SERVERNOTSTARTED);

        }

    }

    m_SharedMem.detach();

    delete m_sessionIdTable;

}

/*!

 Start listening for new service requests

 @param aServerName name of this server

 @return true if listen was successful

 */

bool ServiceFwIPCServerLocalSocket::listen(const QString& aServerName)

{

    m_isValidSession = false; 

    bool firstLaunch(false);

    // Create the global chunk that this process owns

    m_SharedMem.setKey(aServerName);

    if (!m_SharedMem.attach()) {

        // Single byte of data + \0

        m_SharedMem.create(2);

        firstLaunch = true;

    }

    // Initial data is 0, ie server not started

    // Check if data is NULL, this handles the case where shared mem cannot attach or create

    //

    char* data = (char*) m_SharedMem.data();

    if ((data && (strcmp(data, SERVERNOTSTARTED)==0)) || firstLaunch) {

        strcpy(data, SERVERNOTSTARTED);

        //Try to listen

        for (int i=2; i>0; i--) {

            m_isValidSession = m_Listener->listen(aServerName);

            if (m_isValidSession) {

                // Server started flag

                strcpy(data, SERVERSTARTED);

                break;

            } else {

                QLocalServer::removeServer(aServerName);        

            }

        }

        // Signal the client to continue and that server is started

        QSystemSemaphore sem(aServerName + SERVERSEM, 0);

        sem.release(1);

    }

    return m_isValidSession;

}

/*!

 Shutdown the server and stop serving clients 

 @return void

 */

void ServiceFwIPCServerLocalSocket::disconnect()

{

    m_Listener->close();

    // Clean up all sessions

    int count = m_Sessions.count();

    for (int i = 0; i < count; ++i) {

        QObject::disconnect(m_Sessions[i], SIGNAL(disconnected( ServiceIPCSession* ) ),

        this, SLOT( handleSessionDisconnect( ServiceIPCSession* ) ) );

        m_Sessions[i]->close();

        delete m_Sessions[i];

    }

    m_Sessions.clear();

}

/*!

 Handle a new connection, this slot is connected to the socket's newConnection() signal

 @return void

 */

void ServiceFwIPCServerLocalSocket::handleNewConnection()

{

    // Create a new session to host the client

    //

    QLocalSocket* newSocket = m_Listener->nextPendingConnection();

    ServiceIPCSession* session = new LocalSocketSession(newSocket, Observer());

    if (session) {

        session->setParent(this);

        QObject::connect(session, SIGNAL(disconnected( ServiceIPCSession* ) ),

        this, SLOT( handleSessionDisconnect( ServiceIPCSession* ) ) );

        m_Sessions.append(session);

        stopExitTimer(); 

        ClientInfo *client = new ClientInfo();

        client->setSessionId(m_sessionIdTable->allocate());

        session->setClientInfo(client);

    }

}

/*!

 Handle the end of a session

 @param aSession session to be disconnected

 */

void ServiceFwIPCServerLocalSocket::handleSessionDisconnect(ServiceIPCSession* aSession)

{

    int c = m_Sessions.removeAll(aSession);

    if ((m_Sessions.count() == 0) && (!m_isKeepServer)) {

        startExitTimer(); 

    }  

    qDebug() << "Session cleaned up: " << c;

}

/*!

 Config IPC server Life time \n

 Start the shutdown timer if it is the last session and aKeepServer is trues.

 @param aKeepLife to keep or disconnect IPC server when all clients are shutdown. 

*/

void ServiceFwIPCServerLocalSocket::configIpcServerLifetime(bool aKeepServer)

{

    if ((m_isKeepServer) && (m_Sessions.count() == 0) && (!aKeepServer)) {

        startExitTimer(); 

    }  

    m_isKeepServer = aKeepServer;

}

}

// END OF FILE