Temporarily disable ripple on protected contents

submodules/TelegramUI/Components/SpaceWarpView/BUILD

@@ -14,6 +14,7 @@ swift_library(
         "//submodules/AsyncDisplayKit",
         "//submodules/ComponentFlow",
         "//submodules/TelegramUI/Components/SpaceWarpView/STCMeshView",
+        "//submodules/UIKitRuntimeUtils",
     ],
     visibility = [
         "//visibility:public",

submodules/TelegramUI/Components/SpaceWarpView/Sources/SpaceWarpView.swift

@@ -4,6 +4,7 @@ import Display
 import AsyncDisplayKit
 import ComponentFlow
 import STCMeshView
+import UIKitRuntimeUtils
 
 private final class FPSView: UIView {
     private var lastTimestamp: Double?
@@ -327,6 +328,49 @@ private final class MaskGridLayer: SimpleLayer {
     }
 }
 
+private final class PrivateContentLayerRestoreContext {
+    final class Reference {
+        weak var layer: CALayer?
+        
+        init(layer: CALayer) {
+            self.layer = layer
+        }
+    }
+    
+    private static func collectPrivateContentLayers(layer: CALayer, into references: inout [Reference]) {
+        if getLayerDisableScreenshots(layer) {
+            references.append(Reference(layer: layer))
+        }
+        if let sublayers = layer.sublayers {
+            for sublayer in sublayers {
+                collectPrivateContentLayers(layer: sublayer, into: &references)
+            }
+        }
+    }
+    
+    private let references: [Reference]
+    
+    init(rootLayer: CALayer) {
+        var references: [Reference] = []
+        PrivateContentLayerRestoreContext.collectPrivateContentLayers(layer: rootLayer, into: &references)
+        self.references = references
+        
+        for reference in self.references {
+            if let layer = reference.layer {
+                setLayerDisableScreenshots(layer, false)
+            }
+        }
+    }
+    
+    func restore() {
+        for reference in self.references {
+            if let layer = reference.layer {
+                setLayerDisableScreenshots(layer, true)
+            }
+        }
+    }
+}
+
 open class SpaceWarpNodeImpl: ASDisplayNode, SpaceWarpNode {
     private final class Shockwave {
         let startPoint: CGPoint
@@ -346,6 +390,8 @@ open class SpaceWarpNodeImpl: ASDisplayNode, SpaceWarpNode {
     private var currentCloneView: UIView?
     private var meshView: STCMeshView?
     
+    private var privateContentRestoreContext: PrivateContentLayerRestoreContext?
+    
     private var gradientLayer: SimpleGradientLayer?
     private var gradientMaskLayer: MaskGridLayer?
     
@@ -382,7 +428,25 @@ open class SpaceWarpNodeImpl: ASDisplayNode, SpaceWarpNode {
         #endif
     }
     
+    public static func supportsHierarchy(layer: CALayer) -> Bool {
+        if getLayerDisableScreenshots(layer) {
+            return false
+        }
+        if let sublayers = layer.sublayers {
+            for sublayer in sublayers {
+                if !supportsHierarchy(layer: sublayer) {
+                    return false
+                }
+            }
+        }
+        return true
+    }
+    
     public func triggerRipple(at point: CGPoint) {
+        if !SpaceWarpNodeImpl.supportsHierarchy(layer: self.contentNodeSource.view.layer) {
+            return
+        }
+        
         self.shockwaves.append(Shockwave(startPoint: point))
         if self.shockwaves.count > 8 {
             self.shockwaves.removeFirst()
@@ -480,9 +544,18 @@ open class SpaceWarpNodeImpl: ASDisplayNode, SpaceWarpNode {
                 gradientMaskLayer.removeFromSuperlayer()
             }
             
+            if let privateContentRestoreContext = self.privateContentRestoreContext {
+                self.privateContentRestoreContext = nil
+                privateContentRestoreContext.restore()
+            }
+            
             return
         }
         
+        if self.privateContentRestoreContext == nil {
+            self.privateContentRestoreContext = PrivateContentLayerRestoreContext(rootLayer: self.contentNodeSource.view.layer)
+        }
+        
         self.backgroundView.isHidden = false
         self.contentNodeSource.clipsToBounds = true
         self.contentNodeSource.layer.cornerRadius = cornerRadius

submodules/UIKitRuntimeUtils/Source/UIKitRuntimeUtils/UIKitUtils.h

@@ -32,4 +32,6 @@ NSObject * _Nullable makeLuminanceToAlphaFilter();
 NSObject * _Nullable makeMonochromeFilter();
 
 void setLayerDisableScreenshots(CALayer * _Nonnull layer, bool disableScreenshots);
+bool getLayerDisableScreenshots(CALayer * _Nonnull layer);
+
 void setLayerContentsMaskMode(CALayer * _Nonnull layer, bool maskMode);

submodules/UIKitRuntimeUtils/Source/UIKitRuntimeUtils/UIKitUtils.m

@@ -1,5 +1,7 @@
 #import "UIKitUtils.h"
 
+#import <ObjCRuntimeUtils/RuntimeUtils.h>
+
 #import <objc/runtime.h>
 
 #if TARGET_IPHONE_SIMULATOR
@@ -236,6 +238,7 @@ NSObject * _Nullable makeMonochromeFilter() {
     return [(id<GraphicsFilterProtocol>)NSClassFromString(@"CAFilter") filterWithName:@"colorMonochrome"];
 }
 
+static const void *layerDisableScreenshotsKey = &layerDisableScreenshotsKey;
 
 void setLayerDisableScreenshots(CALayer * _Nonnull layer, bool disableScreenshots) {
     static UITextField *textField = nil;
@@ -264,6 +267,17 @@ void setLayerDisableScreenshots(CALayer * _Nonnull layer, bool disableScreenshot
         textField.secureTextEntry = false;
     }
     [secureView setValue:previousLayer forKey:@"layer"];
+    
+    [layer setAssociatedObject:@(disableScreenshots) forKey:layerDisableScreenshotsKey associationPolicy:NSObjectAssociationPolicyRetain];
+}
+
+bool getLayerDisableScreenshots(CALayer * _Nonnull layer) {
+    id result = [layer associatedObjectForKey:layerDisableScreenshotsKey];
+    if ([result respondsToSelector:@selector(boolValue)]) {
+        return [(NSNumber *)result boolValue];
+    } else {
+        return false;
+    }
 }
 
 void setLayerContentsMaskMode(CALayer * _Nonnull layer, bool maskMode) {