shengwang-electron-sdk 4.6.2-rc.1

package/scripts/download.js

@@ -0,0 +1,102 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const { URL } = require('url');
+
+const archiveType = require('archive-type');
+const contentDisposition = require('content-disposition');
+const decompress = require('decompress');
+const extName = require('ext-name');
+const fileType = require('file-type');
+const filenamify = require('filenamify');
+const getStream = require('get-stream');
+const got = require('got');
+const makeDir = require('make-dir');
+const pEvent = require('p-event');
+const pify = require('pify');
+
+const fsP = pify(fs);
+const filenameFromPath = (res) =>
+  path.basename(new URL(res.requestUrl).pathname);
+
+const getExtFromMime = (res) => {
+  const header = res.headers['content-type'];
+
+  if (!header) {
+    return null;
+  }
+
+  const exts = extName.mime(header);
+
+  if (exts.length !== 1) {
+    return null;
+  }
+
+  return exts[0].ext;
+};
+
+const getFilename = (res, data) => {
+  const header = res.headers['content-disposition'];
+
+  if (header) {
+    const parsed = contentDisposition.parse(header);
+
+    if (parsed.parameters && parsed.parameters.filename) {
+      return parsed.parameters.filename;
+    }
+  }
+
+  let filename = filenameFromPath(res);
+
+  if (!path.extname(filename)) {
+    const ext = (fileType(data) || {}).ext || getExtFromMime(res);
+
+    if (ext) {
+      filename = `${filename}.${ext}`;
+    }
+  }
+
+  return filename;
+};
+
+module.exports = (uri, output, opts) => {
+  opts = {
+    ...opts,
+    encoding: null,
+    responseType: 'buffer',
+    rejectUnauthorized: process.env.npm_config_strict_ssl !== 'false',
+  };
+
+  const stream = got.stream(uri);
+
+  const promise = pEvent(stream, 'response')
+    .then((res) => {
+      const encoding = opts.encoding === null ? 'buffer' : opts.encoding;
+      return Promise.all([getStream(stream, { encoding }), res]);
+    })
+    .then((result) => {
+      const [data, res] = result;
+
+      if (!output) {
+        return opts.extract && archiveType(data)
+          ? decompress(data, opts)
+          : data;
+      }
+
+      const filename = opts.filename || filenamify(getFilename(res, data));
+      const outputFilepath = path.join(output, filename);
+
+      if (opts.extract && archiveType(data)) {
+        return decompress(data, path.dirname(outputFilepath), opts);
+      }
+
+      return makeDir(path.dirname(outputFilepath))
+        .then(() => fsP.writeFile(outputFilepath, data))
+        .then(() => data);
+    });
+
+  stream.then = promise.then.bind(promise);
+  stream.catch = promise.catch.bind(promise);
+
+  return stream;
+};

package/scripts/downloadPrebuild.js

