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

Commit 91615fb4 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge "SF: Set up a default factory implementation"

parents 1b871b51 24f3bfe3

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"