1 /* 2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <gtest/gtest.h> 17 #include <semaphore.h> 18 19 #include "accesstoken_kit.h" 20 #include "bytrace_adapter.h" 21 #include "define_multimodal.h" 22 #include "error_multimodal.h" 23 #include "input_handler_manager.h" 24 #include "input_manager.h" 25 #include "multimodal_event_handler.h" 26 #include "nativetoken_kit.h" 27 #include "pointer_event.h" 28 #include "proto.h" 29 #include "token_setproc.h" 30 31 namespace OHOS { 32 namespace MMI { 33 using namespace Security::AccessToken; 34 using Security::AccessToken::AccessTokenID; 35 namespace { 36 using namespace testing::ext; 37 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH) 38 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, MMI_LOG_DOMAIN, "InputManagerManualTest" }; 39 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH 40 41 HapInfoParams infoManagerTestInfoParms = { 42 .userID = 1, 43 .bundleName = "inputManagerManualTest", 44 .instIndex = 0, 45 .appIDDesc = "test", 46 .isSystemApp = true 47 }; 48 49 PermissionDef infoManagerTestPermDef = { 50 .permissionName = "ohos.permission.test", 51 .bundleName = "inputManagerManualTest", 52 .grantMode = 1, 53 .availableLevel = APL_SYSTEM_CORE, 54 .label = "label", 55 .labelId = 1, 56 .description = "test input event filter", 57 .descriptionId = 1, 58 }; 59 60 PermissionStateFull infoManagerTestState = { 61 .permissionName = "ohos.permission.test", 62 .isGeneral = true, 63 .resDeviceID = { "local" }, 64 .grantStatus = { PermissionState::PERMISSION_GRANTED }, 65 .grantFlags = { 1 }, 66 }; 67 68 HapPolicyParams infoManagerTestPolicyPrams = { 69 .apl = APL_SYSTEM_CORE, 70 .domain = "test.domain", 71 .permList = { infoManagerTestPermDef }, 72 .permStateList = { infoManagerTestState } 73 }; 74 } // namespace 75 76 class AccessToken { 77 public: AccessToken()78 AccessToken() 79 { 80 currentID_ = GetSelfTokenID(); 81 AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(infoManagerTestInfoParms, infoManagerTestPolicyPrams); 82 accessID_ = tokenIdEx.tokenIDEx; 83 SetSelfTokenID(accessID_); 84 } ~AccessToken()85 ~AccessToken() 86 { 87 AccessTokenKit::DeleteToken(accessID_); 88 SetSelfTokenID(currentID_); 89 } 90 private: 91 uint64_t currentID_ = 0; 92 uint64_t accessID_ = 0; 93 }; 94 95 class InputManagerManualTest : public testing::Test { 96 public: SetUpTestCase(void)97 static void SetUpTestCase(void) {} TearDownTestCase(void)98 static void TearDownTestCase(void) {} 99 SetUp()100 void SetUp() {} TearDown()101 void TearDown() {} 102 }; 103 104 /** 105 * @tc.name: StartBytrace_001 106 * @tc.desc: Verify keyevent start bytrace 107 * @tc.type: FUNC 108 * @tc.require: 109 */ 110 HWTEST_F(InputManagerManualTest, StartBytrace_001, TestSize.Level1) 111 { 112 CALL_TEST_DEBUG; 113 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 114 ASSERT_NE(keyEvent, nullptr); 115 keyEvent->SetId(0); 116 BytraceAdapter::StartBytrace(keyEvent); 117 ASSERT_EQ(keyEvent->GetId(), 0); 118 } 119 120 /** 121 * @tc.name: StartBytrace_002 122 * @tc.desc: Verify keyevent start bytrace 123 * @tc.type: FUNC 124 * @tc.require: 125 */ 126 HWTEST_F(InputManagerManualTest, StartBytrace_002, TestSize.Level1) 127 { 128 CALL_TEST_DEBUG; 129 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 130 ASSERT_NE(keyEvent, nullptr); 131 keyEvent->SetId(0); 132 keyEvent->SetKeyCode(0); 133 BytraceAdapter::StartBytrace(keyEvent, BytraceAdapter::KEY_INTERCEPT_EVENT); 134 BytraceAdapter::StartBytrace(keyEvent, BytraceAdapter::KEY_LAUNCH_EVENT); 135 BytraceAdapter::StartBytrace(keyEvent, BytraceAdapter::KEY_SUBSCRIBE_EVENT); 136 BytraceAdapter::StartBytrace(keyEvent, BytraceAdapter::KEY_DISPATCH_EVENT); 137 BytraceAdapter::StartBytrace(keyEvent, BytraceAdapter::POINT_INTERCEPT_EVENT); 138 ASSERT_EQ(keyEvent->GetKeyCode(), 0); 139 } 140 141 /** 142 * @tc.name: StartBytrace_003 143 * @tc.desc: Verify pointerEvent start bytrace 144 * @tc.type: FUNC 145 * @tc.require: 146 */ 147 HWTEST_F(InputManagerManualTest, StartBytrace_003, TestSize.Level1) 148 { 149 CALL_TEST_DEBUG; 150 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 151 ASSERT_NE(pointerEvent, nullptr); 152 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE); 153 BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_START); 154 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 155 BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_START); 156 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE); 157 BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_STOP); 158 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 159 BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_STOP); 160 ASSERT_EQ(pointerEvent->GetSourceType(), PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 161 } 162 163 /** 164 * @tc.name: StartBytrace_004 165 * @tc.desc: Verify pointerEvent start bytrace 166 * @tc.type: FUNC 167 * @tc.require: 168 */ 169 HWTEST_F(InputManagerManualTest, StartBytrace_004, TestSize.Level1) 170 { 171 CALL_TEST_DEBUG; 172 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 173 ASSERT_NE(pointerEvent, nullptr); 174 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE); 175 BytraceAdapter::StartBytrace(BytraceAdapter::TRACE_START, BytraceAdapter::START_EVENT); 176 BytraceAdapter::StartBytrace(BytraceAdapter::TRACE_START, BytraceAdapter::LAUNCH_EVENT); 177 BytraceAdapter::StartBytrace(BytraceAdapter::TRACE_START, BytraceAdapter::STOP_EVENT); 178 BytraceAdapter::StartBytrace(BytraceAdapter::TRACE_STOP, BytraceAdapter::START_EVENT); 179 BytraceAdapter::StartBytrace(BytraceAdapter::TRACE_STOP, BytraceAdapter::LAUNCH_EVENT); 180 BytraceAdapter::StartBytrace(BytraceAdapter::TRACE_STOP, BytraceAdapter::STOP_EVENT); 181 ASSERT_EQ(pointerEvent->GetSourceType(), PointerEvent::SOURCE_TYPE_MOUSE); 182 } 183 184 #ifdef OHOS_BUILD_ENABLE_KEYBOARD 185 /** 186 * @tc.name: HandlePointerEventFilter_002 187 * @tc.desc: Max filter number check 188 * @tc.type: FUNC 189 * @tc.require: 190 */ 191 HWTEST_F(InputManagerManualTest, HandleKeyEventFilter_003, TestSize.Level1) 192 { 193 CALL_TEST_DEBUG; 194 struct KeyFilter : public IInputEventFilter { OnInputEventOHOS::MMI::KeyFilter195 bool OnInputEvent(std::shared_ptr<KeyEvent> keyEvent) const override 196 { 197 MMI_HILOGI("KeyFilter::OnInputEvent enter,pid:%{public}d", getpid()); 198 return false; 199 } OnInputEventOHOS::MMI::KeyFilter200 bool OnInputEvent(std::shared_ptr<PointerEvent> pointerEvent) const override { return false; } 201 }; 202 auto filter = std::make_shared<KeyFilter>(); 203 uint32_t touchTags = CapabilityToTags(InputDeviceCapability::INPUT_DEV_CAP_MAX); 204 const int32_t filterId = InputManager::GetInstance()->AddInputEventFilter(filter, 220, touchTags); 205 ASSERT_NE(filterId, RET_ERR); 206 auto retCode = InputManager::GetInstance()->RemoveInputEventFilter(filterId); 207 ASSERT_EQ(retCode, RET_OK); 208 } 209 #endif // OHOS_BUILD_ENABLE_KEYBOARD 210 } // namespace MMI 211 } // namespace OHOS