1
0
mirror of https://github.com/binary-kitchen/doorlockd synced 2024-10-31 22:47:05 +01:00
doorlockd-mirror/doorlockd/client/doorlock-client.cpp
Ralf Ramsauer 49a5b88f6c Big rewrite of several things
- Data type Token changed from uint64_t to std::string
- Added new class "Request" that describes a JSON TCP request
- Classes may now throw Responses for proper error handling
- Removed JSON parsing from Logic
- proper Error handling everywhere
- Many small fixes
- removed unnecessary includes
- removed using namespace std everywhere
2015-10-01 22:09:55 +02:00

193 lines
5.3 KiB
C++

#include <exception>
#include <iostream>
#include <string>
#include <thread>
#include <boost/asio.hpp>
#include <boost/program_options.hpp>
#include <QApplication>
#include "config.h"
#include "../lib/clientmessage.h"
#include "../lib/logger.h"
#include "../lib/response.h"
#include "mainwindow.h"
// Info about doorlock-client version
const static std::string version =
"doorlock-client-" DOORLOCK_VERSION;
const static std::string gitversion =
DOORLOCK_GIT_BRANCH "-" DOORLOCK_GIT_COMMIT_HASH;
const static Logger &l = Logger::get();
namespace po = boost::program_options;
namespace ba = boost::asio;
using ba::ip::tcp;
ba::io_service io_service;
const static std::string subscriptionCommand =
"{ \"command\": \"subscribe\"}";
// The receive buffer length of the TCP socket
const int constexpr SOCKET_BUFFERLENGTH = 2048;
static volatile bool run = true;
std::unique_ptr<MainWindow> mainWindow = nullptr;
static void onDoorlockUpdate(const Clientmessage &msg)
{
const auto& doormessage = msg.doormessage();
l("Received message", LogLevel::info);
l((std::string)" token: " + msg.token(),
LogLevel::info);
l((std::string)" open: " + std::to_string(doormessage.isOpen),
LogLevel::info);
l((std::string)" button lock: " + std::to_string(doormessage.isLockButton),
LogLevel::info);
l((std::string)" button unlock: " + std::to_string(doormessage.isUnlockButton),
LogLevel::info);
l((std::string)" emergency open: " + std::to_string(doormessage.isEmergencyUnlock),
LogLevel::info);
if (mainWindow) {
mainWindow->setQRCode(msg.token());
}
}
static int doorlock_client(const std::string &hostname,
const unsigned short port)
{
int retval = 0;
try {
tcp::resolver resolver(io_service);
tcp::socket socket(io_service);
tcp::resolver::query query(hostname, std::to_string(port));
tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
tcp::resolver::iterator end;
boost::system::error_code error = ba::error::host_not_found;
std::vector<char> data;
while (error && endpoint_iterator != end) {
socket.close();
socket.connect(*endpoint_iterator++, error);
}
if (error)
throw boost::system::system_error(error);
// After connection is established, send the subscription command
socket.write_some(ba::buffer(subscriptionCommand), error);
if (error)
throw boost::system::system_error(error);
data.resize(SOCKET_BUFFERLENGTH);
std::function<void(void)> receiveMessage = [&] () {
socket.async_read_some(ba::buffer(data),
[&] (const boost::system::error_code &ec,
const size_t length)
{
if (ec) {
throw boost::system::system_error(ec);
}
const auto message = Clientmessage::fromString(
std::string(data.begin(), data.begin()+length));
onDoorlockUpdate(message);
receiveMessage();
});
};
receiveMessage();
io_service.run();
}
catch(const Response &err) {
l(err.message, LogLevel::error);
retval = -1;
}
catch(const std::exception &err) {
l(LogLevel::error, err.what());
retval = -1;
}
return retval;
}
int main(int argc, char** argv)
{
std::string hostname;
unsigned short port;
l((std::string)"Hello, this is " + version + " built on " + gitversion,
LogLevel::info);
try {
po::options_description desc("doorlockd (" + version + " built on " + gitversion + ")");
desc.add_options()
("help,h",
"print help")
("port,p",
po::value<unsigned short>(&port)->default_value(DEFAULT_PORT),
"Port")
("host,c",
po::value<std::string>(&hostname)->default_value("localhost"),
"IP or name of host running doorlockd");
po::variables_map vm;
po::store(po::command_line_parser(argc, argv).options(desc).run(), vm);
if (vm.count("help"))
{
std::cout << desc << std::endl;
exit(-1);
}
po::notify(vm);
}
catch(const std::exception &e)
{
l(LogLevel::error, e.what());
exit(-1);
}
l(LogLevel::notice, "Starting doorlock-client");
QApplication app(argc, argv);
app.setOrganizationName("Binary Kitchen");
app.setApplicationName("doorlock-client");
mainWindow = std::unique_ptr<MainWindow>(new MainWindow);
mainWindow->showFullScreen();
// Start the TCP client as thread
std::thread clientThread = std::thread([&] () {
// If the TCP client returns, an error has occured
// In normal operation, it never returns
doorlock_client(hostname, port);
// This will stop the Qapplication
mainWindow->hide();
mainWindow->close();
});
// This routine will never return in normal operation
app.exec();
// Stop the IO service
io_service.stop();
clientThread.join();
if (mainWindow)
mainWindow.reset();
l(LogLevel::notice, "Stopping doorlock-client");
return 0;
}