void qt_connectToServer()
{
if (!qt_initialized)
return;
// Determine to which server we should connect
QString server = qt_localServerName;
if (!qt_optionWidget.isEmpty())
server = qt_optionWidget;
// Check if we are already connected
if (qt_socket.serverName() == server)
return;
// Disconnect
if (qt_socket.state() == QLocalSocket::ConnectedState)
{
qt_socket.disconnectFromServer();
qt_socket.waitForDisconnected(1000);
}
// Connect to server, or local server if not available.
qt_socket.connectToServer(server);
if (!qt_socket.waitForConnected(3000))
while (qt_socket.state() != QLocalSocket::ConnectedState)
qt_socket.connectToServer(qt_localServerName);
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QLocalSocket localSocket;
localSocket.connectToServer("bloggerQml", QIODevice::ReadOnly);
if(localSocket.waitForConnected(5000))
{
// there is already an application running
qDebug() << "Application is already running.";
QMessageBox::information(0, QObject::tr("Erro"), QObject::tr("A aplicação já está a ser executada."), QMessageBox::Ok);
return 0;
}
QLocalServer localServer;
localServer.listen("bloggerQml");
BloggerLoader bloggerloader;
bloggerloader.loadBlogsFromFile();
BloggerProxyModel model;
model.setSourceModel(bloggerloader.model());
Helper helper;
QtQuick2ApplicationViewer viewer;
viewer.rootContext()->setContextProperty("blogsModel", &model);
viewer.rootContext()->setContextProperty("helper", &helper);
viewer.rootContext()->setContextProperty("bloggerloader", &bloggerloader);
viewer.setMainQmlFile(QStringLiteral("qml/blogerQML/main.qml"));
viewer.showExpanded();
int res = app.exec();
bloggerloader.saveDB();
return res;
}
QCopServerPrivate::QCopServerPrivate()
: QCopLocalServer()
{
bool ok;
#ifndef QT_NO_QCOP_LOCAL_SOCKET
QString path = QCopThreadData::socketPath();
ok = listen(path);
#ifdef Q_OS_UNIX
if (!ok) {
// There may be another qcop server running, or the path
// was simply left in the filesystem after a server crash.
// QLocalServer does not clean up such paths. We try to
// connect to the existing qcop server, and if that fails
// we remove the path and try again.
QLocalSocket *socket = new QLocalSocket();
socket->connectToServer(path);
if (!socket->waitForConnected()) {
delete socket;
QFile::remove(QDir::tempPath() + QChar('/') + path);
ok = listen(path);
} else {
delete socket;
}
}
#endif
#else
ok = listen(QHostAddress::LocalHost, QCopThreadData::listenPort());
QString path = QString::number(QCopThreadData::listenPort());
#endif
if (!ok)
qWarning() << "Could not listen for qcop connections on"
<< path << "; another qcop server may already be running.";
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
//a.removeLibraryPath(a.libraryPaths().first());
qRegisterMetaType<Song>("Song");
qRegisterMetaTypeStreamOperators<Song>("Song");
MainWindow w;
QStringList args = a.arguments();
QLocalSocket socket;
socket.connectToServer("iniTunes");
QTextStream stream(&socket);
if(socket.waitForConnected(3000))
{
stream <<QString::number(PLAY)<<endl;
stream << args.at(1) <<endl;
socket.waitForBytesWritten();
exit(0);
}
else
{
qDebug()<<"Launch";
w.show();
w.createRemote();
if(args.count()==2)
{
qDebug()<<"Open";
w.open(args.at(1));
}
}
return a.exec();
}
bool KNSingletonApplication::sendMessages(const QString &uniqueKey,
const QStringList &messages)
{
//Create sender client.
QLocalSocket client;
//Link to the server which is listening to the unique key.
client.connectToServer(uniqueKey, QIODevice::WriteOnly);
//If connecting failed, return false.
if(!client.waitForConnected(TimeoutLimit))
{
qDebug("Cannot connect to the local server.");
//Disconnect from the server.
client.disconnectFromServer();
return false;
}
//Generate the message data.
QByteArray messageData;
QDataStream dataWriter(&messageData, QIODevice::WriteOnly);
dataWriter << messages;
//Send the data to local server.
client.write(messageData);
//Check sending status.
if(!client.waitForBytesWritten(TimeoutLimit))
{
qDebug("Send arguments failed.");
client.disconnectFromServer();
return false;
}
//Send the arguments success.
client.disconnectFromServer();
return true;
}
CommandClient *UnixSocketCommandClient::newClient(const QStringList &args, bool reverse)
{
QVariantMap options;
options["name"] = args.value(1);
QLocalSocket *socket = new QLocalSocket();
UnixSocketCommandClient *client = new UnixSocketCommandClient;
client->setSocket(socket);
client->initialize();
connect(socket, &QLocalSocket::connected, [client, options, reverse]() {
if (reverse)
qInfo().noquote() << QString("unixsocket: Connected to %1").arg(options["name"].toString());
emit client->connected();
});
connect(socket, &QLocalSocket::disconnected, [client, options, reverse]() {
if (reverse)
qInfo().noquote() << QString("unixsocket: Disconnected from %1").arg(options["name"].toString());
emit client->disconnected();
});
connect(socket, static_cast<void(QLocalSocket::*)(QLocalSocket::LocalSocketError)>(&QLocalSocket::error), [options, reverse](QLocalSocket::LocalSocketError e) {
Q_UNUSED(e);
if (reverse)
qDebug().noquote() << QString("unixsocket: Failed to connect to %1").arg(options["name"].toString());
});
QTimer::singleShot(0, [socket, options]() {
socket->connectToServer(options["name"].toString());
});
return client;
}
bool QtLocalPeer::sendMessage(const QString &message, int timeout)
{
if (!isClient())
return false;
QLocalSocket socket;
bool connOk = false;
for (int i = 0; i < 2; i++) {
// Try twice, in case the other instance is just starting up
socket.connectToServer(socketName);
connOk = socket.waitForConnected(timeout/2);
if (connOk || i)
break;
int ms = 250;
#if defined(Q_OS_WIN)
Sleep(DWORD(ms));
#else
struct timespec ts = { ms / 1000, (ms % 1000) * 1000 * 1000 };
nanosleep(&ts, NULL);
#endif
}
if (!connOk)
return false;
QByteArray uMsg(message.toUtf8());
QDataStream ds(&socket);
ds.writeBytes(uMsg.constData(), uMsg.size());
bool res = socket.waitForBytesWritten(timeout);
res &= socket.waitForReadyRead(timeout); // wait for ack
res &= (socket.read(qstrlen(ack)) == ack);
return res;
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
// assure one application instance
QString uniqueID( HomePrism_UUID );
QLocalSocket socket;
socket.connectToServer(uniqueID);
if (socket.waitForConnected(500))
{
QMessageBox::critical(0, QObject::tr("HomePrism"),
QObject::tr("Another HomePrism is already running. Will exit now."));
return EXIT_FAILURE; // Exit already a process running
}
// some app specific params
QCoreApplication::setApplicationName( HomePrism_TITLE );
QCoreApplication::setOrganizationName("DKFZ");
// start
HomePrism homePrismWindow;
homePrismWindow.setGeometry(
QStyle::alignedRect(
Qt::LeftToRight,
Qt::AlignCenter,
homePrismWindow.size(),
qApp->desktop()->availableGeometry()
));
homePrismWindow.show();
//HomePrism.hide();
return app.exec();
}
int QmKeysPrivate::getKeyValue(const struct input_event &query) {
// Try to connect to qmkeyd.
QLocalSocket socket;
socket.connectToServer(SERVER_NAME);
if (!socket.waitForConnected(1000)) {
return -1;
}
// Query for the given key
if (socket.write((char*)&query, sizeof(query)) != sizeof(query)) {
return -1;
}
if (!socket.waitForReadyRead(1000)) {
return -1;
}
struct input_event response;
int ret = 0;
// A loop because we might receive other events as well.
do {
ret = socket.read((char*)&response, sizeof(response));
if (ret == sizeof(response)) {
if (response.type == query.type && response.code == query.code) {
break;
}
}
} while (ret == sizeof(response));
socket.disconnect();
return response.value;
}
// Process incoming IPC command. First check if monero-wallet-gui is
// already running. If it is, send it to that instance instead, if not,
// queue the command for later use inside our QML engine. Returns true
// when queued, false if sent to another instance, at which point we can
// kill the current process.
bool IPC::saveCommand(QString cmdString){
qDebug() << QString("saveCommand called: %1").arg(cmdString);
QLocalSocket ls;
QByteArray buffer;
buffer = buffer.append(cmdString);
QString socketFilePath = this->socketFile().filePath();
ls.connectToServer(socketFilePath, QIODevice::WriteOnly);
if(ls.waitForConnected(1000)){
ls.write(buffer);
if (!ls.waitForBytesWritten(1000)){
qDebug() << QString("Could not send command \"%1\" over IPC %2: \"%3\"").arg(cmdString, socketFilePath, ls.errorString());
return false;
}
qDebug() << QString("Sent command \"%1\" over IPC \"%2\"").arg(cmdString, socketFilePath);
return false;
}
if(ls.isOpen())
ls.disconnectFromServer();
// Queue for later
this->SetQueuedCmd(cmdString);
return true;
}
bool Application::IsAlreadyRunning () const
{
QLocalSocket socket;
socket.connectToServer (GetSocketName ());
if (socket.waitForConnected () ||
socket.state () == QLocalSocket::ConnectedState)
{
QDataStream out (&socket);
out << Arguments_;
if (socket.waitForBytesWritten ())
return true;
if (socket.error() == QLocalSocket::UnknownSocketError)
return true;
}
else
{
switch (socket.error ())
{
case QLocalSocket::ServerNotFoundError:
case QLocalSocket::ConnectionRefusedError:
break;
default:
qWarning () << Q_FUNC_INFO
<< "socket error"
<< socket.error ();
return true;
}
}
// Clear any halted servers and their messages
QLocalServer::removeServer (GetSocketName ());
return false;
}
//
// Sending to the server is done synchronously, at startup.
// If the server isn't already running, startup continues,
// and the items in savedPaymentRequest will be handled
// when uiReady() is called.
//
bool PaymentServer::ipcSendCommandLine()
{
bool fResult = false;
for (const QString& r : savedPaymentRequests)
{
QLocalSocket* socket = new QLocalSocket();
socket->connectToServer(ipcServerName(), QIODevice::WriteOnly);
if (!socket->waitForConnected(BITCOIN_IPC_CONNECT_TIMEOUT))
{
delete socket;
socket = nullptr;
return false;
}
QByteArray block;
QDataStream out(&block, QIODevice::WriteOnly);
out.setVersion(QDataStream::Qt_4_0);
out << r;
out.device()->seek(0);
socket->write(block);
socket->flush();
socket->waitForBytesWritten(BITCOIN_IPC_CONNECT_TIMEOUT);
socket->disconnectFromServer();
delete socket;
socket = nullptr;
fResult = true;
}
return fResult;
}
QT_USE_NAMESPACE
#define NO_DISCOVERED_CONFIGURATIONS_ERROR 1
#define SESSION_OPEN_ERROR 2
int main(int argc, char** argv)
{
QCoreApplication app(argc, argv);
// Cannot read/write to processes on WinCE or Symbian.
// Easiest alternative is to use sockets for IPC.
QLocalSocket oopSocket;
oopSocket.connectToServer("tst_qnetworksession");
oopSocket.waitForConnected(-1);
QNetworkConfigurationManager manager;
QList<QNetworkConfiguration> discovered =
manager.allConfigurations(QNetworkConfiguration::Discovered);
foreach(QNetworkConfiguration config, discovered) {
qDebug() << "Lackey: Name of the config enumerated: " << config.name();
qDebug() << "Lackey: State of the config enumerated: " << config.state();
}
bool ServerCatchcopy::listen()
{
QLocalSocket socketTestConnection;
pathSocket=ExtraSocketCatchcopy::pathSocket();
socketTestConnection.connectToServer(QString::fromStdString(pathSocket));
if(socketTestConnection.waitForConnected(CATCHCOPY_COMMUNICATION_TIMEOUT))
{
error_string="Other server is listening";
emit error(error_string);
return false;
}
else
{
if(!server.removeServer(QString::fromStdString(pathSocket)))
{
error_string="Unable to remove the old server";
emit error(error_string);
}
#ifndef Q_OS_MAC
server.setSocketOptions(QLocalServer::UserAccessOption);
#endif
if(server.listen(QString::fromStdString(pathSocket)))
return true;
else
{
error_string=QStringLiteral("Unable to listen %1: %2").arg(QString::fromStdString(pathSocket)).arg(server.errorString()).toStdString();
emit error(error_string);
return false;
}
}
}
bool SingleInstance::hasPrevious(const QString &name, const QStringList &args)
{
qDebug() << "Checking for previous instance...";
QLocalSocket socket;
socket.connectToServer(name, QLocalSocket::ReadWrite);
if (socket.waitForConnected())
{
qDebug() << "Connection found!";
qDebug() << "Forwarding argument to existing instance...";
QByteArray buffer;
for (auto item : args)
{
buffer.append(item+"\n");
}
qDebug() << "Forwading buffer=" << buffer;
socket.write(buffer);
return true;
}
qDebug() << socket.errorString();
qDebug() << "No connection found";
return false;
}
void MainWidget::initLocalConnection()
{
is_running = false;
QCoreApplication::setApplicationName("localserver");
QString serverName=QCoreApplication::applicationName();
QLocalSocket socket;
socket.connectToServer(serverName);
if(socket.waitForConnected(500))
{
is_running =true;
return;
}
//连接不上服务器，就创建一个
server = new QLocalServer(this);
connect(server, SIGNAL(newConnection()), this, SLOT(newLocalConnection()));
if(server->listen(serverName))
{
//防止程序崩溃时,残留进程服务,移除之
if(server->serverError() == QAbstractSocket::AddressInUseError && QFile::exists(server->serverName()))
{
QFile::remove(server->serverName());
server->listen(serverName);
}
}
}
int main(void)
{
QLocalSocket socket;
socket.connectToServer(SOCK_PATH);
socket.open(QIODevice::ReadWrite);
printf("Connected.\n");
char str[100];
while(printf("> "), fgets(str, 100, stdin), !feof(stdin)) {
if (socket.write(str, strlen(str)) == -1) {
perror("send");
return EXIT_FAILURE;
}
int t;
if ((t = socket.read(str, 100)) > 0) {
str[t] = '\0';
printf("echo> %s", str);
} else {
if (t < 0)
perror("recv");
else
printf("Server closed connection.\n");
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
bool N810GpsPlugin::sendToGpsDriverCtrl(QString cmd)
{
QLocalSocket *gpsCtrlSocket;
gpsCtrlSocket = new QLocalSocket(this);
QByteArray socketPath = ( "/var/lib/gps/gps_driver_ctrl");
gpsCtrlSocket->connectToServer(socketPath.data());
if(gpsCtrlSocket->waitForConnected()) {
qLog(Hardware)<< __PRETTY_FUNCTION__ << "connected" << cmd;
QByteArray data;
data.append(cmd);
data.append("\n");
gpsCtrlSocket->write(data);
gpsCtrlSocket->flush();
gpsCtrlSocket->disconnectFromServer();
return true;
} else {
qLog(Hardware) << __PRETTY_FUNCTION__ << "Could not connect to socket" << gpsCtrlSocket;
}
return false;
}
void LocalClient::run()
{
QLocalSocket *socket = new QLocalSocket(this);
socket->connectToServer("/tmp/testservice");
if (!socket->waitForConnected()) {
qDebug() << "could not connect to server: " << socket->errorString();
return;
}
m_client = new QJsonRpcSocket(socket, this);
QJsonRpcServiceReply *reply = m_client->invokeRemoteMethod("agent.testMethod");
connect(reply, SIGNAL(finished()), this, SLOT(processResponse()));
reply = m_client->invokeRemoteMethod("agent.testMethodWithParams", "one", false, 10);
connect(reply, SIGNAL(finished()), this, SLOT(processResponse()));
reply = m_client->invokeRemoteMethod("agent.testMethodWithVariantParams", "one", false, 10, QVariant(2.5));
connect(reply, SIGNAL(finished()), this, SLOT(processResponse()));
reply = m_client->invokeRemoteMethod("agent.testMethodWithParamsAndReturnValue", "matt");
connect(reply, SIGNAL(finished()), this, SLOT(processResponse()));
// test bulk messages
/*
QJsonRpcMessage first = QJsonRpcMessage::createRequest("agent.testMethodWithParamsAndReturnValue", "testSendMessage");
m_client->sendMessage(first);
QJsonRpcMessage second = QJsonRpcMessage::createRequest("agent.testMethodWithParamsAndReturnValue", "testSendMessages1");
QJsonRpcMessage third = QJsonRpcMessage::createRequest("agent.testMethodWithParamsAndReturnValue", "testSendMessages2");
m_client->sendMessage(QList<QJsonRpcMessage>() << second << third);
*/
}
// Helper function called by qt_connectToServer()
void qt_connectToServer(const QString& server, bool retry = true)
{
bool connectToWidget = (server != qt_localServerName);
// The QLocalSocket::waitForConnected does not respect the time out argument when the
// gnuplot_qt application is not yet started. To wait for it, we need to implement the timeout ourselves
QDateTime timeout = QDateTime::currentDateTime().addMSecs(1000);
do
{
qt_socket.connectToServer(server);
qt_socket.waitForConnected(200);
// TODO: yield CPU ?
}
while((qt_socket.state() != QLocalSocket::ConnectedState) && (QDateTime::currentDateTime() < timeout));
// Still not connected...
if ((qt_socket.state() != QLocalSocket::ConnectedState) && retry)
{
// The widget could not be reached: start a gnuplot_qt program which will create a QtGnuplotApplication
if (connectToWidget)
{
qDebug() << "Could not connect to widget" << qt_optionWidget << ". Starting a QtGnuplotApplication";
qt_optionWidget = QString();
qt_connectToServer(qt_localServerName);
}
// The gnuplot_qt program could not be reached: try to start a new one
else
{
qDebug() << "Could not connect gnuplot_qt" << qt_optionWidget << ". Starting a new one";
execGnuplotQt();
qt_connectToServer(qt_localServerName, false);
}
}
}
qint64 QtLocalPeer::getRunningPid() {
if (!isClient())
return 0;
QLocalSocket socket;
bool connOk = false;
for (int i = 0; i < 2; i++) {
// Try twice, in case the other instance is just starting up
socket.connectToServer(socketName);
connOk = socket.waitForConnected(5000/2);
if (connOk || i)
break;
Sleep(250);
}
if (!connOk) return -1;
const char* msg = "qbt://pid";
QDataStream ds(&socket);
ds.writeBytes(msg, qstrlen(msg));
bool res = socket.waitForBytesWritten(5000) && socket.waitForReadyRead(5000);
if (!res) return -1;
DWORD pid;
qint64 pid_size = sizeof pid;
while (socket.bytesAvailable() < pid_size)
socket.waitForReadyRead();
if (socket.read((char *)&pid, pid_size) < pid_size)
return -1;
return pid;
}
bool MonavRunnerPrivate::retrieveData( const RouteRequest *route, const QString &mapDir, RoutingResult* reply ) const
{
QLocalSocket socket;
socket.connectToServer( "MoNavD" );
if ( socket.waitForConnected() ) {
if ( m_plugin->monavVersion() == MonavPlugin::Monav_0_3 ) {
CommandType commandType;
commandType.value = CommandType::RoutingCommand;
commandType.post( &socket );
}
RoutingCommand command;
QVector<Node> waypoints;
for ( int i = 0; i < route->size(); ++i ) {
Node coordinate;
coordinate.longitude = route->at( i ).longitude( GeoDataCoordinates::Degree );
coordinate.latitude = route->at( i ).latitude( GeoDataCoordinates::Degree );
waypoints << coordinate;
}
command.dataDirectory = mapDir;
command.lookupRadius = 1500;
command.waypoints = waypoints;
command.lookupStrings = true;
command.post( &socket );
socket.flush();
if ( reply->read( &socket ) ) {
switch ( reply->type ) {
case RoutingResult::LoadFailed:
mDebug() << "failed to load monav map from " << mapDir;
return false;
break;
case RoutingResult::RouteFailed:
mDebug() << "failed to retrieve route from monav daemon";
return false;
break;
case RoutingResult::TypeLookupFailed:
mDebug() << "failed to lookup type from monav daemon";
return false;
break;
case RoutingResult::NameLookupFailed:
mDebug() << "failed to lookup name from monav daemon";
return false;
break;
case RoutingResult::Success:
return true;
}
} else {
mDebug() << "Failed to read reply";
}
} else {
mDebug() << "No connection to MoNavD";
}
return false;
}
bool YACReaderLocalServer::isRunning()
{
QLocalSocket socket;
socket.connectToServer(YACREADERLIBRARY_GUID);
if (socket.waitForConnected(500))
return true; // Server is running (another instance of YACReaderLibrary has been launched)
return false;
}
BrowserApplication::BrowserApplication(int &argc, char **argv, char *styleSheet,QSharedDataPointer<ProcessOptions> processOptions)
: QApplication(argc, argv)
, m_localServer(0)
, m_privateProfile(0)
, sawStyleSheetCommandLineOption(false)
, nextSessionNameIndex(1)
{
nameTemplate = QLatin1String("domterm-%1");
QCoreApplication::setOrganizationName(QLatin1String("DomTerm"));
QCoreApplication::setApplicationName(QLatin1String("QtDomTerm"));
QCoreApplication::setApplicationVersion(QLatin1String(QTDOMTERM_VERSION));
QString serverName = QCoreApplication::applicationName()
+ QString::fromLatin1(QT_VERSION_STR).remove('.') + QLatin1String("webengine");
if (styleSheet != NULL) {
m_stylesheetFilename = QString(styleSheet);
sawStyleSheetCommandLineOption = true;
}
m_fileSystemWatcher = new QFileSystemWatcher(this);
QLocalSocket socket;
socket.connectToServer(serverName);
if (socket.waitForConnected(500)) {
QDataStream stream(&socket);
stream << *processOptions;
socket.waitForBytesWritten();
return;
}
#if defined(Q_OS_OSX)
QApplication::setQuitOnLastWindowClosed(false);
#else
QApplication::setQuitOnLastWindowClosed(true);
#endif
m_localServer = new QLocalServer(this);
connect(m_localServer, SIGNAL(newConnection()),
this, SLOT(newLocalSocketConnection()));
if (!m_localServer->listen(serverName)
&& m_localServer->serverError() == QAbstractSocket::AddressInUseError) {
QLocalServer::removeServer(serverName);
if (!m_localServer->listen(serverName))
qWarning("Could not create local socket %s.", qPrintable(serverName));
}
#ifndef QT_NO_OPENSSL
if (!QSslSocket::supportsSsl()) {
QMessageBox::information(0, "Demo Browser",
"This system does not support OpenSSL. SSL websites will not be available.");
}
#endif
QString localSysName = QLocale::system().name();
installTranslator(QLatin1String("qt_") + localSysName);
QTimer::singleShot(0, this, SLOT(postLaunch()));
}
int main(int argc, char **argv)
{
QCoreApplication app(argc, argv);
QStringList args = app.arguments();
QString appName = args.takeFirst();
bool notification = args.contains("-n");
if (notification)
args.removeAll("-n");
if (args.size() < 2) {
qDebug("usage: %s [-n] <service> <method> <arguments>", appName.toLocal8Bit().data());
return -1;
}
// try to process socket
QIODevice *device = 0;
QScopedPointer<QIODevice> devicePtr(device);
QString service = args.takeFirst();
QUrl serviceUrl = QUrl::fromUserInput(service);
QHostAddress serviceAddress(serviceUrl.host());
if (serviceAddress.isNull()) {
QLocalSocket *localSocket = new QLocalSocket;
device = localSocket;
localSocket->connectToServer(service);
if (!localSocket->waitForConnected(5000)) {
qDebug("could not connect to service: %s", service.toLocal8Bit().data());
return -1;
}
} else {
QTcpSocket *tcpSocket = new QTcpSocket;
device = tcpSocket;
int servicePort = serviceUrl.port() ? serviceUrl.port() : 5555;
tcpSocket->connectToHost(serviceAddress, servicePort);
if (!tcpSocket->waitForConnected(5000)) {
qDebug("could not connect to host at %s:%d", serviceUrl.host().toLocal8Bit().data(),
servicePort);
return -1;
}
}
QJsonRpcSocket socket(device);
QString method = args.takeFirst();
QVariantList arguments;
foreach (QString arg, args)
arguments.append(arg);
QJsonRpcMessage request = notification ? QJsonRpcMessage::createNotification(method, arguments) :
QJsonRpcMessage::createRequest(method, arguments);
QJsonRpcMessage response = socket.sendMessageBlocking(request, 5000);
if (response.type() == QJsonRpcMessage::Error) {
qDebug("error(%d): %s", response.errorCode(), response.errorMessage().toLocal8Bit().data());
return -1;
}
qDebug() << response.result();
}
bool LH_QtPlugin_WebKit::sendQuit()
{
QLocalSocket sock;
sock.connectToServer("LCDHost_WebKitServer");
if( !sock.waitForConnected(100) ) return false;
WebKitCommand('Q').write(&sock);
sock.waitForBytesWritten(100);
sock.disconnectFromServer();
return true;
}
bool
socket_test_connect(QString server, int timeout)
{
QLocalSocket sock;
sock.connectToServer(server);
if (!sock.waitForConnected(timeout)) {
return false;
}
sock.disconnectFromServer();
return true;
}
static bool isDeamonRunning()
{
#if USE_LOCAL_SOCKETS
QLocalSocket socket;
socket.connectToServer("gdrdeamon2");
#else
QTcpSocket socket;
socket.connectToHost("127.0.0.1", 15002);
#endif
return socket.waitForConnected(1000);
}
void setupConnection()
{
QLocalSocket socket;
socket.connectToServer(serverName);
if (socket.waitForConnected(1000)) {
this->running = true;
}
else {
startServer();
}
}
QSingleApplication::QSingleApplication(int argc, char **argv):QApplication(argc,argv)
{
_isRunning=false;
QCoreApplication::setApplicationName("localserver");
QString serverName=QCoreApplication::applicationName();
QLocalSocket socket;
socket.connectToServer(serverName);
if(socket.waitForConnected(500))
{
QTextStream stream(&socket);
QStringList args=QCoreApplication::arguments();
if(args.count()>1)
{
stream<<args.last();
}else
{
stream<<QString();
}
stream.flush();
qDebug()<<"Connected server,program will quit";
socket.waitForBytesWritten();
/**
*qApp->quit(); 此代码是用来退出事件循环的;在构造函数中,事件循环
*尚未启动,因此就无法退出. 最好就是设置标志判断在外部判断
*/
_isRunning=true;
return;
}
qDebug()<<"Can't connect to server,build a server";
server=new QLocalServer(this);
connect(server,SIGNAL(newConnection()),this,SLOT(newLocalConnection()));
if(server->listen(serverName))
{
//防止程序崩溃时,残留进程服务,移除之
if(server->serverError()==QAbstractSocket::AddressInUseError&&QFile::exists(server->serverName()))
{
QFile::remove(server->serverName());
server->listen(serverName);
}
}
}
