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