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 #include "rs_render_service_connection_stub.h"
17 #include "ivsync_connection.h"
18 #include "securec.h"
19 #include "sys_binder.h"
20
21 #include "command/rs_command_factory.h"
22 #include "pipeline/rs_base_render_util.h"
23 #include "pipeline/rs_main_thread.h"
24 #include "pipeline/rs_uni_render_judgement.h"
25 #include "pipeline/rs_unmarshal_thread.h"
26 #include "platform/common/rs_log.h"
27 #include "transaction/rs_ashmem_helper.h"
28 #include "rs_trace.h"
29
30 #include "accesstoken_kit.h"
31 #include "access_token.h"
32 #include "ipc_skeleton.h"
33 #include "tokenid_kit.h"
34
35 #if defined (ENABLE_DDGR_OPTIMIZE)
36 #include "ddgr_renderer.h"
37 #endif
38
39 namespace OHOS {
40 namespace Rosen {
41 namespace {
42 constexpr size_t MAX_DATA_SIZE_FOR_UNMARSHALLING_IN_PLACE = 1024 * 30; // 30kB
43 constexpr size_t FILE_DESCRIPTOR_LIMIT = 15;
44
CopyFileDescriptor(MessageParcel & old,MessageParcel & copied)45 void CopyFileDescriptor(MessageParcel& old, MessageParcel& copied)
46 {
47 binder_size_t* object = reinterpret_cast<binder_size_t*>(old.GetObjectOffsets());
48 binder_size_t* copiedObject = reinterpret_cast<binder_size_t*>(copied.GetObjectOffsets());
49
50 size_t objectNum = old.GetOffsetsSize();
51
52 uintptr_t data = old.GetData();
53 uintptr_t copiedData = copied.GetData();
54
55 for (size_t i = 0; i < objectNum; i++) {
56 const flat_binder_object* flat = reinterpret_cast<flat_binder_object*>(data + object[i]);
57 flat_binder_object* copiedFlat = reinterpret_cast<flat_binder_object*>(copiedData + copiedObject[i]);
58
59 if (flat->hdr.type == BINDER_TYPE_FD && flat->handle > 0) {
60 int32_t val = dup(flat->handle);
61 if (val < 0) {
62 ROSEN_LOGW("CopyFileDescriptor dup failed, fd:%d", val);
63 }
64 copiedFlat->handle = static_cast<uint32_t>(val);
65 }
66 }
67 }
68
CopyParcelIfNeed(MessageParcel & old)69 std::shared_ptr<MessageParcel> CopyParcelIfNeed(MessageParcel& old)
70 {
71 auto dataSize = old.GetDataSize();
72 if (dataSize <= MAX_DATA_SIZE_FOR_UNMARSHALLING_IN_PLACE && old.GetOffsetsSize() < FILE_DESCRIPTOR_LIMIT) {
73 return nullptr;
74 }
75 RS_TRACE_NAME("CopyParcelForUnmarsh: size:" + std::to_string(dataSize));
76 void* base = malloc(dataSize);
77 if (base == nullptr) {
78 RS_LOGE("RSRenderServiceConnectionStub::CopyParcelIfNeed malloc failed");
79 return nullptr;
80 }
81 if (memcpy_s(base, dataSize, reinterpret_cast<void*>(old.GetData()), dataSize) != 0) {
82 RS_LOGE("RSRenderServiceConnectionStub::CopyParcelIfNeed copy parcel data failed");
83 free(base);
84 return nullptr;
85 }
86
87 auto parcelCopied = std::make_shared<MessageParcel>();
88 if (!parcelCopied->ParseFrom(reinterpret_cast<uintptr_t>(base), dataSize)) {
89 RS_LOGE("RSRenderServiceConnectionStub::CopyParcelIfNeed ParseFrom failed");
90 free(base);
91 return nullptr;
92 }
93
94 auto objectNum = old.GetOffsetsSize();
95 if (objectNum != 0) {
96 parcelCopied->InjectOffsets(old.GetObjectOffsets(), objectNum);
97 CopyFileDescriptor(old, *parcelCopied);
98 }
99 if (parcelCopied->ReadInt32() != 0) {
100 RS_LOGE("RSRenderServiceConnectionStub::CopyParcelIfNeed parcel data not match");
101 return nullptr;
102 }
103 return parcelCopied;
104 }
105
HasPermission(const std::string & caller="RSRenderServiceConnectionStub::OnRemoteRequest")106 inline bool HasPermission(const std::string &caller = "RSRenderServiceConnectionStub::OnRemoteRequest")
107 {
108 bool hasPermission = false;
109 uint32_t tokenId = IPCSkeleton::GetCallingTokenID();
110 auto tokenType = Security::AccessToken::AccessTokenKit::GetTokenType(tokenId);
111 if (tokenType == Security::AccessToken::ATokenTypeEnum::TOKEN_HAP) {
112 uint64_t fullTokenId = IPCSkeleton::GetCallingFullTokenID();
113 hasPermission = Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(fullTokenId);
114 } else if (tokenType == Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE) {
115 hasPermission = true;
116 } else if (tokenType == Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL) {
117 hasPermission = true;
118 }
119 if (!hasPermission) {
120 RS_LOGE("%s ipc interface code access denied", caller.c_str());
121 }
122 return hasPermission;
123 }
124 }
125
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)126 int RSRenderServiceConnectionStub::OnRemoteRequest(
127 uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
128 {
129 int ret = ERR_NONE;
130 switch (code) {
131 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::COMMIT_TRANSACTION): {
132 RS_TRACE_NAME_FMT("Recv Parcel Size:%zu, fdCnt:%zu", data.GetDataSize(), data.GetOffsetsSize());
133 #if defined (ENABLE_DDGR_OPTIMIZE)
134 DDGRRenderer::GetInstance().IntegrateSetIndex(++transDataIndex_);
135 #endif
136 static bool isUniRender = RSUniRenderJudgement::IsUniRender();
137 std::shared_ptr<MessageParcel> parsedParcel;
138 if (data.ReadInt32() == 0) { // indicate normal parcel
139 if (isUniRender) {
140 // in uni render mode, if parcel size over threshold,
141 // Unmarshalling task will be post to RSUnmarshalThread,
142 // copy the origin parcel to maintain the parcel lifetime
143 parsedParcel = CopyParcelIfNeed(data);
144 }
145 if (parsedParcel == nullptr) {
146 // no need to copy or copy failed, use original parcel
147 // execute Unmarshalling immediately
148 auto transactionData = RSBaseRenderUtil::ParseTransactionData(data);
149 CommitTransaction(transactionData);
150 break;
151 }
152 } else {
153 // indicate ashmem parcel
154 // should be parsed to normal parcel before Unmarshalling
155 parsedParcel = RSAshmemHelper::ParseFromAshmemParcel(&data);
156 }
157 if (parsedParcel == nullptr) {
158 RS_LOGE("RSRenderServiceConnectionStub::COMMIT_TRANSACTION failed: parsed parcel is nullptr");
159 return ERR_INVALID_DATA;
160 }
161 if (isUniRender) {
162 // post Unmarshalling task to RSUnmarshalThread
163 RSUnmarshalThread::Instance().RecvParcel(parsedParcel);
164 } else {
165 // execute Unmarshalling immediately
166 auto transactionData = RSBaseRenderUtil::ParseTransactionData(*parsedParcel);
167 CommitTransaction(transactionData);
168 }
169 break;
170 }
171 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_UNI_RENDER_ENABLED): {
172 reply.WriteBool(GetUniRenderEnabled());
173 break;
174 }
175 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::CREATE_NODE): {
176 if (!HasPermission("RSRenderServiceConnectionStub::CREATE_NODE")) {
177 ret = ERR_INVALID_STATE;
178 break;
179 }
180 auto nodeId = data.ReadUint64();
181 auto surfaceName = data.ReadString();
182 auto bundleName = data.ReadString();
183 RSSurfaceRenderNodeConfig config = {.id = nodeId, .name = surfaceName, .bundleName = bundleName};
184 reply.WriteBool(CreateNode(config));
185 break;
186 }
187 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::CREATE_NODE_AND_SURFACE): {
188 auto nodeId = data.ReadUint64();
189 auto surfaceName = data.ReadString();
190 auto type = static_cast<RSSurfaceNodeType>(data.ReadUint8());
191 auto bundleName = data.ReadString();
192 RSSurfaceRenderNodeConfig config = {
193 .id = nodeId, .name = surfaceName, .bundleName = bundleName, .nodeType = type};
194 sptr<Surface> surface = CreateNodeAndSurface(config);
195 if (surface == nullptr) {
196 ret = ERR_NULL_OBJECT;
197 break;
198 }
199 auto producer = surface->GetProducer();
200 reply.WriteRemoteObject(producer->AsObject());
201 break;
202 }
203 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::SET_FOCUS_APP_INFO): {
204 auto token = data.ReadInterfaceToken();
205 if (token != RSIRenderServiceConnection::GetDescriptor()) {
206 ret = ERR_INVALID_STATE;
207 break;
208 }
209
210 int32_t pid = data.ReadInt32();
211 int32_t uid = data.ReadInt32();
212 std::string bundleName = data.ReadString();
213 std::string abilityName = data.ReadString();
214 uint64_t focusNodeId = data.ReadUint64();
215 int32_t status = SetFocusAppInfo(pid, uid, bundleName, abilityName, focusNodeId);
216 reply.WriteInt32(status);
217 break;
218 }
219 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_DEFAULT_SCREEN_ID): {
220 if (!HasPermission("RSRenderServiceConnectionStub::GET_DEFAULT_SCREEN_ID")) {
221 ret = ERR_INVALID_STATE;
222 break;
223 }
224 auto token = data.ReadInterfaceToken();
225 if (token != RSIRenderServiceConnection::GetDescriptor()) {
226 ret = ERR_INVALID_STATE;
227 break;
228 }
229 ScreenId id = GetDefaultScreenId();
230 reply.WriteUint64(id);
231 break;
232 }
233 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_ALL_SCREEN_IDS): {
234 auto token = data.ReadInterfaceToken();
235 if (token != RSIRenderServiceConnection::GetDescriptor()) {
236 ret = ERR_INVALID_STATE;
237 break;
238 }
239 std::vector<ScreenId> ids = GetAllScreenIds();
240 reply.WriteUint32(ids.size());
241 for (uint32_t i = 0; i < ids.size(); i++) {
242 reply.WriteUint64(ids[i]);
243 }
244 break;
245 }
246 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::CREATE_VIRTUAL_SCREEN): {
247 if (!HasPermission("RSRenderServiceConnectionStub::CREATE_VIRTUAL_SCREEN")) {
248 ret = ERR_INVALID_STATE;
249 break;
250 }
251 auto token = data.ReadInterfaceToken();
252 if (token != RSIRenderServiceConnection::GetDescriptor()) {
253 ret = ERR_INVALID_STATE;
254 break;
255 }
256
257 // read the parcel data.
258 std::string name = data.ReadString();
259 uint32_t width = data.ReadUint32();
260 uint32_t height = data.ReadUint32();
261 sptr<Surface> surface = nullptr;
262 auto remoteObject = data.ReadRemoteObject();
263 if (remoteObject != nullptr) {
264 auto bufferProducer = iface_cast<IBufferProducer>(remoteObject);
265 surface = Surface::CreateSurfaceAsProducer(bufferProducer);
266 }
267
268 ScreenId mirrorId = data.ReadUint64();
269 int32_t flags = data.ReadInt32();
270 ScreenId id = CreateVirtualScreen(name, width, height, surface, mirrorId, flags);
271 reply.WriteUint64(id);
272 break;
273 }
274 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::SET_VIRTUAL_SCREEN_SURFACE): {
275 if (!HasPermission("RSRenderServiceConnectionStub::SET_VIRTUAL_SCREEN_SURFACE")) {
276 ret = ERR_INVALID_STATE;
277 break;
278 }
279 auto token = data.ReadInterfaceToken();
280 if (token != RSIRenderServiceConnection::GetDescriptor()) {
281 ret = ERR_INVALID_STATE;
282 break;
283 }
284
285 // read the parcel data.
286 ScreenId id = data.ReadUint64();
287 auto remoteObject = data.ReadRemoteObject();
288 if (remoteObject == nullptr) {
289 ret = ERR_NULL_OBJECT;
290 break;
291 }
292 auto bufferProducer = iface_cast<IBufferProducer>(remoteObject);
293 sptr<Surface> surface = Surface::CreateSurfaceAsProducer(bufferProducer);
294 if (surface == nullptr) {
295 ret = ERR_NULL_OBJECT;
296 break;
297 }
298 int32_t status = SetVirtualScreenSurface(id, surface);
299 reply.WriteInt32(status);
300 break;
301 }
302 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::REMOVE_VIRTUAL_SCREEN): {
303 if (!HasPermission("RSRenderServiceConnectionStub::REMOVE_VIRTUAL_SCREEN")) {
304 ret = ERR_INVALID_STATE;
305 break;
306 }
307 auto token = data.ReadInterfaceToken();
308 if (token != RSIRenderServiceConnection::GetDescriptor()) {
309 ret = ERR_INVALID_STATE;
310 break;
311 }
312 ScreenId id = data.ReadUint64();
313 RemoveVirtualScreen(id);
314 break;
315 }
316 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::SET_SCREEN_CHANGE_CALLBACK): {
317 if (!HasPermission("RSRenderServiceConnectionStub::SET_SCREEN_CHANGE_CALLBACK")) {
318 ret = ERR_INVALID_STATE;
319 break;
320 }
321 auto token = data.ReadInterfaceToken();
322 if (token != RSIRenderServiceConnection::GetDescriptor()) {
323 ret = ERR_INVALID_STATE;
324 break;
325 }
326
327 auto remoteObject = data.ReadRemoteObject();
328 if (remoteObject == nullptr) {
329 ret = ERR_NULL_OBJECT;
330 break;
331 }
332 sptr<RSIScreenChangeCallback> cb = iface_cast<RSIScreenChangeCallback>(remoteObject);
333 if (cb == nullptr) {
334 ret = ERR_NULL_OBJECT;
335 break;
336 }
337 int32_t status = SetScreenChangeCallback(cb);
338 reply.WriteInt32(status);
339 break;
340 }
341 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::SET_SCREEN_ACTIVE_MODE): {
342 if (!HasPermission("RSRenderServiceConnectionStub::SET_SCREEN_ACTIVE_MODE")) {
343 ret = ERR_INVALID_STATE;
344 break;
345 }
346 auto token = data.ReadInterfaceToken();
347 if (token != RSIRenderServiceConnection::GetDescriptor()) {
348 ret = ERR_INVALID_STATE;
349 break;
350 }
351 ScreenId id = data.ReadUint64();
352 uint32_t modeId = data.ReadUint32();
353 SetScreenActiveMode(id, modeId);
354 break;
355 }
356 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::SET_SCREEN_REFRESH_RATE): {
357 auto token = data.ReadInterfaceToken();
358 if (token != RSIRenderServiceConnection::GetDescriptor()) {
359 ret = ERR_INVALID_STATE;
360 break;
361 }
362 ScreenId id = data.ReadUint64();
363 int32_t sceneId = data.ReadInt32();
364 int32_t rate = data.ReadInt32();
365 SetScreenRefreshRate(id, sceneId, rate);
366 break;
367 }
368 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::SET_REFRESH_RATE_MODE): {
369 auto token = data.ReadInterfaceToken();
370 if (token != RSIRenderServiceConnection::GetDescriptor()) {
371 ret = ERR_INVALID_STATE;
372 break;
373 }
374 int32_t mode = data.ReadInt32();
375 SetRefreshRateMode(mode);
376 break;
377 }
378 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_SCREEN_CURRENT_REFRESH_RATE): {
379 auto token = data.ReadInterfaceToken();
380 if (token != RSIRenderServiceConnection::GetDescriptor()) {
381 ret = ERR_INVALID_STATE;
382 break;
383 }
384 ScreenId id = data.ReadUint64();
385 uint32_t refreshRate = GetScreenCurrentRefreshRate(id);
386 reply.WriteUint32(refreshRate);
387 break;
388 }
389 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_SCREEN_SUPPORTED_REFRESH_RATES): {
390 auto token = data.ReadInterfaceToken();
391 if (token != RSIRenderServiceConnection::GetDescriptor()) {
392 ret = ERR_INVALID_STATE;
393 break;
394 }
395 ScreenId id = data.ReadUint64();
396 std::vector<uint32_t> rates = GetScreenSupportedRefreshRates(id);
397 reply.WriteUint64(static_cast<uint64_t>(rates.size()));
398 for (auto ratesIter : rates) {
399 reply.WriteUint32(ratesIter);
400 }
401 break;
402 }
403 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::SET_VIRTUAL_SCREEN_RESOLUTION): {
404 if (!HasPermission("RSRenderServiceConnectionStub::SET_VIRTUAL_SCREEN_RESOLUTION")) {
405 ret = ERR_INVALID_STATE;
406 break;
407 }
408 auto token = data.ReadInterfaceToken();
409 if (token != RSIRenderServiceConnection::GetDescriptor()) {
410 ret = ERR_INVALID_STATE;
411 break;
412 }
413 ScreenId id = data.ReadUint64();
414 uint32_t width = data.ReadUint32();
415 uint32_t height = data.ReadUint32();
416 int32_t status = SetVirtualScreenResolution(id, width, height);
417 reply.WriteInt32(status);
418 break;
419 }
420 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::SET_SCREEN_POWER_STATUS): {
421 if (!HasPermission("RSRenderServiceConnectionStub::SET_SCREEN_POWER_STATUS")) {
422 ret = ERR_INVALID_STATE;
423 break;
424 }
425 auto token = data.ReadInterfaceToken();
426 if (token != RSIRenderServiceConnection::GetDescriptor()) {
427 ret = ERR_INVALID_STATE;
428 break;
429 }
430 ScreenId id = data.ReadUint64();
431 uint32_t status = data.ReadUint32();
432 SetScreenPowerStatus(id, static_cast<ScreenPowerStatus>(status));
433 break;
434 }
435 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::TAKE_SURFACE_CAPTURE): {
436 NodeId id = data.ReadUint64();
437 auto remoteObject = data.ReadRemoteObject();
438 if (remoteObject == nullptr) {
439 ret = ERR_NULL_OBJECT;
440 break;
441 }
442 sptr<RSISurfaceCaptureCallback> cb = iface_cast<RSISurfaceCaptureCallback>(remoteObject);
443 if (cb == nullptr) {
444 ret = ERR_NULL_OBJECT;
445 break;
446 }
447 float scaleX = data.ReadFloat();
448 float scaleY = data.ReadFloat();
449 TakeSurfaceCapture(id, cb, scaleX, scaleY);
450 break;
451 }
452 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::REGISTER_APPLICATION_AGENT): {
453 uint32_t pid = data.ReadUint32();
454 auto remoteObject = data.ReadRemoteObject();
455 if (remoteObject == nullptr) {
456 ret = ERR_NULL_OBJECT;
457 break;
458 }
459 sptr<IApplicationAgent> app = iface_cast<IApplicationAgent>(remoteObject);
460 if (app == nullptr) {
461 ret = ERR_NULL_OBJECT;
462 break;
463 }
464 RegisterApplicationAgent(pid, app);
465 break;
466 }
467 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_VIRTUAL_SCREEN_RESOLUTION): {
468 if (!HasPermission("RSRenderServiceConnectionStub::GET_VIRTUAL_SCREEN_RESOLUTION")) {
469 ret = ERR_INVALID_STATE;
470 break;
471 }
472 auto token = data.ReadInterfaceToken();
473 if (token != RSIRenderServiceConnection::GetDescriptor()) {
474 ret = ERR_INVALID_STATE;
475 break;
476 }
477 ScreenId id = data.ReadUint64();
478 RSVirtualScreenResolution virtualScreenResolution = GetVirtualScreenResolution(id);
479 reply.WriteParcelable(&virtualScreenResolution);
480 break;
481 }
482 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_SCREEN_ACTIVE_MODE): {
483 if (!HasPermission("RSRenderServiceConnectionStub::GET_SCREEN_ACTIVE_MODE")) {
484 ret = ERR_INVALID_STATE;
485 break;
486 }
487 auto token = data.ReadInterfaceToken();
488 if (token != RSIRenderServiceConnection::GetDescriptor()) {
489 ret = ERR_INVALID_STATE;
490 break;
491 }
492 ScreenId id = data.ReadUint64();
493 RSScreenModeInfo screenModeInfo = GetScreenActiveMode(id);
494 reply.WriteParcelable(&screenModeInfo);
495 break;
496 }
497 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_SCREEN_SUPPORTED_MODES): {
498 auto token = data.ReadInterfaceToken();
499 if (token != RSIRenderServiceConnection::GetDescriptor()) {
500 ret = ERR_INVALID_STATE;
501 break;
502 }
503 ScreenId id = data.ReadUint64();
504 std::vector<RSScreenModeInfo> screenSupportedModes = GetScreenSupportedModes(id);
505 reply.WriteUint64(static_cast<uint64_t>(screenSupportedModes.size()));
506 for (uint32_t modeIndex = 0; modeIndex < screenSupportedModes.size(); modeIndex++) {
507 reply.WriteParcelable(&screenSupportedModes[modeIndex]);
508 }
509 break;
510 }
511 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_MEMORY_GRAPHIC): {
512 if (!HasPermission("RSRenderServiceConnectionStub::GET_MEMORY_GRAPHIC")) {
513 ret = ERR_INVALID_STATE;
514 break;
515 }
516 auto token = data.ReadInterfaceToken();
517 if (token != RSIRenderServiceConnection::GetDescriptor()) {
518 ret = ERR_INVALID_STATE;
519 break;
520 }
521 auto pid = data.ReadInt32();
522 MemoryGraphic memoryGraphic = GetMemoryGraphic(pid);
523 reply.WriteParcelable(&memoryGraphic);
524 break;
525 }
526 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_MEMORY_GRAPHICS): {
527 if (!HasPermission("RSRenderServiceConnectionStub::GET_MEMORY_GRAPHICS")) {
528 ret = ERR_INVALID_STATE;
529 break;
530 }
531 auto token = data.ReadInterfaceToken();
532 if (token != RSIRenderServiceConnection::GetDescriptor()) {
533 ret = ERR_INVALID_STATE;
534 break;
535 }
536 std::vector<MemoryGraphic> memoryGraphics = GetMemoryGraphics();
537 reply.WriteUint64(static_cast<uint64_t>(memoryGraphics.size()));
538 for (uint32_t index = 0; index < memoryGraphics.size(); index++) {
539 reply.WriteParcelable(&memoryGraphics[index]);
540 }
541 break;
542 }
543 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_SCREEN_CAPABILITY): {
544 auto token = data.ReadInterfaceToken();
545 if (token != RSIRenderServiceConnection::GetDescriptor()) {
546 ret = ERR_INVALID_STATE;
547 break;
548 }
549 ScreenId id = data.ReadUint64();
550 RSScreenCapability screenCapability = GetScreenCapability(id);
551 reply.WriteParcelable(&screenCapability);
552 break;
553 }
554 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_SCREEN_POWER_STATUS): {
555 if (!HasPermission("RSRenderServiceConnectionStub::GET_SCREEN_POWER_STATUS")) {
556 ret = ERR_INVALID_STATE;
557 break;
558 }
559 auto token = data.ReadInterfaceToken();
560 if (token != RSIRenderServiceConnection::GetDescriptor()) {
561 ret = ERR_INVALID_STATE;
562 break;
563 }
564 ScreenId id = data.ReadUint64();
565 ScreenPowerStatus status = GetScreenPowerStatus(id);
566 reply.WriteUint32(static_cast<uint32_t>(status));
567 break;
568 }
569 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_SCREEN_DATA): {
570 if (!HasPermission("RSRenderServiceConnectionStub::GET_SCREEN_DATA")) {
571 ret = ERR_INVALID_STATE;
572 break;
573 }
574 auto token = data.ReadInterfaceToken();
575 if (token != RSIRenderServiceConnection::GetDescriptor()) {
576 ret = ERR_INVALID_STATE;
577 break;
578 }
579 ScreenId id = data.ReadUint64();
580 RSScreenData screenData = GetScreenData(id);
581 reply.WriteParcelable(&screenData);
582 break;
583 }
584 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_SCREEN_BACK_LIGHT): {
585 if (!HasPermission("RSRenderServiceConnectionStub::GET_SCREEN_BACK_LIGHT")) {
586 ret = ERR_INVALID_STATE;
587 break;
588 }
589 auto token = data.ReadInterfaceToken();
590 if (token != RSIRenderServiceConnection::GetDescriptor()) {
591 ret = ERR_INVALID_STATE;
592 break;
593 }
594 ScreenId id = data.ReadUint64();
595 int32_t level = GetScreenBacklight(id);
596 reply.WriteInt32(level);
597 break;
598 }
599 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::SET_SCREEN_BACK_LIGHT): {
600 if (!HasPermission("RSRenderServiceConnectionStub::SET_SCREEN_BACK_LIGHT")) {
601 ret = ERR_INVALID_STATE;
602 break;
603 }
604 auto token = data.ReadInterfaceToken();
605 if (token != RSIRenderServiceConnection::GetDescriptor()) {
606 ret = ERR_INVALID_STATE;
607 break;
608 }
609 ScreenId id = data.ReadUint64();
610 uint32_t level = data.ReadUint32();
611 SetScreenBacklight(id, level);
612 break;
613 }
614 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::SET_BUFFER_AVAILABLE_LISTENER): {
615 auto token = data.ReadInterfaceToken();
616 if (token != RSIRenderServiceConnection::GetDescriptor()) {
617 ret = ERR_INVALID_STATE;
618 break;
619 }
620 NodeId id = data.ReadUint64();
621 auto remoteObject = data.ReadRemoteObject();
622 bool isFromRenderThread = data.ReadBool();
623 if (remoteObject == nullptr) {
624 ret = ERR_NULL_OBJECT;
625 break;
626 }
627 sptr<RSIBufferAvailableCallback> cb = iface_cast<RSIBufferAvailableCallback>(remoteObject);
628 if (cb == nullptr) {
629 ret = ERR_NULL_OBJECT;
630 break;
631 }
632 RegisterBufferAvailableListener(id, cb, isFromRenderThread);
633 break;
634 }
635 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::SET_BUFFER_CLEAR_LISTENER): {
636 auto token = data.ReadInterfaceToken();
637 if (token != RSIRenderServiceConnection::GetDescriptor()) {
638 ret = ERR_INVALID_STATE;
639 break;
640 }
641 NodeId id = data.ReadUint64();
642 auto remoteObject = data.ReadRemoteObject();
643 if (remoteObject == nullptr) {
644 ret = ERR_NULL_OBJECT;
645 break;
646 }
647 sptr<RSIBufferClearCallback> cb = iface_cast<RSIBufferClearCallback>(remoteObject);
648 if (cb == nullptr) {
649 ret = ERR_NULL_OBJECT;
650 break;
651 }
652 RegisterBufferClearListener(id, cb);
653 break;
654 }
655 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_SCREEN_SUPPORTED_GAMUTS): {
656 if (!HasPermission("RSRenderServiceConnectionStub::GET_SCREEN_SUPPORTED_GAMUTS")) {
657 ret = ERR_INVALID_STATE;
658 break;
659 }
660 auto token = data.ReadInterfaceToken();
661 if (token != RSIRenderServiceConnection::GetDescriptor()) {
662 ret = ERR_INVALID_STATE;
663 break;
664 }
665 ScreenId id = data.ReadUint64();
666 std::vector<uint32_t> modeSend;
667 std::vector<ScreenColorGamut> mode;
668 int32_t result = GetScreenSupportedColorGamuts(id, mode);
669 reply.WriteInt32(result);
670 if (result != StatusCode::SUCCESS) {
671 break;
672 }
673 std::copy(mode.begin(), mode.end(), std::back_inserter(modeSend));
674 reply.WriteUInt32Vector(modeSend);
675 break;
676 }
677 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_SCREEN_SUPPORTED_METADATAKEYS): {
678 auto token = data.ReadInterfaceToken();
679 if (token != RSIRenderServiceConnection::GetDescriptor()) {
680 ret = ERR_INVALID_STATE;
681 break;
682 }
683 ScreenId id = data.ReadUint64();
684 std::vector<uint32_t> keySend;
685 std::vector<ScreenHDRMetadataKey> keys;
686 int32_t result = GetScreenSupportedMetaDataKeys(id, keys);
687 reply.WriteInt32(result);
688 if (result != StatusCode::SUCCESS) {
689 break;
690 }
691 for (auto i : keys) {
692 keySend.push_back(i);
693 }
694 reply.WriteUInt32Vector(keySend);
695 break;
696 }
697 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_SCREEN_GAMUT): {
698 if (!HasPermission("RSRenderServiceConnectionStub::GET_SCREEN_GAMUT")) {
699 ret = ERR_INVALID_STATE;
700 break;
701 }
702 auto token = data.ReadInterfaceToken();
703 if (token != RSIRenderServiceConnection::GetDescriptor()) {
704 ret = ERR_INVALID_STATE;
705 break;
706 }
707 ScreenId id = data.ReadUint64();
708 ScreenColorGamut mode;
709 int32_t result = GetScreenColorGamut(id, mode);
710 reply.WriteInt32(result);
711 if (result != StatusCode::SUCCESS) {
712 break;
713 }
714 reply.WriteUint32(mode);
715 break;
716 }
717 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::SET_SCREEN_GAMUT): {
718 if (!HasPermission("RSRenderServiceConnectionStub::SET_SCREEN_GAMUT")) {
719 ret = ERR_INVALID_STATE;
720 break;
721 }
722 auto token = data.ReadInterfaceToken();
723 if (token != RSIRenderServiceConnection::GetDescriptor()) {
724 ret = ERR_INVALID_STATE;
725 break;
726 }
727 ScreenId id = data.ReadUint64();
728 int32_t modeIdx = data.ReadInt32();
729 int32_t result = SetScreenColorGamut(id, modeIdx);
730 reply.WriteInt32(result);
731 break;
732 }
733 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::SET_SCREEN_GAMUT_MAP): {
734 if (!HasPermission("RSRenderServiceConnectionStub::SET_SCREEN_GAMUT_MAP")) {
735 ret = ERR_INVALID_STATE;
736 break;
737 }
738 auto token = data.ReadInterfaceToken();
739 if (token != RSIRenderServiceConnection::GetDescriptor()) {
740 ret = ERR_INVALID_STATE;
741 break;
742 }
743 ScreenId id = data.ReadUint64();
744 ScreenGamutMap mode = static_cast<ScreenGamutMap>(data.ReadInt32());
745 int32_t result = SetScreenGamutMap(id, mode);
746 reply.WriteInt32(result);
747 break;
748 }
749 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_SCREEN_GAMUT_MAP): {
750 if (!HasPermission("RSRenderServiceConnectionStub::GET_SCREEN_GAMUT_MAP")) {
751 ret = ERR_INVALID_STATE;
752 break;
753 }
754 auto token = data.ReadInterfaceToken();
755 if (token != RSIRenderServiceConnection::GetDescriptor()) {
756 ret = ERR_INVALID_STATE;
757 break;
758 }
759 ScreenId id = data.ReadUint64();
760 ScreenGamutMap mode;
761 int32_t result = GetScreenGamutMap(id, mode);
762 reply.WriteInt32(result);
763 if (result != StatusCode::SUCCESS) {
764 break;
765 }
766 reply.WriteUint32(mode);
767 break;
768 }
769 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::CREATE_VSYNC_CONNECTION): {
770 std::string name = data.ReadString();
771 auto remoteObj = data.ReadRemoteObject();
772 if (remoteObj == nullptr) {
773 ret = ERR_NULL_OBJECT;
774 break;
775 }
776 if (!remoteObj->IsProxyObject()) {
777 ret = ERR_UNKNOWN_OBJECT;
778 break;
779 }
780 auto token = iface_cast<VSyncIConnectionToken>(remoteObj);
781 if (token == nullptr) {
782 ret = ERR_UNKNOWN_OBJECT;
783 break;
784 }
785 sptr<IVSyncConnection> conn = CreateVSyncConnection(name, token);
786 if (conn == nullptr) {
787 ret = ERR_NULL_OBJECT;
788 break;
789 }
790 reply.WriteRemoteObject(conn->AsObject());
791 break;
792 }
793 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_SCREEN_HDR_CAPABILITY): {
794 if (!HasPermission("RSRenderServiceConnectionStub::GET_SCREEN_HDR_CAPABILITY")) {
795 ret = ERR_INVALID_STATE;
796 break;
797 }
798 auto token = data.ReadInterfaceToken();
799 if (token != RSIRenderServiceConnection::GetDescriptor()) {
800 ret = ERR_INVALID_STATE;
801 break;
802 }
803 ScreenId id = data.ReadUint64();
804 RSScreenHDRCapability screenHDRCapability;
805 int32_t result = GetScreenHDRCapability(id, screenHDRCapability);
806 reply.WriteInt32(result);
807 if (result != StatusCode::SUCCESS) {
808 break;
809 }
810 reply.WriteParcelable(&screenHDRCapability);
811 break;
812 }
813 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_SCREEN_TYPE): {
814 if (!HasPermission("RSRenderServiceConnectionStub::GET_SCREEN_TYPE")) {
815 ret = ERR_INVALID_STATE;
816 break;
817 }
818 auto token = data.ReadInterfaceToken();
819 if (token != RSIRenderServiceConnection::GetDescriptor()) {
820 ret = ERR_INVALID_STATE;
821 break;
822 }
823 ScreenId id = data.ReadUint64();
824 RSScreenType type;
825 int32_t result = GetScreenType(id, type);
826 reply.WriteInt32(result);
827 if (result != StatusCode::SUCCESS) {
828 break;
829 }
830 reply.WriteUint32(type);
831 break;
832 }
833 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_BITMAP): {
834 auto token = data.ReadInterfaceToken();
835 if (token != RSIRenderServiceConnection::GetDescriptor()) {
836 ret = ERR_INVALID_STATE;
837 break;
838 }
839 NodeId id = data.ReadUint64();
840 #ifndef USE_ROSEN_DRAWING
841 SkBitmap bm;
842 #else
843 Drawing::Bitmap bm;
844 #endif
845 bool result = GetBitmap(id, bm);
846 reply.WriteBool(result);
847 if (result) {
848 RSMarshallingHelper::Marshalling(reply, bm);
849 }
850 break;
851 }
852 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::GET_PIXELMAP): {
853 auto token = data.ReadInterfaceToken();
854 if (token != RSIRenderServiceConnection::GetDescriptor()) {
855 ret = ERR_INVALID_STATE;
856 break;
857 }
858 NodeId id = data.ReadUint64();
859 std::shared_ptr<Media::PixelMap> pixelmap =
860 std::shared_ptr<Media::PixelMap>(data.ReadParcelable<Media::PixelMap>());
861 SkRect skRect;
862 RSMarshallingHelper::Unmarshalling(data, skRect);
863 bool result = GetPixelmap(id, pixelmap, &skRect);
864 reply.WriteBool(result);
865 break;
866 }
867 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::SET_SCREEN_SKIP_FRAME_INTERVAL): {
868 auto token = data.ReadInterfaceToken();
869 if (token != RSIRenderServiceConnection::GetDescriptor()) {
870 ret = ERR_INVALID_STATE;
871 break;
872 }
873 ScreenId id = data.ReadUint64();
874 uint32_t skipFrameInterval = data.ReadUint32();
875 int32_t result = SetScreenSkipFrameInterval(id, skipFrameInterval);
876 reply.WriteInt32(result);
877 break;
878 }
879 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::REGISTER_OCCLUSION_CHANGE_CALLBACK): {
880 if (!HasPermission("RSRenderServiceConnectionStub::REGISTER_OCCLUSION_CHANGE_CALLBACK")) {
881 ret = ERR_INVALID_STATE;
882 break;
883 }
884 auto token = data.ReadInterfaceToken();
885 if (token != RSIRenderServiceConnection::GetDescriptor()) {
886 ret = ERR_INVALID_STATE;
887 break;
888 }
889
890 auto remoteObject = data.ReadRemoteObject();
891 if (remoteObject == nullptr) {
892 ret = ERR_NULL_OBJECT;
893 break;
894 }
895 sptr<RSIOcclusionChangeCallback> callback = iface_cast<RSIOcclusionChangeCallback>(remoteObject);
896 if (callback == nullptr) {
897 ret = ERR_NULL_OBJECT;
898 break;
899 }
900 int32_t status = RegisterOcclusionChangeCallback(callback);
901 reply.WriteInt32(status);
902 break;
903 }
904
905 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::SET_APP_WINDOW_NUM): {
906 if (!HasPermission("RSRenderServiceConnectionStub::SET_APP_WINDOW_NUM")) {
907 ret = ERR_INVALID_STATE;
908 break;
909 }
910 auto token = data.ReadInterfaceToken();
911 if (token != RSIRenderServiceConnection::GetDescriptor()) {
912 ret = ERR_INVALID_STATE;
913 break;
914 }
915 uint32_t num = data.ReadUint32();
916 SetAppWindowNum(num);
917 break;
918 }
919 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::SHOW_WATERMARK): {
920 if (!HasPermission("RSRenderServiceConnectionStub::SHOW_WATERMARK")) {
921 ret = ERR_INVALID_STATE;
922 break;
923 }
924 auto token = data.ReadInterfaceToken();
925 if (token != RSIRenderServiceConnection::GetDescriptor()) {
926 ret = ERR_INVALID_STATE;
927 break;
928 }
929 std::shared_ptr<Media::PixelMap> watermarkImg =
930 std::shared_ptr<Media::PixelMap>(data.ReadParcelable<Media::PixelMap>());
931 bool isShow = data.ReadBool();
932 ShowWatermark(watermarkImg, isShow);
933 break;
934 }
935 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::REPORT_JANK_STATS): {
936 auto token = data.ReadInterfaceToken();
937 if (token != RSIRenderServiceConnection::GetDescriptor()) {
938 ret = ERR_INVALID_STATE;
939 break;
940 }
941 ReportJankStats();
942 break;
943 }
944 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::REPORT_EVENT_RESPONSE): {
945 auto token = data.ReadInterfaceToken();
946 if (token != RSIRenderServiceConnection::GetDescriptor()) {
947 ret = ERR_INVALID_STATE;
948 break;
949 }
950 DataBaseRs info;
951 ReadDataBaseRs(info, data);
952 ReportEventResponse(info);
953 break;
954 }
955 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::REPORT_EVENT_COMPLETE): {
956 auto token = data.ReadInterfaceToken();
957 if (token != RSIRenderServiceConnection::GetDescriptor()) {
958 ret = ERR_INVALID_STATE;
959 break;
960 }
961 DataBaseRs info;
962 ReadDataBaseRs(info, data);
963 ReportEventComplete(info);
964 break;
965 }
966 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::REPORT_EVENT_JANK_FRAME): {
967 auto token = data.ReadInterfaceToken();
968 if (token != RSIRenderServiceConnection::GetDescriptor()) {
969 ret = ERR_INVALID_STATE;
970 break;
971 }
972 DataBaseRs info;
973 ReadDataBaseRs(info, data);
974 ReportEventJankFrame(info);
975 break;
976 }
977 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::EXECUTE_SYNCHRONOUS_TASK): {
978 auto token = data.ReadInterfaceToken();
979 if (token != RSIRenderServiceConnection::GetDescriptor()) {
980 ret = ERR_INVALID_STATE;
981 break;
982 }
983 auto type = data.ReadInt16();
984 auto subType = data.ReadInt16();
985 if (type != RS_NODE_SYNCHRONOUS_READ_PROPERTY) {
986 ret = ERR_INVALID_STATE;
987 break;
988 }
989 auto func = RSCommandFactory::Instance().GetUnmarshallingFunc(type, subType);
990 if (func == nullptr) {
991 ret = ERR_INVALID_STATE;
992 break;
993 }
994 auto command = static_cast<RSSyncTask*>((*func)(data));
995 if (command == nullptr) {
996 ret = ERR_INVALID_STATE;
997 break;
998 }
999 std::shared_ptr<RSSyncTask> task(command);
1000 ExecuteSynchronousTask(task);
1001 if (!task->Marshalling(reply)) {
1002 ret = ERR_INVALID_STATE;
1003 }
1004 break;
1005 }
1006 case static_cast<uint32_t>(RSIRenderServiceConnectionInterfaceCode::SET_HARDWARE_ENABLED) : {
1007 auto token = data.ReadInterfaceToken();
1008 if (token != RSIRenderServiceConnection::GetDescriptor()) {
1009 ret = ERR_INVALID_STATE;
1010 break;
1011 }
1012 auto id = data.ReadUint64();
1013 auto isEnabled = data.ReadBool();
1014 SetHardwareEnabled(id, isEnabled);
1015 break;
1016 }
1017 default: {
1018 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
1019 }
1020 }
1021
1022 return ret;
1023 }
1024
ReadDataBaseRs(DataBaseRs & info,MessageParcel & data)1025 void RSRenderServiceConnectionStub::ReadDataBaseRs(DataBaseRs& info, MessageParcel& data)
1026 {
1027 info.appPid = data.ReadInt32();
1028 info.eventType = data.ReadInt32();
1029 info.versionCode = data.ReadInt32();
1030 info.uniqueId = data.ReadInt64();
1031 info.inputTime = data.ReadInt64();
1032 info.beginVsyncTime = data.ReadInt64();
1033 info.endVsyncTime = data.ReadInt64();
1034 info.sceneId = data.ReadString();
1035 info.versionName = data.ReadString();
1036 info.bundleName = data.ReadString();
1037 info.processName = data.ReadString();
1038 info.abilityName = data.ReadString();
1039 info.pageUrl = data.ReadString();
1040 info.sourceType = data.ReadString();
1041 info.note = data.ReadString();
1042 }
1043 } // namespace Rosen
1044 } // namespace OHOS
1045