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

Commit aad4ebf3 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
Merged-In: I8417682f4ead7b550a8973d4716c627e31b07b6e
(cherry picked from commit 9370a480)
parent 57cabaca

services/surfaceflinger/CompositionEngine/Android.bp

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

    static_libs: [

        "libcompositionengine",

        "libcompositionengine",

        "libcompositionengine_mocks",

        "libcompositionengine_mocks",

        "libgui_mocks",

        "librenderengine_mocks",

        "librenderengine_mocks",

        "libgmock",

        "libgmock",

        "libgtest",

        "libgtest",

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

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




#include <cstdint>

#include <cstdint>

#include <optional>

#include <optional>

#include <string>



#include <ui/DisplayInfo.h>

#include <ui/PixelFormat.h>

#include <ui/Size.h>





#include "DisplayHardware/DisplayIdentification.h"

#include "DisplayHardware/DisplayIdentification.h"

#include "DisplayHardware/PowerAdvisor.h"

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

 * A parameter object for creating Display instances

 */

 */

struct DisplayCreationArgs {

struct DisplayCreationArgs {

    // True if this display is a virtual display

    struct Physical {

    bool isVirtual = false;

        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

    // Pixel format of the display

    std::optional<DisplayId> displayId;

    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

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

    // this display.

    // this display.

    Hwc2::PowerAdvisor* powerAdvisor = nullptr;

    Hwc2::PowerAdvisor* powerAdvisor = nullptr;



    // Debugging. Human readable name for the display.

    std::string name;

};

};





/**

/**

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

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

 * Prefer this builder over raw structure initialization.

 * Prefer this builder over raw structure initialization.

 *

 * Instead of:

 *

 *   DisplayCreationArgs{false, false, displayId}

 *

 * Prefer:

 *

 *  DisplayCreationArgsBuilder().setIsVirtual(false)

 *      .setDisplayId(displayId).build();

 */

 */

class DisplayCreationArgsBuilder {

class DisplayCreationArgsBuilder {

public:

public:

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

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





    DisplayCreationArgsBuilder& setIsVirtual(bool isVirtual) {

    DisplayCreationArgsBuilder& setPhysical(DisplayCreationArgs::Physical physical) {

        mArgs.isVirtual = isVirtual;

        mArgs.physical = physical;

        return *this;

        return *this;

    }

    }

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



        mArgs.displayId = displayId;

    DisplayCreationArgsBuilder& setPixels(ui::Size pixels) {

        mArgs.pixels = pixels;

        return *this;

        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) {

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

        mArgs.powerAdvisor = powerAdvisor;

        mArgs.powerAdvisor = powerAdvisor;

        return *this;

        return *this;

    }

    }





    DisplayCreationArgsBuilder& setName(std::string name) {

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

        return *this;

    }



private:

private:

    DisplayCreationArgs mArgs;

    DisplayCreationArgs mArgs;

};

};

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

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




#pragma once

#pragma once





#include <memory>



#include <compositionengine/Display.h>

#include <compositionengine/Display.h>

#include <compositionengine/DisplayColorProfile.h>

#include <compositionengine/DisplayCreationArgs.h>

#include <compositionengine/DisplayCreationArgs.h>

#include <compositionengine/RenderSurface.h>

#include <compositionengine/impl/Output.h>

#include <compositionengine/impl/Output.h>



#include <ui/PixelFormat.h>

#include <memory>

#include <ui/Size.h>





#include "DisplayHardware/DisplayIdentification.h"

#include "DisplayHardware/DisplayIdentification.h"

#include "DisplayHardware/HWComposer.h"

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

// actually contain the final display state.

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

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

public:

public:

    explicit Display(const compositionengine::DisplayCreationArgs&);

    virtual ~Display();

    virtual ~Display();





    // compositionengine::Output overrides

    // compositionengine::Output overrides

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

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

    bool isValid() const override;

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

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

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

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

    void setReleasedLayers(const CompositionRefreshArgs&) override;

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

    virtual void applyLayerRequestsToLayers(const LayerRequests&);





    // Internal

    // 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;

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





    // Testing

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



private:

private:

    const bool mIsVirtual;

    bool mIsVirtual = false;

    std::optional<DisplayId> mId;

    std::optional<DisplayId> mId;

    Hwc2::PowerAdvisor* const mPowerAdvisor{nullptr};

    Hwc2::PowerAdvisor* mPowerAdvisor = nullptr;

};

};





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

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

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

// 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

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

// to the base code.

// to the base code.

template <typename BaseDisplay, typename CompositionEngine, typename DisplayCreationArgs>

template <typename BaseDisplay, typename CompositionEngine>

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

std::shared_ptr<BaseDisplay> createDisplayTemplated(

                                                    const DisplayCreationArgs& args) {

        const CompositionEngine& compositionEngine,

    return createOutputTemplated<BaseDisplay>(compositionEngine, args);

        const compositionengine::DisplayCreationArgs& args) {

    auto display = createOutputTemplated<BaseDisplay>(compositionEngine);



    display->setConfiguration(args);



    return display;

}

}





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

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

services/surfaceflinger/CompositionEngine/src/Display.cpp

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

    return createDisplayTemplated<Display>(compositionEngine, args);

}

}





Display::Display(const DisplayCreationArgs& args)

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



Display::~Display() = default;

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 {

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

    return mId;

    return mId;

}

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

    return mId;

}

}





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

    mId = displayId;

}



void Display::disconnect() {

void Display::disconnect() {

    if (!mId) {

    if (!mId) {

        return;

        return;

services/surfaceflinger/CompositionEngine/tests/DisplayTest.cpp

+373 −177

File changed.

Preview size limit exceeded, changes collapsed.