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

Commit 24f3bfe3 authored by Lloyd Pique's avatar Lloyd Pique
Browse files

SF: Set up a default factory implementation 

The previous factory implementation was effectively private with no
ability to reuse all or part of the implementation elsewhere.

Move the implementation to a new SurfaceFlingerFactoryDefault class,
and have the created implementation derive from it

This will make it easier to add new defaults creator functions without
requiring other implementations be adjusted when they do not care about
the actual type created.

Test: atest libsurfaceflinger_unittest
Test: go/wm_smoke
Bug: None
Change-Id: I6724cbf2e9169116498b0d713a695a27a55338a9
parent adbb90ba

services/surfaceflinger/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -168,6 +168,7 @@ filegroup { 
        "Scheduler/VSyncModulator.cpp",

        "StartPropertySetThread.cpp",

        "SurfaceFlinger.cpp",

        "SurfaceFlingerDefaultFactory.cpp",

        "SurfaceInterceptor.cpp",

        "SurfaceTracing.cpp",

        "TransactionCompletedThread.cpp",

services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp

0 → 100644
+120 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2019 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.

 */



#include <compositionengine/impl/CompositionEngine.h>

#include <ui/GraphicBuffer.h>



#include "BufferQueueLayer.h"

#include "BufferStateLayer.h"

#include "ColorLayer.h"

#include "ContainerLayer.h"

#include "DisplayDevice.h"

#include "Layer.h"

#include "NativeWindowSurface.h"

#include "StartPropertySetThread.h"

#include "SurfaceFlingerDefaultFactory.h"

#include "SurfaceInterceptor.h"



#include "DisplayHardware/ComposerHal.h"

#include "Scheduler/DispSync.h"

#include "Scheduler/EventControlThread.h"

#include "Scheduler/MessageQueue.h"

#include "Scheduler/PhaseOffsets.h"

#include "Scheduler/Scheduler.h"



namespace android::surfaceflinger {



DefaultFactory::~DefaultFactory() = default;



std::unique_ptr<DispSync> DefaultFactory::createDispSync(const char* name, bool hasSyncFramework) {

    return std::make_unique<android::impl::DispSync>(name, hasSyncFramework);

}



std::unique_ptr<EventControlThread> DefaultFactory::createEventControlThread(

        SetVSyncEnabled setVSyncEnabled) {

    return std::make_unique<android::impl::EventControlThread>(std::move(setVSyncEnabled));

}



std::unique_ptr<HWComposer> DefaultFactory::createHWComposer(const std::string& serviceName) {

    return std::make_unique<android::impl::HWComposer>(

            std::make_unique<Hwc2::impl::Composer>(serviceName));

}



std::unique_ptr<MessageQueue> DefaultFactory::createMessageQueue() {

    return std::make_unique<android::impl::MessageQueue>();

}



std::unique_ptr<scheduler::PhaseOffsets> DefaultFactory::createPhaseOffsets() {

    return std::make_unique<scheduler::impl::PhaseOffsets>();

}



std::unique_ptr<Scheduler> DefaultFactory::createScheduler(

        SetVSyncEnabled setVSyncEnabled, const scheduler::RefreshRateConfigs& configs) {

    return std::make_unique<Scheduler>(std::move(setVSyncEnabled), configs);

}



std::unique_ptr<SurfaceInterceptor> DefaultFactory::createSurfaceInterceptor(

        SurfaceFlinger* flinger) {

    return std::make_unique<android::impl::SurfaceInterceptor>(flinger);

}



sp<StartPropertySetThread> DefaultFactory::createStartPropertySetThread(

        bool timestampPropertyValue) {

    return new StartPropertySetThread(timestampPropertyValue);

}



sp<DisplayDevice> DefaultFactory::createDisplayDevice(DisplayDeviceCreationArgs&& creationArgs) {

    return new DisplayDevice(std::move(creationArgs));

}



sp<GraphicBuffer> DefaultFactory::createGraphicBuffer(uint32_t width, uint32_t height,

                                                      PixelFormat format, uint32_t layerCount,

                                                      uint64_t usage, std::string requestorName) {

    return new GraphicBuffer(width, height, format, layerCount, usage, requestorName);

}



void DefaultFactory::createBufferQueue(sp<IGraphicBufferProducer>* outProducer,

                                       sp<IGraphicBufferConsumer>* outConsumer,

                                       bool consumerIsSurfaceFlinger) {

    BufferQueue::createBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);

}



std::unique_ptr<surfaceflinger::NativeWindowSurface> DefaultFactory::createNativeWindowSurface(

        const sp<IGraphicBufferProducer>& producer) {

    return surfaceflinger::impl::createNativeWindowSurface(producer);

}



std::unique_ptr<compositionengine::CompositionEngine> DefaultFactory::createCompositionEngine() {

    return compositionengine::impl::createCompositionEngine();

}



sp<ContainerLayer> DefaultFactory::createContainerLayer(const LayerCreationArgs& args) {

    return new ContainerLayer(args);

}



sp<BufferQueueLayer> DefaultFactory::createBufferQueueLayer(const LayerCreationArgs& args) {

    return new BufferQueueLayer(args);

}



sp<BufferStateLayer> DefaultFactory::createBufferStateLayer(const LayerCreationArgs& args) {

    return new BufferStateLayer(args);

}



sp<ColorLayer> DefaultFactory::createColorLayer(const LayerCreationArgs& args) {

    return new ColorLayer(args);

}



} // namespace android::surfaceflinger

