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

Commit 228f46b5 authored by Marin Shalamanov's avatar Marin Shalamanov
Browse files

Introduce DynamicDisplayInfo 

In this CL we introduce the getDynamicDisplayInfo call
on ISurfaceComposer which replaces the existing
 - getDisplayModes
 - getActiveDisplayMode
 - getColorModes
 - getActiveColorMode
 - getHdrCapabilities

This way all display properties can be queried atomically.

The current DisplayInfo class is moved to the androd::ui
namespace and it's renamed to StaticDisplayInfo.

ui::DisplayMode is now LightFlattenable and the mode ID is
int32_t instead of size_t in order to prevent serialization
problems.

Additionally we add the ID field to ui::DisplayMode. This
way we no longer need the supported display IDs to be
from 0 to N-1.

Bug: 159590486
Bug: 180539476
Test: presubmit, manually test that device boots
Change-Id: I52b170913ce47cb5df2e8417e6cc95d395df1fda
parent 8c9d2483

cmds/surfacereplayer/replayer/Replayer.cpp

+0 −1
Original line number Diff line number Diff line
@@ -28,7 +28,6 @@ 
#include <gui/Surface.h>

#include <private/gui/ComposerService.h>



#include <ui/DisplayInfo.h>

#include <utils/Log.h>

#include <utils/String8.h>

#include <utils/Trace.h>

include/input/TouchVideoFrame.h

+1 −1
Original line number Diff line number Diff line
@@ -57,7 +57,7 @@ public: 


    /**

     * Rotate the video frame.

     * The rotation value is an enum from ui/DisplayInfo.h

     * The rotation value is an enum from ui/Rotation.h

     */

    void rotate(int32_t orientation);

include/ui/DisplayInfo.h

deleted120000 → 0
+0 −1
Original line number Diff line number Diff line 
../../libs/ui/include/ui/DisplayInfo.h
 
 No newline at end of file

include/ui/StaticDisplayInfo.h

0 → 120000
+1 −0
Original line number Diff line number Diff line 
../../libs/ui/include/ui/StaticDisplayInfo.h
 
 No newline at end of file

libs/gui/ISurfaceComposer.cpp

+38 −182
Original line number Diff line number Diff line
@@ -36,11 +36,12 @@ 


#include <system/graphics.h>



#include <ui/DisplayInfo.h>

#include <ui/DisplayMode.h>

#include <ui/DisplayStatInfo.h>

#include <ui/DisplayState.h>

#include <ui/DynamicDisplayInfo.h>

#include <ui/HdrCapabilities.h>

#include <ui/StaticDisplayInfo.h>



