codeplay-common 4.3.4 → 4.3.5

package/files/{take-responsive-screenshot.js → take-screen-image.js}

@@ -3,9 +3,12 @@ const path = require('node:path');
 const readline = require('node:readline/promises');
 const { spawn, spawnSync } = require('node:child_process');
 
-const screenshotDirectory = path.join(__dirname, 'Auto-Screenshot', 'Responsive');
-const inFrameDirectory = path.join(__dirname, 'Auto-Screenshot', 'In-Frame');
-const capacitorConfigPath = path.join(__dirname, 'capacitor.config.json');
+const screenshotDirectory = path.join(__dirname, 'Auto-Screenshot', 'Store-image-Screenshot');
+const inFrameDirectory = path.join(__dirname, 'Auto-Screenshot', 'Store-image-Frame');
+const amazonAssetsDirectory = path.join(__dirname, 'Auto-Screenshot', 'Amazon-assets');
+const samsungAssetsDirectory = path.join(__dirname, 'Auto-Screenshot', 'Samsung-assets');
+const capacitorConfigPath = path.join(__dirname, 'capacitor.config.json');
+const amazonIconPath = path.join(__dirname, 'resources', 'icon-only.png');
 const temporaryDirectory = path.join(__dirname, 'agent-temp');
 const browserExecutablePaths = [
   'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
@@ -26,9 +29,9 @@ const deviceProfiles = [
     orientationSensitive: true,
     mobile: true,
   },
-  {
-    name: 'android-tablet',
-    label: 'Android tablet',
+  {
+    name: 'android-tablet',
+    label: 'Android tablet',
     outputDirectory: 'Android-Tab',
     frameType: 'tablet',
     width: 800,
@@ -36,7 +39,18 @@ const deviceProfiles = [
     deviceScaleFactor: 2,
     orientationSensitive: true,
     mobile: true,
-  },
+  },
+  {
+    name: 'android-tablet-10-inch',
+    label: 'Android 10-inch Play Store tablet',
+    outputDirectory: 'Android-Tab-10-Inch',
+    frameType: 'tablet',
+    width: 720,
+    height: 1280,
+    deviceScaleFactor: 2,
+    orientationSensitive: true,
+    mobile: true,
+  },
   {
     name: 'iphone',
     label: 'iPhone 6.9-inch App Store viewport',
@@ -141,16 +155,16 @@ const deviceProfiles = [
     deviceScaleFactor: 1,
     mobile: false,
   },
-  {
-    name: 'chromebook',
-    label: 'Chromebook-sized viewport',
-    outputDirectory: 'Chromebook',
-    frameType: 'laptop',
-    width: 1366,
-    height: 768,
-    deviceScaleFactor: 1,
-    mobile: false,
-  },
+  {
+    name: 'chromebook',
+    label: 'Chromebook Play Store viewport',
+    outputDirectory: 'Chromebook',
+    frameType: 'laptop',
+    width: 1920,
+    height: 1080,
+    deviceScaleFactor: 1,
+    mobile: false,
+  },
   {
     name: 'android-xr',
     label: 'Android XR 2D panel approximation',
@@ -339,7 +353,9 @@ function getScreenshotFileName(fileNameInput, selectedProfiles) {
 
 function parseArguments() {
   const args = process.argv.slice(2);
-  const options = {
+  const options = {
+    amazonAssets: false,
+    samsungAssets: false,
     dryRun: false,
     frameExisting: false,
     help: false,
@@ -351,7 +367,11 @@ function parseArguments() {
   for (let index = 0; index < args.length; index += 1) {
     const argument = args[index];
 
-    if (argument === '--dry-run') {
+    if (argument === '--amazon-assets') {
+      options.amazonAssets = true;
+    } else if (argument === '--samsung-assets') {
+      options.samsungAssets = true;
+    } else if (argument === '--dry-run') {
       options.dryRun = true;
     } else if (argument === '--frame-existing') {
       options.frameExisting = true;
@@ -395,12 +415,14 @@ function printHelp() {
   console.log('Capture the current live Android WebView at multiple responsive viewport sizes.');
   console.log('');
   console.log('Usage:');
-  console.log('  node take-responsive-screenshot.js');
-  console.log('  node take-responsive-screenshot.js --profiles iphone,ipad');
-  console.log('  node take-responsive-screenshot.js --prefix home --profiles android-phone,ipad');
-  console.log('  node take-responsive-screenshot.js --frame-existing');
-  console.log('  node take-responsive-screenshot.js --dry-run');
-  console.log('  node take-responsive-screenshot.js --list');
+  console.log('  node take-screen-image.js');
+  console.log('  node take-screen-image.js --profiles iphone,ipad');
+  console.log('  node take-screen-image.js --prefix home --profiles android-phone,ipad');
+  console.log('  node take-screen-image.js --frame-existing');
+  console.log('  node take-screen-image.js --amazon-assets');
+  console.log('  node take-screen-image.js --samsung-assets');
+  console.log('  node take-screen-image.js --dry-run');
+  console.log('  node take-screen-image.js --list');
 }
 
 function selectProfiles(input) {
@@ -876,7 +898,7 @@ function getFrameAdornment(frameType) {
   return '<div class="xr-status"></div>';
 }
 
-function createDeviceFrameHtml(profile, screenshotBuffer) {
+function createDeviceFrameHtml(profile, screenshotBuffer) {
   const screenshotDataUrl = `data:image/png;base64,${screenshotBuffer.toString('base64')}`;
   const aspectRatio = `${profile.width} / ${profile.height}`;
 
@@ -1114,9 +1136,397 @@ function createDeviceFrameHtml(profile, screenshotBuffer) {
     ${getFrameAdornment(profile.frameType)}
   </main>
 </body>
-</html>`;
-}
-
+</html>`;
+}
+
+function escapeHtml(value) {
+  return String(value)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function createAmazonAssetHtml(asset, appName, iconBuffer) {
+  const iconDataUrl = `data:image/png;base64,${iconBuffer.toString('base64')}`;
+  const safeAppName = escapeHtml(appName);
+  const logoMarkup = asset.type === 'featured-logo'
+    ? `<main class="featured-logo"><img src="${iconDataUrl}" /><div><small>POCKET RHYTHM STUDIO</small><strong>${safeAppName}</strong></div></main>`
+    : '';
+  const iconMarkup = asset.type === 'icon'
+    ? `<main class="icon-card"><img src="${iconDataUrl}" /><div><small>MAKE THE NEXT BEAT YOURS</small><strong>${safeAppName}</strong></div></main>`
+    : '';
+  const backgroundMarkup = asset.type.includes('background')
+    ? '<main class="background-art"><div class="pulse pulse-one"></div><div class="pulse pulse-two"></div><div class="equalizer"><i></i><i></i><i></i><i></i><i></i><i></i><i></i></div><div class="pad-grid"><i></i><i></i><i></i><i></i><i></i><i></i><i></i><i></i><i></i></div></main>'
+    : '';
+
+  return `<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <style>
+    * { box-sizing: border-box; }
+    html, body { width: 100%; height: 100%; margin: 0; overflow: hidden; }
+    body {
+      position: relative;
+      font-family: Arial, Helvetica, sans-serif;
+      color: #f8fbff;
+      background: transparent;
+    }
+    body.icon,
+    body.background-image,
+    body.featured-background {
+      background:
+        radial-gradient(circle at 16% 18%, rgba(52, 211, 235, 0.32), transparent 28%),
+        radial-gradient(circle at 82% 82%, rgba(201, 255, 65, 0.24), transparent 30%),
+        linear-gradient(135deg, #24113c 0%, #15152d 48%, #071725 100%);
+    }
+    body.icon::before,
+    body.background-image::before,
+    body.featured-background::before {
+      content: '';
+      position: absolute;
+      inset: 0;
+      opacity: 0.22;
+      background-image:
+        linear-gradient(rgba(255,255,255,0.07) 1px, transparent 1px),
+        linear-gradient(90deg, rgba(255,255,255,0.07) 1px, transparent 1px);
+      background-size: 72px 72px;
+    }
+    .icon-card {
+      position: relative;
+      z-index: 2;
+      width: 100%;
+      height: 100%;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      gap: 72px;
+      padding: 72px 110px;
+    }
+    .icon-card img {
+      width: 500px;
+      height: 500px;
+      object-fit: contain;
+      border-radius: 104px;
+      box-shadow: 0 38px 80px rgba(0,0,0,0.48), 0 0 70px rgba(52,211,235,0.2);
+    }
+    .icon-card div { display: flex; flex-direction: column; gap: 18px; }
+    .icon-card small,
+    .featured-logo small {
+      color: #35d4eb;
+      font-size: 24px;
+      font-weight: 700;
+      letter-spacing: 7px;
+    }
+    .icon-card strong { font-size: 86px; line-height: 0.96; max-width: 500px; }
+    .featured-logo {
+      width: 100%;
+      height: 100%;
+      display: flex;
+      align-items: center;
+      gap: 24px;
+      padding: 20px 26px;
+      color: #111827;
+    }
+    .featured-logo img {
+      width: 210px;
+      height: 210px;
+      object-fit: contain;
+      border-radius: 44px;
+    }
+    .featured-logo div { display: flex; min-width: 0; flex-direction: column; gap: 8px; }
+    .featured-logo small { font-size: 14px; letter-spacing: 3px; }
+    .featured-logo strong {
+      max-width: 360px;
+      overflow: hidden;
+      color: #ffffff;
+      font-size: 56px;
+      line-height: 1;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+      text-shadow: 0 3px 12px rgba(0,0,0,0.75);
+    }
+    .background-art { position: absolute; inset: 0; }
+    .pulse {
+      position: absolute;
+      border: 3px solid rgba(53,212,235,0.28);
+      border-radius: 50%;
+      box-shadow: 0 0 80px rgba(53,212,235,0.15);
+    }
+    .pulse-one { width: 520px; height: 520px; top: -180px; left: -110px; }
+    .pulse-two { width: 620px; height: 620px; right: -180px; bottom: -310px; border-color: rgba(201,255,65,0.22); }
+    .equalizer {
+      position: absolute;
+      left: 8%;
+      top: 50%;
+      display: flex;
+      align-items: center;
+      gap: 20px;
+      height: 44%;
+      transform: translateY(-50%);
+    }
+    .equalizer i { width: 18px; border-radius: 999px; background: #35d4eb; box-shadow: 0 0 25px rgba(53,212,235,0.5); }
+    .equalizer i:nth-child(1), .equalizer i:nth-child(7) { height: 28%; }
+    .equalizer i:nth-child(2), .equalizer i:nth-child(6) { height: 52%; background: #ff5964; }
+    .equalizer i:nth-child(3), .equalizer i:nth-child(5) { height: 76%; background: #ff9f43; }
+    .equalizer i:nth-child(4) { height: 100%; background: #c9ff41; }
+    .pad-grid {
+      position: absolute;
+      right: 7%;
+      top: 50%;
+      display: grid;
+      width: 46%;
+      height: 64%;
+      grid-template-columns: repeat(3, 1fr);
+      gap: 20px;
+      transform: translateY(-50%) perspective(900px) rotateY(-10deg) rotateX(5deg);
+    }
+    .pad-grid i {
+      border: 2px solid rgba(255,255,255,0.17);
+      border-top: 7px solid #35d4eb;
+      border-radius: 22px;
+      background: linear-gradient(145deg, rgba(42,55,75,0.96), rgba(11,18,29,0.96));
+      box-shadow: 0 20px 28px rgba(0,0,0,0.28);
+    }
+    .pad-grid i:nth-child(2), .pad-grid i:nth-child(6) { border-top-color: #ff9f43; }
+    .pad-grid i:nth-child(3), .pad-grid i:nth-child(7) { border-top-color: #c9ff41; }
+    .pad-grid i:nth-child(4), .pad-grid i:nth-child(8) { border-top-color: #ff5964; }
+    .pad-grid i:nth-child(5) { border-top-color: #ac7cff; }
+    body.featured-background .pad-grid { width: 49%; height: 72%; }
+    body.featured-background .equalizer { height: 52%; }
+  </style>
+</head>
+<body class="${asset.type}">
+  ${iconMarkup}
+  ${logoMarkup}
+  ${backgroundMarkup}
+</body>
+</html>`;
+}
+
+async function createAmazonAssets(client) {
+  if (!fs.existsSync(amazonIconPath)) {
+    throw new Error(`Amazon asset source icon was not found: ${amazonIconPath}`);
+  }
+
+  const config = JSON.parse(fs.readFileSync(capacitorConfigPath, 'utf8'));
+  const appName = config.appName || 'App';
+  const iconBuffer = fs.readFileSync(amazonIconPath);
+  const assets = [
+    { fileName: 'icon-1280x720.png', type: 'icon', width: 1280, height: 720 },
+    { fileName: 'background-image-1920x1080.png', type: 'background-image', width: 1920, height: 1080 },
+    { fileName: 'featured-content-logo-640x260.png', type: 'featured-logo', width: 640, height: 260, transparent: true },
+    { fileName: 'featured-content-background-1920x720.png', type: 'featured-background', width: 1920, height: 720 },
+  ];
+
+  fs.mkdirSync(amazonAssetsDirectory, { recursive: true });
+
+  for (const asset of assets) {
+    await client.send('Emulation.setDeviceMetricsOverride', {
+      width: asset.width,
+      height: asset.height,
+      deviceScaleFactor: 1,
+      mobile: false,
+      screenWidth: asset.width,
+      screenHeight: asset.height,
+      positionX: 0,
+      positionY: 0,
+    });
+
+    const frameTree = await client.send('Page.getFrameTree');
+    await client.send('Page.setDocumentContent', {
+      frameId: frameTree.frameTree.frame.id,
+      html: createAmazonAssetHtml(asset, appName, iconBuffer),
+    });
+    await client.send('Runtime.evaluate', {
+      expression: `Promise.all([...document.images].map((image) => image.complete
+        ? Promise.resolve()
+        : new Promise((resolve) => {
+          image.addEventListener('load', resolve, { once: true });
+          image.addEventListener('error', resolve, { once: true });
+        }))).then(() => new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve))))`,
+      awaitPromise: true,
+      returnByValue: true,
+    });
+
+    const screenshot = await client.send('Page.captureScreenshot', {
+      format: 'png',
+      fromSurface: true,
+      captureBeyondViewport: false,
+      omitBackground: Boolean(asset.transparent),
+    });
+    const outputPath = path.join(amazonAssetsDirectory, asset.fileName);
+    fs.writeFileSync(outputPath, Buffer.from(screenshot.data, 'base64'));
+    console.log(`Saved Amazon asset ${asset.width}x${asset.height}: ${outputPath}`);
+  }
+}
+
+function createSamsungAssetHtml(asset, appName, iconBuffer) {
+  const iconDataUrl = `data:image/png;base64,${iconBuffer.toString('base64')}`;
+  const safeAppName = escapeHtml(appName);
+  const pads = Array.from({ length: 9 }, (_, index) => (
+    `<button><i>0${index + 1}</i><span>${['OPEN', 'CLOSED', 'HIGH', 'CRASH', 'KICK', 'MID', 'RIDE', 'SNARE', 'FLOOR'][index]}</span></button>`
+  )).join('');
+  const content = asset.type === 'edge-screen'
+    ? `<main class="edge-panel"><header><img src="${iconDataUrl}" /><strong>${safeAppName}</strong></header><section>${pads}</section></main>`
+    : `<main class="single-panel"><header><img src="${iconDataUrl}" /><div><small>POCKET RHYTHM</small><strong>${safeAppName}</strong></div></header><div class="single-action"><span>+</span><strong>OPEN STUDIO</strong><small>Tap to start playing</small></div><div class="rhythm"><i></i><i></i><i></i><i></i><i></i></div></main>`;
+
+  return `<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <style>
+    * { box-sizing: border-box; }
+    html, body { width: 100%; height: 100%; margin: 0; overflow: hidden; }
+    body {
+      position: relative;
+      color: #f7fbff;
+      background:
+        radial-gradient(circle at 50% 8%, rgba(53,212,235,0.26), transparent 24%),
+        radial-gradient(circle at 50% 88%, rgba(201,255,65,0.16), transparent 25%),
+        linear-gradient(180deg, #231039, #111729 48%, #071522);
+      font-family: Arial, Helvetica, sans-serif;
+    }
+    body::before {
+      content: '';
+      position: absolute;
+      inset: 0;
+      opacity: 0.18;
+      background: repeating-linear-gradient(0deg, transparent 0 79px, rgba(255,255,255,0.08) 80px);
+    }
+    main { position: relative; z-index: 1; width: 100%; height: 100%; }
+    .edge-panel { display: flex; flex-direction: column; padding: 28px 12px; }
+    .edge-panel header { display: flex; flex-direction: column; align-items: center; gap: 12px; min-height: 230px; }
+    .edge-panel header img { width: 112px; height: 112px; border-radius: 25px; object-fit: contain; }
+    .edge-panel header strong { max-width: 136px; overflow: hidden; font-size: 18px; text-overflow: ellipsis; white-space: nowrap; }
+    .edge-panel section { display: grid; flex: 1; grid-template-rows: repeat(9, 1fr); gap: 13px; }
+    .edge-panel button {
+      display: flex;
+      width: 100%;
+      min-height: 0;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      gap: 8px;
+      color: #f7fbff;
+      border: 1px solid rgba(255,255,255,0.16);
+      border-top: 5px solid #35d4eb;
+      border-radius: 18px;
+      background: linear-gradient(145deg, rgba(41,55,76,0.98), rgba(10,17,29,0.98));
+      box-shadow: 0 10px 18px rgba(0,0,0,0.3);
+    }
+    .edge-panel button:nth-child(3n+2) { border-top-color: #ff9f43; }
+    .edge-panel button:nth-child(3n) { border-top-color: #c9ff41; }
+    .edge-panel button i { color: #35d4eb; font-size: 14px; font-style: normal; font-weight: 700; }
+    .edge-panel button span { font-size: 12px; font-weight: 700; letter-spacing: 1px; }
+    .single-panel { display: flex; flex-direction: column; align-items: center; padding: 100px 44px; }
+    .single-panel header { display: flex; width: 100%; align-items: center; gap: 24px; }
+    .single-panel header img { width: 160px; height: 160px; border-radius: 36px; object-fit: contain; }
+    .single-panel header div { display: flex; min-width: 0; flex-direction: column; gap: 9px; }
+    .single-panel header small { color: #35d4eb; font-size: 17px; font-weight: 700; letter-spacing: 3px; }
+    .single-panel header strong { overflow: hidden; font-size: 48px; text-overflow: ellipsis; white-space: nowrap; }
+    .single-action {
+      display: flex;
+      width: 100%;
+      height: 880px;
+      margin-top: 380px;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      border: 3px solid rgba(53,212,235,0.5);
+      border-radius: 90px;
+      background: linear-gradient(145deg, rgba(39,53,75,0.96), rgba(8,16,28,0.98));
+      box-shadow: 0 50px 90px rgba(0,0,0,0.42), 0 0 75px rgba(53,212,235,0.16);
+    }
+    .single-action span {
+      display: grid;
+      width: 260px;
+      height: 260px;
+      place-items: center;
+      color: #0d1721;
+      border-radius: 50%;
+      background: linear-gradient(145deg, #35d4eb, #c9ff41);
+      box-shadow: 0 25px 55px rgba(53,212,235,0.3);
+      font-size: 170px;
+      font-weight: 200;
+      line-height: 1;
+    }
+    .single-action strong { margin-top: 65px; font-size: 42px; letter-spacing: 5px; }
+    .single-action small { margin-top: 18px; color: #a9b7c9; font-size: 24px; }
+    .rhythm { display: flex; align-items: center; gap: 18px; height: 300px; margin-top: auto; }
+    .rhythm i { width: 14px; height: 70px; border-radius: 999px; background: #35d4eb; }
+    .rhythm i:nth-child(2), .rhythm i:nth-child(4) { height: 140px; background: #ff5964; }
+    .rhythm i:nth-child(3) { height: 210px; background: #c9ff41; }
+  </style>
+</head>
+<body>${content}</body>
+</html>`;
+}
+
+async function createSamsungAssets(client) {
+  if (!fs.existsSync(amazonIconPath)) {
+    throw new Error(`Samsung asset source icon was not found: ${amazonIconPath}`);
+  }
+
+  const config = JSON.parse(fs.readFileSync(capacitorConfigPath, 'utf8'));
+  const appName = config.appName || 'App';
+  const iconBuffer = fs.readFileSync(amazonIconPath);
+  const assets = [
+    { fileName: 'edge-screen-160x2560.png', type: 'edge-screen', width: 160, height: 2560 },
+    { fileName: 'edge-screen-single-plus-550x2560.png', type: 'edge-screen-single-plus', width: 550, height: 2560 },
+  ];
+  const maximumFileSize = 1024 * 1024;
+
+  fs.mkdirSync(samsungAssetsDirectory, { recursive: true });
+
+  for (const asset of assets) {
+    await client.send('Emulation.setDeviceMetricsOverride', {
+      width: asset.width,
+      height: asset.height,
+      deviceScaleFactor: 1,
+      mobile: false,
+      screenWidth: asset.width,
+      screenHeight: asset.height,
+      positionX: 0,
+      positionY: 0,
+    });
+    const frameTree = await client.send('Page.getFrameTree');
+    await client.send('Page.setDocumentContent', {
+      frameId: frameTree.frameTree.frame.id,
+      html: createSamsungAssetHtml(asset, appName, iconBuffer),
+    });
+    await client.send('Runtime.evaluate', {
+      expression: `Promise.all([...document.images].map((image) => image.complete
+        ? Promise.resolve()
+        : new Promise((resolve) => image.addEventListener('load', resolve, { once: true }))))
+        .then(() => new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve))))`,
+      awaitPromise: true,
+      returnByValue: true,
+    });
+    const screenshot = await client.send('Page.captureScreenshot', {
+      format: 'png',
+      fromSurface: true,
+      captureBeyondViewport: false,
+    });
+    const outputPath = path.join(samsungAssetsDirectory, asset.fileName);
+    const outputBuffer = Buffer.from(screenshot.data, 'base64');
+
+    if (outputBuffer.length >= maximumFileSize) {
+      throw new Error(
+        `Samsung asset exceeds 1024 KB (${Math.ceil(outputBuffer.length / 1024)} KB): ${asset.fileName}`,
+      );
+    }
+
+    fs.writeFileSync(outputPath, outputBuffer);
+    console.log(
+      `Saved Samsung asset ${asset.width}x${asset.height} `
+      + `(${Math.ceil(outputBuffer.length / 1024)} KB): ${outputPath}`,
+    );
+  }
+}
+
 async function captureFramedScreenshot(
   client,
   screenshotBuffer,
@@ -1332,8 +1742,13 @@ async function runInteractiveCaptureLoop(
   console.log('\nResponsive screenshot tool closed.');
 }
 
-async function getInteractiveOptions(options) {
-  if (!process.stdin.isTTY || options.dryRun) {
+async function getInteractiveOptions(options) {
+  if (
+    !process.stdin.isTTY
+    || options.dryRun
+    || options.amazonAssets
+    || options.samsungAssets
+  ) {
     return options;
   }
 
@@ -1370,9 +1785,43 @@ async function main() {
     return;
   }
 
-  options = await getInteractiveOptions(options);
-
-  const selectedProfiles = selectProfiles(options.profiles);
+  options = await getInteractiveOptions(options);
+
+  if (options.amazonAssets) {
+    let amazonBrowser;
+    let amazonClient;
+
+    try {
+      amazonBrowser = await launchReplayBrowser();
+      amazonClient = await createReplayPage(amazonBrowser);
+      await createAmazonAssets(amazonClient);
+    } finally {
+      if (amazonClient) amazonClient.close();
+      if (amazonBrowser) await closeReplayBrowser(amazonBrowser);
+    }
+
+    console.log(`Amazon asset creation completed: ${amazonAssetsDirectory}`);
+    return;
+  }
+
+  if (options.samsungAssets) {
+    let samsungBrowser;
+    let samsungClient;
+
+    try {
+      samsungBrowser = await launchReplayBrowser();
+      samsungClient = await createReplayPage(samsungBrowser);
+      await createSamsungAssets(samsungClient);
+    } finally {
+      if (samsungClient) samsungClient.close();
+      if (samsungBrowser) await closeReplayBrowser(samsungBrowser);
+    }
+
+    console.log(`Samsung asset creation completed: ${samsungAssetsDirectory}`);
+    return;
+  }
+
+  const selectedProfiles = selectProfiles(options.profiles);
 
   if (options.frameExisting) {
     await frameExistingScreenshots(selectedProfiles);

package/files/take-screen-video.js

@@ -0,0 +1,604 @@
+//node take-screen-video.js
+
+//--audio without //with,without
+//--duration 0 //30,120 (0 is used "Enter" key to stop)
+//--countdown 0//0,5,10
+//--name test-name
+//--profiles youtube,non-spatial-xr,samsung,amazon
+
+
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawn, spawnSync } = require('node:child_process');
+
+const scriptDirectory = __dirname;
+const projectDirectory = scriptDirectory;
+const temporaryDirectory = path.join(projectDirectory, 'agent-temp', 'store-video');
+const outputDirectory = path.join(projectDirectory, 'Auto-Screenshot', 'Video', 'Output');
+const deviceRecordingPath = '/sdcard/codeplay_store_video.mp4';
+const ffmpegFallbackDirectory = 'W:\\Tools\\ffmpeg\\bin';
+const scrcpyFallbackPath = 'W:\\Tools\\scrcpy\\scrcpy.exe';
+const capacitorConfigPath = path.join(projectDirectory, 'capacitor.config.json');
+
+const videoProfiles = {
+  youtube: {
+    label: 'YouTube preview',
+    directory: 'YouTube',
+    fileSuffix: 'youtube',
+    width: 1920,
+    height: 1080,
+    videoBitrate: '8M',
+    h264Level: '4.2',
+  },
+  'non-spatial-xr': {
+    label: 'Google Play non-spatial XR',
+    directory: 'Google-Play-XR-Non-Spatial',
+    fileSuffix: 'non-spatial-xr',
+    width: 3840,
+    height: 2160,
+    videoBitrate: '12M',
+    h264Level: '5.1',
+  },
+  samsung: {
+    label: 'Samsung Galaxy Store YouTube preview',
+    directory: 'Samsung',
+    fileSuffix: 'samsung',
+    width: 1920,
+    height: 1080,
+    videoBitrate: '8M',
+    h264Level: '4.2',
+  },
+  amazon: {
+    label: 'Amazon Appstore',
+    directory: 'Amazon',
+    fileSuffix: 'amazon',
+    width: 1920,
+    height: 1080,
+    videoBitrate: '4M',
+    h264Level: '4.2',
+  },
+};
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    encoding: 'utf8',
+    windowsHide: true,
+    stdio: options.inherit ? 'inherit' : 'pipe',
+    ...options,
+  });
+
+  if (result.error) {
+    if (result.error.code === 'ENOENT') {
+      throw new Error(`${command} was not found in PATH.`);
+    }
+
+    throw result.error;
+  }
+
+  if (result.status !== 0) {
+    throw new Error(
+      String(result.stderr || result.stdout || `${command} exited with code ${result.status}.`).trim(),
+    );
+  }
+
+  return String(result.stdout || '').trim();
+}
+
+function commandExists(command) {
+  const result = spawnSync(command, ['-version'], {
+    encoding: 'utf8',
+    windowsHide: true,
+  });
+  return !result.error && result.status === 0;
+}
+
+function getExecutable(command) {
+  if (commandExists(command)) {
+    return command;
+  }
+
+  const fallbackPath = path.join(ffmpegFallbackDirectory, `${command}.exe`);
+  if (fs.existsSync(fallbackPath)) {
+    return fallbackPath;
+  }
+
+  return '';
+}
+
+function wait(milliseconds) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+}
+
+function runAsync(command, args, options = {}) {
+  const child = spawn(command, args, {
+    windowsHide: true,
+    stdio: 'inherit',
+    ...options,
+  });
+
+  return {
+    child,
+    completion: new Promise((resolve, reject) => {
+      child.once('error', reject);
+      child.once('exit', (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`${command} exited with code ${code}.`));
+      });
+    }),
+  };
+}
+
+function getConnectedDevice() {
+  const devices = run('adb', ['devices'])
+    .split(/\r?\n/)
+    .map((line) => line.match(/^(\S+)\s+device$/))
+    .filter(Boolean)
+    .map((match) => match[1]);
+
+  if (!devices.length) {
+    throw new Error('no_connected_device');
+  }
+
+  return devices[0];
+}
+
+function sanitizeName(value) {
+  const name = String(value || '')
+    .trim()
+    .replace(/\.mp4$/i, '')
+    .replace(/[<>:"/\\|?*\u0000-\u001F]/g, '_')
+    .replace(/[. ]+$/g, '');
+  return name || 'store-video';
+}
+
+function getCapacitorConfig() {
+  return JSON.parse(fs.readFileSync(capacitorConfigPath, 'utf8'));
+}
+
+function getDefaultVideoName() {
+  return sanitizeName(getCapacitorConfig().appName || 'store-video');
+}
+
+function parseArguments() {
+  const args = process.argv.slice(2);
+  const options = {
+    audio: 'without',
+    countdown: 5,
+    duration: 0,
+    help: false,
+    input: '',
+    list: false,
+    name: '',
+    profiles: 'youtube,non-spatial-xr,samsung,amazon',
+    spatialInput: '',
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+
+    if (argument === '--audio') {
+      options.audio = String(args[index + 1] || '').toLowerCase();
+      index += 1;
+    } else if (argument === '--countdown') {
+      options.countdown = Number(args[index + 1]);
+      index += 1;
+    } else if (argument === '--duration') {
+      options.duration = Number(args[index + 1]);
+      index += 1;
+    } else if (argument === '--input') {
+      options.input = args[index + 1] || '';
+      index += 1;
+    } else if (argument === '--name') {
+      options.name = args[index + 1] || '';
+      index += 1;
+    } else if (argument === '--profiles') {
+      options.profiles = args[index + 1] || '';
+      index += 1;
+    } else if (argument === '--spatial-input') {
+      options.spatialInput = args[index + 1] || '';
+      index += 1;
+    } else if (argument === '--list') {
+      options.list = true;
+    } else if (argument === '--help' || argument === '-h') {
+      options.help = true;
+    } else {
+      throw new Error(`Unknown argument: ${argument}`);
+    }
+  }
+
+  if (!Number.isInteger(options.duration) || options.duration < 0 || options.duration > 180) {
+    throw new Error('--duration must be 0 (unlimited) or a whole number from 1 to 180 seconds.');
+  }
+
+  if (!Number.isInteger(options.countdown) || options.countdown < 0 || options.countdown > 30) {
+    throw new Error('--countdown must be a whole number from 0 to 30 seconds.');
+  }
+
+  if (!['with', 'without'].includes(options.audio)) {
+    throw new Error('--audio must be with or without.');
+  }
+
+  options.name = options.name
+    ? sanitizeName(options.name)
+    : getDefaultVideoName();
+  return options;
+}
+
+function selectProfiles(input) {
+  const names = String(input)
+    .split(',')
+    .map((name) => name.trim().toLowerCase())
+    .filter(Boolean);
+
+  if (names.includes('all')) {
+    return Object.keys(videoProfiles);
+  }
+
+  for (const name of names) {
+    if (!videoProfiles[name] && name !== 'spatial-xr') {
+      throw new Error(`Unknown profile: ${name}. Run with --list to see valid profiles.`);
+    }
+  }
+
+  return [...new Set(names)];
+}
+
+function printProfiles() {
+  for (const [name, profile] of Object.entries(videoProfiles)) {
+    console.log(
+      `${name.padEnd(16)} ${profile.label} (${profile.width}x${profile.height}, H.264 MP4)`,
+    );
+  }
+
+  console.log('spatial-xr       Genuine 360/180/3D source passthrough (requires --spatial-input)');
+}
+
+function printHelp() {
+  console.log('Record the connected Android device and create store-ready video variants.');
+  console.log('');
+  console.log('Usage:');
+  console.log('  node take-screen-video.js --name gameplay --duration 30');
+  console.log('  node take-screen-video.js --audio with');
+  console.log('  node take-screen-video.js --input recording.mp4 --profiles youtube,amazon');
+  console.log('  node take-screen-video.js --profiles spatial-xr --spatial-input genuine-360.mp4');
+  console.log('  node take-screen-video.js --profiles all');
+  console.log('  node take-screen-video.js --list');
+  console.log('');
+  console.log('Defaults: --audio without --duration 0 (unlimited)');
+  console.log(`Default name: ${getDefaultVideoName()} (capacitor.config.json appName)`);
+  console.log('Manual mode: press Enter to stop; a positive --duration sets a safety maximum.');
+  console.log('Audio recording uses scrcpy and requires Android 11 or newer.');
+}
+
+function waitForManualStop(recordingCompletion, duration) {
+  if (!process.stdin.isTTY) {
+    throw new Error('Manual interaction requires an interactive terminal so Enter can stop recording.');
+  }
+
+  return new Promise((resolve, reject) => {
+    const finish = (reason) => {
+      if (timeout) clearTimeout(timeout);
+      process.stdin.removeListener('data', onInput);
+      process.stdin.pause();
+      resolve(reason);
+    };
+    const onInput = (input) => {
+      if (/\r|\n/.test(String(input))) finish('enter');
+    };
+    const timeout = duration > 0
+      ? setTimeout(() => finish('maximum-duration'), duration * 1000)
+      : null;
+
+    process.stdin.resume();
+    process.stdin.on('data', onInput);
+    recordingCompletion.then(
+      () => finish('recorder-completed'),
+      (error) => {
+        if (timeout) clearTimeout(timeout);
+        process.stdin.removeListener('data', onInput);
+        process.stdin.pause();
+        reject(error);
+      },
+    );
+  });
+}
+
+function getScrcpyCommand() {
+  if (commandExists('scrcpy')) return 'scrcpy';
+  return fs.existsSync(scrcpyFallbackPath) ? scrcpyFallbackPath : '';
+}
+
+async function recordConnectedDevice(options, destinationPath) {
+  const { audio, countdown, duration } = options;
+  const deviceId = getConnectedDevice();
+  fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+  if (fs.existsSync(destinationPath)) {
+    fs.unlinkSync(destinationPath);
+  }
+
+  console.log(`Connected device: ${deviceId}`);
+  console.log(`Interaction: manual; audio: ${audio}.`);
+  console.log('Open the required first app screen, then operate the physical device while recording.');
+
+  for (let seconds = countdown; seconds > 0; seconds -= 1) {
+    console.log(`Recording starts in ${seconds}...`);
+    wait(1000);
+  }
+
+  console.log(
+    duration > 0
+      ? `RECORDING NOW — maximum ${duration} seconds.`
+      : 'RECORDING NOW — unlimited duration; press Enter to stop.',
+  );
+
+  let recording;
+  if (audio === 'with') {
+    const scrcpyCommand = getScrcpyCommand();
+    if (!scrcpyCommand) {
+      throw new Error(
+        'Audio recording requires scrcpy. Install it at W:\\Tools\\scrcpy or add it to PATH.',
+      );
+    }
+
+    const scrcpyArguments = [
+      '--serial', deviceId,
+      '--no-window',
+      '--no-playback',
+      '--no-control',
+      '--require-audio',
+      '--record', destinationPath,
+    ];
+    if (duration > 0) {
+      scrcpyArguments.push('--time-limit', String(duration));
+    }
+    recording = runAsync(scrcpyCommand, scrcpyArguments);
+  } else {
+    recording = runAsync('adb', [
+      '-s', deviceId,
+      'shell', 'screenrecord',
+      '--bit-rate', '12000000',
+      '--time-limit', String(duration),
+      deviceRecordingPath,
+    ]);
+  }
+
+  let manualStopRequested = false;
+  console.log('MANUAL RECORDING — use the device, then press Enter here to stop and convert.');
+  const stopReason = await waitForManualStop(recording.completion, duration);
+
+  if (stopReason === 'enter') {
+    manualStopRequested = true;
+    console.log('Enter pressed — stopping and finalizing the recording...');
+    if (audio === 'with') {
+      run('adb', [
+        '-s', deviceId,
+        'shell', 'pkill', '-TERM', '-f', 'com.genymobile.scrcpy.Server',
+      ]);
+    } else {
+      run('adb', ['-s', deviceId, 'shell', 'pkill', '-INT', 'screenrecord']);
+    }
+  } else if (stopReason === 'maximum-duration') {
+    console.log(`Safety maximum reached after ${duration} seconds.`);
+  }
+
+  try {
+    await recording.completion;
+  } catch (error) {
+    if (!manualStopRequested) throw error;
+  }
+
+  if (audio === 'without') {
+    try {
+      run('adb', ['-s', deviceId, 'pull', deviceRecordingPath, destinationPath], { inherit: true });
+    } finally {
+      try {
+        run('adb', ['-s', deviceId, 'shell', 'rm', deviceRecordingPath]);
+      } catch {
+        // The device may have disconnected after recording.
+      }
+    }
+  }
+
+  console.log('RECORDING FINISHED — converting the captured video.');
+  console.log(`Recorded connected device ${deviceId}: ${destinationPath}`);
+}
+
+function getUniqueOutputPath(profile, name) {
+  const profileDirectory = path.join(outputDirectory, profile.directory);
+  fs.mkdirSync(profileDirectory, { recursive: true });
+
+  let outputPath = path.join(profileDirectory, `${name}-${profile.fileSuffix}.mp4`);
+  let duplicateNumber = 2;
+
+  while (fs.existsSync(outputPath)) {
+    outputPath = path.join(
+      profileDirectory,
+      `${name}-${profile.fileSuffix}-${duplicateNumber}.mp4`,
+    );
+    duplicateNumber += 1;
+  }
+
+  return outputPath;
+}
+
+function getVideoDetails(ffprobeCommand, videoPath) {
+  const output = run(ffprobeCommand, [
+    '-v', 'error',
+    '-show_entries', 'stream=width,height,codec_name,codec_type,bit_rate',
+    '-show_entries', 'format=duration,size,bit_rate',
+    '-of', 'json',
+    videoPath,
+  ]);
+  return JSON.parse(output);
+}
+
+function validateVideo(ffprobeCommand, videoPath, profile) {
+  const details = getVideoDetails(ffprobeCommand, videoPath);
+  const stream = details.streams?.find((candidate) => candidate.codec_type === 'video') || {};
+  const format = details.format || {};
+  const bitRate = Number(stream.bit_rate || format.bit_rate || 0);
+
+  if (stream.codec_name !== 'h264') {
+    throw new Error(`Validation failed for ${videoPath}: expected H.264 video.`);
+  }
+
+  if (Number(stream.width) !== profile.width || Number(stream.height) !== profile.height) {
+    throw new Error(
+      `Validation failed for ${videoPath}: expected ${profile.width}x${profile.height}.`,
+    );
+  }
+
+  if (profile === videoProfiles.amazon && bitRate < 1200000) {
+    throw new Error(`Amazon video bitrate is below 1200 kbps: ${Math.round(bitRate / 1000)} kbps.`);
+  }
+
+  console.log(
+    `Validated ${profile.label}: ${stream.width}x${stream.height}, H.264, `
+    + `${(Number(format.duration) || 0).toFixed(1)}s, ${Math.round(bitRate / 1000)} kbps.`,
+  );
+}
+
+function createVideoVariant(
+  ffmpegCommand,
+  ffprobeCommand,
+  inputPath,
+  profile,
+  name,
+  requireAudio,
+) {
+  const destinationPath = getUniqueOutputPath(profile, name);
+  const videoFilter = [
+    'setparams=colorspace=bt709:color_primaries=bt709:color_trc=bt709:range=tv',
+    `scale=${profile.width}:${profile.height}:force_original_aspect_ratio=decrease`,
+    `pad=${profile.width}:${profile.height}:(ow-iw)/2:(oh-ih)/2:color=black`,
+    'setsar=1',
+  ].join(',');
+
+  run(ffmpegCommand, [
+    '-hide_banner',
+    '-y',
+    '-i', inputPath,
+    '-map', '0:v:0',
+    '-map', '0:a?',
+    '-vf', videoFilter,
+    '-c:v', 'libx264',
+    '-preset', 'medium',
+    '-profile:v', 'high',
+    '-level', profile.h264Level,
+    '-pix_fmt', 'yuv420p',
+    '-b:v', profile.videoBitrate,
+    '-minrate', profile.videoBitrate,
+    '-maxrate', profile.videoBitrate,
+    '-bufsize', profile.videoBitrate,
+    '-x264-params', 'nal-hrd=cbr:force-cfr=1',
+    '-r', '30',
+    '-c:a', 'aac',
+    '-b:a', '192k',
+    '-movflags', '+faststart',
+    destinationPath,
+  ], { inherit: true });
+
+  console.log(`Created ${profile.label}: ${destinationPath}`);
+  validateVideo(ffprobeCommand, destinationPath, profile);
+
+  if (requireAudio) {
+    const details = getVideoDetails(ffprobeCommand, destinationPath);
+    const audioStream = details.streams?.find((stream) => stream.codec_type === 'audio');
+    if (!audioStream) {
+      throw new Error(`Validation failed for ${destinationPath}: audio track is missing.`);
+    }
+    console.log(`Validated audio: ${audioStream.codec_name} track included.`);
+  }
+}
+
+function copySpatialSource(spatialInput, name) {
+  if (!spatialInput) {
+    throw new Error(
+      'Spatial XR requires --spatial-input with a genuine 360-degree, 180-degree, or 3D video.',
+    );
+  }
+
+  const sourcePath = path.resolve(spatialInput);
+  if (!fs.existsSync(sourcePath) || !fs.statSync(sourcePath).isFile()) {
+    throw new Error(`Spatial XR source was not found: ${sourcePath}`);
+  }
+
+  const spatialDirectory = path.join(outputDirectory, 'Google-Play-XR-Spatial');
+  fs.mkdirSync(spatialDirectory, { recursive: true });
+  const extension = path.extname(sourcePath) || '.mp4';
+  let destinationPath = path.join(spatialDirectory, `${name}-spatial-xr${extension}`);
+  let duplicateNumber = 2;
+
+  while (fs.existsSync(destinationPath)) {
+    destinationPath = path.join(
+      spatialDirectory,
+      `${name}-spatial-xr-${duplicateNumber}${extension}`,
+    );
+    duplicateNumber += 1;
+  }
+
+  fs.copyFileSync(sourcePath, destinationPath, fs.constants.COPYFILE_EXCL);
+  console.log(`Copied genuine Spatial XR source without stripping its metadata: ${destinationPath}`);
+}
+
+async function main() {
+  const options = parseArguments();
+
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
+  if (options.list) {
+    printProfiles();
+    return;
+  }
+
+  const selectedProfiles = selectProfiles(options.profiles);
+  const flatProfiles = selectedProfiles.filter((name) => name !== 'spatial-xr');
+
+  if (selectedProfiles.includes('spatial-xr')) {
+    copySpatialSource(options.spatialInput, options.name);
+  }
+
+  if (!flatProfiles.length) {
+    return;
+  }
+
+  const ffmpegCommand = getExecutable('ffmpeg');
+  const ffprobeCommand = getExecutable('ffprobe');
+
+  if (!ffmpegCommand || !ffprobeCommand) {
+    throw new Error(
+      'FFmpeg was not found in PATH. Install FFmpeg, reopen the terminal, and run this script again.',
+    );
+  }
+
+  let inputPath;
+  if (options.input) {
+    inputPath = path.resolve(options.input);
+    if (!fs.existsSync(inputPath) || !fs.statSync(inputPath).isFile()) {
+      throw new Error(`Input video was not found: ${inputPath}`);
+    }
+  } else {
+    inputPath = path.join(temporaryDirectory, `${options.name}-adb-source.mp4`);
+    await recordConnectedDevice(options, inputPath);
+  }
+
+  for (const profileName of flatProfiles) {
+    createVideoVariant(
+      ffmpegCommand,
+      ffprobeCommand,
+      inputPath,
+      videoProfiles[profileName],
+      options.name,
+      options.audio === 'with',
+    );
+  }
+}
+
+main().catch((error) => {
+  console.error(`Store video creation failed: ${error.message}`);
+  process.exitCode = 1;
+});

package/package.json

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

package/files/take-screenshot.js

@@ -1,110 +0,0 @@
-const fs = require('node:fs');
-const path = require('node:path');
-const readline = require('node:readline');
-const { spawnSync } = require('node:child_process');
-
-const screenshotDirectory = path.join(__dirname, 'Auto-Screenshot');
-
-function getNextNumberedPath() {
-  const highestNumber = fs.readdirSync(screenshotDirectory, { withFileTypes: true })
-    .filter((entry) => entry.isFile())
-    .reduce((highest, entry) => {
-      const match = entry.name.match(/^(\d+)\.png$/i);
-      return match ? Math.max(highest, Number(match[1])) : highest;
-    }, 0);
-
-  return path.join(screenshotDirectory, `${highestNumber + 1}.png`);
-}
-
-function getCustomPath(input) {
-  let fileName = input.trim().replace(/\.png$/i, '');
-  fileName = fileName
-    .replace(/[<>:"/\\|?*\u0000-\u001F]/g, '_')
-    .replace(/[. ]+$/g, '');
-
-  if (!fileName) {
-    return getNextNumberedPath();
-  }
-
-  if (/^(con|prn|aux|nul|com[1-9]|lpt[1-9])$/i.test(fileName)) {
-    fileName = `${fileName}_`;
-  }
-
-  let screenshotPath = path.join(screenshotDirectory, `${fileName}.png`);
-  let duplicateNumber = 2;
-
-  while (fs.existsSync(screenshotPath)) {
-    screenshotPath = path.join(
-      screenshotDirectory,
-      `${fileName}-${duplicateNumber}.png`,
-    );
-    duplicateNumber += 1;
-  }
-
-  return screenshotPath;
-}
-
-function takeScreenshot(fileNameInput) {
-  const result = spawnSync('adb', ['exec-out', 'screencap', '-p'], {
-    encoding: null,
-    maxBuffer: 100 * 1024 * 1024,
-    timeout: 30000,
-    windowsHide: true,
-  });
-
-  if (result.error) {
-    if (result.error.code === 'ENOENT') {
-      throw new Error('ADB was not found. Add Android platform-tools to your PATH.');
-    }
-
-    if (result.error.code === 'ETIMEDOUT') {
-      throw new Error('ADB did not respond within 30 seconds. Check the device connection.');
-    }
-
-    throw result.error;
-  }
-
-  if (result.status !== 0) {
-    const adbMessage = result.stderr.toString().trim();
-    throw new Error(adbMessage || `ADB exited with code ${result.status}.`);
-  }
-
-  if (!result.stdout.length) {
-    throw new Error('ADB returned an empty screenshot. Check the connected device.');
-  }
-
-  const screenshotPath = fileNameInput.trim()
-    ? getCustomPath(fileNameInput)
-    : getNextNumberedPath();
-
-  fs.writeFileSync(screenshotPath, result.stdout, { flag: 'wx' });
-  return screenshotPath;
-}
-
-fs.mkdirSync(screenshotDirectory, { recursive: true });
-
-const terminal = readline.createInterface({
-  input: process.stdin,
-  output: process.stdout,
-  prompt: 'Enter a filename, or press Enter for the next number: ',
-});
-
-console.log(`Screenshots will be saved in: ${screenshotDirectory}`);
-console.log('Press Ctrl+C to exit.');
-terminal.prompt();
-
-terminal.on('line', (fileNameInput) => {
-  try {
-    const screenshotPath = takeScreenshot(fileNameInput);
-    console.log(`Screenshot saved: ${screenshotPath}`);
-  } catch (error) {
-    console.error(`Screenshot failed: ${error.message}`);
-  }
-
-  terminal.prompt();
-});
-
-terminal.on('SIGINT', () => {
-  console.log('\nScreenshot tool closed.');
-  terminal.close();
-});