Merge "Add box shadow API to surface control" into main

Author: cairno-google

libs/gui/Android.bp

@@ -94,6 +94,7 @@ filegroup {
         "android/**/TouchOcclusionMode.aidl",
         "android/gui/TrustedOverlay.aidl",
         "android/gui/BorderSettings.aidl",
+        "android/gui/BoxShadowSettings.aidl",
     ],
 }
 

libs/gui/LayerState.cpp

@@ -181,6 +181,7 @@ status_t layer_state_t::write(Parcel& output) const
     }
     SAFE_PARCEL(output.writeFloat, shadowRadius);
     SAFE_PARCEL(output.writeParcelable, borderSettings);
+    SAFE_PARCEL(output.writeParcelable, boxShadowSettings);
     SAFE_PARCEL(output.writeInt32, frameRateSelectionPriority);
     SAFE_PARCEL(output.writeFloat, frameRate);
     SAFE_PARCEL(output.writeByte, frameRateCompatibility);
@@ -330,6 +331,7 @@ status_t layer_state_t::read(const Parcel& input)
     }
     SAFE_PARCEL(input.readFloat, &shadowRadius);
     SAFE_PARCEL(input.readParcelable, &borderSettings);
+    SAFE_PARCEL(input.readParcelable, &boxShadowSettings);
 
     SAFE_PARCEL(input.readInt32, &frameRateSelectionPriority);
     SAFE_PARCEL(input.readFloat, &frameRate);
@@ -734,6 +736,10 @@ void layer_state_t::merge(const layer_state_t& other) {
         what |= eBorderSettingsChanged;
         borderSettings = other.borderSettings;
     }
