diff --git a/adapter/ohos/CommandParser.java b/adapter/ohos/CommandParser.java index 214ea1ab222b31df25c74ba2df832073ad9ddbb3..e49b53a8209a3ca9fe9d20995432439da309c6a9 100644 --- a/adapter/ohos/CommandParser.java +++ b/adapter/ohos/CommandParser.java @@ -88,6 +88,8 @@ public class CommandParser { private static final String MAIN_MODULE_LIMIT = "--main-module-limit"; private static final String NORMAL_MODULE_LIMIT = "--normal-module-limit"; private static final String TOTAL_LIMIT = "--total-limit"; + private static final String ATOMIC_SERVICE_ENTRY_SIZE_LIMIT = "--atomic-service-entry-size-limit"; + private static final String ATOMIC_SERVICE_NON_ENTRY_SIZE_LIMIT = "--atomic-service-non-entry-size-limit"; private static final String VERSION_CODE = "--version-code"; private static final String VERSION_NAME = "--version-name"; private static final String INPUT_LIST = "--input-list"; @@ -335,7 +337,15 @@ public class CommandParser { return true; }); commandFuncs.put(TOTAL_LIMIT, entry -> { - entry.getKey().setTotalLimit(entry.getValue()); + entry.getKey().setAtomicServiceTotalSizeLimit(entry.getValue()); + return true; + }); + commandFuncs.put(ATOMIC_SERVICE_ENTRY_SIZE_LIMIT, entry -> { + entry.getKey().setAtomicServiceEntrySizeLimit(entry.getValue()); + return true; + }); + commandFuncs.put(ATOMIC_SERVICE_NON_ENTRY_SIZE_LIMIT, entry -> { + entry.getKey().setAtomicServiceNonEntrySizeLimit(entry.getValue()); return true; }); commandFuncs.put(VERSION_CODE, entry -> { diff --git a/adapter/ohos/Compressor.java b/adapter/ohos/Compressor.java index 2b97eba326851531a276438236633334f441ffb9..094c1d60f93f4ea4db1c04c74784605b975283c8 100644 --- a/adapter/ohos/Compressor.java +++ b/adapter/ohos/Compressor.java @@ -185,10 +185,10 @@ public class Compressor { private static final String BACKUP_PREFIX = "backup"; // set timestamp to get fixed MD5 - private static final int ENTRY_FILE_LIMIT_DEFAULT = 2; - private static final int NOT_ENTRY_FILE_LIMIT_DEFAULT = 2; - private static final int TOTAL_FILE_LIMIT_DEFAULT = 10; - private static final int FILE_LIMIT = 10; + private static final int ATOMIC_SERVICE_ENTRY_SIZE_LIMIT_DEFAULT = 2048; // 2MB;unit is KB + private static final int ATOMIC_SERVICE_NON_ENTRY_SIZE_LIMIT_DEFAULT = 2048; // 2MB;unit is KB + private static final int ATOMIC_SERVICE_TOTAL_SIZE_LIMIT_DEFAULT = 4194304; // 4GB;unit is KB + private static final int ATOMIC_SERVICE_TOTAL_SIZE_LIMIT_MAX = 4194304; // 4GB;unit is KB private static final int SHA256_BASE = 0xff; private static final int SHA256_OFFSET = 0x100; private static final int RADIX = 16; @@ -201,9 +201,9 @@ public class Compressor { private static final Log LOG = new Log(Compressor.class.toString()); private static final int SHARED_APP_HSP_LIMIT = 1; - private static int entryModuleSizeLimit = 2; - private static int notEntryModuleSizeLimit = 2; - private static int sumModuleSizeLimit = 10; + private static int entryModuleSizeLimit = 2048; + private static int notEntryModuleSizeLimit = 2048; + private static int sumModuleSizeLimit = 10240; private static final int INVALID_VERSION = -1; private static boolean isOverlay = false; @@ -344,56 +344,94 @@ public class Compressor { } /** - * parse file size limit from utility. + * Parse atomicService size limit parameter from utility. * * @param utility Indicates the utility. */ - public void parseFileSizeLimit(Utility utility) throws BundleException { - int sumLimit = TOTAL_FILE_LIMIT_DEFAULT; - String totalLimit = utility.getTotalLimit(); + public void parseAtomicServiceSizeLimit(Utility utility) throws BundleException { + parseAtomicServiceEntrySizeLimitParameter(utility); + parseAtomicServiceNonEntrySizeLimitParameter(utility); + } + + private int parseAtomicServiceSumSizeLimitParameter(Utility utility) throws BundleException{ + int sumLimit = ATOMIC_SERVICE_TOTAL_SIZE_LIMIT_DEFAULT; + String totalLimit = utility.getAtomicServiceTotalSizeLimit(); if (!totalLimit.isEmpty()) { try { sumLimit = Integer.parseInt(totalLimit); } catch (NumberFormatException e) { - LOG.error("parseFileSizeLimit failed, input total-limit invalid."); - throw new BundleException("parseFileSizeLimit failed, input total-limit invalid."); - } - if (sumLimit <= 0 || sumLimit > FILE_LIMIT) { - LOG.error("parseFileSizeLimit failed, input total-limit invalid."); - throw new BundleException("parseFileSizeLimit failed, input total-limit invalid."); + String errMsg = "parseAtomicServiceSumSizeLimitParameter failed, input --atomic-service-total-size-limit invalid."; + String solution = "Check the --atomic-service-total-size-limit parameter."; + LOG.error(PackingToolErrMsg.PARSE_ATOMIC_SERVICE_SIZE_LIMIT_FAILED.toString(errMsg, solution)); + throw new BundleException("parseAtomicServiceSumSizeLimitParameter failed, " + + "input --atomic-service-total-size-limit invalid."); + } + if (sumLimit < 0 || sumLimit > ATOMIC_SERVICE_TOTAL_SIZE_LIMIT_MAX) { + String errMsg = "parseAtomicServiceSumSizeLimitParameter failed, " + + "input --atomic-service-total-size-limit value out of range."; + String solution = "Check the --atomic-service-total-size-limit parameter is " + + "within the range of [0,4194304]."; + LOG.error(PackingToolErrMsg.PARSE_ATOMIC_SERVICE_SIZE_LIMIT_FAILED.toString(errMsg, solution)); + throw new BundleException("parseAtomicServiceSumSizeLimitParameter failed, " + + "input --atomic-service-total-size-limit value out of range."); } } - String normalLimit = utility.getNormalModuleLimit(); - int notEntry = NOT_ENTRY_FILE_LIMIT_DEFAULT; - if (!normalLimit.isEmpty()) { + setSumModuleSizeLimit(sumLimit); + return sumLimit; + } + + private void parseAtomicServiceEntrySizeLimitParameter(Utility utility) throws BundleException{ + String entrySizeLimitParamValue = utility.getAtomicServiceEntrySizeLimit(); + int entryLimit = ATOMIC_SERVICE_ENTRY_SIZE_LIMIT_DEFAULT; + if (!entrySizeLimitParamValue.isEmpty()) { try { - notEntry = Integer.parseInt(normalLimit); + entryLimit = Integer.parseInt(entrySizeLimitParamValue); } catch (NumberFormatException e) { - LOG.error("parseFileSizeLimit failed, input normal-module-limit invalid."); - throw new BundleException("parseFileSizeLimit failed, input normal-module-limit invalid."); - } - if (notEntry <= 0 || notEntry > sumLimit || notEntry > FILE_LIMIT) { - LOG.error("parseFileSizeLimit failed, input normal-module-limit invalid."); - throw new BundleException("parseFileSizeLimit failed, input normal-module-limit invalid."); + String errMsg = "parseAtomicServiceEntrySizeLimitParameter failed, " + + "input --atomic-service-entry-size-limit invalid."; + String solution = "Check the --atomic-service-entry-size-limit parameter is invalid"; + LOG.error(PackingToolErrMsg.PARSE_ATOMIC_SERVICE_SIZE_LIMIT_FAILED.toString(errMsg, solution)); + throw new BundleException("parseAtomicServiceEntrySizeLimitParameter failed, " + + "input --atomic-service-entry-size-limit invalid."); + } + if (entryLimit < 0 || entryLimit > ATOMIC_SERVICE_TOTAL_SIZE_LIMIT_MAX) { + String errMsg = "parseAtomicServiceEntrySizeLimitParameter failed, " + + "input --atomic-service-entry-size-limit value out of range."; + String solution = "Check the --atomic-service-entry-size-limit parameter is " + + "within the valid range."; + LOG.error(PackingToolErrMsg.PARSE_ATOMIC_SERVICE_SIZE_LIMIT_FAILED.toString(errMsg, solution)); + throw new BundleException("parseAtomicServiceEntrySizeLimitParameter failed, " + + "input --atomic-service-entry-size-limit value out of range."); } } - String mainLimit = utility.getMainModuleLimit(); - int entryLimit = ENTRY_FILE_LIMIT_DEFAULT; - if (!mainLimit.isEmpty()) { + setEntryModuleSizeLimit(entryLimit); + } + + private void parseAtomicServiceNonEntrySizeLimitParameter(Utility utility) throws BundleException{ + String nonEntryLimitParamValue = utility.getAtomicServiceNonEntrySizeLimit(); + int notEntryLimit = ATOMIC_SERVICE_NON_ENTRY_SIZE_LIMIT_DEFAULT; + if (!nonEntryLimitParamValue.isEmpty()) { try { - entryLimit = Integer.parseInt(mainLimit); + notEntryLimit = Integer.parseInt(nonEntryLimitParamValue); } catch (NumberFormatException e) { - LOG.error("parseFileSizeLimit failed, input main-module-limit invalid."); - throw new BundleException("parseFileSizeLimit failed, input main-module-limit invalid."); + String errMsg = "parseAtomicServiceSizeLimit failed, " + + "input --atomic-service-non-entry-size-limit invalid."; + String solution = "Check the --atomic-service-non-entry-size-limit parameter"; + LOG.error(PackingToolErrMsg.PARSE_ATOMIC_SERVICE_SIZE_LIMIT_FAILED.toString(errMsg, solution)); + throw new BundleException("parseAtomicServiceSizeLimit failed, " + + "input --atomic-service-non-entry-size-limit invalid."); } - if (entryLimit <= 0 || entryLimit > sumLimit || entryLimit > FILE_LIMIT) { - LOG.error("parseFileSizeLimit failed, input main-module-limit invalid."); - throw new BundleException("parseFileSizeLimit failed, input main-module-limit invalid."); + if (notEntryLimit < 0 || notEntryLimit > ATOMIC_SERVICE_TOTAL_SIZE_LIMIT_MAX) { + String errMsg = "parseAtomicServiceSizeLimit failed, " + + "input --atomic-service-non-entry-size-limit value out of range."; + String solution = "Check the --atomic-service-non-entry-size-limit parameter is " + + "within the valid range."; + LOG.error(PackingToolErrMsg.PARSE_ATOMIC_SERVICE_SIZE_LIMIT_FAILED.toString(errMsg, solution)); + throw new BundleException("parseAtomicServiceSizeLimit failed, " + + "input --atomic-service-non-entry-size-limit value out of range."); } } - setEntryModuleSizeLimit(entryLimit); - setNotEntryModuleSizeLimit(notEntry); - setSumModuleSizeLimit(sumLimit); + setNotEntryModuleSizeLimit(notEntryLimit); } /** @@ -454,6 +492,8 @@ public class Compressor { FileOutputStream fileOut = null; CheckedOutputStream checkedOut = null; try { + parseAtomicServiceSizeLimit(utility); + fileOut = new FileOutputStream(destFile); checkedOut = new CheckedOutputStream(fileOut, new CRC32()); zipOut = new ZipArchiveOutputStream(checkedOut); @@ -476,8 +516,8 @@ public class Compressor { if (compressResult && !checkAppAtomicServiceCompressedSizeValid(utility)) { compressResult = false; - String errMsg = "The size of a single module, or the size of a module plus its dependencies, exceeds " + - getEntryModuleSizeLimit() + "MB."; + String errMsg = "The size of a single module, or the size of a module plus its dependencies, " + + "exceeds the maximum."; LOG.error(PackingToolErrMsg.CHECK_ATOMIC_SERVICE_SIZE_FAILED.toString(errMsg)); } @@ -966,7 +1006,8 @@ public class Compressor { private boolean checkAppAtomicServiceCompressedSizeValid(Utility utility) { if (!utility.getMode().equals(Utility.MODE_APP) && - !utility.getMode().equals(Utility.MODE_FAST_APP)) { + !utility.getMode().equals(Utility.MODE_FAST_APP) && + !utility.getMode().equals(Utility.MODE_MULTI_APP)) { return true; } diff --git a/adapter/ohos/HapVerify.java b/adapter/ohos/HapVerify.java index 990a6a1adae21aa147fd86dd6b78c95307f2e503..e20bc6021b92022edf2e58446aa38cce7c21edda 100644 --- a/adapter/ohos/HapVerify.java +++ b/adapter/ohos/HapVerify.java @@ -44,6 +44,7 @@ class HapVerify { private static final String ATOMIC_SERVICE = "atomicService"; private static final String TYPE_SHARED = "shared"; private static final long FILE_LENGTH_1M = 1024 * 1024L; + private static final long FILE_LENGTH_1KB = 1024L; private static final double FILE_SIZE_OFFSET_DOUBLE = 0.01d; private static final int FILE_SIZE_DECIMAL_PRECISION = 2; private static final String HAP_SUFFIX = ".hap"; @@ -1437,7 +1438,8 @@ class HapVerify { return moduleNames; } - private static boolean checkAtomicServiceModuleSize(List hapVerifyInfoList) throws BundleException { + private static boolean checkAtomicServiceModuleAndDependenciesSize(List hapVerifyInfoList) + throws BundleException { if (hapVerifyInfoList.isEmpty()) { String cause = "Hap verify infos is empty"; LOG.error(PackingToolErrMsg.CHECK_HAP_VERIFY_INFO_LIST_EMPTY.toString(cause)); @@ -1459,16 +1461,20 @@ class HapVerify { } fileSize += dependency.getFileLength(); } - if (hapVerifyInfo.getModuleType().equals(ENTRY) && (fileSize >= entryLimit * FILE_LENGTH_1M)) { + if (hapVerifyInfo.getModuleType().equals(ENTRY) && + entryLimit != 0 && + (fileSize >= entryLimit * FILE_LENGTH_1KB)) { String errMsg = "Module " + hapVerifyInfo.getModuleName() + " and it's dependencies size sum is " + - getCeilFileSize(fileSize, entryLimit) + "MB, which is overlarge than " + entryLimit + "MB."; + getCeilFileSize(fileSize, entryLimit) + "KB, which is overlarge than " + entryLimit + "KB."; LOG.error(PackingToolErrMsg.CHECK_ATOMIC_SERVICE_MODULE_SIZE.toString(errMsg)); return false; } - if (!hapVerifyInfo.getModuleType().equals(ENTRY) && (fileSize >= notEntryLimit * FILE_LENGTH_1M)) { + if (!hapVerifyInfo.getModuleType().equals(ENTRY) && + notEntryLimit != 0 && + (fileSize >= notEntryLimit * FILE_LENGTH_1KB)) { String errMsg = "Module " + hapVerifyInfo.getModuleName() + " and it's dependencies size sum is " + - getCeilFileSize(fileSize, notEntryLimit) + "MB, which is overlarge than " + notEntryLimit + - "MB."; + getCeilFileSize(fileSize, notEntryLimit) + "KB, which is overlarge than " + notEntryLimit + + "KB."; LOG.error(PackingToolErrMsg.CHECK_ATOMIC_SERVICE_MODULE_SIZE.toString(errMsg)); return false; } @@ -1479,7 +1485,7 @@ class HapVerify { private static double getCeilFileSize(long fileSize, int sizeLimit) { double threshold = Double.valueOf(sizeLimit) + FILE_SIZE_OFFSET_DOUBLE; double size = new BigDecimal((float) fileSize - / FILE_LENGTH_1M).setScale(FILE_SIZE_DECIMAL_PRECISION, BigDecimal.ROUND_HALF_UP).doubleValue(); + / FILE_LENGTH_1KB).setScale(FILE_SIZE_DECIMAL_PRECISION, BigDecimal.ROUND_HALF_UP).doubleValue(); if (size < threshold && size >= sizeLimit) { size = threshold; } @@ -1640,18 +1646,20 @@ class HapVerify { int notEntryLimit = hapVerifyInfoList.get(0).getNotEntrySizeLimit(); for (HapVerifyInfo hapVerifyInfo : hapVerifyInfoList) { if (hapVerifyInfo.getModuleType().equals(ENTRY) && - (hapVerifyInfo.getFileLength() >= entryLimit * FILE_LENGTH_1M)) { + entryLimit != 0 && + (hapVerifyInfo.getFileLength() >= entryLimit * FILE_LENGTH_1KB)) { String errMsg = "Module " + hapVerifyInfo.getModuleName() + "'s size is " + getCeilFileSize(hapVerifyInfo.getFileLength(), entryLimit) + - "MB, which is overlarge than " + entryLimit + "MB."; + "KB, which is overlarge than " + entryLimit + "KB."; LOG.error(PackingToolErrMsg.CHECK_FILE_SIZE_INVALID.toString(errMsg)); return false; } if (!hapVerifyInfo.getModuleType().equals(ENTRY) && - (hapVerifyInfo.getFileLength() >= notEntryLimit * FILE_LENGTH_1M)) { + notEntryLimit != 0 && + (hapVerifyInfo.getFileLength() >= notEntryLimit * FILE_LENGTH_1KB)) { String errMsg = "Module " + hapVerifyInfo.getModuleName() + "'s size is " + getCeilFileSize(hapVerifyInfo.getFileLength(), notEntryLimit) + - "MB, which is overlarge than " + notEntryLimit + "MB."; + "KB, which is overlarge than " + notEntryLimit + "KB."; LOG.error(PackingToolErrMsg.CHECK_FILE_SIZE_INVALID.toString(errMsg)); return false; } @@ -1660,7 +1668,7 @@ class HapVerify { Map> deviceInfoMap = getDeviceHapVerifyInfoMap(hapVerifyInfoList); for (String device : deviceInfoMap.keySet()) { ListhapVerifyInfoList1 = deviceInfoMap.get(device); - if (!checkAtomicServiceModuleSize(hapVerifyInfoList1)) { + if (!checkAtomicServiceModuleAndDependenciesSize(hapVerifyInfoList1)) { String errMsg = "Check the atomicService module size failed on device " + device + "."; LOG.error(PackingToolErrMsg.CHECK_FILE_SIZE_INVALID.toString(errMsg)); return false; diff --git a/adapter/ohos/HapVerifyInfo.java b/adapter/ohos/HapVerifyInfo.java index e70b32496e76fe03ab688d648ddfe84526eb3061..1f43fd225640b4093c331a035899f889bf599894 100644 --- a/adapter/ohos/HapVerifyInfo.java +++ b/adapter/ohos/HapVerifyInfo.java @@ -128,11 +128,11 @@ class HapVerifyInfo { private List preloadItems = new ArrayList<>(); private long fileLength = 0L; - private int entrySizeLimit = 2; + private int entrySizeLimit = 2048; - private int notEntrySizeLimit = 2; + private int notEntrySizeLimit = 2048; - private int sumSizeLimit = 10; + private int sumSizeLimit = 10240; private boolean debug = false; diff --git a/adapter/ohos/PackingToolErrMsg.java b/adapter/ohos/PackingToolErrMsg.java index af18f800370bf53ff4b09babf50fed873407ae9f..f6e9e66de2e1906f054db728603bdeb929ec8a8c 100644 --- a/adapter/ohos/PackingToolErrMsg.java +++ b/adapter/ohos/PackingToolErrMsg.java @@ -265,6 +265,17 @@ public class PackingToolErrMsg { .setCause("%s") .build(); + /** + * PARSE_ATOMIC_SERVICE_SIZE_LIMIT_FAILED + */ + public static final ErrorMsg PARSE_ATOMIC_SERVICE_SIZE_LIMIT_FAILED = ErrorMsg.getPackingToolErrBuilder() + .setTypeCode("11") + .setErrCode("022") + .setDescription("Parse atomicService size limit failed.") + .setCause("%s") + .addSolution("%s") + .build(); + // compress process error /** * COMPRESS_PROCESS_FAILED diff --git a/adapter/ohos/Utility.java b/adapter/ohos/Utility.java index 5c47ea08bef09bba49f9ffea67a8c1676747f7e9..5f14276f4329fe3100bea9d5b4f03903b2cd31ed 100644 --- a/adapter/ohos/Utility.java +++ b/adapter/ohos/Utility.java @@ -106,6 +106,8 @@ public class Utility { private String mainModuleLimit = ""; private String normalModuleLimit = ""; private String totalLimit = ""; + private String atomicServiceEntrySizeLimit = ""; + private String atomicServiceNonEntrySizeLimit = ""; private int compressLevel = 1; private String pkgContextPath = ""; private String bundleName = ""; @@ -834,14 +836,14 @@ public class Utility { return isAppService; } - public void setMainModuleLimit(String limit) { - this.mainModuleLimit = limit; - } - public String getMainModuleLimit() { return mainModuleLimit; } + public void setMainModuleLimit(String limit) { + this.mainModuleLimit = limit; + } + public String getNormalModuleLimit() { return normalModuleLimit; } @@ -850,14 +852,30 @@ public class Utility { this.normalModuleLimit = limit; } - public String getTotalLimit() { + public String getAtomicServiceTotalSizeLimit() { return totalLimit; } - public void setTotalLimit(String limit) { + public void setAtomicServiceTotalSizeLimit(String limit) { this.totalLimit = limit; } + public String getAtomicServiceEntrySizeLimit() { + return atomicServiceEntrySizeLimit; + } + + public void setAtomicServiceEntrySizeLimit(String limit) { + this.atomicServiceEntrySizeLimit = limit; + } + + public String getAtomicServiceNonEntrySizeLimit() { + return atomicServiceNonEntrySizeLimit; + } + + public void setAtomicServiceNonEntrySizeLimit(String limit) { + this.atomicServiceNonEntrySizeLimit = limit; + } + public int getCompressLevel() { return compressLevel; } diff --git a/packing_tool/frameworks/include/constants.h b/packing_tool/frameworks/include/constants.h index e0eab38b46c5880389b127c1017edab34076d718..573e68baf656911a41a2e5784e92e3572c57d4cc 100644 --- a/packing_tool/frameworks/include/constants.h +++ b/packing_tool/frameworks/include/constants.h @@ -101,6 +101,8 @@ const std::string PARAM_RPCID = "rpcid"; const std::string PARAM_APPQF_PATH = "appqf-path"; const std::string PARAM_MAIN_MODULE_LIMIT = "main-module-limit"; const std::string PARAM_NORMAL_MODULE_LIMIT = "normal-module-limit"; +const std::string PARAM_ATOMIC_SERVICE_ENTRY_SIZE_LIMIT = "atomic-service-entry-size-limit"; +const std::string PARAM_ATOMIC_SERVICE_NON_ENTRY_SIZE_LIMIT = "atomic-service-non-entry-size-limit"; const std::string PARAM_TOTAL_LIMIT = "total-limit"; const std::string PARAM_BUNDLE_NAME = "bundle-name"; const std::string PARAM_PAC_JSON_PATH = "pac-json-path"; @@ -171,6 +173,9 @@ const int32_t APP_SUFFIX_LENGTH = 4; const char COMMA_SPLIT = ','; const int32_t MAX_VERSION_NAME_LENGTH = 127; const int32_t MAX_VERSION_CODE = 2147483647; +const int32_t ATOMIC_SERVICE_ENTRY_SIZE_LIMIT_DEFAULT = 2048; +const int32_t ATOMIC_SERVICE_NON_ENTRY_SIZE_LIMIT_DEFAULT = 2048; +const int32_t ATOMIC_SERVICE_TOTAL_SIZE_LIMIT_MAX = 4194304; constexpr const char* SHORT_OPTIONS = ""; const struct option LONG_OPTIONS[] = { @@ -228,6 +233,8 @@ const struct option LONG_OPTIONS[] = { {PARAM_INSTALLATION_FREE.c_str(), required_argument, nullptr, 53}, {PARAM_DELIVERY_WITH_INSTALL.c_str(), required_argument, nullptr, 54}, {PARAM_PAC_JSON_PATH.c_str(), required_argument, nullptr, 55}, + {PARAM_ATOMIC_SERVICE_ENTRY_SIZE_LIMIT.c_str(), required_argument, nullptr, 56}, + {PARAM_ATOMIC_SERVICE_NON_ENTRY_SIZE_LIMIT.c_str(), required_argument, nullptr, 57}, {nullptr, 0, nullptr, 0}, }; constexpr const int32_t OPTIONS_SIZE = sizeof(LONG_OPTIONS) / sizeof(LONG_OPTIONS[0]); diff --git a/packing_tool/frameworks/include/json/hap_verify_info.h b/packing_tool/frameworks/include/json/hap_verify_info.h index 54f9a43a1c99efa5e3c8e95ec248391059e1cda6..4ca775ec9e0558ea1c65b6b2275c1caab4cc2e3f 100644 --- a/packing_tool/frameworks/include/json/hap_verify_info.h +++ b/packing_tool/frameworks/include/json/hap_verify_info.h @@ -136,9 +136,9 @@ private: std::list preloadItems_; // json file size int64_t fileLength_ = 0L; - int32_t entrySizeLimit_ = 2; - int32_t notEntrySizeLimit_ = 2; - int32_t sumSizeLimit_ = 10; + int32_t entrySizeLimit_ = 2048; + int32_t notEntrySizeLimit_ = 2048; + int32_t sumSizeLimit_ = 10240; bool debug_ = false; std::string compileSdkVersion_ = ""; std::string compileSdkType_ = ""; diff --git a/packing_tool/frameworks/include/packager.h b/packing_tool/frameworks/include/packager.h index f98e646b790f2855fb8ce756f4b6132a8c27cba4..74727bcb0249dd490e288f27b6c6ae06dc7d7f6c 100644 --- a/packing_tool/frameworks/include/packager.h +++ b/packing_tool/frameworks/include/packager.h @@ -53,6 +53,11 @@ public: int32_t MakePackage(); + static int32_t getAtomicServiceEntrySizeLimit(); + static void setAtomicServiceEntrySizeLimit(int32_t atomicServiceEntrySizeLimit); + static int32_t getAtomicServiceNonEntrySizeLimit(); + static void setAtomicServiceNonEntrySizeLimit(int32_t atomicServiceNonEntrySizeLimit); + virtual int32_t InitAllowedParam() = 0; virtual int32_t PreProcess() = 0; virtual int32_t Process() = 0; @@ -84,6 +89,13 @@ protected: bool IsModuleHap(const std::string& hapPath); void CompressPackinfoIntoHap(const std::string& hapPathItem, const std::string& unzipPathString, const std::string& outPathString, const std::string& packInfoPath); + bool ParseAtomicServiceSizeLimit(); + bool ParseAtomicServiceEntrySizeLimitParameter(); + bool ParseAtomicServiceNonEntrySizeLimitParameter(); + +private: + static int32_t atomicServiceEntrySizeLimit_; + static int32_t atomicServiceNonEntrySizeLimit_; }; } // namespace AppExecFwk diff --git a/packing_tool/frameworks/src/app_packager.cpp b/packing_tool/frameworks/src/app_packager.cpp index df0c2f8d21b806b8a73558f58e2ff4e0fb55bd28..5bc29ec31051166e09ae5bd012b90c90bc0998a3 100644 --- a/packing_tool/frameworks/src/app_packager.cpp +++ b/packing_tool/frameworks/src/app_packager.cpp @@ -45,6 +45,9 @@ int32_t AppPackager::PreProcess() if (!ret) { return ERR_INVALID_VALUE; } + if (!Packager::ParseAtomicServiceSizeLimit()) { + return ERR_INVALID_VALUE; + } return ERR_OK; } diff --git a/packing_tool/frameworks/src/fast_app_packager.cpp b/packing_tool/frameworks/src/fast_app_packager.cpp index 716a07d83620518f16c776c14903061122d67cc3..f4611710df8c68232f5ebac67ca5e06cd8091282 100644 --- a/packing_tool/frameworks/src/fast_app_packager.cpp +++ b/packing_tool/frameworks/src/fast_app_packager.cpp @@ -51,6 +51,9 @@ int32_t FastAppPackager::PreProcess() if (!ret) { return ERR_INVALID_VALUE; } + if (!Packager::ParseAtomicServiceSizeLimit()) { + return ERR_INVALID_VALUE; + } return ERR_OK; } diff --git a/packing_tool/frameworks/src/json/hap_verify_info.cpp b/packing_tool/frameworks/src/json/hap_verify_info.cpp index 12da91bfbde776cb8ca4936134d92a894a5e01ea..c81b4eab81669528c5de8314c936fcbf59323600 100644 --- a/packing_tool/frameworks/src/json/hap_verify_info.cpp +++ b/packing_tool/frameworks/src/json/hap_verify_info.cpp @@ -369,7 +369,7 @@ void HapVerifyInfo::ConvertToDependency() { for (DependencyItem item : dependencyItemList_) { if (!item.bundleName.empty() && item.bundleName.compare(bundleName_) == 0) { - dependencies_.emplace_back(item.bundleName); + dependencies_.emplace_back(item.moduleName); } } } diff --git a/packing_tool/frameworks/src/json/hap_verify_utils.cpp b/packing_tool/frameworks/src/json/hap_verify_utils.cpp index 6d226b1a59388eadb21d045a494dc96e496a8c7f..6494fa33ad37db2b595d26743334a0611e5839ce 100644 --- a/packing_tool/frameworks/src/json/hap_verify_utils.cpp +++ b/packing_tool/frameworks/src/json/hap_verify_utils.cpp @@ -43,7 +43,7 @@ const std::string HAP_SUFFIX = ".hap"; const std::string HSP_SUFFIX = ".hsp"; const std::string APP_PLUGIN = "appPlugin"; const int32_t TWO = 2; -const long FILE_LENGTH_1M = 1024 * 1024L; +const long FILE_LENGTH_1KB = 1024L; } bool HapVerifyUtils::CheckHapIsValid(const std::list& hapVerifyInfos) @@ -950,15 +950,15 @@ bool HapVerifyUtils::CheckFileSizeIsValid(const std::list& hapVer int32_t notEntryLimit = hapVerifyInfos.begin()->GetNotEntrySizeLimit(); for (HapVerifyInfo hapVerifyInfo : hapVerifyInfos) { if (hapVerifyInfo.GetModuleType() == ENTRY && - (hapVerifyInfo.GetFileLength() >= entryLimit * FILE_LENGTH_1M)) { - LOGE("module %s's size is %.2f MB, which is overlarge than %d MB.", + (hapVerifyInfo.GetFileLength() >= entryLimit * FILE_LENGTH_1KB)) { + LOGE("module %s's size is %.2f KB, which is overlarge than %d KB.", hapVerifyInfo.GetModuleName().c_str(), Utils::GetCeilFileSize(hapVerifyInfo.GetFileLength(), entryLimit), entryLimit); return false; } if (hapVerifyInfo.GetModuleType() != ENTRY && - (hapVerifyInfo.GetFileLength() >= notEntryLimit * FILE_LENGTH_1M)) { - LOGE("module %s's size is %.2f MB, which is overlarge than %d MB.", + (hapVerifyInfo.GetFileLength() >= notEntryLimit * FILE_LENGTH_1KB)) { + LOGE("module %s's size is %.2f KB, which is overlarge than %d KB.", hapVerifyInfo.GetModuleName().c_str(), Utils::GetCeilFileSize(hapVerifyInfo.GetFileLength(), notEntryLimit), notEntryLimit); @@ -1005,15 +1005,15 @@ bool HapVerifyUtils::CheckAtomicServiceModuleSize(const std::list for (auto& dependency : dependenciesInfos) { fileSize += dependency.GetFileLength(); } - if (hapVerifyInfo.GetModuleType() == ENTRY && (fileSize >= entryLimit * FILE_LENGTH_1M)) { - LOGE("module %s and it's dependencies size is %.2f MB, which is overlarge than %d MB.", + if (hapVerifyInfo.GetModuleType() == ENTRY && (fileSize >= entryLimit * FILE_LENGTH_1KB)) { + LOGE("module %s and it's dependencies size is %.2f KB, which is overlarge than %d KB.", hapVerifyInfo.GetModuleName().c_str(), Utils::GetCeilFileSize(fileSize, entryLimit), entryLimit); return false; } - if (hapVerifyInfo.GetModuleType() != ENTRY && (fileSize >= notEntryLimit * FILE_LENGTH_1M)) { - LOGE("module %s and it's dependencies size is %.2f MB, which is overlarge than %d MB.", + if (hapVerifyInfo.GetModuleType() != ENTRY && (fileSize >= notEntryLimit * FILE_LENGTH_1KB)) { + LOGE("module %s and it's dependencies size is %.2f KB, which is overlarge than %d KB.", hapVerifyInfo.GetModuleName().c_str(), Utils::GetCeilFileSize(fileSize, notEntryLimit), notEntryLimit); diff --git a/packing_tool/frameworks/src/json/module_json_utils.cpp b/packing_tool/frameworks/src/json/module_json_utils.cpp index b0ff2d9be93e2191157f1de62740b519732f3c5e..7fbdb2bcb88ce5ccc48948be11aec52143b1bcb4 100644 --- a/packing_tool/frameworks/src/json/module_json_utils.cpp +++ b/packing_tool/frameworks/src/json/module_json_utils.cpp @@ -25,6 +25,7 @@ #include "utils.h" #include "zip_utils.h" #include "constants.h" +#include "packager.h" namespace fs = std::filesystem; @@ -40,8 +41,6 @@ const std::string TYPE_SHARED = "shared"; const std::string INCLUDE = "include"; const std::string EXCLUDE = "exclude"; const std::string ATOMIC_SERVICE = "atomicService"; -static int32_t g_entryModuleSizeLimit = 2; -static int32_t g_notEntryModuleSizeLimit = 2; static int32_t g_sumModuleSizeLimit = 10; } @@ -186,7 +185,6 @@ bool ModuleJsonUtils::GetHapVerifyInfosMapfromFileList(const std::list hapVerifyInfos; + for (const auto& [key, ptr] : hapVerifyInfoMap) { + if (ptr) { + hapVerifyInfos.push_back(*ptr); + } + } + ModuleJsonUtils::setAtomicServiceFileSizeLimit(hapVerifyInfos); + auto listIt = hapVerifyInfos.begin(); + for (auto& [key, ptr] : hapVerifyInfoMap) { + if (ptr && listIt != hapVerifyInfos.end()) { + *ptr = *listIt++; + } + } return true; } @@ -316,8 +327,8 @@ void ModuleJsonUtils::setAtomicServiceFileSizeLimit(std::list& ha { for (auto& hapVerifyInfo : hapVerifyInfos) { if (hapVerifyInfo.GetBundleType().compare(ATOMIC_SERVICE) == 0) { - hapVerifyInfo.SetEntrySizeLimit(g_entryModuleSizeLimit); - hapVerifyInfo.SetNotEntrySizeLimit(g_notEntryModuleSizeLimit); + hapVerifyInfo.SetEntrySizeLimit(Packager::getAtomicServiceEntrySizeLimit()); + hapVerifyInfo.SetNotEntrySizeLimit(Packager::getAtomicServiceNonEntrySizeLimit()); hapVerifyInfo.SetSumSizeLimit(g_sumModuleSizeLimit); } } diff --git a/packing_tool/frameworks/src/multiapp_packager.cpp b/packing_tool/frameworks/src/multiapp_packager.cpp index ac9529800416d5e36a1a271e411ebb8e9df79ffa..85e1b8327298ae89af2a570233247065f3d6dafb 100644 --- a/packing_tool/frameworks/src/multiapp_packager.cpp +++ b/packing_tool/frameworks/src/multiapp_packager.cpp @@ -48,6 +48,9 @@ int32_t MultiAppPackager::PreProcess() if (!ret) { return ERR_INVALID_VALUE; } + if (!Packager::ParseAtomicServiceSizeLimit()) { + return ERR_INVALID_VALUE; + } return ERR_OK; } diff --git a/packing_tool/frameworks/src/packager.cpp b/packing_tool/frameworks/src/packager.cpp index ddaa7b94ae3c8f753899951726e53056782c0269..65faf22705cf3eae0ad05b3f1579b633facd7264 100644 --- a/packing_tool/frameworks/src/packager.cpp +++ b/packing_tool/frameworks/src/packager.cpp @@ -29,6 +29,10 @@ namespace OHOS { namespace AppPackingTool { + +int32_t Packager::atomicServiceEntrySizeLimit_ = 2048; +int32_t Packager::atomicServiceNonEntrySizeLimit_ = 2048; + namespace { const std::string EN_US_UTF_8 = "en_US.UTF-8"; } @@ -478,5 +482,74 @@ bool Packager::IsOutDirectoryValid() } return true; } + +bool Packager::ParseAtomicServiceSizeLimit() +{ + bool parseEntry = ParseAtomicServiceEntrySizeLimitParameter(); + bool parseNonEntry = ParseAtomicServiceNonEntrySizeLimitParameter(); + return parseEntry && parseNonEntry; +} + +bool Packager::ParseAtomicServiceEntrySizeLimitParameter() +{ + auto it = parameterMap_.find(Constants::PARAM_ATOMIC_SERVICE_ENTRY_SIZE_LIMIT); + int32_t entrySizeLimit = Constants::ATOMIC_SERVICE_ENTRY_SIZE_LIMIT_DEFAULT; + if (it != parameterMap_.end()) { + try { + entrySizeLimit = std::stoi(it->second); + } catch (const std::exception& e) { + LOGE("Exception: %s", e.what()); + return false; + } + if (entrySizeLimit < 0 || entrySizeLimit > Constants::ATOMIC_SERVICE_TOTAL_SIZE_LIMIT_MAX) { + LOGE("ParseAtomicServiceEntrySizeLimitParameter failed, " + "input --atomic-service-entry-size-limit value out of range."); + return false; + } + } + Packager::setAtomicServiceEntrySizeLimit(entrySizeLimit); + return true; +} + +bool Packager::ParseAtomicServiceNonEntrySizeLimitParameter() +{ + auto it = parameterMap_.find(Constants::PARAM_ATOMIC_SERVICE_NON_ENTRY_SIZE_LIMIT); + int32_t nonEntrySizeLimit = Constants::ATOMIC_SERVICE_NON_ENTRY_SIZE_LIMIT_DEFAULT; + if (it != parameterMap_.end()) { + try { + nonEntrySizeLimit = std::stoi(it->second); + } catch (const std::exception& e) { + LOGE("Exception: %s", e.what()); + return false; + } + if (nonEntrySizeLimit < 0 || nonEntrySizeLimit > Constants::ATOMIC_SERVICE_TOTAL_SIZE_LIMIT_MAX) { + LOGE("ParseAtomicServiceNonEntrySizeLimitParameter failed, " + "input --atomic-service-non-entry-size-limit value out of range."); + return false; + } + } + Packager::setAtomicServiceNonEntrySizeLimit(nonEntrySizeLimit); + return true; +} + +int32_t Packager::getAtomicServiceEntrySizeLimit() +{ + return atomicServiceEntrySizeLimit_; +} + +void Packager::setAtomicServiceEntrySizeLimit(int32_t atomicServiceEntrySizeLimit) +{ + atomicServiceEntrySizeLimit_ = atomicServiceEntrySizeLimit; +} + +int32_t Packager::getAtomicServiceNonEntrySizeLimit() +{ + return atomicServiceNonEntrySizeLimit_; +} + +void Packager::setAtomicServiceNonEntrySizeLimit(int32_t atomicServiceNonEntrySizeLimit) +{ + atomicServiceNonEntrySizeLimit_ = atomicServiceNonEntrySizeLimit; +} } // namespace AppPackingTool } // namespace OHOS \ No newline at end of file diff --git a/packing_tool/frameworks/src/utils.cpp b/packing_tool/frameworks/src/utils.cpp index ab23efee18635c07cb9ac2e668752e58499f03d7..fa53f23971d596bce73d5b4cc3b9c2b1ff5d1988 100644 --- a/packing_tool/frameworks/src/utils.cpp +++ b/packing_tool/frameworks/src/utils.cpp @@ -38,7 +38,7 @@ namespace { const int BUFFER_SIZE = 1024; const int HEX_WIDTH = 2; const char PATH_DELIMITER = '/'; -const long FILE_LENGTH_1M = 1024 * 1024L; +const long FILE_LENGTH_1KB = 1024L; const double FILE_SIZE_OFFSET_DOUBLE = 0.01; const int FILE_SIZE_DECIMAL_PRECISION = 2; const int MAX_UUID_LENGTH = 32; @@ -317,7 +317,7 @@ bool Utils::ForceRemoveDirectory(const std::string& dir, bool isDeleteSelf) double Utils::GetCeilFileSize(long fileSize, int sizeLimit) { double threshold = static_cast(sizeLimit) + FILE_SIZE_OFFSET_DOUBLE; - double size = static_cast(fileSize) / FILE_LENGTH_1M; + double size = static_cast(fileSize) / FILE_LENGTH_1KB; size = std::round(size * std::pow(TEN, FILE_SIZE_DECIMAL_PRECISION)) / std::pow(TEN, FILE_SIZE_DECIMAL_PRECISION); if (size < threshold && size >= sizeLimit) { size = threshold; diff --git a/packing_tool/frameworks/test/unittest/json/module_json_utils_test/BUILD.gn b/packing_tool/frameworks/test/unittest/json/module_json_utils_test/BUILD.gn index 884f2e7e750f8ddc07a176c4a89129c6535a211d..fb70c3e4607f057ade8ca56598a320f061bee915 100644 --- a/packing_tool/frameworks/test/unittest/json/module_json_utils_test/BUILD.gn +++ b/packing_tool/frameworks/test/unittest/json/module_json_utils_test/BUILD.gn @@ -42,6 +42,7 @@ ohos_unittest("module_json_utils_test") { "../../../../src/utils.cpp", "../../../../src/zip_utils.cpp", "../../../../src/zip_wrapper.cpp", + "../../../../src/packager.cpp", "module_json_utils_test.cpp", ] external_deps = [ diff --git a/packing_tool/frameworks/test/unittest/json/module_json_utils_test/module_json_utils_test.cpp b/packing_tool/frameworks/test/unittest/json/module_json_utils_test/module_json_utils_test.cpp index 63281e9a324dad6262d5800d009586fd75f272d1..78d42f372e6dab800def474739214778ca1c3c07 100644 --- a/packing_tool/frameworks/test/unittest/json/module_json_utils_test/module_json_utils_test.cpp +++ b/packing_tool/frameworks/test/unittest/json/module_json_utils_test/module_json_utils_test.cpp @@ -21,6 +21,7 @@ #define protected public #include "module_json_utils.h" #include "constants.h" +#include "packager.h" #include "pt_json.h" #include "log.h" #include "zip_wrapper.h"