# OpenHarmony平台libzip移植实践：交叉编译与HNP打包深度解析

## 一、OpenHarmony交叉编译环境构建

### 1.1 OpenHarmony SDK环境配置

```bash

# 下载并配置OpenHarmony NDK

# 获取最新OpenHarmony SDK

wget https://repo.huaweicloud.com/harmonyos/compiler/ohos-sdk/ohos-sdk-linux-3.2.11.9.tar.gz

tar -xzf ohos-sdk-linux-3.2.11.9.tar.gz -C /opt/

# 设置环境变量

export OHOS_SDK=/opt/ohos-sdk/linux

export OHOS_TOOLCHAIN=${OHOS_SDK}/native/llvm/bin

export OHOS_SYSROOT=${OHOS_SDK}/native/sysroot

export PATH=${OHOS_TOOLCHAIN}:$PATH

# 验证工具链

aarch64-linux-ohos-clang --version

llvm-ranlib --version

# 创建交叉编译配置文件

cat > ${OHOS_SDK}/ohos_config.cmake << EOF

# OpenHarmony 工具链配置

set(OHOS_ARCH "arm64-v8a")

set(OHOS_PLATFORM "ohos")

set(OHOS_SDK_ROOT "\${CMAKE_CURRENT_LIST_DIR}")

set(CMAKE_SYSTEM_NAME Generic)

set(CMAKE_SYSTEM_PROCESSOR aarch64)

set(CMAKE_C_COMPILER \${OHOS_SDK_ROOT}/native/llvm/bin/aarch64-linux-ohos-clang)

set(CMAKE_CXX_COMPILER \${OHOS_SDK_ROOT}/native/llvm/bin/aarch64-linux-ohos-clang++)

set(CMAKE_AR \${OHOS_SDK_ROOT}/native/llvm/bin/llvm-ar)

set(CMAKE_RANLIB \${OHOS_SDK_ROOT}/native/llvm/bin/llvm-ranlib)

set(CMAKE_STRIP \${OHOS_SDK_ROOT}/native/llvm/bin/llvm-strip)

# 系统根目录

set(CMAKE_SYSROOT \${OHOS_SDK_ROOT}/native/sysroot)

set(CMAKE_FIND_ROOT_PATH \${CMAKE_SYSROOT})

set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)

set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)

set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

# 编译标志

set(CMAKE_C_FLAGS "--target=aarch64-linux-ohos -march=armv8-a")

set(CMAKE_CXX_FLAGS "\${CMAKE_C_FLAGS} -std=c++17")

set(CMAKE_EXE_LINKER_FLAGS "-fuse-ld=lld -Wl,--gc-sections")

EOF

```

### 1.2 构建系统基础组件

```python

# build.py - OpenHarmony构建脚本框架

#!/usr/bin/env python3

"""

OpenHarmony libzip构建自动化脚本

"""

import os

import sys

import shutil

import subprocess

from pathlib import Path

class OpenHarmonyBuilder:

    def __init__(self, config_path="build_config.json"):

        self.project_root = Path(__file__).parent.absolute()

        self.config = self.load_config(config_path)

        self.setup_environment()

    

    def load_config(self, config_path):

        """加载构建配置"""

        import json

        config_file = self.project_root / config_path

        

        default_config = {

            "sdk_path": "/opt/ohos-sdk/linux",

            "target_arch": "arm64-v8a",

            "api_level": 9,

            "build_type": "Release",

            "install_prefix": "./output/ohos",

            "dependencies": {

                "zlib": "1.2.13",

                "openssl": "3.0.8",

                "bzip2": "1.0.8"

            }

        }

        

        if config_file.exists():

            with open(config_file, 'r') as f:

                user_config = json.load(f)

                default_config.update(user_config)

        

        return default_config

    

    def setup_environment(self):

        """设置交叉编译环境"""

        os.environ['OHOS_SDK'] = self.config['sdk_path']

        os.environ['OHOS_TOOLCHAIN'] = f"{self.config['sdk_path']}/native/llvm/bin"

        os.environ['OHOS_SYSROOT'] = f"{self.config['sdk_path']}/native/sysroot"

        

        # 添加到PATH

        toolchain_path = os.environ['OHOS_TOOLCHAIN']

        if toolchain_path not in os.environ['PATH']:

            os.environ['PATH'] = f"{toolchain_path}:{os.environ['PATH']}"

        

        print(f"环境配置完成:")

        print(f"  SDK路径: {self.config['sdk_path']}")

        print(f"  目标架构: {self.config['target_arch']}")

    

    def run_cmd(self, cmd, cwd=None):

        """执行命令并检查结果"""

        print(f"执行: {cmd}")

        result = subprocess.run(

            cmd,

            shell=True,

            cwd=cwd or self.project_root,

            capture_output=True,

            text=True

        )

        

        if result.returncode != 0:

            print(f"错误: {result.stderr}")

            raise RuntimeError(f"命令执行失败: {cmd}")

        

        return result.stdout

# 主构建流程

if __name__ == "__main__":

    builder = OpenHarmonyBuilder()

    print("OpenHarmony构建环境就绪")

```

