iOS: After exiting the screen-recording protection mode and opening an H5 page, the input cursor is not shown in the H5 input field.

[Bter]

iOS: After exiting the screen-recording protection mode and opening an H5 page, the input cursor is not shown in the H5 input field.
This issue exists in all versions from iOS 16 to 26.5.2.

screen_protector: 1.5.3
flutter_inappwebview: 6.1.5

[Bter]

Summary

After enabledPreventScreenshot() is turned on and later disablePreventScreenshot() is called, any text input focused afterwards — a plain UITextField or a WKWebView input — shows no blinking caret / insertion point, even
though typing and deleting still work. It never recovers until the app is relaunched. iOS-only, 100% reproducible.

Environment

• ScreenProtectorKit 1.5.1 (also reached via the screen_protector Flutter plugin, which depends on ScreenProtectorKit)
• iOS 18.x, real device

Reproduction

1. enabledPreventScreenshot()
2. disablePreventScreenshot()
3. Focus any UITextField / WKWebView text field.

→ Keyboard appears, input works, but the caret is invisible. Xcode also logs autolayout warnings such as UILayoutGuide … .width == -1.5, emitted by the leftover overlay.

Root cause

The screenshot prevention permanently re-parents the whole window.layer into a secure UITextField's _UITextLayoutCanvasView, and enabled/disablePreventScreenshot() only toggles isSecureTextEntry. It never moves window.layer
back out of the secure canvas and never removes the overlay. Once the field has been secure and is toggled back, the app content keeps rendering inside the secure text canvas, which suppresses insertion-point (caret)
rendering for every subsequently-focused input, WKWebView included.

This logic was open source through tag 1.4.5 in Sources/ScreenProtectorKit/ScreenProtectorKit.swift; from 1.5.0 it was moved into the bundled binary ScreenPreventerKit.xcframework (ScreenPreventer /
ScreenshotProtectionOverlay). The defect below is quoted verbatim from 1.4.5 and still reproduces on 1.5.1 (verified via the live view hierarchy).

Verbatim from 1.4.5:

public func configurePreventionScreenshot() {
guard let w = window else { return }
if (!w.subviews.contains(screenPrevent)) {
w.addSubview(screenPrevent)
screenPrevent.centerYAnchor.constraint(equalTo: w.centerYAnchor).isActive = true
screenPrevent.centerXAnchor.constraint(equalTo: w.centerXAnchor).isActive = true
w.layer.superlayer?.addSublayer(screenPrevent.layer)
if #available(iOS 17.0, *) {
screenPrevent.layer.sublayers?.last?.addSublayer(w.layer) // window.layer -> secure canvas
} else {
screenPrevent.layer.sublayers?.first?.addSublayer(w.layer)
}
}
}

public func enabledPreventScreenshot() { screenPrevent.isSecureTextEntry = true }
public func disablePreventScreenshot() { screenPrevent.isSecureTextEntry = false } // never moves window.layer out

Runtime evidence (key window dumped right after disablePreventScreenshot() on 1.5.1):

UIWindow subs=1 window.layer.superlayer != nil ← window layer still re-parented
… ScreenPreventerKit.ScreenshotProtectionOverlay secure=0 ← overlay still in the hierarchy
_UITextLayoutCanvasView ← still hosting window.layer

Proposed fix

Make enable/disable symmetric: re-parent window.layer into the secure canvas on enable, and fully reverse it on disable so that while protection is off the window is not inside any secure canvas. Order matters — move
window.layer back to its original superlayer before removing the overlay, otherwise removing the overlay tears down the canvas that currently hosts window.layer and blanks the whole UI.

private weak var originalWindowSuperlayer: CALayer?

public func enabledPreventScreenshot() {
guard let w = window else { return }
if !w.subviews.contains(screenPrevent) {
w.addSubview(screenPrevent)
screenPrevent.centerYAnchor.constraint(equalTo: w.centerYAnchor).isActive = true
screenPrevent.centerXAnchor.constraint(equalTo: w.centerXAnchor).isActive = true
originalWindowSuperlayer = w.layer.superlayer // remember the real host
w.layer.superlayer?.addSublayer(screenPrevent.layer)
if #available(iOS 17.0, *) {
screenPrevent.layer.sublayers?.last?.addSublayer(w.layer)
} else {
screenPrevent.layer.sublayers?.first?.addSublayer(w.layer)
}
}
screenPrevent.isSecureTextEntry = true
}