+    if (other.what & eBoxShadowSettingsChanged) {
+        what |= eBoxShadowSettingsChanged;
+        boxShadowSettings = other.boxShadowSettings;
+    }
     if (other.what & eLutsChanged) {
         what |= eLutsChanged;
         luts = other.luts;
@@ -889,6 +895,7 @@ uint64_t layer_state_t::diff(const layer_state_t& other) const {
     if (other.what & eMetadataChanged) diff |= eMetadataChanged;
     CHECK_DIFF(diff, eShadowRadiusChanged, other, shadowRadius);
     CHECK_DIFF(diff, eBorderSettingsChanged, other, borderSettings);
+    CHECK_DIFF(diff, eBoxShadowSettingsChanged, other, boxShadowSettings);
     CHECK_DIFF(diff, eDefaultFrameRateCompatibilityChanged, other, defaultFrameRateCompatibility);
     CHECK_DIFF(diff, eFrameRateSelectionPriority, other, frameRateSelectionPriority);
     CHECK_DIFF3(diff, eFrameRateChanged, other, frameRate, frameRateCompatibility,

libs/gui/SurfaceComposerClient.cpp

@@ -2038,6 +2038,19 @@ SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setBorde
     return *this;
 }
 
+SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setBoxShadowSettings(
+        const sp<SurfaceControl>& sc, gui::BoxShadowSettings settings) {
+    layer_state_t* s = getLayerState(sc);
+    if (!s) {
+        mStatus = BAD_INDEX;
+        return *this;
+    }
+
+    s->what |= layer_state_t::eBoxShadowSettingsChanged;
+    s->boxShadowSettings = settings;
+    return *this;
+}
+
 SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFrameRate(
         const sp<SurfaceControl>& sc, float frameRate, int8_t compatibility,
         int8_t changeFrameRateStrategy) {

libs/gui/android/gui/BoxShadowSettings.aidl

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2025, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.gui;
+
+/** @hide */
+parcelable BoxShadowSettings {
+    parcelable BoxShadowParams
+    {
+        float blurRadius;
+        float spreadRadius;
+        // Space is sRGB, not premultiplied, bit pattern is 0xAARRGGBB.
+        int color;
+        float offsetX;
+        float offsetY;
+    }
+
+    BoxShadowParams []boxShadows = {};
+}

libs/gui/include/gui/LayerState.h

@@ -22,6 +22,7 @@
 #include <span>
 
 #include <android/gui/BorderSettings.h>
+#include <android/gui/BoxShadowSettings.h>
 #include <android/gui/DisplayCaptureArgs.h>
 #include <android/gui/IWindowInfosReportedListener.h>
 #include <android/gui/LayerCaptureArgs.h>
@@ -252,6 +253,7 @@ struct layer_state_t {
         eAppContentPriorityChanged = 0x100000'00000000,
         eClientDrawnCornerRadiusChanged = 0x200000'00000000,
         eBorderSettingsChanged = 0x400000'00000000,
+        eBoxShadowSettingsChanged = 0x800000'00000000,
     };
 
     layer_state_t();
@@ -296,7 +298,8 @@ struct layer_state_t {
             layer_state_t::eCornerRadiusChanged | layer_state_t::eDimmingEnabledChanged |
             layer_state_t::eHdrMetadataChanged | layer_state_t::eShadowRadiusChanged |
             layer_state_t::eStretchChanged | layer_state_t::ePictureProfileHandleChanged |
-            layer_state_t::eAppContentPriorityChanged | layer_state_t::eBorderSettingsChanged;
+            layer_state_t::eAppContentPriorityChanged | layer_state_t::eBorderSettingsChanged |
+            layer_state_t::eBoxShadowSettingsChanged;
 
     // Changes which invalidates the layer's visible region in CE.
     static constexpr uint64_t CONTENT_DIRTY = layer_state_t::CONTENT_CHANGES |
@@ -325,7 +328,7 @@ struct layer_state_t {
     static constexpr uint64_t COMPOSITION_EFFECTS = layer_state_t::eBackgroundBlurRadiusChanged |
             layer_state_t::eBlurRegionsChanged | layer_state_t::eCornerRadiusChanged |
             layer_state_t::eShadowRadiusChanged | layer_state_t::eStretchChanged |
-            layer_state_t::eBorderSettingsChanged;
+            layer_state_t::eBorderSettingsChanged | layer_state_t::eBoxShadowSettingsChanged;
 
     bool hasValidBuffer() const;
     void sanitize(int32_t permissions);
@@ -417,6 +420,9 @@ struct layer_state_t {
     // Draws an outline around the layer.
     gui::BorderSettings borderSettings;
 
+    // Draws a sequence of box shadows under the layer.
+    gui::BoxShadowSettings boxShadowSettings;
+
     // Priority of the layer assigned by Window Manager.
     int32_t frameRateSelectionPriority;
 

libs/gui/include/gui/SurfaceComposerClient.h

@@ -681,6 +681,9 @@ class SurfaceComposerClient : public RefBase
 
         Transaction& setBorderSettings(const sp<SurfaceControl>& sc, gui::BorderSettings settings);
 
+        Transaction& setBoxShadowSettings(const sp<SurfaceControl>& sc,
+                                          gui::BoxShadowSettings settings);
+
         Transaction& setFrameRate(const sp<SurfaceControl>& sc, float frameRate,
                                   int8_t compatibility, int8_t changeFrameRateStrategy);
 

libs/renderengine/include/renderengine/LayerSettings.h

@@ -17,6 +17,7 @@
 #pragma once
 
 #include <android/gui/BorderSettings.h>
+#include <android/gui/BoxShadowSettings.h>
 #include <gui/DisplayLuts.h>
 #include <math/mat4.h>
 #include <math/vec3.h>
@@ -134,6 +135,8 @@ struct LayerSettings {
 
     gui::BorderSettings borderSettings;
 
+    gui::BoxShadowSettings boxShadowSettings;
+
     int backgroundBlurRadius = 0;
 
     std::vector<BlurRegion> blurRegions;

libs/renderengine/skia/SkiaRenderEngine.cpp

@@ -21,6 +21,7 @@
 #include "SkiaRenderEngine.h"
 
 #include <SkBlendMode.h>
+#include <SkBlurTypes.h>
 #include <SkCanvas.h>
 #include <SkColor.h>
 #include <SkColorFilter.h>
@@ -32,6 +33,7 @@
 #include <SkImageFilters.h>
 #include <SkImageInfo.h>
 #include <SkM44.h>
+#include <SkMaskFilter.h>
 #include <SkMatrix.h>
 #include <SkPaint.h>
 #include <SkPath.h>
@@ -986,20 +988,19 @@ void SkiaRenderEngine::drawLayersInternal(
             drawShadow(canvas, rrect, layer.shadow);
         }
 
+        // TODO(b/367464660): Move this code above and
+        // update elevation shadow rendering to use these bounds since they should be
+        // identical.
+        SkRRect originalBounds, originalClip;
+        std::tie(originalBounds, originalClip) =
+                getBoundsAndClip(layer.geometry.originalBounds, layer.geometry.roundedCornersCrop,
+                                 layer.geometry.roundedCornersRadius);
+        const SkRRect& preferredOriginalBounds =
+                originalBounds.isRect() && !originalClip.isEmpty() ? originalClip : originalBounds;
+
         // Similar to shadows, do the rendering before the clip is applied because even when the
         // layer is occluded it should have an outline.
         if (layer.borderSettings.strokeWidth > 0) {
-            // TODO(b/367464660): Move this code to the parent scope and
-            // update shadow rendering above to use these bounds since they should be
-            // identical.
-            SkRRect originalBounds, originalClip;
-            std::tie(originalBounds, originalClip) =
-                    getBoundsAndClip(layer.geometry.boundaries, layer.geometry.roundedCornersCrop,
-                                     layer.geometry.roundedCornersRadius);
-            const SkRRect& preferredOriginalBounds =
-                    originalBounds.isRect() && !originalClip.isEmpty() ? originalClip
-                                                                       : originalBounds;
-
             SkRRect outlineRect = preferredOriginalBounds;
             outlineRect.outset(layer.borderSettings.strokeWidth, layer.borderSettings.strokeWidth);
 
@@ -1010,6 +1011,21 @@ void SkiaRenderEngine::drawLayersInternal(
             canvas->drawDRRect(outlineRect, preferredOriginalBounds, paint);
         }
 
+        if (!layer.boxShadowSettings.boxShadows.empty()) {
+            for (const gui::BoxShadowSettings::BoxShadowParams& box :
+                 layer.boxShadowSettings.boxShadows) {
+                SkRRect boxRect = preferredOriginalBounds;
+                boxRect.outset(box.spreadRadius, box.spreadRadius);
+                boxRect.offset(box.offsetX, box.offsetY);
+                float sigma = convertBlurUserRadiusToSigma(box.blurRadius);
+                SkPaint blur;
+                blur.setAntiAlias(true);
+                blur.setColor(box.color);
+                blur.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, sigma, false));
+                canvas->drawRRect(boxRect, blur);
+            }
+        }
+
         const float layerDimmingRatio = layer.whitePointNits <= 0.f
                 ? displayDimmingRatio
                 : (layer.whitePointNits / maxLayerWhitePoint) * displayDimmingRatio;

libs/ui/include/ui/BlurRegion.h

@@ -62,6 +62,15 @@ static inline void PrintTo(const BlurRegion& blurRegion, ::std::ostream* os) {
     *os << "\n}";
 }
 
+// copied from skia/src/core/SkBlurMask.cpp
+inline float convertBlurUserRadiusToSigma(float radius) {
+    return radius > 0 ? 0.57735f * radius + 0.5f : 0.0f;
+}
+// copied from skia/src/core/SkBlurEngine.h
+inline float convertBlurSigmaToKernelRadius(float sigma) {
+    return sigma <= 0.03f ? 0 : ceilf(3.f * sigma);
+}
+
 } // namespace android
 
 namespace std {

services/surfaceflinger/CompositionEngine/include/compositionengine/LayerFECompositionState.h

@@ -19,6 +19,7 @@
 #include <cstdint>
 
 #include <android/gui/BorderSettings.h>
+#include <android/gui/BoxShadowSettings.h>
 #include <android/gui/CachingHint.h>
 #include <gui/DisplayLuts.h>
 #include <gui/HdrMetadata.h>
@@ -145,6 +146,9 @@ struct LayerFECompositionState {
     // The settings to configure the outline of a layer.
     gui::BorderSettings borderSettings;
 
+    // The settings to configure box shadows of a layer.
+    gui::BoxShadowSettings boxShadowSettings;
+
     // List of regions that require blur
     std::vector<BlurRegion> blurRegions;
 
@@ -240,6 +244,43 @@ struct LayerFECompositionState {
 
     // Debugging
     virtual void dump(std::string& out) const;
+
+    FloatRect outsetRectForShadow(const FloatRect& input) const {
+        FloatRect output = input;
+
+        // RenderEngine currently blurs shadows to smooth out edges, so outset by
+        // 2x the length instead of 1x to compensate
+        float outset = shadowSettings.length * 2;
+
+        // Stroke antialiasing should never add more than 2 pixels.
+        if (borderSettings.strokeWidth > 0) {
+            outset = std::max(outset, borderSettings.strokeWidth + 2);
+        }
+
+        output.left -= outset;
+        output.top -= outset;
+        output.right += outset;
+        output.bottom += outset;
+
+        for (const gui::BoxShadowSettings::BoxShadowParams& boxShadow :
+             boxShadowSettings.boxShadows) {
+            float radius = convertBlurSigmaToKernelRadius(
+                                   convertBlurUserRadiusToSigma(boxShadow.blurRadius)) +
+                    boxShadow.spreadRadius;
+
+            float shadowLeft = input.left + boxShadow.offsetX - radius;
+            float shadowTop = input.top + boxShadow.offsetY - radius;
+            float shadowRight = input.right + boxShadow.offsetX + radius;
+            float shadowBottom = input.bottom + boxShadow.offsetY + radius;
+
+            output.left = std::min(shadowLeft, output.left);
+            output.top = std::min(shadowTop, output.top);
+            output.right = std::max(shadowRight, output.right);
+            output.bottom = std::max(shadowBottom, output.bottom);
+        }
+
+        return output;
+    }
 };
 
 } // namespace android::compositionengine