## 二、依赖库的交叉编译适配

### 2.1 zlib库编译适配

```bash

#!/bin/bash

# build_zlib_ohos.sh - zlib OpenHarmony交叉编译

# 设置变量

ZLIB_VERSION="1.2.13"

SOURCE_DIR="zlib-${ZLIB_VERSION}"

BUILD_DIR="build_ohos"

INSTALL_DIR="$(pwd)/output/ohos"

# 下载源码

if [ ! -d "${SOURCE_DIR}" ]; then

    wget https://zlib.net/zlib-${ZLIB_VERSION}.tar.gz

    tar -xzf zlib-${ZLIB_VERSION}.tar.gz

fi

# 创建构建目录

mkdir -p ${BUILD_DIR}

cd ${BUILD_DIR}

# 配置环境

export CC=aarch64-linux-ohos-clang

export CXX=aarch64-linux-ohos-clang++

export AR=llvm-ar

export RANLIB=llvm-ranlib

export STRIP=llvm-strip

export CFLAGS="--target=aarch64-linux-ohos -march=armv8-a -fPIC -O2"

export CXXFLAGS="${CFLAGS} -std=c++17"

export LDFLAGS="-fuse-ld=lld -static-libstdc++"

# 运行CMake配置

cmake ../${SOURCE_DIR} \

    -DCMAKE_SYSTEM_NAME=Generic \

    -DCMAKE_SYSTEM_PROCESSOR=aarch64 \

    -DCMAKE_C_COMPILER=${CC} \

    -DCMAKE_CXX_COMPILER=${CXX} \

    -DCMAKE_AR=${AR} \

    -DCMAKE_RANLIB=${RANLIB} \

    -DCMAKE_STRIP=${STRIP} \

    -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR} \

    -DCMAKE_BUILD_TYPE=Release \

    -DBUILD_SHARED_LIBS=OFF \

    -DSKIP_INSTALL_FILES=OFF

# 编译和安装

make -j$(nproc)

make install

echo "zlib编译完成，安装到: ${INSTALL_DIR}"

# 验证编译结果

file ${INSTALL_DIR}/lib/libz.a

```

### 2.2 CMake工具链文件编写

```cmake

# ohos_toolchain.cmake - OpenHarmony专用工具链配置

set(CMAKE_SYSTEM_NAME Generic)

set(CMAKE_SYSTEM_PROCESSOR aarch64)

# 编译器设置

set(CMAKE_C_COMPILER aarch64-linux-ohos-clang)

set(CMAKE_CXX_COMPILER aarch64-linux-ohos-clang++)

set(CMAKE_AR llvm-ar CACHE FILEPATH "Archiver")

set(CMAKE_RANLIB llvm-ranlib CACHE FILEPATH "Ranlib")

set(CMAKE_STRIP llvm-strip CACHE FILEPATH "Strip")

set(CMAKE_NM llvm-nm CACHE FILEPATH "Nm")

# 编译标志

set(COMMON_FLAGS "--target=aarch64-linux-ohos -march=armv8-a")

set(CMAKE_C_FLAGS "${COMMON_FLAGS} -fPIC -O2 -DOHOS_BUILD" CACHE STRING "C flags")

set(CMAKE_CXX_FLAGS "${COMMON_FLAGS} -fPIC -O2 -std=c++17 -DOHOS_BUILD" CACHE STRING "C++ flags")

set(CMAKE_EXE_LINKER_FLAGS "-fuse-ld=lld -static-libstdc++" CACHE STRING "Linker flags")

set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}" CACHE STRING "Shared linker flags")

# 查找路径配置

set(CMAKE_FIND_ROOT_PATH "/opt/ohos-sdk/linux/native/sysroot")

set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)

set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)

set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

# OpenHarmony特定定义

add_definitions(-D_OHOS_ -D__OHOS__ -D__OPENHARMONY__)

# 系统信息

set(OHOS TRUE)

set(OHOS_API_LEVEL 9)

set(OHOS_ARCH "arm64-v8a")

# 安装路径

set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "Install path")

```

