ConnectionError ConnectionTCPServer::recv( int timeout )
{
    m_recvMutex.lock();

    if( m_cancel || m_socket < 0 || !m_connectionHandler )
    {
        m_recvMutex.unlock();
        return ConnNotConnected;
    }

    if( !dataAvailable( timeout ) )
    {
        m_recvMutex.unlock();
        return ConnNoError;
    }

    struct sockaddr_in they;
    int sin_size = sizeof( struct sockaddr_in );
#ifdef WIN32
    int newfd = accept( m_socket, (struct sockaddr*)&they, &sin_size );
#else
    int newfd = accept( m_socket, (struct sockaddr*)&they, (socklen_t*)&sin_size );
#endif

    m_recvMutex.unlock();

    ConnectionTCPClient* conn = new ConnectionTCPClient( m_logInstance, inet_ntoa( they.sin_addr ),
            ntohs( they.sin_port ) );
    conn->setSocket( newfd );
    m_connectionHandler->handleIncomingConnection( conn );

    return ConnNoError;
}

ctkDICOMHostMainLogic::ctkDICOMHostMainLogic(ctkHostedAppPlaceholderWidget* placeHolder, ctkDICOMAppWidget* dicomAppWidget, 
                                             QWidget* placeHolderForControls) : 
  QObject(placeHolder), 
  PlaceHolderForHostedApp(placeHolder),
  DicomAppWidget(dicomAppWidget),
  PlaceHolderForControls(placeHolderForControls),
  ValidSelection(false),
  SendData(false)
{
  this->Host = new ctkExampleDicomHost(PlaceHolderForHostedApp);
  this->HostControls = new ctkExampleHostControlWidget(Host, PlaceHolderForControls);

  Data = new ctkDicomAppHosting::AvailableData;

  disconnect(this->Host,SIGNAL(startProgress()),this->Host,SLOT(onStartProgress()));
  connect(this->Host,SIGNAL(appReady()),this,SLOT(onAppReady()), Qt::QueuedConnection);
  connect(this->Host,SIGNAL(startProgress()),this,SLOT(publishSelectedData()), Qt::QueuedConnection);
  connect(this->PlaceHolderForHostedApp,SIGNAL(resized()),this,SLOT(placeHolderResized()));

  QTreeView * treeview = dicomAppWidget->findChild<QTreeView*>("TreeView");
  QItemSelectionModel* selectionmodel = treeview->selectionModel();
  connect(selectionmodel, SIGNAL(selectionChanged ( const QItemSelection &, const QItemSelection & )),
    this, SLOT(onTreeSelectionChanged(const QItemSelection &, const QItemSelection &)));

  connect(this->Host, SIGNAL(dataAvailable()), this, SLOT(onDataAvailable()));

  connect( qApp, SIGNAL(aboutToQuit()), this, SLOT(aboutToQuit()) );
}

bool LH_MonitoringSource_Fraps::doUpdate()
{
#ifndef Q_OS_WIN
    return false;
#else
    HMODULE frapsDLL;
    FRAPS_SHARED_DATA *fsd;
#ifdef Q_PROCESSOR_X86_32
    frapsDLL = GetModuleHandleA("FRAPS32.DLL");
#else
    frapsDLL = GetModuleHandleA("FRAPS64.DLL");
#endif
    bool resultVal = false;

    setDataAvailable(frapsDLL != NULL);
    if(!dataAvailable()) // Not running
        pingFraps();
    else {
        FrapsSharedData = (FRAPS_SHARED_DATA *(WINAPI *)()) GetProcAddress(frapsDLL, "FrapsSharedData");

        if (!FrapsSharedData)
        {
            qWarning() << "This version of Fraps is incompatible with LCDHost: Fraps 1.9C or later is required!";
        } else {
            fsd = FrapsSharedData();
            updateValue("Current FPS","","",(int)fsd->currentFPS, fps_);
            updateValue("Game Name","","",fsd->gameName);
            //updateValue("Total Frames","","",(int)fsd->totalFrames);
            //updateValue("Time of Last Frame","","",(int)fsd->timeOfLastFrame);
            resultVal = true;
        }
    }
    return resultVal;
#endif
}

