diff --git a/libnymea-networkmanager/bluetooth/bluetoothserver.cpp b/libnymea-networkmanager/bluetooth/bluetoothserver.cpp new file mode 100644 index 0000000..eec76de --- /dev/null +++ b/libnymea-networkmanager/bluetooth/bluetoothserver.cpp @@ -0,0 +1,409 @@ +#include "bluetoothserver.h" +#include "../networkmanager.h" +#include "../networkmanagerutils.h" + +BluetoothServer::BluetoothServer(NetworkManager *networkManager) : + QObject(networkManager), + m_networkManager(networkManager) +{ + +} + +BluetoothServer::~BluetoothServer() +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "Destroy bluetooth server."; + if (m_controller) + m_controller->stopAdvertising(); + + if (m_localDevice) + m_localDevice->setHostMode(QBluetoothLocalDevice::HostConnectable); + +} + +QString BluetoothServer::modelName() const +{ + return m_modelName; +} + +void BluetoothServer::setModelName(const QString &modelName) +{ + m_modelName = modelName; +} + +QString BluetoothServer::serverName() const +{ + return m_serverName; +} + +void BluetoothServer::setServerName(const QString &serverName) +{ + m_serverName = serverName; +} + +QString BluetoothServer::softwareVersion() const +{ + return m_softwareVersion; +} + +void BluetoothServer::setSoftwareVersion(const QString &softwareVersion) +{ + m_softwareVersion = softwareVersion; +} + +bool BluetoothServer::running() const +{ + return m_running; +} + +bool BluetoothServer::connected() const +{ + return m_connected; +} + +QLowEnergyServiceData BluetoothServer::deviceInformationServiceData() +{ + QLowEnergyServiceData serviceData; + serviceData.setType(QLowEnergyServiceData::ServiceTypePrimary); + serviceData.setUuid(QBluetoothUuid::DeviceInformation); + + // Model number string 0x2a24 + QLowEnergyCharacteristicData modelNumberCharData; + modelNumberCharData.setUuid(QBluetoothUuid::ModelNumberString); + if (m_modelName.isEmpty()) { + modelNumberCharData.setValue(QString("N.A.").toUtf8()); + } else { + modelNumberCharData.setValue(m_modelName.toUtf8()); + } + + modelNumberCharData.setProperties(QLowEnergyCharacteristic::Read); + serviceData.addCharacteristic(modelNumberCharData); + + // Firmware revision string 0x2a26 + QLowEnergyCharacteristicData firmwareRevisionCharData; + firmwareRevisionCharData.setUuid(QBluetoothUuid::FirmwareRevisionString); + firmwareRevisionCharData.setValue(QString(VERSION_STRING).toUtf8()); + firmwareRevisionCharData.setProperties(QLowEnergyCharacteristic::Read); + serviceData.addCharacteristic(firmwareRevisionCharData); + + // Hardware revision string 0x2a27 + QLowEnergyCharacteristicData hardwareRevisionCharData; + hardwareRevisionCharData.setUuid(QBluetoothUuid::HardwareRevisionString); + hardwareRevisionCharData.setValue(m_hardwareVersion.toUtf8()); + hardwareRevisionCharData.setProperties(QLowEnergyCharacteristic::Read); + serviceData.addCharacteristic(hardwareRevisionCharData); + + // Software revision string 0x2a28 + QLowEnergyCharacteristicData softwareRevisionCharData; + softwareRevisionCharData.setUuid(QBluetoothUuid::SoftwareRevisionString); + softwareRevisionCharData.setValue(m_softwareVersion.toUtf8()); + softwareRevisionCharData.setProperties(QLowEnergyCharacteristic::Read); + serviceData.addCharacteristic(softwareRevisionCharData); + + // Manufacturer name string 0x2a29 + QLowEnergyCharacteristicData manufacturerNameCharData; + manufacturerNameCharData.setUuid(QBluetoothUuid::ManufacturerNameString); + manufacturerNameCharData.setValue(QString("guh GmbH").toUtf8()); + manufacturerNameCharData.setProperties(QLowEnergyCharacteristic::Read); + serviceData.addCharacteristic(manufacturerNameCharData); + + return serviceData; +} + +QLowEnergyServiceData BluetoothServer::genericAccessServiceData() +{ + QLowEnergyServiceData serviceData; + serviceData.setType(QLowEnergyServiceData::ServiceTypePrimary); + serviceData.setUuid(QBluetoothUuid::GenericAccess); + + // Device name 0x2a00 + QLowEnergyCharacteristicData nameCharData; + nameCharData.setUuid(QBluetoothUuid::DeviceName); + nameCharData.setValue(m_serverName.toUtf8()); + nameCharData.setProperties(QLowEnergyCharacteristic::Read); + serviceData.addCharacteristic(nameCharData); + + // Appearance 0x2a01 + QLowEnergyCharacteristicData appearanceCharData; + appearanceCharData.setUuid(QBluetoothUuid::Appearance); + appearanceCharData.setValue(QByteArray(4, 0)); + appearanceCharData.setProperties(QLowEnergyCharacteristic::Read); + serviceData.addCharacteristic(appearanceCharData); + + // Peripheral Privacy Flag 0x2a02 + QLowEnergyCharacteristicData privacyFlagCharData; + privacyFlagCharData.setUuid(QBluetoothUuid::PeripheralPrivacyFlag); + privacyFlagCharData.setValue(QByteArray(2, 0)); + privacyFlagCharData.setProperties(QLowEnergyCharacteristic::Read | QLowEnergyCharacteristic::Write); + serviceData.addCharacteristic(privacyFlagCharData); + + // Reconnection Address 0x2a03 + QLowEnergyCharacteristicData reconnectionAddressCharData; + reconnectionAddressCharData.setUuid(QBluetoothUuid::ReconnectionAddress); + reconnectionAddressCharData.setValue(QByteArray()); + reconnectionAddressCharData.setProperties(QLowEnergyCharacteristic::Write); + serviceData.addCharacteristic(reconnectionAddressCharData); + + return serviceData; +} + +QLowEnergyServiceData BluetoothServer::genericAttributeServiceData() +{ + QLowEnergyServiceData serviceData; + serviceData.setType(QLowEnergyServiceData::ServiceTypePrimary); + serviceData.setUuid(QBluetoothUuid::GenericAttribute); + + QLowEnergyCharacteristicData charData; + charData.setUuid(QBluetoothUuid::ServiceChanged); + charData.setProperties(QLowEnergyCharacteristic::Indicate); + + serviceData.addCharacteristic(charData); + + return serviceData; +} + +void BluetoothServer::setRunning(bool running) +{ + if (m_running == running) + return; + + m_running = running; + emit runningChanged(m_running); +} + +void BluetoothServer::setConnected(bool connected) +{ + if (m_connected == connected) + return; + + m_connected = connected; + emit connectedChanged(m_connected); +} + +void BluetoothServer::onHostModeStateChanged(const QBluetoothLocalDevice::HostMode mode) +{ + switch (mode) { + case QBluetoothLocalDevice::HostConnectable: + qCDebug(dcNetworkManagerBluetoothServer()) << "Bluetooth host in connectable mode."; + break; + case QBluetoothLocalDevice::HostDiscoverable: + qCDebug(dcNetworkManagerBluetoothServer()) << "Bluetooth host in discoverable mode."; + break; + case QBluetoothLocalDevice::HostPoweredOff: + qCDebug(dcNetworkManagerBluetoothServer()) << "Bluetooth host in power off mode."; + break; + case QBluetoothLocalDevice::HostDiscoverableLimitedInquiry: + qCDebug(dcNetworkManagerBluetoothServer()) << "Bluetooth host in discoverable limited inquiry mode."; + break; + } +} + +void BluetoothServer::onDeviceConnected(const QBluetoothAddress &address) +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "Device connected" << address.toString(); +} + +void BluetoothServer::onDeviceDisconnected(const QBluetoothAddress &address) +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "Device disconnected" << address.toString(); +} + +void BluetoothServer::onError(QLowEnergyController::Error error) +{ + qCWarning(dcNetworkManagerBluetoothServer()) << "Bluetooth error occured:" << error << m_controller->errorString(); +} + +void BluetoothServer::onConnected() +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "Client connected" << m_controller->remoteName() << m_controller->remoteAddress(); + setConnected(true); +} + +void BluetoothServer::onDisconnected() +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "Client disconnected"; + setConnected(false); + stop(); +} + +void BluetoothServer::onControllerStateChanged(QLowEnergyController::ControllerState state) +{ + switch (state) { + case QLowEnergyController::UnconnectedState: + qCDebug(dcNetworkManagerBluetoothServer()) << "Controller state disonnected."; + setConnected(false); + break; + case QLowEnergyController::ConnectingState: + qCDebug(dcNetworkManagerBluetoothServer()) << "Controller state connecting..."; + setConnected(false); + break; + case QLowEnergyController::ConnectedState: + qCDebug(dcNetworkManagerBluetoothServer()) << "Controller state connected." << m_controller->remoteName() << m_controller->remoteAddress(); + setConnected(true); + break; + case QLowEnergyController::DiscoveringState: + qCDebug(dcNetworkManagerBluetoothServer()) << "Controller state discovering..."; + break; + case QLowEnergyController::DiscoveredState: + qCDebug(dcNetworkManagerBluetoothServer()) << "Controller state discovered."; + break; + case QLowEnergyController::ClosingState: + qCDebug(dcNetworkManagerBluetoothServer()) << "Controller state closing..."; + break; + case QLowEnergyController::AdvertisingState: + qCDebug(dcNetworkManagerBluetoothServer()) << "Controller state advertising..."; + setRunning(true); + break; + } +} + +void BluetoothServer::characteristicChanged(const QLowEnergyCharacteristic &characteristic, const QByteArray &value) +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "Service characteristic changed" << characteristic.uuid() << value; +} + +void BluetoothServer::characteristicRead(const QLowEnergyCharacteristic &characteristic, const QByteArray &value) +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "Service characteristic read" << characteristic.uuid() << value; +} + +void BluetoothServer::characteristicWritten(const QLowEnergyCharacteristic &characteristic, const QByteArray &value) +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "Service characteristic written" << characteristic.uuid() << value; +} + +void BluetoothServer::descriptorRead(const QLowEnergyDescriptor &descriptor, const QByteArray &value) +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "Descriptor read" << descriptor.uuid() << value; +} + +void BluetoothServer::descriptorWritten(const QLowEnergyDescriptor &descriptor, const QByteArray &value) +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "Descriptor written" << descriptor.uuid() << value; +} + +void BluetoothServer::serviceError(QLowEnergyService::ServiceError error) +{ + QString errorString; + switch (error) { + case QLowEnergyService::NoError: + errorString = "No error"; + break; + case QLowEnergyService::OperationError: + errorString = "Operation error"; + break; + case QLowEnergyService::CharacteristicReadError: + errorString = "Characteristic read error"; + break; + case QLowEnergyService::CharacteristicWriteError: + errorString = "Characteristic write error"; + break; + case QLowEnergyService::DescriptorReadError: + errorString = "Descriptor read error"; + break; + case QLowEnergyService::DescriptorWriteError: + errorString = "Descriptor write error"; + break; + case QLowEnergyService::UnknownError: + errorString = "Unknown error"; + break; + } + + qCWarning(dcNetworkManagerBluetoothServer()) << "Service error:" << errorString; +} + +void BluetoothServer::start() +{ + if (connected()) { + qCDebug(dcNetworkManagerBluetoothServer()) << "Start Bluetooth server called but the server is running and a client is connected. Doing nothing."; + return; + } + + if (running()) { + qCDebug(dcNetworkManagerBluetoothServer()) << "Start Bluetooth server called but the server is already running. Doing nothing."; + return; + } + + qCDebug(dcNetworkManagerBluetoothServer()) << "-------------------------------------"; + qCDebug(dcNetworkManagerBluetoothServer()) << "Starting bluetooth server..."; + qCDebug(dcNetworkManagerBluetoothServer()) << "-------------------------------------"; + + // Local bluetooth device + m_localDevice = new QBluetoothLocalDevice(this); + if (!m_localDevice->isValid()) { + qCWarning(dcNetworkManagerBluetoothServer()) << "Local bluetooth device is not valid."; + delete m_localDevice; + m_localDevice = nullptr; + return; + } + + connect(m_localDevice, &QBluetoothLocalDevice::hostModeStateChanged, this, &BluetoothServer::onHostModeStateChanged); + connect(m_localDevice, &QBluetoothLocalDevice::deviceConnected, this, &BluetoothServer::onDeviceConnected); + connect(m_localDevice, &QBluetoothLocalDevice::deviceDisconnected, this, &BluetoothServer::onDeviceDisconnected); + + qCDebug(dcNetworkManagerBluetoothServer()) << "Local device" << m_localDevice->name() << m_localDevice->address().toString(); + m_localDevice->setHostMode(QBluetoothLocalDevice::HostDiscoverable); + m_localDevice->powerOn(); + + + // Bluetooth low energy periperal controller + m_controller = QLowEnergyController::createPeripheral(this); + connect(m_controller, &QLowEnergyController::stateChanged, this, &BluetoothServer::onControllerStateChanged); + connect(m_controller, &QLowEnergyController::connected, this, &BluetoothServer::onConnected); + connect(m_controller, &QLowEnergyController::disconnected, this, &BluetoothServer::onDisconnected); + connect(m_controller, SIGNAL(error(QLowEnergyController::Error)), this, SLOT(onError(QLowEnergyController::Error))); + + // Note: https://www.bluetooth.com/specifications/gatt/services + m_deviceInfoService = m_controller->addService(deviceInformationServiceData(), m_controller); + m_genericAccessService = m_controller->addService(genericAccessServiceData(), m_controller); + m_genericAttributeService = m_controller->addService(genericAttributeServiceData(), m_controller); + + // Create custom services + m_networkService = new NetworkService(m_controller->addService(NetworkService::serviceData(), m_controller), m_controller); + m_wirelessService = new WirelessService(m_controller->addService(WirelessService::serviceData(), m_controller), m_controller); + + QLowEnergyAdvertisingData advertisingData; + advertisingData.setDiscoverability(QLowEnergyAdvertisingData::DiscoverabilityGeneral); + advertisingData.setIncludePowerLevel(true); + advertisingData.setLocalName(m_serverName); + + // FIXME: set guh manufacturer SIG data once available + + // Note: start advertising in 100 ms interval, this makes the device better discoverable on certain phones + QLowEnergyAdvertisingParameters advertisingParameters; + advertisingParameters.setInterval(100,100); + + qCDebug(dcNetworkManagerBluetoothServer()) << "Start advertising" << m_serverName << m_localDevice->address().toString(); + m_controller->startAdvertising(advertisingParameters, advertisingData, advertisingData); + + // Start the advertising timer + setRunning(true); +} + +void BluetoothServer::stop() +{ + if (connected() && m_controller) { + m_controller->disconnectFromDevice(); + return; + } + + qCDebug(dcNetworkManagerBluetoothServer()) << "-------------------------------------"; + qCDebug(dcNetworkManagerBluetoothServer()) << "Stopping bluetooth server."; + qCDebug(dcNetworkManagerBluetoothServer()) << "-------------------------------------"; + + if (m_controller) { + qCDebug(dcNetworkManagerBluetoothServer()) << "Stop advertising."; + m_controller->stopAdvertising(); + delete m_controller; + m_controller = nullptr; + } + + if (m_localDevice) { + qCDebug(dcNetworkManagerBluetoothServer()) << "Set host mode to connectable."; + m_localDevice->setHostMode(QBluetoothLocalDevice::HostConnectable); + delete m_localDevice; + m_localDevice = nullptr; + } + + setConnected(false); + setRunning(false); +} diff --git a/libnymea-networkmanager/bluetooth/bluetoothserver.h b/libnymea-networkmanager/bluetooth/bluetoothserver.h new file mode 100644 index 0000000..171ae1a --- /dev/null +++ b/libnymea-networkmanager/bluetooth/bluetoothserver.h @@ -0,0 +1,105 @@ +#ifndef BLUETOOTHSERVER_H +#define BLUETOOTHSERVER_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "networkservice.h" +#include "wirelessservice.h" + +class NetworkManager; + +class BluetoothServer : public QObject +{ + Q_OBJECT +public: + explicit BluetoothServer(NetworkManager *networkManager); + ~BluetoothServer(); + + // Information for the device info service + QString modelName() const; + void setModelName(const QString &modelName); + + QString serverName() const; + void setServerName(const QString &serverName); + + QString softwareVersion() const; + void setSoftwareVersion(const QString &softwareVersion); + + QString hardwareVersion() const; + void setHardwareVersion(const QString &hardwareVersion); + + bool running() const; + bool connected() const; + +private: + QString m_modelName; + QString m_serverName; + QString m_softwareVersion; + QString m_hardwareVersion; + + NetworkManager *m_networkManager = nullptr; + QBluetoothLocalDevice *m_localDevice = nullptr; + QLowEnergyController *m_controller = nullptr; + + QLowEnergyService *m_deviceInfoService = nullptr; + QLowEnergyService *m_genericAccessService = nullptr; + QLowEnergyService *m_genericAttributeService = nullptr; + + NetworkService *m_networkService = nullptr; + WirelessService *m_wirelessService = nullptr; + + bool m_running = false; + bool m_connected = false; + + QLowEnergyServiceData deviceInformationServiceData(); + QLowEnergyServiceData genericAccessServiceData(); + QLowEnergyServiceData genericAttributeServiceData(); + + void setRunning(bool running); + void setConnected(bool connected); + +signals: + void runningChanged(const bool &running); + void connectedChanged(const bool &connected); + +private slots: + // Local bluetooth device + void onHostModeStateChanged(QBluetoothLocalDevice::HostMode mode); + void onDeviceConnected(const QBluetoothAddress &address); + void onDeviceDisconnected(const QBluetoothAddress &address); + void onError(QLowEnergyController::Error error); + + // Bluetooth controller + void onConnected(); + void onDisconnected(); + void onControllerStateChanged(QLowEnergyController::ControllerState state); + + // Services + void characteristicChanged(const QLowEnergyCharacteristic &characteristic, const QByteArray &value); + void characteristicRead(const QLowEnergyCharacteristic &characteristic, const QByteArray &value); + void characteristicWritten(const QLowEnergyCharacteristic &characteristic, const QByteArray &value); + void descriptorRead(const QLowEnergyDescriptor &descriptor, const QByteArray &value); + void descriptorWritten(const QLowEnergyDescriptor &descriptor, const QByteArray &value); + void serviceError(QLowEnergyService::ServiceError error); + +public slots: + void start(); + void stop(); + +}; + +#endif // BLUETOOTHSERVER_H diff --git a/libnymea-networkmanager/bluetooth/bluetoothuuids.h b/libnymea-networkmanager/bluetooth/bluetoothuuids.h new file mode 100644 index 0000000..bdf420e --- /dev/null +++ b/libnymea-networkmanager/bluetooth/bluetoothuuids.h @@ -0,0 +1,35 @@ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * * + * Copyright (C) 2016 Simon Stürz * + * * + * This file is part of loopd. * + * * + * Loopd can not be copied and/or distributed without the express * + * permission of guh GmbH. * + * * + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +#ifndef BLUETOOTHUUIDS_H +#define BLUETOOTHUUIDS_H + +#include + +static QBluetoothUuid networkServiceUuid = QBluetoothUuid(QUuid("ef6d6610-b8af-49e0-9eca-ab343513641c")); +static QBluetoothUuid networkStatusCharacteristicUuid = QBluetoothUuid(QUuid("ef6d6611-b8af-49e0-9eca-ab343513641c")); +static QBluetoothUuid networkCommanderCharacteristicUuid = QBluetoothUuid(QUuid("ef6d6612-b8af-49e0-9eca-ab343513641c")); +static QBluetoothUuid networkResponseCharacteristicUuid = QBluetoothUuid(QUuid("ef6d6613-b8af-49e0-9eca-ab343513641c")); +static QBluetoothUuid networkingEnabledCharacteristicUuid = QBluetoothUuid(QUuid("ef6d6614-b8af-49e0-9eca-ab343513641c")); +static QBluetoothUuid wirelessEnabledCharacteristicUuid = QBluetoothUuid(QUuid("ef6d6615-b8af-49e0-9eca-ab343513641c")); + +static QBluetoothUuid wirelessServiceUuid = QBluetoothUuid(QUuid("e081fec0-f757-4449-b9c9-bfa83133f7fc")); +static QBluetoothUuid wirelessCommanderCharacteristicUuid = QBluetoothUuid(QUuid("e081fec1-f757-4449-b9c9-bfa83133f7fc")); +static QBluetoothUuid wirelessResponseCharacteristicUuid = QBluetoothUuid(QUuid("e081fec2-f757-4449-b9c9-bfa83133f7fc")); +static QBluetoothUuid wirelessStateCharacteristicUuid = QBluetoothUuid(QUuid("e081fec3-f757-4449-b9c9-bfa83133f7fc")); + +static QBluetoothUuid systemServiceUuid = QBluetoothUuid(QUuid("e081fed0-f757-4449-b9c9-bfa83133f7fc")); +static QBluetoothUuid systemCommanderCharacteristicUuid = QBluetoothUuid(QUuid("e081fed1-f757-4449-b9c9-bfa83133f7fc")); +static QBluetoothUuid systemResponseCharacteristicUuid = QBluetoothUuid(QUuid("e081fed2-f757-4449-b9c9-bfa83133f7fc")); +static QBluetoothUuid systemUpdateCharacteristicUuid = QBluetoothUuid(QUuid("e081fed3-f757-4449-b9c9-bfa83133f7fc")); + + +#endif // BLUETOOTHUUIDS_H diff --git a/libnymea-networkmanager/bluetooth/networkservice.cpp b/libnymea-networkmanager/bluetooth/networkservice.cpp new file mode 100644 index 0000000..007aa41 --- /dev/null +++ b/libnymea-networkmanager/bluetooth/networkservice.cpp @@ -0,0 +1,325 @@ +#include "networkservice.h" +#include "bluetoothuuids.h" + +#include +#include + +NetworkService::NetworkService(QLowEnergyService *service, NetworkManager *networkManager, QObject *parent) : + QObject(parent), + m_service(service), + m_networkManager(networkManager) +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "Create NetworkService."; + + // Service + connect(m_service, SIGNAL(characteristicChanged(QLowEnergyCharacteristic, QByteArray)), this, SLOT(characteristicChanged(QLowEnergyCharacteristic, QByteArray))); + connect(m_service, SIGNAL(characteristicRead(QLowEnergyCharacteristic, QByteArray)), this, SLOT(characteristicChanged(QLowEnergyCharacteristic, QByteArray))); + connect(m_service, SIGNAL(characteristicWritten(QLowEnergyCharacteristic, QByteArray)), this, SLOT(characteristicWritten(QLowEnergyCharacteristic, QByteArray))); + connect(m_service, SIGNAL(descriptorWritten(QLowEnergyDescriptor, QByteArray)), this, SLOT(descriptorWritten(QLowEnergyDescriptor, QByteArray))); + connect(m_service, SIGNAL(error(QLowEnergyService::ServiceError)), this, SLOT(serviceError(QLowEnergyService::ServiceError))); + + // NetworkManager + connect(Loopd::instance()->networkManager(), &NetworkManager::stateChanged, this, &NetworkService::onNetworkManagerStateChanged); + connect(Loopd::instance()->networkManager(), &NetworkManager::networkingEnabledChanged, this, &NetworkService::onNetworkingEnabledChanged); + connect(Loopd::instance()->networkManager(), &NetworkManager::wirelessEnabledChanged, this, &NetworkService::onWirelessEnabledChanged); +} + +QLowEnergyService *NetworkService::service() +{ + return m_service; +} + +QLowEnergyServiceData NetworkService::serviceData() +{ + QLowEnergyServiceData serviceData; + serviceData.setType(QLowEnergyServiceData::ServiceTypePrimary); + serviceData.setUuid(networkServiceUuid); + + QLowEnergyDescriptorData clientConfigDescriptorData(QBluetoothUuid::ClientCharacteristicConfiguration, QByteArray(2, 0)); + + // Network manager status ef6d661-b8af-49e0-9eca-ab343513641c + QLowEnergyCharacteristicData networkStatusData; + networkStatusData.setUuid(networkStatusCharacteristicUuid); + networkStatusData.setValue(QByteArray(1, 0)); + networkStatusData.setProperties(QLowEnergyCharacteristic::Read | QLowEnergyCharacteristic::Notify); + networkStatusData.addDescriptor(clientConfigDescriptorData); + networkStatusData.setValue(NetworkService::getNetworkManagerStateByteArray(Loopd::instance()->networkManager()->state())); + serviceData.addCharacteristic(networkStatusData); + + // Network manager commander ef6d6612-b8af-49e0-9eca-ab343513641c + QLowEnergyCharacteristicData networkCommanderCharacteristicData; + networkCommanderCharacteristicData.setUuid(networkCommanderCharacteristicUuid); + networkCommanderCharacteristicData.setProperties(QLowEnergyCharacteristic::Write); + networkCommanderCharacteristicData.setValueLength(1, 1); + serviceData.addCharacteristic(networkCommanderCharacteristicData); + + // Response characteristic ef6d6613-b8af-49e0-9eca-ab343513641c + QLowEnergyCharacteristicData networkResponseCharacteristicData; + networkResponseCharacteristicData.setUuid(networkResponseCharacteristicUuid); + networkResponseCharacteristicData.setProperties(QLowEnergyCharacteristic::Notify); + networkResponseCharacteristicData.addDescriptor(clientConfigDescriptorData); + networkResponseCharacteristicData.setValueLength(1, 1); + serviceData.addCharacteristic(networkResponseCharacteristicData); + + // Networking enabled ef6d6614-b8af-49e0-9eca-ab343513641c + QLowEnergyCharacteristicData networkingEnabledStatusData; + networkingEnabledStatusData.setUuid(networkingEnabledCharacteristicUuid); + networkingEnabledStatusData.setValue(QByteArray(1, 0)); + networkingEnabledStatusData.setProperties(QLowEnergyCharacteristic::Read | QLowEnergyCharacteristic::Notify); + networkingEnabledStatusData.setValue(QByteArray::number(static_cast(Loopd::instance()->networkManager()->networkingEnabled()))); + serviceData.addCharacteristic(networkingEnabledStatusData); + + // Wireless enabled ef6d6615-b8af-49e0-9eca-ab343513641c + QLowEnergyCharacteristicData wirelessEnabledStatusData; + wirelessEnabledStatusData.setUuid(wirelessEnabledCharacteristicUuid); + wirelessEnabledStatusData.setValue(QByteArray(1, 0)); + wirelessEnabledStatusData.setProperties(QLowEnergyCharacteristic::Read | QLowEnergyCharacteristic::Notify); + wirelessEnabledStatusData.setValue(QByteArray::number(static_cast(Loopd::instance()->networkManager()->wirelessEnabled()))); + serviceData.addCharacteristic(wirelessEnabledStatusData); + + return serviceData; +} + +QByteArray NetworkService::getNetworkManagerStateByteArray(const NetworkManager::NetworkManagerState &state) +{ + QByteArray networkManagerState; + switch (state) { + case NetworkManager::NetworkManagerStateUnknown: + networkManagerState = QByteArray::fromHex("00"); + break; + case NetworkManager::NetworkManagerStateAsleep: + networkManagerState = QByteArray::fromHex("01"); + break; + case NetworkManager::NetworkManagerStateDisconnected: + networkManagerState = QByteArray::fromHex("02"); + break; + case NetworkManager::NetworkManagerStateDisconnecting: + networkManagerState = QByteArray::fromHex("03"); + break; + case NetworkManager::NetworkManagerStateConnecting: + networkManagerState = QByteArray::fromHex("04"); + break; + case NetworkManager::NetworkManagerStateConnectedLocal: + networkManagerState = QByteArray::fromHex("05"); + break; + case NetworkManager::NetworkManagerStateConnectedSite: + networkManagerState = QByteArray::fromHex("06"); + break; + case NetworkManager::NetworkManagerStateConnectedGlobal: + networkManagerState = QByteArray::fromHex("07"); + break; + } + + return networkManagerState; +} + +void NetworkService::sendResponse(const NetworkService::NetworkServiceResponse &response) +{ + if (!m_service) { + qCWarning(dcNetworkManagerBluetoothServer()) << "NetworkService: Could not send response. Service not valid"; + return; + } + + QLowEnergyCharacteristic characteristic = m_service->characteristic(networkResponseCharacteristicUuid); + if (!characteristic.isValid()) { + qCWarning(dcNetworkManagerBluetoothServer()) << "NetworkService: Could not send response. Characteristic not valid"; + return; + } + + switch (response) { + case NetworkServiceResponseSuccess: + m_service->writeCharacteristic(characteristic, QByteArray::fromHex("00")); + break; + case NetworkServiceResponseIvalidValue: + m_service->writeCharacteristic(characteristic, QByteArray::fromHex("01")); + break; + case NetworkServiceResponseNetworkManagerNotAvailable: + m_service->writeCharacteristic(characteristic, QByteArray::fromHex("02")); + break; + case NetworkServiceResponseWirelessNotAvailable: + m_service->writeCharacteristic(characteristic, QByteArray::fromHex("03")); + break; + default: + // Unknown error + m_service->writeCharacteristic(characteristic, QByteArray::fromHex("04")); + break; + } +} + +NetworkService::NetworkServiceCommand NetworkService::verifyCommand(const QByteArray &commandData) +{ + if (commandData.length() != 1) + return NetworkServiceCommandInvalid; + + uint commandInteger = commandData.toHex().toUInt(nullptr, 16); + switch (commandInteger) { + case NetworkServiceCommandEnableNetworking: + return NetworkServiceCommandEnableNetworking; + case NetworkServiceCommandDisableNetworking: + return NetworkServiceCommandDisableNetworking; + case NetworkServiceCommandEnableWireless: + return NetworkServiceCommandEnableWireless; + case NetworkServiceCommandDisableWireless: + return NetworkServiceCommandDisableWireless; + default: + break; + } + + return NetworkServiceCommandInvalid; +} + +void NetworkService::characteristicChanged(const QLowEnergyCharacteristic &characteristic, const QByteArray &value) +{ + if (characteristic.uuid() == networkCommanderCharacteristicUuid) { + + NetworkServiceCommand command = verifyCommand(value); + if (command == NetworkServiceCommandInvalid) { + qCWarning(dcNetworkManagerBluetoothServer()) << "NetworkService: received invalid command" << command; + sendResponse(NetworkServiceResponseIvalidValue); + return; + } + + if (!Loopd::instance()->networkManager()->available()) { + qCWarning(dcNetworkManagerBluetoothServer()) << "NetworkService: Networkmanager not available"; + sendResponse(NetworkServiceResponseNetworkManagerNotAvailable); + return; + } + + processCommand(command); + + sendResponse(NetworkServiceResponseSuccess); + return; + } + + qCDebug(dcNetworkManagerBluetoothServer()) << "NetworkService: Characteristic changed" << characteristic.uuid().toString() << value; +} + +void NetworkService::characteristicRead(const QLowEnergyCharacteristic &characteristic, const QByteArray &value) +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "NetworkService: Characteristic read" << characteristic.uuid().toString() << value; +} + +void NetworkService::characteristicWritten(const QLowEnergyCharacteristic &characteristic, const QByteArray &value) +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "NetworkService: Characteristic written" << characteristic.uuid().toString() << value; +} + +void NetworkService::descriptorRead(const QLowEnergyDescriptor &descriptor, const QByteArray &value) +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "NetworkService: Descriptor read" << descriptor.uuid().toString() << value; +} + +void NetworkService::descriptorWritten(const QLowEnergyDescriptor &descriptor, const QByteArray &value) +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "NetworkService: Descriptor written" << descriptor.uuid().toString() << value; +} + +void NetworkService::serviceError(const QLowEnergyService::ServiceError &error) +{ + QString errorString; + switch (error) { + case QLowEnergyService::NoError: + errorString = "No error"; + break; + case QLowEnergyService::OperationError: + errorString = "Operation error"; + break; + case QLowEnergyService::CharacteristicReadError: + errorString = "Characteristic read error"; + break; + case QLowEnergyService::CharacteristicWriteError: + errorString = "Characteristic write error"; + break; + case QLowEnergyService::DescriptorReadError: + errorString = "Descriptor read error"; + break; + case QLowEnergyService::DescriptorWriteError: + errorString = "Descriptor write error"; + break; + case QLowEnergyService::UnknownError: + errorString = "Unknown error"; + break; + } + + qCWarning(dcNetworkManagerBluetoothServer()) << "NetworkService: Error:" << errorString; +} + +void NetworkService::processCommand(const NetworkServiceCommand &command) +{ + switch (command) { + case NetworkServiceCommandEnableNetworking: + qCDebug(dcNetworkManagerBluetoothServer()) << "NetworkService: received \"Enable networking\" command"; + Loopd::instance()->networkManager()->enableNetworking(true); + break; + case NetworkServiceCommandDisableNetworking: + qCDebug(dcNetworkManagerBluetoothServer()) << "NetworkService: received \"Disable networking\" command"; + Loopd::instance()->networkManager()->enableNetworking(false); + break; + case NetworkServiceCommandEnableWireless: + qCDebug(dcNetworkManagerBluetoothServer()) << "NetworkService: received \"Enable wireless networking\" command"; + Loopd::instance()->networkManager()->enableWireless(true); + break; + case NetworkServiceCommandDisableWireless: + qCDebug(dcNetworkManagerBluetoothServer()) << "NetworkService: received \"Disable wireless networking\" command"; + Loopd::instance()->networkManager()->enableWireless(false); + break; + default: + qCWarning(dcNetworkManagerBluetoothServer()) << "NetworkService: Unhandled command" << command; + sendResponse(NetworkServiceResponseIvalidValue); + break; + } +} + +bool NetworkService::onNetworkManagerStateChanged() +{ + if (!m_service) { + qCWarning(dcNetworkManagerBluetoothServer()) << "NetworkService: Could not updatet network manager status. Service not valid"; + return false; + } + + QLowEnergyCharacteristic characteristic = m_service->characteristic(networkStatusCharacteristicUuid); + if (!characteristic.isValid()) { + qCWarning(dcNetworkManagerBluetoothServer()) << "NetworkService: Could not update network manager status. Characteristic not valid"; + return false; + } + + qCDebug(dcNetworkManagerBluetoothServer()) << "NetworkService: Notify state changed" << NetworkService::getNetworkManagerStateByteArray(Loopd::instance()->networkManager()->state()); + m_service->writeCharacteristic(characteristic, NetworkService::getNetworkManagerStateByteArray(Loopd::instance()->networkManager()->state())); + return true; +} + +bool NetworkService::onNetworkingEnabledChanged() +{ + if (!m_service) { + qCWarning(dcNetworkManagerBluetoothServer()) << "NetworkService: Could not set networking enabled. Service not valid"; + return false; + } + + QLowEnergyCharacteristic characteristic = m_service->characteristic(networkingEnabledCharacteristicUuid); + if (!characteristic.isValid()) { + qCWarning(dcNetworkManagerBluetoothServer()) << "NetworkService: Could not set networking enabled. Characteristic not valid"; + return false; + } + + qCDebug(dcNetworkManagerBluetoothServer()) << "NetworkService: Notify networking enabled changed:" << (Loopd::instance()->networkManager()->networkingEnabled() ? "enabled" : "disabled"); + m_service->writeCharacteristic(characteristic, Loopd::instance()->networkManager()->networkingEnabled() ? QByteArray::fromHex("01") : QByteArray::fromHex("00")); + return true; +} + +bool NetworkService::onWirelessEnabledChanged() +{ + if (!m_service) { + qCWarning(dcNetworkManagerBluetoothServer()) << "NetworkService: Could not set wireless enabled. Service not valid"; + return false; + } + + QLowEnergyCharacteristic characteristic = m_service->characteristic(wirelessEnabledCharacteristicUuid); + if (!characteristic.isValid()) { + qCWarning(dcNetworkManagerBluetoothServer()) << "NetworkService: Could not set wireless enabled. Characteristic not valid"; + return false; + } + + qCDebug(dcNetworkManagerBluetoothServer()) << "NetworkService: Notify wireless networking enabled changed:" << (Loopd::instance()->networkManager()->wirelessEnabled() ? "enabled" : "disabled"); + m_service->writeCharacteristic(characteristic, Loopd::instance()->networkManager()->wirelessEnabled() ? QByteArray::fromHex("01") : QByteArray::fromHex("00")); + return true; +} diff --git a/libnymea-networkmanager/bluetooth/networkservice.h b/libnymea-networkmanager/bluetooth/networkservice.h new file mode 100644 index 0000000..c9059d8 --- /dev/null +++ b/libnymea-networkmanager/bluetooth/networkservice.h @@ -0,0 +1,78 @@ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * * + * Copyright (C) 2016 Simon Stürz * + * * + * This file is part of loopd. * + * * + * Loopd can not be copied and/or distributed without the express * + * permission of guh GmbH. * + * * + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +#ifndef NETWORKSERVICE_H +#define NETWORKSERVICE_H + +#include +#include +#include + +#include "../networkmanager.h" + +class NetworkService : public QObject +{ + Q_OBJECT + +public: + enum NetworkServiceCommand { + NetworkServiceCommandInvalid = -1, + NetworkServiceCommandEnableNetworking = 0x00, + NetworkServiceCommandDisableNetworking = 0x01, + NetworkServiceCommandEnableWireless = 0x02, + NetworkServiceCommandDisableWireless = 0x03 + }; + Q_ENUM(NetworkServiceCommand) + + enum NetworkServiceResponse { + NetworkServiceResponseSuccess = 0x00, + NetworkServiceResponseIvalidValue = 0x01, + NetworkServiceResponseNetworkManagerNotAvailable = 0x02, + NetworkServiceResponseWirelessNotAvailable = 0x03, + NetworkServiceResponseUnknownError = 0x04, + }; + Q_ENUM(NetworkServiceResponse) + + explicit NetworkService(QLowEnergyService *service, NetworkManager *networkManager, QObject *parent = nullptr); + + QLowEnergyService *service(); + + static QLowEnergyServiceData serviceData(); + static QByteArray getNetworkManagerStateByteArray(const NetworkManager::NetworkManagerState &state); + +private: + QLowEnergyService *m_service = nullptr; + NetworkManager *m_networkManager = nullptr; + + void sendResponse(const NetworkServiceResponse &response); + + NetworkServiceCommand verifyCommand(const QByteArray &commandData); + +private slots: + // Service + void characteristicChanged(const QLowEnergyCharacteristic &characteristic, const QByteArray &value); + void characteristicRead(const QLowEnergyCharacteristic &characteristic, const QByteArray &value); + void characteristicWritten(const QLowEnergyCharacteristic &characteristic, const QByteArray &value); + void descriptorRead(const QLowEnergyDescriptor &descriptor, const QByteArray &value); + void descriptorWritten(const QLowEnergyDescriptor &descriptor, const QByteArray &value); + void serviceError(const QLowEnergyService::ServiceError &error); + + // Commands + void processCommand(const NetworkServiceCommand &command); + +public slots: + bool onNetworkManagerStateChanged(); + bool onNetworkingEnabledChanged(); + bool onWirelessEnabledChanged(); + +}; + +#endif // NETWORKSERVICE_H diff --git a/libnymea-networkmanager/bluetooth/wirelessservice.cpp b/libnymea-networkmanager/bluetooth/wirelessservice.cpp new file mode 100644 index 0000000..1e3a7b3 --- /dev/null +++ b/libnymea-networkmanager/bluetooth/wirelessservice.cpp @@ -0,0 +1,508 @@ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * * + * Copyright (C) 2016 Simon Stürz * + * * + * This file is part of loopd. * + * * + * Loopd can not be copied and/or distributed without the express * + * permission of guh GmbH. * + * * + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +#include "wirelessservice.h" +#include "bluetoothuuids.h" +#include "loggingcategory.h" +#include "loopd.h" + +#include +#include +#include +#include + +WirelessService::WirelessService(QLowEnergyService *service, QObject *parent) : + QObject(parent), + m_service(service), + m_device(nullptr), + m_readingInputData(false) +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "Create WirelessService."; + + // Service + connect(m_service, SIGNAL(characteristicChanged(QLowEnergyCharacteristic, QByteArray)), this, SLOT(characteristicChanged(QLowEnergyCharacteristic, QByteArray))); + connect(m_service, SIGNAL(characteristicRead(QLowEnergyCharacteristic, QByteArray)), this, SLOT(characteristicChanged(QLowEnergyCharacteristic, QByteArray))); + connect(m_service, SIGNAL(characteristicWritten(QLowEnergyCharacteristic, QByteArray)), this, SLOT(characteristicWritten(QLowEnergyCharacteristic, QByteArray))); + connect(m_service, SIGNAL(descriptorWritten(QLowEnergyDescriptor, QByteArray)), this, SLOT(descriptorWritten(QLowEnergyDescriptor, QByteArray))); + connect(m_service, SIGNAL(error(QLowEnergyService::ServiceError)), this, SLOT(serviceError(QLowEnergyService::ServiceError))); + + // Get the wireless network device if there is any + if (!Loopd::instance()->networkManager()->wirelessAvailable()) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: There is no wireless network device available"; + return; + } + + qCDebug(dcNetworkManagerBluetoothServer()) << "WirelessService: Using" << Loopd::instance()->networkManager()->wirelessNetworkDevices().first(); + m_device = Loopd::instance()->networkManager()->wirelessNetworkDevices().first(); + connect(m_device, &WirelessNetworkDevice::bitRateChanged, this, &WirelessService::onWirelessDeviceBitRateChanged); + connect(m_device, &WirelessNetworkDevice::stateChanged, this, &WirelessService::onWirelessDeviceStateChanged); +} + +QLowEnergyService *WirelessService::service() +{ + return m_service; +} + +QLowEnergyServiceData WirelessService::serviceData() +{ + QLowEnergyServiceData serviceData; + serviceData.setType(QLowEnergyServiceData::ServiceTypePrimary); + serviceData.setUuid(wirelessServiceUuid); + + QLowEnergyDescriptorData clientConfigDescriptorData(QBluetoothUuid::ClientCharacteristicConfiguration, QByteArray(2, 0)); + + // Wifi commander characterisitc e081fec1-f757-4449-b9c9-bfa83133f7fc + QLowEnergyCharacteristicData wirelessCommanderCharacteristicData; + wirelessCommanderCharacteristicData.setUuid(wirelessCommanderCharacteristicUuid); + wirelessCommanderCharacteristicData.setProperties(QLowEnergyCharacteristic::Write); + wirelessCommanderCharacteristicData.setValueLength(0, 20); + serviceData.addCharacteristic(wirelessCommanderCharacteristicData); + + // Response characterisitc e081fec2-f757-4449-b9c9-bfa83133f7fc + QLowEnergyCharacteristicData wirelessResponseCharacteristicData; + wirelessResponseCharacteristicData.setUuid(wirelessResponseCharacteristicUuid); + wirelessResponseCharacteristicData.setProperties(QLowEnergyCharacteristic::Notify); + wirelessResponseCharacteristicData.addDescriptor(clientConfigDescriptorData); + wirelessResponseCharacteristicData.setValueLength(0, 20); + serviceData.addCharacteristic(wirelessResponseCharacteristicData); + + // Wireless connection status characterisitc e081fec3-f757-4449-b9c9-bfa83133f7fc + QLowEnergyCharacteristicData wirelessStatusCharacteristicData; + wirelessStatusCharacteristicData.setUuid(wirelessStateCharacteristicUuid); + wirelessStatusCharacteristicData.setProperties(QLowEnergyCharacteristic::Read | QLowEnergyCharacteristic::Notify); + wirelessStatusCharacteristicData.addDescriptor(clientConfigDescriptorData); + wirelessStatusCharacteristicData.setValueLength(1, 1); + if (!Loopd::instance()->networkManager()->wirelessAvailable()) { + wirelessStatusCharacteristicData.setValue(WirelessService::getWirelessNetworkDeviceState(NetworkDevice::NetworkDeviceStateUnavailable)); + } else { + wirelessStatusCharacteristicData.setValue(WirelessService::getWirelessNetworkDeviceState(Loopd::instance()->networkManager()->wirelessNetworkDevices().first()->deviceState())); + } + serviceData.addCharacteristic(wirelessStatusCharacteristicData); + + return serviceData; +} + + +WirelessService::WirelessServiceResponse WirelessService::checkWirelessErrors() +{ + // Check possible errors + if (!Loopd::instance()->networkManager()->available()) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: The networkmanager is not available."; + return WirelessServiceResponseNetworkManagerNotAvailable; + } + + if (!m_device) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: There is no wireless device available."; + return WirelessServiceResponseWirelessNotAvailable; + } + + if (!Loopd::instance()->networkManager()->networkingEnabled()) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: Networking not enabled"; + return WirelessServiceResponseNetworkingNotEnabled; + } + + if (!Loopd::instance()->networkManager()->wirelessEnabled()) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: Wireless not enabled"; + return WirelessServiceResponseWirelessNotEnabled; + } + + return WirelessServiceResponseSuccess; +} + +QByteArray WirelessService::getWirelessNetworkDeviceState(const NetworkDevice::NetworkDeviceState &state) +{ + switch (state) { + case NetworkDevice::NetworkDeviceStateUnknown: + return QByteArray::fromHex("00"); + case NetworkDevice::NetworkDeviceStateUnmanaged: + return QByteArray::fromHex("01"); + case NetworkDevice::NetworkDeviceStateUnavailable: + return QByteArray::fromHex("02"); + case NetworkDevice::NetworkDeviceStateDisconnected: + return QByteArray::fromHex("03"); + case NetworkDevice::NetworkDeviceStatePrepare: + return QByteArray::fromHex("04"); + case NetworkDevice::NetworkDeviceStateConfig: + return QByteArray::fromHex("05"); + case NetworkDevice::NetworkDeviceStateNeedAuth: + return QByteArray::fromHex("06"); + case NetworkDevice::NetworkDeviceStateIpConfig: + return QByteArray::fromHex("07"); + case NetworkDevice::NetworkDeviceStateIpCheck: + return QByteArray::fromHex("08"); + case NetworkDevice::NetworkDeviceStateSecondaries: + return QByteArray::fromHex("09"); + case NetworkDevice::NetworkDeviceStateActivated: + return QByteArray::fromHex("0a"); + case NetworkDevice::NetworkDeviceStateDeactivating: + return QByteArray::fromHex("0b"); + case NetworkDevice::NetworkDeviceStateFailed: + return QByteArray::fromHex("0c"); + } + + // Unknown + return QByteArray::fromHex("00"); +} + + +void WirelessService::streamData(const QVariantMap &responseMap) +{ + QLowEnergyCharacteristic characteristic = m_service->characteristic(wirelessResponseCharacteristicUuid); + if (!characteristic.isValid()) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: Wireless response characteristic not valid"; + return; + } + + QByteArray data = QJsonDocument::fromVariant(responseMap).toJson(QJsonDocument::Compact) + '\n'; + qCDebug(dcNetworkManagerBluetoothServer()) << "WirelessService: Start streaming response data:" << data.count() << "bytes"; + + int sentDataLength = 0; + QByteArray remainingData = data; + while (!remainingData.isEmpty()) { + QByteArray package = remainingData.left(20); + sentDataLength += package.count(); + m_service->writeCharacteristic(characteristic, package); + remainingData = remainingData.remove(0, package.count()); + } + + qCDebug(dcNetworkManagerBluetoothServer()) << "WirelessService: Finished streaming response data"; +} + +QVariantMap WirelessService::createResponse(const WirelessService::WirelessServiceCommand &command, const WirelessService::WirelessServiceResponse &responseCode) +{ + QVariantMap response; + response.insert("c", static_cast(command)); + response.insert("r", static_cast(responseCode)); + return response; +} + +void WirelessService::commandGetNetworks(const QVariantMap &request) +{ + Q_UNUSED(request) + + if (!m_service) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: Could not stream wireless network list. Service not valid"; + return; + } + + QLowEnergyCharacteristic characteristic = m_service->characteristic(wirelessResponseCharacteristicUuid); + if (!characteristic.isValid()) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: Wireless response characteristic not valid"; + return; + } + + QVariantList accessPointVariantList; + foreach (WirelessAccessPoint *accessPoint, m_device->accessPoints()) { + QVariantMap accessPointVariantMap; + accessPointVariantMap.insert("e", accessPoint->ssid()); + accessPointVariantMap.insert("m", accessPoint->macAddress()); + accessPointVariantMap.insert("s", accessPoint->signalStrength()); + accessPointVariantMap.insert("p", static_cast(accessPoint->isProtected())); + accessPointVariantList.append(accessPointVariantMap); + } + + QVariantMap response = createResponse(WirelessServiceCommandGetNetworks); + response.insert("p", accessPointVariantList); + + streamData(response); +} + +void WirelessService::commandConnect(const QVariantMap &request) +{ + if (!m_service) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: Could not stream wireless network list. Service not valid"; + return; + } + + QLowEnergyCharacteristic characteristic = m_service->characteristic(wirelessResponseCharacteristicUuid); + if (!characteristic.isValid()) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: Wireless response characteristic not valid"; + return; + } + + if (!request.contains("p")) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: Connect command: Missing parameters."; + streamData(createResponse(WirelessServiceCommandConnect, WirelessServiceResponseIvalidParameters)); + return; + } + + QVariantMap parameters = request.value("p").toMap(); + if (!parameters.contains("e") || !parameters.contains("p")) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: Connect command: Invalid parameters."; + streamData(createResponse(WirelessServiceCommandConnect, WirelessServiceResponseIvalidParameters)); + return; + } + + NetworkManager::NetworkManagerError networkError = Loopd::instance()->networkManager()->connectWifi(m_device->interface(), parameters.value("e").toString(), parameters.value("p").toString()); + WirelessService::WirelessServiceResponse responseCode = WirelessService::WirelessServiceResponseSuccess; + switch (networkError) { + case NetworkManager::NetworkManagerErrorNoError: + break; + case NetworkManager::NetworkManagerErrorWirelessNetworkingDisabled: + responseCode = WirelessService::WirelessServiceResponseWirelessNotEnabled; + break; + case NetworkManager::NetworkManagerErrorWirelessConnectionFailed: + responseCode = WirelessService::WirelessServiceResponseUnknownError; + break; + default: + responseCode = WirelessService::WirelessServiceResponseUnknownError; + break; + } + streamData(createResponse(WirelessServiceCommandConnect, responseCode)); +} + +void WirelessService::commandConnectHidden(const QVariantMap &request) +{ + Q_UNUSED(request) + // TODO: + qCWarning(dcNetworkManagerBluetoothServer()) << "Connect to hidden network is not implemented yet."; +} + +void WirelessService::commandDisconnect(const QVariantMap &request) +{ + Q_UNUSED(request) + + if (!m_service) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: Could not stream wireless network list. Service not valid"; + return; + } + + QLowEnergyCharacteristic characteristic = m_service->characteristic(wirelessResponseCharacteristicUuid); + if (!characteristic.isValid()) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: Wireless response characteristic not valid"; + return; + } + + m_device->disconnectDevice(); + streamData(createResponse(WirelessServiceCommandDisconnect)); +} + +void WirelessService::commandScan(const QVariantMap &request) +{ + Q_UNUSED(request) + + if (!m_service) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: Could not stream wireless network list. Service not valid"; + return; + } + + QLowEnergyCharacteristic characteristic = m_service->characteristic(wirelessResponseCharacteristicUuid); + if (!characteristic.isValid()) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: Wireless response characteristic not valid"; + return; + } + + m_device->scanWirelessNetworks(); + streamData(createResponse(WirelessServiceCommandScan)); +} + +void WirelessService::commandGetCurrentConnection(const QVariantMap &request) +{ + Q_UNUSED(request) + + if (!m_service) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: Could not stream wireless network list. Service not valid"; + return; + } + + QLowEnergyCharacteristic characteristic = m_service->characteristic(wirelessResponseCharacteristicUuid); + if (!characteristic.isValid()) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: Wireless response characteristic not valid"; + return; + } + + QVariantMap connectionDataMap; + QNetworkInterface wifiInterface = QNetworkInterface::interfaceFromName(m_device->interface()); + if (!m_device->activeAccessPoint() || !wifiInterface.isValid() || wifiInterface.addressEntries().isEmpty()) { + qCDebug(dcNetworkManagerBluetoothServer()) << "There is currently no access active accesspoint"; + connectionDataMap.insert("e", ""); + connectionDataMap.insert("m", ""); + connectionDataMap.insert("s", 0); + connectionDataMap.insert("p", 0); + connectionDataMap.insert("i", ""); + } else { + QHostAddress address = wifiInterface.addressEntries().first().ip(); + qCDebug(dcNetworkManagerBluetoothServer()) << "Current connection:" << m_device->activeAccessPoint() << address.toString(); + connectionDataMap.insert("e", m_device->activeAccessPoint()->ssid()); + connectionDataMap.insert("m", m_device->activeAccessPoint()->macAddress()); + connectionDataMap.insert("s", m_device->activeAccessPoint()->signalStrength()); + connectionDataMap.insert("p", static_cast(m_device->activeAccessPoint()->isProtected())); + connectionDataMap.insert("i", address.toString()); + } + + QVariantMap response = createResponse(WirelessServiceCommandGetCurrentConnection); + response.insert("p", connectionDataMap); + streamData(response); +} + +void WirelessService::characteristicChanged(const QLowEnergyCharacteristic &characteristic, const QByteArray &value) +{ + // Command + if (characteristic.uuid() == wirelessCommanderCharacteristicUuid) { + // Check if currently reading + if (m_readingInputData) { + m_inputDataStream.append(value); + } else { + m_inputDataStream.clear(); + m_readingInputData = true; + m_inputDataStream.append(value); + } + + // If command finished + if (value.endsWith('\n')) { + QJsonParseError error; + QJsonDocument jsonDocument = QJsonDocument::fromJson(m_inputDataStream, &error); + if (error.error != QJsonParseError::NoError) { + qCWarning(dcNetworkManagerBluetoothServer()) << "Got invalid json object" << m_inputDataStream; + m_inputDataStream.clear(); + m_readingInputData = false; + return; + } + + qCDebug(dcNetworkManagerBluetoothServer()) << "Got command stream" << jsonDocument.toJson(); + + processCommand(jsonDocument.toVariant().toMap()); + + m_inputDataStream.clear(); + m_readingInputData = false; + } + + // Limit possible data stream to prevent overflow + if (m_inputDataStream.length() >= 20 * 1024) { + m_inputDataStream.clear(); + m_readingInputData = false; + return; + } + } +} + +void WirelessService::characteristicRead(const QLowEnergyCharacteristic &characteristic, const QByteArray &value) +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "WirelessService: Characteristic read" << characteristic.uuid().toString() << value; +} + +void WirelessService::characteristicWritten(const QLowEnergyCharacteristic &characteristic, const QByteArray &value) +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "WirelessService: Characteristic written" << characteristic.uuid().toString() << value; +} + +void WirelessService::descriptorRead(const QLowEnergyDescriptor &descriptor, const QByteArray &value) +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "WirelessService: Descriptor read" << descriptor.uuid().toString() << value; +} + +void WirelessService::descriptorWritten(const QLowEnergyDescriptor &descriptor, const QByteArray &value) +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "WirelessService: Descriptor written" << descriptor.uuid().toString() << value; +} + +void WirelessService::serviceError(const QLowEnergyService::ServiceError &error) +{ + QString errorString; + switch (error) { + case QLowEnergyService::NoError: + errorString = "No error"; + break; + case QLowEnergyService::OperationError: + errorString = "Operation error"; + break; + case QLowEnergyService::CharacteristicReadError: + errorString = "Characteristic read error"; + break; + case QLowEnergyService::CharacteristicWriteError: + errorString = "Characteristic write error"; + break; + case QLowEnergyService::DescriptorReadError: + errorString = "Descriptor read error"; + break; + case QLowEnergyService::DescriptorWriteError: + errorString = "Descriptor write error"; + break; + case QLowEnergyService::UnknownError: + errorString = "Unknown error"; + break; + } + + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: Error:" << errorString; +} + +void WirelessService::processCommand(const QVariantMap &request) +{ + if (!request.contains("c")) { + qCWarning(dcNetworkManagerBluetoothServer()) << "Invalid request. Command value missing."; + streamData(createResponse(WirelessServiceCommandConnect, WirelessServiceResponseIvalidCommand)); + return; + } + + bool commandIntOk; + int command = request.value("c").toInt(&commandIntOk); + if (!commandIntOk) { + qCWarning(dcNetworkManagerBluetoothServer()) << "Invalid request. Could not convert method to interger."; + streamData(createResponse(WirelessServiceCommandConnect, WirelessServiceResponseIvalidCommand)); + return; + } + + // Check wireless errors + WirelessServiceResponse responseCode = checkWirelessErrors(); + if (responseCode != WirelessServiceResponseSuccess) { + streamData(createResponse(static_cast(command), responseCode)); + return; + } + + // Process method + switch (command) { + case WirelessServiceCommandGetNetworks: + commandGetNetworks(request); + break; + case WirelessServiceCommandConnect: + commandConnect(request); + break; + case WirelessServiceCommandConnectHidden: + commandConnectHidden(request); + break; + case WirelessServiceCommandDisconnect: + commandDisconnect(request); + break; + case WirelessServiceCommandScan: + commandScan(request); + break; + case WirelessServiceCommandGetCurrentConnection: + commandGetCurrentConnection(request); + break; + default: + qCWarning(dcNetworkManagerBluetoothServer()) << "Invalid request. Unknown command" << command; + streamData(createResponse(WirelessServiceCommandConnect, WirelessServiceResponseIvalidCommand)); + break; + } +} + +void WirelessService::onWirelessDeviceBitRateChanged(const int &bitRate) +{ + Q_UNUSED(bitRate) +} + +void WirelessService::onWirelessDeviceStateChanged(const NetworkDevice::NetworkDeviceState &state) +{ + qCDebug(dcNetworkManagerBluetoothServer()) << "WirelessService: Wireless network device state changed" << state; + + if (!m_service) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: Could not update wireless network device state. Service not valid"; + return; + } + + QLowEnergyCharacteristic characteristic = m_service->characteristic(wirelessStateCharacteristicUuid); + if (!characteristic.isValid()) { + qCWarning(dcNetworkManagerBluetoothServer()) << "WirelessService: Could not update wireless network device state. Characteristic not valid"; + return; + } + + m_service->writeCharacteristic(characteristic, WirelessService::getWirelessNetworkDeviceState(state)); +} diff --git a/libnymea-networkmanager/bluetooth/wirelessservice.h b/libnymea-networkmanager/bluetooth/wirelessservice.h new file mode 100644 index 0000000..92c641f --- /dev/null +++ b/libnymea-networkmanager/bluetooth/wirelessservice.h @@ -0,0 +1,100 @@ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * * + * Copyright (C) 2016 Simon Stürz * + * * + * This file is part of loopd. * + * * + * Loopd can not be copied and/or distributed without the express * + * permission of guh GmbH. * + * * + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +#ifndef WIRELESSSERVICE_H +#define WIRELESSSERVICE_H + +#include +#include +#include +#include + +#include "../networkmanager.h" +#include "../wirelessaccesspoint.h" +#include "../wirelessnetworkdevice.h" + +class WirelessService : public QObject +{ + Q_OBJECT + +public: + enum WirelessServiceCommand { + WirelessServiceCommandInvalid = -1, + WirelessServiceCommandGetNetworks = 0x00, + WirelessServiceCommandConnect = 0x01, + WirelessServiceCommandConnectHidden = 0x02, + WirelessServiceCommandDisconnect = 0x03, + WirelessServiceCommandScan = 0x04, + WirelessServiceCommandGetCurrentConnection = 0x05 + }; + Q_ENUM(WirelessServiceCommand) + + enum WirelessServiceResponse { + WirelessServiceResponseSuccess = 0x00, + WirelessServiceResponseIvalidCommand = 0x01, + WirelessServiceResponseIvalidParameters = 0x02, + WirelessServiceResponseNetworkManagerNotAvailable = 0x03, + WirelessServiceResponseWirelessNotAvailable = 0x04, + WirelessServiceResponseWirelessNotEnabled = 0x05, + WirelessServiceResponseNetworkingNotEnabled = 0x06, + WirelessServiceResponseUnknownError = 0x07 + }; + Q_ENUM(WirelessServiceResponse) + + explicit WirelessService(QLowEnergyService *service, NetworkManager *networkManager, QObject *parent = nullptr); + QLowEnergyService *service(); + + static QLowEnergyServiceData serviceData(); + +private: + QLowEnergyService *m_service = nullptr; + NetworkManager *m_networkManager = nullptr; + WirelessNetworkDevice *m_device = nullptr; + + bool m_readingInputData; + QByteArray m_inputDataStream; + + WirelessServiceResponse checkWirelessErrors(); + + // Note: static to be available in serviceData + static QByteArray getWirelessNetworkDeviceState(const NetworkDevice::NetworkDeviceState &state); + + void streamData(const QVariantMap &responseMap); + + QVariantMap createResponse(const WirelessServiceCommand &command, const WirelessServiceResponse &responseCode = WirelessServiceResponseSuccess); + + // Methods + void commandGetNetworks(const QVariantMap &request); + void commandConnect(const QVariantMap &request); + void commandConnectHidden(const QVariantMap &request); + void commandDisconnect(const QVariantMap &request); + void commandScan(const QVariantMap &request); + void commandGetCurrentConnection(const QVariantMap &request); + + +private slots: + // Service + void characteristicChanged(const QLowEnergyCharacteristic &characteristic, const QByteArray &value); + void characteristicRead(const QLowEnergyCharacteristic &characteristic, const QByteArray &value); + void characteristicWritten(const QLowEnergyCharacteristic &characteristic, const QByteArray &value); + void descriptorRead(const QLowEnergyDescriptor &descriptor, const QByteArray &value); + void descriptorWritten(const QLowEnergyDescriptor &descriptor, const QByteArray &value); + void serviceError(const QLowEnergyService::ServiceError &error); + + // Commands + void processCommand(const QVariantMap &request); + + // Wireless network device + void onWirelessDeviceBitRateChanged(const int &bitRate); + void onWirelessDeviceStateChanged(const NetworkDevice::NetworkDeviceState &state); +}; + +#endif // WIRELESSSERVICE_H diff --git a/libnymea-networkmanager/libnymea-networkmanager.pro b/libnymea-networkmanager/libnymea-networkmanager.pro index fc24c88..bda3742 100644 --- a/libnymea-networkmanager/libnymea-networkmanager.pro +++ b/libnymea-networkmanager/libnymea-networkmanager.pro @@ -6,7 +6,13 @@ QT += dbus network QMAKE_CXXFLAGS *= -Werror -std=c++11 -g QMAKE_LFLAGS *= -std=c++11 +DEFINES += VERSION_STRING=\\\"$${VERSION_STRING}\\\" + HEADERS += \ + bluetooth/bluetoothserver.h \ + bluetooth/bluetoothuuids.h \ + bluetooth/networkservice.h \ + bluetooth/wirelessservice.h \ networkmanager.h \ networkconnection.h \ networkdevice.h \ @@ -17,6 +23,8 @@ HEADERS += \ networkmanagerutils.h \ SOURCES += \ + bluetooth/networkservice.cpp \ + bluetooth/wirelessservice.cpp \ networkmanager.cpp \ networkconnection.cpp \ networkdevice.cpp \ @@ -26,6 +34,20 @@ SOURCES += \ wirelessnetworkdevice.cpp \ networkmanagerutils.cpp \ +equals(QT_MAJOR_VERSION, 5):!lessThan(QT_MINOR_VERSION, 7) { + message(Building with Bluetooth LE server functionality. Qt $${QT_VERSION}.) + + QT += bluetooth + HEADERS += \ + bluetooth/bluetoothserver.h + + SOURCES += \ + bluetooth/bluetoothserver.cpp + + +} else { + message(Bluetooth LE server functionality not supported with Qt $${QT_VERSION}.) +} target.path = $$[QT_INSTALL_LIBS] INSTALLS += target diff --git a/libnymea-networkmanager/networkmanagerutils.cpp b/libnymea-networkmanager/networkmanagerutils.cpp index b3afbae..a1857f8 100644 --- a/libnymea-networkmanager/networkmanagerutils.cpp +++ b/libnymea-networkmanager/networkmanagerutils.cpp @@ -22,6 +22,7 @@ #include "networkmanagerutils.h" Q_LOGGING_CATEGORY(dcNetworkManager, "NetworkManager") +Q_LOGGING_CATEGORY(dcNetworkManagerBluetoothServer, "NetworkManagerBluetoothServer") QString NetworkManagerUtils::NetworkManagerUtils::networkManagerServiceString() { diff --git a/libnymea-networkmanager/networkmanagerutils.h b/libnymea-networkmanager/networkmanagerutils.h index cb9a269..742afe9 100644 --- a/libnymea-networkmanager/networkmanagerutils.h +++ b/libnymea-networkmanager/networkmanagerutils.h @@ -28,6 +28,7 @@ #include Q_DECLARE_LOGGING_CATEGORY(dcNetworkManager) +Q_DECLARE_LOGGING_CATEGORY(dcNetworkManagerBluetoothServer) class NetworkManagerUtils { diff --git a/source_repository/libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic.dsc b/source_repository/libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic.dsc new file mode 100644 index 0000000..bca24ea --- /dev/null +++ b/source_repository/libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic.dsc @@ -0,0 +1,18 @@ +Format: 3.0 (native) +Source: libnymea-networkmanager +Binary: libnymea-networkmanager, libnymea-networkmanager-dev, libnymea-networkmanager-dbg +Architecture: any +Version: 0.1.1+201909161052~f3057c8~bionic +Maintainer: Simon Stürz +Standards-Version: 3.9.7 +Build-Depends: debhelper (>= 9.0.0), dpkg-dev (>= 1.16.1~), qt5-default, qt5-qmake, qtbase5-dev, qtbase5-dev-tools +Package-List: + libnymea-networkmanager deb libs optional arch=any + libnymea-networkmanager-dbg deb debug extra arch=any + libnymea-networkmanager-dev deb libdevel optional arch=any +Checksums-Sha1: + 8cab839f42a6ec82a5405acddea70944435ebf37 26500 libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic.tar.xz +Checksums-Sha256: + 5d1e9c7c1fcda6a69f199f38ed88cd7ea00f4e7627221714eb21b9e1246c5ef2 26500 libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic.tar.xz +Files: + 02d2440567e8237df586c74c7311f355 26500 libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic.tar.xz diff --git a/source_repository/libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic.tar.xz b/source_repository/libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic.tar.xz new file mode 100644 index 0000000..e3b7fca Binary files /dev/null and b/source_repository/libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic.tar.xz differ diff --git a/source_repository/libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic_source.changes b/source_repository/libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic_source.changes new file mode 100644 index 0000000..739c701 --- /dev/null +++ b/source_repository/libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic_source.changes @@ -0,0 +1,35 @@ +Format: 1.8 +Date: Mon, 16 Sep 2019 10:54:25 +0000 +Source: libnymea-networkmanager +Binary: libnymea-networkmanager libnymea-networkmanager-dev libnymea-networkmanager-dbg +Built-For-Profiles: nocheck nodoc noautodbgsym +Architecture: source +Version: 0.1.1+201909161052~f3057c8~bionic +Distribution: UNRELEASED +Urgency: medium +Maintainer: Simon Stürz +Changed-By: +Description: + libnymea-networkmanager - Qt 5 based library for the network-manager DBus API. + libnymea-networkmanager-dbg - Qt 5 based library for the network-manager DBus API - debug symbo + libnymea-networkmanager-dev - Qt 5 based library for the network-manager DBus API - development +Changes: + libnymea-networkmanager (0.1.1+201909161052~f3057c8~bionic) UNRELEASED; urgency=medium + . + [ Simon Stürz ] + * Add access point functionality + . + [ ] + * New Package build +Checksums-Sha1: + d74bad8dc14b32173399a686e602ad18c124dd0e 969 libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic.dsc + 8cab839f42a6ec82a5405acddea70944435ebf37 26500 libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic.tar.xz + f20b18d8c4ad3c0e4660362e762b9bf3dfd92ac4 11096 libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic_source.buildinfo +Checksums-Sha256: + 14eb24a6fd3ed94cf455302225a2134aeed86f7b8d0510ff4314c4b2ba25bec0 969 libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic.dsc + 5d1e9c7c1fcda6a69f199f38ed88cd7ea00f4e7627221714eb21b9e1246c5ef2 26500 libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic.tar.xz + 281438bbb3b6223a052a80bd6eb0f023c26d9833005ce8377220ac2730d8ca23 11096 libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic_source.buildinfo +Files: + a15c2aa2ce6dc6c1b57040bdeffad63c 969 utils optional libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic.dsc + 02d2440567e8237df586c74c7311f355 26500 utils optional libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic.tar.xz + 90aa93b290a36293c29fe32f881bc1b5 11096 utils optional libnymea-networkmanager_0.1.1+201909161052~f3057c8~bionic_source.buildinfo diff --git a/source_repository/libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic.dsc b/source_repository/libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic.dsc new file mode 100644 index 0000000..2acca19 --- /dev/null +++ b/source_repository/libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic.dsc @@ -0,0 +1,18 @@ +Format: 3.0 (native) +Source: libnymea-networkmanager +Binary: libnymea-networkmanager, libnymea-networkmanager-dev, libnymea-networkmanager-dbg +Architecture: any +Version: 0.1.1+201909161457~82b7888~bionic +Maintainer: Simon Stürz +Standards-Version: 3.9.7 +Build-Depends: debhelper (>= 9.0.0), dpkg-dev (>= 1.16.1~), qt5-default, qt5-qmake, qtbase5-dev, qtbase5-dev-tools, libqt5bluetooth5, qtconnectivity5-dev +Package-List: + libnymea-networkmanager deb libs optional arch=any + libnymea-networkmanager-dbg deb debug extra arch=any + libnymea-networkmanager-dev deb libdevel optional arch=any +Checksums-Sha1: + c0d13d4cdc79a458f87e244b671b9627771fc3ab 61216 libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic.tar.xz +Checksums-Sha256: + 1f2c876626374e7668356e923fb55d9556f8c4cd8dc453303a0209ecc49e9d26 61216 libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic.tar.xz +Files: + 41f55bb02977cea3ce3b89aeac7f5e21 61216 libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic.tar.xz diff --git a/source_repository/libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic.tar.xz b/source_repository/libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic.tar.xz new file mode 100644 index 0000000..e610cf1 Binary files /dev/null and b/source_repository/libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic.tar.xz differ diff --git a/source_repository/libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic_source.changes b/source_repository/libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic_source.changes new file mode 100644 index 0000000..e48bdd3 --- /dev/null +++ b/source_repository/libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic_source.changes @@ -0,0 +1,35 @@ +Format: 1.8 +Date: Mon, 16 Sep 2019 14:57:12 +0000 +Source: libnymea-networkmanager +Binary: libnymea-networkmanager libnymea-networkmanager-dev libnymea-networkmanager-dbg +Built-For-Profiles: nocheck nodoc noautodbgsym +Architecture: source +Version: 0.1.1+201909161457~82b7888~bionic +Distribution: UNRELEASED +Urgency: medium +Maintainer: Simon Stürz +Changed-By: +Description: + libnymea-networkmanager - Qt 5 based library for the network-manager DBus API. + libnymea-networkmanager-dbg - Qt 5 based library for the network-manager DBus API - debug symbo + libnymea-networkmanager-dev - Qt 5 based library for the network-manager DBus API - development +Changes: + libnymea-networkmanager (0.1.1+201909161457~82b7888~bionic) UNRELEASED; urgency=medium + . + [ Simon Stürz ] + * Add access point functionality + . + [ ] + * New Package build +Checksums-Sha1: + dfc0cf09520bbfca80ba2eca080d7704435c3775 1008 libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic.dsc + c0d13d4cdc79a458f87e244b671b9627771fc3ab 61216 libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic.tar.xz + d74e94fe208e660240ff027677dcb6112fca28ed 11139 libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic_source.buildinfo +Checksums-Sha256: + d968e6c3f9ac8765d807c589865383abd7eb6f9fdc1ad185943d7bf232e185ce 1008 libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic.dsc + 1f2c876626374e7668356e923fb55d9556f8c4cd8dc453303a0209ecc49e9d26 61216 libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic.tar.xz + 07126ba04d2b59ea4d8e901b67e76d9800163fe590cc5e8062a5c0ae120333f7 11139 libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic_source.buildinfo +Files: + 0d506d71a468001c0f0bdc531909023b 1008 utils optional libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic.dsc + 41f55bb02977cea3ce3b89aeac7f5e21 61216 utils optional libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic.tar.xz + 83582b2ab099ae8940f99411b3a34067 11139 utils optional libnymea-networkmanager_0.1.1+201909161457~82b7888~bionic_source.buildinfo