## 三、libzip源码适配与交叉编译

### 3.1 libzip源码获取与补丁应用

```bash

#!/bin/bash

# prepare_libzip_ohos.sh - libzip源码准备与补丁

LIBZIP_VERSION="1.9.2"

LIBZIP_SRC="libzip-${LIBZIP_VERSION}"

PATCH_DIR="patches"

# 下载源码

if [ ! -d "${LIBZIP_SRC}" ]; then

    wget https://libzip.org/download/libzip-${LIBZIP_VERSION}.tar.gz

    tar -xzf libzip-${LIBZIP_VERSION}.tar.gz

fi

# 创建补丁目录

mkdir -p ${PATCH_DIR}

# 生成OpenHarmony适配补丁

cat > ${PATCH_DIR}/ohos_support.patch << 'EOF'

diff --git a/CMakeLists.txt b/CMakeLists.txt

index 1234567..abcdefg 100644

--- a/CMakeLists.txt

+++ b/CMakeLists.txt

@@ -45,6 +45,12 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Android")

   set(ANDROID TRUE)

 endif()

 

+# OpenHarmony平台检测

+if(CMAKE_SYSTEM_NAME STREQUAL "Generic" AND DEFINED OHOS)

+  set(OPENHARMONY TRUE)

+  add_definitions(-DOPENHARMONY)

+endif()

+

 # 编译器检查

 include(CheckCSourceCompiles)

 include(CheckFunctionExists)

@@ -120,6 +126,11 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Windows")

   set(HAVE__STRTOI64 1)

 endif()<"www.8w.fsjdpx.com">

 

+# OpenHarmony特定配置

+if(OPENHARMONY)

+  set(HAVE_ARC4RANDOM 0)

+  set(HAVE_GETRANDOM 0)

+endif()

 

 # 依赖检查

 find_package(ZLIB REQUIRED)

diff --git a/lib/zip_random.c b/lib/zip_random.c

index abcdefg..hijklmn 100644

--- a/lib/zip_random.c

+++ b/lib/zip_random.c

@@ -35,6 +35,10 @@

 #include <unistd.h>

 #endif

 

+#ifdef OPENHARMONY

+#include <stdlib.h>

+#endif

+

 #include "zipint.h"

 

 

@@ -62,6 +66,12 @@ _zip_random(zip_uint32_t *value) {

     return 0;

 }

 

+#ifdef OPENHARMONY

+    // OpenHarmony使用rand作为随机源

+    *value = (zip_uint32_t)rand();

+    return 0;

+#endif

+

 #if defined(HAVE_ARC4RANDOM)

     *value = arc4random();

     return 0;

EOF

# 应用补丁

cd ${LIBZIP_SRC}

patch -p1 < ../${PATCH_DIR}/ohos_support.patch

echo "libzip源码适配完成"

```

### 3.2 libzip交叉编译配置

