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 = "accesstoken_test", 44 .instIndex = 0, 45 .appIDDesc = "test" 46 }; 47 48 PermissionDef infoManagerTestPermDef = { 49 .permissionName = "ohos.permission.test", 50 .bundleName = "accesstoken_test", 51 .grantMode = 1, 52 .availableLevel = APL_SYSTEM_CORE, 53 .label = "label", 54 .labelId = 1, 55 .description = "test input event filter", 56 .descriptionId = 1, 57 }; 58 59 PermissionStateFull infoManagerTestState = { 60 .permissionName = "ohos.permission.test", 61 .isGeneral = true, 62 .resDeviceID = { "local" }, 63 .grantStatus = { PermissionState::PERMISSION_GRANTED }, 64 .grantFlags = { 1 }, 65 }; 66 67 HapPolicyParams infoManagerTestPolicyPrams = { 68 .apl = APL_SYSTEM_CORE, 69 .domain = "test.domain", 70 .permList = { infoManagerTestPermDef }, 71 .permStateList = { infoManagerTestState } 72 }; 73 } // namespace 74 75 class AccessToken { 76 public: AccessToken()77 AccessToken() 78 { 79 currentID_ = GetSelfTokenID(); 80 AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(infoManagerTestInfoParms, infoManagerTestPolicyPrams); 81 accessID_ = tokenIdEx.tokenIdExStruct.tokenID; 82 SetSelfTokenID(accessID_); 83 } ~AccessToken()84 ~AccessToken() 85 { 86 AccessTokenKit::DeleteToken(accessID_); 87 SetSelfTokenID(currentID_); 88 } 89 private: 90 AccessTokenID currentID_ = 0; 91 AccessTokenID accessID_ = 0; 92 }; 93 94 class InputManagerManualTest : public testing::Test { 95 public: SetUpTestCase(void)96 static void SetUpTestCase(void) {} TearDownTestCase(void)97 static void TearDownTestCase(void) {} 98 SetUp()99 void SetUp() {} TearDown()100 void TearDown() {} 101 }; 102 103 /** 104 * @tc.name: StartBytrace_001 105 * @tc.desc: Verify keyevent start bytrace 106 * @tc.type: FUNC 107 * @tc.require: 108 */ 109 HWTEST_F(InputManagerManualTest, StartBytrace_001, TestSize.Level1) 110 { 111 CALL_TEST_DEBUG; 112 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 113 ASSERT_NE(keyEvent, nullptr); 114 keyEvent->SetId(0); 115 BytraceAdapter::StartBytrace(keyEvent); 116 ASSERT_EQ(keyEvent->GetId(), 0); 117 } 118 119 /** 120 * @tc.name: StartBytrace_002 121 * @tc.desc: Verify keyevent start bytrace 122 * @tc.type: FUNC 123 * @tc.require: 124 */ 125 HWTEST_F(InputManagerManualTest, StartBytrace_002, TestSize.Level1) 126 { 127 CALL_TEST_DEBUG; 128 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 129 ASSERT_NE(keyEvent, nullptr); 130 keyEvent->SetId(0); 131 keyEvent->SetKeyCode(0); 132 BytraceAdapter::StartBytrace(keyEvent, BytraceAdapter::KEY_INTERCEPT_EVENT); 133 BytraceAdapter::StartBytrace(keyEvent, BytraceAdapter::KEY_LAUNCH_EVENT); 134 BytraceAdapter::StartBytrace(keyEvent, BytraceAdapter::KEY_SUBSCRIBE_EVENT); 135 BytraceAdapter::StartBytrace(keyEvent, BytraceAdapter::KEY_DISPATCH_EVENT); 136 BytraceAdapter::StartBytrace(keyEvent, BytraceAdapter::POINT_INTERCEPT_EVENT); 137 ASSERT_EQ(keyEvent->GetKeyCode(), 0); 138 } 139 140 /** 141 * @tc.name: StartBytrace_003 142 * @tc.desc: Verify pointerEvent start bytrace 143 * @tc.type: FUNC 144 * @tc.require: 145 */ 146 HWTEST_F(InputManagerManualTest, StartBytrace_003, TestSize.Level1) 147 { 148 CALL_TEST_DEBUG; 149 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 150 ASSERT_NE(pointerEvent, nullptr); 151 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE); 152 BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_START); 153 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 154 BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_START); 155 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE); 156 BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_STOP); 157 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 158 BytraceAdapter::StartBytrace(pointerEvent, BytraceAdapter::TRACE_STOP); 159 ASSERT_EQ(pointerEvent->GetSourceType(), PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 160 } 161 162 /** 163 * @tc.name: StartBytrace_004 164 * @tc.desc: Verify pointerEvent start bytrace 165 * @tc.type: FUNC 166 * @tc.require: 167 */ 168 HWTEST_F(InputManagerManualTest, StartBytrace_004, TestSize.Level1) 169 { 170 CALL_TEST_DEBUG; 171 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 172 ASSERT_NE(pointerEvent, nullptr); 173 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE); 174 BytraceAdapter::StartBytrace(BytraceAdapter::TRACE_START, BytraceAdapter::START_EVENT); 175 BytraceAdapter::StartBytrace(BytraceAdapter::TRACE_START, BytraceAdapter::LAUNCH_EVENT); 176 BytraceAdapter::StartBytrace(BytraceAdapter::TRACE_START, BytraceAdapter::STOP_EVENT); 177 BytraceAdapter::StartBytrace(BytraceAdapter::TRACE_STOP, BytraceAdapter::START_EVENT); 178 BytraceAdapter::StartBytrace(BytraceAdapter::TRACE_STOP, BytraceAdapter::LAUNCH_EVENT); 179 BytraceAdapter::StartBytrace(BytraceAdapter::TRACE_STOP, BytraceAdapter::STOP_EVENT); 180 ASSERT_EQ(pointerEvent->GetSourceType(), PointerEvent::SOURCE_TYPE_MOUSE); 181 } 182 183 #ifdef OHOS_BUILD_ENABLE_KEYBOARD 184 /** 185 * @tc.name: HandlePointerEventFilter_002 186 * @tc.desc: Max filter number check 187 * @tc.type: FUNC 188 * @tc.require: 189 */ 190 HWTEST_F(InputManagerManualTest, HandleKeyEventFilter_003, TestSize.Level1) 191 { 192 CALL_TEST_DEBUG; 193 struct KeyFilter : public IInputEventFilter { OnInputEventOHOS::MMI::KeyFilter194 bool OnInputEvent(std::shared_ptr<KeyEvent> keyEvent) const override 195 { 196 MMI_HILOGI("KeyFilter::OnInputEvent enter,pid: %{public}d", getpid()); 197 return false; 198 } OnInputEventOHOS::MMI::KeyFilter199 bool OnInputEvent(std::shared_ptr<PointerEvent> pointerEvent) const override { return false; } 200 }; 201 AccessToken accessToken;auto filter = std::make_shared<KeyFilter>(); 202 uint32_t touchTags = CapabilityToTags(InputDeviceCapability::INPUT_DEV_CAP_MAX); 203 const int32_t filterId = InputManager::GetInstance()->AddInputEventFilter(filter, 220, touchTags); 204 ASSERT_NE(filterId, RET_ERR); 205 auto retCode = InputManager::GetInstance()->RemoveInputEventFilter(filterId); 206 ASSERT_EQ(retCode, RET_OK); 207 } 208 #endif // OHOS_BUILD_ENABLE_KEYBOARD 209 } // namespace MMI 210 } // namespace OHOS