ETM-Schurig/powersync-networkmanager
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Make debian build work

Browse Source
This commit is contained in:
Simon Stürz 2018-03-08 15:38:53 +01:00
parent 4ab75786a1
commit d498f9339f
37 changed files with 795 additions and 274 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
debian/control vendored
View File

@ -12,39 +12,35 @@ Standards-Version: 3.9.7
Package: nymea-networkmanager
Architecture: any
Depends: libqt5network5,
Depends: ${misc:Depends},
libqt5network5,
libqt5bluetooth5,
${shlibs:Depends},
${misc:Depends}
libnymea-networkmanager (= ${binary:Version})
Description: Daemon for wireless configuration using bluetooth LE.
This daemon allows to configure a wireless network using a bluetooth
low energy gatt server. The tool is written in Qt 5.
Package: libnymea-networkmanager1
Package: libnymea-networkmanager
Section: libs
Architecture: any
Depends: ${shlibs:Depends},
${misc:Depends},
libqt5network5,
Depends: ${misc:Depends},
libqt5network5
Description: Qt 5 based library for the network-manager DBus API.
Qt 5 based library for the network-manager DBus API.
Package: libnymea-networkmanager1-dev
Package: libnymea-networkmanager-dev
Section: libdevel
Architecture: any
Depends: libnymea-networkmanager1 (= ${binary:Version}),
${shlibs:Depends},
${misc:Depends}
Depends: ${misc:Depends},
libnymea-networkmanager (= ${binary:Version})
Description: Qt 5 based library for the network-manager DBus API - development files
Development files for Qt 5 based network-manager DBus API.
Package: libnymea-networkmanager1-dbg
Package: libnymea-networkmanager-dbg
Priority: extra
Architecture: any
Section: debug
Depends: libnymea-networkmanager1 (= ${binary:Version}),
${shlibs:Depends},
${misc:Depends}
Depends: ${misc:Depends},
libnymea-networkmanager (= ${binary:Version})
Description: Qt 5 based library for the network-manager DBus API - debug symbols
Debug Symbols for Qt 5 based network-manager DBus API.

2
debian/libnymea-networkmanager-dev.dirs.in vendored Normal file
View File

@ -0,0 +1,2 @@
usr/lib/@DEB_HOST_MULTIARCH@
usr/include/nymea-networkmanager

3
debian/libnymea-networkmanager-dev.install.in vendored Normal file
View File

@ -0,0 +1,3 @@
usr/lib/@DEB_HOST_MULTIARCH@/libnymea-networkmanager.so
usr/include/libnymea-networkmanager/* usr/include/libnymea-networkmanager

3
debian/libnymea-networkmanager.install.in vendored Normal file
View File

@ -0,0 +1,3 @@
usr/lib/@DEB_HOST_MULTIARCH@/libnymea-networkmanager.so.1
usr/lib/@DEB_HOST_MULTIARCH@/libnymea-networkmanager.so.1.0
usr/lib/@DEB_HOST_MULTIARCH@/libnymea-networkmanager.so.1.0.0

3
debian/libnymea-networkmanager1-dev.install.in vendored
View File

@ -1,3 +0,0 @@
usr/lib/libnymea-networkmanager1.install.in/libnymea-networkmanager1.so
usr/include/nymea-networkmanager/* usr/include/nymea-networkmanager

1
debian/libnymea-networkmanager1.install.in vendored
View File

@ -1 +0,0 @@
usr/lib/@DEB_HOST_MULTIARCH@/

7
debian/rules vendored
View File

@ -12,13 +12,10 @@ $(PREPROCESS_FILES:.in=): %: %.in
dh $@ --buildsystem=qmake --parallel
override_dh_install: $(PREPROCESS_FILES:.in=)
dh_install --fail-missing
override_dh_auto_build:
dh_auto_build
dh_install
override_dh_strip:
dh_strip --dbg-package=libnymea-networkmanager1-dbg
dh_strip --dbg-package=libnymea-networkmanager-dbg
override_dh_auto_clean:
dh_auto_clean

2
libnymea-networkmanager/libnymea-networkmanager.pro
View File

@ -1,4 +1,4 @@
TARGET = nymea-networkmanager1
TARGET = nymea-networkmanager
TEMPLATE = lib
target.path = /usr/lib/$$system('dpkg-architecture -q DEB_HOST_MULTIARCH')

2
libnymea-networkmanager/networkconnection.cpp
View File

@ -51,7 +51,7 @@ NetworkConnection::NetworkConnection(const QDBusObjectPath &objectPath, QObject
m_connectionSettings = qdbus_cast<ConnectionSettings>(argument);
}
/*! Delets this \l{NetworkConnection} in the \l{NetworkManager}. */
/*! Delete this \l{NetworkConnection} in the \l{NetworkManager}. */
void NetworkConnection::deleteConnection()
{
QDBusMessage query = m_connectionInterface->call("Delete");

3
libnymea-networkmanager/networkconnection.h
View File

@ -55,10 +55,9 @@ public:
private:
QDBusObjectPath m_objectPath;
QDBusInterface *m_connectionInterface;
QDBusInterface *m_connectionInterface = nullptr;
ConnectionSettings m_connectionSettings;
};
QDebug operator<<(QDebug debug, NetworkConnection *networkConnection);

6
libnymea-networkmanager/networkdevice.cpp
View File

