@skrillex1224/android-toolkit 0.1.2 → 0.1.8

package/src/internals/compression.js

@@ -0,0 +1,188 @@
+import {Jimp, JimpMime, ResizeStrategy} from 'jimp';
+
+import {Logger} from '../logger.js';
+
+const DEFAULT_SCREENSHOT_MAX_BYTES = 5 * 1024 * 1024;
+const DEFAULT_SCREENSHOT_OUTPUT_TYPE = 'jpeg';
+const DEFAULT_SCREENSHOT_QUALITY = 0.72;
+const DEFAULT_SCREENSHOT_MIN_QUALITY = 0.38;
+const DEFAULT_SCREENSHOT_MIN_SCALE = 0.25;
+const SUPPORTED_SCREENSHOT_OUTPUT_TYPES = new Set(['jpeg']);
+
+const toPositiveInteger = (value, fallback = 0) => {
+    const number = Math.floor(Number(value) || 0);
+    return number > 0 ? number : fallback;
+};
+
+const normalizeQuality = (value, fallback) => {
+    const number = Number(value);
+    if (!Number.isFinite(number) || number <= 0) return fallback;
+    const normalized = number > 1 ? number / 100 : number;
+    return Math.min(1, Math.max(0.01, normalized));
+};
+
+const normalizeScale = (value, fallback) => {
+    const number = Number(value);
+    if (!Number.isFinite(number) || number <= 0) return fallback;
+    return Math.min(1, Math.max(0.05, number));
+};
+
+const normalizeScreenshotOutputType = (value) => {
+    const raw = String(value || DEFAULT_SCREENSHOT_OUTPUT_TYPE).trim().toLowerCase();
+    const normalized = raw === 'jpg' ? 'jpeg' : raw;
+    return SUPPORTED_SCREENSHOT_OUTPUT_TYPES.has(normalized)
+        ? normalized
+        : DEFAULT_SCREENSHOT_OUTPUT_TYPE;
+};
+
+const getBase64BytesFromBuffer = (buffer) => Math.ceil(buffer.length / 3) * 4;
+
+const toJpegQuality = (value) => Math.round(normalizeQuality(value, DEFAULT_SCREENSHOT_QUALITY) * 100);
+
+export const resolveImageCompression = (options = {}) => {
+    const explicit = options.compression;
+    const source = explicit && typeof explicit === 'object' && !Array.isArray(explicit)
+        ? explicit
+        : {};
+
+    const enabled = explicit !== false
+        && source.enabled !== false
+        && options.compress !== false;
+
+    const quality = normalizeQuality(
+        source.quality ?? options.quality,
+        DEFAULT_SCREENSHOT_QUALITY
+    );
+    const minQuality = Math.min(
+        quality,
+        normalizeQuality(source.minQuality ?? options.minQuality, DEFAULT_SCREENSHOT_MIN_QUALITY)
+    );
+
+    return {
+        enabled,
+        maxBytes: toPositiveInteger(
+            source.maxBytes
+                ?? source.maxBase64Bytes
+                ?? options.maxBytes
+                ?? options.maxBase64Bytes,
+            DEFAULT_SCREENSHOT_MAX_BYTES
+        ),
+        outputType: normalizeScreenshotOutputType(
+            source.type
+                ?? source.outputType
+                ?? options.type
+                ?? options.outputType
+        ),
+        quality,
+        minQuality,
+        minScale: normalizeScale(
+            source.minScale ?? options.minScale,
+            DEFAULT_SCREENSHOT_MIN_SCALE
+        ),
+    };
+};
+
+const encodeJpeg = async (sourceImage, compression, scale, quality) => {
+    const width = Math.max(1, Math.round(sourceImage.bitmap.width * scale));
+    const height = Math.max(1, Math.round(sourceImage.bitmap.height * scale));
+    const image = sourceImage.clone();
+
+    if (scale < 0.999) {
+        image.resize({
+            w: width,
+            h: height,
+            mode: ResizeStrategy.BILINEAR,
+        });
+    }
+
+    const buffer = await image.getBuffer(JimpMime.jpeg, {quality});
+    return {
+        buffer,
+        bytes: getBase64BytesFromBuffer(buffer),
+        width,
+        height,
+        quality,
+        scale: Number(scale.toFixed(3)),
+        format: compression.outputType,
+    };
+};
+
+const compressImageBuffer = async (buffer, compression) => {
+    const sourceImage = await Jimp.read(buffer);
+    const maxQuality = toJpegQuality(compression.quality);
+    const minQuality = Math.min(maxQuality, toJpegQuality(compression.minQuality));
+    let quality = maxQuality;
+    let scale = 1;
+    let smallest = null;
+
+    for (let attempt = 0; attempt < 12; attempt += 1) {
+        const candidate = await encodeJpeg(sourceImage, compression, scale, quality);
+        if (!smallest || candidate.bytes < smallest.bytes) {
+            smallest = candidate;
+        }
+        if (candidate.bytes <= compression.maxBytes) {
+            return {...candidate, withinLimit: true};
+        }
+
+        if (quality > minQuality) {
+            quality = Math.max(minQuality, Math.floor(quality * 0.75));
+            continue;
+        }
+
+        const ratio = Math.sqrt(compression.maxBytes / Math.max(1, candidate.bytes));
+        const nextScale = Math.max(
+            compression.minScale,
+            Math.min(scale * 0.85, scale * ratio * 0.94)
+        );
+
+        if (nextScale >= scale * 0.99 || scale <= compression.minScale) {
+            break;
+        }
+
+        scale = nextScale;
+    }
+
+    const finalCandidate = await encodeJpeg(sourceImage, compression, compression.minScale, minQuality);
+    const fallback = !smallest || finalCandidate.bytes < smallest.bytes
+        ? finalCandidate
+        : smallest;
+    return {...fallback, withinLimit: fallback.bytes <= compression.maxBytes};
+};
+
+export const compressImageBufferToBase64 = async (buffer, compression) => {
+    const originalBytes = getBase64BytesFromBuffer(buffer);
+    if (!compression.enabled || originalBytes <= compression.maxBytes) {
+        return buffer.toString('base64');
+    }
+
+    const result = await compressImageBuffer(buffer, compression).catch((error) => {
+        Logger.warn('captureScreen 压缩失败，返回原图', {message: error?.message || String(error)});
+        return null;
+    });
+
+    if (!result?.buffer) {
+        return buffer.toString('base64');
+    }
+
+    if (result.withinLimit) {
+        Logger.info('captureScreen 已压缩', {
+            originalBytes,
+            outputBytes: result.bytes,
+            format: result.format,
+            quality: result.quality,
+            scale: result.scale,
+            size: `${result.width}x${result.height}`,
+        });
+    } else {
+        Logger.warn('captureScreen 压缩后仍超过目标', {
+            originalBytes,
+            outputBytes: result.bytes,
+            maxBytes: compression.maxBytes,
+            format: result.format,
+            quality: result.quality,
+            scale: result.scale,
+        });
+    }
+
+    return result.buffer.toString('base64');
+};