```cmake

# libzip_ohos.cmake - OpenHarmony专用构建配置

# 加载OpenHarmony工具链

include(${CMAKE_CURRENT_LIST_DIR}/ohos_toolchain.cmake)

# 项目设置

project(libzip C CXX)

set(LIBZIP_VERSION "1.9.2")

# 查找依赖库

find_package(ZLIB REQUIRED)

find_package(BZip2 REQUIRED)

find_package(OpenSSL REQUIRED)

# 配置选项

option(BUILD_SHARED_LIBS "Build shared libraries" OFF)

option(BUILD_TOOLS "Build zip tools" ON)

option(BUILD_EXAMPLES "Build examples" OFF)

option(BUILD_DOC "Build documentation" OFF)

option(BUILD_REGRESS "Build regression tests" OFF)

# OpenHarmony特定设置

if(OHOS)

    add_definitions(-D_OHOS_ -D__OHOS__)

    set(CMAKE_POSITION_INDEPENDENT_CODE ON)

    

    # 关闭OpenHarmony不支持的功能

    set(HAVE_ARC4RANDOM OFF)

    set(HAVE_GETRANDOM OFF)

    set(HAVE_CRYPTO OFF)

    

    # 修改默认加密后端

    set(WITH_COMMONCRYPTO OFF)

    set(WITH_GNUTLS OFF)

    set(WITH_MBEDTLS OFF)

    set(WITH_OPENSSL ON)

endif()

# 包含目录

include_directories(

    ${CMAKE_CURRENT_SOURCE_DIR}

    ${CMAKE_CURRENT_BINARY_DIR}

    ${ZLIB_INCLUDE_DIRS}

    ${OPENSSL_INCLUDE_DIR}

)

# 源文件

file(GLOB LIBZIP_SOURCES

    lib/*.c

    lib/*.h

)

file(GLOB LIBZIP_HEADERS

    zip.h

    zipconf.h

)

# 创建目标

if(BUILD_SHARED_LIBS)

    add_library(zip SHARED ${LIBZIP_SOURCES})

else()

    add_library(zip STATIC ${LIBZIP_SOURCES})

endif()

# 链接库

target_link_libraries(zip

    ${ZLIB_LIBRARIES}

    ${BZIP2_LIBRARIES}

    OpenSSL::SSL

    OpenSSL::Crypto

)

# 编译属性设置

target_compile_features(zip PRIVATE c_std_99)

set_target_properties(zip PROPERTIES

    VERSION ${LIBZIP_VERSION}

    SOVERSION 1

    OUTPUT_NAME "zip"

)

# 安装配置

install(TARGETS zip

    ARCHIVE DESTINATION lib

    LIBRARY DESTINATION lib

    RUNTIME DESTINATION bin

)

install(FILES ${LIBZIP_HEADERS}

    DESTINATION include

)

# 构建工具（可选）

if(BUILD_TOOLS)

    add_executable(zipcmp src/zipcmp.c)

    target_link_libraries(zipcmp zip)

    

    add_executable(zipmerge src/zipmerge.c)

    target_link_libraries(zipmerge zip)

    

    install(TARGETS zipcmp zipmerge

        DESTINATION bin

    )

endif()

```

### 3.3 自动化构建脚本

