1 /*
2 * Copyright (c) 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 "dscreen_sink_service.h"
17 #include "if_system_ability_manager.h"
18 #include "ipc_skeleton.h"
19 #include "ipc_types.h"
20 #include "iservice_registry.h"
21 #include "string_ex.h"
22 #include "system_ability_definition.h"
23
24 #include "dscreen_hidumper.h"
25 #include "dscreen_constants.h"
26 #include "dscreen_errcode.h"
27 #include "dscreen_log.h"
28 #include "dscreen_util.h"
29
30 namespace OHOS {
31 namespace DistributedHardware {
32 REGISTER_SYSTEM_ABILITY_BY_ID(DScreenSinkService, DISTRIBUTED_HARDWARE_SCREEN_SINK_SA_ID, true);
33
DScreenSinkService(int32_t saId,bool runOnCreate)34 DScreenSinkService::DScreenSinkService(int32_t saId, bool runOnCreate) : SystemAbility(saId, runOnCreate)
35 {
36 DHLOGI("DScreenSinkService construct.");
37 }
38
OnStart()39 void DScreenSinkService::OnStart()
40 {
41 DHLOGI("dscreen sink service start.");
42 if (!Init()) {
43 DHLOGE("DScreenSinkService init failed.");
44 return;
45 }
46 DHLOGI("DScreenSinkService start success.");
47 }
48
OnStop()49 void DScreenSinkService::OnStop()
50 {
51 DHLOGI("dscreen sink service stop.");
52 registerToService_ = false;
53 }
54
Init()55 bool DScreenSinkService::Init()
56 {
57 DHLOGI("Init dscreen sink service.");
58 if (!registerToService_) {
59 bool ret = Publish(this);
60 if (!ret) {
61 DHLOGE("dscreen sink publish service failed.");
62 return false;
63 }
64 registerToService_ = true;
65 }
66 DHLOGI("dscreen sink service init success.");
67 return true;
68 }
69
InitSink(const std::string & params)70 int32_t DScreenSinkService::InitSink(const std::string ¶ms)
71 {
72 DHLOGI("Init sink dscreen region manager, params: %{public}s", params.c_str());
73 int32_t ret = V2_0::ScreenRegionManager::GetInstance().Initialize();
74 if (ret != DH_SUCCESS) {
75 DHLOGE("Initialize V2_0::ScreenRegionManage failed. err: %{public}d", ret);
76 }
77 return DH_SUCCESS;
78 }
79
ReleaseSink()80 int32_t DScreenSinkService::ReleaseSink()
81 {
82 DHLOGI("Release sink dscreen region manager.");
83 V2_0::ScreenRegionManager::GetInstance().Release();
84 V1_0::ScreenRegionManager::GetInstance().ReleaseAllRegions();
85
86 DHLOGI("exit sink sa process");
87 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
88 if (systemAbilityMgr == nullptr) {
89 DHLOGE("systemAbilityMgr is null");
90 return DSCREEN_INIT_ERR;
91 }
92 int32_t ret = systemAbilityMgr->UnloadSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SINK_SA_ID);
93 if (ret != DH_SUCCESS) {
94 DHLOGE("sink systemAbilityMgr UnLoadSystemAbility failed, ret: %{public}" PRId32, ret);
95 return DSCREEN_BAD_VALUE;
96 }
97 DHLOGI("sink systemAbilityMgr UnLoadSystemAbility success");
98 return DH_SUCCESS;
99 }
100
SubscribeLocalHardware(const std::string & dhId,const std::string & param)101 int32_t DScreenSinkService::SubscribeLocalHardware(const std::string &dhId, const std::string ¶m)
102 {
103 DHLOGI("SubscribeLocalHardware");
104 (void)dhId;
105 (void)param;
106 return DH_SUCCESS;
107 }
108
UnsubscribeLocalHardware(const std::string & dhId)109 int32_t DScreenSinkService::UnsubscribeLocalHardware(const std::string &dhId)
110 {
111 DHLOGI("UnsubscribeLocalHardware");
112 (void)dhId;
113 return DH_SUCCESS;
114 }
115
DScreenNotify(const std::string & devId,int32_t eventCode,const std::string & eventContent)116 void DScreenSinkService::DScreenNotify(const std::string &devId, int32_t eventCode, const std::string &eventContent)
117 {
118 DHLOGI("DScreenNotify, devId:%{public}s, eventCode: %{public}" PRId32 ", eventContent:%{public}s",
119 GetAnonyString(devId).c_str(), eventCode, eventContent.c_str());
120 V1_0::ScreenRegionManager::GetInstance().HandleDScreenNotify(devId, eventCode, eventContent);
121 }
122
Dump(int32_t fd,const std::vector<std::u16string> & args)123 int32_t DScreenSinkService::Dump(int32_t fd, const std::vector<std::u16string>& args)
124 {
125 DHLOGI("DScreenSinkService Dump.");
126 (void)args;
127 std::string result_v1;
128 V1_0::ScreenRegionManager::GetInstance().GetScreenDumpInfo(result_v1);
129 std::string result_v2;
130 V2_0::ScreenRegionManager::GetInstance().GetScreenDumpInfo(result_v2);
131 int ret = dprintf(fd, "%s\n", (result_v1 + result_v2).c_str());
132 if (ret < 0) {
133 DHLOGE("dprintf error");
134 return ERR_DH_SCREEN_SA_HIDUMPER_ERROR;
135 }
136
137 std::string result;
138 std::vector<std::string> argsStr;
139
140 std::transform(args.cbegin(), args.cend(), std::back_inserter(argsStr),
141 [](const std::u16string &item) { return Str16ToStr8(item); });
142
143 if (!DscreenHidumper::GetInstance().Dump(argsStr, result)) {
144 DHLOGE("Hidump error");
145 return ERR_DH_SCREEN_SA_HIDUMPER_ERROR;
146 }
147
148 ret = dprintf(fd, "%s\n", result.c_str());
149 if (ret < 0) {
150 DHLOGE("Dprintf error");
151 return DSCREEN_BAD_VALUE;
152 }
153 return ERR_OK;
154 }
155 } // namespace DistributedHardware
156 } // namespace OHOS