void web_socket_client::onConnected() { qDebug() << "Connection is"; isConnected = true; emit connection_success(); QObject::connect(&WebSock, &QWebSocket::binaryMessageReceived,this, &web_socket_client::onBinaryMessage); QObject::connect(&WebSock, &QWebSocket::textMessageReceived,this, &web_socket_client::onTextMessage); }
static void v1_connect_handler(lcb_sockdata_t *sockptr, int status) { lcb_connection_t conn = (lcb_connection_t)sockptr->lcbconn; if (!conn) { /* closed? */ return; } if (status) { v1_connect(conn, 0); } else { connection_success(conn); } }
static lcb_connection_result_t v1_connect(lcb_connection_t conn, int nocb) { int save_errno; int rv; int retry = 1; int retry_once = 0; lcb_connect_status_t status; lcb_io_opt_t io = conn->instance->io; do { if (!conn->sockptr) { conn->sockptr = lcb_gai2sock_v1(conn->instance, &conn->curr_ai, &save_errno); } if (conn->sockptr) { conn->sockptr->lcbconn = conn; conn->sockptr->parent = io; } else { conn->last_error = io->v.v1.error; if (handle_conn_failure(conn) == -1) { conn_do_callback(conn, nocb, LCB_CONNECT_ERROR); return LCB_CONN_ERROR; } } rv = io->v.v1.start_connect(io, conn->sockptr, conn->curr_ai->ai_addr, (unsigned int)conn->curr_ai->ai_addrlen, v1_connect_handler); if (rv == 0) { if (nocb) { return LCB_CONN_INPROGRESS; } connection_success(conn); return LCB_CONN_CONNECTED; } status = lcb_connect_status(io->v.v1.error); switch (status) { case LCB_CONNECT_EINTR: retry = 1; break; case LCB_CONNECT_EISCONN: connection_success(conn); return LCB_CONN_CONNECTED; case LCB_CONNECT_EALREADY: case LCB_CONNECT_EINPROGRESS: return LCB_CONN_INPROGRESS; case LCB_CONNECT_EINVAL: /** TODO: do we still need this for v1? */ conn->last_error = io->v.v1.error; if (!retry_once) { retry = 1; retry_once = 1; break; } else { retry_once = 0; } case LCB_CONNECT_EFAIL: conn->last_error = io->v.v1.error; if (handle_conn_failure(conn) == -1) { conn_do_callback(conn, nocb, LCB_CONNECT_ERROR); return LCB_CONN_ERROR; } break; default: conn->last_error = io->v.v1.error; return LCB_CONN_ERROR; } } while (retry); return LCB_CONN_ERROR; }
/** * IOPS v0 connection routines. This is the standard select()/poll() model. * Returns a status indicating whether the connection has been scheduled * successfuly or not. */ static lcb_connection_result_t v0_connect(struct lcb_connection_st *conn, int nocb, short events) { int retry; int retry_once = 0; int save_errno; lcb_connect_status_t connstatus; struct lcb_io_opt_st *io = conn->instance->io; do { if (conn->sockfd == INVALID_SOCKET) { conn->sockfd = lcb_gai2sock(conn->instance, &conn->curr_ai, &save_errno); } if (conn->curr_ai == NULL) { conn->last_error = io->v.v0.error; /* this means we're not going to retry!! add an error here! */ return LCB_CONN_ERROR; } retry = 0; if (events & LCB_ERROR_EVENT) { socklen_t errlen = sizeof(int); int sockerr = 0; getsockopt(conn->sockfd, SOL_SOCKET, SO_ERROR, (char *)&sockerr, &errlen); conn->last_error = sockerr; } else { if (io->v.v0.connect(io, conn->sockfd, conn->curr_ai->ai_addr, (unsigned int)conn->curr_ai->ai_addrlen) == 0) { /** * Connected. * XXX: In the odd event that this does connect immediately, we * still enqueue it! - this is because we likely want to invoke some * other callbacks after this, and we can't be sure that it's safe to * do so until the event loop has control. Therefore we actually rely * on EISCONN!. * This isn't a whole lot of overhead as we shouldn't be connecting * too much in the first place */ if (nocb) { return LCB_CONN_INPROGRESS; } else { connection_success(conn); return LCB_CONN_CONNECTED; } } else { conn->last_error = io->v.v0.error; } } connstatus = lcb_connect_status(conn->last_error); switch (connstatus) { case LCB_CONNECT_EINTR: retry = 1; break; case LCB_CONNECT_EISCONN: connection_success(conn); return LCB_CONN_CONNECTED; case LCB_CONNECT_EINPROGRESS: /*first call to connect*/ io->v.v0.update_event(io, conn->sockfd, conn->evinfo.ptr, LCB_WRITE_EVENT, conn, v0_reconnect_handler); return LCB_CONN_INPROGRESS; case LCB_CONNECT_EALREADY: /* Subsequent calls to connect */ return LCB_CONN_INPROGRESS; case LCB_CONNECT_EINVAL: if (!retry_once) { /* First time get WSAEINVAL error - do retry */ retry = 1; retry_once = 1; break; } else { /* Second time get WSAEINVAL error - it is permanent error */ retry_once = 0; /* go to LCB_CONNECT_EFAIL brench (no break or return) */ } case LCB_CONNECT_EFAIL: default: if (handle_conn_failure(conn) == -1) { conn_do_callback(conn, nocb, LCB_CONNECT_ERROR); return LCB_CONN_ERROR; } /* Try next AI */ retry = 1; break; } } while (retry); lcb_assert("this statement shouldn't be reached" && 0); return LCB_CONN_ERROR; }
int main(int argc, char *argv[]) { QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling); QGuiApplication app(argc, argv); QGuiApplication::setApplicationName("Presentao"); QGuiApplication::setOrganizationName("Embedded_Multimedia"); QSettings settings; QString style = QQuickStyle::name(); if (!style.isEmpty()) settings.setValue("style", style); else QQuickStyle::setStyle(settings.value("style").toString()); web_socket_client websocketclient; audioWindow audioengine; QQmlApplicationEngine engine; engine.load(QUrl(QLatin1String("qrc:/main.qml"))); if (engine.rootObjects().isEmpty()) return -1; PdfRenderer myPdfRenderer; handcontrol myhandcontrol; engine.addImageProvider(QLatin1String("pdfrenderer"), &myPdfRenderer); QObject *root = engine.rootObjects()[0]; //QObject::connect(root, SIGNAL(nextpage()),&myPdfRenderer, SLOT(nextPage())); //QObject::connect(root, SIGNAL(prevpage()),&myPdfRenderer, SLOT(prevPage())); QObject::connect(root, SIGNAL(openfile(QUrl)),&myPdfRenderer, SLOT(OpenPDF(QUrl))); QObject::connect(&myPdfRenderer, SIGNAL(sendTotalPageCount(QVariant)),root, SLOT(setTotalPageCount(QVariant))); /* * signals from web_socket_client * void OpenPDF(QString) * void signal_setPage(int) * void connection_success() */ QObject::connect(&websocketclient, SIGNAL(OpenPDF(QUrl)), &myPdfRenderer, SLOT(OpenPDF(QUrl))); QObject::connect(&websocketclient, SIGNAL(signal_setPage(QVariant)), root, SLOT(setCurrentPageNr(QVariant))); QObject::connect(&websocketclient, SIGNAL(connection_success()), root, SLOT(connection_success())); /* * slots of web_socket_client * void connect(QString) * void onConnected() * void onBinaryMessage(QByteArray) * void onTextMessage(QString) * void sendFile(QString filename) * void registerMaster(QString) * void download_pdf(QString filename) * void getPage() * void setPage(QString) */ QObject::connect(root, SIGNAL(connect(QString)), &websocketclient, SLOT(connect(QString))); QObject::connect(root, SIGNAL(registerMaster(QString)), &websocketclient, SLOT(registerMaster(QString))); QObject::connect(root, SIGNAL(sendFile(QUrl)), &websocketclient, SLOT(sendFile(QUrl))); QObject::connect(root, SIGNAL(download_pdf(QString)), &websocketclient, SLOT(download_pdf(QString))); QObject::connect(root, SIGNAL(setPage(QString)), &websocketclient, SLOT(setPage(QString))); QObject::connect(root, SIGNAL(getPage()), &websocketclient, SLOT(getPage())); //AUDIO QObject::connect(root, SIGNAL(startstopKlopfen()),&audioengine, SLOT(startStopRecording())); QObject::connect(&audioengine, SIGNAL(knock()),root, SLOT(klopf_weiter())); QObject::connect(&audioengine, SIGNAL(double_knock()),root,SLOT(klopf_zurück())); // Gestensteuerng QObject *cameraComponent = root->findChild<QObject*>("camera"); QCamera *camera = qvariant_cast<QCamera*>(cameraComponent->property("mediaObject")); myhandcontrol.setCamera(camera); QObject::connect(root, SIGNAL(handcontrol_enable(int)),&myhandcontrol, SLOT(enable(int))); QObject::connect(&myhandcontrol, SIGNAL(debugMessage(QVariant)),root, SLOT(handcontrol_debugOut(QVariant))); QObject::connect(&myhandcontrol, SIGNAL(errorMessage(QVariant)),root, SLOT(handcontrol_debugOut(QVariant))); QObject::connect(&myhandcontrol, SIGNAL(change_page(QVariant)),root, SLOT(handcontrol_change_page(QVariant))); qDebug()<<"From main thread: "<<QThread::currentThreadId(); return app.exec(); }