#include <utils/Log.h>
@@ -323,32 +324,26 @@ public: 
        return result;

    }



    status_t getDisplayInfo(const sp<IBinder>& display, DisplayInfo* info) override {

    status_t getStaticDisplayInfo(const sp<IBinder>& display,

                                  ui::StaticDisplayInfo* info) override {

        Parcel data, reply;

        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());

        data.writeStrongBinder(display);

        remote()->transact(BnSurfaceComposer::GET_DISPLAY_INFO, data, &reply);

        remote()->transact(BnSurfaceComposer::GET_STATIC_DISPLAY_INFO, data, &reply);

        const status_t result = reply.readInt32();

        if (result != NO_ERROR) return result;

        return reply.read(*info);

    }



    status_t getDisplayModes(const sp<IBinder>& display, Vector<ui::DisplayMode>* modes) override {

    status_t getDynamicDisplayInfo(const sp<IBinder>& display,

                                   ui::DynamicDisplayInfo* info) override {

        Parcel data, reply;

        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());

        data.writeStrongBinder(display);

        remote()->transact(BnSurfaceComposer::GET_DISPLAY_MODES, data, &reply);

        remote()->transact(BnSurfaceComposer::GET_DYNAMIC_DISPLAY_INFO, data, &reply);

        const status_t result = reply.readInt32();

        if (result == NO_ERROR) {

            const size_t numModes = reply.readUint32();

            modes->clear();

            modes->resize(numModes);

            for (size_t i = 0; i < numModes; i++) {

                memcpy(&(modes->editItemAt(i)), reply.readInplace(sizeof(ui::DisplayMode)),

                       sizeof(ui::DisplayMode));

            }

        }

        return result;

        if (result != NO_ERROR) return result;

        return reply.read(*info);

    }



    status_t getDisplayStats(const sp<IBinder>& display, DisplayStatInfo* stats) override {
@@ -365,44 +360,6 @@ public: 
        return result;

    }



    int getActiveDisplayModeId(const sp<IBinder>& display) override {

        Parcel data, reply;

        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());

        data.writeStrongBinder(display);

        remote()->transact(BnSurfaceComposer::GET_ACTIVE_DISPLAY_MODE, data, &reply);

        return reply.readInt32();

    }



    status_t getDisplayColorModes(const sp<IBinder>& display,

                                  Vector<ColorMode>* outColorModes) override {

        Parcel data, reply;

        status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());

        if (result != NO_ERROR) {

            ALOGE("getDisplayColorModes failed to writeInterfaceToken: %d", result);

            return result;

        }

        result = data.writeStrongBinder(display);

        if (result != NO_ERROR) {

            ALOGE("getDisplayColorModes failed to writeStrongBinder: %d", result);

            return result;

        }

        result = remote()->transact(BnSurfaceComposer::GET_DISPLAY_COLOR_MODES, data, &reply);

        if (result != NO_ERROR) {

            ALOGE("getDisplayColorModes failed to transact: %d", result);

            return result;

        }

        result = static_cast<status_t>(reply.readInt32());

        if (result == NO_ERROR) {

            size_t numModes = reply.readUint32();

            outColorModes->clear();

            outColorModes->resize(numModes);

            for (size_t i = 0; i < numModes; ++i) {

                outColorModes->replaceAt(static_cast<ColorMode>(reply.readInt32()), i);

            }

        }

        return result;

    }



    status_t getDisplayNativePrimaries(const sp<IBinder>& display,

                                       ui::DisplayPrimaries& primaries) override {

        Parcel data, reply;
@@ -429,26 +386,6 @@ public: 
        return result;

    }



    ColorMode getActiveColorMode(const sp<IBinder>& display) override {

        Parcel data, reply;

        status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());

        if (result != NO_ERROR) {

            ALOGE("getActiveColorMode failed to writeInterfaceToken: %d", result);

            return static_cast<ColorMode>(result);

        }

        result = data.writeStrongBinder(display);

        if (result != NO_ERROR) {

            ALOGE("getActiveColorMode failed to writeStrongBinder: %d", result);

            return static_cast<ColorMode>(result);

        }

        result = remote()->transact(BnSurfaceComposer::GET_ACTIVE_COLOR_MODE, data, &reply);

        if (result != NO_ERROR) {

            ALOGE("getActiveColorMode failed to transact: %d", result);

            return static_cast<ColorMode>(result);

        }

        return static_cast<ColorMode>(reply.readInt32());

    }



    status_t setActiveColorMode(const sp<IBinder>& display, ColorMode colorMode) override {

        Parcel data, reply;

        status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
@@ -580,28 +517,6 @@ public: 
        return reply.readInt32();

    }



    status_t getHdrCapabilities(const sp<IBinder>& display,

                                HdrCapabilities* outCapabilities) const override {

        Parcel data, reply;

        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());

        status_t result = data.writeStrongBinder(display);

        if (result != NO_ERROR) {

            ALOGE("getHdrCapabilities failed to writeStrongBinder: %d", result);

            return result;

        }

        result = remote()->transact(BnSurfaceComposer::GET_HDR_CAPABILITIES,

                data, &reply);

        if (result != NO_ERROR) {

            ALOGE("getHdrCapabilities failed to transact: %d", result);

            return result;

        }

        result = reply.readInt32();

        if (result == NO_ERROR) {

            result = reply.read(*outCapabilities);

        }

        return result;

    }



    status_t enableVSyncInjections(bool enable) override {

        Parcel data, reply;

        status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
@@ -881,9 +796,10 @@ public: 
        return error;

    }



    status_t setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken, size_t defaultMode,

                                        bool allowGroupSwitching, float primaryRefreshRateMin,

                                        float primaryRefreshRateMax, float appRequestRefreshRateMin,

    status_t setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,

                                        ui::DisplayModeId defaultMode, bool allowGroupSwitching,

                                        float primaryRefreshRateMin, float primaryRefreshRateMax,

                                        float appRequestRefreshRateMin,

                                        float appRequestRefreshRateMax) override {

        Parcel data, reply;

        status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
@@ -938,7 +854,8 @@ public: 
        return reply.readInt32();

    }



    status_t getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken, size_t* outDefaultMode,

    status_t getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,

                                        ui::DisplayModeId* outDefaultMode,

                                        bool* outAllowGroupSwitching,

                                        float* outPrimaryRefreshRateMin,

                                        float* outPrimaryRefreshRateMax,
