ApplicationManagement.cpp

Go to the documentation of this file.

#include "include/ApplicationManagement.h"

ApplicationManagement::ApplicationManagement(Manager *man, bool bt, bool ut, bool app) :
    m_can((FakeCANProvider*)man->hashMap["CAN"]),
    m_gps((FakeGPSProvider*)man->hashMap["GPS"]),
    m_network((ParameterNetwork*)man->hashMap["Network"]),
    m_bt(bt),
    m_hasUt(ut)
{
    /* CAN & GPS initialization */
    if(app)
    {
        QObject::connect(m_can, SIGNAL(canChanged()), this, SLOT(situationChanged()));
        QObject::connect(m_gps, SIGNAL(positionChanged()), this, SLOT(situationChanged()));
    }

    /* BT initialization */
    if(m_bt)
    {
        QBluetoothLocalDevice localAdapter;
        QString localDeviceName;

        rfcommServer = new QBluetoothServer(QBluetoothServiceInfo::RfcommProtocol, this);
      //  QObject::connect(rfcommServer, SIGNAL(newConnection()), this, SLOT(clientConnected()));

        if(localAdapter.isValid())
        {
            // Turn Bluetooth on
            qInfo() << "Turning on Bluetooth device";
            localAdapter.powerOn();

            // Read local device name
            qInfo() << "Reading Bluetooth device name";
            localDeviceName = localAdapter.name();
            qInfo() << "Local adapter is named" << localDeviceName;

            // Make it visible to others
            qInfo() << "Making Bluetooth device visible";
            localAdapter.setHostMode(QBluetoothLocalDevice::HostDiscoverable);

            if(!rfcommServer->listen(localAdapter.address()))
            {
                qWarning() << "Cannot bind application manager to" << localAdapter.address().toString();
                m_bt = false;
            }
            else
            {
                qInfo() << "Listening to" << localAdapter.address().toString();
                /* Textual description */
//                serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceName, tr("GeoNet application bluetooth server"));
//                serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceDescription, tr("Make bluetooth connection between HMI "
//                                                                                       "and GeoNet application"));
//                serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceProvider, tr("URCA"));
                serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceName, tr("DENM BT forwarder"));
                serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceDescription, tr("Forward DENM from and to Android"));
                serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceProvider, tr("URCA"));
                qInfo() << "Textual description set";

                /* UUID definition */
                QBluetoothServiceInfo::Sequence classId;
                static const QLatin1String serviceUuid("76931fac-9dab-2b36-9ccf-c248b87d6ae3");
  //              static const QLatin1String serviceUuid("e8e10f95-1a70-4b27-9ccf-02010264e9c8");

                classId << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::SerialPort));
                serviceInfo.setAttribute(QBluetoothServiceInfo::BluetoothProfileDescriptorList, classId);

                classId.prepend(QVariant::fromValue(QBluetoothUuid(serviceUuid)));

                serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceClassIds, classId);

                serviceInfo.setServiceUuid(QBluetoothUuid(serviceUuid));
                qInfo() << "UUID set to" << serviceInfo.serviceUuid();
                qInfo() << "ServicesClassInfo" << serviceInfo.serviceClassUuids();

                /* Making BT discoverable */
                QBluetoothServiceInfo::Sequence publicBrowse;
                publicBrowse << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::PublicBrowseGroup));
                serviceInfo.setAttribute(QBluetoothServiceInfo::BrowseGroupList, publicBrowse);
                qInfo() << "BT discoverable";

                /* ProtocolDescriptorList */
                QBluetoothServiceInfo::Sequence protocolDescriptorList;
                QBluetoothServiceInfo::Sequence protocol;
                protocol << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::L2cap));
                protocolDescriptorList.append(QVariant::fromValue(protocol));
                protocol.clear();
                protocol << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::Rfcomm))
                         << QVariant::fromValue(quint8(rfcommServer->serverPort()));
                protocolDescriptorList.append(QVariant::fromValue(protocol));
                serviceInfo.setAttribute(QBluetoothServiceInfo::ProtocolDescriptorList, protocolDescriptorList);
                qInfo() << "PDL set";

                /* Service registering */
                bool foo = serviceInfo.registerService(localAdapter.address());
                qInfo() << "Service registration" << foo;

                qInfo() << "BT resume" << rfcommServer->serverAddress().toString() << rfcommServer->serverPort()
                        << rfcommServer->serverType();

                QObject::connect(rfcommServer, SIGNAL(newConnection()), this, SLOT(clientConnected()));

                QObject::connect(this, SIGNAL(btMessageReceived(QByteArray)), this, SLOT(sendMessageToFac(QByteArray)));
            }
        }
        else
        {
            qWarning() << "No connected Bluetooth device found";
            delete rfcommServer;
            rfcommServer = 0;
            m_bt = false;
        }
    }

    /* UDP initialization */
    m_udpSocket = new QUdpSocket(this);
    m_udpSocket->bind();
    QObject::connect(m_udpSocket, SIGNAL(readyRead()), this, SLOT(readUdpSocket()));
    QObject::connect(this, SIGNAL(udpMessageReceived(QByteArray)), this, SLOT(sendMessageToBt(QByteArray)));
    m_network->addPort("Application", m_udpSocket->localPort());
    qDebug() << "Application" << m_udpSocket->localPort();

    /* UT Initialization */
    if(m_hasUt)
    {
        m_ut = (ParameterUpperTester*)man->hashMap["UpperTester"];
        m_utSocket = new QUdpSocket(this);
        m_utSocket->open(QIODevice::ReadWrite);
        m_utSocket->bind();
        m_network->addPort("ApplicationUT", m_utSocket->localPort());
        qDebug() << "ApplicationUT" << m_utSocket->localPort();
        QObject::connect(m_utSocket, SIGNAL(readyRead()), this, SLOT(readUtSocket()));
        QObject::connect(this, SIGNAL(utMessageReceived(QByteArray)), this, SLOT(sendMessageToFac(QByteArray)));
    }

}

