codeplay-common 4.9.2 → 4.9.4

package/files/buildCodeplay/codeplayBeforeBuild-6.4.js

@@ -1,3 +1,4 @@
+// Version 6.5: recreate failed WebViews, defer background recovery, and suppress foreground recovery toasts.
 const fs = require('fs');
 const path = require('path');
 const plist = require('plist');
@@ -1191,6 +1192,8 @@ if (!fs.existsSync(bridgeWebViewClientFilePath)) {
 }
 
 let fileContent = fs.readFileSync(bridgeWebViewClientFilePath, 'utf8');
+const bridgeWebViewLineEnding = fileContent.includes('\r\n') ? '\r\n' : '\n';
+fileContent = fileContent.replace(/\r\n/g, '\n');
 
 // Define old and new code
 const oldCodeStart = `@Override
@@ -1208,7 +1211,8 @@ const oldCodeStart = `@Override
         return result;
     }`;
 
-const newCode = `@Override
+// Match the previous patch so existing projects migrate without reinstalling Capacitor.
+const legacyReloadCode = `@Override
     public boolean onRenderProcessGone(WebView view, RenderProcessGoneDetail detail) {
         super.onRenderProcessGone(view, detail);
 
@@ -1244,15 +1248,104 @@ const newCode = `@Override
         return result;
     }`;
 
-// Step 1: Update method if needed
+const newCode = `// Codeplay WebView renderer recovery (before-build 6.5).
+    private boolean codeplayRendererRecoveryPending = false;
+    private static long codeplayRendererRecoveryWindowStart = -1L;
+    private static int codeplayRendererRecoveryCount = 0;
+
+    @Override
+    public boolean onRenderProcessGone(WebView view, RenderProcessGoneDetail detail) {
+        if (codeplayRendererRecoveryPending) return true;
+
+        boolean handled = false;
+        List<WebViewListener> webViewListeners = bridge.getWebViewListeners();
+        if (webViewListeners != null) {
+            for (WebViewListener listener : webViewListeners) {
+                handled = listener.onRenderProcessGone(view, detail) || handled;
+            }
+        }
+        if (handled) return true;
+
+        codeplayRendererRecoveryPending = true;
+        final androidx.appcompat.app.AppCompatActivity activity = bridge.getActivity();
+        final boolean wasInForeground = activity != null && activity.getLifecycle()
+            .getCurrentState().isAtLeast(androidx.lifecycle.Lifecycle.State.STARTED);
+
+        // A terminated renderer's WebView must never be loaded or reloaded again.
+        if (view.getParent() instanceof android.view.ViewGroup) {
+            ((android.view.ViewGroup) view.getParent()).removeView(view);
+        }
+        view.destroy();
+
+        if (activity == null || activity.isFinishing() || activity.isDestroyed()) return true;
+
+        final android.os.Handler mainHandler = new android.os.Handler(android.os.Looper.getMainLooper());
+        final Runnable recover = () -> {
+            if (activity.isFinishing() || activity.isDestroyed()) return;
+
+            // Static counters survive Activity recreation and prevent an automatic restart loop.
+            long now = android.os.SystemClock.elapsedRealtime();
+            if (codeplayRendererRecoveryWindowStart < 0L ||
+                now - codeplayRendererRecoveryWindowStart >= 60000L) {
+                codeplayRendererRecoveryWindowStart = now;
+                codeplayRendererRecoveryCount = 0;
+            }
+
+            if (codeplayRendererRecoveryCount >= 3) {
+                new android.app.AlertDialog.Builder(activity)
+                    .setTitle("Unable to restore the app")
+                    .setMessage("The app could not recover automatically. Please try again.")
+                    .setCancelable(false)
+                    .setPositiveButton("Try again", (dialog, which) -> {
+                        codeplayRendererRecoveryWindowStart = -1L;
+                        codeplayRendererRecoveryCount = 0;
+                        if (!activity.isFinishing() && !activity.isDestroyed()) activity.recreate();
+                    })
+                    .setNegativeButton("Close", (dialog, which) -> activity.finish())
+                    .show();
+                return;
+            }
+
+            codeplayRendererRecoveryCount++;
+            if (!wasInForeground) {
+                Toast.makeText(activity.getApplicationContext(), "Restoring your app…", Toast.LENGTH_SHORT).show();
+            }
+            activity.recreate();
+        };
+
+        if (wasInForeground) {
+            mainHandler.post(recover);
+        } else {
+            // Do not allocate another renderer while the app is hidden and memory may still be low.
+            activity.getLifecycle().addObserver(new androidx.lifecycle.LifecycleEventObserver() {
+                @Override
+                public void onStateChanged(
+                    androidx.lifecycle.LifecycleOwner source,
+                    androidx.lifecycle.Lifecycle.Event event
+                ) {
+                    if (event == androidx.lifecycle.Lifecycle.Event.ON_RESUME) {
+                        source.getLifecycle().removeObserver(this);
+                        mainHandler.post(recover);
+                    } else if (event == androidx.lifecycle.Lifecycle.Event.ON_DESTROY) {
+                        source.getLifecycle().removeObserver(this);
+                    }
+                }
+            });
+        }
+        return true;
+    }`;
+
+// Step 1: Update the stock method or migrate the previous reload-based patch.
 let updated = false;
 
-if (fileContent.includes(oldCodeStart)) {
-  console.log('✅ Found old onRenderProcessGone method. Replacing it...');
+if (fileContent.includes(newCode)) {
+  console.log('ℹ️  Method already updated. No changes needed in "BridgeWebViewClient.java".');
+} else if (fileContent.includes(legacyReloadCode)) {
+  fileContent = fileContent.replace(legacyReloadCode, newCode);
+  updated = true;
+} else if (fileContent.includes(oldCodeStart)) {
   fileContent = fileContent.replace(oldCodeStart, newCode);
   updated = true;
-} else if (fileContent.includes(newCode)) {
-  console.log('ℹ️  Method already updated. No changes needed in "BridgeWebViewClient.java".');
 } else {
   console.error('❌ Error: Neither old nor new code found. Unexpected content.');
   process.exit(1);
@@ -1280,7 +1373,7 @@ if (!fileContent.includes(importToast)) {
 
 // Step 3: Save if updated
 if (updated) {
-  fs.writeFileSync(bridgeWebViewClientFilePath, fileContent, 'utf8');
+  fs.writeFileSync(bridgeWebViewClientFilePath, fileContent.replace(/\n/g, bridgeWebViewLineEnding), 'utf8');
   console.log('✅ File updated successfully.');
 } else {
   console.log('ℹ️  No changes needed.');
@@ -4258,6 +4351,103 @@ function patchFile() {
 
 //##################################  SystemBars.java update for "@capacitor/android": "^8.3.0" plugin END ###############################
 
+// Android build optimization START
+function findAndroidBuildBlock(content, name) {
+  // Mask comments and strings without changing offsets or line endings.
+  const masked = content.replace(/\/\*[\s\S]*?\*\/|\/\/[^\r\n]*|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/g,
+    value => value.replace(/[^\r\n]/g, ' '));
+  const header = new RegExp(`\\b${name}\\s*\\{`, 'g');
+  let depth = 0;
+  for (let index = 0; index < masked.length; index += 1) {
+    if (depth === 0) {
+      header.lastIndex = index;
+      const match = header.exec(masked);
+      if (match && match.index === index) {
+        const start = header.lastIndex;
+        let blockDepth = 1;
+        for (let end = start; end < masked.length; end += 1) {
+          if (masked[end] === '{') blockDepth += 1;
+          if (masked[end] === '}' && --blockDepth === 0) return { start, end };
+        }
+        throw new Error(`Unclosed Android Gradle ${name} block.`);
+      }
+    }
+    if (masked[index] === '{') depth += 1;
+    if (masked[index] === '}') depth -= 1;
+  }
+  return null;
+}
+
+function syncAndroidBuildOptimization() {
+  if (buildPlatform !== 'android' || !fs.existsSync(androidAppBuildGradlePath)) return;
+
+  const original = fs.readFileSync(androidAppBuildGradlePath, 'utf8');
+  const newline = original.includes('\r\n') ? '\r\n' : '\n';
+  const androidBlock = findAndroidBuildBlock(original, 'android');
+  if (!androidBlock) throw new Error('Android Gradle android block was not found.');
+  let androidContent = original.slice(androidBlock.start, androidBlock.end);
+  const buildTypesBlock = findAndroidBuildBlock(androidContent, 'buildTypes');
+  if (!buildTypesBlock) throw new Error('Android Gradle buildTypes block was not found.');
+  let buildTypesContent = androidContent.slice(buildTypesBlock.start, buildTypesBlock.end);
+
+  // Match the existing finalrelease compatibility exception for this native plugin.
+  const ffmpegPluginXml = path.join(process.cwd(), 'node_modules', 'codeplay-fmpg', 'plugin.xml');
+  const optimizeRelease = !(fs.existsSync(ffmpegPluginXml)
+    && /<plugin\b/.test(fs.readFileSync(ffmpegPluginXml, 'utf8')));
+
+  for (const name of ['debug', 'release']) {
+    const enabled = name === 'debug' || optimizeRelease;
+    const block = findAndroidBuildBlock(buildTypesContent, name);
+    const blockComments = buildTypesContent.match(/\/\*[\s\S]*?\*\/|\/\/[^\r\n]*|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/g) || [];
+    if (!block && blockComments.some(comment => (comment.startsWith('//') || comment.startsWith('/*'))
+      && new RegExp(`\\b${name}\\s*\\{`).test(comment))) continue;
+    let body = block ? buildTypesContent.slice(block.start, block.end) : `${newline}        `;
+    const comments = (body.match(/\/\*[\s\S]*?\*\/|\/\/[^\r\n]*|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/g) || [])
+      .filter(value => value.startsWith('//') || value.startsWith('/*'));
+    for (const setting of ['minifyEnabled', 'shrinkResources']) {
+      const masked = body.replace(/\/\*[\s\S]*?\*\/|\/\/[^\r\n]*|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/g,
+        value => value.replace(/[^\r\n]/g, ' '));
+      const settingPattern = new RegExp(`\\b${setting}\\b`);
+      // Existing values, expressions and commented opt-outs take precedence.
+      if (settingPattern.test(masked) || comments.some(comment => settingPattern.test(comment))) continue;
+      const value = setting === 'shrinkResources'
+        ? enabled && /\bminifyEnabled\s*(?:=\s*)?true\b/.test(masked)
+        : enabled;
+      body = `${newline}            ${setting} ${value}${body}`;
+    }
+    const activeBody = body.replace(/\/\*[\s\S]*?\*\/|\/\/[^\r\n]*|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/g,
+      value => value.startsWith('//') || value.startsWith('/*') ? value.replace(/[^\r\n]/g, ' ') : value);
+    const defaultRules = [...activeBody.matchAll(/getDefaultProguardFile\(\s*(['"])proguard-android\.txt\1\s*\)/g)];
+    for (const match of defaultRules.reverse()) {
+      body = body.slice(0, match.index) + "getDefaultProguardFile('proguard-android-optimize.txt')"
+        + body.slice(match.index + match[0].length);
+    }
+    if (!/\bproguardFiles\b/.test(activeBody)
+      && !comments.some(comment => /\bproguardFiles\b/.test(comment))) {
+      body = `${newline}            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'${body}`;
+    }
+    buildTypesContent = block
+      ? buildTypesContent.slice(0, block.start) + body + buildTypesContent.slice(block.end)
+      : `${buildTypesContent.trimEnd()}${newline}        ${name} {${body}}${newline}    `;
+  }
+
+  androidContent = androidContent.slice(0, buildTypesBlock.start) + buildTypesContent
+    + androidContent.slice(buildTypesBlock.end);
+  const next = original.slice(0, androidBlock.start) + androidContent + original.slice(androidBlock.end);
+  if (next !== original) fs.writeFileSync(androidAppBuildGradlePath, next, 'utf8');
+
+  const propertiesPath = path.join(androidPlatformPath, 'gradle.properties');
+  const properties = fs.existsSync(propertiesPath) ? fs.readFileSync(propertiesPath, 'utf8') : '';
+  const property = 'android.r8.optimizedResourceShrinking=true';
+  const propertyPattern = /^[ \t]*[#!]?[ \t]*android\.r8\.optimizedResourceShrinking(?:[ \t]*[=:]|[ \t]+|[ \t]*$)/m;
+  const nextProperties = propertyPattern.test(properties)
+    ? properties
+    : `${properties.trimEnd()}${newline}${property}${newline}`;
+  if (nextProperties !== properties) fs.writeFileSync(propertiesPath, nextProperties, 'utf8');
+  console.log('✅ Android build optimization defaults checked; existing settings and commented opt-outs preserved.');
+}
+// Android build optimization END
+
 async function main() {
   validateThemeFolderLocation();
   validateAndRestoreSignDetails();
@@ -4276,6 +4466,7 @@ async function main() {
   checkAndupdateDropInViteConfig();
   checkAdmobConfigurationProperty();
   syncAndroidAdIdPermission();
+  syncAndroidBuildOptimization();
 }
 
 await main();
@@ -4291,6 +4482,8 @@ await main();
 Release Notes
 
   6.5
+    Enable debug/release optimization and optimized resource shrinking before Android builds.
+    Preserve existing values and commented opt-outs without adding duplicate settings.
     Kids ad configuration disables iOS ATT prompts and excludes Android AD_ID during builds.
     Non-kids apps retain tracking prompts and normal permission behavior.
     Ad configuration migration preserves newer local configuration versions.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeplay-common",
-  "version": "4.9.2",
+  "version": "4.9.4",
   "description": "Common build scripts and files",
   "scripts": {
 	"postinstall": "node scripts/sync-files.js",