platform.cpp

/*
 * 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/>.
 *
 */

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wswitch-default"
#include "anbox/platform/sdl/platform.h"
#include "anbox/input/device.h"
#include "anbox/input/manager.h"
#include "anbox/logger.h"
#include "anbox/platform/sdl/keycode_converter.h"
#include "anbox/platform/sdl/window.h"
#include "anbox/platform/sdl/audio_sink.h"
#include "anbox/platform/alsa/audio_source.h"
#include "anbox/system_configuration.h"

#include "anbox/wm/manager.h"

#include <boost/throw_exception.hpp>

#include <signal.h>
#include <sys/types.h>
#pragma GCC diagnostic pop

namespace anbox {
namespace platform {
namespace sdl {
Platform::Platform(
    const std::shared_ptr<input::Manager> &input_manager,
    const Configuration &config)
    : input_manager_(input_manager),
      event_thread_running_(false),
      ime_socket_file_(utils::string_format("%s/ime_socket", SystemConfiguration::instance().socket_dir())),
      config_(config) {
  // Don't block the screensaver from kicking in. It will be blocked
  // by the desktop shell already and we don't have to do this again.
  // If we would leave this enabled it will prevent systems from
  // suspending correctly.
  SDL_SetHint(SDL_HINT_VIDEO_ALLOW_SCREENSAVER, "1");

#ifdef SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
  // Don't disable compositing
  // Available since SDL 2.0.8
  SDL_SetHint(SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR, "0");
#endif

  if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_EVENTS) < 0) {
    const auto message = utils::string_format("Failed to initialize SDL: %s", SDL_GetError());
    BOOST_THROW_EXCEPTION(std::runtime_error(message));
  }

  auto display_frame = graphics::Rect::Invalid;
  if (config_.display_frame == graphics::Rect::Invalid) {
    for (auto n = 0; n < SDL_GetNumVideoDisplays(); n++) {
      SDL_Rect r;
      if (SDL_GetDisplayBounds(n, &r) != 0) continue;

      graphics::Rect frame{r.x, r.y, r.x + r.w, r.y + r.h};

      if (display_frame == graphics::Rect::Invalid)
        display_frame = frame;
      else
        display_frame.merge(frame);
    }

    if (display_frame == graphics::Rect::Invalid)
      BOOST_THROW_EXCEPTION(
          std::runtime_error("No valid display configuration found"));
  } else {
    display_frame = config_.display_frame;
    window_size_immutable_ = true;
  }

  graphics::emugl::DisplayInfo::get()->set_resolution(display_frame.width(), display_frame.height());
  display_frame_ = display_frame;

  pointer_ = input_manager->create_device();
  pointer_->set_name("anbox-pointer");
  pointer_->set_driver_version(1);
  pointer_->set_input_id({BUS_VIRTUAL, 2, 2, 2});
  pointer_->set_physical_location("none");
  pointer_->set_key_bit(BTN_MOUSE);
  // NOTE: We don't use REL_X/REL_Y in reality but have to specify them here
  // to allow InputFlinger to detect we're a cursor device.
  pointer_->set_rel_bit(REL_X);
  pointer_->set_rel_bit(REL_Y);
  pointer_->set_rel_bit(REL_HWHEEL);
  pointer_->set_rel_bit(REL_WHEEL);
  pointer_->set_prop_bit(INPUT_PROP_POINTER);

  keyboard_ = input_manager->create_device();
  keyboard_->set_name("anbox-keyboard");
  keyboard_->set_driver_version(1);
  keyboard_->set_input_id({BUS_VIRTUAL, 3, 3, 3});
  keyboard_->set_physical_location("none");
  keyboard_->set_key_bit(BTN_MISC);
  keyboard_->set_key_bit(KEY_OK);

