@simplysm/sd-cli 12.8.18 → 12.8.21

package/src/entry/sd-cli-cordova.ts

@@ -1,13 +1,28 @@
 import * as path from "path";
 import { FsUtils, SdLogger, SdProcess } from "@simplysm/sd-core-node";
-import xml2js from "xml2js";
-import JSZip from "jszip";
 import { INpmConfig } from "../types/common-configs.types";
 import { ISdClientBuilderCordovaConfig } from "../types/config.types";
-
-// const BIN_PATH = path.resolve(process.cwd(), "node_modules/.bin/cordova.cmd");
+import { SdZip, XmlConvert } from "@simplysm/sd-core-common";
 
 export class SdCliCordova {
+  // 상수 정의
+  private readonly CORDOVA_DIR_NAME = ".cordova";
+  private readonly PLATFORMS_DIR_NAME = "platforms";
+  private readonly WWW_DIR_NAME = "www";
+
+  private readonly PLUGINS_DIR_NAME = "plugins";
+  private readonly PLUGINS_FETCH_FILE = "fetch.json";
+  private readonly ANDROID_PLATFORM_VERSION = "12.0.0";
+  private readonly ANDROID_SDK_VERSION = "33";
+  private readonly KEYSTORE_FILE_NAME = "android.keystore";
+  private readonly CONFIG_XML_FILE_NAME = "config.xml";
+  private readonly CONFIG_XML_BACKUP_FILE_NAME = "config.xml.bak";
+  private readonly BUILD_JSON_FILE_NAME = "build.json";
+  private readonly ANDROID_SIGNING_PROP_PATH = "platforms/android/release-signing.properties";
+  private readonly ICON_DIR_PATH = "res/icons";
+  private readonly SPLASH_SCREEN_DIR_PATH = "res/screen/android";
+  private readonly SPLASH_SCREEN_XML_FILE = "splashscreen.xml";
+
   private _logger = SdLogger.get(["simplysm", "sd-cli", "SdCliCordova"]);
 
   private _platforms: string[];
@@ -16,18 +31,51 @@ export class SdCliCordova {
   constructor(private readonly _opt: { pkgPath: string; config: ISdClientBuilderCordovaConfig }) {
     this._platforms = Object.keys(this._opt.config.platform ?? { browser: {} });
     this._npmConfig = FsUtils.readJson(path.resolve(this._opt.pkgPath, "package.json"));
-    // this._logger = Logger.get(["simplysm", "sd-cli", this.constructor.name, this._npmConfig.name]);
   }
 
   private async _execAsync(cmd: string, cwd: string): Promise<void> {
-    this._logger.debug(cmd);
-    const msg = await SdProcess.spawnAsync(cmd, { cwd });
-    this._logger.debug(msg);
+    try {
+      this._logger.debug(`실행 명령: ${cmd}`);
+      const msg = await SdProcess.spawnAsync(cmd, { cwd });
+      this._logger.debug(`실행 결과: ${msg}`);
+    }
+    catch (err) {
+      this._logger.error(`명령 실행 실패: ${cmd}`);
+      this._logger.error(`오류: ${err instanceof Error ? err.message : String(err)}`);
+      throw err;
+    }
   }
 
   public async initializeAsync(): Promise<void> {
-    const cordovaPath = path.resolve(this._opt.pkgPath, ".cordova");
+    const cordovaPath = path.resolve(this._opt.pkgPath, this.CORDOVA_DIR_NAME);
+
+    // 1. Cordova 프로젝트 초기화
+    await this._initializeCordovaProjectAsync(cordovaPath);
+
+    // 2. 플랫폼 관리
+    await this._managePlatformsAsync(cordovaPath);
+
+    // 3. 플러그인 관리
+    await this._managePluginsAsync(cordovaPath);
+
+    // 4. 안드로이드 서명 설정
+    this._setupAndroidSign(cordovaPath);
+
+    // 5. 빌드 설정 파일 생성
+    this._createBuildConfig(cordovaPath);
+
+    // 6. 아이콘 및 스플래시 스크린 설정
+    this._setupIconAndSplashScreen(cordovaPath);
 
+    // 7. XML 설정 구성
+    this._configureXml(cordovaPath);
+
+    // 8. 각 플랫폼 www 준비
+    await this._execAsync(`npx cordova prepare`, cordovaPath);
+  }
+
+  // 1. Cordova 프로젝트 초기화
+  private async _initializeCordovaProjectAsync(cordovaPath: string): Promise<void> {
     if (FsUtils.exists(cordovaPath)) {
       this._logger.log("이미 생성되어있는 '.cordova'를 사용합니다.");
     }
@@ -39,135 +87,173 @@ export class SdCliCordova {
         `npx cordova create "${cordovaPath}" "${this._opt.config.appId}" "${this._opt.config.appName}"`,
         process.cwd(),
       );
-
-      // volta
-      // await this._execAsync(`volta pin node@18`, cordovaPath);
-
-      // package.json 수정
-      /*const npmConfig = FsUtil.readJson(path.resolve(cordovaPath, "package.json"));
-      npmConfig.volta = {
-        node: process.version.substring(1)
-      };
-      FsUtil.writeJson(path.resolve(cordovaPath, "package.json"), npmConfig);*/
     }
 
     // platforms 폴더 혹시 없으면 생성
-    FsUtils.mkdirs(path.resolve(cordovaPath, "platforms"));
+    FsUtils.mkdirs(path.resolve(cordovaPath, this.PLATFORMS_DIR_NAME));
 
     // www 폴더 혹시 없으면 생성
-    FsUtils.mkdirs(path.resolve(cordovaPath, "www"));
+    FsUtils.mkdirs(path.resolve(cordovaPath, this.WWW_DIR_NAME));
+  }
 
-    // 미설치 빌드 플랫폼 신규 생성
-    const alreadyPlatforms = FsUtils.readdir(path.resolve(cordovaPath, "platforms"));
-    for (const platform of this._platforms) {
-      if (!alreadyPlatforms.includes(platform)) {
-        // await this._execAsync(`${BIN_PATH} platform add ${platform}`, cordovaPath);
+  // 2. 플랫폼 관리
+  private async _managePlatformsAsync(cordovaPath: string): Promise<void> {
+    const alreadyPlatforms = FsUtils.readdir(path.resolve(cordovaPath, this.PLATFORMS_DIR_NAME));
+
+    // 미설치 빌드 플랫폼 신규 생성 - 병렬 처리
+    const platformInstallPromises = this._platforms
+      .filter(platform => !alreadyPlatforms.includes(platform))
+      .map(platform => {
         if (platform === "android") {
-          await this._execAsync(`npx cordova platform add ${platform}@12.0.0`, cordovaPath);
+          return this._execAsync(
+            `npx cordova platform add ${platform}@${this.ANDROID_PLATFORM_VERSION}`,
+            cordovaPath,
+          );
         }
         else {
-          await this._execAsync(`npx cordova platform add ${platform}`, cordovaPath);
+          return this._execAsync(`npx cordova platform add ${platform}`, cordovaPath);
         }
-      }
-    }
+      });
 
-    // 설치 미빌드 플랫폼 삭제
-    /*for (const alreadyPlatform of alreadyPlatforms) {
-      if (!this._platforms.includes(alreadyPlatform)) {
-        await this._execAsync(`${BIN_PATH} platform remove ${alreadyPlatform}`, cordovaPath);
-      }
-    }*/
+    await Promise.all(platformInstallPromises);
+  }
 
-    // 설치된 미사용 플러그인 삭제
-    const pluginsFetch = FsUtils.exists(path.resolve(cordovaPath, "plugins/fetch.json"))
-      ? FsUtils.readJson(path.resolve(cordovaPath, "plugins/fetch.json"))
-      : undefined;
+  // 3. 플러그인 관리
+  private async _managePluginsAsync(cordovaPath: string): Promise<void> {
+    const pluginsFetchPath = path.resolve(
+      cordovaPath,
+      this.PLUGINS_DIR_NAME,
+      this.PLUGINS_FETCH_FILE,
+    );
+    const pluginsFetch = FsUtils.exists(pluginsFetchPath)
+      ? FsUtils.readJson(pluginsFetchPath)
+      : {};
+
+    const alreadyPlugins: Array<{
+      name: string;
+      id: string;
+      dependencies?: string[]
+    }> = Object.keys(pluginsFetch).map(key => ({
+      name: key,
+      id: pluginsFetch[key].source.id,
+      dependencies: pluginsFetch[key].dependencies,
+    }));
 
-    const alreadyPlugins: { name: string; id: string }[] = [];
+    const usePlugins = (this._opt.config.plugins ?? []).distinct();
 
-    if (pluginsFetch != null) {
-      for (const key of Object.keys(pluginsFetch)) {
-        alreadyPlugins.push({
-          name: key,
-          id: pluginsFetch[key].source.id,
-        });
-      }
-    }
+    // 사용하지 않는 플러그인 제거 및 새 플러그인 설치 - 의존성 때문에 순차 처리
+    await this._removeUnusedPluginsAsync(cordovaPath, alreadyPlugins, usePlugins);
+    await this._installNewPluginsAsync(cordovaPath, alreadyPlugins, usePlugins);
+  }
 
-    const usePlugins = (this._opt.config.plugins ?? []).distinct();
+  private async _removeUnusedPluginsAsync(
+    cordovaPath: string,
+    alreadyPlugins: Array<{ name: string; id: string; dependencies?: string[] }>,
+    usePlugins: string[],
+  ): Promise<void> {
+    for (const alreadyPlugin of alreadyPlugins) {
+      // 사용하지 않는 플러그인 제거 시 의존성 검사
+      const isPluginUsed = usePlugins.some(
+        usePlugin => usePlugin === alreadyPlugin.id || usePlugin === alreadyPlugin.name,
+      );
 
-    // TODO: Dependency에 의해 설치된 플러그인 삭제되면 안됨 android.json의 installed_plugin으로 변경하면 될지도?
-    /*for (const alreadyPlugin of alreadyPlugins) {
-      let hasPlugin = false;
-      for (const usePlugin of usePlugins) {
-        if (alreadyPlugin.name === usePlugin || alreadyPlugin.id === usePlugin) {
-          hasPlugin = true;
-          break;
-        }
-      }
+      if (!isPluginUsed) {
+        const isDependencyExists = alreadyPlugins.some(
+          plugin => plugin.dependencies?.includes(alreadyPlugin.name),
+        );
 
-      if (!hasPlugin) {
-        await this._execAsync(`${BIN_PATH} plugin remove ${alreadyPlugin.name}`, cordovaPath);
+        if (!isDependencyExists) {
+          await this._execAsync(`npx cordova plugin remove ${alreadyPlugin.name}`, cordovaPath);
+        }
       }
-    }*/
+    }
+  }
 
-    // 미설치 플러그인들 설치
+  private async _installNewPluginsAsync(
+    cordovaPath: string,
+    alreadyPlugins: Array<{ name: string; id: string; dependencies?: string[] }>,
+    usePlugins: string[],
+  ): Promise<void> {
+    // 병렬로 플러그인을 설치하면 충돌이 발생할 수 있으므로 순차 처리
     for (const usePlugin of usePlugins) {
-      if (!alreadyPlugins.some((item) => usePlugin === item.id || usePlugin === item.name)) {
+      const isPluginAlreadyInstalled = alreadyPlugins.some(
+        plugin => usePlugin === plugin.id || usePlugin === plugin.name,
+      );
+
+      if (!isPluginAlreadyInstalled) {
         await this._execAsync(`npx cordova plugin add ${usePlugin}`, cordovaPath);
       }
     }
+  }
+
+  // 4. 안드로이드 서명 설정
+  private _setupAndroidSign(cordovaPath: string): void {
+    const keystorePath = path.resolve(cordovaPath, this.KEYSTORE_FILE_NAME);
+    const signingPropsPath = path.resolve(cordovaPath, this.ANDROID_SIGNING_PROP_PATH);
 
-    // ANDROID SIGN 파일 복사
     if (this._opt.config.platform?.android?.sign) {
       FsUtils.copy(
         path.resolve(this._opt.pkgPath, this._opt.config.platform.android.sign.keystore),
-        path.resolve(cordovaPath, "android.keystore"),
+        keystorePath,
       );
     }
     else {
-      FsUtils.remove(path.resolve(cordovaPath, "android.keystore"));
+      FsUtils.remove(keystorePath);
       // SIGN을 안쓸경우 아래 파일이 생성되어 있으면 오류남
-      FsUtils.remove(path.resolve(cordovaPath, "platforms/android/release-signing.properties"));
+      FsUtils.remove(signingPropsPath);
     }
+  }
 
-    // 빌드 옵션 파일 생성
-    FsUtils.writeJson(path.resolve(cordovaPath, "build.json"), {
-      ...(this._opt.config.platform?.android
-        ? {
-          android: {
-            release: {
-              packageType: this._opt.config.platform.android.bundle ? "bundle" : "apk",
-              ...(this._opt.config.platform.android.sign
-                ? {
-                  keystore: path.resolve(cordovaPath, "android.keystore"),
-                  storePassword: this._opt.config.platform.android.sign.storePassword,
-                  alias: this._opt.config.platform.android.sign.alias,
-                  password: this._opt.config.platform.android.sign.password,
-                  keystoreType: this._opt.config.platform.android.sign.keystoreType,
-                }
-                : {}),
-            },
+  // 5. 빌드 설정 파일 생성
+  private _createBuildConfig(cordovaPath: string): void {
+    const buildJsonPath = path.resolve(cordovaPath, this.BUILD_JSON_FILE_NAME);
+    const keystorePath = path.resolve(cordovaPath, this.KEYSTORE_FILE_NAME);
+
+    const androidConfig = this._opt.config.platform?.android
+      ? {
+        android: {
+          release: {
+            packageType: this._opt.config.platform.android.bundle ? "bundle" : "apk",
+            ...(this._opt.config.platform.android.sign
+              ? {
+                keystore: keystorePath,
+                storePassword: this._opt.config.platform.android.sign.storePassword,
+                alias: this._opt.config.platform.android.sign.alias,
+                password: this._opt.config.platform.android.sign.password,
+                keystoreType: this._opt.config.platform.android.sign.keystoreType,
+              }
+              : {}),
           },
-        }
-        : {}),
-    });
+        },
+      }
+      : {};
+
+    FsUtils.writeJson(buildJsonPath, androidConfig);
+  }
+
+  // 6. 아이콘 및 스플래시 스크린 설정
+  private _setupIconAndSplashScreen(cordovaPath: string): void {
+    const iconDirPath = path.resolve(cordovaPath, this.ICON_DIR_PATH);
+    const splashScreenPath = path.resolve(cordovaPath, this.SPLASH_SCREEN_DIR_PATH);
+    const splashScreenXmlPath = path.resolve(splashScreenPath, this.SPLASH_SCREEN_XML_FILE);
 
     // ICON 파일 복사
     if (this._opt.config.icon != null) {
+      FsUtils.mkdirs(iconDirPath);
       FsUtils.copy(
         path.resolve(this._opt.pkgPath, this._opt.config.icon),
-        path.resolve(cordovaPath, "res/icons", path.basename(this._opt.config.icon)),
+        path.resolve(iconDirPath, path.basename(this._opt.config.icon)),
       );
     }
     else {
-      FsUtils.remove(path.resolve(cordovaPath, "res/icons"));
+      FsUtils.remove(iconDirPath);
     }
 
     // SplashScreen 파일 생성
     if (this._opt.config.platform?.android && this._opt.config.icon != null) {
+      FsUtils.mkdirs(splashScreenPath);
       FsUtils.writeFile(
-        path.resolve(cordovaPath, "res/screen/android/splashscreen.xml"),
+        splashScreenXmlPath,
         `
 <?xml version="1.0" encoding="utf-8"?>
 <layer-list xmlns:android="http://schemas.android.com/apk/res/android">
@@ -179,240 +265,264 @@ export class SdCliCordova {
 </layer-list>`.trim(),
       );
     }
+  }
 
+  // 7. XML 설정 구성
+  private _configureXml(cordovaPath: string) {
     // CONFIG: 초기값 백업
-    const configFilePath = path.resolve(cordovaPath, "config.xml");
-    const configBackFilePath = path.resolve(cordovaPath, "config.xml.bak");
+    const configFilePath = path.resolve(cordovaPath, this.CONFIG_XML_FILE_NAME);
+    const configBackFilePath = path.resolve(cordovaPath, this.CONFIG_XML_BACKUP_FILE_NAME);
+
     if (!FsUtils.exists(configBackFilePath)) {
       FsUtils.copy(configFilePath, configBackFilePath);
     }
 
     // CONFIG: 초기값 읽기
     const configFileContent = FsUtils.readFile(configBackFilePath);
-    const configXml = await xml2js.parseStringPromise(configFileContent);
+    const configXml = XmlConvert.parse(configFileContent);
+
+    // CONFIG: 기본 설정
+    this._configureBasicXmlSettings(configXml);
+
+    // CONFIG: 안드로이드 설정
+    if (this._opt.config.platform?.android) {
+      this._configureAndroidXmlSettings(configXml);
+    }
+
+    // CONFIG: 파일 새로 쓰기
+    const configResultContent = XmlConvert.stringify(configXml);
+    FsUtils.writeFile(configFilePath, configResultContent);
+  }
 
-    // CONFIG: 버전 설정
+  private _configureBasicXmlSettings(configXml: any): void {
+    // 버전 설정
     configXml.widget.$.version = this._npmConfig.version;
 
-    // CONFIG: ICON 설정
+    // ICON 설정
     if (this._opt.config.icon != null) {
-      configXml["widget"]["icon"] = [
+      configXml.widget.icon = [
         {
           $: {
-            src: "res/icons/"
-              + path.basename(this._opt.config.icon),
+            src: `${this.ICON_DIR_PATH}/${path.basename(this._opt.config.icon)}`,
           },
         },
       ];
     }
 
-    // CONFIG: 접근허용 세팅
-    // configXml["widget"]["content"] = [{ $: { src: "index.html" } }];
-    configXml["widget"]["content"] = [{ $: { src: "http://localhost/index.html" } }];
-    configXml["widget"]["access"] = [{ $: { origin: "*" } }];
-    configXml["widget"]["allow-navigation"] = [{ $: { href: "*" } }];
-    configXml["widget"]["allow-intent"] = [{ $: { href: "*" } }];
-    // configXml["widget"]["preference"] = [{ $: { name: "Scheme", value: "http" } }];
-    configXml["widget"]["preference"] = [{ $: { name: "MixedContentMode", value: "1" } }];
+    // 접근허용 세팅
+    configXml.widget.content = [{ $: { src: "http://localhost/index.html" } }];
+    configXml.widget.access = [{ $: { origin: "*" } }];
+    configXml.widget["allow-navigation"] = [{ $: { href: "*" } }];
+    configXml.widget["allow-intent"] = [{ $: { href: "*" } }];
+    configXml.widget.preference = [{ $: { name: "MixedContentMode", value: "1" } }];
+  }
 
-    // CONFIG: ANDROID usesCleartextTraffic 설정 및 splashscreen 파일 설정
-    if (this._opt.config.platform?.android) {
-      configXml.widget.$["xmlns:android"] = "http://schemas.android.com/apk/res/android";
-      configXml.widget.$["xmlns:tools"] = "http://schemas.android.com/tools";
+  private _configureAndroidXmlSettings(configXml: any): void {
+    configXml.widget.$["xmlns:android"] = "http://schemas.android.com/apk/res/android";
+    configXml.widget.$["xmlns:tools"] = "http://schemas.android.com/tools";
 
-      configXml["widget"]["platform"] = configXml["widget"]["platform"] ?? [];
+    configXml.widget.platform = configXml.widget.platform ?? [];
 
-      const androidPlatform = {
-        "$": {
-          name: "android",
-        },
-        "preference": [
-          {
-            $: {
-              name: "AndroidWindowSplashScreenAnimatedIcon",
-              value: "res/screen/android/splashscreen.xml",
-            },
-          },
-        ],
-        "edit-config": [
-          {
-            $: {
-              file: "app/src/main/AndroidManifest.xml",
-              mode: "merge",
-              target: "/manifest",
-            },
-            manifest: [
-              {
-                $: {
-                  "xmlns:tools": "http://schemas.android.com/tools",
-                },
-              },
-            ],
+    const androidPlatform = {
+      "$": {
+        name: "android",
+      },
+      "preference": [
+        {
+          $: {
+            name: "AndroidWindowSplashScreenAnimatedIcon",
+            value: `${this.SPLASH_SCREEN_DIR_PATH}/${this.SPLASH_SCREEN_XML_FILE}`,
           },
-          {
-            $: {
-              file: "app/src/main/AndroidManifest.xml",
-              mode: "merge",
-              target: "/manifest/application",
-            },
-            application: [
-              {
-                $: {
-                  "android:usesCleartextTraffic": "true",
-                  ...this._opt.config.platform.android.config
-                    ? Object.keys(this._opt.config.platform.android.config)
-                      .toObject(
-                        key => "android:" + key,
-                        key => this._opt.config.platform!.android!.config![key],
-                      )
-                    : {},
-                },
-              },
-            ],
+        },
+      ],
+      "edit-config": [
+        {
+          $: {
+            file: "app/src/main/AndroidManifest.xml",
+            mode: "merge",
+            target: "/manifest",
           },
-        ],
-      };
-
-      if (this._opt.config.platform.android.sdkVersion != null) {
-        androidPlatform.preference.push(
-          ...[
+          manifest: [
             {
               $: {
-                name: "android-maxSdkVersion",
-                value: `${this._opt.config.platform.android.sdkVersion}`,
-              },
-            },
-            {
-              $: {
-                name: "android-minSdkVersion",
-                value: `${this._opt.config.platform.android.sdkVersion}`,
-              },
-            },
-            {
-              $: {
-                name: "android-targetSdkVersion",
-                value: `${this._opt.config.platform.android.sdkVersion}`,
+                "xmlns:tools": "http://schemas.android.com/tools",
               },
             },
+          ],
+        },
+        {
+          $: {
+            file: "app/src/main/AndroidManifest.xml",
+            mode: "merge",
+            target: "/manifest/application",
+          },
+          application: [
             {
               $: {
-                name: "android-compileSdkVersion",
-                value: `33`,
+                "android:usesCleartextTraffic": "true",
+                ...this._opt.config.platform!.android!.config
+                  ? Object.keys(this._opt.config.platform!.android!.config)
+                    .toObject(
+                      key => "android:" + key,
+                      key => this._opt.config.platform!.android!.config![key],
+                    )
+                  : {},
               },
             },
           ],
-        );
-      }
+        },
+      ],
+    };
 
-      if (this._opt.config.platform.android.permissions) {
-        androidPlatform["config-file"] = androidPlatform["config-file"] ?? [];
-        androidPlatform["config-file"].push({
-          "$": {
-            target: "AndroidManifest.xml",
-            parent: "/*",
+    // SDK 버전 설정
+    if (this._opt.config.platform!.android!.sdkVersion != null) {
+      androidPlatform.preference.push(
+        ...[
+          {
+            $: {
+              name: "android-maxSdkVersion",
+              value: `${this._opt.config.platform!.android!.sdkVersion}`,
+            },
           },
-          "uses-permission": this._opt.config.platform.android.permissions.map((perm) => ({
+          {
             $: {
-              "android:name": `android.permission.${perm.name}`,
-              ...(perm.maxSdkVersion != null
-                ? {
-                  "android:maxSdkVersion": `${perm.maxSdkVersion}`,
-                }
-                : {}),
-              ...(perm.ignore != null
-                ? {
-                  "tools:ignore": `${perm.ignore}`,
-                }
-                : {}),
+              name: "android-minSdkVersion",
+              value: `${this._opt.config.platform!.android!.sdkVersion}`,
             },
-          })),
-        });
-      }
-
-      configXml["widget"]["platform"].push(androidPlatform);
+          },
+          {
+            $: {
+              name: "android-targetSdkVersion",
+              value: `${this._opt.config.platform!.android!.sdkVersion}`,
+            },
+          },
+          {
+            $: {
+              name: "android-compileSdkVersion",
+              value: this.ANDROID_SDK_VERSION,
+            },
+          },
+        ],
+      );
     }
 
-    // CONFIG: 파일 새로 쓰기
-    const configResultContent = new xml2js.Builder().buildObject(configXml);
-    FsUtils.writeFile(configFilePath, configResultContent);
-
-    //android.json의 undefined 문제 해결
-    /*const androidJsonFilePath = path.resolve(cordovaPath, "platforms/android/android.json");
-    if (FsUtil.exists(androidJsonFilePath)) {
-      const androidConf = FsUtil.readJson(androidJsonFilePath);
-      if (androidConf.config_munge.files["undefined"] != null) {
-        delete androidConf.config_munge.files["undefined"];
-      }
-      FsUtil.writeJson(androidJsonFilePath, androidConf, { space: 2 });
-    }*/
+    // 권한 설정
+    if (this._opt.config.platform!.android!.permissions) {
+      androidPlatform["config-file"] = androidPlatform["config-file"] ?? [];
+      androidPlatform["config-file"].push({
+        "$": {
+          target: "AndroidManifest.xml",
+          parent: "/*",
+        },
+        "uses-permission": this._opt.config.platform!.android!.permissions.map((perm) => ({
+          $: {
+            "android:name": `android.permission.${perm.name}`,
+            ...(perm.maxSdkVersion != null
+              ? {
+                "android:maxSdkVersion": `${perm.maxSdkVersion}`,
+              }
+              : {}),
+            ...(perm.ignore != null
+              ? {
+                "tools:ignore": `${perm.ignore}`,
+              }
+              : {}),
+          },
+        })),
+      });
+    }
 
-    // 각 플랫폼 www 준비
-    await this._execAsync(`npx cordova prepare`, cordovaPath);
+    configXml.widget.platform.push(androidPlatform);
   }
 
   public async buildAsync(outPath: string): Promise<void> {
-    const cordovaPath = path.resolve(this._opt.pkgPath, ".cordova");
+    const cordovaPath = path.resolve(this._opt.pkgPath, this.CORDOVA_DIR_NAME);
 
-    // 실행
+    // 빌드 실행 - 병렬 처리로 개선
     const buildType = this._opt.config.debug ? "debug" : "release";
-    for (const platform of this._platforms) {
-      await this._execAsync(`npx cordova build ${platform} --${buildType}`, cordovaPath);
+
+    // 모든 플랫폼 동시에 빌드
+    await Promise.all(this._platforms.map(platform =>
+      this._execAsync(`npx cordova build ${platform} --${buildType}`, cordovaPath),
+    ));
+
+    // 결과물 복사 및 ZIP 파일 생성 - 병렬 처리
+    await Promise.all(Object.keys(this._opt.config.platform ?? {}).map(async platform => {
+      await this._processBuildOutputAsync(cordovaPath, outPath, platform, buildType);
+    }));
+  }
+
+  private async _processBuildOutputAsync(
+    cordovaPath: string,
+    outPath: string,
+    platform: string,
+    buildType: string,
+  ): Promise<void> {
+    const targetOutPath = path.resolve(outPath, platform);
+
+    // 결과물 복사: ANDROID
+    if (platform === "android") {
+      this._copyAndroidBuildOutput(cordovaPath, targetOutPath, buildType);
     }
 
-    for (const platform of Object.keys(this._opt.config.platform ?? {})) {
-      const targetOutPath = path.resolve(outPath, platform);
-
-      // 결과물 복사: ANDROID
-      if (platform === "android") {
-        const apkFileName = this._opt.config.platform!.android!.sign
-          ? `app-${buildType}.apk`
-          : `app-${buildType}-unsigned.apk`;
-        const latestDistApkFileName = path.basename(
-          `${this._opt.config.appName}${this._opt.config.platform!.android!.sign
-            ? ""
-            : "-unsigned"}-latest.apk`,
-        );
-        FsUtils.mkdirs(targetOutPath);
-        FsUtils.copy(
-          path.resolve(
-            cordovaPath,
-            "platforms/android/app/build/outputs/apk",
-            buildType,
-            apkFileName,
-          ),
-          path.resolve(targetOutPath, latestDistApkFileName),
-        );
-      }
+    // 자동업데이트를 위한 파일 생성
+    await this._createUpdateZipAsync(cordovaPath, outPath, platform);
+  }
 
-      // 자동업데이트를 위한 파일 쓰기 (ZIP)
-      const zip = new JSZip();
-      const wwwFiles = FsUtils.glob(path.resolve(cordovaPath, "www/**/*"), { nodir: true });
-      for (const wwwFile of wwwFiles) {
-        const relFilePath = path.relative(path.resolve(cordovaPath, "www"), wwwFile);
-        const fileBuffer = FsUtils.readFileBuffer(wwwFile);
-        zip.file(relFilePath, fileBuffer);
-      }
-      const platformWwwFiles = FsUtils.glob(path.resolve(
-        cordovaPath,
-        "platforms",
-        platform,
-        "platform_www/**/*",
-      ), {
-        nodir: true,
-      });
-      for (const platformWwwFile of platformWwwFiles) {
-        const relFilePath = path.relative(
-          path.resolve(cordovaPath, "platforms", platform, "platform_www"),
-          platformWwwFile,
-        );
-        const fileBuffer = FsUtils.readFileBuffer(platformWwwFile);
-        zip.file(relFilePath, fileBuffer);
-      }
+  private _copyAndroidBuildOutput(
+    cordovaPath: string,
+    targetOutPath: string,
+    buildType: string,
+  ) {
+    const apkFileName = this._opt.config.platform!.android!.sign
+      ? `app-${buildType}.apk`
+      : `app-${buildType}-unsigned.apk`;
+
+    const latestDistApkFileName = path.basename(
+      `${this._opt.config.appName}${this._opt.config.platform!.android!.sign
+        ? ""
+        : "-unsigned"}-latest.apk`,
+    );
+
+    FsUtils.mkdirs(targetOutPath);
+    FsUtils.copy(
+      path.resolve(cordovaPath, "platforms/android/app/build/outputs/apk", buildType, apkFileName),
+      path.resolve(targetOutPath, latestDistApkFileName),
+    );
+  }
 
-      FsUtils.writeFile(
-        path.resolve(path.resolve(outPath, platform, "updates"), this._npmConfig.version + ".zip"),
-        await zip.generateAsync({ type: "nodebuffer" }),
-      );
+  private async _createUpdateZipAsync(
+    cordovaPath: string,
+    outPath: string,
+    platform: string,
+  ): Promise<void> {
+    const zip = new SdZip();
+    const wwwPath = path.resolve(cordovaPath, this.WWW_DIR_NAME);
+    const platformWwwPath = path.resolve(
+      cordovaPath,
+      this.PLATFORMS_DIR_NAME,
+      platform,
+      "platform_www",
+    );
+
+    this._addFilesToZip(zip, wwwPath);
+    this._addFilesToZip(zip, platformWwwPath);
+
+    // ZIP 파일 생성
+    const updateDirPath = path.resolve(outPath, platform, "updates");
+    FsUtils.mkdirs(updateDirPath);
+    FsUtils.writeFile(
+      path.resolve(updateDirPath, this._npmConfig.version + ".zip"),
+      await zip.compressAsync(),
+    );
+  }
+
+  private _addFilesToZip(zip: SdZip, dirPath: string) {
+    const files = FsUtils.glob(path.resolve(dirPath, "**/*"), { nodir: true });
+    for (const file of files) {
+      const relFilePath = path.relative(dirPath, file);
+      const fileBuffer = FsUtils.readFileBuffer(file);
+      zip.write(relFilePath, new Uint8Array(fileBuffer));
     }
   }
 
@@ -428,13 +538,16 @@ export class SdCliCordova {
       FsUtils.mkdirs(path.resolve(cordovaPath, "www"));
       FsUtils.writeFile(
         path.resolve(cordovaPath, "www/index.html"),
-        `'${opt.url}'로 이동중... <script>setTimeout(function () {window.location.href = "${opt.url.replace(
-          /\/$/,
-          "",
-        )}/${opt.pkgName}/cordova/"}, 3000);</script>`.trim(),
+        `
+'${opt.url}'로 이동중...
+<script>
+  setTimeout(function () {
+    window.location.href = "${opt.url.replace(/\/$/, "")}/${opt.pkgName}/cordova/";
+  }, 3000);
+</script>`.trim(),
       );
     }
 
     await SdProcess.spawnAsync(`npx cordova run ${opt.platform} --device`, { cwd: cordovaPath });
   }
-}
+}