diff --git a/services/surfaceflinger/Android.mk b/services/surfaceflinger/Android.mk
index 20fe0fd..4987a18 100644
--- a/services/surfaceflinger/Android.mk
+++ b/services/surfaceflinger/Android.mk
@@ -42,6 +42,7 @@
 LOCAL_C_INCLUDES := \
     frameworks/native/vulkan/include \
     external/vulkan-validation-layers/libs/vkjson \
+    system/libhwbinder/fast_msgq/include \
 
 LOCAL_CFLAGS := -DLOG_TAG=\"SurfaceFlinger\"
 LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES
@@ -130,13 +131,14 @@
 
 LOCAL_CFLAGS += -fvisibility=hidden -Werror=format
 
-LOCAL_STATIC_LIBRARIES := libtrace_proto libvkjson
+LOCAL_STATIC_LIBRARIES := libhwcomposer-command-buffer libtrace_proto libvkjson
 LOCAL_SHARED_LIBRARIES := \
     android.hardware.graphics.allocator@2.0 \
     android.hardware.graphics.composer@2.1 \
     libcutils \
     liblog \
     libdl \
+    libfmq \
     libhardware \
     libhidlbase \
     libhidltransport \
@@ -150,6 +152,7 @@
     libgui \
     libpowermanager \
     libvulkan \
+    libsync \
     libprotobuf-cpp-lite \
     libbase \
     android.hardware.power@1.0
diff --git a/services/surfaceflinger/DisplayHardware/ComposerHal.cpp b/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
index 06f67ba..63fd1e8 100644
--- a/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
+++ b/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
@@ -110,17 +110,29 @@
 } // anonymous namespace
 
 Composer::Composer()
