1 /*
2  * Copyright (c) 2021-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 #ifndef ROSEN_RENDER_SERVICE_BASE_TRANSACTION_RS_RENDER_SERVICE_CONNECTION_PROXY_H
17 #define ROSEN_RENDER_SERVICE_BASE_TRANSACTION_RS_RENDER_SERVICE_CONNECTION_PROXY_H
18 
19 #include "command/rs_node_showing_command.h"
20 #include <iremote_proxy.h>
21 #include <memory>
22 #include <platform/ohos/rs_irender_service_connection.h>
23 #include <platform/ohos/rs_irender_service_connection_ipc_interface_code.h>
24 #include "sandbox_utils.h"
25 
26 namespace OHOS {
27 namespace Rosen {
28 class RSRenderServiceConnectionProxy : public IRemoteProxy<RSIRenderServiceConnection> {
29 public:
30     explicit RSRenderServiceConnectionProxy(const sptr<IRemoteObject>& impl);
31     virtual ~RSRenderServiceConnectionProxy() noexcept = default;
32 
33     void CommitTransaction(std::unique_ptr<RSTransactionData>& transactionData) override;
34     void ExecuteSynchronousTask(const std::shared_ptr<RSSyncTask>& task) override;
35 
36     MemoryGraphic GetMemoryGraphic(int pid) override;
37     std::vector<MemoryGraphic> GetMemoryGraphics() override;
38     bool GetTotalAppMemSize(float& cpuMemSize, float& gpuMemSize) override;
39 
40     bool GetUniRenderEnabled() override;
41 
42     bool CreateNode(const RSSurfaceRenderNodeConfig& config) override;
43     bool CreateNode(const RSDisplayNodeConfig& displayNodeConfig, NodeId nodeId) override;
44     sptr<Surface> CreateNodeAndSurface(const RSSurfaceRenderNodeConfig& config) override;
45 
46     virtual sptr<IVSyncConnection> CreateVSyncConnection(const std::string& name,
47                                                          const sptr<VSyncIConnectionToken>& token,
48                                                          uint64_t id = 0,
49                                                          NodeId windowNodeId = 0,
50                                                          bool fromXcomponent = false) override;
51 
52     std::shared_ptr<Media::PixelMap> CreatePixelMapFromSurface(sptr<Surface> surface, const Rect &srcRect) override;
53 
54     int32_t SetFocusAppInfo(
55         int32_t pid, int32_t uid, const std::string &bundleName, const std::string &abilityName,
56         uint64_t focusNodeId) override;
57 
58     ScreenId GetDefaultScreenId() override;
59     ScreenId GetActiveScreenId() override;
60 
61     std::vector<ScreenId> GetAllScreenIds() override;
62 
63     // mirrorId: decide which screen id to mirror, INVALID_SCREEN_ID means do not mirror any screen.
64     ScreenId CreateVirtualScreen(
65         const std::string &name,
66         uint32_t width,
67         uint32_t height,
68         sptr<Surface> surface,
69         ScreenId mirrorId = 0,
70         int32_t flags = 0,
71         std::vector<NodeId> whiteList = {}) override;
72 
73     int32_t SetVirtualScreenSurface(ScreenId id, sptr<Surface> surface) override;
74 
75     int32_t SetVirtualScreenBlackList(ScreenId id, std::vector<NodeId>& blackListVector) override;
76 
77     int32_t AddVirtualScreenBlackList(ScreenId id, std::vector<NodeId>& blackListVector) override;
78 
79     int32_t RemoveVirtualScreenBlackList(ScreenId id, std::vector<NodeId>& blackListVector) override;
80 
81     int32_t SetVirtualScreenSecurityExemptionList(
82         ScreenId id, const std::vector<NodeId>& securityExemptionList) override;
83 
84     int32_t SetCastScreenEnableSkipWindow(ScreenId id, bool enable) override;
85 
86     void RemoveVirtualScreen(ScreenId id) override;
87 
88     int32_t SetScreenChangeCallback(sptr<RSIScreenChangeCallback> callback) override;
89 
90     void SetScreenActiveMode(ScreenId id, uint32_t modeId) override;
91 
92     void SetScreenRefreshRate(ScreenId id, int32_t sceneId, int32_t rate) override;
93 
94     void SetRefreshRateMode(int32_t refreshRateMode) override;
95 
96     void SyncFrameRateRange(FrameRateLinkerId id, const FrameRateRange& range,
97         int32_t animatorExpectedFrameRate) override;
98 
99     void UnregisterFrameRateLinker(FrameRateLinkerId id) override;
100 
101     uint32_t GetScreenCurrentRefreshRate(ScreenId id) override;
102 
103     int32_t GetCurrentRefreshRateMode() override;
104 
105     std::vector<int32_t> GetScreenSupportedRefreshRates(ScreenId id) override;
106 
107     bool GetShowRefreshRateEnabled() override;
108 
109     void SetShowRefreshRateEnabled(bool enable) override;
110 
111     std::string GetRefreshInfo(pid_t pid) override;
112 
113     int32_t SetVirtualScreenResolution(ScreenId id, uint32_t width, uint32_t height) override;
114 
115     void MarkPowerOffNeedProcessOneFrame() override;
116 
117     void DisablePowerOffRenderControl(ScreenId id) override;
118 
119     void SetScreenPowerStatus(ScreenId id, ScreenPowerStatus status) override;
120 
121     void RegisterApplicationAgent(uint32_t pid, sptr<IApplicationAgent> app) override;
122 
123     void TakeSurfaceCapture(NodeId id, sptr<RSISurfaceCaptureCallback> callback,
124         const RSSurfaceCaptureConfig& captureConfig,
125         RSSurfaceCapturePermissions permissions = RSSurfaceCapturePermissions()) override;
126 
127     void SetWindowFreezeImmediately(NodeId id, bool isFreeze, sptr<RSISurfaceCaptureCallback> callback,
128         const RSSurfaceCaptureConfig& captureConfig) override;
129 
130     bool WriteSurfaceCaptureConfig(const RSSurfaceCaptureConfig& captureConfig, MessageParcel& data);
131 
132     RSVirtualScreenResolution GetVirtualScreenResolution(ScreenId id) override;
133 
134     RSScreenModeInfo GetScreenActiveMode(ScreenId id) override;
135 
136     std::vector<RSScreenModeInfo> GetScreenSupportedModes(ScreenId id) override;
137 
138     RSScreenCapability GetScreenCapability(ScreenId id) override;
139 
140     ScreenPowerStatus GetScreenPowerStatus(ScreenId id) override;
141 
142     RSScreenData GetScreenData(ScreenId id) override;
143 
144     int32_t GetScreenBacklight(ScreenId id) override;
145 
146     void SetScreenBacklight(ScreenId id, uint32_t level) override;
147 
148     void RegisterBufferAvailableListener(
149         NodeId id, sptr<RSIBufferAvailableCallback> callback, bool isFromRenderThread) override;
150 
151     void RegisterBufferClearListener(
152         NodeId id, sptr<RSIBufferClearCallback> callback) override;
153 
154     int32_t GetScreenSupportedColorGamuts(ScreenId id, std::vector<ScreenColorGamut>& mode) override;
155 
156     int32_t GetScreenSupportedMetaDataKeys(ScreenId id, std::vector<ScreenHDRMetadataKey>& keys) override;
157 
158     int32_t GetScreenColorGamut(ScreenId id, ScreenColorGamut& mode) override;
159 
160     int32_t SetScreenColorGamut(ScreenId id, int32_t modeIdx) override;
161 
162     int32_t SetScreenGamutMap(ScreenId id, ScreenGamutMap mode) override;
163 
164     int32_t SetScreenCorrection(ScreenId id, ScreenRotation screenRotation) override;
165 
166     bool SetVirtualMirrorScreenCanvasRotation(ScreenId id, bool canvasRotation) override;
167 
168     bool SetVirtualMirrorScreenScaleMode(ScreenId id, ScreenScaleMode scaleMode) override;
169 
170     bool SetGlobalDarkColorMode(bool isDark) override;
171 
172     int32_t GetScreenGamutMap(ScreenId id, ScreenGamutMap& mode) override;
173 
174     int32_t GetScreenHDRCapability(ScreenId id, RSScreenHDRCapability& screenHdrCapability) override;
175 
176     int32_t GetPixelFormat(ScreenId id, GraphicPixelFormat& pixelFormat) override;
177 
178     int32_t SetPixelFormat(ScreenId id, GraphicPixelFormat pixelFormat) override;
179 
180     int32_t GetScreenSupportedHDRFormats(ScreenId id, std::vector<ScreenHDRFormat>& hdrFormats) override;
181 
182     int32_t GetScreenHDRFormat(ScreenId id, ScreenHDRFormat& hdrFormat) override;
183 
184     int32_t SetScreenHDRFormat(ScreenId id, int32_t modeIdx) override;
185 
186     int32_t GetScreenSupportedColorSpaces(ScreenId id, std::vector<GraphicCM_ColorSpaceType>& colorSpaces) override;
187 
188     int32_t GetScreenColorSpace(ScreenId id, GraphicCM_ColorSpaceType& colorSpace) override;
189 
190     int32_t SetScreenColorSpace(ScreenId id, GraphicCM_ColorSpaceType colorSpace) override;
191 
192     int32_t GetScreenType(ScreenId id, RSScreenType& screenType) override;
193 
194     bool GetBitmap(NodeId id, Drawing::Bitmap& bitmap) override;
195     bool GetPixelmap(NodeId id, std::shared_ptr<Media::PixelMap> pixelmap,
196         const Drawing::Rect* rect, std::shared_ptr<Drawing::DrawCmdList> drawCmdList) override;
197     bool RegisterTypeface(uint64_t globalUniqueId, std::shared_ptr<Drawing::Typeface>& typeface) override;
198     bool UnRegisterTypeface(uint64_t globalUniqueId) override;
199 
200     int32_t SetScreenSkipFrameInterval(ScreenId id, uint32_t skipFrameInterval) override;
201 
202     int32_t SetVirtualScreenRefreshRate(ScreenId id, uint32_t maxRefreshRate, uint32_t& actualRefreshRate) override;
203 
204     int32_t RegisterOcclusionChangeCallback(sptr<RSIOcclusionChangeCallback> callback) override;
205 
206     int32_t RegisterSurfaceOcclusionChangeCallback(
207         NodeId id, sptr<RSISurfaceOcclusionChangeCallback> callback, std::vector<float>& partitionPoints) override;
208 
209     int32_t UnRegisterSurfaceOcclusionChangeCallback(NodeId id) override;
210 
211     int32_t RegisterHgmConfigChangeCallback(sptr<RSIHgmConfigChangeCallback> callback) override;
212 
213     int32_t RegisterHgmRefreshRateModeChangeCallback(sptr<RSIHgmConfigChangeCallback> callback) override;
214 
215     int32_t RegisterHgmRefreshRateUpdateCallback(sptr<RSIHgmConfigChangeCallback> callback) override;
216 
217     int32_t RegisterFrameRateLinkerExpectedFpsUpdateCallback(int32_t dstPid,
218         sptr<RSIFrameRateLinkerExpectedFpsUpdateCallback> callback) override;
219 
220     void SetAppWindowNum(uint32_t num) override;
221 
222     bool SetSystemAnimatedScenes(SystemAnimatedScenes systemAnimatedScenes) override;
223 
224     void ShowWatermark(const std::shared_ptr<Media::PixelMap> &watermarkImg, bool isShow) override;
225 
226     int32_t ResizeVirtualScreen(ScreenId id, uint32_t width, uint32_t height) override;
227 
228     void ReportJankStats() override;
229 
230     void NotifyLightFactorStatus(bool isSafe) override;
231 
232     void NotifyPackageEvent(uint32_t listSize, const std::vector<std::string>& packageList) override;
233 
234     void NotifyRefreshRateEvent(const EventInfo& eventInfo) override;
235 
236     void NotifyTouchEvent(int32_t touchStatus, int32_t touchCnt) override;
237 
238     void NotifyDynamicModeEvent(bool enableDynamicMode) override;
239 
240     void ReportEventResponse(DataBaseRs info) override;
241 
242     void ReportEventComplete(DataBaseRs info) override;
243 
244     void ReportEventJankFrame(DataBaseRs info) override;
245 
246     void ReportGameStateData(GameStateData info) override;
247 
248     void SetHardwareEnabled(NodeId id, bool isEnabled, SelfDrawingNodeType selfDrawingType,
249         bool dynamicHardwareEnable) override;
250 
251     uint32_t SetHidePrivacyContent(NodeId id, bool needHidePrivacyContent) override;
252 
253     void SetCacheEnabledForRotation(bool isEnabled) override;
254 
255     void SetOnRemoteDiedCallback(const OnRemoteDiedCallback& callback) override;
256 
257     void RunOnRemoteDiedCallback() override;
258 
259     std::vector<ActiveDirtyRegionInfo> GetActiveDirtyRegionInfo() override;
260 
261     GlobalDirtyRegionInfo GetGlobalDirtyRegionInfo() override;
262 
263     LayerComposeInfo GetLayerComposeInfo() override;
264 
265     HwcDisabledReasonInfos GetHwcDisabledReasonInfo() override;
266 
267     void SetVmaCacheStatus(bool flag) override;
268 
269     int32_t RegisterUIExtensionCallback(uint64_t userId, sptr<RSIUIExtensionCallback> callback) override;
270 
271 #ifdef TP_FEATURE_ENABLE
272     void SetTpFeatureConfig(int32_t feature, const char* config,
273         TpFeatureConfigType tpFeatureConfigType = TpFeatureConfigType::DEFAULT_TP_FEATURE) override;
274 #endif
275     void SetVirtualScreenUsingStatus(bool isVirtualScreenUsingStatus) override;
276     void SetCurtainScreenUsingStatus(bool isCurtainScreenOn) override;
277 
278     void DropFrameByPid(const std::vector<int32_t> pidList) override;
279 
280     void RegisterSurfaceBufferCallback(pid_t pid, uint64_t uid,
281         sptr<RSISurfaceBufferCallback> callback) override;
282 
283     void UnregisterSurfaceBufferCallback(pid_t pid, uint64_t uid) override;
284 
285 private:
286     bool FillParcelWithTransactionData(
287         std::unique_ptr<RSTransactionData>& transactionData, std::shared_ptr<MessageParcel>& data);
288 
289     void ReportDataBaseRs(MessageParcel& data, MessageParcel& reply, MessageOption& option, DataBaseRs info);
290 
291     void ReportGameStateDataRs(MessageParcel& data, MessageParcel& reply, MessageOption& option, GameStateData info);
292 
293     bool SetAncoForceDoDirect(bool direct) override;
294 
295     void SetLayerTop(const std::string &nodeIdStr, bool isTop) override;
296 
297     static inline BrokerDelegator<RSRenderServiceConnectionProxy> delegator_;
298 
299     pid_t pid_ = GetRealPid();
300     uint32_t transactionDataIndex_ = 0;
301     OnRemoteDiedCallback OnRemoteDiedCallback_;
302 };
303 } // namespace Rosen
304 } // namespace OHOS
305 
306 #endif // ROSEN_RENDER_SERVICE_BASE_TRANSACTION_RS_RENDER_SERVICE_CONNECTION_PROXY_H
307