src/sensor_dummy.cpp

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <sensor.h>
  18
  19 int sensor_is_supported(sensor_type_e type, bool *supported)
  20 {
  21         return SENSOR_ERROR_NOT_SUPPORTED;
  22 }
  23
  24 int sensor_get_default_sensor(sensor_type_e type, sensor_h *sensor)
  25 {
  26         return SENSOR_ERROR_NOT_SUPPORTED;
  27 }
  28
  29 int sensor_get_sensor_list(sensor_type_e type, sensor_h **list, int *sensor_count)
  30 {
  31         return SENSOR_ERROR_NOT_SUPPORTED;
  32 }
  33
  34 int sensor_is_wake_up(sensor_h sensor, bool *wakeup)
  35 {
  36         return SENSOR_ERROR_NOT_SUPPORTED;
  37 }
  38
  39 int sensor_create_listener(sensor_h sensor, sensor_listener_h *listener)
  40 {
  41         return SENSOR_ERROR_NOT_SUPPORTED;
  42 }
  43
  44 int sensor_destroy_listener(sensor_listener_h listener)
  45 {
  46         return SENSOR_ERROR_NOT_SUPPORTED;
  47 }
  48
  49 int sensor_listener_start(sensor_listener_h listener)
  50 {
  51         return SENSOR_ERROR_NOT_SUPPORTED;
  52 }
  53
  54 int sensor_listener_stop(sensor_listener_h listener)
  55 {
  56         return SENSOR_ERROR_NOT_SUPPORTED;
  57 }
  58
  59 int sensor_listener_set_event_cb(sensor_listener_h listener,
  60                 unsigned int interval, sensor_event_cb callback, void *user_data)
  61 {
  62         return SENSOR_ERROR_NOT_SUPPORTED;
  63 }
  64
  65 int sensor_listener_unset_event_cb(sensor_listener_h listener)
  66 {
  67         return SENSOR_ERROR_NOT_SUPPORTED;
  68 }
  69
  70 int sensor_listener_set_accuracy_cb(sensor_listener_h listener,
  71                 sensor_accuracy_changed_cb callback, void *data)
  72 {
  73         return SENSOR_ERROR_NOT_SUPPORTED;
  74 }
  75
  76 int sensor_listener_unset_accuracy_cb(sensor_listener_h listener)
  77 {
  78         return SENSOR_ERROR_NOT_SUPPORTED;
  79 }
  80
  81 int sensor_listener_set_interval(sensor_listener_h listener, unsigned int interval)
  82 {
  83         return SENSOR_ERROR_NOT_SUPPORTED;
  84 }
  85
  86 int sensor_listener_set_max_batch_latency(sensor_listener_h listener, unsigned int max_batch_latency)
  87 {
  88         return SENSOR_ERROR_NOT_SUPPORTED;
  89 }
  90
  91 int sensor_listener_set_attribute_int(sensor_listener_h listener, sensor_attribute_e attribute, int value)
  92 {
  93         return SENSOR_ERROR_NOT_SUPPORTED;
  94 }
  95
  96 int sensor_listener_set_option(sensor_listener_h listener, sensor_option_e option)
  97 {
  98         return SENSOR_ERROR_NOT_SUPPORTED;
  99 }
 100
 101 int sensor_listener_read_data(sensor_listener_h listener, sensor_event_s *event)
 102 {
 103         return SENSOR_ERROR_NOT_SUPPORTED;
 104 }
 105
 106 int sensor_get_name(sensor_h sensor, char** name)
 107 {
 108         return SENSOR_ERROR_NOT_SUPPORTED;
 109 }
 110
 111 int sensor_get_vendor(sensor_h sensor, char** vendor)
 112 {
 113         return SENSOR_ERROR_NOT_SUPPORTED;
 114 }
 115
 116 int sensor_get_type(sensor_h sensor, sensor_type_e *type)
 117 {
 118         return SENSOR_ERROR_NOT_SUPPORTED;
 119 }
 120
 121 int sensor_get_min_range(sensor_h sensor, float *min_range)
 122 {
 123         return SENSOR_ERROR_NOT_SUPPORTED;
 124 }
 125
 126 int sensor_get_max_range(sensor_h sensor, float *max_range)
 127 {
 128         return SENSOR_ERROR_NOT_SUPPORTED;
 129 }
 130
 131 int sensor_get_resolution(sensor_h sensor, float *resolution)
 132 {
 133         return SENSOR_ERROR_NOT_SUPPORTED;
 134 }
 135
 136 int sensor_get_min_interval(sensor_h sensor, int *min_interval)
 137 {
 138         return SENSOR_ERROR_NOT_SUPPORTED;
 139 }
 140
 141 int sensor_get_fifo_count(sensor_h sensor, int *fifo_count)
 142 {
 143         return SENSOR_ERROR_NOT_SUPPORTED;
 144 }
 145
 146 int sensor_get_max_batch_count(sensor_h sensor, int *max_batch_count)
 147 {
 148         return SENSOR_ERROR_NOT_SUPPORTED;
 149 }
 150
 151 /*
 152  *      FUNCTIONS : SENSOR_UTIL_*
 153  */
 154
 155 int sensor_util_get_declination(float latitude, float longitude, float altitude, float *declination)
 156 {
 157         return SENSOR_ERROR_NOT_SUPPORTED;
 158 }
 159
 160 int sensor_util_get_angle_change(float R[], float prevR[], float angleChange[])
 161 {
 162         return SENSOR_ERROR_NOT_SUPPORTED;
 163 }
 164
 165 int sensor_util_get_orientation(float R[], float values[])
 166 {
 167         return SENSOR_ERROR_NOT_SUPPORTED;
 168 }
 169
 170 int sensor_util_get_inclination(float I[], float* inclination)
 171 {
 172         return SENSOR_ERROR_NOT_SUPPORTED;
 173 }
 174
 175 int sensor_util_remap_coordinate_system(float inR[], sensor_util_axis_e x, sensor_util_axis_e y, float outR[])
 176 {
 177         return SENSOR_ERROR_NOT_SUPPORTED;
 178 }
 179
 180 int sensor_util_get_rotation_matrix_from_vector(float Vx, float Vy, float Vz, float R[])
 181 {
 182         return SENSOR_ERROR_NOT_SUPPORTED;
 183 }
 184
 185 int sensor_util_get_rotation_matrix(float Gx, float Gy, float Gz, float Mx, float My, float Mz, float R[], float I[])
 186 {
 187         return SENSOR_ERROR_NOT_SUPPORTED;
 188 }
 189