tango_client_api.h

Go to the documentation of this file.

// Copyright 2014 Google Inc. All Rights Reserved.
//
// 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 TANGO_CLIENT_API_HEADER_TANGO_CLIENT_API_H_
#define TANGO_CLIENT_API_HEADER_TANGO_CLIENT_API_H_

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>



typedef enum {
  TANGO_CAMERA_COLOR = 0,  
  TANGO_CAMERA_RGBIR,      
  TANGO_CAMERA_FISHEYE,    
  TANGO_CAMERA_DEPTH,      
  TANGO_MAX_CAMERA_ID      
} TangoCameraId;

typedef enum {
  TANGO_CONFIG_DEFAULT = 0,      
  TANGO_CONFIG_CURRENT,          
  TANGO_CONFIG_MOTION_TRACKING,  
  TANGO_CONFIG_AREA_LEARNING,    
  TANGO_CONFIG_RUNTIME,          
  TANGO_MAX_CONFIG_TYPE          
} TangoConfigType;

typedef enum {
  TANGO_COORDINATE_FRAME_GLOBAL_WGS84 = 0,
  TANGO_COORDINATE_FRAME_AREA_DESCRIPTION,
  TANGO_COORDINATE_FRAME_START_OF_SERVICE,
  TANGO_COORDINATE_FRAME_PREVIOUS_DEVICE_POSE,
  TANGO_COORDINATE_FRAME_DEVICE,          
  TANGO_COORDINATE_FRAME_IMU,             
  TANGO_COORDINATE_FRAME_DISPLAY,         
  TANGO_COORDINATE_FRAME_CAMERA_COLOR,    
  TANGO_COORDINATE_FRAME_CAMERA_DEPTH,    
  TANGO_COORDINATE_FRAME_CAMERA_FISHEYE,  
  TANGO_COORDINATE_FRAME_UUID,            
  TANGO_COORDINATE_FRAME_INVALID,
  TANGO_MAX_COORDINATE_FRAME_TYPE         
} TangoCoordinateFrameType;

typedef enum {
  TANGO_NO_LOCATION_PERMISSION = -8,
  TANGO_NO_DATASET_PERMISSION = -7,
  TANGO_NO_IMPORT_EXPORT_PERMISSION = -6,
  TANGO_NO_CAMERA_PERMISSION = -5,
  TANGO_NO_ADF_PERMISSION = -4,
  TANGO_NO_MOTION_TRACKING_PERMISSION = -3,
  TANGO_INVALID = -2,
  TANGO_ERROR = -1,
  TANGO_SUCCESS = 0,
} TangoErrorType;

typedef enum {
  TANGO_POSE_INITIALIZING = 0,  
  TANGO_POSE_VALID,             
  TANGO_POSE_INVALID,           
  TANGO_POSE_UNKNOWN            
} TangoPoseStatusType;

// Known TangoEvents are documented below in non-doxygen style. One of the tech
// writers is welcome to edit and expose later, if desired.
typedef enum {
  TANGO_EVENT_UNKNOWN = 0,  
  TANGO_EVENT_GENERAL,      
  // "TangoServiceException" : "Service faulted will restart."
  // "EXPERIMENTAL_PleaseDisconnect" : ""  (Experimental)
  // "CloudLocalizeSuccess" : ""  (Internal Debug)
  // "CloudLocalizeFailure" : ""  (Internal Debug)
  // "TileRequested" : "<s2Token>"  (Internal Debug)
  // "TileUnavailable" : "<s2Token>"  (Internal Debug)
  // "TileLoaded" : "<s2Token>"  (Internal Debug)
  // "TileUnloaded" : "<s2Token>"  (Internal Debug)
  // "TileDownloadFailed" : "<s2Token>"  (Internal Debug)
  TANGO_EVENT_FISHEYE_CAMERA,  
  // "FisheyeOverExposed" : ""
  // "FisheyeUnderExposed" : ""
  TANGO_EVENT_COLOR_CAMERA,  
  // "ColorOverExposed" : ""
  // "ColorUnderExposed" : ""
  TANGO_EVENT_IMU,  
  // <none>
  TANGO_EVENT_FEATURE_TRACKING,  
  // "TooFewFeaturesTracked" : ""
  TANGO_EVENT_AREA_LEARNING,  
  // "AreaDescriptionSaveProgress" : "<fraction complete>"
  TANGO_EVENT_CLOUD_ADF,  
                          // "STATUS_READY" : "0"  (Experimental)
                          // "STATUS_NOT_AVAILABLE" : "0"  (Experimental)
                          // "STATUS_FAILURE" : "0"  (Experimental)
} TangoEventType;

