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
|
// Copyright (C) 2015-2017 Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
// 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/.
#ifndef VSOMEIP_ENABLE_SIGNAL_HANDLING
#include <csignal>
#endif
#include <vsomeip/vsomeip.hpp>
#include <chrono>
#include <thread>
#include <condition_variable>
#include <mutex>
#include <iostream>
static vsomeip::service_t service_id = 0x1111;
static vsomeip::instance_t service_instance_id = 0x2222;
static vsomeip::method_t service_method_id = 0x3333;
class hello_world_service {
public:
// Get the vSomeIP runtime and
// create a application via the runtime, we could pass the application name
// here otherwise the name supplied via the VSOMEIP_APPLICATION_NAME
// environment variable is used
hello_world_service() :
rtm_(vsomeip::runtime::get()),
app_(rtm_->create_application()),
stop_(false),
stop_thread_(std::bind(&hello_world_service::stop, this))
{
}
~hello_world_service()
{
stop_thread_.join();
}
bool init()
{
// init the application
if (!app_->init()) {
std::cerr << "Couldn't initialize application" << std::endl;
return false;
}
// register a message handler callback for messages sent to our service
app_->register_message_handler(service_id, service_instance_id,
service_method_id,
std::bind(&hello_world_service::on_message_cbk, this,
std::placeholders::_1));
// register a state handler to get called back after registration at the
// runtime was successful
app_->register_state_handler(
std::bind(&hello_world_service::on_state_cbk, this,
std::placeholders::_1));
return true;
}
void start()
{
// start the application and wait for the on_event callback to be called
// this method only returns when app_->stop() is called
app_->start();
}
void stop()
{
std::unique_lock<std::mutex> its_lock(mutex_);
while(!stop_) {
condition_.wait(its_lock);
}
std::this_thread::sleep_for(std::chrono::seconds(5));
// Stop offering the service
app_->stop_offer_service(service_id, service_instance_id);
// unregister the state handler
app_->unregister_state_handler();
// unregister the message handler
app_->unregister_message_handler(service_id, service_instance_id,
service_method_id);
// shutdown the application
app_->stop();
}
void terminate() {
std::lock_guard<std::mutex> its_lock(mutex_);
stop_ = true;
condition_.notify_one();
}
void on_state_cbk(vsomeip::state_type_e _state)
{
if(_state == vsomeip::state_type_e::ST_REGISTERED)
{
// we are registered at the runtime and can offer our service
app_->offer_service(service_id, service_instance_id);
}
}
void on_message_cbk(const std::shared_ptr<vsomeip::message> &_request)
{
// Create a response based upon the request
std::shared_ptr<vsomeip::message> resp = rtm_->create_response(_request);
// Construct string to send back
std::string str("Hello ");
str.append(
reinterpret_cast<const char*>(_request->get_payload()->get_data()),
0, _request->get_payload()->get_length());
// Create a payload which will be sent back to the client
std::shared_ptr<vsomeip::payload> resp_pl = rtm_->create_payload();
std::vector<vsomeip::byte_t> pl_data(str.begin(), str.end());
resp_pl->set_data(pl_data);
resp->set_payload(resp_pl);
// Send the response back
app_->send(resp);
// we have finished
terminate();
}
private:
std::shared_ptr<vsomeip::runtime> rtm_;
std::shared_ptr<vsomeip::application> app_;
bool stop_;
std::mutex mutex_;
std::condition_variable condition_;
std::thread stop_thread_;
};
#ifndef VSOMEIP_ENABLE_SIGNAL_HANDLING
hello_world_service *hw_srv_ptr(nullptr);
void handle_signal(int _signal) {
if (hw_srv_ptr != nullptr &&
(_signal == SIGINT || _signal == SIGTERM))
hw_srv_ptr->terminate();
}
#endif
int main(int argc, char **argv)
{
hello_world_service hw_srv;
#ifndef VSOMEIP_ENABLE_SIGNAL_HANDLING
hw_srv_ptr = &hw_srv;
signal(SIGINT, handle_signal);
signal(SIGTERM, handle_signal);
#endif
if (hw_srv.init()) {
hw_srv.start();
return 0;
} else {
return 1;
}
}
|
