LedDisplay/OmobiDisplayApp/omobidisplaybackend.cpp

#include "omobidisplaybackend.h"

OmobiDisplayBackend::OmobiDisplayBackend(QObject *parent) : QObject(parent)
{
    this->ble = new QBluetoothLeUart();
    this->ble->setUUIDs("92fecb20-1406-426a-afa5-cd5c1f306462", "92fecb21-1406-426a-afa5-cd5c1f306462", "92fecb22-1406-426a-afa5-cd5c1f306462");
    this->displayTextModel = new OmobiDisplayTextModel(this);
    this->textSetsBuffer.clear();
    this->displayBrightness = -1;
    this->waitingCommands = 0;

    this->keepAliveTimer = new QTimer(this);
    this->keepAliveTimer->setInterval(5000);
    this->keepAliveTimer->setSingleShot(false);
    connect(this->keepAliveTimer, &QTimer::timeout, this, &OmobiDisplayBackend::sendBluetoothKeepAlive);

    connect(this->ble, &QBluetoothLeUart::stateChanged, this, &OmobiDisplayBackend::handleBluetoothStateChange);
    connect(this->ble, &QBluetoothLeUart::foundNewDevice, this, &OmobiDisplayBackend::handleFoundNewDevice);
    connect(this->ble, &QBluetoothLeUart::dataReceived, this, &OmobiDisplayBackend::handleBluetoothDataReceived);
    connect(this->ble, &QBluetoothLeUart::connectedToDevice, this, &OmobiDisplayBackend::handleBluetoothDeviceConected);
    connect(this->displayTextModel, &OmobiDisplayTextModel::dataChanged, this, &OmobiDisplayBackend::handleDisplayTextModelDataChanged);
    connect(this->displayTextModel, &OmobiDisplayTextModel::rowsInserted, this, &OmobiDisplayBackend::handleDisplayTextModelRowsInserted);
    connect(this->displayTextModel, &OmobiDisplayTextModel::rowsRemoved, this, &OmobiDisplayBackend::handleDisplayTextModelRowsRemoved);

    this->setState(Idle);
    this->ble->startScanningForDevices();

    qDebug() << QCryptographicHash::hash("HalloTest", QCryptographicHash::Sha256).toHex();
    // dd86fcfda3a20cbb8fbb3026a84550e0d70c2c79e7e8e36d6ffa04b9eef0401f
    // dd86fcfda3a20cbb8fbb3026a84550e0d70c2c79e7e8e36d6ffa04b9eef0401f
}


void OmobiDisplayBackend::startScanning() {
    this->ble->startScanningForDevices();
}

void OmobiDisplayBackend::handleBluetoothStateChange(QBluetoothLeUart::BluetoothLeUartState state){
    switch(state){
    case QBluetoothLeUart::Idle: {
        this->setState(Idle);
        break;
    }
    case QBluetoothLeUart::Scanning: {
        this->setState(Scanning);
        break;
    }
    case QBluetoothLeUart::ScanFinished: {
        this->setState(ReadyToConnect);
        break;
    }
    case QBluetoothLeUart::Connecting: {
        this->setState(Connecting);
        break;
    }
    case QBluetoothLeUart::ScanningForService: {
        this->setState(Connecting);
        break;
    }
    case QBluetoothLeUart::ServiceFound: {
        this->setState(Connecting);
        break;
    }
    case QBluetoothLeUart::Connected:
    {
        break;
    }
    }

    if(state == QBluetoothLeUart::Connected)
        this->keepAliveTimer->start();
    else if(this->keepAliveTimer->isActive())
        this->keepAliveTimer->stop();
}

void OmobiDisplayBackend::handleBluetoothDeviceConected() {
    this->setState(Initing);

    // tell display to send over existing model data
    this->sendBluetoothCommand(AuthorizeSessionCommand, QVariantMap{{"secret", QCryptographicHash::hash("1234", QCryptographicHash::Sha256).toHex()}});
    this->sendBluetoothCommand(GetAllTextSetsCommand);
    this->sendBluetoothCommand(GetDisplayBrightnessCommand);
}

void OmobiDisplayBackend::handleFoundNewDevice(QBluetoothLeUartDevice* device) {
    qDebug() << "Found a device: name: " << device->getName() << " address: " << device->getAddress();
}

void OmobiDisplayBackend::handleDisplayTextModelDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles) {

    qDebug() << "Data changed: topLeft: " << topLeft << " bottomRight: " << bottomRight << " roles: " << roles;

    for(int role : roles)
        this->updateDisplayTextSetParameter(topLeft.row(), role);
}

void OmobiDisplayBackend::handleDisplayTextModelRowsInserted(const QModelIndex &parent, int first, int last) {
    qDebug() << "Rows inserted: parent: " << parent << " first: " << first << " last " << last;
    for(int i = 0; i < OmobiDisplayTextModel::OmobiDisplayTextModelRoleCount; i++) {
        this->updateDisplayTextSetParameter(first, i);
    }
}

void OmobiDisplayBackend::handleDisplayTextModelRowsRemoved(const QModelIndex &parent, int first, int last) {
    qDebug() << "Rows removed: parent: " << parent << " first: " << first << " last " << last;
    // Setting Text to "" will delete the item
    this->updateDisplayTextSetParameter(first, OmobiDisplayTextModel::TextRole, "");
}