services/surfaceflinger/SurfaceFlingerDefaultFactory.h

0 → 100644
+54 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2019 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 "SurfaceFlingerFactory.h"



namespace android::surfaceflinger {



// A default implementation of the factory which creates the standard

// implementation types for each interface.

class DefaultFactory : public surfaceflinger::Factory {

public:

    virtual ~DefaultFactory();



    std::unique_ptr<DispSync> createDispSync(const char* name, bool hasSyncFramework) override;

    std::unique_ptr<EventControlThread> createEventControlThread(SetVSyncEnabled) override;

    std::unique_ptr<HWComposer> createHWComposer(const std::string& serviceName) override;

    std::unique_ptr<MessageQueue> createMessageQueue() override;

    std::unique_ptr<scheduler::PhaseOffsets> createPhaseOffsets() override;

    std::unique_ptr<Scheduler> createScheduler(SetVSyncEnabled,

                                               const scheduler::RefreshRateConfigs&) override;

    std::unique_ptr<SurfaceInterceptor> createSurfaceInterceptor(SurfaceFlinger*) override;

    sp<StartPropertySetThread> createStartPropertySetThread(bool timestampPropertyValue) override;

    sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs&&) override;

    sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,

                                          uint32_t layerCount, uint64_t usage,

                                          std::string requestorName) override;

    void createBufferQueue(sp<IGraphicBufferProducer>* outProducer,

                           sp<IGraphicBufferConsumer>* outConsumer,

                           bool consumerIsSurfaceFlinger) override;

    std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(

            const sp<IGraphicBufferProducer>&) override;

    std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override;

    sp<BufferQueueLayer> createBufferQueueLayer(const LayerCreationArgs& args) override;

    sp<BufferStateLayer> createBufferStateLayer(const LayerCreationArgs& args) override;

    sp<ColorLayer> createColorLayer(const LayerCreationArgs& args) override;

    sp<ContainerLayer> createContainerLayer(const LayerCreationArgs& args) override;

};



} // namespace android::surfaceflinger

services/surfaceflinger/SurfaceFlingerFactory.cpp

+2 −105
Original line number Diff line number Diff line
@@ -14,116 +14,13 @@ 
 * limitations under the License.

 */



#include <compositionengine/impl/CompositionEngine.h>

#include <ui/GraphicBuffer.h>



#include "BufferQueueLayer.h"

#include "BufferStateLayer.h"

#include "ColorLayer.h"

#include "ContainerLayer.h"

#include "DisplayDevice.h"

#include "Layer.h"

#include "NativeWindowSurface.h"

#include "StartPropertySetThread.h"

#include "SurfaceFlinger.h"

