Add gitlab issue/merge request templates
[apps/camera-gstreamer.git] / app / AglShellGrpcClient.cpp
1 //include stuff here
2 #include <cstdio>
3
4 #include <mutex>
5 #include <condition_variable>
6 #include <chrono>
7 #include <grpc/grpc.h>
8 #include <grpcpp/grpcpp.h>
9 #include <grpcpp/server.h>
10 #include <grpcpp/server_builder.h>
11 #include <grpcpp/server_context.h>
12
13 #include <grpcpp/ext/proto_server_reflection_plugin.h>
14 #include <grpcpp/health_check_service_interface.h>
15
16 #include "AglShellGrpcClient.h"
17 #include "agl_shell.grpc.pb.h"
18
19 using namespace std::chrono;
20
21 namespace {
22         const char kDefaultGrpcServiceAddress[] = "127.0.0.1:14005";
23 }
24
25 GrpcClient::GrpcClient()
26 {
27         m_channel = grpc::CreateChannel(kDefaultGrpcServiceAddress,
28                         grpc::InsecureChannelCredentials());
29
30         // init the stub here
31         m_stub = agl_shell_ipc::AglShellManagerService::NewStub(m_channel);
32         reader = new Reader(m_stub.get());
33 }
34
35 void
36 GrpcClient::WaitForConnected(int wait_time_ms, int tries_timeout)
37 {
38         struct timespec ts;
39         grpc_connectivity_state state;
40         int try_ = 0;
41
42         clock_gettime(CLOCK_MONOTONIC, &ts);
43         ts.tv_sec = 0;
44         ts.tv_nsec = 500 * 1000 * 1000; // 500ms
45
46         while (((state = m_channel->GetState(true)) != GRPC_CHANNEL_READY) && 
47                 try_++ < tries_timeout) {
48                 fprintf(stderr, "waiting for channel state to be ready, current state %d", state);
49                 nanosleep(&ts, NULL);
50         }
51
52 }
53
54
55 bool
56 GrpcClient::ActivateApp(const std::string& app_id, const std::string& output_name)
57 {
58         agl_shell_ipc::ActivateRequest request;
59
60         request.set_app_id(app_id);
61         request.set_output_name(output_name);
62
63         grpc::ClientContext context;
64         ::agl_shell_ipc::ActivateResponse reply;
65
66         grpc::Status status = m_stub->ActivateApp(&context, request, &reply);
67         return status.ok();
68 }
69
70 bool
71 GrpcClient::DeactivateApp(const std::string& app_id)
72 {
73         agl_shell_ipc::DeactivateRequest request;
74
75         request.set_app_id(app_id);
76
77         grpc::ClientContext context;
78         ::agl_shell_ipc::DeactivateResponse reply;
79
80         grpc::Status status = m_stub->DeactivateApp(&context, request, &reply);
81         return status.ok();
82 }
83
84 bool
85 GrpcClient::SetAppFloat(const std::string& app_id, int32_t x_pos, int32_t y_pos)
86 {
87         agl_shell_ipc::FloatRequest request;
88
89         request.set_app_id(app_id);
90
91         request.set_x_pos(x_pos);
92         request.set_y_pos(y_pos);
93
94         grpc::ClientContext context;
95         ::agl_shell_ipc::FloatResponse reply;
96
97         grpc::Status status = m_stub->SetAppFloat(&context, request, &reply);
98         return status.ok();
99 }
100
101 bool
102 GrpcClient::SetAppNormal(const std::string& app_id)
103 {
104         agl_shell_ipc::NormalRequest request;
105
106         request.set_app_id(app_id);
107
108         grpc::ClientContext context;
109         ::agl_shell_ipc::NormalResponse reply;
110
111         grpc::Status status = m_stub->SetAppNormal(&context, request, &reply);
112         return status.ok();
113 }
114
115 bool
116 GrpcClient::SetAppFullscreen(const std::string& app_id)
117 {
118         agl_shell_ipc::FullscreenRequest request;
119
120         request.set_app_id(app_id);
121
122         grpc::ClientContext context;
123         ::agl_shell_ipc::FullscreenResponse reply;
124
125         grpc::Status status = m_stub->SetAppFullscreen(&context, request, &reply);
126         return status.ok();
127 }
128
129 bool
130 GrpcClient::SetAppOnOutput(const std::string& app_id, const std::string &output)
131 {
132         agl_shell_ipc::AppOnOutputRequest request;
133
134         request.set_app_id(app_id);
135         request.set_output(output);
136
137         grpc::ClientContext context;
138         ::agl_shell_ipc::AppOnOutputResponse reply;
139
140         grpc::Status status = m_stub->SetAppOnOutput(&context, request, &reply);
141         return status.ok();
142 }
143
144 bool
145 GrpcClient::SetAppPosition(const std::string& app_id, int32_t x, int32_t y)
146 {
147         agl_shell_ipc::AppPositionRequest request;
148
149         request.set_app_id(app_id);
150         request.set_x(x);
151         request.set_y(y);
152
153         grpc::ClientContext context;
154         ::agl_shell_ipc::AppPositionResponse reply;
155
156         grpc::Status status = m_stub->SetAppPosition(&context, request, &reply);
157         return status.ok();
158 }
159
160 bool
161 GrpcClient::SetAppScale(const std::string& app_id, int32_t width, int32_t height)
162 {
163         agl_shell_ipc::AppScaleRequest request;
164
165         request.set_app_id(app_id);
166         request.set_width(width);
167         request.set_height(height);
168
169         grpc::ClientContext context;
170         ::agl_shell_ipc::AppScaleResponse reply;
171
172         grpc::Status status = m_stub->SetAppScale(&context, request, &reply);
173         return status.ok();
174 }
175
176
177 grpc::Status
178 GrpcClient::Wait(void)
179 {
180         return reader->Await();
181 }
182
183 void
184 GrpcClient::AppStatusState(Callback callback, void *data)
185 {
186         reader->AppStatusState(callback, data);
187 }
188
189 std::vector<std::string>
190 GrpcClient::GetOutputs()
191 {
192         grpc::ClientContext context;
193         std::vector<std::string> v;
194
195         ::agl_shell_ipc::OutputRequest request;
196         ::agl_shell_ipc::ListOutputResponse response;
197
198         grpc::Status status = m_stub->GetOutputs(&context, request, &response);
199         if (!status.ok())
200                 return std::vector<std::string>();
201
202         for (int i = 0; i < response.outputs_size(); i++) {
203                 ::agl_shell_ipc::OutputResponse rresponse = response.outputs(i);
204                 v.push_back(rresponse.name());
205         }
206
207         return v;
208 }