Merge "Add trace for sensor event" into main (e5b8ea30) · Commits · e / os / android_frameworks_native

libs/sensor/Android.bp

+2 −0

Original line number	Diff line number	Diff line
		@@ -63,6 +63,8 @@ cc_library {
		"libhardware",
		"libpermission",
		"android.companion.virtual.virtualdevice_aidl-cpp",
		"libaconfig_storage_read_api_cc",
		"server_configurable_flags",
		],

		static_libs: [

libs/sensor/SensorEventQueue.cpp

+38 −15

Original line number	Diff line number	Diff line
		@@ -15,30 +15,39 @@
		*/

		#define LOG_TAG "Sensors"
		#define ATRACE_TAG ATRACE_TAG_SYSTEM_SERVER

		#include <android/sensor.h>
		#include <com_android_hardware_libsensor_flags.h>
		#include <cutils/trace.h>
		#include <hardware/sensors-base.h>
		#include <sensor/BitTube.h>
		#include <sensor/ISensorEventConnection.h>
		#include <sensor/Sensor.h>
		#include <sensor/SensorEventQueue.h>

		#include <algorithm>
		#include <sensor/SensorManager.h>
		#include <sys/socket.h>

		#include <utils/RefBase.h>
		#include <utils/Looper.h>
		#include <utils/RefBase.h>

		#include <sensor/Sensor.h>
		#include <sensor/BitTube.h>
		#include <sensor/ISensorEventConnection.h>

		#include <android/sensor.h>
		#include <hardware/sensors-base.h>
		#include <algorithm>
		#include <cinttypes>
		#include <string>

		using std::min;
		namespace libsensor_flags = com::android::hardware::libsensor::flags;

		// ----------------------------------------------------------------------------
		namespace android {
		// ----------------------------------------------------------------------------

		SensorEventQueue::SensorEventQueue(const sp<ISensorEventConnection>& connection)
		: mSensorEventConnection(connection), mRecBuffer(nullptr), mAvailable(0), mConsumed(0),
		SensorEventQueue::SensorEventQueue(const sp<ISensorEventConnection>& connection,
		SensorManager& sensorManager)
		: mSensorEventConnection(connection),
		mRecBuffer(nullptr),
		mSensorManager(sensorManager),
		mAvailable(0),
		mConsumed(0),
		mNumAcksToSend(0) {
		mRecBuffer = new ASensorEvent[MAX_RECEIVE_BUFFER_EVENT_COUNT];
		}
		@@ -65,8 +74,8 @@ ssize_t SensorEventQueue::write(const sp<BitTube>& tube,

		ssize_t SensorEventQueue::read(ASensorEvent* events, size_t numEvents) {
		if (mAvailable == 0) {
		ssize_t err = BitTube::recvObjects(mSensorChannel,
		mRecBuffer, MAX_RECEIVE_BUFFER_EVENT_COUNT);
		ssize_t err =
		BitTube::recvObjects(mSensorChannel, mRecBuffer, MAX_RECEIVE_BUFFER_EVENT_COUNT);
		if (err < 0) {
		return err;
		}
		@@ -75,6 +84,20 @@ ssize_t SensorEventQueue::read(ASensorEvent* events, size_t numEvents) {
		}
		size_t count = min(numEvents, mAvailable);
		memcpy(events, mRecBuffer + mConsumed, count * sizeof(ASensorEvent));

		if (CC_UNLIKELY(ATRACE_ENABLED()) &&
		libsensor_flags::sensor_event_queue_report_sensor_usage_in_tracing()) {
		for (size_t i = 0; i < count; i++) {
		std::optional<std::string_view> sensorName =
		mSensorManager.getSensorNameByHandle(events->sensor);
		if (sensorName.has_value()) {
		char buffer[UINT8_MAX];
		std::snprintf(buffer, sizeof(buffer), "Sensor event from %s",
		sensorName.value().data());
		ATRACE_INSTANT_FOR_TRACK(LOG_TAG, buffer);
		}
		}
		}
		mAvailable -= count;
		mConsumed += count;
		return static_cast<ssize_t>(count);

libs/sensor/SensorManager.cpp

+36 −1

Original line number	Diff line number	Diff line
		@@ -38,6 +38,7 @@
		#include <sensor/SensorEventQueue.h>

		#include <com_android_hardware_libsensor_flags.h>
		namespace libsensor_flags = com::android::hardware::libsensor::flags;

		// ----------------------------------------------------------------------------
		namespace android {
		@@ -78,6 +79,21 @@ int getDeviceIdForUid(uid_t uid) {
		return DEVICE_ID_DEFAULT;
		}

		bool findSensorNameInList(int32_t handle, const Vector<Sensor>& sensorList,
		std::string* outString) {
		for (auto& sensor : sensorList) {
		if (sensor.getHandle() == handle) {
		std::ostringstream oss;
		oss << sensor.getStringType() << ":" << sensor.getName();
		if (outString) {
		*outString = std::move(oss.str());
		}
		return true;
		}
		}
		return false;
		}

		} // namespace

		Mutex SensorManager::sLock;
		@@ -355,6 +371,25 @@ Sensor const* SensorManager::getDefaultSensor(int type)
		return nullptr;
		}

		std::optional<std::string_view> SensorManager::getSensorNameByHandle(int32_t handle) {
		std::lock_guard<std::mutex> lock(mSensorHandleToNameMutex);
		auto iterator = mSensorHandleToName.find(handle);
		if (iterator != mSensorHandleToName.end()) {
		return iterator->second;
		}

		std::string sensorName;
		if (!findSensorNameInList(handle, mSensors, &sensorName) &&
		!findSensorNameInList(handle, mDynamicSensors, &sensorName)) {
		ALOGW("Cannot find sensor with handle %d", handle);
		return std::nullopt;
		}

		mSensorHandleToName[handle] = std::move(sensorName);

		return mSensorHandleToName[handle];
		}

		sp<SensorEventQueue> SensorManager::createEventQueue(
		String8 packageName, int mode, String16 attributionTag) {
		sp<SensorEventQueue> queue;
		@@ -368,7 +403,7 @@ sp<SensorEventQueue> SensorManager::createEventQueue(
		ALOGE("createEventQueue: connection is NULL.");
		return nullptr;
		}
		queue = new SensorEventQueue(connection);
		queue = new SensorEventQueue(connection, *this);
		break;
		}
		return queue;

libs/sensor/include/sensor/SensorEventQueue.h

+4 −1

Original line number	Diff line number	Diff line
		@@ -42,6 +42,7 @@ namespace android {
		// ----------------------------------------------------------------------------

		class ISensorEventConnection;
		class SensorManager;
		class Sensor;
		class Looper;

		@@ -65,7 +66,8 @@ public:
		// Default sensor sample period
		static constexpr int32_t SENSOR_DELAY_NORMAL = 200000;

		explicit SensorEventQueue(const sp<ISensorEventConnection>& connection);
		explicit SensorEventQueue(const sp<ISensorEventConnection>& connection,
		SensorManager& sensorManager);
		virtual ~SensorEventQueue();
		virtual void onFirstRef();

		@@ -107,6 +109,7 @@ private:
		mutable Mutex mLock;
		mutable sp<Looper> mLooper;
		ASensorEvent* mRecBuffer;
		SensorManager& mSensorManager;
		size_t mAvailable;
		size_t mConsumed;
		uint32_t mNumAcksToSend;

libs/sensor/include/sensor/SensorManager.h

+11 −9

Original line number	Diff line number	Diff line
		@@ -17,22 +17,20 @@
		#ifndef ANDROID_GUI_SENSOR_MANAGER_H
		#define ANDROID_GUI_SENSOR_MANAGER_H

		#include <map>
		#include <unordered_map>

		#include <stdint.h>
		#include <sys/types.h>

		#include <binder/IBinder.h>
		#include <binder/IPCThreadState.h>
		#include <binder/IServiceManager.h>

		#include <sensor/SensorEventQueue.h>
		#include <stdint.h>
		#include <sys/types.h>
		#include <utils/Errors.h>
		#include <utils/String8.h>
		#include <utils/StrongPointer.h>
		#include <utils/Vector.h>
		#include <utils/String8.h>

		#include <sensor/SensorEventQueue.h>
		#include <map>
		#include <string>
		#include <unordered_map>

		// ----------------------------------------------------------------------------
		// Concrete types for the NDK
		@@ -66,6 +64,7 @@ public:
		sp<SensorEventQueue> createEventQueue(
		String8 packageName = String8(""), int mode = 0, String16 attributionTag = String16(""));
		bool isDataInjectionEnabled();
		std::optional<std::string_view> getSensorNameByHandle(int32_t handle);
		bool isReplayDataInjectionEnabled();
		bool isHalBypassReplayDataInjectionEnabled();
		int createDirectChannel(size_t size, int channelType, const native_handle_t *channelData);
		@@ -97,6 +96,9 @@ private:
		const String16 mOpPackageName;
		const int mDeviceId;
		std::unordered_map<int, sp<ISensorEventConnection>> mDirectConnection;

		std::mutex mSensorHandleToNameMutex;
		std::unordered_map<int32_t, std::string> mSensorHandleToName;
		int32_t mDirectConnectionHandle;
		};