@capgo/capacitor-patch 8.1.0 → 8.2.1

package/patches/upstream-pr-8275-android.patch

@@ -0,0 +1,158 @@
+diff --git a/capacitor/src/main/java/com/getcapacitor/BridgeWebChromeClient.java b/capacitor/src/main/java/com/getcapacitor/BridgeWebChromeClient.java
+index 6ca1c8a8..6b9f603d 100644
+--- a/capacitor/src/main/java/com/getcapacitor/BridgeWebChromeClient.java
++++ b/capacitor/src/main/java/com/getcapacitor/BridgeWebChromeClient.java
+@@ -46,6 +46,17 @@ public class BridgeWebChromeClient extends WebChromeClient {
+         void onActivityResult(ActivityResult result);
+     }
+ 
++    // Static variables to store pending file chooser state to survive activity recreation
++    private static ValueCallback<Uri[]> pendingFilePathCallback;
++    private static Uri pendingImageFileUri;
++    private static FileChooserType pendingFileChooserType;
++
++    private enum FileChooserType {
++        IMAGE_CAPTURE,
++        VIDEO_CAPTURE,
++        FILE_PICKER
++    }
++
+     private ActivityResultLauncher permissionLauncher;
+     private ActivityResultLauncher activityLauncher;
+     private PermissionListener permissionListener;
+@@ -70,10 +81,70 @@ public class BridgeWebChromeClient extends WebChromeClient {
+         activityLauncher = bridge.registerForActivityResult(new ActivityResultContracts.StartActivityForResult(), (result) -> {
+             if (activityListener != null) {
+                 activityListener.onActivityResult(result);
++            } else if (pendingFilePathCallback != null) {
++                // Handle case where activity was recreated and instance callback is null
++                // Use the static callback instead
++                handlePendingFileChooserResult(result);
+             }
+         });
+     }
+ 
++    /**
++     * Handle file chooser result when the activity was recreated and instance callbacks were lost.
++     * This uses the static pending callback to deliver the result.
++     */
++    private void handlePendingFileChooserResult(ActivityResult result) {
++        if (pendingFilePathCallback == null) {
++            return;
++        }
++
++        try {
++            Uri[] uriResult = null;
++            if (result.getResultCode() == Activity.RESULT_OK) {
++                switch (pendingFileChooserType) {
++                    case IMAGE_CAPTURE:
++                        if (pendingImageFileUri != null) {
++                            uriResult = new Uri[] { pendingImageFileUri };
++                        }
++                        break;
++                    case VIDEO_CAPTURE:
++                        Intent videoData = result.getData();
++                        if (videoData != null && videoData.getData() != null) {
++                            uriResult = new Uri[] { videoData.getData() };
++                        }
++                        break;
++                    case FILE_PICKER:
++                        Intent fileData = result.getData();
++                        if (fileData != null) {
++                            if (fileData.getClipData() != null) {
++                                final int numFiles = fileData.getClipData().getItemCount();
++                                uriResult = new Uri[numFiles];
++                                for (int i = 0; i < numFiles; i++) {
++                                    uriResult[i] = fileData.getClipData().getItemAt(i).getUri();
++                                }
++                            } else {
++                                uriResult = WebChromeClient.FileChooserParams.parseResult(result.getResultCode(), fileData);
++                            }
++                        }
++                        break;
++                }
++            }
++            pendingFilePathCallback.onReceiveValue(uriResult);
++        } finally {
++            // Clear the static state after handling
++            clearPendingFileChooserState();
++        }
++    }
++
++    /**
++     * Clear the static pending file chooser state.
++     */
++    private static void clearPendingFileChooserState() {
++        pendingFilePathCallback = null;
++        pendingImageFileUri = null;
++        pendingFileChooserType = null;
++    }
++
+     /**
+      * Render web content in `view`.
+      *
+@@ -340,12 +411,19 @@ public class BridgeWebChromeClient extends WebChromeClient {
+             return false;
+         }
+         takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, imageFileUri);
++
++        // Store in static variables to survive activity recreation
++        pendingFilePathCallback = filePathCallback;
++        pendingImageFileUri = imageFileUri;
++        pendingFileChooserType = FileChooserType.IMAGE_CAPTURE;
++
+         activityListener = (activityResult) -> {
+             Uri[] result = null;
+             if (activityResult.getResultCode() == Activity.RESULT_OK) {
+                 result = new Uri[] { imageFileUri };
+             }
+             filePathCallback.onReceiveValue(result);
++            clearPendingFileChooserState();
+         };
+         activityLauncher.launch(takePictureIntent);
+ 
+@@ -359,12 +437,18 @@ public class BridgeWebChromeClient extends WebChromeClient {
+             return false;
+         }
+ 
++        // Store in static variables to survive activity recreation
++        pendingFilePathCallback = filePathCallback;
++        pendingImageFileUri = null;
++        pendingFileChooserType = FileChooserType.VIDEO_CAPTURE;
++
+         activityListener = (activityResult) -> {
+             Uri[] result = null;
+             if (activityResult.getResultCode() == Activity.RESULT_OK) {
+                 result = new Uri[] { activityResult.getData().getData() };
+             }
+             filePathCallback.onReceiveValue(result);
++            clearPendingFileChooserState();
+         };
+         activityLauncher.launch(takeVideoIntent);
+ 
+@@ -383,6 +467,12 @@ public class BridgeWebChromeClient extends WebChromeClient {
+                 intent.setType(validTypes[0]);
+             }
+         }
++
++        // Store in static variables to survive activity recreation
++        pendingFilePathCallback = filePathCallback;
++        pendingImageFileUri = null;
++        pendingFileChooserType = FileChooserType.FILE_PICKER;
++
+         try {
+             activityListener = (activityResult) -> {
+                 Uri[] result;
+@@ -397,10 +487,12 @@ public class BridgeWebChromeClient extends WebChromeClient {
+                     result = WebChromeClient.FileChooserParams.parseResult(activityResult.getResultCode(), resultIntent);
+                 }
+                 filePathCallback.onReceiveValue(result);
++                clearPendingFileChooserState();
+             };
+             activityLauncher.launch(intent);
+         } catch (ActivityNotFoundException e) {
+             filePathCallback.onReceiveValue(null);
++            clearPendingFileChooserState();
+         }
+     }
+ 

package/patches/upstream-pr-8304-ios.patch

@@ -0,0 +1,36 @@
+diff --git a/Capacitor/Capacitor/Plugins/HttpRequestHandler.swift b/Capacitor/Capacitor/Plugins/HttpRequestHandler.swift
+index 651c1b76..2230b32d 100644
+--- a/Capacitor/Capacitor/Plugins/HttpRequestHandler.swift
++++ b/Capacitor/Capacitor/Plugins/HttpRequestHandler.swift
+@@ -224,11 +224,26 @@ open class HttpRequestHandler {
+                 call.reject(error.localizedDescription, (error as NSError).domain, error, nil)
+                 return
+             }
+-
+-            setCookiesFromResponse(response as! HTTPURLResponse, config)
+-
+-            let type = ResponseType(rawValue: responseType) ?? .default
+-            call.resolve(self.buildResponse(data, response as! HTTPURLResponse, responseType: type))
++                                                          
++            if let response = response as? HTTPURLResponse {
++                setCookiesFromResponse(response, config)
++    
++                let type = ResponseType(rawValue: responseType) ?? .default
++                call.resolve(self.buildResponse(data, response, responseType: type))
++            } else if let response = response as? NSURLResponse {
++                // applicable to data: URI requests
++                var headers = [:] as [String: Any]
++                headers["Content-Type"] = response.mimeType
++                
++                var output = [:] as [String: Any]
++                output["status"] = 200
++                output["headers"] = headers
++                output["data"] = String(data: data!, encoding: .utf8)
++                call.resolve(output)
++            } else {
++                call.reject("Unknown response kind")
++                return
++            }
+         }
+ 
+         task.resume()

package/patches/upstream-pr-8418-android.patch

@@ -0,0 +1,82 @@
+diff --git a/capacitor/src/main/java/com/getcapacitor/WebViewLocalServer.java b/capacitor/src/main/java/com/getcapacitor/WebViewLocalServer.java
+index a39483de..a952f2ca 100755
+--- a/capacitor/src/main/java/com/getcapacitor/WebViewLocalServer.java
++++ b/capacitor/src/main/java/com/getcapacitor/WebViewLocalServer.java
+@@ -348,16 +348,22 @@ public class WebViewLocalServer {
+             Map<String, String> tempResponseHeaders = handler.buildDefaultResponseHeaders();
+             int statusCode = 206;
+             try {
+-                int totalRange = responseStream.available();
++                int totalSize = responseStream.available();
+                 String[] parts = rangeString.split("=");
+                 String[] streamParts = parts[1].split("-");
+-                String fromRange = streamParts[0];
+-                int range = totalRange - 1;
+-                if (streamParts.length > 1) {
+-                    range = Integer.parseInt(streamParts[1]);
++                int fromRange = Integer.parseInt(streamParts[0]);
++                int endRange = totalSize - 1;
++                if (streamParts.length > 1 && !streamParts[1].isEmpty()) {
++                    endRange = Integer.parseInt(streamParts[1]);
+                 }
++
++                // Truncate the stream at the end of the requested range.
++                // Somewhere in the request pipeline, the stream gets automatically
++                // seeked to the correct start position, so we don't need to skip to the fromRange position here.
++                responseStream = new BoundedInputStream(responseStream, endRange + 1);
++
+                 tempResponseHeaders.put("Accept-Ranges", "bytes");
+-                tempResponseHeaders.put("Content-Range", "bytes " + fromRange + "-" + range + "/" + totalRange);
++                tempResponseHeaders.put("Content-Range", "bytes " + fromRange + "-" + endRange + "/" + totalSize);
+             } catch (IOException e) {
+                 statusCode = 404;
+             }
+@@ -750,6 +756,48 @@ public class WebViewLocalServer {
+         }
+     }
+ 
++    /**
++     * An InputStream wrapper that limits the number of bytes that can be read.
++     */
++    static class BoundedInputStream extends InputStream {
++
++        private final InputStream in;
++        private long remaining;
++
++        public BoundedInputStream(InputStream in, long limit) {
++            this.in = in;
++            this.remaining = limit;
++        }
++
++        @Override
++        public int available() throws IOException {
++            int available = in.available();
++            return (int) Math.min(available, remaining);
++        }
++
++        @Override
++        public int read() throws IOException {
++            if (remaining <= 0) return -1;
++            int result = in.read();
++            if (result != -1) remaining--;
++            return result;
++        }
++
++        @Override
++        public int read(byte[] b, int off, int len) throws IOException {
++            if (remaining <= 0) return -1;
++            int toRead = (int) Math.min(len, remaining);
++            int result = in.read(b, off, toRead);
++            if (result > 0) remaining -= result;
++            return result;
++        }
++
++        @Override
++        public void close() throws IOException {
++            in.close();
++        }
++    }
++
+     // For L and above.
+     private static class LollipopLazyInputStream extends LazyInputStream {
+ 

package/patches/upstream-pr-8424-android.patch

@@ -0,0 +1,55 @@
+diff --git a/capacitor/src/main/java/com/getcapacitor/plugin/SystemBars.java b/capacitor/src/main/java/com/getcapacitor/plugin/SystemBars.java
+index b335b4b1..76e74207 100644
+--- a/capacitor/src/main/java/com/getcapacitor/plugin/SystemBars.java
++++ b/capacitor/src/main/java/com/getcapacitor/plugin/SystemBars.java
+@@ -164,13 +164,18 @@ public class SystemBars extends Plugin {
+     }
+ 
+     private void initSafeAreaCSSVariables() {
+-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM && insetHandlingEnabled) {
++        WindowInsetsCompat insets;
++
++        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM) {
+             View v = (View) this.getBridge().getWebView().getParent();
+-            WindowInsetsCompat insets = ViewCompat.getRootWindowInsets(v);
+-            if (insets != null) {
+-                Insets safeAreaInsets = calcSafeAreaInsets(insets);
+-                injectSafeAreaCSS(safeAreaInsets.top, safeAreaInsets.right, safeAreaInsets.bottom, safeAreaInsets.left);
+-            }
++            insets = ViewCompat.getRootWindowInsets(v);
++        } else {
++            insets = WindowInsetsCompat.CONSUMED;
++        }
++
++        if (insets != null) {
++            Insets safeAreaInsets = calcSafeAreaInsets(insets);
++            injectSafeAreaCSS(safeAreaInsets.top, safeAreaInsets.right, safeAreaInsets.bottom, safeAreaInsets.left);
+         }
+     }
+ 
+@@ -186,10 +191,8 @@ public class SystemBars extends Plugin {
+                 // We need to correct for a possible shown IME
+                 v.setPadding(0, 0, 0, keyboardVisible ? imeInsets.bottom : 0);
+ 
+-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM && hasViewportCover && insetHandlingEnabled) {
+-                    Insets safeAreaInsets = calcSafeAreaInsets(insets);
+-                    injectSafeAreaCSS(safeAreaInsets.top, safeAreaInsets.right, safeAreaInsets.bottom, safeAreaInsets.left);
+-                }
++                Insets safeAreaInsets = calcSafeAreaInsets(insets);
++                injectSafeAreaCSS(safeAreaInsets.top, safeAreaInsets.right, safeAreaInsets.bottom, safeAreaInsets.left);
+ 
+                 return new WindowInsetsCompat.Builder(insets)
+                     .setInsets(
+@@ -221,10 +224,8 @@ public class SystemBars extends Plugin {
+                 .setInsets(WindowInsetsCompat.Type.systemBars() | WindowInsetsCompat.Type.displayCutout(), Insets.of(0, 0, 0, 0))
+                 .build();
+ 
+-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM && hasViewportCover && insetHandlingEnabled) {
+-                Insets safeAreaInsets = calcSafeAreaInsets(newInsets);
+-                injectSafeAreaCSS(safeAreaInsets.top, safeAreaInsets.right, safeAreaInsets.bottom, safeAreaInsets.left);
+-            }
++            Insets safeAreaInsets = calcSafeAreaInsets(newInsets);
++            injectSafeAreaCSS(safeAreaInsets.top, safeAreaInsets.right, safeAreaInsets.bottom, safeAreaInsets.left);
+ 
+             return newInsets;
+         });