```python

# build_libzip_ohos.py - libzip自动化构建

#!/usr/bin/env python3

import os

import sys

import shutil

import subprocess

from pathlib import Path

class LibZipBuilder:

    def __init__(self):

        self.root_dir = Path(__file__).parent.absolute()

        self.build_dir = self.root_dir / "build_ohos"

        self.install_dir = self.root_dir / "output" / "ohos"

        self.source_dir = self.root_dir / "libzip-1.9.2"

        

        # 设置环境

        self.setup_environment()

    

    def setup_environment(self):

        """设置OpenHarmony编译环境"""

        ohos_sdk = "/opt/ohos-sdk/linux"

        

        env_vars = {

            'CC': f'{ohos_sdk}/native/llvm/bin/aarch64-linux-ohos-clang',

            'CXX': f'{ohos_sdk}/native/llvm/bin/aarch64-linux-ohos-clang++',

            'AR': f'{ohos_sdk}/native/llvm/bin/llvm-ar',

            'RANLIB': f'{ohos_sdk}/native/llvm/bin/llvm-ranlib',

            'STRIP': f'{ohos_sdk}/native/llvm/bin/llvm-strip',

            'CMAKE_TOOLCHAIN_FILE': str(self.root_dir / 'ohos_toolchain.cmake'),

            'PKG_CONFIG_PATH': f'{self.install_dir}/lib/pkgconfig',

            'CFLAGS': '--target=aarch64-linux-ohos -march=armv8-a -fPIC -O2',

            'CXXFLAGS': '--target=aarch64-linux-ohos -march=armv8-a -fPIC -O2 -std=c++17',

            'LDFLAGS': '-fuse-ld=lld -static-libstdc++'

        }

        

        for key, value in env_vars.items():

            os.environ[key] = value

        

        # 确保安装目录存在

        self.install_dir.mkdir(parents=True, exist_ok=True)

    

    def configure_cmake(self):

        """运行CMake配置"""

        cmake_cmd = [

            'cmake',

            f'-S{self.source_dir}',

            f'-B{self.build_dir}',

            f'-DCMAKE_INSTALL_PREFIX={self.install_dir}',

            f'-DCMAKE_TOOLCHAIN_FILE={os.environ["CMAKE_TOOLCHAIN_FILE"]}',

            '-DCMAKE_BUILD_TYPE=Release',

            '-DBUILD_SHARED_LIBS=OFF',

            '-DBUILD_TOOLS=ON',

            '-DBUILD_EXAMPLES=OFF',

            '-DBUILD_DOC=OFF',

            '-DBUILD_REGRESS=OFF',

            f'-DZLIB_ROOT={self.install_dir}',

            f'-DBZIP2_ROOT={self.install_dir}',

            f'-DOPENSSL_ROOT_DIR={self.install_dir}',

            '-DOPENSSL_USE_STATIC_LIBS=TRUE'

        ]

        

        print("配置CMake...")

        result = subprocess.run(cmake_cmd, capture_output=True, text=True)

        

        if result.returncode != 0:

            print(f"CMake配置失败: {result.stderr}")

            sys.exit(1)

        

        print("CMake配置成功")

    

    def build_and_install(self):

        """编译和安装"""

        # 编译

        print("开始编译...")

        build_cmd = ['cmake', '--build', str(self.build_dir), '--parallel', '8']

        result = subprocess.run(build_cmd, capture_output=True, text=True)

        

        if result.returncode != 0:

            print(f"编译失败: {result.stderr}")

            sys.exit(1)

        

        # 安装

        print("安装到目标目录...")

        install_cmd = ['cmake', '--install', str(self.build_dir)]

        result = subprocess.run(install_cmd, capture_output=True, text=True)

        

        if result.returncode != 0:

            print(f"安装失败: {result.stderr}")

            sys.exit(1)

        

        print(f"安装完成: {self.install_dir}")

    

    def verify_build(self):

        """验证构建结果"""

        print("\n验证构建结果:")

        

        # 检查库文件

        lib_file = self.install_dir / "lib" / "libzip.a"

        if lib_file.exists():

            # 检查架构

            result = subprocess.run(

                ['llvm-readelf', '-h', str(lib_file)],

                capture_output=True,

                text=True

            )

            if 'AArch64' in result.stdout:

                print("✓ libzip.a 是有效的ARM64库")

            else:

                print("✗ libzip.a 架构不正确")

        else:

            print("✗ 未找到libzip.a")

        

        # 检查头文件

        header_file = self.install_dir / "include" / "zip.h"

        if header_file.exists():

            print("✓ zip.h 头文件存在")

        else:

            print("✗ 未找到zip.h")

        

        # 测试简单程序

        test_program = self.build_dir / "test_zip"

        if test_program.exists():

            print("✓ 测试程序编译成功")

            

            # 检查文件类型

            result = subprocess.run(

                ['file', str(test_program)],

                capture_output=True,

                text=True

            )

            if 'ARM aarch64' in result.stdout:

                print("✓ 测试程序是ARM64架构")

        else:

            print("✗ 测试程序未找到")

    

    def run(self):

        """主构建流程"""

        print("开始构建libzip for OpenHarmony")

        print(f"源码目录: {self.source_dir}")

        print(f"构建目录: {self.build_dir}")

        print(f"安装目录: {self.install_dir}")

        

        # 清理旧的构建

        if self.build_dir.exists():

            shutil.rmtree(self.build_dir)

        

        # 执行构建步骤

        self.configure_cmake()

        self.build_and_install()

        self.verify_build()

        

        print("\nlibzip构建完成！")

if __name__ == "__main__":

    builder = LibZipBuilder()

    builder.run()

```

