blob: e4df44648267a880bb40c114d7a79e07ec85a360 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
/* Copyright (C) 2013 BMW Group
* Author: Manfred Bathelt (manfred.bathelt@bmw.de)
* Author: Juergen Gehring (juergen.gehring@bmw.de)
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "DBusMainLoopContext.h"
#include "DBusConnection.h"
#ifdef WIN32
#include <CommonAPI/pollStructures.h>
#else
#include <poll.h>
#endif
#include <chrono>
namespace CommonAPI {
namespace DBus {
DBusDispatchSource::DBusDispatchSource(DBusConnection* dbusConnection):
dbusConnection_(dbusConnection) {
}
DBusDispatchSource::~DBusDispatchSource() {
}
bool DBusDispatchSource::prepare(int64_t& timeout) {
return dbusConnection_->isDispatchReady();
}
bool DBusDispatchSource::check() {
return dbusConnection_->isDispatchReady();
}
bool DBusDispatchSource::dispatch() {
return dbusConnection_->singleDispatch();
}
DBusWatch::DBusWatch(::DBusWatch* libdbusWatch, std::weak_ptr<MainLoopContext>& mainLoopContext):
libdbusWatch_(libdbusWatch),
mainLoopContext_(mainLoopContext),
channelFlags_(0) {
assert(libdbusWatch_);
}
bool DBusWatch::isReadyToBeWatched() {
return dbus_watch_get_enabled(libdbusWatch_);
}
void DBusWatch::startWatching() {
channelFlags_ = dbus_watch_get_flags(libdbusWatch_);
short int pollFlags = POLLERR | POLLHUP;
if(channelFlags_ & DBUS_WATCH_READABLE) {
pollFlags |= POLLIN;
}
if(channelFlags_ & DBUS_WATCH_WRITABLE) {
pollFlags |= POLLOUT;
}
pollFileDescriptor_.fd = dbus_watch_get_unix_fd(libdbusWatch_);
pollFileDescriptor_.events = pollFlags;
pollFileDescriptor_.revents = 0;
auto lockedContext = mainLoopContext_.lock();
assert(lockedContext);
lockedContext->registerWatch(this);
}
void DBusWatch::stopWatching() {
auto lockedContext = mainLoopContext_.lock();
assert(lockedContext);
lockedContext->deregisterWatch(this);
}
const COMMONAPI_POLLFD& DBusWatch::getAssociatedFileDescriptor() {
return pollFileDescriptor_;
}
//XXX Default hierfür die revent-flags?
void DBusWatch::dispatch(unsigned int eventFlags) {
dbus_watch_handle(libdbusWatch_, eventFlags);
}
const std::vector<DispatchSource*>& DBusWatch::getDependentDispatchSources() {
return dependentDispatchSources_;
}
void DBusWatch::addDependentDispatchSource(DispatchSource* dispatchSource) {
dependentDispatchSources_.push_back(dispatchSource);
}
DBusTimeout::DBusTimeout(::DBusTimeout* libdbusTimeout, std::weak_ptr<MainLoopContext>& mainLoopContext) :
libdbusTimeout_(libdbusTimeout),
mainLoopContext_(mainLoopContext),
dueTimeInMs_(TIMEOUT_INFINITE) {
}
bool DBusTimeout::isReadyToBeMonitored() {
return dbus_timeout_get_enabled(libdbusTimeout_);
}
void DBusTimeout::startMonitoring() {
auto lockedContext = mainLoopContext_.lock();
assert(lockedContext);
recalculateDueTime();
lockedContext->registerTimeoutSource(this);
}
void DBusTimeout::stopMonitoring() {
dueTimeInMs_ = TIMEOUT_INFINITE;
auto lockedContext = mainLoopContext_.lock();
assert(lockedContext);
lockedContext->deregisterTimeoutSource(this);
}
bool DBusTimeout::dispatch() {
recalculateDueTime();
dbus_timeout_handle(libdbusTimeout_);
return true;
}
int64_t DBusTimeout::getTimeoutInterval() const {
return dbus_timeout_get_interval(libdbusTimeout_);
}
int64_t DBusTimeout::getReadyTime() const {
return dueTimeInMs_;
}
void DBusTimeout::recalculateDueTime() {
if(dbus_timeout_get_enabled(libdbusTimeout_)) {
unsigned int intervalInMs = dbus_timeout_get_interval(libdbusTimeout_);
dueTimeInMs_ = getCurrentTimeInMs() + intervalInMs;
} else {
dueTimeInMs_ = TIMEOUT_INFINITE;
}
}
} // namespace DBus
} // namespace CommonAPI
|