typedef enum {
  TANGO_CALIBRATION_UNKNOWN,
  TANGO_CALIBRATION_EQUIDISTANT,
  TANGO_CALIBRATION_POLYNOMIAL_2_PARAMETERS,
  TANGO_CALIBRATION_POLYNOMIAL_3_PARAMETERS,
  TANGO_CALIBRATION_POLYNOMIAL_5_PARAMETERS,
} TangoCalibrationType;

typedef enum {
  TANGO_HAL_PIXEL_FORMAT_RGBA_8888 = 1,       
  TANGO_HAL_PIXEL_FORMAT_YV12 = 0x32315659,   
  TANGO_HAL_PIXEL_FORMAT_YCrCb_420_SP = 0x11  
} TangoImageFormatType;

typedef enum {
  TANGO_POINTCLOUD_XYZIJ = -1,
  TANGO_POINTCLOUD_XYZC = 0
} TangoDepthMode;

typedef enum {
  TANGO_RECORDING_MODE_UNKNOWN = -1,
  TANGO_RECORDING_MODE_MOTION_TRACKING = 0,
  TANGO_RECORDING_MODE_SCENE_RECONSTRUCTION = 1,
  TANGO_RECORDING_MODE_MOTION_TRACKING_AND_FISHEYE = 2,
  TANGO_RECORDING_MODE_ALL = 3
} TangoRecordingMode_Experimental;

typedef enum {
  TANGO_RUNTIME_RECORDING_NO_CHANGE = 0,
  TANGO_RUNTIME_RECORDING_START = 1,
  TANGO_RUNTIME_RECORDING_STOP = 2
} TangoRuntimeRecordingControl_Experimental;


typedef void* TangoConfig;

#define TANGO_UUID_LEN 37
#define TANGO_COORDINATE_FRAME_ID_LEN 37
#define TANGO_LEVEL_SHORT_NAME_BYTE_MAX_LEN 16
#define TANGO_LEVEL_ID_BYTE_MAX_LEN 19

typedef char TangoUUID[TANGO_UUID_LEN];

// The unique id associated with a frame of interest.
// When a new frame of interest is created, the returned id can be used to
// reference the same frame of interest in future calls. A caller should not
// need to create such an id manually.
typedef struct TangoCoordinateFrameId {
  // String representation of the unique id (36 characters + null terminator).
  char data[TANGO_COORDINATE_FRAME_ID_LEN];
} TangoCoordinateFrameId;

// The following predefined UUIDs must be in the reserved space in
// 10000000-0000-0000-0000-0000000000[00-ff].
const TangoCoordinateFrameId TANGO_COORDINATE_FRAME_ID_NONE = {
    "10000000-0000-0000-0000-0000000000ff"};
const TangoCoordinateFrameId TANGO_COORDINATE_FRAME_ID_GLOBAL_WGS84 = {
    "10000000-0000-0000-0000-000000000000"};
const TangoCoordinateFrameId TANGO_COORDINATE_FRAME_ID_AREA_DESCRIPTION = {
    "10000000-0000-0000-0000-000000000001"};
const TangoCoordinateFrameId TANGO_COORDINATE_FRAME_ID_START_OF_SERVICE = {
    "10000000-0000-0000-0000-000000000002"};
const TangoCoordinateFrameId TANGO_COORDINATE_FRAME_ID_PREVIOUS_DEVICE_POSE = {
    "10000000-0000-0000-0000-000000000003"};
const TangoCoordinateFrameId TANGO_COORDINATE_FRAME_ID_DEVICE = {
    "10000000-0000-0000-0000-000000000004"};
const TangoCoordinateFrameId TANGO_COORDINATE_FRAME_ID_IMU = {
    "10000000-0000-0000-0000-000000000005"};
const TangoCoordinateFrameId TANGO_COORDINATE_FRAME_ID_DISPLAY = {
    "10000000-0000-0000-0000-000000000006"};
const TangoCoordinateFrameId TANGO_COORDINATE_FRAME_ID_CAMERA_COLOR = {
    "10000000-0000-0000-0000-000000000007"};
const TangoCoordinateFrameId TANGO_COORDINATE_FRAME_ID_CAMERA_DEPTH = {
    "10000000-0000-0000-0000-000000000008"};
const TangoCoordinateFrameId TANGO_COORDINATE_FRAME_ID_CAMERA_FISHEYE = {
    "10000000-0000-0000-0000-000000000009"};

typedef void* TangoAreaDescriptionMetadata;