## 四、HNP包配置与打包

### 4.1 HNP配置文件编写

```json

// bundle.json - HNP包描述文件

{

  "name": "libzip",

  "version": "1.9.2",

  "description": "C library for reading, creating, and modifying zip archives",

  "license": "BSD-3-Clause",

  "type": "library",

  "targets": [

    {

      "name": "ohos-arm64",

      "api": 9,

      "arch": "arm64-v8a",

      "libs": {

        "static": ["libzip.a"],

        "shared": []

      },<"www.2c.fsjdpx.com">

      "headers": ["include/*.h"],

      "dependencies": [

        {<"www.5x.fsjdpx.com">

          "name": "zlib",

          "version": "1.2.13"

        },

        {

          "name": "openssl",

          "version": "3.0.8"

        }

      ]

    }

  ],

  "build": {

    "script": "build_ohos.sh",

    "toolchain": "ohos-ndk-3.2.11.9",

    "environment": {

      "sdk": "/opt/ohos-sdk/linux",

      "sysroot": "/opt/ohos-sdk/linux/native/sysroot"

    }

  },

  "install": {

    "dest": "/system/lib64",

    "headers_dest": "/usr/include",

    "pkgconfig": true

  },

  "test": {

    "enabled": true,

    "script": "test_ohos.sh",

    "cases": ["test_zip_archive", "test_zip_stream"]

  },

  "metadata": {

    "author": "OpenHarmony Community",

    "repository": "https://gitee.com/openharmony/third_party_libzip",

    "issues": "https://gitee.com/openharmony/third_party_libzip/issues"

  }

}

```

```yaml

# hnp.yaml - HNP包构建配置

package:

  name: libzip

  version: 1.9.2

  type: library

  description: "Zip archive manipulation library for OpenHarmony"

  

targets:

  - name: arm64-v8a

    api: 9

    toolchain: ohos-ndk

    flags:

      cflags: "--target=aarch64-linux-ohos -march=armv8-a -fPIC -O2"

      ldflags: "-fuse-ld=lld -static-libstdc++"

    

dependencies:

  build:

    - cmake>=3.18

    - ninja>=1.10

    - ohos-ndk>=3.2.11

  runtime:

    - zlib>=1.2.13

    - openssl>=3.0.8

    

sources:

  - url: https://libzip.org/download/libzip-1.9.2.tar.gz

    sha256: c93e9852b7b8dc5e26c4c9d80db3b4302d5f41b6f2d4644e95c5c2a4a5e8e6f7

    patches:

      - patches/ohos_support.patch

      

build_steps:

  configure:

    command: cmake -B build -DCMAKE_TOOLCHAIN_FILE=ohos_toolchain.cmake

    args:

      - -DBUILD_SHARED_LIBS=OFF

      - -DCMAKE_INSTALL_PREFIX=${PREFIX}

      

  compile:

    command: cmake --build build --parallel ${NPROC}

    

  install:

    command: cmake --install build

    dest: ${OUTPUT_DIR}

    

  package:

    command: hnp pack --name libzip --version 1.9.2

    files:

      - ${OUTPUT_DIR}/lib/libzip.a -> lib/${TARGET_ARCH}/

      - ${OUTPUT_DIR}/include/*.h -> include/

      - bundle.json

      - LICENSE

    

tests:

  unit:

    - name: archive_test

      source: test/archive_test.cpp

      libraries: [zip, z, crypto, ssl]

      

  integration:

    - script: test_integration.sh

      timeout: 300

```

### 4.2 HNP打包脚本

