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