#include "SurfaceFlingerFactory.h"

#include "SurfaceInterceptor.h"



#include "DisplayHardware/ComposerHal.h"

#include "Scheduler/DispSync.h"

#include "Scheduler/EventControlThread.h"

#include "Scheduler/MessageQueue.h"

#include "Scheduler/PhaseOffsets.h"

#include "Scheduler/Scheduler.h"

#include "SurfaceFlingerDefaultFactory.h"



namespace android::surfaceflinger {



sp<SurfaceFlinger> createSurfaceFlinger() {

    class Factory final : public surfaceflinger::Factory {

    public:

        Factory() = default;

        ~Factory() = default;



        std::unique_ptr<DispSync> createDispSync(const char* name, bool hasSyncFramework) override {

            return std::make_unique<android::impl::DispSync>(name, hasSyncFramework);

        }



        std::unique_ptr<EventControlThread> createEventControlThread(

                SetVSyncEnabled setVSyncEnabled) override {

            return std::make_unique<android::impl::EventControlThread>(std::move(setVSyncEnabled));

        }



        std::unique_ptr<HWComposer> createHWComposer(const std::string& serviceName) override {

            return std::make_unique<android::impl::HWComposer>(

                    std::make_unique<Hwc2::impl::Composer>(serviceName));

        }



        std::unique_ptr<MessageQueue> createMessageQueue() override {

            return std::make_unique<android::impl::MessageQueue>();

        }



        std::unique_ptr<scheduler::PhaseOffsets> createPhaseOffsets() override {

            return std::make_unique<scheduler::impl::PhaseOffsets>();

        }



        std::unique_ptr<Scheduler> createScheduler(

                SetVSyncEnabled setVSyncEnabled,

                const scheduler::RefreshRateConfigs& configs) override {

            return std::make_unique<Scheduler>(std::move(setVSyncEnabled), configs);

        }



        std::unique_ptr<SurfaceInterceptor> createSurfaceInterceptor(

                SurfaceFlinger* flinger) override {

            return std::make_unique<android::impl::SurfaceInterceptor>(flinger);

        }



        sp<StartPropertySetThread> createStartPropertySetThread(

                bool timestampPropertyValue) override {

            return new StartPropertySetThread(timestampPropertyValue);

        }



        sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs&& creationArgs) override {

            return new DisplayDevice(std::move(creationArgs));

        }



        sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,

                                              uint32_t layerCount, uint64_t usage,

                                              std::string requestorName) override {

            return new GraphicBuffer(width, height, format, layerCount, usage, requestorName);

        }



        void createBufferQueue(sp<IGraphicBufferProducer>* outProducer,

                               sp<IGraphicBufferConsumer>* outConsumer,

                               bool consumerIsSurfaceFlinger) override {

            BufferQueue::createBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);

        }



        std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(

                const sp<IGraphicBufferProducer>& producer) override {

            return surfaceflinger::impl::createNativeWindowSurface(producer);

        }



        std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override {

            return compositionengine::impl::createCompositionEngine();

        }



        sp<ContainerLayer> createContainerLayer(const LayerCreationArgs& args) override {

            return new ContainerLayer(args);

        }



        sp<BufferQueueLayer> createBufferQueueLayer(const LayerCreationArgs& args) override {

            return new BufferQueueLayer(args);

        }



        sp<BufferStateLayer> createBufferStateLayer(const LayerCreationArgs& args) override {

            return new BufferStateLayer(args);

        }



        sp<ColorLayer> createColorLayer(const LayerCreationArgs& args) override {

            return new ColorLayer(args);

        }

    };

    static Factory factory;

    static DefaultFactory factory;



    return new SurfaceFlinger(factory);

}

services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h

+1 −1
Original line number Diff line number Diff line
@@ -35,7 +35,7 @@ 
#include "Scheduler/RefreshRateConfigs.h"

#include "StartPropertySetThread.h"

#include "SurfaceFlinger.h"

#include "SurfaceFlingerFactory.h"

#include "SurfaceFlingerDefaultFactory.h"

#include "SurfaceInterceptor.h"

#include "TestableScheduler.h"