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