@24i/smartapps-bigscreen-rnv-build-engine 0.0.2-alpha.1321 → 0.0.2-alpha.1323

package/engine/src/scripts/utils/gitUtils.js

@@ -0,0 +1,94 @@
+const { ok } = require('assert').strict;
+const { cmdSyncTrimOut, cmdSyncInheritOut, cmdSyncPipeOut } = require('./cmdUtils');
+const { splitByNewLine } = require('./stringUtils');
+
+const statusList = () => {
+    const gitCmd = 'git status --porcelain';
+    const outputString = cmdSyncTrimOut(gitCmd);
+
+    if (!outputString) return [];
+    const handleMultipleWhitespaces = (rowString) => {
+        const spaceChar = ' ';
+        const parts = rowString.split(spaceChar);
+        return parts.filter(Boolean).join(spaceChar);
+    };
+
+    return splitByNewLine(outputString).map(handleMultipleWhitespaces);
+};
+
+const getCurrentBranchName = () => cmdSyncTrimOut('git branch --show-current');
+
+// only for GitHub
+const pullRequest = (fromBranch, toBranch, prTitle) => {
+    const cmdTool = 'hub';
+    const installDocUrl = 'https://github.com/github/hub#installation';
+    const errorMsg = `${cmdTool} is not installed! See ${installDocUrl}\n`;
+
+    try {
+        const toolPath = cmdSyncTrimOut(`${cmdTool} --version`);
+        ok(toolPath, errorMsg);
+    } catch (error) {
+        throw new Error(errorMsg);
+    }
+
+    cmdSyncInheritOut(`${cmdTool} pull-request -m "${prTitle}" --head ${fromBranch} --base ${toBranch}`);
+};
+
+const remoteBranchExists = (expectedBranchName) => {
+    const gitCmd = `git ls-remote --heads origin ${expectedBranchName}`;
+    const output = cmdSyncTrimOut(gitCmd);
+    return Boolean(output);
+};
+
+const pull = () => cmdSyncPipeOut('git remote update -p && git merge --ff-only @{u}');
+
+const addAll = () => cmdSyncPipeOut('git add --all');
+
+const add = (fileList) => cmdSyncPipeOut(`git add ${fileList.join(' ')}`);
+
+const checkout = (branchName) => cmdSyncPipeOut(`git checkout ${branchName}`);
+
+const createBranch = (branchName) => cmdSyncPipeOut(`git branch ${branchName}`);
+
+const commit = (commitMessage, noVerify) => {
+    const maybeNoVerifyParam = noVerify ? '--no-verify' : '';
+    return cmdSyncPipeOut(`git commit -m "${commitMessage}" ${maybeNoVerifyParam}`.trimEnd());
+}
+
+const push = (branchName, noVerify) => {
+    const maybeNoVerifyParam = noVerify ? '--no-verify' : '';
+    return cmdSyncPipeOut(`git push --set-upstream origin ${branchName} ${maybeNoVerifyParam}`.trimEnd());
+}
+
+const assertEmptyStatusList = () => {
+    ok(statusList().length === 0, 'An empty GIT stage is expected!');
+};
+
+const assertCurrentBranch = (expectedBranchName) => {
+    const currentGitBranchName = getCurrentBranchName();
+    const errorMsg = `The ${expectedBranchName} branch is expected to be active, not "${currentGitBranchName}"`;
+    ok(currentGitBranchName === expectedBranchName, errorMsg);
+};
+
+const assertRemoteBranch = (expectedBranchName) => {
+    const errorMsg = `Remote branch ${expectedBranchName} does not exist!`;
+    ok(remoteBranchExists(expectedBranchName), errorMsg);
+};
+
+module.exports = {
+    statusList,
+    getCurrentBranchName,
+    pullRequest, // only for GitHub
+    remoteBranchExists,
+    pull,
+    addAll,
+    add,
+    checkout,
+    createBranch,
+    commit,
+    push,
+    // asserts
+    assertEmptyStatusList,
+    assertCurrentBranch,
+    assertRemoteBranch,
+};

package/engine/src/scripts/utils/index.js

@@ -0,0 +1,11 @@
+const cmdUtils = require('./cmdUtils');
+const fsUtils = require('./fsUtils');
+const gitUtils = require('./gitUtils');
+const stringUtils = require('./stringUtils');
+
+module.exports = {
+    cmdUtils,
+    fsUtils,
+    gitUtils,
+    stringUtils,
+};

