FakeComposerClient.h revision 41b98d41f9f4e94a1a9a31960a317649cbec3b09 
1/*
2 * Copyright 2017 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#pragma once
18
19#include "ComposerClient.h"
20#include "RenderState.h"
21
22#include <utils/Condition.h>
23
24#include <chrono>
25
26using namespace android::hardware::graphics::composer::V2_1;
27using namespace android::hardware::graphics::composer::V2_1::implementation;
28using namespace android::hardware;
29using namespace std::chrono_literals;
30
31namespace {
32class LayerImpl;
33class Frame;
34class DelayedEventGenerator;
35} // namespace
36
37namespace android {
38class SurfaceComposerClient;
39} // namespace android
40
41namespace sftest {
42
43class FakeComposerClient : public ComposerBase {
44public:
45    FakeComposerClient();
46    virtual ~FakeComposerClient();
47
48    bool hasCapability(hwc2_capability_t capability) override;
49
50    void removeClient() override;
51    void enableCallback(bool enable) override;
52    uint32_t getMaxVirtualDisplayCount() override;
53    Error createVirtualDisplay(uint32_t width, uint32_t height, PixelFormat* format,
54                               Display* outDisplay) override;
55    Error destroyVirtualDisplay(Display display) override;
56    Error createLayer(Display display, Layer* outLayer) override;
57    Error destroyLayer(Display display, Layer layer) override;
58
59    Error getActiveConfig(Display display, Config* outConfig) override;
60    Error getClientTargetSupport(Display display, uint32_t width, uint32_t height,
61                                 PixelFormat format, Dataspace dataspace) override;
62    Error getColorModes(Display display, hidl_vec<ColorMode>* outModes) override;
63    Error getDisplayAttribute(Display display, Config config, IComposerClient::Attribute attribute,
64                              int32_t* outValue) override;
65    Error getDisplayConfigs(Display display, hidl_vec<Config>* outConfigs) override;
66    Error getDisplayName(Display display, hidl_string* outName) override;
67    Error getDisplayType(Display display, IComposerClient::DisplayType* outType) override;
68    Error getDozeSupport(Display display, bool* outSupport) override;
69    Error getHdrCapabilities(Display display, hidl_vec<Hdr>* outTypes, float* outMaxLuminance,
70                             float* outMaxAverageLuminance, float* outMinLuminance) override;
71
72    Error setActiveConfig(Display display, Config config) override;
73    Error setColorMode(Display display, ColorMode mode) override;
74    Error setPowerMode(Display display, IComposerClient::PowerMode mode) override;
75    Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled) override;
76
77    Error setColorTransform(Display display, const float* matrix, int32_t hint) override;
78    Error setClientTarget(Display display, buffer_handle_t target, int32_t acquireFence,
79                          int32_t dataspace, const std::vector<hwc_rect_t>& damage) override;
80    Error setOutputBuffer(Display display, buffer_handle_t buffer, int32_t releaseFence) override;
81    Error validateDisplay(Display display, std::vector<Layer>* outChangedLayers,
82                          std::vector<IComposerClient::Composition>* outCompositionTypes,
83                          uint32_t* outDisplayRequestMask, std::vector<Layer>* outRequestedLayers,
84                          std::vector<uint32_t>* outRequestMasks) override;
85    Error acceptDisplayChanges(Display display) override;
86    Error presentDisplay(Display display, int32_t* outPresentFence, std::vector<Layer>* outLayers,
87                         std::vector<int32_t>* outReleaseFences) override;
88
89    Error setLayerCursorPosition(Display display, Layer layer, int32_t x, int32_t y) override;
90    Error setLayerBuffer(Display display, Layer layer, buffer_handle_t buffer,
91                         int32_t acquireFence) override;
92    Error setLayerSurfaceDamage(Display display, Layer layer,
93                                const std::vector<hwc_rect_t>& damage) override;
94    Error setLayerBlendMode(Display display, Layer layer, int32_t mode) override;
95    Error setLayerColor(Display display, Layer layer, IComposerClient::Color color) override;
96    Error setLayerCompositionType(Display display, Layer layer, int32_t type) override;
97    Error setLayerDataspace(Display display, Layer layer, int32_t dataspace) override;
98    Error setLayerDisplayFrame(Display display, Layer layer, const hwc_rect_t& frame) override;
99    Error setLayerPlaneAlpha(Display display, Layer layer, float alpha) override;
100    Error setLayerSidebandStream(Display display, Layer layer, buffer_handle_t stream) override;
101    Error setLayerSourceCrop(Display display, Layer layer, const hwc_frect_t& crop) override;
102    Error setLayerTransform(Display display, Layer layer, int32_t transform) override;
103    Error setLayerVisibleRegion(Display display, Layer layer,
104                                const std::vector<hwc_rect_t>& visible) override;
105    Error setLayerZOrder(Display display, Layer layer, uint32_t z) override;
106
107    void setClient(ComposerClient* client);
108
109    void requestVSync(uint64_t vsyncTime = 0);
110    // We don't want tests hanging, so always use a timeout. Remember
111    // to always check the number of frames with test ASSERT_!
112    // Wait until next frame is rendered after requesting vsync.
113    void runVSyncAndWait(std::chrono::nanoseconds maxWait = 100ms);
114    void runVSyncAfter(std::chrono::nanoseconds wait);
115
116    int getFrameCount() const;
117    // We don't want tests hanging, so always use a timeout. Remember
118    // to always check the number of frames with test ASSERT_!
119    void waitUntilFrame(int targetFrame, std::chrono::nanoseconds maxWait = 100ms) const;
120    std::vector<RenderState> getFrameRects(int frame) const;
121    std::vector<RenderState> getLatestFrame() const;
122    void clearFrames();
123
124    void onSurfaceFlingerStart();
125    void onSurfaceFlingerStop();
126
127    int getLayerCount() const;
128    Layer getLayer(size_t index) const;
129
130    void hotplugDisplay(Display display, IComposerCallback::Connection state);
131
132private:
133    LayerImpl& getLayerImpl(Layer handle);
134
135    bool mCallbacksOn;
136    ComposerClient* mClient;
137    Config mCurrentConfig;
138    bool mVsyncEnabled;
139    std::vector<std::unique_ptr<LayerImpl>> mLayers;
140    std::vector<std::unique_ptr<Frame>> mFrames;
141    // Using a pointer to hide the implementation into the CPP file.
142    std::unique_ptr<DelayedEventGenerator> mDelayedEventGenerator;
143    android::sp<android::SurfaceComposerClient> mSurfaceComposer; // For VSync injections
144    mutable android::Mutex mStateMutex;
145    mutable android::Condition mFramesAvailable;
146};
147
148} // namespace sftest
149