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 "display_power_mgr_proxy.h"
17
18 #include "errors.h"
19 #include "message_option.h"
20 #include "message_parcel.h"
21 #include "display_log.h"
22 #include "display_common.h"
23 #include "display_power_mgr_ipc_interface_code.h"
24
25 namespace OHOS {
26 namespace DisplayPowerMgr {
SetDisplayState(uint32_t id,DisplayState state,uint32_t reason)27 bool DisplayPowerMgrProxy::SetDisplayState(uint32_t id, DisplayState state, uint32_t reason)
28 {
29 sptr<IRemoteObject> remote = Remote();
30 RETURN_IF_WITH_RET(remote == nullptr, false);
31
32 bool result = false;
33 MessageParcel data;
34 MessageParcel reply;
35 MessageOption option;
36
37 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
38 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
39 return result;
40 }
41
42 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, id, false);
43 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, static_cast<uint32_t>(state), false);
44 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, reason, false);
45
46 int ret = remote->SendRequest(
47 static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_DISPLAY_STATE),
48 data, reply, option);
49 if (ret != ERR_OK) {
50 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
51 return result;
52 }
53
54 if (!reply.ReadBool(result)) {
55 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
56 return result;
57 }
58
59 return result;
60 }
61
GetDisplayState(uint32_t id)62 DisplayState DisplayPowerMgrProxy::GetDisplayState(uint32_t id)
63 {
64 sptr<IRemoteObject> remote = Remote();
65 RETURN_IF_WITH_RET(remote == nullptr, DisplayState::DISPLAY_UNKNOWN);
66
67 uint32_t result = 0;
68 MessageParcel data;
69 MessageParcel reply;
70 MessageOption option;
71
72 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
73 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
74 return DisplayState::DISPLAY_UNKNOWN;
75 }
76
77 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, id, DisplayState::DISPLAY_UNKNOWN);
78
79 int ret = remote->SendRequest(
80 static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_DISPLAY_STATE),
81 data, reply, option);
82 if (ret != ERR_OK) {
83 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
84 return DisplayState::DISPLAY_UNKNOWN;
85 }
86
87 if (!reply.ReadUint32(result)) {
88 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
89 return DisplayState::DISPLAY_UNKNOWN;
90 }
91
92 return static_cast<DisplayState>(result);
93 }
94
GetDisplayIds()95 std::vector<uint32_t> DisplayPowerMgrProxy::GetDisplayIds()
96 {
97 sptr<IRemoteObject> remote = Remote();
98 std::vector<uint32_t> result;
99
100 RETURN_IF_WITH_RET(remote == nullptr, result);
101
102 uint32_t count = 0;
103 MessageParcel data;
104 MessageParcel reply;
105 MessageOption option;
106
107 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
108 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
109 return result;
110 }
111
112 int ret = remote->SendRequest(
113 static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_DISPLAY_IDS),
114 data, reply, option);
115 if (ret != ERR_OK) {
116 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
117 return result;
118 }
119
120 if (!reply.ReadUint32(count)) {
121 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
122 return result;
123 }
124
125 for (uint32_t i = 0; i < count; i++) {
126 uint32_t value;
127 if (reply.ReadUint32(value)) {
128 result.push_back(value);
129 } else {
130 DISPLAY_HILOGE(COMP_FWK, "read value fail: %{public}d", i);
131 }
132 }
133
134 return result;
135 }
136
GetMainDisplayId()137 uint32_t DisplayPowerMgrProxy::GetMainDisplayId()
138 {
139 sptr<IRemoteObject> remote = Remote();
140 uint32_t result = 0;
141
142 RETURN_IF_WITH_RET(remote == nullptr, result);
143
144 MessageParcel data;
145 MessageParcel reply;
146 MessageOption option;
147
148 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
149 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
150 return result;
151 }
152
153 int ret = remote->SendRequest(
154 static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_MAIN_DISPLAY_ID),
155 data, reply, option);
156 if (ret != ERR_OK) {
157 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
158 return result;
159 }
160
161 if (!reply.ReadUint32(result)) {
162 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
163 return result;
164 }
165
166 return result;
167 }
168
SetBrightness(uint32_t value,uint32_t displayId,bool continuous)169 bool DisplayPowerMgrProxy::SetBrightness(uint32_t value, uint32_t displayId, bool continuous)
170 {
171 sptr<IRemoteObject> remote = Remote();
172 RETURN_IF_WITH_RET(remote == nullptr, false);
173
174 bool result = false;
175 MessageParcel data;
176 MessageParcel reply;
177 MessageOption option;
178
179 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
180 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
181 return result;
182 }
183
184 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, value, false);
185 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, false);
186 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Bool, continuous, false);
187
188 int ret = remote->SendRequest(
189 static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_BRIGHTNESS),
190 data, reply, option);
191 if (ret != ERR_OK) {
192 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
193 return result;
194 }
195
196 if (!reply.ReadBool(result)) {
197 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
198 return result;
199 }
200 int32_t error;
201 RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, result);
202 lastError_ = static_cast<DisplayErrors>(error);
203
204 return result;
205 }
206
SetMaxBrightness(double value,uint32_t enterTestMode)207 bool DisplayPowerMgrProxy::SetMaxBrightness(double value, uint32_t enterTestMode)
208 {
209 sptr<IRemoteObject> remote = Remote();
210 RETURN_IF_WITH_RET(remote == nullptr, false);
211
212 bool result = false;
213 MessageParcel data;
214 MessageParcel reply;
215 MessageOption option;
216
217 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
218 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
219 return result;
220 }
221
222 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Double, value, false);
223 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, enterTestMode, false);
224
225 int ret = remote->SendRequest(
226 static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_MAX_BRIGHTNESS),
227 data, reply, option);
228 if (ret != ERR_OK) {
229 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
230 return result;
231 }
232
233 if (!reply.ReadBool(result)) {
234 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
235 return result;
236 }
237 int32_t error;
238 RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, result);
239 lastError_ = static_cast<DisplayErrors>(error);
240 return result;
241 }
242
SetMaxBrightnessNit(uint32_t maxNit,uint32_t enterTestMode)243 bool DisplayPowerMgrProxy::SetMaxBrightnessNit(uint32_t maxNit, uint32_t enterTestMode)
244 {
245 sptr<IRemoteObject> remote = Remote();
246 RETURN_IF_WITH_RET(remote == nullptr, false);
247
248 bool result = false;
249 MessageParcel data;
250 MessageParcel reply;
251 MessageOption option;
252
253 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
254 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
255 return result;
256 }
257
258 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, maxNit, false);
259 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, enterTestMode, false);
260
261 int ret = remote->SendRequest(
262 static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_MAX_BRIGHTNESS_NIT),
263 data, reply, option);
264 if (ret != ERR_OK) {
265 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
266 return result;
267 }
268
269 if (!reply.ReadBool(result)) {
270 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
271 return result;
272 }
273 int32_t error;
274 RETURN_IF_READ_PARCEL_FAILED_WITH_RET(reply, Int32, error, result);
275 lastError_ = static_cast<DisplayErrors>(error);
276
277 return result;
278 }
279
DiscountBrightness(double discount,uint32_t displayId)280 bool DisplayPowerMgrProxy::DiscountBrightness(double discount, uint32_t displayId)
281 {
282 sptr<IRemoteObject> remote = Remote();
283 RETURN_IF_WITH_RET(remote == nullptr, false);
284
285 bool result = false;
286 MessageParcel data;
287 MessageParcel reply;
288 MessageOption option;
289
290 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
291 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
292 return result;
293 }
294
295 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Double, discount, false);
296 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, false);
297
298 int ret = remote->SendRequest(
299 static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::DISCOUNT_BRIGHTNESS),
300 data, reply, option);
301 if (ret != ERR_OK) {
302 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
303 return false;
304 }
305
306 if (!reply.ReadBool(result)) {
307 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
308 return false;
309 }
310
311 return result;
312 }
313
OverrideBrightness(uint32_t value,uint32_t displayId,uint32_t duration)314 bool DisplayPowerMgrProxy::OverrideBrightness(uint32_t value, uint32_t displayId, uint32_t duration)
315 {
316 sptr<IRemoteObject> remote = Remote();
317 RETURN_IF_WITH_RET(remote == nullptr, false);
318
319 bool result = false;
320 MessageParcel data;
321 MessageParcel reply;
322 MessageOption option;
323
324 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
325 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
326 return result;
327 }
328
329 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, value, false);
330 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, false);
331 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, duration, false);
332
333 int ret = remote->SendRequest(
334 static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::OVERRIDE_BRIGHTNESS),
335 data, reply, option);
336 if (ret != ERR_OK) {
337 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
338 return result;
339 }
340
341 if (!reply.ReadBool(result)) {
342 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
343 return result;
344 }
345
346 return result;
347 }
348
OverrideDisplayOffDelay(uint32_t delayMs)349 bool DisplayPowerMgrProxy::OverrideDisplayOffDelay(uint32_t delayMs)
350 {
351 sptr<IRemoteObject> remote = Remote();
352 RETURN_IF_WITH_RET(remote == nullptr, false);
353
354 bool result = false;
355 MessageParcel data;
356 MessageParcel reply;
357 MessageOption option;
358
359 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
360 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
361 return result;
362 }
363
364 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, delayMs, false);
365
366 int ret = remote->SendRequest(
367 static_cast<int32_t>(PowerMgr::DisplayPowerMgrInterfaceCode::OVERRIDE_DISPLAY_OFF_DELAY),
368 data, reply, option);
369 if (ret != ERR_OK) {
370 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
371 return result;
372 }
373
374 if (!reply.ReadBool(result)) {
375 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
376 return result;
377 }
378
379 return result;
380 }
381
RestoreBrightness(uint32_t displayId,uint32_t duration)382 bool DisplayPowerMgrProxy::RestoreBrightness(uint32_t displayId, uint32_t duration)
383 {
384 sptr<IRemoteObject> remote = Remote();
385 uint32_t result = 0;
386
387 RETURN_IF_WITH_RET(remote == nullptr, result);
388
389 MessageParcel data;
390 MessageParcel reply;
391 MessageOption option;
392
393 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
394 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
395 return result;
396 }
397
398 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, false);
399 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, duration, false);
400
401 int ret = remote->SendRequest(
402 static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::RESTORE_BRIGHTNESS),
403 data, reply, option);
404 if (ret != ERR_OK) {
405 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
406 return result;
407 }
408
409 if (!reply.ReadUint32(result)) {
410 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
411 return result;
412 }
413
414 return result;
415 }
416
GetBrightness(uint32_t displayId)417 uint32_t DisplayPowerMgrProxy::GetBrightness(uint32_t displayId)
418 {
419 sptr<IRemoteObject> remote = Remote();
420 uint32_t result = 0;
421
422 RETURN_IF_WITH_RET(remote == nullptr, result);
423
424 MessageParcel data;
425 MessageParcel reply;
426 MessageOption option;
427
428 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
429 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
430 return result;
431 }
432
433 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, false);
434
435 int ret = remote->SendRequest(static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_BRIGHTNESS),
436 data, reply, option);
437 if (ret != ERR_OK) {
438 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
439 return result;
440 }
441
442 if (!reply.ReadUint32(result)) {
443 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
444 return result;
445 }
446
447 return result;
448 }
449
GetDefaultBrightness()450 uint32_t DisplayPowerMgrProxy::GetDefaultBrightness()
451 {
452 sptr<IRemoteObject> remote = Remote();
453 uint32_t result = 0;
454
455 RETURN_IF_WITH_RET(remote == nullptr, result);
456
457 MessageParcel data;
458 MessageParcel reply;
459 MessageOption option;
460
461 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
462 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
463 return result;
464 }
465
466 int ret = remote->SendRequest(
467 static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_DEFAULT_BRIGHTNESS),
468 data, reply, option);
469 if (ret != ERR_OK) {
470 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
471 return result;
472 }
473
474 if (!reply.ReadUint32(result)) {
475 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
476 return result;
477 }
478
479 return result;
480 }
481
GetMaxBrightness()482 uint32_t DisplayPowerMgrProxy::GetMaxBrightness()
483 {
484 sptr<IRemoteObject> remote = Remote();
485 uint32_t result = 0;
486
487 RETURN_IF_WITH_RET(remote == nullptr, result);
488
489 MessageParcel data;
490 MessageParcel reply;
491 MessageOption option;
492
493 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
494 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
495 return result;
496 }
497
498 int ret = remote->SendRequest(
499 static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_MAX_BRIGHTNESS),
500 data, reply, option);
501 if (ret != ERR_OK) {
502 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
503 return result;
504 }
505
506 if (!reply.ReadUint32(result)) {
507 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
508 return result;
509 }
510
511 return result;
512 }
513
GetMinBrightness()514 uint32_t DisplayPowerMgrProxy::GetMinBrightness()
515 {
516 sptr<IRemoteObject> remote = Remote();
517 uint32_t result = 0;
518
519 RETURN_IF_WITH_RET(remote == nullptr, result);
520
521 MessageParcel data;
522 MessageParcel reply;
523 MessageOption option;
524
525 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
526 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
527 return result;
528 }
529
530 int ret = remote->SendRequest(
531 static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_MIN_BRIGHTNESS),
532 data, reply, option);
533 if (ret != ERR_OK) {
534 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
535 return result;
536 }
537
538 if (!reply.ReadUint32(result)) {
539 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
540 return result;
541 }
542
543 return result;
544 }
545
AdjustBrightness(uint32_t id,int32_t value,uint32_t duration)546 bool DisplayPowerMgrProxy::AdjustBrightness(uint32_t id, int32_t value, uint32_t duration)
547 {
548 sptr<IRemoteObject> remote = Remote();
549 RETURN_IF_WITH_RET(remote == nullptr, false);
550
551 bool result = false;
552 MessageParcel data;
553 MessageParcel reply;
554 MessageOption option;
555
556 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
557 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
558 return result;
559 }
560
561 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, id, false);
562 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Int32, value, false);
563 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Int32, duration, false);
564
565 int ret = remote->SendRequest(
566 static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::ADJUST_BRIGHTNESS),
567 data, reply, option);
568 if (ret != ERR_OK) {
569 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
570 return result;
571 }
572
573 if (!reply.ReadBool(result)) {
574 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
575 return result;
576 }
577
578 return result;
579 }
580
AutoAdjustBrightness(bool enable)581 bool DisplayPowerMgrProxy::AutoAdjustBrightness(bool enable)
582 {
583 sptr<IRemoteObject> remote = Remote();
584 RETURN_IF_WITH_RET(remote == nullptr, false);
585
586 bool result = false;
587 MessageParcel data;
588 MessageParcel reply;
589 MessageOption option;
590
591 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
592 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
593 return result;
594 }
595
596 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Bool, enable, false);
597
598 int ret = remote->SendRequest(
599 static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::AUTO_ADJUST_BRIGHTNESS),
600 data, reply, option);
601 if (ret != ERR_OK) {
602 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
603 return result;
604 }
605
606 if (!reply.ReadBool(result)) {
607 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
608 return result;
609 }
610
611 return result;
612 }
613
IsAutoAdjustBrightness()614 bool DisplayPowerMgrProxy::IsAutoAdjustBrightness()
615 {
616 sptr<IRemoteObject> remote = Remote();
617 RETURN_IF_WITH_RET(remote == nullptr, false);
618
619 bool result = false;
620 MessageParcel data;
621 MessageParcel reply;
622 MessageOption option;
623
624 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
625 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
626 return result;
627 }
628
629 int ret = remote->SendRequest(
630 static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::IS_AUTO_ADJUST_BRIGHTNESS),
631 data, reply, option);
632 if (ret != ERR_OK) {
633 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
634 return result;
635 }
636
637 if (!reply.ReadBool(result)) {
638 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
639 return result;
640 }
641
642 return result;
643 }
644
RegisterCallback(sptr<IDisplayPowerCallback> callback)645 bool DisplayPowerMgrProxy::RegisterCallback(sptr<IDisplayPowerCallback> callback)
646 {
647 sptr<IRemoteObject> remote = Remote();
648 RETURN_IF_WITH_RET(remote == nullptr, false);
649
650 bool result = false;
651 MessageParcel data;
652 MessageParcel reply;
653 MessageOption option;
654
655 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
656 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
657 return result;
658 }
659
660 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, RemoteObject, callback->AsObject(), false);
661
662 int ret = remote->SendRequest(
663 static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::REGISTER_CALLBACK),
664 data, reply, option);
665 if (ret != ERR_OK) {
666 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
667 return result;
668 }
669
670 if (!reply.ReadBool(result)) {
671 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
672 return result;
673 }
674
675 return result;
676 }
677
BoostBrightness(int32_t timeoutMs,uint32_t displayId)678 bool DisplayPowerMgrProxy::BoostBrightness(int32_t timeoutMs, uint32_t displayId)
679 {
680 sptr<IRemoteObject> remote = Remote();
681 RETURN_IF_WITH_RET(remote == nullptr, false);
682
683 bool result = false;
684 MessageParcel data;
685 MessageParcel reply;
686 MessageOption option;
687
688 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
689 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
690 return result;
691 }
692
693 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Int32, timeoutMs, false);
694 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, false);
695
696 int ret = remote->SendRequest(
697 static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::BOOST_BRIGHTNESS),
698 data, reply, option);
699 if (ret != ERR_OK) {
700 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
701 return result;
702 }
703
704 if (!reply.ReadBool(result)) {
705 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
706 return result;
707 }
708
709 return result;
710 }
711
CancelBoostBrightness(uint32_t displayId)712 bool DisplayPowerMgrProxy::CancelBoostBrightness(uint32_t displayId)
713 {
714 sptr<IRemoteObject> remote = Remote();
715 RETURN_IF_WITH_RET(remote == nullptr, false);
716
717 bool result = false;
718 MessageParcel data;
719 MessageParcel reply;
720 MessageOption option;
721
722 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
723 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
724 return result;
725 }
726 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, false);
727
728 int ret = remote->SendRequest(
729 static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::CANCEL_BOOST_BRIGHTNESS),
730 data, reply, option);
731 if (ret != ERR_OK) {
732 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
733 return result;
734 }
735
736 if (!reply.ReadBool(result)) {
737 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
738 return result;
739 }
740
741 return result;
742 }
743
GetDeviceBrightness(uint32_t displayId)744 uint32_t DisplayPowerMgrProxy::GetDeviceBrightness(uint32_t displayId)
745 {
746 sptr<IRemoteObject> remote = Remote();
747 uint32_t result = 0;
748
749 RETURN_IF_WITH_RET(remote == nullptr, result);
750
751 MessageParcel data;
752 MessageParcel reply;
753 MessageOption option;
754
755 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
756 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
757 return result;
758 }
759
760 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, false);
761
762 int ret = remote->SendRequest(
763 static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::GET_DEVICE_BRIGHTNESS),
764 data, reply, option);
765 if (ret != ERR_OK) {
766 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
767 return result;
768 }
769
770 if (!reply.ReadUint32(result)) {
771 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
772 return result;
773 }
774
775 return result;
776 }
777
SetCoordinated(bool coordinated,uint32_t displayId)778 bool DisplayPowerMgrProxy::SetCoordinated(bool coordinated, uint32_t displayId)
779 {
780 sptr<IRemoteObject> remote = Remote();
781 RETURN_IF_WITH_RET(remote == nullptr, false);
782
783 bool result = false;
784 MessageParcel data;
785 MessageParcel reply;
786 MessageOption option;
787
788 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
789 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
790 return result;
791 }
792
793 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Bool, coordinated, false);
794 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Uint32, displayId, false);
795
796 int ret = remote->SendRequest(
797 static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_COORDINATED),
798 data, reply, option);
799 if (ret != ERR_OK) {
800 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
801 return result;
802 }
803
804 if (!reply.ReadBool(result)) {
805 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
806 return result;
807 }
808
809 return result;
810 }
811
SetLightBrightnessThreshold(std::vector<int32_t> threshold,sptr<IDisplayBrightnessCallback> callback)812 uint32_t DisplayPowerMgrProxy::SetLightBrightnessThreshold(
813 std::vector<int32_t> threshold, sptr<IDisplayBrightnessCallback> callback)
814 {
815 sptr<IRemoteObject> remote = Remote();
816 uint32_t result = 0;
817 RETURN_IF_WITH_RET(remote == nullptr, result);
818
819 MessageParcel data;
820 MessageParcel reply;
821 MessageOption option;
822
823 if (!data.WriteInterfaceToken(DisplayPowerMgrProxy::GetDescriptor())) {
824 DISPLAY_HILOGE(COMP_FWK, "write descriptor failed!");
825 return result;
826 }
827
828 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, Int32Vector, threshold, result);
829 RETURN_IF_WRITE_PARCEL_FAILED_WITH_RET(data, RemoteObject, callback->AsObject(), result);
830
831 int ret = remote->SendRequest(
832 static_cast<int>(PowerMgr::DisplayPowerMgrInterfaceCode::SET_APS_LIGHT_AND_BRIGHTNESS_THRESOLD), data, reply,
833 option);
834 if (ret != ERR_OK) {
835 DISPLAY_HILOGE(COMP_FWK, "SendRequest is failed, error code: %d", ret);
836 return result;
837 }
838
839 if (!reply.ReadUint32(result)) {
840 DISPLAY_HILOGE(COMP_FWK, "Readback fail!");
841 return result;
842 }
843
844 return result;
845 }
846
GetError()847 DisplayErrors DisplayPowerMgrProxy::GetError()
848 {
849 return lastError_;
850 }
851 } // namespace DisplayPowerMgr
852 } // namespace OHOS
853