Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9370a480 authored by Lloyd Pique's avatar Lloyd Pique
Browse files

SF: Start restructuring display creation 

Create the compositionengine::Display first thing, outside of
DisplayDevice, and pass it in as part of creating the DisplayDevice,
rather than creating it internal to DisplayDevice.

Also to start, move the logic to allocate a DisplayId for a HWC backed
virtual display into the CompositionEngine class.

This is a first step to moving the internal setup of the display to
CompositionEngine, and eventually eliminating DisplayDevice entirely, as
it is but a thin wrapper around the other class.

DisplayTransactionTest is adjusted so the dummy created DisplayDevices
have an appropriate compositionengine::Display.

Test: atest libsurfaceflinger_unittest libcompositionengine_test
Bug: 142831417
Change-Id: I8417682f4ead7b550a8973d4716c627e31b07b6e
parent fc874ae0

services/surfaceflinger/CompositionEngine/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -104,6 +104,7 @@ cc_test { 
    static_libs: [

        "libcompositionengine",

        "libcompositionengine_mocks",

        "libgui_mocks",

        "librenderengine_mocks",

        "libgmock",

        "libgtest",

services/surfaceflinger/CompositionEngine/include/compositionengine/DisplayCreationArgs.h

+61 −17
Original line number Diff line number Diff line
@@ -18,6 +18,11 @@ 


#include <cstdint>

#include <optional>

#include <string>



#include <ui/DisplayInfo.h>

#include <ui/PixelFormat.h>

#include <ui/Size.h>



#include "DisplayHardware/DisplayIdentification.h"

#include "DisplayHardware/PowerAdvisor.h"
@@ -30,47 +35,86 @@ class CompositionEngine; 
 * A parameter object for creating Display instances

 */

struct DisplayCreationArgs {

    // True if this display is a virtual display

    bool isVirtual = false;

    struct Physical {

        DisplayId id;

        DisplayConnectionType type;

    };



    // Required for physical displays. Gives the HWC display id for the existing

    // display along with the connection type.

    std::optional<Physical> physical;



    // Size of the display in pixels

    ui::Size pixels = ui::Size::INVALID;



    // Identifies the display to the HWC, if composition is supported by it

    std::optional<DisplayId> displayId;

    // Pixel format of the display

    ui::PixelFormat pixelFormat = static_cast<ui::PixelFormat>(PIXEL_FORMAT_UNKNOWN);



    // True if virtual displays should be created with the HWC API if possible

    bool useHwcVirtualDisplays = false;



    // True if this display should be considered secure

    bool isSecure = false;



    // Gives the initial layer stack id to be used for the display

    uint32_t layerStackId = ~0u;



    // Optional pointer to the power advisor interface, if one is needed for

    // this display.

    Hwc2::PowerAdvisor* powerAdvisor = nullptr;



    // Debugging. Human readable name for the display.

    std::string name;

};



/**

 * A helper for setting up a DisplayCreationArgs value in-line.

 * Prefer this builder over raw structure initialization.

 *

 * Instead of:

 *

 *   DisplayCreationArgs{false, false, displayId}

 *

 * Prefer:

 *

 *  DisplayCreationArgsBuilder().setIsVirtual(false)

 *      .setDisplayId(displayId).build();

 */

class DisplayCreationArgsBuilder {

public:

    DisplayCreationArgs build() { return std::move(mArgs); }



    DisplayCreationArgsBuilder& setIsVirtual(bool isVirtual) {

        mArgs.isVirtual = isVirtual;

    DisplayCreationArgsBuilder& setPhysical(DisplayCreationArgs::Physical physical) {

        mArgs.physical = physical;

        return *this;

    }

    DisplayCreationArgsBuilder& setDisplayId(std::optional<DisplayId> displayId) {

        mArgs.displayId = displayId;



    DisplayCreationArgsBuilder& setPixels(ui::Size pixels) {

        mArgs.pixels = pixels;

        return *this;

    }



    DisplayCreationArgsBuilder& setPixelFormat(ui::PixelFormat pixelFormat) {

        mArgs.pixelFormat = pixelFormat;

        return *this;

    }



    DisplayCreationArgsBuilder& setUseHwcVirtualDisplays(bool useHwcVirtualDisplays) {

        mArgs.useHwcVirtualDisplays = useHwcVirtualDisplays;

        return *this;

    }



    DisplayCreationArgsBuilder& setIsSecure(bool isSecure) {

        mArgs.isSecure = isSecure;

        return *this;

    }



    DisplayCreationArgsBuilder& setLayerStackId(uint32_t layerStackId) {

        mArgs.layerStackId = layerStackId;

        return *this;

    }



    DisplayCreationArgsBuilder& setPowerAdvisor(Hwc2::PowerAdvisor* powerAdvisor) {

        mArgs.powerAdvisor = powerAdvisor;

        return *this;

    }



    DisplayCreationArgsBuilder& setName(std::string name) {

        mArgs.name = std::move(name);

        return *this;

    }



private:

    DisplayCreationArgs mArgs;

};

services/surfaceflinger/CompositionEngine/include/compositionengine/impl/Display.h

+24 −9
Original line number Diff line number Diff line
@@ -16,11 +16,15 @@ 


#pragma once



#include <memory>



#include <compositionengine/Display.h>

#include <compositionengine/DisplayColorProfile.h>

#include <compositionengine/DisplayCreationArgs.h>

#include <compositionengine/RenderSurface.h>

#include <compositionengine/impl/Output.h>



#include <memory>

#include <ui/PixelFormat.h>

#include <ui/Size.h>



#include "DisplayHardware/DisplayIdentification.h"

#include "DisplayHardware/HWComposer.h"
@@ -36,11 +40,11 @@ namespace impl { 
// actually contain the final display state.

class Display : public compositionengine::impl::Output, public virtual compositionengine::Display {

public:

    explicit Display(const compositionengine::DisplayCreationArgs&);

    virtual ~Display();



    // compositionengine::Output overrides

    std::optional<DisplayId> getDisplayId() const override;

    bool isValid() const override;

    void dump(std::string&) const override;

    using compositionengine::impl::Output::setReleasedLayers;

    void setReleasedLayers(const CompositionRefreshArgs&) override;
@@ -73,22 +77,33 @@ public: 
    virtual void applyLayerRequestsToLayers(const LayerRequests&);



    // Internal

    virtual void setConfiguration(const compositionengine::DisplayCreationArgs&);

    virtual std::optional<DisplayId> maybeAllocateDisplayIdForVirtualDisplay(ui::Size,

                                                                             ui::PixelFormat) const;

    std::unique_ptr<compositionengine::OutputLayer> createOutputLayer(const sp<LayerFE>&) const;



    // Testing

    void setDisplayIdForTesting(std::optional<DisplayId> displayId);



private:

    const bool mIsVirtual;

    bool mIsVirtual = false;

    std::optional<DisplayId> mId;

    Hwc2::PowerAdvisor* const mPowerAdvisor{nullptr};

    Hwc2::PowerAdvisor* mPowerAdvisor = nullptr;

};



// This template factory function standardizes the implementation details of the

// final class using the types actually required by the implementation. This is

// not possible to do in the base class as those types may not even be visible

// to the base code.

template <typename BaseDisplay, typename CompositionEngine, typename DisplayCreationArgs>

std::shared_ptr<BaseDisplay> createDisplayTemplated(const CompositionEngine& compositionEngine,

                                                    const DisplayCreationArgs& args) {

    return createOutputTemplated<BaseDisplay>(compositionEngine, args);

template <typename BaseDisplay, typename CompositionEngine>

std::shared_ptr<BaseDisplay> createDisplayTemplated(

        const CompositionEngine& compositionEngine,

        const compositionengine::DisplayCreationArgs& args) {

    auto display = createOutputTemplated<BaseDisplay>(compositionEngine);



    display->setConfiguration(args);



    return display;

}



std::shared_ptr<Display> createDisplay(const compositionengine::CompositionEngine&,

services/surfaceflinger/CompositionEngine/src/Display.cpp

+32 −3
Original line number Diff line number Diff line
@@ -47,11 +47,36 @@ std::shared_ptr<Display> createDisplay( 
    return createDisplayTemplated<Display>(compositionEngine, args);

}



Display::Display(const DisplayCreationArgs& args)

      : mIsVirtual(args.isVirtual), mId(args.displayId), mPowerAdvisor(args.powerAdvisor) {}



Display::~Display() = default;



void Display::setConfiguration(const compositionengine::DisplayCreationArgs& args) {

    mIsVirtual = !args.physical;

    mId = args.physical ? std::make_optional(args.physical->id) : std::nullopt;

    mPowerAdvisor = args.powerAdvisor;



    editState().isSecure = args.isSecure;



    setLayerStackFilter(args.layerStackId,

                        args.physical ? args.physical->type == DisplayConnectionType::Internal

                                      : false);

    setName(args.name);



    if (!args.physical && args.useHwcVirtualDisplays) {

        mId = maybeAllocateDisplayIdForVirtualDisplay(args.pixels, args.pixelFormat);

    }

}



std::optional<DisplayId> Display::maybeAllocateDisplayIdForVirtualDisplay(

        ui::Size pixels, ui::PixelFormat pixelFormat) const {

    auto& hwc = getCompositionEngine().getHwComposer();

    return hwc.allocateVirtualDisplay(static_cast<uint32_t>(pixels.width),

                                      static_cast<uint32_t>(pixels.height), &pixelFormat);

}



bool Display::isValid() const {

    return Output::isValid() && mPowerAdvisor;

}



const std::optional<DisplayId>& Display::getId() const {

    return mId;

}
@@ -68,6 +93,10 @@ std::optional<DisplayId> Display::getDisplayId() const { 
    return mId;

}



void Display::setDisplayIdForTesting(std::optional<DisplayId> displayId) {

    mId = displayId;

}



void Display::disconnect() {

    if (!mId) {

        return;