openharmony/accessibility
1
0
Fork 0
mirror of https://gitee.com/openharmony/accessibility synced 2025-03-01 15:45:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

修改用户切替时的crash问题

Browse Source 
Signed-off-by: Mupceet <laiguizhong@huawei.com>
This commit is contained in:
Mupceet 2022-09-24 13:42:56 +08:00
parent 0fc01188db
commit 6f225b87a5
19 changed files with 152 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
services/aams/include/accessible_ability_connection.h
View File

@ -31,8 +31,7 @@ class AccessibilityAccountData;
class AccessibleAbilityConnection : public AAFwk::AbilityConnectionStub {
public:
AccessibleAbilityConnection(const sptr<AccessibilityAccountData> &accountData, const int32_t connectionId,
AccessibilityAbilityInfo &abilityInfo);
AccessibleAbilityConnection(int32_t accountId, int32_t connectionId, AccessibilityAbilityInfo &abilityInfo);
virtual ~AccessibleAbilityConnection();
@ -62,11 +61,6 @@ public:
return elementName_;
}
inline sptr<AccessibilityAccountData> GetAccountData()
{
return accountData_;
}
inline sptr<IAccessibleAbilityClient> GetAbilityClient()
{
return abilityClient_;
@ -84,15 +78,15 @@ public:
private:
class AccessibleAbilityConnectionDeathRecipient final : public IRemoteObject::DeathRecipient {
public:
AccessibleAbilityConnectionDeathRecipient(sptr<AccessibilityAccountData> accountData,
AccessibleAbilityConnectionDeathRecipient(int32_t accountId,
AppExecFwk::ElementName& elementName, std::shared_ptr<AppExecFwk::EventHandler> handler)
: recipientAccountData_(accountData), recipientElementName_(elementName), handler_(handler) {};
: accountId_(accountId), recipientElementName_(elementName), handler_(handler) {};
~AccessibleAbilityConnectionDeathRecipient() = default;
DISALLOW_COPY_AND_MOVE(AccessibleAbilityConnectionDeathRecipient);
void OnRemoteDied(const wptr<IRemoteObject>& remote);
sptr<AccessibilityAccountData> recipientAccountData_;
int32_t accountId_ = -1;
AppExecFwk::ElementName& recipientElementName_;
std::shared_ptr<AppExecFwk::EventHandler> handler_ = nullptr;
};
@ -100,14 +94,13 @@ private:
bool IsWantedEvent(int32_t eventType);
void InitAbilityClient(const sptr<IRemoteObject> &remoteObject);
int32_t accountId_ = -1;
int32_t connectionId_ = -1;
sptr<IRemoteObject::DeathRecipient> deathRecipient_ = nullptr;
sptr<IAccessibleAbilityClient> abilityClient_ = nullptr;
sptr<AccessibleAbilityChannel> channel_ = nullptr;
AccessibilityAbilityInfo abilityInfo_ {};
AppExecFwk::ElementName elementName_ {};
sptr<AccessibilityAccountData> accountData_ = nullptr;
static std::mutex mutex_;
std::shared_ptr<AppExecFwk::EventHandler> eventHandler_ = nullptr;
};
} // namespace Accessibility

6
services/aams/src/accessibility_account_data.cpp
View File

@ -717,7 +717,7 @@ void AccessibilityAccountData::UpdateAbilities()
continue;
}
AppExecFwk::ElementName element(deviceId, bundleName, abilityName);
connection = new(std::nothrow) AccessibleAbilityConnection(this, connectCounter_++, installAbility);
connection = new(std::nothrow) AccessibleAbilityConnection(id_, connectCounter_++, installAbility);
if (connection) {
connection->Connect(element);
AddConnectingA11yAbility(Utils::GetUri(bundleName, abilityName), connection);
@ -725,6 +725,7 @@ void AccessibilityAccountData::UpdateAbilities()
} else {
HILOG_DEBUG("not in enabledAbilites list .");
if (connection) {
RemoveConnectedAbility(connection->GetElementName());
connection->Disconnect();
}
}
@ -846,7 +847,7 @@ void AccessibilityAccountData::AddUITestClient(const sptr<IRemoteObject> &obj,
elementName->SetBundleName(bundleName);
elementName->SetAbilityName(abilityName);
sptr<AccessibleAbilityConnection> connection = new(std::nothrow) AccessibleAbilityConnection(
this, connectCounter_++, *abilityInfo);
id_, connectCounter_++, *abilityInfo);
if (!connection) {
HILOG_ERROR("connection is null");
return;
@ -863,6 +864,7 @@ void AccessibilityAccountData::RemoveUITestClient(sptr<AccessibleAbilityConnecti
return;
}
RemoveInstalledAbility(bundleName);
RemoveConnectedAbility(connection->GetElementName());
connection->OnAbilityDisconnectDoneSync(connection->GetElementName());
}
} // namespace Accessibility

60
services/aams/src/accessible_ability_connection.cpp
View File

