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();
}