@@ -966,17 +883,16 @@ public: 
            ALOGE("getDesiredDisplayModeSpecs failed to transact: %d", result);

            return result;

        }

        int32_t defaultMode;

        result = reply.readInt32(&defaultMode);



        result = reply.readInt32(outDefaultMode);

        if (result != NO_ERROR) {

            ALOGE("getDesiredDisplayModeSpecs failed to read defaultMode: %d", result);

            return result;

        }

        if (defaultMode < 0) {

            ALOGE("%s: defaultMode must be non-negative but it was %d", __func__, defaultMode);

        if (*outDefaultMode < 0) {

            ALOGE("%s: defaultMode must be non-negative but it was %d", __func__, *outDefaultMode);

            return BAD_VALUE;

        }

        *outDefaultMode = static_cast<size_t>(defaultMode);



        result = reply.readBool(outAllowGroupSwitching);

        if (result != NO_ERROR) {
@@ -1436,28 +1352,24 @@ status_t BnSurfaceComposer::onTransact( 
            }

            return NO_ERROR;

        }

        case GET_DISPLAY_INFO: {

        case GET_STATIC_DISPLAY_INFO: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            DisplayInfo info;

            ui::StaticDisplayInfo info;

            const sp<IBinder> display = data.readStrongBinder();

            const status_t result = getDisplayInfo(display, &info);

            reply->writeInt32(result);

            const status_t result = getStaticDisplayInfo(display, &info);

            SAFE_PARCEL(reply->writeInt32, result);

            if (result != NO_ERROR) return result;

            return reply->write(info);

            SAFE_PARCEL(reply->write, info);

            return NO_ERROR;

        }

        case GET_DISPLAY_MODES: {

        case GET_DYNAMIC_DISPLAY_INFO: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            Vector<ui::DisplayMode> modes;

            ui::DynamicDisplayInfo info;

            const sp<IBinder> display = data.readStrongBinder();

            const status_t result = getDisplayModes(display, &modes);

            reply->writeInt32(result);

            if (result == NO_ERROR) {

                reply->writeUint32(static_cast<uint32_t>(modes.size()));

                for (size_t i = 0; i < modes.size(); i++) {

                    memcpy(reply->writeInplace(sizeof(ui::DisplayMode)), &modes[i],

                           sizeof(ui::DisplayMode));

                }

            }

            const status_t result = getDynamicDisplayInfo(display, &info);

            SAFE_PARCEL(reply->writeInt32, result);

            if (result != NO_ERROR) return result;

            SAFE_PARCEL(reply->write, info);

            return NO_ERROR;

        }

        case GET_DISPLAY_STATS: {
@@ -1472,32 +1384,6 @@ status_t BnSurfaceComposer::onTransact( 
            }

            return NO_ERROR;

        }

        case GET_ACTIVE_DISPLAY_MODE: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            sp<IBinder> display = data.readStrongBinder();

            int id = getActiveDisplayModeId(display);

            reply->writeInt32(id);

            return NO_ERROR;

        }

        case GET_DISPLAY_COLOR_MODES: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            Vector<ColorMode> colorModes;

            sp<IBinder> display = nullptr;

            status_t result = data.readStrongBinder(&display);

            if (result != NO_ERROR) {

                ALOGE("getDisplayColorModes failed to readStrongBinder: %d", result);

                return result;

            }

            result = getDisplayColorModes(display, &colorModes);

            reply->writeInt32(result);

            if (result == NO_ERROR) {

                reply->writeUint32(static_cast<uint32_t>(colorModes.size()));

                for (size_t i = 0; i < colorModes.size(); ++i) {

                    reply->writeInt32(static_cast<int32_t>(colorModes[i]));

                }

            }

            return NO_ERROR;

        }

        case GET_DISPLAY_NATIVE_PRIMARIES: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            ui::DisplayPrimaries primaries;