ApplicationManagement::~ApplicationManagement()
{
    qDebug() << "Deleting application management";
    if(m_bt)
    {
        /* Unregister service */
        serviceInfo.unregisterService();

        /* Close sockets */
        qDeleteAll(clientSockets);

        /* Close server */
        delete rfcommServer;
        rfcommServer = 0;
    }
}

void ApplicationManagement::clientConnected()
{
    QBluetoothSocket *socket = rfcommServer->nextPendingConnection();
    if(!socket)
        return;

    qInfo() << "There is a new client connected" << socket->peerName();

    clientSockets.append(socket);
    QObject::connect(clientSockets.last(), SIGNAL(readyRead()), this, SLOT(readBtSocket()));
    QObject::connect(clientSockets.last(), SIGNAL(disconnected()), this, SLOT(clientDisconnected()));
}

void ApplicationManagement::readBtSocket()
{
    QBluetoothSocket *socket = qobject_cast<QBluetoothSocket *>(sender());
    if(!socket)
        return;

    qInfo() << "Receiving data from BT";
    QByteArray line = socket->readAll();
    qInfo() << line.toHex() << "received from" << socket->peerName();
    emit btMessageReceived(line);
}

void ApplicationManagement::clientDisconnected()
{
    QBluetoothSocket *socket = qobject_cast<QBluetoothSocket *>(sender());
    if(!socket)
        return;

    qInfo() << socket->peerName() << "disconnected";
    clientSockets.removeOne(socket);
    socket->deleteLater();
}

void ApplicationManagement::sendMessageToBt(const QByteArray &message)
{
    qint64 size;
    QByteArray msg;

    qInfo() << "I have to sent" << message.toHex() << "to BT / UT";
    if(m_bt)
    {
        foreach (QBluetoothSocket *socket, clientSockets)
        {
            qInfo() << "Sending" << message.toHex() << "to" << socket->peerName();
            msg = transformMessageToBT(message);
            qInfo() << "Sending" << msg.toHex() << "to BT";
            size = socket->write(msg);
            qInfo() << size << "Bytes sent to BT";
        }
    }
    if(m_hasUt)
    {
        quint16 utPort = getUtPort(message.at(0));
        if(utPort != 0)
        {
            m_udpSocket->writeDatagram(message, QHostAddress::LocalHost, utPort);
            qDebug() << message.toHex() << "sent to UT" << utPort;
        }
        else
            qInfo() << "This message is not supposed to be sent to UT";
    }
}

void ApplicationManagement::readUdpSocket()
{
    QUdpSocket *socket = qobject_cast<QUdpSocket*>(sender());
    while(socket->hasPendingDatagrams())
    {
        qDebug() << socket->localPort() << "in readUdpSocket" << socket->state();
        QNetworkDatagram datagram = socket->receiveDatagram();
        qInfo() << datagram.data().toHex() << "received from facilities";
        emit udpMessageReceived(datagram.data());
        qInfo() << "readUdpSocket emit data";
    }
}

void ApplicationManagement::situationChanged(){}

void ApplicationManagement::sendMessageToFac(const QByteArray &message)
{
    switch (message.at(0))
    {
    case 0x10:
    case 0x12:
    case 0x14:
        qDebug() << "Application sends" << message.toHex() << m_network->internalPort("DENM");
        m_udpSocket->writeDatagram(message, QHostAddress::LocalHost, m_network->internalPort("DENM"));
        break;
    default:
        break;
    }
}

void ApplicationManagement::readUtSocket()
{
    while(m_utSocket->hasPendingDatagrams())
    {
        QNetworkDatagram datagram = m_utSocket->receiveDatagram();
        m_utPort = datagram.senderPort();
        qInfo() << datagram.data().toHex() << "received from UT";
        emit utMessageReceived(datagram.data());
    }
}

QByteArray ApplicationManagement::transformMessageToBT(const QByteArray &message)
{
    QByteArray ret = message;
    DENM_t *denm = 0;
    ValidityDuration_t validity = 600;
    long unsigned int detectionTime;

    switch (message[0])
    {
    case 0x17:
        uper_decode_complete(NULL, &asn_DEF_DENM, (void**)&denm, message.right(message.length() - 3), message.length() - 3);
        asn_fprint(stdout, &asn_DEF_DENM, denm);
        if(denm->denm.management.validityDuration)
            validity = *denm->denm.management.validityDuration;
        asn_INTEGER2ulong((const INTEGER_t*)&denm->denm.management.detectionTime, &detectionTime);
        qInfo() << "Transforming AppDENMIndication";
        ret = AppDenmIndication::toBluetooth(*denm, (detectionTime + (validity * 1000) - m_gps->timestamp()) / 1000);
        qInfo() << ret.toHex();
        break;
    default:
        break;
    }

    return ret;
}

quint16 ApplicationManagement::getUtPort(const char mt)
{
    quint16 port = m_ut->upperTesterEventIndicationListenPort();

    switch((unsigned char)mt)
    {
    case 0x16:
        port = m_network->internalPort("UpperTester");
        break;
    case 0x18:
        port = 0;
    default:
        break;
    }

    return port;
}