@ -24,9 +24,9 @@
namespace OHOS {
namespace Accessibility {
AccessibleAbilityConnection::AccessibleAbilityConnection(const sptr<AccessibilityAccountData> &accountData,
int32_t connectionId, AccessibilityAbilityInfo &abilityInfo)
: connectionId_(connectionId), abilityInfo_(abilityInfo), accountData_(accountData)
AccessibleAbilityConnection::AccessibleAbilityConnection(int32_t accountId, int32_t connectionId,
AccessibilityAbilityInfo &abilityInfo)
: accountId_(accountId), connectionId_(connectionId), abilityInfo_(abilityInfo)
{
eventHandler_ = std::make_shared<AppExecFwk::EventHandler>(
Singleton<AccessibleAbilityManagerService>::GetInstance().GetMainRunner());
@ -50,13 +50,13 @@ void AccessibleAbilityConnection::OnAbilityConnectDone(const AppExecFwk::Element
return;
}
eventHandler_->PostTask(std::bind([element, remoteObject, resultCode](
sptr<AccessibilityAccountData> &accountData) -> void {
eventHandler_->PostTask(std::bind([element, remoteObject, resultCode](int32_t accountId) -> void {
HILOG_DEBUG("ResultCode is %{public}d", resultCode);
FinishAsyncTrace(HITRACE_TAG_ACCESSIBILITY_MANAGER, "AccessibleAbilityConnect",
static_cast<int32_t>(TraceTaskId::ACCESSIBLE_ABILITY_CONNECT));
std::string bundleName = element.GetBundleName();
std::string abilityName = element.GetAbilityName();
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetAccountData(accountId);
if (!accountData) {
Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
A11yError::ERROR_CONNECT_A11Y_APPLICATION_FAILED, bundleName, abilityName);
@ -90,7 +90,7 @@ void AccessibleAbilityConnection::OnAbilityConnectDone(const AppExecFwk::Element
accountData->RemoveConnectingA11yAbility(Utils::GetUri(element));
Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateAccessibilityManagerService();
connection->InitAbilityClient(remoteObject);
}, accountData_), "OnAbilityConnectDone");
}, accountId_), "OnAbilityConnectDone");
}
void AccessibleAbilityConnection::OnAbilityDisconnectDone(const AppExecFwk::ElementName &element, int32_t resultCode)
@ -166,14 +166,8 @@ AAFwk::Want CreateWant(AppExecFwk::ElementName& element)
void AccessibleAbilityConnection::Disconnect()
{
HILOG_DEBUG();
if (!accountData_) {
HILOG_ERROR("accountData is nullptr.");
return;
}
accountData_->RemoveConnectedAbility(elementName_);
if (accountData_->GetAccountId() ==
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountId()) {
if (accountId_ == Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountId()) {
Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateAccessibilityManagerService();
}
@ -201,16 +195,10 @@ void AccessibleAbilityConnection::Connect(const AppExecFwk::ElementName &element
static_cast<int32_t>(TraceTaskId::ACCESSIBLE_ABILITY_CONNECT));
std::string bundleName = element.GetBundleName();
std::string abilityName = element.GetAbilityName();
if (!accountData_) {
Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
A11yError::ERROR_CONNECT_A11Y_APPLICATION_FAILED, bundleName, abilityName);
HILOG_ERROR("accountData_ is nullptr");
return;
}
elementName_ = element;
int32_t accountId = accountData_->GetAccountId();
HILOG_DEBUG("bundleName[%{public}s], abilityName [%{public}s], accountId [%{public}d]",
bundleName.c_str(), abilityName.c_str(), accountId);
bundleName.c_str(), abilityName.c_str(), accountId_);
auto bundleMgr = Singleton<AccessibleAbilityManagerService>::GetInstance().GetBundleMgrProxy();
if (!bundleMgr) {
@ -219,7 +207,7 @@ void AccessibleAbilityConnection::Connect(const AppExecFwk::ElementName &element
HILOG_ERROR("get bundleMgr failed");
return;
}
int uid = bundleMgr->GetUidByBundleName(bundleName, accountId);
int uid = bundleMgr->GetUidByBundleName(bundleName, accountId_);
HILOG_DEBUG("uid is %{public}d ", uid);
auto abilityManagerClient = AAFwk::AbilityManagerClient::GetInstance();
@ -248,8 +236,9 @@ void AccessibleAbilityConnection::OnAbilityConnectDoneSync(const AppExecFwk::Ele
const sptr<IRemoteObject> &remoteObject)
{
HILOG_DEBUG();
if (!accountData_) {
HILOG_ERROR("accountData_ is nullptr.");
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetAccountData(accountId_);
if (!accountData) {
HILOG_ERROR("accountData is nullptr.");
return;
}
if (!remoteObject) {
@ -259,7 +248,7 @@ void AccessibleAbilityConnection::OnAbilityConnectDoneSync(const AppExecFwk::Ele
elementName_ = element;
sptr<AccessibleAbilityConnection> pointer = this;
accountData_->AddConnectedAbility(pointer);
accountData->AddConnectedAbility(pointer);
Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateAccessibilityManagerService();
InitAbilityClient(remoteObject);
}
@ -267,14 +256,8 @@ void AccessibleAbilityConnection::OnAbilityConnectDoneSync(const AppExecFwk::Ele
void AccessibleAbilityConnection::OnAbilityDisconnectDoneSync(const AppExecFwk::ElementName &element)
{
HILOG_DEBUG();
if (!accountData_) {
HILOG_ERROR("accountData_ is nullptr.");
return;
}
accountData_->RemoveConnectedAbility(element);
if (accountData_->GetAccountId() ==
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountId()) {
if (accountId_ == Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountId()) {
Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateAccessibilityManagerService();
}
@ -299,7 +282,7 @@ void AccessibleAbilityConnection::InitAbilityClient(const sptr<IRemoteObject> &r
if (!deathRecipient_) {
deathRecipient_ = new(std::nothrow) AccessibleAbilityConnectionDeathRecipient(
accountData_, elementName_, eventHandler_);
accountId_, elementName_, eventHandler_);
if (!deathRecipient_) {
Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
A11yError::ERROR_CONNECT_A11Y_APPLICATION_FAILED, bundleName, abilityName);
@ -312,7 +295,7 @@ void AccessibleAbilityConnection::InitAbilityClient(const sptr<IRemoteObject> &r
HILOG_ERROR("Failed to add death recipient");
}
channel_ = new(std::nothrow) AccessibleAbilityChannel(accountData_->GetAccountId(), abilityInfo_.GetId());
channel_ = new(std::nothrow) AccessibleAbilityChannel(accountId_, abilityInfo_.GetId());
if (!channel_) {
Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
A11yError::ERROR_CONNECT_A11Y_APPLICATION_FAILED, bundleName, abilityName);
@ -332,9 +315,11 @@ void AccessibleAbilityConnection::AccessibleAbilityConnectionDeathRecipient::OnR
HILOG_ERROR("handler_ is nullptr");
return;
}
handler_->PostTask(std::bind(
[](sptr<AccessibilityAccountData> &accountData, AppExecFwk::ElementName &elementName) -> void {
handler_->PostTask(std::bind([](int32_t accountId, AppExecFwk::ElementName &elementName) -> void {
HILOG_DEBUG();
auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
auto accountData = aams.GetAccountData(accountId);
if (!accountData) {
HILOG_ERROR("accountData is null.");
return;
@ -354,10 +339,9 @@ void AccessibleAbilityConnection::AccessibleAbilityConnectionDeathRecipient::OnR
accountData->RemoveInstalledAbility("ohos.uitest");
}
auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
accountData->UpdateAbilities();
aams.UpdateAccessibilityManagerService();
}, recipientAccountData_, recipientElementName_), "OnRemoteDied");
}, accountId_, recipientElementName_), "OnRemoteDied");
}
} // namespace Accessibility
} // namespace OHOS

3
services/aams/test/mock/include/mock_accessible_ability_connection.h
View File

@ -52,8 +52,7 @@ public:
class MockAccessibleAbilityConnection : public AccessibleAbilityConnection {
public:
MockAccessibleAbilityConnection(const sptr<AccessibilityAccountData>& accountData, const int32_t connectionId,
AccessibilityAbilityInfo& abilityInfo);
MockAccessibleAbilityConnection(int32_t accountId, int32_t connectionId, AccessibilityAbilityInfo& abilityInfo);
virtual ~MockAccessibleAbilityConnection();

2
services/aams/test/mock/src/mock_accessible_ability_client_proxy.cpp
View File

@ -45,7 +45,7 @@ void AccessibleAbilityClientProxy::Init(const sptr<IAccessibleAbilityChannel>& c
void AccessibleAbilityClientProxy::Disconnect(const int32_t channelId)
{
(void)channelId;
AccessibilityAbilityHelper::GetInstance().SetTestChannelId(channelId);
}
void AccessibleAbilityClientProxy::OnAccessibilityEvent(const AccessibilityEventInfo& eventInfo)

1
services/aams/test/mock/src/mock_accessible_ability_client_stub_impl.cpp
View File

@ -76,6 +76,7 @@ void MockAccessibleAbilityClientStubImpl::Disconnect(const int32_t channelId)
{
(void)channelId;
GTEST_LOG_(INFO) << "MockAccessibleAbilityClientStubImpl Disconnect";
AccessibilityAbilityHelper::GetInstance().SetTestChannelId(INVALID_CHANNEL_ID);
}
void MockAccessibleAbilityClientStubImpl::OnAccessibilityEvent(const AccessibilityEventInfo& eventInfo)
{

17
services/aams/test/mock/src/mock_accessible_ability_connection.cpp
View File

@ -24,11 +24,11 @@
namespace OHOS {
namespace Accessibility {
MockAccessibleAbilityConnection::MockAccessibleAbilityConnection(const sptr<AccessibilityAccountData>& accountData,
const int32_t connectionId, AccessibilityAbilityInfo& abilityInfo)
: AccessibleAbilityConnection(accountData, connectionId, abilityInfo)
MockAccessibleAbilityConnection::MockAccessibleAbilityConnection(int32_t accountId, int32_t connectionId,
AccessibilityAbilityInfo& abilityInfo)
: AccessibleAbilityConnection(accountId, connectionId, abilityInfo)
{
(void)accountData;
(void)accountId;
(void)connectionId;
(void)abilityInfo;
}
@ -181,11 +181,11 @@ sptr<AccessibleAbilityConnection> AccessibleAbilityChannel::GetConnection(int32_
}
AccessibleAbilityConnection::AccessibleAbilityConnection(
const sptr<AccessibilityAccountData>& accountData, int32_t connectionId, AccessibilityAbilityInfo& abilityInfo)
int32_t accountId, int32_t connectionId, AccessibilityAbilityInfo& abilityInfo)
{
accountId_ = accountId;
connectionId_ = connectionId;
abilityInfo_ = abilityInfo;
accountData_ = accountData;
}
AccessibleAbilityConnection::~AccessibleAbilityConnection()
@ -199,9 +199,10 @@ void AccessibleAbilityConnection::OnAbilityConnectDone(
(void)element;
(void)remoteObject;
(void)resultCode;
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetAccountData(accountId_);
sptr<AccessibleAbilityConnection> pointer = this;
if (accountData_ != nullptr) {
accountData_->AddConnectedAbility(pointer);
if (accountData) {
accountData->AddConnectedAbility(pointer);
}
}

109
services/aams/test/unittest/accessibility_account_data_test.cpp
View File

@ -16,10 +16,12 @@
#include <gtest/gtest.h>
#include "accessibility_ability_info.h"
#include "accessibility_account_data.h"
#include "accessibility_common_helper.h"
#include "accessibility_constants.h"
#include "accessibility_element_operator_proxy.h"
#include "accessibility_element_operator_stub.h"
#include "accessibility_ut_helper.h"
#include "accessible_ability_manager_service.h"
#include "mock_accessibility_element_operator_proxy.h"
#include "mock_accessibility_element_operator_stub.h"
#include "mock_accessible_ability_client_stub_impl.h"
@ -65,11 +67,13 @@ void AccessibilityAccountDataTest::TearDownTestCase()
void AccessibilityAccountDataTest::SetUp()
{
Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(AccessibilityAbilityHelper::accountId_);
GTEST_LOG_(INFO) << "AccessibilityAccountDataTest SetUp";
}
void AccessibilityAccountDataTest::TearDown()
{
Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
GTEST_LOG_(INFO) << "AccessibilityAccountDataTest TearDown";
}
@ -108,7 +112,7 @@ HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAcce
sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData, connectCounter++, *abilityInfo);
new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
/* add connected ability */
accountData->AddConnectedAbility(connection);
@ -138,7 +142,7 @@ HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAcce
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData, connectCounter++, *abilityInfo);
new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
const std::string bundleName = "bbb";
EXPECT_FALSE(accountData->GetConnectingA11yAbility(bundleName));
/* add connecting A11y ability */
@ -170,7 +174,7 @@ HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAcce
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData, connectCounter++, *abilityInfo);
new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
/* add connected ability */
accountData->AddConnectedAbility(connection);
/* add connecting A11y ability */
@ -202,7 +206,7 @@ HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AddConn
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData, connectCounter++, *abilityInfo);
new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
/* add connected ability */
accountData->AddConnectedAbility(connection);
@ -227,7 +231,7 @@ HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveC
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData, connectCounter++, *abilityInfo);
new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
/* add */
accountData->AddConnectedAbility(connection);
@ -255,7 +259,7 @@ HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_Ability
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData, connectCounter++, *abilityInfo);
new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
/* add */
accountData->AddConnectedAbility(connection);
@ -288,7 +292,7 @@ HWTEST_F(
AccessibilityAbilityInitParams initParams;
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData, 0, *abilityInfo);
new MockAccessibleAbilityConnection(accountId, 0, *abilityInfo);
accountData->AddConnectingA11yAbility(bundleName, connection);
EXPECT_TRUE(accountData->GetConnectingA11yAbility(bundleName));
/* remove */
@ -440,7 +444,7 @@ HWTEST_F(
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData, connectCounter++, *abilityInfo);
new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
std::string elementName = Utils::GetUri(connection->GetElementName());
EXPECT_FALSE(accountData->GetAccessibleAbilityConnection(elementName));
@ -466,7 +470,7 @@ HWTEST_F(
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData, connectCounter++, *abilityInfo);
new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
accountData->AddConnectedAbility(connection);
const std::string elementName = "111name";
/* get */
@ -488,7 +492,7 @@ HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetConn
AccessibilityAbilityInitParams initParams;
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData, connectCounter++, *abilityInfo);
new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
/* get */
size_t size = accountData->GetConnectedA11yAbilities().size();
EXPECT_EQ(0, size);
@ -578,7 +582,7 @@ HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAbil
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData, connectCounter++, *abilityInfo);
new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
/* add connected ability */
EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
accountData->AddConnectedAbility(connection);
@ -615,7 +619,7 @@ HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAbil
std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData, connectCounter++, *abilityInfo);
new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
EXPECT_NE(abilityInfo->GetId(), installAbilityInfo->GetId());
@ -742,8 +746,7 @@ HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_OnAccou
{
GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_OnAccountSwitched001 start";
// new accountData
const int32_t accountId = 101;
sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
accountData->Init();
// new abilityInfo
AccessibilityAbilityInitParams initParams;
@ -751,7 +754,8 @@ HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_OnAccou
abilityInfo->SetCapabilityValues(CAPABILITY_RETRIEVE | CAPABILITY_TOUCH_GUIDE | CAPABILITY_GESTURE |
CAPABILITY_KEY_EVENT_OBSERVER | CAPABILITY_ZOOM);
// new AAconnection
sptr<AccessibleAbilityConnection> AAConnection = new AccessibleAbilityConnection(accountData, 0, *abilityInfo);
sptr<AccessibleAbilityConnection> AAConnection =
new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
// new aastub
sptr<AccessibleAbilityClientStub> aastub = new MockAccessibleAbilityClientStubImpl();
GTEST_LOG_(INFO) << "OnAbilityConnectDoneSync start !!!!!";
@ -761,29 +765,28 @@ HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_OnAccou
EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
/* CapabilityValues */
accountData->UpdateAccountCapabilities();
bool test1 = accountData->GetGesturesSimulationFlag();
EXPECT_TRUE(test1);
bool test2 = accountData->GetFilteringKeyEventsFlag();
EXPECT_TRUE(test2);
bool test3 = accountData->GetEventTouchGuideStateFlag();
EXPECT_TRUE(test3);
bool test4 = accountData->GetScreenMagnificationFlag();
EXPECT_TRUE(test4);
EXPECT_TRUE(accountData->GetGesturesSimulationFlag());
EXPECT_TRUE(accountData->GetFilteringKeyEventsFlag());
EXPECT_TRUE(accountData->GetEventTouchGuideStateFlag());
EXPECT_TRUE(accountData->GetScreenMagnificationFlag());
/* Account Switched */
GTEST_LOG_(INFO) << "OnAccountSwitched";
accountData->OnAccountSwitched();
AAConnection->OnAbilityDisconnectDoneSync(elementName);
bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
if (AccessibilityAbilityHelper::GetInstance().GetTestChannelId() == INVALID_CHANNEL_ID) {
return true;
} else {
return false;
}
}), 1);
EXPECT_TRUE(ret);
accountData->UpdateAccountCapabilities();
/* initialization */
EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
bool test5 = accountData->GetGesturesSimulationFlag();
EXPECT_FALSE(test5);
bool test6 = accountData->GetFilteringKeyEventsFlag();
EXPECT_FALSE(test6);
bool test7 = accountData->GetEventTouchGuideStateFlag();
EXPECT_FALSE(test7);
bool test8 = accountData->GetScreenMagnificationFlag();
EXPECT_FALSE(test8);
EXPECT_FALSE(accountData->GetGesturesSimulationFlag());
EXPECT_FALSE(accountData->GetFilteringKeyEventsFlag());
EXPECT_FALSE(accountData->GetEventTouchGuideStateFlag());
EXPECT_FALSE(accountData->GetScreenMagnificationFlag());
GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_OnAccountSwitched001 end";
}
@ -802,8 +805,7 @@ HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AddConn
/* add connecting A11y ability */
AccessibilityAbilityInitParams initParams;
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData, 0, *abilityInfo);
sptr<AccessibleAbilityConnection> connection = new MockAccessibleAbilityConnection(accountId, 0, *abilityInfo);
accountData->AddConnectingA11yAbility(bundleName, connection);
accountData->AddConnectingA11yAbility(bundleName, connection);
EXPECT_TRUE(accountData->GetConnectingA11yAbility(bundleName));
@ -1087,8 +1089,7 @@ HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_UpdateA
std::make_shared<AccessibilityAbilityInfo>(initParams);
accountData->AddInstalledAbility(*connectingAbilityInfo);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData, 0, *connectingAbilityInfo);
sptr<AccessibleAbilityConnection> connection = new MockAccessibleAbilityConnection(0, 0, *connectingAbilityInfo);
accountData->AddConnectingA11yAbility("connectingBundle/connectingAbility", connection);
accountData->UpdateAbilities();
EXPECT_TRUE(accountData->GetConnectingA11yAbility("connectingBundle/connectingAbility"));
@ -1103,21 +1104,22 @@ HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_UpdateA
HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_UpdateAbilities_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_002 start";
sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
accountData->AddInstalledAbility(*abilityInfo);
accountData->AddEnabledAbility("testBundle/testAbility");
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData, 0, *abilityInfo);
AppExecFwk::ElementName elementName("testDeviceId", "testBundle", "testAbility");
sptr<AccessibleAbilityClientStub> aastub = new MockAccessibleAbilityClientStubImpl();
connection->OnAbilityConnectDoneSync(elementName, aastub);
EXPECT_TRUE(accountData->GetAccessibleAbilityConnection("testBundle/testAbility"));
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
accountData->AddEnabledAbility(Utils::GetUri(connection->GetElementName()));
connection->Connect(elementName);
accountData->AddConnectedAbility(connection);
EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(Utils::GetUri(connection->GetElementName())));
accountData->UpdateAbilities();
EXPECT_TRUE(accountData->GetAccessibleAbilityConnection("testBundle/testAbility"));
EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(Utils::GetUri(connection->GetElementName())));
GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_002 end";
}
@ -1153,17 +1155,17 @@ HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_UpdateA
HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_UpdateAbilities_004, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_004 start";
sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
accountData->AddInstalledAbility(*abilityInfo);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData, 0, *abilityInfo);
new MockAccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
AppExecFwk::ElementName elementName("testDeviceId", "testBundle", "testAbility");
sptr<AccessibleAbilityClientStub> aastub = new MockAccessibleAbilityClientStubImpl();
connection->OnAbilityConnectDoneSync(elementName, aastub);
EXPECT_TRUE(accountData->GetAccessibleAbilityConnection("testBundle/testAbility"));
connection->Connect(elementName);
accountData->AddConnectedAbility(connection);
EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(Utils::GetUri(connection->GetElementName())));
AccessibilityAbilityHelper::GetInstance().SetTestChannelId(0);
EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTestChannelId(), 0);
@ -1205,8 +1207,7 @@ HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveA
accountData->AddEnabledAbility("testBundle/testAbility");
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData, 0, *abilityInfo);
sptr<AccessibleAbilityConnection> connection = new MockAccessibleAbilityConnection(0, 0, *abilityInfo);
accountData->AddConnectedAbility(connection);
EXPECT_TRUE(accountData->RemoveAbility("testBundle"));
@ -1294,10 +1295,8 @@ HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveU
AccessibilityAbilityInitParams initParams;
initParams.bundleName = "uitestBundle";
initParams.name = "uitestAbility";
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo =
std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(accountData, 0, *abilityInfo);
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
sptr<AccessibleAbilityConnection> connection = new MockAccessibleAbilityConnection(0, 0, *abilityInfo);
accountData->AddUITestClient(nullptr, "uitestBundle", "uitestAbility");
EXPECT_EQ(1, static_cast<int>(accountData->GetInstalledAbilities().size()));