@@ -1518,18 +1404,6 @@ status_t BnSurfaceComposer::onTransact( 


            return NO_ERROR;

        }

        case GET_ACTIVE_COLOR_MODE: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            sp<IBinder> display = nullptr;

            status_t result = data.readStrongBinder(&display);

            if (result != NO_ERROR) {

                ALOGE("getActiveColorMode failed to readStrongBinder: %d", result);

                return result;

            }

            ColorMode colorMode = getActiveColorMode(display);

            result = reply->writeInt32(static_cast<int32_t>(colorMode));

            return result;

        }

        case SET_ACTIVE_COLOR_MODE: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            sp<IBinder> display = nullptr;
@@ -1639,23 +1513,6 @@ status_t BnSurfaceComposer::onTransact( 
            setPowerMode(display, mode);

            return NO_ERROR;

        }

        case GET_HDR_CAPABILITIES: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            sp<IBinder> display = nullptr;

            status_t result = data.readStrongBinder(&display);

            if (result != NO_ERROR) {

                ALOGE("getHdrCapabilities failed to readStrongBinder: %d",

                        result);

                return result;

            }

            HdrCapabilities capabilities;

            result = getHdrCapabilities(display, &capabilities);

            reply->writeInt32(result);

            if (result == NO_ERROR) {

                reply->write(capabilities);

            }

            return NO_ERROR;

        }

        case ENABLE_VSYNC_INJECTIONS: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            bool enable = false;
@@ -1862,7 +1719,7 @@ status_t BnSurfaceComposer::onTransact( 
        case SET_DESIRED_DISPLAY_MODE_SPECS: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            sp<IBinder> displayToken = data.readStrongBinder();

            int32_t defaultMode;

            ui::DisplayModeId defaultMode;

            status_t result = data.readInt32(&defaultMode);

            if (result != NO_ERROR) {

                ALOGE("setDesiredDisplayModeSpecs: failed to read defaultMode: %d", result);
@@ -1906,10 +1763,9 @@ status_t BnSurfaceComposer::onTransact( 
                      result);

                return result;

            }

            result = setDesiredDisplayModeSpecs(displayToken, static_cast<size_t>(defaultMode),

                                                allowGroupSwitching, primaryRefreshRateMin,

                                                primaryRefreshRateMax, appRequestRefreshRateMin,

                                                appRequestRefreshRateMax);

            result = setDesiredDisplayModeSpecs(displayToken, defaultMode, allowGroupSwitching,

                                                primaryRefreshRateMin, primaryRefreshRateMax,

                                                appRequestRefreshRateMin, appRequestRefreshRateMax);

            if (result != NO_ERROR) {

                ALOGE("setDesiredDisplayModeSpecs: failed to call setDesiredDisplayModeSpecs: "

                      "%d",
@@ -1922,7 +1778,7 @@ status_t BnSurfaceComposer::onTransact( 
        case GET_DESIRED_DISPLAY_MODE_SPECS: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            sp<IBinder> displayToken = data.readStrongBinder();

            size_t defaultMode;

            ui::DisplayModeId defaultMode;

            bool allowGroupSwitching;

            float primaryRefreshRateMin;

            float primaryRefreshRateMax;
@@ -1941,7 +1797,7 @@ status_t BnSurfaceComposer::onTransact( 
                return result;

            }



            result = reply->writeInt32(static_cast<int32_t>(defaultMode));

            result = reply->writeInt32(defaultMode);

            if (result != NO_ERROR) {

                ALOGE("getDesiredDisplayModeSpecs: failed to write defaultMode: %d", result);

                return result;