public func disablePreventScreenshot() {
screenPrevent.isSecureTextEntry = false
guard let w = window, w.subviews.contains(screenPrevent) else { return }
originalWindowSuperlayer?.addSublayer(w.layer) // 1) restore window.layer to its original host FIRST
originalWindowSuperlayer = nil
screenPrevent.layer.removeFromSuperlayer() // 2) then remove the overlay + its secure canvas
screenPrevent.removeFromSuperview()
}

Stateless alternative (no saved field) — after enable, screenPrevent.layer.superlayer is the original host:

public func disablePreventScreenshot() {
screenPrevent.isSecureTextEntry = false
guard let w = window, w.subviews.contains(screenPrevent) else { return }
screenPrevent.layer.superlayer?.addSublayer(w.layer)
screenPrevent.layer.removeFromSuperlayer()
screenPrevent.removeFromSuperview()
}

Expected result after fix: window.layer.superlayer is restored, the overlay is gone, the caret renders normally in UITextField / WKWebView, and the UILayoutGuide … .width == -1.5 autolayout warnings disappear.

Question: does 1.5.2 already address this? (The 1.5.2 release has no changelog notes, and the current implementation lives in the binary ScreenPreventerKit.xcframework, so it can't be verified from the repo source.)

[Bter]

Here's a minimal, self-contained UIKit repro to append to the issue:

---

Minimal reproducible example (pure UIKit, no WKWebView needed)

Single view controller. Tap Enable → Disable, then tap the text field: the keyboard appears and typing works, but there is no caret. (Comment out the two protector calls and the caret is normal — isolating the cause to
ScreenProtectorKit.)

import UIKit
import ScreenProtectorKit

final class CaretBugViewController: UIViewController {

  private lazy var protectorKit = ScreenProtectorKit(window: view.window)
  private let field = UITextField()

  override func viewDidLoad() {
      super.viewDidLoad()
      view.backgroundColor = .systemBackground

      field.borderStyle = .roundedRect
      field.placeholder = "Tap me AFTER pressing Enable→Disable — caret is gone"
      field.translatesAutoresizingMaskIntoConstraints = false

      let enableBtn = UIButton(type: .system)
      enableBtn.setTitle("1) Enable prevent-screenshot", for: .normal)
      enableBtn.addTarget(self, action: #selector(enableTapped), for: .touchUpInside)
      enableBtn.translatesAutoresizingMaskIntoConstraints = false

      let disableBtn = UIButton(type: .system)
      disableBtn.setTitle("2) Disable prevent-screenshot", for: .normal)
      disableBtn.addTarget(self, action: #selector(disableTapped), for: .touchUpInside)
      disableBtn.translatesAutoresizingMaskIntoConstraints = false

      let stack = UIStackView(arrangedSubviews: [enableBtn, disableBtn, field])
      stack.axis = .vertical
      stack.spacing = 24
      stack.translatesAutoresizingMaskIntoConstraints = false
      view.addSubview(stack)

      NSLayoutConstraint.activate([
          stack.centerYAnchor.constraint(equalTo: view.centerYAnchor),
          stack.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 24),
          stack.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -24),
          field.heightAnchor.constraint(equalToConstant: 44),
      ])
  }

  override func viewDidAppear(_ animated: Bool) {
      super.viewDidAppear(animated)
      // window is only available once the view is on screen
      protectorKit.setWindow(view.window)
  }

  @objc private func enableTapped() {
      protectorKit.enabledPreventScreenshot()   // screenPrevent.isSecureTextEntry = true
  }

  @objc private func disableTapped() {
      protectorKit.disablePreventScreenshot()   // screenPrevent.isSecureTextEntry = false — window.layer NOT restored
  }

}

Steps

1. Present CaretBugViewController.
2. Tap 1) Enable, then 2) Disable.
3. Tap the text field.

Actual: keyboard shows, typing/deleting works, caret invisible — and stays invisible for every text field afterwards until app relaunch.
Expected: caret visible after disablePreventScreenshot().

Control: comment out the enabledPreventScreenshot() / disablePreventScreenshot() calls → caret is normal, confirming ScreenProtectorKit as the cause.

(Note: depending on version you may need configurePreventionScreenshot() in didFinishLaunchingWithOptions for the overlay to be installed, as shown in the README's app-wide setup; the caret regression is the same.)