```bash

#!/bin/bash

# package_libzip_hnp.sh - 创建libzip的HNP包

set -e

# 配置

PKG_NAME="libzip"

PKG_VERSION="1.9.2"

PKG_ARCH="arm64-v8a"

OHOS_API=9

BUILD_DIR="build_ohos"

INSTALL_DIR="output/ohos"

HNP_OUTPUT="hnp_packages"

TEMP_DIR="tmp_hnp"

# 清理旧文件

rm -rf ${TEMP_DIR} ${HNP_OUTPUT}/${PKG_NAME}-${PKG_VERSION}.hnp

mkdir -p ${TEMP_DIR} ${HNP_OUTPUT}

# 创建包结构

mkdir -p ${TEMP_DIR}/lib/${PKG_ARCH}

mkdir -p ${TEMP_DIR}/include

mkdir -p ${TEMP_DIR}/pkgconfig

mkdir -p ${TEMP_DIR}/test

mkdir -p ${TEMP_DIR}/docs

# 复制库文件和头文件

cp ${INSTALL_DIR}/lib/libzip.a ${TEMP_DIR}/lib/${PKG_ARCH}/

cp ${INSTALL_DIR}/include/*.h ${TEMP_DIR}/include/

# 创建pkg-config文件

cat > ${TEMP_DIR}/pkgconfig/zip.pc << EOF

prefix=/system

exec_prefix=\${prefix}

libdir=\${exec_prefix}/lib/${PKG_ARCH}

includedir=\${prefix}/include

Name: libzip

Description: library for handling zip archives

Version: ${PKG_VERSION}

Libs: -L\${libdir} -lzip -lz -lcrypto -lssl

Cflags: -I\${includedir}

Requires: zlib openssl

EOF

# 创建测试程序

cat > ${TEMP_DIR}/test/test_minimal.c << EOF

#include <zip.h>

#include <stdio.h>

#include <stdlib.h>

int main() {

    int error = 0;

    zip_t *archive = zip_open("/data/test.zip", ZIP_CREATE | ZIP_TRUNCATE, &error);

    

    if (archive == NULL) {

        printf("Failed to create zip archive\\n");

        return 1;

    }

    

    printf("Successfully created zip archive\\n");

    

    // 添加测试文件

    const char *content = "Hello OpenHarmony!";

    zip_source_t *source = zip_source_buffer(archive, content, strlen(content), 0);

    

    if (source == NULL) {

        printf("Failed to create zip source\\n");

        zip_close(archive);

        return 1;

    }

    

    if (zip_file_add(archive, "hello.txt", source, ZIP_FL_OVERWRITE) < 0) {

        printf("Failed to add file to archive\\n");

        zip_source_free(source);

        zip_close(archive);

        return 1;

    }

    

    // 保存归档

    if (zip_close(archive) < 0) {

        printf("Failed to save archive\\n");

        return 1;

    }

    

    printf("Test completed successfully\\n");

    return 0;

}

EOF

# 编译测试程序

aarch64-linux-ohos-clang \

    --target=aarch64-linux-ohos \

    -I${TEMP_DIR}/include \

    -L${TEMP_DIR}/lib/${PKG_ARCH} \

    ${TEMP_DIR}/test/test_minimal.c \

    -lzip -lz -lcrypto -lssl \

    -o ${TEMP_DIR}/test/test_minimal

# 创建安装脚本

cat > ${TEMP_DIR}/install.sh << 'EOF'

#!/system/bin/sh

# libzip安装脚本

PKG_NAME="libzip"

PKG_VERSION="1.9.2"

ARCH="arm64-v8a"

echo "Installing ${PKG_NAME} ${PKG_VERSION} for ${ARCH}..."

# 创建目录

mkdir -p /system/lib64

mkdir -p /usr/include

mkdir -p /usr/lib/pkgconfig

# 复制库文件

cp ${0%/*}/lib/${ARCH}/libzip.a /system/lib64/

# 复制头文件

cp ${0%/*}/include/*.h /usr/include/

# 复制pkg-config文件

cp ${0%/*}/pkgconfig/zip.pc /usr/lib/pkgconfig/

# 设置权限

chmod 644 /system/lib64/libzip.a

chmod 644 /usr/include/*.h

chmod 644 /usr/lib/pkgconfig/zip.pc

echo "Installation complete"

echo "Library: /system/lib64/libzip.a"

echo "Headers: /usr/include/zip.h"

echo "pkg-config: /usr/lib/pkgconfig/zip.pc"

EOF

chmod +x ${TEMP_DIR}/install.sh

# 创建卸载脚本

cat > ${TEMP_DIR}/uninstall.sh << 'EOF'

#!/system/bin/sh

# libzip卸载脚本

echo "Removing libzip..."

# 删除文件

rm -f /system/lib64/libzip.a

rm -f /usr/include/zip.h

rm -f /usr/include/zipconf.h

rm -f /usr/lib/pkgconfig/zip.pc

echo "libzip removed"

EOF

chmod +x ${TEMP_DIR}/uninstall.sh

# 创建验证脚本

cat > ${TEMP_DIR}/verify.sh << 'EOF'

#!/system/bin/sh

# libzip验证脚本

echo "Verifying libzip installation..."

# 检查库文件

if [ -f "/system/lib64/libzip.a" ]; then

    echo "✓ Library file exists"

else

    echo "✗ Library file missing"

    exit 1

fi

# 检查头文件

if [ -f "/usr/include/zip.h" ]; then

    echo "✓ Header file exists"

else

    echo "✗ Header file missing"

    exit 1

fi

# 测试编译简单程序

cat > /tmp/test_zip.c << 'TEST'

#include <zip.h>

int main() { return 0; }

TEST

if aarch64-linux-ohos-clang -I/usr/include -L/system/lib64 \

    /tmp/test_zip.c -lzip -o /tmp/test_compile 2>/dev/null; then

    echo "✓ Library can be linked"

    rm -f /tmp/test_compile

else

    echo "✗ Library linking failed"

    exit 1

fi

rm -f /tmp/test_zip.c

echo "Verification successful"

EOF

chmod +x ${TEMP_DIR}/verify.sh

# 创建MANIFEST文件

cat > ${TEMP_DIR}/MANIFEST << EOF

name=${PKG_NAME}

version=${PKG_VERSION}

arch=${PKG_ARCH}

api=${OHOS_API}

type=library

timestamp=$(date +%s)

files:

  lib/${PKG_ARCH}/libzip.a

  include/zip.h

  include/zipconf.h

  pkgconfig/zip.pc

  install.sh

  uninstall.sh

  verify.sh

  test/test_minimal

  test/test_minimal.c

dependencies:

  zlib>=1.2.13

  openssl>=3.0.8

checksums:

  $(sha256sum ${TEMP_DIR}/lib/${PKG_ARCH}/libzip.a | cut -d' ' -f1) lib/${PKG_ARCH}/libzip.a

  $(sha256sum ${TEMP_DIR}/include/zip.h | cut -d' ' -f1) include/zip.h

EOF

# 创建包信息文件

cat > ${TEMP_DIR}/INFO << EOF

Package: ${PKG_NAME}

Version: ${PKG_VERSION}

Architecture: ${PKG_ARCH}

Maintainer: OpenHarmony Team <openharmony@example.com>

Description: C library for reading, creating, and modifying zip archives

 This library allows manipulation of zip archives. It can

 create, read, write, and modify zip archives.

 

Features:

 - Create new zip archives

 - Read, modify, and extract existing zip archives

 - Support for encrypted archives (via OpenSSL)

 - Stream-based access for large files

 - Support for zip64 (large files)

<"www.9y.fsjdpx.com"><"gd.wandaihu.cn"><"tu.wandaihu.cn">

Homepage: https://libzip.org/

License: BSD-3-Clause

EOF

# 打包成HNP格式

cd ${TEMP_DIR}

tar -czf ../${HNP_OUTPUT}/${PKG_NAME}-${PKG_VERSION}.hnp .

# 生成签名（可选）

cd ..

if command -v openssl &> /dev/null; then

    openssl dgst -sha256 -sign private.key -out \

        ${HNP_OUTPUT}/${PKG_NAME}-${PKG_VERSION}.sig \

        ${HNP_OUTPUT}/${PKG_NAME}-${PKG_VERSION}.hnp

    echo "Package signed"

fi

# 清理

rm -rf ${TEMP_DIR}

echo "HNP package created: ${HNP_OUTPUT}/${PKG_NAME}-${PKG_VERSION}.hnp"

echo "Package size: $(du -h ${HNP_OUTPUT}/${PKG_NAME}-${PKG_VERSION}.hnp | cut -f1)"

```

## 五、集成测试与验证

### 5.1 测试套件开发

```c++

// test_ohos_zip.cpp - OpenHarmony平台测试程序

#include <zip.h>

#include <cstdio>

#include <cstring>

#include <cstdlib>

#include <unistd.h>

#define TEST_FILE "