2
services/aams/test/unittest/accessibility_dumper_test.cpp
View File

@ -165,7 +165,7 @@ HWTEST_F(AccessibilityDumperUnitTest, AccessibilityDumper_Unittest_Dump_005, Tes
return;
}
sptr<AccessibleAbilityConnection> connection =
new MockAccessibleAbilityConnection(currentAccount, 0, *abilityInfo);
new MockAccessibleAbilityConnection(currentAccount->GetAccountId(), 0, *abilityInfo);
if (!connection) {
GTEST_LOG_(ERROR) << "Connection is nullptr";
return;

5
services/aams/test/unittest/accessibility_keyevent_filter_test.cpp
View File

@ -87,7 +87,8 @@ void KeyEventFilterUnitTest::AddConnection()
AppExecFwk::ElementName elementName("deviceId", "bundleName", "name");
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
accountData->AddInstalledAbility(*abilityInfo);
sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(accountData, 0, *abilityInfo);
sptr<AccessibleAbilityConnection> connection =
new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
aastub_ = new AccessibleAbilityChannel(accountData->GetAccountId(), abilityInfo->GetId());
connection->OnAbilityConnectDoneSync(elementName, aastub_);
sleep(SLEEP_TIME_3);
@ -144,7 +145,7 @@ HWTEST_F(KeyEventFilterUnitTest, KeyEventFilter_Unittest_SetServiceOnKeyEventRes
sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
AccessibilityAbilityInfo abilityInfo;
std::shared_ptr<AccessibleAbilityConnection> connection =
std::make_shared<AccessibleAbilityConnection>(accountData, connectionId, abilityInfo);
std::make_shared<AccessibleAbilityConnection>(accountId, connectionId, abilityInfo);
AddConnection();
keyEventFilter_->OnKeyEvent(*event);

2
services/aams/test/unittest/accessible_ability_channel_test.cpp
View File

@ -82,7 +82,7 @@ void AccessibleAbilityChannelUnitTest::SetUp()
sptr<AccessibilityAccountData> accountData =
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
ASSERT_TRUE(accountData);
connection_ = new AccessibleAbilityConnection(accountData, 0, *abilityInfo);
connection_ = new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
ASSERT_TRUE(connection_);
AppExecFwk::ElementName elementName("testDeviceId", "testBundleName", "testAbilityName");
channel_ = new AccessibleAbilityChannel(accountData->GetAccountId(), abilityInfo->GetId());

22
services/aams/test/unittest/accessible_ability_connection_test.cpp
View File

@ -87,11 +87,11 @@ void AccessibleAbilityConnectionUnitTest::SetUp()
initParams.abilityTypes = ACCESSIBILITY_ABILITY_TYPE_ALL;
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
abilityInfo->SetEventTypes(EventType::TYPES_ALL_MASK);
accountData_ = new AccessibilityAccountData(0);
accountData_ = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
if (accountData_ != nullptr) {
accountData_->AddAccessibilityWindowConnection(0, connection);
}
connection_ = new AccessibleAbilityConnection(accountData_, 0, *abilityInfo);
connection_ = new AccessibleAbilityConnection(AccessibilityAbilityHelper::accountId_, 0, *abilityInfo);
elementName_ = new AppExecFwk::ElementName("1", "2", "3");
obj_ = new MockAccessibleAbilityClientStubImpl();
if (obj_ != nullptr && connection_ != nullptr) {
@ -149,21 +149,6 @@ HWTEST_F(AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unitte
GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetElementName_001 end";
}
/**
* @tc.number: AccessibleAbilityConnection_Unittest_GetAccountData_001
* @tc.name: GetAccountData
* @tc.desc: Test function GetAccountData
*/
HWTEST_F(AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_GetAccountData_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetAccountData_001 start";
if (connection_ != nullptr) {
auto ret = connection_->GetAccountData();
EXPECT_TRUE(ret.GetRefPtr());
}
GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetAccountData_001 end";
}
/**
* @tc.number: AccessibleAbilityConnection_Unittest_GetAbilityClient_001
* @tc.name: GetAbilityClient
@ -239,8 +224,7 @@ HWTEST_F(AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unitte
connection_->Connect(element);
sptr<AccessibleAbilityClientStub> obj = new MockAccessibleAbilityClientStubImpl();
connection_->OnAbilityConnectDoneSync(element, obj);
auto accountData = connection_->GetAccountData();
EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(Utils::GetUri(
EXPECT_TRUE(accountData_->GetAccessibleAbilityConnection(Utils::GetUri(
element.GetBundleName(), element.GetAbilityName())));
}
GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_Connect_001 end";

33
services/aams/test/unittest/accessible_ability_manager_service_test.cpp
View File

@ -28,6 +28,7 @@
#include "mock_accessible_ability_manager_service_state_observer_proxy.h"
#include "mock_accessible_ability_manager_service_state_observer_stub.h"
#include "mock_bundle_manager.h"
#include "system_ability_definition.h"
using namespace testing;
using namespace testing::ext;
@ -98,7 +99,8 @@ void AccessibleAbilityManagerServiceUnitTest::RegisterAbilityConnectionClient(co
return;
}
accountData->AddInstalledAbility(*abilityInfo);
sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(accountData, 0, *abilityInfo);
sptr<AccessibleAbilityConnection> connection =
new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
connection->OnAbilityConnectDoneSync(elementName, obj);
sleep(SLEEP_TIME_1);
}
@ -575,10 +577,35 @@ HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetActiveWindow_001, TestSize.
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnRemoveSystemAbility_001, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_001 start";
int32_t systemAbilityId = SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN;
std::string deviceId = "test";
auto &ins = Singleton<AccessibleAbilityManagerService>::GetInstance();
ins.OnRemoveSystemAbility(systemAbilityId, deviceId);
AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
if (Singleton<AccessibleAbilityManagerService>::GetInstance().IsServiceReady() == false) {
return true;
} else {
return false;
}
}), SLEEP_TIME_1);
EXPECT_FALSE(ins.IsServiceReady());
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_001 end";
}
/**
* @tc.number: AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_002
* @tc.name: OnRemoveSystemAbility
* @tc.desc: Test function OnRemoveSystemAbility
*/
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnRemoveSystemAbility_002, TestSize.Level1)
{
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_002 start";
int32_t systemAbilityId = 1;
std::string deviceId = "test";
Singleton<AccessibleAbilityManagerService>::GetInstance().OnRemoveSystemAbility(systemAbilityId, deviceId);
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_001 end";
auto &ins = Singleton<AccessibleAbilityManagerService>::GetInstance();
ins.OnRemoveSystemAbility(systemAbilityId, deviceId);
EXPECT_TRUE(ins.IsServiceReady());
GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_002 end";
}
/**

19
services/test/moduletest/aamstest/aams_accessibility_keyevent_filter_test/aams_accessibility_keyevent_filter_test.cpp
View File

@ -98,7 +98,8 @@ void AamsKeyEventFilterTest::SetUp()
AppExecFwk::ElementName elementName("deviceId", "bundleName", "name");
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
accountData->AddInstalledAbility(*abilityInfo);
sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(accountData, 0, *abilityInfo);
sptr<AccessibleAbilityConnection> connection =
new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
aastub_ = new AccessibleAbilityChannel(accountData->GetAccountId(), abilityInfo->GetId());
connection->OnAbilityConnectDoneSync(elementName, aastub_);
interceptorId_ = std::make_shared<AccessibilityInputEventConsumer>();
@ -147,9 +148,8 @@ HWTEST_F(AamsKeyEventFilterTest, AamsKeyEventFilterTest_Moduletest_OnKeyEvent001
std::shared_ptr<MMI::KeyEvent> keyEvent = CreateOnKeyEvent(MMI::KeyEvent::KEYCODE_VOLUME_UP);
sleep(TEST_NUM_3);
std::map<std::string, sptr<AccessibleAbilityConnection>> connectionMaps =
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData()
->GetConnectedA11yAbilities();
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
std::map<std::string, sptr<AccessibleAbilityConnection>> connectionMaps = accountData->GetConnectedA11yAbilities();
EXPECT_EQ(connectionMaps.size(), 1);
auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
@ -163,8 +163,7 @@ HWTEST_F(AamsKeyEventFilterTest, AamsKeyEventFilterTest_Moduletest_OnKeyEvent001
auto iter = connectionMaps.begin();
sptr<AccessibleAbilityConnection> ptr_connect = iter->second;
ASSERT_TRUE(ptr_connect);
ASSERT_TRUE(ptr_connect->GetAccountData());
aacs_ = new AccessibleAbilityChannel(ptr_connect->GetAccountData()->GetAccountId(),
aacs_ = new AccessibleAbilityChannel(accountData->GetAccountId(),
ptr_connect->GetAbilityInfo().GetId());
aacs_->SetOnKeyPressEventResult(handled, sequence);
@ -186,9 +185,8 @@ HWTEST_F(AamsKeyEventFilterTest, AamsKeyEventFilterTest_Moduletest_OnKeyEvent002
std::shared_ptr<MMI::KeyEvent> keyEvent = CreateOnKeyEvent(MMI::KeyEvent::KEYCODE_VOLUME_UP);
sleep(TEST_NUM_3);
std::map<std::string, sptr<AccessibleAbilityConnection>> connectionMaps =
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData()
->GetConnectedA11yAbilities();
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
std::map<std::string, sptr<AccessibleAbilityConnection>> connectionMaps = accountData->GetConnectedA11yAbilities();
EXPECT_EQ(connectionMaps.size(), 1);
auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
@ -202,8 +200,7 @@ HWTEST_F(AamsKeyEventFilterTest, AamsKeyEventFilterTest_Moduletest_OnKeyEvent002
auto iter = connectionMaps.begin();
sptr<AccessibleAbilityConnection> ptr_connect = iter->second;
ASSERT_TRUE(ptr_connect);
ASSERT_TRUE(ptr_connect->GetAccountData());
aacs_ = new AccessibleAbilityChannel(ptr_connect->GetAccountData()->GetAccountId(),
aacs_ = new AccessibleAbilityChannel(accountData->GetAccountId(),
ptr_connect->GetAbilityInfo().GetId());
aacs_->SetOnKeyPressEventResult(handled, sequence);

7
services/test/moduletest/aamstest/aams_accessibility_touchEvent_injector_test/aams_accessibility_touchEvent_injector_test.cpp
View File

@ -87,7 +87,8 @@ void AamsInjectorTest::SetUp()
AppExecFwk::ElementName elementName("deviceId", "bundleName", "name");
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
accountData->AddInstalledAbility(*abilityInfo);
sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(accountData, 0, *abilityInfo);
sptr<AccessibleAbilityConnection> connection =
new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
aastub_ = new AccessibleAbilityChannel(accountData->GetAccountId(), abilityInfo->GetId());
connection->OnAbilityConnectDoneSync(elementName, aastub_);
@ -97,8 +98,8 @@ void AamsInjectorTest::SetUp()
Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData()->GetConnectedA11yAbilities();
auto iter = connectionMaps.begin();
sptr<AccessibleAbilityConnection> ptr_connect = iter->second;
if (ptr_connect && ptr_connect->GetAccountData()) {
aacs_ = new AccessibleAbilityChannel(ptr_connect->GetAccountData()->GetAccountId(),
if (ptr_connect) {
aacs_ = new AccessibleAbilityChannel(accountData->GetAccountId(),
ptr_connect->GetAbilityInfo().GetId());
}
GTEST_LOG_(INFO) << "AamsInjectorTest SetUp end";

3
services/test/moduletest/aamstest/aams_accessibility_touch_guider_test/aams_accessibility_touch_guider_test.cpp
View File

@ -106,7 +106,8 @@ void AamsTouchGuideTest::SetUp()
AppExecFwk::ElementName elementName("deviceId", "bundleName", "name");
auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
accountData->AddInstalledAbility(*abilityInfo);
sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(accountData, 0, *abilityInfo);
sptr<AccessibleAbilityConnection> connection =
new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
aastub_ = new AccessibleAbilityChannel(accountData->GetAccountId(), abilityInfo->GetId());
connection->OnAbilityConnectDoneSync(elementName, aastub_);

2
services/test/moduletest/aamstest/aams_accessible_ability_channel_test/aams_accessible_ability_channel_test.cpp
View File

@ -120,7 +120,7 @@ void AamsAccessibleAbilityChannelTest::AddAccessibleAbilityConnection(bool isNoC
}
accountData_ = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
accountData_->Init();
AAConnection_ = new AccessibleAbilityConnection(accountData_, 0, *abilityInfo);
AAConnection_ = new AccessibleAbilityConnection(accountData_->GetAccountId(), 0, *abilityInfo);
elementName_ = new AppExecFwk::ElementName(deviceId, initParams.bundleName, initParams.name);
aastub_ = new AccessibleAbilityChannel(accountData_->GetAccountId(), abilityInfo->GetId());
AAConnection_->OnAbilityConnectDoneSync(*elementName_, aastub_);

2
services/test/moduletest/aamstest/aams_common_event_registry_test/aams_common_event_registry_test.cpp
View File

@ -90,7 +90,7 @@ void AccessibilityCommonEventRegistryTest::AddAccessibleAbilityConnection()
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
accountData_ = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
AAConnection_ = new AccessibleAbilityConnection(accountData_, 0, *abilityInfo);
AAConnection_ = new AccessibleAbilityConnection(accountData_->GetAccountId(), 0, *abilityInfo);
elementName_ = new AppExecFwk::ElementName("name", "bundleName", "id");
aastub_ = new AccessibleAbilityChannel(accountData_->GetAccountId(), abilityInfo->GetId());
AAConnection_->OnAbilityConnectDoneSync(*elementName_, aastub_);

2
services/test/moduletest/aamstest/aams_server_test/aams_server_test.cpp
View File

@ -112,7 +112,7 @@ void AAMSServerTest::AddAccessibleAbilityConnection()
std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
abilityInfo->SetAccessibilityAbilityType(AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_ALL);
accountData_ = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
AAConnection_ = new AccessibleAbilityConnection(accountData_, 0, *abilityInfo);
AAConnection_ = new AccessibleAbilityConnection(accountData_->GetAccountId(), 0, *abilityInfo);
elementName_ = new AppExecFwk::ElementName(deviceId, initParams.bundleName, initParams.name);
aastub_ = new AccessibleAbilityChannel(accountData_->GetAccountId(), abilityInfo->GetId());
AAConnection_->OnAbilityConnectDoneSync(*elementName_, aastub_);