@ -138,11 +138,7 @@
/*! Constructs a new \l{NetworkDevice} with the given dbus \a objectPath and \a parent. */
NetworkDevice::NetworkDevice(const QDBusObjectPath &objectPath, QObject *parent) :
QObject(parent),
m_objectPath(objectPath),
m_mtu(0),
m_metered(0),
m_deviceState(NetworkDeviceStateUnknown),
m_deviceStateReason(NetworkDeviceStateReasonUnknown)
m_objectPath(objectPath)
{
QDBusConnection systemBus = QDBusConnection::systemBus();
if (!systemBus.isConnected()) {

14
libnymea-networkmanager/networkdevice.h
View File

@ -177,7 +177,7 @@ public:
static QString deviceStateReasonToString(const NetworkDeviceStateReason &deviceStateReason);
private:
QDBusInterface *m_networkDeviceInterface;
QDBusInterface *m_networkDeviceInterface = nullptr;
QDBusObjectPath m_objectPath;
// Device properties
@ -188,12 +188,12 @@ private:
QString m_driverVersion;
QString m_firmwareVersion;
QString m_physicalPortId;
uint m_mtu;
uint m_metered;
bool m_autoconnect;
NetworkDeviceState m_deviceState;
NetworkDeviceStateReason m_deviceStateReason;
NetworkDeviceType m_deviceType;
uint m_mtu = 0;
uint m_metered = 0;
bool m_autoconnect = false;
NetworkDeviceState m_deviceState = NetworkDeviceStateUnknown;
NetworkDeviceStateReason m_deviceStateReason = NetworkDeviceStateReasonUnknown;
NetworkDeviceType m_deviceType = NetworkDeviceTypeUnknown;
QDBusObjectPath m_activeConnection;
QDBusObjectPath m_ip4Config;

205
libnymea-networkmanager/networkmanager.cpp
View File

@ -28,46 +28,9 @@
/*! Constructs a new \l{NetworkManager} object with the given \a parent. */
NetworkManager::NetworkManager(QObject *parent) :
QObject(parent),
m_networkManagerInterface(nullptr),
m_available(false),
m_state(NetworkManagerStateUnknown),
m_connectivityState(NetworkManagerConnectivityStateUnknown),
m_networkingEnabled(false),
m_wirelessEnabled(false)
QObject(parent)
{
// Check DBus connection
if (!QDBusConnection::systemBus().isConnected()) {
qCWarning(dcNetworkManager()) << "System DBus not connected. NetworkManagre not available.";
return;
}
// Create interface
m_networkManagerInterface = new QDBusInterface(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), QDBusConnection::systemBus(), this);
if(!m_networkManagerInterface->isValid()) {
qCWarning(dcNetworkManager()) << "Invalid DBus network manager interface. NetworkManagre not available.";
return;
}
m_available = true;
// Read properties
setVersion(m_networkManagerInterface->property("Version").toString());
setState((NetworkManagerState)m_networkManagerInterface->property("State").toUInt());
setConnectivityState((NetworkManagerConnectivityState)m_networkManagerInterface->property("Connectivity").toUInt());
setNetworkingEnabled(m_networkManagerInterface->property("NetworkingEnabled").toBool());
setWirelessEnabled(m_networkManagerInterface->property("WirelessEnabled").toBool());
loadDevices();
// Connect signals
QDBusConnection::systemBus().connect(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), "StateChanged", this, SLOT(onStateChanged(uint)));
QDBusConnection::systemBus().connect(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), "DeviceAdded", this, SLOT(onDeviceAdded(QDBusObjectPath)));
QDBusConnection::systemBus().connect(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), "DeviceRemoved", this, SLOT(onDeviceRemoved(QDBusObjectPath)));
QDBusConnection::systemBus().connect(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), "PropertiesChanged", this, SLOT(onPropertiesChanged(QVariantMap)));
// Create settings
m_networkSettings = new NetworkSettings(this);
}
NetworkManager::~NetworkManager()
@ -76,13 +39,13 @@ NetworkManager::~NetworkManager()
}
/*! Returns true if the network-manager is available on this system. */
bool NetworkManager::available()
bool NetworkManager::available() const
{
return m_available;
}
/*! Returns true if wifi is available on this system. */
bool NetworkManager::wirelessAvailable()
bool NetworkManager::wirelessAvailable() const
{
return !m_wirelessNetworkDevices.isEmpty();
}
@ -111,7 +74,7 @@ NetworkDevice *NetworkManager::getNetworkDevice(const QString &interface)
if (device->interface() == interface)
return device;
}
return Q_NULLPTR;
return nullptr;
}
/*! Returns the version of the running \l{NetworkManager}. */
@ -139,7 +102,7 @@ NetworkManager::NetworkManagerConnectivityState NetworkManager::connectivityStat
}
/*! Connect the given \a interface to a wifi network with the given \a ssid and \a password. Returns the \l{NetworkManagerError} to inform about the result. \sa NetworkManagerError, */
NetworkManager::NetworkManagerError NetworkManager::connectWifi(const QString &interface, const QString &ssid, const QString &password, const bool &hidden)
NetworkManager::NetworkManagerError NetworkManager::connectWifi(const QString &interface, const QString &ssid, const QString &password, bool hidden)
{
// Check interface
if (!getNetworkDevice(interface))
@ -226,7 +189,7 @@ bool NetworkManager::networkingEnabled() const
}
/*! Returns true if the networking of this \l{NetworkManager} could be \a enabled. */
bool NetworkManager::enableNetworking(const bool &enabled)
bool NetworkManager::enableNetworking(bool enabled)
{
if (m_networkingEnabled == enabled)
return true;
@ -240,11 +203,15 @@ bool NetworkManager::enableNetworking(const bool &enabled)
}
/*! Sets the networking of this \l{NetworkManager} to \a enabled. */
void NetworkManager::setNetworkingEnabled(const bool &enabled)
void NetworkManager::setNetworkingEnabled(bool enabled)
{
if (m_networkingEnabled == enabled)
return;
qCDebug(dcNetworkManager()) << "Networking" << (enabled ? "enabled" : "disabled");
m_networkingEnabled = enabled;
emit networkingEnabledChanged();
emit networkingEnabledChanged(m_networkingEnabled);
}
/*! Returns true if the wireless networking of this \l{NetworkManager} is enabled. */
@ -254,7 +221,7 @@ bool NetworkManager::wirelessEnabled() const
}
/*! Returns true if the wireless networking of this \l{NetworkManager} could be set to \a enabled. */
bool NetworkManager::enableWireless(const bool &enabled)
bool NetworkManager::enableWireless(bool enabled)
{
if (m_wirelessEnabled == enabled)
return true;
@ -262,6 +229,25 @@ bool NetworkManager::enableWireless(const bool &enabled)
return m_networkManagerInterface->setProperty("WirelessEnabled", enabled);
}
bool NetworkManager::isConnectedToLan() const
{
// Check all wireless devices if one is connected
foreach (WirelessNetworkDevice *wirelessDevice, wirelessNetworkDevices()) {
if (wirelessDevice->deviceState() == NetworkDevice::NetworkDeviceStateActivated) {
return true;
}
}
// Check all wired devices if one is connected
foreach (WiredNetworkDevice *wiredDevice, wiredNetworkDevices()) {
if (wiredDevice->deviceState() == NetworkDevice::NetworkDeviceStateActivated) {
return true;
}
}
return false;
}
void NetworkManager::loadDevices()
{
// Get network devices
@ -299,15 +285,31 @@ QString NetworkManager::networkManagerConnectivityStateToString(const NetworkMan
return QString(metaEnum.valueToKey(state)).remove("NetworkManagerConnectivityState");
}
void NetworkManager::setVersion(const QString &version)
void NetworkManager::setAvailable(bool available)
{
qCDebug(dcNetworkManager()) << "Version:" << version;
m_version = version;
emit versionChanged();
if (m_available == available)
return;
qCDebug(dcNetworkManager()) << "Service is now" << (available ? "available" : "unavailable");
m_available = available;
emit availableChanged(m_available);
}
void NetworkManager::setWirelessEnabled(const bool &enabled)
void NetworkManager::setVersion(const QString &version)
{
if (m_version == version)
return;
qCDebug(dcNetworkManager()) << "Version:" << version;
m_version = version;
emit versionChanged(m_version);
}
void NetworkManager::setWirelessEnabled(bool enabled)
{
if (m_wirelessEnabled == enabled)
return;
qCDebug(dcNetworkManager()) << "Wireless networking" << (enabled ? "enabled" : "disabled");
m_wirelessEnabled = enabled;
emit wirelessEnabledChanged();
@ -315,6 +317,9 @@ void NetworkManager::setWirelessEnabled(const bool &enabled)
void NetworkManager::setConnectivityState(const NetworkManager::NetworkManagerConnectivityState &connectivityState)
{
if (m_connectivityState == connectivityState)
return;
qCDebug(dcNetworkManager()) << "Connectivity state changed:" << networkManagerConnectivityStateToString(connectivityState);
m_connectivityState = connectivityState;
emit connectivityStateChanged();
@ -322,11 +327,26 @@ void NetworkManager::setConnectivityState(const NetworkManager::NetworkManagerCo
void NetworkManager::setState(const NetworkManager::NetworkManagerState &state)
{
if (m_state == state)
return;
qCDebug(dcNetworkManager()) << "State changed:" << networkManagerStateToString(state);
m_state = state;
emit stateChanged();
}
void NetworkManager::onServiceRegistered()
{
qCDebug(dcNetworkManager()) << "DBus service registered and available.";
// TODO: init stuff
}
void NetworkManager::onServiceUnregistered()
{
qCWarning(dcNetworkManager()) << "DBus service unregistered.";
// TODO: deinit stuff
}
void NetworkManager::onDeviceAdded(const QDBusObjectPath &deviceObjectPath)
{
if (m_networkDevices.keys().contains(deviceObjectPath)) {
@ -429,3 +449,86 @@ void NetworkManager::onWiredDeviceChanged()
emit wiredDeviceChanged(networkDevice);
}
bool NetworkManager::start()
{
// Get notification when network-manager appears/disappears on DBus
m_serviceWatcher = new QDBusServiceWatcher(NetworkManagerUtils::networkManagerServiceString(), QDBusConnection::systemBus(), QDBusServiceWatcher::WatchForRegistration | QDBusServiceWatcher::WatchForUnregistration, this);
connect(m_serviceWatcher, &QDBusServiceWatcher::serviceRegistered, this, &NetworkManager::onServiceRegistered);
connect(m_serviceWatcher, &QDBusServiceWatcher::serviceUnregistered, this, &NetworkManager::onServiceUnregistered);
// Check DBus connection
if (!QDBusConnection::systemBus().isConnected()) {
qCWarning(dcNetworkManager()) << "System DBus not connected. NetworkManagre not available.";
m_serviceWatcher->deleteLater();
m_serviceWatcher = nullptr;
return false;
}
// Create interface
m_networkManagerInterface = new QDBusInterface(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), QDBusConnection::systemBus(), this);
if(!m_networkManagerInterface->isValid()) {
qCWarning(dcNetworkManager()) << "Invalid DBus network manager interface. NetworkManagre not available.";
m_serviceWatcher->deleteLater();
m_serviceWatcher = nullptr;
m_networkManagerInterface->deleteLater();
m_networkManagerInterface = nullptr;
return false;
}
// Init properties
setVersion(m_networkManagerInterface->property("Version").toString());
setState((NetworkManagerState)m_networkManagerInterface->property("State").toUInt());
setConnectivityState((NetworkManagerConnectivityState)m_networkManagerInterface->property("Connectivity").toUInt());
setNetworkingEnabled(m_networkManagerInterface->property("NetworkingEnabled").toBool());
setWirelessEnabled(m_networkManagerInterface->property("WirelessEnabled").toBool());
// Load network devices
loadDevices();
// Create settings
m_networkSettings = new NetworkSettings(this);
// Connect signals
QDBusConnection::systemBus().connect(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), "StateChanged", this, SLOT(onStateChanged(uint)));
QDBusConnection::systemBus().connect(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), "DeviceAdded", this, SLOT(onDeviceAdded(QDBusObjectPath)));
QDBusConnection::systemBus().connect(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), "DeviceRemoved", this, SLOT(onDeviceRemoved(QDBusObjectPath)));
QDBusConnection::systemBus().connect(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::networkManagerPathString(), NetworkManagerUtils::networkManagerServiceString(), "PropertiesChanged", this, SLOT(onPropertiesChanged(QVariantMap)));
setAvailable(true);
return true;
}
void NetworkManager::stop()
{
foreach (NetworkDevice *device, m_networkDevices) {
onDeviceRemoved(device->objectPath());
}
m_wiredNetworkDevices.clear();
m_wirelessNetworkDevices.clear();
if (m_networkSettings) {
delete m_networkSettings;
m_networkSettings = nullptr;
}
if (m_networkManagerInterface) {
delete m_networkManagerInterface;
m_networkManagerInterface = nullptr;
}
if (m_serviceWatcher) {
delete m_serviceWatcher;
m_serviceWatcher = nullptr;
}
m_version = QString();
m_state = NetworkManagerStateUnknown;
m_connectivityState = NetworkManagerConnectivityStateUnknown;
m_networkingEnabled = false;
m_wirelessEnabled = false;
setAvailable(false);
}

59
libnymea-networkmanager/networkmanager.h
View File

@ -23,16 +23,17 @@
#define NETWORKMANAGER_H
#include <QObject>
#include <QDBusConnection>
#include <QDBusInterface>
#include <QDBusMessage>
#include <QDBusContext>
#include <QDBusArgument>
#include <QDBusInterface>
#include <QDBusConnection>
#include <QDBusServiceWatcher>
#include "networkmanagerutils.h"
#include "wirednetworkdevice.h"
#include "wirelessnetworkdevice.h"
#include "networksettings.h"
#include "wirednetworkdevice.h"
#include "networkmanagerutils.h"
#include "wirelessnetworkdevice.h"
// Docs: https://developer.gnome.org/NetworkManager/unstable/spec.html
@ -79,8 +80,8 @@ public:
explicit NetworkManager(QObject *parent = 0);
~NetworkManager();
bool available();
bool wirelessAvailable();
bool available() const;
bool wirelessAvailable() const;
QList<NetworkDevice *> networkDevices() const;
QList<WirelessNetworkDevice *> wirelessNetworkDevices() const;
@ -94,48 +95,54 @@ public:
QString stateString() const;
NetworkManagerConnectivityState connectivityState() const;
NetworkManagerError connectWifi(const QString &interface, const QString &ssid, const QString &password, const bool &hidden = false);
NetworkManagerError connectWifi(const QString &interface, const QString &ssid, const QString &password, bool hidden = false);
// Networking
bool networkingEnabled() const;
bool enableNetworking(const bool &enabled);
bool enableNetworking(bool enabled);
// Wireless Networking
bool wirelessEnabled() const;
bool enableWireless(const bool &enabled);
bool enableWireless(bool enabled);
// Status methods
bool isConnectedToLan() const;
bool isOnline() const;
private:
QDBusInterface *m_networkManagerInterface;
QDBusServiceWatcher *m_serviceWatcher = nullptr;
QDBusInterface *m_networkManagerInterface = nullptr;
NetworkSettings *m_networkSettings = nullptr;
QHash<QDBusObjectPath, NetworkDevice *> m_networkDevices;
QHash<QDBusObjectPath, WirelessNetworkDevice *> m_wirelessNetworkDevices;
QHash<QDBusObjectPath, WiredNetworkDevice *> m_wiredNetworkDevices;
NetworkSettings *m_networkSettings;
bool m_available;
bool m_available = false;
QString m_version;
NetworkManagerState m_state;
NetworkManagerConnectivityState m_connectivityState;
bool m_networkingEnabled;
bool m_wirelessEnabled;
NetworkManagerState m_state = NetworkManagerStateUnknown;
NetworkManagerConnectivityState m_connectivityState = NetworkManagerConnectivityStateUnknown;
bool m_networkingEnabled = false;
bool m_wirelessEnabled = false;
void loadDevices();
static QString networkManagerStateToString(const NetworkManagerState &state);
static QString networkManagerConnectivityStateToString(const NetworkManagerConnectivityState &state);
void setAvailable(bool available);
void setVersion(const QString &version);
void setNetworkingEnabled(const bool &enabled);
void setWirelessEnabled(const bool &enabled);
void setNetworkingEnabled(bool enabled);
void setWirelessEnabled(bool enabled);
void setConnectivityState(const NetworkManagerConnectivityState &connectivityState);
void setState(const NetworkManagerState &state);
signals:
void versionChanged();
void networkingEnabledChanged();
void availableChanged(bool available);
void versionChanged(const QString &version);
void networkingEnabledChanged(bool enabled);
void wirelessEnabledChanged();
void wirelessAvailableChanged();
void stateChanged();
@ -150,12 +157,20 @@ signals:
void wiredDeviceChanged(WiredNetworkDevice *wiredDevice);
private slots:
void onServiceRegistered();
void onServiceUnregistered();
void onDeviceAdded(const QDBusObjectPath &deviceObjectPath);
void onDeviceRemoved(const QDBusObjectPath &deviceObjectPath);
void onPropertiesChanged(const QVariantMap &properties);
void onWirelessDeviceChanged();
void onWiredDeviceChanged();
public slots:
bool start();
void stop();
};
#endif // NETWORKMANAGER_H

