diff --git a/BUILD.gn b/BUILD.gn index 2c06ece5b580d7c126ee99b517a801fa391c440a..1fa272b7eba2193aed97ab9a8e10ed578be991a3 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -108,6 +108,9 @@ group("input_jsapi_group") { if (input_feature_short_key) { deps += [ "frameworks/napi/short_key:shortkey" ] } + if (input_feature_infrared_emitter) { + deps += [ "frameworks/napi/infrared_emitter:infraredemitter" ] + } } } diff --git a/bundle.json b/bundle.json index 0f953cf91c598a9858d7ea0bc43c740972b1da8e..11e13f7cfcccdc9d99c8832c4cfda1116e8fa8f5 100644 --- a/bundle.json +++ b/bundle.json @@ -73,7 +73,9 @@ "relational_store", "faultloggerd", "ffrt", - "graphic_2d_ext" + "graphic_2d_ext", + "drivers_interface_tros_extra", + "hdf_core" ], "third_party": [ "cJSON", diff --git a/frameworks/napi/infrared_emitter/BUILD.gn b/frameworks/napi/infrared_emitter/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..da3856d39fcf1a85b7af734f08d92f118b66bbf5 --- /dev/null +++ b/frameworks/napi/infrared_emitter/BUILD.gn @@ -0,0 +1,60 @@ +# 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("../../../multimodalinput_mini.gni") + +print("input_feature_infrared_emitter = ${input_feature_infrared_emitter}") + +config("infraredemitter_config") { + visibility = [ ":*" ] + include_dirs = [ + "${mmi_path}/input/interfaces/native/innerkits/event/include/", + "${mmi_path}/frameworks/napi/infrared_emitter/include", + "${mmi_path}/util/common/include", + "${mmi_path}/util/network/include", + ] +} + +ohos_shared_library("infraredemitter") { + sources = infraredemitter_sources + stack_protector_ret = true + sanitize = { + integer_overflow = true + ubsan = true + boundary_sanitize = true + cfi = true + cfi_cross_dso = true + debug = false + } + + configs = [ + "${mmi_path}:coverage_flags", + ":infraredemitter_config", + ] + + deps = [ + "${mmi_path}/frameworks/proxy:libmmi-client", + "${mmi_path}/util:libmmi-util", + ] + + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + "napi:ace_napi", + ] + + relative_install_dir = "module/multimodalinput" + + part_name = "input" + subsystem_name = "multimodalinput" +} diff --git a/frameworks/napi/infrared_emitter/include/js_register_module.h b/frameworks/napi/infrared_emitter/include/js_register_module.h new file mode 100644 index 0000000000000000000000000000000000000000..5b1720cac9c6af109935220e12bcab8245f4eb3b --- /dev/null +++ b/frameworks/napi/infrared_emitter/include/js_register_module.h @@ -0,0 +1,31 @@ +/* + * 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 JS_INFRARED_MANAGER_H +#define JS_INFRARED_MANAGER_H + +#include "define_multimodal.h" +#include "napi/native_api.h" +#include "napi/native_node_api.h" +#include "nocopyable.h" +#include "utils/log.h" +#include "key_event.h" +#include "key_option.h" + +namespace OHOS { +namespace MMI { +} // namespace MMI +} // namespace OHOS +#endif // JS_INFRARED_MANAGER_H \ No newline at end of file diff --git a/frameworks/napi/infrared_emitter/src/js_register_module.cpp b/frameworks/napi/infrared_emitter/src/js_register_module.cpp new file mode 100644 index 0000000000000000000000000000000000000000..abb512fb3beaf19c07556477aa5717104274cce7 --- /dev/null +++ b/frameworks/napi/infrared_emitter/src/js_register_module.cpp @@ -0,0 +1,253 @@ +/* + * 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 "js_register_module.h" +#include + +#include "input_manager.h" +#include "mmi_log.h" +#include "napi_constants.h" +#include "util_napi_error.h" +#include "util_napi.h" + +namespace OHOS { +namespace MMI { +namespace { +constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, MMI_LOG_DOMAIN, "JsInfraredRegister" }; +const uint32_t NUMBER_PARAMETERS = 2; +const uint32_t NUMBER_DEFAULT = 0; +} + +bool CheckType(const napi_env& env, const napi_value& value, const napi_valuetype& type) +{ + napi_valuetype valuetype = napi_undefined; + napi_typeof(env, value, &valuetype); + if (valuetype != type) { + return false; + } + return true; +} + +bool IsArray(const napi_env& env, const napi_value& value) +{ + bool isArray = false; + napi_status ret = napi_is_array(env, value, &isArray); + if (ret != napi_ok) { + return false; + } + return isArray; +} + +bool ParseInt64(const napi_env& env, const napi_value& value, int64_t& result) +{ + if (!CheckType(env, value, napi_number)) { + MMI_HILOGE("ParseInt64 type not number"); + THROWERR_API9(env, COMMON_PARAMETER_ERROR, "element of pattern", "Number"); + return false; + } + if (napi_get_value_int64(env, value, &result) != napi_ok) { + MMI_HILOGE("ParseInt64 cannot get value int64"); + THROWERR_API9(env, COMMON_PARAMETER_ERROR, "element of pattern", "Int64"); + return false; + } + return true; +} + +bool ParsePatternArray(const napi_env& env, const napi_value& value, std::vector& result) +{ + uint32_t length = 0; + if (!IsArray(env, value)) { + MMI_HILOGE("ParsePatternArray second para not array"); + THROWERR_API9(env, COMMON_PARAMETER_ERROR, "pattern", "Array"); + return false; + } + napi_get_array_length(env, value, &length); + for (uint32_t i = 0; i < length; i++) { + napi_value valueArray = nullptr; + if (napi_get_element(env, value, i, &valueArray) != napi_ok) { + MMI_HILOGE("ParsePatternArray napi_get_element failed. index:%{public}d", i); + return false; + } + int64_t res = 0; + if (!ParseInt64(env, valueArray, res)) { + MMI_HILOGE("ParsePatternArray parse array fail. index:%{public}d", i); + THROWERR_API9(env, COMMON_PARAMETER_ERROR, "element of pattern", "Int64"); + return false; + } + result.emplace_back(res); + } + return true; +}; + +bool ParseTransmitInfraredJSParam(const napi_env& env, const napi_callback_info &info, int64_t & infraredFrequency, + std::vector & vecPattern) +{ + CALL_DEBUG_ENTER; + size_t argc = NUMBER_DEFAULT; + napi_value argv[NUMBER_PARAMETERS]; + CHKRF(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr), GET_CB_INFO); + if (argc != NUMBER_PARAMETERS) { + MMI_HILOGE("ParseTransmitInfraredJSParam Parameter number error"); + return false; + } + if (!CheckType(env, argv[0], napi_number)) { + MMI_HILOGE("ParseTransmitInfraredJSParam infraredFrequency parameter[0] type is invalid."); + THROWERR_API9(env, COMMON_PARAMETER_ERROR, "infraredFrequency", "number"); + return false; + } + CHKRF(napi_get_value_int64(env, argv[0], &infraredFrequency), "get number64 value error"); + if (!ParsePatternArray(env, argv[1], vecPattern)) { + MMI_HILOGE("ParsePatternArray parse pattern array fail."); + return false; + } + return true; +} + +static void ThrowError(napi_env env, int32_t code, std::string operateType) +{ + int32_t errorCode = -code; + if (code > 0) { + errorCode = code; + } + MMI_HILOGE("Operate %{public}s requst error. returnCode:%{public}d", operateType.c_str(), code); + if (errorCode == COMMON_PERMISSION_CHECK_ERROR) { + THROWERR_API9(env, COMMON_PERMISSION_CHECK_ERROR, "Infrared", "ohos.permission.INFRARED_EMITTER"); + } else if (COMMON_USE_SYSAPI_ERROR == errorCode) { + THROWERR_API9(env, COMMON_USE_SYSAPI_ERROR, "Infrared", "Non system applications use system API"); + } else { + return; + } +} + +napi_value CreateInfraredFrequencyItem(napi_env env, const InfraredFrequency &infraredFrequency) +{ + napi_value result; + napi_status status = napi_create_object(env, &result); + CHKRP(status, CREATE_OBJECT); + napi_value jsMax; + CHKRP(napi_create_int64(env, infraredFrequency.max_, &jsMax), "napi_create_int64:max"); + CHKRP(napi_set_named_property(env, result, "max", jsMax), SET_NAMED_PROPERTY); + napi_value jsMin; + CHKRP(napi_create_int64(env, infraredFrequency.min_, &jsMin), "napi_create_int64:min"); + CHKRP(napi_set_named_property(env, result, "min", jsMin), SET_NAMED_PROPERTY); + return result; +} + +static napi_value HasIrEmitter(napi_env env, napi_callback_info info) +{ + CALL_DEBUG_ENTER; + napi_value result = nullptr; + napi_status status = napi_get_boolean(env, true, &result); + if (status != napi_ok) { + THROWERR_API9(env, COMMON_PARAMETER_ERROR, "type", "boolean"); + return nullptr; + } + return result; +} + +static napi_value GetInfraredFrequencies(napi_env env, napi_callback_info info) +{ + CALL_DEBUG_ENTER; + napi_value result = nullptr; + CHKRP(napi_create_array(env, &result), CREATE_ARRAY); + std::vector requencys; + int32_t ret = InputManager::GetInstance()->GetInfraredFrequencies(requencys); + if (ret != RET_OK) { + if (RET_OK > ret || COMMON_PERMISSION_CHECK_ERROR == ret || ERROR_NOT_SYSAPI == ret) { + MMI_HILOGE("js_register.GetFreq reqErr. Permi Err or Not System APP. Positive retCode:%{public}d", ret); + ThrowError(env, ret, "GetInfraredFrequencies"); + } + MMI_HILOGE("Parse GetInfraredFrequencies requst error. returnCode: %{public}d", ret); + return result; + } + size_t size = requencys.size(); + std::string logPrint = "size:" + std::to_string(size) + ";"; + CHKRP(napi_create_array(env, &result), CREATE_ARRAY); + for (size_t i = 0; i < size; i++) { + InfraredFrequency frequencyItem = requencys[i]; + logPrint = logPrint + std::to_string(i) + "max:" + std::to_string(frequencyItem.max_) + ";min:" + + std::to_string(frequencyItem.min_) + ";"; + napi_value item = CreateInfraredFrequencyItem(env, requencys[i]); + if (item == nullptr) { + MMI_HILOGE("CreateInfraredFrequencyItem error"); + return nullptr; + } + CHKRP(napi_set_element(env, result, i, item), SET_ELEMENT); + } + MMI_HILOGD("js_register_module.GetInfraredFrequencies :%{public}s ", logPrint.c_str()); + return result; +} + +static napi_value TransmitInfrared(napi_env env, napi_callback_info info) +{ + CALL_DEBUG_ENTER; + napi_value result = nullptr; + int64_t number = -1; + std::vector pattern; + if (!ParseTransmitInfraredJSParam(env, info, number, pattern)) { + MMI_HILOGE("Parse TransmitInfrared JSParam error"); + THROWERR_CUSTOM(env, COMMON_PARAMETER_ERROR, "Parse TransmitInfrared JSParam error"); + return nullptr; + } + int32_t size = static_cast(pattern.size()); + std::string context = "number:" + std::to_string(number) + "\n;" + "; size=" + std::to_string(size) + ";"; + for (int32_t i = 0; i < size; i++) { + context = context + std::to_string(i) + ": pattern: " + std::to_string(pattern[i]) + ";"; + } + MMI_HILOGD("js_register_module.TransmitInfrared para size :%{public}s", context.c_str()); + int32_t ret = InputManager::GetInstance()->TransmitInfrared(number, pattern); + if (ret != RET_OK) { + if (RET_OK > ret || COMMON_PERMISSION_CHECK_ERROR == ret || ERROR_NOT_SYSAPI == ret) { + MMI_HILOGE("js_register.Transmit req err. Per Er or Not Sys APP. Posi retCode:%{public}d", ret); + ThrowError(env, ret, "TransmitInfrared"); + } + MMI_HILOGE("js_register_module.TransmitInfrared requst error. returnCode:%{public}d", ret); + return nullptr; + } + CHKRP(napi_create_int32(env, 0, &result), CREATE_INT32); + return result; +} + +EXTERN_C_START +static napi_value MmiInit(napi_env env, napi_value exports) +{ + CALL_DEBUG_ENTER; + napi_property_descriptor desc[] = { + DECLARE_NAPI_FUNCTION("hasIrEmitter", HasIrEmitter), + DECLARE_NAPI_FUNCTION("getInfraredFrequencies", GetInfraredFrequencies), + DECLARE_NAPI_FUNCTION("transmitInfrared", TransmitInfrared) + }; + NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); + return exports; +} +EXTERN_C_END + +static napi_module infraredModule = { + .nm_version = 1, + .nm_flags = 0, + .nm_filename = nullptr, + .nm_register_func = MmiInit, + .nm_modname = "multimodalInput.infraredEmitter", + .nm_priv = ((void*)0), + .reserved = { 0 }, +}; + +extern "C" __attribute__((constructor)) void RegisterModule(void) +{ + napi_module_register(&infraredModule); +} + +} +} \ No newline at end of file diff --git a/frameworks/napi/infrared_emitter/test/register_module_test.cpp b/frameworks/napi/infrared_emitter/test/register_module_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..028fedd4626e44d83640de11a2acfd8b03db986f --- /dev/null +++ b/frameworks/napi/infrared_emitter/test/register_module_test.cpp @@ -0,0 +1,81 @@ +/* + * 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. + */ + +namespace OHOS { +namespace MMI { +namespace { +using namespace testing::ext; +} // namespace +class RegisterModuleTest : public testing::Test { + public: + int64_t frequency_Max; + int64_t frequency_Min; +}; + +/** + * @tc.name: GetInfraredFrequenciesTest + * @tc.desc: Event dump CheckCount + * @tc.type: FUNC + * @tc.require:AR000GJG6G + */ +HWTEST_F(RegisterModuleTest, GetInfraredFrequenciesTest, TestSize.Level1) +{ + std::vector requencys; + int32_t ret = InputManager::GetInstance()->GetInfraredFrequencies(requencys); + bool testResult = true; + int32_t size = requencys.size(); + EXPECT_GE(size, 1); + frequency_Max = requencys[0].max_; + frequency_Min = requencys[0].min_; + for (int32_t i = 0; i < size; i++) { + InfraredFrequency fre = requencys[i]; + if (fre.max_ < fre.min_) { + testResult = false; + break; + } + } + EXPECT_EQ(testResult, true); +} + +/** + * @tc.name: EventDumpTest_CheckCount_001 + * @tc.desc: Event dump CheckCount + * @tc.type: FUNC + * @tc.require:AR000GJG6G + */ +HWTEST_F(RegisterModuleTest, TransmitInfraredTest, TestSize.Level1) +{ + std::vector requencys; + int64_t dist = (frequency_Max - frequency_Min) / 10; + bool testResult = true; + + for (int i = 0; i < 10; i++) { + requencys.push_back(dist * i + frequency_Min); + } + int32_t ret = InputManager::GetInstance()->TransmitInfrared(frequency_Min, requencys); + if (0 != ret) { + testResult = false; + } + EXPECT_EQ(testResult, true); +} + +HWTEST_F(RegisterModuleTest, HasIrEmitterTest, TestSize.Level1) +{ + bool hasEmmited = false; + int32_t ret = InputManager::GetInstance()->HasIrEmitter(hasEmmited); + EXPECT_EQ(hasEmmited, false); +} +} // namespace MMI +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/proxy/event_handler/include/input_manager_impl.h b/frameworks/proxy/event_handler/include/input_manager_impl.h index cecb0f296f3b6426488974aa94557f4d620554a2..3f49dcdc91a7039088a9abde188fa21ea88f1d74 100644 --- a/frameworks/proxy/event_handler/include/input_manager_impl.h +++ b/frameworks/proxy/event_handler/include/input_manager_impl.h @@ -44,6 +44,7 @@ #include "pointer_event.h" #include "pointer_style.h" #include "switch_event.h" +#include "infrared_frequency_info.h" namespace OHOS { namespace MMI { @@ -192,6 +193,11 @@ public: int32_t GetKeyState(std::vector &pressedKeys, std::map &specialKeysState); void Authorize(bool isAuthorize); int32_t CancelInjection(); + + int32_t HasIrEmitter(bool &hasIrEmitter); + int32_t GetInfraredFrequencies(std::vector& requencys); + int32_t TransmitInfrared(int64_t number, std::vector& pattern); + private: int32_t PackWindowInfo(NetPacket &pkt); int32_t PackWindowGroupInfo(NetPacket &pkt); diff --git a/frameworks/proxy/event_handler/src/input_manager_impl.cpp b/frameworks/proxy/event_handler/src/input_manager_impl.cpp index 41e6f44743fa74c3467706b81def4b3ad9242524..339633ed7fdd39ea247719be5c54fc8db7552152 100644 --- a/frameworks/proxy/event_handler/src/input_manager_impl.cpp +++ b/frameworks/proxy/event_handler/src/input_manager_impl.cpp @@ -2024,5 +2024,23 @@ int32_t InputManagerImpl::CancelInjection() } return RET_OK; } + +int32_t InputManagerImpl::HasIrEmitter(bool &hasIrEmitter) +{ + CALL_INFO_TRACE; + return MultimodalInputConnMgr->HasIrEmitter(hasIrEmitter); +} + +int32_t InputManagerImpl::GetInfraredFrequencies(std::vector& requencys) +{ + CALL_INFO_TRACE; + return MultimodalInputConnMgr->GetInfraredFrequencies(requencys); +} + +int32_t InputManagerImpl::TransmitInfrared(int64_t number, std::vector& pattern) +{ + CALL_INFO_TRACE; + return MultimodalInputConnMgr->TransmitInfrared(number, pattern); +} } // namespace MMI } // namespace OHOS diff --git a/frameworks/proxy/events/src/input_manager.cpp b/frameworks/proxy/events/src/input_manager.cpp index 60ec7858374b141c2e1f7378492f56b91a19071f..1d29b86ce6809d72f4eef887c7fc3ef159476d2d 100644 --- a/frameworks/proxy/events/src/input_manager.cpp +++ b/frameworks/proxy/events/src/input_manager.cpp @@ -522,5 +522,20 @@ void InputManager::Authorize(bool isAuthorize) { InputMgrImpl.Authorize(isAuthorize); } + +int32_t InputManager::HasIrEmitter(bool &hasIrEmitter) +{ + return InputMgrImpl.HasIrEmitter(hasIrEmitter); +} + +int32_t InputManager::GetInfraredFrequencies(std::vector& requencys) +{ + return InputMgrImpl.GetInfraredFrequencies(requencys); +} + +int32_t InputManager::TransmitInfrared(int64_t number, std::vector& pattern) +{ + return InputMgrImpl.TransmitInfrared(number, pattern); +} } // namespace MMI } // namespace OHOS diff --git a/interfaces/native/innerkits/event/include/infrared_frequency_info.h b/interfaces/native/innerkits/event/include/infrared_frequency_info.h new file mode 100644 index 0000000000000000000000000000000000000000..162563ddd1bafd88f5cb944fcfdc4ad9255e3b4a --- /dev/null +++ b/interfaces/native/innerkits/event/include/infrared_frequency_info.h @@ -0,0 +1,27 @@ +/* + * 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 I_INFRARED_MANAGER +#define I_INFRARED_MANAGER + +namespace OHOS { +namespace MMI { +struct InfraredFrequency { + int64_t max_ { 0 }; + int64_t min_ { 0 }; +}; +} // namespace MMI +} // namespace OHOS +#endif // I_INFRARED_MANAGER \ No newline at end of file diff --git a/interfaces/native/innerkits/proxy/include/input_manager.h b/interfaces/native/innerkits/proxy/include/input_manager.h index d72cec0dfaf64e6f8ea1ef03812186c62e435e97..926527bcd605526e8088759a8f53ac95fac1b615 100644 --- a/interfaces/native/innerkits/proxy/include/input_manager.h +++ b/interfaces/native/innerkits/proxy/include/input_manager.h @@ -37,6 +37,7 @@ #include "key_option.h" #include "pointer_style.h" #include "window_info.h" +#include "infrared_frequency_info.h" namespace OHOS { namespace MMI { @@ -816,6 +817,31 @@ public: */ int32_t GetTouchpadRotateSwitch(bool &rotateSwitch); + /** + * @brief Get whether System has IrEmitter. + * @param hasIrEmitter the para takes the value which Indicates the device has IrEmitter or not. + * @return 0 if success; returns a non-0 value otherwise. + * @since 12 + */ + int32_t HasIrEmitter(bool &hasIrEmitter); + + /** + * @brief Get InfraredFrequency of the IrEmitter in device. + * @param requencys take out the IrEmitter's Frequency. + * @return 0 if success; returns a non-0 value otherwise. + * @since 12 + */ + int32_t GetInfraredFrequencies(std::vector& requencys); + + /** + * @brief user IrEmitter with parameter number and pattern. + * @param number Frequency of IrEmitter works . + * @param pattern Pattern of signal transmission in alternate on/off mode, in microseconds. + * @return 0 if success; returns a non-0 value otherwise. + * @since 12 + */ + int32_t TransmitInfrared(int64_t number, std::vector& pattern); + private: InputManager() = default; DISALLOW_COPY_AND_MOVE(InputManager); diff --git a/multimodalinput_mini.gni b/multimodalinput_mini.gni index ee1366aa6aec634dcc2f2f2b714b583856516d47..fa9f2aa3f86b7fe6ed3d9442f4638fa2ee9502fd 100644 --- a/multimodalinput_mini.gni +++ b/multimodalinput_mini.gni @@ -40,6 +40,7 @@ declare_args() { input_ext_feature_fingersense = false input_feature_fingerprint = false input_ext_feature_magiccursor = false + input_feature_infrared_emitter = true if (defined(global_parts_info) && defined(global_parts_info.resourceschedule_resource_schedule_service)) { @@ -118,6 +119,8 @@ declare_args() { "window_manager/src/input_windows_manager.cpp", ] + infraredemitter_sources = [ "src/js_register_module.cpp" ] + inputdevice_sources = [ "src/js_event_target.cpp", "src/js_input_device_context.cpp", @@ -197,6 +200,8 @@ declare_args() { libmmi_virtual_device_sources = [ "src/virtual_device.cpp", "src/virtual_finger.cpp", + "src/virtual_fingerprint_key.cpp", + "src/virtual_fingerprint_mouse.cpp", "src/virtual_gamepad.cpp", "src/virtual_joystick.cpp", "src/virtual_keyboard.cpp", @@ -222,8 +227,6 @@ declare_args() { "src/virtual_trackpad.cpp", "src/virtual_trackpad_mouse.cpp", "src/virtual_trackpad_sys_ctrl.cpp", - "src/virtual_fingerprint_key.cpp", - "src/virtual_fingerprint_mouse.cpp", ] libmmi_util_sources = [ @@ -258,6 +261,7 @@ print("input_feature_joystick = ${input_feature_joystick}") print("input_feature_touchscreen = ${input_feature_touchscreen}") print("input_feature_input_device = ${input_feature_input_device}") print("input_feature_short_key = ${input_feature_short_key}") +print("input_feature_infrared_emitter = ${input_feature_infrared_emitter}") input_default_defines = [] @@ -325,6 +329,7 @@ if (input_ext_feature_anco) { "${mmi_ext_path}/anco_uds_manager/src/anco_uds_manager.cpp", "${mmi_ext_path}/anco_uds_manager/src/input_windows_manager_ext.cpp", "${mmi_ext_path}/anco_uds_manager/src/mmi_service_ext.cpp", + "${mmi_path}/service/infrared_emitter/src/infrared_emitter_controller.cpp", ] } diff --git a/service/BUILD.gn b/service/BUILD.gn index 7e43c735dfb4363bc019fede23967b2e6a256481..0ff6f1031122e88f479d72c754c1f3e2d7214454 100644 --- a/service/BUILD.gn +++ b/service/BUILD.gn @@ -91,7 +91,10 @@ config("libmmi_server_config") { } if (input_ext_feature_anco) { - include_dirs += [ "${mmi_ext_path}/anco_uds_manager/include" ] + include_dirs += [ + "${mmi_ext_path}/anco_uds_manager/include", + "${mmi_service_path}/infrared_emitter/include", + ] } if (input_ext_feature_magiccursor) { @@ -233,6 +236,13 @@ ohos_shared_library("libmmi-server") { external_deps += [ "resource_schedule_service:ressched_client" ] } + if (input_ext_feature_anco) { + external_deps += [ + "drivers_interface_rtos_extra:libconsumerir_proxy_1.0", + "hdf_core:libhdi", + ] + } + external_deps += [ "ability_base:want", "ability_base:zuri", diff --git a/service/connect_manager/include/i_multimodal_input_connect.h b/service/connect_manager/include/i_multimodal_input_connect.h index 09a96c8403bbb57e962fd9bd49378faea7855ea7..e0948c71b03b29d65c6ce1fecd9b35832d3e5d6a 100644 --- a/service/connect_manager/include/i_multimodal_input_connect.h +++ b/service/connect_manager/include/i_multimodal_input_connect.h @@ -32,6 +32,7 @@ #include "window_info.h" #include "nap_process.h" #include "multimodalinput_ipc_interface_code.h" +#include "infrared_frequency_info.h" namespace OHOS { namespace MMI { @@ -129,6 +130,9 @@ public: virtual int32_t GetKeyState(std::vector &pressedKeys, std::map &specialKeysState) = 0; virtual int32_t Authorize(bool isAuthorize) = 0; virtual int32_t CancelInjection() = 0; + virtual int32_t HasIrEmitter(bool &hasIrEmitter) = 0; + virtual int32_t GetInfraredFrequencies(std::vector& requencys) = 0; + virtual int32_t TransmitInfrared(int64_t number, std::vector& pattern) = 0; }; } // namespace MMI } // namespace OHOS diff --git a/service/connect_manager/include/multimodal_input_connect_manager.h b/service/connect_manager/include/multimodal_input_connect_manager.h index 504d4e1018cc0ebff0b2e43a32e53ec41b70624a..04018628f6124c7aaf46fe1ac2e3dd1408dab43c 100644 --- a/service/connect_manager/include/multimodal_input_connect_manager.h +++ b/service/connect_manager/include/multimodal_input_connect_manager.h @@ -26,6 +26,7 @@ #include "i_input_service_watcher.h" #include "i_multimodal_input_connect.h" #include "multimodalinput_ipc_interface_code.h" +#include "infrared_frequency_info.h" namespace OHOS { namespace MMI { @@ -121,7 +122,9 @@ public: int32_t GetKeyState(std::vector &pressedKeys, std::map &specialKeysState); int32_t Authorize(bool isAuthorize); int32_t CancelInjection(); - + int32_t HasIrEmitter(bool &hasIrEmitter); + int32_t GetInfraredFrequencies(std::vector& requencys); + int32_t TransmitInfrared(int64_t number, std::vector& pattern); void AddServiceWatcher(std::shared_ptr watcher); void RemoveServiceWatcher(std::shared_ptr watcher); diff --git a/service/connect_manager/include/multimodal_input_connect_proxy.h b/service/connect_manager/include/multimodal_input_connect_proxy.h index cbe2f858f93b4d115b451f08d93014c70cbc6a3a..62a92487ddbe019ccf126df1056c9c40839cac4c 100644 --- a/service/connect_manager/include/multimodal_input_connect_proxy.h +++ b/service/connect_manager/include/multimodal_input_connect_proxy.h @@ -118,6 +118,9 @@ public: int32_t GetKeyState(std::vector &pressedKeys, std::map &specialKeysState) override; int32_t Authorize(bool isAuthorize) override; int32_t CancelInjection() override; + int32_t HasIrEmitter(bool &hasIrEmitter) override; + int32_t GetInfraredFrequencies(std::vector& requencys) override; + int32_t TransmitInfrared(int64_t number, std::vector& pattern) override; private: static inline BrokerDelegator delegator_; diff --git a/service/connect_manager/include/multimodal_input_connect_stub.h b/service/connect_manager/include/multimodal_input_connect_stub.h index 49dbdcb64b017d4b9fbc19005278e61efd771439..573575ee12100f3355d1a45c433bcc9dcdef6432 100644 --- a/service/connect_manager/include/multimodal_input_connect_stub.h +++ b/service/connect_manager/include/multimodal_input_connect_stub.h @@ -120,6 +120,9 @@ protected: int32_t StubGetKeyState(MessageParcel& data, MessageParcel& reply); int32_t StubAuthorize(MessageParcel& data, MessageParcel& reply); int32_t StubCancelInjection(MessageParcel& data, MessageParcel& reply); + int32_t StubHasIrEmitter(MessageParcel& data, MessageParcel& reply); + int32_t StubGetInfraredFrequencies(MessageParcel& data, MessageParcel& reply); + int32_t StubTransmitInfrared(MessageParcel& data, MessageParcel& reply); private: int32_t VerifyTouchPadSetting(void); }; diff --git a/service/connect_manager/include/multimodalinput_ipc_interface_code.h b/service/connect_manager/include/multimodalinput_ipc_interface_code.h index a60c8598e82d1c47e6720fcb8577447eced8b5f7..e6deb014cb1aed4e3ab5c84e7a23dc1f1b2f497c 100644 --- a/service/connect_manager/include/multimodalinput_ipc_interface_code.h +++ b/service/connect_manager/include/multimodalinput_ipc_interface_code.h @@ -102,6 +102,9 @@ enum class MultimodalinputConnectInterfaceCode { GET_KEY_STATE = 80, NATIVE_AUTHORIZE = 81, NATIVE_CANCEL_INJECTION = 82, + NATIVE_INFRARED_OWN = 83, + NATIVE_INFRARED_FREQUENCY = 84, + NATIVE_CANCEL_TRANSMIT = 85, }; enum class MultimodalinputEventObserverCode { diff --git a/service/connect_manager/src/multimodal_input_connect_manager.cpp b/service/connect_manager/src/multimodal_input_connect_manager.cpp index 146ec7e1aca33b90ac82641bc8dec9718b93db98..863d25e6250545918b5b4c2b84c70aa7b9b13cb1 100644 --- a/service/connect_manager/src/multimodal_input_connect_manager.cpp +++ b/service/connect_manager/src/multimodal_input_connect_manager.cpp @@ -694,5 +694,23 @@ int32_t MultimodalInputConnectManager::CancelInjection() CHKPR(multimodalInputConnectService_, RET_ERR); return multimodalInputConnectService_->CancelInjection(); } + +int32_t MultimodalInputConnectManager::HasIrEmitter(bool &hasIrEmitter) +{ + CHKPR(multimodalInputConnectService_, RET_ERR); + return multimodalInputConnectService_->HasIrEmitter(hasIrEmitter); +} + +int32_t MultimodalInputConnectManager::GetInfraredFrequencies(std::vector& requencys) +{ + CHKPR(multimodalInputConnectService_, RET_ERR); + return multimodalInputConnectService_->GetInfraredFrequencies(requencys); +} + +int32_t MultimodalInputConnectManager::TransmitInfrared(int64_t number, std::vector& pattern) +{ + CHKPR(multimodalInputConnectService_, RET_ERR); + return multimodalInputConnectService_->TransmitInfrared(number, pattern); +} } // namespace MMI } // namespace OHOS diff --git a/service/connect_manager/src/multimodal_input_connect_proxy.cpp b/service/connect_manager/src/multimodal_input_connect_proxy.cpp index 9b427c08908e01e5a3f2cf0fc274c22342d8e430..20fbdafc32c8b7d0d8a44ffed5296b141116a222 100644 --- a/service/connect_manager/src/multimodal_input_connect_proxy.cpp +++ b/service/connect_manager/src/multimodal_input_connect_proxy.cpp @@ -23,6 +23,7 @@ #include "string_ex.h" #include "multimodalinput_ipc_interface_code.h" #include "input_scene_board_judgement.h" +#include "infrared_frequency_info.h" namespace OHOS { namespace MMI { @@ -1892,5 +1893,88 @@ int32_t MultimodalInputConnectProxy::CancelInjection() } return RET_OK; } + +int32_t MultimodalInputConnectProxy::HasIrEmitter(bool &hasIrEmitter) +{ + CALL_DEBUG_ENTER; + MessageParcel data; + if (!data.WriteInterfaceToken(MultimodalInputConnectProxy::GetDescriptor())) { + MMI_HILOGE("Failed to write descriptor"); + return ERR_INVALID_VALUE; + } + MessageParcel reply; + MessageOption option; + sptr remote = Remote(); + CHKPR(remote, RET_ERR); + int32_t ret = remote->SendRequest(static_cast(MultimodalinputConnectInterfaceCode::NATIVE_INFRARED_OWN), + data, reply, option); + READBOOL(reply, hasIrEmitter, IPC_PROXY_DEAD_OBJECT_ERR); + if (ret != RET_OK) { + MMI_HILOGE("MultimodalInputConnectProxy::HasIrEmitter Send request fail, ret:%{public}d", ret); + return ret; + } + return RET_OK; +} + +int32_t MultimodalInputConnectProxy::GetInfraredFrequencies(std::vector& requencys) +{ + CALL_DEBUG_ENTER; + MessageParcel data; + if (!data.WriteInterfaceToken(MultimodalInputConnectProxy::GetDescriptor())) { + MMI_HILOGE("Failed to write descriptor"); + return ERR_INVALID_VALUE; + } + MessageParcel reply; + MessageOption option; + sptr remote = Remote(); + CHKPR(remote, RET_ERR); + int32_t ret = remote->SendRequest(static_cast( + MultimodalinputConnectInterfaceCode::NATIVE_INFRARED_FREQUENCY), + data, reply, option); + if (ret != RET_OK) { + MMI_HILOGE("MultimodalInputConnectProxy::GetInfraredFrequencies Send request fail, ret:%{public}d", ret); + return ret; + } + int64_t number; + READINT64(reply, number, IPC_PROXY_DEAD_OBJECT_ERR); + int64_t min = 0; + int64_t max = 0; + for (int32_t i = 0; i < number; i++) { + READINT64(reply, max); + READINT64(reply, min); + InfraredFrequency item; + item.max_ = max; + item.min_ = min; + requencys.push_back(item); + } + return ret; +} + +int32_t MultimodalInputConnectProxy::TransmitInfrared(int64_t number, std::vector& pattern) +{ + CALL_DEBUG_ENTER; + MessageParcel data; + if (!data.WriteInterfaceToken(MultimodalInputConnectProxy::GetDescriptor())) { + MMI_HILOGE("Failed to write descriptor"); + return ERR_INVALID_VALUE; + } + WRITEINT64(data, number, ERR_INVALID_VALUE); + WRITEINT32(data, static_cast(pattern.size()), ERR_INVALID_VALUE); + for (const auto &item : pattern) { + WRITEINT64(data, item); + } + MessageParcel reply; + MessageOption option; + sptr remote = Remote(); + CHKPR(remote, RET_ERR); + int32_t ret = remote->SendRequest(static_cast( + MultimodalinputConnectInterfaceCode::NATIVE_CANCEL_TRANSMIT), + data, reply, option); + if (ret != RET_OK) { + MMI_HILOGE("MultimodalInputConnectProxy::TransmitInfrared Send request fail, ret:%{public}d", ret); + return ret; + } + return RET_OK; +} } // namespace MMI } // namespace OHOS diff --git a/service/connect_manager/src/multimodal_input_connect_stub.cpp b/service/connect_manager/src/multimodal_input_connect_stub.cpp index 6668728064f146daf75a029d172ca96251a73fa0..a691d86da02a3d68712f4ee5d0ff000336df5c0f 100644 --- a/service/connect_manager/src/multimodal_input_connect_stub.cpp +++ b/service/connect_manager/src/multimodal_input_connect_stub.cpp @@ -297,6 +297,15 @@ int32_t MultimodalInputConnectStub::OnRemoteRequest(uint32_t code, MessageParcel case static_cast(MultimodalinputConnectInterfaceCode::NATIVE_CANCEL_INJECTION): return StubCancelInjection(data, reply); break; + case static_cast(MultimodalinputConnectInterfaceCode::NATIVE_INFRARED_OWN): + return StubHasIrEmitter(data, reply); + break; + case static_cast(MultimodalinputConnectInterfaceCode::NATIVE_INFRARED_FREQUENCY): + return StubGetInfraredFrequencies(data, reply); + break; + case static_cast(MultimodalinputConnectInterfaceCode::NATIVE_CANCEL_TRANSMIT): + return StubTransmitInfrared(data, reply); + break; default: { MMI_HILOGE("Unknown code:%{public}u, go switch default", code); return IPCObjectStub::OnRemoteRequest(code, data, reply, option); @@ -2067,5 +2076,77 @@ int32_t MultimodalInputConnectStub::StubCancelInjection(MessageParcel& data, Mes } return RET_OK; } + +int32_t MultimodalInputConnectStub::StubHasIrEmitter(MessageParcel& data, MessageParcel& reply) +{ + CALL_DEBUG_ENTER; + if (!PerHelper->VerifySystemApp()) { + MMI_HILOGE("Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + bool hasIrEmitter = false; + int32_t ret = HasIrEmitter(hasIrEmitter); + if (ret != RET_OK) { + MMI_HILOGE("Call StubHasIrEmitter failed ret:%{public}d", ret); + return ret; + } + WRITEBOOL(reply, hasIrEmitter, IPC_STUB_WRITE_PARCEL_ERR); + return RET_OK; +} + +int32_t MultimodalInputConnectStub::StubGetInfraredFrequencies(MessageParcel& data, MessageParcel& reply) +{ + CALL_DEBUG_ENTER; + if (!PerHelper->VerifySystemApp()) { + MMI_HILOGE("GetInfraredFrequencies Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (!PerHelper->CheckInfraredEmmit()) { + MMI_HILOGE("MulmodalConStub::StubGetInfr permi check failed. returnCode:%{public}d", ERROR_NO_PERMISSION); + return ERROR_NO_PERMISSION; + } + std::vector requencys; + int32_t ret = GetInfraredFrequencies(requencys); + if (ret != RET_OK) { + MMI_HILOGE("Call StubGetInfraredFrequencies failed returnCode:%{public}d", ret); + return ret; + } + WRITEINT64(reply, requencys.size()); + for (const auto &item : requencys) { + WRITEINT64(reply, item.max_); + WRITEINT64(reply, item.min_); + } + return RET_OK; +} + +int32_t MultimodalInputConnectStub::StubTransmitInfrared(MessageParcel& data, MessageParcel& reply) +{ + CALL_DEBUG_ENTER; + if (!PerHelper->VerifySystemApp()) { + MMI_HILOGE("StubTransmitInfrared Verify system APP failed"); + return ERROR_NOT_SYSAPI; + } + if (!PerHelper->CheckInfraredEmmit()) { + MMI_HILOGE("StubTransmitInfrared permission check failed. returnCode:%{public}d", ERROR_NO_PERMISSION); + return ERROR_NO_PERMISSION; + } + int64_t number = 0; + READINT64(data, number, IPC_PROXY_DEAD_OBJECT_ERR); + int32_t pattern_len = 0; + std::vector pattern; + READINT32(data, pattern_len, IPC_PROXY_DEAD_OBJECT_ERR); + for (int32_t i = 0; i < pattern_len; i++) { + int64_t value = 0; + READINT64(data, value); + pattern.push_back(value); + } + int32_t ret = TransmitInfrared(number, pattern); + if (ret != RET_OK) { + MMI_HILOGE("Call StubTransmitInfrared failed returnCode:%{public}d", ret); + return ret; + } + WRITEINT32(reply, ret); + return RET_OK; +} } // namespace MMI } // namespace OHOS diff --git a/service/device_manager/test/input_device_manager_test.cpp b/service/device_manager/test/input_device_manager_test.cpp index 796d8c0a76af57af055cad29d4b4e2bd3125d705..c9a5d1f5c926540df750750ac39dfd5ae3939005 100644 --- a/service/device_manager/test/input_device_manager_test.cpp +++ b/service/device_manager/test/input_device_manager_test.cpp @@ -139,19 +139,6 @@ HWTEST_F(InputDeviceManagerTest, HasTouchDevice_Test_001, TestSize.Level1) EXPECT_FALSE(ret); } -/** - * @tc.name: ParseDeviceId_Test_001 - * @tc.desc: Test the function ParseDeviceId - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(InputDeviceManagerTest, ParseDeviceId_Test_001, TestSize.Level1) -{ - InputDeviceManager inputDevice; - std::string sysName = "test"; - int32_t ret = inputDevice.ParseDeviceId(sysName); - EXPECT_EQ(ret, RET_ERR); -} /** * @tc.name: ScanPointerDevice_Test_001 diff --git a/service/infrared_emitter/include/infrared_emitter_controller.h b/service/infrared_emitter/include/infrared_emitter_controller.h new file mode 100644 index 0000000000000000000000000000000000000000..1e0e87499270ac0d25e4988d605eba4ec39489d1 --- /dev/null +++ b/service/infrared_emitter/include/infrared_emitter_controller.h @@ -0,0 +1,48 @@ +/* + * 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 INFRARED_EMMITTER_CONTROLLER_H +#define INFRARED_EMMITTER_CONTROLLER_H + +#include "infrared_frequency_info.h" + +#include "nocopyable.h" +#include "v1_0/consumer_ir.h" +#include "v1_0/types.h" + +namespace OHOS { +namespace MMI { +class InfraredEmitterController { +public: + /** + * @brief Obtains an InfraredEmitterController instance. + * @return Returns the pointer to the InfraredEmitterController instance. + * @since 12 + */ + static InfraredEmitterController *GetInstance(); + virtual ~InfraredEmitterController() = default; + void InitInfraredEmitter(); + bool Transmit(int64_t carrierFreq, std::vector pattern); + bool GetFrequencies(std::vector &frequencyInfo); + +private: + InfraredEmitterController() =default; + DISALLOW_COPY_AND_MOVE(InfraredEmitterController); + static InfraredEmitterController *instance_; + sptr irInterface_ {nullptr}; +}; +} +} +#endif // INFRARED_EMMITTER_CONTROLLER_H \ No newline at end of file diff --git a/service/infrared_emitter/src/infrared_emitter_controller.cpp b/service/infrared_emitter/src/infrared_emitter_controller.cpp new file mode 100644 index 0000000000000000000000000000000000000000..625131dfce244b761f3795d37b9be9dae3a14a65 --- /dev/null +++ b/service/infrared_emitter/src/infrared_emitter_controller.cpp @@ -0,0 +1,108 @@ +/* + * 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 "infrared_emitter_controller.h" +#include "mmi_log.h" + +namespace OHOS { +namespace MMI { +namespace { +constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, MMI_LOG_DOMAIN, "InfraredEmitterController" }; +} // namespace +using namespace OHOS::HDI::Consumerir::V1_0; +InfraredEmitterController *InfraredEmitterController::instance_ = new (std::nothrow) InfraredEmitterController(); +InfraredEmitterController *InfraredEmitterController::GetInstance() +{ + return instance_; +} + +void InfraredEmitterController::InitInfraredEmitter() +{ + CALL_DEBUG_ENTER; + MMI_HILOGI("infrared emitter call ConsumerIr::Get()"); + irInterface_ = ConsumerIr::Get(); + if (irInterface_ == nullptr) { + MMI_HILOGE("infrared emitter init"); + return; + } + MMI_HILOGI("infrared emitter init ok"); +} + +bool InfraredEmitterController::Transmit(int64_t carrierFreq, std::vector pattern) +{ + CALL_DEBUG_ENTER; + if (!irInterface_) { + MMI_HILOGE("infrared emitter not init"); + return false; + } + + int32_t tempCarrierFreq = carrierFreq; + std::vector tempPattern; + std::string context = "infraredFrequency:" + std::to_string(tempCarrierFreq) + ";"; + for (size_t i = 0; i < pattern.size(); i++) { + int32_t per = pattern[i]; + context = context + "index:" + std::to_string(i) + ": pattern:" + std::to_string(per) + ";"; + tempPattern.push_back(per); + } + MMI_HILOGI("irInterface_->Transmit params:%{public}s", context.c_str()); + + bool outRet = false; + int32_t ret = irInterface_->Transmit(tempCarrierFreq, tempPattern, outRet); + MMI_HILOGI("irInterface_->Transmit ret:%{public}d", ret); + if (ret < HDF_SUCCESS) { + MMI_HILOGE("infrared emitter transmit %{public}d", ret); + return false; + } + if (!outRet) { + MMI_HILOGE("infrared emitter transmit out false"); + return false; + } + return true; +} + +bool InfraredEmitterController::GetFrequencies(std::vector &frequencyInfo) +{ + CALL_DEBUG_ENTER; + if (!irInterface_) { + MMI_HILOGE("infrared emitter not init"); + return false; + } + bool outRet = false; + std::vector outRange; + MMI_HILOGI("irInterface_->GetCarrierFreqs"); + int32_t ret = irInterface_->GetCarrierFreqs(outRet, outRange); + MMI_HILOGI("irInterface_->GetCarrierFreqs ret:%{public}d", ret); + if (ret < HDF_SUCCESS) { + MMI_HILOGE("infrared emitter GetCarrierFreqs %{public}d", ret); + return false; + } + if (!outRet) { + MMI_HILOGE("infrared emitter GetCarrierFreqs out false"); + return false; + } + std::string context = "size:" + std::to_string(outRange.size()) + ";"; + for (size_t i = 0; i < outRange.size(); i++) { + InfraredFrequency item; + context = context + "index:" + std::to_string(i) + ": per.max:" + std::to_string(outRange[i].max) + + ": per.min:" + std::to_string(outRange[i].min) + ";;"; + item.max_ = outRange[i].max; + item.min_ = outRange[i].min; + frequencyInfo.pushback(item); + } + return true; +} +} // namespace MMI +} // namespace OHOS + diff --git a/service/module_loader/include/mmi_service.h b/service/module_loader/include/mmi_service.h index 9d947948b0a70f5e35407dd519eaa1bbb406982a..cf538d1e8f98c3034b55809264ebdd0fa332978e 100644 --- a/service/module_loader/include/mmi_service.h +++ b/service/module_loader/include/mmi_service.h @@ -32,6 +32,7 @@ #include "server_msg_handler.h" #include "uds_server.h" #include "nap_process.h" +#include "infrared_frequency_info.h" namespace OHOS { namespace MMI { @@ -133,6 +134,12 @@ public: int32_t Authorize(bool isAuthorize) override; int32_t CancelInjection() override; void OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override; + int32_t HasIrEmitter(bool &hasIrEmitter) override; + int32_t GetInfraredFrequencies(std::vector& requencys) override; + int32_t TransmitInfrared(int64_t number, std::vector& pattern) override; + int32_t OnHasIrEmitter(bool &hasIrEmitter); + int32_t OnGetInfraredFrequencies(std::vector& requencys); + int32_t OnTransmitInfrared(int64_t number, std::vector& pattern); #ifdef OHOS_BUILD_ENABLE_ANCO void InitAncoUds(); diff --git a/service/module_loader/src/mmi_service.cpp b/service/module_loader/src/mmi_service.cpp index 4a6e3dd8c26056279753822ddeee958ecba7f95d..584866ee2389f60d1661eca3bc4028233aa85c84 100644 --- a/service/module_loader/src/mmi_service.cpp +++ b/service/module_loader/src/mmi_service.cpp @@ -56,6 +56,9 @@ #include "display_event_monitor.h" #include "fingersense_wrapper.h" #include "multimodal_input_preferences_manager.h" +#ifdef OHOS_BUILD_ENABLE_ANCO +#include "infrared_emitter_controller.h" +#endif namespace OHOS { namespace MMI { @@ -247,7 +250,14 @@ int32_t MMIService::Init() NapProcess::GetInstance()->Init(*this); MMI_HILOGD("ANRManager Init"); ANRMgr->Init(*this); - MMI_HILOGD("PointerDrawingManager Init"); +#ifdef OHOS_BUILD_ENABLE_ANCO + MMI_HILOGI("InitInfraredEmitter Init"); + InfraredEmitterController::GetInstance()->InitInfraredEmitter(); +#else + MMI_HILOGI("InfraredEmitter not supported"); +#endif + + MMI_HILOGI("PointerDrawingManager Init"); #ifdef OHOS_BUILD_ENABLE_POINTER if (!IPointerDrawingManager::GetInstance()->Init()) { MMI_HILOGE("Pointer draw init failed"); @@ -2026,5 +2036,75 @@ int32_t MMIService::OnCancelInjection() { return sMsgHandler_.OnCancelInjection(); } + +int32_t MMIService::HasIrEmitter(bool &hasIrEmitter) +{ + CALL_DEBUG_ENTER; + int32_t ret = delegateTasks_.PostSyncTask(std::bind(&MMIService::OnHasIrEmitter, this, std::ref(hasIrEmitter))); + if (ret != RET_OK) { + MMI_HILOGE("OnHasIrEmitter failed, ret:%{public}d", ret); + return RET_ERR; + } + return RET_OK; +} + +int32_t MMIService::GetInfraredFrequencies(std::vector& requencys) +{ + CALL_DEBUG_ENTER; + int32_t ret = delegateTasks_.PostSyncTask(std::bind(&MMIService::OnGetInfraredFrequencies, + this, std::ref(requencys))); + if (ret != RET_OK) { + MMI_HILOGE("OnGetInfraredFrequencies failed, returnCode:%{public}d", ret); + return RET_ERR; + } + return RET_OK; +} + +int32_t MMIService::TransmitInfrared(int64_t number, std::vector& pattern) +{ + CALL_DEBUG_ENTER; + int32_t ret = delegateTasks_.PostSyncTask(std::bind(&MMIService::OnTransmitInfrared, this, number, pattern)); + if (ret != RET_OK) { + MMI_HILOGE("OnTransmitInfrared failed, returnCode:%{public}d", ret); + return RET_ERR; + } + return RET_OK; +} + +int32_t MMIService::OnHasIrEmitter(bool &hasIrEmitter) +{ + hasIrEmitter = false; + return RET_OK; +} + +int32_t MMIService::OnGetInfraredFrequencies(std::vector& requencys) +{ + #ifdef OHOS_BUILD_ENABLE_ANCO + InfraredEmitterController::GetInstance()->GetFrequencies(requencys); + #endif + std::string context = ""; + int32_t size = static_cast(requencys.size()); + for (int32_t i = 0; i < size; i++) { + context = context + "requencys[" + std::to_string(i) + "]. max=" + + std::to_string(requencys[i].max_) + ",min=" + std::to_string(requencys[i].min_) +";"; + } + MMI_HILOGD("MMIService::OnGetInfraredFrequencies data from hdf is. %{public}s ", context.c_str()); + return RET_OK; +} + +int32_t MMIService::OnTransmitInfrared(int64_t infraredFrequency, std::vector& pattern) +{ + std::string context = "infraredFrequency:" + std::to_string(infraredFrequency) + ";"; + int32_t size = static_cast(pattern.size()); + for (int32_t i = 0; i < size; i++) { + context = context + "index:" + std::to_string(i) + ": pattern:" + std::to_string(pattern[i]) + ";"; + } + #ifdef OHOS_BUILD_ENABLE_ANCO + InfraredEmitterController::GetInstance()->Transmit(infraredFrequency, pattern); + #endif + + MMI_HILOGI("MMIService::OnTransmitInfrared para. %{public}s", context.c_str()); + return RET_OK; +} } // namespace MMI } // namespace OHOS diff --git a/service/permission_helper/include/permission_helper.h b/service/permission_helper/include/permission_helper.h index 4ad116a6d553e6b66539f6655734855a293e7226..16044c042b1521102fd035c8cd9d3b030b70e203 100644 --- a/service/permission_helper/include/permission_helper.h +++ b/service/permission_helper/include/permission_helper.h @@ -37,9 +37,23 @@ public: int32_t GetTokenType(); bool CheckDispatchControl(); bool VerifySystemApp(); + bool CheckInfraredEmmit(); private: bool CheckHapPermission(uint32_t tokenId, uint32_t required); + /*** + * this function is checked whether a oparate from APP has certial permissions + * tokenId: id of applicaiton + * permissionCode: code of permission for checked + * returnedValue: true: check successful; false: check failed + * ****/ + bool CheckHapPermission(uint32_t tokenId, std::string permissionCode); + /*** + * this function is checked whether a oparate from APP has certial permissions + * permissionCode: code of permission for checked + * returnedValue: true: check successful; false: check failed + * ****/ + bool CheckHapPermission(std::string permissionCode); bool CheckMonitorPermission(uint32_t tokenId); bool CheckInterceptorPermission(uint32_t tokenId); bool CheckDispatchControlPermission(uint32_t tokenId); diff --git a/service/permission_helper/src/permission_helper.cpp b/service/permission_helper/src/permission_helper.cpp index 0d4305be39b2737b79837ca9017fe51810f61a1b..70f0bdc9844e60ea04681803542bdc0891ab2a0c 100644 --- a/service/permission_helper/src/permission_helper.cpp +++ b/service/permission_helper/src/permission_helper.cpp @@ -118,6 +118,67 @@ bool PermissionHelper::CheckHapPermission(uint32_t tokenId, uint32_t required) return true; } +/*** + * add this funciton just because CheckHapPermission(int, String) and + * CheckHapPermission(string ) are private function + * In fact this should be added as the previous two functions as public + * but consider the privacy and security add them as private + * ***/ +bool PermissionHelper::CheckInfraredEmmit() +{ + std::string infraredEmmitPermissionCode = "ohos.permission.INFRARED_EMITTER"; + return CheckHapPermission(infraredEmmitPermissionCode); +} + +/*** + * this function is checked whether a oparate from APP has certial permissions + * tokenId: id of applicaiton + * permissionCode: code of permission for checked + * returnedValue: true: check successful; false: check failed + * permissionCode of InfraredEmitter Function: ohos.permission.INFRARED_EMITTER + * ****/ +bool PermissionHelper::CheckHapPermission(const std::string permissionCode) +{ + CALL_DEBUG_ENTER; + auto tokenId = IPCSkeleton::GetCallingTokenID(); + return CheckHapPermission(tokenId, permissionCode); +} + +/*** + * this function is checked whether a oparate from APP has certial permissions + * tokenId:id of applicaiton + * permissionCode:code of permission for checked + * returnedValue:true: check successful; false: check failed + * permissionCode of InfraredEmitter Function: ohos.permission.InfraredEmitter + * CheckHapPermission(pid, permissionCode) + * ****/ +bool PermissionHelper::CheckHapPermission(uint32_t tokenId, const std::string permissionCode) +{ + CALL_DEBUG_ENTER; + auto tokenType = OHOS::Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(tokenId); + if ((tokenType == OHOS::Security::AccessToken::TOKEN_HAP) || + (tokenType == OHOS::Security::AccessToken::TOKEN_NATIVE)) { + /*** check permission later ***/ + } else if (tokenType == OHOS::Security::AccessToken::TOKEN_SHELL) { + MMI_HILOGI("Token type is shell"); + return true; + } else { + MMI_HILOGE("Unsupported token type:%{public}d", tokenType); + return false; + } + + /*** check permission here ***/ + std::string context = "For CheckPerm. PermiCode" + permissionCode + ";appId:" + std::to_string(tokenId); + int32_t ret = OHOS::Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenId, permissionCode); + if (ret != OHOS::Security::AccessToken::PERMISSION_GRANTED) { + MMI_HILOGE("Check Permi: %{public}s fail for appId:%{public}d, and ret:%{public}d", + permissionCode.c_str(), tokenId, ret); + return false; + } + MMI_HILOGD("Check permission( %{public}s) permission success", permissionCode.c_str()); + return true; +} + bool PermissionHelper::CheckMonitorPermission(uint32_t tokenId) { static const std::string inputMonitor = "ohos.permission.INPUT_MONITORING"; diff --git a/test/unittest/interfaces/BUILD.gn b/test/unittest/interfaces/BUILD.gn index bab08f02f5ae5dc0ad0ed2fae971eddb309232ac..3f509052a20e11f8f946d9d2056b5e0730b1ade7 100644 --- a/test/unittest/interfaces/BUILD.gn +++ b/test/unittest/interfaces/BUILD.gn @@ -19,8 +19,17 @@ module_output_path = "multimodalinput/mmi_unit_out" ohos_unittest("InputNativeTest") { module_out_path = module_output_path - + defines = [] include_dirs = [ "${mmi_path}/interfaces/kits/c/input" ] + if (input_ext_feature_anco) { + defines += [ "OHOS_BUILD_ENABLE_ANCO" ] + } + if (input_ext_feature_anco) { + include_dirs += [ + "${mmi_path}/service/infrared_emitter/include", + "${mmi_path}/interfaces/native/innerkits/event/include", + ] + } sources = [ "${mmi_path}/test/unittest/interfaces/kits/input_native_test.cpp" ] @@ -38,6 +47,12 @@ ohos_unittest("InputNativeTest") { "//third_party/googletest:gtest_main", ] + if (input_ext_feature_anco) { + external_deps += [ + "drivers_interface_rtos_extra:libconsumerir_proxy_1.0", + "hdf_core:libhdi", + ] + } external_deps = [ "c_utils:utils", "hilog:libhilog", diff --git a/test/unittest/interfaces/kits/input_native_test.cpp b/test/unittest/interfaces/kits/input_native_test.cpp index 80d99b3f7e765f72f7106eb39c22595a866c1524..ac0f5ccf8c52e4d13d37fb350b716b0a0ca04c2e 100644 --- a/test/unittest/interfaces/kits/input_native_test.cpp +++ b/test/unittest/interfaces/kits/input_native_test.cpp @@ -19,7 +19,9 @@ #include "key_event.h" #include "oh_input_manager.h" #include "oh_key_code.h" - +#ifdef OHOS_BUILD_ENABLE_ANCO + #include "infrared_emitter_controller.h" +#endif namespace OHOS { namespace MMI { namespace { @@ -30,7 +32,6 @@ class InputNativeTest : public testing::Test { public: static void SetUpTestCase(void) {} static void TearDownTestCase(void) {} - void SetUp() {} void TearDown() {} }; @@ -479,5 +480,45 @@ HWTEST_F(InputNativeTest, InputNativeTest_TouchEventActionTime_001, TestSize.Lev OH_Input_DestroyTouchEvent(&touchEvent); EXPECT_EQ(touchEvent, nullptr); } + +/** + * @tc.name: InputNativeTest_IR_001 + * @tc.desc: Verify the IR GetFrequencies + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(InputNativeTest, InputNativeTest_IR_001, TestSize.Level1) +{ +#ifdef OHOS_BUILD_ENABLE_ANCO + InfraredEmitter::GetInstance()->InitInfraredEmitter(); + std::vector frequencyInfo; + bool bRet = InfraredEmitter::GetInstance()->GetFrequencies(frequencyInfo); + ASSERT_EQ(bRet, true); + bool bSizeBiggerZero = frequencyInfo.size(); + ASSERT_EQ(bSizeBiggerZero, true); +#else + ASSERT_EQ("no support", "no support"); +#endif // OHOS_BUILD_ENABLE_ANCO +} + +/** + * @tc.name: InputNativeTest_IR_002 + * @tc.desc: Verify the set and get of touchEvent actionTime + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(InputNativeTest, InputNativeTest_IR_002, TestSize.Level1) +{ +#ifdef OHOS_BUILD_ENABLE_ANCO + InfraredEmitter::GetInstance()->InitInfraredEmitter(); + int64_t carrierFreq = 3800; + std::vector pattern = {0x01, 0x02, 0x03}; + std::vector frequencyInfo; + bool bRet = InfraredEmitter::GetInstance()->Transmit(carrierFreq, pattern); + ASSERT_EQ(bRet, true); +#else + ASSERT_EQ("no support", "no support"); +#endif // OHOS_BUILD_ENABLE_ANCO +} } // namespace MMI } // namespace OHOS