TextTraceHandler::TextTraceHandler(QIODevice *device, QObject *parent)
: QObject(parent)
{
    d = new TextTraceHandlerPrivate;
    d->device = device;
    connect(device, SIGNAL(readyRead()), this, SLOT(dataAvailable()));
}

bool SensorfwRotationSensor::doConnect()
{
    Q_ASSERT(m_sensorInterface);
    if (m_bufferSize==1)
       return QObject::connect(m_sensorInterface, SIGNAL(dataAvailable(XYZ)), this, SLOT(slotDataAvailable(XYZ)));
    return QObject::connect(m_sensorInterface, SIGNAL(frameAvailable(QVector<XYZ>)),this, SLOT(slotFrameAvailable(QVector<XYZ>)));
}

void ServerSocket::handleData()
{
    /*  qWarning() << "void ServerSocket::handleSocketData()" << m_bufferedData << m_bufferedData.size();
      int datasize = m_bufferedData.size();
      if((!(datasize % 4)) && datasize < 20)
      {
        if(m_bufferedData.contains(Command::playerlist))
        {
    //       qWarning() << "Playerlist requested; ID: " << m_id;
          emit playerlistRequested(m_id);
        }
        else if(m_bufferedData.contains(Command::ohsocketIdent))
        {
    //       m_ident = true;
          killSocketTimer();
        }
        else if(m_bufferedData.contains(Command::playerReady))
        {
          emit playerReady(m_id);
        }
        else
          emit dataAvailable(m_id);
      }
      else*/
    emit dataAvailable(m_id);
}

void
SmugMug::WebService::_slotHttpRequestFinished (int id, bool error) {

    qDebug () << "Request Finished: " << id;

    if (error) {

        _logHttpError (QString ("Request Finished: %1").arg (id));
    }
    else {

        emit dataAvailable (_dataIn);

        bool err = false;

        QDomDocument doc;
        if (doc.setContent (_dataIn)) {

            QDomElement root = doc.documentElement();

            if (!_isResponseValid (root)) {

                err = true;
                _responseFailed (root);
            }

            _handleResponse (id, root, err);
        }

        emit actionFinished ();
        qDebug () << "actionFinished: " << id;
    }
}

bool LabelToolPlugin::visualizeImgCb(label_tool_msgs::ImagesToLabel::Request &req,
                                     label_tool_msgs::ImagesToLabel::Response &res)
{
  reset();

  // copy data on class structure
  for(auto &img : req.images)
  {
    // convert to opencv mat
    cv_bridge::CvImagePtr cv_ptr;
    try
    {
      cv_ptr = cv_bridge::toCvCopy(img, img.encoding);
    }
    catch (cv_bridge::Exception& e)
    {
      ROS_ERROR("cv_bridge exception: %s", e.what());
      return false;
    }


    std::vector<cv::Point> polygon_edges;

    ImgWithPolygon img_with_poly_class;
    img_with_poly_class.img_ = cv_ptr->image;
    img_with_poly_class.polygon_edges_ = polygon_edges;
    img_with_polygons_.push_back(img_with_poly_class);
  }

  emit dataAvailable();
  return true;
}

void QmlProfilerModelManager::complete()
{
    switch (state()) {
    case QmlProfilerDataState::ProcessingData:
        setState(QmlProfilerDataState::Done);
        emit dataAvailable();
        break;
    case QmlProfilerDataState::AcquiringData:
        // If trace end time was not explicitly set, use the last event
        if (d->traceTime->endTime() == 0)
            d->traceTime->setEndTime(d->model->lastTimeMark());
        setState(QmlProfilerDataState::ProcessingData);
        d->model->complete();
        d->v8Model->complete();
        break;
    case QmlProfilerDataState::Empty:
        setState(QmlProfilerDataState::Done);
        break;
    case QmlProfilerDataState::Done:
        break;
    default:
        emit error(tr("Unexpected complete signal in data model."));
        break;
    }
}