  touch_ = input_manager->create_device();
  touch_->set_name("anbox-touch");
  touch_->set_driver_version(1);
  touch_->set_input_id({BUS_VIRTUAL, 4, 4, 4});
  touch_->set_physical_location("none");
  touch_->set_abs_bit(ABS_MT_SLOT);
  touch_->set_abs_max(ABS_MT_SLOT, 10);
  touch_->set_abs_bit(ABS_MT_TOUCH_MAJOR);
  touch_->set_abs_max(ABS_MT_TOUCH_MAJOR, 127);
  touch_->set_abs_bit(ABS_MT_TOUCH_MINOR);
  touch_->set_abs_max(ABS_MT_TOUCH_MINOR, 127);
  touch_->set_abs_bit(ABS_MT_POSITION_X);
  touch_->set_abs_max(ABS_MT_POSITION_X, display_frame.width());
  touch_->set_abs_bit(ABS_MT_POSITION_Y);
  touch_->set_abs_max(ABS_MT_POSITION_Y, display_frame.height());
  touch_->set_abs_bit(ABS_MT_TRACKING_ID);
  touch_->set_abs_max(ABS_MT_TRACKING_ID, MAX_TRACKING_ID);
  touch_->set_prop_bit(INPUT_PROP_DIRECT);

  for (int i = 0; i < MAX_FINGERS; i++)
      touch_slots[i] = -1;

  event_thread_ = std::thread(&Platform::process_events, this);
  ime_thread_ = std::thread(&Platform::create_ime_socket, this);