typedef struct {
  TangoCoordinateFrameType base;

  TangoCoordinateFrameType target;
} TangoCoordinateFramePair;

typedef struct TangoPoseData {
  uint32_t version;

  double timestamp;

  double orientation[4];

  double translation[3];
  TangoPoseStatusType status_code;
  TangoCoordinateFramePair frame;
  uint32_t confidence;   
  float accuracy;        
} TangoPoseData;

typedef struct TangoTransformation {
  double orientation[4];

  double translation[3];
} TangoTransformation;

typedef struct TangoImageBuffer {
  uint32_t width;
  uint32_t height;
  uint32_t stride;
  double timestamp;
  int64_t frame_number;
  TangoImageFormatType format;
  uint8_t* data;
  int64_t exposure_duration_ns;
} TangoImageBuffer;

#define TANGO_MAX_IMAGE_PLANES (4)
typedef struct TangoImage {
  uint32_t width;
  uint32_t height;
  TangoImageFormatType format;
  int64_t timestamp_ns;

  uint32_t num_planes;
  uint8_t* plane_data[TANGO_MAX_IMAGE_PLANES];
  int32_t plane_size[TANGO_MAX_IMAGE_PLANES];
  int32_t plane_row_stride[TANGO_MAX_IMAGE_PLANES];
  int32_t plane_pixel_stride[TANGO_MAX_IMAGE_PLANES];
} TangoImage;

typedef struct TangoCameraMetadata {
  int64_t timestamp_ns;
  int64_t frame_number;
  int64_t exposure_duration_ns;
} TangoCameraMetadata;

typedef struct TangoXYZij {
  uint32_t version;

  double timestamp;

  uint32_t xyz_count;

  float (*xyz)[3];

  uint32_t ij_rows;
  uint32_t ij_cols;

  uint32_t* ij;

  TangoImageBuffer* color_image;
} TangoXYZij;

typedef struct TangoPointCloud {
  uint32_t version;

  double timestamp;

  uint32_t num_points;

  float (*points)[4];
} TangoPointCloud;

typedef struct TangoCameraIntrinsics {
  TangoCameraId camera_id;
  TangoCalibrationType calibration_type;

  uint32_t width;
  uint32_t height;

  double fx;
  double fy;
  double cx;
  double cy;

  double distortion[5];
} TangoCameraIntrinsics;

typedef struct TangoEvent {
  double timestamp;
  TangoEventType type;
  const char* event_key;
  const char* event_value;
} TangoEvent;