4
libnymea-networkmanager/networksettings.cpp
View File

@ -25,7 +25,8 @@
#include <QDebug>
/*! Constructs a new \l{NetworkSettings} object with the given \a parent. */
NetworkSettings::NetworkSettings(QObject *parent) : QObject(parent)
NetworkSettings::NetworkSettings(QObject *parent) :
QObject(parent)
{
m_settingsInterface = new QDBusInterface(NetworkManagerUtils::networkManagerServiceString(), NetworkManagerUtils::settingsPathString(), NetworkManagerUtils::settingsInterfaceString(), QDBusConnection::systemBus(), this);
if(!m_settingsInterface->isValid()) {
@ -100,5 +101,6 @@ void NetworkSettings::connectionRemoved(const QDBusObjectPath &objectPath)
void NetworkSettings::propertiesChanged(const QVariantMap &properties)
{
Q_UNUSED(properties);
// TODO: handle settings changes
//qCDebug(dcNetworkManager()) << "Settins: properties changed" << properties;
}

4
libnymea-networkmanager/networksettings.h
View File

@ -42,13 +42,11 @@ public:
QList<NetworkConnection *> connections() const;
private:
QDBusInterface *m_settingsInterface;
QDBusInterface *m_settingsInterface = nullptr;
QHash<QDBusObjectPath, NetworkConnection *> m_connections;
void loadConnections();
signals:
private slots:
void connectionAdded(const QDBusObjectPath &objectPath);
void connectionRemoved(const QDBusObjectPath &objectPath);

6
libnymea-networkmanager/wirednetworkdevice.h
View File

@ -38,11 +38,11 @@ public:
bool pluggedIn() const;
private:
QDBusInterface *m_wiredInterface;
QDBusInterface *m_wiredInterface = nullptr;
QString m_macAddress;
int m_bitRate;
bool m_pluggedIn;
int m_bitRate = 0;
bool m_pluggedIn = false;
void setMacAddress(const QString &macAddress);
void setBitRate(const int &bitRate);

2
nymea-networkmanager.pro
View File

@ -1,5 +1,5 @@
TEMPLATE=subdirs
networkmanager.depends = libnymea-networkmanager
nymea-networkmanager.depends = libnymea-networkmanager
SUBDIRS += libnymea-networkmanager nymea-networkmanager

81
nymea-networkmanager/application.cpp Normal file
View File

@ -0,0 +1,81 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Copyright (C) 2018 Simon Stürz <simon.stuerz@guh.io> *
* *
* This file is part of nymea-networkmanager. *
* *
* nymea-networkmanager is free software: you can redistribute it and/or *
* modify it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, *
* or (at your option) any later version. *
* *
* nymea-networkmanager is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License along *
* with nymea-networkmanager. If not, see <http://www.gnu.org/licenses/>. *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "application.h"
#include "loggingcategories.h"
#include "core.h"
#include <signal.h>
static bool s_aboutToShutdown = false;
static void catchUnixSignals(const std::vector<int>& quitSignals, const std::vector<int>& ignoreSignals = std::vector<int>())
{
auto handler = [](int sig) ->void {
switch (sig) {
case SIGQUIT:
qCDebug(dcApplication()) << "Cought SIGQUIT quit signal...";
break;
case SIGINT:
qCDebug(dcApplication()) << "Cought SIGINT quit signal...";
break;
case SIGTERM:
qCDebug(dcApplication()) << "Cought SIGTERM quit signal...";
break;
case SIGHUP:
qCDebug(dcApplication()) << "Cought SIGHUP quit signal...";
break;
case SIGSEGV: {
qCCritical(dcApplication()) << "Cought SIGSEGV signal. Segmentation fault!";
exit(EXIT_FAILURE);
}
default:
break;
}
if (s_aboutToShutdown) {
qCCritical(dcApplication()) << "Already shutting down.";
return;
}
qCDebug(dcApplication()) << "=====================================";
qCDebug(dcApplication()) << "Shutting down nymea-networkmanager";
qCDebug(dcApplication()) << "=====================================";
s_aboutToShutdown = true;
Core::instance()->destroy();
Application::quit();
};
// all these signals will be ignored.
for (int sig : ignoreSignals)
signal(sig, SIG_IGN);
for (int sig : quitSignals)
signal(sig, handler);
}
Application::Application(int &argc, char **argv) :
QCoreApplication(argc, argv)
{
catchUnixSignals({SIGQUIT, SIGINT, SIGTERM, SIGHUP, SIGSEGV});
}

37
nymea-networkmanager/application.h Normal file
View File

@ -0,0 +1,37 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Copyright (C) 2018 Simon Stürz <simon.stuerz@guh.io> *
* *
* This file is part of nymea-networkmanager. *
* *
* nymea-networkmanager is free software: you can redistribute it and/or *
* modify it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, *
* or (at your option) any later version. *
* *
* nymea-networkmanager is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License along *
* with nymea-networkmanager. If not, see <http://www.gnu.org/licenses/>. *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#ifndef APPLICATION_H
#define APPLICATION_H
#include <QObject>
#include <QCoreApplication>
class Application : public QCoreApplication
{
Q_OBJECT
public:
explicit Application(int &argc, char **argv);
};
#endif // APPLICATION_H

61
nymea-networkmanager/bluetooth/bluetoothserver.cpp
View File

@ -19,7 +19,6 @@
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "bluetoothserver.h"
#include "loggingcategories.h"
#include "bluetoothuuids.h"
@ -31,11 +30,7 @@ BluetoothServer::BluetoothServer(const QString &machineId, QObject *parent) :
QObject(parent),
m_machineId(machineId)
{
m_advertisingTimer = new QTimer(this);
m_advertisingTimer->setInterval(60000);
m_advertisingTimer->setSingleShot(true);
connect(m_advertisingTimer, &QTimer::timeout, this, &BluetoothServer::onAdvertisingTimeout);
}
BluetoothServer::~BluetoothServer()
@ -117,7 +112,7 @@ QLowEnergyServiceData BluetoothServer::genericAccessServiceData()
// Device name 0x2a00
QLowEnergyCharacteristicData nameCharData;
nameCharData.setUuid(QBluetoothUuid::DeviceName);
nameCharData.setValue(QString("Loop-box").toUtf8());
nameCharData.setValue(QString("nymea-networkmanager").toUtf8());
nameCharData.setProperties(QLowEnergyCharacteristic::Read);
serviceData.addCharacteristic(nameCharData);
@ -236,12 +231,10 @@ void BluetoothServer::onControllerStateChanged(const QLowEnergyController::Contr
case QLowEnergyController::ConnectingState:
qCDebug(dcBluetoothServer()) << "Controller state connecting...";
setConnected(false);
m_advertisingTimer->stop();
break;
case QLowEnergyController::ConnectedState:
qCDebug(dcBluetoothServer()) << "Controller state connected." << m_controller->remoteName() << m_controller->remoteAddress();
setConnected(true);
m_advertisingTimer->stop();
break;
case QLowEnergyController::DiscoveringState:
qCDebug(dcBluetoothServer()) << "Controller state discovering...";
@ -261,12 +254,6 @@ void BluetoothServer::onControllerStateChanged(const QLowEnergyController::Contr
}
}
void BluetoothServer::onAdvertisingTimeout()
{
qCDebug(dcBluetoothServer()) << "Advertising timeout.";
stop();
}
void BluetoothServer::characteristicChanged(const QLowEnergyCharacteristic &characteristic, const QByteArray &value)
{
qCDebug(dcBluetoothServer()) << "Service characteristic changed" << characteristic.uuid() << value;
@ -325,7 +312,7 @@ void BluetoothServer::serviceError(const QLowEnergyService::ServiceError &error)
qCWarning(dcBluetoothServer()) << "Service error:" << errorString;
}
void BluetoothServer::start()
void BluetoothServer::start(WirelessNetworkDevice *wirelessDevice)
{
// Check if a user is connected
if (connected()) {
@ -334,27 +321,19 @@ void BluetoothServer::start()
}
if (running()) {
qCDebug(dcBluetoothServer()) << "Already running. Restart advertise timer." << Loopd::instance()->advertisingTimeout() << "[s].";
qCDebug(dcBluetoothServer()) << "Already running.";
m_localDevice->setHostMode(QBluetoothLocalDevice::HostDiscoverable);
m_advertisingTimer->stop();
m_advertisingTimer->setSingleShot(true);
m_advertisingTimer->setInterval(Loopd::instance()->advertisingTimeout() * 1000);
m_advertisingTimer->start();
return;
}
qCDebug(dcBluetoothServer()) << "-------------------------------------";
qCDebug(dcBluetoothServer()) << "Starting bluetooth server for" << Loopd::instance()->advertisingTimeout() << "[s].";
m_advertisingTimer->stop();
m_advertisingTimer->setSingleShot(true);
m_advertisingTimer->setInterval(Loopd::instance()->advertisingTimeout() * 1000);
qCDebug(dcBluetoothServer()) << "Starting bluetooth server";
qCDebug(dcBluetoothServer()) << "-------------------------------------";
// Local bluetooth device
m_localDevice = new QBluetoothLocalDevice(this);
if (!m_localDevice->isValid()) {
qCCritical(dcBluetoothServer()) << "Local bluetooth device is not valid.";
m_advertisingTimer->stop();
delete m_localDevice;
m_localDevice = nullptr;
return;
@ -383,8 +362,7 @@ void BluetoothServer::start()
// Create 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);
m_systemService = new SystemService(m_controller->addService(SystemService::serviceData(), m_controller), m_controller);
m_wirelessService = new WirelessService(m_controller->addService(WirelessService::serviceData(), m_controller), wirelessDevice, m_controller);
QLowEnergyAdvertisingData advertisingData;
advertisingData.setDiscoverability(QLowEnergyAdvertisingData::DiscoverabilityGeneral);
@ -392,17 +370,12 @@ void BluetoothServer::start()
advertisingData.setLocalName("Loop-box");
// TODO: set guh manufacturer SIG data
// Note: start advertising in 100 ms interval, this makes the device better discoverable on certain phones
QLowEnergyAdvertisingParameters advertisingParameters;
advertisingParameters.setInterval(100,100);
qCDebug(dcBluetoothServer()) << "Start advertising loopd" << m_localDevice->address().toString();
m_controller->startAdvertising(advertisingParameters, advertisingData, advertisingData);
// Start the advertising timer
m_advertisingTimer->start();
setRunning(true);
}
void BluetoothServer::stop()
@ -434,3 +407,27 @@ void BluetoothServer::stop()
setRunning(false);
}
void BluetoothServer::onNetworkManagerAvailableChanged(bool available)
{
if (m_networkService)
m_networkService->setNetworkManagerAvailable(available);
}
void BluetoothServer::onNetworkingEnabledChanged(bool enabled)
{
if (m_networkService)
m_networkService->setNetworkingEnabled(enabled);
}
void BluetoothServer::onWirelessNetworkingEnabledChanged(bool enabled)
{
if (m_networkService)
m_networkService->setNetworkingEnabled(enabled);
}
void BluetoothServer::onNetworkManagerStateChanged(const NetworkManager::NetworkManagerState &state)
{
if (m_networkService)
m_networkService->setNetworkManagerState(state);
}

13
nymea-networkmanager/bluetooth/bluetoothserver.h
View File

@ -64,9 +64,6 @@ private:
NetworkService *m_networkService = nullptr;
WirelessService *m_wirelessService = nullptr;
SystemService *m_systemService = nullptr;
QTimer *m_advertisingTimer = nullptr;
bool m_running = false;
bool m_connected = false;
@ -94,8 +91,6 @@ private slots:
void onDisconnected();
void onControllerStateChanged(const QLowEnergyController::ControllerState &state);
void onAdvertisingTimeout();
// Services
void characteristicChanged(const QLowEnergyCharacteristic &characteristic, const QByteArray &value);
void characteristicRead(const QLowEnergyCharacteristic &characteristic, const QByteArray &value);
@ -105,9 +100,15 @@ private slots:
void serviceError(const QLowEnergyService::ServiceError &error);
public slots:
void start();
void start(WirelessNetworkDevice *wirelessDevice);
void stop();
// Network manager
void onNetworkManagerAvailableChanged(bool available);
void onNetworkingEnabledChanged(bool enabled);
void onWirelessNetworkingEnabledChanged(bool enabled);
void onNetworkManagerStateChanged(const NetworkManager::NetworkManagerState &state);
};
#endif // BLUETOOTHSERVER_H

149
nymea-networkmanager/bluetooth/networkservice.cpp
View File

@ -19,8 +19,9 @@
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "networkservice.h"
#include "core.h"
#include "bluetoothuuids.h"
#include "loggingcategories.h"
@ -39,11 +40,6 @@ NetworkService::NetworkService(QLowEnergyService *service, QObject *parent) :
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()
@ -51,6 +47,77 @@ QLowEnergyService *NetworkService::service()
return m_service;
}
void NetworkService::setNetworkManagerAvailable(bool available)
{
m_networkManagerAvailable = available;
}
void NetworkService::setNetworkManagerState(const NetworkManager::NetworkManagerState &state)
{
if (m_state == state)
return;
m_state = state;
if (!m_service) {
qCWarning(dcBluetoothServer()) << "NetworkService: Could not updatet network manager status. Service not valid";
return;
}
QLowEnergyCharacteristic characteristic = m_service->characteristic(networkStatusCharacteristicUuid);
if (!characteristic.isValid()) {
qCWarning(dcBluetoothServer()) << "NetworkService: Could not update network manager status. Characteristic not valid";
return;
}
qCDebug(dcBluetoothServer()) << "NetworkService: Notify state changed" << NetworkService::getNetworkManagerStateByteArray(m_state);
m_service->writeCharacteristic(characteristic, NetworkService::getNetworkManagerStateByteArray(m_state));
}
void NetworkService::setNetworkingEnabled(bool enabled)
{
if (m_networkingEnabled == enabled)
return;
m_networkingEnabled = enabled;
if (!m_service) {
qCWarning(dcBluetoothServer()) << "NetworkService: Could not set networking enabled. Service not valid";
return;
}
QLowEnergyCharacteristic characteristic = m_service->characteristic(networkingEnabledCharacteristicUuid);
if (!characteristic.isValid()) {
qCWarning(dcBluetoothServer()) << "NetworkService: Could not set networking enabled. Characteristic not valid";
return;
}
qCDebug(dcBluetoothServer()) << "NetworkService: Notify networking enabled changed:" << (m_networkingEnabled ? "enabled" : "disabled");
m_service->writeCharacteristic(characteristic, m_networkingEnabled ? QByteArray::fromHex("01") : QByteArray::fromHex("00"));
}
void NetworkService::setWirelessNetworkingEnabled(bool enabled)
{
if (m_wirelessNetworkingEnabled == enabled)
return;
m_wirelessNetworkingEnabled = enabled;
if (!m_service) {
qCWarning(dcBluetoothServer()) << "NetworkService: Could not set wireless enabled. Service not valid";
return;
}
QLowEnergyCharacteristic characteristic = m_service->characteristic(wirelessEnabledCharacteristicUuid);
if (!characteristic.isValid()) {
qCWarning(dcBluetoothServer()) << "NetworkService: Could not set wireless enabled. Characteristic not valid";
return;
}
qCDebug(dcBluetoothServer()) << "NetworkService: Notify wireless networking enabled changed:" << (m_wirelessNetworkingEnabled ? "enabled" : "disabled");
m_service->writeCharacteristic(characteristic, m_wirelessNetworkingEnabled ? QByteArray::fromHex("01") : QByteArray::fromHex("00"));
}
QLowEnergyServiceData NetworkService::serviceData()
{
QLowEnergyServiceData serviceData;
@ -65,7 +132,7 @@ QLowEnergyServiceData NetworkService::serviceData()
networkStatusData.setValue(QByteArray(1, 0));
networkStatusData.setProperties(QLowEnergyCharacteristic::Read | QLowEnergyCharacteristic::Notify);
networkStatusData.addDescriptor(clientConfigDescriptorData);
networkStatusData.setValue(NetworkService::getNetworkManagerStateByteArray(Loopd::instance()->networkManager()->state()));
networkStatusData.setValue(NetworkService::getNetworkManagerStateByteArray(NetworkManager::NetworkManagerStateUnknown));
serviceData.addCharacteristic(networkStatusData);
// Network manager commander ef6d6612-b8af-49e0-9eca-ab343513641c
@ -88,7 +155,7 @@ QLowEnergyServiceData NetworkService::serviceData()
networkingEnabledStatusData.setUuid(networkingEnabledCharacteristicUuid);
networkingEnabledStatusData.setValue(QByteArray(1, 0));
networkingEnabledStatusData.setProperties(QLowEnergyCharacteristic::Read | QLowEnergyCharacteristic::Notify);
networkingEnabledStatusData.setValue(QByteArray::number((int)Loopd::instance()->networkManager()->networkingEnabled()));
networkingEnabledStatusData.setValue(QByteArray::fromHex("00"));
serviceData.addCharacteristic(networkingEnabledStatusData);
// Wireless enabled ef6d6615-b8af-49e0-9eca-ab343513641c
@ -96,7 +163,7 @@ QLowEnergyServiceData NetworkService::serviceData()
wirelessEnabledStatusData.setUuid(wirelessEnabledCharacteristicUuid);
wirelessEnabledStatusData.setValue(QByteArray(1, 0));
wirelessEnabledStatusData.setProperties(QLowEnergyCharacteristic::Read | QLowEnergyCharacteristic::Notify);
wirelessEnabledStatusData.setValue(QByteArray::number((int)Loopd::instance()->networkManager()->wirelessEnabled()));
wirelessEnabledStatusData.setValue(QByteArray::fromHex("00"));
serviceData.addCharacteristic(wirelessEnabledStatusData);
return serviceData;
@ -201,7 +268,7 @@ void NetworkService::characteristicChanged(const QLowEnergyCharacteristic &chara
return;
}
if (!Loopd::instance()->networkManager()->available()) {
if (!m_networkManagerAvailable) {
qCWarning(dcBluetoothServer()) << "NetworkService: Networkmanager not available";
sendResponse(NetworkServiceResponseNetworkManagerNotAvailable);
return;
@ -274,19 +341,19 @@ void NetworkService::processCommand(const NetworkServiceCommand &command)
switch (command) {
case NetworkServiceCommandEnableNetworking:
qCDebug(dcBluetoothServer()) << "NetworkService: received \"Enable networking\" command";
Loopd::instance()->networkManager()->enableNetworking(true);
Core::instance()->networkManager()->enableNetworking(true);
break;
case NetworkServiceCommandDisableNetworking:
qCDebug(dcBluetoothServer()) << "NetworkService: received \"Disable networking\" command";
Loopd::instance()->networkManager()->enableNetworking(false);
Core::instance()->networkManager()->enableNetworking(false);
break;
case NetworkServiceCommandEnableWireless:
qCDebug(dcBluetoothServer()) << "NetworkService: received \"Enable wireless networking\" command";
Loopd::instance()->networkManager()->enableWireless(true);
Core::instance()->networkManager()->enableWireless(true);
break;
case NetworkServiceCommandDisableWireless:
qCDebug(dcBluetoothServer()) << "NetworkService: received \"Disable wireless networking\" command";
Loopd::instance()->networkManager()->enableWireless(false);
Core::instance()->networkManager()->enableWireless(false);
break;
default:
qCWarning(dcBluetoothServer()) << "NetworkService: Unhandled command" << command;
@ -294,57 +361,3 @@ void NetworkService::processCommand(const NetworkServiceCommand &command)
break;
}
}
bool NetworkService::onNetworkManagerStateChanged()
{
if (!m_service) {
qCWarning(dcBluetoothServer()) << "NetworkService: Could not updatet network manager status. Service not valid";
return false;
}
QLowEnergyCharacteristic characteristic = m_service->characteristic(networkStatusCharacteristicUuid);
if (!characteristic.isValid()) {
qCWarning(dcBluetoothServer()) << "NetworkService: Could not update network manager status. Characteristic not valid";
return false;
}
qCDebug(dcBluetoothServer()) << "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(dcBluetoothServer()) << "NetworkService: Could not set networking enabled. Service not valid";
return false;
}
QLowEnergyCharacteristic characteristic = m_service->characteristic(networkingEnabledCharacteristicUuid);
if (!characteristic.isValid()) {
qCWarning(dcBluetoothServer()) << "NetworkService: Could not set networking enabled. Characteristic not valid";
return false;
}
qCDebug(dcBluetoothServer()) << "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(dcBluetoothServer()) << "NetworkService: Could not set wireless enabled. Service not valid";
return false;
}
QLowEnergyCharacteristic characteristic = m_service->characteristic(wirelessEnabledCharacteristicUuid);
if (!characteristic.isValid()) {
qCWarning(dcBluetoothServer()) << "NetworkService: Could not set wireless enabled. Characteristic not valid";
return false;
}
qCDebug(dcBluetoothServer()) << "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;
}

