@lynker-desktop/electron-sdk 0.0.9-alpha.4 → 0.0.9-alpha.41

package/main/index.js

@@ -5,6 +5,7 @@ const path = require('node:path');
 const node_util = require('node:util');
 const http = require('node:http');
 const https = require('node:https');
+const node_child_process = require('node:child_process');
 const electron = require('electron');
 const md5 = require('md5');
 const uuid = require('uuid');
@@ -56,7 +57,7 @@ function findWebContentsByPid(pid) {
  * @returns
  */
 const initialize = (options) => {
-    let { protocol, preload, loadingViewUrl, serveOptions = [], errorViewUrl, preloadWebContentsUrl, webviewDomainWhiteList, resourceCacheOptions } = options;
+    let { protocol, preload, loadingViewUrl, serveOptions = [], errorViewUrl, preloadWebContentsConfig, webviewDomainWhiteList, resourceCacheOptions } = options;
     if (exports.isInitialized) {
         // @ts-ignore
         return global['__GLBOAL_ELECTRON_SDK__'];
@@ -64,7 +65,10 @@ const initialize = (options) => {
     exports.isInitialized = true;
     ipc__namespace.initialize();
     logs__namespace.initialize();
-    const wm = windowManager__namespace.initialize(preload, loadingViewUrl, errorViewUrl, preloadWebContentsUrl, webviewDomainWhiteList || []);
+    if (options.ffmpegPath) {
+        VideoDownloader.getInstance().setFFmpegPath(options.ffmpegPath);
+    }
+    const wm = windowManager__namespace.initialize(preload, loadingViewUrl, errorViewUrl, preloadWebContentsConfig, webviewDomainWhiteList || []);
     if (protocol) {
         registerProtocol(protocol);
     }
@@ -92,6 +96,10 @@ const initialize = (options) => {
     SDK.ipc = ipc__namespace.mainIPC;
     SDK.windowManager = wm;
     SDK.getPreload = () => preload;
+    SDK.downloadVideo = downloadVideo;
+    SDK.clearVideoCache = clearVideoCache;
+    SDK.getVideoCacheStats = getVideoCacheStats;
+    SDK.removeVideoCache = removeVideoCache;
     ipc__namespace.mainIPC.handleRenderer(index$1.IPC_GET_APP_METRICS, async () => {
         const metrics = electron.app.getAppMetrics().map(i => {
             const webContents = findWebContentsByPid(i.pid || 0);
@@ -104,6 +112,30 @@ const initialize = (options) => {
         });
         return JSON.stringify(metrics);
     });
+    ipc__namespace.mainIPC.handleRenderer(`__sdk_transcode_video__`, async (options) => {
+        const md5Options = md5(JSON.stringify(options.url));
+        downloadVideo(options, {
+            onDownloadProgress: (progress) => {
+                ipc__namespace.mainIPC.invokeAllRenderer(`__sdk_transcode_video_callback_${md5Options}__`, {
+                    type: 'downloadProgress',
+                    data: progress
+                });
+            },
+            onTranscodeProgress: (progress) => {
+                ipc__namespace.mainIPC.invokeAllRenderer(`__sdk_transcode_video_callback_${md5Options}__`, {
+                    type: 'transcodeProgress',
+                    data: progress
+                });
+            },
+            onComplete: (result) => {
+                ipc__namespace.mainIPC.invokeAllRenderer(`__sdk_transcode_video_callback_${md5Options}__`, {
+                    type: 'complete',
+                    data: result
+                });
+            },
+        });
+        return true;
+    });
     // @ts-ignore
     global['__GLBOAL_ELECTRON_SDK__'] = SDK;
     return SDK;
@@ -461,6 +493,30 @@ ResourceCache.scheme = 'cachefile';
  * @returns
  */
 const enable = (webContents) => remote__namespace.enable(webContents);
+/**
+ * 生成跨平台的文件URL
+ * @param filePath 文件路径
+ * @returns file:// URL
+ */
+function getFileUrl(filePath) {
+    if (!filePath) {
+        return '';
+    }
+    if (filePath.startsWith('file://')) {
+        return filePath;
+    }
+    // 在Windows上，需要添加驱动器字母前的斜杠
+    if (process.platform === 'win32') {
+        // 如果路径是绝对路径（如 C:\path\to\file），转换为 /C:/path/to/file
+        if (filePath.match(/^[A-Za-z]:/)) {
+            return `file:///${filePath}`;
+        }
+        // 如果已经是 /C:/path/to/file 格式，直接添加 file://
+        return `file://${filePath}`;
+    }
+    // macOS 和 Linux 使用 file:/// 前缀
+    return `file://${filePath}`;
+}
 /**
  * 获取随机UUID
  * @param key
@@ -484,6 +540,469 @@ function getRandomUUID(key = `${Date.now()}`) {
     const uuid$1 = uuid.v5(`${JSON.stringify(key)}_${Date.now()}_${randomValue}`, uuid.v5.URL);
     return uuid$1;
 }
+/**
+ * 视频下载和转码类
+ */
+class VideoDownloader {
+    constructor() {
+        this.ffmpegPath = '';
+        this.defaultCacheTTL = 24 * 60 * 60 * 1000; // 24小时缓存有效期
+    }
+    static getInstance() {
+        if (!VideoDownloader.instance) {
+            VideoDownloader.instance = new VideoDownloader();
+        }
+        return VideoDownloader.instance;
+    }
+    setFFmpegPath(ffmpegPath) {
+        this.ffmpegPath = ffmpegPath;
+    }
+    /**
+     * 下载视频文件
+     */
+    async downloadVideoFile(url, outputPath, onProgress) {
+        return new Promise((resolve, reject) => {
+            const lib = url.startsWith('https') ? https : http;
+            const file = fs.createWriteStream(outputPath);
+            let downloadedBytes = 0;
+            let totalBytes = 0;
+            let startTime = Date.now();
+            let lastTime = startTime;
+            let lastBytes = 0;
+            const cleanup = () => {
+                if (file) {
+                    file.close();
+                    fs.unlinkSync(outputPath);
+                }
+            };
+            const request = lib.get(url, (res) => {
+                if (res.statusCode !== 200) {
+                    cleanup();
+                    reject(new Error(`下载失败，状态码: ${res.statusCode}`));
+                    return;
+                }
+                totalBytes = parseInt(res.headers['content-length'] || '0', 10);
+                res.on('data', (chunk) => {
+                    downloadedBytes += chunk.length;
+                    const now = Date.now();
+                    if (onProgress && (now - lastTime > 100 || downloadedBytes === totalBytes)) {
+                        const speed = ((downloadedBytes - lastBytes) * 1000) / (now - lastTime);
+                        onProgress({
+                            downloaded: downloadedBytes,
+                            total: totalBytes,
+                            percentage: totalBytes > 0 ? (downloadedBytes / totalBytes) * 100 : 0,
+                            speed: speed || 0
+                        });
+                        lastTime = now;
+                        lastBytes = downloadedBytes;
+                    }
+                });
+                res.pipe(file);
+                file.on('finish', () => {
+                    file.close();
+                    resolve();
+                });
+                file.on('error', (err) => {
+                    cleanup();
+                    reject(err);
+                });
+            });
+            request.on('error', (err) => {
+                cleanup();
+                reject(err);
+            });
+        });
+    }
+    /**
+     * 使用FFmpeg转码视频
+     */
+    async transcodeVideo(inputPath, outputPath, options, onProgress) {
+        return new Promise((resolve, reject) => {
+            const ffmpegPath = options.ffmpegPath || this.ffmpegPath;
+            if (!ffmpegPath) {
+                reject(new Error('FFmpeg路径未设置'));
+                return;
+            }
+            const format = options.format || 'mp4';
+            const quality = options.quality || 18;
+            const videoCodec = options.videoCodec || 'h264';
+            const audioCodec = options.audioCodec || 'aac';
+            // 根据格式选择合适的编码器
+            const getCodecForFormat = (format, videoCodec, audioCodec) => {
+                switch (format) {
+                    case 'webm':
+                        return {
+                            videoCodec: videoCodec === 'h264' ? 'libvpx-vp9' : videoCodec,
+                            audioCodec: audioCodec === 'aac' ? 'libopus' : audioCodec
+                        };
+                    case 'avi':
+                        return {
+                            videoCodec: videoCodec === 'h265' ? 'h264' : videoCodec, // AVI不支持H265
+                            audioCodec: audioCodec === 'opus' ? 'mp3' : audioCodec
+                        };
+                    case 'mov':
+                        return {
+                            videoCodec: videoCodec === 'vp9' ? 'h264' : videoCodec, // MOV对VP9支持有限
+                            audioCodec: audioCodec === 'opus' ? 'aac' : audioCodec
+                        };
+                    default: // mp4, mkv
+                        return { videoCodec, audioCodec };
+                }
+            };
+            const { videoCodec: finalVideoCodec, audioCodec: finalAudioCodec } = getCodecForFormat(format, videoCodec, audioCodec);
+            // 构建FFmpeg命令
+            const args = [
+                '-i', inputPath,
+                '-c:v', finalVideoCodec,
+                '-c:a', finalAudioCodec,
+                '-crf', quality.toString(),
+                '-preset', 'medium',
+                '-f', format, // 指定输出格式
+                '-y', // 覆盖输出文件
+                outputPath
+            ];
+            const ffmpegProcess = node_child_process.spawn(ffmpegPath, args);
+            let duration = 0;
+            let stderr = '';
+            ffmpegProcess.stderr.on('data', (data) => {
+                stderr += data.toString();
+                // 解析FFmpeg输出获取进度
+                if (onProgress) {
+                    const durationMatch = stderr.match(/Duration: (\d{2}):(\d{2}):(\d{2})\.(\d{2})/);
+                    if (durationMatch && duration === 0) {
+                        const hours = parseInt(durationMatch[1] || '0', 10);
+                        const minutes = parseInt(durationMatch[2] || '0', 10);
+                        const seconds = parseInt(durationMatch[3] || '0', 10);
+                        const centiseconds = parseInt(durationMatch[4] || '0', 10);
+                        duration = hours * 3600 + minutes * 60 + seconds + centiseconds / 100;
+                    }
+                    const timeMatch = stderr.match(/time=(\d{2}):(\d{2}):(\d{2})\.(\d{2})/);
+                    if (timeMatch && duration > 0) {
+                        const hours = parseInt(timeMatch[1] || '0', 10);
+                        const minutes = parseInt(timeMatch[2] || '0', 10);
+                        const seconds = parseInt(timeMatch[3] || '0', 10);
+                        const centiseconds = parseInt(timeMatch[4] || '0', 10);
+                        const currentTime = hours * 3600 + minutes * 60 + seconds + centiseconds / 100;
+                        const percentage = (currentTime / duration) * 100;
+                        const speedMatch = stderr.match(/speed=([\d.]+)x/);
+                        const speed = speedMatch ? parseFloat(speedMatch[1] || '1') : 1;
+                        onProgress({
+                            percentage: Math.min(percentage, 100),
+                            time: currentTime,
+                            speed: speed
+                        });
+                    }
+                }
+            });
+            ffmpegProcess.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`FFmpeg转码失败，退出码: ${code}\n${stderr}`));
+                }
+            });
+            ffmpegProcess.on('error', (err) => {
+                reject(new Error(`FFmpeg执行失败: ${err.message}`));
+            });
+        });
+    }
+    /**
+     * 检查FFmpeg是否可用
+     */
+    async checkFFmpegAvailable(ffmpegPath) {
+        return new Promise((resolve) => {
+            const command = ffmpegPath || this.ffmpegPath;
+            if (!command) {
+                resolve(false);
+                return;
+            }
+            const childProcess = node_child_process.spawn(command, ['-version']);
+            childProcess.on('error', (error) => {
+                console.log("checkFFmpegAvailable", error);
+                resolve(false);
+            });
+            childProcess.on('close', (code) => {
+                console.log("checkFFmpegAvailable", code);
+                resolve(code === 0);
+            });
+        });
+    }
+    /**
+     * 获取视频信息
+     */
+    async getVideoInfo(inputPath, ffmpegPath) {
+        return new Promise((resolve, reject) => {
+            const ffmpegPath_cmd = ffmpegPath || this.ffmpegPath;
+            const args = ['-i', inputPath, '-f', 'null', '-'];
+            if (!ffmpegPath_cmd) {
+                resolve({ duration: 0, fileSize: 0 });
+                return;
+            }
+            const ffmpegProcess = node_child_process.spawn(ffmpegPath_cmd, args);
+            let stderr = '';
+            let duration = 0;
+            ffmpegProcess.stderr.on('data', (data) => {
+                stderr += data.toString();
+                const durationMatch = stderr.match(/Duration: (\d{2}):(\d{2}):(\d{2})\.(\d{2})/);
+                if (durationMatch) {
+                    const hours = parseInt(durationMatch[1] || '0', 10);
+                    const minutes = parseInt(durationMatch[2] || '0', 10);
+                    const seconds = parseInt(durationMatch[3] || '0', 10);
+                    const centiseconds = parseInt(durationMatch[4] || '0', 10);
+                    duration = hours * 3600 + minutes * 60 + seconds + centiseconds / 100;
+                }
+            });
+            ffmpegProcess.on('close', () => {
+                const stats = fs.statSync(inputPath);
+                resolve({
+                    duration,
+                    fileSize: stats.size
+                });
+            });
+            ffmpegProcess.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+    /**
+     * 生成缓存文件名（基于URL的MD5）
+     */
+    generateCacheFileName(options) {
+        const format = options.format || 'mp4';
+        const urlMd5 = md5(options.url);
+        return `${urlMd5}.${format}`;
+    }
+    /**
+     * 检查缓存文件是否存在
+     */
+    isCacheFileExists(cacheFilePath) {
+        console.log('检查缓存文件是否存在: ', cacheFilePath);
+        return fs.existsSync(cacheFilePath);
+    }
+    /**
+     * 清理过期缓存文件
+     */
+    cleanExpiredCacheFiles(outputDir, cacheTTL = this.defaultCacheTTL) {
+        try {
+            const files = fs.readdirSync(outputDir);
+            const now = Date.now();
+            files.forEach(file => {
+                const filePath = path.join(outputDir, file);
+                try {
+                    const stats = fs.statSync(filePath);
+                    // 如果文件超过缓存时间，删除它
+                    if (now - stats.mtimeMs > cacheTTL) {
+                        fs.unlinkSync(filePath);
+                        console.log(`🧹 删除过期缓存文件: ${file}`);
+                    }
+                }
+                catch (error) {
+                    // 忽略单个文件错误
+                }
+            });
+        }
+        catch (error) {
+            // 忽略目录读取错误
+        }
+    }
+    /**
+     * 下载并转码视频
+     */
+    async downloadAndTranscode(options, callbacks) {
+        try {
+            const outputDir = options.outputDir || electron.app.getPath('temp');
+            // 获取缓存配置
+            const cacheConfig = options.cache || { enabled: true, ttl: this.defaultCacheTTL };
+            const cacheEnabled = cacheConfig.enabled !== false;
+            const cacheTTL = cacheConfig.ttl || this.defaultCacheTTL;
+            // 确保输出目录存在
+            if (!fs.existsSync(outputDir)) {
+                fs.mkdirSync(outputDir, { recursive: true });
+            }
+            // 清理过期缓存文件
+            this.cleanExpiredCacheFiles(outputDir, cacheTTL);
+            // 生成缓存文件名
+            const cacheFileName = this.generateCacheFileName(options);
+            const cacheFilePath = path.join(outputDir, cacheFileName);
+            // 如果启用缓存，检查缓存文件是否存在
+            if (cacheEnabled && this.isCacheFileExists(cacheFilePath)) {
+                console.log('🎯 命中缓存，直接返回缓存文件');
+                // 获取文件信息
+                const stats = fs.statSync(cacheFilePath);
+                const result = {
+                    success: true,
+                    outputPath: getFileUrl(cacheFilePath),
+                    fileSize: stats.size,
+                    fromCache: true
+                };
+                callbacks?.onComplete?.({
+                    success: true,
+                    outputPath: result.outputPath
+                });
+                return result;
+            }
+            // 检查FFmpeg是否可用
+            const ffmpegAvailable = await this.checkFFmpegAvailable(options.ffmpegPath);
+            if (!ffmpegAvailable) {
+                throw new Error('FFmpeg不可用，请确保已安装FFmpeg或提供正确的路径');
+            }
+            // 生成临时文件名和最终输出路径
+            const fileName = options.outputName || md5(options.url);
+            const format = options.format || 'mp4';
+            const tempPath = path.join(outputDir, `${fileName}.temp`);
+            const finalOutputPath = path.join(outputDir, `${fileName}.${format}`);
+            const outputPath = cacheEnabled ? cacheFilePath : finalOutputPath;
+            console.log('📥 开始下载视频...');
+            // 下载视频
+            await this.downloadVideoFile(options.url, tempPath, callbacks?.onDownloadProgress);
+            console.log('🔄 开始转码视频...');
+            // 转码视频
+            await this.transcodeVideo(tempPath, outputPath, {
+                ...options,
+                outputDir
+            }, callbacks?.onTranscodeProgress);
+            // 如果启用了缓存，将缓存文件复制到最终输出路径
+            if (cacheEnabled && outputPath !== finalOutputPath) {
+                fs.copyFileSync(outputPath, finalOutputPath);
+                console.log('📋 缓存文件已复制到最终输出路径');
+            }
+            // 获取视频信息
+            const videoInfo = await this.getVideoInfo(outputPath, options.ffmpegPath);
+            // 清理临时文件
+            if (!options.keepOriginal) {
+                fs.unlinkSync(tempPath);
+            }
+            console.log('💾 文件已保存到缓存');
+            const result = {
+                success: true,
+                outputPath: getFileUrl(cacheEnabled ? finalOutputPath : outputPath),
+                originalPath: options.keepOriginal ? getFileUrl(tempPath) : undefined,
+                duration: videoInfo.duration,
+                fileSize: videoInfo.fileSize,
+                fromCache: false
+            };
+            callbacks?.onComplete?.({
+                success: true,
+                outputPath: result.outputPath
+            });
+            return result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : '未知错误';
+            const result = {
+                success: false,
+                error: errorMessage
+            };
+            callbacks?.onComplete?.({
+                success: false,
+                error: errorMessage
+            });
+            return result;
+        }
+    }
+    /**
+     * 清除指定目录的所有缓存文件
+     */
+    clearCache(outputDir) {
+        try {
+            const files = fs.readdirSync(outputDir);
+            files.forEach(file => {
+                const filePath = path.join(outputDir, file);
+                try {
+                    fs.unlinkSync(filePath);
+                }
+                catch (error) {
+                    // 忽略单个文件删除错误
+                }
+            });
+            console.log('🧹 缓存文件已清空');
+        }
+        catch (error) {
+            console.log('⚠️ 清理缓存时发生错误:', error instanceof Error ? error.message : '未知错误');
+        }
+    }
+    /**
+     * 获取缓存统计信息
+     */
+    getCacheStats(outputDir) {
+        try {
+            const files = fs.readdirSync(outputDir);
+            const entries = files.map(file => {
+                const filePath = path.join(outputDir, file);
+                try {
+                    const stats = fs.statSync(filePath);
+                    return {
+                        fileName: file,
+                        filePath: filePath,
+                        fileSize: stats.size,
+                        mtime: stats.mtimeMs
+                    };
+                }
+                catch {
+                    return null;
+                }
+            }).filter((entry) => entry !== null);
+            return {
+                size: entries.length,
+                entries
+            };
+        }
+        catch (error) {
+            return { size: 0, entries: [] };
+        }
+    }
+    /**
+     * 删除指定URL的缓存文件
+     */
+    removeCache(options) {
+        try {
+            const cacheFileName = this.generateCacheFileName(options);
+            const cacheFilePath = path.join(options.outputDir, cacheFileName);
+            if (fs.existsSync(cacheFilePath)) {
+                fs.unlinkSync(cacheFilePath);
+                console.log(`🗑️ 删除缓存文件: ${cacheFileName}`);
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            console.log('⚠️ 删除缓存文件时发生错误:', error instanceof Error ? error.message : '未知错误');
+            return false;
+        }
+    }
+}
+/**
+ * 下载视频并转码
+ * @param options 下载和转码选项
+ * @param callbacks 进度回调
+ * @returns 转码结果
+ */
+const downloadVideo = async (options, callbacks) => {
+    const downloader = VideoDownloader.getInstance();
+    return downloader.downloadAndTranscode(options, callbacks);
+};
+/**
+ * 清除指定目录的所有缓存文件
+ */
+const clearVideoCache = (outputDir) => {
+    const downloader = VideoDownloader.getInstance();
+    downloader.clearCache(outputDir);
+};
+/**
+ * 获取缓存统计信息
+ */
+const getVideoCacheStats = (outputDir) => {
+    const downloader = VideoDownloader.getInstance();
+    return downloader.getCacheStats(outputDir);
+};
+/**
+ * 删除指定URL的缓存文件
+ */
+const removeVideoCache = (options) => {
+    const downloader = VideoDownloader.getInstance();
+    return downloader.removeCache(options);
+};
 /**
  * 获取定制Session
  */
@@ -493,25 +1012,34 @@ const getCustomSession = windowManager__namespace.getCustomSession;
  * @returns
  */
 const index = new Proxy({}, {
-    get() {
+    get(_target, prop) {
         if (!exports.isInitialized) {
             throw new Error('请在ready前先调用initialize');
         }
+        if (!prop) {
+            // @ts-ignore
+            return global['__GLBOAL_ELECTRON_SDK__'];
+        }
         // @ts-ignore
-        return global['__GLBOAL_ELECTRON_SDK__'];
+        return global['__GLBOAL_ELECTRON_SDK__'][prop];
     },
     set() {
-        return true;
+        return false;
     }
 });
 
 exports.ResourceCache = ResourceCache;
+exports.clearVideoCache = clearVideoCache;
 exports.default = index;
+exports.downloadVideo = downloadVideo;
 exports.enable = enable;
 exports.getCustomSession = getCustomSession;
+exports.getFileUrl = getFileUrl;
 exports.getRandomUUID = getRandomUUID;
 exports.getSDK = getSDK;
+exports.getVideoCacheStats = getVideoCacheStats;
 exports.initialize = initialize;
 exports.registerProtocol = registerProtocol;
+exports.removeVideoCache = removeVideoCache;
 exports.serve = serve;
 //# sourceMappingURL=index.js.map