#ifdef __cplusplus
extern "C" {
#endif


void TangoConfig_free(TangoConfig config);

char* TangoConfig_toString(TangoConfig config);


TangoErrorType TangoService_initialize(void* jni_env, void* activity);

TangoErrorType TangoService_setBinder(void* jni_env, void* iBinder);

TangoConfig TangoService_getConfig(TangoConfigType config_type);

TangoErrorType TangoService_connect(void* context, TangoConfig config);

TangoErrorType TangoService_setRuntimeConfig(TangoConfig tconfig);

void TangoService_disconnect();

void TangoService_resetMotionTracking();


TangoErrorType TangoService_connectOnPoseAvailable(
    uint32_t count, const TangoCoordinateFramePair* frames,
    void (*TangoService_onPoseAvailable)(void* context,
                                         const TangoPoseData* pose),
    ...);

TangoErrorType TangoService_getPoseAtTime(double timestamp,
                                          TangoCoordinateFramePair frame,
                                          TangoPoseData* pose);


TangoErrorType TangoService_connectOnXYZijAvailable(
    void (*TangoService_onXYZijAvailable)(void* context,
                                          const TangoXYZij* xyz_ij),
    ...);

TangoErrorType TangoService_connectOnPointCloudAvailable(
    void (*TangoService_onPointCloudAvailable)(void* context,
                                               const TangoPointCloud* cloud),
    ...);


TangoErrorType TangoService_connectOnTangoEvent(
    void (*TangoService_onTangoEvent)(void* context, const TangoEvent* event),
    ...);


typedef void (*TangoService_OnTextureAvailable)(void*, TangoCameraId);

TangoErrorType TangoService_connectTextureId(
    TangoCameraId id, unsigned int tex, void* context,
    TangoService_OnTextureAvailable callback);

TangoErrorType TangoService_updateTexture(TangoCameraId id, double* timestamp);

TangoErrorType TangoService_connectOnTextureAvailable(
    TangoCameraId id, void* context, TangoService_OnTextureAvailable callback);

TangoErrorType TangoService_updateTextureExternalOes(TangoCameraId id,
                                                     unsigned int tex,
                                                     double* timestamp);

typedef int64_t TangoBufferId;

TangoErrorType TangoService_lockCameraBuffer(TangoCameraId id,
                                             double* timestamp,
                                             TangoBufferId* buffer);

void TangoService_unlockCameraBuffer(TangoCameraId id, TangoBufferId buffer);

TangoErrorType TangoService_updateTextureExternalOesForBuffer(
    TangoCameraId id, unsigned int texture_id, TangoBufferId buffer);

TangoErrorType TangoService_connectOnFrameAvailable(
    TangoCameraId id, void* context,
    void (*onFrameAvailable)(void* context, TangoCameraId id,
                             const TangoImageBuffer* buffer));

TangoErrorType TangoService_connectOnImageAvailable(
    TangoCameraId id, void* context,
    void (*onImageAvailable)(void* context, TangoCameraId id,
                             const TangoImage* image,
                             const TangoCameraMetadata* metadata));

TangoErrorType TangoService_disconnectCamera(TangoCameraId id);

TangoErrorType TangoService_getCameraIntrinsics(TangoCameraId camera_id,
    TangoCameraIntrinsics* intrinsics);


TangoErrorType TangoService_saveAreaDescription(TangoUUID* uuid);

TangoErrorType TangoService_deleteAreaDescription(const TangoUUID uuid);

TangoErrorType TangoService_getAreaDescriptionUUIDList(char** uuid_list);

TangoErrorType TangoService_getAreaDescriptionMetadata(
    const TangoUUID uuid, TangoAreaDescriptionMetadata* metadata);

TangoErrorType TangoService_saveAreaDescriptionMetadata(
    const TangoUUID uuid, TangoAreaDescriptionMetadata metadata);

TangoErrorType TangoAreaDescriptionMetadata_free(
    TangoAreaDescriptionMetadata metadata);

TangoErrorType TangoService_importAreaDescription(const char* src_file_path,
                                                  TangoUUID* uuid);

TangoErrorType TangoService_exportAreaDescription(
    const TangoUUID uuid, const char* dst_file_dir);

TangoErrorType TangoAreaDescriptionMetadata_get(
    TangoAreaDescriptionMetadata metadata, const char* key, size_t* value_size,
    char** value);

TangoErrorType TangoAreaDescriptionMetadata_set(
    TangoAreaDescriptionMetadata metadata, const char* key, size_t value_size,
    const char* value);

TangoErrorType TangoAreaDescriptionMetadata_listKeys(
    TangoAreaDescriptionMetadata metadata, char** key_list);


TangoErrorType TangoConfig_setBool(TangoConfig config, const char* key,
                                   bool value);

TangoErrorType TangoConfig_setInt32(TangoConfig config, const char* key,
                                    int32_t value);

TangoErrorType TangoConfig_setInt64(TangoConfig config, const char* key,
                                    int64_t value);

TangoErrorType TangoConfig_setDouble(TangoConfig config, const char* key,
                                     double value);

TangoErrorType TangoConfig_setString(TangoConfig config, const char* key,
                                     const char* value);

TangoErrorType TangoConfig_getBool(TangoConfig config, const char* key,
                                   bool* value);

TangoErrorType TangoConfig_getInt32(TangoConfig config, const char* key,
                                    int32_t* value);

TangoErrorType TangoConfig_getInt64(TangoConfig config, const char* key,
                                    int64_t* value);

TangoErrorType TangoConfig_getDouble(TangoConfig config, const char* key,
                                     double* value);

TangoErrorType TangoConfig_getString(TangoConfig config, const char* key,
                                     char* value, size_t size);
TangoErrorType TangoService_Experimental_connectTextureIdUnity(
    TangoCameraId id, unsigned int texture_y, unsigned int texture_Cb,
    unsigned int texture_Cr, void* context,
    void (*callback)(void*, TangoCameraId));

TangoErrorType TangoService_Experimental_getDatasetUUIDs(
    TangoUUID** dataset_uuids, int* num_dataset_uuids);

TangoErrorType TangoService_Experimental_releaseDatasetUUIDs(
    TangoUUID** dataset_uuids);

TangoErrorType TangoService_Experimental_deleteDataset(
    const TangoUUID dataset_uuid);

TangoErrorType TangoService_Experimental_getCurrentDatasetUUID(
    TangoUUID* dataset_uuid);

#ifdef __cplusplus
}
#endif

#endif  // TANGO_CLIENT_API_HEADER_TANGO_CLIENT_API_H_