@@ -0,0 +1,199 @@
+const path = require('path');
+
+const fs = require('fs-extra');
+
+const { cleanDir, buildDir } = require('./clean');
+const download = require('./download');
+
+const getConfig = require('./getConfig');
+const logger = require('./logger');
+const { getOS } = require('./util');
+
+const {
+  platform,
+  packageVersion,
+  arch,
+  no_symbol,
+  native_sdk_mac,
+  native_sdk_win,
+} = getConfig();
+
+const workspaceDir = `${path.join(__dirname, '..')}`;
+
+const normalizePath = (filePath) => filePath.split(path.sep).join('/');
+
+const getDownloadURL = () => {
+  let downloadUrl = `https://download.agora.io/sdk/release/Electron-${getOS()}-${packageVersion}-napi.zip`;
+  if (platform === 'win32' && arch === 'x64') {
+    downloadUrl = `https://download.agora.io/sdk/release/Electron-win64-${packageVersion}-napi.zip`;
+  }
+  return downloadUrl;
+};
+
+// If native_stk_url is not defined in app/packaging.json,
+// it will be read from agora-electron-sdk/packaging.json
+const getNativeDownloadURL = () => {
+  let downloadUrl = '';
+  if (platform === 'win32') {
+    downloadUrl = native_sdk_win;
+  } else if (platform === 'darwin') {
+    downloadUrl = native_sdk_mac;
+  }
+
+  if (!downloadUrl) {
+    const {
+      agora_electron: { native_sdk_win, native_sdk_mac },
+    } = require('../package.json');
+    if (platform === 'win32') {
+      downloadUrl = native_sdk_win;
+    } else if (platform === 'darwin') {
+      downloadUrl = native_sdk_mac;
+    }
+  }
+
+  return downloadUrl;
+};
+
+const matchNativeFile = (path) => {
+  let result = false;
+  switch (platform) {
+    case 'win32':
+      switch (arch) {
+        case 'ia32':
+          result = path.startsWith('sdk/x86/') && path.endsWith('.dll');
+          break;
+        case 'x64':
+          result = path.startsWith('sdk/x86_64/') && path.endsWith('.dll');
+          break;
+      }
+      break;
+    case 'darwin':
+      result =
+        path.startsWith('libs') &&
+        /^libs\/.*\.xcframework\/macos-arm64_x86_64\//.test(path);
+      break;
+  }
+  return result;
+};
+
+const macNoSymbolList = [
+  './build/Release/obj.target',
+  './build/Api',
+  './build/Renderer',
+  './build/Utils',
+  './build/agora_node_ext.target.mk',
+  './build/AgoraSdk.js',
+  './build/binding.Makefile',
+  './build/config.gypi',
+  './build/gyp-mac-tool',
+  './build/Makefile',
+  './build/VideoSource.target.mk',
+  './build/Release/agora_node_ext.node.dSYM',
+  './build/Release/VideoSource.dSYM',
+];
+
+const winNoSymbolList = [
+  './build/Release/obj',
+  './build/Api',
+  './build/Renderer',
+  './build/Utils',
+  './build/agora_node_ext.vcxproj',
+  './build/agora_node_ext.vcxproj.filters',
+  './build/binding.sln',
+  './build/config.gypi',
+  './build/VideoSource.vcxproj',
+  './build/VideoSource.vcxproj.filters',
+  './build/AgoraSdk.js',
+  './build/Release/agora_node_ext.exp',
+  './build/Release/agora_node_ext.iobj',
+  './build/Release/agora_node_ext.ipdb',
+  './build/Release/agora_node_ext.pdb',
+  './build/Release/VideoSource.iobj',
+  './build/Release/VideoSource.ipdb',
+  './build/Release/VideoSource.pdb',
+  './build/Release/agora_node_ext.ilk',
+  './build/Release/VideoSource.ilk',
+];
+
+const removeFileByFilter = async () => {
+  const filterList = platform === 'darwin' ? macNoSymbolList : winNoSymbolList;
+
+  for (const iterator of filterList) {
+    const filePath = `${path.join(workspaceDir, iterator)}`;
+    await fs.remove(filePath);
+  }
+  logger.info('Success: Download and cleanup finished');
+};
+
+module.exports = async () => {
+  await cleanDir(buildDir);
+
+  const downloadUrl = getDownloadURL();
+  const nativeDownloadURL = getNativeDownloadURL();
+
+  /** start download */
+  logger.info('Package Version: %s', packageVersion);
+  logger.info('Platform: %s', platform);
+  if (arch) logger.info('Arch: %s', arch);
+  logger.info('Download URL  %s ', downloadUrl);
+
+  logger.info('Downloading prebuilt C++ addon for Agora Electron SDK...');
+  await download(downloadUrl, buildDir, {
+    strip: 1,
+    extract: true,
+    filter: (file) => {
+      return (
+        file.type !== 'directory' &&
+        !file.path.endsWith(path.sep) &&
+        file.data.length !== 0
+      );
+    },
+  });
+
+  if (nativeDownloadURL) {
+    logger.info('Native SDK URL  %s ', nativeDownloadURL);
+    logger.info('Downloading native SDK for Agora Electron SDK...');
+    const nativeLibDir = path.resolve(__dirname, `${buildDir}/Release`);
+    await download(nativeDownloadURL, nativeLibDir, {
+      strip: 1,
+      extract: true,
+      filter: (file) => {
+        file.path = normalizePath(file.path);
+        if (matchNativeFile(file.path)) {
+          if (file.type === 'file' && file.path.endsWith('/')) {
+            file.type = 'directory';
+          }
+          switch (platform) {
+            case 'win32':
+              switch (arch) {
+                case 'ia32':
+                  file.path = file.path.replace(/^sdk\/x86\//, '');
+                  break;
+                case 'x64':
+                  file.path = file.path.replace(/^sdk\/x86_64\//, '');
+                  break;
+              }
+              break;
+            case 'darwin':
+              file.path = file.path.replace(
+                /^libs\/.*\.xcframework\/macos-arm64_x86_64\//,
+                ''
+              );
+              if (fs.exists(`${nativeLibDir}/${file.path}`)) {
+                fs.remove(`${nativeLibDir}/${file.path}`);
+              }
+              break;
+          }
+          logger.info(`move native file: ${file.path} → ${nativeLibDir}`);
+          return true;
+        } else {
+          return false;
+        }
+      },
+    });
+  }
+
+  if (no_symbol) {
+    await removeFileByFilter();
+  }
+};

package/scripts/getConfig.js

@@ -0,0 +1,73 @@
+const path = require('path');
+
+const minimist = require('minimist');
+
+const logger = require('./logger');
+
+const { INIT_CWD } = minimist(process.argv.slice(2), {
+  string: ['INIT_CWD'],
+  default: {},
+});
+logger.info(`pass INIT_CWD ${INIT_CWD}`);
+logger.info(`process.env.INIT_CWD ${process.env.INIT_CWD}`);
+
+const getArgvFromPkgJson = () => {
+  const projectDir = path.join(INIT_CWD, 'package.json');
+  const { agora_electron = {} } = require(projectDir);
+  const { version } = require(path.join(process.env.INIT_CWD, 'package.json'));
+  const {
+    prebuilt = true,
+    platform = process.platform,
+    debug = false,
+    silent = false,
+    arch = process.arch,
+    no_symbol = true,
+  } = agora_electron;
+
+  return {
+    ...agora_electron,
+    packageVersion: version,
+    platform,
+    prebuilt: !!prebuilt,
+    debug: !!debug,
+    silent: !!silent,
+    arch,
+    no_symbol,
+  };
+};
+
+const getConfig = () => {
+  const {
+    argv,
+    env: {
+      npm_config_agora_electron_sdk_pre_built,
+      npm_config_agora_electron_sdk_platform,
+      npm_config_agora_electron_sdk_arch,
+    },
+  } = process;
+
+  let config = minimist(argv.slice(2), {
+    boolean: ['prebuilt', 'debug', 'silent', 'no_symbol'],
+    string: ['arch', 'platform'],
+    default: { ...getArgvFromPkgJson() },
+  });
+
+  logger.info(
+    `env: ${npm_config_agora_electron_sdk_pre_built} ${npm_config_agora_electron_sdk_platform} ${npm_config_agora_electron_sdk_arch}`
+  );
+
+  // argv from ci/npm_config
+  if (npm_config_agora_electron_sdk_pre_built !== undefined) {
+    config.prebuilt = !!+npm_config_agora_electron_sdk_pre_built;
+  }
+
+  if (npm_config_agora_electron_sdk_platform !== undefined) {
+    config.platform = npm_config_agora_electron_sdk_platform;
+  }
+
+  if (npm_config_agora_electron_sdk_arch !== undefined) {
+    config.arch = npm_config_agora_electron_sdk_arch;
+  }
+  return config;
+};
+module.exports = getConfig;

package/scripts/logger.js

@@ -0,0 +1,32 @@
+const { createLogger, format, transports } = require('winston');
+
+const myFormat = format.printf(({ level, message, label, timestamp }) => {
+  return `${timestamp} [${label}] ${level}: ${message}`;
+});
+const formatList = [
+  format.label({ label: 'agora-script' }),
+  format.timestamp({
+    format: 'HH:mm:ss',
+  }),
+  format.errors({ stack: true }),
+  format.splat(),
+  myFormat,
+];
+
+const logger = createLogger({
+  level: 'silly',
+  format: format.combine(...formatList),
+  defaultMeta: { service: 'agora-electron-sdk-log' },
+  transports: [
+    // - Write to all logs with level `info` and below to `quick-start-combined.log`.
+    new transports.File({ filename: 'agora-electron-sdk-script.log' }),
+  ],
+  silent: false,
+});
+
+logger.add(
+  new transports.Console({
+    format: format.combine(...[format.colorize(), ...formatList]),
+  })
+);
+module.exports = logger;

package/scripts/synclib.js

@@ -0,0 +1,69 @@
+const path = require('path');
+
+const { destIrisSDKDir, cleanDir, destNativeSDKDir } = require('./clean');
+const download = require('./download');
+
+const getConfig = require('./getConfig');
+const logger = require('./logger');
+const { getOS, moveFile, getIrisStandAlone } = require('./util');
+
+const config = getConfig();
+
+const { iris_sdk_mac, iris_sdk_win, native_sdk_mac, native_sdk_win } = config;
+
+const downloadSDK = async ({
+  preHook,
+  postHook,
+  sdkURL,
+  destDir,
+  strip = 1,
+}) => {
+  logger.info(`Downloading:${sdkURL}`);
+  await preHook();
+  await download(sdkURL, destDir, {
+    strip: strip,
+    extract: true,
+    //https://github.com/kevva/decompress/issues/68
+    map: (file) => {
+      if (file.type === 'file' && file.path.endsWith('/')) {
+        file.type = 'directory';
+      }
+      return file;
+    },
+  });
+  logger.info(`Finish download:${sdkURL}`);
+  typeof postHook === 'function' && (await postHook());
+};
+
+const syncLib = async (cb) => {
+  const os = getOS();
+  let irisStandAlone = getIrisStandAlone();
+  await downloadSDK({
+    preHook: () => {
+      cleanDir(destIrisSDKDir);
+    },
+    postHook: () => {
+      if (irisStandAlone) {
+        cleanDir(destNativeSDKDir);
+      }
+    },
+    sdkURL: os === 'mac' ? iris_sdk_mac : iris_sdk_win,
+    destDir: destIrisSDKDir,
+  });
+  if (irisStandAlone) {
+    await downloadSDK({
+      preHook: () => {
+        cleanDir(destNativeSDKDir);
+      },
+      strip: 0,
+      sdkURL: os === 'mac' ? native_sdk_mac : native_sdk_win,
+      destDir: destNativeSDKDir,
+    });
+  } else {
+    moveFile(path.join(destIrisSDKDir, `../iris/DCG`), destNativeSDKDir);
+  }
+
+  cb();
+};
+
+module.exports = syncLib;

package/scripts/util.js

@@ -0,0 +1,47 @@
+const os = require('os');
+
+const fs = require('fs-extra');
+
+const getConfig = require('./getConfig');
+const logger = require('./logger');
+
+exports.getOS = () => {
+  const { platform } = getConfig();
+  if (platform === 'darwin') {
+    return 'mac';
+  } else if (platform === 'win32') {
+    return 'win32';
+  } else {
+    return 'linux';
+  }
+};
+
+exports.createTmpDir = async () => await fs.mkdtemp(`${os.tmpdir()}_AgoraTmp`);
+
+exports.moveFile = (sp, tp) => {
+  logger.info(`move file from ${sp} to ${tp}`);
+  fs.rename(sp, tp, function (err) {
+    if (err) {
+      throw err;
+    }
+  });
+};
+
+exports.getIrisStandAlone = () => {
+  const { iris_sdk_mac, iris_sdk_win } = getConfig();
+  const os = this.getOS();
+  if (
+    (os === 'mac' &&
+      iris_sdk_mac &&
+      iris_sdk_mac.toLowerCase().indexOf('standalone') !== -1) ||
+    (os === 'win32' &&
+      iris_sdk_win &&
+      iris_sdk_win.toLowerCase().indexOf('standalone') !== -1)
+  ) {
+    logger.info('iris use standalone package');
+    return true;
+  } else {
+    logger.info('iris use non-standalone package');
+    return false;
+  }
+};

package/scripts/zipBuild.js

@@ -0,0 +1,40 @@
+const fs = require('fs');
+const path = require('path');
+
+const { exec } = require('shelljs');
+
+const logger = require('./logger');
+const { getOS } = require('./util');
+
+const keepList = ['AgoraRtcWrapper', 'agora_node_ext'];
+
+const filesMove = (src, dest, keepList) => {
+  fs.readdirSync(src).forEach((file) => {
+    const filePath = path.join(src, file);
+    const shouldKeep = keepList.some((pattern) => file.includes(pattern));
+    if (!shouldKeep) {
+      const destPath = path.join(dest, file);
+      fs.renameSync(filePath, destPath);
+    }
+  });
+};
+
+const zipBuild = async () => {
+  const temp_native = path.join(__dirname, '..', 'build', 'temp_native');
+  const build_release = path.join(__dirname, '..', 'build', 'Release');
+  fs.mkdirSync(temp_native);
+  filesMove(build_release, temp_native, keepList);
+
+  const isMac = getOS() === 'mac';
+  const fileListStr = ` build${path.sep}Release js types package.json`;
+  const shellStr =
+    (isMac ? 'zip -ry electron.zip' : '7z a electron.zip') + fileListStr;
+  const { code, stderr } = await exec(shellStr);
+  if (code !== 0) {
+    logger.error(stderr);
+  }
+  filesMove(temp_native, build_release, []);
+  fs.rmdirSync(temp_native, { recursive: true });
+};
+
+module.exports = zipBuild;

package/ts/AgoraSdk.ts

@@ -0,0 +1,44 @@
+import { IMediaPlayerCacheManager } from './Private/IAgoraMediaPlayer';
+import { IRtcEngineEx } from './Private/IAgoraRtcEngineEx';
+import { RtcEngineExInternal } from './Private/internal/RtcEngineExInternal';
+import { AgoraEnvOptions } from './Types';
+import { AgoraEnv } from './Utils';
+
+export * from './Private/AgoraBase';
+export * from './Private/AgoraMediaBase';
+export * from './Private/AgoraMediaPlayerTypes';
+export * from './Private/IAgoraLog';
+export * from './Private/IAgoraMediaEngine';
+export * from './Private/IAgoraMediaPlayer';
+export * from './Private/IAgoraMediaPlayerSource';
+export * from './Private/IAgoraMediaRecorder';
+export * from './Private/IAgoraMusicContentCenter';
+export * from './Private/IAgoraRhythmPlayer';
+export * from './Private/IAgoraRtcEngine';
+export * from './Private/IAgoraRtcEngineEx';
+export * from './Private/IAgoraSpatialAudio';
+export * from './Private/IAudioDeviceManager';
+export * from './Renderer';
+export * from './Types';
+export * from './Utils';
+
+const instance = new RtcEngineExInternal();
+
+/**
+ * @ignore
+ */
+export function createAgoraRtcEngine(options?: AgoraEnvOptions): IRtcEngineEx {
+  Object.assign(AgoraEnv, options);
+  return instance;
+}
+
+/**
+ * @ignore
+ */
+export function getMediaPlayerCacheManager(): IMediaPlayerCacheManager {
+  return new IMediaPlayerCacheManagerImpl();
+}
+
+export default createAgoraRtcEngine;
+
+import { IMediaPlayerCacheManagerImpl } from './Private/impl/IAgoraMediaPlayerImpl';

package/ts/Decoder/gpu-utils.ts

@@ -0,0 +1,92 @@
+//@ts-ignore
+import { BrowserWindow } from 'electron';
+
+/**
+ * @ignore
+ */
+
+export type VideoDecodeAcceleratorSupportedProfile = {
+  codec: string;
+  minWidth: number;
+  maxWidth: number;
+  minHeight: number;
+  maxHeight: number;
+};
+
+/**
+ * @ignore
+ */
+export class GpuInfo {
+  videoDecodeAcceleratorSupportedProfile: VideoDecodeAcceleratorSupportedProfile[] =
+    [];
+}
+
+/**
+ * @ignore
+ */
+export const getGpuInfoInternal = (callback: any): void => {
+  //@ts-ignore
+  if (process.type === 'renderer') {
+    console.error('getGpuInfoInternal should be called in main process');
+    return;
+  }
+  const gpuPage = new BrowserWindow({
+    show: false,
+    webPreferences: { offscreen: true },
+  });
+  gpuPage.loadURL('chrome://gpu');
+  let executeJavaScriptText =
+    `` +
+    `let videoAccelerationInfo = [];` +
+    `let nodeList = document.querySelector('info-view')?.shadowRoot?.querySelector('#video-acceleration-info info-view-table')?.shadowRoot?.querySelectorAll('#info-view-table info-view-table-row') || [];` +
+    `for (node of nodeList) {` +
+    `  videoAccelerationInfo.push({` +
+    `     title: node.shadowRoot.querySelector('#title')?.innerText,` +
+    `     value: node.shadowRoot.querySelector('#value')?.innerText,` +
+    ` })` +
+    `}` +
+    `JSON.stringify(videoAccelerationInfo)`;
+  gpuPage.webContents
+    .executeJavaScript(executeJavaScriptText)
+    .then((result: string) => {
+      if (!result) {
+        console.error(
+          'Failed to get GPU info, chrome://gpu is not available in this environment.'
+        );
+      }
+      let filterResult: { title: string; value: string }[] = JSON.parse(
+        result
+      ).filter((item: any) => {
+        return item.title.indexOf('Decode') !== -1;
+      });
+      let convertResult: VideoDecodeAcceleratorSupportedProfile[] = [];
+      const resolutionPattern = /(\d+)x(\d+) to (\d+)x(\d+)/;
+      for (const profile of filterResult) {
+        const match = profile.value.match(resolutionPattern);
+        if (!match) {
+          continue;
+        }
+
+        const [_resolution, minWidth, minHeight, maxWidth, maxHeight] = match;
+
+        convertResult.push({
+          codec: profile.title,
+          minWidth: minWidth ? Number(minWidth) : 0,
+          maxWidth: maxWidth ? Number(maxWidth) : 0,
+          minHeight: minHeight ? Number(minHeight) : 0,
+          maxHeight: maxHeight ? Number(maxHeight) : 0,
+        });
+      }
+      typeof callback === 'function' && callback(convertResult);
+    })
+    .catch((error: any) => {
+      console.error(
+        'Failed to get GPU info, please import agora-electron-sdk in main process',
+        error
+      );
+      typeof callback === 'function' && callback(error);
+    })
+    .finally(() => {
+      gpuPage.close();
+    });
+};