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
16 #include "zidl/screen_session_manager_client_stub.h"
17
18 #include "window_manager_hilog.h"
19
20 namespace OHOS::Rosen {
21 namespace {
22 constexpr HiviewDFX::HiLogLabel LABEL = { LOG_CORE, HILOG_DOMAIN_DISPLAY, "ScreenSessionManagerClientStub" };
23 } // namespace
24
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)25 int ScreenSessionManagerClientStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply,
26 MessageOption& option)
27 {
28 if (data.ReadInterfaceToken() != GetDescriptor()) {
29 WLOGFE("Failed to check interface token!");
30 return ERR_INVALID_STATE;
31 }
32 ScreenSessionManagerClientMessage msgId = static_cast<ScreenSessionManagerClientMessage>(code);
33 switch (msgId) {
34 case ScreenSessionManagerClientMessage::TRANS_ID_ON_SCREEN_CONNECTION_CHANGED: {
35 return HandleOnScreenConnectionChanged(data, reply);
36 }
37 case ScreenSessionManagerClientMessage::TRANS_ID_ON_PROPERTY_CHANGED: {
38 return HandleOnPropertyChanged(data, reply);
39 }
40 case ScreenSessionManagerClientMessage::TRANS_ID_ON_POWER_STATUS_CHANGED: {
41 return HandleOnPowerStatusChanged(data, reply);
42 }
43 case ScreenSessionManagerClientMessage::TRANS_ID_ON_SENSOR_ROTATION_CHANGED: {
44 return HandleOnSensorRotationChanged(data, reply);
45 }
46 case ScreenSessionManagerClientMessage::TRANS_ID_ON_SCREEN_ORIENTATION_CHANGED: {
47 return HandleOnScreenOrientationChanged(data, reply);
48 }
49 case ScreenSessionManagerClientMessage::TRANS_ID_ON_SCREEN_ROTATION_LOCKED_CHANGED: {
50 return HandleOnScreenRotationLockedChanged(data, reply);
51 }
52 case ScreenSessionManagerClientMessage::TRANS_ID_ON_DISPLAY_STATE_CHANGED: {
53 return HandleOnDisplayStateChanged(data, reply);
54 }
55 case ScreenSessionManagerClientMessage::TRANS_ID_ON_SCREEN_SHOT: {
56 return HandleOnScreenshot(data, reply);
57 }
58 case ScreenSessionManagerClientMessage::TRANS_ID_ON_IMMERSIVE_STATE_CHANGED: {
59 return HandleOnImmersiveStateChanged(data, reply);
60 }
61 case ScreenSessionManagerClientMessage::TRANS_ID_SET_DISPLAY_NODE_SCREEN_ID: {
62 return HandleOnSetDisplayNodeScreenId(data, reply);
63 }
64 case ScreenSessionManagerClientMessage::TRANS_ID_GET_SURFACENODEID_FROM_MISSIONID: {
65 return HandleOnGetSurfaceNodeIdsFromMissionIdsChanged(data, reply);
66 }
67 case ScreenSessionManagerClientMessage::TRANS_ID_SET_FOLD_DISPLAY_MODE: {
68 return HandleOnUpdateFoldDisplayMode(data, reply);
69 }
70 case ScreenSessionManagerClientMessage::TRANS_ID_ON_SWITCH_USER_CMD: {
71 return HandleSwitchUserCallback(data, reply);
72 }
73 case ScreenSessionManagerClientMessage::TRANS_ID_SET_VIRTUAL_PIXEL_RATIO_SYSTEM: {
74 return HandleSetVirtualPixelRatioSystem(data, reply);
75 }
76 case ScreenSessionManagerClientMessage::TRANS_ID_ON_FOLDSTATUS_CHANGED_REPORT_UE: {
77 return HandleOnFoldStatusChangedReportUE(data, reply);
78 }
79 default: {
80 WLOGFE("Failed to find function handler!");
81 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
82 }
83 }
84
85 return 0;
86 }
87
HandleSwitchUserCallback(MessageParcel & data,MessageParcel & reply)88 int ScreenSessionManagerClientStub::HandleSwitchUserCallback(MessageParcel& data, MessageParcel& reply)
89 {
90 WLOGD("HandleSwitchUserCallback");
91 std::vector<int32_t> oldScbPids;
92 data.ReadInt32Vector(&oldScbPids);
93 int32_t currentScbPid = data.ReadInt32();
94 SwitchUserCallback(oldScbPids, currentScbPid);
95 return ERR_NONE;
96 }
97
HandleOnScreenConnectionChanged(MessageParcel & data,MessageParcel & reply)98 int ScreenSessionManagerClientStub::HandleOnScreenConnectionChanged(MessageParcel& data, MessageParcel& reply)
99 {
100 WLOGD("HandleOnScreenConnectionChanged");
101 auto screenId = static_cast<ScreenId>(data.ReadUint64());
102 auto screenEvent = static_cast<ScreenEvent>(data.ReadUint8());
103 auto rsId = static_cast<ScreenId>(data.ReadUint64());
104 auto name = data.ReadString();
105 OnScreenConnectionChanged(screenId, screenEvent, rsId, name);
106 return ERR_NONE;
107 }
108
HandleOnPropertyChanged(MessageParcel & data,MessageParcel & reply)109 int ScreenSessionManagerClientStub::HandleOnPropertyChanged(MessageParcel& data, MessageParcel& reply)
110 {
111 WLOGD("HandleOnPropertyChanged");
112 auto screenId = static_cast<ScreenId>(data.ReadUint64());
113 ScreenProperty property;
114 if (!RSMarshallingHelper::Unmarshalling(data, property)) {
115 WLOGFE("Read property failed");
116 return ERR_INVALID_DATA;
117 }
118 auto reason = static_cast<ScreenPropertyChangeReason>(data.ReadUint32());
119 OnPropertyChanged(screenId, property, reason);
120 return ERR_NONE;
121 }
122
HandleOnPowerStatusChanged(MessageParcel & data,MessageParcel & reply)123 int ScreenSessionManagerClientStub::HandleOnPowerStatusChanged(MessageParcel& data, MessageParcel& reply)
124 {
125 WLOGD("HandleOnPowerStatusChanged");
126 auto event = static_cast<DisplayPowerEvent>(data.ReadUint32());
127 auto status = static_cast<EventStatus>(data.ReadUint32());
128 auto reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
129 OnPowerStatusChanged(event, status, reason);
130 return ERR_NONE;
131 }
132
HandleOnSensorRotationChanged(MessageParcel & data,MessageParcel & reply)133 int ScreenSessionManagerClientStub::HandleOnSensorRotationChanged(MessageParcel& data, MessageParcel& reply)
134 {
135 WLOGD("HandleOnSensorRotationChanged");
136 auto screenId = static_cast<ScreenId>(data.ReadUint64());
137 auto sensorRotation = data.ReadFloat();
138 OnSensorRotationChanged(screenId, sensorRotation);
139 return ERR_NONE;
140 }
141
HandleOnScreenOrientationChanged(MessageParcel & data,MessageParcel & reply)142 int ScreenSessionManagerClientStub::HandleOnScreenOrientationChanged(MessageParcel& data, MessageParcel& reply)
143 {
144 WLOGD("HandleOnScreenOrientationChanged");
145 auto screenId = static_cast<ScreenId>(data.ReadUint64());
146 auto screenOrientation = data.ReadFloat();
147 OnScreenOrientationChanged(screenId, screenOrientation);
148 return ERR_NONE;
149 }
150
HandleOnScreenRotationLockedChanged(MessageParcel & data,MessageParcel & reply)151 int ScreenSessionManagerClientStub::HandleOnScreenRotationLockedChanged(MessageParcel& data, MessageParcel& reply)
152 {
153 WLOGD("HandleOnScreenRotationLockedChanged");
154 auto screenId = static_cast<ScreenId>(data.ReadUint64());
155 auto isLocked = data.ReadBool();
156 OnScreenRotationLockedChanged(screenId, isLocked);
157 return ERR_NONE;
158 }
159
HandleOnDisplayStateChanged(MessageParcel & data,MessageParcel & reply)160 int ScreenSessionManagerClientStub::HandleOnDisplayStateChanged(MessageParcel& data, MessageParcel& reply)
161 {
162 WLOGD("HandleOnDisplayStateChanged");
163 auto defaultDisplayId = static_cast<DisplayId>(data.ReadUint64());
164 auto displayInfo = data.ReadStrongParcelable<DisplayInfo>();
165 auto mapSize = data.ReadUint32();
166 std::map<DisplayId, sptr<DisplayInfo>> displayInfoMap;
167 while (mapSize--) {
168 auto displayId = data.ReadUint64();
169 auto displayInfoValue = data.ReadStrongParcelable<DisplayInfo>();
170 displayInfoMap.emplace(displayId, displayInfoValue);
171 }
172 auto type = static_cast<DisplayStateChangeType>(data.ReadUint32());
173 OnDisplayStateChanged(defaultDisplayId, displayInfo, displayInfoMap, type);
174 return ERR_NONE;
175 }
176
HandleOnUpdateFoldDisplayMode(MessageParcel & data,MessageParcel & reply)177 int ScreenSessionManagerClientStub::HandleOnUpdateFoldDisplayMode(MessageParcel& data, MessageParcel& reply)
178 {
179 WLOGD("HandleOnUpdateFoldDisplayMode");
180 auto foldDisplayMode = static_cast<FoldDisplayMode>(data.ReadUint32());
181 OnUpdateFoldDisplayMode(foldDisplayMode);
182 return ERR_NONE;
183 }
184
HandleOnGetSurfaceNodeIdsFromMissionIdsChanged(MessageParcel & data,MessageParcel & reply)185 int ScreenSessionManagerClientStub::HandleOnGetSurfaceNodeIdsFromMissionIdsChanged(MessageParcel& data,
186 MessageParcel& reply)
187 {
188 std::vector<uint64_t> missionIds;
189 data.ReadUInt64Vector(&missionIds);
190 std::vector<uint64_t> surfaceNodeIds;
191 data.ReadUInt64Vector(&surfaceNodeIds);
192 bool isBlackList = data.ReadBool();
193 OnGetSurfaceNodeIdsFromMissionIdsChanged(missionIds, surfaceNodeIds, isBlackList);
194 if (!reply.WriteUInt64Vector(surfaceNodeIds)) {
195 WLOGFE("Write surfaceNodeIds failed");
196 return ERR_TRANSACTION_FAILED;
197 }
198 return ERR_NONE;
199 }
200
HandleOnScreenshot(MessageParcel & data,MessageParcel & reply)201 int ScreenSessionManagerClientStub::HandleOnScreenshot(MessageParcel& data, MessageParcel& reply)
202 {
203 WLOGD("HandleOnScreenshot");
204 auto displayId = static_cast<DisplayId>(data.ReadUint64());
205 OnScreenshot(displayId);
206 return ERR_NONE;
207 }
208
HandleOnImmersiveStateChanged(MessageParcel & data,MessageParcel & reply)209 int ScreenSessionManagerClientStub::HandleOnImmersiveStateChanged(MessageParcel& data, MessageParcel& reply)
210 {
211 WLOGD("HandleOnImmersiveStateChanged");
212 bool immersive = false;
213 OnImmersiveStateChanged(immersive);
214 if (!reply.WriteBool(immersive)) {
215 WLOGFE("Write immersive failed");
216 return ERR_TRANSACTION_FAILED;
217 }
218 return ERR_NONE;
219 }
220
HandleOnSetDisplayNodeScreenId(MessageParcel & data,MessageParcel & reply)221 int ScreenSessionManagerClientStub::HandleOnSetDisplayNodeScreenId(MessageParcel& data, MessageParcel& reply)
222 {
223 WLOGD("HandleOnSetDisplayNodeScreenId");
224 auto screenId = static_cast<ScreenId>(data.ReadUint64());
225 auto displayNodeScreenId = static_cast<ScreenId>(data.ReadUint64());
226 SetDisplayNodeScreenId(screenId, displayNodeScreenId);
227 return ERR_NONE;
228 }
229
HandleSetVirtualPixelRatioSystem(MessageParcel & data,MessageParcel & reply)230 int ScreenSessionManagerClientStub::HandleSetVirtualPixelRatioSystem(MessageParcel& data, MessageParcel& reply)
231 {
232 WLOGD("HandleSetVirtualPixelRatioSystem");
233 auto screenId = static_cast<ScreenId>(data.ReadUint64());
234 float virtualPixelRatio = data.ReadFloat();
235 SetVirtualPixelRatioSystem(screenId, virtualPixelRatio);
236 return ERR_NONE;
237 }
238
HandleOnFoldStatusChangedReportUE(MessageParcel & data,MessageParcel & reply)239 int ScreenSessionManagerClientStub::HandleOnFoldStatusChangedReportUE(MessageParcel& data, MessageParcel& reply)
240 {
241 std::vector<std::string> screenFoldInfo;
242 data.ReadStringVector(&screenFoldInfo);
243 OnFoldStatusChangedReportUE(screenFoldInfo);
244 return ERR_NONE;
245 }
246 } // namespace OHOS::Rosen
247