int MG2639_Cell::readWaitForResponses(const char * goodRsp, 
                                      const char * failRsp, unsigned int timeout)
{
	unsigned long timeIn = millis(); // Timestamp coming into function
	unsigned int received = 0; // received keeps track of number of chars read
	
	clearBuffer(); // Clear the class receive buffer (rxBuffer)
	while (timeIn + timeout > millis()) // While we haven't timed out
	{
		if (dataAvailable()) // If data is available on UART RX
		{
			// Increment received count & read byte to buffer
			received += readByteToBuffer();
			if (searchBuffer(goodRsp))
				return received; // If we've received [goodRsp], return received
			if (searchBuffer(failRsp)) // If we've received [failRsp]
				return ERROR_FAIL_RESPONSE; // return FAIL response error code
		}
	}
	
	if (received > 0) // If we received any characters
		return ERROR_UNKNOWN_RESPONSE;	// Return unkown response error code
	else // If we haven't received any characters
		return ERROR_TIMEOUT; // Return the timeout error code
}

bool QBluetoothSocketPrivate::setSocketDescriptor(const QAndroidJniObject &socket, QBluetoothServiceInfo::Protocol socketType_,
                         QBluetoothSocket::SocketState socketState, QBluetoothSocket::OpenMode openMode)
{
    Q_Q(QBluetoothSocket);

    if (q->state() != QBluetoothSocket::UnconnectedState || !socket.isValid())
        return false;

    if (!ensureNativeSocket(socketType_))
        return false;

    socketObject = socket;

    QAndroidJniEnvironment env;
    inputStream = socketObject.callObjectMethod("getInputStream", "()Ljava/io/InputStream;");
    outputStream = socketObject.callObjectMethod("getOutputStream", "()Ljava/io/OutputStream;");

    if (env->ExceptionCheck() || !inputStream.isValid() || !outputStream.isValid()) {
        env->ExceptionDescribe();
        env->ExceptionClear();

        //close socket again
        socketObject.callMethod<void>("close");
        if (env->ExceptionCheck()) {
            env->ExceptionDescribe();
            env->ExceptionClear();
        }

        socketObject = inputStream = outputStream = remoteDevice = QAndroidJniObject();


        errorString = QBluetoothSocket::tr("Obtaining streams for service failed");
        q->setSocketError(QBluetoothSocket::NetworkError);
        q->setSocketState(QBluetoothSocket::UnconnectedState);
        return false;
    }

    remoteDevice = socketObject.callObjectMethod("getRemoteDevice", "()Landroid/bluetooth/BluetoothDevice;");

    if (inputThread) {
        inputThread->deleteLater();
        inputThread = 0;
    }
    inputThread = new InputStreamThread(this);
    QObject::connect(inputThread, SIGNAL(dataAvailable()),
                     q, SIGNAL(readyRead()), Qt::QueuedConnection);
    QObject::connect(inputThread, SIGNAL(error(int)),
                     this, SLOT(inputThreadError(int)), Qt::QueuedConnection);
    inputThread->run();


    q->setSocketState(socketState);
    q->setOpenMode(openMode | QIODevice::Unbuffered);

    if (openMode == QBluetoothSocket::ConnectedState)
        emit q->connected();

    return true;
}

bool SensorfwMagnetometer::doConnect()
{
    Q_ASSERT(m_sensorInterface);
    if (m_bufferSize==1)
        return QObject::connect(m_sensorInterface, SIGNAL(dataAvailable(MagneticField)),
                                this, SLOT(slotDataAvailable(MagneticField)));
     return QObject::connect(m_sensorInterface, SIGNAL(frameAvailable(QVector<MagneticField>)),
                             this, SLOT(slotFrameAvailable(QVector<MagneticField>)));
}

