anbox_proxy.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_SDK_ANBOX_PROXY_H_
#define ANBOX_SDK_ANBOX_PROXY_H_
 
#include "anbox-platform-sdk/types.h"
 
#include <errno.h>
#include <stdint.h>
#include <unistd.h>
 
typedef int (*AnboxChangeScreenOrientationCallback)(AnboxScreenOrientationType orientation_type, void* user_data);
 
typedef int (*AnboxChangeDisplayDensityCallback)(uint32_t density, void* user_data);
 
typedef int (*AnboxChangeDisplaySizeCallback)(uint32_t width, uint32_t height, void* user_data);
 
typedef int (*AnboxTriggerActionCallback)(const char* name, const char **args, size_t args_len, void* user_data);
 
typedef int (*AnboxCreateADBConnectionCallback)(const char* id, void* user_data);
 
typedef int (*AnboxDisconnectADBConnectionCallback)(const char* id, void* user_data);
 
namespace anbox {
class AnboxProxy {
  public:
   AnboxProxy() = default;
   virtual ~AnboxProxy() = default;
   AnboxProxy(const AnboxProxy &) = delete;
   AnboxProxy& operator=(const AnboxProxy &) = delete;
 
   int change_screen_orientation(AnboxScreenOrientationType orientation_type) {
     if (!change_screen_orientation_callback_)
       return -EINVAL;
     return change_screen_orientation_callback_(orientation_type, screen_orientation_callback_user_data_);
   }
 
   void set_change_screen_orientation_callback(const AnboxChangeScreenOrientationCallback& callback,
                                               void* user_data) {
     change_screen_orientation_callback_ = callback;
     screen_orientation_callback_user_data_ = user_data;
   }
 
   int change_display_density(uint32_t density) {
     if (!change_display_density_callback_)
       return -EINVAL;
     return change_display_density_callback_(density, display_density_callback_user_data_);
   }
 
   void set_change_display_density_callback(const AnboxChangeDisplayDensityCallback& callback,
                                            void* user_data) {
     change_display_density_callback_ = callback;
     display_density_callback_user_data_ = user_data;
   }
 
   int change_display_size(uint32_t width, uint32_t height) {
     if (!change_display_size_callback_)
       return -EINVAL;
     return change_display_size_callback_(width, height, display_size_callback_user_data_);
   }
 
   void set_change_display_size_callback(const AnboxChangeDisplaySizeCallback& callback,
                                         void* user_data) {
     change_display_size_callback_ = callback;
     display_size_callback_user_data_ = user_data;
   }
 
   int trigger_action(const char* name, const char** args, size_t args_len) {
     if (!trigger_action_callback_)
       return -EINVAL;
     return trigger_action_callback_(name, args, args_len, trigger_action_callback_user_data_);
   }
 
   void set_trigger_action_callback(const AnboxTriggerActionCallback& callback,
                                    void* user_data) {
     trigger_action_callback_ = callback;
     trigger_action_callback_user_data_ = user_data;
   }
 
   virtual int send_message(const char* type, size_t type_size,
                            const char* data, size_t data_size) {
     (void) type;
     (void) type_size;
     (void) data;
     (void) data_size;
     return -EIO;
   }
 
   int create_adb_connection(const char* id) {
     if (!create_adb_connection_callback_)
       return -EINVAL;
     return create_adb_connection_callback_(id, create_adb_connection_callback_user_data_);
   }
 
   void set_create_adb_connection_callback(const AnboxCreateADBConnectionCallback& callback,
                                           void* user_data) {
     create_adb_connection_callback_ = callback;
     create_adb_connection_callback_user_data_ = user_data;
   }
 
   int disconnect_adb_connection(const char* id) {
     if (!disconnect_adb_connection_callback_)
       return -EINVAL;
     return disconnect_adb_connection_callback_(id, disconnect_adb_connection_callback_user_data_);
   }
 
   void set_disconnect_adb_connection_callback(const AnboxDisconnectADBConnectionCallback& callback,
                                               void* user_data) {
     disconnect_adb_connection_callback_ = callback;
     disconnect_adb_connection_callback_user_data_ = user_data;
   }
 
  private:
   AnboxChangeScreenOrientationCallback change_screen_orientation_callback_{nullptr};
   AnboxChangeDisplayDensityCallback change_display_density_callback_{nullptr};
   AnboxChangeDisplaySizeCallback change_display_size_callback_{nullptr};
   AnboxTriggerActionCallback trigger_action_callback_{nullptr};
   AnboxCreateADBConnectionCallback create_adb_connection_callback_{nullptr};
   AnboxDisconnectADBConnectionCallback disconnect_adb_connection_callback_{nullptr};
 
   void* screen_orientation_callback_user_data_{nullptr};
   void* display_density_callback_user_data_{nullptr};
   void* display_size_callback_user_data_{nullptr};
   void* trigger_action_callback_user_data_{nullptr};
   void* create_adb_connection_callback_user_data_{nullptr};
   void* disconnect_adb_connection_callback_user_data_{nullptr};
};
} // namespace anbox
 
#endif