qtcreator-tizen-plugin/sdbconnector.cpp

/****************************************************************************
**
** Copyright (C) 2013 Jarek Pelczar <jpelczar@gmail.com>
** Copyright (C) 2014 Tomasz Olszak <olszak.tomasz@gmail.com>
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.  For licensing terms and
** conditions see http://qt.digia.com/licensing.  For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights.  These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/
#include "tizendebug.h"
#include "sdbconnector.h"
#include "sdbpacketutils.h"
#include <QHostAddress>
#include <QTcpSocket>
#include <QRegularExpression>
#include <QDebug>
#include <QFileInfo>
#include <coreplugin/id.h>

const int DefaultServerPort=26099;

namespace Tizen {
namespace Internal {

SdbConnector::SdbConnector(QObject *parent) :
    QObject(parent),
    m_socket(0),
    m_sdbProcess(0),
    m_state(SdbDisconnected),
    m_sdbPort(DefaultServerPort),
    m_startWait(0),
    m_retry(0)
{
    qCDebug(QTC_TIZEN_SDBCONNECTOR);
    m_startWait = new QTimer(this);
    connect(m_startWait, SIGNAL(timeout()), SLOT(_q_startWaitTimeout()));
    m_startWait->setInterval(1000);
    m_startWait->setSingleShot(true);

    m_commandResponseTimer = new QTimer(this);
    connect(m_commandResponseTimer, SIGNAL(timeout()), SLOT(_q_commandTimeout()));
    m_commandResponseTimer->setSingleShot(true);
    m_commandResponseTimer->setInterval(500);
}

SdbConnector::~SdbConnector()
{
    qCDebug(QTC_TIZEN_SDBCONNECTOR);
}

int SdbConnector::serverPort() const
{
    return m_sdbPort;
}

QString SdbConnector::sdbPath() const
{
    return m_sdbPath;
}

void SdbConnector::setSdbPath(const QString& path)
{
    m_sdbPath = path;
}

SdbState SdbConnector::state() const
{
    return m_state;
}

void SdbConnector::startConnector()
{
    qCDebug(QTC_TIZEN_SDBCONNECTOR) << "State:" << m_state;
    if (m_sdbPath.isEmpty()) {
        qCWarning(QTC_TIZEN_SDBCONNECTOR) << "SDB path empty";
        return;
    }

    if(!QFile::exists(m_sdbPath)) {
        qCWarning(QTC_TIZEN_SDBCONNECTOR) << "SDB executable not found in " << m_sdbPath;
        return;
    }

    if (QProcess::execute(m_sdbPath, QStringList() << QStringLiteral("kill-server"))) {
        qCWarning(QTC_TIZEN_SDBCONNECTOR) << "Error encountered while running " << m_sdbPath << " kill-server";
    }

    if(m_state == SdbDisconnected || m_state == SdbError) {
        startConnecting();
    } else if(m_state == SdbDisconnecting) {
        m_socket->disconnect(this);
        m_socket->deleteLater();
        m_socket = NULL;
        m_retry = 0;
        startConnecting();
    }
}

void SdbConnector::stopConnector()
{
    qCDebug(QTC_TIZEN_SDBCONNECTOR) << "State:" << m_state;

    m_commandResponseTimer->stop();

    if(m_state == SdbConnecting) {
        m_socket->disconnect(this);
        m_socket->deleteLater();
        m_socket = NULL;
        m_retry = 0;
        m_state = SdbDisconnected;
        emit stateChanged(SdbDisconnected);
    } else if(m_state == SdbConnected) {
        m_socket->disconnectFromHost();
    } else if(m_state == SdbDisconnecting) {

    } else if(m_state == SdbRestarting) {
        m_startWait->stop();
        m_retry = 0;
    }
}

void SdbConnector::startConnecting()
{
    qCDebug(QTC_TIZEN_SDBCONNECTOR) << "Port:" << m_sdbPort;

    if(m_state != SdbConnecting) {
        m_state = SdbConnecting;
        emit stateChanged(m_state);
    }

    m_socket = new QTcpSocket(this);
    connect(m_socket, SIGNAL(connected()), SLOT(_q_tcpConnected()));
    connect(m_socket, SIGNAL(readyRead()), SLOT(_q_readyRead()));
    connect(m_socket, SIGNAL(disconnected()), SLOT(_q_tcpDisconnected()));
    connect(m_socket, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(_q_socketError(QAbstractSocket::SocketError)));

    m_socket->connectToHost(QHostAddress::LocalHost, m_sdbPort);
    m_commandResponseTimer->start(1000);
}

void SdbConnector::_q_tcpConnected()
{
    qCDebug(QTC_TIZEN_SDBCONNECTOR) << "Local port:" << m_socket->localPort();

    m_commandResponseTimer->stop();
    m_state = SdbConnected;
    m_protoState = WaitingForDeviceListResp;
    m_socket->write(SdbPacketUtils::makeRequest(QByteArray("host:track-devices")));
    m_commandResponseTimer->start();

    emit stateChanged(SdbConnected);
}

void SdbConnector::_q_readyRead()
{
    qCDebug(QTC_TIZEN_SDBCONNECTOR) << "m_socket->atEnd():" << m_socket->atEnd() << "m_protoState:" << m_protoState ;
    while(!m_socket->atEnd()) {
        if(m_protoState == WaitingForDeviceListResp) {
            SdbResponse resp;
            if(SdbPacketUtils::parseResponse(m_socket, SdbPacketUtils::DontReadDiagnosticString, resp)) {
                m_commandResponseTimer->stop();
                m_protoState = WaitingForDeviceListHeader;
                if(!resp.okay) {
                    qCDebug(QTC_TIZEN_SDBCONNECTOR) << "[SdbConnector] Failed to query device list";
                }
            }
        }

        if(m_protoState == WaitingForDeviceListHeader) {
            qCDebug(QTC_TIZEN_SDBCONNECTOR) << "m_socket->bytesAvailable():" << m_socket->bytesAvailable();
            if(m_socket->bytesAvailable() >= 4) {
                char hdr[5];
                if(m_socket->read(hdr, 4) != 4)
                    return;
                hdr[4] = 0;
                sscanf(hdr, "%X", &m_packetLength);
                qCDebug(QTC_TIZEN_SDBCONNECTOR) << "m_packetLength:" << m_packetLength;
                m_protoState = WaitingForDeviceListData;
            } else {
                return;
            }
        }

        if(m_protoState == WaitingForDeviceListData) {
            if(m_socket->bytesAvailable() >= m_packetLength) {
                SdbDeviceList deviceList;
                m_protoState = WaitingForDeviceListHeader;
                if (m_packetLength > 0) {
                    QByteArray string = m_socket->read(m_packetLength);
                    QList<QByteArray> lines = string.split('\n');

                    qCDebug(QTC_TIZEN_SDBCONNECTOR) << "received list update" << string;

                    if(!lines.empty())
                        deviceList.reserve(lines.size());

                    foreach(const QByteArray& line, lines) {
                        QList<QByteArray> params = line.split('\t');

                        if(params.length() == 3) {
                            SdbDevice device;
                            device.serialNumber = params.at(0).trimmed();
                            device.name = QString::fromUtf8(params.at(2));
                            QByteArray deviceState = params.at(1).trimmed();
                            if(deviceState == "offline") {
                                device.state = SdbDevice::Offline;
                            } else if(deviceState == "device") {
                                device.state = SdbDevice::Device;
                            } else {
                                device.state = SdbDevice::Unknown;
                            }
                            deviceList.append(device);
                        }
                    }
                }
                emit deviceListUpdated(deviceList);
            } else
                return;
        }
    }
}

void SdbConnector::_q_tcpDisconnected()
{
    qCDebug(QTC_TIZEN_SDBCONNECTOR);

    m_commandResponseTimer->stop();
    m_socket->disconnect(this);
    m_socket->deleteLater();
    m_socket = NULL;
    m_retry = 0;

    m_state = SdbDisconnected;

    emit stateChanged(SdbDisconnected);
}

void SdbConnector::_q_socketError(QAbstractSocket::SocketError error)
{
    Q_UNUSED(error);
    qCDebug(QTC_TIZEN_SDBCONNECTOR) << "Error =" << error << "and error string =" << m_socket->errorString();

    m_commandResponseTimer->stop();

    if(m_state == SdbConnecting) {
        m_socket->disconnect(this);
        m_socket->deleteLater();
        m_socket = NULL;

        if (m_retry > 0) {
            m_state = SdbError;
            m_retry = 0;

            emit stateChanged(SdbError);
            return;
        }

        m_state = SdbRestarting;

        m_sdbProcess = new QProcess(this);
        connect(m_sdbProcess, SIGNAL(finished(int,QProcess::ExitStatus)), SLOT(_q_finished(int,QProcess::ExitStatus)));

        m_sdbProcess->start(m_sdbPath, QStringList() << QLatin1String("start-server"));

        emit stateChanged(SdbRestarting);
    } else if(m_state == SdbConnected) {
        m_socket->disconnect(this);
        m_socket->deleteLater();
        m_socket = NULL;
        m_state = SdbDisconnected;
        m_retry = 0;

        emit stateChanged(SdbDisconnected);
    }
}

void SdbConnector::_q_finished(int exitCode, QProcess::ExitStatus exitStatus)
{

    qCDebug(QTC_TIZEN_SDBCONNECTOR) << "Exit code =" << exitCode << "Status =" << exitStatus <<
                "Error =" << m_sdbProcess->errorString();
    QString output = QString::fromLatin1(m_sdbProcess->readAll());
    QRegularExpression rePortLine(QStringLiteral("daemon not running. starting it now on port \\d*"));
    QRegularExpression rePort(QStringLiteral("\\d+"));
    output = rePortLine.match(output).captured();
    output = rePort.match(output).captured();

    if (output.isEmpty()) {
        qCDebug(QTC_TIZEN_SDBCONNECTOR) << "Can't determine the sdb server port";
        m_sdbPort = DefaultServerPort;
    } else
        m_sdbPort = output.toInt();

    m_sdbProcess->deleteLater();
    m_sdbProcess = NULL;

    if(exitStatus == QProcess::NormalExit && exitCode == 0) {
        m_startWait->start();
    } else {
        m_state = SdbError;
        m_retry = 0;
        emit stateChanged(SdbError);
    }
}

void SdbConnector::_q_startWaitTimeout()
{
    qCDebug(QTC_TIZEN_SDBCONNECTOR);
    ++m_retry;
    startConnecting();
}

QTcpSocket * SdbConnector::createChannel(QObject *parent)
{
    if(m_state != SdbConnected)
        return NULL;

    QTcpSocket * socket = new QTcpSocket(parent);
    socket->connectToHost(QHostAddress::LocalHost, m_sdbPort);
    return socket;
}

void SdbConnector::_q_commandTimeout()
{
    qCDebug(QTC_TIZEN_SDBCONNECTOR) << "Command timeout in state" << m_state;

    if(m_state == SdbConnecting) {
        m_socket->disconnect(this);
        m_socket->deleteLater();
        m_socket = NULL;

        QFileInfo fi(m_sdbPath);
        if( m_retry > 0) {
            m_state = SdbError;
            m_retry = 0;

            emit stateChanged(SdbError);
            return;
        }

        qCDebug(QTC_TIZEN_SDBCONNECTOR) << "Try starting SDB";

        m_state = SdbRestarting;

        m_sdbProcess = new QProcess(this);
        connect(m_sdbProcess, SIGNAL(finished(int,QProcess::ExitStatus)), SLOT(_q_finished(int,QProcess::ExitStatus)));

        m_sdbProcess->start(m_sdbPath, QStringList() << QLatin1String("start-server"));

        emit stateChanged(SdbRestarting);
    } else if(m_state == SdbConnected) {
        m_socket->disconnect(this);
        m_socket->deleteLater();
        m_socket = NULL;
        m_state = SdbError;
        m_retry = 0;
        emit stateChanged(SdbError);
    }
}

} //namespace Internal
} //namespace Tizen