void UDPServer::handleDataRequest(QString data)
{
    qDebug() << "UDPServer::handleDataRequest called with data:" << data;
    QString cmd = data.section(';',1,1).toLower();
    switch (COMMANDS.indexOf(cmd.section(' ',0,0)))
    {
    case 0: // Help command (help)
        qDebug() << "help command called";
        sendHelp();
        break;
    case 1: // List devices command (lsdvs)
        qDebug() << "List devices command called";
        sendDeviceList();
        break;
    case 2: // Select device command (sldvc)
        qDebug() << "Select device command called";
        selectDevice(cmd);
        break;
    case 3: // Deselect device command (dsdvc)
        qDebug() << "Deselect device command called";
        deselectDevice();
        break;
    case 4: // List buttons command (lsbts)
        qDebug() << "List buttons command called";
        listButtons();
        break;
    case 5: // Keymap command (kmap)
        qDebug() << "Keymap command called";
        mapKey(cmd);
        break;
    case 6: // Undo keymap command (umap)
        qDebug() << "Undo keymap command called";
        unmapKey(cmd);
        break;
    case 7: // Supported devices command (supdvs)
        qDebug() << "Supported devices command called";
        supportedDevices(cmd);
        break;
    case 8: // Axis Format Map (afmap)
        qDebug() << "Axis Format Map command called";
        axisFormatMap(cmd);
        break;
    case 9: // Axis Key Map (akmap)
        qDebug() << "Axis Key Map command called";
        axisKeyMap(cmd);
        break;
    default:
        qDebug() << "Command not recognised";
        QString reply = "10;";
        reply += "\'" + cmd.section(' ',0,0) + "\'";
        reply += " is not recognized as a command, use the \'help\' command for more information";
        sendDatagram(reply.toLatin1());
        break;
    }

    emit dataAvailable(data);
}