19
nymea-networkmanager/bluetooth/networkservice.h
View File

@ -57,13 +57,23 @@ public:
QLowEnergyService *service();
void setNetworkManagerAvailable(bool available);
void setNetworkManagerState(const NetworkManager::NetworkManagerState &state);
void setNetworkingEnabled(bool enabled);
void setWirelessNetworkingEnabled(bool enabled);
static QLowEnergyServiceData serviceData();
static QByteArray getNetworkManagerStateByteArray(const NetworkManager::NetworkManagerState &state);
private:
QLowEnergyService *m_service;
void sendResponse(const NetworkServiceResponse &response);
QLowEnergyService *m_service = nullptr;
bool m_networkManagerAvailable = false;
NetworkManager::NetworkManagerState m_state = NetworkManager::NetworkManagerStateUnknown;
bool m_networkingEnabled = false;
bool m_wirelessNetworkingEnabled = false;
void sendResponse(const NetworkServiceResponse &response);
NetworkServiceCommand verifyCommand(const QByteArray &commandData);
private slots:
@ -78,11 +88,6 @@ private slots:
// Commands
void processCommand(const NetworkServiceCommand &command);
public slots:
bool onNetworkManagerStateChanged();
bool onNetworkingEnabledChanged();
bool onWirelessEnabledChanged();
};
#endif // NETWORKSERVICE_H

