Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 71df3978 authored by Rocky Fang's avatar Rocky Fang
Browse files

Add trace for sensor event

Test: collect trace for system server, see expected trace
Bug: 333132224
Flag: com.android.hardware.libsensor.flags.sensor_event_queue_report_sensor_usage_in_tracing
Change-Id: I066a150cdc85060e2530c3fc4ea4fa13c56af298
parent 4ae283aa
Loading
Loading
Loading
Loading
+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: [
+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);
+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;
+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;
+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;
};

Loading