SensorService.cpp revision e74baf6ca7d57375f38540b6b7ac5e4af019951b 
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#include <sys/socket.h>
22
23#include <cutils/properties.h>
24
25#include <utils/SortedVector.h>
26#include <utils/KeyedVector.h>
27#include <utils/threads.h>
28#include <utils/Atomic.h>
29#include <utils/Errors.h>
30#include <utils/RefBase.h>
31#include <utils/Singleton.h>
32#include <utils/String16.h>
33
34#include <binder/BinderService.h>
35#include <binder/IServiceManager.h>
36#include <binder/PermissionCache.h>
37
38#include <gui/ISensorServer.h>
39#include <gui/ISensorEventConnection.h>
40#include <gui/SensorEventQueue.h>
41
42#include <hardware/sensors.h>
43#include <hardware_legacy/power.h>
44
45#include "BatteryService.h"
46#include "CorrectedGyroSensor.h"
47#include "GravitySensor.h"
48#include "LinearAccelerationSensor.h"
49#include "OrientationSensor.h"
50#include "RotationVectorSensor.h"
51#include "SensorFusion.h"
52#include "SensorService.h"
53
54namespace android {
55// ---------------------------------------------------------------------------
56
57/*
58 * Notes:
59 *
60 * - what about a gyro-corrected magnetic-field sensor?
61 * - run mag sensor from time to time to force calibration
62 * - gravity sensor length is wrong (=> drift in linear-acc sensor)
63 *
64 */
65
66const char* SensorService::WAKE_LOCK_NAME = "SensorService";
67
68SensorService::SensorService()
69    : mInitCheck(NO_INIT)
70{
71}
72
73void SensorService::onFirstRef()
74{
75    ALOGD("nuSensorService starting...");
76
77    SensorDevice& dev(SensorDevice::getInstance());
78
79    if (dev.initCheck() == NO_ERROR) {
80        sensor_t const* list;
81        ssize_t count = dev.getSensorList(&list);
82        if (count > 0) {
83            ssize_t orientationIndex = -1;
84            bool hasGyro = false;
85            uint32_t virtualSensorsNeeds =
86                    (1<<SENSOR_TYPE_GRAVITY) |
87                    (1<<SENSOR_TYPE_LINEAR_ACCELERATION) |
88                    (1<<SENSOR_TYPE_ROTATION_VECTOR);
89
90            mLastEventSeen.setCapacity(count);
91            for (ssize_t i=0 ; i<count ; i++) {
92                registerSensor( new HardwareSensor(list[i]) );
93                switch (list[i].type) {
94                    case SENSOR_TYPE_ORIENTATION:
95                        orientationIndex = i;
96                        break;
97                    case SENSOR_TYPE_GYROSCOPE:
98                    case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
99                        hasGyro = true;
100                        break;
101                    case SENSOR_TYPE_GRAVITY:
102                    case SENSOR_TYPE_LINEAR_ACCELERATION:
103                    case SENSOR_TYPE_ROTATION_VECTOR:
104                        virtualSensorsNeeds &= ~(1<<list[i].type);
105                        break;
106                }
107            }
108
109            // it's safe to instantiate the SensorFusion object here
110            // (it wants to be instantiated after h/w sensors have been
111            // registered)
112            const SensorFusion& fusion(SensorFusion::getInstance());
113
114            // build the sensor list returned to users
115            mUserSensorList = mSensorList;
116
117            if (hasGyro) {
118                Sensor aSensor;
119
120                // Add Android virtual sensors if they're not already
121                // available in the HAL
122
123                aSensor = registerVirtualSensor( new RotationVectorSensor() );
124                if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) {
125                    mUserSensorList.add(aSensor);
126                }
127
128                aSensor = registerVirtualSensor( new GravitySensor(list, count) );
129                if (virtualSensorsNeeds & (1<<SENSOR_TYPE_GRAVITY)) {
130                    mUserSensorList.add(aSensor);
131                }
132
133                aSensor = registerVirtualSensor( new LinearAccelerationSensor(list, count) );
134                if (virtualSensorsNeeds & (1<<SENSOR_TYPE_LINEAR_ACCELERATION)) {
135                    mUserSensorList.add(aSensor);
136                }
137
138                aSensor = registerVirtualSensor( new OrientationSensor() );
139                if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) {
140                    // if we are doing our own rotation-vector, also add
141                    // the orientation sensor and remove the HAL provided one.
142                    mUserSensorList.replaceAt(aSensor, orientationIndex);
143                }
144
145                // virtual debugging sensors are not added to mUserSensorList
146                registerVirtualSensor( new CorrectedGyroSensor(list, count) );
147                registerVirtualSensor( new GyroDriftSensor() );
148            }
149
150            // debugging sensor list
151            mUserSensorListDebug = mSensorList;
152
153            mSocketBufferSize = SOCKET_BUFFER_SIZE_NON_BATCHED;
154            FILE *fp = fopen("/proc/sys/net/core/wmem_max", "r");
155            char line[128];
156            if (fp != NULL && fgets(line, sizeof(line), fp) != NULL) {
157                line[sizeof(line) - 1] = '\0';
158                sscanf(line, "%zu", &mSocketBufferSize);
159                if (mSocketBufferSize > MAX_SOCKET_BUFFER_SIZE_BATCHED) {
160                    mSocketBufferSize = MAX_SOCKET_BUFFER_SIZE_BATCHED;
161                }
162            }
163            if (fp) {
164                fclose(fp);
165            }
166
167            mWakeLockAcquired = false;
168            run("SensorService", PRIORITY_URGENT_DISPLAY);
169            mLooper = new Looper(false);
170            mInitCheck = NO_ERROR;
171        }
172    }
173}
174
175Sensor SensorService::registerSensor(SensorInterface* s)
176{
177    sensors_event_t event;
178    memset(&event, 0, sizeof(event));
179
180    const Sensor sensor(s->getSensor());
181    // add to the sensor list (returned to clients)
182    mSensorList.add(sensor);
183    // add to our handle->SensorInterface mapping
184    mSensorMap.add(sensor.getHandle(), s);
185    // create an entry in the mLastEventSeen array
186    mLastEventSeen.add(sensor.getHandle(), event);
187
188    return sensor;
189}
190
191Sensor SensorService::registerVirtualSensor(SensorInterface* s)
192{
193    Sensor sensor = registerSensor(s);
194    mVirtualSensorList.add( s );
195    return sensor;
196}
197
198SensorService::~SensorService()
199{
200    for (size_t i=0 ; i<mSensorMap.size() ; i++)
201        delete mSensorMap.valueAt(i);
202}
203
204static const String16 sDump("android.permission.DUMP");
205
206status_t SensorService::dump(int fd, const Vector<String16>& /*args*/)
207{
208    String8 result;
209    if (!PermissionCache::checkCallingPermission(sDump)) {
210        result.appendFormat("Permission Denial: "
211                "can't dump SensorService from pid=%d, uid=%d\n",
212                IPCThreadState::self()->getCallingPid(),
213                IPCThreadState::self()->getCallingUid());
214    } else {
215        Mutex::Autolock _l(mLock);
216        result.append("Sensor List:\n");
217        for (size_t i=0 ; i<mSensorList.size() ; i++) {
218            const Sensor& s(mSensorList[i]);
219            const sensors_event_t& e(mLastEventSeen.valueFor(s.getHandle()));
220            result.appendFormat(
221                    "%-15s| %-10s| %-20s| 0x%08x | \"%s\" | type=%d |",
222                    s.getName().string(),
223                    s.getVendor().string(),
224                    s.getStringType().string(),
225                    s.getHandle(),
226                    s.getRequiredPermission().string(),
227                    s.getType());
228
229            const int reportingMode = s.getReportingMode();
230            if (reportingMode == AREPORTING_MODE_CONTINUOUS) {
231                result.append(" continuous | ");
232            } else if (reportingMode == AREPORTING_MODE_ON_CHANGE) {
233                result.append(" on-change | ");
234            } else if (reportingMode == AREPORTING_MODE_ONE_SHOT) {
235                result.append(" one-shot | ");
236            } else {
237                result.append(" special-trigger | ");
238            }
239
240            if (s.getMaxDelay() > 0) {
241                result.appendFormat("minRate=%.2fHz | ", 1e6f / s.getMaxDelay());
242            } else {
243                result.appendFormat("maxDelay=%dus |", s.getMaxDelay());
244            }
245
246            if (s.getMinDelay() > 0) {
247                result.appendFormat("maxRate=%.2fHz | ", 1e6f / s.getMinDelay());
248            } else {
249                result.appendFormat("minDelay=%dus |", s.getMinDelay());
250            }
251
252            if (s.getFifoMaxEventCount() > 0) {
253                result.appendFormat("FifoMax=%d events | ",
254                        s.getFifoMaxEventCount());
255            } else {
256                result.append("no batching | ");
257            }
258
259            if (s.isWakeUpSensor()) {
260                result.appendFormat("wakeUp | ");
261            } else {
262                result.appendFormat("non-wakeUp | ");
263            }
264
265            switch (s.getType()) {
266                case SENSOR_TYPE_ROTATION_VECTOR:
267                case SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR:
268                    result.appendFormat(
269                            "last=<%5.1f,%5.1f,%5.1f,%5.1f,%5.1f, %" PRId64 ">\n",
270                            e.data[0], e.data[1], e.data[2], e.data[3], e.data[4], e.timestamp);
271                    break;
272                case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED:
273                case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
274                    result.appendFormat(
275                            "last=<%5.1f,%5.1f,%5.1f,%5.1f,%5.1f,%5.1f, %" PRId64 ">\n",
276                            e.data[0], e.data[1], e.data[2], e.data[3], e.data[4], e.data[5],
277                            e.timestamp);
278                    break;
279                case SENSOR_TYPE_GAME_ROTATION_VECTOR:
280                    result.appendFormat(
281                            "last=<%5.1f,%5.1f,%5.1f,%5.1f, %" PRId64 ">\n",
282                            e.data[0], e.data[1], e.data[2], e.data[3], e.timestamp);
283                    break;
284                case SENSOR_TYPE_SIGNIFICANT_MOTION:
285                case SENSOR_TYPE_STEP_DETECTOR:
286                    result.appendFormat( "last=<%f %" PRId64 ">\n", e.data[0], e.timestamp);
287                    break;
288                case SENSOR_TYPE_STEP_COUNTER:
289                    result.appendFormat( "last=<%" PRIu64 ", %" PRId64 ">\n", e.u64.step_counter,
290                                         e.timestamp);
291                    break;
292                default:
293                    // default to 3 values
294                    result.appendFormat(
295                            "last=<%5.1f,%5.1f,%5.1f, %" PRId64 ">\n",
296                            e.data[0], e.data[1], e.data[2], e.timestamp);
297                    break;
298            }
299            result.append("\n");
300        }
301        SensorFusion::getInstance().dump(result);
302        SensorDevice::getInstance().dump(result);
303
304        result.append("Active sensors:\n");
305        for (size_t i=0 ; i<mActiveSensors.size() ; i++) {
306            int handle = mActiveSensors.keyAt(i);
307            result.appendFormat("%s (handle=0x%08x, connections=%zu)\n",
308                    getSensorName(handle).string(),
309                    handle,
310                    mActiveSensors.valueAt(i)->getNumConnections());
311        }
312
313        result.appendFormat("Max Socket Buffer size = %d events\n",
314                            mSocketBufferSize/sizeof(sensors_event_t));
315        result.appendFormat("WakeLock Status: %s \n", mWakeLockAcquired ? "acquired" : "not held");
316        result.appendFormat("%zd active connections\n", mActiveConnections.size());
317
318        for (size_t i=0 ; i < mActiveConnections.size() ; i++) {
319            sp<SensorEventConnection> connection(mActiveConnections[i].promote());
320            if (connection != 0) {
321                result.appendFormat("Connection Number: %zu \n", i);
322                connection->dump(result);
323            }
324        }
325    }
326    write(fd, result.string(), result.size());
327    return NO_ERROR;
328}
329
330void SensorService::cleanupAutoDisabledSensorLocked(const sp<SensorEventConnection>& connection,
331        sensors_event_t const* buffer, const int count) {
332    for (int i=0 ; i<count ; i++) {
333        int handle = buffer[i].sensor;
334        if (connection->hasSensor(handle)) {
335            SensorInterface* sensor = mSensorMap.valueFor(handle);
336            // If this buffer has an event from a one_shot sensor and this connection is registered
337            // for this particular one_shot sensor, try cleaning up the connection.
338            if (sensor != NULL &&
339                sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) {
340                sensor->autoDisable(connection.get(), handle);
341                cleanupWithoutDisableLocked(connection, handle);
342            }
343        }
344    }
345}
346
347bool SensorService::threadLoop()
348{
349    ALOGD("nuSensorService thread starting...");
350
351    // each virtual sensor could generate an event per "real" event, that's why we need
352    // to size numEventMax much smaller than MAX_RECEIVE_BUFFER_EVENT_COUNT.
353    // in practice, this is too aggressive, but guaranteed to be enough.
354    const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT;
355    const size_t numEventMax = minBufferSize / (1 + mVirtualSensorList.size());
356
357    sensors_event_t buffer[minBufferSize];
358    sensors_event_t scratch[minBufferSize];
359    SensorDevice& device(SensorDevice::getInstance());
360    const size_t vcount = mVirtualSensorList.size();
361
362    SensorEventAckReceiver sender(this);
363    sender.run("SensorEventAckReceiver", PRIORITY_URGENT_DISPLAY);
364    ssize_t count;
365    const int halVersion = device.getHalDeviceVersion();
366    do {
367        count = device.poll(buffer, numEventMax);
368        if (count<0) {
369            ALOGE("sensor poll failed (%s)", strerror(-count));
370            break;
371        }
372
373        // Reset sensors_event_t.flags to zero for all events in the buffer.
374        for (int i = 0; i < count; i++) {
375             buffer[i].flags = 0;
376        }
377        Mutex::Autolock _l(mLock);
378        // Poll has returned. Hold a wakelock if one of the events is from a wake up sensor. The
379        // rest of this loop is under a critical section protected by mLock. Acquiring a wakeLock,
380        // sending events to clients (incrementing SensorEventConnection::mWakeLockRefCount) should
381        // not be interleaved with decrementing SensorEventConnection::mWakeLockRefCount and
382        // releasing the wakelock.
383        bool bufferHasWakeUpEvent = false;
384        for (int i = 0; i < count; i++) {
385            if (isWakeUpSensorEvent(buffer[i])) {
386                bufferHasWakeUpEvent = true;
387                break;
388            }
389        }
390
391        if (bufferHasWakeUpEvent && !mWakeLockAcquired) {
392            acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME);
393            mWakeLockAcquired = true;
394            ALOGD_IF(DEBUG_CONNECTIONS, "acquired wakelock %s", WAKE_LOCK_NAME);
395        }
396        recordLastValueLocked(buffer, count);
397
398        // handle virtual sensors
399        if (count && vcount) {
400            sensors_event_t const * const event = buffer;
401            const size_t activeVirtualSensorCount = mActiveVirtualSensors.size();
402            if (activeVirtualSensorCount) {
403                size_t k = 0;
404                SensorFusion& fusion(SensorFusion::getInstance());
405                if (fusion.isEnabled()) {
406                    for (size_t i=0 ; i<size_t(count) ; i++) {
407                        fusion.process(event[i]);
408                    }
409                }
410                for (size_t i=0 ; i<size_t(count) && k<minBufferSize ; i++) {
411                    for (size_t j=0 ; j<activeVirtualSensorCount ; j++) {
412                        if (count + k >= minBufferSize) {
413                            ALOGE("buffer too small to hold all events: "
414                                    "count=%zd, k=%zu, size=%zu",
415                                    count, k, minBufferSize);
416                            break;
417                        }
418                        sensors_event_t out;
419                        SensorInterface* si = mActiveVirtualSensors.valueAt(j);
420                        if (si->process(&out, event[i])) {
421                            buffer[count + k] = out;
422                            k++;
423                        }
424                    }
425                }
426                if (k) {
427                    // record the last synthesized values
428                    recordLastValueLocked(&buffer[count], k);
429                    count += k;
430                    // sort the buffer by time-stamps
431                    sortEventBuffer(buffer, count);
432                }
433            }
434        }
435
436        // handle backward compatibility for RotationVector sensor
437        if (halVersion < SENSORS_DEVICE_API_VERSION_1_0) {
438            for (int i = 0; i < count; i++) {
439                if (buffer[i].type == SENSOR_TYPE_ROTATION_VECTOR) {
440                    // All the 4 components of the quaternion should be available
441                    // No heading accuracy. Set it to -1
442                    buffer[i].data[4] = -1;
443                }
444            }
445        }
446
447        // Send our events to clients. Check the state of wake lock for each client and release the
448        // lock if none of the clients need it.
449        bool needsWakeLock = false;
450        for (size_t i=0 ; i < mActiveConnections.size(); i++) {
451            sp<SensorEventConnection> connection(mActiveConnections[i].promote());
452            if (connection != 0) {
453                connection->sendEvents(buffer, count, scratch);
454                needsWakeLock |= connection->needsWakeLock();
455                // Some sensors need to be auto disabled after the trigger
456                cleanupAutoDisabledSensorLocked(connection, buffer, count);
457            }
458        }
459
460        if (mWakeLockAcquired && !needsWakeLock) {
461            release_wake_lock(WAKE_LOCK_NAME);
462            mWakeLockAcquired = false;
463            ALOGD_IF(DEBUG_CONNECTIONS, "released wakelock %s", WAKE_LOCK_NAME);
464        }
465    } while (count >= 0 || Thread::exitPending());
466
467    ALOGW("Exiting SensorService::threadLoop => aborting...");
468    abort();
469    return false;
470}
471
472sp<Looper> SensorService::getLooper() const {
473    return mLooper;
474}
475
476bool SensorService::SensorEventAckReceiver::threadLoop() {
477    ALOGD("new thread SensorEventAckReceiver");
478    do {
479        sp<Looper> looper = mService->getLooper();
480        looper->pollOnce(-1);
481    } while(!Thread::exitPending());
482    return false;
483}
484
485void SensorService::recordLastValueLocked(
486        const sensors_event_t* buffer, size_t count) {
487    const sensors_event_t* last = NULL;
488    for (size_t i = 0; i < count; i++) {
489        const sensors_event_t* event = &buffer[i];
490        if (event->type != SENSOR_TYPE_META_DATA) {
491            if (last && event->sensor != last->sensor) {
492                mLastEventSeen.editValueFor(last->sensor) = *last;
493            }
494            last = event;
495        }
496    }
497    if (last) {
498        mLastEventSeen.editValueFor(last->sensor) = *last;
499    }
500}
501
502void SensorService::sortEventBuffer(sensors_event_t* buffer, size_t count)
503{
504    struct compar {
505        static int cmp(void const* lhs, void const* rhs) {
506            sensors_event_t const* l = static_cast<sensors_event_t const*>(lhs);
507            sensors_event_t const* r = static_cast<sensors_event_t const*>(rhs);
508            return l->timestamp - r->timestamp;
509        }
510    };
511    qsort(buffer, count, sizeof(sensors_event_t), compar::cmp);
512}
513
514String8 SensorService::getSensorName(int handle) const {
515    size_t count = mUserSensorList.size();
516    for (size_t i=0 ; i<count ; i++) {
517        const Sensor& sensor(mUserSensorList[i]);
518        if (sensor.getHandle() == handle) {
519            return sensor.getName();
520        }
521    }
522    String8 result("unknown");
523    return result;
524}
525
526bool SensorService::isVirtualSensor(int handle) const {
527    SensorInterface* sensor = mSensorMap.valueFor(handle);
528    return sensor->isVirtual();
529}
530
531bool SensorService::isWakeUpSensorEvent(const sensors_event_t& event) const {
532    int handle = event.sensor;
533    if (event.type == SENSOR_TYPE_META_DATA) {
534        handle = event.meta_data.sensor;
535    }
536    SensorInterface* sensor = mSensorMap.valueFor(handle);
537    return sensor != NULL && sensor->getSensor().isWakeUpSensor();
538}
539
540
541SensorService::SensorRecord * SensorService::getSensorRecord(int handle) {
542     return mActiveSensors.valueFor(handle);
543}
544
545Vector<Sensor> SensorService::getSensorList()
546{
547    char value[PROPERTY_VALUE_MAX];
548    property_get("debug.sensors", value, "0");
549    const Vector<Sensor>& initialSensorList = (atoi(value)) ?
550            mUserSensorListDebug : mUserSensorList;
551    Vector<Sensor> accessibleSensorList;
552    for (size_t i = 0; i < initialSensorList.size(); i++) {
553        Sensor sensor = initialSensorList[i];
554        if (canAccessSensor(sensor)) {
555            accessibleSensorList.add(sensor);
556        } else {
557            String8 infoMessage;
558            infoMessage.appendFormat(
559                    "Skipped sensor %s because it requires permission %s",
560                    sensor.getName().string(),
561                    sensor.getRequiredPermission().string());
562            ALOGI(infoMessage.string());
563        }
564    }
565    return accessibleSensorList;
566}
567
568sp<ISensorEventConnection> SensorService::createSensorEventConnection()
569{
570    uid_t uid = IPCThreadState::self()->getCallingUid();
571    sp<SensorEventConnection> result(new SensorEventConnection(this, uid));
572    return result;
573}
574
575void SensorService::cleanupConnection(SensorEventConnection* c)
576{
577    Mutex::Autolock _l(mLock);
578    const wp<SensorEventConnection> connection(c);
579    size_t size = mActiveSensors.size();
580    ALOGD_IF(DEBUG_CONNECTIONS, "%zu active sensors", size);
581    for (size_t i=0 ; i<size ; ) {
582        int handle = mActiveSensors.keyAt(i);
583        if (c->hasSensor(handle)) {
584            ALOGD_IF(DEBUG_CONNECTIONS, "%zu: disabling handle=0x%08x", i, handle);
585            SensorInterface* sensor = mSensorMap.valueFor( handle );
586            ALOGE_IF(!sensor, "mSensorMap[handle=0x%08x] is null!", handle);
587            if (sensor) {
588                sensor->activate(c, false);
589            }
590        }
591        SensorRecord* rec = mActiveSensors.valueAt(i);
592        ALOGE_IF(!rec, "mActiveSensors[%zu] is null (handle=0x%08x)!", i, handle);
593        ALOGD_IF(DEBUG_CONNECTIONS,
594                "removing connection %p for sensor[%zu].handle=0x%08x",
595                c, i, handle);
596
597        if (rec && rec->removeConnection(connection)) {
598            ALOGD_IF(DEBUG_CONNECTIONS, "... and it was the last connection");
599            mActiveSensors.removeItemsAt(i, 1);
600            mActiveVirtualSensors.removeItem(handle);
601            delete rec;
602            size--;
603        } else {
604            i++;
605        }
606    }
607    mActiveConnections.remove(connection);
608    BatteryService::cleanup(c->getUid());
609    if (c->needsWakeLock()) {
610        checkWakeLockStateLocked();
611    }
612}
613
614Sensor SensorService::getSensorFromHandle(int handle) const {
615    return mSensorMap.valueFor(handle)->getSensor();
616}
617
618status_t SensorService::enable(const sp<SensorEventConnection>& connection,
619        int handle, nsecs_t samplingPeriodNs,  nsecs_t maxBatchReportLatencyNs, int reservedFlags)
620{
621    if (mInitCheck != NO_ERROR)
622        return mInitCheck;
623
624    SensorInterface* sensor = mSensorMap.valueFor(handle);
625    if (sensor == NULL) {
626        return BAD_VALUE;
627    }
628
629    if (!verifyCanAccessSensor(sensor->getSensor(), "Tried enabling")) {
630        return BAD_VALUE;
631    }
632
633    Mutex::Autolock _l(mLock);
634    SensorRecord* rec = mActiveSensors.valueFor(handle);
635    if (rec == 0) {
636        rec = new SensorRecord(connection);
637        mActiveSensors.add(handle, rec);
638        if (sensor->isVirtual()) {
639            mActiveVirtualSensors.add(handle, sensor);
640        }
641    } else {
642        if (rec->addConnection(connection)) {
643            // this sensor is already activated, but we are adding a connection that uses it.
644            // Immediately send down the last known value of the requested sensor if it's not a
645            // "continuous" sensor.
646            if (sensor->getSensor().getReportingMode() == AREPORTING_MODE_ON_CHANGE) {
647                // NOTE: The wake_up flag of this event may get set to
648                // WAKE_UP_SENSOR_EVENT_NEEDS_ACK if this is a wake_up event.
649                sensors_event_t& event(mLastEventSeen.editValueFor(handle));
650                if (event.version == sizeof(sensors_event_t)) {
651                    if (isWakeUpSensorEvent(event) && !mWakeLockAcquired) {
652                        acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME);
653                        mWakeLockAcquired = true;
654                        ALOGD_IF(DEBUG_CONNECTIONS, "acquired wakelock for on_change sensor %s",
655                                                        WAKE_LOCK_NAME);
656                    }
657                    connection->sendEvents(&event, 1, NULL);
658                    if (!connection->needsWakeLock() && mWakeLockAcquired) {
659                        checkWakeLockStateLocked();
660                    }
661                }
662            }
663        }
664    }
665
666    if (connection->addSensor(handle)) {
667        BatteryService::enableSensor(connection->getUid(), handle);
668        // the sensor was added (which means it wasn't already there)
669        // so, see if this connection becomes active
670        if (mActiveConnections.indexOf(connection) < 0) {
671            mActiveConnections.add(connection);
672        }
673    } else {
674        ALOGW("sensor %08x already enabled in connection %p (ignoring)",
675            handle, connection.get());
676    }
677
678    nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs();
679    if (samplingPeriodNs < minDelayNs) {
680        samplingPeriodNs = minDelayNs;
681    }
682
683    ALOGD_IF(DEBUG_CONNECTIONS, "Calling batch handle==%d flags=%d"
684                                "rate=%" PRId64 " timeout== %" PRId64"",
685             handle, reservedFlags, samplingPeriodNs, maxBatchReportLatencyNs);
686
687    status_t err = sensor->batch(connection.get(), handle, reservedFlags, samplingPeriodNs,
688                                 maxBatchReportLatencyNs);
689
690    if (err == NO_ERROR && sensor->getSensor().getReportingMode() != AREPORTING_MODE_ONE_SHOT) {
691        status_t err_flush = sensor->flush(connection.get(), handle);
692        // Flush may return error if the sensor is not activated or the underlying h/w sensor does
693        // not support flush.
694        if (err_flush == NO_ERROR) {
695            connection->setFirstFlushPending(handle, true);
696            rec->addPendingFlushConnection(connection.get());
697        }
698    }
699
700    if (err == NO_ERROR) {
701        ALOGD_IF(DEBUG_CONNECTIONS, "Calling activate on %d", handle);
702        err = sensor->activate(connection.get(), true);
703    }
704
705    if (err == NO_ERROR && sensor->getSensor().isWakeUpSensor()) {
706        // Add the file descriptor to the Looper for receiving acknowledgments;
707        int ret = mLooper->addFd(connection->getSensorChannel()->getSendFd(), 0,
708                                        ALOOPER_EVENT_INPUT, connection.get(), NULL);
709    }
710
711    if (err != NO_ERROR) {
712        // batch/activate has failed, reset our state.
713        cleanupWithoutDisableLocked(connection, handle);
714    }
715    return err;
716}
717
718status_t SensorService::disable(const sp<SensorEventConnection>& connection,
719        int handle)
720{
721    if (mInitCheck != NO_ERROR)
722        return mInitCheck;
723
724    Mutex::Autolock _l(mLock);
725    status_t err = cleanupWithoutDisableLocked(connection, handle);
726    if (err == NO_ERROR) {
727        SensorInterface* sensor = mSensorMap.valueFor(handle);
728        err = sensor ? sensor->activate(connection.get(), false) : status_t(BAD_VALUE);
729    }
730    return err;
731}
732
733status_t SensorService::cleanupWithoutDisable(
734        const sp<SensorEventConnection>& connection, int handle) {
735    Mutex::Autolock _l(mLock);
736    return cleanupWithoutDisableLocked(connection, handle);
737}
738
739status_t SensorService::cleanupWithoutDisableLocked(
740        const sp<SensorEventConnection>& connection, int handle) {
741    SensorRecord* rec = mActiveSensors.valueFor(handle);
742    if (rec) {
743        // see if this connection becomes inactive
744        if (connection->removeSensor(handle)) {
745            BatteryService::disableSensor(connection->getUid(), handle);
746        }
747        if (connection->hasAnySensor() == false) {
748            mActiveConnections.remove(connection);
749        }
750        // see if this sensor becomes inactive
751        if (rec->removeConnection(connection)) {
752            mActiveSensors.removeItem(handle);
753            mActiveVirtualSensors.removeItem(handle);
754            delete rec;
755        }
756        return NO_ERROR;
757    }
758    return BAD_VALUE;
759}
760
761status_t SensorService::setEventRate(const sp<SensorEventConnection>& connection,
762        int handle, nsecs_t ns)
763{
764    if (mInitCheck != NO_ERROR)
765        return mInitCheck;
766
767    SensorInterface* sensor = mSensorMap.valueFor(handle);
768    if (!sensor)
769        return BAD_VALUE;
770
771    if (!verifyCanAccessSensor(sensor->getSensor(), "Tried configuring")) {
772        return BAD_VALUE;
773    }
774
775    if (ns < 0)
776        return BAD_VALUE;
777
778    nsecs_t minDelayNs = sensor->getSensor().getMinDelayNs();
779    if (ns < minDelayNs) {
780        ns = minDelayNs;
781    }
782
783    return sensor->setDelay(connection.get(), handle, ns);
784}
785
786status_t SensorService::flushSensor(const sp<SensorEventConnection>& connection,
787                                    int handle) {
788    if (mInitCheck != NO_ERROR) return mInitCheck;
789    SensorInterface* sensor = mSensorMap.valueFor(handle);
790    if (sensor == NULL) {
791        return BAD_VALUE;
792    }
793
794    if (!verifyCanAccessSensor(sensor->getSensor(), "Tried flushing")) {
795        return BAD_VALUE;
796    }
797
798    if (sensor->getSensor().getReportingMode() == AREPORTING_MODE_ONE_SHOT) {
799        ALOGE("flush called on a one-shot sensor");
800        return INVALID_OPERATION;
801    }
802
803    status_t ret = sensor->flush(connection.get(), handle);
804    if (ret == NO_ERROR) {
805        SensorRecord* rec = mActiveSensors.valueFor(handle);
806        if (rec != NULL) rec->addPendingFlushConnection(connection);
807    }
808    return ret;
809}
810
811
812bool SensorService::canAccessSensor(const Sensor& sensor) {
813    return (sensor.getRequiredPermission().isEmpty()) ||
814            PermissionCache::checkCallingPermission(String16(sensor.getRequiredPermission()));
815}
816
817bool SensorService::verifyCanAccessSensor(const Sensor& sensor, const char* operation) {
818    if (canAccessSensor(sensor)) {
819        return true;
820    } else {
821        String8 errorMessage;
822        errorMessage.appendFormat(
823                "%s a sensor (%s) without holding its required permission: %s",
824                operation,
825                sensor.getName().string(),
826                sensor.getRequiredPermission().string());
827        return false;
828    }
829}
830
831void SensorService::checkWakeLockState() {
832    Mutex::Autolock _l(mLock);
833    checkWakeLockStateLocked();
834}
835
836void SensorService::checkWakeLockStateLocked() {
837    if (!mWakeLockAcquired) {
838        return;
839    }
840    bool releaseLock = true;
841    for (size_t i=0 ; i<mActiveConnections.size() ; i++) {
842        sp<SensorEventConnection> connection(mActiveConnections[i].promote());
843        if (connection != 0) {
844            if (connection->needsWakeLock()) {
845                releaseLock = false;
846                break;
847            }
848        }
849    }
850    if (releaseLock) {
851        ALOGD_IF(DEBUG_CONNECTIONS, "releasing wakelock %s", WAKE_LOCK_NAME);
852        release_wake_lock(WAKE_LOCK_NAME);
853        mWakeLockAcquired = false;
854    }
855}
856
857// ---------------------------------------------------------------------------
858SensorService::SensorRecord::SensorRecord(
859        const sp<SensorEventConnection>& connection)
860{
861    mConnections.add(connection);
862}
863
864bool SensorService::SensorRecord::addConnection(
865        const sp<SensorEventConnection>& connection)
866{
867    if (mConnections.indexOf(connection) < 0) {
868        mConnections.add(connection);
869        return true;
870    }
871    return false;
872}
873
874bool SensorService::SensorRecord::removeConnection(
875        const wp<SensorEventConnection>& connection)
876{
877    ssize_t index = mConnections.indexOf(connection);
878    if (index >= 0) {
879        mConnections.removeItemsAt(index, 1);
880    }
881    // Remove this connections from the queue of flush() calls made on this sensor.
882    for (Vector< wp<SensorEventConnection> >::iterator it =
883            mPendingFlushConnections.begin(); it != mPendingFlushConnections.end();) {
884        if (it->unsafe_get() == connection.unsafe_get()) {
885            it = mPendingFlushConnections.erase(it);
886        } else {
887            ++it;
888        }
889    }
890    return mConnections.size() ? false : true;
891}
892
893void SensorService::SensorRecord::addPendingFlushConnection(
894        const sp<SensorEventConnection>& connection) {
895    mPendingFlushConnections.add(connection);
896}
897
898void SensorService::SensorRecord::removeFirstPendingFlushConnection() {
899    if (mPendingFlushConnections.size() > 0) {
900        mPendingFlushConnections.removeAt(0);
901    }
902}
903
904SensorService::SensorEventConnection *
905SensorService::SensorRecord::getFirstPendingFlushConnection() {
906   if (mPendingFlushConnections.size() > 0) {
907        return mPendingFlushConnections[0].unsafe_get();
908    }
909    return NULL;
910}
911
912// ---------------------------------------------------------------------------
913
914SensorService::SensorEventConnection::SensorEventConnection(
915        const sp<SensorService>& service, uid_t uid)
916    : mService(service), mUid(uid), mWakeLockRefCount(0), mEventCache(NULL), mCacheSize(0),
917      mMaxCacheSize(0) {
918    const SensorDevice& device(SensorDevice::getInstance());
919    if (device.getHalDeviceVersion() >= SENSORS_DEVICE_API_VERSION_1_1) {
920        // Increase socket buffer size to a max of 100 KB for batching capabilities.
921        mChannel = new BitTube(mService->mSocketBufferSize);
922    } else {
923        mChannel = new BitTube(SOCKET_BUFFER_SIZE_NON_BATCHED);
924    }
925#if DEBUG_CONNECTIONS
926    mEventsReceived = mEventsSentFromCache = mEventsSent = 0;
927    mTotalAcksNeeded = mTotalAcksReceived = 0;
928#endif
929}
930
931SensorService::SensorEventConnection::~SensorEventConnection() {
932    ALOGD_IF(DEBUG_CONNECTIONS, "~SensorEventConnection(%p)", this);
933    if (mEventCache != NULL) {
934        delete mEventCache;
935    }
936    mService->cleanupConnection(this);
937}
938
939void SensorService::SensorEventConnection::onFirstRef() {
940    LooperCallback::onFirstRef();
941}
942
943bool SensorService::SensorEventConnection::needsWakeLock() {
944    Mutex::Autolock _l(mConnectionLock);
945    return mWakeLockRefCount > 0;
946}
947
948void SensorService::SensorEventConnection::dump(String8& result) {
949    Mutex::Autolock _l(mConnectionLock);
950    result.appendFormat("\t %d WakeLockRefCount \n", mWakeLockRefCount);
951    for (size_t i = 0; i < mSensorInfo.size(); ++i) {
952        const FlushInfo& flushInfo = mSensorInfo.valueAt(i);
953        result.appendFormat("\t %s 0x%08x | status: %s | pending flush events %d | uid %d|"
954                            "cache size: %d max cache size %d\n",
955                            mService->getSensorName(mSensorInfo.keyAt(i)).string(),
956                            mSensorInfo.keyAt(i),
957                            flushInfo.mFirstFlushPending ? "First flush pending" :
958                                                           "active",
959                            flushInfo.mPendingFlushEventsToSend,
960                            mUid,
961                            mCacheSize,
962                            mMaxCacheSize);
963#if DEBUG_CONNECTIONS
964        result.appendFormat("\t events recvd: %d | sent %d | cache %d | dropped %d |"
965                                  " total_acks_needed %d | total_acks_recvd %d\n",
966                                        mEventsReceived,
967                                        mEventsSent,
968                                        mEventsSentFromCache,
969                                        mEventsReceived - (mEventsSentFromCache +
970                                                           mEventsSent + mCacheSize),
971                                        mTotalAcksNeeded,
972                                        mTotalAcksReceived);
973#endif
974
975    }
976}
977
978bool SensorService::SensorEventConnection::addSensor(int32_t handle) {
979    Mutex::Autolock _l(mConnectionLock);
980    if (!verifyCanAccessSensor(mService->getSensorFromHandle(handle), "Tried adding")) {
981        return false;
982    }
983    if (mSensorInfo.indexOfKey(handle) < 0) {
984        mSensorInfo.add(handle, FlushInfo());
985        return true;
986    }
987    return false;
988}
989
990bool SensorService::SensorEventConnection::removeSensor(int32_t handle) {
991    Mutex::Autolock _l(mConnectionLock);
992    if (mSensorInfo.removeItem(handle) >= 0) {
993        return true;
994    }
995    return false;
996}
997
998bool SensorService::SensorEventConnection::hasSensor(int32_t handle) const {
999    Mutex::Autolock _l(mConnectionLock);
1000    return mSensorInfo.indexOfKey(handle) >= 0;
1001}
1002
1003bool SensorService::SensorEventConnection::hasAnySensor() const {
1004    Mutex::Autolock _l(mConnectionLock);
1005    return mSensorInfo.size() ? true : false;
1006}
1007
1008void SensorService::SensorEventConnection::setFirstFlushPending(int32_t handle,
1009                                bool value) {
1010    Mutex::Autolock _l(mConnectionLock);
1011    ssize_t index = mSensorInfo.indexOfKey(handle);
1012    if (index >= 0) {
1013        FlushInfo& flushInfo = mSensorInfo.editValueAt(index);
1014        flushInfo.mFirstFlushPending = value;
1015    }
1016}
1017
1018status_t SensorService::SensorEventConnection::sendEvents(
1019        sensors_event_t const* buffer, size_t numEvents,
1020        sensors_event_t* scratch) {
1021    // filter out events not for this connection
1022    size_t count = 0;
1023    Mutex::Autolock _l(mConnectionLock);
1024    if (scratch) {
1025        size_t i=0;
1026        while (i<numEvents) {
1027            int32_t sensor_handle = buffer[i].sensor;
1028            if (buffer[i].type == SENSOR_TYPE_META_DATA) {
1029                ALOGD_IF(DEBUG_CONNECTIONS, "flush complete event sensor==%d ",
1030                         buffer[i].meta_data.sensor);
1031                // Setting sensor_handle to the correct sensor to ensure the sensor events per connection are
1032                // filtered correctly. buffer[i].sensor is zero for meta_data events.
1033                sensor_handle = buffer[i].meta_data.sensor;
1034            }
1035            ssize_t index = mSensorInfo.indexOfKey(sensor_handle);
1036            // Check if this connection has registered for this sensor. If not continue to the
1037            // next sensor_event.
1038            if (index < 0) {
1039                ++i;
1040                continue;
1041            }
1042
1043            FlushInfo& flushInfo = mSensorInfo.editValueAt(index);
1044            // Check if there is a pending flush_complete event for this sensor on this connection.
1045            if (buffer[i].type == SENSOR_TYPE_META_DATA && flushInfo.mFirstFlushPending == true) {
1046                SensorService::SensorRecord *rec = mService->getSensorRecord(sensor_handle);
1047                if (rec && rec->getFirstPendingFlushConnection() == this) {
1048                    rec->removeFirstPendingFlushConnection();
1049                    flushInfo.mFirstFlushPending = false;
1050                    ++i;
1051                    ALOGD_IF(DEBUG_CONNECTIONS, "First flush event for sensor==%d ",
1052                                                    buffer[i].meta_data.sensor);
1053                    continue;
1054                }
1055            }
1056
1057            // If there is a pending flush complete event for this sensor on this connection,
1058            // ignore the event and proceed to the next.
1059            if (flushInfo.mFirstFlushPending) {
1060                ++i;
1061                continue;
1062            }
1063
1064            do {
1065                if (buffer[i].type == SENSOR_TYPE_META_DATA) {
1066                   // Check if this connection has called flush() on this sensor. Only if
1067                   // a flush() has been explicitly called, send a flush_complete_event.
1068                   SensorService::SensorRecord *rec = mService->getSensorRecord(sensor_handle);
1069                   if (rec && rec->getFirstPendingFlushConnection() == this) {
1070                        rec->removeFirstPendingFlushConnection();
1071                        scratch[count++] = buffer[i];
1072                    }
1073                    ++i;
1074                } else {
1075                    // Regular sensor event, just copy it to the scratch buffer.
1076                    scratch[count++] = buffer[i++];
1077                }
1078            } while ((i<numEvents) && ((buffer[i].sensor == sensor_handle) ||
1079                                       (buffer[i].type == SENSOR_TYPE_META_DATA  &&
1080                                        buffer[i].meta_data.sensor == sensor_handle)));
1081        }
1082    } else {
1083        scratch = const_cast<sensors_event_t *>(buffer);
1084        count = numEvents;
1085    }
1086
1087    sendPendingFlushEventsLocked();
1088    // Early return if there are no events for this connection.
1089    if (count == 0) {
1090        return status_t(NO_ERROR);
1091    }
1092
1093#if DEBUG_CONNECTIONS
1094     mEventsReceived += count;
1095#endif
1096    if (mCacheSize != 0) {
1097        // There are some events in the cache which need to be sent first. Copy this buffer to
1098        // the end of cache.
1099        if (mCacheSize + count <= mMaxCacheSize) {
1100            memcpy(&mEventCache[mCacheSize], scratch, count * sizeof(sensors_event_t));
1101            mCacheSize += count;
1102        } else {
1103            // Check if any new sensors have registered on this connection which may have increased
1104            // the max cache size that is desired.
1105            if (mCacheSize + count < computeMaxCacheSizeLocked()) {
1106                reAllocateCacheLocked(scratch, count);
1107                return status_t(NO_ERROR);
1108            }
1109            // Some events need to be dropped.
1110            int remaningCacheSize = mMaxCacheSize - mCacheSize;
1111            if (remaningCacheSize != 0) {
1112                memcpy(&mEventCache[mCacheSize], scratch,
1113                                                remaningCacheSize * sizeof(sensors_event_t));
1114            }
1115            int numEventsDropped = count - remaningCacheSize;
1116            countFlushCompleteEventsLocked(mEventCache, numEventsDropped);
1117            // Drop the first "numEventsDropped" in the cache.
1118            memmove(mEventCache, &mEventCache[numEventsDropped],
1119                    (mCacheSize - numEventsDropped) * sizeof(sensors_event_t));
1120
1121            // Copy the remainingEvents in scratch buffer to the end of cache.
1122            memcpy(&mEventCache[mCacheSize - numEventsDropped], scratch + remaningCacheSize,
1123                                            numEventsDropped * sizeof(sensors_event_t));
1124        }
1125        return status_t(NO_ERROR);
1126    }
1127
1128    int index_wake_up_event = findWakeUpSensorEventLocked(scratch, count);
1129    if (index_wake_up_event >= 0) {
1130        scratch[index_wake_up_event].flags |= WAKE_UP_SENSOR_EVENT_NEEDS_ACK;
1131        ++mWakeLockRefCount;
1132#if DEBUG_CONNECTIONS
1133        ++mTotalAcksNeeded;
1134#endif
1135    }
1136
1137    // NOTE: ASensorEvent and sensors_event_t are the same type.
1138    ssize_t size = SensorEventQueue::write(mChannel,
1139                                    reinterpret_cast<ASensorEvent const*>(scratch), count);
1140    if (size < 0) {
1141        // Write error, copy events to local cache.
1142        if (index_wake_up_event >= 0) {
1143            // If there was a wake_up sensor_event, reset the flag.
1144            scratch[index_wake_up_event].flags &= ~WAKE_UP_SENSOR_EVENT_NEEDS_ACK;
1145            --mWakeLockRefCount;
1146#if DEBUG_CONNECTIONS
1147            --mTotalAcksNeeded;
1148#endif
1149        }
1150        if (mEventCache == NULL) {
1151            mMaxCacheSize = computeMaxCacheSizeLocked();
1152            mEventCache = new sensors_event_t[mMaxCacheSize];
1153            mCacheSize = 0;
1154        }
1155        memcpy(&mEventCache[mCacheSize], scratch, count * sizeof(sensors_event_t));
1156        mCacheSize += count;
1157
1158        // Add this file descriptor to the looper to get a callback when this fd is available for
1159        // writing.
1160        mService->getLooper()->addFd(mChannel->getSendFd(), 0,
1161                ALOOPER_EVENT_OUTPUT | ALOOPER_EVENT_INPUT, this, NULL);
1162        return size;
1163    }
1164
1165#if DEBUG_CONNECTIONS
1166    if (size > 0) {
1167        mEventsSent += count;
1168    }
1169#endif
1170
1171    return size < 0 ? status_t(size) : status_t(NO_ERROR);
1172}
1173
1174void SensorService::SensorEventConnection::reAllocateCacheLocked(sensors_event_t const* scratch,
1175                                                                 int count) {
1176    sensors_event_t *eventCache_new;
1177    const int new_cache_size = computeMaxCacheSizeLocked();
1178    // Allocate new cache, copy over events from the old cache & scratch, free up memory.
1179    eventCache_new = new sensors_event_t[new_cache_size];
1180    memcpy(eventCache_new, mEventCache, mCacheSize * sizeof(sensors_event_t));
1181    memcpy(&eventCache_new[mCacheSize], scratch, count * sizeof(sensors_event_t));
1182
1183    ALOGD_IF(DEBUG_CONNECTIONS, "reAllocateCacheLocked maxCacheSize=%d %d", mMaxCacheSize,
1184            new_cache_size);
1185
1186    delete mEventCache;
1187    mEventCache = eventCache_new;
1188    mCacheSize += count;
1189    mMaxCacheSize = new_cache_size;
1190}
1191
1192void SensorService::SensorEventConnection::sendPendingFlushEventsLocked() {
1193    ASensorEvent flushCompleteEvent;
1194    flushCompleteEvent.type = SENSOR_TYPE_META_DATA;
1195    flushCompleteEvent.sensor = 0;
1196    // Loop through all the sensors for this connection and check if there are any pending
1197    // flush complete events to be sent.
1198    for (size_t i = 0; i < mSensorInfo.size(); ++i) {
1199        FlushInfo& flushInfo = mSensorInfo.editValueAt(i);
1200        while (flushInfo.mPendingFlushEventsToSend > 0) {
1201            flushCompleteEvent.meta_data.sensor = mSensorInfo.keyAt(i);
1202            ssize_t size = SensorEventQueue::write(mChannel, &flushCompleteEvent, 1);
1203            if (size < 0) {
1204                return;
1205            }
1206            ALOGD_IF(DEBUG_CONNECTIONS, "sent dropped flush complete event==%d ",
1207                    flushCompleteEvent.meta_data.sensor);
1208            flushInfo.mPendingFlushEventsToSend--;
1209        }
1210    }
1211}
1212
1213void SensorService::SensorEventConnection::writeToSocketFromCacheLocked() {
1214    // At a time write at most half the size of the receiver buffer in SensorEventQueue.
1215    const int maxWriteSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT/2;
1216    sendPendingFlushEventsLocked();
1217    // Write "count" events at a time.
1218    for (int numEventsSent = 0; numEventsSent < mCacheSize;) {
1219        const int numEventsToWrite = (mCacheSize - numEventsSent) < maxWriteSize ?
1220                                        mCacheSize - numEventsSent : maxWriteSize;
1221        int index_wake_up_event =
1222                  findWakeUpSensorEventLocked(mEventCache + numEventsSent, numEventsToWrite);
1223        if (index_wake_up_event >= 0) {
1224            mEventCache[index_wake_up_event + numEventsSent].flags |=
1225                    WAKE_UP_SENSOR_EVENT_NEEDS_ACK;
1226            ++mWakeLockRefCount;
1227#if DEBUG_CONNECTIONS
1228            ++mTotalAcksNeeded;
1229#endif
1230        }
1231
1232        ssize_t size = SensorEventQueue::write(mChannel,
1233                          reinterpret_cast<ASensorEvent const*>(mEventCache + numEventsSent),
1234                          numEventsToWrite);
1235        if (size < 0) {
1236            if (index_wake_up_event >= 0) {
1237                // If there was a wake_up sensor_event, reset the flag.
1238                mEventCache[index_wake_up_event + numEventsSent].flags  &=
1239                        ~WAKE_UP_SENSOR_EVENT_NEEDS_ACK;
1240                --mWakeLockRefCount;
1241#if DEBUG_CONNECTIONS
1242                --mTotalAcksNeeded;
1243#endif
1244            }
1245            memmove(mEventCache, &mEventCache[numEventsSent],
1246                                 (mCacheSize - numEventsSent) * sizeof(sensors_event_t));
1247            ALOGD_IF(DEBUG_CONNECTIONS, "wrote %d events from cache size==%d ",
1248                    numEventsSent, mCacheSize);
1249            mCacheSize -= numEventsSent;
1250            return;
1251        }
1252        numEventsSent += numEventsToWrite;
1253#if DEBUG_CONNECTIONS
1254        mEventsSentFromCache += numEventsToWrite;
1255#endif
1256    }
1257    ALOGD_IF(DEBUG_CONNECTIONS, "wrote all events from cache size=%d ", mCacheSize);
1258    // All events from the cache have been sent. Reset cache size to zero.
1259    mCacheSize = 0;
1260    // Poll only for ALOOPER_EVENT_INPUT(read) on the file descriptor.
1261    mService->getLooper()->addFd(mChannel->getSendFd(), 0, ALOOPER_EVENT_INPUT, this, NULL);
1262}
1263
1264void SensorService::SensorEventConnection::countFlushCompleteEventsLocked(
1265                sensors_event_t* scratch, const int numEventsDropped) {
1266    ALOGD_IF(DEBUG_CONNECTIONS, "dropping %d events ", numEventsDropped);
1267    // Count flushComplete events in the events that are about to the dropped. These will be sent
1268    // separately before the next batch of events.
1269    for (int j = 0; j < numEventsDropped; ++j) {
1270        if (scratch[j].type == SENSOR_TYPE_META_DATA) {
1271            FlushInfo& flushInfo = mSensorInfo.editValueFor(scratch[j].meta_data.sensor);
1272            flushInfo.mPendingFlushEventsToSend++;
1273            ALOGD_IF(DEBUG_CONNECTIONS, "increment pendingFlushCount %d",
1274                     flushInfo.mPendingFlushEventsToSend);
1275        }
1276    }
1277    return;
1278}
1279
1280int SensorService::SensorEventConnection::findWakeUpSensorEventLocked(
1281                       sensors_event_t const* scratch, const int count) {
1282    for (int i = 0; i < count; ++i) {
1283        if (mService->isWakeUpSensorEvent(scratch[i])) {
1284            return i;
1285        }
1286    }
1287    return -1;
1288}
1289
1290sp<BitTube> SensorService::SensorEventConnection::getSensorChannel() const
1291{
1292    return mChannel;
1293}
1294
1295status_t SensorService::SensorEventConnection::enableDisable(
1296        int handle, bool enabled, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs,
1297        int reservedFlags)
1298{
1299    status_t err;
1300    if (enabled) {
1301        err = mService->enable(this, handle, samplingPeriodNs, maxBatchReportLatencyNs,
1302                               reservedFlags);
1303
1304    } else {
1305        err = mService->disable(this, handle);
1306    }
1307    return err;
1308}
1309
1310status_t SensorService::SensorEventConnection::setEventRate(
1311        int handle, nsecs_t samplingPeriodNs)
1312{
1313    return mService->setEventRate(this, handle, samplingPeriodNs);
1314}
1315
1316status_t  SensorService::SensorEventConnection::flush() {
1317    SensorDevice& dev(SensorDevice::getInstance());
1318    const int halVersion = dev.getHalDeviceVersion();
1319    Mutex::Autolock _l(mConnectionLock);
1320    status_t err(NO_ERROR);
1321    // Loop through all sensors for this connection and call flush on each of them.
1322    for (size_t i = 0; i < mSensorInfo.size(); ++i) {
1323        const int handle = mSensorInfo.keyAt(i);
1324        FlushInfo& flushInfo = mSensorInfo.editValueFor(handle);
1325        if (halVersion < SENSORS_DEVICE_API_VERSION_1_1 || mService->isVirtualSensor(handle)) {
1326            // For older devices just increment pending flush count which will send a trivial
1327            // flush complete event.
1328            flushInfo.mPendingFlushEventsToSend++;
1329        } else {
1330            status_t err_flush = mService->flushSensor(this, handle);
1331            if (err_flush != NO_ERROR) {
1332                ALOGE("Flush error handle=%d %s", handle, strerror(-err_flush));
1333            }
1334            err = (err_flush != NO_ERROR) ? err_flush : err;
1335        }
1336    }
1337    return err;
1338}
1339
1340int SensorService::SensorEventConnection::handleEvent(int fd, int events, void* data) {
1341    if (events & ALOOPER_EVENT_HANGUP || events & ALOOPER_EVENT_ERROR) {
1342        return 0;
1343    }
1344
1345    if (events & ALOOPER_EVENT_INPUT) {
1346        char buf;
1347        ssize_t ret = ::recv(fd, &buf, sizeof(buf), MSG_DONTWAIT);
1348
1349        {
1350           Mutex::Autolock _l(mConnectionLock);
1351           --mWakeLockRefCount;
1352#if DEBUG_CONNECTIONS
1353           ++mTotalAcksReceived;
1354#endif
1355        }
1356        // Check if wakelock can be released by sensorservice. mConnectionLock needs to be released
1357        // here as checkWakeLockState() will need it.
1358        if (mWakeLockRefCount == 0) {
1359            mService->checkWakeLockState();
1360        }
1361        // continue getting callbacks.
1362        return 1;
1363    }
1364
1365    if (events & ALOOPER_EVENT_OUTPUT) {
1366        // send sensor data that is stored in mEventCache.
1367        Mutex::Autolock _l(mConnectionLock);
1368        writeToSocketFromCacheLocked();
1369    }
1370    return 1;
1371}
1372
1373int SensorService::SensorEventConnection::computeMaxCacheSizeLocked() const {
1374    int fifoWakeUpSensors = 0;
1375    int fifoNonWakeUpSensors = 0;
1376    for (size_t i = 0; i < mSensorInfo.size(); ++i) {
1377        const Sensor& sensor = mService->getSensorFromHandle(mSensorInfo.keyAt(i));
1378        if (sensor.getFifoReservedEventCount() == sensor.getFifoMaxEventCount()) {
1379            // Each sensor has a reserved fifo. Sum up the fifo sizes for all wake up sensors and
1380            // non wake_up sensors.
1381            if (sensor.isWakeUpSensor()) {
1382                fifoWakeUpSensors += sensor.getFifoReservedEventCount();
1383            } else {
1384                fifoNonWakeUpSensors += sensor.getFifoReservedEventCount();
1385            }
1386        } else {
1387            // Shared fifo. Compute the max of the fifo sizes for wake_up and non_wake up sensors.
1388            if (sensor.isWakeUpSensor()) {
1389                fifoWakeUpSensors = fifoWakeUpSensors > sensor.getFifoMaxEventCount() ?
1390                                          fifoWakeUpSensors : sensor.getFifoMaxEventCount();
1391
1392            } else {
1393                fifoNonWakeUpSensors = fifoNonWakeUpSensors > sensor.getFifoMaxEventCount() ?
1394                                          fifoNonWakeUpSensors : sensor.getFifoMaxEventCount();
1395
1396            }
1397        }
1398   }
1399   if (fifoWakeUpSensors + fifoNonWakeUpSensors == 0) {
1400       // It is extremely unlikely that there is a write failure in non batch mode. Return a cache
1401       // size that is equal to that of the batch mode.
1402       // ALOGW("Write failure in non-batch mode");
1403       return MAX_SOCKET_BUFFER_SIZE_BATCHED/sizeof(sensors_event_t);
1404   }
1405   return fifoWakeUpSensors + fifoNonWakeUpSensors;
1406}
1407
1408// ---------------------------------------------------------------------------
1409}; // namespace android
1410
1411