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