src/server/plugins/sensor_module_create.cpp.in

   1 #ifdef ENABLE_ACCEL
   2 #include <accel_sensor.h>
   3 #endif
   4 #ifdef ENABLE_GYRO
   5 #include <gyro_sensor.h>
   6 #endif
   7 #ifdef ENABLE_PROXI
   8 #include <proxi_sensor.h>
   9 #endif
  10 #ifdef ENABLE_LIGHT
  11 #include <light_sensor.h>
  12 #endif
  13 #ifdef ENABLE_GEO
  14 #include <geo_sensor.h>
  15 #endif
  16 #ifdef ENABLE_AUTO_ROTATION
  17 #include <auto_rotation_sensor.h>
  18 #endif
  19 #ifdef ENABLE_PRESSURE
  20 #include <pressure_sensor.h>
  21 #endif
  22 #ifdef ENABLE_TEMPERATURE
  23 #include <temperature_sensor.h>
  24 #endif
  25 #ifdef ENABLE_ULTRAVIOLET
  26 #include <ultraviolet_sensor.h>
  27 #endif
  28 #ifdef ENABLE_BIO_LED_RED
  29 #include <bio_led_red_sensor.h>
  30 #endif
  31 #ifdef ENABLE_ORIENTATION
  32 #include <orientation_sensor.h>
  33 #endif
  34 #ifdef ENABLE_GEOMAGNETIC_RV
  35 #include <geomagnetic_rv_sensor.h>
  36 #endif
  37 #ifdef ENABLE_GAMING_RV
  38 #include <gaming_rv_sensor.h>
  39 #endif
  40 #ifdef ENABLE_TILT
  41 #include <tilt_sensor.h>
  42 #endif
  43 #ifdef ENABLE_UNCAL_GYRO
  44 #include <uncal_gyro_sensor.h>
  45 #endif
  46 #ifdef ENABLE_GRAVITY
  47 #include <gravity_sensor.h>
  48 #endif
  49 #ifdef ENABLE_LINEAR_ACCEL
  50 #include <linear_accel_sensor.h>
  51 #endif
  52 #ifdef ENABLE_RV
  53 #include <rv_sensor.h>
  54 #endif
  55 #ifdef ENABLE_RV_RAW
  56 #include <rv_raw_sensor.h>
  57 #endif
  58
  59 #include <sf_common.h>
  60
  61 extern "C" sensor_module* create(void)
  62 {
  63         sensor_module *module = new(std::nothrow) sensor_module;
  64         retvm_if(!module, NULL, "Failed to allocate memory");
  65
  66 #ifdef ENABLE_ACCEL
  67         accel_sensor *accel_sensor_ptr = NULL;
  68         try {
  69                 accel_sensor_ptr = new(std::nothrow) accel_sensor;
  70         } catch (int err) {
  71                 ERR("Failed to create accel_sensor module, err: %d, cause: %s", err, strerror(err));
  72         }
  73         if (accel_sensor_ptr != NULL) {
  74                 module->sensors.push_back(accel_sensor_ptr);
  75         }
  76 #endif
  77
  78 #ifdef ENABLE_AUTO_ROTATION
  79         auto_rotation_sensor *auto_rotation_sensor_ptr = NULL;
  80         try {
  81                 auto_rotation_sensor_ptr = new(std::nothrow) auto_rotation_sensor;
  82         } catch (int err) {
  83                 ERR("Failed to create auto_rotation_sensor module, err: %d, cause: %s", err, strerror(err));
  84         }
  85         if (auto_rotation_sensor_ptr != NULL)
  86                 module->sensors.push_back(auto_rotation_sensor_ptr);
  87 #endif
  88
  89 #ifdef ENABLE_GYRO
  90         gyro_sensor *gyro_sensor_ptr = NULL;
  91         try {
  92                 gyro_sensor_ptr = new(std::nothrow) gyro_sensor;
  93         } catch (int err) {
  94                 ERR("Failed to create gyro_sensor module, err: %d, cause: %s", err, strerror(err));
  95         }
  96         if (gyro_sensor_ptr != NULL)
  97                 module->sensors.push_back(gyro_sensor_ptr);
  98 #endif
  99
 100 #ifdef ENABLE_PROXI
 101         proxi_sensor *proxi_sensor_ptr = NULL;
 102         try {
 103                 proxi_sensor_ptr = new(std::nothrow) proxi_sensor;
 104         } catch (int err) {
 105                 ERR("Failed to create proxi_sensor module, err: %d, cause: %s", err, strerror(err));
 106         }
 107         if (proxi_sensor_ptr != NULL)
 108                 module->sensors.push_back(proxi_sensor_ptr);
 109 #endif
 110
 111 #ifdef ENABLE_LIGHT
 112         light_sensor *light_sensor_ptr = NULL;
 113         try {
 114                 light_sensor_ptr = new(std::nothrow) light_sensor;
 115         } catch (int err) {
 116                 ERR("Failed to create light_sensor module, err: %d, cause: %s", err, strerror(err));
 117         }
 118         if (light_sensor_ptr != NULL)
 119                 module->sensors.push_back(light_sensor_ptr);
 120 #endif
 121
 122 #ifdef ENABLE_GEO
 123         geo_sensor *geo_sensor_ptr = NULL;
 124         try {
 125                 geo_sensor_ptr = new(std::nothrow) geo_sensor;
 126         } catch (int err) {
 127                 ERR("Failed to create geo_sensor module, err: %d, cause: %s", err, strerror(err));
 128         }
 129         if (geo_sensor_ptr != NULL)
 130                 module->sensors.push_back(geo_sensor_ptr);
 131 #endif
 132
 133 #ifdef ENABLE_PRESSURE
 134         pressure_sensor *pressure_sensor_ptr = NULL;
 135         try {
 136                 pressure_sensor_ptr = new(std::nothrow) pressure_sensor;
 137         } catch (int err) {
 138                 ERR("Failed to create pressure_sensor module, err: %d, cause: %s", err, strerror(err));
 139         }
 140         if (pressure_sensor_ptr != NULL)
 141                 module->sensors.push_back(pressure_sensor_ptr);
 142 #endif
 143
 144 #ifdef ENABLE_TEMPERATURE
 145         temperature_sensor *temperature_sensor_ptr = NULL;
 146         try {
 147                 temperature_sensor_ptr = new(std::nothrow) temperature_sensor;
 148         } catch (int err) {
 149                 ERR("Failed to create temperature_sensor module, err: %d, cause: %s", err, strerror(err));
 150         }
 151         if (temperature_sensor_ptr != NULL)
 152                 module->sensors.push_back(temperature_sensor_ptr);
 153 #endif
 154
 155 #ifdef ENABLE_ULTRAVIOLET
 156         ultraviolet_sensor *ultraviolet_sensor_ptr = NULL;
 157         try {
 158                 ultraviolet_sensor_ptr = new(std::nothrow) ultraviolet_sensor;
 159         } catch (int err) {
 160                 ERR("Failed to create ultraviolet_sensor module, err: %d, cause: %s", err, strerror(err));
 161         }
 162         if (ultraviolet_sensor_ptr != NULL)
 163                 module->sensors.push_back(ultraviolet_sensor_ptr);
 164 #endif
 165
 166 #ifdef DENABLE_SENSOR_FUSION
 167         fusion_sensor *fusion_sensor_ptr = NULL;
 168         try {
 169                 fusion_sensor_ptr = new(std::nothrow) fusion_sensor;
 170         } catch (int err) {
 171                 ERR("Failed to create fusion_sensor module, err: %d, cause: %s", err, strerror(err));
 172         }
 173         if (fusion_sensor_ptr != NULL)
 174                 module->sensors.push_back(fusion_sensor_ptr);
 175 #endif
 176
 177 #ifdef ENABLE_ORIENTATION
 178         orientation_sensor *orientation_sensor_ptr = NULL;
 179         try {
 180                 orientation_sensor_ptr = new(std::nothrow) orientation_sensor;
 181         } catch (int err) {
 182                 ERR("Failed to create orientation_sensor module, err: %d, cause: %s", err, strerror(err));
 183         }
 184         if (orientation_sensor_ptr != NULL)
 185                 module->sensors.push_back(orientation_sensor_ptr);
 186 #endif
 187
 188 #ifdef ENABLE_GRAVITY
 189         gravity_sensor *gravity_sensor_ptr = NULL;
 190         try {
 191                 gravity_sensor_ptr = new(std::nothrow) gravity_sensor;
 192         } catch (int err) {
 193                 ERR("Failed to create gravity_sensor module, err: %d, cause: %s", err, strerror(err));
 194         }
 195         if (gravity_sensor_ptr != NULL)
 196                 module->sensors.push_back(gravity_sensor_ptr);
 197 #endif
 198
 199 #ifdef ENABLE_LINEAR_ACCEL
 200         linear_accel_sensor *linear_accel_sensor_ptr = NULL;
 201         try {
 202                 linear_accel_sensor_ptr = new(std::nothrow) linear_accel_sensor;
 203         } catch (int err) {
 204                 ERR("Failed to create linear_accel_sensor module, err: %d, cause: %s", err, strerror(err));
 205         }
 206         if (linear_accel_sensor_ptr != NULL)
 207                 module->sensors.push_back(linear_accel_sensor_ptr);
 208 #endif
 209
 210 #ifdef ENABLE_GEOMAGNETIC_RV
 211         geomagnetic_rv_sensor *geomagnetic_rv_sensor_ptr = NULL;
 212         try {
 213                 geomagnetic_rv_sensor_ptr = new(std::nothrow) geomagnetic_rv_sensor;
 214         } catch (int err) {
 215                 ERR("Failed to create geomagnetic_rv_sensor module, err: %d, cause: %s", err, strerror(err));
 216         }
 217         if (geomagnetic_rv_sensor_ptr != NULL)
 218                 module->sensors.push_back(geomagnetic_rv_sensor_ptr);
 219 #endif
 220
 221 #ifdef ENABLE_GAMING_RV
 222         gaming_rv_sensor *gaming_rv_sensor_ptr = NULL;
 223         try {
 224                 gaming_rv_sensor_ptr = new(std::nothrow) gaming_rv_sensor;
 225         } catch (int err) {
 226                 ERR("Failed to create gaming_rv_sensor module, err: %d, cause: %s", err, strerror(err));
 227         }
 228         if (gaming_rv_sensor_ptr != NULL)
 229                 module->sensors.push_back(gaming_rv_sensor_ptr);
 230 #endif
 231
 232 #ifdef ENABLE_RV
 233         rv_sensor *rv_sensor_ptr = NULL;
 234         try {
 235                 rv_sensor_ptr = new(std::nothrow) rv_sensor;
 236         } catch (int err) {
 237                 ERR("Failed to create rv_sensor module, err: %d, cause: %s", err, strerror(err));
 238         }
 239         if (rv_sensor_ptr != NULL)
 240                 module->sensors.push_back(rv_sensor_ptr);
 241 #endif
 242
 243 #ifdef ENABLE_TILT
 244         tilt_sensor *tilt_sensor_ptr = NULL;
 245         try {
 246                 tilt_sensor_ptr = new(std::nothrow) tilt_sensor;
 247         } catch (int err) {
 248                 ERR("Failed to create tilt_sensor module, err: %d, cause: %s", err, strerror(err));
 249         }
 250         if (tilt_sensor_ptr != NULL)
 251                 module->sensors.push_back(tilt_sensor_ptr);
 252 #endif
 253
 254 #ifdef ENABLE_UNCAL_GYRO
 255         uncal_gyro_sensor *uncal_gyro_sensor_ptr = NULL;
 256         try {
 257                 uncal_gyro_sensor_ptr = new(std::nothrow) uncal_gyro_sensor;
 258         } catch (int err) {
 259                 ERR("Failed to create uncal_gyro_sensor module, err: %d, cause: %s", err, strerror(err));
 260         }
 261         if (uncal_gyro_sensor_ptr != NULL)
 262                 module->sensors.push_back(uncal_gyro_sensor_ptr);
 263 #endif
 264
 265 #ifdef ENABLE_BIO_LED_RED
 266         bio_led_red_sensor *bio_led_red_sensor_ptr = NULL;
 267         try {
 268                 bio_led_red_sensor_ptr = new(std::nothrow) bio_led_red_sensor;
 269         } catch (int err) {
 270                 ERR("Failed to create bio_led_red_sensor module, err: %d, cause: %s", err, strerror(err));
 271         }
 272         if (bio_led_red_sensor_ptr != NULL)
 273                 module->sensors.push_back(bio_led_red_sensor_ptr);
 274 #endif
 275
 276 #ifdef ENABLE_RV_RAW
 277         rv_raw_sensor *rv_raw_sensor_ptr = NULL;
 278         try {
 279                 rv_raw_sensor_ptr = new(std::nothrow) rv_raw_sensor;
 280         } catch (int err) {
 281                 ERR("Failed to create rv_raw_sensor module, err: %d, cause: %s", err, strerror(err));
 282         }
 283         if (rv_raw_sensor_ptr != NULL)
 284                 module->sensors.push_back(rv_raw_sensor_ptr);
 285 #endif
 286
 287         return module;
 288 }