mucho mas agradable.
// Callbacks para las conexiones
void on_conexion_finished();
void on_conexion_ok(const std::string &body);
- void on_conexion_error(unsigned code);
+ void on_conexion_fatal_error(const PlaQui::Server::ControlClient::Error& code, const std::string& desc);
+ void on_conexion_error(unsigned code, const std::string& desc);
void on_conexion_frame(const std::string &frame);
};
}
// Espera a que termine realmente.
while (conexion) {
- Glib::usleep(10000); // 10 milisegundos
+ Glib::usleep(100000); // 0,1 segundo
}
}
// Conecto las señales
conexion->signal_ok_received().connect( SigC::slot(*this, &Principal::on_conexion_ok) );
+ conexion->signal_error().connect( SigC::slot(*this, &Principal::on_conexion_fatal_error) );
conexion->signal_error_received().connect( SigC::slot(*this, &Principal::on_conexion_error) );
conexion->signal_finished().connect( SigC::slot(*this, &Principal::on_conexion_finished) );
conexion->signal_frame_received().connect(SigC::slot(*this, &Principal::on_conexion_frame));
}
}
-void Principal::on_conexion_error(unsigned code)
+void Principal::on_conexion_fatal_error(const PlaQui::Server::ControlClient::Error& code, const std::string& desc)
{
std::stringstream a;
std::string s;
a << code;
a >> s;
- txt_view->get_buffer()->insert_at_cursor("El server dice que hay error : ");
+ txt_view->get_buffer()->insert_at_cursor("Error de red nro. ");
txt_view->get_buffer()->insert_at_cursor(s);
+ txt_view->get_buffer()->insert_at_cursor(": ");
+ txt_view->get_buffer()->insert_at_cursor(desc);
+ txt_view->get_buffer()->insert_at_cursor("\n");
+}
+
+void Principal::on_conexion_error(unsigned code, const std::string& desc)
+{
+ std::stringstream a;
+ std::string s;
+ a << code;
+ a >> s;
+ txt_view->get_buffer()->insert_at_cursor("El server dice que hay error nro. ");
+ txt_view->get_buffer()->insert_at_cursor(s);
+ txt_view->get_buffer()->insert_at_cursor(": ");
+ txt_view->get_buffer()->insert_at_cursor(desc);
txt_view->get_buffer()->insert_at_cursor("\n");
}
#include "plaqui/server/command.h"
#include "plaqui/server/connection.h"
-#include "plaqui/server/receiver.h" // TODO TEMPRORAL
+#include "plaqui/server/receiver.h" // FIXME TEMPRORAL
#include <string>
namespace PlaQui {
typedef SigC::Signal1<void, const std::string&> SignalOKReceived;
/// Tipo de señal para indicar que se recibió un error.
- typedef SigC::Signal1<void, unsigned> SignalErrorReceived;
+ typedef SigC::Signal2<void, unsigned, const std::string&>
+ SignalErrorReceived;
/// Tipo de señal para indicar que se recibió un frame. FIXME
typedef Receiver::SignalFrameReceived SignalFrameReceived;
/**
* Obtiene la señal que avisa cuando se recibió un cuadro.
- * \todo TODO Temporal.
+ * \todo FIXME Temporal.
*/
SignalFrameReceived& signal_frame_received(void);
/// Señal para indicar que se recibió un error.
SignalErrorReceived error_received;
- /// Receptor del estado de la planta TODO Temporal.
+ /// Receptor del estado de la planta FIXME Temporal.
Receiver* receiver;
/////////////////////////////////////////////////////////////////////
*/
void send(const Command& command);
+ /**
+ * Envia una señal de error si hay un error en la recepción.
+ * \todo FIXME Temporal.
+ */
+ void on_receiver_error(const Error& code, const std::string& desc);
+
+ /**
+ * Limpia el puntero del receptor cuando termina.
+ * \todo FIXME Temporal.
+ */
+ void on_receiver_finished(void);
+
};
}
#include "plaqui/server/response.h"
#include "plaqui/server/controlclient.h"
+#include <glibmm/timer.h>
+#include <sigc++/class_slot.h>
#ifdef DEBUG
# include <iostream>
#endif // DEBUG
<< ": destructor." << endl;
#endif // DEBUG
// TODO Temporal: espero que el receiver muera.
- // Conectar señal on_receiver_finished() y esperar a que el puntero sea
- // NULL para saber que terminó.
- receiver->finish();
+ if (receiver) {
+ receiver->finish();
+ }
+ while (receiver) {
+ Glib::usleep(100000); // 0,1 segundo
+ }
}
ControlClient::ControlClient(const string& _host,
<< " | port = " << port << endl;
#endif // DEBUG
receiver = new Receiver(7528, host);
+ receiver->signal_finished().connect(SigC::slot_class(*this,
+ &ControlClient::on_receiver_finished));
+ receiver->signal_error().connect(SigC::slot_class(*this,
+ &ControlClient::on_receiver_error));
}
void ControlClient::real_run(void) throw() {
<< " : real_run() ERROR nro: " << e << endl;
#endif // DEBUG
// TODO - es un error recuperable? O manda señal error()?
- error_received(e);
+ error_received(e, "La respuesta recibida es inválida");
continue;
}
switch (response.get_code()) {
ok_received(response.get_contents());
break;
default:
- error_received(response.get_code());
+ error_received(response.get_code(), response.get_description());
break;
}
}
#endif // DEBUG
}
+void ControlClient::on_receiver_finished(void) {
+ receiver = NULL;
+}
+
+void ControlClient::on_receiver_error(const Runnable::Error& code,
+ const string& desc) {
+ signal_error().emit(code, string("Receiver Error: ") + desc);
+}
+
ControlClient::SignalOKReceived& ControlClient::signal_ok_received(void) {
return ok_received;
}
}
// TODO - temporal
-Receiver::SignalFrameReceived& ControlClient::signal_frame_received(void) {
+ControlClient::SignalFrameReceived& ControlClient::signal_frame_received(void) {
// XXX - cuidado, esto puede dar quilombo si no esta protegido por un mutex,
// aunque no deberia porque la señal no es llamada hasta que no se empice
// la transmision y la señal se conecta antes de pedir la transmision.