重构

Signed-off-by: HanSY <hansiyuan1@huawei.com>

BUILD.gn

@@ -23,6 +23,7 @@ ohos_executable("restool") {
     "src/compression_parser.cpp",
     "src/config_parser.cpp",
     "src/factory_resource_compiler.cpp",
+    "src/factory_resource_packer.cpp",
     "src/file_entry.cpp",
     "src/file_manager.cpp",
     "src/generic_compiler.cpp",
@@ -32,6 +33,8 @@ ohos_executable("restool") {
     "src/id_worker.cpp",
     "src/json_compiler.cpp",
     "src/key_parser.cpp",
+    "src/overlap_binary_file_packer.cpp",
+    "src/overlap_compiler.cpp",
     "src/reference_parser.cpp",
     "src/resconfig_parser.cpp",
     "src/resource_append.cpp",
@@ -40,6 +43,7 @@ ohos_executable("restool") {
     "src/resource_item.cpp",
     "src/resource_merge.cpp",
     "src/resource_module.cpp",
+    "src/resource_overlap.cpp",
     "src/resource_pack.cpp",
     "src/resource_table.cpp",
     "src/resource_util.cpp",

include/binary_file_packer.h

@@ -29,22 +29,23 @@ public:
     ~BinaryFilePacker();
     std::future<uint32_t> CopyBinaryFileAsync(const std::vector<std::string> &inputs);
     void StopCopy();
-    void SetCopyHap(bool state);
 
-private:
-    uint32_t CopyBinaryFile(const std::vector<std::string> &inputs);
-    uint32_t CopyBinaryFile(const std::string &filePath, const std::string &fileType);
-    uint32_t CopyBinaryFileImpl(const std::string &src, const std::string &dst);
-    uint32_t CopySingleFile(const std::string &path, std::string &subPath);
-    uint32_t CopyBinaryFileWithHap(const std::vector<std::string> &inputs);
-    bool IsDefinedFile(const std::unique_ptr<FileEntry> &entry, std::string subPath);
+protected:
+    virtual uint32_t CopyBinaryFile(const std::vector<std::string> &inputs);
+    uint32_t CheckCopyResults();
+    uint32_t CopyBinaryFile(const std::string &input);
+    virtual bool IsDuplicated(const std::unique_ptr<FileEntry> &entry, std::string subPath);
     PackageParser packageParser_;
     std::string moduleName_;
     ThreadPool threadPool_;
     std::vector<std::future<uint32_t>> copyResults_;
     std::atomic<bool> stopCopy_{false};
-    bool copyHap_{false};
     std::mutex mutex_;
+
+private:
+    uint32_t CopyBinaryFile(const std::string &filePath, const std::string &fileType);
+    uint32_t CopyBinaryFileImpl(const std::string &src, const std::string &dst);
+    uint32_t CopySingleFile(const std::string &path, std::string &subPath);
 };
 } // namespace Restool
 } // namespace Global

include/cmd_parser.h

@@ -57,7 +57,7 @@ public:
     bool IsTargetConfig() const;
     const std::vector<std::string> &GetSysIdDefinedPaths() const;
     const std::string &GetCompressionPath() const;
-    bool ExistHapInput();
+    bool IsOverlap() const;
 
 private:
     void InitCommand();

include/factory_resource_compiler.h

