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"
 
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 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) { \
    auto platform = std::make_unique<platform_type>(configuration); \
    return anbox_platform_plugin_register(std::move(platform)); \
  } \
  ANBOX_EXPORT void anbox_deinitialize(AnboxPlatform* platform) { \
      anbox_platform_plugin_unregister(platform); \
  } \
}
#endif