package/engine/src/scripts/utils/stringUtils.js

@@ -0,0 +1,5 @@
+const splitByNewLine = (string = '') => string.split(/\r?\n/);
+
+module.exports = {
+    splitByNewLine,
+};

package/engine/src/sdks/index.js

@@ -0,0 +1,22 @@
+import { enginePlatforms } from '../enginePlatforms';
+import * as SDKWebos from './sdk-webos';
+import * as SDKTizen from './sdk-tizen';
+import * as SDKWebpack from './sdk-webpack';
+
+const handlePlatformSdk = async (c) => {
+    switch (c.platform) {
+        case enginePlatforms.TIZEN:
+            await SDKTizen.handleTizenSdk(c);
+            break;
+        case enginePlatforms.WEBOS:
+            await SDKWebos.handleWebosSdk(c);
+            break;
+    }
+}
+
+export {
+    SDKWebos,
+    SDKTizen,
+    SDKWebpack,
+    handlePlatformSdk,
+};

package/engine/src/sdks/sdk-tizen/index.js

@@ -0,0 +1,287 @@
+import path from 'path';
+import semver from 'semver';
+import os from 'os';
+import fs from 'fs';
+const { spawnSync, execSync } = require('child_process');
+const { installSdk, registerSdkPath } = require('../sdkUtils');
+const { checkAndConfigureTizenSdks } = require('rnv/dist/core/sdkManager/installer');
+import { Exec, WebpackUtils, FileUtils, Common, Logger, Constants, SDKManager, PlatformManager, ProjectManager } from 'rnv';
+
+const { execCLI } = Exec;
+const { CLI_TIZEN, REMOTE_DEBUGGER_ENABLED_PLATFORMS } = Constants;
+const {
+    getPlatformProjectDir,
+    getAppVersion,
+    getConfigProp,
+    checkPortInUse,
+    confirmActiveBundler,
+    addSystemInjects
+} = Common;
+const {
+    chalk,
+    logTask,
+    logDebug,
+    logError,
+    logSuccess,
+    logWarning,
+    logInfo
+} = Logger;
+const { isPlatformActive } = PlatformManager;
+const { writeCleanFile, fsExistsSync } = FileUtils;
+const { buildCoreWebpackProject, runWebpackServer, configureCoreWebProject, waitForWebpack } = WebpackUtils;
+const { copyAssetsFolder, copyBuildsFolder } = ProjectManager;
+
+const {
+    runTizenSimOrDevice, createDevelopTizenCertificate,
+    DEFAULT_CERTIFICATE_NAME, DEFAULT_SECURITY_PROFILE_NAME
+} = SDKManager.Tizen;
+
+const DEFAULT_CERTIFICATE_NAME_WITH_EXTENSION = `${DEFAULT_CERTIFICATE_NAME}.p12`;
+
+export const configureTizenGlobal = c => new Promise((resolve, reject) => {
+    logTask('configureTizenGlobal');
+    // Check Tizen Cert
+    const tizenAuthorCert = path.join(c.paths.workspace.dir, DEFAULT_CERTIFICATE_NAME_WITH_EXTENSION);
+    if (fsExistsSync(tizenAuthorCert)) {
+        logDebug(`${DEFAULT_CERTIFICATE_NAME_WITH_EXTENSION} file exists!`);
+        resolve();
+    } else {
+        logWarning(
+            `${DEFAULT_CERTIFICATE_NAME_WITH_EXTENSION} file missing! Creating one for you...`
+        );
+        createDevelopTizenCertificate(c)
+            .then(() => resolve())
+            .catch(e => reject(e));
+    }
+});
+
+const _runTizenSimOrDevice = async (c) => {
+    try {
+        await runTizenSimOrDevice(c);
+    } catch (e) {
+        // TODO: Capture different errors and react accordingly
+        return Promise.reject(e);
+    }
+    return true;
+};
+
+export const runTizen = async (c, target) => {
+    logTask('runTizen', `target:${target}`);
+    const { platform } = c;
+    const { hosted } = c.program;
+
+    const isHosted = hosted && !getConfigProp(c, platform, 'bundleAssets');
+
+    if (isHosted) {
+        const isPortActive = await checkPortInUse(c, platform, c.runtime.port);
+        if (isPortActive) {
+            const resetCompleted = await confirmActiveBundler(c);
+            c.runtime.skipActiveServerCheck = !resetCompleted;
+        }
+    }
+
+    logTask('runTizen', `target:${target} hosted:${!!isHosted}`);
+    if (isHosted) return;
+
+    const bundleAssets = getConfigProp(c, platform, 'bundleAssets') === true;
+
+    if (bundleAssets) {
+        await buildCoreWebpackProject(c);
+        await _runTizenSimOrDevice(c);
+    } else {
+        const isPortActive = await checkPortInUse(c, platform, c.runtime.port);
+        const isWeinreEnabled = REMOTE_DEBUGGER_ENABLED_PLATFORMS.includes(platform) && !bundleAssets && !hosted;
+
+        if (!isPortActive) {
+            logInfo(
+                `Your ${chalk().white(
+                    platform
+                )} devServer at port ${chalk().white(
+                    c.runtime.port
+                )} is not running. Starting it up for you...`
+            );
+            waitForWebpack(c)
+                .then(() => _runTizenSimOrDevice(c))
+                .catch(logError);
+            await runWebpackServer(c, isWeinreEnabled);
+        } else {
+            const resetCompleted = await confirmActiveBundler(c);
+
+            if (resetCompleted) {
+                waitForWebpack(c)
+                    .then(() => _runTizenSimOrDevice(c))
+                    .catch(logError);
+                await runWebpackServer(c, isWeinreEnabled);
+            } else {
+                await _runTizenSimOrDevice(c);
+            }
+        }
+    }
+};
+
+export const buildTizenProject = async (c) => {
+    logTask('buildTizenProject');
+
+    await buildCoreWebpackProject(c);
+    if (!c.program.hosted) {
+        const { buildConfig, platform } = c;
+        const platformConfig = buildConfig.platforms[platform];
+        const projectDir = getPlatformProjectDir(c);
+        const projectParentDir = path.join(projectDir, '..');
+
+        const tBuild = path.join(projectParentDir, 'build');
+        const tOut = path.join(projectParentDir, 'output');
+        const certProfile = platformConfig.certificateProfile ?? DEFAULT_SECURITY_PROFILE_NAME;
+
+        await execCLI(c, CLI_TIZEN, `build-web -- ${projectDir} -out ${tBuild}`);
+        await execCLI(
+            c,
+            CLI_TIZEN,
+            `package -- ${tBuild} -s ${certProfile} -t wgt -o ${tOut}`
+        );
+
+        logSuccess(`Your WGT package is located in ${chalk().cyan(tOut)} .`);
+    }
+
+    return true;
+};
+
+let _isGlobalConfigured = false;
+
+export const configureTizenProject = async (c) => {
+    logTask('configureTizenProject');
+    const { platform } = c;
+
+    c.runtime.platformBuildsProjectPath = `${getPlatformProjectDir(c)}`;
+
+    if (!isPlatformActive(c, platform)) {
+        return;
+    }
+
+    if (!_isGlobalConfigured) {
+        _isGlobalConfigured = true;
+        await configureTizenGlobal(c);
+    }
+
+    await copyAssetsFolder(c, platform);
+    await configureCoreWebProject(c);
+    await _configureProject(c);
+    return copyBuildsFolder(c, platform);
+};
+
+const _configureProject = c => new Promise((resolve) => {
+    logTask('_configureProject');
+    const { platform } = c;
+
+    const configFile = 'config.xml';
+    const p = c.buildConfig.platforms[platform];
+
+    const injects = [
+        { pattern: '{{PACKAGE}}', override: p.package },
+        { pattern: '{{ID}}', override: p.id },
+        { pattern: '{{APP_NAME}}', override: p.appName },
+        { pattern: '{{APP_VERSION}}', override: semver.coerce(getAppVersion(c, platform)) }
+    ];
+
+    addSystemInjects(c, injects);
+
+    const file = path.join(getPlatformProjectDir(c), configFile);
+    writeCleanFile(file, file, injects, null, c);
+
+    resolve();
+});
+
+const handleLinuxKeyring = () => {
+    if (process.env.CI && os.platform() === 'linux') {
+        const options = { stdio: 'inherit' };
+
+        execSync('eval $(dbus-launch --sh-syntax)', options);
+        execSync('mkdir -p ~/.cache', options);
+        execSync('mkdir -p ~/.local/share/keyrings', options);
+        execSync('eval "$(printf \'\\n\' | gnome-keyring-daemon --unlock)"', options);
+        execSync('eval "$(printf \'\\n\' | /usr/bin/gnome-keyring-daemon --start)"', options);
+    }
+};
+
+const setTizenCertificate = (c) => {
+    const {
+        TIZEN_SECURITY_PROFILE_NAME = '24i-SmartApps-BigScreen',
+        TIZEN_AUTHOR_CERTIFICATE_RELATIVE_PATH = 'certificates/24i_smartapps_bigscreen_author.p12',
+        TIZEN_AUTHOR_CERTIFICATE_PASSWORD,
+    } = process.env;
+    const tizenCliPath = c.cli.tizen;
+
+    if (!fs.existsSync(TIZEN_AUTHOR_CERTIFICATE_RELATIVE_PATH)) {
+        console.log(`'process.env.TIZEN_AUTHOR_CERTIFICATE_RELATIVE_PATH' points to not existing location: ${TIZEN_AUTHOR_CERTIFICATE_RELATIVE_PATH}`);
+        return false;
+    }
+
+    if (!TIZEN_AUTHOR_CERTIFICATE_PASSWORD) {
+        console.log(`'process.env.TIZEN_AUTHOR_CERTIFICATE_PASSWORD' password is not set`);
+        return false;
+    }
+
+    if (!tizenCliPath) {
+        console.log(`'c.cli.tizen' is not set`);
+        return false;
+    }
+
+    const spawnSyncReturn = spawnSync(tizenCliPath, [
+        'security-profiles', 'add',
+        '-n', TIZEN_SECURITY_PROFILE_NAME,
+        '-a', TIZEN_AUTHOR_CERTIFICATE_RELATIVE_PATH,
+        '-p', TIZEN_AUTHOR_CERTIFICATE_PASSWORD,
+    ]);
+
+    if (spawnSyncReturn.error) throw spawnSyncReturn.error;
+    if (spawnSyncReturn.stdout.toString().includes('Invalid file or password')) {
+        throw spawnSyncReturn.stdout.toString();
+    }
+
+    process.stdout.write(spawnSyncReturn.stdout || '');
+
+    const rnvWorkspaceConfigPath = c.paths.workspace.config;
+    const customObjectToMerge = {
+        platforms: {
+            tizen: { certificateProfile: TIZEN_SECURITY_PROFILE_NAME },
+        },
+    };
+    FileUtils.updateObjectSync(rnvWorkspaceConfigPath, customObjectToMerge);
+    Object.assign(c.buildConfig, customObjectToMerge);
+
+    return true;
+};
+
+const getSdkInstallerUrl = () => {
+    switch (os.platform()) {
+        case 'darwin':
+            return 'https://s3.amazonaws.com/tools.nxg-bigscreen.24imedia.com/sdks/tizen/tizen_builder_v3.7_mac.zip';
+        case 'linux':
+            return 'https://s3.amazonaws.com/tools.nxg-bigscreen.24imedia.com/sdks/tizen/tizen_builder_v3.7_ubuntu.zip';
+        default:
+            return '';
+    }
+}
+
+export const handleTizenSdk = async (c) => {
+    const { TIZEN_SDK_INSTALLER_URL = getSdkInstallerUrl() } = process.env;
+    const { TIZEN_SDK } = c.buildConfig?.sdks || {};
+    const installPath = `${os.homedir()}/tizen-studio`;
+    const rnvSdkKey = 'TIZEN_SDK'
+
+    if (!TIZEN_SDK) {
+        handleLinuxKeyring(); // needed to work with Tizen certificate passwords
+
+        if (fs.existsSync(installPath)) {
+            await registerSdkPath(c, rnvSdkKey, installPath);
+        } else {
+            const sdkInstalledToPath = await installSdk(TIZEN_SDK_INSTALLER_URL, installPath);
+            if (sdkInstalledToPath) {
+                await registerSdkPath(c, rnvSdkKey, sdkInstalledToPath);
+            }
+        }
+    }
+
+    await checkAndConfigureTizenSdks(c);
+    setTizenCertificate(c);
+}

