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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROMEOS_DBUS_PEER_DAEMON_MANAGER_CLIENT_H_
#define CHROMEOS_DBUS_PEER_DAEMON_MANAGER_CLIENT_H_
#include <stdint.h>
#include <map>
#include <string>
#include <utility>
#include <vector>
#include "base/macros.h"
#include "base/values.h"
#include "chromeos/chromeos_export.h"
#include "chromeos/dbus/dbus_client.h"
#include "chromeos/dbus/dbus_method_call_status.h"
#include "dbus/property.h"
namespace chromeos {
// PeerDaemonManagerClient is used to communicate with the PeerDaemon Manager
// service. All methods should be called from the origin thread which
// initializes the DBusThreadManager instance.
class CHROMEOS_EXPORT PeerDaemonManagerClient : public DBusClient {
public:
class ManagerProperties : public dbus::PropertySet {
public:
ManagerProperties(dbus::ObjectProxy* object_proxy,
const PropertyChangedCallback& callback);
~ManagerProperties() override;
const std::vector<std::string>& monitored_technologies() const {
return monitored_technologies_.value();
}
private:
dbus::Property<std::vector<std::string>> monitored_technologies_;
DISALLOW_COPY_AND_ASSIGN(ManagerProperties);
};
class ServiceProperties : public dbus::PropertySet {
public:
ServiceProperties(dbus::ObjectProxy* object_proxy,
const PropertyChangedCallback& callback);
~ServiceProperties() override;
const std::string& service_id() const { return service_id_.value(); }
const std::map<std::string, std::string>& service_info() const {
return service_info_.value();
}
const std::vector<std::pair<std::vector<uint8_t>, uint16_t>>& ip_infos()
const {
return ip_infos_.value();
}
private:
dbus::Property<std::string> service_id_;
dbus::Property<std::map<std::string, std::string>> service_info_;
dbus::Property<std::vector<std::pair<std::vector<uint8_t>, uint16_t>>>
ip_infos_;
DISALLOW_COPY_AND_ASSIGN(ServiceProperties);
};
class PeerProperties : public dbus::PropertySet {
public:
PeerProperties(dbus::ObjectProxy* object_proxy,
const PropertyChangedCallback& callback);
~PeerProperties() override;
const std::string& uuid() const { return uuid_.value(); }
uint64_t last_seen() const { return last_seen_.value(); }
private:
dbus::Property<std::string> uuid_;
dbus::Property<uint64_t> last_seen_;
DISALLOW_COPY_AND_ASSIGN(PeerProperties);
};
// Interface for observing changes from a leadership daemon.
class Observer {
public:
virtual ~Observer() {}
// Called when the peer daemon manager is added.
virtual void ManagerAdded() {}
// Called when the peer daemon manager is removed; perhaps on a process
// crash of the peer daemon.
virtual void ManagerRemoved() {}
// Called when the manager changes a property value.
virtual void ManagerPropertyChanged(const std::string& property_name) {}
// Called when the service with object path |object_path| is added to the
// system.
virtual void ServiceAdded(const dbus::ObjectPath& object_path) {}
// Called when the service with object path |object_path| is removed from
// the system.
virtual void ServiceRemoved(const dbus::ObjectPath& object_path) {}
// Called when the service with object path |object_path| changes a
// property value.
virtual void ServicePropertyChanged(const dbus::ObjectPath& object_path,
const std::string& property_name) {}
// Called when the peer with object path |object_path| is added to the
// system.
virtual void PeerAdded(const dbus::ObjectPath& object_path) {}
// Called when the peer with object path |object_path| is removed from
// the system.
virtual void PeerRemoved(const dbus::ObjectPath& object_path) {}
// Called when the peer with object path |object_path| changes a
// property value.
virtual void PeerPropertyChanged(const dbus::ObjectPath& object_path,
const std::string& property_name) {}
};
~PeerDaemonManagerClient() override;
// Factory function, creates a new instance which is owned by the caller.
// For normal usage, access the singleton via DBusThreadManager::Get().
static PeerDaemonManagerClient* Create();
// Adds and removes observers for events on all peer events.
virtual void AddObserver(Observer* observer) = 0;
virtual void RemoveObserver(Observer* observer) = 0;
// Retrieves a list of all the services.
virtual std::vector<dbus::ObjectPath> GetServices() = 0;
// Retrieves a list of all the peers.
virtual std::vector<dbus::ObjectPath> GetPeers() = 0;
// Obtains the properties for the service with object path |object_path|,
// any values should be copied if needed.
virtual ServiceProperties* GetServiceProperties(
const dbus::ObjectPath& object_path) = 0;
// Obtains the properties for the peer with object path |object_path|,
// any values should be copied if needed.
virtual PeerProperties* GetPeerProperties(
const dbus::ObjectPath& object_path) = 0;
// Calls StartMonitoring method.
// |callback| is called with its |call_status| argument set to
// DBUS_METHOD_CALL_SUCCESS if the method call succeeds. Otherwise,
// |callback| is called with |call_status| set to DBUS_METHOD_CALL_FAILURE.
virtual void StartMonitoring(
const std::vector<std::string>& requested_technologies,
const base::DictionaryValue& options,
const StringDBusMethodCallback& callback) = 0;
// Calls StopMonitoring method.
// |callback| is called with its |call_status| argument set to
// DBUS_METHOD_CALL_SUCCESS if the method call succeeds. Otherwise,
// |callback| is called with |call_status| set to DBUS_METHOD_CALL_FAILURE.
virtual void StopMonitoring(const std::string& monitoring_token,
const VoidDBusMethodCallback& callback) = 0;
// Calls ExposeService method.
// |callback| is called with its |call_status| argument set to
// DBUS_METHOD_CALL_SUCCESS if the method call succeeds. Otherwise,
// |callback| is called with |call_status| set to DBUS_METHOD_CALL_FAILURE.
virtual void ExposeService(
const std::string& service_id,
const std::map<std::string, std::string>& service_info,
const base::DictionaryValue& options,
const StringDBusMethodCallback& callback) = 0;
// Calls RemoveExposedService method.
// |callback| is called with its |call_status| argument set to
// DBUS_METHOD_CALL_SUCCESS if the method call succeeds. Otherwise,
// |callback| is called with |call_status| set to DBUS_METHOD_CALL_FAILURE.
virtual void RemoveExposedService(const std::string& service_token,
const VoidDBusMethodCallback& callback) = 0;
// Calls Ping method.
// |callback| is called with its |call_status| argument set to
// DBUS_METHOD_CALL_SUCCESS if the method call succeeds. Otherwise,
// |callback| is called with |call_status| set to DBUS_METHOD_CALL_FAILURE.
virtual void Ping(const StringDBusMethodCallback& callback) = 0;
protected:
// Create() should be used instead.
PeerDaemonManagerClient();
private:
DISALLOW_COPY_AND_ASSIGN(PeerDaemonManagerClient);
};
} // namespace chromeos
#endif // CHROMEOS_DBUS_PEER_DAEMON_MANAGER_CLIENT_H_
|
