trtc-electron-sdk 11.3.601-alpha.0 → 11.3.601-alpha.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trtc-electron-sdk",
-  "version": "11.3.601-alpha.0",
+  "version": "11.3.601-alpha.2",
   "description": "trtc electron sdk",
   "main": "./liteav/trtc.js",
   "types": "./liteav/trtc.d.ts",
@@ -65,6 +65,7 @@
     "build",
     "liteav",
     "types",
+    "scripts",
     "README.md",
     "package.json"
   ]

package/scripts/constant.js

@@ -0,0 +1,9 @@
+module.exports.Platform = {
+  MACOS: 'mac', // mac-x64
+  MACOS_ARM: 'mac-arm64',
+  WINDOWS32: 'win32',
+  WINDOWS64: 'win64',
+  UNSUPPORTED: 'unsupported',
+  LINUX_X64: 'linux-x64',
+  LINUX_ARM64: 'linux-arm64',
+};

package/scripts/copy-sdk.js

@@ -0,0 +1,70 @@
+const path = require("path");
+const { removeSync, copySync } = require("fs-extra");
+
+// npm run copy:sdk
+const SDK_ROOT = path.resolve(__dirname, "../../");
+const SDK_CPP_PATH = path.join(SDK_ROOT, "trtc-electron-cpp");
+const SDK_JS_PATH = path.join(SDK_ROOT, "trtc-electron-sdk");
+
+removeSync(path.join(SDK_JS_PATH, "build"));
+
+copySync(
+  path.resolve(SDK_CPP_PATH, "build/Release/trtc_electron_sdk.node"),
+  path.resolve(SDK_JS_PATH, "build/Release/trtc_electron_sdk.node")
+);
+if (process.platform === "win32") {
+  let dllPrefix = "";
+  if (process.arch === "x64") {
+    dllPrefix = "Win64";
+  } else {
+    dllPrefix = "Win32";
+  }
+  copySync(
+    path.resolve(SDK_CPP_PATH, `v2/win/${dllPrefix}/lib/`),
+    path.resolve(SDK_JS_PATH, "build/Release/")
+  );
+  copySync(
+    path.resolve(SDK_CPP_PATH, "build/Release/trtc_electron_sdk.pdb"),
+    path.resolve(SDK_JS_PATH, "build/Release/trtc_electron_sdk.pdb")
+  );
+} else if (process.platform === 'darwin') {
+  copySync(
+    path.resolve(SDK_CPP_PATH, "build/Release/trtc_electron_sdk.node"),
+    path.resolve(SDK_JS_PATH, `build/Release/${process.arch}/trtc_electron_sdk.node`)
+  );
+  copySync(
+    path.resolve(SDK_CPP_PATH, "build/Release/trtc_electron_sdk.node.dSYM"),
+    path.resolve(SDK_JS_PATH, "build/Release/trtc_electron_sdk.node.dSYM")
+  );
+  copySync(
+    path.resolve(SDK_CPP_PATH, `v2/mac/Frameworks/${process.arch}/TXFFmpeg.framework`),
+    path.resolve(SDK_JS_PATH, `build/mac-framework/${process.arch}/TXFFmpeg.framework`)
+  );
+  copySync(
+    path.resolve(SDK_CPP_PATH, `v2/mac/Frameworks/${process.arch}/TXSoundTouch.framework`),
+    path.resolve(SDK_JS_PATH, `build/mac-framework/${process.arch}/TXSoundTouch.framework`)
+  );
+} else {
+  // linux
+  let soPrefix = ""
+    if (process.arch === 'x64') {
+      soPrefix = "x86_64";
+    } else {
+      soPrefix = "arm64";
+    }
+    copySync(
+      path.resolve(SDK_CPP_PATH, 'build/Release/trtc_electron_sdk.node'),
+      path.resolve(SDK_JS_PATH, `build/Release/${process.arch}/trtc_electron_sdk.node`)
+    );
+    copySync(
+      path.resolve(SDK_CPP_PATH, `v2/linux/libs/${soPrefix}/`), 
+      path.resolve(SDK_JS_PATH, 'build/Release/')
+    );
+    copySync(
+      path.resolve(SDK_CPP_PATH, `v2/linux/libs/${soPrefix}/`),
+      path.resolve(SDK_JS_PATH, `build/Release/${process.arch}/`)
+    );
+}
+
+
+console.log("CopySDKManual.doCopy: 复制结束");

