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
|
// 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/.
#include <vsomeip/vsomeip.hpp>
#if defined ANDROID || defined __ANDROID__
#include "android/log.h"
#define LOG_TAG "hello_world_client"
#define LOG_INF(...) fprintf(stdout, __VA_ARGS__), fprintf(stdout, "\n"), (void)__android_log_print(ANDROID_LOG_INFO, LOG_TAG, ##__VA_ARGS__)
#define LOG_ERR(...) fprintf(stderr, __VA_ARGS__), fprintf(stderr, "\n"), (void)__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, ##__VA_ARGS__)
#else
#include <cstdio>
#define LOG_INF(...) fprintf(stdout, __VA_ARGS__), fprintf(stdout, "\n")
#define LOG_ERR(...) fprintf(stderr, __VA_ARGS__), fprintf(stderr, "\n")
#endif
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())
{
}
bool init(){
// init the application
if (!app_->init()) {
LOG_ERR ("Couldn't initialize application");
return false;
}
// register a state handler to get called back after registration at the
// runtime was successful
app_->register_state_handler(
std::bind(&hello_world_client::on_state_cbk, this,
std::placeholders::_1));
// 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));
// 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));
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 on_state_cbk(vsomeip::state_type_e _state)
{
if(_state == vsomeip::state_type_e::ST_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
LOG_INF("Sending: %s", str.c_str());
app_->send(rq);
}
}
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());
LOG_INF("Received: %s", resp.c_str());
stop();
}
}
void stop()
{
// unregister the state handler
app_->unregister_state_handler();
// unregister the message handler
app_->unregister_message_handler(vsomeip::ANY_SERVICE,
service_instance_id, vsomeip::ANY_METHOD);
// alternatively unregister all registered handlers at once
app_->clear_all_handler();
// release the service
app_->release_service(service_id, service_instance_id);
// shutdown the application
app_->stop();
}
private:
std::shared_ptr<vsomeip::runtime> rtm_;
std::shared_ptr<vsomeip::application> app_;
};
|