package/src/internals/frida/webview_event_agent.js

@@ -14,6 +14,9 @@ function getConfig() {
         keywords: Array.isArray(CONFIG.keywords)
             ? CONFIG.keywords.map((item) => String(item || '')).filter(Boolean)
             : [],
+        // 调试开关：捕获所有能解析到的 WebView JS 回调，用于先确认业务事件名。
+        // 默认关闭，避免正式任务记录无关事件。
+        captureAllEvents: CONFIG.captureAllEvents === true,
         includeRawJs: CONFIG.includeRawJs === true,
         maxRawJsLength: Number(CONFIG.maxRawJsLength || 1200),
         maxPayloadLength: Number(CONFIG.maxPayloadLength || 4 * 1024 * 1024)
@@ -86,6 +89,7 @@ function extractCallPayload(rawSource) {
 
 function shouldCapture(config, rawJs, parsed) {
     const eventName = String(parsed?.eventName || '').trim();
+    if (config.captureAllEvents && (eventName || parsed?.payload || config.includeRawJs)) return true;
     if (eventName && config.eventNames.has(eventName)) return true;
     if (config.keywords.length === 0) return false;
     const raw = String(rawJs || '');

package/src/launch.js

@@ -5,48 +5,66 @@ import {createAndroidContext} from './context.js';
 import {Device} from './device.js';
 import {Frida} from './frida-client.js';
 import {Logger} from './logger.js';
+import {Share} from './share.js';
+
+const DEFAULT_INPUT_PATH = '/apify_storage/input.json';
+const DEFAULT_OUTPUT_PATH = '/apify_storage/output.json';
 
 export const Launch = {
     /**
      * Android androider 的统一入口。
      *
      * 这层等价于普通 visitor 里的 Actor.init + Actor.getInput + requestHandler 的组合。
-     * 注意：toolkit 不读取环境变量，input/output 路径必须由具体 androider 的
-     * main.js 显式传入。这样 toolkit 不会和某个 runner、某个云手机平台绑定。
+     * 容器里默认使用 cluster 固定的 input/output 路径；本地调试仍可由
+     * main.js 透传 argv 覆盖。
      *
      * handler 内建议只写业务流程；输入、ctx、toolkit 模块都从参数里取。
      */
     async run(handler, options = {}) {
-        const input = options.input || JSON.parse(fs.readFileSync(requiredOption(options.inputPath, 'inputPath'), 'utf8'));
+        const startedAt = Date.now();
+        const inputPath = pathOption(options.inputPath, DEFAULT_INPUT_PATH);
+        const outputPath = pathOption(options.outputPath, DEFAULT_OUTPUT_PATH);
+        const input = options.input || JSON.parse(fs.readFileSync(inputPath, 'utf8'));
         const ctx = options.ctx || createAndroidContext(input, options.contextDefaults || {});
+        ctx.runId = ctx.runId || input.run_id || input.runId || input.runtime?.run_id || input.runtime?.runId || '';
         const apifyKit = await ApifyKit.useApifyKit({
             reset: true,
             input,
             ctx,
-            inputPath: options.inputPath,
-            outputPath: requiredOption(options.outputPath, 'outputPath')
+            inputPath,
+            outputPath
         });
 
         const kit = {
             ApifyKit: apifyKit,
             Device,
             Frida,
+            Share,
             Logger
         };
 
         try {
+            Logger.start('Launch run', {
+                inputPath,
+                outputPath,
+                runId: ctx.runId,
+                serial: ctx.serial,
+                packageName: ctx.packageName,
+                queryChars: ctx.query.length
+            });
             await handler({input, ctx, kit, ApifyKit: apifyKit});
+            Logger.success('Launch run', {duration: Logger.duration(startedAt)});
         } catch (error) {
-            Logger.fail('Launch handler failed', error);
+            Logger.fail(`Launch handler failed duration=${Logger.duration(startedAt)}`, error);
             if (!apifyKit.hasPushed()) {
                 await apifyKit.pushFailed(error);
             }
+            throw error;
         }
     }
 };
 
-function requiredOption(value, name) {
+function pathOption(value, fallback) {
     const clean = String(value || '').trim();
-    if (!clean) throw new Error(`Launch.run requires ${name}`);
-    return clean;
+    return clean || fallback;
 }

package/src/logger.js

@@ -9,8 +9,11 @@ const defaultLogger = {
 let activeLogger = defaultLogger;
 
 function write(level, message, detail = '') {
-    const line = detail ? `[android-toolkit] ${message} ${detail}` : `[android-toolkit] ${message}`;
-    const writer = activeLogger[level] || activeLogger.info || console.error;
+    const formattedDetail = formatDetail(detail);
+    const line = formattedDetail
+        ? `[${formatTimestamp()}] [android-toolkit] ${message} ${formattedDetail}`
+        : `[${formatTimestamp()}] [android-toolkit] ${message}`;
+    const writer = activeLogger[level] || activeLogger.warning || activeLogger.warn || activeLogger.info || console.error;
     writer.call(activeLogger, line);
 }
 
@@ -36,6 +39,23 @@ export const Logger = {
     info(message, detail = '') {
         write('info', message, detail);
     },
+    debug(message, detail = '') {
+        write('debug', message, detail);
+    },
+    duration(startedAt) {
+        return `${((Date.now() - startedAt) / 1000).toFixed(2)}s`;
+    },
+    createLogger(scope) {
+        const prefix = scope ? `[${scope}] ` : '';
+        return {
+            start: (message, detail = '') => Logger.start(`${prefix}${message}`, detail),
+            success: (message, detail = '') => Logger.success(`${prefix}${message}`, detail),
+            fail: (message, error = '') => Logger.fail(`${prefix}${message}`, error),
+            warn: (message, detail = '') => Logger.warn(`${prefix}${message}`, detail),
+            info: (message, detail = '') => Logger.info(`${prefix}${message}`, detail),
+            debug: (message, detail = '') => Logger.debug(`${prefix}${message}`, detail)
+        };
+    },
     useTemplate() {
         return {
             taskStart: (detail) => Logger.start('任务开始', detail),
@@ -51,3 +71,41 @@ export const Logger = {
 export function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+
+function formatTimestamp(date = new Date()) {
+    const pad = (value, size = 2) => String(value).padStart(size, '0');
+    return [
+        `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`,
+        `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}.${pad(date.getMilliseconds(), 3)}`
+    ].join(' ');
+}
+
+function formatDetail(detail) {
+    if (detail == null || detail === '') return '';
+    if (typeof detail === 'string') return detail;
+    if (detail instanceof Error) return detail.message;
+    if (Array.isArray(detail)) {
+        return detail.map(formatDetail).filter(Boolean).join(' ');
+    }
+    if (typeof detail === 'object') {
+        const parts = [];
+        for (const [key, value] of Object.entries(detail)) {
+            if (value == null || value === '') continue;
+            if (typeof value === 'object') {
+                parts.push(`${key}=${safeJson(value)}`);
+            } else {
+                parts.push(`${key}=${String(value)}`);
+            }
+        }
+        return parts.join(' ');
+    }
+    return String(detail);
+}
+
+function safeJson(value) {
+    try {
+        return JSON.stringify(value);
+    } catch {
+        return String(value);
+    }
+}