package/scripts/copy-types.js

@@ -0,0 +1,3 @@
+const path = require('path');
+const {copy} = require('fs-sync');
+copy(path.resolve('./types'), path.resolve('./liteav'));

package/scripts/download.js

@@ -0,0 +1,206 @@
+const download = require('download');
+const path = require('path');
+const fs = require('fs-extra');
+const rimraf = require('rimraf');
+const signale = require('signale');
+const { exec } = require('child_process');
+const { HttpsProxyAgent } = require('hpagent');
+
+const currentPath = process.cwd();
+const pathFlagValue = `packages${process.platform === "win32" ? "\\" : "/"}trtc-electron-sdk`;
+if (currentPath.indexOf(pathFlagValue) !== -1) {
+    signale.info("trtc-electron-sdk: development mode, skip native sdk lib download");
+    return;
+}
+
+const {
+    readCliArgv,
+    readArgvFromNpmEnv,
+    detectOS,
+    detectOwnVersion,
+    detectOwnName,
+    readProxyUrlFromEnv,
+} = require('./utils');
+const { Platform } = require('./constant');
+
+const buildDownloadInfo = () => {
+    const configArgv = Object.assign({
+        arch: process.arch,
+        platform: process.platform,
+    }, readCliArgv(), readArgvFromNpmEnv());
+
+    // build os label
+    const osLabel = detectOS(configArgv.arch, configArgv.platform);
+
+    // build version label
+    const { version } = detectOwnVersion();
+    signale.info('buildDownloadInfo version=', version);
+
+    const name = detectOwnName();
+    signale.info('buildDownloadInfo name=', name);
+
+    // generate download url
+    return {
+        platform: osLabel,
+        downloadUrl: `https://web.sdk.qcloud.com/trtc/electron/download/${name}/${version}/${name}-${osLabel}-${version}.zip`,
+        name,
+        version,
+        archType: configArgv.arch
+    };
+};
+
+const main = () => {
+    const {
+        platform,
+        downloadUrl,
+        name,
+        version,
+        archType
+    } = buildDownloadInfo();
+
+    const outputDir = path.join(__dirname, '../temp');
+    const buildDir = path.join(__dirname, '../build');
+
+    rimraf.sync(outputDir);
+    rimraf(buildDir, err => {
+        if (err) {
+            signale.error(err);
+            process.exit(1);
+        }
+
+        // print download info
+        signale.info('removeDir  =', buildDir);
+        signale.info('outputDir  =', outputDir);
+
+        signale.info('Package Version =', version);
+        signale.info('Platform =', platform);
+        signale.info('Download Url =', downloadUrl, '\n');
+
+        signale.pending('Downloading C++ addon Electron SDK...\n');
+        const downloadOptions = {
+            strip: 0,
+            extract: true
+        };
+        const proxyUrl = readProxyUrlFromEnv(downloadUrl);
+        if (proxyUrl) {
+            downloadOptions.agent = {
+                https: new HttpsProxyAgent({
+                    keepAlive: true,
+                    keepAliveMsecs: 1000,
+                    maxSockets: 256,
+                    maxFreeSockets: 256,
+                    scheduling: 'lifo',
+                    proxy: proxyUrl
+                })
+            }
+        }
+        download(downloadUrl, outputDir, downloadOptions).then(() => {
+            signale.success(`Download finished - ${platform}`);
+
+            fs.copySync(
+                path.join(outputDir, './build/Release'),
+                path.join(buildDir, 'Release')
+            );
+            signale.success(`copy success! - ${platform}`);
+
+            if (platform === Platform.WINDOWS32 || platform === Platform.WINDOWS64) {
+                // windows 下
+                rimraf.sync(outputDir);
+            } else if (platform === 'mac' || platform === 'mac-arm64') {
+                // mac 下
+                const arch = archType;
+                fs.copySync(
+                    path.join(outputDir, './build/Release/trtc_electron_sdk.node'),
+                    path.join(buildDir, 'Release', arch, 'trtc_electron_sdk.node')
+                );
+                fs.copySync(
+                    path.join(outputDir, './build/mac-framework', arch),
+                    path.join(buildDir, 'mac-framework', arch)
+                );
+                signale.success(`copy success! - mac ${arch}`, '\n');
+
+                let anotherPlatform, anotherArch;
+                if (arch === 'x64') {
+                    // download arm64
+                    anotherPlatform = Platform.MACOS_ARM;
+                    anotherArch = 'arm64';
+                } else {
+                    // arch = arm64, download x64
+                    anotherPlatform = Platform.MACOS;
+                    anotherArch = 'x64';
+                }
+                const anotherDownloadUrl = `https://web.sdk.qcloud.com/trtc/electron/download/${name}/${version}/${name}-${anotherPlatform}-${version}.zip`;
+                signale.info('Download Url =', anotherDownloadUrl, '\n');
+                signale.pending(`Downloading C++ addon Electron SDK... ${anotherArch}\n`);
+                download(anotherDownloadUrl, path.join(outputDir, anotherPlatform), {
+                    strip: 0,
+                    extract: true
+                })
+                    .then(() => {
+                        signale.success(`Download finished - mac ${anotherArch}`);
+
+                        fs.copySync(
+                            path.join(outputDir, anotherPlatform, '/build/Release/trtc_electron_sdk.node'),
+                            path.join(buildDir, 'Release', anotherArch, 'trtc_electron_sdk.node')
+                        );
+                        fs.copySync(
+                            path.join(outputDir, anotherPlatform, '/build/mac-framework', anotherArch),
+                            path.join(buildDir, 'mac-framework', anotherArch)
+                        );
+                        signale.success(`copy success! - mac ${anotherArch}`);
+
+                        // Mac 下完成文件下载后，执行该命令，同步文件到 Electron 目录下
+                        exec(`rsync -a ../../node_modules/trtc-electron-sdk/build/mac-framework/${archType}/ ../../node_modules/electron/dist/Electron.app/Contents/Frameworks`);
+
+                        rimraf.sync(outputDir);
+                    })
+                    .catch(err => {
+                        signale.error(`download error! - mac ${anotherPlatform}`, err);
+                    });
+            } else if (platform === 'linux-x64' || platform === 'linux-arm64') {
+                // Linux 下
+                const arch = process.arch;
+                fs.copySync(
+                    path.join(outputDir, './build/Release'),
+                    path.join(buildDir, 'Release', arch)
+                );
+                signale.success(`copy success! - linux ${arch}`, '\n');
+
+                let anotherPlatform, anotherArch;
+                if (arch === 'x64') {
+                    // download arm64
+                    anotherPlatform = Platform.LINUX_ARM64;
+                    anotherArch = 'arm64';
+                } else {
+                    // arch = arm64, download x64
+                    anotherPlatform = Platform.LINUX_X64;
+                    anotherArch = 'x64';
+                }
+                const anotherDownloadUrl = `https://web.sdk.qcloud.com/trtc/electron/download/${name}/${version}/${name}-${anotherPlatform}-${version}.zip`;
+                signale.info('Download Url =', anotherDownloadUrl, '\n');
+                signale.pending(`Downloading C++ addon Electron SDK... ${anotherArch}\n`);
+                download(anotherDownloadUrl, path.join(outputDir, anotherPlatform), {
+                    strip: 0,
+                    extract: true
+                }).then(() => {
+                    signale.success(`Download finished - linux ${anotherArch}`);
+                    fs.copySync(
+                        path.join(outputDir, anotherPlatform, '/build/Release'),
+                        path.join(buildDir, 'Release', anotherArch)
+                    );
+                    signale.success(`copy success! - linux ${anotherArch}`);
+
+                    rimraf.sync(outputDir);
+                }).catch(err => {
+                    signale.error(`download error! - linux ${anotherPlatform}`, err);
+                })
+            } else {
+                signale.warn(`Not supported platform: ${platform}`);
+            }
+        }).catch(err => {
+            signale.error(`Failed! Download error - ${platform}`, err);
+        });
+    });
+};
+
+main();

