platform.h

Go to the documentation of this file.

/*
 * This file is part of Anbox Platform SDK
 *
 * Copyright 2021 Canonical Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef ANBOX_PLATFORM_SDK_PLATFORM_H_
#define ANBOX_PLATFORM_SDK_PLATFORM_H_
 
#include "anbox-platform-sdk/types.h"
#include "anbox-platform-sdk/common.h"
#include "anbox-platform-sdk/version.h"
#include "anbox-platform-sdk/audio_processor.h"
#include "anbox-platform-sdk/input_processor.h"
#include "anbox-platform-sdk/sensor_processor.h"
#include "anbox-platform-sdk/gps_processor.h"
#include "anbox-platform-sdk/graphics_processor.h"
#include "anbox-platform-sdk/camera_processor.h"
#include "anbox-platform-sdk/anbox_proxy.h"
#include "anbox-platform-sdk/video_decoder.h"
#include "anbox-platform-sdk/vhal_connector.h"
 
#include <iostream>
#include <exception>
 
namespace anbox {
 
class Platform {
 public:
  Platform() = default;
  virtual ~Platform() = default;
  Platform(const Platform &) = delete;
  Platform& operator=(const Platform &) = delete;
 
  virtual AudioProcessor* audio_processor() = 0;
 
  virtual InputProcessor* input_processor() = 0;
 
  virtual GraphicsProcessor* graphics_processor() { return nullptr; }
 
  virtual SensorProcessor* sensor_processor() { return nullptr; }
 
  virtual GpsProcessor* gps_processor() { return nullptr; }
 
  virtual CameraProcessor* camera_processor() { return nullptr; }
 
  virtual AnboxProxy* anbox_proxy() { return &anbox_proxy_; }
 
  virtual VideoDecoder* create_video_decoder(AnboxVideoCodecType codec_type) {
    (void) codec_type;
    return nullptr;
  }
 
  virtual VhalConnector* vhal_connector() { return &vhal_connector_; }
 
  virtual bool ready() const = 0;
 
  virtual int wait_until_ready() = 0;
 
  virtual int get_config_item(AnboxPlatformConfigurationKey key, void* data, size_t data_size) = 0;
 
  virtual int stop() { return 0; }
 
  virtual void handle_event(AnboxEventType type) { (void)type; }
 
  virtual int set_config_item(AnboxPlatformConfigurationKey key, void* data, size_t data_size) {
    (void)key;
    (void)data;
    (void)data_size;
    return 0;
  }
 
  virtual int set_config_items(const AnboxPlatformConfigurationItem* items, size_t count) {
    (void)items;
    (void)count;
    return 0;
  }
 
  virtual void setup_event_tracer(
    AnboxTracerGetCategoryEnabledFunc get_category_enabled_callback,
    AnboxTracerAddEventFunc add_event_callback) {
    (void) get_category_enabled_callback;
    (void) add_event_callback;
  }
 
 private:
  AnboxProxy  anbox_proxy_;
  VhalConnector vhal_connector_;
};
}
 
#define ANBOX_PLATFORM_PLUGIN_DESCRIBE(platform_type, name, vendor,         \
                                       description)                         \
  AnboxPlatformDescriptor anbox_platform_descriptor                         \
    __attribute((section(ANBOX_PLATFORM_DESCRIPTOR_SECTION))) = {           \
      name, vendor, description, ANBOX_PLATFORM_VERSION};                   \
  extern "C" {                                                              \
  ANBOX_EXPORT AnboxPlatform* anbox_initialize(                             \
    const AnboxPlatformConfiguration* configuration) {                      \
    try {                                                                   \
      auto platform = std::make_unique<platform_type>(configuration);       \
      return anbox_platform_plugin_register(std::move(platform));           \
    } catch (const std::exception& e) {                                     \
      std::cerr << "Anbox Platform SDK caught exception: " << e.what()      \
                << std::endl;                                               \
      return nullptr;                                                       \
    } catch (...) {                                                         \
      std::cerr << "Anbox Platform SDK caught unknown exception."           \
                << std::endl;                                               \
      return nullptr;                                                       \
    }                                                                       \
  }                                                                         \
                                                                            \
  ANBOX_EXPORT void anbox_deinitialize(AnboxPlatform* platform) {           \
    anbox_platform_plugin_unregister(platform);                             \
  }                                                                         \
  }
 
#endif