1 /*
2 * Copyright (C) 2023 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 #include "if_system_ability_manager.h"
16 #include "iservice_registry.h"
17 #include "system_ability_definition.h"
18 #include "app_domain_verify_agent_client.h"
19
20 namespace OHOS {
21 namespace AppDomainVerify {
22 constexpr int32_t LOADSA_TIMEOUT_MS = 10000;
23 sptr<IAppDomainVerifyAgentService> AppDomainVerifyAgentClient::agentServiceProxy_;
24 AppDomainVerifyAgentClient::StaticDestoryMonitor AppDomainVerifyAgentClient::staticDestoryMonitor_;
25 std::mutex AppDomainVerifyAgentClient::proxyLock_;
26
AppDomainVerifyAgentClient()27 AppDomainVerifyAgentClient::AppDomainVerifyAgentClient()
28 {
29 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_CLIENT, "new instance created.");
30 }
31
~AppDomainVerifyAgentClient()32 AppDomainVerifyAgentClient::~AppDomainVerifyAgentClient()
33 {
34 std::lock_guard<std::mutex> autoLock(proxyLock_);
35 if (agentServiceProxy_ != nullptr && !staticDestoryMonitor_.IsDestoryed()) {
36 auto remoteObject = agentServiceProxy_->AsObject();
37 if (remoteObject != nullptr) {
38 remoteObject->RemoveDeathRecipient(deathRecipient_);
39 }
40 }
41 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_CLIENT, "instance dead.");
42 }
43
SingleVerify(const AppVerifyBaseInfo & appVerifyBaseInfo,const VerifyResultInfo & verifyResultInfo)44 void AppDomainVerifyAgentClient::SingleVerify(const AppVerifyBaseInfo &appVerifyBaseInfo,
45 const VerifyResultInfo &verifyResultInfo)
46 {
47 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_CLIENT, "called");
48 std::lock_guard<std::mutex> autoLock(proxyLock_);
49 if (IsServiceAvailable()) {
50 agentServiceProxy_->SingleVerify(appVerifyBaseInfo, verifyResultInfo);
51 }
52 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_CLIENT, "call end");
53 }
54
IsServiceAvailable()55 bool AppDomainVerifyAgentClient::IsServiceAvailable()
56 {
57 if (agentServiceProxy_ == nullptr) {
58 APP_DOMAIN_VERIFY_HILOGW(APP_DOMAIN_VERIFY_AGENT_MODULE_CLIENT, "Redo ConnectService");
59 ConnectService();
60 }
61 if (agentServiceProxy_ == nullptr) {
62 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_CLIENT, "Service proxy null.");
63 return false;
64 }
65 return true;
66 }
67
ConnectService()68 void AppDomainVerifyAgentClient::ConnectService()
69 {
70 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_CLIENT, "ConnectService start.");
71 sptr<ISystemAbilityManager> samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
72 if (samgrProxy == nullptr) {
73 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_AGENT_MODULE_CLIENT, "Get SystemAbilityManager failed.");
74 agentServiceProxy_ = nullptr;
75 return;
76 }
77 sptr<IRemoteObject> remoteObject = samgrProxy->CheckSystemAbility(APP_DOMAIN_VERIFY_AGENT_SA_ID);
78 if (remoteObject == nullptr) {
79 remoteObject = samgrProxy->LoadSystemAbility(APP_DOMAIN_VERIFY_AGENT_SA_ID, LOADSA_TIMEOUT_MS);
80 }
81 if (remoteObject != nullptr) {
82 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_CLIENT, "Get AgentServiceProxy succeed.");
83 if (deathRecipient_ == nullptr) {
84 deathRecipient_ = sptr<IRemoteObject::DeathRecipient>(new AgentSaDeathRecipient());
85 }
86 remoteObject->AddDeathRecipient(deathRecipient_);
87 agentServiceProxy_ = iface_cast<IAppDomainVerifyAgentService>(remoteObject);
88 return;
89 }
90 APP_DOMAIN_VERIFY_HILOGW(APP_DOMAIN_VERIFY_AGENT_MODULE_CLIENT, "Getting AgentServiceProxy failed.");
91 }
92
OnRemoteSaDied(const wptr<IRemoteObject> & object)93 void AppDomainVerifyAgentClient::OnRemoteSaDied(const wptr<IRemoteObject> &object)
94 {
95 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_AGENT_MODULE_CLIENT, "OnRemoteSaDied.");
96 std::lock_guard<std::mutex> autoLock(proxyLock_);
97 if (agentServiceProxy_ != nullptr) {
98 auto remoteObj = agentServiceProxy_->AsObject();
99 if (remoteObj != nullptr) {
100 remoteObj->RemoveDeathRecipient(deathRecipient_);
101 }
102 }
103 agentServiceProxy_ = nullptr;
104 }
105
ConvertToExplicitWant(AAFwk::Want & implicitWant,sptr<IConvertCallback> & callback)106 void AppDomainVerifyAgentClient::ConvertToExplicitWant(AAFwk::Want& implicitWant, sptr<IConvertCallback>& callback)
107 {
108 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
109 std::lock_guard<std::mutex> autoLock(proxyLock_);
110 if (IsServiceAvailable()) {
111 agentServiceProxy_->ConvertToExplicitWant(implicitWant, callback);
112 }
113 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
114 }
115
AgentSaDeathRecipient()116 AgentSaDeathRecipient::AgentSaDeathRecipient()
117 {
118 }
119
~AgentSaDeathRecipient()120 AgentSaDeathRecipient::~AgentSaDeathRecipient()
121 {
122 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_CLIENT, "deathRecipient dead.");
123 }
124
OnRemoteDied(const wptr<IRemoteObject> & object)125 void AgentSaDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &object)
126 {
127 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_AGENT_MODULE_CLIENT,
128 "AppDomainVerifyMgrSaDeathRecipient on remote systemAbility died.");
129 AppDomainVerifyAgentClient::GetInstance()->OnRemoteSaDied(object);
130 }
131 }
132 }