src/type3_AndroidCloud/anbox-master/android/sensors/sensors_qemu.c

   1 /*
   2  * Copyright (C) 2009 The Android Open Source Project
   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 /* this implements a sensors hardware library for the Android emulator.
  18  * the following code should be built as a shared library that will be
  19  * placed into /system/lib/hw/sensors.goldfish.so
  20  *
  21  * it will be loaded by the code in hardware/libhardware/hardware.c
  22  * which is itself called from com_android_server_SensorService.cpp
  23  */
  24
  25
  26 /* we connect with the emulator through the "sensors" qemud service
  27  */
  28 #define  SENSORS_SERVICE_NAME "sensors"
  29
  30 #define LOG_TAG "QemuSensors"
  31
  32 #include <unistd.h>
  33 #include <fcntl.h>
  34 #include <errno.h>
  35 #include <string.h>
  36 #include <cutils/log.h>
  37 #include <cutils/sockets.h>
  38 #include <hardware/sensors.h>
  39
  40 #if 0
  41 #define  D(...)  ALOGD(__VA_ARGS__)
  42 #else
  43 #define  D(...)  ((void)0)
  44 #endif
  45
  46 #define  E(...)  ALOGE(__VA_ARGS__)
  47
  48 #include <hardware/qemud.h>
  49
  50 /** SENSOR IDS AND NAMES
  51  **/
  52
  53 #define MAX_NUM_SENSORS 8
  54
  55 #define SUPPORTED_SENSORS  ((1<<MAX_NUM_SENSORS)-1)
  56
  57 #define  ID_BASE           SENSORS_HANDLE_BASE
  58 #define  ID_ACCELERATION   (ID_BASE+0)
  59 #define  ID_MAGNETIC_FIELD (ID_BASE+1)
  60 #define  ID_ORIENTATION    (ID_BASE+2)
  61 #define  ID_TEMPERATURE    (ID_BASE+3)
  62 #define  ID_PROXIMITY      (ID_BASE+4)
  63 #define  ID_LIGHT          (ID_BASE+5)
  64 #define  ID_PRESSURE       (ID_BASE+6)
  65 #define  ID_HUMIDITY       (ID_BASE+7)
  66
  67 #define  SENSORS_ACCELERATION    (1 << ID_ACCELERATION)
  68 #define  SENSORS_MAGNETIC_FIELD  (1 << ID_MAGNETIC_FIELD)
  69 #define  SENSORS_ORIENTATION     (1 << ID_ORIENTATION)
  70 #define  SENSORS_TEMPERATURE     (1 << ID_TEMPERATURE)
  71 #define  SENSORS_PROXIMITY       (1 << ID_PROXIMITY)
  72 #define  SENSORS_LIGHT           (1 << ID_LIGHT)
  73 #define  SENSORS_PRESSURE        (1 << ID_PRESSURE)
  74 #define  SENSORS_HUMIDITY        (1 << ID_HUMIDITY)
  75
  76 #define  ID_CHECK(x)  ((unsigned)((x) - ID_BASE) < MAX_NUM_SENSORS)
  77
  78 #define  SENSORS_LIST  \
  79     SENSOR_(ACCELERATION,"acceleration") \
  80     SENSOR_(MAGNETIC_FIELD,"magnetic-field") \
  81     SENSOR_(ORIENTATION,"orientation") \
  82     SENSOR_(TEMPERATURE,"temperature") \
  83     SENSOR_(PROXIMITY,"proximity") \
  84     SENSOR_(LIGHT, "light") \
  85     SENSOR_(PRESSURE, "pressure") \
  86     SENSOR_(HUMIDITY, "humidity")
  87
  88 static const struct {
  89     const char*  name;
  90     int          id; } _sensorIds[MAX_NUM_SENSORS] =
  91 {
  92 #define SENSOR_(x,y)  { y, ID_##x },
  93     SENSORS_LIST
  94 #undef  SENSOR_
  95 };
  96
  97 static const char*
  98 _sensorIdToName( int  id )
  99 {
 100     int  nn;
 101     for (nn = 0; nn < MAX_NUM_SENSORS; nn++)
 102         if (id == _sensorIds[nn].id)
 103             return _sensorIds[nn].name;
 104     return "<UNKNOWN>";
 105 }
 106
 107 static int
 108 _sensorIdFromName( const char*  name )
 109 {
 110     int  nn;
 111
 112     if (name == NULL)
 113         return -1;
 114
 115     for (nn = 0; nn < MAX_NUM_SENSORS; nn++)
 116         if (!strcmp(name, _sensorIds[nn].name))
 117             return _sensorIds[nn].id;
 118
 119     return -1;
 120 }
 121
 122 /* return the current time in nanoseconds */
 123 static int64_t now_ns(void) {
 124     struct timespec  ts;
 125     clock_gettime(CLOCK_MONOTONIC, &ts);
 126     return (int64_t)ts.tv_sec * 1000000000 + ts.tv_nsec;
 127 }
 128
 129 /** SENSORS POLL DEVICE
 130  **
 131  ** This one is used to read sensor data from the hardware.
 132  ** We implement this by simply reading the data from the
 133  ** emulator through the QEMUD channel.
 134  **/
 135
 136 typedef struct SensorDevice {
 137     struct sensors_poll_device_1  device;
 138     sensors_event_t               sensors[MAX_NUM_SENSORS];
 139     uint32_t                      pendingSensors;
 140     int64_t                       timeStart;
 141     int64_t                       timeOffset;
 142     uint32_t                      active_sensors;
 143     int                           fd;
 144     pthread_mutex_t               lock;
 145 } SensorDevice;
 146
 147 /* Grab the file descriptor to the emulator's sensors service pipe.
 148  * This function returns a file descriptor on success, or -errno on
 149  * failure, and assumes the SensorDevice instance's lock is held.
 150  *
 151  * This is needed because set_delay(), poll() and activate() can be called
 152  * from different threads, and poll() is blocking.
 153  *
 154  * Note that the emulator's sensors service creates a new client for each
 155  * connection through qemud_channel_open(), where each client has its own
 156  * delay and set of activated sensors. This precludes calling
 157  * qemud_channel_open() on each request, because a typical emulated system
 158  * will do something like:
 159  *
 160  * 1) On a first thread, de-activate() all sensors first, then call poll(),
 161  *    which results in the thread blocking.
 162  *
 163  * 2) On a second thread, slightly later, call set_delay() then activate()
 164  *    to enable the acceleration sensor.
 165  *
 166  * The system expects this to unblock the first thread which will receive
 167  * new sensor events after the activate() call in 2).
 168  *
 169  * This cannot work if both threads don't use the same connection.
 170  *
 171  * TODO(digit): This protocol is brittle, implement another control channel
 172  *              for set_delay()/activate()/batch() when supporting HAL 1.3
 173  */
 174 static int sensor_device_get_fd_locked(SensorDevice* dev) {
 175     /* Create connection to service on first call */
 176     if (dev->fd < 0) {
 177         dev->fd = qemud_channel_open(SENSORS_SERVICE_NAME);
 178         if (dev->fd < 0) {
 179             int ret = -errno;
 180             E("%s: Could not open connection to service: %s", __FUNCTION__,
 181                 strerror(-ret));
 182             return ret;
 183         }
 184     }
 185     return dev->fd;
 186 }
 187
 188 /* Send a command to the sensors virtual device. |dev| is a device instance and
 189  * |cmd| is a zero-terminated command string. Return 0 on success, or -errno
 190  * on failure. */
 191 static int sensor_device_send_command_locked(SensorDevice* dev,
 192                                              const char* cmd) {
 193     int fd = sensor_device_get_fd_locked(dev);
 194     if (fd < 0) {
 195         return fd;
 196     }
 197
 198     int ret = 0;
 199     if (qemud_channel_send(fd, cmd, strlen(cmd)) < 0) {
 200         ret = -errno;
 201         E("%s(fd=%d): ERROR: %s", __FUNCTION__, fd, strerror(errno));
 202     }
 203     return ret;
 204 }
 205
 206 /* Pick up one pending sensor event. On success, this returns the sensor
 207  * id, and sets |*event| accordingly. On failure, i.e. if there are no
 208  * pending events, return -EINVAL.
 209  *
 210  * Note: The device's lock must be acquired.
 211  */
 212 static int sensor_device_pick_pending_event_locked(SensorDevice* d,
 213                                                    sensors_event_t*  event)
 214 {
 215     uint32_t mask = SUPPORTED_SENSORS & d->pendingSensors;
 216     if (mask) {
 217         uint32_t i = 31 - __builtin_clz(mask);
 218         d->pendingSensors &= ~(1U << i);
 219         *event = d->sensors[i];
 220         event->sensor = i;
 221         event->version = sizeof(*event);
 222
 223         D("%s: %d [%f, %f, %f]", __FUNCTION__,
 224                 i,
 225                 event->data[0],
 226                 event->data[1],
 227                 event->data[2]);
 228         return i;
 229     }
 230     E("No sensor to return!!! pendingSensors=0x%08x", d->pendingSensors);
 231     // we may end-up in a busy loop, slow things down, just in case.
 232     usleep(100000);
 233     return -EINVAL;
 234 }
 235
 236 /* Block until new sensor events are reported by the emulator, or if a
 237  * 'wake' command is received through the service. On succes, return 0
 238  * and updates the |pendingEvents| and |sensors| fields of |dev|.
 239  * On failure, return -errno.
 240  *
 241  * Note: The device lock must be acquired when calling this function, and
 242  *       will still be held on return. However, the function releases the
 243  *       lock temporarily during the blocking wait.
 244  */
 245 static int sensor_device_poll_event_locked(SensorDevice* dev)
 246 {
 247     D("%s: dev=%p", __FUNCTION__, dev);
 248
 249     int fd = sensor_device_get_fd_locked(dev);
 250     if (fd < 0) {
 251         E("%s: Could not get pipe channel: %s", __FUNCTION__, strerror(-fd));
 252         return fd;
 253     }
 254
 255     // Accumulate pending events into |events| and |new_sensors| mask
 256     // until a 'sync' or 'wake' command is received. This also simplifies the
 257     // code a bit.
 258     uint32_t new_sensors = 0U;
 259     sensors_event_t* events = dev->sensors;
 260
 261     int64_t event_time = -1;
 262     int ret = 0;
 263
 264     for (;;) {
 265         /* Release the lock since we're going to block on recv() */
 266         pthread_mutex_unlock(&dev->lock);
 267
 268         /* read the next event */
 269         char buff[256];
 270         int len = qemud_channel_recv(fd, buff, sizeof(buff) - 1U);
 271         /* re-acquire the lock to modify the device state. */
 272         pthread_mutex_lock(&dev->lock);
 273
 274         if (len < 0) {
 275             ret = -errno;
 276             E("%s(fd=%d): Could not receive event data len=%d, errno=%d: %s",
 277               __FUNCTION__, fd, len, errno, strerror(errno));
 278             break;
 279         }
 280         buff[len] = 0;
 281         D("%s(fd=%d): received [%s]", __FUNCTION__, fd, buff);
 282
 283
 284         /* "wake" is sent from the emulator to exit this loop. */
 285         /* TODO(digit): Is it still needed? */
 286         if (!strcmp((const char*)buff, "wake")) {
 287             ret = 0x7FFFFFFF;
 288             break;
 289         }
 290
 291         float params[3];
 292
 293         /* "acceleration:<x>:<y>:<z>" corresponds to an acceleration event */
 294         if (sscanf(buff, "acceleration:%g:%g:%g", params+0, params+1, params+2)
 295                 == 3) {
 296             new_sensors |= SENSORS_ACCELERATION;
 297             events[ID_ACCELERATION].acceleration.x = params[0];
 298             events[ID_ACCELERATION].acceleration.y = params[1];
 299             events[ID_ACCELERATION].acceleration.z = params[2];
 300             events[ID_ACCELERATION].type = SENSOR_TYPE_ACCELEROMETER;
 301             continue;
 302         }
 303
 304         /* "orientation:<azimuth>:<pitch>:<roll>" is sent when orientation
 305          * changes */
 306         if (sscanf(buff, "orientation:%g:%g:%g", params+0, params+1, params+2)
 307                 == 3) {
 308             new_sensors |= SENSORS_ORIENTATION;
 309             events[ID_ORIENTATION].orientation.azimuth = params[0];
 310             events[ID_ORIENTATION].orientation.pitch   = params[1];
 311             events[ID_ORIENTATION].orientation.roll    = params[2];
 312             events[ID_ORIENTATION].orientation.status  =
 313                     SENSOR_STATUS_ACCURACY_HIGH;
 314             events[ID_ORIENTATION].type = SENSOR_TYPE_ORIENTATION;
 315             continue;
 316         }
 317
 318         /* "magnetic:<x>:<y>:<z>" is sent for the params of the magnetic
 319          * field */
 320         if (sscanf(buff, "magnetic:%g:%g:%g", params+0, params+1, params+2)
 321                 == 3) {
 322             new_sensors |= SENSORS_MAGNETIC_FIELD;
 323             events[ID_MAGNETIC_FIELD].magnetic.x = params[0];
 324             events[ID_MAGNETIC_FIELD].magnetic.y = params[1];
 325             events[ID_MAGNETIC_FIELD].magnetic.z = params[2];
 326             events[ID_MAGNETIC_FIELD].magnetic.status =
 327                     SENSOR_STATUS_ACCURACY_HIGH;
 328             events[ID_MAGNETIC_FIELD].type = SENSOR_TYPE_MAGNETIC_FIELD;
 329             continue;
 330         }
 331
 332         /* "temperature:<celsius>" */
 333         if (sscanf(buff, "temperature:%g", params+0) == 1) {
 334             new_sensors |= SENSORS_TEMPERATURE;
 335             events[ID_TEMPERATURE].temperature = params[0];
 336             events[ID_TEMPERATURE].type = SENSOR_TYPE_TEMPERATURE;
 337             continue;
 338         }
 339
 340         /* "proximity:<value>" */
 341         if (sscanf(buff, "proximity:%g", params+0) == 1) {
 342             new_sensors |= SENSORS_PROXIMITY;
 343             events[ID_PROXIMITY].distance = params[0];
 344             events[ID_PROXIMITY].type = SENSOR_TYPE_PROXIMITY;
 345             continue;
 346         }
 347         /* "light:<lux>" */
 348         if (sscanf(buff, "light:%g", params+0) == 1) {
 349             new_sensors |= SENSORS_LIGHT;
 350             events[ID_LIGHT].light = params[0];
 351             events[ID_LIGHT].type = SENSOR_TYPE_LIGHT;
 352             continue;
 353         }
 354
 355         /* "pressure:<hpa>" */
 356         if (sscanf(buff, "pressure:%g", params+0) == 1) {
 357             new_sensors |= SENSORS_PRESSURE;
 358             events[ID_PRESSURE].pressure = params[0];
 359             events[ID_PRESSURE].type = SENSOR_TYPE_PRESSURE;
 360             continue;
 361         }
 362
 363         /* "humidity:<percent>" */
 364         if (sscanf(buff, "humidity:%g", params+0) == 1) {
 365             new_sensors |= SENSORS_HUMIDITY;
 366             events[ID_HUMIDITY].relative_humidity = params[0];
 367             events[ID_HUMIDITY].type = SENSOR_TYPE_RELATIVE_HUMIDITY;
 368             continue;
 369         }
 370
 371         /* "sync:<time>" is sent after a series of sensor events.
 372          * where 'time' is expressed in micro-seconds and corresponds
 373          * to the VM time when the real poll occured.
 374          */
 375         if (sscanf(buff, "sync:%lld", &event_time) == 1) {
 376             if (new_sensors) {
 377                 goto out;
 378             }
 379             D("huh ? sync without any sensor data ?");
 380             continue;
 381         }
 382         D("huh ? unsupported command");
 383     }
 384 out:
 385     if (new_sensors) {
 386         /* update the time of each new sensor event. */
 387         dev->pendingSensors |= new_sensors;
 388         int64_t t = (event_time < 0) ? 0 : event_time * 1000LL;
 389
 390         /* use the time at the first sync: as the base for later
 391          * time values */
 392         if (dev->timeStart == 0) {
 393             dev->timeStart  = now_ns();
 394             dev->timeOffset = dev->timeStart - t;
 395         }
 396         t += dev->timeOffset;
 397
 398         while (new_sensors) {
 399             uint32_t i = 31 - __builtin_clz(new_sensors);
 400             new_sensors &= ~(1U << i);
 401             dev->sensors[i].timestamp = t;
 402         }
 403     }
 404     return ret;
 405 }
 406
 407 /** SENSORS POLL DEVICE FUNCTIONS **/
 408
 409 static int sensor_device_close(struct hw_device_t* dev0)
 410 {
 411     SensorDevice* dev = (void*)dev0;
 412     // Assume that there are no other threads blocked on poll()
 413     if (dev->fd >= 0) {
 414         close(dev->fd);
 415         dev->fd = -1;
 416     }
 417     pthread_mutex_destroy(&dev->lock);
 418     free(dev);
 419     return 0;
 420 }
 421
 422 /* Return an array of sensor data. This function blocks until there is sensor
 423  * related events to report. On success, it will write the events into the
 424  * |data| array, which contains |count| items. The function returns the number
 425  * of events written into the array, which shall never be greater than |count|.
 426  * On error, return -errno code.
 427  *
 428  * Note that according to the sensor HAL [1], it shall never return 0!
 429  *
 430  * [1] http://source.android.com/devices/sensors/hal-interface.html
 431  */
 432 static int sensor_device_poll(struct sensors_poll_device_t *dev0,
 433                               sensors_event_t* data, int count)
 434 {
 435     SensorDevice* dev = (void*)dev0;
 436     D("%s: dev=%p data=%p count=%d ", __FUNCTION__, dev, data, count);
 437
 438     if (count <= 0) {
 439         return -EINVAL;
 440     }
 441
 442     int result = 0;
 443     pthread_mutex_lock(&dev->lock);
 444     if (!dev->pendingSensors) {
 445         /* Block until there are pending events. Note that this releases
 446          * the lock during the blocking call, then re-acquires it before
 447          * returning. */
 448         int ret = sensor_device_poll_event_locked(dev);
 449         if (ret < 0) {
 450             result = ret;
 451             goto out;
 452         }
 453         if (!dev->pendingSensors) {
 454             /* 'wake' event received before any sensor data. */
 455             result = -EIO;
 456             goto out;
 457         }
 458     }
 459     /* Now read as many pending events as needed. */
 460     int i;
 461     for (i = 0; i < count; i++)  {
 462         if (!dev->pendingSensors) {
 463             break;
 464         }
 465         int ret = sensor_device_pick_pending_event_locked(dev, data);
 466         if (ret < 0) {
 467             if (!result) {
 468                 result = ret;
 469             }
 470             break;
 471         }
 472         data++;
 473         result++;
 474     }
 475 out:
 476     pthread_mutex_unlock(&dev->lock);
 477     D("%s: result=%d", __FUNCTION__, result);
 478     return result;
 479 }
 480
 481 static int sensor_device_activate(struct sensors_poll_device_t *dev0,
 482                                   int handle,
 483                                   int enabled)
 484 {
 485     SensorDevice* dev = (void*)dev0;
 486
 487     D("%s: handle=%s (%d) enabled=%d", __FUNCTION__,
 488         _sensorIdToName(handle), handle, enabled);
 489
 490     /* Sanity check */
 491     if (!ID_CHECK(handle)) {
 492         E("%s: bad handle ID", __FUNCTION__);
 493         return -EINVAL;
 494     }
 495
 496     /* Exit early if sensor is already enabled/disabled. */
 497     uint32_t mask = (1U << handle);
 498     uint32_t sensors = enabled ? mask : 0;
 499
 500     pthread_mutex_lock(&dev->lock);
 501
 502     uint32_t active = dev->active_sensors;
 503     uint32_t new_sensors = (active & ~mask) | (sensors & mask);
 504     uint32_t changed = active ^ new_sensors;
 505
 506     int ret = 0;
 507     if (changed) {
 508         /* Send command to the emulator. */
 509         char command[64];
 510         snprintf(command,
 511                  sizeof command,
 512                  "set:%s:%d",
 513                  _sensorIdToName(handle),
 514                  enabled != 0);
 515
 516         ret = sensor_device_send_command_locked(dev, command);
 517         if (ret < 0) {
 518             E("%s: when sending command errno=%d: %s", __FUNCTION__, -ret,
 519               strerror(-ret));
 520         } else {
 521             dev->active_sensors = new_sensors;
 522         }
 523     }
 524     pthread_mutex_unlock(&dev->lock);
 525     return ret;
 526 }
 527
 528 static int sensor_device_set_delay(struct sensors_poll_device_t *dev0,
 529                                    int handle __unused,
 530                                    int64_t ns)
 531 {
 532     SensorDevice* dev = (void*)dev0;
 533
 534     int ms = (int)(ns / 1000000);
 535     D("%s: dev=%p delay-ms=%d", __FUNCTION__, dev, ms);
 536
 537     char command[64];
 538     snprintf(command, sizeof command, "set-delay:%d", ms);
 539
 540     pthread_mutex_lock(&dev->lock);
 541     int ret = sensor_device_send_command_locked(dev, command);
 542     pthread_mutex_unlock(&dev->lock);
 543     if (ret < 0) {
 544         E("%s: Could not send command: %s", __FUNCTION__, strerror(-ret));
 545     }
 546     return ret;
 547 }
 548
 549 /** MODULE REGISTRATION SUPPORT
 550  **
 551  ** This is required so that hardware/libhardware/hardware.c
 552  ** will dlopen() this library appropriately.
 553  **/
 554
 555 /*
 556  * the following is the list of all supported sensors.
 557  * this table is used to build sSensorList declared below
 558  * according to which hardware sensors are reported as
 559  * available from the emulator (see get_sensors_list below)
 560  *
 561  * note: numerical values for maxRange/resolution/power for
 562  *       all sensors but light, pressure and humidity were
 563  *       taken from the reference AK8976A implementation
 564  */
 565 static const struct sensor_t sSensorListInit[] = {
 566         { .name       = "Goldfish 3-axis Accelerometer",
 567           .vendor     = "The Android Open Source Project",
 568           .version    = 1,
 569           .handle     = ID_ACCELERATION,
 570           .type       = SENSOR_TYPE_ACCELEROMETER,
 571           .maxRange   = 2.8f,
 572           .resolution = 1.0f/4032.0f,
 573           .power      = 3.0f,
 574           .reserved   = {}
 575         },
 576
 577         { .name       = "Goldfish 3-axis Magnetic field sensor",
 578           .vendor     = "The Android Open Source Project",
 579           .version    = 1,
 580           .handle     = ID_MAGNETIC_FIELD,
 581           .type       = SENSOR_TYPE_MAGNETIC_FIELD,
 582           .maxRange   = 2000.0f,
 583           .resolution = 1.0f,
 584           .power      = 6.7f,
 585           .reserved   = {}
 586         },
 587
 588         { .name       = "Goldfish Orientation sensor",
 589           .vendor     = "The Android Open Source Project",
 590           .version    = 1,
 591           .handle     = ID_ORIENTATION,
 592           .type       = SENSOR_TYPE_ORIENTATION,
 593           .maxRange   = 360.0f,
 594           .resolution = 1.0f,
 595           .power      = 9.7f,
 596           .reserved   = {}
 597         },
 598
 599         { .name       = "Goldfish Temperature sensor",
 600           .vendor     = "The Android Open Source Project",
 601           .version    = 1,
 602           .handle     = ID_TEMPERATURE,
 603           .type       = SENSOR_TYPE_TEMPERATURE,
 604           .maxRange   = 80.0f,
 605           .resolution = 1.0f,
 606           .power      = 0.0f,
 607           .reserved   = {}
 608         },
 609
 610         { .name       = "Goldfish Proximity sensor",
 611           .vendor     = "The Android Open Source Project",
 612           .version    = 1,
 613           .handle     = ID_PROXIMITY,
 614           .type       = SENSOR_TYPE_PROXIMITY,
 615           .maxRange   = 1.0f,
 616           .resolution = 1.0f,
 617           .power      = 20.0f,
 618           .reserved   = {}
 619         },
 620
 621         { .name       = "Goldfish Light sensor",
 622           .vendor     = "The Android Open Source Project",
 623           .version    = 1,
 624           .handle     = ID_LIGHT,
 625           .type       = SENSOR_TYPE_LIGHT,
 626           .maxRange   = 40000.0f,
 627           .resolution = 1.0f,
 628           .power      = 20.0f,
 629           .reserved   = {}
 630         },
 631
 632         { .name       = "Goldfish Pressure sensor",
 633           .vendor     = "The Android Open Source Project",
 634           .version    = 1,
 635           .handle     = ID_PRESSURE,
 636           .type       = SENSOR_TYPE_PRESSURE,
 637           .maxRange   = 800.0f,
 638           .resolution = 1.0f,
 639           .power      = 20.0f,
 640           .reserved   = {}
 641         },
 642
 643         { .name       = "Goldfish Humidity sensor",
 644           .vendor     = "The Android Open Source Project",
 645           .version    = 1,
 646           .handle     = ID_HUMIDITY,
 647           .type       = SENSOR_TYPE_RELATIVE_HUMIDITY,
 648           .maxRange   = 100.0f,
 649           .resolution = 1.0f,
 650           .power      = 20.0f,
 651           .reserved   = {}
 652         }
 653 };
 654
 655 static struct sensor_t  sSensorList[MAX_NUM_SENSORS];
 656
 657 static int sensors__get_sensors_list(struct sensors_module_t* module __unused,
 658         struct sensor_t const** list)
 659 {
 660     int  fd = qemud_channel_open(SENSORS_SERVICE_NAME);
 661     char buffer[12];
 662     int  mask, nn, count;
 663     int  ret = 0;
 664
 665     if (fd < 0) {
 666         E("%s: no qemud connection", __FUNCTION__);
 667         goto out;
 668     }
 669     ret = qemud_channel_send(fd, "list-sensors", -1);
 670     if (ret < 0) {
 671         E("%s: could not query sensor list: %s", __FUNCTION__,
 672           strerror(errno));
 673         goto out;
 674     }
 675     ret = qemud_channel_recv(fd, buffer, sizeof buffer-1);
 676     if (ret < 0) {
 677         E("%s: could not receive sensor list: %s", __FUNCTION__,
 678           strerror(errno));
 679         goto out;
 680     }
 681     buffer[ret] = 0;
 682
 683     /* the result is a integer used as a mask for available sensors */
 684     mask  = atoi(buffer);
 685     count = 0;
 686     for (nn = 0; nn < MAX_NUM_SENSORS; nn++) {
 687         if (((1 << nn) & mask) == 0)
 688             continue;
 689
 690         sSensorList[count++] = sSensorListInit[nn];
 691     }
 692     D("%s: returned %d sensors (mask=%d)", __FUNCTION__, count, mask);
 693     *list = sSensorList;
 694
 695     ret = count;
 696 out:
 697     if (fd >= 0) {
 698         close(fd);
 699     }
 700     return ret;
 701 }
 702
 703
 704 static int
 705 open_sensors(const struct hw_module_t* module,
 706              const char*               name,
 707              struct hw_device_t*      *device)
 708 {
 709     int  status = -EINVAL;
 710
 711     D("%s: name=%s", __FUNCTION__, name);
 712
 713     if (!strcmp(name, SENSORS_HARDWARE_POLL)) {
 714         SensorDevice *dev = malloc(sizeof(*dev));
 715
 716         memset(dev, 0, sizeof(*dev));
 717
 718         dev->device.common.tag     = HARDWARE_DEVICE_TAG;
 719         dev->device.common.version = SENSORS_DEVICE_API_VERSION_1_0;
 720         dev->device.common.module  = (struct hw_module_t*) module;
 721         dev->device.common.close   = sensor_device_close;
 722         dev->device.poll           = sensor_device_poll;
 723         dev->device.activate       = sensor_device_activate;
 724         dev->device.setDelay       = sensor_device_set_delay;
 725
 726         dev->fd = -1;
 727         pthread_mutex_init(&dev->lock, NULL);
 728
 729         *device = &dev->device.common;
 730         status  = 0;
 731     }
 732     return status;
 733 }
 734
 735
 736 static struct hw_module_methods_t sensors_module_methods = {
 737     .open = open_sensors
 738 };
 739
 740 struct sensors_module_t HAL_MODULE_INFO_SYM = {
 741     .common = {
 742         .tag = HARDWARE_MODULE_TAG,
 743         .version_major = 1,
 744         .version_minor = 0,
 745         .id = SENSORS_HARDWARE_MODULE_ID,
 746         .name = "Goldfish SENSORS Module",
 747         .author = "The Android Open Source Project",
 748         .methods = &sensors_module_methods,
 749     },
 750     .get_sensors_list = sensors__get_sensors_list
 751 };