← Back to branch summary

~phablet-team/aethercast/fix-for-microsoft-dongle

« back to all changes in this revision

Viewing changes to src/mcs/miracastcontrollerskeleton.cpp

Introduce interface mcs::MiracastController to decouple MiracastService and MiracastServiceAdapter.
Refactor mcs::MiracastServiceAdapter to be a skeleton-implementation of MiracastController and rename accordingly.

Approved by Simon Fels, PS Jenkins bot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mcs/miracastcontrollerskeleton.cpp
22
22
 
23
23
#include <boost/concept_check.hpp>
24
24
 
25
 
#include "miracastserviceadapter.h"
 
25
#include "miracastcontrollerskeleton.h"
26
26
#include "keep_alive.h"
27
27
#include "utils.h"
28
28
#include "dbushelpers.h"
29
29
#include "logger.h"
30
30
 
31
31
namespace mcs {
32
 
std::shared_ptr<MiracastServiceAdapter> MiracastServiceAdapter::create(const std::shared_ptr<MiracastService> &service) {
33
 
    return std::shared_ptr<MiracastServiceAdapter>(new MiracastServiceAdapter(service))->FinalizeConstruction();
 
32
std::shared_ptr<MiracastControllerSkeleton> MiracastControllerSkeleton::create(const std::shared_ptr<MiracastController> &controller) {
 
33
    return std::shared_ptr<MiracastControllerSkeleton>(new MiracastControllerSkeleton(controller))->FinalizeConstruction();
34
34
}
35
35
 
36
 
MiracastServiceAdapter::MiracastServiceAdapter(const std::shared_ptr<MiracastService> &service) :
37
 
    service_(service),
 
36
MiracastControllerSkeleton::MiracastControllerSkeleton(const std::shared_ptr<MiracastController> &controller) :
 
37
    ForwardingMiracastController(controller),
38
38
    manager_obj_(nullptr),
39
39
    bus_connection_(nullptr),
40
40
    bus_id_(0),
41
41
    object_manager_(nullptr) {
42
42
}
43
43
 
44
 
MiracastServiceAdapter::~MiracastServiceAdapter() {
 
44
MiracastControllerSkeleton::~MiracastControllerSkeleton() {
45
45
    if (bus_id_ > 0)
46
46
        g_bus_unown_name(bus_id_);
47
47
 
51
51
    // as we own the object emitting those signals.
52
52
}
53
53
 
54
 
void MiracastServiceAdapter::SyncProperties() {
 
54
void MiracastControllerSkeleton::SyncProperties() {
55
55
    aethercast_interface_manager_set_state(manager_obj_.get(),
56
 
                                         NetworkDevice::StateToStr(service_->State()).c_str());
 
56
                                           NetworkDevice::StateToStr(State()).c_str());
57
57
 
58
58
    // Capabilities are a collection of different things our local adapter
59
59
    // supports. The supported roles are just one part of this.
60
 
    auto roles = service_->SupportedRoles();
 
60
    auto roles = SupportedRoles();
61
61
    auto capabilities = DBusHelpers::GenerateCapabilities(roles);
62
62
 
63
63
    aethercast_interface_manager_set_capabilities(manager_obj_.get(), capabilities);
64
64
 
65
65
    g_strfreev(capabilities);
66
66
 
67
 
    aethercast_interface_manager_set_scanning(manager_obj_.get(), service_->Scanning());
 
67
    aethercast_interface_manager_set_scanning(manager_obj_.get(), Scanning());
68
68
}
69
69
 
70
 
void MiracastServiceAdapter::OnStateChanged(NetworkDeviceState state) {
 
70
void MiracastControllerSkeleton::OnStateChanged(NetworkDeviceState state) {
71
71
    if (!manager_obj_)
72
72
        return;
73
73
 
74
74
    aethercast_interface_manager_set_state(manager_obj_.get(),
75
 
                                         NetworkDevice::StateToStr(service_->State()).c_str());
 
75
                                           NetworkDevice::StateToStr(State()).c_str());
76
76
}
77
77
 
78
 
std::string MiracastServiceAdapter::GenerateDevicePath(const NetworkDevice::Ptr &device) const {
 
78
std::string MiracastControllerSkeleton::GenerateDevicePath(const NetworkDevice::Ptr &device) const {
79
79
    std::string address = device->Address();
80
80
    std::replace(address.begin(), address.end(), ':', '_');
81
81
    // FIXME using kManagerPath doesn't seem to work. Fails at link time ...
82
82
    return mcs::Utils::Sprintf("/org/aethercast/dev_%s", address.c_str());
83
83
}
84
84
 
85
 
void MiracastServiceAdapter::OnDeviceFound(const NetworkDevice::Ptr &device) {
 
85
void MiracastControllerSkeleton::OnDeviceFound(const NetworkDevice::Ptr &device) {
86
86
    DEBUG("device %s", device->Address().c_str());
87
87
 
88
88
    auto path = GenerateDevicePath(device);
89
 
    auto adapter = NetworkDeviceAdapter::Create(bus_connection_, path , device, service_);
 
89
    auto adapter = NetworkDeviceAdapter::Create(bus_connection_, path , device, shared_from_this());
90
90
    devices_.insert(std::pair<std::string,NetworkDeviceAdapter::Ptr>(device->Address(), adapter));
91
91
 
92
92
    g_dbus_object_manager_server_export(object_manager_.get(), adapter->DBusObject());
93
93
}
94
94
 
95
 
void MiracastServiceAdapter::OnDeviceLost(const NetworkDevice::Ptr &device) {
 
95
void MiracastControllerSkeleton::OnDeviceLost(const NetworkDevice::Ptr &device) {
96
96
    auto iter = devices_.find(device->Address());
97
97
    if (iter == devices_.end())
98
98
        return;
102
102
    devices_.erase(iter);
103
103
}
104
104
 
105
 
void MiracastServiceAdapter::OnDeviceChanged(const NetworkDevice::Ptr &peer) {
 
105
void MiracastControllerSkeleton::OnDeviceChanged(const NetworkDevice::Ptr &peer) {
106
106
    auto iter = devices_.find(peer->Address());
107
107
    if (iter == devices_.end())
108
108
        return;
110
110
    iter->second->SyncProperties();
111
111
}
112
112
 
113
 
void MiracastServiceAdapter::OnChanged() {
 
113
void MiracastControllerSkeleton::OnChanged() {
114
114
    SyncProperties();
115
115
}
116
116
 
117
 
void MiracastServiceAdapter::OnNameAcquired(GDBusConnection *connection, const gchar *name, gpointer user_data) {
118
 
    auto inst = static_cast<SharedKeepAlive<MiracastServiceAdapter>*>(user_data)->ShouldDie();
 
117
void MiracastControllerSkeleton::OnNameAcquired(GDBusConnection *connection, const gchar *name, gpointer user_data) {
 
118
    auto inst = static_cast<SharedKeepAlive<MiracastControllerSkeleton>*>(user_data)->ShouldDie();
119
119
    inst->manager_obj_.reset(aethercast_interface_manager_skeleton_new());
120
120
 
121
121
    g_signal_connect_data(inst->manager_obj_.get(), "handle-scan",
122
 
                     G_CALLBACK(&MiracastServiceAdapter::OnHandleScan), new WeakKeepAlive<MiracastServiceAdapter>(inst),
123
 
                     [](gpointer data, GClosure *) { delete static_cast<WeakKeepAlive<MiracastServiceAdapter>*>(data); }, GConnectFlags(0));
 
122
                     G_CALLBACK(&MiracastControllerSkeleton::OnHandleScan), new WeakKeepAlive<MiracastControllerSkeleton>(inst),
 
123
                     [](gpointer data, GClosure *) { delete static_cast<WeakKeepAlive<MiracastControllerSkeleton>*>(data); }, GConnectFlags(0));
124
124
 
125
125
    inst->SyncProperties();
126
126
 
133
133
    INFO("Registered bus name %s", name);
134
134
}
135
135
 
136
 
void MiracastServiceAdapter::OnHandleScan(AethercastInterfaceManager *skeleton,
137
 
                                        GDBusMethodInvocation *invocation, gpointer user_data) {
 
136
void MiracastControllerSkeleton::OnHandleScan(AethercastInterfaceManager *skeleton,
 
137
                                              GDBusMethodInvocation *invocation, gpointer user_data) {
138
138
    boost::ignore_unused_variable_warning(skeleton);
139
 
    auto inst = static_cast<WeakKeepAlive<MiracastServiceAdapter>*>(user_data)->GetInstance().lock();
 
139
    auto inst = static_cast<WeakKeepAlive<MiracastControllerSkeleton>*>(user_data)->GetInstance().lock();
140
140
 
141
141
    if (not inst)
142
142
        return;
143
143
 
144
144
    INFO("Scanning for remote devices");
145
145
 
146
 
    inst->service_->Scan();
 
146
    inst->Scan();
147
147
 
148
148
    g_dbus_method_invocation_return_value(invocation, nullptr);
149
149
}
150
150
 
151
 
std::shared_ptr<MiracastServiceAdapter> MiracastServiceAdapter::FinalizeConstruction() {
 
151
std::shared_ptr<MiracastControllerSkeleton> MiracastControllerSkeleton::FinalizeConstruction() {
152
152
    auto sp = shared_from_this();
153
153
 
154
154
    GError *error = nullptr;
160
160
    }
161
161
 
162
162
    bus_id_ = g_bus_own_name(G_BUS_TYPE_SYSTEM, kBusName, G_BUS_NAME_OWNER_FLAGS_NONE,
163
 
                   nullptr, &MiracastServiceAdapter::OnNameAcquired, nullptr, new SharedKeepAlive<MiracastServiceAdapter>{sp}, nullptr);
 
163
                   nullptr, &MiracastControllerSkeleton::OnNameAcquired, nullptr, new SharedKeepAlive<MiracastControllerSkeleton>{sp}, nullptr);
164
164
    if (bus_id_ == 0)
165
165
        WARNING("Failed to register bus name");
166
166
 
167
 
    service_->SetDelegate(sp);
 
167
    SetDelegate(sp);
168
168
    return sp;
169
169
}
170
170
} // namespace mcs