// After calling Start(), the delegate will receive an OnResponseStarted
// callback when the request has completed. If an error occurred, the
// request->status() will be set. On success, all redirects have been
// followed and the final response is beginning to arrive. At this point,
// meta data about the response is available, including for example HTTP
// response headers if this is a request for a HTTP resource.
void WebRequest::OnResponseStarted(net::URLRequest* request)
{
ASSERT(m_loadState == Started, "Got response after receiving response");
// SAMSUNG CHANGES : add_network_log
LOGIFDEBUG("OnResponseStarted() url(%s) isMainFrame(%d) isMainResource(%d)", m_url.c_str(), m_isMainFrame, m_isMainResource);
// SAMSUNG CHANGE: read timer stop
timer_.Stop();
// SAMSUNG CHANGE
m_loadState = Response;
//SAMSUNG_CHANGES >>
m_webResponse = new WebResponse(request);
if (request && request->status().is_success()) {
if(m_rssSniffingEnabled)
{
std::string mimeType = m_webResponse->getMimeType();
if(m_isMainResource && m_isMainFrame && HTTP_OK == m_webResponse->getStatusCode() && (TYPE_TEXT_XML == mimeType || TYPE_APPLICATION_XML == mimeType)) {
m_ShouldSniffFeed = true;
startReading();
return;
}
if(TYPE_ATOM == mimeType ||TYPE_RDF == mimeType || TYPE_RSS == mimeType)
m_webResponse-> setMimeType(TYPE_MAYBE_FEED );
}
//SAMSUNG_CHANGES <<
m_urlLoader->maybeCallOnMainThread(NewRunnableMethod(
m_urlLoader.get(), &WebUrlLoaderClient::didReceiveResponse, m_webResponse.release()));
// Start reading the response
startReading();
} else {
finish(false);
}
}
void ZDvidBufferReader::read(const QString &url, bool outputingUrl)
{
if (outputingUrl) {
qDebug() << url;
}
m_buffer.clear();
#if defined(_ENABLE_LIBDVIDCPP_)
// qDebug() << "Using libdvidcpp";
ZDvidTarget target;
target.setFromUrl(url.toStdString());
if (target.isValid()) {
try {
libdvid::DVIDNodeService service(
target.getAddressWithPort(), target.getUuid());
std::string endPoint = ZDvidUrl::GetEndPoint(url.toStdString());
libdvid::BinaryDataPtr data = service.custom_request(
endPoint, libdvid::BinaryDataPtr(), libdvid::GET, m_tryingCompress);
m_buffer.append(data->get_data().c_str(), data->length());
m_status = READ_OK;
} catch (std::exception &e) {
std::cout << e.what() << std::endl;
m_status = READ_FAILED;
}
} else {
startReading();
m_networkReply = m_networkManager->get(QNetworkRequest(url));
connect(m_networkReply, SIGNAL(finished()), this, SLOT(finishReading()));
connect(m_networkReply, SIGNAL(readyRead()), this, SLOT(readBuffer()));
connect(m_networkReply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(handleError(QNetworkReply::NetworkError)));
waitForReading();
}
#else
startReading();
m_networkReply = m_networkManager->get(QNetworkRequest(url));
connect(m_networkReply, SIGNAL(finished()), this, SLOT(finishReading()));
connect(m_networkReply, SIGNAL(readyRead()), this, SLOT(readBuffer()));
connect(m_networkReply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(handleError(QNetworkReply::NetworkError)));
waitForReading();
#endif
}
// Called when the a Read of the response body is completed after an
// IO_PENDING status from a Read() call.
// The data read is filled into the buffer which the caller passed
// to Read() previously.
//
// If an error occurred, request->status() will contain the error,
// and bytes read will be -1.
void WebRequest::OnReadCompleted(net::URLRequest* request, int bytesRead)
{
ASSERT(m_loadState == Response || m_loadState == GotData, "OnReadCompleted in state other than RESPONSE and GOTDATA");
if (request->status().is_success()) {
//SAMSUNG_CHANGES >>
if(m_rssSniffingEnabled)
{
if( m_ShouldSniffFeed) {
std::string currentMimeType, newMimeType;
bool sniffResult = false;
GURL sniffURL(m_url);
m_request->GetMimeType(¤tMimeType);
sniffResult = net::SniffMimeType(m_networkBuffer->data(), bytesRead, sniffURL,currentMimeType, &newMimeType);
m_ShouldSniffFeed = false;
if(TYPE_ATOM == newMimeType ||TYPE_RDF == newMimeType || TYPE_RSS == newMimeType)
m_webResponse-> setMimeType(TYPE_MAYBE_FEED );
m_urlLoader->maybeCallOnMainThread(NewRunnableMethod(
m_urlLoader.get(), &WebUrlLoaderClient::didReceiveResponse, m_webResponse.release()));
}
}
//SAMSUNG_CHANGES <<
m_loadState = GotData;
m_urlLoader->maybeCallOnMainThread(NewRunnableMethod(
m_urlLoader.get(), &WebUrlLoaderClient::didReceiveData, m_networkBuffer, bytesRead));
m_networkBuffer = 0;
// Get the rest of the data
startReading();
} else {
finish(false);
}
}
void Widget::toggleReading()
{
if (!m_timer->isActive())
startReading();
else
stopReading();
}
// Read all the values and store into the device
static void __srf08_read(SENSOR* sensor) {
Devantech_SRF08* device = (Devantech_SRF08*)sensor;
if(startReading(device)) {
getReading(device);
}
}
SettingsUI::SettingsUI(QWidget *parent) :
QWidget(parent),
ui(new Ui::SettingsUI)
{
ui->setupUi(this);
connect(ui->pushButton_startTest, SIGNAL(clicked()), this, SLOT(startReading()));
connect(ui->pushButton_endTest, SIGNAL(clicked()), this, SLOT(endTest()));
first = true;
}
void ZDvidBufferReader::readHead(const QString &url)
{
startReading();
qDebug() << url;
m_networkReply = m_networkManager->head(QNetworkRequest(url));
connect(m_networkReply, SIGNAL(finished()), this, SLOT(finishReading()));
connect(m_networkReply, SIGNAL(readyRead()), this, SLOT(readBuffer()));
connect(m_networkReply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(handleError(QNetworkReply::NetworkError)));
waitForReading();
}
bool FileParser::startReading()
{
bool couldRead = true;
endOfFile_ = false;
reading_ = true;
if(!startReading(0))
{
couldRead = false;
endOfFile_ = true;
}
return couldRead;
}
// Called when the a Read of the response body is completed after an
// IO_PENDING status from a Read() call.
// The data read is filled into the buffer which the caller passed
// to Read() previously.
//
// If an error occurred, request->status() will contain the error,
// and bytes read will be -1.
void WebRequest::OnReadCompleted(net::URLRequest* request, int bytesRead)
{
ASSERT(m_loadState == Response || m_loadState == GotData, "OnReadCompleted in state other than RESPONSE and GOTDATA");
if (request->status().is_success()) {
m_loadState = GotData;
m_urlLoader->maybeCallOnMainThread(NewRunnableMethod(
m_urlLoader.get(), &WebUrlLoaderClient::didReceiveData, m_networkBuffer, bytesRead));
m_networkBuffer = 0;
// Get the rest of the data
startReading();
} else {
finish(false);
}
}
// After calling Start(), the delegate will receive an OnResponseStarted
// callback when the request has completed. If an error occurred, the
// request->status() will be set. On success, all redirects have been
// followed and the final response is beginning to arrive. At this point,
// meta data about the response is available, including for example HTTP
// response headers if this is a request for a HTTP resource.
void WebRequest::OnResponseStarted(net::URLRequest* request)
{
ASSERT(m_loadState == Started, "Got response after receiving response");
m_loadState = Response;
if (request && request->status().is_success()) {
OwnPtr<WebResponse> webResponse(new WebResponse(request));
m_urlLoader->maybeCallOnMainThread(NewRunnableMethod(
m_urlLoader.get(), &WebUrlLoaderClient::didReceiveResponse, webResponse.release()));
// Start reading the response
startReading();
} else {
finish(false);
}
}
bool ZDvidBufferReader::hasHead(const QString &url)
{
startReading();
qDebug() << url;
m_networkReply = m_networkManager->head(QNetworkRequest(url));
connect(m_networkReply, SIGNAL(readyRead()), this, SLOT(finishReading()));
connect(m_networkReply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(handleError(QNetworkReply::NetworkError)));
waitForReading();
return m_status == READ_OK;
}
void ZDvidBufferReader::readQt(const QString &url, bool outputUrl)
{
if (outputUrl) {
qDebug() << url;
}
m_buffer.clear();
startReading();
m_networkReply = m_networkManager->get(QNetworkRequest(url));
connect(m_networkReply, SIGNAL(finished()), this, SLOT(finishReading()));
connect(m_networkReply, SIGNAL(readyRead()), this, SLOT(readBuffer()));
connect(m_networkReply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(handleError(QNetworkReply::NetworkError)));
waitForReading();
}
bool ZDvidBufferReader::isReadable(const QString &url)
{
QTimer::singleShot(5000, this, SLOT(handleTimeout()));
startReading();
qDebug() << url;
m_networkReply = m_networkManager->get(QNetworkRequest(url));
//return m_networkReply->error() == QNetworkReply::NoError;
connect(m_networkReply, SIGNAL(readyRead()), this, SLOT(finishReading()));
connect(m_networkReply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(handleError(QNetworkReply::NetworkError)));
waitForReading();
return m_status == READ_OK;
}
void main()
{
// Placa Generica - Implementacion del protocolo
init();
// Init del protocol
initProtocol();
// FOREVER
while(true)
{
// Ejecucion de la maquina de estados
switch (state)
{
case STATE_FREE:
/*
* Analiza los paquetes y retransmite o lanza el pedido de lectura
*/
#if TRIGGER_TYPE == SWITCH_SENSOR
// Enviar alarma de trigger
if (triggerAlarm == 1)
sendAlarm();
#endif
// Protocolo
runProtocol(&command);
if (readSensor != 0x00)
{
// Almacena el pedido sobre los sensores
actualReadSensor = readSensor;
readSensor = 0x00;
actalTO = requestFrom;
actalCmd = requestCmd;
// Cambio de estado
state = STATE_START_READING;
}
break;
case STATE_START_READING:
/*
* Genera un pedido de lectura a los sensores que lo necesiten
* y setea los TIMERs para contabilizar los tiempos
*/
// Limpio la variable
bufferedReadSensor = 0x00;
// Inhabilita los sensores enmascarados
actualReadSensor &= sensorMask;
// Pedido de -START-
startReading(actualReadSensor);
// Flag de interrupcion
intTMR = 0;
// Seteo de TIMERs
set_timer1(SENSORS_WAITING_TIME);
enable_interrupts(INT_TIMER1);
// Cambio de estado
state = STATE_WAIT_TO_READ;
break;
case STATE_WAIT_TO_READ:
/*
* Espera el tiempo necesario para tomar las muestras en los sensores
* Recibe nuevos pedidos y los agraga para una proxima lectura
*/
#if TRIGGER_TYPE == SWITCH_SENSOR
// Enviar alarma de trigger
if (triggerAlarm == 1)
sendAlarm();
#endif
// Protocolo
runProtocol(&command);
// Almacena el pedido sobre los sensores si no hay otro ya
if ((readSensor != 0x00) && (bufferedReadSensor == 0x00))
{
bufferedReadSensor = readSensor;
bufferedFrom = requestFrom;
bufferedCmd = requestCmd;
readSensor = 0x00;
}
// Cambio de estado?
if (intTMR == 1)
{
// El TIMER1 hizo timeout -> leer sensores
state = STATE_READ_VALUES;
}
break;
case STATE_READ_VALUES:
/*
* Toma las muestras en los sensores y envia el paquete de respuesta
*/
// Toma las muestras de los sensores
readSensors(actualReadSensor);
// Mandar paquete de respuesta
sendValues(actalTO, actalCMD, values, actualReadSensor);
// Flag de interrupcion
intTMR = 0;
// Setea el tiempo de espera y pasa al estado de espera
set_timer1(WAITING_TIME);
enable_interrupts(INT_TIMER1);
state = STATE_WAITING;
break;
case STATE_WAITING:
/*
* Espera a que pase el tiempo de espera entre lecturas para evitar rebotes
* Recibe nuevos pedidos y los agraga para una proxima lectura
*/
#if TRIGGER_TYPE == SWITCH_SENSOR
// Enviar alarma de trigger
if (triggerAlarm == 1)
sendAlarm();
#endif
// Protocolo
runProtocol(&command);
// Almacena el pedido sobre los sensores si no hay otro ya
if ((readSensor != 0x00) && (bufferedReadSensor == 0x00))
{
bufferedReadSensor = readSensor;
bufferedFrom = requestFrom;
bufferedCmd = requestCmd;
readSensor = 0x00;
}
// Cambio de estado?
if (intTMR == 1)
{
// El TIMER1 hizo timeout
if (bufferedReadSensor != 0x00)
{
// Hay un pedido pendiente y lo carga
actualReadSensor = bufferedReadSensor;
bufferedReadSensor = 0x00;
actalTO = bufferedFrom;
actalCmd = bufferedCmd;
// Cambio de estado
state = STATE_START_READING;
} else {
state = STATE_FREE;
}
}
break;
default:
init();
break;
}
}
return;
}