1
nymea-networkmanager/bluetooth/systemservice.h
View File

@ -39,7 +39,6 @@ private:
void streamData(const QVariantMap &responseMap);
QVariantMap createResponse(const SystemServiceCommand &command, const SystemServiceResponse &responseCode = SystemServiceResponseSuccess);
private slots:
// Service
void characteristicChanged(const QLowEnergyCharacteristic &characteristic, const QByteArray &value);

28
nymea-networkmanager/bluetooth/wirelessservice.cpp
View File

@ -20,6 +20,8 @@
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "wirelessservice.h"
#include "core.h"
#include "bluetoothuuids.h"
#include "loggingcategories.h"
@ -28,10 +30,10 @@
#include <QLowEnergyDescriptorData>
#include <QLowEnergyCharacteristicData>
WirelessService::WirelessService(QLowEnergyService *service, QObject *parent) :
WirelessService::WirelessService(QLowEnergyService *service, WirelessNetworkDevice *wirelessDevice, QObject *parent) :
QObject(parent),
m_service(service),
m_device(nullptr),
m_device(wirelessDevice),
m_readingInputData(false)
{
qCDebug(dcBluetoothServer()) << "Create WirelessService.";
@ -43,14 +45,8 @@ WirelessService::WirelessService(QLowEnergyService *service, QObject *parent) :
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(dcBluetoothServer()) << "WirelessService: There is no wireless network device available";
return;
}
qCDebug(dcBluetoothServer()) << "WirelessService: Using" << Loopd::instance()->networkManager()->wirelessNetworkDevices().first();
m_device = Loopd::instance()->networkManager()->wirelessNetworkDevices().first();
qCDebug(dcBluetoothServer()) << "WirelessService: Using" << m_device;
connect(m_device, &WirelessNetworkDevice::bitRateChanged, this, &WirelessService::onWirelessDeviceBitRateChanged);
connect(m_device, &WirelessNetworkDevice::stateChanged, this, &WirelessService::onWirelessDeviceStateChanged);
}
@ -89,11 +85,7 @@ QLowEnergyServiceData WirelessService::serviceData()
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()));
}
wirelessStatusCharacteristicData.setValue(WirelessService::getWirelessNetworkDeviceState(NetworkDevice::NetworkDeviceStateUnknown));
serviceData.addCharacteristic(wirelessStatusCharacteristicData);
return serviceData;
@ -103,7 +95,7 @@ QLowEnergyServiceData WirelessService::serviceData()
WirelessService::WirelessServiceResponse WirelessService::checkWirelessErrors()
{
// Check possible errors
if (!Loopd::instance()->networkManager()->available()) {
if (!Core::instance()->networkManager()->available()) {
qCWarning(dcBluetoothServer()) << "WirelessService: The networkmanager is not available.";
return WirelessServiceResponseNetworkManagerNotAvailable;
}
@ -113,12 +105,12 @@ WirelessService::WirelessServiceResponse WirelessService::checkWirelessErrors()
return WirelessServiceResponseWirelessNotAvailable;
}
if (!Loopd::instance()->networkManager()->networkingEnabled()) {
if (!Core::instance()->networkManager()->networkingEnabled()) {
qCWarning(dcBluetoothServer()) << "WirelessService: Networking not enabled";
return WirelessServiceResponseNetworkingNotEnabled;
}
if (!Loopd::instance()->networkManager()->wirelessEnabled()) {
if (!Core::instance()->networkManager()->wirelessEnabled()) {
qCWarning(dcBluetoothServer()) << "WirelessService: Wireless not enabled";
return WirelessServiceResponseWirelessNotEnabled;
}
@ -253,7 +245,7 @@ void WirelessService::commandConnect(const QVariantMap &request)
return;
}
Loopd::instance()->networkManager()->connectWifi(m_device->interface(), parameters.value("e").toString(), parameters.value("p").toString());
Core::instance()->networkManager()->connectWifi(m_device->interface(), parameters.value("e").toString(), parameters.value("p").toString());
streamData(createResponse(WirelessServiceCommandConnect));
}

9
nymea-networkmanager/bluetooth/wirelessservice.h
View File

@ -61,16 +61,17 @@ public:
};
Q_ENUM(WirelessServiceResponse)
explicit WirelessService(QLowEnergyService *service, QObject *parent = 0);
explicit WirelessService(QLowEnergyService *service, WirelessNetworkDevice *wirelessDevice, QObject *parent = 0);
QLowEnergyService *service();
static QLowEnergyServiceData serviceData();
private:
QLowEnergyService *m_service;
WirelessNetworkDevice *m_device;
QLowEnergyService *m_service = nullptr;
WirelessNetworkDevice *m_device = nullptr;
bool m_readingInputData;
bool m_readingInputData = false;
QByteArray m_inputDataStream;
WirelessServiceResponse checkWirelessErrors();

