void ble_bas_c_on_ble_evt(ble_evt_t const * p_ble_evt, void * p_context)
{
if ((p_ble_evt == NULL) || (p_context == NULL))
{
return;
}
ble_bas_c_t * p_ble_bas_c = (ble_bas_c_t *)p_context;
switch (p_ble_evt->header.evt_id)
{
case BLE_GATTC_EVT_HVX:
on_hvx(p_ble_bas_c, p_ble_evt);
break;
case BLE_GATTC_EVT_WRITE_RSP:
on_write_rsp(p_ble_bas_c, p_ble_evt);
break;
case BLE_GATTC_EVT_READ_RSP:
on_read_rsp(p_ble_bas_c, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnected(p_ble_bas_c, p_ble_evt);
break;
default:
break;
}
}
/// Connection manager event dispatcher. Called by the CM event loop.
void on_cm_event(struct rdma_cm_event* event)
{
L_(trace) << rdma_event_str(event->event);
switch (event->event) {
case RDMA_CM_EVENT_ADDR_RESOLVED:
on_addr_resolved(event->id);
return;
case RDMA_CM_EVENT_ADDR_ERROR:
throw InfinibandException("rdma_resolve_addr failed");
case RDMA_CM_EVENT_ROUTE_RESOLVED:
on_route_resolved(event->id);
return;
case RDMA_CM_EVENT_ROUTE_ERROR:
throw InfinibandException("rdma_resolve_route failed");
case RDMA_CM_EVENT_CONNECT_ERROR:
throw InfinibandException("could not establish connection");
case RDMA_CM_EVENT_UNREACHABLE:
throw InfinibandException("remote server is not reachable");
case RDMA_CM_EVENT_REJECTED:
on_rejected(event);
return;
case RDMA_CM_EVENT_ESTABLISHED:
on_established(event);
return;
case RDMA_CM_EVENT_CONNECT_REQUEST:
on_connect_request(event);
return;
case RDMA_CM_EVENT_DISCONNECTED:
on_disconnected(event);
return;
default:
L_(warning) << rdma_event_str(event->event);
}
}
IRC_Session::IRC_Session(ServerProfile profile, QObject *parent = 0, QTreeWidget *sParent = 0) : Irc::Session(parent) {
ChanList.insert("status",new irc_channel);
ServerItem = new QTreeWidgetItem(sParent);
ServerItem->setText(0,profile.HostName);
Message temp = ChanList["status"]->append("INIT","*","Initializing protocol..");
emit init_message(this,temp);
connect(this, SIGNAL(connected()), SLOT(on_connected()));
connect(this, SIGNAL(disconnected()), SLOT(on_disconnected()));
connect(this, SIGNAL(msgQuit(QString, QString)), SLOT(on_msgQuit(QString, QString)));
connect(this, SIGNAL(msgJoined(QString, QString)), SLOT(on_msgJoined(QString, QString)));
connect(this, SIGNAL(msgNickChanged(QString, QString)), SLOT(on_msgNickChanged(QString, QString)));
connect(this, SIGNAL(msgParted(QString, QString, QString)), SLOT(on_msgParted(QString, QString, QString)));
connect(this, SIGNAL(msgInvited(QString, QString, QString)), SLOT(on_msgInvited(QString, QString, QString)));
connect(this, SIGNAL(msgCtcpReplyReceived(QString, QString)), SLOT(on_msgCtcpReplyReceived(QString, QString)));
connect(this, SIGNAL(msgCtcpRequestReceived(QString, QString)), SLOT(on_msgCtcpRequestReceived(QString, QString)));
connect(this, SIGNAL(msgTopicChanged(QString, QString, QString)), SLOT(on_msgTopicChanged(QString, QString, QString)));
connect(this, SIGNAL(msgNoticeReceived(QString, QString, QString)), SLOT(on_msgNoticeReceived(QString, QString, QString)));
connect(this, SIGNAL(msgKicked(QString, QString, QString, QString)), SLOT(on_msgKicked(QString, QString, QString, QString)));
connect(this, SIGNAL(msgMessageReceived(QString, QString, QString)), SLOT(on_msgMessageReceived(QString, QString, QString)));
connect(this, SIGNAL(msgUnknownMessageReceived(QString, QStringList)), SLOT(on_msgUnknownMessageReceived(QString, QStringList)));
connect(this, SIGNAL(msgCtcpActionReceived(QString, QString, QString)), SLOT(on_msgCtcpActionReceived(QString, QString, QString)));
connect(this, SIGNAL(msgModeChanged(QString, QString, QString, QString)), SLOT(on_msgModeChanged(QString, QString, QString, QString)));
connect(this, SIGNAL(msgNumericMessageReceived(QString, uint, QStringList)), SLOT(on_msgNumericMessageReceived(QString, uint, QStringList)));
temp = ChanList["status"]->append("INIT","*","Setting up server environment..");
emit init_message(this,temp);
setAutoJoinChannels(Profile->AutoJoinChannels);
if(ClientProfile->RealName)
setRealName(ClientProfile->RealName);
}
void ViewerWindow::on_actionCapturar_triggered()
{
//Stop movie if running
if (movie_->state() == QMovie::Paused || movie_->state() == QMovie::Running)
{
movie_->stop();
}
//(Re)create camera
if (camera != NULL) delete camera;
camera = new QCamera(selected_camera);
//Set up camera and start
camera->setViewfinder(captureBuffer);
camera->setCaptureMode(QCamera::CaptureViewfinder);
//Connect to server
QSettings settings("GS", "viewer");
QString host = settings.value("Host", "127.0.0.1").toString();
quint16 port = settings.value("Port", 7890).toUInt();
connect(tcpSocket, SIGNAL(connected()), this, SLOT(on_connected()));
connect(tcpSocket, SIGNAL(disconnected()), this, SLOT(on_disconnected()));
tcpSocket->connectToHost(host, port);
}
Light::Light()
{
QObject::connect(&m_connection, SIGNAL(connected()), SLOT(on_connected()));
QObject::connect(&m_connection, SIGNAL(error()), SLOT(on_error()));
QObject::connect(&m_connection, SIGNAL(disconnected()), SLOT(on_disconnected()));
QObject::connect(&m_connection, SIGNAL(readyRead()), SLOT(on_readyRead()));
}
void ble_hrs_c_on_ble_evt(ble_hrs_c_t * p_ble_hrs_c, const ble_evt_t * p_ble_evt)
{
if ((p_ble_hrs_c == NULL) || (p_ble_evt == NULL))
{
return;
}
switch (p_ble_evt->header.evt_id)
{
case BLE_GATTC_EVT_HVX:
on_hvx(p_ble_hrs_c, p_ble_evt);
break;
case BLE_GATTC_EVT_WRITE_RSP:
on_write_rsp(p_ble_hrs_c, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnected(p_ble_hrs_c, p_ble_evt);
break;
default:
break;
}
}
void ble_db_discovery_on_ble_evt(ble_db_discovery_t * const p_db_discovery,
const ble_evt_t * const p_ble_evt)
{
VERIFY_PARAM_NOT_NULL_VOID(p_db_discovery);
VERIFY_PARAM_NOT_NULL_VOID(p_ble_evt);
VERIFY_MODULE_INITIALIZED_VOID();
switch (p_ble_evt->header.evt_id)
{
case BLE_GATTC_EVT_PRIM_SRVC_DISC_RSP:
on_primary_srv_discovery_rsp(p_db_discovery, &(p_ble_evt->evt.gattc_evt));
break;
case BLE_GATTC_EVT_CHAR_DISC_RSP:
on_characteristic_discovery_rsp(p_db_discovery, &(p_ble_evt->evt.gattc_evt));
break;
case BLE_GATTC_EVT_DESC_DISC_RSP:
on_descriptor_discovery_rsp(p_db_discovery, &(p_ble_evt->evt.gattc_evt));
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnected(p_db_discovery, &(p_ble_evt->evt.gap_evt));
break;
default:
break;
}
}
ClientConnection::ClientConnection(int socketDescriptor) :
QObject(), _socketDescriptor(socketDescriptor), _opened(false), _isAReader(false), _clientAddress("")
{
qDebug() << QThread::currentThreadId() << Q_FUNC_INFO << socketDescriptor;
_tcpSocket.setParent(this);
this->connect(&_tcpSocket, SIGNAL(disconnected()), SIGNAL(sig_disconnected()));
// TODO this->connect(&_tcpSocket, SIGNAL(disconnected()), SLOT(deleteLater())); // C'est Server qui crée des ClientConnection, c'est donc Server qui décide quand les détruire
this->connect(&_tcpSocket, SIGNAL(disconnected()), SLOT(on_disconnected()));
}
ServerSocket::ServerSocket(int id)
{
this->setSocketDescriptor(id);
connect(this, SIGNAL(readyRead()),
this, SLOT(on_readyRead()));
connect(this, SIGNAL(disconnected()),
this, SLOT(deleteLater()));
connect(this, SIGNAL(disconnected()),
this, SLOT(on_disconnected()));
}
MyIrcSession::MyIrcSession(const std::string &user, NetworkPlugin *np, const std::string &suffix, QObject* parent) : IrcSession(parent)
{
this->np = np;
this->user = user;
this->suffix = suffix;
m_connected = false;
rooms = 0;
connect(this, SIGNAL(disconnected()), SLOT(on_disconnected()));
connect(this, SIGNAL(connected()), SLOT(on_connected()));
connect(this, SIGNAL(messageReceived(IrcMessage*)), this, SLOT(onMessageReceived(IrcMessage*)));
}
connection::connection(QObject *parent) :
QObject(parent)
{
ableToWrite=false;
socket = new QTcpSocket(this);
connect(socket,SIGNAL(error(QAbstractSocket::SocketError)),this,SLOT(printError(QAbstractSocket::SocketError)));
connect(socket, SIGNAL(connected()), this, SLOT(on_connected()));
connect(socket,SIGNAL(disconnected()), this, SLOT(on_disconnected()));
connect(socket,SIGNAL(readyRead()),this,SLOT(incommingData()));
UDPsocket = new QUdpSocket(this);
UDPsocket->bind(6666, QUdpSocket::ShareAddress);
connect(UDPsocket, SIGNAL(readyRead()),this, SLOT(chatData()));
}
void Server::on_newConnection()
{
socket = server->nextPendingConnection();
if(socket->state() == QTcpSocket::ConnectedState)
{
printf("New connection established.\n");
}
else
printf ("Something Wrong");
connect(socket, SIGNAL(disconnected()),
this, SLOT(on_disconnected()));
connect(socket, SIGNAL(readyRead()),
this, SLOT(on_readyRead()));
}
MyIrcSession::MyIrcSession(const std::string &user, IRCNetworkPlugin *np, const std::string &suffix, QObject* parent) : IrcSession(parent)
{
this->np = np;
this->user = user;
this->suffix = suffix;
m_connected = false;
rooms = 0;
connect(this, SIGNAL(disconnected()), SLOT(on_disconnected()));
connect(this, SIGNAL(socketError(QAbstractSocket::SocketError)), SLOT(on_socketError(QAbstractSocket::SocketError)));
connect(this, SIGNAL(connected()), SLOT(on_connected()));
connect(this, SIGNAL(messageReceived(IrcMessage*)), this, SLOT(onMessageReceived(IrcMessage*)));
m_awayTimer = new QTimer(this);
connect(m_awayTimer, SIGNAL(timeout()), this, SLOT(awayTimeout()));
m_awayTimer->start(5*1000);
}
void asio_rpc_session::on_failure()
{
if (on_disconnected())
{
try {
_socket->shutdown(boost::asio::socket_base::shutdown_type::shutdown_both);
_socket->close();
}
catch (std::exception& /*ex*/)
{
/*dwarn("network session %s exits failed, err = %s",
remote_address().to_ip_string().c_str(),
static_cast<int>remote_address().port(),
ex.what()
);*/
}
}
}
void ble_ancs_c_on_ble_evt(ble_ancs_c_t * p_ancs, const ble_evt_t * p_ble_evt)
{
uint16_t evt = p_ble_evt->header.evt_id;
switch (evt)
{
case BLE_GATTC_EVT_WRITE_RSP:
on_write_rsp(p_ancs, p_ble_evt);
break;
case BLE_GATTC_EVT_HVX:
on_evt_gattc_notif (p_ancs, p_ble_evt);
break;
case BLE_GAP_EVT_DISCONNECTED:
on_disconnected(p_ancs, p_ble_evt);
break;
default:
break;
}
}
void netstream_threaded::operator()()
{ binary_data tmp_data;
// Post disconnect once the disconnect
sem_disconnect.post();
while(1)
{
// Wait for new socket
sem_newsocket.wait();
// On zombie-mode exit thread
if (b_zombie)
return;
// We must be connected
b_connected = true;
on_connected();
sem_connect.post();
try{
while(1)
{
tmp_data = netstream::receive(1024);
on_data_received(tmp_data);
}
}
catch(std::exception){}
// We got disconnected
b_connected = false;
netstream::disconnect(); // Disconnect for sure
on_disconnected();
// Post event
sem_disconnect.post();
}
}
void hpc_rpc_session::on_failure(bool is_write)
{
if (on_disconnected(is_write))
close();
}
void hpc_rpc_session::on_failure()
{
_looper->unbind_io_handle((dsn_handle_t)(intptr_t)_socket, &_ready_event);
if (on_disconnected())
close();
}
void hpc_rpc_session::on_failure()
{
if (on_disconnected())
close();
}
void MyIrcSession::on_socketError(QAbstractSocket::SocketError error) {
on_disconnected();
}
ClientConnection::~ClientConnection()
{
qDebug() << QThread::currentThreadId() << Q_FUNC_INFO;
_tcpSocket.close();
on_disconnected();
}
