forked from qt-creator/qt-creator
ab574ba88d
The appropriate client handles the debugging based on the service available at the server side. Change-Id: I46b66036f700fc7e45e8b38cef7f1ce1445b1122 Reviewed-on: http://codereview.qt.nokia.com/2497 Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com> Reviewed-by: Kai Koehne <kai.koehne@nokia.com>
451 lines
16 KiB
C++
451 lines
16 KiB
C++
/**************************************************************************
|
|
**
|
|
** This file is part of Qt Creator
|
|
**
|
|
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
|
|
**
|
|
** Contact: Nokia Corporation (info@qt.nokia.com)
|
|
**
|
|
**
|
|
** GNU Lesser General Public License Usage
|
|
**
|
|
** 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, Nokia gives you certain additional
|
|
** rights. These rights are described in the Nokia Qt LGPL Exception
|
|
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
|
**
|
|
** Other Usage
|
|
**
|
|
** Alternatively, this file may be used in accordance with the terms and
|
|
** conditions contained in a signed written agreement between you and Nokia.
|
|
**
|
|
** If you have questions regarding the use of this file, please contact
|
|
** Nokia at info@qt.nokia.com.
|
|
**
|
|
**************************************************************************/
|
|
|
|
#include "codaruncontrol.h"
|
|
|
|
#include "s60deployconfiguration.h"
|
|
#include "s60devicerunconfiguration.h"
|
|
|
|
#include "codadevice.h"
|
|
#include "codamessage.h"
|
|
|
|
#include "qt4buildconfiguration.h"
|
|
#include "qt4symbiantarget.h"
|
|
#include "qt4target.h"
|
|
#include "symbiandevicemanager.h"
|
|
|
|
#include <coreplugin/icore.h>
|
|
#include <utils/qtcassert.h>
|
|
#include <projectexplorer/projectexplorerconstants.h>
|
|
|
|
#include <symbianutils/symbiandevicemanager.h>
|
|
|
|
#include <QtCore/QDir>
|
|
#include <QtCore/QFileInfo>
|
|
#include <QtCore/QScopedPointer>
|
|
#include <QtCore/QTimer>
|
|
|
|
#include <QtGui/QMessageBox>
|
|
#include <QtGui/QMainWindow>
|
|
|
|
#include <QtNetwork/QTcpSocket>
|
|
|
|
using namespace ProjectExplorer;
|
|
using namespace Qt4ProjectManager;
|
|
using namespace Qt4ProjectManager::Internal;
|
|
using namespace Coda;
|
|
|
|
enum { debug = 0 };
|
|
|
|
CodaRunControl::CodaRunControl(RunConfiguration *runConfiguration, const QString &mode) :
|
|
S60RunControlBase(runConfiguration, mode),
|
|
m_port(0),
|
|
m_state(StateUninit),
|
|
m_codaFlags(0),
|
|
m_stopAfterConnect(false)
|
|
{
|
|
const S60DeviceRunConfiguration *s60runConfig = qobject_cast<S60DeviceRunConfiguration *>(runConfiguration);
|
|
QTC_ASSERT(s60runConfig, return);
|
|
const S60DeployConfiguration *activeDeployConf = qobject_cast<S60DeployConfiguration *>(s60runConfig->target()->activeDeployConfiguration());
|
|
QTC_ASSERT(activeDeployConf, return);
|
|
|
|
S60DeployConfiguration::CommunicationChannel channel = activeDeployConf->communicationChannel();
|
|
if (channel == S60DeployConfiguration::CommunicationCodaTcpConnection) {
|
|
m_address = activeDeployConf->deviceAddress();
|
|
m_port = activeDeployConf->devicePort().toInt();
|
|
} else if (channel == S60DeployConfiguration::CommunicationCodaSerialConnection) {
|
|
m_serialPort = activeDeployConf->serialPortName();
|
|
} else {
|
|
QTC_ASSERT(false, return);
|
|
}
|
|
}
|
|
|
|
CodaRunControl::~CodaRunControl()
|
|
{
|
|
}
|
|
|
|
bool CodaRunControl::doStart()
|
|
{
|
|
if (m_address.isEmpty() && m_serialPort.isEmpty()) {
|
|
cancelProgress();
|
|
QString msg = tr("No device is connected. Please connect a device and try again.\n");
|
|
appendMessage(msg, Utils::NormalMessageFormat);
|
|
return false;
|
|
}
|
|
appendMessage(tr("Executable file: %1\n").arg(msgListFile(executableFileName())),
|
|
Utils::NormalMessageFormat);
|
|
return true;
|
|
}
|
|
|
|
bool CodaRunControl::isRunning() const
|
|
{
|
|
return m_state >= StateConnecting;
|
|
}
|
|
|
|
QIcon CodaRunControl::icon() const
|
|
{
|
|
return QIcon(ProjectExplorer::Constants::ICON_DEBUG_SMALL);
|
|
}
|
|
|
|
bool CodaRunControl::setupLauncher()
|
|
{
|
|
QTC_ASSERT(!m_codaDevice, return false);
|
|
|
|
if (m_serialPort.length()) {
|
|
// We get the port from SymbianDeviceManager
|
|
appendMessage(tr("Connecting to '%1'...\n").arg(m_serialPort), Utils::NormalMessageFormat);
|
|
m_codaDevice = SymbianUtils::SymbianDeviceManager::instance()->getCodaDevice(m_serialPort);
|
|
if (m_codaDevice.isNull()) {
|
|
appendMessage(tr("Unable to create CODA connection. Please try again.\n"), Utils::ErrorMessageFormat);
|
|
return false;
|
|
}
|
|
if (!m_codaDevice->device()->isOpen()) {
|
|
appendMessage(tr("Could not open serial device: %1\n").arg(m_codaDevice->device()->errorString()), Utils::ErrorMessageFormat);
|
|
return false;
|
|
}
|
|
connect(SymbianUtils::SymbianDeviceManager::instance(), SIGNAL(deviceRemoved(const SymbianUtils::SymbianDevice)),
|
|
this, SLOT(deviceRemoved(SymbianUtils::SymbianDevice)));
|
|
m_state = StateConnecting;
|
|
m_codaDevice->sendSerialPing(false);
|
|
} else {
|
|
// For TCP we don't use device manager, we just set it up directly
|
|
m_codaDevice = QSharedPointer<Coda::CodaDevice>(new Coda::CodaDevice, &QObject::deleteLater); // finishRunControl, which deletes m_codaDevice, can get called from within a coda callback, so need to use deleteLater
|
|
const QSharedPointer<QTcpSocket> codaSocket(new QTcpSocket);
|
|
m_codaDevice->setDevice(codaSocket);
|
|
codaSocket->connectToHost(m_address, m_port);
|
|
m_state = StateConnecting;
|
|
appendMessage(tr("Connecting to %1:%2...\n").arg(m_address).arg(m_port), Utils::NormalMessageFormat);
|
|
}
|
|
|
|
connect(m_codaDevice.data(), SIGNAL(error(QString)), this, SLOT(slotError(QString)));
|
|
connect(m_codaDevice.data(), SIGNAL(logMessage(QString)), this, SLOT(slotCodaLogMessage(QString)));
|
|
connect(m_codaDevice.data(), SIGNAL(codaEvent(Coda::CodaEvent)), this, SLOT(slotCodaEvent(Coda::CodaEvent)));
|
|
|
|
QTimer::singleShot(5000, this, SLOT(checkForTimeout()));
|
|
if (debug)
|
|
m_codaDevice->setVerbose(debug);
|
|
return true;
|
|
}
|
|
|
|
void CodaRunControl::doStop()
|
|
{
|
|
switch (m_state) {
|
|
case StateUninit:
|
|
case StateConnecting:
|
|
case StateConnected:
|
|
finishRunControl();
|
|
break;
|
|
case StateProcessRunning:
|
|
QTC_ASSERT(!m_runningProcessId.isEmpty(), return);
|
|
m_codaDevice->sendRunControlTerminateCommand(CodaCallback(),
|
|
m_runningProcessId.toAscii());
|
|
break;
|
|
default:
|
|
if (debug)
|
|
qDebug() << "Unrecognised state while performing shutdown" << m_state;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CodaRunControl::slotError(const QString &error)
|
|
{
|
|
appendMessage(tr("Error: %1\n").arg(error), Utils::ErrorMessageFormat);
|
|
finishRunControl();
|
|
}
|
|
|
|
void CodaRunControl::slotCodaLogMessage(const QString &log)
|
|
{
|
|
if (debug > 1)
|
|
qDebug("CODA log: %s", qPrintable(log.size()>200?log.left(200).append(QLatin1String(" ...")): log));
|
|
}
|
|
|
|
void CodaRunControl::slotCodaEvent(const CodaEvent &event)
|
|
{
|
|
if (debug)
|
|
qDebug() << "CODA event:" << "Type:" << event.type() << "Message:" << event.toString();
|
|
|
|
switch (event.type()) {
|
|
case CodaEvent::LocatorHello:
|
|
handleConnected(event);
|
|
break;
|
|
case CodaEvent::RunControlContextRemoved:
|
|
handleContextRemoved(event);
|
|
break;
|
|
case CodaEvent::RunControlContextAdded:
|
|
m_state = StateProcessRunning;
|
|
reportLaunchFinished();
|
|
handleContextAdded(event);
|
|
break;
|
|
case CodaEvent::RunControlSuspended:
|
|
handleContextSuspended(event);
|
|
break;
|
|
case CodaEvent::RunControlModuleLoadSuspended:
|
|
handleModuleLoadSuspended(event);
|
|
break;
|
|
case CodaEvent::LoggingWriteEvent:
|
|
handleLogging(event);
|
|
break;
|
|
case CodaEvent::ProcessExitedEvent:
|
|
handleProcessExited(event);
|
|
break;
|
|
default:
|
|
if (debug)
|
|
qDebug() << "CODA event not handled" << event.type();
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CodaRunControl::initCommunication()
|
|
{
|
|
if (m_codaFlags & OptionsUseDebugSession)
|
|
m_codaDevice->sendDebugSessionControlSessionStartCommand(CodaCallback(this, &CodaRunControl::handleDebugSessionStarted));
|
|
else
|
|
m_codaDevice->sendLoggingAddListenerCommand(CodaCallback(this, &CodaRunControl::handleAddListener));
|
|
}
|
|
|
|
void CodaRunControl::handleConnected(const CodaEvent &event)
|
|
{
|
|
if (m_state >= StateConnected)
|
|
return;
|
|
m_state = StateConnected;
|
|
appendMessage(tr("Connected.\n"), Utils::NormalMessageFormat);
|
|
setProgress(maxProgress()*0.80);
|
|
|
|
m_codaServices = static_cast<const CodaLocatorHelloEvent &>(event).services();
|
|
if (m_codaServices.contains(QLatin1String("DebugSessionControl")))
|
|
m_codaFlags |= OptionsUseDebugSession;
|
|
|
|
emit connected();
|
|
if (!m_stopAfterConnect)
|
|
initCommunication();
|
|
}
|
|
|
|
void CodaRunControl::handleContextRemoved(const CodaEvent &event)
|
|
{
|
|
const QVector<QByteArray> removedItems
|
|
= static_cast<const CodaRunControlContextRemovedEvent &>(event).ids();
|
|
if (!m_runningProcessId.isEmpty()
|
|
&& removedItems.contains(m_runningProcessId.toAscii())) {
|
|
appendMessage(tr("Process has finished.\n"), Utils::NormalMessageFormat);
|
|
if (m_codaFlags & OptionsUseDebugSession)
|
|
m_codaDevice->sendDebugSessionControlSessionEndCommand(CodaCallback(this, &CodaRunControl::handleDebugSessionEnded));
|
|
else
|
|
finishRunControl();
|
|
}
|
|
}
|
|
|
|
void CodaRunControl::handleContextAdded(const CodaEvent &event)
|
|
{
|
|
typedef CodaRunControlContextAddedEvent CodaAddedEvent;
|
|
|
|
const CodaAddedEvent &me = static_cast<const CodaAddedEvent &>(event);
|
|
foreach (const RunControlContext &context, me.contexts()) {
|
|
if (context.parentId == "root") //is the created context a process
|
|
m_runningProcessId = QLatin1String(context.id);
|
|
}
|
|
}
|
|
|
|
void CodaRunControl::handleContextSuspended(const CodaEvent &event)
|
|
{
|
|
typedef CodaRunControlContextSuspendedEvent CodaSuspendEvent;
|
|
|
|
const CodaSuspendEvent &me = static_cast<const CodaSuspendEvent &>(event);
|
|
|
|
switch (me.reason()) {
|
|
case CodaSuspendEvent::Other:
|
|
case CodaSuspendEvent::Crash:
|
|
appendMessage(tr("Thread has crashed: %1\n").arg(QString::fromLatin1(me.message())), Utils::ErrorMessageFormat);
|
|
|
|
if (me.reason() == CodaSuspendEvent::Crash)
|
|
stop();
|
|
else
|
|
m_codaDevice->sendRunControlResumeCommand(CodaCallback(), me.id()); //TODO: Should I resume automatically
|
|
break;
|
|
default:
|
|
if (debug)
|
|
qDebug() << "Context suspend not handled:" << "Reason:" << me.reason() << "Message:" << me.message();
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CodaRunControl::handleModuleLoadSuspended(const CodaEvent &event)
|
|
{
|
|
// Debug mode start: Continue:
|
|
typedef CodaRunControlModuleLoadContextSuspendedEvent CodaModuleLoadSuspendedEvent;
|
|
|
|
const CodaModuleLoadSuspendedEvent &me = static_cast<const CodaModuleLoadSuspendedEvent &>(event);
|
|
if (me.info().requireResume)
|
|
m_codaDevice->sendRunControlResumeCommand(CodaCallback(), me.id());
|
|
}
|
|
|
|
void CodaRunControl::handleLogging(const CodaEvent &event)
|
|
{
|
|
const CodaLoggingWriteEvent &me = static_cast<const CodaLoggingWriteEvent &>(event);
|
|
appendMessage(QString::fromLatin1(QByteArray(me.message() + '\n')), Utils::StdOutFormat);
|
|
}
|
|
|
|
void CodaRunControl::handleProcessExited(const CodaEvent &event)
|
|
{
|
|
Q_UNUSED(event)
|
|
appendMessage(tr("Process has finished.\n"), Utils::NormalMessageFormat);
|
|
m_codaDevice->sendDebugSessionControlSessionEndCommand(CodaCallback(this, &CodaRunControl::handleDebugSessionEnded));
|
|
}
|
|
|
|
void CodaRunControl::handleAddListener(const CodaCommandResult &result)
|
|
{
|
|
Q_UNUSED(result)
|
|
m_codaDevice->sendSymbianOsDataFindProcessesCommand(CodaCallback(this, &CodaRunControl::handleFindProcesses),
|
|
QByteArray(),
|
|
QByteArray::number(executableUid(), 16));
|
|
}
|
|
|
|
void CodaRunControl::handleDebugSessionStarted(const CodaCommandResult &result)
|
|
{
|
|
Q_UNUSED(result)
|
|
m_state = StateDebugSessionStarted;
|
|
m_codaDevice->sendLoggingAddListenerCommand(CodaCallback(this, &CodaRunControl::handleAddListener));
|
|
}
|
|
|
|
void CodaRunControl::handleDebugSessionEnded(const CodaCommandResult &result)
|
|
{
|
|
Q_UNUSED(result)
|
|
m_state = StateDebugSessionEnded;
|
|
finishRunControl();
|
|
}
|
|
|
|
void CodaRunControl::handleFindProcesses(const CodaCommandResult &result)
|
|
{
|
|
if (result.values.size() && result.values.at(0).type() == Json::JsonValue::Array && result.values.at(0).children().count()) {
|
|
//there are processes running. Cannot run mine
|
|
appendMessage(tr("The process is already running on the device. Please first close it.\n"), Utils::ErrorMessageFormat);
|
|
finishRunControl();
|
|
} else {
|
|
setProgress(maxProgress()*0.90);
|
|
m_codaDevice->sendProcessStartCommand(CodaCallback(this, &CodaRunControl::handleCreateProcess),
|
|
executableName(),
|
|
executableUid(),
|
|
commandLineArguments().split(' '),
|
|
QString(),
|
|
!(m_codaFlags & OptionsUseDebugSession));
|
|
appendMessage(tr("Launching: %1\n").arg(executableName()), Utils::NormalMessageFormat);
|
|
}
|
|
}
|
|
|
|
void CodaRunControl::handleCreateProcess(const CodaCommandResult &result)
|
|
{
|
|
const bool ok = result.type == CodaCommandResult::SuccessReply;
|
|
bool processCreated = false;
|
|
if (ok) {
|
|
if (m_codaFlags & OptionsUseDebugSession) {
|
|
if (result.values.size()) {
|
|
Json::JsonValue id = result.values.at(0).findChild("ID");
|
|
if (id.isValid()) {
|
|
m_state = StateProcessRunning;
|
|
m_runningProcessId = id.data();
|
|
processCreated = true;
|
|
}
|
|
}
|
|
} else // If no DebugSession is present the process will already be created by now
|
|
processCreated = true;
|
|
}
|
|
if (processCreated) {
|
|
setProgress(maxProgress());
|
|
appendMessage(tr("Launched.\n"), Utils::NormalMessageFormat);
|
|
} else {
|
|
appendMessage(tr("Launch failed: %1\n").arg(result.toString()), Utils::ErrorMessageFormat);
|
|
finishRunControl();
|
|
}
|
|
}
|
|
|
|
void CodaRunControl::finishRunControl()
|
|
{
|
|
m_runningProcessId.clear();
|
|
if (m_codaDevice) {
|
|
disconnect(m_codaDevice.data(), 0, this, 0);
|
|
SymbianUtils::SymbianDeviceManager::instance()->releaseCodaDevice(m_codaDevice);
|
|
}
|
|
m_state = StateUninit;
|
|
emit finished();
|
|
}
|
|
|
|
QMessageBox *CodaRunControl::createCodaWaitingMessageBox(QWidget *parent)
|
|
{
|
|
const QString title = tr("Waiting for CODA");
|
|
const QString text = tr("Qt Creator is waiting for the CODA application to connect.<br>"
|
|
"Please make sure the application is running on "
|
|
"your mobile phone and the right IP address and/or port are "
|
|
"configured in the project settings.");
|
|
QMessageBox *mb = new QMessageBox(QMessageBox::Information, title, text, QMessageBox::Cancel, parent);
|
|
return mb;
|
|
}
|
|
|
|
void CodaRunControl::checkForTimeout()
|
|
{
|
|
if (m_state != StateConnecting)
|
|
return;
|
|
|
|
QMessageBox *mb = createCodaWaitingMessageBox(Core::ICore::instance()->mainWindow());
|
|
connect(this, SIGNAL(finished()), mb, SLOT(close()));
|
|
connect(mb, SIGNAL(finished(int)), this, SLOT(cancelConnection()));
|
|
mb->open();
|
|
}
|
|
|
|
void CodaRunControl::cancelConnection()
|
|
{
|
|
if (m_state != StateConnecting)
|
|
return;
|
|
|
|
stop();
|
|
appendMessage(tr("Canceled.\n"), Utils::ErrorMessageFormat);
|
|
emit finished();
|
|
}
|
|
|
|
void CodaRunControl::deviceRemoved(const SymbianUtils::SymbianDevice &device)
|
|
{
|
|
if (m_codaDevice && device.portName() == m_serialPort) {
|
|
QString msg = tr("The device '%1' has been disconnected.\n").arg(device.friendlyName());
|
|
appendMessage(msg, Utils::ErrorMessageFormat);
|
|
finishRunControl();
|
|
}
|
|
}
|
|
|
|
void CodaRunControl::connect()
|
|
{
|
|
m_stopAfterConnect = true;
|
|
start();
|
|
}
|
|
|
|
void CodaRunControl::run()
|
|
{
|
|
initCommunication();
|
|
}
|