X-Git-Url: https://gerrit.akraino.org/r/gitweb?a=blobdiff_plain;ds=sidebyside;f=src%2Ftype3_AndroidCloud%2Fanbox-master%2Fsrc%2Fanbox%2Fqemu%2Fpipe_connection_creator.cpp;fp=src%2Ftype3_AndroidCloud%2Fanbox-master%2Fsrc%2Fanbox%2Fqemu%2Fpipe_connection_creator.cpp;h=722b227cc0349ac9170067e19edcf6aef37fc618;hb=e26c1ec581be598521517829adba8c8dd23a768f;hp=0000000000000000000000000000000000000000;hpb=6699c1aea74eeb0eb400e6299079f0c7576f716f;p=iec.git

diff --git a/src/type3_AndroidCloud/anbox-master/src/anbox/qemu/pipe_connection_creator.cpp b/src/type3_AndroidCloud/anbox-master/src/anbox/qemu/pipe_connection_creator.cpp
new file mode 100644
index 0000000..722b227
--- /dev/null
+++ b/src/type3_AndroidCloud/anbox-master/src/anbox/qemu/pipe_connection_creator.cpp
@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2016 Simon Fels <morphis@gravedo.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <string>
+
+#include "anbox/graphics/opengles_message_processor.h"
+#include "anbox/logger.h"
+#include "anbox/network/local_socket_messenger.h"
+#include "anbox/qemu/adb_message_processor.h"
+#include "anbox/qemu/boot_properties_message_processor.h"
+#include "anbox/qemu/bootanimation_message_processor.h"
+#include "anbox/qemu/camera_message_processor.h"
+#include "anbox/qemu/fingerprint_message_processor.h"
+#include "anbox/qemu/gsm_message_processor.h"
+#include "anbox/qemu/hwcontrol_message_processor.h"
+#include "anbox/qemu/null_message_processor.h"
+#include "anbox/qemu/pipe_connection_creator.h"
+#include "anbox/qemu/sensors_message_processor.h"
+
+namespace ba = boost::asio;
+
+namespace {
+std::string client_type_to_string(
+    const anbox::qemu::PipeConnectionCreator::client_type &type) {
+  switch (type) {
+    case anbox::qemu::PipeConnectionCreator::client_type::opengles:
+      return "opengles";
+    case anbox::qemu::PipeConnectionCreator::client_type::qemud_boot_properties:
+      return "boot-properties";
+    case anbox::qemu::PipeConnectionCreator::client_type::qemud_hw_control:
+      return "hw-control";
+    case anbox::qemu::PipeConnectionCreator::client_type::qemud_sensors:
+      return "sensors";
+    case anbox::qemu::PipeConnectionCreator::client_type::qemud_camera:
+      return "camera";
+    case anbox::qemu::PipeConnectionCreator::client_type::qemud_fingerprint:
+      return "fingerprint";
+    case anbox::qemu::PipeConnectionCreator::client_type::qemud_gsm:
+      return "gsm";
+    case anbox::qemu::PipeConnectionCreator::client_type::qemud_adb:
+      return "adb";
+    case anbox::qemu::PipeConnectionCreator::client_type::bootanimation:
+      return "boot-animation";
+    case anbox::qemu::PipeConnectionCreator::client_type::invalid:
+      break;
+    default:
+      break;
+  }
+  return "unknown";
+}
+}
+namespace anbox {
+namespace qemu {
+PipeConnectionCreator::PipeConnectionCreator(const std::shared_ptr<Renderer> &renderer, const std::shared_ptr<Runtime> &rt)
+    : renderer_(renderer),
+      runtime_(rt),
+      next_connection_id_(0),
+      connections_(
+          std::make_shared<network::Connections<network::SocketConnection>>()) {
+}
+
+PipeConnectionCreator::~PipeConnectionCreator() noexcept {
+  connections_->clear();
+}
+
+void PipeConnectionCreator::create_connection_for(
+    std::shared_ptr<boost::asio::local::stream_protocol::socket> const
+        &socket) {
+  auto const messenger = std::make_shared<network::LocalSocketMessenger>(socket);
+  const auto type = identify_client(messenger);
+  auto const processor = create_processor(type, messenger);
+  if (!processor)
+    BOOST_THROW_EXCEPTION(std::runtime_error("Unhandled client type"));
+
+  auto const &connection = std::make_shared<network::SocketConnection>(
+      messenger, messenger, next_id(), connections_, processor);
+  connection->set_name(client_type_to_string(type));
+  connections_->add(connection);
+  connection->read_next_message();
+}
+
+PipeConnectionCreator::client_type PipeConnectionCreator::identify_client(
+    std::shared_ptr<network::SocketMessenger> const &messenger) {
+  // The client will identify itself as first thing by writing a string
+  // in the format 'pipe:<name>[:<arguments>]\0' to the channel.
+  std::vector<char> buffer;
+  for (;;) {
+    unsigned char byte[1] = {0};
+    const auto err = messenger->receive_msg(ba::buffer(byte, 1));
+    if (err) break;
+    buffer.push_back(byte[0]);
+    if (byte[0] == 0x0) break;
+  }
+
+  std::string identifier_and_args = buffer.data();
+
+  if (utils::string_starts_with(identifier_and_args, "pipe:opengles"))
+    return client_type::opengles;
+  // Even if 'boot-properties' is an argument to the service 'qemud' here we
+  // take this as a own service instance as that is what it is.
+  else if (utils::string_starts_with(identifier_and_args,
+                                     "pipe:qemud:boot-properties"))
+    return client_type::qemud_boot_properties;
+  else if (utils::string_starts_with(identifier_and_args,
+                                     "pipe:qemud:hw-control"))
+    return client_type::qemud_hw_control;
+  else if (utils::string_starts_with(identifier_and_args, "pipe:qemud:sensors"))
+    return client_type::qemud_sensors;
+  else if (utils::string_starts_with(identifier_and_args, "pipe:qemud:camera"))
+    return client_type::qemud_camera;
+  else if (utils::string_starts_with(identifier_and_args,
+                                     "pipe:qemud:fingerprintlisten"))
+    return client_type::qemud_fingerprint;
+  else if (utils::string_starts_with(identifier_and_args, "pipe:qemud:gsm"))
+    return client_type::qemud_gsm;
+  else if (utils::string_starts_with(identifier_and_args,
+                                     "pipe:anbox:bootanimation"))
+    return client_type::bootanimation;
+  else if (utils::string_starts_with(identifier_and_args, "pipe:qemud:adb"))
+    return client_type::qemud_adb;
+
+  return client_type::invalid;
+}
+
+std::shared_ptr<network::MessageProcessor>
+PipeConnectionCreator::create_processor(
+    const client_type &type,
+    const std::shared_ptr<network::SocketMessenger> &messenger) {
+  if (type == client_type::opengles)
+    return std::make_shared<graphics::OpenGlesMessageProcessor>(renderer_, messenger);
+  else if (type == client_type::qemud_boot_properties)
+    return std::make_shared<qemu::BootPropertiesMessageProcessor>(messenger);
+  else if (type == client_type::qemud_hw_control)
+    return std::make_shared<qemu::HwControlMessageProcessor>(messenger);
+  else if (type == client_type::qemud_sensors)
+    return std::make_shared<qemu::SensorsMessageProcessor>(messenger);
+  else if (type == client_type::qemud_camera)
+    return std::make_shared<qemu::CameraMessageProcessor>(messenger);
+  else if (type == client_type::qemud_fingerprint)
+    return std::make_shared<qemu::FingerprintMessageProcessor>(messenger);
+  else if (type == client_type::qemud_gsm)
+    return std::make_shared<qemu::GsmMessageProcessor>(messenger);
+  else if (type == client_type::qemud_adb)
+    return std::make_shared<qemu::AdbMessageProcessor>(runtime_, messenger);
+
+  return std::make_shared<qemu::NullMessageProcessor>();
+}
+
+int PipeConnectionCreator::next_id() {
+  return next_connection_id_.fetch_add(1);
+}
+}  // namespace qemu
+}  // namespace anbox