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
|
// Copyright (C) 2015 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/.
#include <vsomeip/vsomeip.hpp>
#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_client {
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_client() :
rtm_(vsomeip::runtime::get()),
app_(rtm_->create_application())
{
}
void init(){
// init the application
app_->init();
// register an event handler to get called back after registration at the
// runtime was successful
app_->register_event_handler(
std::bind(&hello_world_client::on_event_cbk, this,
std::placeholders::_1));
// register a callback which is called as soon as the service is available
app_->register_availability_handler(service_id, service_instance_id,
std::bind(&hello_world_client::on_availability_cbk, this,
std::placeholders::_1, std::placeholders::_2,
std::placeholders::_3));
// register a callback for responses from the service
app_->register_message_handler(vsomeip::ANY_SERVICE,
service_instance_id, vsomeip::ANY_METHOD,
std::bind(&hello_world_client::on_message_cbk, this,
std::placeholders::_1));
}
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 on_event_cbk(vsomeip::event_type_e _event)
{
if(_event == vsomeip::event_type_e::ET_REGISTERED)
{
// we are registered at the runtime now we can request the service
// and wait for the on_availability callback to be called
app_->request_service(service_id, service_instance_id);
}
}
void on_availability_cbk(vsomeip::service_t _service,
vsomeip::instance_t _instance, bool _is_available)
{
// Check if the available service is the the hello world service
if(service_id == _service && service_instance_id == _instance
&& _is_available)
{
// The service is available then we send the request
// Create a new request
std::shared_ptr<vsomeip::message> rq = rtm_->create_request();
// Set the hello world service as target of the request
rq->set_service(service_id);
rq->set_instance(service_instance_id);
rq->set_method(service_method_id);
// Create a payload which will be sent to the service
std::shared_ptr<vsomeip::payload> pl = rtm_->create_payload();
std::string str("World");
std::vector<vsomeip::byte_t> pl_data(std::begin(str), std::end(str));
pl->set_data(pl_data);
rq->set_payload(pl);
// Send the request to the service. Response will be delivered to the
// registered message handler
std::cout << "Sending: " << str << std::endl;
app_->send(rq, true);
}
}
void on_message_cbk(const std::shared_ptr<vsomeip::message> &_response)
{
if(service_id == _response->get_service()
&& service_instance_id == _response->get_instance()
&& vsomeip::message_type_e::MT_RESPONSE
== _response->get_message_type()
&& vsomeip::return_code_e::E_OK == _response->get_return_code())
{
// Get the payload and print it
std::shared_ptr<vsomeip::payload> pl = _response->get_payload();
std::string resp = std::string(
reinterpret_cast<const char*>(pl->get_data()), 0,
pl->get_length());
std::cout << "Received: " << resp << std::endl;
stop();
}
}
void stop()
{
// unregister the event handler
app_->unregister_event_handler();
// unregister the message handler
app_->unregister_message_handler(vsomeip::ANY_SERVICE,
service_instance_id, vsomeip::ANY_METHOD);
// shutdown the application
app_->stop();
}
private:
std::shared_ptr<vsomeip::runtime> rtm_;
std::shared_ptr<vsomeip::application> app_;
};
int main(int argc, char **argv)
{
hello_world_client hw_cl;
hw_cl.init();
hw_cl.start();
return 0;
}
|
