添加一款新的 sensor_type 类型

哈哈哈，少年

已于 2023-10-08 13:19:02 修改

阅读量363

点赞数

分类专栏： sensor 文章标签： android c语言

于 2023-10-08 10:48:53 首次发布

本文链接：https://blog.csdn.net/weixin_42546931/article/details/133671049

版权

sensor 专栏收录该内容

23 篇文章 4 订阅

订阅专栏

添加一款新的 sensor_type 类型

adsp 这边的修改
sensors-see 修改
hardware 方面的修改
framework 的添加

adsp 这边的修改

xxx_publish_attributes
修改
char const type[] = “new_sensor_type”;

sensors-see 修改

我们要使用 QsensorTest.apk 。所以这边也要做下修改
sensors-see/QSensorTest/src/com/qualcomm/qti/sensors/core/qsensortest/SettingsDatabase.java

public enum TriggerMode {
    Continuous, OnChange, OneShot, Special;

    @SuppressWarnings("deprecation")
    public static TriggerMode getMode(Sensor sensor) {

      if(android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.LOLLIPOP) {
        if(Sensor.TYPE_ACCELEROMETER == sensor.getType() ||
           ........
          return TriggerMode.Continuous;
        else if(Sensor.TYPE_LIGHT == sensor.getType() ||
            Sensor.TYPE_PROXIMITY == sensor.getType() ||
            Sensor.TYPE_new_sensor_type == sensor.getType() ||    // add ++++++
           ............
          return TriggerMode.OnChange;

sensors-see/QSensorTest/src/com/qualcomm/qti/sensors/core/stream/SensorAdapter.java


static public String sensorTypeString(Sensor sensor)
  {
    String  sensorTypeString;
    switch (sensor.getType())
    {
    
    case Sensor.new_sensor_type:
      sensorTypeString = "new_sensor_type";
      break;

添加这个主要是为了解决 cts 的问题:
sensors-see/build_config/sns_vendor_product.mk

PRODUCT_COPY_FILES += \
    frameworks/native/data/etc/android.hardware.sensor.new_sensor_type.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/$(SNS_PRODUCT_SKU_PARROT)/android.hardware.sensor.new_sensor_type.xml \
endif

sensors-see/sensorcal-hidl-impl/SensorsCalibrate.cpp

std::string SensorsCalibrate::get_datatype(int32_t sensor_type, bool * primary) {
    
    switch (sensor_type) {
    
    case SENSOR_TYPE_new_sensor_type:
         data_type = "new_sensor_type";
         break;

接下来就是 sensors-hal 的修改。
放入 json 文件，对应的 sensor.cpp 文件

hardware 方面的修改

hardware/libhardware / include/hardware/context_hub.h

typedef enum {
    CONTEXT_SENSOR_RESERVED,             // 0
    CONTEXT_SENSOR_ACCELEROMETER,        // 1
    CONTEXT_SENSOR_GYROSCOPE,            // 2
    CONTEXT_SENSOR_MAGNETOMETER,         // 3
    CONTEXT_SENSOR_BAROMETER,            // 4
    CONTEXT_SENSOR_PROXIMITY_SENSOR,     // 5
    CONTEXT_SENSOR_AMBIENT_LIGHT_SENSOR, // 6
    CONTEXT_SENSOR_new_sensor_type,     // add +++++++++++++++++++
..........................
} context_sensor_e;

hardware/libhardware / include/hardware/sensors-base.h

enum {
    
    SENSOR_TYPE_WRIST_TILT_GESTURE = 26,
    SENSOR_TYPE_DEVICE_ORIENTATION = 27,
    SENSOR_TYPE_POSE_6DOF = 28,
    SENSOR_TYPE_STATIONARY_DETECT = 29,
    SENSOR_TYPE_MOTION_DETECT = 30,
    SENSOR_TYPE_HEART_BEAT = 31,
    SENSOR_TYPE_DYNAMIC_SENSOR_META = 32,
    SENSOR_TYPE_ADDITIONAL_INFO = 33,
    SENSOR_TYPE_LOW_LATENCY_OFFBODY_DETECT = 34,
    SENSOR_TYPE_ACCELEROMETER_UNCALIBRATED = 35,
    SENSOR_TYPE_HINGE_ANGLE = 36,
    SENSOR_TYPE_DEVICE_PRIVATE_BASE = 65536 /* 0x10000 */,
    SENSOR_TYPE_new_sensor_type = 65537,  // add +++++++++++++++++
};

hardware/libhardware / include/hardware/sensors.h

#define SENSOR_STRING_TYPE_LOW_LATENCY_OFFBODY_DETECT   "android.sensor.low_latency_offbody_detect"
#define SENSOR_STRING_TYPE_ACCELEROMETER_UNCALIBRATED   "android.sensor.accelerometer_uncalibrated"
#define SENSOR_STRING_TYPE_HINGE_ANGLE                  "android.sensor.hinge_angle"
#define SENSOR_STRING_TYPE_new_sensor_type             "com.symbol.sensor.new_sensor_type"

framework 的添加

frameworks/base / core/java/android/hardware/Sensor.java

  public static final int TYPE_ALL = -1;

    /**
     * The lowest sensor type vendor defined sensors can use.
     *
     * All vendor sensor types are greater than or equal to this constant.
     *
     */
    public static final int TYPE_DEVICE_PRIVATE_BASE = 0x10000;

    public static final int TYPE_new_sensor_type = 0x10001;

    public static final String STRING_TYPE_LONGDISTANCEPROX = "com.symbol.sensor.new_sensor_type"; // add +++++++

    // If this flag is set, the sensor defined as a wake up sensor. This field and REPORTING_MODE_*
    // constants are defined as flags in sensors.h. Modify at both places if needed.
    private static final int SENSOR_FLAG_WAKE_UP_SENSOR = 1;

....................
private static final int[] sSensorReportingModes = {
	
	  6, // SENSOR_TYPE_ACCELEROMETER_UNCALIBRATED
      1, // SENSOR_TYPE_HINGE_ANGLE
      1, // SENSOR_TYPE_new_sensor_type add++++++++++++++++++++++++++++++++++++++++++
}

 private boolean setType(int value) {
        mType = value;
        switch (mType) {
            case TYPE_ACCELEROMETER:
                mStringType = STRING_TYPE_ACCELEROMETER;
                return true;
	           case TYPE_new_sensor_type:   //  add+++++++++++++++++
                mStringType = STRING_TYPE_new_sensor_type; //  add +++++++++++++++        

}

frameworks/base / core/java/android/hardware/SensorManager.java


public Sensor getDefaultSensor(int type) {
        // TODO: need to be smarter, for now, just return the 1st sensor
        List<Sensor> l = getSensorList(type);
        boolean wakeUpSensor = false;
        if (type == Sensor.TYPE_PROXIMITY || type == Sensor.TYPE_SIGNIFICANT_MOTION
                || type == Sensor.TYPE_new_sensor_type   // add +++++++++++++++++++++++++++++++++++

添加对应的 sensor_type xml 文件
frameworks/native / data/etc/android.hardware.sensor.new_sensor_type.xml

frameworks/native / include/android/sensor.h

   ASENSOR_TYPE_ACCELEROMETER_UNCALIBRATED = 35,
    ASENSOR_TYPE_HINGE_ANGLE = 36,
   // add +++++++++++++++++
    ASENSOR_TYPE_new_sensor_type = 0x10001,

frameworks/native / include/input/InputDevice.h


/* Types of input device sensors. Keep sync with core/java/android/hardware/Sensor.java */
enum class InputDeviceSensorType : int32_t {
    
    MAGNETIC_FIELD_UNCALIBRATED = ASENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED,
    GAME_ROTATION_VECTOR = ASENSOR_TYPE_GAME_ROTATION_VECTOR,
    GYROSCOPE_UNCALIBRATED = ASENSOR_TYPE_GYROSCOPE_UNCALIBRATED,
    SIGNIFICANT_MOTION = ASENSOR_TYPE_SIGNIFICANT_MOTION,
    new_sensor_type = ASENSOR_TYPE_new_sensor_type,   // add ++++++++++++++++
};

frameworks/native / libs/input/KeyLayoutMap.cpp

static const std::unordered_map<std::string, InputDeviceSensorType> SENSOR_LIST =
        {{SENSOR_ENTRY(InputDeviceSensorType::ACCELEROMETER)},
         
         {SENSOR_ENTRY(InputDeviceSensorType::PROXIMITY)},
         {SENSOR_ENTRY(InputDeviceSensorType::new_sensor_type)},  // add ++++++++++
         {SENSOR_ENTRY(InputDeviceSensorType::GRAVITY)},
         {SENSOR_ENTRY(InputDeviceSensorType::SIGNIFICANT_MOTION)}};

frameworks/native / libs/sensor/Sensor.cpp

Sensor::Sensor(struct sensor_t const& hwSensor, const uuid_t& uuid, int halVersion) :
        Sensor("") {
    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;
     // add ++++        mFlag 要注意，什么类型的sensor 就写什么类型的.
    case SENSOR_TYPE_new_sensor_type:
        mStringType = SENSOR_STRING_TYPE_new_sensor_type;
        mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
        if (halVersion < SENSORS_DEVICE_API_VERSION_1_3) {
            mFlags |= SENSOR_FLAG_WAKE_UP;
        }
        break;

}

frameworks/native / libs/sensor/SensorManager.cpp


Sensor const* SensorManager::getDefaultSensor(int type)
{
	    Mutex::Autolock _l(mLock);
    if (assertStateLocked() == NO_ERROR) {
        bool wakeUpSensor = false;

        if (type == SENSOR_TYPE_PROXIMITY || type == SENSOR_TYPE_SIGNIFICANT_MOTION ||
            type == SENSOR_TYPE_new_sensor_type ||   // add +++++++++++++++++
 }

frameworks/native / libs/sensor/include/sensor/Sensor.h


class Sensor : public ASensor, public LightFlattenable<Sensor>
{
public:
    enum {
        TYPE_ACCELEROMETER  = ASENSOR_TYPE_ACCELEROMETER,
        TYPE_MAGNETIC_FIELD = ASENSOR_TYPE_MAGNETIC_FIELD,
        TYPE_GYROSCOPE      = ASENSOR_TYPE_GYROSCOPE,
        TYPE_LIGHT          = ASENSOR_TYPE_LIGHT,
        TYPE_PROXIMITY      = ASENSOR_TYPE_PROXIMITY,
        TYPE_new_sensor_type = ASENSOR_TYPE_new_sensor_type  // add ++++++++++++
    };

frameworks/native / services/sensorservice/RecentEventLogger.cpp

size_t RecentEventLogger::logSizeBySensorType(int sensorType) {
    if (sensorType == SENSOR_TYPE_STEP_COUNTER ||
        sensorType == SENSOR_TYPE_SIGNIFICANT_MOTION ||
        sensorType == SENSOR_TYPE_ACCELEROMETER ||
        sensorType == SENSOR_TYPE_LIGHT) {
        return LOG_SIZE_LARGE;
    }
    if (sensorType == SENSOR_TYPE_PROXIMITY  ||
        sensorType == SENSOR_TYPE_new_sensor_type ) {
        return LOG_SIZE_MED;
    }
    return LOG_SIZE;
}

frameworks/native / services/sensorservice/SensorDeviceUtils.cpp

void quantizeSensorEventValues(sensors_event_t *event, float resolution) {
    if (resolution == 0) {
        return;
    }

    size_t axes = 0;
    switch ((SensorTypeV2_1)event->type) {
        case SensorTypeV2_1::DEVICE_ORIENTATION:
        case SensorTypeV2_1::LIGHT:
        case SensorTypeV2_1::PRESSURE:
        case SensorTypeV2_1::TEMPERATURE:
        case SensorTypeV2_1::PROXIMITY:
        case SensorTypeV2_1::new_sensor_type:
        case SensorTypeV2_1::RELATIVE_HUMIDITY:

frameworks/native / services/sensorservice/SensorInterface.h

class ProximitySensor : public HardwareSensor {
public:
    explicit ProximitySensor(const sensor_t& sensor, SensorService& service);

    status_t activate(void* ident, bool enabled) override;

private:
    SensorService& mSensorService;
};

// add +++++++++++++

class new_sensor_type : public HardwareSensor {
public:
    explicit new_sensor_typeSensor(const sensor_t& sensor, SensorService& service);

    status_t activate(void* ident, bool enabled) override;

private:
    SensorService& mSensorService;
};

frameworks/native / services/sensorservice/SensorInterface.cpp


ProximitySensor::ProximitySensor(const sensor_t& sensor, SensorService& service)
        : HardwareSensor(sensor), mSensorService(service) {
}

status_t ProximitySensor::activate(void* ident, bool enabled) {
    status_t status = HardwareSensor::activate(ident, enabled);
    if (status != NO_ERROR) {
        return status;
    }
    mSensorService.checkAndReportProxStateChangeLocked();
    return NO_ERROR;
}

// ---------------------------------------------------------------------------

LongdistanceproxSensor::LongdistanceproxSensor(const sensor_t& sensor, SensorService& service)
        : HardwareSensor(sensor), mSensorService(service) {
}

status_t new_sensor_typeSensor::activate(void* ident, bool enabled) {
    status_t status = HardwareSensor::activate(ident, enabled);
    if (status != NO_ERROR) {
        return status;
    }
    mSensorService.checkAndReportnew_sensor_typeStateChangeLocked();
    return NO_ERROR;
}

frameworks/native / services/sensorservice/SensorService.h

 class ProximityActiveListener : public virtual RefBase {
    public:
        // Note that the callback is invoked from an async thread and can interact with the
        // SensorService directly.
        virtual void onProximityActive(bool isActive) = 0;
    };
  // add ++++++++++++++++++++++++
    class new_sensor_typeActiveListener : public virtual RefBase {
    public:
        virtual void onnew_sensor_typeActive(bool isActive) = 0;
    };

   // Call with mLock held.
    void checkAndReportProxStateChangeLocked();
    void notifyProximityStateLocked(const bool isActive,
                                    const std::vector<sp<ProximityActiveListener>>& listeners);
    // add +++++++++++++++++                                
    void checkAndReportnew_sensor_typeStateChangeLocked();
    void notifynew_sensor_typeStateLocked(const bool isActive,
                                    const std::vector<sp<new_sensor_typeActiveListener>>& listeners);


   status_t addProximityActiveListener(const sp<ProximityActiveListener>& callback) ANDROID_API;
    status_t removeProximityActiveListener(const sp<ProximityActiveListener>& callback) ANDROID_API;
    // add ++++++++++++
    status_t addnew_sensor_typeActiveListener(const sp<new_sensor_typeActiveListener>& callback) ANDROID_API;
    status_t removenew_sensor_typeActiveListener(const sp<new_sensor_typeActiveListener>& callback) ANDROID_API;

.................
    // Caps active direct connections (when the mic toggle is flipped to on)
    void capRates(userid_t userId);
    // Removes the capped rate on active direct connections (when the mic toggle is flipped to off)
    void uncapRates(userid_t userId);

    static uint8_t sHmacGlobalKey[128];
    static bool sHmacGlobalKeyIsValid;

    static std::atomic_uint64_t curProxCallbackSeq;
    static std::atomic_uint64_t curnew_sensor_typeCallbackSeq;  // add ++++++++++++++
    static std::atomic_uint64_t completedCallbackSeq;

  .....................
    // Map from user to SensorPrivacyPolicy
    std::map<userid_t, sp<SensorPrivacyPolicy>> mMicSensorPrivacyPolicies;
    // Checks if the mic sensor privacy is enabled for the uid
    bool isMicSensorPrivacyEnabledForUid(uid_t uid);

    // Keeps track of the handles of all proximity sensors in the system.
    std::vector<int32_t> mProxSensorHandles;
    // The last proximity sensor active state reported to listeners.
    bool mLastReportedProxIsActive;
    // Listeners subscribed to receive updates on the proximity sensor active state.
    std::vector<sp<ProximityActiveListener>> mProximityActiveListeners;
    // add ++++++++++++++++
    std::vector<int32_t> mnew_sensor_typeSensorHandles;
    bool mLastReportednew_sensor_typeIsActive;
    std::vector<sp<new_sensor_typeActiveListener>> mnew_sensor_typeActiveListeners;

frameworks/native / services/sensorservice/SensorService.cpp


std::atomic_uint64_t SensorService::curProxCallbackSeq(0);
std::atomic_uint64_t SensorService::curnew_sensor_typeCallbackSeq(0); // add ++++++++++++
std::atomic_uint64_t SensorService::completedCallbackSeq(0);

...............

 if (useThisSensor) {
                    if (list[i].type == SENSOR_TYPE_PROXIMITY) {
                        SensorInterface* s = new ProximitySensor(list[i], *this);
                        registerSensor(s);
                        mProxSensorHandles.push_back(s->getSensor().getHandle());
                    } else if (list[i].type == SENSOR_TYPE_new_sensor_type) {   // add ++++++++++++++
                        SensorInterface* s = new new_sensor_typeSensor(list[i], *this);  // add ++++++++++++++ 
                        registerSensor(s);                                               //  add ++++++++++++++
                        mLongdistanceproxSensorHandles.push_back(s->getSensor().getHandle());  // add ++++++++++++++
                    } else {
                        registerSensor(new HardwareSensor(list[i]));
                    }
                }
            }

            // it's safe to instantiate the SensorFusion object here
            // (it wants to be instantiated after h/w sensors have been
            // registered)
            SensorFusion::getInstance();

..................................
status_t SensorService::removeProximityActiveListener(
        const sp<ProximityActiveListener>& callback) {
    if (callback == nullptr) {
        return BAD_VALUE;
    }

    Mutex::Autolock _l(mLock);

    for (auto iter = mProximityActiveListeners.begin();
         iter != mProximityActiveListeners.end();
         ++iter) {
        if (*iter == callback) {
            mProximityActiveListeners.erase(iter);
            return OK;
        }
    }
    return NAME_NOT_FOUND;
}

// add ++++   start ............
void SensorService::checkAndReportnew_sensor_typeStateChangeLocked() {
    if (mnew_sensor_typeSensorHandles.empty()) return;

    SensorDevice& dev(SensorDevice::getInstance());
    bool isActive = false;
    for (auto& sensor : mnew_sensor_typeSensorHandles) {
        if (dev.isSensorActive(sensor)) {
            isActive = true;
            break;
        }
    }
    if (isActive != mLastReportednew_sensor_typeIsActive) {
        notifynew_sensor_typeStateLocked(isActive, mnew_sensor_typeActiveListeners);
        mLastReportednew_sensor_typeIsActive = isActive;
    }
}

void SensorService::notifynew_sensor_typeStateLocked(
        const bool isActive,
        const std::vector<sp<new_sensor_typeActiveListener>>& listeners) {
    const uint64_t mySeq = ++curnew_sensor_typeCallbackSeq;
    std::thread t([isActive, mySeq, listenersCopy = listeners]() {
        while (completedCallbackSeq.load() != mySeq - 1)
            std::this_thread::sleep_for(1ms);
        for (auto& listener : listenersCopy)
            listener->onnew_sensor_typeActive(isActive);
        completedCallbackSeq++;
    });
    t.detach();
}

status_t SensorService::addnew_sensor_typeActiveListener(const sp<new_sensor_typeActiveListener>& callback) {
    if (callback == nullptr) {
        return BAD_VALUE;
    }

    Mutex::Autolock _l(mLock);

    // Check if the callback was already added.
    for (const auto& cb : mnew_sensor_typeActiveListeners) {
        if (cb == callback) {
            return ALREADY_EXISTS;
        }
    }

    mnew_sensor_typeActiveListeners.push_back(callback);
    std::vector<sp<new_sensor_typeActiveListener>> listener(1, callback);
    notifynew_sensor_typeStateLocked(mLastReportednew_sensor_typeIsActive, listener);
    return OK;
}

status_t SensorService::removenew_sensor_typeActiveListener(
        const sp<new_sensor_typeActiveListener>& callback) {
    if (callback == nullptr) {
        return BAD_VALUE;
    }

    Mutex::Autolock _l(mLock);

    for (auto iter = mnew_sensor_typeActiveListeners.begin();
         iter != mnew_sensor_typeActiveListeners.end();
         ++iter) {
        if (*iter == callback) {
            mnew_sensor_typeActiveListeners.erase(iter);
            return OK;
        }
    }
    return NAME_NOT_FOUND;
}

// add ++++   end ............


完成。  framework 的添加比较麻烦点..