void OmobiDisplayBackend::sendBluetoothCommand(OmobiDisplayCommand command, QVariant data) {
    QVariantMap commandMap = {
        {"header", command},
        {"data", data}
    };

    QJsonDocument doc = QJsonDocument::fromVariant(commandMap);

    qDebug() << "Sending command: \n" << qPrintable(doc.toJson(QJsonDocument::Indented));

    this->waitingCommands ++;

    if(this->state == Connected)
        this->setState(Loading);

    this->ble->sendData(doc.toJson(QJsonDocument::Compact));
}

void OmobiDisplayBackend::sendBluetoothKeepAlive() {
    QJsonDocument doc = QJsonDocument::fromVariant(QVariantMap{{"header", KeepAliveCommand}});

    qDebug() << "Sending keep alive: \n" << qPrintable(doc.toJson(QJsonDocument::Indented));

    this->ble->sendData(doc.toJson(QJsonDocument::Compact));
}

void OmobiDisplayBackend::handleBluetoothDataReceived(QString s){
    qDebug() << "New data: \n" << qPrintable(s);

    QJsonParseError parseError;
    QJsonDocument doc = QJsonDocument::fromJson(s.toUtf8(), &parseError);

    if(parseError.error != QJsonParseError::NoError)
        return;

    OmobiDisplayCommand header = OmobiDisplayCommand(doc.toVariant().toMap()["header"].toInt());
    QVariantMap data = doc.toVariant().toMap()["data"].toMap();
    OmobiDisplayStatusCode status = OmobiDisplayStatusCode(doc.toVariant().toMap()["status"].toInt());

    switch (header) {
    case AuthorizeSessionCommand: {
        // TODO: handle error
        this->refreshLoadingState();
        break;
    }
    case KeepAliveCommand: {
        break;
    }

    case GetAllTextSetsCommand: {
        // indicates that all existing txt sets have been sent over after GetAllTextSetsCommand was called
        if(status != Success)
            // TODO: handle error
            break;

        this->displayTextModel->maximumTextLength = data["maximumTextLength"].toInt();
        this->displayTextModel->maximumTextSets = data["maximumTextSets"].toInt();

        this->displayTextModel->setTexts(this->textSetsBuffer);
        this->textSetsBuffer.clear();

        this->refreshLoadingState();

        break;
    }
    case GetTextSetParameterCommand: {

        int index = data["index"].toInt();

        if(index < 0)
            return;

        while(this->textSetsBuffer.length() <= index)
            this->textSetsBuffer.append(QMap<int, QVariant>());

        int parameter = data["parameter"].toInt();

        if(!this->textSetsBuffer[index].contains(parameter))
            this->textSetsBuffer[index].insert(parameter, QVariant());

        this->textSetsBuffer[index][parameter] = data["value"].toString();

        if(this->state != Initing)
            this->refreshLoadingState();

        break;
    }
    case GetDisplayBrightnessCommand: {
        this->setDisplayBrightness(data["displayBrightness"].toInt());
        this->refreshLoadingState();
        break;
    }
    case SetTextSetParameterCommand: {
        // TODO: Error handling
        this->refreshLoadingState();
        break;
    }
    case SetDisplayBrightnessCommand: {
        // TODO: Error handling
        this->refreshLoadingState();
        break;
    }

    }
}


void OmobiDisplayBackend::updateDisplayTextSetParameter(int index, int parameter) {
    this->updateDisplayTextSetParameter(index, parameter, this->displayTextModel->data(index, parameter).toString());
}

void OmobiDisplayBackend::updateDisplayTextSetParameter(int index, int parameter, QString value) {
    if(this->state == Initing)
        return;
    qDebug() << "Updating data at index: " << index << " parameter: " << parameter << " and value: " << value;

    QVariantMap dataMap = {
        {"index", index},
        {"parameter", parameter},
        {"value", value}
    };

    this->sendBluetoothCommand(SetTextSetParameterCommand, dataMap);
}

QBluetoothLeUart* OmobiDisplayBackend::getBleController() {
    return this->ble;
}


OmobiDisplayTextModel* OmobiDisplayBackend::getDisplayTextModel() {
    return this->displayTextModel;
}

OmobiDisplayBackend::OmobiDisplayAppState OmobiDisplayBackend::getState() {
    return this->state;
}

void OmobiDisplayBackend::refreshLoadingState() {
    if(this->state != Initing && this->state != Loading)
        return;

    qDebug() << "Refreshing loading state! Waiting: " << this->waitingCommands;

    if(this->waitingCommands <= 1) {
        this->waitingCommands = 0;
        this->setState(Connected);
    }
    else
        this->waitingCommands--;
}

void OmobiDisplayBackend::setState(OmobiDisplayAppState state) {
    if(state == this->state)
        return;

    this->state = state;
    emit this->stateChanged();

    qDebug() << "Now in " << state << " state";

    if(this->state == Idle)
        this->ble->startScanningForDevices();
}

int OmobiDisplayBackend::getDisplayBrightness() {
    return this->displayBrightness;
}

void OmobiDisplayBackend::setDisplayBrightness(int brightness) {
    if(brightness == this->displayBrightness)
        return;

    this->displayBrightness = brightness;

    this->sendBluetoothCommand(SetDisplayBrightnessCommand, QVariantMap{{"displayBrightness",this->displayBrightness}});

    emit this->displayBrightnessChanged();
}