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

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;

};