1 /*
2 * Copyright (c) 2021-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 "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 namespace OHOS {
31 namespace Rosen {
32 namespace {
33 constexpr size_t MAX_DATA_SIZE_FOR_UNMARSHALLING_IN_PLACE = 1024 * 30; // 30kB
34
CopyFileDescriptor(MessageParcel & old,MessageParcel & copied)35 void CopyFileDescriptor(MessageParcel& old, MessageParcel& copied)
36 {
37 binder_size_t* object = reinterpret_cast<binder_size_t*>(old.GetObjectOffsets());
38 binder_size_t* copiedObject = reinterpret_cast<binder_size_t*>(copied.GetObjectOffsets());
39
40 size_t objectNum = old.GetOffsetsSize();
41
42 uintptr_t data = old.GetData();
43 uintptr_t copiedData = copied.GetData();
44
45 for (size_t i = 0; i < objectNum; i++) {
46 const flat_binder_object* flat = reinterpret_cast<flat_binder_object*>(data + object[i]);
47 flat_binder_object* copiedFlat = reinterpret_cast<flat_binder_object*>(copiedData + copiedObject[i]);
48
49 if (flat->hdr.type == BINDER_TYPE_FD && flat->handle > 0) {
50 int32_t val = dup(flat->handle);
51 if (val < 0) {
52 ROSEN_LOGW("CopyFileDescriptor dup failed, fd:%d", val);
53 }
54 copiedFlat->handle = static_cast<uint32_t>(val);
55 }
56 }
57 }
58
CopyParcelIfNeed(MessageParcel & old)59 std::shared_ptr<MessageParcel> CopyParcelIfNeed(MessageParcel& old)
60 {
61 auto dataSize = old.GetDataSize();
62 if (dataSize <= MAX_DATA_SIZE_FOR_UNMARSHALLING_IN_PLACE) {
63 return nullptr;
64 }
65 RS_TRACE_NAME("CopyParcelForUnmarsh: size:" + std::to_string(dataSize));
66 void* base = malloc(dataSize);
67 if (memcpy_s(base, dataSize, reinterpret_cast<void*>(old.GetData()), dataSize) != 0) {
68 RS_LOGE("RSRenderServiceConnectionStub::CopyParcelIfNeed copy parcel data failed");
69 free(base);
70 return nullptr;
71 }
72
73 auto parcelCopied = std::make_shared<MessageParcel>();
74 if (!parcelCopied->ParseFrom(reinterpret_cast<uintptr_t>(base), dataSize)) {
75 RS_LOGE("RSRenderServiceConnectionStub::CopyParcelIfNeed ParseFrom failed");
76 free(base);
77 return nullptr;
78 }
79
80 auto objectNum = old.GetOffsetsSize();
81 if (objectNum != 0) {
82 parcelCopied->InjectOffsets(old.GetObjectOffsets(), objectNum);
83 CopyFileDescriptor(old, *parcelCopied);
84 }
85 if (parcelCopied->ReadInt32() != 0) {
86 RS_LOGE("RSRenderServiceConnectionStub::CopyParcelIfNeed parcel data not match");
87 return nullptr;
88 }
89 return parcelCopied;
90 }
91 }
92
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)93 int RSRenderServiceConnectionStub::OnRemoteRequest(
94 uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
95 {
96 int ret = ERR_NONE;
97 switch (code) {
98 case COMMIT_TRANSACTION: {
99 RS_ASYNC_TRACE_END("RSProxySendRequest", data.GetDataSize());
100 static bool isUniRender = RSUniRenderJudgement::IsUniRender();
101 std::shared_ptr<MessageParcel> parsedParcel;
102 if (data.ReadInt32() == 0) { // indicate normal parcel
103 if (isUniRender) {
104 // in uni render mode, if parcel size over threshold,
105 // Unmarshalling task will be post to RSUnmarshalThread,
106 // copy the origin parcel to maintain the parcel lifetime
107 parsedParcel = CopyParcelIfNeed(data);
108 }
109 if (parsedParcel == nullptr) {
110 // no need to copy or copy failed, use original parcel
111 // execute Unmarshalling immediately
112 RSMainThread::Instance()->RequestNextVSync();
113 auto transactionData = RSBaseRenderUtil::ParseTransactionData(data);
114 CommitTransaction(transactionData);
115 break;
116 }
117 } else {
118 // indicate ashmem parcel
119 // should be parsed to normal parcel before Unmarshalling
120 parsedParcel = RSAshmemHelper::ParseFromAshmemParcel(&data);
121 }
122 if (parsedParcel == nullptr) {
123 RS_LOGE("RSRenderServiceConnectionStub::COMMIT_TRANSACTION failed");
124 return ERR_INVALID_DATA;
125 }
126 if (RSMainThread::Instance()->QueryIfUseUniVisitor()) {
127 // post Unmarshalling task to RSUnmarshalThread
128 RSUnmarshalThread::Instance().RecvParcel(parsedParcel);
129 } else {
130 // execute Unmarshalling immediately
131 auto transactionData = RSBaseRenderUtil::ParseTransactionData(*parsedParcel);
132 CommitTransaction(transactionData);
133 }
134 break;
135 }
136 case SET_RENDER_MODE_CHANGE_CALLBACK: {
137 auto token = data.ReadInterfaceToken();
138 if (token != RSIRenderServiceConnection::GetDescriptor()) {
139 ret = ERR_INVALID_STATE;
140 break;
141 }
142
143 auto remoteObject = data.ReadRemoteObject();
144 if (remoteObject == nullptr) {
145 ret = ERR_NULL_OBJECT;
146 break;
147 }
148 sptr<RSIRenderModeChangeCallback> cb = iface_cast<RSIRenderModeChangeCallback>(remoteObject);
149 int32_t status = SetRenderModeChangeCallback(cb);
150 reply.WriteInt32(status);
151 break;
152 }
153 case UPDATE_RENDER_MODE: {
154 bool isUniRender = data.ReadBool();
155 UpdateRenderMode(isUniRender);
156 break;
157 }
158 case GET_UNI_RENDER_ENABLED: {
159 reply.WriteBool(GetUniRenderEnabled());
160 break;
161 }
162 case QUERY_RT_NEED_RENDER: {
163 reply.WriteBool(QueryIfRTNeedRender());
164 break;
165 }
166 case CREATE_NODE: {
167 auto nodeId = data.ReadUint64();
168 auto surfaceName = data.ReadString();
169 RSSurfaceRenderNodeConfig config = {.id = nodeId, .name = surfaceName};
170 reply.WriteBool(CreateNode(config));
171 break;
172 }
173 case CREATE_NODE_AND_SURFACE: {
174 auto nodeId = data.ReadUint64();
175 auto surfaceName = data.ReadString();
176 auto type = static_cast<RSSurfaceNodeType>(data.ReadUint8());
177 RSSurfaceRenderNodeConfig config = {.id = nodeId, .name = surfaceName, .nodeType = type };
178 sptr<Surface> surface = CreateNodeAndSurface(config);
179 auto producer = surface->GetProducer();
180 reply.WriteRemoteObject(producer->AsObject());
181 break;
182 }
183 case SET_FOCUS_APP_INFO: {
184 auto token = data.ReadInterfaceToken();
185 if (token != RSIRenderServiceConnection::GetDescriptor()) {
186 ret = ERR_INVALID_STATE;
187 break;
188 }
189
190 int32_t pid = data.ReadInt32();
191 int32_t uid = data.ReadInt32();
192 std::string bundleName = data.ReadString();
193 std::string abilityName = data.ReadString();
194 int32_t status = SetFocusAppInfo(pid, uid, bundleName, abilityName);
195 reply.WriteInt32(status);
196 break;
197 }
198 case GET_DEFAULT_SCREEN_ID: {
199 auto token = data.ReadInterfaceToken();
200 if (token != RSIRenderServiceConnection::GetDescriptor()) {
201 ret = ERR_INVALID_STATE;
202 break;
203 }
204 ScreenId id = GetDefaultScreenId();
205 reply.WriteUint64(id);
206 break;
207 }
208 case GET_ALL_SCREEN_IDS: {
209 auto token = data.ReadInterfaceToken();
210 if (token != RSIRenderServiceConnection::GetDescriptor()) {
211 ret = ERR_INVALID_STATE;
212 break;
213 }
214 std::vector<ScreenId> ids = GetAllScreenIds();
215 reply.WriteUint32(ids.size());
216 for (uint32_t i = 0; i < ids.size(); i++) {
217 reply.WriteUint64(ids[i]);
218 }
219 break;
220 }
221 case CREATE_VIRTUAL_SCREEN: {
222 auto token = data.ReadInterfaceToken();
223 if (token != RSIRenderServiceConnection::GetDescriptor()) {
224 ret = ERR_INVALID_STATE;
225 break;
226 }
227
228 // read the parcel data.
229 std::string name = data.ReadString();
230 uint32_t width = data.ReadUint32();
231 uint32_t height = data.ReadUint32();
232 sptr<Surface> surface = nullptr;
233 auto remoteObject = data.ReadRemoteObject();
234 if (remoteObject != nullptr) {
235 auto bufferProducer = iface_cast<IBufferProducer>(remoteObject);
236 surface = Surface::CreateSurfaceAsProducer(bufferProducer);
237 }
238
239 ScreenId mirrorId = data.ReadUint64();
240 int32_t flags = data.ReadInt32();
241
242 ScreenId id = CreateVirtualScreen(name, width, height, surface, mirrorId, flags);
243 reply.WriteUint64(id);
244 break;
245 }
246 case SET_VIRTUAL_SCREEN_SURFACE: {
247 auto token = data.ReadInterfaceToken();
248 if (token != RSIRenderServiceConnection::GetDescriptor()) {
249 ret = ERR_INVALID_STATE;
250 break;
251 }
252
253 // read the parcel data.
254 ScreenId id = data.ReadUint64();
255 auto remoteObject = data.ReadRemoteObject();
256 if (remoteObject == nullptr) {
257 ret = ERR_NULL_OBJECT;
258 break;
259 }
260 auto bufferProducer = iface_cast<IBufferProducer>(remoteObject);
261 sptr<Surface> surface = Surface::CreateSurfaceAsProducer(bufferProducer);
262
263 int32_t status = SetVirtualScreenSurface(id, surface);
264 reply.WriteInt32(status);
265 break;
266 }
267 case REMOVE_VIRTUAL_SCREEN: {
268 auto token = data.ReadInterfaceToken();
269 if (token != RSIRenderServiceConnection::GetDescriptor()) {
270 ret = ERR_INVALID_STATE;
271 break;
272 }
273 ScreenId id = data.ReadUint64();
274 RemoveVirtualScreen(id);
275 break;
276 }
277 case SET_SCREEN_CHANGE_CALLBACK: {
278 auto token = data.ReadInterfaceToken();
279 if (token != RSIRenderServiceConnection::GetDescriptor()) {
280 ret = ERR_INVALID_STATE;
281 break;
282 }
283
284 auto remoteObject = data.ReadRemoteObject();
285 if (remoteObject == nullptr) {
286 ret = ERR_NULL_OBJECT;
287 break;
288 }
289 sptr<RSIScreenChangeCallback> cb = iface_cast<RSIScreenChangeCallback>(remoteObject);
290 int32_t status = SetScreenChangeCallback(cb);
291 reply.WriteInt32(status);
292 break;
293 }
294 case SET_SCREEN_ACTIVE_MODE: {
295 auto token = data.ReadInterfaceToken();
296 if (token != RSIRenderServiceConnection::GetDescriptor()) {
297 ret = ERR_INVALID_STATE;
298 break;
299 }
300 ScreenId id = data.ReadUint64();
301 uint32_t modeId = data.ReadUint32();
302 SetScreenActiveMode(id, modeId);
303 break;
304 }
305 case SET_VIRTUAL_SCREEN_RESOLUTION: {
306 auto token = data.ReadInterfaceToken();
307 if (token != RSIRenderServiceConnection::GetDescriptor()) {
308 ret = ERR_INVALID_STATE;
309 break;
310 }
311 ScreenId id = data.ReadUint64();
312 uint32_t width = data.ReadUint32();
313 uint32_t height = data.ReadUint32();
314 int32_t status = SetVirtualScreenResolution(id, width, height);
315 reply.WriteInt32(status);
316 break;
317 }
318 case SET_SCREEN_POWER_STATUS: {
319 auto token = data.ReadInterfaceToken();
320 if (token != RSIRenderServiceConnection::GetDescriptor()) {
321 ret = ERR_INVALID_STATE;
322 break;
323 }
324 ScreenId id = data.ReadUint64();
325 uint32_t status = data.ReadUint32();
326 SetScreenPowerStatus(id, static_cast<ScreenPowerStatus>(status));
327 break;
328 }
329 case TAKE_SURFACE_CAPTURE: {
330 NodeId id = data.ReadUint64();
331 auto remoteObject = data.ReadRemoteObject();
332 if (remoteObject == nullptr) {
333 ret = ERR_NULL_OBJECT;
334 break;
335 }
336 sptr<RSISurfaceCaptureCallback> cb = iface_cast<RSISurfaceCaptureCallback>(remoteObject);
337 float scaleX = data.ReadFloat();
338 float scaleY = data.ReadFloat();
339 TakeSurfaceCapture(id, cb, scaleX, scaleY);
340 break;
341 }
342 case REGISTER_APPLICATION_AGENT: {
343 uint32_t pid = data.ReadUint32();
344 auto remoteObject = data.ReadRemoteObject();
345 if (remoteObject == nullptr) {
346 ret = ERR_NULL_OBJECT;
347 break;
348 }
349 sptr<IApplicationAgent> app = iface_cast<IApplicationAgent>(remoteObject);
350 RegisterApplicationAgent(pid, app);
351 break;
352 }
353 case GET_VIRTUAL_SCREEN_RESOLUTION: {
354 auto token = data.ReadInterfaceToken();
355 if (token != RSIRenderServiceConnection::GetDescriptor()) {
356 ret = ERR_INVALID_STATE;
357 break;
358 }
359 ScreenId id = data.ReadUint64();
360 RSVirtualScreenResolution virtualScreenResolution = GetVirtualScreenResolution(id);
361 reply.WriteParcelable(&virtualScreenResolution);
362 break;
363 }
364 case GET_SCREEN_ACTIVE_MODE: {
365 auto token = data.ReadInterfaceToken();
366 if (token != RSIRenderServiceConnection::GetDescriptor()) {
367 ret = ERR_INVALID_STATE;
368 break;
369 }
370 ScreenId id = data.ReadUint64();
371 RSScreenModeInfo screenModeInfo = GetScreenActiveMode(id);
372 reply.WriteParcelable(&screenModeInfo);
373 break;
374 }
375 case GET_SCREEN_SUPPORTED_MODES: {
376 auto token = data.ReadInterfaceToken();
377 if (token != RSIRenderServiceConnection::GetDescriptor()) {
378 ret = ERR_INVALID_STATE;
379 break;
380 }
381 ScreenId id = data.ReadUint64();
382 std::vector<RSScreenModeInfo> screenSupportedModes = GetScreenSupportedModes(id);
383 reply.WriteUint64(static_cast<uint64_t>(screenSupportedModes.size()));
384 for (uint32_t modeIndex = 0; modeIndex < screenSupportedModes.size(); modeIndex++) {
385 reply.WriteParcelable(&screenSupportedModes[modeIndex]);
386 }
387 break;
388 }
389 case GET_SCREEN_CAPABILITY: {
390 auto token = data.ReadInterfaceToken();
391 if (token != RSIRenderServiceConnection::GetDescriptor()) {
392 ret = ERR_INVALID_STATE;
393 break;
394 }
395 ScreenId id = data.ReadUint64();
396 RSScreenCapability screenCapability = GetScreenCapability(id);
397 reply.WriteParcelable(&screenCapability);
398 break;
399 }
400 case GET_SCREEN_POWER_STATUS: {
401 auto token = data.ReadInterfaceToken();
402 if (token != RSIRenderServiceConnection::GetDescriptor()) {
403 ret = ERR_INVALID_STATE;
404 break;
405 }
406 ScreenId id = data.ReadUint64();
407 ScreenPowerStatus status = GetScreenPowerStatus(id);
408 reply.WriteUint32(static_cast<uint32_t>(status));
409 break;
410 }
411 case GET_SCREEN_DATA: {
412 auto token = data.ReadInterfaceToken();
413 if (token != RSIRenderServiceConnection::GetDescriptor()) {
414 ret = ERR_INVALID_STATE;
415 break;
416 }
417 ScreenId id = data.ReadUint64();
418 RSScreenData screenData = GetScreenData(id);
419 reply.WriteParcelable(&screenData);
420 break;
421 }
422 case EXECUTE_SYNCHRONOUS_TASK: {
423 auto token = data.ReadInterfaceToken();
424 if (token != RSIRenderServiceConnection::GetDescriptor()) {
425 ret = ERR_INVALID_STATE;
426 break;
427 }
428 auto type = data.ReadUint16();
429 auto subType = data.ReadUint16();
430 if (type != RS_NODE_SYNCHRONOUS_READ_PROPERTY) {
431 ret = ERR_INVALID_STATE;
432 break;
433 }
434 auto func = RSCommandFactory::Instance().GetUnmarshallingFunc(type, subType);
435 if (func == nullptr) {
436 ret = ERR_INVALID_STATE;
437 break;
438 }
439 auto command = static_cast<RSSyncTask*>((*func)(data));
440 if (command == nullptr) {
441 ret = ERR_INVALID_STATE;
442 break;
443 }
444 std::shared_ptr<RSSyncTask> task(command);
445 ExecuteSynchronousTask(task);
446 if (!task->Marshalling(reply)) {
447 ret = ERR_INVALID_STATE;
448 }
449 break;
450 }
451 case GET_SCREEN_BACK_LIGHT: {
452 auto token = data.ReadInterfaceToken();
453 if (token != RSIRenderServiceConnection::GetDescriptor()) {
454 ret = ERR_INVALID_STATE;
455 break;
456 }
457 ScreenId id = data.ReadUint64();
458 int32_t level = GetScreenBacklight(id);
459 reply.WriteInt32(level);
460 break;
461 }
462 case SET_SCREEN_BACK_LIGHT: {
463 auto token = data.ReadInterfaceToken();
464 if (token != RSIRenderServiceConnection::GetDescriptor()) {
465 ret = ERR_INVALID_STATE;
466 break;
467 }
468 ScreenId id = data.ReadUint64();
469 uint32_t level = data.ReadUint32();
470 SetScreenBacklight(id, level);
471 break;
472 }
473 case SET_BUFFER_AVAILABLE_LISTENER: {
474 auto token = data.ReadInterfaceToken();
475 if (token != RSIRenderServiceConnection::GetDescriptor()) {
476 ret = ERR_INVALID_STATE;
477 break;
478 }
479 NodeId id = data.ReadUint64();
480 auto remoteObject = data.ReadRemoteObject();
481 bool isFromRenderThread = data.ReadBool();
482 if (remoteObject == nullptr) {
483 ret = ERR_NULL_OBJECT;
484 break;
485 }
486 sptr<RSIBufferAvailableCallback> cb = iface_cast<RSIBufferAvailableCallback>(remoteObject);
487 RegisterBufferAvailableListener(id, cb, isFromRenderThread);
488 break;
489 }
490 case GET_SCREEN_SUPPORTED_GAMUTS: {
491 auto token = data.ReadInterfaceToken();
492 if (token != RSIRenderServiceConnection::GetDescriptor()) {
493 ret = ERR_INVALID_STATE;
494 break;
495 }
496 ScreenId id = data.ReadUint64();
497 std::vector<uint32_t> modeSend;
498 std::vector<ScreenColorGamut> mode;
499 int32_t result = GetScreenSupportedColorGamuts(id, mode);
500 reply.WriteInt32(result);
501 if (result != StatusCode::SUCCESS) {
502 break;
503 }
504 std::copy(mode.begin(), mode.end(), std::back_inserter(modeSend));
505 reply.WriteUInt32Vector(modeSend);
506 break;
507 }
508 case GET_SCREEN_SUPPORTED_METADATAKEYS: {
509 auto token = data.ReadInterfaceToken();
510 if (token != RSIRenderServiceConnection::GetDescriptor()) {
511 ret = ERR_INVALID_STATE;
512 break;
513 }
514 ScreenId id = data.ReadUint64();
515 std::vector<uint32_t> keySend;
516 std::vector<ScreenHDRMetadataKey> keys;
517 int32_t result = GetScreenSupportedMetaDataKeys(id, keys);
518 reply.WriteInt32(result);
519 if (result != StatusCode::SUCCESS) {
520 break;
521 }
522 for (auto i : keys) {
523 keySend.push_back(i);
524 }
525 reply.WriteUInt32Vector(keySend);
526 break;
527 }
528 case GET_SCREEN_GAMUT: {
529 auto token = data.ReadInterfaceToken();
530 if (token != RSIRenderServiceConnection::GetDescriptor()) {
531 ret = ERR_INVALID_STATE;
532 break;
533 }
534 ScreenId id = data.ReadUint64();
535 ScreenColorGamut mode;
536 int32_t result = GetScreenColorGamut(id, mode);
537 reply.WriteInt32(result);
538 if (result != StatusCode::SUCCESS) {
539 break;
540 }
541 reply.WriteUint32(mode);
542 break;
543 }
544 case SET_SCREEN_GAMUT: {
545 auto token = data.ReadInterfaceToken();
546 if (token != RSIRenderServiceConnection::GetDescriptor()) {
547 ret = ERR_INVALID_STATE;
548 break;
549 }
550 ScreenId id = data.ReadUint64();
551 int32_t modeIdx = data.ReadInt32();
552 int32_t result = SetScreenColorGamut(id, modeIdx);
553 reply.WriteInt32(result);
554 break;
555 }
556 case SET_SCREEN_GAMUT_MAP: {
557 auto token = data.ReadInterfaceToken();
558 if (token != RSIRenderServiceConnection::GetDescriptor()) {
559 ret = ERR_INVALID_STATE;
560 break;
561 }
562 ScreenId id = data.ReadUint64();
563 ScreenGamutMap mode = static_cast<ScreenGamutMap>(data.ReadInt32());
564 int32_t result = SetScreenGamutMap(id, mode);
565 reply.WriteInt32(result);
566 break;
567 }
568 case GET_SCREEN_GAMUT_MAP: {
569 auto token = data.ReadInterfaceToken();
570 if (token != RSIRenderServiceConnection::GetDescriptor()) {
571 ret = ERR_INVALID_STATE;
572 break;
573 }
574 ScreenId id = data.ReadUint64();
575 ScreenGamutMap mode;
576 int32_t result = GetScreenGamutMap(id, mode);
577 reply.WriteInt32(result);
578 if (result != StatusCode::SUCCESS) {
579 break;
580 }
581 reply.WriteUint32(mode);
582 break;
583 }
584 case CREATE_VSYNC_CONNECTION: {
585 std::string name = data.ReadString();
586 sptr<IVSyncConnection> conn = CreateVSyncConnection(name);
587 reply.WriteRemoteObject(conn->AsObject());
588 break;
589 }
590 case GET_SCREEN_HDR_CAPABILITY: {
591 auto token = data.ReadInterfaceToken();
592 if (token != RSIRenderServiceConnection::GetDescriptor()) {
593 ret = ERR_INVALID_STATE;
594 break;
595 }
596 ScreenId id = data.ReadUint64();
597 RSScreenHDRCapability screenHDRCapability;
598 int32_t result = GetScreenHDRCapability(id, screenHDRCapability);
599 reply.WriteInt32(result);
600 if (result != StatusCode::SUCCESS) {
601 break;
602 }
603 reply.WriteParcelable(&screenHDRCapability);
604 break;
605 }
606 case GET_SCREEN_TYPE: {
607 auto token = data.ReadInterfaceToken();
608 if (token != RSIRenderServiceConnection::GetDescriptor()) {
609 ret = ERR_INVALID_STATE;
610 break;
611 }
612 ScreenId id = data.ReadUint64();
613 RSScreenType type;
614 int32_t result = GetScreenType(id, type);
615 reply.WriteInt32(result);
616 if (result != StatusCode::SUCCESS) {
617 break;
618 }
619 reply.WriteUint32(type);
620 break;
621 }
622 case SET_SCREEN_SKIP_FRAME_INTERVAL: {
623 auto token = data.ReadInterfaceToken();
624 if (token != RSIRenderServiceConnection::GetDescriptor()) {
625 ret = ERR_INVALID_STATE;
626 break;
627 }
628 ScreenId id = data.ReadUint64();
629 uint32_t skipFrameInterval = data.ReadUint32();
630 int32_t result = SetScreenSkipFrameInterval(id, skipFrameInterval);
631 reply.WriteInt32(result);
632 break;
633 }
634 case REGISTER_OCCLUSION_CHANGE_CALLBACK: {
635 auto token = data.ReadInterfaceToken();
636 if (token != RSIRenderServiceConnection::GetDescriptor()) {
637 ret = ERR_INVALID_STATE;
638 break;
639 }
640
641 auto remoteObject = data.ReadRemoteObject();
642 if (remoteObject == nullptr) {
643 ret = ERR_NULL_OBJECT;
644 break;
645 }
646 sptr<RSIOcclusionChangeCallback> callback = iface_cast<RSIOcclusionChangeCallback>(remoteObject);
647 int32_t status = RegisterOcclusionChangeCallback(callback);
648 reply.WriteInt32(status);
649 break;
650 }
651 case UNREGISTER_OCCLUSION_CHANGE_CALLBACK: {
652 auto token = data.ReadInterfaceToken();
653 if (token != RSIRenderServiceConnection::GetDescriptor()) {
654 ret = ERR_INVALID_STATE;
655 break;
656 }
657
658 auto remoteObject = data.ReadRemoteObject();
659 if (remoteObject == nullptr) {
660 ret = ERR_NULL_OBJECT;
661 break;
662 }
663 sptr<RSIOcclusionChangeCallback> callback = iface_cast<RSIOcclusionChangeCallback>(remoteObject);
664 int32_t status = UnRegisterOcclusionChangeCallback(callback);
665 reply.WriteInt32(status);
666 break;
667 }
668 case SET_APP_WINDOW_NUM: {
669 auto token = data.ReadInterfaceToken();
670 if (token != RSIRenderServiceConnection::GetDescriptor()) {
671 ret = ERR_INVALID_STATE;
672 break;
673 }
674 uint32_t num = data.ReadUint32();
675 SetAppWindowNum(num);
676 }
677 default: {
678 ret = ERR_UNKNOWN_TRANSACTION;
679 break;
680 }
681 }
682
683 return ret;
684 }
685 } // namespace Rosen
686 } // namespace OHOS
687