  user_window_event = SDL_RegisterEvents(1);
  if (user_window_event < 0) {
    FATAL("SDL_RegisterEvents failed and can not recover,please restart service!!");
  }
}

Platform::~Platform() {
  if (event_thread_running_) {
    event_thread_running_ = false;
    event_thread_.join();
  }
  ime_thread_.join();
  if (ime_socket_ != -1) {
    close(ime_socket_);
  }
}

void Platform::set_renderer(const std::shared_ptr<Renderer> &renderer) {
  renderer_ = renderer;
}

void Platform::set_window_manager(const std::shared_ptr<wm::Manager> &window_manager) {
  window_manager_ = window_manager;
}

// Added for Chinese input anbox begin
void Platform::create_ime_socket() {
  int ime_socket = -1;
  int client_socket = -1;
  int rc = -1;
  int len = 0;
  struct sockaddr_un socket_addr, client_addr;
  memset(&socket_addr, 0, sizeof(socket_addr));
  DEBUG("Starting create_ime_socket thread");
  ime_socket = socket(AF_UNIX, SOCK_STREAM, 0);
  if (ime_socket == -1) {
    ERROR("Create ime socket failed");
    return;
  }
  socket_addr.sun_family = AF_UNIX;
  if (ime_socket_file_.length() >= strlen(socket_addr.sun_path) - 1) {
    ERROR("Create ime failed, socket path too long");
    return;
  }
  strcpy(socket_addr.sun_path, ime_socket_file_.c_str());
  unlink(ime_socket_file_.c_str());
  rc = bind(ime_socket, reinterpret_cast<struct sockaddr *>(&socket_addr), sizeof(socket_addr));
  if (rc == -1) {
    ERROR("bind ime socket failed");
    close(ime_socket);
    return;
  }
  rc = listen(ime_socket, 1);
  if (rc == -1) {
    ERROR("Listen ime socket failed");
    close(ime_socket);
    return;
  }
  DEBUG("Before ime socket accept");
  client_socket = accept(ime_socket, reinterpret_cast<struct sockaddr*>(&client_addr), 
      reinterpret_cast<socklen_t*>(&len));
  if (client_socket == -1) {
    ERROR("Accept ime socket failed");
    close(ime_socket);
    return;
  }
  ime_fd_ = client_socket;
  ime_socket_ = ime_socket;
  DEBUG("accept ime socket successful");
}
// Added for Chinese input anbox end

void Platform::process_events() {
  event_thread_running_ = true;

  while (event_thread_running_) {
    SDL_Event event;
    while (SDL_WaitEventTimeout(&event, 100)) {
      switch (event.type) {
        case SDL_QUIT:
          break;
        case SDL_WINDOWEVENT:
          for (auto &iter : windows_) {
            if (auto w = iter.second.lock()) {
              if (w->window_id() == event.window.windowID) {
                w->process_event(event);
                break;
              }
            }
          }
          break;
        case SDL_KEYDOWN:
          input_flag = 1;
          if (keyboard_)
            process_input_event(event);
          break;
        case SDL_KEYUP:
          input_flag = 0;
          if (keyboard_)
            process_input_event(event);
          break;
        case SDL_MOUSEMOTION:
        case SDL_MOUSEBUTTONDOWN:
        case SDL_MOUSEBUTTONUP:
        case SDL_MOUSEWHEEL:
        case SDL_FINGERDOWN:
        case SDL_FINGERUP:
        case SDL_FINGERMOTION:
          process_input_event(event);
          break;
        case SDL_TEXTINPUT:
          WARNING("Input Event TEXT=%s TYPE=%d WINDOWID=%d", event.text.text, event.type, event.text.windowID);
          if (text_input_fliter(event.text.text)) {
            send(ime_fd_, event.text.text, strlen(event.text.text), 0);
          }
          break;
        default:
          user_event_function(event);
          break;
      }
    }
  }
}

bool Platform::text_input_fliter(const char* text) {
  return text[0] > 0x7f || (input_flag == 0 &&
          ((text[0] <= 'Z' && text[0] >= 'A') || (text[0] <= 'z' && text[0] >= 'a')));
}

void Platform::user_event_function(const SDL_Event &event) {
  if (event.type == user_window_event) {
    int event_type = event.user.code;
    manager_window_param* param = (manager_window_param*) event.user.data1;
    if (param) {
      if (event_type == USER_CREATE_WINDOW) {
        if (tasks_.find(param->taskId) != tasks_.end()) {
          delete param;
          return;
        }
        auto w = create_window(param->taskId, param->rect, param->title);
        if (w) {
          w->attach();
          window_manager_->insert_task(param->taskId, w);
        } else {
          WARNING("create window failed! remove task on android!");
          window_manager_->remove_task(param->taskId);
        }
      } else if (event_type == USER_DESTROY_WINDOW) {
        window_manager_->erase_task(param->taskId);
        auto it = tasks_.find(param->taskId);
        if (it != tasks_.end()) {
            windows_.erase(it->second);
            tasks_.erase(it);
        }
      }
      delete param;
      param = nullptr;
    } else {
      ERROR("null point param!!");
    }
  }
}

void Platform::input_key_event(const SDL_Scancode &scan_code, std::int32_t down_or_up) {  // down_or_up: 1-down,0-up
  std::vector<input::Event> keyboard_events;
  std::uint16_t code = KeycodeConverter::convert(scan_code);
  keyboard_events.push_back({EV_KEY, code, down_or_up});
  keyboard_->send_events(keyboard_events);
}

void Platform::process_input_event(const SDL_Event &event) {
  std::vector<input::Event> mouse_events;
  std::vector<input::Event> keyboard_events;
  std::vector<input::Event> touch_events;

  std::int32_t x = 0;
  std::int32_t y = 0;

  switch (event.type) {
    // Mouse
    case SDL_MOUSEBUTTONDOWN:
      for (auto &iter : windows_) {
        if (auto w = iter.second.lock()) {
          if (w->window_id() == event.window.windowID &&
                  w->title_event_filter(event.button.y)) {
            return;
          }
        }
      }
      if (config_.no_touch_emulation) {
        mouse_events.push_back({EV_KEY, BTN_LEFT, 1});
      } else {
        x = event.button.x;
        y = event.button.y;
        if (!adjust_coordinates(x, y))
          break;
        push_finger_down(x, y, emulated_touch_id_, touch_events);
      }
      break;
    case SDL_MOUSEBUTTONUP:
      if (config_.no_touch_emulation) {
        mouse_events.push_back({EV_KEY, BTN_LEFT, 0});
      } else {
        push_finger_up(emulated_touch_id_, touch_events);
      }
      break;
    case SDL_MOUSEMOTION:
      x = event.motion.x;
      y = event.motion.y;
      if (!adjust_coordinates(x, y))
        break;

      if (config_.no_touch_emulation) {
        // NOTE: Sending relative move events doesn't really work and we have
        // changes in libinputflinger to take ABS_X/ABS_Y instead for absolute
        // position events.
        mouse_events.push_back({EV_ABS, ABS_X, x});
        mouse_events.push_back({EV_ABS, ABS_Y, y});
        // We're sending relative position updates here too but they will be only
        // used by the Android side EventHub/InputReader to determine if the cursor
        // was moved. They are not used to find out the exact position.
        mouse_events.push_back({EV_REL, REL_X, event.motion.xrel});
        mouse_events.push_back({EV_REL, REL_Y, event.motion.yrel});
      } else {
        push_finger_motion(x, y, emulated_touch_id_, touch_events);
      }
      break;
    case SDL_MOUSEWHEEL:
      if (!config_.no_touch_emulation) {
        SDL_GetMouseState(&x, &y);
        if (!adjust_coordinates(x, y))
          break;

        mouse_events.push_back({EV_ABS, ABS_X, x});
        mouse_events.push_back({EV_ABS, ABS_Y, y});
      }
      mouse_events.push_back(
          {EV_REL, REL_WHEEL, static_cast<std::int32_t>(event.wheel.y)});
      break;
    // Keyboard
    case SDL_KEYDOWN: {
      const auto code = KeycodeConverter::convert(event.key.keysym.scancode);
      if (code == KEY_RESERVED) break;
      if (code == KEY_ESC) {
        input_key_event(SDL_SCANCODE_AC_BACK, 1);
        break;
      }
      keyboard_events.push_back({EV_KEY, code, 1});
      break;
    }
    case SDL_KEYUP: {
      const auto code = KeycodeConverter::convert(event.key.keysym.scancode);
      if (code == KEY_RESERVED) break;
      if (code == KEY_ESC) {
        input_key_event(SDL_SCANCODE_AC_BACK, 0);
        break;
      }
      if (code == KEY_CAPSLOCK) {
        key_mod_ ^= KMOD_CAPS;
      }
      if (code == KEY_NUMLOCK) {
        key_mod_ ^= KMOD_NUM;
      }
      keyboard_events.push_back({EV_KEY, code, 0});
      break;
    }
    // Touch screen
    case SDL_FINGERDOWN: {
      if (!calculate_touch_coordinates(event, x, y))
        break;
      push_finger_down(x, y, event.tfinger.fingerId, touch_events);

      break;
    }
    case SDL_FINGERUP: {
      push_finger_up(event.tfinger.fingerId, touch_events);
      break;
    }
    case SDL_FINGERMOTION: {
      if (!calculate_touch_coordinates(event, x, y))
        break;
      push_finger_motion(x, y, event.tfinger.fingerId, touch_events);
      break;
    }
    default:
      break;
  }

  if (mouse_events.size() > 0) {
    mouse_events.push_back({EV_SYN, SYN_REPORT, 0});
    pointer_->send_events(mouse_events);
  }

  if (keyboard_events.size() > 0)
    keyboard_->send_events(keyboard_events);

  if (touch_events.size() > 0)
    touch_->send_events(touch_events);
}

int Platform::find_touch_slot(int id) {
  for (int i = 0; i < MAX_FINGERS; i++) {
    if (touch_slots[i] == id)
      return i;
  }
  return -1;
}

void Platform::push_slot(std::vector<input::Event> &touch_events, int slot) {
  if (last_slot != slot) {
    touch_events.push_back({EV_ABS, ABS_MT_SLOT, slot});
    last_slot = slot;
  }
}

void Platform::push_finger_down(int x, int y, int finger_id, std::vector<input::Event> &touch_events) {
  int slot = find_touch_slot(-1);
  if (slot == -1) {
    DEBUG("no free slot!");
    return;
  }
  touch_slots[slot] = finger_id;
  push_slot(touch_events, slot);
  touch_events.push_back({EV_ABS, ABS_MT_TRACKING_ID, static_cast<std::int32_t>(finger_id % MAX_TRACKING_ID + 1)});
  touch_events.push_back({EV_ABS, ABS_MT_POSITION_X, x});
  touch_events.push_back({EV_ABS, ABS_MT_POSITION_Y, y});
  touch_events.push_back({EV_SYN, SYN_REPORT, 0});
}

void Platform::push_finger_up(int finger_id, std::vector<input::Event> &touch_events) {
  int slot = find_touch_slot(finger_id);
  if (slot == -1)
    return;
  push_slot(touch_events, slot);
  touch_events.push_back({EV_ABS, ABS_MT_TRACKING_ID, -1});
  touch_events.push_back({EV_SYN, SYN_REPORT, 0});
  touch_slots[slot] = -1;
}

void Platform::push_finger_motion(int x, int y, int finger_id, std::vector<input::Event> &touch_events) {
  int slot = find_touch_slot(finger_id);
  if (slot == -1)
    return;
  push_slot(touch_events, slot);
  touch_events.push_back({EV_ABS, ABS_MT_POSITION_X, x});
  touch_events.push_back({EV_ABS, ABS_MT_POSITION_Y, y});
  touch_events.push_back({EV_SYN, SYN_REPORT, 0});
}


bool Platform::adjust_coordinates(std::int32_t &x, std::int32_t &y) {
  SDL_Window *window = nullptr;

  if (!config_.single_window) {
    window = SDL_GetWindowFromID(focused_sdl_window_id_);
    return adjust_coordinates(window, x, y);
  } else {
    // When running the whole Android system in a single window we don't
    // need to reacalculate and the pointer position as they are already
    // relative to our window.
    return true;
  }
}

bool Platform::adjust_coordinates(SDL_Window *window, std::int32_t &x, std::int32_t &y) {
  std::int32_t rel_x = 0;
  std::int32_t rel_y = 0;

  if (!window) {
    return false;
  }
  // As we get only absolute coordindates relative to our window we have to
  // calculate the correct position based on the current focused window
  SDL_GetWindowPosition(window, &rel_x, &rel_y);
  x += rel_x;
  y += rel_y;
  return true;
}

bool Platform::calculate_touch_coordinates(const SDL_Event &event,
                                           std::int32_t &x,
                                           std::int32_t &y) {
  SDL_Window *window = nullptr;

  window = SDL_GetWindowFromID(focused_sdl_window_id_);
  // before SDL 2.0.7 on X11 tfinger coordinates are not normalized
  if (!SDL_VERSION_ATLEAST(2,0,7) && (event.tfinger.x > 1 || event.tfinger.y > 1)) {
    x = event.tfinger.x;
    y = event.tfinger.y;
  } else {
    if (window) {
      SDL_GetWindowSize(window, &x, &y);
      x *= event.tfinger.x;
      y *= event.tfinger.y;
    } else {
      x = display_frame_.width() * event.tfinger.x;
      y = display_frame_.height() * event.tfinger.y;
    }
  }

  if (config_.single_window) {
    // When running the whole Android system in a single window we don't
    // need to reacalculate and the pointer position as they are already
    // relative to our window.
    return true;
  } else {
    return adjust_coordinates(window, x, y);
  }
}

Window::Id Platform::next_window_id() {
  static Window::Id next_id = 0;
  return next_id++;
}

std::shared_ptr<wm::Window> Platform::create_window(
    const anbox::wm::Task::Id &task, const anbox::graphics::Rect &frame, const std::string &title) {
  if (!renderer_) {
    ERROR("Can't create window without a renderer set");
    return nullptr;
  }

  auto id = next_window_id();
  auto w = std::make_shared<Window>(renderer_, id, task, shared_from_this(), frame, title, !window_size_immutable_);
  focused_sdl_window_id_ = w->window_id();
  windows_.insert({id, w});
  tasks_.insert({task, id});
  return w;
}

void Platform::window_deleted(const Window::Id &id) {
  auto w = windows_.find(id);
  if (w == windows_.end()) {
    WARNING("Got window removed event for unknown window (id %d)", id);
    return;
  }
  if (auto window = w->second.lock())
  {
    tasks_.erase(window->task());
    window_manager_->remove_task(window->task());
  }
  windows_.erase(w);
}

void Platform::window_wants_focus(const Window::Id &id) {
  auto w = windows_.find(id);
  if (w == windows_.end()) {
    return;
  }

  // if window's modstate is not the same as android, send
  // capslock or numlock message to android to change it.
  auto mod_state = SDL_GetModState();
  if ((key_mod_ & KMOD_NUM) != (mod_state & KMOD_NUM)) {
    input_key_event(SDL_SCANCODE_NUMLOCKCLEAR, 1);
    input_key_event(SDL_SCANCODE_NUMLOCKCLEAR, 0);
    key_mod_ ^= KMOD_NUM;
  }
  if ((key_mod_ & KMOD_CAPS) != (mod_state & KMOD_CAPS)) {
    input_key_event(SDL_SCANCODE_CAPSLOCK, 1);
    input_key_event(SDL_SCANCODE_CAPSLOCK, 0);
    key_mod_ ^= KMOD_CAPS;
  }

  if (auto window = w->second.lock()) {
    focused_sdl_window_id_ = window->window_id();
    window_manager_->set_focused_task(window->task());
  }
}

void Platform::window_moved(const Window::Id &id, const std::int32_t &x,
                                  const std::int32_t &y) {
  auto w = windows_.find(id);
  if (w == windows_.end()) return;

  if (auto window = w->second.lock()) {
    auto new_frame = window->frame();
    new_frame.translate(x, y);
    window->update_frame(new_frame);
    window_manager_->resize_task(window->task(), new_frame, 3);
  }
}

void Platform::window_resized(const Window::Id &id,
                                    const std::int32_t &width,
                                    const std::int32_t &height) {
  auto w = windows_.find(id);
  if (w == windows_.end()) return;

  if (auto window = w->second.lock()) {
    auto new_frame = window->frame();
    new_frame.resize(width, height);
    // We need to update the window frame in advance here as otherwise we may
    // get a movement event before we got an update of the actual layer
    // representing this window and then we're back to the original size of
    // the task.
    window->update_frame(new_frame);
    window_manager_->resize_task(window->task(), new_frame, 3);
  }
}

void Platform::set_clipboard_data(const ClipboardData &data) {
  if (data.text.empty())
    return;
  SDL_SetClipboardText(data.text.c_str());
}

Platform::ClipboardData Platform::get_clipboard_data() {
  if (!SDL_HasClipboardText())
    return ClipboardData{};

  auto text = SDL_GetClipboardText();
  if (!text)
    return ClipboardData{};

  auto data = ClipboardData{text};
  SDL_free(text);
  return data;
}

std::shared_ptr<audio::Sink> Platform::create_audio_sink() {
  return std::make_shared<AudioSink>();
}

std::shared_ptr<audio::Source> Platform::create_audio_source() {
  return std::make_shared<AudioSource>();
}

bool Platform::supports_multi_window() const {
  return true;
}

int Platform::get_user_window_event() const {
  if (user_window_event < 0) {
    FATAL("SDL_RegisterEvents failed and can not recover,please restart service!!");
  }
  return user_window_event;
}
} // namespace sdl
} // namespace platform
} // namespace anbox