package/scripts/prerelase.js

@@ -0,0 +1,19 @@
+const path = require('path');
+const {copy, remove} = require('fs-sync');
+const fs = require('fs');
+
+const liteavPath = path.join(__dirname, '../liteav');
+const liteavFiles = fs.readdirSync(liteavPath, {withFileTypes: true});
+liteavFiles.forEach(file => {
+  if (file.isFile() && file.name.indexOf('_en.') !== -1) {
+    const filePath = path.join(liteavPath, file.name);
+    console.log(`Remove en files not to be published: `, filePath);
+    remove(filePath);
+  }
+});
+
+remove('./npm');
+copy(path.resolve('./liteav'), path.resolve('./npm/liteav'));
+copy(path.resolve('./scripts'), path.resolve('./npm/scripts'));
+copy(path.resolve('./package.json'), path.resolve('./npm/package.json'));
+copy(path.resolve('./README.md'), path.resolve('./npm/README.md'));

package/scripts/publish-doc.js

@@ -0,0 +1,91 @@
+const fs = require('fs');
+const path = require('path');
+const COS = require('cos-nodejs-sdk-v5');
+
+const cosConfig = {
+    SecretId: '',
+    SecretKey: ''
+};
+
+let enableWrite = false;
+const myArgs = process.argv.slice(2);
+myArgs.forEach(arg => {
+    if (arg.includes('=')) {
+        const [key, value] = arg.split('=');
+        if (key === 'SecretId' && value) {
+            // 注意: 确保在蓝盾运行时才打开, 真正上传文档到 cos
+            enableWrite = true;
+            cosConfig.SecretId = value;
+        }
+        if (key === 'SecretKey' && value) {
+            cosConfig.SecretKey = value;
+        }
+    }
+});
+
+if (!cosConfig.SecretId || !cosConfig.SecretKey) {
+    console.log('unable to upload doc');
+}
+
+const cos = new COS({
+    SecretId: cosConfig.SecretId,
+    SecretKey: cosConfig.SecretKey
+});
+
+const bucket = 'sdk-web-1252463788';
+const region = 'ap-hongkong';
+const keyPrefix = 'trtc/electron/doc/';
+const docPath = path.join(__dirname, '../_doc');
+
+function walkSync(dir, filelist) {
+    const files = fs.readdirSync(dir);
+    filelist = filelist || [];
+    files.forEach(function(file) {
+        if (fs.statSync(path.join(dir, file)).isDirectory()) {
+            filelist = walkSync(path.join(dir, file), filelist);
+        } else {
+            filelist.push({
+                path: path.join(dir, file),
+                name: path.relative(docPath, path.join(dir, file))
+            });
+        }
+    });
+    return filelist;
+};
+
+function getUploadFiles(docFileList) {
+    return docFileList.map(file => {
+        return {
+            Bucket: bucket,
+            Region: region,
+            Key: keyPrefix + file.name,
+            FilePath: file.path,
+        };
+    });
+}
+
+function uploadFiles() {
+    const docFileList = [];
+    walkSync(docPath, docFileList);
+    const fileList = getUploadFiles(docFileList);
+    if (enableWrite) {
+        cos.uploadFiles({
+            files: fileList,
+            SliceSize: 1024 * 1024,
+            onProgress: function (info) {
+                const percent = parseInt(info.percent * 10000) / 100;
+                const speed = parseInt((info.speed / 1024 / 1024) * 100) / 100;
+                console.log(`进度：${percent}%; 速度：${speed}Mb/s;`);
+            },
+            onFileFinish: function (err, data, options) {
+                console.log(`${options.Key}上传${err ? '失败' : '完成'}`);
+            },
+        }, function (err, data) {
+            if (err) {
+                console.log(JSON.stringify(err));
+            }
+        });
+    }
+}
+
+uploadFiles();

