From 975e2500d3562afd97c6b10eaec4bfbff25a99af Mon Sep 17 00:00:00 2001 From: zj94 Date: Mon, 23 Sep 2024 20:12:47 +0800 Subject: [PATCH] [cj]: support cj api Signed-off-by: zj94 Change-Id: Ib9fc4016d36637c8665356760850990b8899111f --- bundle.json | 1 + frameworks/cj/BUILD.gn | 55 +++ frameworks/cj/include/cj_sensor_ffi.h | 105 ++++++ frameworks/cj/include/cj_sensor_impl.h | 79 ++++ frameworks/cj/include/cj_sensor_visibility.h | 23 ++ frameworks/cj/src/cj_sensor_ffi.cpp | 118 ++++++ frameworks/cj/src/cj_sensor_impl.cpp | 374 +++++++++++++++++++ 7 files changed, 755 insertions(+) create mode 100644 frameworks/cj/BUILD.gn create mode 100644 frameworks/cj/include/cj_sensor_ffi.h create mode 100644 frameworks/cj/include/cj_sensor_impl.h create mode 100644 frameworks/cj/include/cj_sensor_visibility.h create mode 100644 frameworks/cj/src/cj_sensor_ffi.cpp create mode 100644 frameworks/cj/src/cj_sensor_impl.cpp diff --git a/bundle.json b/bundle.json index 197e29b7..b5207319 100755 --- a/bundle.json +++ b/bundle.json @@ -41,6 +41,7 @@ "base_group": [], "fwk_group": [ "//base/sensors/sensor/frameworks/js/napi:sensor_js_target", + "//base/sensors/sensor/frameworks/cj:cj_sensor_ffi", "//base/sensors/sensor/frameworks/native:sensor_target", "//base/sensors/sensor/frameworks/native:ohsensor", "//base/sensors/sensor/utils:sensor_utils_target" diff --git a/frameworks/cj/BUILD.gn b/frameworks/cj/BUILD.gn new file mode 100644 index 00000000..7198ec1e --- /dev/null +++ b/frameworks/cj/BUILD.gn @@ -0,0 +1,55 @@ +# Copyright (c) 2024 Huawei Device Co., Ltd. +# 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. + +import("//build/ohos.gni") +import("./../../sensor.gni") + +ohos_shared_library("cj_sensor_ffi") { + branch_protector_ret = "pac_ret" + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } + + cflags = [ + "-fdata-sections", + "-ffunction-sections", + "-fvisibility=hidden", + ] + + include_dirs = [ + "$SUBSYSTEM_DIR/frameworks/native/include", + "$SUBSYSTEM_DIR/interfaces/inner_api", + "$SUBSYSTEM_DIR/utils/common/include", + "include", + ] + + sources = [ + "src/cj_sensor_ffi.cpp", + "src/cj_sensor_impl.cpp", + ] + + deps = [ "$SUBSYSTEM_DIR/frameworks/native:sensor_interface_native" ] + + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + "napi:cj_bind_ffi", + "napi:cj_bind_native", + ] + + innerapi_tags = [ "platformsdk" ] + part_name = "sensor" + subsystem_name = "sensors" +} diff --git a/frameworks/cj/include/cj_sensor_ffi.h b/frameworks/cj/include/cj_sensor_ffi.h new file mode 100644 index 00000000..7296d134 --- /dev/null +++ b/frameworks/cj/include/cj_sensor_ffi.h @@ -0,0 +1,105 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * 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. + */ + +#ifndef OHOS_CJ_SENSOR_FFI_H +#define OHOS_CJ_SENSOR_FFI_H + +#include + +#include "cj_sensor_visibility.h" +#include "sensor_agent_type.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif + +typedef struct { + float latitude; + float longitude; + float altitude; +} CLocationOptions; + +typedef struct { + float x; + float y; + float z; + float geomagneticDip; + float deflectionAngle; + float levelIntensity; + float totalIntensity; +} CGeomagneticData; + +typedef struct { + float *head; + int64_t size; +} CArrFloat32; + +typedef struct { + int32_t x; + int32_t y; +} CCoordinatesOptions; + +typedef struct { + CArrFloat32 rotation; + CArrFloat32 inclination; +} CRotationMatrixResponse; + +typedef struct CSensor { + char *sensorName; + char *vendorName; + char *firmwareVersion; + char *hardwareVersion; + int32_t sensorTypeId; + float maxRange; + int64_t minSamplePeriod; + int64_t maxSamplePeriod; + float precision; + float power; +} CSensor; + +typedef struct { + CSensor *head; + int64_t size; +} CSensorArray; + +SENSOR_FFI_EXPORT int32_t FfiSensorSubscribeSensor(int32_t sensorId, int64_t interval, + void (*callback)(SensorEvent *event)); + +SENSOR_FFI_EXPORT int32_t FfiSensorUnSubscribeSensor(int32_t sensorId); +SENSOR_FFI_EXPORT CGeomagneticData FfiSensorGetGeomagneticInfo(CLocationOptions location, int64_t timeMillis); +SENSOR_FFI_EXPORT int32_t FfiSensorGetDeviceAltitude(float seaPressure, float currentPressure, float *altitude); +SENSOR_FFI_EXPORT int32_t FfiSensorGetInclination(CArrFloat32 inclinationMatrix, float *inclination); +SENSOR_FFI_EXPORT int32_t FfiSensorGetAngleVariation(CArrFloat32 currentRotationMatrix, CArrFloat32 preRotationMatrix, + CArrFloat32 *angleChange); +SENSOR_FFI_EXPORT int32_t FfiSensorGetRotationMatrix(CArrFloat32 rotationVector, CArrFloat32 *rotation); +SENSOR_FFI_EXPORT int32_t FfiSensorTransformRotationMatrix(CArrFloat32 inRotationVector, + CCoordinatesOptions coordinates, + CArrFloat32 *rotationMatrix); +SENSOR_FFI_EXPORT int32_t FfiSensorGetQuaternion(CArrFloat32 rotationVector, CArrFloat32 *quaternion); +SENSOR_FFI_EXPORT int32_t FfiSensorGetOrientation(CArrFloat32 rotationMatrix, CArrFloat32 *rotationAngle); +SENSOR_FFI_EXPORT int32_t FfiSensorGetRotationMatrixByGravityAndGeomagnetic(CArrFloat32 gravity, + CArrFloat32 geomagnetic, + CRotationMatrixResponse *rotationMaxtrix); +SENSOR_FFI_EXPORT int32_t FfiSensorGetAllSensors(CSensorArray *sensors); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif +#endif /* OHOS_CJ_SENSOR_FFI_H */ +/**< @} */ diff --git a/frameworks/cj/include/cj_sensor_impl.h b/frameworks/cj/include/cj_sensor_impl.h new file mode 100644 index 00000000..95200c9e --- /dev/null +++ b/frameworks/cj/include/cj_sensor_impl.h @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * 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. + */ + +#ifndef OHOS_CJ_SENSOR_IMPL_H +#define OHOS_CJ_SENSOR_IMPL_H + +#include +#include +#include + +#include "cj_sensor_ffi.h" +#include "sensor_agent_type.h" +#include "singleton.h" + +namespace OHOS { +namespace Sensors { +using SensorCallbackType = std::function; + +class CJSensorImpl { + DECLARE_DELAYED_SINGLETON(CJSensorImpl); + +public: + DISALLOW_COPY_AND_MOVE(CJSensorImpl); + int32_t OnSensorChange(int32_t sensorId, int64_t interval, void (*callback)(SensorEvent *event)); + int32_t OffSensorChange(int32_t sensorId); + void EmitCallBack(SensorEvent *event); + + CGeomagneticData GetGeomagneticInfo(CLocationOptions location, int64_t timeMillis); + int32_t GetAltitude(float seaPressure, float currentPressure, float *altitude); + int32_t GetGeomagneticDip(CArrFloat32 inclinationMatrix, float *geomagneticDip); + int32_t GetAngleModify(const CArrFloat32 &curRotationMatrix, const CArrFloat32 &preRotationMatrix, + CArrFloat32 *angleChange); + int32_t GetRotationMatrix(const CArrFloat32 &rotationCArr, CArrFloat32 &rotation); + int32_t TransformRotationMatrix(const CArrFloat32 &rotationCArr, int32_t axisX, int32_t axisY, + CArrFloat32 &outRotationMatrix); + int32_t GetQuaternion(const CArrFloat32 &rotationVector, CArrFloat32 &quaternionOut); + int32_t GetOrientation(const CArrFloat32 &rotationMatrix, CArrFloat32 &rotationAngleOut); + int32_t GetRotationMatrixByGraityAndGeomagnetic(const CArrFloat32 gravity, const CArrFloat32 geomagnetic, + CArrFloat32 &rotationMatrix, CArrFloat32 &inclinationMatrix); + int32_t GetAllSensorList(CSensorArray &sensorList); + +private: + std::map eventMap_; + std::mutex mutex_; + + int32_t SubscribeSensorImpl(int32_t sensorId, int64_t interval); + int32_t UnsubscribeSensorImpl(int32_t sensorTypeId); + + void DelCallback(int32_t type); + void AddCallback2Map(int32_t type, SensorCallbackType callback); + std::optional FindCallback(int32_t type); + + char *MallocCString(const std::string origin); + void Transform2CSensor(const SensorInfo &in, CSensor &out); + std::vector ConvertCArr2Vector(const CArrFloat32 &in); + CArrFloat32 ConvertVector2CArr(const std::vector &in); + + static void CJDataCallbackImpl(SensorEvent *event); + const SensorUser cjUser_ = {.callback = CJDataCallbackImpl}; +}; + +#define CJ_SENSOR_IMPL OHOS::DelayedSingleton::GetInstance() + +} // namespace Sensors +} // namespace OHOS + +#endif // OHOS_CJ_SENSOR_IMPL_H \ No newline at end of file diff --git a/frameworks/cj/include/cj_sensor_visibility.h b/frameworks/cj/include/cj_sensor_visibility.h new file mode 100644 index 00000000..4566e4f3 --- /dev/null +++ b/frameworks/cj/include/cj_sensor_visibility.h @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * 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. + */ + +#ifndef OHOS_CJ_SENSOR_VISIBILITY_H +#define OHOS_CJ_SENSOR_VISIBILITY_H + +#ifndef SENSOR_FFI_EXPORT +#define SENSOR_FFI_EXPORT __attribute__((visibility("default"))) +#endif + +#endif // OHOS_CJ_SENSOR_VISIBILITY_H diff --git a/frameworks/cj/src/cj_sensor_ffi.cpp b/frameworks/cj/src/cj_sensor_ffi.cpp new file mode 100644 index 00000000..da441cf1 --- /dev/null +++ b/frameworks/cj/src/cj_sensor_ffi.cpp @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * 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 "cj_sensor_ffi.h" + +#include "cj_sensor_impl.h" +#include "sensor_errors.h" + +using OHOS::Sensors::CJSensorImpl; +using OHOS::Sensors::PARAMETER_ERROR; + +extern "C" { +int32_t FfiSensorSubscribeSensor(int32_t sensorId, int64_t interval, void (*callback)(SensorEvent *event)) +{ + return CJ_SENSOR_IMPL->OnSensorChange(sensorId, interval, callback); +} + +int32_t FfiSensorUnSubscribeSensor(int32_t sensorId) +{ + return CJ_SENSOR_IMPL->OffSensorChange(sensorId); +} + +CGeomagneticData FfiSensorGetGeomagneticInfo(CLocationOptions location, int64_t timeMillis) +{ + return CJ_SENSOR_IMPL->GetGeomagneticInfo(location, timeMillis); +} + +int32_t FfiSensorGetDeviceAltitude(float seaPressure, float currentPressure, float *altitude) +{ + return CJ_SENSOR_IMPL->GetAltitude(seaPressure, currentPressure, altitude); +} + +int32_t FfiSensorGetInclination(CArrFloat32 inclinationMatrix, float *geomagneticDip) +{ + return CJ_SENSOR_IMPL->GetGeomagneticDip(inclinationMatrix, geomagneticDip); +} + +int32_t FfiSensorGetAngleVariation(CArrFloat32 currentRotationMatrix, CArrFloat32 preRotationMatrix, + CArrFloat32 *angleChange) +{ + return CJ_SENSOR_IMPL->GetAngleModify(currentRotationMatrix, preRotationMatrix, angleChange); +} + +int32_t FfiSensorGetRotationMatrix(CArrFloat32 rotationVector, CArrFloat32 *rotation) +{ + if (rotation == nullptr) { + SEN_HILOGE("Invalid parameter, rotation is nullptr!"); + return PARAMETER_ERROR; + } + + return CJ_SENSOR_IMPL->GetRotationMatrix(rotationVector, *rotation); +} + +int32_t FfiSensorTransformRotationMatrix(CArrFloat32 inRotationVector, CCoordinatesOptions coordinates, + CArrFloat32 *rotationMatrix) +{ + if (rotationMatrix == nullptr) { + SEN_HILOGE("Invalid parameter, rotationMatrix is nullptr!"); + return PARAMETER_ERROR; + } + + return CJ_SENSOR_IMPL->TransformRotationMatrix(inRotationVector, coordinates.x, coordinates.y, *rotationMatrix); +} + +int32_t FfiSensorGetQuaternion(CArrFloat32 rotationVector, CArrFloat32 *quaternion) +{ + if (quaternion == nullptr) { + SEN_HILOGE("Invalid parameter, quaternion is nullptr!"); + return PARAMETER_ERROR; + } + + return CJ_SENSOR_IMPL->GetQuaternion(rotationVector, *quaternion); +} + +int32_t FfiSensorGetOrientation(CArrFloat32 rotationMatrix, CArrFloat32 *rotationAngle) +{ + if (rotationAngle == nullptr) { + SEN_HILOGE("Invalid parameter, rotationAngle is nullptr!"); + return PARAMETER_ERROR; + } + + return CJ_SENSOR_IMPL->GetOrientation(rotationMatrix, *rotationAngle); +} + +int32_t FfiSensorGetRotationMatrixByGravityAndGeomagnetic(CArrFloat32 gravity, CArrFloat32 geomagnetic, + CRotationMatrixResponse *rotationMaxtrix) +{ + if (rotationMaxtrix == nullptr) { + SEN_HILOGE("Invalid parameter, rotationMaxtrix is nullptr!"); + return PARAMETER_ERROR; + } + + return CJ_SENSOR_IMPL->GetRotationMatrixByGraityAndGeomagnetic(gravity, geomagnetic, rotationMaxtrix->rotation, + rotationMaxtrix->inclination); +} + +int32_t FfiSensorGetAllSensors(CSensorArray *sensors) +{ + if (sensors == nullptr) { + SEN_HILOGE("Invalid parameter, sensors is nullptr!"); + return PARAMETER_ERROR; + } + + return CJ_SENSOR_IMPL->GetAllSensorList(*sensors); +} +} \ No newline at end of file diff --git a/frameworks/cj/src/cj_sensor_impl.cpp b/frameworks/cj/src/cj_sensor_impl.cpp new file mode 100644 index 00000000..30ada43c --- /dev/null +++ b/frameworks/cj/src/cj_sensor_impl.cpp @@ -0,0 +1,374 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * 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 "cj_sensor_impl.h" + +#include +#include +#include + +#include "cj_lambda.h" +#include "cj_sensor_ffi.h" +#include "errors.h" +#include "geomagnetic_field.h" +#include "sensor_agent.h" +#include "sensor_algorithm.h" +#include "sensor_errors.h" + +namespace OHOS { +namespace Sensors { +namespace { +constexpr int32_t ROTATION_VECTOR_LENGTH = 3; +constexpr int32_t QUATERNION_LENGTH = 4; +constexpr int32_t THREE_DIMENSIONAL_MATRIX_LENGTH = 9; +constexpr int32_t DATA_LENGTH = 16; +} // namespace + +CJSensorImpl::CJSensorImpl() {} +CJSensorImpl::~CJSensorImpl() {} + +void CJSensorImpl::CJDataCallbackImpl(SensorEvent *event) +{ + CHKPV(event); + CJ_SENSOR_IMPL->EmitCallBack(event); +} + +int32_t CJSensorImpl::SubscribeSensorImpl(int32_t sensorId, int64_t interval) +{ + CALL_LOG_ENTER; + int32_t ret = SubscribeSensor(sensorId, &cjUser_); + if (ret != ERR_OK) { + SEN_HILOGE("SubscribeSensor failed"); + return ret; + } + ret = SetBatch(sensorId, &cjUser_, interval, 0); + if (ret != ERR_OK) { + SEN_HILOGE("SetBatch failed"); + return ret; + } + + return ActivateSensor(sensorId, &cjUser_); +} + +int32_t CJSensorImpl::UnsubscribeSensorImpl(int32_t sensorTypeId) +{ + CALL_LOG_ENTER; + int32_t ret = DeactivateSensor(sensorTypeId, &cjUser_); + if (ret != ERR_OK) { + SEN_HILOGE("DeactivateSensor failed"); + return ret; + } + return UnsubscribeSensor(sensorTypeId, &cjUser_); +} + +char *CJSensorImpl::MallocCString(const std::string origin) +{ + if (origin.empty()) { + SEN_HILOGD("String is empty."); + return nullptr; + } + auto len = origin.length() + 1; + char *res = static_cast(malloc(sizeof(char) * len)); + if (res == nullptr) { + SEN_HILOGE("Malloc failed."); + return nullptr; + } + return std::char_traits::copy(res, origin.c_str(), len); +} + +void CJSensorImpl::Transform2CSensor(const SensorInfo &in, CSensor &out) +{ + out.sensorName = MallocCString(in.sensorName); + out.vendorName = MallocCString(in.vendorName); + out.firmwareVersion = MallocCString(in.firmwareVersion); + out.hardwareVersion = MallocCString(in.hardwareVersion); + + out.sensorTypeId = in.sensorTypeId; + out.maxRange = in.maxRange; + out.minSamplePeriod = in.minSamplePeriod; + out.maxSamplePeriod = in.maxSamplePeriod; + out.precision = in.precision; + out.power = in.power; +} + +std::vector CJSensorImpl::ConvertCArr2Vector(const CArrFloat32 &in) +{ + std::vector res; + if (in.head == nullptr || in.size <= 0) { + SEN_HILOGD("head is nullptr or size is zero."); + return res; + } + + for (int64_t i = 0; i < in.size; i++) { + res.push_back(in.head[i]); + } + + return res; +} + +CArrFloat32 CJSensorImpl::ConvertVector2CArr(const std::vector &in) +{ + CArrFloat32 res = {NULL, 0}; + if (in.empty()) { + SEN_HILOGD("vector is empty."); + return res; + } + + res.head = static_cast(malloc(sizeof(float) * in.size())); + if (res.head == nullptr) { + SEN_HILOGE("Malloc failed."); + return res; + } + size_t i = 0; + for (; i < in.size(); ++i) { + res.head[i] = in[i]; + } + res.size = i; + return res; +} + +int32_t CJSensorImpl::OnSensorChange(int32_t sensorId, int64_t interval, void (*callback)(SensorEvent *event)) +{ + CALL_LOG_ENTER; + int32_t ret = SubscribeSensorImpl(sensorId, interval); + if (ret != ERR_OK) { + SEN_HILOGE("subscribe sensor failed, %{public}d.", sensorId); + return ret; + } + + AddCallback2Map(sensorId, CJLambda::Create(callback)); + return ERR_OK; +} + +int32_t CJSensorImpl::OffSensorChange(int32_t sensorId) +{ + CALL_LOG_ENTER; + int32_t ret = UnsubscribeSensorImpl(sensorId); + if (ret != ERR_OK) { + SEN_HILOGE("unsubscribe sensor failed, %{public}d.", sensorId); + return ret; + } + + DelCallback(sensorId); + return ERR_OK; +} + +void CJSensorImpl::EmitCallBack(SensorEvent *event) +{ + auto callback = FindCallback(event->sensorTypeId); + if (callback == std::nullopt) { + SEN_HILOGE("EmitCallBack failed, %{public}d not find.", event->sensorTypeId); + return; + } + + callback.value()(event); +} + +void CJSensorImpl::AddCallback2Map(int32_t type, SensorCallbackType callback) +{ + std::lock_guard mutex(mutex_); + eventMap_[type] = callback; +} + +void CJSensorImpl::DelCallback(int32_t type) +{ + std::lock_guard mutex(mutex_); + eventMap_.erase(type); +} + +std::optional CJSensorImpl::FindCallback(int32_t type) +{ + std::lock_guard mutex(mutex_); + auto iter = eventMap_.find(type); + if (iter != eventMap_.end()) { + return iter->second; + } + + return std::nullopt; +} + +CGeomagneticData CJSensorImpl::GetGeomagneticInfo(CLocationOptions location, int64_t timeMillis) +{ + GeomagneticField geomagneticField(location.latitude, location.longitude, location.altitude, timeMillis); + CGeomagneticData res = { + .x = geomagneticField.ObtainX(), + .y = geomagneticField.ObtainY(), + .z = geomagneticField.ObtainZ(), + .geomagneticDip = geomagneticField.ObtainGeomagneticDip(), + .deflectionAngle = geomagneticField.ObtainDeflectionAngle(), + .levelIntensity = geomagneticField.ObtainLevelIntensity(), + .totalIntensity = geomagneticField.ObtainTotalIntensity(), + }; + return res; +} + +int32_t CJSensorImpl::GetAltitude(float seaPressure, float currentPressure, float *altitude) +{ + SensorAlgorithm sensorAlgorithm; + int32_t ret = sensorAlgorithm.GetAltitude(seaPressure, currentPressure, altitude); + if (ret != ERR_OK) { + SEN_HILOGE("Get altitude failed, ret:%{public}d", ret); + } + return ret; +} + +int32_t CJSensorImpl::GetGeomagneticDip(CArrFloat32 inclinationMatrix, float *geomagneticDip) +{ + SensorAlgorithm sensorAlgorithm; + int32_t ret = sensorAlgorithm.GetGeomagneticDip(ConvertCArr2Vector(inclinationMatrix), geomagneticDip); + if (ret != ERR_OK) { + SEN_HILOGE("Get geomagnetic dip failed, ret:%{public}d", ret); + } + + return ret; +} + +int32_t CJSensorImpl::GetAngleModify(const CArrFloat32 &curRotationMatrix, const CArrFloat32 &preRotationMatrix, + CArrFloat32 *angleChangeOut) +{ + if (angleChangeOut == nullptr) { + SEN_HILOGE("Invalid parameter, angleChangeOut is nullptr!"); + return PARAMETER_ERROR; + } + std::vector angleChange(ROTATION_VECTOR_LENGTH); + SensorAlgorithm sensorAlgorithm; + int32_t ret = sensorAlgorithm.GetAngleModify(ConvertCArr2Vector(curRotationMatrix), + ConvertCArr2Vector(preRotationMatrix), angleChange); + if (ret != ERR_OK) { + SEN_HILOGE("Get angle change failed, ret:%{public}d", ret); + return ret; + } + + *angleChangeOut = ConvertVector2CArr(angleChange); + return ret; +} + +int32_t CJSensorImpl::GetRotationMatrix(const CArrFloat32 &rotationCArr, CArrFloat32 &rotation) +{ + std::vector rotationMatrix(THREE_DIMENSIONAL_MATRIX_LENGTH); + SensorAlgorithm sensorAlgorithm; + int32_t ret = sensorAlgorithm.CreateRotationMatrix(ConvertCArr2Vector(rotationCArr), rotationMatrix); + if (ret != ERR_OK) { + SEN_HILOGE("Get rotation matrix failed, ret:%{public}d", ret); + return ret; + } + + rotation = ConvertVector2CArr(rotationMatrix); + return ret; +} + +int32_t CJSensorImpl::TransformRotationMatrix(const CArrFloat32 &rotationCArr, int32_t axisX, int32_t axisY, + CArrFloat32 &outRotationMatrix) +{ + int64_t length = rotationCArr.size; + if ((length != DATA_LENGTH) && (length != THREE_DIMENSIONAL_MATRIX_LENGTH)) { + SEN_HILOGE("Transform rotation mastrix failed, invalid parameter."); + return PARAMETER_ERROR; + } + std::vector outRotationVector(length); + SensorAlgorithm sensorAlgorithm; + int32_t ret = + sensorAlgorithm.TransformCoordinateSystem(ConvertCArr2Vector(rotationCArr), axisX, axisY, outRotationVector); + if (ret != ERR_OK) { + SEN_HILOGE("Transform coordinate system failed, ret:%{public}d", ret); + return ret; + } + + outRotationMatrix = ConvertVector2CArr(outRotationVector); + return ret; +} + +int32_t CJSensorImpl::GetQuaternion(const CArrFloat32 &rotationVector, CArrFloat32 &quaternionOut) +{ + std::vector quaternion(QUATERNION_LENGTH); + SensorAlgorithm sensorAlgorithm; + int32_t ret = sensorAlgorithm.CreateQuaternion(ConvertCArr2Vector(rotationVector), quaternion); + if (ret != ERR_OK) { + SEN_HILOGE("Get quaternion failed, ret:%{public}d", ret); + return ret; + } + + quaternionOut = ConvertVector2CArr(quaternion); + return ret; +} + +int32_t CJSensorImpl::GetOrientation(const CArrFloat32 &rotationMatrix, CArrFloat32 &rotationAngleOut) +{ + std::vector rotationAngle(ROTATION_VECTOR_LENGTH); + SensorAlgorithm sensorAlgorithm; + int32_t ret = sensorAlgorithm.GetDirection(ConvertCArr2Vector(rotationMatrix), rotationAngle); + if (ret != OHOS::ERR_OK) { + SEN_HILOGE("Get direction failed, ret:%{public}d", ret); + return ret; + } + + rotationAngleOut = ConvertVector2CArr(rotationAngle); + return ret; +} + +int32_t CJSensorImpl::GetRotationMatrixByGraityAndGeomagnetic(const CArrFloat32 gravity, const CArrFloat32 geomagnetic, + CArrFloat32 &rotationMatrix, + CArrFloat32 &inclinationMatrix) +{ + std::vector rotation(THREE_DIMENSIONAL_MATRIX_LENGTH); + std::vector inclination(THREE_DIMENSIONAL_MATRIX_LENGTH); + SensorAlgorithm sensorAlgorithm; + int32_t ret = sensorAlgorithm.CreateRotationAndInclination(ConvertCArr2Vector(gravity), + ConvertCArr2Vector(geomagnetic), rotation, inclination); + if (ret != OHOS::ERR_OK) { + SEN_HILOGE("Create rotation and inclination failed, ret:%{public}d", ret); + return ret; + } + + rotationMatrix = ConvertVector2CArr(rotation); + inclinationMatrix = ConvertVector2CArr(inclination); + + return ret; +} + +int32_t CJSensorImpl::GetAllSensorList(CSensorArray &sensorList) +{ + SensorInfo *sensorInfos = nullptr; + int32_t count = 0; + int32_t ret = GetAllSensors(&sensorInfos, &count); + if (ret != OHOS::ERR_OK) { + SEN_HILOGE("Get all sensors failed, ret:%{public}d", ret); + return ret; + } + + if (count == 0) { + return ERR_OK; + } + + sensorList.head = static_cast(malloc(sizeof(CSensor) * count)); + if (sensorList.head == nullptr) { + SEN_HILOGE("Malloc failed."); + return ERR_OK; + } + int32_t i = 0; + for (; i < count; ++i) { + if ((sensorInfos[i].sensorTypeId == SENSOR_TYPE_ID_AMBIENT_LIGHT1) || + (sensorInfos[i].sensorTypeId == SENSOR_TYPE_ID_PROXIMITY1)) { + SEN_HILOGD("This sensor is secondary ambient light"); + continue; + } + Transform2CSensor(sensorInfos[i], sensorList.head[i]); + } + sensorList.size = i; + + return ERR_OK; +} +} // namespace Sensors +} // namespace OHOS \ No newline at end of file -- Gitee