package/patches/upstream-pr-8429-android.patch

@@ -0,0 +1,19 @@
+diff --git a/capacitor/src/main/java/com/getcapacitor/Bridge.java b/capacitor/src/main/java/com/getcapacitor/Bridge.java
+index d4995fbb..71b658f5 100644
+--- a/capacitor/src/main/java/com/getcapacitor/Bridge.java
++++ b/capacitor/src/main/java/com/getcapacitor/Bridge.java
+@@ -265,8 +265,13 @@ public class Bridge {
+         JSInjector injector = getJSInjector();
+         if (WebViewFeature.isFeatureSupported(WebViewFeature.DOCUMENT_START_SCRIPT)) {
+             String allowedOrigin = Uri.parse(appUrl).buildUpon().path(null).fragment(null).clearQuery().build().toString();
++            final String finalAllowedOrigin = allowedOrigin;
++            Set<String> allowedOrigins = new HashSet<String>() {{
++                add(finalAllowedOrigin);
++                addAll(allowedOriginRules);
++            }};
+             try {
+-                WebViewCompat.addDocumentStartJavaScript(webView, injector.getScriptString(), Collections.singleton(allowedOrigin));
++                WebViewCompat.addDocumentStartJavaScript(webView, injector.getScriptString(), allowedOrigins);
+                 injector = null;
+             } catch (IllegalArgumentException ex) {
+                 Logger.warn("Invalid url, using fallback");

package/patches/upstream-pr-8454-android.patch

@@ -0,0 +1,207 @@
+diff --git a/capacitor/src/main/java/com/getcapacitor/plugin/SystemBars.java b/capacitor/src/main/java/com/getcapacitor/plugin/SystemBars.java
+index b335b4b1..c77efda7 100644
+--- a/capacitor/src/main/java/com/getcapacitor/plugin/SystemBars.java
++++ b/capacitor/src/main/java/com/getcapacitor/plugin/SystemBars.java
+@@ -59,6 +59,8 @@ public class SystemBars extends Plugin {
+     private String currentStatusBarStyle = STYLE_DEFAULT;
+     private String currentGestureBarStyle = STYLE_DEFAULT;
+ 
++    private boolean navBarVisible = true;
++
+     @Override
+     public void load() {
+         getBridge().getWebView().addJavascriptInterface(this, "CapacitorSystemBarsAndroidInterface");
+@@ -76,7 +78,15 @@ public class SystemBars extends Plugin {
+                 @Override
+                 public void onPageCommitVisible(WebView view, String url) {
+                     super.onPageCommitVisible(view, url);
+-                    getBridge().getWebView().requestApplyInsets();
++                    View parentView = (View) getBridge().getWebView().getParent();
++                    ViewCompat.requestApplyInsets(parentView);
++                    if (insetHandlingEnabled) {
++                        WindowInsetsCompat rootInsets = ViewCompat.getRootWindowInsets(parentView);
++                        if (rootInsets != null) {
++                            Insets safeArea = calcSafeAreaInsets(rootInsets);
++                            injectSafeAreaCSS(safeArea.top, safeArea.right, safeArea.bottom, safeArea.left);
++                        }
++                    }
+                 }
+             }
+         );
+@@ -103,8 +113,17 @@ public class SystemBars extends Plugin {
+         initSafeAreaCSSVariables();
+ 
+         getBridge().executeOnMainThread(() -> {
++            Window window = getActivity().getWindow();
++            WindowCompat.setDecorFitsSystemWindows(window, false);
++            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.VANILLA_ICE_CREAM) {
++                window.setNavigationBarColor(android.graphics.Color.TRANSPARENT);
++                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
++                    window.setNavigationBarContrastEnforced(false);
++                }
++            }
+             setStyle(style, "");
+             setHidden(hidden, "");
++            ViewCompat.requestApplyInsets((View) getBridge().getWebView().getParent());
+         });
+     }
+ 
+@@ -144,27 +163,64 @@ public class SystemBars extends Plugin {
+         call.resolve();
+     }
+ 
++    @Override
++    protected void handleOnResume() {
++        super.handleOnResume();
++        getBridge().executeOnMainThread(() -> {
++            Window window = getActivity().getWindow();
++            WindowCompat.setDecorFitsSystemWindows(window, false);
++            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.VANILLA_ICE_CREAM) {
++                window.setNavigationBarColor(android.graphics.Color.TRANSPARENT);
++                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
++                    window.setNavigationBarContrastEnforced(false);
++                }
++            }
++            setStyle(currentGestureBarStyle, BAR_GESTURE_BAR);
++            setStyle(currentStatusBarStyle, BAR_STATUS_BAR);
++            ViewCompat.requestApplyInsets((View) getBridge().getWebView().getParent());
++        });
++    }
++
+     @JavascriptInterface
+     public void onDOMReady() {
+         getActivity().runOnUiThread(() -> {
+             this.bridge.getWebView().evaluateJavascript(viewportMetaJSFunction, (res) -> {
+                 hasViewportCover = res.equals("true");
+-
+-                getBridge().getWebView().requestApplyInsets();
++                ViewCompat.requestApplyInsets((View) getBridge().getWebView().getParent());
+             });
+         });
+     }
+ 
+     private Insets calcSafeAreaInsets(WindowInsetsCompat insets) {
+         Insets safeArea = insets.getInsets(WindowInsetsCompat.Type.systemBars() | WindowInsetsCompat.Type.displayCutout());
+-        if (insets.isVisible(WindowInsetsCompat.Type.ime())) {
++
++        int bottom = safeArea.bottom;
++
++        if (bottom == 0
++                && Build.VERSION.SDK_INT < Build.VERSION_CODES.R
++                && safeArea.left == 0 && safeArea.right == 0) { // skip if nav bar is on a side (landscape)
++            bottom = getNavBarHeightFromResources();
++        }
++
++        boolean imeVisible = Build.VERSION.SDK_INT >= Build.VERSION_CODES.O
++                ? insets.isVisible(WindowInsetsCompat.Type.ime())
++                : insets.getInsets(WindowInsetsCompat.Type.ime()).bottom > 0;
++
++        if (imeVisible) {
+             return Insets.of(safeArea.left, safeArea.top, safeArea.right, 0);
+         }
+-        return Insets.of(safeArea.left, safeArea.top, safeArea.right, safeArea.bottom);
++        return Insets.of(safeArea.left, safeArea.top, safeArea.right, bottom);
++    }
++
++    private int getNavBarHeightFromResources() {
++        if (!navBarVisible) return 0;
++        android.content.res.Resources res = getActivity().getResources();
++        int heightId = res.getIdentifier("navigation_bar_height", "dimen", "android");
++        return heightId > 0 ? res.getDimensionPixelSize(heightId) : 0;
+     }
+ 
+     private void initSafeAreaCSSVariables() {
+-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM && insetHandlingEnabled) {
++        if (insetHandlingEnabled) {
+             View v = (View) this.getBridge().getWebView().getParent();
+             WindowInsetsCompat insets = ViewCompat.getRootWindowInsets(v);
+             if (insets != null) {
+@@ -176,6 +232,10 @@ public class SystemBars extends Plugin {
+ 
+     private void initWindowInsetsListener() {
+         ViewCompat.setOnApplyWindowInsetsListener((View) getBridge().getWebView().getParent(), (v, insets) -> {
++            // getRootWindowInsets() bypasses AppCompat's intermediate view consuming the bottom inset on API < 30
++            WindowInsetsCompat rawInsets = ViewCompat.getRootWindowInsets(v);
++            WindowInsetsCompat safeAreaSource = (rawInsets != null) ? rawInsets : insets;
++
+             boolean shouldPassthroughInsets = getWebViewMajorVersion() >= WEBVIEW_VERSION_WITH_SAFE_AREA_FIX && hasViewportCover;
+ 
+             Insets systemBarsInsets = insets.getInsets(WindowInsetsCompat.Type.systemBars() | WindowInsetsCompat.Type.displayCutout());
+@@ -186,8 +246,8 @@ public class SystemBars extends Plugin {
+                 // We need to correct for a possible shown IME
+                 v.setPadding(0, 0, 0, keyboardVisible ? imeInsets.bottom : 0);
+ 
+-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM && hasViewportCover && insetHandlingEnabled) {
+-                    Insets safeAreaInsets = calcSafeAreaInsets(insets);
++                if (hasViewportCover && insetHandlingEnabled) {
++                    Insets safeAreaInsets = calcSafeAreaInsets(safeAreaSource);
+                     injectSafeAreaCSS(safeAreaInsets.top, safeAreaInsets.right, safeAreaInsets.bottom, safeAreaInsets.left);
+                 }
+ 
+@@ -204,15 +264,7 @@ public class SystemBars extends Plugin {
+                     .build();
+             }
+ 
+-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM) {
+-                // We need to correct for a possible shown IME
+-                v.setPadding(
+-                    systemBarsInsets.left,
+-                    systemBarsInsets.top,
+-                    systemBarsInsets.right,
+-                    keyboardVisible ? imeInsets.bottom : systemBarsInsets.bottom
+-                );
+-            }
++            v.setPadding(0, 0, 0, keyboardVisible ? imeInsets.bottom : 0);
+ 
+             // Returning `WindowInsetsCompat.CONSUMED` breaks recalculation of safe area insets
+             // So we have to explicitly set insets to `0`
+@@ -221,8 +273,8 @@ public class SystemBars extends Plugin {
+                 .setInsets(WindowInsetsCompat.Type.systemBars() | WindowInsetsCompat.Type.displayCutout(), Insets.of(0, 0, 0, 0))
+                 .build();
+ 
+-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM && hasViewportCover && insetHandlingEnabled) {
+-                Insets safeAreaInsets = calcSafeAreaInsets(newInsets);
++            if (insetHandlingEnabled) {
++                Insets safeAreaInsets = calcSafeAreaInsets(safeAreaSource);
+                 injectSafeAreaCSS(safeAreaInsets.top, safeAreaInsets.right, safeAreaInsets.bottom, safeAreaInsets.left);
+             }
+ 
+@@ -263,6 +315,7 @@ public class SystemBars extends Plugin {
+     }
+ 
+     private void setStyle(String style, String bar) {
++        String requestedStyle = style;
+         if (style.equals(STYLE_DEFAULT)) {
+             style = getStyleForTheme();
+         }
+@@ -270,12 +323,12 @@ public class SystemBars extends Plugin {
+         Window window = getActivity().getWindow();
+         WindowInsetsControllerCompat windowInsetsControllerCompat = WindowCompat.getInsetsController(window, window.getDecorView());
+         if (bar.isEmpty() || bar.equals(BAR_STATUS_BAR)) {
+-            currentStatusBarStyle = style;
++            currentStatusBarStyle = requestedStyle;
+             windowInsetsControllerCompat.setAppearanceLightStatusBars(!style.equals(STYLE_DARK));
+         }
+ 
+         if (bar.isEmpty() || bar.equals(BAR_GESTURE_BAR)) {
+-            currentGestureBarStyle = style;
++            currentGestureBarStyle = requestedStyle;
+             windowInsetsControllerCompat.setAppearanceLightNavigationBars(!style.equals(STYLE_DARK));
+         }
+ 
+@@ -292,6 +345,7 @@ public class SystemBars extends Plugin {
+             }
+             if (bar.isEmpty() || bar.equals(BAR_GESTURE_BAR)) {
+                 windowInsetsControllerCompat.hide(WindowInsetsCompat.Type.navigationBars());
++                navBarVisible = false;
+             }
+             return;
+         }
+@@ -301,6 +355,7 @@ public class SystemBars extends Plugin {
+         }
+         if (bar.isEmpty() || bar.equals(BAR_GESTURE_BAR)) {
+             windowInsetsControllerCompat.show(WindowInsetsCompat.Type.navigationBars());
++            navBarVisible = true;
+         }
+     }
+ 

package/patches/upstream-pr-8458-cli.patch

@@ -0,0 +1,14 @@
+diff --git a/dist/ios/build.js b/dist/ios/build.js
+index 249518e..c293d47 100644
+--- a/dist/ios/build.js
++++ b/dist/ios/build.js
+@@ -44,6 +44,9 @@ async function buildiOS(config, buildOptions) {
+     if (buildOptions.xcodeSigningType == 'manual') {
+         buildArgs.push(`PROVISIONING_PROFILE_SPECIFIER=${buildOptions.xcodeProvisioningProfile}`);
+     }
++    else {
++        buildArgs.push('-allowProvisioningUpdates');
++    }
+     await (0, common_1.runTask)('Building xArchive', async () => (0, subprocess_1.runCommand)('xcodebuild', buildArgs, {
+         cwd: config.ios.nativeProjectDirAbs,
+     }));

package/scripts/capacitor-patch/runner.mjs

@@ -28,6 +28,18 @@ export async function runCapacitorPatch(options) {
     });
   }
 
+  for (const entry of selected.superseded) {
+    results.push({
+      id: entry.patch.id,
+      title: entry.patch.title,
+      phase,
+      selectedBy: entry.selectedBy,
+      status: 'skipped',
+      changedFiles: [],
+      reason: `Superseded by ${entry.supersededBy}.`,
+    });
+  }
+
   for (const entry of selected.patches) {
     results.push(
       await applyCatalogPatch({
@@ -50,7 +62,7 @@ export async function runCapacitorPatch(options) {
 
   return {
     phase,
-    selectedCount: selected.patches.length + selected.unknownIds.length,
+    selectedCount: selected.patches.length + selected.unknownIds.length + selected.superseded.length,
     results,
   };
 }
@@ -59,7 +71,7 @@ export function selectPatches(catalog, patchConfig, phase) {
   const disabled = new Set(patchConfig.disabled);
   const explicit = new Set(patchConfig.patches);
   const catalogById = new Map(catalog.map((patch) => [patch.id, patch]));
-  const patches = [];
+  const selectedEntries = [];
 
   for (const patch of catalog) {
     if (!patch?.id || patch.phase !== phase || disabled.has(patch.id)) {
@@ -67,14 +79,36 @@ export function selectPatches(catalog, patchConfig, phase) {
     }
 
     if (explicit.has(patch.id)) {
-      patches.push({ patch, selectedBy: 'explicit' });
+      selectedEntries.push({ patch, selectedBy: 'explicit' });
     } else if (patchConfig.recommended && patch.recommended === true) {
-      patches.push({ patch, selectedBy: 'recommended' });
+      selectedEntries.push({ patch, selectedBy: 'recommended' });
+    }
+  }
+
+  const selectedIds = new Set(selectedEntries.map((entry) => entry.patch.id));
+  const supersededBy = new Map();
+  for (const entry of selectedEntries) {
+    for (const supersededId of entry.patch.supersedes ?? []) {
+      if (selectedIds.has(supersededId) && !disabled.has(supersededId)) {
+        supersededBy.set(supersededId, entry.patch.id);
+      }
+    }
+  }
+
+  const patches = [];
+  const superseded = [];
+  for (const entry of selectedEntries) {
+    const replacementId = supersededBy.get(entry.patch.id);
+    if (replacementId) {
+      superseded.push({ ...entry, supersededBy: replacementId });
+    } else {
+      patches.push(entry);
     }
   }
 
   return {
     patches,
+    superseded,
     unknownIds: patchConfig.patches.filter((id) => !disabled.has(id) && !catalogById.has(id)),
   };
 }