bool AccelerometerSensorChannelInterface::dataReceivedImpl()
{
    QVector<AccelerationData> values;
    if(!read<AccelerationData>(values))
        return false;
    if(!frameAvailableConnected || values.size() == 1)
    {
        foreach(const AccelerationData& data, values)
            emit dataAvailable(XYZ(data));
    }

void ONBinaryProtocol::Detach(bool keepBuffer)
{
    disconnect(this, SLOT(dataAvailable()));

    _device = nullptr;

    if (! keepBuffer) {
        _buffer.clear();
    }
}

bool DataLink::foundFrameStart()
{
	//const uint16_t MAX_BYTES_TO_INSPECT = maxFrameSize()*10;

	bool slipEscape = false;
	uint16_t inspected = 0;
	int c = 0;

	// TODO - Jordan: Break out into separate function?

	// Look for start character and break out when found
	while(true)
	{
		// Read enough characters for now, go do something else
		if(inspected >= 100)
		{
			return false;
		}

		inspected++;
		if(not dataAvailable())
		{
			//std::cout << "NOTHING AVAILABLE ;(" << std::endl;
			continue;
		}


		c = readByte();

		// No characters left to read
		if(c == -1)
		{
			return false;
		}

		if((uint8_t)c == SLIP_PACKET_START && not slipEscape)
		{				
			break;
		}

		if((uint8_t)c == SLIP_PACKET_ESCAPE)
		{				
			slipEscape = true;
		}
		else
		{				
			slipEscape = false;
		}

		//std::this_thread::sleep_for(std::chrono::milliseconds(2));
	}

	return true;

}

void eHTTPStream::haveData(void *vdata, int len)
{
	__u8 *data=(__u8*)vdata;
	
	while (len)
	{
		int valid=len;
		if (!metadataleft)
		{
				// not in metadata mode.. process mp3 data (stream to input buffer)

				// are we just at the beginning of metadata? (pointer)
			if (metadatainterval && (metadatainterval == bytes))
			{
						// enable metadata mode
				metadataleft=*data++*16;
				metadatapointer=0;
				len--;
				bytes=0;
				continue;
			} else if (metadatainterval && (metadatainterval < bytes))
				eFatal("metadatainterval < bytes");

				// otherwise there's really data.
			if (metadatainterval)
			{
					// is metadata in our buffer?
				if ((valid + bytes) > metadatainterval)
					valid=metadatainterval-bytes;
			}
			buffer.write(data, valid);
			data+=valid;
			len-=valid;
			bytes+=valid;
		} else
		{
				// metadata ... process it.
			int meta=len;
			if (meta > metadataleft)
				meta=metadataleft;

			memcpy(metadata+metadatapointer, data, meta);

			metadatapointer+=meta;
			data+=meta;
			len-=meta;
			metadataleft-=meta;
			
			if (!metadataleft)
				processMetaData();
		}
	}
	dataAvailable();
}

void main(void)
{
	/* Configure the oscillator for the device */
	ConfigureOscillator();



	/* Initialize I/O and Peripherals for application */
	 InitApp();

	W5200_nRESET = 0;
	__delay_us(5);
	W5200_nRESET = 1;
	__delay_ms(50);
	__delay_ms(50);
	__delay_ms(50);
	__delay_ms(50);
	
	/* Initialize application settings */
	InitSettings();
	
	/* Initialize TCP server */
	initServer(&macAddress, &gateway, &netmask);
	startServer(&localEndpoint);

        LED = 1;

    while(1)
    {
		if(clientConnected())
		{
			if(dataAvailable())
			{
				uint16_t length = getReceivedLength();
				if(length > MAX_BUFFER)
				{
					// Limit maximum buffer size to avoid ram saturation due to packet flooding, a normal communication is shorter anyway
					length = MAX_BUFFER;
				}
				
				uint8_t buffer[MAX_BUFFER];
				getReceivedData(buffer, length);
				
				parseCommand(buffer[0], buffer, length);
				
				stopServer();
				startServer(&localEndpoint);
			}
			checkClientDisconnection();
		}		
    }

}

  ConnectionError ConnectionTCPClient::recv( int timeout )
  {
    m_recvMutex.lock();

    if( m_cancel || m_socket < 0 )
    {
      m_recvMutex.unlock();
      return ConnNotConnected;
    }

    if( !dataAvailable( timeout ) )
    {
      m_recvMutex.unlock();
      return ConnNoError;
    }

    int size = static_cast<int>( ::recv( m_socket, m_buf, m_bufsize, 0 ) );
    if( size > 0 )
      m_totalBytesIn += size;

    m_recvMutex.unlock();

    if( size <= 0 )
    {
      if( size == -1 )
      {
        // recv() failed for an unexpected reason
        std::string message = "recv() failed. "
#if defined( _WIN32 ) && !defined( __SYMBIAN32__ )
          "WSAGetLastError: " + util::int2string( ::WSAGetLastError() );
#else
          "errno: " + util::int2string( errno ) + ": " + strerror( errno );
#endif
        m_logInstance.err( LogAreaClassConnectionTCPClient, message );
      }

      ConnectionError error = ( size ? ConnIoError : ConnStreamClosed );
      if( m_handler )
        m_handler->handleDisconnect( this, error );
      return error;
    }

    m_buf[size] = '\0';
    
    // KEVIN
    printf("RECV: %d\n", size);

    if( m_handler )
      m_handler->handleReceivedData( this, std::string( m_buf, size ) );

    return ConnNoError;
  }

void AudioSourceOss::read()
{
    struct audio_oss_internal *oss =
            (struct audio_oss_internal *)internal_data;
    unsigned char buf[BUF_SIZE];
    unsigned char* buffer = buf;
    int got = 0;
    while ( got < BUF_SIZE ) {
        int r = ::read(oss->fd, buffer+got, BUF_SIZE-got);
        got += r;
    }
    emit dataAvailable( (short*)buf, BUF_SIZE/2 );
}