38
nymea-networkmanager/core.cpp
View File

@ -20,8 +20,9 @@
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "core.h"
#include "loggingcategories.h"
Core* Core::s_instance = 0;
Core* Core::s_instance = nullptr;
Core *Core::instance()
{
@ -32,17 +33,48 @@ Core *Core::instance()
}
void Core::destroy()
{
{
if (s_instance)
delete s_instance;
s_instance = 0;
s_instance = nullptr;
}
NetworkManager *Core::networkManager() const
{
return m_networkManager;
}
Core::Core(QObject *parent) :
QObject(parent)
{
m_networkManager = new NetworkManager(this);
connect(m_networkManager, &NetworkManager::availableChanged, this, &Core::onNetworkManagerAvailableChanged);
m_bluetoothServer = new BluetoothServer("nymea", this);
m_nymeaService = new NymeadService(false, this);
if (!m_networkManager->start()) {
qCWarning(dcApplication()) << "Could not start network manager.";
}
}
Core::~Core()
{
delete m_networkManager;
m_networkManager = nullptr;
delete m_bluetoothServer;
m_bluetoothServer = nullptr;
}
void Core::onNetworkManagerAvailableChanged(const bool &available)
{
if (!available) {
qCWarning(dcApplication()) << "Networkmanager is not available any more.";
} else {
qCDebug(dcApplication()) << "Networkmanager is now available.";
}
}

13
nymea-networkmanager/core.h
View File

@ -25,6 +25,8 @@
#include <QObject>
#include "networkmanager.h"
#include "nymeadservice.h"
#include "bluetooth/bluetoothserver.h"
class Core : public QObject
{
@ -33,17 +35,20 @@ public:
static Core* instance();
void destroy();
NetworkManager *networkManager() const;
private:
explicit Core(QObject *parent = nullptr);
~Core();
static Core *s_instance;
NetworkManager *m_networkManager = nullptr;
BluetoothServer *m_bluetoothServer = nullptr;
NymeadService *m_nymeaService = nullptr;
signals:
public slots:
private slots:
void onNetworkManagerAvailableChanged(const bool &available);
};

1
nymea-networkmanager/bluetooth/loggingcategories.cpp → nymea-networkmanager/loggingcategories.cpp
View File

@ -21,5 +21,6 @@
#include "loggingcategories.h"
Q_LOGGING_CATEGORY(dcApplication, "Application")
Q_LOGGING_CATEGORY(dcBluetoothServer, "BluetoothServer")
Q_LOGGING_CATEGORY(dcNymeaService, "NymeaService")

1
nymea-networkmanager/bluetooth/loggingcategories.h → nymea-networkmanager/loggingcategories.h
View File

@ -25,6 +25,7 @@
#include <QDebug>
#include <QLoggingCategory>
Q_DECLARE_LOGGING_CATEGORY(dcApplication)
Q_DECLARE_LOGGING_CATEGORY(dcBluetoothServer)
Q_DECLARE_LOGGING_CATEGORY(dcNymeaService)

27
nymea-networkmanager/main.cpp
View File

@ -20,11 +20,12 @@
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include <QCoreApplication>
#include <QLoggingCategory>
#include <QCommandLineParser>
#include <QCommandLineOption>
#include "core.h"
#include "application.h"
#include "loggingcategories.h"
static const char *const normal = "\033[0m";
static const char *const warning = "\e[33m";
@ -72,24 +73,38 @@ static void consoleLogHandler(QtMsgType type, const QMessageLogContext& context,
}
int main(int argc, char *argv[])
{
qInstallMessageHandler(consoleLogHandler);
QCoreApplication application(argc, argv);
application.setApplicationName("loopd");
application.setOrganizationName("guh");
Application application(argc, argv);
application.setApplicationName("nymea-networkmanager");
application.setOrganizationName("nymea");
application.setApplicationVersion("0.0.1");
// Command line parser
QCommandLineParser parser;
parser.addHelpOption();
parser.addVersionOption();
parser.setApplicationDescription(QString("\nThis daemon allows to configure a wifi network with a bluetooth low energy connection.\n\nCopyright %1 2018 Simon Stürz <simon.stuerz@guh.io>").arg(QChar(0xA9)));
parser.setApplicationDescription(QString("\nThis daemon allows to configure a wifi network using a bluetooth low energy connection.\n\nCopyright %1 2018 Simon Stürz <simon.stuerz@guh.io>").arg(QChar(0xA9)));
// TODO: set options
parser.process(application);
// Enable debug categories
s_loggingFilters.insert("Application", true);
s_loggingFilters.insert("BluetoothServer", true);
s_loggingFilters.insert("NetworkManager", true);
s_loggingFilters.insert("NymeaService", true);
QLoggingCategory::installFilter(loggingCategoryFilter);
qCDebug(dcApplication()) << "=====================================";
qCDebug(dcApplication()) << "Starting nymea-networkmanager" << application.applicationVersion();
qCDebug(dcApplication()) << "=====================================";
// Start core
Core::instance();
return application.exec();

12
nymea-networkmanager/nymea-networkmanager.pro
View File

@ -11,23 +11,29 @@ CONFIG -= app_bundle
TEMPLATE = app
INCLUDEPATH += $$top_srcdir/libnymea-networkmanager/
LIBS += -L$$top_builddir/libnymea-networkmanager/ -lnymea-networkmanager1
LIBS += -L$$top_builddir/libnymea-networkmanager/ -lnymea-networkmanager
HEADERS += \
application.h \
core.h \
loggingcategories.h \
nymeadservice.h \
pushbuttonagent.h \
bluetooth/bluetoothserver.h \
bluetooth/networkservice.h \
bluetooth/bluetoothuuids.h \
bluetooth/wirelessservice.h \
bluetooth/loggingcategories.h
SOURCES += \
main.cpp \
application.cpp \
core.cpp \
loggingcategories.cpp \
nymeadservice.cpp \
pushbuttonagent.cpp \
bluetooth/bluetoothserver.cpp \
bluetooth/networkservice.cpp \
bluetooth/wirelessservice.cpp \
bluetooth/loggingcategories.cpp
target.path = /usr/bin
INSTALLS += target

121
nymea-networkmanager/nymeadservice.cpp Normal file
View File

@ -0,0 +1,121 @@
#include "nymeadservice.h"
#include "loggingcategories.h"
NymeadService::NymeadService(bool pushbuttonEnabled, QObject *parent) :
QObject(parent),
m_pushbuttonEnabled(pushbuttonEnabled)
{
// Check DBus connection
if (!QDBusConnection::systemBus().isConnected()) {
qCWarning(dcNymeaService()) << "System DBus not connected.";
return;
}
// Get notification when nymead appears/disappears on DBus
m_serviceWatcher = new QDBusServiceWatcher("io.guh.nymead", QDBusConnection::systemBus(), QDBusServiceWatcher::WatchForRegistration | QDBusServiceWatcher::WatchForUnregistration, this);
connect(m_serviceWatcher, &QDBusServiceWatcher::serviceRegistered, this, &NymeadService::serviceRegistered);
connect(m_serviceWatcher, &QDBusServiceWatcher::serviceUnregistered, this, &NymeadService::serviceUnregistered);
if (init()) {
qCDebug(dcNymeaService()) << "Initialized nymea D-Bus services successfully";
} else {
qCWarning(dcNymeaService()) << "Could not init nymea D-Bus services";
setAvailable(false);
}
}
bool NymeadService::available() const
{
return m_available;
}
void NymeadService::enableBluetooth(const bool &enable)
{
if (!m_nymeadHardwareInterface) {
qCCritical(dcNymeaService()) << "Could not enable/disable bluetooth hardware resource. D-Bus interface not available.";
return;
}
qCDebug(dcNymeaService()) << "Request nymea to" << (enable ? "enable" : "disable") << "bluetooth resources";
QDBusMessage query = m_nymeadHardwareInterface->call("EnableBluetooth", enable);
if(query.type() != QDBusMessage::ReplyMessage) {
qCWarning(dcNymeaService()) << "Could not enable/disable bluetooth on dbus:" << query.errorName() << query.errorMessage();
return;
}
}
void NymeadService::pushButtonPressed()
{
if (!m_pushButtonAgent) {
qCCritical(dcNymeaService()) << "Could not press pushbutton. Pushbutton agent not available.";
return;
}
qCDebug(dcNymeaService()) << "Pushbutton pressed. Send to nymead";
m_pushButtonAgent->sendButtonPressed();
}
void NymeadService::setAvailable(const bool &available)
{
if (m_available == available)
return;
if (available) {
qCDebug(dcNymeaService()) << "Service is now available.";
} else {
qCWarning(dcNymeaService()) << "Service is not available any more.";
}
m_available = available;
emit availableChanged(m_available);
}
bool NymeadService::init()
{
if (m_pushbuttonEnabled) {
m_pushButtonAgent = new PushButtonAgent(this);
if (!m_pushButtonAgent->init()) {
qCWarning(dcNymeaService()) << "Could not init D-Bus push button agent.";
m_pushButtonAgent->deleteLater();
m_pushButtonAgent = nullptr;
return false;
}
}
m_nymeadHardwareInterface = new QDBusInterface("io.guh.nymead", "/io/guh/nymead/HardwareManager", "io.guh.nymead", QDBusConnection::systemBus(), this);
if (!m_nymeadHardwareInterface->isValid()) {
qCWarning(dcNymeaService()) << "Invalid D-Bus HardwareManager interface.";
m_nymeadHardwareInterface->deleteLater();
m_nymeadHardwareInterface = nullptr;
return false;
}
setAvailable(true);
return true;
}
void NymeadService::serviceRegistered(const QString &serviceName)
{
qCDebug(dcNymeaService()) << "Service registered" << serviceName;
if (!m_available) {
init();
}
}
void NymeadService::serviceUnregistered(const QString &serviceName)
{
qCDebug(dcNymeaService()) << "Service unregistered" << serviceName;
if (m_pushButtonAgent) {
m_pushButtonAgent->deleteLater();
m_pushButtonAgent = nullptr;
}
if (m_nymeadHardwareInterface) {
m_nymeadHardwareInterface->deleteLater();
m_nymeadHardwareInterface = nullptr;
}
setAvailable(false);
}

43
nymea-networkmanager/nymeadservice.h Normal file
View File

@ -0,0 +1,43 @@
#ifndef NYMEADSERVICE_H
#define NYMEADSERVICE_H
#include <QObject>
#include <QDBusInterface>
#include <QDBusConnection>
#include <QDBusServiceWatcher>
#include "pushbuttonagent.h"
class NymeadService : public QObject
{
Q_OBJECT
public:
explicit NymeadService(bool pushbuttonEnabled, QObject *parent = nullptr);
bool available() const;
void enableBluetooth(const bool &enable);
void pushButtonPressed();
private:
QDBusServiceWatcher *m_serviceWatcher = nullptr;
PushButtonAgent *m_pushButtonAgent = nullptr;
QDBusInterface *m_nymeadHardwareInterface = nullptr;
bool m_pushbuttonEnabled = false;
bool m_available = false;
void setAvailable(const bool &available);
bool init();
signals:
void availableChanged(const bool &available);
private slots:
void serviceRegistered(const QString &serviceName);
void serviceUnregistered(const QString &serviceName);
};
#endif // NYMEADSERVICE_H

38
nymea-networkmanager/pushbuttonagent.cpp Normal file
View File

@ -0,0 +1,38 @@
#include "pushbuttonagent.h"
#include "loggingcategories.h"
#include <QDBusMessage>
#include <QDBusObjectPath>
PushButtonAgent::PushButtonAgent(QObject *parent) :
QObject(parent)
{
}
bool PushButtonAgent::init(QDBusConnection::BusType busType)
{
QDBusConnection bus = busType == QDBusConnection::SessionBus ? QDBusConnection::sessionBus() : QDBusConnection::systemBus();
bool result = bus.registerObject("/io/guh/loopd/pushbutton", this, QDBusConnection::ExportScriptableContents);
if (!result) {
qCWarning(dcNymeaService()) << "PushButtonAgent: Error registering PushButton agent on D-Bus.";
return false;
}
QDBusMessage message = QDBusMessage::createMethodCall("io.guh.nymead", "/io/guh/nymead/UserManager", QString(), "RegisterButtonAgent");
message << qVariantFromValue(QDBusObjectPath("/io/guh/loopd/pushbutton"));
QDBusMessage reply = bus.call(message);
if (!reply.errorName().isEmpty()) {
qCWarning(dcNymeaService()) << "PushButtonAgent: Error registering PushButton agent:" << reply.errorMessage();
return false;
}
qCDebug(dcNymeaService()) << "PushButton agent registered.";
return true;
}
void PushButtonAgent::sendButtonPressed()
{
qCDebug(dcNymeaService()) << "PushButtonAgent: Sending button pressed event.";
emit PushButtonPressed();
}

23
nymea-networkmanager/pushbuttonagent.h Normal file
View File

@ -0,0 +1,23 @@
#ifndef PUSHBUTTONAGENT_H
#define PUSHBUTTONAGENT_H
#include <QObject>
#include <QDBusConnection>
class PushButtonAgent : public QObject
{
Q_OBJECT
public:
explicit PushButtonAgent(QObject *parent = nullptr);
bool init(QDBusConnection::BusType busType = QDBusConnection::SystemBus);
signals:
Q_SCRIPTABLE void PushButtonPressed();
public slots:
void sendButtonPressed();
};
#endif // PUSHBUTTONAGENT_H