+    : mWriter(kWriterInitialSize)
 {
-    mService = IComposer::getService("hwcomposer");
-    if (mService == nullptr) {
+    mComposer = IComposer::getService("hwcomposer");
+    if (mComposer == nullptr) {
         LOG_ALWAYS_FATAL("failed to get hwcomposer service");
     }
+
+    mComposer->createClient(
+            [&](const auto& tmpError, const auto& tmpClient)
+            {
+                if (tmpError == Error::NONE) {
+                    mClient = tmpClient;
+                }
+            });
+    if (mClient == nullptr) {
+        LOG_ALWAYS_FATAL("failed to create composer client");
+    }
 }
 
-std::vector<IComposer::Capability> Composer::getCapabilities() const
+std::vector<IComposer::Capability> Composer::getCapabilities()
 {
     std::vector<IComposer::Capability> capabilities;
-    mService->getCapabilities(
+    mComposer->getCapabilities(
             [&](const auto& tmpCapabilities) {
                 assignFromHidlVec(capabilities, tmpCapabilities);
             });
@@ -128,35 +140,36 @@
     return capabilities;
 }
 
-std::string Composer::dumpDebugInfo() const
+std::string Composer::dumpDebugInfo()
 {
     std::string info;
-    mService->dumpDebugInfo([&](const auto& tmpInfo) {
+    mComposer->dumpDebugInfo([&](const auto& tmpInfo) {
         info = tmpInfo.c_str();
     });
 
     return info;
 }
 
-void Composer::registerCallback(const sp<IComposerCallback>& callback) const
+void Composer::registerCallback(const sp<IComposerCallback>& callback)
 {
-    auto ret = mService->registerCallback(callback);
+    auto ret = mClient->registerCallback(callback);
     if (!ret.getStatus().isOk()) {
         ALOGE("failed to register IComposerCallback");
     }
 }
 
-uint32_t Composer::getMaxVirtualDisplayCount() const
+uint32_t Composer::getMaxVirtualDisplayCount()
 {
-    auto ret = mService->getMaxVirtualDisplayCount();
+    auto ret = mClient->getMaxVirtualDisplayCount();
     return unwrapRet(ret, 0);
 }
 
 Error Composer::createVirtualDisplay(uint32_t width, uint32_t height,
-            PixelFormat& format, Display& display) const
+            PixelFormat& format, Display& display)
 {
+    const uint32_t bufferSlotCount = 1;
     Error error = kDefaultError;
-    mService->createVirtualDisplay(width, height, format,
+    mClient->createVirtualDisplay(width, height, format, bufferSlotCount,
             [&](const auto& tmpError, const auto& tmpDisplay,
                 const auto& tmpFormat) {
                 error = tmpError;
@@ -171,22 +184,24 @@
     return error;
 }
 
-Error Composer::destroyVirtualDisplay(Display display) const
+Error Composer::destroyVirtualDisplay(Display display)
 {
-    auto ret = mService->destroyVirtualDisplay(display);
+    auto ret = mClient->destroyVirtualDisplay(display);
     return unwrapRet(ret);
 }
 
-Error Composer::acceptDisplayChanges(Display display) const
+Error Composer::acceptDisplayChanges(Display display)
 {
-    auto ret = mService->acceptDisplayChanges(display);
-    return unwrapRet(ret);
+    mWriter.selectDisplay(display);
+    mWriter.acceptDisplayChanges();
+    return Error::NONE;
 }
 
-Error Composer::createLayer(Display display, Layer& layer) const
+Error Composer::createLayer(Display display, Layer& layer)
 {
+    const uint32_t bufferSlotCount = 1;
     Error error = kDefaultError;
-    mService->createLayer(display,
+    mClient->createLayer(display, bufferSlotCount,
             [&](const auto& tmpError, const auto& tmpLayer) {
                 error = tmpError;
                 if (error != Error::NONE) {
@@ -199,16 +214,16 @@
     return error;
 }
 
-Error Composer::destroyLayer(Display display, Layer layer) const
+Error Composer::destroyLayer(Display display, Layer layer)
 {
-    auto ret = mService->destroyLayer(display, layer);
+    auto ret = mClient->destroyLayer(display, layer);
     return unwrapRet(ret);
 }
 
-Error Composer::getActiveConfig(Display display, Config& config) const
+Error Composer::getActiveConfig(Display display, Config& config)
 {
     Error error = kDefaultError;
-    mService->getActiveConfig(display,
+    mClient->getActiveConfig(display,
             [&](const auto& tmpError, const auto& tmpConfig) {
                 error = tmpError;
                 if (error != Error::NONE) {
@@ -223,29 +238,17 @@
 
 Error Composer::getChangedCompositionTypes(Display display,
         std::vector<Layer>& layers,
-        std::vector<IComposer::Composition>& types) const
+        std::vector<IComposerClient::Composition>& types)
 {
-    Error error = kDefaultError;
-    mService->getChangedCompositionTypes(display,
-            [&](const auto& tmpError, const auto& tmpLayers,
-                const auto& tmpTypes) {
-                error = tmpError;
-                if (error != Error::NONE) {
-                    return;
-                }
-
-                assignFromHidlVec(layers, tmpLayers);
-                assignFromHidlVec(types, tmpTypes);
-            });
-
-    return error;
+    mReader.takeChangedCompositionTypes(display, layers, types);
+    return Error::NONE;
 }
 
 Error Composer::getColorModes(Display display,
-        std::vector<ColorMode>& modes) const
+        std::vector<ColorMode>& modes)
 {
     Error error = kDefaultError;
-    mService->getColorModes(display,
+    mClient->getColorModes(display,
             [&](const auto& tmpError, const auto& tmpModes) {
                 error = tmpError;
                 if (error != Error::NONE) {
@@ -259,10 +262,10 @@
 }
 
 Error Composer::getDisplayAttribute(Display display, Config config,
-        IComposer::Attribute attribute, int32_t& value) const
+        IComposerClient::Attribute attribute, int32_t& value)
 {
     Error error = kDefaultError;
-    mService->getDisplayAttribute(display, config, attribute,
+    mClient->getDisplayAttribute(display, config, attribute,
             [&](const auto& tmpError, const auto& tmpValue) {
                 error = tmpError;
                 if (error != Error::NONE) {
@@ -276,10 +279,10 @@
 }
 
 Error Composer::getDisplayConfigs(Display display,
-        std::vector<Config>& configs) const
+        std::vector<Config>& configs)
 {
     Error error = kDefaultError;
-    mService->getDisplayConfigs(display,
+    mClient->getDisplayConfigs(display,
             [&](const auto& tmpError, const auto& tmpConfigs) {
                 error = tmpError;
                 if (error != Error::NONE) {
@@ -292,10 +295,10 @@
     return error;
 }
 
-Error Composer::getDisplayName(Display display, std::string& name) const
+Error Composer::getDisplayName(Display display, std::string& name)
 {
     Error error = kDefaultError;
-    mService->getDisplayName(display,
+    mClient->getDisplayName(display,
             [&](const auto& tmpError, const auto& tmpName) {
                 error = tmpError;
                 if (error != Error::NONE) {
@@ -310,29 +313,17 @@
 
 Error Composer::getDisplayRequests(Display display,
         uint32_t& displayRequestMask, std::vector<Layer>& layers,
-        std::vector<uint32_t>& layerRequestMasks) const
+        std::vector<uint32_t>& layerRequestMasks)
 {
-    Error error = kDefaultError;
-    mService->getDisplayRequests(display,
-            [&](const auto& tmpError, const auto& tmpDisplayRequestMask,
-                const auto& tmpLayers, const auto& tmpLayerRequestMasks) {
-                error = tmpError;
-                if (error != Error::NONE) {
-                    return;
-                }
-
-                displayRequestMask = tmpDisplayRequestMask;
-                assignFromHidlVec(layers, tmpLayers);
-                assignFromHidlVec(layerRequestMasks, tmpLayerRequestMasks);
-            });
-
-    return error;
+    mReader.takeDisplayRequests(display, displayRequestMask,
+            layers, layerRequestMasks);
+    return Error::NONE;
 }
 
-Error Composer::getDisplayType(Display display, IComposer::DisplayType& type) const
+Error Composer::getDisplayType(Display display, IComposerClient::DisplayType& type)
 {
     Error error = kDefaultError;
-    mService->getDisplayType(display,
+    mClient->getDisplayType(display,
             [&](const auto& tmpError, const auto& tmpType) {
                 error = tmpError;
                 if (error != Error::NONE) {
@@ -345,10 +336,10 @@
     return error;
 }
 
-Error Composer::getDozeSupport(Display display, bool& support) const
+Error Composer::getDozeSupport(Display display, bool& support)
 {
     Error error = kDefaultError;
-    mService->getDozeSupport(display,
+    mClient->getDozeSupport(display,
             [&](const auto& tmpError, const auto& tmpSupport) {
                 error = tmpError;
                 if (error != Error::NONE) {
@@ -363,10 +354,10 @@
 
 Error Composer::getHdrCapabilities(Display display, std::vector<Hdr>& types,
         float& maxLuminance, float& maxAverageLuminance,
-        float& minLuminance) const
+        float& minLuminance)
 {
     Error error = kDefaultError;
-    mService->getHdrCapabilities(display,
+    mClient->getHdrCapabilities(display,
             [&](const auto& tmpError, const auto& tmpTypes,
                 const auto& tmpMaxLuminance,
                 const auto& tmpMaxAverageLuminance,
@@ -386,266 +377,574 @@
 }
 
 Error Composer::getReleaseFences(Display display, std::vector<Layer>& layers,
-        std::vector<int>& releaseFences) const
+        std::vector<int>& releaseFences)
 {
-    Error error = kDefaultError;
-    mService->getReleaseFences(display,
-            [&](const auto& tmpError, const auto& tmpLayers,
-                const auto& tmpReleaseFences) {
-                error = tmpError;
-                if (error != Error::NONE) {
-                    return;
-                }
-
-                if (static_cast<int>(tmpLayers.size()) !=
-                        tmpReleaseFences->numFds) {
-                    ALOGE("invalid releaseFences outputs: "
-                          "layer count %zu != fence count %d",
-                          tmpLayers.size(), tmpReleaseFences->numFds);
-                    error = Error::NO_RESOURCES;
-                    return;
-                }
-
-                // dup the file descriptors
-                std::vector<int> tmpFds;
-                tmpFds.reserve(tmpReleaseFences->numFds);
-                for (int i = 0; i < tmpReleaseFences->numFds; i++) {
-                    int fd = dup(tmpReleaseFences->data[i]);
-                    if (fd < 0) {
-                        break;
-                    }
-                    tmpFds.push_back(fd);
-                }
-                if (static_cast<int>(tmpFds.size()) <
-                        tmpReleaseFences->numFds) {
-                    for (auto fd : tmpFds) {
-                        close(fd);
-                    }
-
-                    error = Error::NO_RESOURCES;
-                    return;
-                }
-
-                assignFromHidlVec(layers, tmpLayers);
-                releaseFences = std::move(tmpFds);
-            });
-
-    return error;
+    mReader.takeReleaseFences(display, layers, releaseFences);
+    return Error::NONE;
 }
 
-Error Composer::presentDisplay(Display display, int& presentFence) const
+Error Composer::presentDisplay(Display display, int& presentFence)
 {
-    Error error = kDefaultError;
-    mService->presentDisplay(display,
-            [&](const auto& tmpError, const auto& tmpPresentFence) {
-                error = tmpError;
-                if (error != Error::NONE) {
-                    return;
-                }
+    mWriter.selectDisplay(display);
+    mWriter.presentDisplay();
 
-                if (tmpPresentFence->numFds == 1) {
-                    int fd = dup(tmpPresentFence->data[0]);
-                    if (fd >= 0) {
-                        presentFence = fd;
-                    } else {
-                        error = Error::NO_RESOURCES;
-                    }
-                } else {
-                    presentFence = -1;
-                }
-            });
+    Error error = execute();
+    if (error != Error::NONE) {
+        return error;
+    }
 
-    return error;
+    mReader.takePresentFence(display, presentFence);
+
+    return Error::NONE;
 }
 
-Error Composer::setActiveConfig(Display display, Config config) const
+Error Composer::setActiveConfig(Display display, Config config)
 {
-    auto ret = mService->setActiveConfig(display, config);
+    auto ret = mClient->setActiveConfig(display, config);
     return unwrapRet(ret);
 }
 
 Error Composer::setClientTarget(Display display, const native_handle_t* target,
         int acquireFence, Dataspace dataspace,
-        const std::vector<IComposer::Rect>& damage) const
+        const std::vector<IComposerClient::Rect>& damage)
 {
-    BufferHandle tmpTarget(target);
-    FenceHandle tmpAcquireFence(acquireFence, true);
-
-    hidl_vec<IComposer::Rect> tmpDamage;
-    tmpDamage.setToExternal(const_cast<IComposer::Rect*>(damage.data()),
-            damage.size());
-
-    auto ret = mService->setClientTarget(display, tmpTarget,
-            tmpAcquireFence, dataspace, tmpDamage);
-    return unwrapRet(ret);
+    mWriter.selectDisplay(display);
+    mWriter.setClientTarget(0, target, acquireFence, dataspace, damage);
+    return Error::NONE;
 }
 
-Error Composer::setColorMode(Display display, ColorMode mode) const
+Error Composer::setColorMode(Display display, ColorMode mode)
 {
-    auto ret = mService->setColorMode(display, mode);
+    auto ret = mClient->setColorMode(display, mode);
     return unwrapRet(ret);
 }
 
 Error Composer::setColorTransform(Display display, const float* matrix,
-        ColorTransform hint) const
+        ColorTransform hint)
 {
-    hidl_vec<float> tmpMatrix;
-    tmpMatrix.setToExternal(const_cast<float*>(matrix), 16);
-
-    auto ret = mService->setColorTransform(display, tmpMatrix, hint);
-    return unwrapRet(ret);
+    mWriter.selectDisplay(display);
+    mWriter.setColorTransform(matrix, hint);
+    return Error::NONE;
 }
 
 Error Composer::setOutputBuffer(Display display, const native_handle_t* buffer,
-        int releaseFence) const
+        int releaseFence)
 {
-    BufferHandle tmpBuffer(buffer);
-    FenceHandle tmpReleaseFence(releaseFence, false);
+    mWriter.selectDisplay(display);
+    mWriter.setOutputBuffer(0, buffer, dup(releaseFence));
+    return Error::NONE;
+}
 
-    auto ret = mService->setOutputBuffer(display, tmpBuffer, tmpReleaseFence);
+Error Composer::setPowerMode(Display display, IComposerClient::PowerMode mode)
+{
+    auto ret = mClient->setPowerMode(display, mode);
     return unwrapRet(ret);
 }
 
-Error Composer::setPowerMode(Display display, IComposer::PowerMode mode) const
+Error Composer::setVsyncEnabled(Display display, IComposerClient::Vsync enabled)
 {
-    auto ret = mService->setPowerMode(display, mode);
+    auto ret = mClient->setVsyncEnabled(display, enabled);
     return unwrapRet(ret);
 }
 
-Error Composer::setVsyncEnabled(Display display, IComposer::Vsync enabled) const
+Error Composer::setClientTargetSlotCount(Display display)
 {
-    auto ret = mService->setVsyncEnabled(display, enabled);
+    const uint32_t bufferSlotCount = 1;
+    auto ret = mClient->setClientTargetSlotCount(display, bufferSlotCount);
     return unwrapRet(ret);
 }
 
-Error Composer::validateDisplay(Display display, uint32_t& numTypes, uint32_t&
-        numRequests) const
+Error Composer::validateDisplay(Display display, uint32_t& numTypes,
+        uint32_t& numRequests)
 {
+    mWriter.selectDisplay(display);
+    mWriter.validateDisplay();
+
+    Error error = execute();
+    if (error != Error::NONE) {
+        return error;
+    }
+
+    mReader.hasChanges(display, numTypes, numRequests);
+
+    return Error::NONE;
+}
+
+Error Composer::setCursorPosition(Display display, Layer layer,
+        int32_t x, int32_t y)
+{
+    mWriter.selectDisplay(display);
+    mWriter.selectLayer(layer);
+    mWriter.setLayerCursorPosition(x, y);
+    return Error::NONE;
+}
+
+Error Composer::setLayerBuffer(Display display, Layer layer,
+        const native_handle_t* buffer, int acquireFence)
+{
+    mWriter.selectDisplay(display);
+    mWriter.selectLayer(layer);
+    mWriter.setLayerBuffer(0, buffer, acquireFence);
+    return Error::NONE;
+}
+
+Error Composer::setLayerSurfaceDamage(Display display, Layer layer,
+        const std::vector<IComposerClient::Rect>& damage)
+{
+    mWriter.selectDisplay(display);
+    mWriter.selectLayer(layer);
+    mWriter.setLayerSurfaceDamage(damage);
+    return Error::NONE;
+}
+
+Error Composer::setLayerBlendMode(Display display, Layer layer,
+        IComposerClient::BlendMode mode)
+{
+    mWriter.selectDisplay(display);
+    mWriter.selectLayer(layer);
+    mWriter.setLayerBlendMode(mode);
+    return Error::NONE;
+}
+
+Error Composer::setLayerColor(Display display, Layer layer,
+        const IComposerClient::Color& color)
+{
+    mWriter.selectDisplay(display);
+    mWriter.selectLayer(layer);
+    mWriter.setLayerColor(color);
+    return Error::NONE;
+}
+
+Error Composer::setLayerCompositionType(Display display, Layer layer,
+        IComposerClient::Composition type)
+{
+    mWriter.selectDisplay(display);
+    mWriter.selectLayer(layer);
+    mWriter.setLayerCompositionType(type);
+    return Error::NONE;
+}
+
+Error Composer::setLayerDataspace(Display display, Layer layer,
+        Dataspace dataspace)
+{
+    mWriter.selectDisplay(display);
+    mWriter.selectLayer(layer);
+    mWriter.setLayerDataspace(dataspace);
+    return Error::NONE;
+}
+
+Error Composer::setLayerDisplayFrame(Display display, Layer layer,
+        const IComposerClient::Rect& frame)
+{
+    mWriter.selectDisplay(display);
+    mWriter.selectLayer(layer);
+    mWriter.setLayerDisplayFrame(frame);
+    return Error::NONE;
+}
+
+Error Composer::setLayerPlaneAlpha(Display display, Layer layer,
+        float alpha)
+{
+    mWriter.selectDisplay(display);
+    mWriter.selectLayer(layer);
+    mWriter.setLayerPlaneAlpha(alpha);
+    return Error::NONE;
+}
+
+Error Composer::setLayerSidebandStream(Display display, Layer layer,
+        const native_handle_t* stream)
+{
+    mWriter.selectDisplay(display);
+    mWriter.selectLayer(layer);
+    mWriter.setLayerSidebandStream(stream);
+    return Error::NONE;
+}
+
+Error Composer::setLayerSourceCrop(Display display, Layer layer,
+        const IComposerClient::FRect& crop)
+{
+    mWriter.selectDisplay(display);
+    mWriter.selectLayer(layer);
+    mWriter.setLayerSourceCrop(crop);
+    return Error::NONE;
+}
+
+Error Composer::setLayerTransform(Display display, Layer layer,
+        Transform transform)
+{
+    mWriter.selectDisplay(display);
+    mWriter.selectLayer(layer);
+    mWriter.setLayerTransform(transform);
+    return Error::NONE;
+}
+
+Error Composer::setLayerVisibleRegion(Display display, Layer layer,
+        const std::vector<IComposerClient::Rect>& visible)
+{
+    mWriter.selectDisplay(display);
+    mWriter.selectLayer(layer);
+    mWriter.setLayerVisibleRegion(visible);
+    return Error::NONE;
+}
+
+Error Composer::setLayerZOrder(Display display, Layer layer, uint32_t z)
+{
+    mWriter.selectDisplay(display);
+    mWriter.selectLayer(layer);
+    mWriter.setLayerZOrder(z);
+    return Error::NONE;
+}
+
+Error Composer::execute()
+{
+    // prepare input command queue
+    bool queueChanged = false;
+    uint32_t commandLength = 0;
+    hidl_vec<hidl_handle> commandHandles;
+    if (!mWriter.writeQueue(queueChanged, commandLength, commandHandles)) {
+        mWriter.reset();
+        return Error::NO_RESOURCES;
+    }
+
+    // set up new input command queue if necessary
+    if (queueChanged) {
+        auto ret = mClient->setInputCommandQueue(*mWriter.getMQDescriptor());
+        auto error = unwrapRet(ret);
+        if (error != Error::NONE) {
+            mWriter.reset();
+            return error;
+        }
+    }
+
     Error error = kDefaultError;
-    mService->validateDisplay(display,
-            [&](const auto& tmpError, const auto& tmpNumTypes,
-                const auto& tmpNumRequests) {
+    mClient->executeCommands(commandLength, commandHandles,
+            [&](const auto& tmpError, const auto& tmpOutChanged,
+                const auto& tmpOutLength, const auto& tmpOutHandles)
+            {
                 error = tmpError;
+
+                // set up new output command queue if necessary
+                if (error == Error::NONE && tmpOutChanged) {
+                    error = kDefaultError;
+                    mClient->getOutputCommandQueue(
+                            [&](const auto& tmpError,
+                                const auto& tmpDescriptor)
+                            {
+                                error = tmpError;
+                                if (error != Error::NONE) {
+                                    return;
+                                }
+
+                                mReader.setMQDescriptor(tmpDescriptor);
+                            });
+                }
+
                 if (error != Error::NONE) {
                     return;
                 }
 
-                numTypes = tmpNumTypes;
-                numRequests = tmpNumRequests;
+                if (mReader.readQueue(tmpOutLength, tmpOutHandles)) {
+                    error = mReader.parse();
+                    mReader.reset();
+                } else {
+                    error = Error::NO_RESOURCES;
+                }
             });
 
+    if (error == Error::NONE) {
+        std::vector<CommandReader::CommandError> commandErrors =
+            mReader.takeErrors();
+
+        for (const auto& cmdErr : commandErrors) {
+            auto command = mWriter.getCommand(cmdErr.location);
+
+            if (command == IComposerClient::Command::VALIDATE_DISPLAY ||
+                command == IComposerClient::Command::PRESENT_DISPLAY) {
+                error = cmdErr.error;
+            } else {
+                ALOGW("command 0x%x generated error %d",
+                        command, cmdErr.error);
+            }
+        }
+    }
+
+    mWriter.reset();
+
     return error;
 }
 
-Error Composer::setCursorPosition(Display display, Layer layer,
-        int32_t x, int32_t y) const
+CommandReader::~CommandReader()
 {
-    auto ret = mService->setCursorPosition(display, layer, x, y);
-    return unwrapRet(ret);
+    resetData();
 }
 
-Error Composer::setLayerBuffer(Display display, Layer layer,
-        const native_handle_t* buffer, int acquireFence) const
+Error CommandReader::parse()
 {
-    BufferHandle tmpBuffer(buffer);
-    FenceHandle tmpAcquireFence(acquireFence, true);
+    resetData();
 
-    auto ret = mService->setLayerBuffer(display, layer,
-            tmpBuffer, tmpAcquireFence);
-    return unwrapRet(ret);
+    IComposerClient::Command command;
+    uint16_t length = 0;
+
+    while (!isEmpty()) {
+        if (!beginCommand(command, length)) {
+            break;
+        }
+
+        bool parsed = false;
+        switch (command) {
+        case IComposerClient::Command::SELECT_DISPLAY:
+            parsed = parseSelectDisplay(length);
+            break;
+        case IComposerClient::Command::SET_ERROR:
+            parsed = parseSetError(length);
+            break;
+        case IComposerClient::Command::SET_CHANGED_COMPOSITION_TYPES:
+            parsed = parseSetChangedCompositionTypes(length);
+            break;
+        case IComposerClient::Command::SET_DISPLAY_REQUESTS:
+            parsed = parseSetDisplayRequests(length);
+            break;
+        case IComposerClient::Command::SET_PRESENT_FENCE:
+            parsed = parseSetPresentFence(length);
+            break;
+        case IComposerClient::Command::SET_RELEASE_FENCES:
+            parsed = parseSetReleaseFences(length);
+            break;
+        default:
+            parsed = false;
+            break;
+        }
+
+        endCommand();
+
+        if (!parsed) {
+            ALOGE("failed to parse command 0x%x length %" PRIu16,
+                    command, length);
+            break;
+        }
+    }
+
+    return isEmpty() ? Error::NONE : Error::NO_RESOURCES;
 }
 
-Error Composer::setLayerSurfaceDamage(Display display, Layer layer,
-        const std::vector<IComposer::Rect>& damage) const
+bool CommandReader::parseSelectDisplay(uint16_t length)
 {
-    hidl_vec<IComposer::Rect> tmpDamage;
-    tmpDamage.setToExternal(const_cast<IComposer::Rect*>(damage.data()),
-            damage.size());
+    if (length != CommandWriter::kSelectDisplayLength) {
+        return false;
+    }
 
-    auto ret = mService->setLayerSurfaceDamage(display, layer, tmpDamage);
-    return unwrapRet(ret);
+    mCurrentReturnData = &mReturnData[read64()];
+
+    return true;
 }
 
-Error Composer::setLayerBlendMode(Display display, Layer layer,
-        IComposer::BlendMode mode) const
+bool CommandReader::parseSetError(uint16_t length)
 {
-    auto ret = mService->setLayerBlendMode(display, layer, mode);
-    return unwrapRet(ret);
+    if (length != CommandWriter::kSetErrorLength) {
+        return false;
+    }
+
+    auto location = read();
+    auto error = static_cast<Error>(readSigned());
+
+    mErrors.emplace_back(CommandError{location, error});
+
+    return true;
 }
 
-Error Composer::setLayerColor(Display display, Layer layer,
-        const IComposer::Color& color) const
+bool CommandReader::parseSetChangedCompositionTypes(uint16_t length)
 {
-    auto ret = mService->setLayerColor(display, layer, color);
-    return unwrapRet(ret);
+    // (layer id, composition type) pairs
+    if (length % 3 != 0 || !mCurrentReturnData) {
+        return false;
+    }
+
+    uint32_t count = length / 3;
+    mCurrentReturnData->changedLayers.reserve(count);
+    mCurrentReturnData->compositionTypes.reserve(count);
+    while (count > 0) {
+        auto layer = read64();
+        auto type = static_cast<IComposerClient::Composition>(readSigned());
+
+        mCurrentReturnData->changedLayers.push_back(layer);
+        mCurrentReturnData->compositionTypes.push_back(type);
+
+        count--;
+    }
+
+    return true;
 }
 
-Error Composer::setLayerCompositionType(Display display, Layer layer,
-        IComposer::Composition type) const
+bool CommandReader::parseSetDisplayRequests(uint16_t length)
 {
-    auto ret = mService->setLayerCompositionType(display, layer, type);
-    return unwrapRet(ret);
+    // display requests followed by (layer id, layer requests) pairs
+    if (length % 3 != 1 || !mCurrentReturnData) {
+        return false;
+    }
+
+    mCurrentReturnData->displayRequests = read();
+
+    uint32_t count = (length - 1) / 3;
+    mCurrentReturnData->requestedLayers.reserve(count);
+    mCurrentReturnData->requestMasks.reserve(count);
+    while (count > 0) {
+        auto layer = read64();
+        auto layerRequestMask = read();
+
+        mCurrentReturnData->requestedLayers.push_back(layer);
+        mCurrentReturnData->requestMasks.push_back(layerRequestMask);
+
+        count--;
+    }
+
+    return true;
 }
 
-Error Composer::setLayerDataspace(Display display, Layer layer,
-        Dataspace dataspace) const
+bool CommandReader::parseSetPresentFence(uint16_t length)
 {
-    auto ret = mService->setLayerDataspace(display, layer, dataspace);
-    return unwrapRet(ret);
+    if (length != CommandWriter::kSetPresentFenceLength ||
+            !mCurrentReturnData) {
+        return false;
+    }
+
+    if (mCurrentReturnData->presentFence >= 0) {
+        close(mCurrentReturnData->presentFence);
+    }
+    mCurrentReturnData->presentFence = readFence();
+
+    return true;
 }
 
-Error Composer::setLayerDisplayFrame(Display display, Layer layer,
-        const IComposer::Rect& frame) const
+bool CommandReader::parseSetReleaseFences(uint16_t length)
 {
-    auto ret = mService->setLayerDisplayFrame(display, layer, frame);
-    return unwrapRet(ret);
+    // (layer id, release fence index) pairs
+    if (length % 3 != 0 || !mCurrentReturnData) {
+        return false;
+    }
+
+    uint32_t count = length / 3;
+    mCurrentReturnData->releasedLayers.reserve(count);
+    mCurrentReturnData->releaseFences.reserve(count);
+    while (count > 0) {
+        auto layer = read64();
+        auto fence = readFence();
+
+        mCurrentReturnData->releasedLayers.push_back(layer);
+        mCurrentReturnData->releaseFences.push_back(fence);
+
+        count--;
+    }
+
+    return true;
 }
 
-Error Composer::setLayerPlaneAlpha(Display display, Layer layer,
-        float alpha) const
+void CommandReader::resetData()
 {
-    auto ret = mService->setLayerPlaneAlpha(display, layer, alpha);
-    return unwrapRet(ret);
+    mErrors.clear();
+
+    for (auto& data : mReturnData) {
+        if (data.second.presentFence >= 0) {
+            close(data.second.presentFence);
+        }
+        for (auto fence : data.second.releaseFences) {
+            if (fence >= 0) {
+                close(fence);
+            }
+        }
+    }
+
+    mReturnData.clear();
+    mCurrentReturnData = nullptr;
 }
 
-Error Composer::setLayerSidebandStream(Display display, Layer layer,
-        const native_handle_t* stream) const
+std::vector<CommandReader::CommandError> CommandReader::takeErrors()
 {
-    BufferHandle tmpStream(stream);
-
-    auto ret = mService->setLayerSidebandStream(display, layer, tmpStream);
-    return unwrapRet(ret);
+    return std::move(mErrors);
 }
 
-Error Composer::setLayerSourceCrop(Display display, Layer layer,
-        const IComposer::FRect& crop) const
+bool CommandReader::hasChanges(Display display,
+        uint32_t& numChangedCompositionTypes,
+        uint32_t& numLayerRequestMasks) const
 {
-    auto ret = mService->setLayerSourceCrop(display, layer, crop);
-    return unwrapRet(ret);
+    auto found = mReturnData.find(display);
+    if (found == mReturnData.end()) {
+        numChangedCompositionTypes = 0;
+        numLayerRequestMasks = 0;
+        return false;
+    }
+
+    const ReturnData& data = found->second;
+
+    numChangedCompositionTypes = data.compositionTypes.size();
+    numLayerRequestMasks = data.requestMasks.size();
+
+    return !(data.compositionTypes.empty() && data.requestMasks.empty());
 }
 
-Error Composer::setLayerTransform(Display display, Layer layer,
-        Transform transform) const
+void CommandReader::takeChangedCompositionTypes(Display display,
+        std::vector<Layer>& layers,
+        std::vector<IComposerClient::Composition>& types)
 {
-    auto ret = mService->setLayerTransform(display, layer, transform);
-    return unwrapRet(ret);
+    auto found = mReturnData.find(display);
+    if (found == mReturnData.end()) {
+        layers.clear();
+        types.clear();
+        return;
+    }
+
+    ReturnData& data = found->second;
+
+    layers = std::move(data.changedLayers);
+    types = std::move(data.compositionTypes);
 }
 
-Error Composer::setLayerVisibleRegion(Display display, Layer layer,
-        const std::vector<IComposer::Rect>& visible) const
+void CommandReader::takeDisplayRequests(Display display,
+        uint32_t& displayRequestMask, std::vector<Layer>& layers,
+        std::vector<uint32_t>& layerRequestMasks)
 {
-    hidl_vec<IComposer::Rect> tmpVisible;
-    tmpVisible.setToExternal(const_cast<IComposer::Rect*>(visible.data()),
-            visible.size());
+    auto found = mReturnData.find(display);
+    if (found == mReturnData.end()) {
+        displayRequestMask = 0;
+        layers.clear();
+        layerRequestMasks.clear();
+        return;
+    }
 
-    auto ret = mService->setLayerVisibleRegion(display, layer, tmpVisible);
-    return unwrapRet(ret);
+    ReturnData& data = found->second;
+
+    displayRequestMask = data.displayRequests;
+    layers = std::move(data.requestedLayers);
+    layerRequestMasks = std::move(data.requestMasks);
 }
 
-Error Composer::setLayerZOrder(Display display, Layer layer, uint32_t z) const
+void CommandReader::takeReleaseFences(Display display,
+        std::vector<Layer>& layers, std::vector<int>& releaseFences)
 {
-    auto ret = mService->setLayerZOrder(display, layer, z);
-    return unwrapRet(ret);
+    auto found = mReturnData.find(display);
+    if (found == mReturnData.end()) {
+        layers.clear();
+        releaseFences.clear();
+        return;
+    }
+
+    ReturnData& data = found->second;
+
+    layers = std::move(data.releasedLayers);
+    releaseFences = std::move(data.releaseFences);
+}
+
+void CommandReader::takePresentFence(Display display, int& presentFence)
+{
+    auto found = mReturnData.find(display);
+    if (found == mReturnData.end()) {
+        presentFence = -1;
+        return;
+    }
+
+    ReturnData& data = found->second;
+
+    presentFence = data.presentFence;
+    data.presentFence = -1;
 }
 
 } // namespace Hwc2
diff --git a/services/surfaceflinger/DisplayHardware/ComposerHal.h b/services/surfaceflinger/DisplayHardware/ComposerHal.h
index b8f7c20..2246f76 100644
--- a/services/surfaceflinger/DisplayHardware/ComposerHal.h
+++ b/services/surfaceflinger/DisplayHardware/ComposerHal.h
@@ -17,11 +17,16 @@
 #ifndef ANDROID_SF_COMPOSER_HAL_H
 #define ANDROID_SF_COMPOSER_HAL_H
 
+#include <memory>
 #include <string>
+#include <unordered_map>
+#include <utility>
 #include <vector>
 
 #include <android/hardware/graphics/composer/2.1/IComposer.h>
 #include <utils/StrongPointer.h>
+#include <IComposerCommandBuffer.h>
+#include <MessageQueue.h>
 
 namespace android {
 
@@ -36,102 +41,195 @@
 
 using android::hardware::graphics::composer::V2_1::IComposer;
 using android::hardware::graphics::composer::V2_1::IComposerCallback;
+using android::hardware::graphics::composer::V2_1::IComposerClient;
 using android::hardware::graphics::composer::V2_1::Error;
 using android::hardware::graphics::composer::V2_1::Display;
 using android::hardware::graphics::composer::V2_1::Layer;
 using android::hardware::graphics::composer::V2_1::Config;
 
+using android::hardware::graphics::composer::V2_1::CommandWriter;
+using android::hardware::graphics::composer::V2_1::CommandReaderBase;
+
+using android::hardware::kSynchronizedReadWrite;
+using android::hardware::MessageQueue;
+using android::hardware::MQDescriptorSync;
+using android::hardware::hidl_vec;
+using android::hardware::hidl_handle;
+
+class CommandReader : public CommandReaderBase {
+public:
+    ~CommandReader();
+
+    // Parse and execute commands from the command queue.  The commands are
+    // actually return values from the server and will be saved in ReturnData.
+    Error parse();
+
+    // Get and clear saved errors.
+    struct CommandError {
+        uint32_t location;
+        Error error;
+    };
+    std::vector<CommandError> takeErrors();
+
+    bool hasChanges(Display display, uint32_t& numChangedCompositionTypes,
+            uint32_t& numLayerRequestMasks) const;
+
+    // Get and clear saved changed composition types.
+    void takeChangedCompositionTypes(Display display,
+            std::vector<Layer>& layers,
+            std::vector<IComposerClient::Composition>& types);
+
+    // Get and clear saved display requests.
+    void takeDisplayRequests(Display display,
+        uint32_t& displayRequestMask, std::vector<Layer>& layers,
+        std::vector<uint32_t>& layerRequestMasks);
+
+    // Get and clear saved release fences.
+    void takeReleaseFences(Display display, std::vector<Layer>& layers,
+            std::vector<int>& releaseFences);
+
+    // Get and clear saved present fence.
+    void takePresentFence(Display display, int& presentFence);
+
+private:
+    void resetData();
+
+    bool parseSelectDisplay(uint16_t length);
+    bool parseSetError(uint16_t length);
+    bool parseSetChangedCompositionTypes(uint16_t length);
+    bool parseSetDisplayRequests(uint16_t length);
+    bool parseSetPresentFence(uint16_t length);
+    bool parseSetReleaseFences(uint16_t length);
+
+    struct ReturnData {
+        uint32_t displayRequests = 0;
+
+        std::vector<Layer> changedLayers;
+        std::vector<IComposerClient::Composition> compositionTypes;
+
+        std::vector<Layer> requestedLayers;
+        std::vector<uint32_t> requestMasks;
+
+        int presentFence = -1;
+
+        std::vector<Layer> releasedLayers;
+        std::vector<int> releaseFences;
+    };
+
+    std::vector<CommandError> mErrors;
+    std::unordered_map<Display, ReturnData> mReturnData;
+
+    // When SELECT_DISPLAY is parsed, this is updated to point to the
+    // display's return data in mReturnData.  We use it to avoid repeated
+    // map lookups.
+    ReturnData* mCurrentReturnData;
+};
+
 // Composer is a wrapper to IComposer, a proxy to server-side composer.
 class Composer {
 public:
     Composer();
 
-    std::vector<IComposer::Capability> getCapabilities() const;
-    std::string dumpDebugInfo() const;
+    std::vector<IComposer::Capability> getCapabilities();
+    std::string dumpDebugInfo();
 
-    void registerCallback(const sp<IComposerCallback>& callback) const;
+    void registerCallback(const sp<IComposerCallback>& callback);
 
-    uint32_t getMaxVirtualDisplayCount() const;
+    uint32_t getMaxVirtualDisplayCount();
     Error createVirtualDisplay(uint32_t width, uint32_t height,
-            PixelFormat& format, Display& display) const;
-    Error destroyVirtualDisplay(Display display) const;
+            PixelFormat& format, Display& display);
+    Error destroyVirtualDisplay(Display display);
 
-    Error acceptDisplayChanges(Display display) const;
+    Error acceptDisplayChanges(Display display);
 
-    Error createLayer(Display display, Layer& layer) const;
-    Error destroyLayer(Display display, Layer layer) const;
+    Error createLayer(Display display, Layer& layer);
+    Error destroyLayer(Display display, Layer layer);
 
-    Error getActiveConfig(Display display, Config& config) const;
+    Error getActiveConfig(Display display, Config& config);
     Error getChangedCompositionTypes(Display display,
             std::vector<Layer>& layers,
-            std::vector<IComposer::Composition>& types) const;
-    Error getColorModes(Display display, std::vector<ColorMode>& modes) const;
+            std::vector<IComposerClient::Composition>& types);
+    Error getColorModes(Display display, std::vector<ColorMode>& modes);
     Error getDisplayAttribute(Display display, Config config,
-            IComposer::Attribute attribute, int32_t& value) const;
+            IComposerClient::Attribute attribute, int32_t& value);
     Error getDisplayConfigs(Display display,
-            std::vector<Config>& configs) const;
-    Error getDisplayName(Display display, std::string& name) const;
+            std::vector<Config>& configs);
+    Error getDisplayName(Display display, std::string& name);
 
     Error getDisplayRequests(Display display, uint32_t& displayRequestMask,
             std::vector<Layer>& layers,
-            std::vector<uint32_t>& layerRequestMasks) const;
+            std::vector<uint32_t>& layerRequestMasks);
 
-    Error getDisplayType(Display display, IComposer::DisplayType& type) const;
-    Error getDozeSupport(Display display, bool& support) const;
+    Error getDisplayType(Display display, IComposerClient::DisplayType& type);
+    Error getDozeSupport(Display display, bool& support);
     Error getHdrCapabilities(Display display, std::vector<Hdr>& types,
             float& maxLuminance, float& maxAverageLuminance,
-            float& minLuminance) const;
+            float& minLuminance);
 
     Error getReleaseFences(Display display, std::vector<Layer>& layers,
-            std::vector<int>& releaseFences) const;
+            std::vector<int>& releaseFences);
 
-    Error presentDisplay(Display display, int& presentFence) const;
+    Error presentDisplay(Display display, int& presentFence);
 
-    Error setActiveConfig(Display display, Config config) const;
+    Error setActiveConfig(Display display, Config config);
     Error setClientTarget(Display display, const native_handle_t* target,
             int acquireFence, Dataspace dataspace,
-            const std::vector<IComposer::Rect>& damage) const;
-    Error setColorMode(Display display, ColorMode mode) const;
+            const std::vector<IComposerClient::Rect>& damage);
+    Error setColorMode(Display display, ColorMode mode);
     Error setColorTransform(Display display, const float* matrix,
-            ColorTransform hint) const;
+            ColorTransform hint);
     Error setOutputBuffer(Display display, const native_handle_t* buffer,
-            int releaseFence) const;
-    Error setPowerMode(Display display, IComposer::PowerMode mode) const;
-    Error setVsyncEnabled(Display display, IComposer::Vsync enabled) const;
+            int releaseFence);
+    Error setPowerMode(Display display, IComposerClient::PowerMode mode);
+    Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled);
+
+    Error setClientTargetSlotCount(Display display);
 
     Error validateDisplay(Display display, uint32_t& numTypes,
-            uint32_t& numRequests) const;
+            uint32_t& numRequests);
 
     Error setCursorPosition(Display display, Layer layer,
-            int32_t x, int32_t y) const;
+            int32_t x, int32_t y);
     Error setLayerBuffer(Display display, Layer layer,
-            const native_handle_t* buffer, int acquireFence) const;
+            const native_handle_t* buffer, int acquireFence);
     Error setLayerSurfaceDamage(Display display, Layer layer,
-            const std::vector<IComposer::Rect>& damage) const;
+            const std::vector<IComposerClient::Rect>& damage);
     Error setLayerBlendMode(Display display, Layer layer,
-            IComposer::BlendMode mode) const;
+            IComposerClient::BlendMode mode);
     Error setLayerColor(Display display, Layer layer,
-            const IComposer::Color& color) const;
+            const IComposerClient::Color& color);
     Error setLayerCompositionType(Display display, Layer layer,
-            IComposer::Composition type) const;
+            IComposerClient::Composition type);
     Error setLayerDataspace(Display display, Layer layer,
-            Dataspace dataspace) const;
+            Dataspace dataspace);
     Error setLayerDisplayFrame(Display display, Layer layer,
-            const IComposer::Rect& frame) const;
+            const IComposerClient::Rect& frame);
     Error setLayerPlaneAlpha(Display display, Layer layer,
-            float alpha) const;
+            float alpha);
     Error setLayerSidebandStream(Display display, Layer layer,
-            const native_handle_t* stream) const;
+            const native_handle_t* stream);
     Error setLayerSourceCrop(Display display, Layer layer,
-            const IComposer::FRect& crop) const;
+            const IComposerClient::FRect& crop);
     Error setLayerTransform(Display display, Layer layer,
-            Transform transform) const;
+            Transform transform);
     Error setLayerVisibleRegion(Display display, Layer layer,
-            const std::vector<IComposer::Rect>& visible) const;
-    Error setLayerZOrder(Display display, Layer layer, uint32_t z) const;
+            const std::vector<IComposerClient::Rect>& visible);
+    Error setLayerZOrder(Display display, Layer layer, uint32_t z);
 
 private:
-    sp<IComposer> mService;
+    // Many public functions above simply write a command into the command
+    // queue to batch the calls.  validateDisplay and presentDisplay will call
+    // this function to execute the command queue.
+    Error execute();
+
+    sp<IComposer> mComposer;
+    sp<IComposerClient> mClient;
+
+    // 64KiB minus a small space for metadata such as read/write pointers
+    static constexpr size_t kWriterInitialSize =
+        64 * 1024 / sizeof(uint32_t) - 16;
+    CommandWriter mWriter;
+    CommandReader mReader;
 };
 
 } // namespace Hwc2
diff --git a/services/surfaceflinger/DisplayHardware/HWC2.cpp b/services/surfaceflinger/DisplayHardware/HWC2.cpp
index dd909aa..10b0acf 100644
--- a/services/surfaceflinger/DisplayHardware/HWC2.cpp
+++ b/services/surfaceflinger/DisplayHardware/HWC2.cpp
@@ -286,6 +286,9 @@
 {
     if (connected == Connection::Connected) {
         if (!display->isConnected()) {
+#ifndef BYPASS_IHWC
+            mComposer->setClientTargetSlotCount(display->getId());
+#endif
             display->loadConfigs();
             display->setConnected(true);
         }
@@ -650,7 +653,7 @@
             &numElements, layerIds.data(), types.data());
 #else
     std::vector<Hwc2::Layer> layerIds;
-    std::vector<Hwc2::IComposer::Composition> types;
+    std::vector<Hwc2::IComposerClient::Composition> types;
     auto intError = mDevice.mComposer->getChangedCompositionTypes(mId,
             layerIds, types);
     uint32_t numElements = layerIds.size();
@@ -805,8 +808,8 @@
     int32_t intError = mDevice.mGetDisplayType(mDevice.mHwcDevice, mId,
             &intType);
 #else
-    Hwc2::IComposer::DisplayType intType =
-        Hwc2::IComposer::DisplayType::INVALID;
+    Hwc2::IComposerClient::DisplayType intType =
+        Hwc2::IComposerClient::DisplayType::INVALID;
     auto intError = mDevice.mComposer->getDisplayType(mId, intType);
 #endif
     auto error = static_cast<Error>(intError);
@@ -970,7 +973,7 @@
 #else
     auto intError = mDevice.mComposer->setClientTarget(mId, target, fenceFd,
             static_cast<Hwc2::Dataspace>(dataspace),
-            std::vector<Hwc2::IComposer::Rect>());
+            std::vector<Hwc2::IComposerClient::Rect>());
 #endif
     return static_cast<Error>(intError);
 }
@@ -1020,7 +1023,7 @@
     auto intMode = static_cast<int32_t>(mode);
     int32_t intError = mDevice.mSetPowerMode(mDevice.mHwcDevice, mId, intMode);
 #else
-    auto intMode = static_cast<Hwc2::IComposer::PowerMode>(mode);
+    auto intMode = static_cast<Hwc2::IComposerClient::PowerMode>(mode);
     auto intError = mDevice.mComposer->setPowerMode(mId, intMode);
 #endif
     return static_cast<Error>(intError);
@@ -1033,7 +1036,7 @@
     int32_t intError = mDevice.mSetVsyncEnabled(mDevice.mHwcDevice, mId,
             intEnabled);
 #else
-    auto intEnabled = static_cast<Hwc2::IComposer::Vsync>(enabled);
+    auto intEnabled = static_cast<Hwc2::IComposerClient::Vsync>(enabled);
     auto intError = mDevice.mComposer->setVsyncEnabled(mId, intEnabled);
 #endif
     return static_cast<Error>(intError);
@@ -1070,7 +1073,7 @@
             configId, static_cast<int32_t>(attribute), &value);
 #else
     auto intError = mDevice.mComposer->getDisplayAttribute(mId,
-            configId, static_cast<Hwc2::IComposer::Attribute>(attribute),
+            configId, static_cast<Hwc2::IComposerClient::Attribute>(attribute),
             value);
 #endif
     auto error = static_cast<Error>(intError);
@@ -1221,7 +1224,7 @@
                 mDisplayId, mId, {0, nullptr});
 #else
         intError = mDevice.mComposer->setLayerSurfaceDamage(mDisplayId,
-                mId, std::vector<Hwc2::IComposer::Rect>());
+                mId, std::vector<Hwc2::IComposerClient::Rect>());
 #endif
     } else {
         size_t rectCount = 0;
@@ -1230,7 +1233,7 @@
 #ifdef BYPASS_IHWC
         std::vector<hwc_rect_t> hwcRects;
 #else
-        std::vector<Hwc2::IComposer::Rect> hwcRects;
+        std::vector<Hwc2::IComposerClient::Rect> hwcRects;
 #endif
         for (size_t rect = 0; rect < rectCount; ++rect) {
             hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
@@ -1260,7 +1263,7 @@
     int32_t intError = mDevice.mSetLayerBlendMode(mDevice.mHwcDevice,
             mDisplayId, mId, intMode);
 #else
-    auto intMode = static_cast<Hwc2::IComposer::BlendMode>(mode);
+    auto intMode = static_cast<Hwc2::IComposerClient::BlendMode>(mode);
     auto intError = mDevice.mComposer->setLayerBlendMode(mDisplayId,
             mId, intMode);
 #endif
@@ -1273,7 +1276,7 @@
     int32_t intError = mDevice.mSetLayerColor(mDevice.mHwcDevice, mDisplayId,
             mId, color);
 #else
-    Hwc2::IComposer::Color hwcColor{color.r, color.g, color.b, color.a};
+    Hwc2::IComposerClient::Color hwcColor{color.r, color.g, color.b, color.a};
     auto intError = mDevice.mComposer->setLayerColor(mDisplayId,
             mId, hwcColor);
 #endif
@@ -1287,7 +1290,7 @@
     int32_t intError = mDevice.mSetLayerCompositionType(mDevice.mHwcDevice,
             mDisplayId, mId, intType);
 #else
-    auto intType = static_cast<Hwc2::IComposer::Composition>(type);
+    auto intType = static_cast<Hwc2::IComposerClient::Composition>(type);
     auto intError = mDevice.mComposer->setLayerCompositionType(mDisplayId,
             mId, intType);
 #endif
@@ -1315,7 +1318,7 @@
     int32_t intError = mDevice.mSetLayerDisplayFrame(mDevice.mHwcDevice,
             mDisplayId, mId, hwcRect);
 #else
-    Hwc2::IComposer::Rect hwcRect{frame.left, frame.top,
+    Hwc2::IComposerClient::Rect hwcRect{frame.left, frame.top,
         frame.right, frame.bottom};
     auto intError = mDevice.mComposer->setLayerDisplayFrame(mDisplayId,
             mId, hwcRect);
@@ -1359,7 +1362,7 @@
     int32_t intError = mDevice.mSetLayerSourceCrop(mDevice.mHwcDevice,
             mDisplayId, mId, hwcRect);
 #else
-    Hwc2::IComposer::FRect hwcRect{
+    Hwc2::IComposerClient::FRect hwcRect{
         crop.left, crop.top, crop.right, crop.bottom};
     auto intError = mDevice.mComposer->setLayerSourceCrop(mDisplayId,
             mId, hwcRect);
@@ -1389,7 +1392,7 @@
 #ifdef BYPASS_IHWC
     std::vector<hwc_rect_t> hwcRects;
 #else
-    std::vector<Hwc2::IComposer::Rect> hwcRects;
+    std::vector<Hwc2::IComposerClient::Rect> hwcRects;
 #endif
     for (size_t rect = 0; rect < rectCount; ++rect) {
         hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,