split libsensor our of libgui
Test: compile & run
Bug: treble cleanup
Change-Id: I5b2c2a14f7d3b364d25695cf0901c5b08cfb0fc9
diff --git a/libs/gui/Android.bp b/libs/gui/Android.bp
index 8f9c38a..a1b4abc 100644
--- a/libs/gui/Android.bp
+++ b/libs/gui/Android.bp
@@ -38,10 +38,6 @@
// Don't warn about struct padding
"-Wno-padded",
- // android/sensors.h uses nested anonymous unions and anonymous structs
- "-Wno-nested-anon-types",
- "-Wno-gnu-anonymous-struct",
-
// We are aware of the risks inherent in comparing floats for equality
"-Wno-float-equal",
@@ -61,8 +57,6 @@
},
srcs: [
- "IGraphicBufferConsumer.cpp",
- "IConsumerListener.cpp",
"BitTube.cpp",
"BufferItem.cpp",
"BufferItemConsumer.cpp",
@@ -79,18 +73,15 @@
"GraphicBufferAlloc.cpp",
"GuiConfig.cpp",
"IDisplayEventConnection.cpp",
+ "IConsumerListener.cpp",
"IGraphicBufferAlloc.cpp",
+ "IGraphicBufferConsumer.cpp",
"IGraphicBufferProducer.cpp",
"IProducerListener.cpp",
- "ISensorEventConnection.cpp",
- "ISensorServer.cpp",
"ISurfaceComposer.cpp",
"ISurfaceComposerClient.cpp",
"LayerState.cpp",
"OccupancyTracker.cpp",
- "Sensor.cpp",
- "SensorEventQueue.cpp",
- "SensorManager.cpp",
"StreamSplitter.cpp",
"Surface.cpp",
"SurfaceControl.cpp",
diff --git a/libs/gui/BitTube.cpp b/libs/gui/BitTube.cpp
index b653c5b..51a8d67 100644
--- a/libs/gui/BitTube.cpp
+++ b/libs/gui/BitTube.cpp
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#include <private/gui/BitTube.h>
+
#include <stdint.h>
#include <sys/types.h>
#include <sys/socket.h>
@@ -25,7 +27,6 @@
#include <binder/Parcel.h>
-#include <gui/BitTube.h>
namespace android {
// ----------------------------------------------------------------------------
diff --git a/libs/gui/DisplayEventReceiver.cpp b/libs/gui/DisplayEventReceiver.cpp
index 9973e8d..07e07e0 100644
--- a/libs/gui/DisplayEventReceiver.cpp
+++ b/libs/gui/DisplayEventReceiver.cpp
@@ -18,13 +18,14 @@
#include <utils/Errors.h>
-#include <gui/BitTube.h>
#include <gui/DisplayEventReceiver.h>
#include <gui/IDisplayEventConnection.h>
#include <gui/ISurfaceComposer.h>
#include <private/gui/ComposerService.h>
+#include <private/gui/BitTube.h>
+
// ---------------------------------------------------------------------------
namespace android {
diff --git a/libs/gui/IDisplayEventConnection.cpp b/libs/gui/IDisplayEventConnection.cpp
index b1d3b00..e5c3c48 100644
--- a/libs/gui/IDisplayEventConnection.cpp
+++ b/libs/gui/IDisplayEventConnection.cpp
@@ -15,17 +15,15 @@
*/
#include <stdint.h>
-#include <sys/types.h>
#include <utils/Errors.h>
#include <utils/RefBase.h>
-#include <utils/Timers.h>
#include <binder/Parcel.h>
-#include <binder/IInterface.h>
#include <gui/IDisplayEventConnection.h>
-#include <gui/BitTube.h>
+
+#include <private/gui/BitTube.h>
namespace android {
// ----------------------------------------------------------------------------
diff --git a/libs/gui/ISensorEventConnection.cpp b/libs/gui/ISensorEventConnection.cpp
deleted file mode 100644
index 8af51c5..0000000
--- a/libs/gui/ISensorEventConnection.cpp
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <stdint.h>
-#include <sys/types.h>
-
-#include <utils/Errors.h>
-#include <utils/RefBase.h>
-#include <utils/Timers.h>
-
-#include <binder/Parcel.h>
-#include <binder/IInterface.h>
-
-#include <gui/ISensorEventConnection.h>
-#include <gui/BitTube.h>
-
-namespace android {
-// ----------------------------------------------------------------------------
-
-enum {
- GET_SENSOR_CHANNEL = IBinder::FIRST_CALL_TRANSACTION,
- ENABLE_DISABLE,
- SET_EVENT_RATE,
- FLUSH_SENSOR,
- CONFIGURE_CHANNEL
-};
-
-class BpSensorEventConnection : public BpInterface<ISensorEventConnection>
-{
-public:
- explicit BpSensorEventConnection(const sp<IBinder>& impl)
- : BpInterface<ISensorEventConnection>(impl)
- {
- }
-
- virtual ~BpSensorEventConnection();
-
- virtual sp<BitTube> getSensorChannel() const
- {
- Parcel data, reply;
- data.writeInterfaceToken(ISensorEventConnection::getInterfaceDescriptor());
- remote()->transact(GET_SENSOR_CHANNEL, data, &reply);
- return new BitTube(reply);
- }
-
- virtual status_t enableDisable(int handle, bool enabled, nsecs_t samplingPeriodNs,
- nsecs_t maxBatchReportLatencyNs, int reservedFlags)
- {
- Parcel data, reply;
- data.writeInterfaceToken(ISensorEventConnection::getInterfaceDescriptor());
- data.writeInt32(handle);
- data.writeInt32(enabled);
- data.writeInt64(samplingPeriodNs);
- data.writeInt64(maxBatchReportLatencyNs);
- data.writeInt32(reservedFlags);
- remote()->transact(ENABLE_DISABLE, data, &reply);
- return reply.readInt32();
- }
-
- virtual status_t setEventRate(int handle, nsecs_t ns)
- {
- Parcel data, reply;
- data.writeInterfaceToken(ISensorEventConnection::getInterfaceDescriptor());
- data.writeInt32(handle);
- data.writeInt64(ns);
- remote()->transact(SET_EVENT_RATE, data, &reply);
- return reply.readInt32();
- }
-
- virtual status_t flush() {
- Parcel data, reply;
- data.writeInterfaceToken(ISensorEventConnection::getInterfaceDescriptor());
- remote()->transact(FLUSH_SENSOR, data, &reply);
- return reply.readInt32();
- }
-
- virtual int32_t configureChannel(int32_t handle, int32_t rateLevel) {
- Parcel data, reply;
- data.writeInterfaceToken(ISensorEventConnection::getInterfaceDescriptor());
- data.writeInt32(handle);
- data.writeInt32(rateLevel);
- remote()->transact(CONFIGURE_CHANNEL, data, &reply);
- return reply.readInt32();
- }
-};
-
-// Out-of-line virtual method definition to trigger vtable emission in this
-// translation unit (see clang warning -Wweak-vtables)
-BpSensorEventConnection::~BpSensorEventConnection() {}
-
-IMPLEMENT_META_INTERFACE(SensorEventConnection, "android.gui.SensorEventConnection");
-
-// ----------------------------------------------------------------------------
-
-status_t BnSensorEventConnection::onTransact(
- uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
-{
- switch(code) {
- case GET_SENSOR_CHANNEL: {
- CHECK_INTERFACE(ISensorEventConnection, data, reply);
- sp<BitTube> channel(getSensorChannel());
- channel->writeToParcel(reply);
- return NO_ERROR;
- }
- case ENABLE_DISABLE: {
- CHECK_INTERFACE(ISensorEventConnection, data, reply);
- int handle = data.readInt32();
- int enabled = data.readInt32();
- nsecs_t samplingPeriodNs = data.readInt64();
- nsecs_t maxBatchReportLatencyNs = data.readInt64();
- int reservedFlags = data.readInt32();
- status_t result = enableDisable(handle, enabled, samplingPeriodNs,
- maxBatchReportLatencyNs, reservedFlags);
- reply->writeInt32(result);
- return NO_ERROR;
- }
- case SET_EVENT_RATE: {
- CHECK_INTERFACE(ISensorEventConnection, data, reply);
- int handle = data.readInt32();
- nsecs_t ns = data.readInt64();
- status_t result = setEventRate(handle, ns);
- reply->writeInt32(result);
- return NO_ERROR;
- }
- case FLUSH_SENSOR: {
- CHECK_INTERFACE(ISensorEventConnection, data, reply);
- status_t result = flush();
- reply->writeInt32(result);
- return NO_ERROR;
- }
- case CONFIGURE_CHANNEL: {
- CHECK_INTERFACE(ISensorEventConnection, data, reply);
- int handle = data.readInt32();
- int rateLevel = data.readInt32();
- status_t result = configureChannel(handle, rateLevel);
- reply->writeInt32(result);
- return NO_ERROR;
- }
-
- }
- return BBinder::onTransact(code, data, reply, flags);
-}
-
-// ----------------------------------------------------------------------------
-}; // namespace android
diff --git a/libs/gui/ISensorServer.cpp b/libs/gui/ISensorServer.cpp
deleted file mode 100644
index aea7403..0000000
--- a/libs/gui/ISensorServer.cpp
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <stdint.h>
-#include <sys/types.h>
-
-#include <cutils/native_handle.h>
-#include <utils/Errors.h>
-#include <utils/RefBase.h>
-#include <utils/Vector.h>
-#include <utils/Timers.h>
-
-#include <binder/Parcel.h>
-#include <binder/IInterface.h>
-
-#include <gui/Sensor.h>
-#include <gui/ISensorServer.h>
-#include <gui/ISensorEventConnection.h>
-
-namespace android {
-// ----------------------------------------------------------------------------
-
-enum {
- GET_SENSOR_LIST = IBinder::FIRST_CALL_TRANSACTION,
- CREATE_SENSOR_EVENT_CONNECTION,
- ENABLE_DATA_INJECTION,
- GET_DYNAMIC_SENSOR_LIST,
- CREATE_SENSOR_DIRECT_CONNECTION,
-};
-
-class BpSensorServer : public BpInterface<ISensorServer>
-{
-public:
- explicit BpSensorServer(const sp<IBinder>& impl)
- : BpInterface<ISensorServer>(impl)
- {
- }
-
- virtual ~BpSensorServer();
-
- virtual Vector<Sensor> getSensorList(const String16& opPackageName)
- {
- Parcel data, reply;
- data.writeInterfaceToken(ISensorServer::getInterfaceDescriptor());
- data.writeString16(opPackageName);
- remote()->transact(GET_SENSOR_LIST, data, &reply);
- Sensor s;
- Vector<Sensor> v;
- uint32_t n = reply.readUint32();
- v.setCapacity(n);
- while (n--) {
- reply.read(s);
- v.add(s);
- }
- return v;
- }
-
- virtual Vector<Sensor> getDynamicSensorList(const String16& opPackageName)
- {
- Parcel data, reply;
- data.writeInterfaceToken(ISensorServer::getInterfaceDescriptor());
- data.writeString16(opPackageName);
- remote()->transact(GET_DYNAMIC_SENSOR_LIST, data, &reply);
- Sensor s;
- Vector<Sensor> v;
- uint32_t n = reply.readUint32();
- v.setCapacity(n);
- while (n--) {
- reply.read(s);
- v.add(s);
- }
- return v;
- }
-
- virtual sp<ISensorEventConnection> createSensorEventConnection(const String8& packageName,
- int mode, const String16& opPackageName)
- {
- Parcel data, reply;
- data.writeInterfaceToken(ISensorServer::getInterfaceDescriptor());
- data.writeString8(packageName);
- data.writeInt32(mode);
- data.writeString16(opPackageName);
- remote()->transact(CREATE_SENSOR_EVENT_CONNECTION, data, &reply);
- return interface_cast<ISensorEventConnection>(reply.readStrongBinder());
- }
-
- virtual int isDataInjectionEnabled() {
- Parcel data, reply;
- data.writeInterfaceToken(ISensorServer::getInterfaceDescriptor());
- remote()->transact(ENABLE_DATA_INJECTION, data, &reply);
- return reply.readInt32();
- }
-
- virtual sp<ISensorEventConnection> createSensorDirectConnection(const String16& opPackageName,
- uint32_t size, int32_t type, int32_t format, const native_handle_t *resource) {
- Parcel data, reply;
- data.writeInterfaceToken(ISensorServer::getInterfaceDescriptor());
- data.writeString16(opPackageName);
- data.writeUint32(size);
- data.writeInt32(type);
- data.writeInt32(format);
- data.writeNativeHandle(resource);
- remote()->transact(CREATE_SENSOR_DIRECT_CONNECTION, data, &reply);
- return interface_cast<ISensorEventConnection>(reply.readStrongBinder());
- }
-};
-
-// Out-of-line virtual method definition to trigger vtable emission in this
-// translation unit (see clang warning -Wweak-vtables)
-BpSensorServer::~BpSensorServer() {}
-
-IMPLEMENT_META_INTERFACE(SensorServer, "android.gui.SensorServer");
-
-// ----------------------------------------------------------------------
-
-status_t BnSensorServer::onTransact(
- uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
-{
- switch(code) {
- case GET_SENSOR_LIST: {
- CHECK_INTERFACE(ISensorServer, data, reply);
- const String16& opPackageName = data.readString16();
- Vector<Sensor> v(getSensorList(opPackageName));
- size_t n = v.size();
- reply->writeUint32(static_cast<uint32_t>(n));
- for (size_t i = 0; i < n; i++) {
- reply->write(v[i]);
- }
- return NO_ERROR;
- }
- case CREATE_SENSOR_EVENT_CONNECTION: {
- CHECK_INTERFACE(ISensorServer, data, reply);
- String8 packageName = data.readString8();
- int32_t mode = data.readInt32();
- const String16& opPackageName = data.readString16();
- sp<ISensorEventConnection> connection(createSensorEventConnection(packageName, mode,
- opPackageName));
- reply->writeStrongBinder(IInterface::asBinder(connection));
- return NO_ERROR;
- }
- case ENABLE_DATA_INJECTION: {
- CHECK_INTERFACE(ISensorServer, data, reply);
- int32_t ret = isDataInjectionEnabled();
- reply->writeInt32(static_cast<int32_t>(ret));
- return NO_ERROR;
- }
- case GET_DYNAMIC_SENSOR_LIST: {
- CHECK_INTERFACE(ISensorServer, data, reply);
- const String16& opPackageName = data.readString16();
- Vector<Sensor> v(getDynamicSensorList(opPackageName));
- size_t n = v.size();
- reply->writeUint32(static_cast<uint32_t>(n));
- for (size_t i = 0; i < n; i++) {
- reply->write(v[i]);
- }
- return NO_ERROR;
- }
- case CREATE_SENSOR_DIRECT_CONNECTION: {
- CHECK_INTERFACE(ISensorServer, data, reply);
- const String16& opPackageName = data.readString16();
- uint32_t size = data.readUint32();
- int32_t type = data.readInt32();
- int32_t format = data.readInt32();
- native_handle_t *resource = data.readNativeHandle();
- sp<ISensorEventConnection> ch =
- createSensorDirectConnection(opPackageName, size, type, format, resource);
- native_handle_close(resource);
- native_handle_delete(resource);
- reply->writeStrongBinder(IInterface::asBinder(ch));
- return NO_ERROR;
- }
- }
- return BBinder::onTransact(code, data, reply, flags);
-}
-
-// ----------------------------------------------------------------------------
-}; // namespace android
diff --git a/libs/gui/Sensor.cpp b/libs/gui/Sensor.cpp
deleted file mode 100644
index e2f733a..0000000
--- a/libs/gui/Sensor.cpp
+++ /dev/null
@@ -1,584 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <inttypes.h>
-#include <stdint.h>
-#include <sys/limits.h>
-#include <sys/types.h>
-
-#include <binder/AppOpsManager.h>
-#include <binder/IServiceManager.h>
-#include <gui/Sensor.h>
-#include <hardware/sensors.h>
-#include <log/log.h>
-#include <utils/Errors.h>
-#include <utils/String8.h>
-#include <utils/Flattenable.h>
-
-// ----------------------------------------------------------------------------
-namespace android {
-// ----------------------------------------------------------------------------
-
-Sensor::Sensor(const char * name) :
- mName(name), mHandle(0), mType(0),
- mMinValue(0), mMaxValue(0), mResolution(0),
- mPower(0), mMinDelay(0), mVersion(0), mFifoReservedEventCount(0),
- mFifoMaxEventCount(0), mRequiredAppOp(0),
- mMaxDelay(0), mFlags(0) {
-}
-
-Sensor::Sensor(struct sensor_t const* hwSensor, int halVersion) :
- Sensor(*hwSensor, uuid_t(), halVersion) {
-}
-
-Sensor::Sensor(struct sensor_t const& hwSensor, const uuid_t& uuid, int halVersion) {
- mName = hwSensor.name;
- mVendor = hwSensor.vendor;
- mVersion = hwSensor.version;
- mHandle = hwSensor.handle;
- mType = hwSensor.type;
- mMinValue = 0; // FIXME: minValue
- mMaxValue = hwSensor.maxRange; // FIXME: maxValue
- mResolution = hwSensor.resolution;
- mPower = hwSensor.power;
- mMinDelay = hwSensor.minDelay;
- mFlags = 0;
- mUuid = uuid;
-
- // Set fifo event count zero for older devices which do not support batching. Fused
- // sensors also have their fifo counts set to zero.
- if (halVersion > SENSORS_DEVICE_API_VERSION_1_0) {
- mFifoReservedEventCount = hwSensor.fifoReservedEventCount;
- mFifoMaxEventCount = hwSensor.fifoMaxEventCount;
- } else {
- mFifoReservedEventCount = 0;
- mFifoMaxEventCount = 0;
- }
-
- if (halVersion >= SENSORS_DEVICE_API_VERSION_1_3) {
- if (hwSensor.maxDelay > INT_MAX) {
- // Max delay is declared as a 64 bit integer for 64 bit architectures. But it should
- // always fit in a 32 bit integer, log error and cap it to INT_MAX.
- ALOGE("Sensor maxDelay overflow error %s %" PRId64, mName.string(),
- static_cast<int64_t>(hwSensor.maxDelay));
- mMaxDelay = INT_MAX;
- } else {
- mMaxDelay = static_cast<int32_t>(hwSensor.maxDelay);
- }
- } else {
- // For older hals set maxDelay to 0.
- mMaxDelay = 0;
- }
-
- // Ensure existing sensors have correct string type, required permissions and reporting mode.
- // Set reportingMode for all android defined sensor types, set wake-up flag only for proximity
- // sensor, significant motion, tilt, pick_up gesture, wake gesture and glance gesture on older
- // HALs. Newer HALs can define both wake-up and non wake-up proximity sensors.
- // All the OEM defined defined sensors have flags set to whatever is provided by the HAL.
- switch (mType) {
- case SENSOR_TYPE_ACCELEROMETER:
- mStringType = SENSOR_STRING_TYPE_ACCELEROMETER;
- mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
- break;
- case SENSOR_TYPE_AMBIENT_TEMPERATURE:
- mStringType = SENSOR_STRING_TYPE_AMBIENT_TEMPERATURE;
- mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
- break;
- case SENSOR_TYPE_GAME_ROTATION_VECTOR:
- mStringType = SENSOR_STRING_TYPE_GAME_ROTATION_VECTOR;
- mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
- break;
- case SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR:
- mStringType = SENSOR_STRING_TYPE_GEOMAGNETIC_ROTATION_VECTOR;
- mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
- break;
- case SENSOR_TYPE_GRAVITY:
- mStringType = SENSOR_STRING_TYPE_GRAVITY;
- mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
- break;
- case SENSOR_TYPE_GYROSCOPE:
- mStringType = SENSOR_STRING_TYPE_GYROSCOPE;
- mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
- break;
- case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
- mStringType = SENSOR_STRING_TYPE_GYROSCOPE_UNCALIBRATED;
- mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
- break;
- case SENSOR_TYPE_HEART_RATE: {
- mStringType = SENSOR_STRING_TYPE_HEART_RATE;
- mRequiredPermission = SENSOR_PERMISSION_BODY_SENSORS;
- AppOpsManager appOps;
- mRequiredAppOp = appOps.permissionToOpCode(String16(SENSOR_PERMISSION_BODY_SENSORS));
- mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
- } break;
- case SENSOR_TYPE_LIGHT:
- mStringType = SENSOR_STRING_TYPE_LIGHT;
- mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
- break;
- case SENSOR_TYPE_LINEAR_ACCELERATION:
- mStringType = SENSOR_STRING_TYPE_LINEAR_ACCELERATION;
- mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
- break;
- case SENSOR_TYPE_MAGNETIC_FIELD:
- mStringType = SENSOR_STRING_TYPE_MAGNETIC_FIELD;
- mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
- break;
- case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED:
- mStringType = SENSOR_STRING_TYPE_MAGNETIC_FIELD_UNCALIBRATED;
- mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
- break;
- case SENSOR_TYPE_ORIENTATION:
- mStringType = SENSOR_STRING_TYPE_ORIENTATION;
- mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
- break;
- case SENSOR_TYPE_PRESSURE:
- mStringType = SENSOR_STRING_TYPE_PRESSURE;
- mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
- break;
- case SENSOR_TYPE_PROXIMITY:
- mStringType = SENSOR_STRING_TYPE_PROXIMITY;
- mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
- if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) {
- mFlags |= SENSOR_FLAG_WAKE_UP;
- }
- break;
- case SENSOR_TYPE_RELATIVE_HUMIDITY:
- mStringType = SENSOR_STRING_TYPE_RELATIVE_HUMIDITY;
- mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
- break;
- case SENSOR_TYPE_ROTATION_VECTOR:
- mStringType = SENSOR_STRING_TYPE_ROTATION_VECTOR;
- mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
- break;
- case SENSOR_TYPE_SIGNIFICANT_MOTION:
- mStringType = SENSOR_STRING_TYPE_SIGNIFICANT_MOTION;
- mFlags |= SENSOR_FLAG_ONE_SHOT_MODE;
- if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) {
- mFlags |= SENSOR_FLAG_WAKE_UP;
- }
- break;
- case SENSOR_TYPE_STEP_COUNTER:
- mStringType = SENSOR_STRING_TYPE_STEP_COUNTER;
- mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
- break;
- case SENSOR_TYPE_STEP_DETECTOR:
- mStringType = SENSOR_STRING_TYPE_STEP_DETECTOR;
- mFlags |= SENSOR_FLAG_SPECIAL_REPORTING_MODE;
- break;
- case SENSOR_TYPE_TEMPERATURE:
- mStringType = SENSOR_STRING_TYPE_TEMPERATURE;
- mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
- break;
- case SENSOR_TYPE_TILT_DETECTOR:
- mStringType = SENSOR_STRING_TYPE_TILT_DETECTOR;
- mFlags |= SENSOR_FLAG_SPECIAL_REPORTING_MODE;
- if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) {
- mFlags |= SENSOR_FLAG_WAKE_UP;
- }
- break;
- case SENSOR_TYPE_WAKE_GESTURE:
- mStringType = SENSOR_STRING_TYPE_WAKE_GESTURE;
- mFlags |= SENSOR_FLAG_ONE_SHOT_MODE;
- if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) {
- mFlags |= SENSOR_FLAG_WAKE_UP;
- }
- break;
- case SENSOR_TYPE_GLANCE_GESTURE:
- mStringType = SENSOR_STRING_TYPE_GLANCE_GESTURE;
- mFlags |= SENSOR_FLAG_ONE_SHOT_MODE;
- if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) {
- mFlags |= SENSOR_FLAG_WAKE_UP;
- }
- break;
- case SENSOR_TYPE_PICK_UP_GESTURE:
- mStringType = SENSOR_STRING_TYPE_PICK_UP_GESTURE;
- mFlags |= SENSOR_FLAG_ONE_SHOT_MODE;
- if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) {
- mFlags |= SENSOR_FLAG_WAKE_UP;
- }
- break;
- case SENSOR_TYPE_LOW_LATENCY_OFFBODY_DETECT:
- mStringType = SENSOR_STRING_TYPE_LOW_LATENCY_OFFBODY_DETECT;
- mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
- break;
- case SENSOR_TYPE_WRIST_TILT_GESTURE:
- mStringType = SENSOR_STRING_TYPE_WRIST_TILT_GESTURE;
- mFlags |= SENSOR_FLAG_SPECIAL_REPORTING_MODE;
- if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) {
- mFlags |= SENSOR_FLAG_WAKE_UP;
- }
- break;
- case SENSOR_TYPE_DYNAMIC_SENSOR_META:
- mStringType = SENSOR_STRING_TYPE_DYNAMIC_SENSOR_META;
- mFlags |= SENSOR_FLAG_SPECIAL_REPORTING_MODE; // special trigger
- if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) {
- mFlags |= SENSOR_FLAG_WAKE_UP;
- }
- break;
- case SENSOR_TYPE_POSE_6DOF:
- mStringType = SENSOR_STRING_TYPE_POSE_6DOF;
- mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
- break;
- case SENSOR_TYPE_STATIONARY_DETECT:
- mStringType = SENSOR_STRING_TYPE_STATIONARY_DETECT;
- mFlags |= SENSOR_FLAG_ONE_SHOT_MODE;
- if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) {
- mFlags |= SENSOR_FLAG_WAKE_UP;
- }
- break;
- case SENSOR_TYPE_MOTION_DETECT:
- mStringType = SENSOR_STRING_TYPE_MOTION_DETECT;
- mFlags |= SENSOR_FLAG_ONE_SHOT_MODE;
- if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) {
- mFlags |= SENSOR_FLAG_WAKE_UP;
- }
- break;
- case SENSOR_TYPE_HEART_BEAT:
- mStringType = SENSOR_STRING_TYPE_HEART_BEAT;
- mFlags |= SENSOR_FLAG_SPECIAL_REPORTING_MODE;
- break;
-
- // TODO: Placeholder for LLOB sensor type
-
-
- case SENSOR_TYPE_ACCELEROMETER_UNCALIBRATED:
- mStringType = SENSOR_STRING_TYPE_ACCELEROMETER_UNCALIBRATED;
- mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
- break;
- default:
- // Only pipe the stringType, requiredPermission and flags for custom sensors.
- if (halVersion > SENSORS_DEVICE_API_VERSION_1_0 && hwSensor.stringType) {
- mStringType = hwSensor.stringType;
- }
- if (halVersion > SENSORS_DEVICE_API_VERSION_1_0 && hwSensor.requiredPermission) {
- mRequiredPermission = hwSensor.requiredPermission;
- if (!strcmp(mRequiredPermission, SENSOR_PERMISSION_BODY_SENSORS)) {
- AppOpsManager appOps;
- mRequiredAppOp = appOps.permissionToOpCode(String16(SENSOR_PERMISSION_BODY_SENSORS));
- }
- }
-
- if (halVersion >= SENSORS_DEVICE_API_VERSION_1_3) {
- mFlags = static_cast<uint32_t>(hwSensor.flags);
- } else {
- // This is an OEM defined sensor on an older HAL. Use minDelay to determine the
- // reporting mode of the sensor.
- if (mMinDelay > 0) {
- mFlags |= SENSOR_FLAG_CONTINUOUS_MODE;
- } else if (mMinDelay == 0) {
- mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
- } else if (mMinDelay < 0) {
- mFlags |= SENSOR_FLAG_ONE_SHOT_MODE;
- }
- }
- break;
- }
-
- if (halVersion >= SENSORS_DEVICE_API_VERSION_1_3) {
- // Wake-up flag of HAL 1.3 and above is set here
- mFlags |= (hwSensor.flags & SENSOR_FLAG_WAKE_UP);
-
- // Log error if the reporting mode is not as expected, but respect HAL setting.
- int actualReportingMode = (hwSensor.flags & REPORTING_MODE_MASK) >> REPORTING_MODE_SHIFT;
- int expectedReportingMode = (mFlags & REPORTING_MODE_MASK) >> REPORTING_MODE_SHIFT;
- if (actualReportingMode != expectedReportingMode) {
- ALOGE("Reporting Mode incorrect: sensor %s handle=%#010" PRIx32 " type=%" PRId32 " "
- "actual=%d expected=%d",
- mName.string(), mHandle, mType, actualReportingMode, expectedReportingMode);
- }
- }
-
- // Feature flags
- // Set DYNAMIC_SENSOR_MASK and ADDITIONAL_INFO_MASK flag here. Compatible with HAL 1_3.
- if (halVersion >= SENSORS_DEVICE_API_VERSION_1_3) {
- mFlags |= hwSensor.flags & (DYNAMIC_SENSOR_MASK | ADDITIONAL_INFO_MASK);
- }
- // Set DIRECT_REPORT_MASK and DIRECT_CHANNEL_MASK flags. Compatible with HAL 1_3.
- if (halVersion >= SENSORS_DEVICE_API_VERSION_1_3) {
- // only on continuous sensors direct report mode is defined
- if ((mFlags & REPORTING_MODE_MASK) == SENSOR_FLAG_CONTINUOUS_MODE) {
- mFlags |= hwSensor.flags
- & (SENSOR_FLAG_MASK_DIRECT_REPORT | SENSOR_FLAG_MASK_DIRECT_CHANNEL);
- }
- }
- // Set DATA_INJECTION flag here. Defined in HAL 1_4.
- if (halVersion >= SENSORS_DEVICE_API_VERSION_1_4) {
- mFlags |= (hwSensor.flags & DATA_INJECTION_MASK);
- }
-
- if (mRequiredPermission.length() > 0) {
- // If the sensor is protected by a permission we need to know if it is
- // a runtime one to determine whether we can use the permission cache.
- sp<IBinder> binder = defaultServiceManager()->getService(String16("permission"));
- if (binder != 0) {
- sp<IPermissionController> permCtrl = interface_cast<IPermissionController>(binder);
- mRequiredPermissionRuntime = permCtrl->isRuntimePermission(
- String16(mRequiredPermission));
- }
- }
-}
-
-Sensor::~Sensor() {
-}
-
-const String8& Sensor::getName() const {
- return mName;
-}
-
-const String8& Sensor::getVendor() const {
- return mVendor;
-}
-
-int32_t Sensor::getHandle() const {
- return mHandle;
-}
-
-int32_t Sensor::getType() const {
- return mType;
-}
-
-float Sensor::getMinValue() const {
- return mMinValue;
-}
-
-float Sensor::getMaxValue() const {
- return mMaxValue;
-}
-
-float Sensor::getResolution() const {
- return mResolution;
-}
-
-float Sensor::getPowerUsage() const {
- return mPower;
-}
-
-int32_t Sensor::getMinDelay() const {
- return mMinDelay;
-}
-
-nsecs_t Sensor::getMinDelayNs() const {
- return getMinDelay() * 1000;
-}
-
-int32_t Sensor::getVersion() const {
- return mVersion;
-}
-
-uint32_t Sensor::getFifoReservedEventCount() const {
- return mFifoReservedEventCount;
-}
-
-uint32_t Sensor::getFifoMaxEventCount() const {
- return mFifoMaxEventCount;
-}
-
-const String8& Sensor::getStringType() const {
- return mStringType;
-}
-
-const String8& Sensor::getRequiredPermission() const {
- return mRequiredPermission;
-}
-
-bool Sensor::isRequiredPermissionRuntime() const {
- return mRequiredPermissionRuntime;
-}
-
-int32_t Sensor::getRequiredAppOp() const {
- return mRequiredAppOp;
-}
-
-int32_t Sensor::getMaxDelay() const {
- return mMaxDelay;
-}
-
-uint32_t Sensor::getFlags() const {
- return mFlags;
-}
-
-bool Sensor::isWakeUpSensor() const {
- return (mFlags & SENSOR_FLAG_WAKE_UP) != 0;
-}
-
-bool Sensor::isDynamicSensor() const {
- return (mFlags & SENSOR_FLAG_DYNAMIC_SENSOR) != 0;
-}
-
-bool Sensor::hasAdditionalInfo() const {
- return (mFlags & SENSOR_FLAG_ADDITIONAL_INFO) != 0;
-}
-
-int32_t Sensor::getHighestDirectReportRateLevel() const {
- return ((mFlags & SENSOR_FLAG_MASK_DIRECT_REPORT) >> SENSOR_FLAG_SHIFT_DIRECT_REPORT);
-}
-
-bool Sensor::isDirectChannelTypeSupported(int32_t sharedMemType) const {
- switch (sharedMemType) {
- case SENSOR_DIRECT_MEM_TYPE_ASHMEM:
- return mFlags & SENSOR_FLAG_DIRECT_CHANNEL_ASHMEM;
- case SENSOR_DIRECT_MEM_TYPE_GRALLOC:
- return mFlags & SENSOR_FLAG_DIRECT_CHANNEL_GRALLOC;
- default:
- return false;
- }
-}
-
-int32_t Sensor::getReportingMode() const {
- return ((mFlags & REPORTING_MODE_MASK) >> REPORTING_MODE_SHIFT);
-}
-
-const Sensor::uuid_t& Sensor::getUuid() const {
- return mUuid;
-}
-
-void Sensor::setId(int32_t id) {
- mUuid.i64[0] = id;
- mUuid.i64[1] = 0;
-}
-
-int32_t Sensor::getId() const {
- return int32_t(mUuid.i64[0]);
-}
-
-size_t Sensor::getFlattenedSize() const {
- size_t fixedSize =
- sizeof(mVersion) + sizeof(mHandle) + sizeof(mType) +
- sizeof(mMinValue) + sizeof(mMaxValue) + sizeof(mResolution) +
- sizeof(mPower) + sizeof(mMinDelay) + sizeof(mFifoMaxEventCount) +
- sizeof(mFifoMaxEventCount) + sizeof(mRequiredPermissionRuntime) +
- sizeof(mRequiredAppOp) + sizeof(mMaxDelay) + sizeof(mFlags) + sizeof(mUuid);
-
- size_t variableSize =
- sizeof(uint32_t) + FlattenableUtils::align<4>(mName.length()) +
- sizeof(uint32_t) + FlattenableUtils::align<4>(mVendor.length()) +
- sizeof(uint32_t) + FlattenableUtils::align<4>(mStringType.length()) +
- sizeof(uint32_t) + FlattenableUtils::align<4>(mRequiredPermission.length());
-
- return fixedSize + variableSize;
-}
-
-status_t Sensor::flatten(void* buffer, size_t size) const {
- if (size < getFlattenedSize()) {
- return NO_MEMORY;
- }
-
- flattenString8(buffer, size, mName);
- flattenString8(buffer, size, mVendor);
- FlattenableUtils::write(buffer, size, mVersion);
- FlattenableUtils::write(buffer, size, mHandle);
- FlattenableUtils::write(buffer, size, mType);
- FlattenableUtils::write(buffer, size, mMinValue);
- FlattenableUtils::write(buffer, size, mMaxValue);
- FlattenableUtils::write(buffer, size, mResolution);
- FlattenableUtils::write(buffer, size, mPower);
- FlattenableUtils::write(buffer, size, mMinDelay);
- FlattenableUtils::write(buffer, size, mFifoReservedEventCount);
- FlattenableUtils::write(buffer, size, mFifoMaxEventCount);
- flattenString8(buffer, size, mStringType);
- flattenString8(buffer, size, mRequiredPermission);
- FlattenableUtils::write(buffer, size, mRequiredPermissionRuntime);
- FlattenableUtils::write(buffer, size, mRequiredAppOp);
- FlattenableUtils::write(buffer, size, mMaxDelay);
- FlattenableUtils::write(buffer, size, mFlags);
- if (mUuid.i64[1] != 0) {
- // We should never hit this case with our current API, but we
- // could via a careless API change. If that happens,
- // this code will keep us from leaking our UUID (while probably
- // breaking dynamic sensors). See b/29547335.
- ALOGW("Sensor with UUID being flattened; sending 0. Expect "
- "bad dynamic sensor behavior");
- uuid_t tmpUuid; // default constructor makes this 0.
- FlattenableUtils::write(buffer, size, tmpUuid);
- } else {
- FlattenableUtils::write(buffer, size, mUuid);
- }
- return NO_ERROR;
-}
-
-status_t Sensor::unflatten(void const* buffer, size_t size) {
- if (!unflattenString8(buffer, size, mName)) {
- return NO_MEMORY;
- }
- if (!unflattenString8(buffer, size, mVendor)) {
- return NO_MEMORY;
- }
-
- size_t fixedSize1 =
- sizeof(mVersion) + sizeof(mHandle) + sizeof(mType) + sizeof(mMinValue) +
- sizeof(mMaxValue) + sizeof(mResolution) + sizeof(mPower) + sizeof(mMinDelay) +
- sizeof(mFifoMaxEventCount) + sizeof(mFifoMaxEventCount);
- if (size < fixedSize1) {
- return NO_MEMORY;
- }
-
- FlattenableUtils::read(buffer, size, mVersion);
- FlattenableUtils::read(buffer, size, mHandle);
- FlattenableUtils::read(buffer, size, mType);
- FlattenableUtils::read(buffer, size, mMinValue);
- FlattenableUtils::read(buffer, size, mMaxValue);
- FlattenableUtils::read(buffer, size, mResolution);
- FlattenableUtils::read(buffer, size, mPower);
- FlattenableUtils::read(buffer, size, mMinDelay);
- FlattenableUtils::read(buffer, size, mFifoReservedEventCount);
- FlattenableUtils::read(buffer, size, mFifoMaxEventCount);
-
- if (!unflattenString8(buffer, size, mStringType)) {
- return NO_MEMORY;
- }
- if (!unflattenString8(buffer, size, mRequiredPermission)) {
- return NO_MEMORY;
- }
-
- size_t fixedSize2 =
- sizeof(mRequiredPermissionRuntime) + sizeof(mRequiredAppOp) + sizeof(mMaxDelay) +
- sizeof(mFlags) + sizeof(mUuid);
- if (size < fixedSize2) {
- return NO_MEMORY;
- }
-
- FlattenableUtils::read(buffer, size, mRequiredPermissionRuntime);
- FlattenableUtils::read(buffer, size, mRequiredAppOp);
- FlattenableUtils::read(buffer, size, mMaxDelay);
- FlattenableUtils::read(buffer, size, mFlags);
- FlattenableUtils::read(buffer, size, mUuid);
- return NO_ERROR;
-}
-
-void Sensor::flattenString8(void*& buffer, size_t& size,
- const String8& string8) {
- uint32_t len = static_cast<uint32_t>(string8.length());
- FlattenableUtils::write(buffer, size, len);
- memcpy(static_cast<char*>(buffer), string8.string(), len);
- FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len));
-}
-
-bool Sensor::unflattenString8(void const*& buffer, size_t& size, String8& outputString8) {
- uint32_t len;
- if (size < sizeof(len)) {
- return false;
- }
- FlattenableUtils::read(buffer, size, len);
- if (size < len) {
- return false;
- }
- outputString8.setTo(static_cast<char const*>(buffer), len);
- FlattenableUtils::advance(buffer, size, FlattenableUtils::align<4>(len));
- return true;
-}
-
-// ----------------------------------------------------------------------------
-}; // namespace android
diff --git a/libs/gui/SensorEventQueue.cpp b/libs/gui/SensorEventQueue.cpp
deleted file mode 100644
index 6d69839..0000000
--- a/libs/gui/SensorEventQueue.cpp
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define LOG_TAG "Sensors"
-
-#include <algorithm>
-#include <stdint.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <linux/errno.h>
-
-#include <utils/Errors.h>
-#include <utils/RefBase.h>
-#include <utils/Looper.h>
-
-#include <gui/Sensor.h>
-#include <gui/BitTube.h>
-#include <gui/SensorEventQueue.h>
-#include <gui/ISensorEventConnection.h>
-
-#include <android/sensor.h>
-
-using std::min;
-
-// ----------------------------------------------------------------------------
-namespace android {
-// ----------------------------------------------------------------------------
-
-SensorEventQueue::SensorEventQueue(const sp<ISensorEventConnection>& connection)
- : mSensorEventConnection(connection), mRecBuffer(NULL), mAvailable(0), mConsumed(0),
- mNumAcksToSend(0) {
- mRecBuffer = new ASensorEvent[MAX_RECEIVE_BUFFER_EVENT_COUNT];
-}
-
-SensorEventQueue::~SensorEventQueue() {
- delete [] mRecBuffer;
-}
-
-void SensorEventQueue::onFirstRef()
-{
- mSensorChannel = mSensorEventConnection->getSensorChannel();
-}
-
-int SensorEventQueue::getFd() const
-{
- return mSensorChannel->getFd();
-}
-
-
-ssize_t SensorEventQueue::write(const sp<BitTube>& tube,
- ASensorEvent const* events, size_t numEvents) {
- return BitTube::sendObjects(tube, events, numEvents);
-}
-
-ssize_t SensorEventQueue::read(ASensorEvent* events, size_t numEvents) {
- if (mAvailable == 0) {
- ssize_t err = BitTube::recvObjects(mSensorChannel,
- mRecBuffer, MAX_RECEIVE_BUFFER_EVENT_COUNT);
- if (err < 0) {
- return err;
- }
- mAvailable = static_cast<size_t>(err);
- mConsumed = 0;
- }
- size_t count = min(numEvents, mAvailable);
- memcpy(events, mRecBuffer + mConsumed, count * sizeof(ASensorEvent));
- mAvailable -= count;
- mConsumed += count;
- return static_cast<ssize_t>(count);
-}
-
-sp<Looper> SensorEventQueue::getLooper() const
-{
- Mutex::Autolock _l(mLock);
- if (mLooper == 0) {
- mLooper = new Looper(true);
- mLooper->addFd(getFd(), getFd(), ALOOPER_EVENT_INPUT, NULL, NULL);
- }
- return mLooper;
-}
-
-status_t SensorEventQueue::waitForEvent() const
-{
- const int fd = getFd();
- sp<Looper> looper(getLooper());
-
- int events;
- int32_t result;
- do {
- result = looper->pollOnce(-1, NULL, &events, NULL);
- if (result == ALOOPER_POLL_ERROR) {
- ALOGE("SensorEventQueue::waitForEvent error (errno=%d)", errno);
- result = -EPIPE; // unknown error, so we make up one
- break;
- }
- if (events & ALOOPER_EVENT_HANGUP) {
- // the other-side has died
- ALOGE("SensorEventQueue::waitForEvent error HANGUP");
- result = -EPIPE; // unknown error, so we make up one
- break;
- }
- } while (result != fd);
-
- return (result == fd) ? status_t(NO_ERROR) : result;
-}
-
-status_t SensorEventQueue::wake() const
-{
- sp<Looper> looper(getLooper());
- looper->wake();
- return NO_ERROR;
-}
-
-status_t SensorEventQueue::enableSensor(Sensor const* sensor) const {
- return enableSensor(sensor, SENSOR_DELAY_NORMAL);
-}
-
-status_t SensorEventQueue::enableSensor(Sensor const* sensor, int32_t samplingPeriodUs) const {
- return mSensorEventConnection->enableDisable(sensor->getHandle(), true,
- us2ns(samplingPeriodUs), 0, 0);
-}
-
-status_t SensorEventQueue::disableSensor(Sensor const* sensor) const {
- return mSensorEventConnection->enableDisable(sensor->getHandle(), false, 0, 0, 0);
-}
-
-status_t SensorEventQueue::enableSensor(int32_t handle, int32_t samplingPeriodUs,
- int maxBatchReportLatencyUs, int reservedFlags) const {
- return mSensorEventConnection->enableDisable(handle, true, us2ns(samplingPeriodUs),
- us2ns(maxBatchReportLatencyUs), reservedFlags);
-}
-
-status_t SensorEventQueue::flush() const {
- return mSensorEventConnection->flush();
-}
-
-status_t SensorEventQueue::disableSensor(int32_t handle) const {
- return mSensorEventConnection->enableDisable(handle, false, 0, 0, false);
-}
-
-status_t SensorEventQueue::setEventRate(Sensor const* sensor, nsecs_t ns) const {
- return mSensorEventConnection->setEventRate(sensor->getHandle(), ns);
-}
-
-status_t SensorEventQueue::injectSensorEvent(const ASensorEvent& event) {
- do {
- // Blocking call.
- ssize_t size = ::send(mSensorChannel->getFd(), &event, sizeof(event), MSG_NOSIGNAL);
- if (size >= 0) {
- return NO_ERROR;
- } else if (size < 0 && errno == EAGAIN) {
- // If send is returning a "Try again" error, sleep for 100ms and try again. In all
- // other cases log a failure and exit.
- usleep(100000);
- } else {
- ALOGE("injectSensorEvent failure %s %zd", strerror(errno), size);
- return INVALID_OPERATION;
- }
- } while (true);
-}
-
-void SensorEventQueue::sendAck(const ASensorEvent* events, int count) {
- for (int i = 0; i < count; ++i) {
- if (events[i].flags & WAKE_UP_SENSOR_EVENT_NEEDS_ACK) {
- ++mNumAcksToSend;
- }
- }
- // Send mNumAcksToSend to acknowledge for the wake up sensor events received.
- if (mNumAcksToSend > 0) {
- ssize_t size = ::send(mSensorChannel->getFd(), &mNumAcksToSend, sizeof(mNumAcksToSend),
- MSG_DONTWAIT | MSG_NOSIGNAL);
- if (size < 0) {
- ALOGE("sendAck failure %zd %d", size, mNumAcksToSend);
- } else {
- mNumAcksToSend = 0;
- }
- }
- return;
-}
-
-// ----------------------------------------------------------------------------
-}; // namespace android
-
diff --git a/libs/gui/SensorManager.cpp b/libs/gui/SensorManager.cpp
deleted file mode 100644
index 513b889..0000000
--- a/libs/gui/SensorManager.cpp
+++ /dev/null
@@ -1,300 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define LOG_TAG "Sensors"
-
-#include <stdint.h>
-#include <sys/types.h>
-
-#include <cutils/native_handle.h>
-#include <utils/Errors.h>
-#include <utils/RefBase.h>
-#include <utils/Singleton.h>
-
-#include <binder/IBinder.h>
-#include <binder/IServiceManager.h>
-
-#include <gui/ISensorServer.h>
-#include <gui/ISensorEventConnection.h>
-#include <gui/Sensor.h>
-#include <gui/SensorManager.h>
-#include <gui/SensorEventQueue.h>
-
-// ----------------------------------------------------------------------------
-namespace android {
-// ----------------------------------------------------------------------------
-
-android::Mutex android::SensorManager::sLock;
-std::map<String16, SensorManager*> android::SensorManager::sPackageInstances;
-
-SensorManager& SensorManager::getInstanceForPackage(const String16& packageName) {
- Mutex::Autolock _l(sLock);
- SensorManager* sensorManager;
- std::map<String16, SensorManager*>::iterator iterator =
- sPackageInstances.find(packageName);
-
- if (iterator != sPackageInstances.end()) {
- sensorManager = iterator->second;
- } else {
- String16 opPackageName = packageName;
-
- // It is possible that the calling code has no access to the package name.
- // In this case we will get the packages for the calling UID and pick the
- // first one for attributing the app op. This will work correctly for
- // runtime permissions as for legacy apps we will toggle the app op for
- // all packages in the UID. The caveat is that the operation may be attributed
- // to the wrong package and stats based on app ops may be slightly off.
- if (opPackageName.size() <= 0) {
- sp<IBinder> binder = defaultServiceManager()->getService(String16("permission"));
- if (binder != 0) {
- const uid_t uid = IPCThreadState::self()->getCallingUid();
- Vector<String16> packages;
- interface_cast<IPermissionController>(binder)->getPackagesForUid(uid, packages);
- if (!packages.isEmpty()) {
- opPackageName = packages[0];
- } else {
- ALOGE("No packages for calling UID");
- }
- } else {
- ALOGE("Cannot get permission service");
- }
- }
-
- sensorManager = new SensorManager(opPackageName);
-
- // If we had no package name, we looked it up from the UID and the sensor
- // manager instance we created should also be mapped to the empty package
- // name, to avoid looking up the packages for a UID and get the same result.
- if (packageName.size() <= 0) {
- sPackageInstances.insert(std::make_pair(String16(), sensorManager));
- }
-
- // Stash the per package sensor manager.
- sPackageInstances.insert(std::make_pair(opPackageName, sensorManager));
- }
-
- return *sensorManager;
-}
-
-SensorManager::SensorManager(const String16& opPackageName)
- : mSensorList(0), mOpPackageName(opPackageName), mDirectConnectionHandle(1) {
- // okay we're not locked here, but it's not needed during construction
- assertStateLocked();
-}
-
-SensorManager::~SensorManager() {
- free(mSensorList);
-}
-
-void SensorManager::sensorManagerDied() {
- Mutex::Autolock _l(mLock);
- mSensorServer.clear();
- free(mSensorList);
- mSensorList = NULL;
- mSensors.clear();
-}
-
-status_t SensorManager::assertStateLocked() {
- bool initSensorManager = false;
- if (mSensorServer == NULL) {
- initSensorManager = true;
- } else {
- // Ping binder to check if sensorservice is alive.
- status_t err = IInterface::asBinder(mSensorServer)->pingBinder();
- if (err != NO_ERROR) {
- initSensorManager = true;
- }
- }
- if (initSensorManager) {
- // try for 300 seconds (60*5(getService() tries for 5 seconds)) before giving up ...
- const String16 name("sensorservice");
- for (int i = 0; i < 60; i++) {
- status_t err = getService(name, &mSensorServer);
- if (err == NAME_NOT_FOUND) {
- sleep(1);
- continue;
- }
- if (err != NO_ERROR) {
- return err;
- }
- break;
- }
-
- class DeathObserver : public IBinder::DeathRecipient {
- SensorManager& mSensorManager;
- virtual void binderDied(const wp<IBinder>& who) {
- ALOGW("sensorservice died [%p]", who.unsafe_get());
- mSensorManager.sensorManagerDied();
- }
- public:
- explicit DeathObserver(SensorManager& mgr) : mSensorManager(mgr) { }
- };
-
- LOG_ALWAYS_FATAL_IF(mSensorServer.get() == NULL, "getService(SensorService) NULL");
-
- mDeathObserver = new DeathObserver(*const_cast<SensorManager *>(this));
- IInterface::asBinder(mSensorServer)->linkToDeath(mDeathObserver);
-
- mSensors = mSensorServer->getSensorList(mOpPackageName);
- size_t count = mSensors.size();
- mSensorList =
- static_cast<Sensor const**>(malloc(count * sizeof(Sensor*)));
- LOG_ALWAYS_FATAL_IF(mSensorList == NULL, "mSensorList NULL");
-
- for (size_t i=0 ; i<count ; i++) {
- mSensorList[i] = mSensors.array() + i;
- }
- }
-
- return NO_ERROR;
-}
-
-ssize_t SensorManager::getSensorList(Sensor const* const** list) {
- Mutex::Autolock _l(mLock);
- status_t err = assertStateLocked();
- if (err < 0) {
- return static_cast<ssize_t>(err);
- }
- *list = mSensorList;
- return static_cast<ssize_t>(mSensors.size());
-}
-
-ssize_t SensorManager::getDynamicSensorList(Vector<Sensor> & dynamicSensors) {
- Mutex::Autolock _l(mLock);
- status_t err = assertStateLocked();
- if (err < 0) {
- return static_cast<ssize_t>(err);
- }
-
- dynamicSensors = mSensorServer->getDynamicSensorList(mOpPackageName);
- size_t count = dynamicSensors.size();
-
- return static_cast<ssize_t>(count);
-}
-
-Sensor const* SensorManager::getDefaultSensor(int type)
-{
- Mutex::Autolock _l(mLock);
- if (assertStateLocked() == NO_ERROR) {
- bool wakeUpSensor = false;
- // For the following sensor types, return a wake-up sensor. These types are by default
- // defined as wake-up sensors. For the rest of the sensor types defined in sensors.h return
- // a non_wake-up version.
- if (type == SENSOR_TYPE_PROXIMITY || type == SENSOR_TYPE_SIGNIFICANT_MOTION ||
- type == SENSOR_TYPE_TILT_DETECTOR || type == SENSOR_TYPE_WAKE_GESTURE ||
- type == SENSOR_TYPE_GLANCE_GESTURE || type == SENSOR_TYPE_PICK_UP_GESTURE ||
- type == SENSOR_TYPE_WRIST_TILT_GESTURE ||
- type == SENSOR_TYPE_LOW_LATENCY_OFFBODY_DETECT) {
- wakeUpSensor = true;
- }
- // For now we just return the first sensor of that type we find.
- // in the future it will make sense to let the SensorService make
- // that decision.
- for (size_t i=0 ; i<mSensors.size() ; i++) {
- if (mSensorList[i]->getType() == type &&
- mSensorList[i]->isWakeUpSensor() == wakeUpSensor) {
- return mSensorList[i];
- }
- }
- }
- return NULL;
-}
-
-sp<SensorEventQueue> SensorManager::createEventQueue(String8 packageName, int mode) {
- sp<SensorEventQueue> queue;
-
- Mutex::Autolock _l(mLock);
- while (assertStateLocked() == NO_ERROR) {
- sp<ISensorEventConnection> connection =
- mSensorServer->createSensorEventConnection(packageName, mode, mOpPackageName);
- if (connection == NULL) {
- // SensorService just died or the app doesn't have required permissions.
- ALOGE("createEventQueue: connection is NULL.");
- return NULL;
- }
- queue = new SensorEventQueue(connection);
- break;
- }
- return queue;
-}
-
-bool SensorManager::isDataInjectionEnabled() {
- Mutex::Autolock _l(mLock);
- if (assertStateLocked() == NO_ERROR) {
- return mSensorServer->isDataInjectionEnabled();
- }
- return false;
-}
-
-int SensorManager::createDirectChannel(
- size_t size, int channelType, const native_handle_t *resourceHandle) {
- Mutex::Autolock _l(mLock);
- if (assertStateLocked() != NO_ERROR) {
- return NO_INIT;
- }
-
- switch (channelType) {
- case SENSOR_DIRECT_MEM_TYPE_ASHMEM: {
- sp<ISensorEventConnection> conn =
- mSensorServer->createSensorDirectConnection(mOpPackageName,
- static_cast<uint32_t>(size),
- static_cast<int32_t>(channelType),
- SENSOR_DIRECT_FMT_SENSORS_EVENT, resourceHandle);
- if (conn == nullptr) {
- return NO_MEMORY;
- }
- int nativeHandle = mDirectConnectionHandle++;
- mDirectConnection.emplace(nativeHandle, conn);
- return nativeHandle;
- }
- case SENSOR_DIRECT_MEM_TYPE_GRALLOC:
- LOG_FATAL("%s: Finish implementation of ION and GRALLOC or remove", __FUNCTION__);
- return BAD_VALUE;
- default:
- ALOGE("Bad channel shared memory type %d", channelType);
- return BAD_VALUE;
- }
-}
-
-void SensorManager::destroyDirectChannel(int channelNativeHandle) {
- Mutex::Autolock _l(mLock);
- if (assertStateLocked() == NO_ERROR) {
- mDirectConnection.erase(channelNativeHandle);
- }
-}
-
-int SensorManager::configureDirectChannel(int channelNativeHandle, int sensorHandle, int rateLevel) {
- Mutex::Autolock _l(mLock);
- if (assertStateLocked() != NO_ERROR) {
- return NO_INIT;
- }
-
- auto i = mDirectConnection.find(channelNativeHandle);
- if (i == mDirectConnection.end()) {
- ALOGE("Cannot find the handle in client direct connection table");
- return BAD_VALUE;
- }
-
- int ret;
- ret = i->second->configureChannel(sensorHandle, rateLevel);
- ALOGE_IF(ret < 0, "SensorManager::configureChannel (%d, %d) returns %d",
- static_cast<int>(sensorHandle), static_cast<int>(rateLevel),
- static_cast<int>(ret));
- return ret;
-}
-
-// ----------------------------------------------------------------------------
-}; // namespace android
diff --git a/libs/gui/tests/Android.bp b/libs/gui/tests/Android.bp
index 5944110..4492a08 100644
--- a/libs/gui/tests/Android.bp
+++ b/libs/gui/tests/Android.bp
@@ -14,7 +14,6 @@
"GLTest.cpp",
"IGraphicBufferProducer_test.cpp",
"MultiTextureConsumer_test.cpp",
- "Sensor_test.cpp",
"StreamSplitter_test.cpp",
"SurfaceTextureClient_test.cpp",
"SurfaceTextureFBO_test.cpp",
diff --git a/libs/gui/tests/Sensor_test.cpp b/libs/gui/tests/Sensor_test.cpp
deleted file mode 100644
index fbf282d..0000000
--- a/libs/gui/tests/Sensor_test.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * Copyright (C) 2012 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define LOG_TAG "Sensor_test"
-
-#include <gui/Sensor.h>
-#include <hardware/sensors.h>
-#include <utils/Errors.h>
-
-#include <gtest/gtest.h>
-
-namespace android {
-
-// Returns true if the two sensors have the same attributes. Does not compare
-// UUID since that should not be transmitted via flatten/unflatten.
-static bool sensorsMatch(const Sensor& a, const Sensor& b) {
- return a.getName() == b.getName () &&
- a.getVendor() == b.getVendor () &&
- a.getHandle() == b.getHandle () &&
- a.getType() == b.getType () &&
- a.getMinValue() == b.getMinValue () &&
- a.getMaxValue() == b.getMaxValue () &&
- a.getResolution() == b.getResolution () &&
- a.getPowerUsage() == b.getPowerUsage () &&
- a.getMinDelay() == b.getMinDelay () &&
- a.getMinDelayNs() == b.getMinDelayNs () &&
- a.getVersion() == b.getVersion () &&
- a.getFifoReservedEventCount() == b.getFifoReservedEventCount () &&
- a.getFifoMaxEventCount() == b.getFifoMaxEventCount () &&
- a.getStringType() == b.getStringType () &&
- a.getRequiredPermission() == b.getRequiredPermission () &&
- a.isRequiredPermissionRuntime() == b.isRequiredPermissionRuntime () &&
- a.getRequiredAppOp() == b.getRequiredAppOp () &&
- a.getMaxDelay() == b.getMaxDelay () &&
- a.getFlags() == b.getFlags () &&
- a.isWakeUpSensor() == b.isWakeUpSensor () &&
- a.isDynamicSensor() == b.isDynamicSensor () &&
- a.hasAdditionalInfo() == b.hasAdditionalInfo () &&
- a.getReportingMode() == b.getReportingMode();
-}
-
-// Creates and returns a sensor_t struct with some default values filled in.
-static sensor_t getTestSensorT() {
- sensor_t hwSensor = {};
- hwSensor.name = "Test Sensor";
- hwSensor.vendor = "Test Vendor";
- hwSensor.version = 1;
- hwSensor.handle = 2;
- hwSensor.type = SENSOR_TYPE_ACCELEROMETER;
- hwSensor.maxRange = 10.f;
- hwSensor.resolution = 1.f;
- hwSensor.power = 5.f;
- hwSensor.minDelay = 1000;
- hwSensor.fifoReservedEventCount = 50;
- hwSensor.fifoMaxEventCount = 100;
- hwSensor.stringType = SENSOR_STRING_TYPE_ACCELEROMETER;
- hwSensor.requiredPermission = "";
- hwSensor.maxDelay = 5000;
- hwSensor.flags = SENSOR_FLAG_CONTINUOUS_MODE;
- return hwSensor;
-}
-
-TEST(SensorTest, FlattenAndUnflatten) {
- sensor_t hwSensor = getTestSensorT();
- Sensor sensor1(&hwSensor, SENSORS_DEVICE_API_VERSION_1_4);
- Sensor sensor2;
-
- std::vector<uint8_t> buffer(sensor1.getFlattenedSize());
- ASSERT_EQ(OK, sensor1.flatten(buffer.data(), buffer.size()));
- ASSERT_EQ(OK, sensor2.unflatten(buffer.data(), buffer.size()));
-
- EXPECT_TRUE(sensorsMatch(sensor1, sensor2));
-}
-
-} // namespace android