1 /*
2  * Copyright (c) 2021 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 HDI_BACKEND_HDI_BACKEND_H
17 #define HDI_BACKEND_HDI_BACKEND_H
18 
19 #include <functional>
20 #include <unordered_map>
21 #include <refbase.h>
22 
23 #include "hdi_device.h"
24 #include "hdi_screen.h"
25 #include "hdi_layer.h"
26 #include "hdi_output.h"
27 #include "graphic_error.h"
28 #include "surface_type.h"
29 
30 namespace OHOS {
31 namespace Rosen {
32 
33 using OutputPtr = std::shared_ptr<HdiOutput>;
34 
35 struct PrepareCompleteParam {
36     bool needFlushFramebuffer;
37     std::vector<LayerInfoPtr> layers;
38     uint32_t screenId;
39 };
40 
41 using OnScreenHotplugFunc = std::function<void(OutputPtr &output, bool connected, void* data)>;
42 using OnPrepareCompleteFunc = std::function<void(sptr<Surface>& surface,
43                                                  const struct PrepareCompleteParam &param, void* data)>;
44 using OnScreenRefreshFunc = std::function<void(uint32_t deviceId, void* data)>;
45 
46 
47 class HdiBackend {
48 public:
49     /* for RS begin */
50     static HdiBackend* GetInstance();
51     RosenError RegScreenHotplug(OnScreenHotplugFunc func, void* data);
52     RosenError RegScreenRefresh(OnScreenRefreshFunc func, void* data);
53     RosenError RegPrepareComplete(OnPrepareCompleteFunc func, void* data);
54     RosenError RegHwcDeadListener(OnHwcDeadCallback func, void* data);
55     RosenError RegScreenVBlankIdleCallback(OnVBlankIdleCallback func, void* data);
56     void Repaint(const OutputPtr &output);
57     void ResetDevice();
58     /* for RS end */
59 
60     /* only used for mock tests */
61     RosenError SetHdiBackendDevice(HdiDevice* device);
62     void StartSample(const OutputPtr &output);
63     /* set a temporary period used only for VSyncSampler::GetHardwarePeriod interface */
64     void SetPendingMode(const OutputPtr &output, int64_t period, int64_t timestamp);
65     void SetVsyncSamplerEnabled(const OutputPtr &output, bool enabled);
66     bool GetVsyncSamplerEnabled(const OutputPtr &output);
67 private:
68     HdiBackend() = default;
69     virtual ~HdiBackend() = default;
70 
71     HdiBackend(const HdiBackend& rhs) = delete;
72     HdiBackend& operator=(const HdiBackend& rhs) = delete;
73     HdiBackend(HdiBackend&& rhs) = delete;
74     HdiBackend& operator=(HdiBackend&& rhs) = delete;
75 
76     HdiDevice *device_ = nullptr;
77     void* onHotPlugCbData_ = nullptr;
78     void* onRefreshCbData_ = nullptr;
79     void* onPrepareCompleteCbData_ = nullptr;
80     OnScreenHotplugFunc onScreenHotplugCb_ = nullptr;
81     OnScreenRefreshFunc onScreenRefreshCb_ = nullptr;
82     OnPrepareCompleteFunc onPrepareCompleteCb_ = nullptr;
83     std::unordered_map<uint32_t, OutputPtr> outputs_;
84 
85     static void OnHdiBackendHotPlugEvent(uint32_t deviceId, bool connected, void *data);
86     static void OnHdiBackendRefreshEvent(uint32_t deviceId, void *data);
87     RosenError InitDevice();
88     void OnHdiBackendConnected(uint32_t screenId, bool connected);
89     void CreateHdiOutput(uint32_t screenId);
90     void OnScreenHotplug(uint32_t screenId, bool connected);
91     void OnScreenRefresh(uint32_t deviceId);
92     void ReorderLayerInfo(std::vector<LayerInfoPtr> &newLayerInfos);
93     void OnPrepareComplete(bool needFlush, const OutputPtr &output, std::vector<LayerInfoPtr> &newLayerInfos);
94     int32_t PrepareCompleteIfNeed(const OutputPtr &output, bool needFlush);
95 };
96 } // namespace Rosen
97 } // namespace OHOS
98 
99 #endif // HDI_BACKEND_HDI_BACKEND_H