diff options
Diffstat (limited to 'libs/gui/ISurfaceComposer.cpp')
| -rw-r--r-- | libs/gui/ISurfaceComposer.cpp | 1315 |
1 files changed, 682 insertions, 633 deletions
diff --git a/libs/gui/ISurfaceComposer.cpp b/libs/gui/ISurfaceComposer.cpp index e62a61fc55..0d7795e1ba 100644 --- a/libs/gui/ISurfaceComposer.cpp +++ b/libs/gui/ISurfaceComposer.cpp @@ -17,13 +17,10 @@ // tag as surfaceflinger #define LOG_TAG "SurfaceFlinger" -#include <stdint.h> -#include <sys/types.h> - -#include <binder/Parcel.h> +#include <android/gui/ITransactionTraceListener.h> #include <binder/IPCThreadState.h> #include <binder/IServiceManager.h> - +#include <binder/Parcel.h> #include <gui/IDisplayEventConnection.h> #include <gui/IGraphicBufferProducer.h> #include <gui/IRegionSamplingListener.h> @@ -31,15 +28,16 @@ #include <gui/ISurfaceComposerClient.h> #include <gui/LayerDebugInfo.h> #include <gui/LayerState.h> - +#include <private/gui/ParcelUtils.h> +#include <stdint.h> +#include <sys/types.h> #include <system/graphics.h> - -#include <ui/DisplayConfig.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> // --------------------------------------------------------------------------- @@ -66,145 +64,87 @@ public: return interface_cast<ISurfaceComposerClient>(reply.readStrongBinder()); } - virtual void setTransactionState(const Vector<ComposerState>& state, - const Vector<DisplayState>& displays, uint32_t flags, - const sp<IBinder>& applyToken, - const InputWindowCommands& commands, - int64_t desiredPresentTime, - const client_cache_t& uncacheBuffer, bool hasListenerCallbacks, - const std::vector<ListenerCallbacks>& listenerCallbacks) { + status_t setTransactionState(const FrameTimelineInfo& frameTimelineInfo, + const Vector<ComposerState>& state, + const Vector<DisplayState>& displays, uint32_t flags, + const sp<IBinder>& applyToken, const InputWindowCommands& commands, + int64_t desiredPresentTime, bool isAutoTimestamp, + const client_cache_t& uncacheBuffer, bool hasListenerCallbacks, + const std::vector<ListenerCallbacks>& listenerCallbacks, + uint64_t transactionId) override { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); - data.writeUint32(static_cast<uint32_t>(state.size())); + SAFE_PARCEL(frameTimelineInfo.write, data); + + SAFE_PARCEL(data.writeUint32, static_cast<uint32_t>(state.size())); for (const auto& s : state) { - s.write(data); + SAFE_PARCEL(s.write, data); } - data.writeUint32(static_cast<uint32_t>(displays.size())); + SAFE_PARCEL(data.writeUint32, static_cast<uint32_t>(displays.size())); for (const auto& d : displays) { - d.write(data); + SAFE_PARCEL(d.write, data); } - data.writeUint32(flags); - data.writeStrongBinder(applyToken); - commands.write(data); - data.writeInt64(desiredPresentTime); - data.writeStrongBinder(uncacheBuffer.token.promote()); - data.writeUint64(uncacheBuffer.id); - data.writeBool(hasListenerCallbacks); + SAFE_PARCEL(data.writeUint32, flags); + SAFE_PARCEL(data.writeStrongBinder, applyToken); + SAFE_PARCEL(commands.write, data); + SAFE_PARCEL(data.writeInt64, desiredPresentTime); + SAFE_PARCEL(data.writeBool, isAutoTimestamp); + SAFE_PARCEL(data.writeStrongBinder, uncacheBuffer.token.promote()); + SAFE_PARCEL(data.writeUint64, uncacheBuffer.id); + SAFE_PARCEL(data.writeBool, hasListenerCallbacks); - if (data.writeVectorSize(listenerCallbacks) == NO_ERROR) { - for (const auto& [listener, callbackIds] : listenerCallbacks) { - data.writeStrongBinder(listener); - data.writeInt64Vector(callbackIds); - } + SAFE_PARCEL(data.writeVectorSize, listenerCallbacks); + for (const auto& [listener, callbackIds] : listenerCallbacks) { + SAFE_PARCEL(data.writeStrongBinder, listener); + SAFE_PARCEL(data.writeParcelableVector, callbackIds); } - remote()->transact(BnSurfaceComposer::SET_TRANSACTION_STATE, data, &reply); + SAFE_PARCEL(data.writeUint64, transactionId); + + return remote()->transact(BnSurfaceComposer::SET_TRANSACTION_STATE, data, &reply); } - virtual void bootFinished() - { + void bootFinished() override { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); remote()->transact(BnSurfaceComposer::BOOT_FINISHED, data, &reply); } - virtual status_t captureScreen(const sp<IBinder>& display, sp<GraphicBuffer>* outBuffer, - bool& outCapturedSecureLayers, ui::Dataspace reqDataspace, - ui::PixelFormat reqPixelFormat, const Rect& sourceCrop, - uint32_t reqWidth, uint32_t reqHeight, bool useIdentityTransform, - ui::Rotation rotation, bool captureSecureLayers) { + status_t captureDisplay(const DisplayCaptureArgs& args, + const sp<IScreenCaptureListener>& captureListener) override { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); - data.writeStrongBinder(display); - data.writeInt32(static_cast<int32_t>(reqDataspace)); - data.writeInt32(static_cast<int32_t>(reqPixelFormat)); - data.write(sourceCrop); - data.writeUint32(reqWidth); - data.writeUint32(reqHeight); - data.writeInt32(static_cast<int32_t>(useIdentityTransform)); - data.writeInt32(static_cast<int32_t>(rotation)); - data.writeInt32(static_cast<int32_t>(captureSecureLayers)); - status_t result = remote()->transact(BnSurfaceComposer::CAPTURE_SCREEN, data, &reply); - if (result != NO_ERROR) { - ALOGE("captureScreen failed to transact: %d", result); - return result; - } - result = reply.readInt32(); - if (result != NO_ERROR) { - ALOGE("captureScreen failed to readInt32: %d", result); - return result; - } + SAFE_PARCEL(args.write, data); + SAFE_PARCEL(data.writeStrongBinder, IInterface::asBinder(captureListener)); - *outBuffer = new GraphicBuffer(); - reply.read(**outBuffer); - outCapturedSecureLayers = reply.readBool(); - - return result; + return remote()->transact(BnSurfaceComposer::CAPTURE_DISPLAY, data, &reply); } - virtual status_t captureScreen(uint64_t displayOrLayerStack, ui::Dataspace* outDataspace, - sp<GraphicBuffer>* outBuffer) { + status_t captureDisplay(uint64_t displayOrLayerStack, + const sp<IScreenCaptureListener>& captureListener) override { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); - data.writeUint64(displayOrLayerStack); - status_t result = remote()->transact(BnSurfaceComposer::CAPTURE_SCREEN_BY_ID, data, &reply); - if (result != NO_ERROR) { - ALOGE("captureScreen failed to transact: %d", result); - return result; - } - result = reply.readInt32(); - if (result != NO_ERROR) { - ALOGE("captureScreen failed to readInt32: %d", result); - return result; - } + SAFE_PARCEL(data.writeUint64, displayOrLayerStack); + SAFE_PARCEL(data.writeStrongBinder, IInterface::asBinder(captureListener)); - *outDataspace = static_cast<ui::Dataspace>(reply.readInt32()); - *outBuffer = new GraphicBuffer(); - reply.read(**outBuffer); - return result; + return remote()->transact(BnSurfaceComposer::CAPTURE_DISPLAY_BY_ID, data, &reply); } - virtual status_t captureLayers( - const sp<IBinder>& layerHandleBinder, sp<GraphicBuffer>* outBuffer, - const ui::Dataspace reqDataspace, const ui::PixelFormat reqPixelFormat, - const Rect& sourceCrop, - const std::unordered_set<sp<IBinder>, SpHash<IBinder>>& excludeLayers, float frameScale, - bool childrenOnly) { + status_t captureLayers(const LayerCaptureArgs& args, + const sp<IScreenCaptureListener>& captureListener) override { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); - data.writeStrongBinder(layerHandleBinder); - data.writeInt32(static_cast<int32_t>(reqDataspace)); - data.writeInt32(static_cast<int32_t>(reqPixelFormat)); - data.write(sourceCrop); - data.writeInt32(excludeLayers.size()); - for (auto el : excludeLayers) { - data.writeStrongBinder(el); - } - data.writeFloat(frameScale); - data.writeBool(childrenOnly); - status_t result = remote()->transact(BnSurfaceComposer::CAPTURE_LAYERS, data, &reply); - if (result != NO_ERROR) { - ALOGE("captureLayers failed to transact: %d", result); - return result; - } - result = reply.readInt32(); - if (result != NO_ERROR) { - ALOGE("captureLayers failed to readInt32: %d", result); - return result; - } - - *outBuffer = new GraphicBuffer(); - reply.read(**outBuffer); + SAFE_PARCEL(args.write, data); + SAFE_PARCEL(data.writeStrongBinder, IInterface::asBinder(captureListener)); - return result; + return remote()->transact(BnSurfaceComposer::CAPTURE_LAYERS, data, &reply); } - virtual bool authenticateSurfaceTexture( - const sp<IGraphicBufferProducer>& bufferProducer) const - { + bool authenticateSurfaceTexture( + const sp<IGraphicBufferProducer>& bufferProducer) const override { Parcel data, reply; int err = NO_ERROR; err = data.writeInterfaceToken( @@ -237,8 +177,7 @@ public: return result != 0; } - virtual status_t getSupportedFrameTimestamps( - std::vector<FrameEvent>* outSupported) const { + status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) const override { if (!outSupported) { return UNEXPECTED_NULL; } @@ -281,8 +220,8 @@ public: return NO_ERROR; } - virtual sp<IDisplayEventConnection> createDisplayEventConnection(VsyncSource vsyncSource, - ConfigChanged configChanged) { + sp<IDisplayEventConnection> createDisplayEventConnection( + VsyncSource vsyncSource, EventRegistrationFlags eventRegistration) override { Parcel data, reply; sp<IDisplayEventConnection> result; int err = data.writeInterfaceToken( @@ -291,7 +230,7 @@ public: return result; } data.writeInt32(static_cast<int32_t>(vsyncSource)); - data.writeInt32(static_cast<int32_t>(configChanged)); + data.writeUint32(eventRegistration.get()); err = remote()->transact( BnSurfaceComposer::CREATE_DISPLAY_EVENT_CONNECTION, data, &reply); @@ -304,31 +243,47 @@ public: return result; } - virtual sp<IBinder> createDisplay(const String8& displayName, bool secure) - { + sp<IBinder> createDisplay(const String8& displayName, bool secure) override { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); - data.writeString8(displayName); - data.writeInt32(secure ? 1 : 0); - remote()->transact(BnSurfaceComposer::CREATE_DISPLAY, data, &reply); - return reply.readStrongBinder(); + status_t status = data.writeString8(displayName); + if (status) { + return nullptr; + } + status = data.writeBool(secure); + if (status) { + return nullptr; + } + + status = remote()->transact(BnSurfaceComposer::CREATE_DISPLAY, data, &reply); + if (status) { + return nullptr; + } + sp<IBinder> display; + status = reply.readNullableStrongBinder(&display); + if (status) { + return nullptr; + } + return display; } - virtual void destroyDisplay(const sp<IBinder>& display) - { + void destroyDisplay(const sp<IBinder>& display) override { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); data.writeStrongBinder(display); remote()->transact(BnSurfaceComposer::DESTROY_DISPLAY, data, &reply); } - virtual std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const { + std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const override { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); if (remote()->transact(BnSurfaceComposer::GET_PHYSICAL_DISPLAY_IDS, data, &reply) == NO_ERROR) { - std::vector<PhysicalDisplayId> displayIds; - if (reply.readUint64Vector(&displayIds) == NO_ERROR) { + std::vector<uint64_t> rawIds; + if (reply.readUint64Vector(&rawIds) == NO_ERROR) { + std::vector<PhysicalDisplayId> displayIds(rawIds.size()); + std::transform(rawIds.begin(), rawIds.end(), displayIds.begin(), + [](uint64_t rawId) { return PhysicalDisplayId(rawId); }); return displayIds; } } @@ -336,16 +291,15 @@ public: return {}; } - virtual sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const { + sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const override { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); - data.writeUint64(displayId); + data.writeUint64(displayId.value); remote()->transact(BnSurfaceComposer::GET_PHYSICAL_DISPLAY_TOKEN, data, &reply); return reply.readStrongBinder(); } - virtual void setPowerMode(const sp<IBinder>& display, int mode) - { + void setPowerMode(const sp<IBinder>& display, int mode) override { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); data.writeStrongBinder(display); @@ -353,7 +307,7 @@ public: remote()->transact(BnSurfaceComposer::SET_POWER_MODE, data, &reply); } - virtual status_t getDisplayState(const sp<IBinder>& display, ui::DisplayState* state) { + status_t getDisplayState(const sp<IBinder>& display, ui::DisplayState* state) override { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); data.writeStrongBinder(display); @@ -365,39 +319,29 @@ public: return result; } - virtual status_t getDisplayInfo(const sp<IBinder>& display, DisplayInfo* info) { + 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) { - memcpy(info, reply.readInplace(sizeof(DisplayInfo)), sizeof(DisplayInfo)); - } - return result; + if (result != NO_ERROR) return result; + return reply.read(*info); } - virtual status_t getDisplayConfigs(const sp<IBinder>& display, Vector<DisplayConfig>* configs) { + 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_CONFIGS, data, &reply); + remote()->transact(BnSurfaceComposer::GET_DYNAMIC_DISPLAY_INFO, data, &reply); const status_t result = reply.readInt32(); - if (result == NO_ERROR) { - const size_t numConfigs = reply.readUint32(); - configs->clear(); - configs->resize(numConfigs); - for (size_t c = 0; c < numConfigs; ++c) { - memcpy(&(configs->editItemAt(c)), reply.readInplace(sizeof(DisplayConfig)), - sizeof(DisplayConfig)); - } - } - return result; + if (result != NO_ERROR) return result; + return reply.read(*info); } - virtual status_t getDisplayStats(const sp<IBinder>& display, - DisplayStatInfo* stats) - { + status_t getDisplayStats(const sp<IBinder>& display, DisplayStatInfo* stats) override { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); data.writeStrongBinder(display); @@ -411,47 +355,8 @@ public: return result; } - virtual int getActiveConfig(const sp<IBinder>& display) - { - Parcel data, reply; - data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); - data.writeStrongBinder(display); - remote()->transact(BnSurfaceComposer::GET_ACTIVE_CONFIG, data, &reply); - return reply.readInt32(); - } - - virtual status_t getDisplayColorModes(const sp<IBinder>& display, - Vector<ColorMode>* outColorModes) { - 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; - } - - virtual status_t getDisplayNativePrimaries(const sp<IBinder>& display, - ui::DisplayPrimaries& primaries) { + status_t getDisplayNativePrimaries(const sp<IBinder>& display, + ui::DisplayPrimaries& primaries) override { Parcel data, reply; status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); if (result != NO_ERROR) { @@ -476,28 +381,7 @@ public: return result; } - virtual ColorMode getActiveColorMode(const sp<IBinder>& display) { - 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()); - } - - virtual status_t setActiveColorMode(const sp<IBinder>& display, - ColorMode colorMode) { + status_t setActiveColorMode(const sp<IBinder>& display, ColorMode colorMode) override { Parcel data, reply; status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); if (result != NO_ERROR) { @@ -522,25 +406,7 @@ public: return static_cast<status_t>(reply.readInt32()); } - virtual status_t getAutoLowLatencyModeSupport(const sp<IBinder>& display, - bool* outSupport) const { - Parcel data, reply; - data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); - status_t result = data.writeStrongBinder(display); - if (result != NO_ERROR) { - ALOGE("getAutoLowLatencyModeSupport failed to writeStrongBinder: %d", result); - return result; - } - result = remote()->transact(BnSurfaceComposer::GET_AUTO_LOW_LATENCY_MODE_SUPPORT, data, - &reply); - if (result != NO_ERROR) { - ALOGE("getAutoLowLatencyModeSupport failed to transact: %d", result); - return result; - } - return reply.readBool(outSupport); - } - - virtual void setAutoLowLatencyMode(const sp<IBinder>& display, bool on) { + void setAutoLowLatencyMode(const sp<IBinder>& display, bool on) override { Parcel data, reply; status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); if (result != NO_ERROR) { @@ -565,23 +431,7 @@ public: } } - virtual status_t getGameContentTypeSupport(const sp<IBinder>& display, bool* outSupport) const { - Parcel data, reply; - data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); - status_t result = data.writeStrongBinder(display); - if (result != NO_ERROR) { - ALOGE("getGameContentTypeSupport failed to writeStrongBinder: %d", result); - return result; - } - result = remote()->transact(BnSurfaceComposer::GET_GAME_CONTENT_TYPE_SUPPORT, data, &reply); - if (result != NO_ERROR) { - ALOGE("getGameContentTypeSupport failed to transact: %d", result); - return result; - } - return reply.readBool(outSupport); - } - - virtual void setGameContentType(const sp<IBinder>& display, bool on) { + void setGameContentType(const sp<IBinder>& display, bool on) override { Parcel data, reply; status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); if (result != NO_ERROR) { @@ -604,7 +454,7 @@ public: } } - virtual status_t clearAnimationFrameStats() { + status_t clearAnimationFrameStats() override { Parcel data, reply; status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); if (result != NO_ERROR) { @@ -619,7 +469,7 @@ public: return reply.readInt32(); } - virtual status_t getAnimationFrameStats(FrameStats* outStats) const { + status_t getAnimationFrameStats(FrameStats* outStats) const override { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); remote()->transact(BnSurfaceComposer::GET_ANIMATION_FRAME_STATS, data, &reply); @@ -627,29 +477,49 @@ public: return reply.readInt32(); } - virtual status_t getHdrCapabilities(const sp<IBinder>& display, - HdrCapabilities* outCapabilities) const { + virtual status_t overrideHdrTypes(const sp<IBinder>& display, + const std::vector<ui::Hdr>& hdrTypes) { 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; + SAFE_PARCEL(data.writeInterfaceToken, ISurfaceComposer::getInterfaceDescriptor()); + SAFE_PARCEL(data.writeStrongBinder, display); + + std::vector<int32_t> hdrTypesVector; + for (ui::Hdr i : hdrTypes) { + hdrTypesVector.push_back(static_cast<int32_t>(i)); } - result = remote()->transact(BnSurfaceComposer::GET_HDR_CAPABILITIES, - data, &reply); + SAFE_PARCEL(data.writeInt32Vector, hdrTypesVector); + + status_t result = remote()->transact(BnSurfaceComposer::OVERRIDE_HDR_TYPES, data, &reply); if (result != NO_ERROR) { - ALOGE("getHdrCapabilities failed to transact: %d", result); + ALOGE("overrideHdrTypes failed to transact: %d", result); return result; } - result = reply.readInt32(); - if (result == NO_ERROR) { - result = reply.read(*outCapabilities); - } return result; } - virtual status_t enableVSyncInjections(bool enable) { + status_t onPullAtom(const int32_t atomId, std::string* pulledData, bool* success) { + Parcel data, reply; + SAFE_PARCEL(data.writeInterfaceToken, ISurfaceComposer::getInterfaceDescriptor()); + SAFE_PARCEL(data.writeInt32, atomId); + + status_t err = remote()->transact(BnSurfaceComposer::ON_PULL_ATOM, data, &reply); + if (err != NO_ERROR) { + ALOGE("onPullAtom failed to transact: %d", err); + return err; + } + + int32_t size = 0; + SAFE_PARCEL(reply.readInt32, &size); + const void* dataPtr = reply.readInplace(size); + if (dataPtr == nullptr) { + return UNEXPECTED_NULL; + } + pulledData->assign((const char*)dataPtr, size); + SAFE_PARCEL(reply.readBool, success); + return NO_ERROR; + } + + status_t enableVSyncInjections(bool enable) override { Parcel data, reply; status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); if (result != NO_ERROR) { @@ -670,7 +540,7 @@ public: return result; } - virtual status_t injectVSync(nsecs_t when) { + status_t injectVSync(nsecs_t when) override { Parcel data, reply; status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); if (result != NO_ERROR) { @@ -691,7 +561,7 @@ public: return result; } - virtual status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) { + status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) override { if (!outLayers) { return UNEXPECTED_NULL; } @@ -721,10 +591,10 @@ public: return reply.readParcelableVector(outLayers); } - virtual status_t getCompositionPreference(ui::Dataspace* defaultDataspace, - ui::PixelFormat* defaultPixelFormat, - ui::Dataspace* wideColorGamutDataspace, - ui::PixelFormat* wideColorGamutPixelFormat) const { + status_t getCompositionPreference(ui::Dataspace* defaultDataspace, + ui::PixelFormat* defaultPixelFormat, + ui::Dataspace* wideColorGamutDataspace, + ui::PixelFormat* wideColorGamutPixelFormat) const override { Parcel data, reply; status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); if (error != NO_ERROR) { @@ -744,7 +614,7 @@ public: return error; } - virtual status_t getColorManagement(bool* outGetColorManagement) const { + status_t getColorManagement(bool* outGetColorManagement) const override { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); remote()->transact(BnSurfaceComposer::GET_COLOR_MANAGEMENT, data, &reply); @@ -756,10 +626,10 @@ public: return err; } - virtual status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& display, - ui::PixelFormat* outFormat, - ui::Dataspace* outDataspace, - uint8_t* outComponentMask) const { + status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& display, + ui::PixelFormat* outFormat, + ui::Dataspace* outDataspace, + uint8_t* outComponentMask) const override { if (!outFormat || !outDataspace || !outComponentMask) return BAD_VALUE; Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); @@ -793,8 +663,8 @@ public: return error; } - virtual status_t setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable, - uint8_t componentMask, uint64_t maxFrames) { + status_t setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable, + uint8_t componentMask, uint64_t maxFrames) override { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); data.writeStrongBinder(display); @@ -807,9 +677,9 @@ public: return result; } - virtual status_t getDisplayedContentSample(const sp<IBinder>& display, uint64_t maxFrames, - uint64_t timestamp, - DisplayedFrameStats* outStats) const { + status_t getDisplayedContentSample(const sp<IBinder>& display, uint64_t maxFrames, + uint64_t timestamp, + DisplayedFrameStats* outStats) const override { if (!outStats) return BAD_VALUE; Parcel data, reply; @@ -846,7 +716,7 @@ public: return result; } - virtual status_t getProtectedContentSupport(bool* outSupported) const { + status_t getProtectedContentSupport(bool* outSupported) const override { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); status_t error = @@ -858,8 +728,8 @@ public: return error; } - virtual status_t isWideColorDisplay(const sp<IBinder>& token, - bool* outIsWideColorDisplay) const { + status_t isWideColorDisplay(const sp<IBinder>& token, + bool* outIsWideColorDisplay) const override { Parcel data, reply; status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); if (error != NO_ERROR) { @@ -878,9 +748,8 @@ public: return error; } - virtual status_t addRegionSamplingListener(const Rect& samplingArea, - const sp<IBinder>& stopLayerHandle, - const sp<IRegionSamplingListener>& listener) { + status_t addRegionSamplingListener(const Rect& samplingArea, const sp<IBinder>& stopLayerHandle, + const sp<IRegionSamplingListener>& listener) override { Parcel data, reply; status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); if (error != NO_ERROR) { @@ -909,7 +778,7 @@ public: return error; } - virtual status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) { + status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) override { Parcel data, reply; status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); if (error != NO_ERROR) { @@ -929,119 +798,190 @@ public: return error; } - virtual status_t setDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken, - int32_t defaultConfig, - float primaryRefreshRateMin, - float primaryRefreshRateMax, - float appRequestRefreshRateMin, - float appRequestRefreshRateMax) { + virtual status_t addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener) { + Parcel data, reply; + SAFE_PARCEL(data.writeInterfaceToken, ISurfaceComposer::getInterfaceDescriptor()); + SAFE_PARCEL(data.writeInt32, taskId); + SAFE_PARCEL(data.writeStrongBinder, IInterface::asBinder(listener)); + const status_t error = + remote()->transact(BnSurfaceComposer::ADD_FPS_LISTENER, data, &reply); + if (error != OK) { + ALOGE("addFpsListener: Failed to transact"); + } + return error; + } + + virtual status_t removeFpsListener(const sp<gui::IFpsListener>& listener) { + Parcel data, reply; + SAFE_PARCEL(data.writeInterfaceToken, ISurfaceComposer::getInterfaceDescriptor()); + SAFE_PARCEL(data.writeStrongBinder, IInterface::asBinder(listener)); + + const status_t error = + remote()->transact(BnSurfaceComposer::REMOVE_FPS_LISTENER, data, &reply); + if (error != OK) { + ALOGE("removeFpsListener: Failed to transact"); + } + return error; + } + + virtual status_t addTunnelModeEnabledListener( + const sp<gui::ITunnelModeEnabledListener>& listener) { + Parcel data, reply; + SAFE_PARCEL(data.writeInterfaceToken, ISurfaceComposer::getInterfaceDescriptor()); + SAFE_PARCEL(data.writeStrongBinder, IInterface::asBinder(listener)); + + const status_t error = + remote()->transact(BnSurfaceComposer::ADD_TUNNEL_MODE_ENABLED_LISTENER, data, + &reply); + if (error != NO_ERROR) { + ALOGE("addTunnelModeEnabledListener: Failed to transact"); + } + return error; + } + + virtual status_t removeTunnelModeEnabledListener( + const sp<gui::ITunnelModeEnabledListener>& listener) { + Parcel data, reply; + SAFE_PARCEL(data.writeInterfaceToken, ISurfaceComposer::getInterfaceDescriptor()); + SAFE_PARCEL(data.writeStrongBinder, IInterface::asBinder(listener)); + + const status_t error = + remote()->transact(BnSurfaceComposer::REMOVE_TUNNEL_MODE_ENABLED_LISTENER, data, + &reply); + if (error != NO_ERROR) { + ALOGE("removeTunnelModeEnabledListener: Failed to transact"); + } + return error; + } + + 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()); if (result != NO_ERROR) { - ALOGE("setDesiredDisplayConfigSpecs: failed to writeInterfaceToken: %d", result); + ALOGE("setDesiredDisplayModeSpecs: failed to writeInterfaceToken: %d", result); return result; } result = data.writeStrongBinder(displayToken); if (result != NO_ERROR) { - ALOGE("setDesiredDisplayConfigSpecs: failed to write display token: %d", result); + ALOGE("setDesiredDisplayModeSpecs: failed to write display token: %d", result); + return result; + } + result = data.writeInt32(defaultMode); + if (result != NO_ERROR) { + ALOGE("setDesiredDisplayModeSpecs failed to write defaultMode: %d", result); return result; } - result = data.writeInt32(defaultConfig); + result = data.writeBool(allowGroupSwitching); if (result != NO_ERROR) { - ALOGE("setDesiredDisplayConfigSpecs failed to write defaultConfig: %d", result); + ALOGE("setDesiredDisplayModeSpecs failed to write allowGroupSwitching: %d", result); return result; } result = data.writeFloat(primaryRefreshRateMin); if (result != NO_ERROR) { - ALOGE("setDesiredDisplayConfigSpecs failed to write primaryRefreshRateMin: %d", result); + ALOGE("setDesiredDisplayModeSpecs failed to write primaryRefreshRateMin: %d", result); return result; } result = data.writeFloat(primaryRefreshRateMax); if (result != NO_ERROR) { - ALOGE("setDesiredDisplayConfigSpecs failed to write primaryRefreshRateMax: %d", result); + ALOGE("setDesiredDisplayModeSpecs failed to write primaryRefreshRateMax: %d", result); return result; } result = data.writeFloat(appRequestRefreshRateMin); if (result != NO_ERROR) { - ALOGE("setDesiredDisplayConfigSpecs failed to write appRequestRefreshRateMin: %d", + ALOGE("setDesiredDisplayModeSpecs failed to write appRequestRefreshRateMin: %d", result); return result; } result = data.writeFloat(appRequestRefreshRateMax); if (result != NO_ERROR) { - ALOGE("setDesiredDisplayConfigSpecs failed to write appRequestRefreshRateMax: %d", + ALOGE("setDesiredDisplayModeSpecs failed to write appRequestRefreshRateMax: %d", result); return result; } - result = remote()->transact(BnSurfaceComposer::SET_DESIRED_DISPLAY_CONFIG_SPECS, data, - &reply); + result = + remote()->transact(BnSurfaceComposer::SET_DESIRED_DISPLAY_MODE_SPECS, data, &reply); if (result != NO_ERROR) { - ALOGE("setDesiredDisplayConfigSpecs failed to transact: %d", result); + ALOGE("setDesiredDisplayModeSpecs failed to transact: %d", result); return result; } return reply.readInt32(); } - virtual status_t getDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken, - int32_t* outDefaultConfig, - float* outPrimaryRefreshRateMin, - float* outPrimaryRefreshRateMax, - float* outAppRequestRefreshRateMin, - float* outAppRequestRefreshRateMax) { - if (!outDefaultConfig || !outPrimaryRefreshRateMin || !outPrimaryRefreshRateMax || - !outAppRequestRefreshRateMin || !outAppRequestRefreshRateMax) { + status_t getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken, + ui::DisplayModeId* outDefaultMode, + bool* outAllowGroupSwitching, + float* outPrimaryRefreshRateMin, + float* outPrimaryRefreshRateMax, + float* outAppRequestRefreshRateMin, + float* outAppRequestRefreshRateMax) override { + if (!outDefaultMode || !outAllowGroupSwitching || !outPrimaryRefreshRateMin || + !outPrimaryRefreshRateMax || !outAppRequestRefreshRateMin || + !outAppRequestRefreshRateMax) { return BAD_VALUE; } Parcel data, reply; status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); if (result != NO_ERROR) { - ALOGE("getDesiredDisplayConfigSpecs failed to writeInterfaceToken: %d", result); + ALOGE("getDesiredDisplayModeSpecs failed to writeInterfaceToken: %d", result); return result; } result = data.writeStrongBinder(displayToken); if (result != NO_ERROR) { - ALOGE("getDesiredDisplayConfigSpecs failed to writeStrongBinder: %d", result); + ALOGE("getDesiredDisplayModeSpecs failed to writeStrongBinder: %d", result); return result; } - result = remote()->transact(BnSurfaceComposer::GET_DESIRED_DISPLAY_CONFIG_SPECS, data, - &reply); + result = + remote()->transact(BnSurfaceComposer::GET_DESIRED_DISPLAY_MODE_SPECS, data, &reply); if (result != NO_ERROR) { - ALOGE("getDesiredDisplayConfigSpecs failed to transact: %d", result); + ALOGE("getDesiredDisplayModeSpecs failed to transact: %d", result); return result; } - result = reply.readInt32(outDefaultConfig); + + result = reply.readInt32(outDefaultMode); + if (result != NO_ERROR) { + ALOGE("getDesiredDisplayModeSpecs failed to read defaultMode: %d", result); + return result; + } + if (*outDefaultMode < 0) { + ALOGE("%s: defaultMode must be non-negative but it was %d", __func__, *outDefaultMode); + return BAD_VALUE; + } + + result = reply.readBool(outAllowGroupSwitching); if (result != NO_ERROR) { - ALOGE("getDesiredDisplayConfigSpecs failed to read defaultConfig: %d", result); + ALOGE("getDesiredDisplayModeSpecs failed to read allowGroupSwitching: %d", result); return result; } result = reply.readFloat(outPrimaryRefreshRateMin); if (result != NO_ERROR) { - ALOGE("getDesiredDisplayConfigSpecs failed to read primaryRefreshRateMin: %d", result); + ALOGE("getDesiredDisplayModeSpecs failed to read primaryRefreshRateMin: %d", result); return result; } result = reply.readFloat(outPrimaryRefreshRateMax); if (result != NO_ERROR) { - ALOGE("getDesiredDisplayConfigSpecs failed to read primaryRefreshRateMax: %d", result); + ALOGE("getDesiredDisplayModeSpecs failed to read primaryRefreshRateMax: %d", result); return result; } result = reply.readFloat(outAppRequestRefreshRateMin); if (result != NO_ERROR) { - ALOGE("getDesiredDisplayConfigSpecs failed to read appRequestRefreshRateMin: %d", - result); + ALOGE("getDesiredDisplayModeSpecs failed to read appRequestRefreshRateMin: %d", result); return result; } result = reply.readFloat(outAppRequestRefreshRateMax); if (result != NO_ERROR) { - ALOGE("getDesiredDisplayConfigSpecs failed to read appRequestRefreshRateMax: %d", - result); + ALOGE("getDesiredDisplayModeSpecs failed to read appRequestRefreshRateMax: %d", result); return result; } return reply.readInt32(); } - virtual status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken, - bool* outSupport) const { + status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken, + bool* outSupport) const override { Parcel data, reply; status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); if (error != NO_ERROR) { @@ -1068,7 +1008,8 @@ public: return NO_ERROR; } - virtual status_t setDisplayBrightness(const sp<IBinder>& displayToken, float brightness) { + status_t setDisplayBrightness(const sp<IBinder>& displayToken, + const gui::DisplayBrightness& brightness) override { Parcel data, reply; status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); if (error != NO_ERROR) { @@ -1080,7 +1021,7 @@ public: ALOGE("setDisplayBrightness: failed to write display token: %d", error); return error; } - error = data.writeFloat(brightness); + error = data.writeParcelable(brightness); if (error != NO_ERROR) { ALOGE("setDisplayBrightness: failed to write brightness: %d", error); return error; @@ -1093,29 +1034,57 @@ public: return NO_ERROR; } - virtual status_t notifyPowerHint(int32_t hintId) { + status_t addHdrLayerInfoListener(const sp<IBinder>& displayToken, + const sp<gui::IHdrLayerInfoListener>& listener) override { + Parcel data, reply; + SAFE_PARCEL(data.writeInterfaceToken, ISurfaceComposer::getInterfaceDescriptor()); + SAFE_PARCEL(data.writeStrongBinder, displayToken); + SAFE_PARCEL(data.writeStrongBinder, IInterface::asBinder(listener)); + const status_t error = + remote()->transact(BnSurfaceComposer::ADD_HDR_LAYER_INFO_LISTENER, data, &reply); + if (error != OK) { + ALOGE("addHdrLayerInfoListener: Failed to transact; error = %d", error); + } + return error; + } + + status_t removeHdrLayerInfoListener(const sp<IBinder>& displayToken, + const sp<gui::IHdrLayerInfoListener>& listener) override { + Parcel data, reply; + SAFE_PARCEL(data.writeInterfaceToken, ISurfaceComposer::getInterfaceDescriptor()); + SAFE_PARCEL(data.writeStrongBinder, displayToken); + SAFE_PARCEL(data.writeStrongBinder, IInterface::asBinder(listener)); + const status_t error = + remote()->transact(BnSurfaceComposer::REMOVE_HDR_LAYER_INFO_LISTENER, data, &reply); + if (error != OK) { + ALOGE("removeHdrLayerInfoListener: Failed to transact; error = %d", error); + } + return error; + } + + status_t notifyPowerBoost(int32_t boostId) override { Parcel data, reply; status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); if (error != NO_ERROR) { - ALOGE("notifyPowerHint: failed to write interface token: %d", error); + ALOGE("notifyPowerBoost: failed to write interface token: %d", error); return error; } - error = data.writeInt32(hintId); + error = data.writeInt32(boostId); if (error != NO_ERROR) { - ALOGE("notifyPowerHint: failed to write hintId: %d", error); + ALOGE("notifyPowerBoost: failed to write boostId: %d", error); return error; } - error = remote()->transact(BnSurfaceComposer::NOTIFY_POWER_HINT, data, &reply, + error = remote()->transact(BnSurfaceComposer::NOTIFY_POWER_BOOST, data, &reply, IBinder::FLAG_ONEWAY); if (error != NO_ERROR) { - ALOGE("notifyPowerHint: failed to transact: %d", error); + ALOGE("notifyPowerBoost: failed to transact: %d", error); return error; } return NO_ERROR; } - virtual status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor, - float lightPosY, float lightPosZ, float lightRadius) { + status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor, + float lightPosY, float lightPosZ, float lightRadius) override { Parcel data, reply; status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); if (error != NO_ERROR) { @@ -1143,34 +1112,16 @@ public: return NO_ERROR; } - virtual status_t setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate, - int8_t compatibility) { + status_t setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate, + int8_t compatibility, int8_t changeFrameRateStrategy) override { Parcel data, reply; - status_t err = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); - if (err != NO_ERROR) { - ALOGE("setFrameRate: failed writing interface token: %s (%d)", strerror(-err), -err); - return err; - } + SAFE_PARCEL(data.writeInterfaceToken, ISurfaceComposer::getInterfaceDescriptor()); + SAFE_PARCEL(data.writeStrongBinder, IInterface::asBinder(surface)); + SAFE_PARCEL(data.writeFloat, frameRate); + SAFE_PARCEL(data.writeByte, compatibility); + SAFE_PARCEL(data.writeByte, changeFrameRateStrategy); - err = data.writeStrongBinder(IInterface::asBinder(surface)); - if (err != NO_ERROR) { - ALOGE("setFrameRate: failed writing strong binder: %s (%d)", strerror(-err), -err); - return err; - } - - err = data.writeFloat(frameRate); - if (err != NO_ERROR) { - ALOGE("setFrameRate: failed writing float: %s (%d)", strerror(-err), -err); - return err; - } - - err = data.writeByte(compatibility); - if (err != NO_ERROR) { - ALOGE("setFrameRate: failed writing byte: %s (%d)", strerror(-err), -err); - return err; - } - - err = remote()->transact(BnSurfaceComposer::SET_FRAME_RATE, data, &reply); + status_t err = remote()->transact(BnSurfaceComposer::SET_FRAME_RATE, data, &reply); if (err != NO_ERROR) { ALOGE("setFrameRate: failed to transact: %s (%d)", strerror(-err), err); return err; @@ -1179,7 +1130,7 @@ public: return reply.readInt32(); } - virtual status_t acquireFrameRateFlexibilityToken(sp<IBinder>* outToken) { + status_t acquireFrameRateFlexibilityToken(sp<IBinder>* outToken) override { if (!outToken) return BAD_VALUE; Parcel data, reply; @@ -1213,6 +1164,69 @@ public: return NO_ERROR; } + + status_t setFrameTimelineInfo(const sp<IGraphicBufferProducer>& surface, + const FrameTimelineInfo& frameTimelineInfo) override { + Parcel data, reply; + status_t err = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); + if (err != NO_ERROR) { + ALOGE("%s: failed writing interface token: %s (%d)", __func__, strerror(-err), -err); + return err; + } + + err = data.writeStrongBinder(IInterface::asBinder(surface)); + if (err != NO_ERROR) { + ALOGE("%s: failed writing strong binder: %s (%d)", __func__, strerror(-err), -err); + return err; + } + + SAFE_PARCEL(frameTimelineInfo.write, data); + + err = remote()->transact(BnSurfaceComposer::SET_FRAME_TIMELINE_INFO, data, &reply); + if (err != NO_ERROR) { + ALOGE("%s: failed to transact: %s (%d)", __func__, strerror(-err), err); + return err; + } + + return reply.readInt32(); + } + + status_t addTransactionTraceListener( + const sp<gui::ITransactionTraceListener>& listener) override { + Parcel data, reply; + SAFE_PARCEL(data.writeInterfaceToken, ISurfaceComposer::getInterfaceDescriptor()); + SAFE_PARCEL(data.writeStrongBinder, IInterface::asBinder(listener)); + + return remote()->transact(BnSurfaceComposer::ADD_TRANSACTION_TRACE_LISTENER, data, &reply); + } + + /** + * Get priority of the RenderEngine in surface flinger. + */ + int getGPUContextPriority() override { + Parcel data, reply; + data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); + status_t err = + remote()->transact(BnSurfaceComposer::GET_GPU_CONTEXT_PRIORITY, data, &reply); + if (err != NO_ERROR) { + ALOGE("getGPUContextPriority failed to read data: %s (%d)", strerror(-err), err); + return 0; + } + return reply.readInt32(); + } + + status_t getMaxAcquiredBufferCount(int* buffers) const override { + Parcel data, reply; + data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); + status_t err = + remote()->transact(BnSurfaceComposer::GET_MAX_ACQUIRED_BUFFER_COUNT, data, &reply); + if (err != NO_ERROR) { + ALOGE("getMaxAcquiredBufferCount failed to read data: %s (%d)", strerror(-err), err); + return err; + } + + return reply.readInt32(buffers); + } }; // Out-of-line virtual method definition to trigger vtable emission in this @@ -1236,135 +1250,98 @@ status_t BnSurfaceComposer::onTransact( case SET_TRANSACTION_STATE: { CHECK_INTERFACE(ISurfaceComposer, data, reply); - size_t count = data.readUint32(); - if (count > data.dataSize()) { - return BAD_VALUE; - } + FrameTimelineInfo frameTimelineInfo; + SAFE_PARCEL(frameTimelineInfo.read, data); + + uint32_t count = 0; + SAFE_PARCEL_READ_SIZE(data.readUint32, &count, data.dataSize()); Vector<ComposerState> state; state.setCapacity(count); for (size_t i = 0; i < count; i++) { ComposerState s; - if (s.read(data) == BAD_VALUE) { - return BAD_VALUE; - } + SAFE_PARCEL(s.read, data); state.add(s); } - count = data.readUint32(); - if (count > data.dataSize()) { - return BAD_VALUE; - } + SAFE_PARCEL_READ_SIZE(data.readUint32, &count, data.dataSize()); DisplayState d; Vector<DisplayState> displays; displays.setCapacity(count); for (size_t i = 0; i < count; i++) { - if (d.read(data) == BAD_VALUE) { - return BAD_VALUE; - } + SAFE_PARCEL(d.read, data); displays.add(d); } - uint32_t stateFlags = data.readUint32(); - sp<IBinder> applyToken = data.readStrongBinder(); + uint32_t stateFlags = 0; + SAFE_PARCEL(data.readUint32, &stateFlags); + sp<IBinder> applyToken; + SAFE_PARCEL(data.readStrongBinder, &applyToken); InputWindowCommands inputWindowCommands; - inputWindowCommands.read(data); + SAFE_PARCEL(inputWindowCommands.read, data); - int64_t desiredPresentTime = data.readInt64(); + int64_t desiredPresentTime = 0; + bool isAutoTimestamp = true; + SAFE_PARCEL(data.readInt64, &desiredPresentTime); + SAFE_PARCEL(data.readBool, &isAutoTimestamp); client_cache_t uncachedBuffer; - uncachedBuffer.token = data.readStrongBinder(); - uncachedBuffer.id = data.readUint64(); + sp<IBinder> tmpBinder; + SAFE_PARCEL(data.readNullableStrongBinder, &tmpBinder); + uncachedBuffer.token = tmpBinder; + SAFE_PARCEL(data.readUint64, &uncachedBuffer.id); - bool hasListenerCallbacks = data.readBool(); + bool hasListenerCallbacks = false; + SAFE_PARCEL(data.readBool, &hasListenerCallbacks); std::vector<ListenerCallbacks> listenerCallbacks; - int32_t listenersSize = data.readInt32(); + int32_t listenersSize = 0; + SAFE_PARCEL_READ_SIZE(data.readInt32, &listenersSize, data.dataSize()); for (int32_t i = 0; i < listenersSize; i++) { - auto listener = data.readStrongBinder(); + SAFE_PARCEL(data.readStrongBinder, &tmpBinder); std::vector<CallbackId> callbackIds; - data.readInt64Vector(&callbackIds); - listenerCallbacks.emplace_back(listener, callbackIds); + SAFE_PARCEL(data.readParcelableVector, &callbackIds); + listenerCallbacks.emplace_back(tmpBinder, callbackIds); } - setTransactionState(state, displays, stateFlags, applyToken, inputWindowCommands, - desiredPresentTime, uncachedBuffer, hasListenerCallbacks, - listenerCallbacks); - return NO_ERROR; + + uint64_t transactionId = -1; + SAFE_PARCEL(data.readUint64, &transactionId); + + return setTransactionState(frameTimelineInfo, state, displays, stateFlags, applyToken, + inputWindowCommands, desiredPresentTime, isAutoTimestamp, + uncachedBuffer, hasListenerCallbacks, listenerCallbacks, + transactionId); } case BOOT_FINISHED: { CHECK_INTERFACE(ISurfaceComposer, data, reply); bootFinished(); return NO_ERROR; } - case CAPTURE_SCREEN: { + case CAPTURE_DISPLAY: { CHECK_INTERFACE(ISurfaceComposer, data, reply); - sp<IBinder> display = data.readStrongBinder(); - ui::Dataspace reqDataspace = static_cast<ui::Dataspace>(data.readInt32()); - ui::PixelFormat reqPixelFormat = static_cast<ui::PixelFormat>(data.readInt32()); - sp<GraphicBuffer> outBuffer; - Rect sourceCrop(Rect::EMPTY_RECT); - data.read(sourceCrop); - uint32_t reqWidth = data.readUint32(); - uint32_t reqHeight = data.readUint32(); - bool useIdentityTransform = static_cast<bool>(data.readInt32()); - int32_t rotation = data.readInt32(); - bool captureSecureLayers = static_cast<bool>(data.readInt32()); - - bool capturedSecureLayers = false; - status_t res = captureScreen(display, &outBuffer, capturedSecureLayers, reqDataspace, - reqPixelFormat, sourceCrop, reqWidth, reqHeight, - useIdentityTransform, ui::toRotation(rotation), - captureSecureLayers); - - reply->writeInt32(res); - if (res == NO_ERROR) { - reply->write(*outBuffer); - reply->writeBool(capturedSecureLayers); - } - return NO_ERROR; + DisplayCaptureArgs args; + sp<IScreenCaptureListener> captureListener; + SAFE_PARCEL(args.read, data); + SAFE_PARCEL(data.readStrongBinder, &captureListener); + + return captureDisplay(args, captureListener); } - case CAPTURE_SCREEN_BY_ID: { + case CAPTURE_DISPLAY_BY_ID: { CHECK_INTERFACE(ISurfaceComposer, data, reply); - uint64_t displayOrLayerStack = data.readUint64(); - ui::Dataspace outDataspace = ui::Dataspace::V0_SRGB; - sp<GraphicBuffer> outBuffer; - status_t res = captureScreen(displayOrLayerStack, &outDataspace, &outBuffer); - reply->writeInt32(res); - if (res == NO_ERROR) { - reply->writeInt32(static_cast<int32_t>(outDataspace)); - reply->write(*outBuffer); - } - return NO_ERROR; + uint64_t displayOrLayerStack = 0; + sp<IScreenCaptureListener> captureListener; + SAFE_PARCEL(data.readUint64, &displayOrLayerStack); + SAFE_PARCEL(data.readStrongBinder, &captureListener); + + return captureDisplay(displayOrLayerStack, captureListener); } case CAPTURE_LAYERS: { CHECK_INTERFACE(ISurfaceComposer, data, reply); - sp<IBinder> layerHandleBinder = data.readStrongBinder(); - ui::Dataspace reqDataspace = static_cast<ui::Dataspace>(data.readInt32()); - ui::PixelFormat reqPixelFormat = static_cast<ui::PixelFormat>(data.readInt32()); - sp<GraphicBuffer> outBuffer; - Rect sourceCrop(Rect::EMPTY_RECT); - data.read(sourceCrop); - - std::unordered_set<sp<IBinder>, SpHash<IBinder>> excludeHandles; - int numExcludeHandles = data.readInt32(); - if (numExcludeHandles >= static_cast<int>(MAX_LAYERS)) { - return BAD_VALUE; - } - excludeHandles.reserve(numExcludeHandles); - for (int i = 0; i < numExcludeHandles; i++) { - excludeHandles.emplace(data.readStrongBinder()); - } - - float frameScale = data.readFloat(); - bool childrenOnly = data.readBool(); + LayerCaptureArgs args; + sp<IScreenCaptureListener> captureListener; + SAFE_PARCEL(args.read, data); + SAFE_PARCEL(data.readStrongBinder, &captureListener); - status_t res = - captureLayers(layerHandleBinder, &outBuffer, reqDataspace, reqPixelFormat, - sourceCrop, excludeHandles, frameScale, childrenOnly); - reply->writeInt32(res); - if (res == NO_ERROR) { - reply->write(*outBuffer); - } - return NO_ERROR; + return captureLayers(args, captureListener); } case AUTHENTICATE_SURFACE: { CHECK_INTERFACE(ISurfaceComposer, data, reply); @@ -1396,19 +1373,22 @@ status_t BnSurfaceComposer::onTransact( case CREATE_DISPLAY_EVENT_CONNECTION: { CHECK_INTERFACE(ISurfaceComposer, data, reply); auto vsyncSource = static_cast<ISurfaceComposer::VsyncSource>(data.readInt32()); - auto configChanged = static_cast<ISurfaceComposer::ConfigChanged>(data.readInt32()); + EventRegistrationFlags eventRegistration = + static_cast<EventRegistration>(data.readUint32()); sp<IDisplayEventConnection> connection( - createDisplayEventConnection(vsyncSource, configChanged)); + createDisplayEventConnection(vsyncSource, eventRegistration)); reply->writeStrongBinder(IInterface::asBinder(connection)); return NO_ERROR; } case CREATE_DISPLAY: { CHECK_INTERFACE(ISurfaceComposer, data, reply); - String8 displayName = data.readString8(); - bool secure = bool(data.readInt32()); - sp<IBinder> display(createDisplay(displayName, secure)); - reply->writeStrongBinder(display); + String8 displayName; + SAFE_PARCEL(data.readString8, &displayName); + bool secure = false; + SAFE_PARCEL(data.readBool, &secure); + sp<IBinder> display = createDisplay(displayName, secure); + SAFE_PARCEL(reply->writeStrongBinder, display); return NO_ERROR; } case DESTROY_DISPLAY: { @@ -1419,7 +1399,7 @@ status_t BnSurfaceComposer::onTransact( } case GET_PHYSICAL_DISPLAY_TOKEN: { CHECK_INTERFACE(ISurfaceComposer, data, reply); - PhysicalDisplayId displayId = data.readUint64(); + PhysicalDisplayId displayId(data.readUint64()); sp<IBinder> display = getPhysicalDisplayToken(displayId); reply->writeStrongBinder(display); return NO_ERROR; @@ -1436,30 +1416,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); - if (result == NO_ERROR) { - memcpy(reply->writeInplace(sizeof(DisplayInfo)), &info, sizeof(DisplayInfo)); - } + const status_t result = getStaticDisplayInfo(display, &info); + SAFE_PARCEL(reply->writeInt32, result); + if (result != NO_ERROR) return result; + SAFE_PARCEL(reply->write, info); return NO_ERROR; } - case GET_DISPLAY_CONFIGS: { + case GET_DYNAMIC_DISPLAY_INFO: { CHECK_INTERFACE(ISurfaceComposer, data, reply); - Vector<DisplayConfig> configs; + ui::DynamicDisplayInfo info; const sp<IBinder> display = data.readStrongBinder(); - const status_t result = getDisplayConfigs(display, &configs); - reply->writeInt32(result); - if (result == NO_ERROR) { - reply->writeUint32(static_cast<uint32_t>(configs.size())); - for (size_t c = 0; c < configs.size(); ++c) { - memcpy(reply->writeInplace(sizeof(DisplayConfig)), &configs[c], - sizeof(DisplayConfig)); - } - } + 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: { @@ -1474,32 +1448,6 @@ status_t BnSurfaceComposer::onTransact( } return NO_ERROR; } - case GET_ACTIVE_CONFIG: { - CHECK_INTERFACE(ISurfaceComposer, data, reply); - sp<IBinder> display = data.readStrongBinder(); - int id = getActiveConfig(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; @@ -1520,18 +1468,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; @@ -1551,23 +1487,6 @@ status_t BnSurfaceComposer::onTransact( result = reply->writeInt32(result); return result; } - - case GET_AUTO_LOW_LATENCY_MODE_SUPPORT: { - CHECK_INTERFACE(ISurfaceComposer, data, reply); - sp<IBinder> display = nullptr; - status_t result = data.readStrongBinder(&display); - if (result != NO_ERROR) { - ALOGE("getAutoLowLatencyModeSupport failed to readStrongBinder: %d", result); - return result; - } - bool supported = false; - result = getAutoLowLatencyModeSupport(display, &supported); - if (result == NO_ERROR) { - result = reply->writeBool(supported); - } - return result; - } - case SET_AUTO_LOW_LATENCY_MODE: { CHECK_INTERFACE(ISurfaceComposer, data, reply); sp<IBinder> display = nullptr; @@ -1585,23 +1504,6 @@ status_t BnSurfaceComposer::onTransact( setAutoLowLatencyMode(display, setAllm); return result; } - - case GET_GAME_CONTENT_TYPE_SUPPORT: { - CHECK_INTERFACE(ISurfaceComposer, data, reply); - sp<IBinder> display = nullptr; - status_t result = data.readStrongBinder(&display); - if (result != NO_ERROR) { - ALOGE("getGameContentTypeSupport failed to readStrongBinder: %d", result); - return result; - } - bool supported = false; - result = getGameContentTypeSupport(display, &supported); - if (result == NO_ERROR) { - result = reply->writeBool(supported); - } - return result; - } - case SET_GAME_CONTENT_TYPE: { CHECK_INTERFACE(ISurfaceComposer, data, reply); sp<IBinder> display = nullptr; @@ -1619,7 +1521,6 @@ status_t BnSurfaceComposer::onTransact( setGameContentType(display, setGameContentTypeOn); return result; } - case CLEAR_ANIMATION_FRAME_STATS: { CHECK_INTERFACE(ISurfaceComposer, data, reply); status_t result = clearAnimationFrameStats(); @@ -1641,23 +1542,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; @@ -1823,7 +1707,11 @@ status_t BnSurfaceComposer::onTransact( } case GET_PHYSICAL_DISPLAY_IDS: { CHECK_INTERFACE(ISurfaceComposer, data, reply); - return reply->writeUint64Vector(getPhysicalDisplayIds()); + std::vector<PhysicalDisplayId> ids = getPhysicalDisplayIds(); + std::vector<uint64_t> rawIds(ids.size()); + std::transform(ids.begin(), ids.end(), rawIds.begin(), + [](PhysicalDisplayId id) { return id.value; }); + return reply->writeUint64Vector(rawIds); } case ADD_REGION_SAMPLING_LISTENER: { CHECK_INTERFACE(ISurfaceComposer, data, reply); @@ -1857,49 +1745,104 @@ status_t BnSurfaceComposer::onTransact( } return removeRegionSamplingListener(listener); } - case SET_DESIRED_DISPLAY_CONFIG_SPECS: { + case ADD_FPS_LISTENER: { + CHECK_INTERFACE(ISurfaceComposer, data, reply); + int32_t taskId; + status_t result = data.readInt32(&taskId); + if (result != NO_ERROR) { + ALOGE("addFpsListener: Failed to read layer handle"); + return result; + } + sp<gui::IFpsListener> listener; + result = data.readNullableStrongBinder(&listener); + if (result != NO_ERROR) { + ALOGE("addFpsListener: Failed to read listener"); + return result; + } + return addFpsListener(taskId, listener); + } + case REMOVE_FPS_LISTENER: { + CHECK_INTERFACE(ISurfaceComposer, data, reply); + sp<gui::IFpsListener> listener; + status_t result = data.readNullableStrongBinder(&listener); + if (result != NO_ERROR) { + ALOGE("removeFpsListener: Failed to read listener"); + return result; + } + return removeFpsListener(listener); + } + case ADD_TUNNEL_MODE_ENABLED_LISTENER: { + CHECK_INTERFACE(ISurfaceComposer, data, reply); + sp<gui::ITunnelModeEnabledListener> listener; + status_t result = data.readNullableStrongBinder(&listener); + if (result != NO_ERROR) { + ALOGE("addTunnelModeEnabledListener: Failed to read listener"); + return result; + } + return addTunnelModeEnabledListener(listener); + } + case REMOVE_TUNNEL_MODE_ENABLED_LISTENER: { + CHECK_INTERFACE(ISurfaceComposer, data, reply); + sp<gui::ITunnelModeEnabledListener> listener; + status_t result = data.readNullableStrongBinder(&listener); + if (result != NO_ERROR) { + ALOGE("removeTunnelModeEnabledListener: Failed to read listener"); + return result; + } + return removeTunnelModeEnabledListener(listener); + } + case SET_DESIRED_DISPLAY_MODE_SPECS: { CHECK_INTERFACE(ISurfaceComposer, data, reply); sp<IBinder> displayToken = data.readStrongBinder(); - int32_t defaultConfig; - status_t result = data.readInt32(&defaultConfig); + ui::DisplayModeId defaultMode; + status_t result = data.readInt32(&defaultMode); if (result != NO_ERROR) { - ALOGE("setDesiredDisplayConfigSpecs: failed to read defaultConfig: %d", result); + ALOGE("setDesiredDisplayModeSpecs: failed to read defaultMode: %d", result); + return result; + } + if (defaultMode < 0) { + ALOGE("%s: defaultMode must be non-negative but it was %d", __func__, defaultMode); + return BAD_VALUE; + } + bool allowGroupSwitching; + result = data.readBool(&allowGroupSwitching); + if (result != NO_ERROR) { + ALOGE("setDesiredDisplayModeSpecs: failed to read allowGroupSwitching: %d", result); return result; } float primaryRefreshRateMin; result = data.readFloat(&primaryRefreshRateMin); if (result != NO_ERROR) { - ALOGE("setDesiredDisplayConfigSpecs: failed to read primaryRefreshRateMin: %d", + ALOGE("setDesiredDisplayModeSpecs: failed to read primaryRefreshRateMin: %d", result); return result; } float primaryRefreshRateMax; result = data.readFloat(&primaryRefreshRateMax); if (result != NO_ERROR) { - ALOGE("setDesiredDisplayConfigSpecs: failed to read primaryRefreshRateMax: %d", + ALOGE("setDesiredDisplayModeSpecs: failed to read primaryRefreshRateMax: %d", result); return result; } float appRequestRefreshRateMin; result = data.readFloat(&appRequestRefreshRateMin); if (result != NO_ERROR) { - ALOGE("setDesiredDisplayConfigSpecs: failed to read appRequestRefreshRateMin: %d", + ALOGE("setDesiredDisplayModeSpecs: failed to read appRequestRefreshRateMin: %d", result); return result; } float appRequestRefreshRateMax; result = data.readFloat(&appRequestRefreshRateMax); if (result != NO_ERROR) { - ALOGE("setDesiredDisplayConfigSpecs: failed to read appRequestRefreshRateMax: %d", + ALOGE("setDesiredDisplayModeSpecs: failed to read appRequestRefreshRateMax: %d", result); return result; } - result = - setDesiredDisplayConfigSpecs(displayToken, defaultConfig, primaryRefreshRateMin, - primaryRefreshRateMax, appRequestRefreshRateMin, - appRequestRefreshRateMax); + result = setDesiredDisplayModeSpecs(displayToken, defaultMode, allowGroupSwitching, + primaryRefreshRateMin, primaryRefreshRateMax, + appRequestRefreshRateMin, appRequestRefreshRateMax); if (result != NO_ERROR) { - ALOGE("setDesiredDisplayConfigSpecs: failed to call setDesiredDisplayConfigSpecs: " + ALOGE("setDesiredDisplayModeSpecs: failed to call setDesiredDisplayModeSpecs: " "%d", result); return result; @@ -1907,53 +1850,60 @@ status_t BnSurfaceComposer::onTransact( reply->writeInt32(result); return result; } - case GET_DESIRED_DISPLAY_CONFIG_SPECS: { + case GET_DESIRED_DISPLAY_MODE_SPECS: { CHECK_INTERFACE(ISurfaceComposer, data, reply); sp<IBinder> displayToken = data.readStrongBinder(); - int32_t defaultConfig; + ui::DisplayModeId defaultMode; + bool allowGroupSwitching; float primaryRefreshRateMin; float primaryRefreshRateMax; float appRequestRefreshRateMin; float appRequestRefreshRateMax; status_t result = - getDesiredDisplayConfigSpecs(displayToken, &defaultConfig, - &primaryRefreshRateMin, &primaryRefreshRateMax, - &appRequestRefreshRateMin, - &appRequestRefreshRateMax); + getDesiredDisplayModeSpecs(displayToken, &defaultMode, &allowGroupSwitching, + &primaryRefreshRateMin, &primaryRefreshRateMax, + &appRequestRefreshRateMin, + &appRequestRefreshRateMax); if (result != NO_ERROR) { - ALOGE("getDesiredDisplayConfigSpecs: failed to get getDesiredDisplayConfigSpecs: " + ALOGE("getDesiredDisplayModeSpecs: failed to get getDesiredDisplayModeSpecs: " "%d", result); return result; } - result = reply->writeInt32(defaultConfig); + result = reply->writeInt32(defaultMode); if (result != NO_ERROR) { - ALOGE("getDesiredDisplayConfigSpecs: failed to write defaultConfig: %d", result); + ALOGE("getDesiredDisplayModeSpecs: failed to write defaultMode: %d", result); + return result; + } + result = reply->writeBool(allowGroupSwitching); + if (result != NO_ERROR) { + ALOGE("getDesiredDisplayModeSpecs: failed to write allowGroupSwitching: %d", + result); return result; } result = reply->writeFloat(primaryRefreshRateMin); if (result != NO_ERROR) { - ALOGE("getDesiredDisplayConfigSpecs: failed to write primaryRefreshRateMin: %d", + ALOGE("getDesiredDisplayModeSpecs: failed to write primaryRefreshRateMin: %d", result); return result; } result = reply->writeFloat(primaryRefreshRateMax); if (result != NO_ERROR) { - ALOGE("getDesiredDisplayConfigSpecs: failed to write primaryRefreshRateMax: %d", + ALOGE("getDesiredDisplayModeSpecs: failed to write primaryRefreshRateMax: %d", result); return result; } result = reply->writeFloat(appRequestRefreshRateMin); if (result != NO_ERROR) { - ALOGE("getDesiredDisplayConfigSpecs: failed to write appRequestRefreshRateMin: %d", + ALOGE("getDesiredDisplayModeSpecs: failed to write appRequestRefreshRateMin: %d", result); return result; } result = reply->writeFloat(appRequestRefreshRateMax); if (result != NO_ERROR) { - ALOGE("getDesiredDisplayConfigSpecs: failed to write appRequestRefreshRateMax: %d", + ALOGE("getDesiredDisplayModeSpecs: failed to write appRequestRefreshRateMax: %d", result); return result; } @@ -1981,23 +1931,55 @@ status_t BnSurfaceComposer::onTransact( ALOGE("setDisplayBrightness: failed to read display token: %d", error); return error; } - float brightness = -1.0f; - error = data.readFloat(&brightness); + gui::DisplayBrightness brightness; + error = data.readParcelable(&brightness); if (error != NO_ERROR) { ALOGE("setDisplayBrightness: failed to read brightness: %d", error); return error; } return setDisplayBrightness(displayToken, brightness); } - case NOTIFY_POWER_HINT: { + case ADD_HDR_LAYER_INFO_LISTENER: { CHECK_INTERFACE(ISurfaceComposer, data, reply); - int32_t hintId; - status_t error = data.readInt32(&hintId); + sp<IBinder> displayToken; + status_t error = data.readNullableStrongBinder(&displayToken); + if (error != NO_ERROR) { + ALOGE("addHdrLayerInfoListener: Failed to read display token"); + return error; + } + sp<gui::IHdrLayerInfoListener> listener; + error = data.readNullableStrongBinder(&listener); if (error != NO_ERROR) { - ALOGE("notifyPowerHint: failed to read hintId: %d", error); + ALOGE("addHdrLayerInfoListener: Failed to read listener"); return error; } - return notifyPowerHint(hintId); + return addHdrLayerInfoListener(displayToken, listener); + } + case REMOVE_HDR_LAYER_INFO_LISTENER: { + CHECK_INTERFACE(ISurfaceComposer, data, reply); + sp<IBinder> displayToken; + status_t error = data.readNullableStrongBinder(&displayToken); + if (error != NO_ERROR) { + ALOGE("removeHdrLayerInfoListener: Failed to read display token"); + return error; + } + sp<gui::IHdrLayerInfoListener> listener; + error = data.readNullableStrongBinder(&listener); + if (error != NO_ERROR) { + ALOGE("removeHdrLayerInfoListener: Failed to read listener"); + return error; + } + return removeHdrLayerInfoListener(displayToken, listener); + } + case NOTIFY_POWER_BOOST: { + CHECK_INTERFACE(ISurfaceComposer, data, reply); + int32_t boostId; + status_t error = data.readInt32(&boostId); + if (error != NO_ERROR) { + ALOGE("notifyPowerBoost: failed to read boostId: %d", error); + return error; + } + return notifyPowerBoost(boostId); } case SET_GLOBAL_SHADOW_SETTINGS: { CHECK_INTERFACE(ISurfaceComposer, data, reply); @@ -2021,30 +2003,24 @@ status_t BnSurfaceComposer::onTransact( case SET_FRAME_RATE: { CHECK_INTERFACE(ISurfaceComposer, data, reply); sp<IBinder> binder; - status_t err = data.readStrongBinder(&binder); - if (err != NO_ERROR) { - ALOGE("setFrameRate: failed to read strong binder: %s (%d)", strerror(-err), -err); - return err; - } + SAFE_PARCEL(data.readStrongBinder, &binder); + sp<IGraphicBufferProducer> surface = interface_cast<IGraphicBufferProducer>(binder); if (!surface) { - ALOGE("setFrameRate: failed to cast to IGraphicBufferProducer: %s (%d)", - strerror(-err), -err); - return err; + ALOGE("setFrameRate: failed to cast to IGraphicBufferProducer"); + return BAD_VALUE; } float frameRate; - err = data.readFloat(&frameRate); - if (err != NO_ERROR) { - ALOGE("setFrameRate: failed to read float: %s (%d)", strerror(-err), -err); - return err; - } + SAFE_PARCEL(data.readFloat, &frameRate); + int8_t compatibility; - err = data.readByte(&compatibility); - if (err != NO_ERROR) { - ALOGE("setFrameRate: failed to read byte: %s (%d)", strerror(-err), -err); - return err; - } - status_t result = setFrameRate(surface, frameRate, compatibility); + SAFE_PARCEL(data.readByte, &compatibility); + + int8_t changeFrameRateStrategy; + SAFE_PARCEL(data.readByte, &changeFrameRateStrategy); + + status_t result = + setFrameRate(surface, frameRate, compatibility, changeFrameRateStrategy); reply->writeInt32(result); return NO_ERROR; } @@ -2058,6 +2034,79 @@ status_t BnSurfaceComposer::onTransact( } return NO_ERROR; } + case SET_FRAME_TIMELINE_INFO: { + CHECK_INTERFACE(ISurfaceComposer, data, reply); + sp<IBinder> binder; + status_t err = data.readStrongBinder(&binder); + if (err != NO_ERROR) { + ALOGE("setFrameTimelineInfo: failed to read strong binder: %s (%d)", strerror(-err), + -err); + return err; + } + sp<IGraphicBufferProducer> surface = interface_cast<IGraphicBufferProducer>(binder); + if (!surface) { + ALOGE("setFrameTimelineInfo: failed to cast to IGraphicBufferProducer: %s (%d)", + strerror(-err), -err); + return err; + } + + FrameTimelineInfo frameTimelineInfo; + SAFE_PARCEL(frameTimelineInfo.read, data); + + status_t result = setFrameTimelineInfo(surface, frameTimelineInfo); + reply->writeInt32(result); + return NO_ERROR; + } + case ADD_TRANSACTION_TRACE_LISTENER: { + CHECK_INTERFACE(ISurfaceComposer, data, reply); + sp<gui::ITransactionTraceListener> listener; + SAFE_PARCEL(data.readStrongBinder, &listener); + + return addTransactionTraceListener(listener); + } + case GET_GPU_CONTEXT_PRIORITY: { + CHECK_INTERFACE(ISurfaceComposer, data, reply); + int priority = getGPUContextPriority(); + SAFE_PARCEL(reply->writeInt32, priority); + return NO_ERROR; + } + case GET_MAX_ACQUIRED_BUFFER_COUNT: { + CHECK_INTERFACE(ISurfaceComposer, data, reply); + int buffers = 0; + int err = getMaxAcquiredBufferCount(&buffers); + if (err != NO_ERROR) { + return err; + } + SAFE_PARCEL(reply->writeInt32, buffers); + return NO_ERROR; + } + case OVERRIDE_HDR_TYPES: { + CHECK_INTERFACE(ISurfaceComposer, data, reply); + sp<IBinder> display = nullptr; + SAFE_PARCEL(data.readStrongBinder, &display); + + std::vector<int32_t> hdrTypes; + SAFE_PARCEL(data.readInt32Vector, &hdrTypes); + + std::vector<ui::Hdr> hdrTypesVector; + for (int i : hdrTypes) { + hdrTypesVector.push_back(static_cast<ui::Hdr>(i)); + } + return overrideHdrTypes(display, hdrTypesVector); + } + case ON_PULL_ATOM: { + CHECK_INTERFACE(ISurfaceComposer, data, reply); + int32_t atomId = 0; + SAFE_PARCEL(data.readInt32, &atomId); + + std::string pulledData; + bool success; + status_t err = onPullAtom(atomId, &pulledData, &success); + SAFE_PARCEL(reply->writeByteArray, pulledData.size(), + reinterpret_cast<const uint8_t*>(pulledData.data())); + SAFE_PARCEL(reply->writeBool, success); + return err; + } default: { return BBinder::onTransact(code, data, reply, flags); } |