You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
124 lines
6.5 KiB
124 lines
6.5 KiB
/*
|
|
* Copyright 2018 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <compositionengine/Output.h>
|
|
#include <gmock/gmock.h>
|
|
|
|
// TODO(b/129481165): remove the #pragma below and fix conversion issues
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wconversion"
|
|
#pragma clang diagnostic ignored "-Wextra"
|
|
|
|
#include "DisplayHardware/HWComposer.h"
|
|
|
|
// TODO(b/129481165): remove the #pragma below and fix conversion issues
|
|
#pragma clang diagnostic pop // ignored "-Wconversion -Wextra"
|
|
|
|
namespace android {
|
|
namespace mock {
|
|
|
|
namespace hal = android::hardware::graphics::composer::hal;
|
|
|
|
class HWComposer : public android::HWComposer {
|
|
public:
|
|
HWComposer();
|
|
~HWComposer() override;
|
|
|
|
MOCK_METHOD1(setCallback, void(HWC2::ComposerCallback*));
|
|
MOCK_CONST_METHOD3(getDisplayIdentificationData,
|
|
bool(hal::HWDisplayId, uint8_t*, DisplayIdentificationData*));
|
|
MOCK_CONST_METHOD1(hasCapability, bool(hal::Capability));
|
|
MOCK_CONST_METHOD2(hasDisplayCapability, bool(HalDisplayId, hal::DisplayCapability));
|
|
|
|
MOCK_CONST_METHOD0(getMaxVirtualDisplayCount, size_t());
|
|
MOCK_CONST_METHOD0(getMaxVirtualDisplayDimension, size_t());
|
|
MOCK_METHOD4(allocateVirtualDisplay,
|
|
bool(HalVirtualDisplayId, ui::Size, ui::PixelFormat*,
|
|
std::optional<PhysicalDisplayId>));
|
|
MOCK_METHOD2(allocatePhysicalDisplay, void(hal::HWDisplayId, PhysicalDisplayId));
|
|
MOCK_METHOD1(createLayer, std::shared_ptr<HWC2::Layer>(HalDisplayId));
|
|
MOCK_METHOD5(getDeviceCompositionChanges,
|
|
status_t(HalDisplayId, bool, std::chrono::steady_clock::time_point,
|
|
const std::shared_ptr<FenceTime>&,
|
|
std::optional<android::HWComposer::DeviceRequestedChanges>*));
|
|
MOCK_METHOD5(setClientTarget,
|
|
status_t(HalDisplayId, uint32_t, const sp<Fence>&, const sp<GraphicBuffer>&,
|
|
ui::Dataspace));
|
|
MOCK_METHOD3(presentAndGetReleaseFences,
|
|
status_t(HalDisplayId, std::chrono::steady_clock::time_point,
|
|
const std::shared_ptr<FenceTime>&));
|
|
MOCK_METHOD2(setPowerMode, status_t(PhysicalDisplayId, hal::PowerMode));
|
|
MOCK_METHOD2(setActiveConfig, status_t(HalDisplayId, size_t));
|
|
MOCK_METHOD2(setColorTransform, status_t(HalDisplayId, const mat4&));
|
|
MOCK_METHOD1(disconnectDisplay, void(HalDisplayId));
|
|
MOCK_CONST_METHOD1(hasDeviceComposition, bool(const std::optional<DisplayId>&));
|
|
MOCK_CONST_METHOD1(getPresentFence, sp<Fence>(HalDisplayId));
|
|
MOCK_CONST_METHOD2(getLayerReleaseFence, sp<Fence>(HalDisplayId, HWC2::Layer*));
|
|
MOCK_METHOD3(setOutputBuffer,
|
|
status_t(HalVirtualDisplayId, const sp<Fence>&, const sp<GraphicBuffer>&));
|
|
MOCK_METHOD1(clearReleaseFences, void(HalDisplayId));
|
|
MOCK_METHOD2(getHdrCapabilities, status_t(HalDisplayId, HdrCapabilities*));
|
|
MOCK_CONST_METHOD1(getSupportedPerFrameMetadata, int32_t(HalDisplayId));
|
|
MOCK_CONST_METHOD2(getRenderIntents,
|
|
std::vector<ui::RenderIntent>(HalDisplayId, ui::ColorMode));
|
|
MOCK_METHOD2(getDataspaceSaturationMatrix, mat4(HalDisplayId, ui::Dataspace));
|
|
MOCK_METHOD4(getDisplayedContentSamplingAttributes,
|
|
status_t(HalDisplayId, ui::PixelFormat*, ui::Dataspace*, uint8_t*));
|
|
MOCK_METHOD4(setDisplayContentSamplingEnabled, status_t(HalDisplayId, bool, uint8_t, uint64_t));
|
|
MOCK_METHOD4(getDisplayedContentSample,
|
|
status_t(HalDisplayId, uint64_t, uint64_t, DisplayedFrameStats*));
|
|
MOCK_METHOD2(setDisplayBrightness, std::future<status_t>(PhysicalDisplayId, float));
|
|
MOCK_METHOD2(getDisplayBrightnessSupport, status_t(PhysicalDisplayId, bool*));
|
|
|
|
MOCK_METHOD2(onHotplug,
|
|
std::optional<DisplayIdentificationInfo>(hal::HWDisplayId, hal::Connection));
|
|
MOCK_CONST_METHOD0(updatesDeviceProductInfoOnHotplugReconnect, bool());
|
|
MOCK_METHOD2(onVsync, bool(hal::HWDisplayId, int64_t));
|
|
MOCK_METHOD2(setVsyncEnabled, void(PhysicalDisplayId, hal::Vsync));
|
|
MOCK_CONST_METHOD1(isConnected, bool(PhysicalDisplayId));
|
|
MOCK_CONST_METHOD1(getModes, std::vector<HWComposer::HWCDisplayMode>(PhysicalDisplayId));
|
|
MOCK_CONST_METHOD1(getActiveMode, std::optional<hal::HWConfigId>(PhysicalDisplayId));
|
|
MOCK_CONST_METHOD1(getColorModes, std::vector<ui::ColorMode>(PhysicalDisplayId));
|
|
MOCK_METHOD3(setActiveColorMode, status_t(PhysicalDisplayId, ui::ColorMode, ui::RenderIntent));
|
|
MOCK_CONST_METHOD0(isUsingVrComposer, bool());
|
|
MOCK_CONST_METHOD1(getDisplayConnectionType, ui::DisplayConnectionType(PhysicalDisplayId));
|
|
MOCK_CONST_METHOD1(isVsyncPeriodSwitchSupported, bool(PhysicalDisplayId));
|
|
MOCK_CONST_METHOD2(getDisplayVsyncPeriod, status_t(PhysicalDisplayId, nsecs_t*));
|
|
MOCK_METHOD4(setActiveModeWithConstraints,
|
|
status_t(PhysicalDisplayId, hal::HWConfigId,
|
|
const hal::VsyncPeriodChangeConstraints&,
|
|
hal::VsyncPeriodChangeTimeline*));
|
|
MOCK_METHOD2(setAutoLowLatencyMode, status_t(PhysicalDisplayId, bool));
|
|
MOCK_METHOD2(getSupportedContentTypes,
|
|
status_t(PhysicalDisplayId, std::vector<hal::ContentType>*));
|
|
MOCK_METHOD2(setContentType, status_t(PhysicalDisplayId, hal::ContentType));
|
|
MOCK_CONST_METHOD0(getSupportedLayerGenericMetadata,
|
|
const std::unordered_map<std::string, bool>&());
|
|
|
|
MOCK_CONST_METHOD1(dump, void(std::string&));
|
|
MOCK_CONST_METHOD0(getComposer, android::Hwc2::Composer*());
|
|
MOCK_CONST_METHOD1(getHwcDisplayId, std::optional<hal::HWDisplayId>(int32_t));
|
|
MOCK_CONST_METHOD0(getInternalHwcDisplayId, std::optional<hal::HWDisplayId>());
|
|
MOCK_CONST_METHOD0(getExternalHwcDisplayId, std::optional<hal::HWDisplayId>());
|
|
MOCK_CONST_METHOD1(toPhysicalDisplayId, std::optional<PhysicalDisplayId>(hal::HWDisplayId));
|
|
MOCK_CONST_METHOD1(fromPhysicalDisplayId, std::optional<hal::HWDisplayId>(PhysicalDisplayId));
|
|
};
|
|
|
|
} // namespace mock
|
|
} // namespace android
|