package/engine/src/sdks/sdk-webos/index.js

@@ -0,0 +1,201 @@
+import fs from 'fs';
+import path from 'path';
+import semver from 'semver';
+const { homedir } = require('os');
+const { installSdk, registerSdkPath } = require('../sdkUtils');
+const { checkAndConfigureWebosSdks } = require('rnv/dist/core/sdkManager/installer');
+import { Exec, WebpackUtils, FileUtils, Common, Logger, Constants, PlatformManager, ProjectManager, SDKManager } from 'rnv';
+
+const { writeCleanFile } = FileUtils;
+const { execCLI } = Exec;
+const {
+    getPlatformProjectDir,
+    getTemplateProjectDir,
+    getPlatformBuildDir,
+    getAppVersion,
+    getAppTitle,
+    getAppId,
+    getAppDescription,
+    getConfigProp,
+    checkPortInUse,
+    confirmActiveBundler,
+    addSystemInjects
+} = Common;
+const { buildCoreWebpackProject, runWebpackServer, configureCoreWebProject, waitForWebpack } = WebpackUtils;
+
+const { isPlatformActive } = PlatformManager;
+const {
+    chalk,
+    logTask,
+    logInfo,
+    logSuccess,
+    logError
+} = Logger;
+const {
+    copyBuildsFolder,
+    copyAssetsFolder
+} = ProjectManager;
+const {
+    CLI_WEBOS_ARES_PACKAGE,
+    REMOTE_DEBUGGER_ENABLED_PLATFORMS
+} = Constants;
+const { runWebosSimOrDevice } = SDKManager.Webos;
+
+
+export const runWebOS = async (c) => {
+    const { hosted } = c.program;
+    const { target } = c.runtime;
+    const { platform } = c;
+
+
+    const isHosted = hosted && !getConfigProp(c, platform, 'bundleAssets');
+
+    if (isHosted) {
+        const isPortActive = await checkPortInUse(c, platform, c.runtime.port);
+        if (isPortActive) {
+            const resetCompleted = await confirmActiveBundler(c);
+            c.runtime.skipActiveServerCheck = !resetCompleted;
+        }
+    }
+
+    logTask('runWebOS', `target:${target} hosted:${!!isHosted}`);
+    if (isHosted) return;
+
+    const bundleAssets = getConfigProp(c, platform, 'bundleAssets') === true;
+
+    if (bundleAssets) {
+        await buildCoreWebpackProject(c);
+        await runWebosSimOrDevice(c);
+    } else {
+        const isPortActive = await checkPortInUse(c, platform, c.runtime.port);
+        const isWeinreEnabled = REMOTE_DEBUGGER_ENABLED_PLATFORMS.includes(platform) && !bundleAssets && !hosted;
+
+        if (!isPortActive) {
+            logInfo(
+                `Your ${chalk().white(
+                    platform
+                )} devServer at port ${chalk().white(
+                    c.runtime.port
+                )} is not running. Starting it up for you...`
+            );
+            waitForWebpack(c)
+                .then(() => runWebosSimOrDevice(c))
+                .catch(logError);
+            await runWebpackServer(c, isWeinreEnabled);
+        } else {
+            const resetCompleted = await confirmActiveBundler(c);
+            if (resetCompleted) {
+                waitForWebpack(c)
+                    .then(() => runWebosSimOrDevice(c))
+                    .catch(logError);
+                await runWebpackServer(c, isWeinreEnabled);
+            } else {
+                await runWebosSimOrDevice(c);
+            }
+        }
+    }
+};
+
+export const buildWebOSProject = async (c) => {
+    logTask('buildWebOSProject');
+
+    await buildCoreWebpackProject(c);
+
+    if (!c.program.hosted) {
+        const tDir = getPlatformProjectDir(c);
+        const tOut = path.join(getPlatformBuildDir(c), 'output');
+        await execCLI(c, CLI_WEBOS_ARES_PACKAGE, `-o ${tOut} ${tDir} -n`);
+
+        logSuccess(
+            `Your IPK package is located in ${chalk().cyan(tOut)} .`
+        );
+    }
+};
+
+export const configureWebOSProject = async (c) => {
+    logTask('configureWebOSProject');
+
+    const { platform } = c;
+
+    c.runtime.platformBuildsProjectPath = getPlatformProjectDir(c);
+
+    if (!isPlatformActive(c, platform)) return;
+
+    await copyAssetsFolder(c, platform);
+    await configureCoreWebProject(c);
+    await _configureProject(c);
+    return copyBuildsFolder(c, platform);
+};
+
+const _configureProject = async (c) => {
+    logTask('_configureProject');
+    const { platform } = c;
+
+    const configFile = 'appinfo.json';
+
+    const injects = [
+        {
+            pattern: '{{APPLICATION_ID}}',
+            override: getAppId(c, platform).toLowerCase()
+        },
+        {
+            pattern: '{{APP_TITLE}}',
+            override: getAppTitle(c, platform)
+        },
+        {
+            pattern: '{{APP_VERSION}}',
+            override: semver.coerce(getAppVersion(c, platform))
+        },
+        {
+            pattern: '{{APP_DESCRIPTION}}',
+            override: getAppDescription(c, platform)
+        },
+        {
+            pattern: '{{APP_BG_COLOR}}',
+            override: getConfigProp(c, platform, 'bgColor', '#fff')
+        },
+        {
+            pattern: '{{APP_ICON_COLOR}}',
+            override: getConfigProp(c, platform, 'iconColor', '#000')
+        },
+        {
+            pattern: '{{APP_VENDOR}}',
+            override: getConfigProp(c, platform, 'vendor', '24i')
+        }
+    ];
+
+    addSystemInjects(c, injects);
+
+    writeCleanFile(
+        path.join(getTemplateProjectDir(c), configFile),
+        path.join(getPlatformProjectDir(c), configFile),
+        injects, null, c
+    );
+
+    return true;
+};
+
+const getSdkInstallerUrl = () => {
+    return 'https://s3.amazonaws.com/tools.nxg-bigscreen.24imedia.com/sdks/webos/ares_webos_builder_v1.10.4_multiplatform.zip';
+}
+
+export const handleWebosSdk = async (c) => {
+    const { WEBOS_SDK_INSTALLER_URL = getSdkInstallerUrl() } = process.env;
+    const { WEBOS_SDK } = c.buildConfig?.sdks || {};
+    const installPath = `${homedir()}/webOS_TV_SDK`;
+    const rnvSdkKey = 'WEBOS_SDK'
+
+
+    if (!WEBOS_SDK) {
+        if (fs.existsSync(installPath)) {
+            await registerSdkPath(c, rnvSdkKey, installPath);
+        }
+
+        const sdkInstalledToPath = await installSdk(WEBOS_SDK_INSTALLER_URL, installPath);
+        if (sdkInstalledToPath) {
+            await registerSdkPath(c, rnvSdkKey, sdkInstalledToPath);
+        }
+    }
+
+    await checkAndConfigureWebosSdks(c);
+};

