SensorService.cpp revision 7869e224aaaf717b5ab86df00b60fd5be5a0996c 
1/*
2 * Copyright (C) 2010 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#include <inttypes.h>
18#include <math.h>
19#include <stdint.h>
20#include <sys/types.h>
21
22#include <cutils/properties.h>
23
24#include <utils/SortedVector.h>
25#include <utils/KeyedVector.h>
26#include <utils/threads.h>
27#include <utils/Atomic.h>
28#include <utils/Errors.h>
29#include <utils/RefBase.h>
30#include <utils/Singleton.h>
31#include <utils/String16.h>
32
33#include <binder/BinderService.h>
34#include <binder/IServiceManager.h>
35#include <binder/PermissionCache.h>
36
37#include <gui/ISensorServer.h>
38#include <gui/ISensorEventConnection.h>
39#include <gui/SensorEventQueue.h>
40
41#include <hardware/sensors.h>
42#include <hardware_legacy/power.h>
43
44#include "BatteryService.h"
45#include "CorrectedGyroSensor.h"
46#include "GravitySensor.h"
47#include "LinearAccelerationSensor.h"
48#include "OrientationSensor.h"
49#include "RotationVectorSensor.h"
50#include "SensorFusion.h"
51#include "SensorService.h"
52
53namespace android {
54// ---------------------------------------------------------------------------
55
56/*
57 * Notes:
58 *
59 * - what about a gyro-corrected magnetic-field sensor?
60 * - run mag sensor from time to time to force calibration
61 * - gravity sensor length is wrong (=> drift in linear-acc sensor)
62 *
63 */
64
65const char* SensorService::WAKE_LOCK_NAME = "SensorService";
66
67SensorService::SensorService()
68    : mInitCheck(NO_INIT)
69{
70}
71
72void SensorService::onFirstRef()
73{
74    ALOGD("nuSensorService starting...");
75
76    SensorDevice& dev(SensorDevice::getInstance());
77
78    if (dev.initCheck() == NO_ERROR) {
79        sensor_t const* list;
80        ssize_t count = dev.getSensorList(&list);
81        if (count > 0) {
82            ssize_t orientationIndex = -1;
83            bool hasGyro = false;
84            uint32_t virtualSensorsNeeds =
85                    (1<<SENSOR_TYPE_GRAVITY) |
86                    (1<<SENSOR_TYPE_LINEAR_ACCELERATION) |
87                    (1<<SENSOR_TYPE_ROTATION_VECTOR);
88
89            mLastEventSeen.setCapacity(count);
90            for (ssize_t i=0 ; i<count ; i++) {
91                registerSensor( new HardwareSensor(list[i]) );
92                switch (list[i].type) {
93                    case SENSOR_TYPE_ORIENTATION:
94                        orientationIndex = i;
95                        break;
96                    case SENSOR_TYPE_GYROSCOPE:
97                    case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
98                        hasGyro = true;
99                        break;
100                    case SENSOR_TYPE_GRAVITY:
101                    case SENSOR_TYPE_LINEAR_ACCELERATION:
102                    case SENSOR_TYPE_ROTATION_VECTOR:
103                        virtualSensorsNeeds &= ~(1<<list[i].type);
104                        break;
105                }
106            }
107
108            // it's safe to instantiate the SensorFusion object here
109            // (it wants to be instantiated after h/w sensors have been
110            // registered)
111            const SensorFusion& fusion(SensorFusion::getInstance());
112
113            // build the sensor list returned to users
114            mUserSensorList = mSensorList;
115
116            if (hasGyro) {
117                Sensor aSensor;
118
119                // Add Android virtual sensors if they're not already
120                // available in the HAL
121
122                aSensor = registerVirtualSensor( new RotationVectorSensor() );
123                if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) {
124                    mUserSensorList.add(aSensor);
125                }
126
127                aSensor = registerVirtualSensor( new GravitySensor(list, count) );
128                if (virtualSensorsNeeds & (1<<SENSOR_TYPE_GRAVITY)) {
129                    mUserSensorList.add(aSensor);
130                }
131
132                aSensor = registerVirtualSensor( new LinearAccelerationSensor(list, count) );
133                if (virtualSensorsNeeds & (1<<SENSOR_TYPE_LINEAR_ACCELERATION)) {
134                    mUserSensorList.add(aSensor);
135                }
136
137                aSensor = registerVirtualSensor( new OrientationSensor() );
138                if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) {
139                    // if we are doing our own rotation-vector, also add
140                    // the orientation sensor and remove the HAL provided one.
141                    mUserSensorList.replaceAt(aSensor, orientationIndex);
142                }
143
144                // virtual debugging sensors are not added to mUserSensorList
145                registerVirtualSensor( new CorrectedGyroSensor(list, count) );
146                registerVirtualSensor( new GyroDriftSensor() );
147            }
148
149            // debugging sensor list
150            mUserSensorListDebug = mSensorList;
151
152            mSocketBufferSize = SOCKET_BUFFER_SIZE_NON_BATCHED;
153            FILE *fp = fopen("/proc/sys/net/core/wmem_max", "r");
154            char line[128];
155            if (fp != NULL && fgets(line, sizeof(line), fp) != NULL) {
156                line[sizeof(line) - 1] = '\0';
157                sscanf(line, "%zu", &mSocketBufferSize);
158                if (mSocketBufferSize > MAX_SOCKET_BUFFER_SIZE_BATCHED) {
159                    mSocketBufferSize = MAX_SOCKET_BUFFER_SIZE_BATCHED;
160                }
161            }
162            if (fp) {
163                fclose(fp);
164            }
165
166            mWakeLockAcquired = false;
167            run("SensorService", PRIORITY_URGENT_DISPLAY);
168            mInitCheck = NO_ERROR;
169        }
170    }
171}
172
173Sensor SensorService::registerSensor(SensorInterface* s)
174{
175    sensors_event_t event;
176    memset(&event, 0, sizeof(event));
177
178    const Sensor sensor(s->getSensor());
179    // add to the sensor list (returned to clients)
180    mSensorList.add(sensor);
181    // add to our handle->SensorInterface mapping
182    mSensorMap.add(sensor.getHandle(), s);
183    // create an entry in the mLastEventSeen array
184    mLastEventSeen.add(sensor.getHandle(), event);
185
186    return sensor;
187}
188
189Sensor SensorService::registerVirtualSensor(SensorInterface* s)
190{
191    Sensor sensor = registerSensor(s);
192    mVirtualSensorList.add( s );
193    return sensor;
194}
195
196SensorService::~SensorService()
197{
198    for (size_t i=0 ; i<mSensorMap.size() ; i++)
199        delete mSensorMap.valueAt(i);
200}
201
202static const String16 sDump("android.permission.DUMP");
203
204status_t SensorService::dump(int fd, const Vector<String16>& /*args*/)
205{
206    String8 result;
207    if (!PermissionCache::checkCallingPermission(sDump)) {
208        result.appendFormat("Permission Denial: "
209                "can't dump SensorService from pid=%d, uid=%d\n",
210                IPCThreadState::self()->getCallingPid(),
211                IPCThreadState::self()->getCallingUid());
212    } else {
213        Mutex::Autolock _l(mLock);
214        result.append("Sensor List:\n");
215        for (size_t i=0 ; i<mSensorList.size() ; i++) {
216            const Sensor& s(mSensorList[i]);
217            const sensors_event_t& e(mLastEventSeen.valueFor(s.getHandle()));
218            result.appendFormat(
219                    "%-48s| %-32s| %-48s| 0x%08x | \"%s\"\n\t",
220                    s.getName().string(),
221                    s.getVendor().string(),
222                    s.getStringType().string(),
223                    s.getHandle(),
224                    s.getRequiredPermission().string());
225
226            const int reportingMode = s.getReportingMode();
227            if (reportingMode == AREPORTING_MODE_CONTINUOUS) {
228                result.append("continuous      |");
229            } else if (reportingMode == AREPORTING_MODE_ON_CHANGE) {
230                result.append("on-change       | ");
231            } else if (reportingMode == AREPORTING_MODE_ONE_SHOT) {
232                result.append("one-shot        | ");
233            } else {
234                result.append("special-trigger | ");
235            }
236
237            if (s.getMinDelay() > 0) {
238                result.appendFormat("maxRate=%7.2fHz | ", 1e6f / s.getMinDelay());
239            } else {
240                result.appendFormat("minDelay=%5dus |", s.getMinDelay());
241            }
242
243            if (s.getFifoMaxEventCount() > 0) {
244                result.appendFormat("FifoMax=%d events | ",
245                        s.getFifoMaxEventCount());
246            } else {
247                result.append("no batching support | ");
248            }
249
250            switch (s.getType()) {
251                case SENSOR_TYPE_ROTATION_VECTOR:
252                case SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR:
253                    result.appendFormat(
254                            "last=<%5.1f,%5.1f,%5.1f,%5.1f,%5.1f>\n",
255                            e.data[0], e.data[1], e.data[2], e.data[3], e.data[4]);
256                    break;
257                case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED:
258                case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
259                    result.appendFormat(
260                            "last=<%5.1f,%5.1f,%5.1f,%5.1f,%5.1f,%5.1f>\n",
261                            e.data[0], e.data[1], e.data[2], e.data[3], e.data[4], e.data[5]);
262                    break;
263                case SENSOR_TYPE_GAME_ROTATION_VECTOR:
264                    result.appendFormat(
265                            "last=<%5.1f,%5.1f,%5.1f,%5.1f>\n",
266                            e.data[0], e.data[1], e.data[2], e.data[3]);
267                    break;
268                case SENSOR_TYPE_SIGNIFICANT_MOTION:
269                case SENSOR_TYPE_STEP_DETECTOR:
270                    result.appendFormat( "last=<%f>\n", e.data[0]);
271                    break;
272                case SENSOR_TYPE_STEP_COUNTER:
273                    result.appendFormat( "last=<%" PRIu64 ">\n", e.u64.step_counter);
274                    break;
275                default:
276                    // default to 3 values
277                    result.appendFormat(
278                            "last=<%5.1f,%5.1f,%5.1f>\n",
279                            e.data[0], e.data[1], e.data[2]);
280                    break;
281            }
282        }
283        SensorFusion::getInstance().dump(result);
284        SensorDevice::getInstance().dump(result);
285
286        result.append("Active sensors:\n");
287        for (size_t i=0 ; i<mActiveSensors.size() ; i++) {
288            int handle = mActiveSensors.keyAt(i);
289            result.appendFormat("%s (handle=0x%08x, connections=%zu)\n",
290                    getSensorName(handle).string(),
291                    handle,
292                    mActiveSensors.valueAt(i)->getNumConnections());
293        }
294
295        result.appendFormat("%zu Max Socket Buffer size\n", mSocketBufferSize);
296        result.appendFormat("WakeLock Status: %s \n", mWakeLockAcquired ? "acquired" : "not held");
297        result.appendFormat("%zd active connections\n", mActiveConnections.size());
298
299        for (size_t i=0 ; i < mActiveConnections.size() ; i++) {
300            sp<SensorEventConnection> connection(mActiveConnections[i].promote());
301            if (connection != 0) {
302                result.appendFormat("Connection Number: %zu \n", i);
303                connection->dump(result);
304            }
305        }
306    }
307    write(fd, result.string(), result.size());
308    return NO_ERROR;
309}
310
311void SensorService::cleanupAutoDisabledSensorLocked(const sp<SensorEventConnection>& connection,
312        sensors_event_t const* buffer, const int count) {
313    for (int i=0 ; i<count ; i++) {
314        int handle = buffer[i].sensor;
315        if (connection->hasSensor(handle)) {
316            SensorInterface* sensor = mSensorMap.valueFor(handle);
317            // If this buffer has an event from a one_shot sensor and this connection is registered
318            // for this particular one_shot sensor, try cleaning up the connection.
319            if (sensor != NULL &&
320                sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) {
321                sensor->autoDisable(connection.get(), handle);
322                cleanupWithoutDisableLocked(connection, handle);
323            }
324        }
325    }
326}
327
328bool SensorService::threadLoop()
329{
330    ALOGD("nuSensorService thread starting...");
331
332    // each virtual sensor could generate an event per "real" event, that's why we need
333    // to size numEventMax much smaller than MAX_RECEIVE_BUFFER_EVENT_COUNT.
334    // in practice, this is too aggressive, but guaranteed to be enough.
335    const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT;
336    const size_t numEventMax = minBufferSize / (1 + mVirtualSensorList.size());
337
338    sensors_event_t buffer[minBufferSize];
339    sensors_event_t scratch[minBufferSize];
340    SensorDevice& device(SensorDevice::getInstance());
341    const size_t vcount = mVirtualSensorList.size();
342
343    ssize_t count;
344    const int halVersion = device.getHalDeviceVersion();
345    do {
346        count = device.poll(buffer, numEventMax);
347        if (count<0) {
348            ALOGE("sensor poll failed (%s)", strerror(-count));
349            break;
350        }
351        Mutex::Autolock _l(mLock);
352        // Poll has returned. Hold a wakelock if one of the events is from a wake up sensor. The
353        // rest of this loop is under a critical section protected by mLock. Acquiring a wakeLock,
354        // sending events to clients (incrementing SensorEventConnection::mWakeLockRefCount) should
355        // not be interleaved with decrementing SensorEventConnection::mWakeLockRefCount and
356        // releasing the wakelock.
357        bool bufferHasWakeUpEvent = false;
358        for (int i = 0; i < count; i++) {
359            if (isWakeUpSensorEvent(buffer[i])) {
360                bufferHasWakeUpEvent = true;
361                break;
362            }
363        }
364
365        if (bufferHasWakeUpEvent && !mWakeLockAcquired) {
366            acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME);
367            mWakeLockAcquired = true;
368            ALOGD_IF(DEBUG_CONNECTIONS, "acquired wakelock %s", WAKE_LOCK_NAME);
369        }
370        recordLastValueLocked(buffer, count);
371
372        // handle virtual sensors
373        if (count && vcount) {
374            sensors_event_t const * const event = buffer;
375            const size_t activeVirtualSensorCount = mActiveVirtualSensors.size();
376            if (activeVirtualSensorCount) {
377                size_t k = 0;
378                SensorFusion& fusion(SensorFusion::getInstance());
379                if (fusion.isEnabled()) {
380                    for (size_t i=0 ; i<size_t(count) ; i++) {
381                        fusion.process(event[i]);
382                    }
383                }
384                for (size_t i=0 ; i<size_t(count) && k<minBufferSize ; i++) {
385                    for (size_t j=0 ; j<activeVirtualSensorCount ; j++) {
386                        if (count + k >= minBufferSize) {
387                            ALOGE("buffer too small to hold all events: "
388                                    "count=%zd, k=%zu, size=%zu",
389                                    count, k, minBufferSize);
390                            break;
391                        }
392                        sensors_event_t out;
393                        SensorInterface* si = mActiveVirtualSensors.valueAt(j);
394                        if (si->process(&out, event[i])) {
395                            buffer[count + k] = out;
396                            k++;
397                        }
398                    }
399                }
400                if (k) {
401                    // record the last synthesized values
402                    recordLastValueLocked(&buffer[count], k);
403                    count += k;
404                    // sort the buffer by time-stamps
405                    sortEventBuffer(buffer, count);
406                }
407            }
408        }
409
410        // handle backward compatibility for RotationVector sensor
411        if (halVersion < SENSORS_DEVICE_API_VERSION_1_0) {
412            for (int i = 0; i < count; i++) {
413                if (buffer[i].type == SENSOR_TYPE_ROTATION_VECTOR) {
414                    // All the 4 components of the quaternion should be available
415                    // No heading accuracy. Set it to -1
416                    buffer[i].data[4] = -1;
417                }
418            }
419        }
420
421        // Send our events to clients. Check the state of wake lock for each client and release the
422        // lock if none of the clients need it.
423        bool needsWakeLock = false;
424        for (size_t i=0 ; i < mActiveConnections.size(); i++) {
425            sp<SensorEventConnection> connection(mActiveConnections[i].promote());
426            if (connection != 0) {
427                connection->sendEvents(buffer, count, scratch);
428                needsWakeLock |= connection->needsWakeLock();
429                // Some sensors need to be auto disabled after the trigger
430                cleanupAutoDisabledSensorLocked(connection, buffer, count);
431            }
432        }
433
434        if (mWakeLockAcquired && !needsWakeLock) {
435            release_wake_lock(WAKE_LOCK_NAME);
436            mWakeLockAcquired = false;
437            ALOGD_IF(DEBUG_CONNECTIONS, "released wakelock %s", WAKE_LOCK_NAME);
438        }
439    } while (count >= 0 || Thread::exitPending());
440
441    ALOGW("Exiting SensorService::threadLoop => aborting...");
442    abort();
443    return false;
444}
445
446void SensorService::recordLastValueLocked(
447        const sensors_event_t* buffer, size_t count) {
448    const sensors_event_t* last = NULL;
449    for (size_t i = 0; i < count; i++) {
450        const sensors_event_t* event = &buffer[i];
451        if (event->type != SENSOR_TYPE_META_DATA) {
452            if (last && event->sensor != last->sensor) {
453                mLastEventSeen.editValueFor(last->sensor) = *last;
454            }
455            last = event;
456        }
457    }
458    if (last) {
459        mLastEventSeen.editValueFor(last->sensor) = *last;
460    }
461}
462
463void SensorService::sortEventBuffer(sensors_event_t* buffer, size_t count)
464{
465    struct compar {
466        static int cmp(void const* lhs, void const* rhs) {
467            sensors_event_t const* l = static_cast<sensors_event_t const*>(lhs);
468            sensors_event_t const* r = static_cast<sensors_event_t const*>(rhs);
469            return l->timestamp - r->timestamp;
470        }
471    };
472    qsort(buffer, count, sizeof(sensors_event_t), compar::cmp);
473}
474
475String8 SensorService::getSensorName(int handle) const {
476    size_t count = mUserSensorList.size();
477    for (size_t i=0 ; i<count ; i++) {
478        const Sensor& sensor(mUserSensorList[i]);
479        if (sensor.getHandle() == handle) {
480            return sensor.getName();
481        }
482    }
483    String8 result("unknown");
484    return result;
485}
486
487bool SensorService::isVirtualSensor(int handle) const {
488    SensorInterface* sensor = mSensorMap.valueFor(handle);
489    return sensor->isVirtual();
490}
491
492bool SensorService::isWakeUpSensorEvent(const sensors_event_t& event) const {
493    int handle = event.sensor;
494    if (event.type == SENSOR_TYPE_META_DATA) {
495        handle = event.meta_data.sensor;
496    }
497    SensorInterface* sensor = mSensorMap.valueFor(handle);
498    return sensor != NULL && sensor->getSensor().isWakeUpSensor();
499}
500
501Vector<Sensor> SensorService::getSensorList()
502{
503    char value[PROPERTY_VALUE_MAX];
504    property_get("debug.sensors", value, "0");
505    const Vector<Sensor>& initialSensorList = (atoi(value)) ?
506            mUserSensorListDebug : mUserSensorList;
507    Vector<Sensor> accessibleSensorList;
508    for (size_t i = 0; i < initialSensorList.size(); i++) {
509        Sensor sensor = initialSensorList[i];
510        if (canAccessSensor(sensor)) {
511            accessibleSensorList.add(sensor);
512        } else {
513            String8 infoMessage;
514            infoMessage.appendFormat(
515                    "Skipped sensor %s because it requires permission %s",
516                    sensor.getName().string(),
517                    sensor.getRequiredPermission().string());
518            ALOGI(infoMessage.string());
519        }
520    }
521    return accessibleSensorList;
522}
523
524sp<ISensorEventConnection> SensorService::createSensorEventConnection()
525{
526    uid_t uid = IPCThreadState::self()->getCallingUid();
527    sp<SensorEventConnection> result(new SensorEventConnection(this, uid));
528    return result;
529}
530
531void SensorService::cleanupConnection(SensorEventConnection* c)
532{
533    Mutex::Autolock _l(mLock);
534    const wp<SensorEventConnection> connection(c);
535    size_t size = mActiveSensors.size();
536    ALOGD_IF(DEBUG_CONNECTIONS, "%zu active sensors", size);
537    for (size_t i=0 ; i<size ; ) {
538        int handle = mActiveSensors.keyAt(i);
539        if (c->hasSensor(handle)) {
540            ALOGD_IF(DEBUG_CONNECTIONS, "%zu: disabling handle=0x%08x", i, handle);
541            SensorInterface* sensor = mSensorMap.valueFor( handle );
542            ALOGE_IF(!sensor, "mSensorMap[handle=0x%08x] is null!", handle);
543            if (sensor) {
544                sensor->activate(c, false);
545            }
546        }
547        SensorRecord* rec = mActiveSensors.valueAt(i);
548        ALOGE_IF(!rec, "mActiveSensors[%zu] is null (handle=0x%08x)!", i, handle);
549        ALOGD_IF(DEBUG_CONNECTIONS,
550                "removing connection %p for sensor[%zu].handle=0x%08x",
551                c, i, handle);
552
553        if (rec && rec->removeConnection(connection)) {
554            ALOGD_IF(DEBUG_CONNECTIONS, "... and it was the last connection");
555            mActiveSensors.removeItemsAt(i, 1);
556            mActiveVirtualSensors.removeItem(handle);
557            delete rec;
558            size--;
559        } else {
560            i++;
561        }
562    }
563    mActiveConnections.remove(connection);
564    BatteryService::cleanup(c->getUid());
565    if (c->needsWakeLock()) {
566        checkWakeLockStateLocked();
567    }
568}
569
570Sensor SensorService::getSensorFromHandle(int handle) const {
571    return mSensorMap.valueFor(handle)->getSensor();
572}
573
574status_t SensorService::enable(const sp<SensorEventConnection>& connection,
575        int handle, nsecs_t samplingPeriodNs,  nsecs_t maxBatchReportLatencyNs, int reservedFlags)
576{
577    if (mInitCheck != NO_ERROR)
578        return mInitCheck;
579
580    SensorInterface* sensor = mSensorMap.valueFor(handle);
581    if (sensor == NULL) {
582        return BAD_VALUE;
583    }
584
585    if (!verifyCanAccessSensor(sensor->getSensor(), "Tried enabling")) {
586        return BAD_VALUE;
587    }
588
589    Mutex::Autolock _l(mLock);
590    SensorRecord* rec = mActiveSensors.valueFor(handle);
591    if (rec == 0) {
592        rec = new SensorRecord(connection);
593        mActiveSensors.add(handle, rec);
594        if (sensor->isVirtual()) {
595            mActiveVirtualSensors.add(handle, sensor);
596        }
597    } else {
598        if (rec->addConnection(connection)) {
599            // this sensor is already activated, but we are adding a connection that uses it.
600            // Immediately send down the last known value of the requested sensor if it's not a
601            // "continuous" sensor.
602            if (sensor->getSensor().getReportingMode() == AREPORTING_MODE_ON_CHANGE) {
603                // NOTE: The wake_up flag of this event may get set to
604                // WAKE_UP_SENSOR_EVENT_NEEDS_ACK if this is a wake_up event.
605                sensors_event_t& event(mLastEventSeen.editValueFor(handle));
606                if (event.version == sizeof(sensors_event_t)) {
607                    if (isWakeUpSensorEvent(event) && !mWakeLockAcquired) {
608                        acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME);
609                        mWakeLockAcquired = true;
610                        ALOGD_IF(DEBUG_CONNECTIONS, "acquired wakelock for on_change sensor %s",
611                                                        WAKE_LOCK_NAME);
612                    }
613                    connection->sendEvents(&event, 1, NULL);
614                    if (!connection->needsWakeLock() && mWakeLockAcquired) {
615                        checkWakeLockStateLocked();
616                    }
617                }
618            }
619        }
620    }
621
622    if (connection->addSensor(handle)) {
623        BatteryService::enableSensor(connection->getUid(), handle);
624        // the sensor was added (which means it wasn't already there)
625        // so, see if this connection becomes active
626        if (mActiveConnections.indexOf(connection) < 0) {
627            mActiveConnections.add(connection);
628        }
629    } else {
630        ALOGW("sensor %08x already enabled in connection %p (ignoring)",
631            handle, connection.get());
632    }
633
634    nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs();
635    if (samplingPeriodNs < minDelayNs) {
636        samplingPeriodNs = minDelayNs;
637    }
638
639    ALOGD_IF(DEBUG_CONNECTIONS, "Calling batch handle==%d flags=%d rate=%" PRId64 " timeout== %" PRId64,
640             handle, reservedFlags, samplingPeriodNs, maxBatchReportLatencyNs);
641
642    status_t err = sensor->batch(connection.get(), handle, reservedFlags, samplingPeriodNs,
643                                 maxBatchReportLatencyNs);
644    if (err == NO_ERROR) {
645        connection->setFirstFlushPending(handle, true);
646        status_t err_flush = sensor->flush(connection.get(), handle);
647        // Flush may return error if the sensor is not activated or the underlying h/w sensor does
648        // not support flush.
649        if (err_flush != NO_ERROR) {
650            connection->setFirstFlushPending(handle, false);
651        }
652    }
653
654    if (err == NO_ERROR) {
655        ALOGD_IF(DEBUG_CONNECTIONS, "Calling activate on %d", handle);
656        err = sensor->activate(connection.get(), true);
657    }
658
659    if (err != NO_ERROR) {
660        // batch/activate has failed, reset our state.
661        cleanupWithoutDisableLocked(connection, handle);
662    }
663    return err;
664}
665
666status_t SensorService::disable(const sp<SensorEventConnection>& connection,
667        int handle)
668{
669    if (mInitCheck != NO_ERROR)
670        return mInitCheck;
671
672    Mutex::Autolock _l(mLock);
673    status_t err = cleanupWithoutDisableLocked(connection, handle);
674    if (err == NO_ERROR) {
675        SensorInterface* sensor = mSensorMap.valueFor(handle);
676        err = sensor ? sensor->activate(connection.get(), false) : status_t(BAD_VALUE);
677    }
678    return err;
679}
680
681status_t SensorService::cleanupWithoutDisable(
682        const sp<SensorEventConnection>& connection, int handle) {
683    Mutex::Autolock _l(mLock);
684    return cleanupWithoutDisableLocked(connection, handle);
685}
686
687status_t SensorService::cleanupWithoutDisableLocked(
688        const sp<SensorEventConnection>& connection, int handle) {
689    SensorRecord* rec = mActiveSensors.valueFor(handle);
690    if (rec) {
691        // see if this connection becomes inactive
692        if (connection->removeSensor(handle)) {
693            BatteryService::disableSensor(connection->getUid(), handle);
694        }
695        if (connection->hasAnySensor() == false) {
696            mActiveConnections.remove(connection);
697        }
698        // see if this sensor becomes inactive
699        if (rec->removeConnection(connection)) {
700            mActiveSensors.removeItem(handle);
701            mActiveVirtualSensors.removeItem(handle);
702            delete rec;
703        }
704        return NO_ERROR;
705    }
706    return BAD_VALUE;
707}
708
709status_t SensorService::setEventRate(const sp<SensorEventConnection>& connection,
710        int handle, nsecs_t ns)
711{
712    if (mInitCheck != NO_ERROR)
713        return mInitCheck;
714
715    SensorInterface* sensor = mSensorMap.valueFor(handle);
716    if (!sensor)
717        return BAD_VALUE;
718
719    if (!verifyCanAccessSensor(sensor->getSensor(), "Tried configuring")) {
720        return BAD_VALUE;
721    }
722
723    if (ns < 0)
724        return BAD_VALUE;
725
726    nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs();
727    if (ns < minDelayNs) {
728        ns = minDelayNs;
729    }
730
731    return sensor->setDelay(connection.get(), handle, ns);
732}
733
734status_t SensorService::flushSensor(const sp<SensorEventConnection>& connection,
735                                    int handle) {
736    if (mInitCheck != NO_ERROR) return mInitCheck;
737    SensorInterface* sensor = mSensorMap.valueFor(handle);
738    if (sensor == NULL) {
739        return BAD_VALUE;
740    }
741
742    if (!verifyCanAccessSensor(sensor->getSensor(), "Tried flushing")) {
743        return BAD_VALUE;
744    }
745
746    if (sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) {
747        ALOGE("flush called on a one-shot sensor");
748        return INVALID_OPERATION;
749    }
750    return sensor->flush(connection.get(), handle);
751}
752
753
754bool SensorService::canAccessSensor(const Sensor& sensor) {
755    String16 permissionString(sensor.getRequiredPermission());
756    return permissionString.size() == 0 ||
757            PermissionCache::checkCallingPermission(permissionString);
758}
759
760bool SensorService::verifyCanAccessSensor(const Sensor& sensor, const char* operation) {
761    if (canAccessSensor(sensor)) {
762        return true;
763    } else {
764        String8 errorMessage;
765        errorMessage.appendFormat(
766                "%s a sensor (%s) without holding its required permission: %s",
767                operation,
768                sensor.getName().string(),
769                sensor.getRequiredPermission().string());
770        return false;
771    }
772}
773
774void SensorService::checkWakeLockState() {
775    Mutex::Autolock _l(mLock);
776    checkWakeLockStateLocked();
777}
778
779void SensorService::checkWakeLockStateLocked() {
780    if (!mWakeLockAcquired) {
781        return;
782    }
783    bool releaseLock = true;
784    for (size_t i=0 ; i<mActiveConnections.size() ; i++) {
785        sp<SensorEventConnection> connection(mActiveConnections[i].promote());
786        if (connection != 0) {
787            if (connection->needsWakeLock()) {
788                releaseLock = false;
789                break;
790            }
791        }
792    }
793    if (releaseLock) {
794        ALOGD_IF(DEBUG_CONNECTIONS, "releasing wakelock %s", WAKE_LOCK_NAME);
795        release_wake_lock(WAKE_LOCK_NAME);
796        mWakeLockAcquired = false;
797    }
798}
799// ---------------------------------------------------------------------------
800
801SensorService::SensorRecord::SensorRecord(
802        const sp<SensorEventConnection>& connection)
803{
804    mConnections.add(connection);
805}
806
807bool SensorService::SensorRecord::addConnection(
808        const sp<SensorEventConnection>& connection)
809{
810    if (mConnections.indexOf(connection) < 0) {
811        mConnections.add(connection);
812        return true;
813    }
814    return false;
815}
816
817bool SensorService::SensorRecord::removeConnection(
818        const wp<SensorEventConnection>& connection)
819{
820    ssize_t index = mConnections.indexOf(connection);
821    if (index >= 0) {
822        mConnections.removeItemsAt(index, 1);
823    }
824    return mConnections.size() ? false : true;
825}
826
827// ---------------------------------------------------------------------------
828
829SensorService::SensorEventConnection::SensorEventConnection(
830        const sp<SensorService>& service, uid_t uid)
831    : mService(service), mUid(uid), mWakeLockRefCount(0)
832{
833    const SensorDevice& device(SensorDevice::getInstance());
834    if (device.getHalDeviceVersion() >= SENSORS_DEVICE_API_VERSION_1_1) {
835        // Increase socket buffer size to 1MB for batching capabilities.
836        mChannel = new BitTube(service->mSocketBufferSize);
837    } else {
838        mChannel = new BitTube(SOCKET_BUFFER_SIZE_NON_BATCHED);
839    }
840}
841
842SensorService::SensorEventConnection::~SensorEventConnection()
843{
844    ALOGD_IF(DEBUG_CONNECTIONS, "~SensorEventConnection(%p)", this);
845    mService->cleanupConnection(this);
846}
847
848void SensorService::SensorEventConnection::onFirstRef()
849{
850}
851
852bool SensorService::SensorEventConnection::needsWakeLock() {
853    Mutex::Autolock _l(mConnectionLock);
854    return mWakeLockRefCount > 0;
855}
856
857void SensorService::SensorEventConnection::dump(String8& result) {
858    Mutex::Autolock _l(mConnectionLock);
859    result.appendFormat("%d WakeLockRefCount\n", mWakeLockRefCount);
860    for (size_t i = 0; i < mSensorInfo.size(); ++i) {
861        const FlushInfo& flushInfo = mSensorInfo.valueAt(i);
862        result.appendFormat("\t %s | status: %s | pending flush events %d | uid %d\n",
863                            mService->getSensorName(mSensorInfo.keyAt(i)).string(),
864                            flushInfo.mFirstFlushPending ? "First flush pending" :
865                                                           "active",
866                            flushInfo.mPendingFlushEventsToSend,
867                            mUid);
868    }
869}
870
871bool SensorService::SensorEventConnection::addSensor(int32_t handle) {
872    Mutex::Autolock _l(mConnectionLock);
873    if (!verifyCanAccessSensor(mService->getSensorFromHandle(handle), "Tried adding")) {
874        return false;
875    }
876    if (mSensorInfo.indexOfKey(handle) < 0) {
877        mSensorInfo.add(handle, FlushInfo());
878        return true;
879    }
880    return false;
881}
882
883bool SensorService::SensorEventConnection::removeSensor(int32_t handle) {
884    Mutex::Autolock _l(mConnectionLock);
885    if (mSensorInfo.removeItem(handle) >= 0) {
886        return true;
887    }
888    return false;
889}
890
891bool SensorService::SensorEventConnection::hasSensor(int32_t handle) const {
892    Mutex::Autolock _l(mConnectionLock);
893    return mSensorInfo.indexOfKey(handle) >= 0;
894}
895
896bool SensorService::SensorEventConnection::hasAnySensor() const {
897    Mutex::Autolock _l(mConnectionLock);
898    return mSensorInfo.size() ? true : false;
899}
900
901void SensorService::SensorEventConnection::setFirstFlushPending(int32_t handle,
902                                bool value) {
903    Mutex::Autolock _l(mConnectionLock);
904    ssize_t index = mSensorInfo.indexOfKey(handle);
905    if (index >= 0) {
906        FlushInfo& flushInfo = mSensorInfo.editValueAt(index);
907        flushInfo.mFirstFlushPending = value;
908    }
909}
910
911status_t SensorService::SensorEventConnection::sendEvents(
912        sensors_event_t const* buffer, size_t numEvents,
913        sensors_event_t* scratch)
914{
915    // filter out events not for this connection
916    size_t count = 0;
917    Mutex::Autolock _l(mConnectionLock);
918    if (scratch) {
919        size_t i=0;
920        while (i<numEvents) {
921            int32_t curr = buffer[i].sensor;
922            if (buffer[i].type == SENSOR_TYPE_META_DATA) {
923                ALOGD_IF(DEBUG_CONNECTIONS, "flush complete event sensor==%d ",
924                         buffer[i].meta_data.sensor);
925                // Setting curr to the correct sensor to ensure the sensor events per connection are
926                // filtered correctly. buffer[i].sensor is zero for meta_data events.
927                curr = buffer[i].meta_data.sensor;
928            }
929            ssize_t index = mSensorInfo.indexOfKey(curr);
930            if (index >= 0 && mSensorInfo[index].mFirstFlushPending == true &&
931                buffer[i].type == SENSOR_TYPE_META_DATA) {
932                // This is the first flush before activate is called. Events can now be sent for
933                // this sensor on this connection.
934                ALOGD_IF(DEBUG_CONNECTIONS, "First flush event for sensor==%d ",
935                         buffer[i].meta_data.sensor);
936                mSensorInfo.editValueAt(index).mFirstFlushPending = false;
937            }
938            if (index >= 0 && mSensorInfo[index].mFirstFlushPending == false)  {
939                do {
940                    scratch[count++] = buffer[i++];
941                } while ((i<numEvents) && ((buffer[i].sensor == curr) ||
942                         (buffer[i].type == SENSOR_TYPE_META_DATA  &&
943                          buffer[i].meta_data.sensor == curr)));
944            } else {
945                i++;
946            }
947        }
948    } else {
949        scratch = const_cast<sensors_event_t *>(buffer);
950        count = numEvents;
951    }
952
953    // Send pending flush events (if any) before sending events from the cache.
954    {
955        ASensorEvent flushCompleteEvent;
956        flushCompleteEvent.type = SENSOR_TYPE_META_DATA;
957        flushCompleteEvent.sensor = 0;
958        // Loop through all the sensors for this connection and check if there are any pending
959        // flush complete events to be sent.
960        for (size_t i = 0; i < mSensorInfo.size(); ++i) {
961            FlushInfo& flushInfo = mSensorInfo.editValueAt(i);
962            while (flushInfo.mPendingFlushEventsToSend > 0) {
963                flushCompleteEvent.meta_data.sensor = mSensorInfo.keyAt(i);
964                ssize_t size = SensorEventQueue::write(mChannel, &flushCompleteEvent, 1);
965                if (size < 0) {
966                    // ALOGW("dropping %d events on the floor", count);
967                    countFlushCompleteEventsLocked(scratch, count);
968                    return size;
969                }
970                ALOGD_IF(DEBUG_CONNECTIONS, "sent dropped flush complete event==%d ",
971                         flushCompleteEvent.meta_data.sensor);
972                flushInfo.mPendingFlushEventsToSend--;
973            }
974        }
975    }
976
977    // Early return if there are no events for this connection.
978    if (count == 0) {
979        return status_t(NO_ERROR);
980    }
981
982    int numWakeUpSensorEvents = countWakeUpSensorEventsLocked(scratch, count);
983    // NOTE: ASensorEvent and sensors_event_t are the same type
984    ssize_t size = SensorEventQueue::write(mChannel,
985            reinterpret_cast<ASensorEvent const*>(scratch), count);
986    if (size == -EAGAIN) {
987        // the destination doesn't accept events anymore, it's probably
988        // full. For now, we just drop the events on the floor.
989        // ALOGW("dropping %d events on the floor", count);
990        countFlushCompleteEventsLocked(scratch, count);
991        mWakeLockRefCount -= numWakeUpSensorEvents;
992        return size;
993    }
994    return size < 0 ? status_t(size) : status_t(NO_ERROR);
995}
996
997void SensorService::SensorEventConnection::countFlushCompleteEventsLocked(
998                sensors_event_t* scratch, const int numEventsDropped) {
999    ALOGD_IF(DEBUG_CONNECTIONS, "dropping %d events ", numEventsDropped);
1000    // Count flushComplete events in the events that are about to the dropped. These will be sent
1001    // separately before the next batch of events.
1002    for (int j = 0; j < numEventsDropped; ++j) {
1003        if (scratch[j].type == SENSOR_TYPE_META_DATA) {
1004            FlushInfo& flushInfo = mSensorInfo.editValueFor(scratch[j].meta_data.sensor);
1005            flushInfo.mPendingFlushEventsToSend++;
1006            ALOGD_IF(DEBUG_CONNECTIONS, "increment pendingFlushCount %d",
1007                     flushInfo.mPendingFlushEventsToSend);
1008        }
1009    }
1010    return;
1011}
1012
1013int SensorService::SensorEventConnection::countWakeUpSensorEventsLocked(
1014                       sensors_event_t* scratch, const int count) {
1015    for (int i = 0; i < count; ++i) {
1016        if (mService->isWakeUpSensorEvent(scratch[i])) {
1017            scratch[i].flags |= WAKE_UP_SENSOR_EVENT_NEEDS_ACK;
1018            ++mWakeLockRefCount;
1019            return 1;
1020        }
1021    }
1022    return 0;
1023}
1024
1025sp<BitTube> SensorService::SensorEventConnection::getSensorChannel() const
1026{
1027    return mChannel;
1028}
1029
1030status_t SensorService::SensorEventConnection::enableDisable(
1031        int handle, bool enabled, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs,
1032        int reservedFlags)
1033{
1034    status_t err;
1035    if (enabled) {
1036        err = mService->enable(this, handle, samplingPeriodNs, maxBatchReportLatencyNs,
1037                               reservedFlags);
1038    } else {
1039        err = mService->disable(this, handle);
1040    }
1041    return err;
1042}
1043
1044status_t SensorService::SensorEventConnection::setEventRate(
1045        int handle, nsecs_t samplingPeriodNs)
1046{
1047    return mService->setEventRate(this, handle, samplingPeriodNs);
1048}
1049
1050status_t  SensorService::SensorEventConnection::flush() {
1051    SensorDevice& dev(SensorDevice::getInstance());
1052    const int halVersion = dev.getHalDeviceVersion();
1053    Mutex::Autolock _l(mConnectionLock);
1054    status_t err(NO_ERROR);
1055    // Loop through all sensors for this connection and call flush on each of them.
1056    for (size_t i = 0; i < mSensorInfo.size(); ++i) {
1057        const int handle = mSensorInfo.keyAt(i);
1058        if (halVersion < SENSORS_DEVICE_API_VERSION_1_1 || mService->isVirtualSensor(handle)) {
1059            // For older devices just increment pending flush count which will send a trivial
1060            // flush complete event.
1061            FlushInfo& flushInfo = mSensorInfo.editValueFor(handle);
1062            flushInfo.mPendingFlushEventsToSend++;
1063        } else {
1064            status_t err_flush = mService->flushSensor(this, handle);
1065            if (err_flush != NO_ERROR) {
1066                ALOGE("Flush error handle=%d %s", handle, strerror(-err_flush));
1067            }
1068            err = (err_flush != NO_ERROR) ? err_flush : err;
1069        }
1070    }
1071    return err;
1072}
1073
1074void SensorService::SensorEventConnection::decreaseWakeLockRefCount() {
1075    {
1076        Mutex::Autolock _l(mConnectionLock);
1077        --mWakeLockRefCount;
1078    }
1079    // Release the lock before calling checkWakeLockState which also needs the same connectionLock.
1080    if (mWakeLockRefCount == 0) {
1081        mService->checkWakeLockState();
1082    }
1083}
1084
1085// ---------------------------------------------------------------------------
1086}; // namespace android
1087
1088