SensorService.cpp revision 92dc3fc52cf097bd105460cf377779bdcf146d62 
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            ALOGD("Max socket buffer size %u", mSocketBufferSize);
163            if (fp) {
164                fclose(fp);
165            }
166
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 SurfaceFlinger 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 | 0x%08x | ",
220                    s.getName().string(),
221                    s.getVendor().string(),
222                    s.getHandle());
223
224            if (s.getMinDelay() > 0) {
225                result.appendFormat(
226                    "maxRate=%7.2fHz | ", 1e6f / s.getMinDelay());
227            } else {
228                result.append(s.getMinDelay() == 0
229                        ? "on-demand         | "
230                        : "one-shot          | ");
231            }
232            if (s.getFifoMaxEventCount() > 0) {
233                result.appendFormat("getFifoMaxEventCount=%d events | ", s.getFifoMaxEventCount());
234            } else {
235                result.append("no batching support | ");
236            }
237
238            switch (s.getType()) {
239                case SENSOR_TYPE_ROTATION_VECTOR:
240                case SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR:
241                    result.appendFormat(
242                            "last=<%5.1f,%5.1f,%5.1f,%5.1f,%5.1f>\n",
243                            e.data[0], e.data[1], e.data[2], e.data[3], e.data[4]);
244                    break;
245                case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED:
246                case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
247                    result.appendFormat(
248                            "last=<%5.1f,%5.1f,%5.1f,%5.1f,%5.1f,%5.1f>\n",
249                            e.data[0], e.data[1], e.data[2], e.data[3], e.data[4], e.data[5]);
250                    break;
251                case SENSOR_TYPE_GAME_ROTATION_VECTOR:
252                    result.appendFormat(
253                            "last=<%5.1f,%5.1f,%5.1f,%5.1f>\n",
254                            e.data[0], e.data[1], e.data[2], e.data[3]);
255                    break;
256                case SENSOR_TYPE_SIGNIFICANT_MOTION:
257                case SENSOR_TYPE_STEP_DETECTOR:
258                    result.appendFormat( "last=<%f>\n", e.data[0]);
259                    break;
260                case SENSOR_TYPE_STEP_COUNTER:
261                    result.appendFormat( "last=<%" PRIu64 ">\n", e.u64.step_counter);
262                    break;
263                default:
264                    // default to 3 values
265                    result.appendFormat(
266                            "last=<%5.1f,%5.1f,%5.1f>\n",
267                            e.data[0], e.data[1], e.data[2]);
268                    break;
269            }
270        }
271        SensorFusion::getInstance().dump(result);
272        SensorDevice::getInstance().dump(result);
273
274        result.append("Active sensors:\n");
275        for (size_t i=0 ; i<mActiveSensors.size() ; i++) {
276            int handle = mActiveSensors.keyAt(i);
277            result.appendFormat("%s (handle=0x%08x, connections=%zu)\n",
278                    getSensorName(handle).string(),
279                    handle,
280                    mActiveSensors.valueAt(i)->getNumConnections());
281        }
282
283        result.appendFormat("%zu Max Socket Buffer size\n", mSocketBufferSize);
284        result.appendFormat("%zd active connections\n", mActiveConnections.size());
285
286        for (size_t i=0 ; i < mActiveConnections.size() ; i++) {
287            sp<SensorEventConnection> connection(mActiveConnections[i].promote());
288            if (connection != 0) {
289                result.appendFormat("Connection Number: %zu \n", i);
290                connection->dump(result);
291            }
292        }
293    }
294    write(fd, result.string(), result.size());
295    return NO_ERROR;
296}
297
298void SensorService::cleanupAutoDisabledSensor(const sp<SensorEventConnection>& connection,
299        sensors_event_t const* buffer, const int count) {
300    SensorInterface* sensor;
301    status_t err = NO_ERROR;
302    for (int i=0 ; i<count ; i++) {
303        int handle = buffer[i].sensor;
304        int type = buffer[i].type;
305        if (type == SENSOR_TYPE_SIGNIFICANT_MOTION) {
306            if (connection->hasSensor(handle)) {
307                sensor = mSensorMap.valueFor(handle);
308                if (sensor != NULL) {
309                    sensor->autoDisable(connection.get(), handle);
310                }
311                cleanupWithoutDisable(connection, handle);
312            }
313        }
314    }
315}
316
317bool SensorService::threadLoop()
318{
319    ALOGD("nuSensorService thread starting...");
320
321    // each virtual sensor could generate an event per "real" event, that's why we need
322    // to size numEventMax much smaller than MAX_RECEIVE_BUFFER_EVENT_COUNT.
323    // in practice, this is too aggressive, but guaranteed to be enough.
324    const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT;
325    const size_t numEventMax = minBufferSize / (1 + mVirtualSensorList.size());
326
327    sensors_event_t buffer[minBufferSize];
328    sensors_event_t scratch[minBufferSize];
329    SensorDevice& device(SensorDevice::getInstance());
330    const size_t vcount = mVirtualSensorList.size();
331
332    ssize_t count;
333    bool wakeLockAcquired = false;
334    const int halVersion = device.getHalDeviceVersion();
335    do {
336        count = device.poll(buffer, numEventMax);
337        if (count<0) {
338            ALOGE("sensor poll failed (%s)", strerror(-count));
339            break;
340        }
341
342        // Poll has returned. Hold a wakelock.
343        // Todo(): add a flag to the sensors definitions to indicate
344        // the sensors which can wake up the AP
345        for (int i = 0; i < count; i++) {
346            if (buffer[i].type == SENSOR_TYPE_SIGNIFICANT_MOTION) {
347                 acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME);
348                 wakeLockAcquired = true;
349                 break;
350            }
351        }
352
353        recordLastValue(buffer, count);
354
355        // handle virtual sensors
356        if (count && vcount) {
357            sensors_event_t const * const event = buffer;
358            const DefaultKeyedVector<int, SensorInterface*> virtualSensors(
359                    getActiveVirtualSensors());
360            const size_t activeVirtualSensorCount = virtualSensors.size();
361            if (activeVirtualSensorCount) {
362                size_t k = 0;
363                SensorFusion& fusion(SensorFusion::getInstance());
364                if (fusion.isEnabled()) {
365                    for (size_t i=0 ; i<size_t(count) ; i++) {
366                        fusion.process(event[i]);
367                    }
368                }
369                for (size_t i=0 ; i<size_t(count) && k<minBufferSize ; i++) {
370                    for (size_t j=0 ; j<activeVirtualSensorCount ; j++) {
371                        if (count + k >= minBufferSize) {
372                            ALOGE("buffer too small to hold all events: "
373                                    "count=%u, k=%u, size=%u",
374                                    count, k, minBufferSize);
375                            break;
376                        }
377                        sensors_event_t out;
378                        SensorInterface* si = virtualSensors.valueAt(j);
379                        if (si->process(&out, event[i])) {
380                            buffer[count + k] = out;
381                            k++;
382                        }
383                    }
384                }
385                if (k) {
386                    // record the last synthesized values
387                    recordLastValue(&buffer[count], k);
388                    count += k;
389                    // sort the buffer by time-stamps
390                    sortEventBuffer(buffer, count);
391                }
392            }
393        }
394
395        // handle backward compatibility for RotationVector sensor
396        if (halVersion < SENSORS_DEVICE_API_VERSION_1_0) {
397            for (int i = 0; i < count; i++) {
398                if (buffer[i].type == SENSOR_TYPE_ROTATION_VECTOR) {
399                    // All the 4 components of the quaternion should be available
400                    // No heading accuracy. Set it to -1
401                    buffer[i].data[4] = -1;
402                }
403            }
404        }
405
406        // send our events to clients...
407        const SortedVector< wp<SensorEventConnection> > activeConnections(
408                getActiveConnections());
409        size_t numConnections = activeConnections.size();
410        for (size_t i=0 ; i<numConnections ; i++) {
411            sp<SensorEventConnection> connection(
412                    activeConnections[i].promote());
413            if (connection != 0) {
414                connection->sendEvents(buffer, count, scratch);
415                // Some sensors need to be auto disabled after the trigger
416                cleanupAutoDisabledSensor(connection, buffer, count);
417            }
418        }
419
420        // We have read the data, upper layers should hold the wakelock.
421        if (wakeLockAcquired) release_wake_lock(WAKE_LOCK_NAME);
422    } while (count >= 0 || Thread::exitPending());
423
424    ALOGW("Exiting SensorService::threadLoop => aborting...");
425    abort();
426    return false;
427}
428
429void SensorService::recordLastValue(
430        sensors_event_t const * buffer, size_t count)
431{
432    Mutex::Autolock _l(mLock);
433    // record the last event for each sensor
434    int32_t prev = buffer[0].sensor;
435    for (size_t i=1 ; i<count ; i++) {
436        // record the last event of each sensor type in this buffer
437        int32_t curr = buffer[i].sensor;
438        if (curr != prev) {
439            mLastEventSeen.editValueFor(prev) = buffer[i-1];
440            prev = curr;
441        }
442    }
443    mLastEventSeen.editValueFor(prev) = buffer[count-1];
444}
445
446void SensorService::sortEventBuffer(sensors_event_t* buffer, size_t count)
447{
448    struct compar {
449        static int cmp(void const* lhs, void const* rhs) {
450            sensors_event_t const* l = static_cast<sensors_event_t const*>(lhs);
451            sensors_event_t const* r = static_cast<sensors_event_t const*>(rhs);
452            return l->timestamp - r->timestamp;
453        }
454    };
455    qsort(buffer, count, sizeof(sensors_event_t), compar::cmp);
456}
457
458SortedVector< wp<SensorService::SensorEventConnection> >
459SensorService::getActiveConnections() const
460{
461    Mutex::Autolock _l(mLock);
462    return mActiveConnections;
463}
464
465DefaultKeyedVector<int, SensorInterface*>
466SensorService::getActiveVirtualSensors() const
467{
468    Mutex::Autolock _l(mLock);
469    return mActiveVirtualSensors;
470}
471
472String8 SensorService::getSensorName(int handle) const {
473    size_t count = mUserSensorList.size();
474    for (size_t i=0 ; i<count ; i++) {
475        const Sensor& sensor(mUserSensorList[i]);
476        if (sensor.getHandle() == handle) {
477            return sensor.getName();
478        }
479    }
480    String8 result("unknown");
481    return result;
482}
483
484bool SensorService::isVirtualSensor(int handle) const {
485    SensorInterface* sensor = mSensorMap.valueFor(handle);
486    return sensor->isVirtual();
487}
488
489Vector<Sensor> SensorService::getSensorList()
490{
491    char value[PROPERTY_VALUE_MAX];
492    property_get("debug.sensors", value, "0");
493    if (atoi(value)) {
494        return mUserSensorListDebug;
495    }
496    return mUserSensorList;
497}
498
499sp<ISensorEventConnection> SensorService::createSensorEventConnection()
500{
501    uid_t uid = IPCThreadState::self()->getCallingUid();
502    sp<SensorEventConnection> result(new SensorEventConnection(this, uid));
503    return result;
504}
505
506void SensorService::cleanupConnection(SensorEventConnection* c)
507{
508    Mutex::Autolock _l(mLock);
509    const wp<SensorEventConnection> connection(c);
510    size_t size = mActiveSensors.size();
511    ALOGD_IF(DEBUG_CONNECTIONS, "%d active sensors", size);
512    for (size_t i=0 ; i<size ; ) {
513        int handle = mActiveSensors.keyAt(i);
514        if (c->hasSensor(handle)) {
515            ALOGD_IF(DEBUG_CONNECTIONS, "%i: disabling handle=0x%08x", i, handle);
516            SensorInterface* sensor = mSensorMap.valueFor( handle );
517            ALOGE_IF(!sensor, "mSensorMap[handle=0x%08x] is null!", handle);
518            if (sensor) {
519                sensor->activate(c, false);
520            }
521        }
522        SensorRecord* rec = mActiveSensors.valueAt(i);
523        ALOGE_IF(!rec, "mActiveSensors[%d] is null (handle=0x%08x)!", i, handle);
524        ALOGD_IF(DEBUG_CONNECTIONS,
525                "removing connection %p for sensor[%d].handle=0x%08x",
526                c, i, handle);
527
528        if (rec && rec->removeConnection(connection)) {
529            ALOGD_IF(DEBUG_CONNECTIONS, "... and it was the last connection");
530            mActiveSensors.removeItemsAt(i, 1);
531            mActiveVirtualSensors.removeItem(handle);
532            delete rec;
533            size--;
534        } else {
535            i++;
536        }
537    }
538    mActiveConnections.remove(connection);
539    BatteryService::cleanup(c->getUid());
540}
541
542status_t SensorService::enable(const sp<SensorEventConnection>& connection,
543        int handle, nsecs_t samplingPeriodNs,  nsecs_t maxBatchReportLatencyNs, int reservedFlags)
544{
545    if (mInitCheck != NO_ERROR)
546        return mInitCheck;
547
548    SensorInterface* sensor = mSensorMap.valueFor(handle);
549    if (sensor == NULL) {
550        return BAD_VALUE;
551    }
552    Mutex::Autolock _l(mLock);
553    SensorRecord* rec = mActiveSensors.valueFor(handle);
554    if (rec == 0) {
555        rec = new SensorRecord(connection);
556        mActiveSensors.add(handle, rec);
557        if (sensor->isVirtual()) {
558            mActiveVirtualSensors.add(handle, sensor);
559        }
560    } else {
561        if (rec->addConnection(connection)) {
562            // this sensor is already activated, but we are adding a
563            // connection that uses it. Immediately send down the last
564            // known value of the requested sensor if it's not a
565            // "continuous" sensor.
566            if (sensor->getSensor().getMinDelay() == 0) {
567                sensors_event_t scratch;
568                sensors_event_t& event(mLastEventSeen.editValueFor(handle));
569                if (event.version == sizeof(sensors_event_t)) {
570                    connection->sendEvents(&event, 1);
571                }
572            }
573        }
574    }
575
576    if (connection->addSensor(handle)) {
577        BatteryService::enableSensor(connection->getUid(), handle);
578        // the sensor was added (which means it wasn't already there)
579        // so, see if this connection becomes active
580        if (mActiveConnections.indexOf(connection) < 0) {
581            mActiveConnections.add(connection);
582        }
583    } else {
584        ALOGW("sensor %08x already enabled in connection %p (ignoring)",
585            handle, connection.get());
586    }
587
588    nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs();
589    if (samplingPeriodNs < minDelayNs) {
590        samplingPeriodNs = minDelayNs;
591    }
592
593    ALOGD_IF(DEBUG_CONNECTIONS, "Calling batch handle==%d flags=%d rate=%lld timeout== %lld",
594             handle, reservedFlags, samplingPeriodNs, maxBatchReportLatencyNs);
595
596    status_t err = sensor->batch(connection.get(), handle, reservedFlags, samplingPeriodNs,
597                                 maxBatchReportLatencyNs);
598    if (err == NO_ERROR) {
599        connection->setFirstFlushPending(handle, true);
600        status_t err_flush = sensor->flush(connection.get(), handle);
601        // Flush may return error if the sensor is not activated or the underlying h/w sensor does
602        // not support flush.
603        if (err_flush != NO_ERROR) {
604            connection->setFirstFlushPending(handle, false);
605        }
606    }
607
608    if (err == NO_ERROR) {
609        ALOGD_IF(DEBUG_CONNECTIONS, "Calling activate on %d", handle);
610        err = sensor->activate(connection.get(), true);
611    }
612
613    if (err != NO_ERROR) {
614        // batch/activate has failed, reset our state.
615        cleanupWithoutDisableLocked(connection, handle);
616    }
617    return err;
618}
619
620status_t SensorService::disable(const sp<SensorEventConnection>& connection,
621        int handle)
622{
623    if (mInitCheck != NO_ERROR)
624        return mInitCheck;
625
626    Mutex::Autolock _l(mLock);
627    status_t err = cleanupWithoutDisableLocked(connection, handle);
628    if (err == NO_ERROR) {
629        SensorInterface* sensor = mSensorMap.valueFor(handle);
630        err = sensor ? sensor->activate(connection.get(), false) : status_t(BAD_VALUE);
631    }
632    return err;
633}
634
635status_t SensorService::cleanupWithoutDisable(
636        const sp<SensorEventConnection>& connection, int handle) {
637    Mutex::Autolock _l(mLock);
638    return cleanupWithoutDisableLocked(connection, handle);
639}
640
641status_t SensorService::cleanupWithoutDisableLocked(
642        const sp<SensorEventConnection>& connection, int handle) {
643    SensorRecord* rec = mActiveSensors.valueFor(handle);
644    if (rec) {
645        // see if this connection becomes inactive
646        if (connection->removeSensor(handle)) {
647            BatteryService::disableSensor(connection->getUid(), handle);
648        }
649        if (connection->hasAnySensor() == false) {
650            mActiveConnections.remove(connection);
651        }
652        // see if this sensor becomes inactive
653        if (rec->removeConnection(connection)) {
654            mActiveSensors.removeItem(handle);
655            mActiveVirtualSensors.removeItem(handle);
656            delete rec;
657        }
658        return NO_ERROR;
659    }
660    return BAD_VALUE;
661}
662
663status_t SensorService::setEventRate(const sp<SensorEventConnection>& connection,
664        int handle, nsecs_t ns)
665{
666    if (mInitCheck != NO_ERROR)
667        return mInitCheck;
668
669    SensorInterface* sensor = mSensorMap.valueFor(handle);
670    if (!sensor)
671        return BAD_VALUE;
672
673    if (ns < 0)
674        return BAD_VALUE;
675
676    nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs();
677    if (ns < minDelayNs) {
678        ns = minDelayNs;
679    }
680
681    return sensor->setDelay(connection.get(), handle, ns);
682}
683
684status_t SensorService::flushSensor(const sp<SensorEventConnection>& connection,
685                                    int handle) {
686  if (mInitCheck != NO_ERROR) return mInitCheck;
687  SensorInterface* sensor = mSensorMap.valueFor(handle);
688  if (sensor == NULL) {
689      return BAD_VALUE;
690  }
691  if (sensor->getSensor().getType() == SENSOR_TYPE_SIGNIFICANT_MOTION) {
692      ALOGE("flush called on Significant Motion sensor");
693      return INVALID_OPERATION;
694  }
695  return sensor->flush(connection.get(), handle);
696}
697// ---------------------------------------------------------------------------
698
699SensorService::SensorRecord::SensorRecord(
700        const sp<SensorEventConnection>& connection)
701{
702    mConnections.add(connection);
703}
704
705bool SensorService::SensorRecord::addConnection(
706        const sp<SensorEventConnection>& connection)
707{
708    if (mConnections.indexOf(connection) < 0) {
709        mConnections.add(connection);
710        return true;
711    }
712    return false;
713}
714
715bool SensorService::SensorRecord::removeConnection(
716        const wp<SensorEventConnection>& connection)
717{
718    ssize_t index = mConnections.indexOf(connection);
719    if (index >= 0) {
720        mConnections.removeItemsAt(index, 1);
721    }
722    return mConnections.size() ? false : true;
723}
724
725// ---------------------------------------------------------------------------
726
727SensorService::SensorEventConnection::SensorEventConnection(
728        const sp<SensorService>& service, uid_t uid)
729    : mService(service), mUid(uid)
730{
731    const SensorDevice& device(SensorDevice::getInstance());
732    if (device.getHalDeviceVersion() >= SENSORS_DEVICE_API_VERSION_1_1) {
733        // Increase socket buffer size to 1MB for batching capabilities.
734        mChannel = new BitTube(service->mSocketBufferSize);
735    } else {
736        mChannel = new BitTube(SOCKET_BUFFER_SIZE_NON_BATCHED);
737    }
738}
739
740SensorService::SensorEventConnection::~SensorEventConnection()
741{
742    ALOGD_IF(DEBUG_CONNECTIONS, "~SensorEventConnection(%p)", this);
743    mService->cleanupConnection(this);
744}
745
746void SensorService::SensorEventConnection::onFirstRef()
747{
748}
749
750void SensorService::SensorEventConnection::dump(String8& result) {
751    Mutex::Autolock _l(mConnectionLock);
752    for (size_t i = 0; i < mSensorInfo.size(); ++i) {
753        const FlushInfo& flushInfo = mSensorInfo.valueAt(i);
754        result.appendFormat("\t %s | status: %s | pending flush events %d\n",
755                            mService->getSensorName(mSensorInfo.keyAt(i)).string(),
756                            flushInfo.mFirstFlushPending ? "First flush pending" :
757                                                           "active",
758                            flushInfo.mPendingFlushEventsToSend);
759    }
760}
761
762bool SensorService::SensorEventConnection::addSensor(int32_t handle) {
763    Mutex::Autolock _l(mConnectionLock);
764    if (mSensorInfo.indexOfKey(handle) < 0) {
765        mSensorInfo.add(handle, FlushInfo());
766        return true;
767    }
768    return false;
769}
770
771bool SensorService::SensorEventConnection::removeSensor(int32_t handle) {
772    Mutex::Autolock _l(mConnectionLock);
773    if (mSensorInfo.removeItem(handle) >= 0) {
774        return true;
775    }
776    return false;
777}
778
779bool SensorService::SensorEventConnection::hasSensor(int32_t handle) const {
780    Mutex::Autolock _l(mConnectionLock);
781    return mSensorInfo.indexOfKey(handle) >= 0;
782}
783
784bool SensorService::SensorEventConnection::hasAnySensor() const {
785    Mutex::Autolock _l(mConnectionLock);
786    return mSensorInfo.size() ? true : false;
787}
788
789void SensorService::SensorEventConnection::setFirstFlushPending(int32_t handle,
790                                bool value) {
791    Mutex::Autolock _l(mConnectionLock);
792    ssize_t index = mSensorInfo.indexOfKey(handle);
793    if (index >= 0) {
794        FlushInfo& flushInfo = mSensorInfo.editValueAt(index);
795        flushInfo.mFirstFlushPending = value;
796    }
797}
798
799status_t SensorService::SensorEventConnection::sendEvents(
800        sensors_event_t const* buffer, size_t numEvents,
801        sensors_event_t* scratch)
802{
803    // filter out events not for this connection
804    size_t count = 0;
805
806    if (scratch) {
807        Mutex::Autolock _l(mConnectionLock);
808        size_t i=0;
809        while (i<numEvents) {
810            int32_t curr = buffer[i].sensor;
811            if (buffer[i].type == SENSOR_TYPE_META_DATA) {
812                ALOGD_IF(DEBUG_CONNECTIONS, "flush complete event sensor==%d ",
813                         buffer[i].meta_data.sensor);
814                // Setting curr to the correct sensor to ensure the sensor events per connection are
815                // filtered correctly. buffer[i].sensor is zero for meta_data events.
816                curr = buffer[i].meta_data.sensor;
817            }
818            ssize_t index = mSensorInfo.indexOfKey(curr);
819            if (index >= 0 && mSensorInfo[index].mFirstFlushPending == true &&
820                buffer[i].type == SENSOR_TYPE_META_DATA) {
821                // This is the first flush before activate is called. Events can now be sent for
822                // this sensor on this connection.
823                ALOGD_IF(DEBUG_CONNECTIONS, "First flush event for sensor==%d ",
824                         buffer[i].meta_data.sensor);
825                mSensorInfo.editValueAt(index).mFirstFlushPending = false;
826            }
827            if (index >= 0 && mSensorInfo[index].mFirstFlushPending == false)  {
828                do {
829                    scratch[count++] = buffer[i++];
830                } while ((i<numEvents) && ((buffer[i].sensor == curr) ||
831                         (buffer[i].type == SENSOR_TYPE_META_DATA  &&
832                          buffer[i].meta_data.sensor == curr)));
833            } else {
834                i++;
835            }
836        }
837    } else {
838        scratch = const_cast<sensors_event_t *>(buffer);
839        count = numEvents;
840    }
841
842    // Send pending flush events (if any) before sending events from the cache.
843    {
844        ASensorEvent flushCompleteEvent;
845        flushCompleteEvent.type = SENSOR_TYPE_META_DATA;
846        flushCompleteEvent.sensor = 0;
847        Mutex::Autolock _l(mConnectionLock);
848        // Loop through all the sensors for this connection and check if there are any pending
849        // flush complete events to be sent.
850        for (size_t i = 0; i < mSensorInfo.size(); ++i) {
851            FlushInfo& flushInfo = mSensorInfo.editValueAt(i);
852            while (flushInfo.mPendingFlushEventsToSend > 0) {
853                flushCompleteEvent.meta_data.sensor = mSensorInfo.keyAt(i);
854                ssize_t size = SensorEventQueue::write(mChannel, &flushCompleteEvent, 1);
855                if (size < 0) {
856                    // ALOGW("dropping %d events on the floor", count);
857                    countFlushCompleteEventsLocked(scratch, count);
858                    return size;
859                }
860                ALOGD_IF(DEBUG_CONNECTIONS, "sent dropped flush complete event==%d ",
861                         flushCompleteEvent.meta_data.sensor);
862                flushInfo.mPendingFlushEventsToSend--;
863            }
864        }
865    }
866
867    // Early return if there are no events for this connection.
868    if (count == 0) {
869        return status_t(NO_ERROR);
870    }
871
872    // NOTE: ASensorEvent and sensors_event_t are the same type
873    ssize_t size = SensorEventQueue::write(mChannel,
874            reinterpret_cast<ASensorEvent const*>(scratch), count);
875    if (size == -EAGAIN) {
876        // the destination doesn't accept events anymore, it's probably
877        // full. For now, we just drop the events on the floor.
878        // ALOGW("dropping %d events on the floor", count);
879        Mutex::Autolock _l(mConnectionLock);
880        countFlushCompleteEventsLocked(scratch, count);
881        return size;
882    }
883
884    return size < 0 ? status_t(size) : status_t(NO_ERROR);
885}
886
887void SensorService::SensorEventConnection::countFlushCompleteEventsLocked(
888                sensors_event_t* scratch, const int numEventsDropped) {
889    ALOGD_IF(DEBUG_CONNECTIONS, "dropping %d events ", numEventsDropped);
890    // Count flushComplete events in the events that are about to the dropped. These will be sent
891    // separately before the next batch of events.
892    for (int j = 0; j < numEventsDropped; ++j) {
893        if (scratch[j].type == SENSOR_TYPE_META_DATA) {
894            FlushInfo& flushInfo = mSensorInfo.editValueFor(scratch[j].meta_data.sensor);
895            flushInfo.mPendingFlushEventsToSend++;
896            ALOGD_IF(DEBUG_CONNECTIONS, "increment pendingFlushCount %d",
897                     flushInfo.mPendingFlushEventsToSend);
898        }
899    }
900    return;
901}
902
903sp<BitTube> SensorService::SensorEventConnection::getSensorChannel() const
904{
905    return mChannel;
906}
907
908status_t SensorService::SensorEventConnection::enableDisable(
909        int handle, bool enabled, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs,
910        int reservedFlags)
911{
912    status_t err;
913    if (enabled) {
914        err = mService->enable(this, handle, samplingPeriodNs, maxBatchReportLatencyNs,
915                               reservedFlags);
916    } else {
917        err = mService->disable(this, handle);
918    }
919    return err;
920}
921
922status_t SensorService::SensorEventConnection::setEventRate(
923        int handle, nsecs_t samplingPeriodNs)
924{
925    return mService->setEventRate(this, handle, samplingPeriodNs);
926}
927
928status_t  SensorService::SensorEventConnection::flush() {
929    SensorDevice& dev(SensorDevice::getInstance());
930    const int halVersion = dev.getHalDeviceVersion();
931    Mutex::Autolock _l(mConnectionLock);
932    status_t err(NO_ERROR);
933    // Loop through all sensors for this connection and call flush on each of them.
934    for (size_t i = 0; i < mSensorInfo.size(); ++i) {
935        const int handle = mSensorInfo.keyAt(i);
936        if (halVersion < SENSORS_DEVICE_API_VERSION_1_1 || mService->isVirtualSensor(handle)) {
937            // For older devices just increment pending flush count which will send a trivial
938            // flush complete event.
939            FlushInfo& flushInfo = mSensorInfo.editValueFor(handle);
940            flushInfo.mPendingFlushEventsToSend++;
941        } else {
942            status_t err_flush = mService->flushSensor(this, handle);
943            if (err_flush != NO_ERROR) {
944                ALOGE("Flush error handle=%d %s", handle, strerror(-err_flush));
945            }
946            err = (err_flush != NO_ERROR) ? err_flush : err;
947        }
948    }
949    return err;
950}
951
952// ---------------------------------------------------------------------------
953}; // namespace android
954
955