package/scripts/publish-npm.js

@@ -0,0 +1,26 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// trtc-electron-sdk 蓝盾地址: http://devops.oa.com/console/pipeline/ecc/p-b80c02872fad42dc9763c266593dfaed/history
+// 因为需要去覆盖 ~/.npmrc 文件, 所以构建环境采用的是 macOS on DevCloud 云主机
+
+let npmToken = '';
+const myArgs = process.argv.slice(2);
+myArgs.forEach(arg => {
+    if (arg.includes('=')) {
+        const [key, value] = arg.split('=');
+        if (key === 'npmToken' && value) {
+            npmToken = value;
+        }
+    }
+});
+
+if (!npmToken) {
+    console.log('not publish npmToken, cant publish npm');
+    return;
+}
+fs.writeFileSync(path.resolve(os.homedir(), '.npmrc'), `//registry.npmjs.org/:_authToken=${npmToken}`);
+
+const content = fs.readFileSync(path.resolve(os.homedir(), '.npmrc'), {encoding: 'utf8'});
+console.log('content: ', content);

package/scripts/utils.js

@@ -0,0 +1,86 @@
+/**
+ * Utils for command line tools
+ */
+const semver = require('semver');
+const pkg = require('../package.json');
+
+const { Platform } = require('./constant');
+
+module.exports.readCliArgv = function() {
+  const cliArgv = process.argv;
+  const newArgv = {};
+  let tmp = [];
+  console.log('readCliArgv',cliArgv);
+  for (let i = 0, len = cliArgv.length ; i < len ; i++) {
+    if (i === 0) {
+      newArgv.nodeDir = cliArgv[i];
+      continue;
+    }
+    if (i === 1) {
+      newArgv.scriptDir = cliArgv[i];
+      continue;
+    }
+    tmp = cliArgv[i].replace('--','').split('=');
+    newArgv[tmp[0]] = tmp[1];
+    tmp = [];
+  }
+  return newArgv;
+};
+
+module.exports.readProxyUrlFromEnv = function(downloadUrl) {
+  if (downloadUrl.indexOf('https') === 0) {
+    return process.env.https_proxy || ''
+  }
+  return process.env.http_proxy || '';
+}
+
+module.exports.readArgvFromNpmEnv = function() {
+  const result = {};
+  if (process.env.npm_config_trtc_electron_arch) {
+    result.arch = process.env.npm_config_trtc_electron_arch;
+  }
+  if (process.env.npm_config_trtc_electron_platform) {
+    result.platform = process.env.npm_config_trtc_electron_platform;
+  }
+  return result;
+};
+
+module.exports.detectOS = (archType = '', platformType = '') => {
+  const platform = platformType !== '' ? platformType : process.platform;
+  const arch = archType !== '' ? archType : process.arch;
+  if (platform === 'darwin') {
+    if (arch === 'x64') {
+      return Platform.MACOS;
+    } else {
+      return Platform.MACOS_ARM;
+    }
+  } else if (platform === 'win32') {
+    if (arch === 'x64') {
+      return Platform.WINDOWS64;
+    } else {
+      return Platform.WINDOWS32;
+    }
+  } else if (platform === 'linux') {
+    if (arch === 'x64') {
+      return Platform.LINUX_X64;
+    } else if (arch === 'arm64') {
+      return Platform.LINUX_ARM64;
+    } else {
+      // unsupported
+    }
+  }
+  return Platform.UNSUPPORTED;
+};
+
+module.exports.detectOwnVersion = () => {
+  const { major, minor, patch } = semver.coerce(pkg.version);
+  return {
+    major, minor, patch, version: pkg.version
+  };
+};
+
+module.exports.detectOwnName = () => {
+  const name = pkg.name;
+  return name;
+};
+