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 }