@@ -24,7 +24,7 @@ namespace Global {
 namespace Restool {
 class FactoryResourceCompiler {
 public:
-    static std::unique_ptr<IResourceCompiler> CreateCompiler(ResType type, const std::string &output);
+    static std::unique_ptr<IResourceCompiler> CreateCompiler(ResType type, const std::string &output, bool isHap);
     static std::unique_ptr<IResourceCompiler> CreateCompilerForAppend(ResType type, const std::string &output);
 };
 }

include/factory_resource_packer.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_RESTOOL_FACTORY_RESOURCE_PACKER_H
+#define OHOS_RESTOOL_FACTORY_RESOURCE_PACKER_H
+
+#include <memory>
+#include "resource_pack.h"
+
+namespace OHOS {
+namespace Global {
+namespace Restool {
+class FactoryResourcePacker {
+public:
+    static std::unique_ptr<ResourcePack> CreatePacker(PackType type, const PackageParser &packageParser);
+};
+}
+}
+}
+#endif

include/file_manager.h

@@ -35,7 +35,6 @@ public:
     {
         moduleName_ = moduleName;
     };
-    void MarkItemsAsHap();
     uint32_t MergeResourceItem(const std::map<int64_t, std::vector<ResourceItem>> &resourceInfos);
     bool ScaleIcons(const std::string &output, const std::map<std::string, std::set<uint32_t>> &iconMap);
     void SetScanHap(bool state);

include/generic_compiler.h

@@ -24,17 +24,19 @@ namespace Global {
 namespace Restool {
 class GenericCompiler : public IResourceCompiler {
 public:
-    GenericCompiler(ResType type, const std::string &output);
+    GenericCompiler(ResType type, const std::string &output, bool isOverlap = false);
     virtual ~GenericCompiler();
+
 protected:
+    std::string GetOutputFilePath(const FileInfo &fileInfo) const;
+    virtual bool IsIgnore(const FileInfo &fileInfo);
     uint32_t CompileSingleFile(const FileInfo &fileInfo) override;
     uint32_t CompileFiles(const std::vector<FileInfo> &fileInfos) override;
     bool PostMediaFile(const FileInfo &fileInfo, const std::string &output);
-private:
-    std::string GetOutputFilePath(const FileInfo &fileInfo) const;
-    bool IsIgnore(const FileInfo &fileInfo);
-    bool CopyMediaFile(const FileInfo &fileInfo, std::string &output);
     std::mutex mutex_;
+
+private:
+    bool CopyMediaFile(const FileInfo &fileInfo, std::string &output);
 };
 }
 }

include/i_resource_compiler.h

@@ -25,7 +25,7 @@ namespace Global {
 namespace Restool {
 class IResourceCompiler {
 public:
-    IResourceCompiler(ResType type, const std::string &output);
+    IResourceCompiler(ResType type, const std::string &output, bool isOverlap = false);
     virtual ~IResourceCompiler();
     uint32_t Compile(const std::vector<DirectoryInfo> &directoryInfos);
     const std::map<int64_t, std::vector<ResourceItem>> &GetResult() const;
@@ -33,7 +33,6 @@ public:
     void SetModuleName(const std::string &moduleName);
     uint32_t CompileForAppend(const FileInfo &fileInfo);
     const std::map<std::pair<ResType, std::string>, std::vector<ResourceItem>> &GetResourceItems() const;
-    void SetHapRes(bool state);
 
 protected:
     virtual uint32_t CompileSingleFile(const FileInfo &fileInfo);
@@ -43,7 +42,7 @@ protected:
     ResType type_;
     std::string output_;
     std::string moduleName_;
-    bool hapRes_ = false;
+    bool isOverlap_;
 
     // id, resource items
     std::map<int64_t, std::vector<ResourceItem>> resourceInfos_;

include/json_compiler.h

@@ -26,7 +26,7 @@ namespace Global {
 namespace Restool {
 class JsonCompiler : public IResourceCompiler {
 public:
-    JsonCompiler(ResType type, const std::string &output);
+    JsonCompiler(ResType type, const std::string &output, bool isOverlap = false);
     virtual ~JsonCompiler();
 protected:
     uint32_t CompileSingleFile(const FileInfo &fileInfo) override;

include/overlap_binary_file_packer.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_RESTOOL_OVERLAP_BINARY_FILE_PACKER_H
+#define OHOS_RESTOOL_OVERLAP_BINARY_FILE_PACKER_H
+
+#include "binary_file_packer.h"
+
+namespace OHOS {
+namespace Global {
+namespace Restool {
+class OverlapBinaryFilePacker : public BinaryFilePacker {
+public:
+    OverlapBinaryFilePacker(const PackageParser &packageParser, const std::string &moduleName);
+
+protected:
+    uint32_t CopyBinaryFile(const std::vector<std::string> &inputs);
+    bool IsDuplicated(const std::unique_ptr<FileEntry> &entry, std::string subPath);
+};
+}
+}
+}
+#endif

include/overlap_compiler.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_RESTOOL_OVERLAP_COMPILER_H
+#define OHOS_RESTOOL_OVERLAP_COMPILER_H
+
+#include "generic_compiler.h"
+
+namespace OHOS {
+namespace Global {
+namespace Restool {
+class OverlapCompiler : public GenericCompiler {
+public:
+    OverlapCompiler(ResType type, const std::string &output, bool isOverlap = false);
+
+protected:
+    bool IsIgnore(const FileInfo &fileInfo);
+};
+}
+}
+}
+#endif

include/resource_data.h

@@ -49,7 +49,7 @@ const static std::string SOLUTIONS_ARROW = "> ";
 const static std::string LONG_PATH_HEAD = "\\\\?\\";
 const static int32_t VERSION_MAX_LEN = 128;
 const static int32_t INT_TO_BYTES = sizeof(uint32_t);
-static const int8_t RESTOOL_VERSION[VERSION_MAX_LEN] = { "Restool 5.012" };
+static const int8_t RESTOOL_VERSION[VERSION_MAX_LEN] = { "Restool 5.1.0.002" };
 const static int32_t TAG_LEN = 4;
 static std::set<std::string> g_resourceSet;
 static std::set<std::string> g_hapResourceSet;
@@ -93,6 +93,11 @@ enum class ResType {
     INVALID_RES_TYPE = -1,
 };
 
+enum class PackType {
+    NORMAL = 1,
+    OVERLAP
+};
+
 enum class OrientationType {
     VERTICAL = 0,
     HORIZONTAL = 1,

include/resource_item.h

@@ -34,7 +34,7 @@ public:
     void SetFilePath(const std::string &filePath);
     void SetLimitKey(const std::string &limitKey);
     void SetName(const std::string &name);
-    void MarkHapRes();
+    void MarkCoverable();
 
     const int8_t *GetData() const;
     uint32_t GetDataLength() const;
@@ -43,7 +43,7 @@ public:
     const std::vector<KeyParam> &GetKeyParam() const;
     const std::string &GetFilePath() const;
     const std::string &GetLimitKey() const;
-    bool IsHapRes() const;
+    bool IsCoverable() const;
 
     ResourceItem &operator=(const ResourceItem &other);
 private:
@@ -56,7 +56,7 @@ private:
     ResType type_;
     std::string filePath_;
     std::string limitKey_;
-    bool hapRes_ = false;
+    bool coverable_ = false;
 };
 }
 }

include/resource_overlap.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_RESTOOL_RESOURCE_OVERLAP_H
+#define OHOS_RESTOOL_RESOURCE_OVERLAP_H
+
+#include "cmd_parser.h"
+#include "resource_pack.h"
+
+namespace OHOS {
+namespace Global {
+namespace Restool {
+class ResourceOverlap : public ResourcePack {
+public:
+    ResourceOverlap(const PackageParser &packageParser);
+    uint32_t Pack();
+
+protected:
+    uint32_t ScanResources(const std::vector<std::string> &inputs, const std::string &output);
+
+private:
+    uint32_t LoadHapResources();
+};
+}
+}
+}
+#endif

include/resource_pack.h

@@ -27,19 +27,22 @@
 namespace OHOS {
 namespace Global {
 namespace Restool {
-enum class PackType {
-    NORMAL = 1,
-    OVERLAP
-};
-
 class ResourcePack {
 public:
     explicit ResourcePack(const PackageParser &packageParser);
     virtual ~ResourcePack() = default;
     uint32_t Package();
+    virtual uint32_t Pack();
+
+protected:
+    uint32_t InitResourcePack();
+    uint32_t PackResources(const ResourceMerge &resourceMerge);
+    virtual uint32_t ScanResources(const std::vector<std::string> &inputs, const std::string &output);
+    PackageParser packageParser_;
+    std::string moduleName_;
+    ConfigParser configJson_;
 
 private:
-    uint32_t InitResourcePack();
     uint32_t InitModule();
     void InitHeaderCreater();
     uint32_t InitOutput() const;
@@ -50,10 +53,6 @@ private:
     uint32_t GenerateCplusHeader(const std::string &headerPath) const;
     uint32_t GenerateJsHeader(const std::string &headerPath) const;
     uint32_t GenerateConfigJson();
-    uint32_t ScanResources(const std::vector<std::string> &inputs, const std::string &output);
-    uint32_t Pack();
-    uint32_t PackResources(const ResourceMerge &resourceMerge);
-    uint32_t LoadHapResources();
     uint32_t PackPreview();
     uint32_t PackAppend();
     uint32_t PackCombine();
@@ -66,11 +65,8 @@ private:
     void CheckConfigJson();
     void CheckConfigJsonForCombine(ResourceAppend &resourceAppend);
     bool CopyIcon(std::string &dataPath, const std::string &idName, std::string &fileName) const;
-    PackageParser packageParser_;
-    std::string moduleName_;
     using HeaderCreater = std::function<uint32_t(const std::string&)>;
     std::map<std::string, HeaderCreater> headerCreaters_;
-    ConfigParser configJson_;
     PackType packType_ = PackType::NORMAL;
 };
 }

src/binary_file_packer.cpp

@@ -39,62 +39,35 @@ void BinaryFilePacker::StopCopy()
     stopCopy_.store(true);
 }
 
-void BinaryFilePacker::SetCopyHap(bool state)
-{
-    copyHap_ = state;
-}
-
 std::future<uint32_t> BinaryFilePacker::CopyBinaryFileAsync(const std::vector<std::string> &inputs)
 {
-    if (copyHap_) {
-        auto func = [this](const vector<string> &inputs) { return this->CopyBinaryFileWithHap(inputs); };
-        future<uint32_t> res = threadPool_.Enqueue(func, inputs);
-        return res;
-    }
     auto func = [this](const vector<string> &inputs) { return this->CopyBinaryFile(inputs); };
     std::future<uint32_t> res = threadPool_.Enqueue(func, inputs);
     return res;
 }
 
-uint32_t BinaryFilePacker::CopyBinaryFileWithHap(const vector<string> &inputs)
+uint32_t BinaryFilePacker::CopyBinaryFile(const vector<string> &inputs)
 {
-    vector<string> hapResource{inputs[0]};
-    if (CopyBinaryFile(hapResource) != RESTOOL_SUCCESS) {
-        return RESTOOL_ERROR;
+    for (const auto &input : inputs) {
+        CopyBinaryFile(input);
     }
-    copyResults_.clear();
-    SetCopyHap(false);
-
-    vector<string> resource(inputs.begin() + 1, inputs.end());
-    if (CopyBinaryFile(resource) != RESTOOL_SUCCESS) {
+    if (CheckCopyResults() != RESTOOL_SUCCESS) {
         return RESTOOL_ERROR;
     }
     return RESTOOL_SUCCESS;
 }
 
-uint32_t BinaryFilePacker::CopyBinaryFile(const vector<string> &inputs)
+uint32_t BinaryFilePacker::CopyBinaryFile(const string &input)
 {
-    for (const auto &input : inputs) {
-        string rawfilePath = FileEntry::FilePath(input).Append(RAW_FILE_DIR).GetPath();
-        if (CopyBinaryFile(rawfilePath, RAW_FILE_DIR) == RESTOOL_ERROR) {
-            cerr << "Error: copy raw file failed." << NEW_LINE_PATH << rawfilePath << endl;
-            return RESTOOL_ERROR;
-        }
-        string resfilePath = FileEntry::FilePath(input).Append(RES_FILE_DIR).GetPath();
-        if (CopyBinaryFile(resfilePath, RES_FILE_DIR) == RESTOOL_ERROR) {
-            cerr << "Error: copy res file failed." << NEW_LINE_PATH << resfilePath << endl;
-            return RESTOOL_ERROR;
-        }
+    string rawfilePath = FileEntry::FilePath(input).Append(RAW_FILE_DIR).GetPath();
+    if (CopyBinaryFile(rawfilePath, RAW_FILE_DIR) == RESTOOL_ERROR) {
+        cerr << "Error: copy raw file failed." << NEW_LINE_PATH << rawfilePath << endl;
+        return RESTOOL_ERROR;
     }
-    for (auto &res : copyResults_) {
-        if (stopCopy_.load()) {
-            cout << "Info: CopyBinaryFile: stop copy binary file." << endl;
-            return RESTOOL_ERROR;
-        }
-        uint32_t ret = res.get();
-        if (ret != RESTOOL_SUCCESS) {
-            return RESTOOL_ERROR;
-        }
+    string resfilePath = FileEntry::FilePath(input).Append(RES_FILE_DIR).GetPath();
+    if (CopyBinaryFile(resfilePath, RES_FILE_DIR) == RESTOOL_ERROR) {
+        cerr << "Error: copy res file failed." << NEW_LINE_PATH << resfilePath << endl;
+        return RESTOOL_ERROR;
     }
     return RESTOOL_SUCCESS;
 }
@@ -142,7 +115,7 @@ uint32_t BinaryFilePacker::CopyBinaryFileImpl(const string &src, const string &d
             continue;
         }
 
-        if (IsDefinedFile(entry, subPath)) {
+        if (IsDuplicated(entry, subPath)) {
             continue;
         }
 
@@ -159,20 +132,12 @@ uint32_t BinaryFilePacker::CopyBinaryFileImpl(const string &src, const string &d
     return RESTOOL_SUCCESS;
 }
 
-bool BinaryFilePacker::IsDefinedFile(const unique_ptr<FileEntry> &entry, string subPath)
+bool BinaryFilePacker::IsDuplicated(const unique_ptr<FileEntry> &entry, string subPath)
 {
     lock_guard<mutex> lock(mutex_);
-    bool resEmplaceSuccess = true;
-    if (copyHap_) {
-        g_hapResourceSet.emplace(subPath);
-        g_resourceSet.emplace(subPath);
-    } else if (g_hapResourceSet.count(subPath)) {
+    if (g_hapResourceSet.count(subPath)) {
         g_hapResourceSet.erase(subPath);
-    } else {
-        resEmplaceSuccess = g_resourceSet.emplace(subPath).second;
-    }
-    
-    if (!resEmplaceSuccess) {
+    } else if (!g_resourceSet.emplace(subPath).second) {
         cerr << "Warning: '" << entry->GetFilePath().GetPath() << "' is defined repeatedly." << endl;
         return true;
     }
@@ -194,6 +159,22 @@ uint32_t BinaryFilePacker::CopySingleFile(const std::string &path, std::string &
     }
     return RESTOOL_SUCCESS;
 }
+
+uint32_t BinaryFilePacker::CheckCopyResults()
+{
+    for (auto &res : copyResults_) {
+        if (stopCopy_.load()) {
+            cout << "Info: CopyBinaryFile: stop copy binary file." << endl;
+            return RESTOOL_ERROR;
+        }
+        uint32_t ret = res.get();
+        if (ret != RESTOOL_SUCCESS) {
+            cerr << "Error: copy binary file failed." << endl;
+            return RESTOOL_ERROR;
+        }
+    }
+    return RESTOOL_SUCCESS;
+}
 } // namespace Restool
 } // namespace Global
 } // namespace OHOS

src/cmd_parser.cpp

@@ -135,7 +135,13 @@ uint32_t PackageParser::AddInput(const string& argValue)
     if (!IsAscii(inputPath)) {
         return RESTOOL_ERROR;
     }
-    inputs_.push_back(inputPath);
+
+    string indexPath = ResourceUtil::GetMainPath(inputPath).Append(RESOURCE_INDEX_FILE).GetPath();
+    if (ResourceUtil::FileExist(indexPath)) {
+        inputs_.emplace(inputs_.begin(), inputPath);
+    } else {
+        inputs_.push_back(inputPath);
+    }
     return RESTOOL_SUCCESS;
 }
 
@@ -444,15 +450,11 @@ const std::string &PackageParser::GetCompressionPath() const
     return compressionPath_;
 }
 
-bool PackageParser::ExistHapInput()
+bool PackageParser::IsOverlap() const
 {
-    for (auto &input : inputs_) {
-        string indexPath = ResourceUtil::GetMainPath(input).Append(RESOURCE_INDEX_FILE).GetPath();
-        if (ResourceUtil::FileExist(indexPath)) {
-            inputs_.erase(find(inputs_.begin(), inputs_.end(), input));
-            inputs_.emplace(inputs_.begin(), input);
-            return true;
-        }
+    string indexPath = ResourceUtil::GetMainPath(inputs_[0]).Append(RESOURCE_INDEX_FILE).GetPath();
+    if (ResourceUtil::FileExist(indexPath)) {
+        return true;
     }
     return false;
 }

src/factory_resource_compiler.cpp

@@ -17,17 +17,21 @@
 #include "append_compiler.h"
 #include "generic_compiler.h"
 #include "json_compiler.h"
+#include "overlap_compiler.h"
 
 namespace OHOS {
 namespace Global {
 namespace Restool {
 using namespace std;
-unique_ptr<IResourceCompiler> FactoryResourceCompiler::CreateCompiler(ResType type, const string &output)
+unique_ptr<IResourceCompiler> FactoryResourceCompiler::CreateCompiler(ResType type,
+    const string &output, bool isOverlap)
 {
     if (type == ResType::ELEMENT) {
-        return make_unique<JsonCompiler>(type, output);
+        return make_unique<JsonCompiler>(type, output, isOverlap);
+    } else if (isOverlap) {
+        return make_unique<OverlapCompiler>(type, output, isOverlap);
     } else {
-        return make_unique<GenericCompiler>(type, output);
+        return make_unique<GenericCompiler>(type, output, isOverlap);
     }
 }
 

src/factory_resource_packer.cpp

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "factory_resource_packer.h"
+#include "resource_overlap.h"
+
+namespace OHOS {
+namespace Global {
+namespace Restool {
+using namespace std;
+
+unique_ptr<ResourcePack> FactoryResourcePacker::CreatePacker(PackType type, const PackageParser &packageParser)
+{
+    if (type == PackType::NORMAL) {
+        return make_unique<ResourcePack>(packageParser);
+    } else if (type == PackType::OVERLAP) {
+        return make_unique<ResourceOverlap>(packageParser);
+    } else {
+        cerr << "Error: FactoryResourcePacker: Unknown input PackType." << endl;
+        return nullptr;
+    }
+}
+}
+}
+}

src/file_manager.cpp

@@ -42,21 +42,9 @@ uint32_t FileManager::ScanModules(const vector<string> &inputs, const string &ou
     if (!noBaseResource.empty()) {
         ResourceUtil::PrintWarningMsg(noBaseResource);
     }
-    if (scanHap_) {
-        MarkItemsAsHap();
-    }
     return isHar || scanHap_ ? RESTOOL_SUCCESS : ParseReference(output);
 }
 
-void FileManager::MarkItemsAsHap()
-{
-    for (auto &item : items_) {
-        for (auto &resourceItem : item.second) {
-            resourceItem.MarkHapRes();
-        }
-    }
-}
-
 uint32_t FileManager::MergeResourceItem(const map<int64_t, vector<ResourceItem>> &resourceInfos)
 {
     return ResourceModule::MergeResourceItem(items_, resourceInfos);

src/generic_compiler.cpp

@@ -25,8 +25,8 @@ namespace OHOS {
 namespace Global {
 namespace Restool {
 using namespace std;
-GenericCompiler::GenericCompiler(ResType type, const string &output)
-    : IResourceCompiler(type, output)
+GenericCompiler::GenericCompiler(ResType type, const string &output, bool isOverlap)
+    : IResourceCompiler(type, output, isOverlap)
 {
 }
 GenericCompiler::~GenericCompiler()
@@ -87,6 +87,11 @@ bool GenericCompiler::PostMediaFile(const FileInfo &fileInfo, const std::string
         cerr << "Error: resource item set data fail, data: " << data << NEW_LINE_PATH << fileInfo.filePath << endl;
         return false;
     }
+
+    if (isOverlap_) {
+        resourceItem.MarkCoverable();
+    }
+
     return MergeResourceItem(resourceItem);
 }
 
@@ -99,19 +104,11 @@ string GenericCompiler::GetOutputFilePath(const FileInfo &fileInfo) const
 
 bool GenericCompiler::IsIgnore(const FileInfo &fileInfo)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    lock_guard<mutex> lock(mutex_);
     string output = GetOutputFilePath(fileInfo);
-    bool resEmplaceSuccess = true;
-    if (hapRes_) {
-        g_hapResourceSet.emplace(output);
-        g_resourceSet.emplace(output);
-    } else if (g_hapResourceSet.count(output)) {
+    if (g_hapResourceSet.count(output)) {
         g_hapResourceSet.erase(output);
-    } else {
-        resEmplaceSuccess = g_resourceSet.emplace(output).second;
-    }
-
-    if (!resEmplaceSuccess) {
+    } else if (!g_resourceSet.emplace(output).second) {
         cerr << "Warning: '" << fileInfo.filePath << "' is defined repeatedly." << endl;
         return true;
     }

src/i_resource_compiler.cpp

@@ -25,8 +25,8 @@ namespace OHOS {
 namespace Global {
 namespace Restool {
 using namespace std;
-IResourceCompiler::IResourceCompiler(ResType type, const string &output)
-    :type_(type), output_(output)
+IResourceCompiler::IResourceCompiler(ResType type, const string &output, bool isOverlap)
+    :type_(type), output_(output), isOverlap_(isOverlap)
 {
 }
 
@@ -104,11 +104,6 @@ const map<pair<ResType, string>, vector<ResourceItem>> &IResourceCompiler::GetRe
     return nameInfos_;
 }
 
-void IResourceCompiler::SetHapRes(bool state)
-{
-    hapRes_ = state;
-}
-
 void IResourceCompiler::SetModuleName(const string &moduleName)
 {
     moduleName_ = moduleName;
@@ -157,7 +152,6 @@ bool IResourceCompiler::MergeResourceItem(const ResourceItem &resourceItem)
         cerr << "but declare again." << NEW_LINE_PATH << resourceItem.GetFilePath() << endl;
         return false;
     }
-
     nameInfos_[make_pair(resourceItem.GetResType(), idName)].push_back(resourceItem);
     return true;
 }

src/json_compiler.cpp

@@ -31,8 +31,8 @@ const string TAG_QUANTITY = "quantity";
 const vector<string> QUANTITY_ATTRS = { "zero", "one", "two", "few", "many", "other" };
 const vector<string> TRANSLATION_TYPE = { "string", "strarray", "plural" };
 
-JsonCompiler::JsonCompiler(ResType type, const string &output)
-    : IResourceCompiler(type, output), isBaseString_(false), root_(nullptr)
+JsonCompiler::JsonCompiler(ResType type, const string &output, bool isOverlap)
+    : IResourceCompiler(type, output, isOverlap), isBaseString_(false), root_(nullptr)
 {
     InitParser();
 }
@@ -157,6 +157,10 @@ bool JsonCompiler::ParseJsonObjectLevel(cJSON *objectNode, const FileInfo &fileI
         return false;
     }
 
+    if (isOverlap_) {
+        resourceItem.MarkCoverable();
+    }
+
     return MergeResourceItem(resourceItem);
 }
 

src/overlap_binary_file_packer.cpp

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "overlap_binary_file_packer.h"
+
+namespace OHOS {
+namespace Global {
+namespace Restool {
+using namespace std;
+
+OverlapBinaryFilePacker::OverlapBinaryFilePacker(const PackageParser &packageParser, const std::string &moduleName)
+    : BinaryFilePacker(packageParser, moduleName)
+{
+}
+
+uint32_t OverlapBinaryFilePacker::CopyBinaryFile(const vector<string> &inputs)
+{
+    string hapPath = inputs[0];
+    BinaryFilePacker::CopyBinaryFile(hapPath);
+    if (CheckCopyResults() != RESTOOL_SUCCESS) {
+        return RESTOOL_ERROR;
+    }
+
+    vector<string> resource(inputs.begin() + 1, inputs.end());
+    BinaryFilePacker rawFilePacker(packageParser_, moduleName_);
+    std::future<uint32_t> copyFuture = rawFilePacker.CopyBinaryFileAsync(resource);
+    if (copyFuture.get() != RESTOOL_SUCCESS) {
+        cerr << "Error: copy binary file failed." << endl;
+        return RESTOOL_ERROR;
+    }
+    return RESTOOL_SUCCESS;
+}
+
+bool OverlapBinaryFilePacker::IsDuplicated(const unique_ptr<FileEntry> &entry, string subPath)
+{
+    lock_guard<mutex> lock(mutex_);
+    if (!g_hapResourceSet.emplace(subPath).second || !g_resourceSet.emplace(subPath).second) {
+        cerr << "Warning: '" << entry->GetFilePath().GetPath() << "' is defined repeatedly in hap." << endl;
+        return true;
+    }
+    return false;
+}
+}
+}
+}

src/overlap_compiler.cpp

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "overlap_compiler.h"
+#include <iostream>
+
+namespace OHOS {
+namespace Global {
+namespace Restool {
+using namespace std;
+
+OverlapCompiler::OverlapCompiler(ResType type, const std::string &output, bool isOverlap)
+    : GenericCompiler(type, output, isOverlap)
+{
+}
+
+bool OverlapCompiler::IsIgnore(const FileInfo &fileInfo)
+{
+    lock_guard<mutex> lock(mutex_);
+    string output = GetOutputFilePath(fileInfo);
+    if (!g_hapResourceSet.emplace(output).second || !g_resourceSet.emplace(output).second) {
+        cerr << "Warning: '" << fileInfo.filePath << "' is defined repeatedly." << endl;
+        return true;
+    }
+    return false;
+}
+}
+}
+}

src/resource_item.cpp

@@ -85,9 +85,9 @@ void ResourceItem::SetName(const string &name)
     name_ = name;
 }
 
-void ResourceItem::MarkHapRes()
+void ResourceItem::MarkCoverable()
 {
-    hapRes_ = true;
+    coverable_ = true;
 }
 
 const int8_t *ResourceItem::GetData() const
@@ -125,9 +125,9 @@ const string &ResourceItem::GetLimitKey() const
     return limitKey_;
 }
 
-bool ResourceItem::IsHapRes() const
+bool ResourceItem::IsCoverable() const
 {
-    return hapRes_;
+    return coverable_;
 }
 
 ResourceItem &ResourceItem::operator=(const ResourceItem &other)
@@ -157,7 +157,7 @@ void ResourceItem::CopyFrom(const ResourceItem &other)
     dataLen_ = other.dataLen_;
     filePath_ = other.filePath_;
     limitKey_ = other.limitKey_;
-    hapRes_ = other.hapRes_;
+    coverable_ = other.coverable_;
     if (!SetData(other.data_, other.dataLen_)) {
         ReleaseData();
     }

src/resource_module.cpp

@@ -54,11 +54,8 @@ uint32_t ResourceModule::ScanResource(bool isHap)
         }
 
         unique_ptr<IResourceCompiler> resourceCompiler =
-            FactoryResourceCompiler::CreateCompiler(type, moduleOutput_);
+            FactoryResourceCompiler::CreateCompiler(type, moduleOutput_, isHap);
         resourceCompiler->SetModuleName(moduleName_);
-        if (isHap) {
-            resourceCompiler->SetHapRes(true);
-        }
         if (resourceCompiler->Compile(item->second) != RESTOOL_SUCCESS) {
             return RESTOOL_ERROR;
         }
@@ -94,7 +91,7 @@ uint32_t ResourceModule::MergeResourceItem(map<int64_t, vector<ResourceItem>> &a
                 result.first->second.push_back(resourceItem);
                 continue;
             }
-            if (ret->IsHapRes()) { // overlap the hap resource by new resource
+            if (ret->IsCoverable()) { // overlap the hap resource by new resource
                 *ret = resourceItem;
                 continue;
             }

src/resource_overlap.cpp

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <future>
+#include "resource_overlap.h"
+#include "overlap_binary_file_packer.h"
+#include "file_manager.h"
+#include "resource_table.h"
+#include "id_worker.h"
+
+namespace OHOS {
+namespace Global {
+namespace Restool {
+using namespace std;
+
+ResourceOverlap::ResourceOverlap(const PackageParser &packageParser) : ResourcePack(packageParser)
+{
+}
+
+uint32_t ResourceOverlap::Pack()
+{
+    cout << "Info: Pack: overlap pack mode" << endl;
+
+    if (InitResourcePack() != RESTOOL_SUCCESS) {
+        cerr << "Error: ResourcePack init failed." << endl;
+        return RESTOOL_ERROR;
+    }
+
+    ResourceMerge resourceMerge;
+    if (resourceMerge.Init(packageParser_) != RESTOOL_SUCCESS) {
+        cerr << "Error: resourceMerge init failed." << endl;
+        return RESTOOL_ERROR;
+    }
+
+    OverlapBinaryFilePacker rawFilePacker(packageParser_, moduleName_);
+    future<uint32_t> copyFuture = rawFilePacker.CopyBinaryFileAsync(resourceMerge.GetInputs());
+
+    if (LoadHapResources() != RESTOOL_SUCCESS) {
+        rawFilePacker.StopCopy();
+        cerr << "Error: load hap resources failed." << endl;
+        return RESTOOL_ERROR;
+    }
+
+    if (PackResources(resourceMerge) != RESTOOL_SUCCESS) {
+        rawFilePacker.StopCopy();
+        cerr << "Error: pack resources failed." << endl;
+        return RESTOOL_ERROR;
+    }
+
+    if (copyFuture.get() != RESTOOL_SUCCESS) {
+        cerr << "Error: copy binary file failed." << endl;
+        return RESTOOL_ERROR;
+    }
+    return RESTOOL_SUCCESS;
+}
+
+uint32_t ResourceOverlap::ScanResources(const std::vector<std::string> &inputs, const std::string &output)
+{
+    auto &fileManager = FileManager::GetInstance();
+    fileManager.SetModuleName(moduleName_);
+    vector<string> hapResInput{inputs[0]};
+    if (fileManager.ScanModules(hapResInput, output, configJson_.IsHar()) != RESTOOL_SUCCESS) {
+        cerr << "Error: scan hap error" << endl;
+        return RESTOOL_ERROR;
+    }
+    fileManager.SetScanHap(false);
+
+    vector<string> resInputs(inputs.begin() + 1, inputs.end());
+    if (fileManager.ScanModules(resInputs, output, configJson_.IsHar()) != RESTOOL_SUCCESS) {
+        cerr << "Error: scan resources error" << endl;
+        return RESTOOL_ERROR;
+    }
+    return RESTOOL_SUCCESS;
+}
+
+uint32_t ResourceOverlap::LoadHapResources()
+{
+    ResourceTable resourceTabel;
+    map<int64_t, vector<ResourceItem>> items;
+    string resourceIndexPath =
+        FileEntry::FilePath(packageParser_.GetInputs()[0]).GetParent().Append(RESOURCE_INDEX_FILE).GetPath();
+    if (resourceTabel.LoadResTable(resourceIndexPath, items) != RESTOOL_SUCCESS) {
+        return RESTOOL_ERROR;
+    }
+    
+    IdWorker::GetInstance().LoadIdFromHap(items);
+
+    FileManager &fileManager = FileManager::GetInstance();
+    fileManager.SetModuleName(moduleName_);
+    if (fileManager.MergeResourceItem(items) != RESTOOL_SUCCESS) {
+        return RESTOOL_ERROR;
+    }
+    fileManager.SetScanHap(true);
+    return RESTOOL_SUCCESS;
+}
+}
+}
+}

src/resource_pack.cpp

@@ -24,6 +24,7 @@
 #include "resource_table.h"
 #include "compression_parser.h"
 #include "binary_file_packer.h"
+#include "factory_resource_packer.h"
 
 namespace OHOS {
 namespace Global {
@@ -43,10 +44,13 @@ uint32_t ResourcePack::Package()
         return PackCombine();
     }
 
-    if (packageParser_.ExistHapInput()) {
+    if (packageParser_.IsOverlap()) {
         packType_ = PackType::OVERLAP;
     }
-    return Pack();
+
+    unique_ptr<ResourcePack> resourcePacker =
+            FactoryResourcePacker::CreatePacker(packType_, packageParser_);
+    return resourcePacker->Pack();
 }
 
 uint32_t ResourcePack::InitCompression()
@@ -280,32 +284,15 @@ uint32_t ResourcePack::ScanResources(const vector<string> &inputs, const string
 {
     auto &fileManager = FileManager::GetInstance();
     fileManager.SetModuleName(moduleName_);
-    if (packType_ == PackType::OVERLAP) {
-        vector<string> hapResInput{inputs[0]};
-        if (fileManager.ScanModules(hapResInput, output, configJson_.IsHar()) != RESTOOL_SUCCESS) {
-            return RESTOOL_ERROR;
-        }
-        fileManager.SetScanHap(false);
-
-        vector<string> resInputs(inputs.begin() + 1, inputs.end());
-        if (fileManager.ScanModules(resInputs, output, configJson_.IsHar()) != RESTOOL_SUCCESS) {
-            return RESTOOL_ERROR;
-        }
-    } else {
-        if (fileManager.ScanModules(inputs, output, configJson_.IsHar()) != RESTOOL_SUCCESS) {
-            return RESTOOL_ERROR;
-        }
+    if (fileManager.ScanModules(inputs, output, configJson_.IsHar()) != RESTOOL_SUCCESS) {
+        return RESTOOL_ERROR;
     }
     return RESTOOL_SUCCESS;
 }
 
 uint32_t ResourcePack::Pack()
 {
-    if (packType_ == PackType::NORMAL) {
-        cout << "Info: Pack: normal pack mode" << endl;
-    } else if (packType_ == PackType::OVERLAP) {
-        cout << "Info: Pack: overlap pack mode" << endl;
-    }
+    cout << "Info: Pack: normal pack mode" << endl;
 
     if (InitResourcePack() != RESTOOL_SUCCESS) {
         cerr << "Error: ResourcePack init failed." << endl;
@@ -319,9 +306,6 @@ uint32_t ResourcePack::Pack()
     }
 
     BinaryFilePacker rawFilePacker(packageParser_, moduleName_);
-    if (packType_ == PackType::OVERLAP) {
-        rawFilePacker.SetCopyHap(true);
-    }
     std::future<uint32_t> copyFuture = rawFilePacker.CopyBinaryFileAsync(resourceMerge.GetInputs());
 
     if (PackResources(resourceMerge) != RESTOOL_SUCCESS) {
@@ -339,10 +323,6 @@ uint32_t ResourcePack::Pack()
 
 uint32_t ResourcePack::PackResources(const ResourceMerge &resourceMerge)
 {
-    if (packType_ == PackType::OVERLAP && LoadHapResources() != RESTOOL_SUCCESS) {
-        return RESTOOL_ERROR;
-    }
-
     if (ScanResources(resourceMerge.GetInputs(), packageParser_.GetOutput()) != RESTOOL_SUCCESS) {
         return RESTOOL_ERROR;
     }
@@ -379,28 +359,6 @@ uint32_t ResourcePack::PackResources(const ResourceMerge &resourceMerge)
     return RESTOOL_SUCCESS;
 }
 
-uint32_t ResourcePack::LoadHapResources()
-{
-    ResourceTable resourceTabel;
-    map<int64_t, vector<ResourceItem>> items;
-    string resourceIndexPath =
-        FileEntry::FilePath(packageParser_.GetInputs()[0]).GetParent().Append(RESOURCE_INDEX_FILE).GetPath();
-    if (resourceTabel.LoadResTable(resourceIndexPath, items) != RESTOOL_SUCCESS) {
-        return RESTOOL_ERROR;
-    }
-    
-    IdWorker::GetInstance().LoadIdFromHap(items);
-
-    FileManager &fileManager = FileManager::GetInstance();
-    fileManager.SetModuleName(moduleName_);
-    if (fileManager.MergeResourceItem(items) != RESTOOL_SUCCESS) {
-        return RESTOOL_ERROR;
-    }
-    fileManager.MarkItemsAsHap();
-    fileManager.SetScanHap(true);
-    return RESTOOL_SUCCESS;
-}
-
 uint32_t ResourcePack::HandleFeature()
 {
     string output = packageParser_.GetOutput();
@@ -620,7 +578,6 @@ void ResourcePack::CheckConfigJsonForCombine(ResourceAppend &resourceAppend)
     ResourceCheck resourceCheck(configJson_.GetCheckNode(), make_shared<ResourceAppend>(resourceAppend));
     resourceCheck.CheckConfigJsonForCombine();
 }
-
 }
 }
 }

src/resource_table.cpp

@@ -111,6 +111,7 @@ uint32_t ResourceTable::LoadResTable(const string path, map<int64_t, vector<Reso
     int64_t length = in.tellg();
     if (length <= 0) {
         in.close();
+        cerr << "Error: file is empty." << NEW_LINE_PATH << path <<endl;
         return RESTOOL_ERROR;
     }
     in.seekg(0, ios::beg);
@@ -497,6 +498,7 @@ bool ResourceTable::ReadDataRecordStart(std::ifstream &in, RecordItem &record,
         value_size--;
     }
     resourceitem.SetData(values, value_size);
+    resourceitem.MarkCoverable();
     resInfos[record.id].push_back(resourceitem);
     return true;
 }