1 /*
2  * Copyright (c) 2022-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 
16 #include "dscreen_source_service.h"
17 
18 #include "if_system_ability_manager.h"
19 #include "ipc_skeleton.h"
20 #include "ipc_types.h"
21 #include "iservice_registry.h"
22 #include "string_ex.h"
23 #include "system_ability_definition.h"
24 
25 #include "dscreen_hidumper.h"
26 #include "dscreen_constants.h"
27 #include "dscreen_errcode.h"
28 #include "dscreen_hisysevent.h"
29 #include "dscreen_log.h"
30 #include "dscreen_util.h"
31 
32 namespace OHOS {
33 namespace DistributedHardware {
34 REGISTER_SYSTEM_ABILITY_BY_ID(DScreenSourceService, DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID, true);
35 
DScreenSourceService(int32_t saId,bool runOnCreate)36 DScreenSourceService::DScreenSourceService(int32_t saId, bool runOnCreate) : SystemAbility(saId, runOnCreate)
37 {
38     DHLOGI("dscreen source service create.");
39 }
40 
OnStart()41 void DScreenSourceService::OnStart()
42 {
43     DHLOGI("dscreen source service start.");
44     Init();
45     DeleteExistDScreens();
46 }
47 
DeleteExistDScreens()48 void DScreenSourceService::DeleteExistDScreens()
49 {
50     std::vector<sptr<Rosen::Screen>> screens;
51     Rosen::ScreenManager::GetInstance().GetAllScreens(screens);
52     DHLOGI("screens size is: %{public}zu", screens.size());
53     for (const auto &screen : screens) {
54         if (screen == nullptr) {
55             DHLOGE("screen is nullptr.");
56             continue;
57         }
58         std::string screenName = screen->GetName();
59         DHLOGI("DeleteExistDScreens, screenName:%{public}s", screenName.c_str());
60         if (screenName.find(DSCREEN_PREFIX) != std::string::npos) {
61             DHLOGI("DestroyVirtualScreen");
62             Rosen::DMError err = Rosen::ScreenManager::GetInstance().DestroyVirtualScreen(screen->GetId());
63             if (err != Rosen::DMError::DM_OK) {
64                 DHLOGE("remove virtual screen failed, screenId:%{public}" PRIu64, screen->GetId());
65             }
66         }
67     }
68 }
69 
OnStop()70 void DScreenSourceService::OnStop()
71 {
72     DHLOGI("dscreen source service stop.");
73     int32_t ret = V2_0::DScreenManager::GetInstance().Release();
74     if (ret != DH_SUCCESS) {
75         DHLOGE("Release V2_0::DScreenManager failed. err: %{public}" PRId32, ret);
76     }
77     ret = V1_0::DScreenManager::GetInstance().UnInit();
78     if (ret != DH_SUCCESS) {
79         DHLOGE("UnInit V1_0::DScreenManager failed. err: %{public}" PRId32, ret);
80     }
81     registerToService_ = false;
82 }
83 
Init()84 bool DScreenSourceService::Init()
85 {
86     DHLOGI("Init dscreen source service.");
87     if (!registerToService_) {
88         bool ret = Publish(this);
89         if (!ret) {
90             DHLOGE("dscreen source publish service failed.");
91             return false;
92         }
93         registerToService_ = true;
94     }
95     DHLOGI("dscreen source service init success.");
96     return true;
97 }
98 
InitSource(const std::string & params,const sptr<IDScreenSourceCallback> & callback)99 int32_t DScreenSourceService::InitSource(const std::string &params, const sptr<IDScreenSourceCallback> &callback)
100 {
101     DHLOGI("Init source dscreen manager, params: %{public}s", params.c_str());
102     if (callback == nullptr) {
103         DHLOGE("DScreenSourceService::InitSource, callback is nullptr.");
104         return ERR_DH_SCREEN_SA_INIT_SOURCE_FAIL;
105     }
106 
107     int32_t ret = V2_0::DScreenManager::GetInstance().Initialize();
108     if (ret != DH_SUCCESS) {
109         DHLOGE("Initialize V2_0::DScreenManager failed. err: %{public}" PRId32, ret);
110         return ERR_DH_SCREEN_SA_INIT_SOURCE_FAIL;
111     }
112     V2_0::DScreenManager::GetInstance().RegisterDScreenCallback(callback);
113     ret = V1_0::DScreenManager::GetInstance().Init();
114     if (ret != DH_SUCCESS) {
115         DHLOGE("Init V1_0::DScreenManager failed. err: %{public}" PRId32, ret);
116         return ERR_DH_SCREEN_SA_INIT_SOURCE_FAIL;
117     }
118     V1_0::DScreenManager::GetInstance().RegisterDScreenCallback(callback);
119     return DH_SUCCESS;
120 }
121 
ReleaseSource()122 int32_t DScreenSourceService::ReleaseSource()
123 {
124     DHLOGI("Release source dscreen manager.");
125     int32_t ret = V1_0::DScreenManager::GetInstance().UnInit();
126     if (ret != DH_SUCCESS) {
127         DHLOGE("UnInit V1_0::DScreenManager failed. err: %{public}" PRId32, ret);
128     }
129     ret = V2_0::DScreenManager::GetInstance().Release();
130     if (ret != DH_SUCCESS) {
131         DHLOGE("Release V2_0::DScreenManager failed. err: %{public}" PRId32, ret);
132     }
133     DHLOGI("exit source sa process");
134     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
135     if (systemAbilityMgr == nullptr) {
136         DHLOGE("systemAbilityMgr is null");
137         return DSCREEN_INIT_ERR;
138     }
139     ret = systemAbilityMgr->UnloadSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
140     if (ret != DH_SUCCESS) {
141         DHLOGE("source systemAbilityMgr UnLoadSystemAbility failed, ret: %{public}" PRId32, ret);
142         return DSCREEN_BAD_VALUE;
143     }
144     DHLOGI("source systemAbilityMgr UnLoadSystemAbility success");
145     return DH_SUCCESS;
146 }
147 
RegisterDistributedHardware(const std::string & devId,const std::string & dhId,const EnableParam & param,const std::string & reqId)148 int32_t DScreenSourceService::RegisterDistributedHardware(const std::string &devId, const std::string &dhId,
149     const EnableParam &param, const std::string &reqId)
150 {
151     DHLOGI("Register source distributed screen, peer dscreen version: %{public}s", param.sinkVersion.c_str());
152     int32_t ret = DH_SUCCESS;
153     if (IsSupportAVTransEngine(param.sinkVersion)) {
154         ret = V2_0::DScreenManager::GetInstance().EnableDistributedScreen(devId, dhId, param, reqId);
155     } else {
156         ret = V1_0::DScreenManager::GetInstance().EnableDistributedScreen(devId, dhId, param, reqId);
157     }
158     if (ret != DH_SUCCESS) {
159         DHLOGE("enable distributedScreen failed. devId: %{public}s, dhId: %{public}s, reqId: %{public}s, "
160             "param attrs: %{public}s", GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(),
161             GetAnonyString(reqId).c_str(), param.sinkAttrs.c_str());
162         ReportRegisterFail(DSCREEN_REGISTER_FAIL, ret, GetAnonyString(devId).c_str(),
163             GetAnonyString(dhId).c_str(), "enable distributedScreen failed.");
164         return ERR_DH_SCREEN_SA_ENABLE_FAILED;
165     }
166     return DH_SUCCESS;
167 }
168 
UnregisterDistributedHardware(const std::string & devId,const std::string & dhId,const std::string & reqId)169 int32_t DScreenSourceService::UnregisterDistributedHardware(const std::string &devId, const std::string &dhId,
170     const std::string &reqId)
171 {
172     int ret = V1_0::DScreenManager::GetInstance().DisableDistributedScreen(devId, dhId, reqId);
173     if (ret != DH_SUCCESS) {
174         DHLOGE("V1_0::DScreenManager disable distributedScreen failed. devId: %{public}s, dhId: %{public}s, "
175             "reqId: %{public}s", GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(),
176             GetAnonyString(reqId).c_str());
177         ReportUnRegisterFail(DSCREEN_REGISTER_FAIL, ret, GetAnonyString(devId).c_str(),
178             GetAnonyString(dhId).c_str(), "disable distributedScreen failed.");
179         return ERR_DH_SCREEN_SA_DISABLE_FAILED;
180     }
181 
182     ret = V2_0::DScreenManager::GetInstance().DisableDistributedScreen(devId, dhId, reqId);
183     if (ret != DH_SUCCESS) {
184         DHLOGE("V2_0::DScreenManager disable distributedScreen failed. devId: %{public}s, dhId: %{public}s, "
185             "reqId: %{public}s", GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(),
186             GetAnonyString(reqId).c_str());
187         ReportUnRegisterFail(DSCREEN_REGISTER_FAIL, ret, GetAnonyString(devId).c_str(),
188             GetAnonyString(dhId).c_str(), "disable distributedScreen failed.");
189         return ERR_DH_SCREEN_SA_DISABLE_FAILED;
190     }
191     return DH_SUCCESS;
192 }
193 
ConfigDistributedHardware(const std::string & devId,const std::string & dhId,const std::string & key,const std::string & value)194 int32_t DScreenSourceService::ConfigDistributedHardware(const std::string &devId, const std::string &dhId,
195     const std::string &key, const std::string &value)
196 {
197     (void)devId;
198     (void)dhId;
199     (void)key;
200     (void)value;
201     return DH_SUCCESS;
202 }
203 
DScreenNotify(const std::string & devId,const int32_t eventCode,const std::string & eventContent)204 void DScreenSourceService::DScreenNotify(const std::string &devId, const int32_t eventCode,
205     const std::string &eventContent)
206 {
207     DHLOGI("DScreenNotify, devId: %{public}s, eventCode: %{public}" PRId32, GetAnonyString(devId).c_str(), eventCode);
208     V1_0::DScreenManager::GetInstance().HandleDScreenNotify(devId, eventCode, eventContent);
209 }
210 
Dump(int32_t fd,const std::vector<std::u16string> & args)211 int32_t DScreenSourceService::Dump(int32_t fd, const std::vector<std::u16string>& args)
212 {
213     DHLOGI("DScreenSourceService Dump.");
214     (void)args;
215     std::string result_v1;
216     V1_0::DScreenManager::GetInstance().GetScreenDumpInfo(result_v1);
217     std::string result_v2;
218     V2_0::DScreenManager::GetInstance().GetScreenDumpInfo(result_v2);
219     int ret = dprintf(fd, "%s\n", (result_v1 + result_v2).c_str());
220     if (ret < 0) {
221         DHLOGE("Dprintf error.");
222         return ERR_DH_SCREEN_SA_HIDUMPER_ERROR;
223     }
224     std::string result;
225     std::vector<std::string> argsStr;
226 
227     std::transform(args.cbegin(), args.cend(), std::back_inserter(argsStr),
228         [](const std::u16string &item) { return Str16ToStr8(item); });
229 
230     if (!DscreenHidumper::GetInstance().Dump(argsStr, result)) {
231         DHLOGE("Hidump error.");
232         return ERR_DH_SCREEN_SA_HIDUMPER_ERROR;
233     }
234 
235     ret = dprintf(fd, "%s\n", result.c_str());
236     if (ret < 0) {
237         DHLOGE("Dprintf error.");
238         return DSCREEN_BAD_VALUE;
239     }
240     return ERR_OK;
241 }
242 } // namespace DistributedHardware
243 } // namespace OHOS