src/AglShellGrpcClient.cpp

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