package/engine/src/sdks/sdk-webpack/index.js

@@ -0,0 +1,45 @@
+
+import { WebpackUtils, Common, Logger, PlatformManager, ProjectManager } from 'rnv';
+
+const { getPlatformProjectDir } = Common;
+const { isPlatformActive } = PlatformManager;
+const { logTask } = Logger;
+const { copyBuildsFolder, copyAssetsFolder } = ProjectManager;
+
+const { buildCoreWebpackProject, configureCoreWebProject } = WebpackUtils;
+
+export const buildWeb = async c => buildCoreWebpackProject(c);
+
+export const configureWebProject = async (c) => {
+    logTask('configureWebProject');
+
+    const { platform } = c;
+
+    c.runtime.platformBuildsProjectPath = getPlatformProjectDir(c);
+
+    if (!isPlatformActive(c, platform)) return;
+
+    await copyAssetsFolder(c, platform);
+    await configureCoreWebProject(c);
+
+    return copyBuildsFolder(c, platform);
+};
+
+export const deployWeb = () => {
+    logTask('deployWeb');
+    // const { platform } = c;
+
+    // DEPRECATED: custom deployers moved to external packages
+    // return selectWebToolAndDeploy(c, platform);
+
+    return true;
+};
+
+export const exportWeb = () => {
+    logTask('exportWeb');
+    // const { platform } = c;
+
+    // DEPRECATED: custom deployers moved to external packages
+    // return selectWebToolAndExport(c, platform);
+    return true;
+};

package/engine/src/sdks/sdkUtils.js

@@ -0,0 +1,22 @@
+const { FileUtils } = require('rnv');
+const { sdkInstaller } = require('@24i/smartapps-bigscreen-sdk-installer');
+
+const registerSdkPath = async (c, sdkKey, sdkValue) => {
+    const rnvWorkspaceConfigPath = c.paths.workspace.config;
+    const customObjectToMerge = { sdks: { [sdkKey]: sdkValue } };
+    FileUtils.updateObjectSync(rnvWorkspaceConfigPath, customObjectToMerge);
+    Object.assign(c.buildConfig, customObjectToMerge);
+};
+
+const installSdk = async (installerUrl, installPath) => {
+    return sdkInstaller({
+        zipPath: installerUrl,
+        installPath,
+        enableLogs: true,
+    });
+};
+
+export {
+    registerSdkPath,
+    installSdk
+};