创建 Kanzi Engine 插件¶

Kanzi Engine 插件扩展了 Kanzi Engine 的功能。Kanzi Engine 在目标平台上执行这些插件。

使用 Kanzi Engine 插件来：

使用 Kanzi Engine API 创建自定义节点，在您的 Kanzi Studio 项目中使用它们，并在 Kanzi Studio Preview 中查看它们的工作原理。
使用 Kanzi Engine API 创建自定义属性类型和消息，并在您的 Kanzi Studio 项目中使用它们。
定义数据入口点到您的 Kanzi 应用程序，并在 Kanzi 应用程序设计师和开发人员之间形成合同。

要了解如何使用 Kanzi Engine 插件，请参阅：

要创建本机 Kanzi Engine 插件：

按以下方式之一创建插件：
- 使用模板。请参阅使用模板创建本机 Kanzi Engine 插件。或使用模板创建一个 Java Kanzi Engine 插件。。
- 手动。请参阅手动创建本机 Kanzi Engine 插件或手动创建一个 Java Kanzi Engine 插件。
安装插件。请参阅将 Kanzi Engine 插件添加到 Kanzi Studio 项目中。。
调试插件。请参阅调试本机 Kanzi Engine 插件。

使用模板创建本机 Kanzi Engine 插件。¶

您可以使用与 Kanzi 一起安装的模板创建一个本机 Kanzi Engine 插件。

要使用模板创建本机 Kanzi Engine 插件：

在 Kanzi Studio 的 Quick Start 屏幕中点击 New。
在 Quick Start 窗口的 New 选项卡中，选择 Application with Kanzi Engine plugin 工程模板，然后点击 Create。

Kanzi 在 <ProjectName>/Tool_project 目录中创建一个 Kanzi Studio 项目，并在 <ProjectName>/Application 目录中创建项目的应用程序代码结构：
- bin 目录包含项目的 kzb 和配置文件。
- configs 目录包含不同平台的配置文件。默认情况下，Kanzi 会为多个不同的平台创建配置文件。开发 Kanzi 应用程序的推荐平台是 Microsoft Visual Studio。请参阅部署 Kanzi 应用程序。
- src 目录包含您的应用程序的源代码。
- CMakeLists.txt 文件包含 CMake 为 Kanzi 应用程序生成 Visual Studio 解决方案的说明。
- generate_cmake_vs<Version>_solution.bat 是一个脚本，您可以使用它为 Kanzi 应用程序生成一个 Visual Studio 解决方案。该脚本在 <ProjectName>/Application/build_vs<Version> 目录中生成 Visual Studio 解决方案。
在 Kanzi Studio 中，选择 File > Open Kanzi Command Prompt。

Kanzi Command Prompt 打开 Windows 命令提示符，并为您打开 Kanzi Command Prompt 的 Kanzi 版本设置 Kanzi 环境变量。

使用 Kanzi Command Prompt 访问 Kanzi 实用工具和构建工具（例如 Gradle 和 CMake），而无需使用绝对路径或设置环境变量。

小技巧

您可以在 Windows 开始菜单的 Rightware 目录中找到 Kanzi Command Prompt。

当您安装了多个版本的 Kanzi 时，确保将您要在该命令提示符下使用的 Kanzi 版本的 Kanzi Command Prompt 启动。
在 <ProjectName>/Application 目录中的 Kanzi Command Prompt 中，运行生成应用程序的 Visual Studio 解决方案的脚本。
```
generate_cmake_vs2022_solution.bat
```
此脚本会在 <ProjectName>/Application/build_vs2022 目录中为应用程序生成 Visual Studio 解决方案。
在 Visual Studio 中打开 <ProjectName>/Application/build_vs<Version>/<ProjectName>.sln Visual Studio 解决方案。

Visual Studio 解决方案包含：
- 用于 Kanzi Engine 插件的项目名为 <ProjectName>。在此项目中定义您的 Kanzi Engine 插件。
- 用于名为 <ProjectName>_executable 的 C++ 应用程序的项目。在此项目中定义您的 Kanzi 应用程序的逻辑。
在 Visual Studio 中为您的 Kanzi 应用程序和您的 Kanzi Engine 插件创建逻辑，并在您的 Kanzi Engine 插件中为 Kanzi Studio 配置自定义组件。请参阅应用程序开发、定义数据源和扩展 Kanzi Engine 的功能。

当您添加或删除 Kanzi 应用程序或 Kanzi Engine 插件使用的文件时，请在 CMakeLists.txt 中更新 set 命令中的文件列表，并运行 generate_cmake_vs<Version>_solution.bat 脚本：
- 当您更改在 Kanzi 应用程序中使用的文件时，更新 <ProjectName>/Application/src/executable/CMakeLists.txt。
- 当您更改在 Kanzi Engine 插件中使用的文件时，更新 <ProjectName>/Application/src/plugin/CMakeLists.txt。
例如，要将 tinyxml2.cpp 和 tinyxml2.h 文件添加到您的 Kanzi Engine 插件中，请更新 <ProjectName>/Application/src/plugin/CMakeLists.txt 以包含这些文件。
```
set(sources_plugin
    src/tinyxml2.cpp
    src/tinyxml2.h
    src/mykanziengineplugin.cpp
    src/mykanziengineplugin.hpp
    src/mykanziengineplugin.rc
    src/mykanziengineplugin_module.cpp
    src/mykanziengineplugin_module.hpp)
```
选择您要使用的解决方案配置。

在开发期间，选择 Debug 配置。当您准备好创建生产版本时，选择 Release 配置。
构建您的 Kanzi Engine 插件：
- 要仅构建 Kanzi Engine 插件 DLL，请右键单击 <ProjectName> 项目并选择构建。
- 要构建 Kanzi Engine 插件 DLL 和您的 Kanzi 应用程序，右键单击 <ProjectName>_executable 项目并选择 Build。
Visual Studio 构建：
- 在 <ProjectName>/Application/lib/<PlatformName>/<ConfigurationName> 和 <ProjectName>/Application/build_vs<Version>/runtime/<ConfigurationName> 目录中的插件 DLL
  
  Kanzi Studio 在 <ProjectName>/Application/lib 目录中使用插件 DLL。
- 在 <ProjectName>/Application/build_<Version>/runtime/<ConfigurationName> 目录中的应用程序可执行文件。
更新 Kanzi Studio 项目中的 Kanzi Engine 插件：
1. 对于 DLL 插件，确保 Kanzi Studio 工程中的设置与您在 Visual Studio 中构建应用程序和插件工程所使用的解决方案配置相匹配。
  
  例如，如果您在 Visual Studio 2022 中使用 Release 解决方案配置，则在 Kanzi Studio 工程的 Project > Properties 中设置：
  - Preview Build Configuration 到 Release
  - 将 Preview Visual Studio Version 设置为 2022
  - Preview Working Directory 到 ..\Application\bin。
  通过这些设置，您可以将 Kanzi Studio Preview 设置为与插件一起使用。
2. 在您在第一步中创建的项目中的 Kanzi Studio 中，在 Library > Kanzi Engine Plugins 中右键单击插件并选择 Update Kanzi Engine Plugin。
  
  通过这种方式，您可以更新插件并使用您在 Visual Studio 插件项目中所做的更改。
3. 在 Properties 中，确保将 Is Enabled 属性启用。
  
  小技巧
  
  使用 Is Enabled 属性在您的项目中启用或禁用任何 Kanzi Engine 插件。

手动创建本机 Kanzi Engine 插件¶

要手动创建本机 Kanzi Engine 插件：

在 Quick Start 窗口的 New 选项卡中，选择 Application 工程模板，以新建带有 C++ 应用程序的工程。
在 <ProjectName>/Application 目录的文件资源管理器中，创建 plugin/src 目录。

向 <ProjectName>/Application/plugin/src 目录添加一个文件，在其中添加 createModule、deleteModule 和 Module::getMetaclassesOverride 函数，并注册您在插件中实现的所有元类。

插件使用这些函数来获取 DLL 中的函数、元类和组件列表。它使用它们将这些注册到 Kanzi Engine。

例如，将该文件命名为 my_kanzi_engine_plugin.cpp。

#include <kanzi/core/module/module.hpp>
extern "C"
{
    MY_KANZI_ENGINE_PLUGIN_API kanzi::Module* createModule(uint32_t kanziVersionMajor, uint32_t kanziVersionMinor);
}
class MY_KANZI_ENGINE_PLUGIN_API MyKanziEnginePluginModule: public kanzi::Module
{
    MetaclassContainer getMetaclassesOverride() override;
};
MyKanziEnginePluginModule::MetaclassContainer MyKanziEnginePluginModule::getMetaclassesOverride()
{
    MetaclassContainer metaclasses;
    return metaclasses;
}
MY_KANZI_ENGINE_PLUGIN_API kanzi::Module* createModule(uint32_t /*kanziVersionMajor*/, uint32_t /*kanziVersionMinor*/)
{
    return new MyKanziEnginePluginModule;
}

将包含构建说明的 CMakeLists.txt 文件添加到 <ProjectName>/Application/plugin 目录中。

cmake_minimum_required(VERSION 3.25.0)
# Define the name of the plugin.
project(MyKanziEnginePlugin)
# Build the plugin as a dll.
if(MSVC)
    option(BUILD_SHARED_LIBS "Selects whether to build and link to shared or static libraries" ON)
endif()
# Import the Kanzi CMake targets. Define the path to Kanzi (Kanzi_DIR) either in the
# CMakeLists.txt or pass as a parameter when running cmake.
find_package(Kanzi REQUIRED CONFIG CMAKE_FIND_ROOT_PATH_BOTH
    HINTS "$ENV{KANZI_HOME}/Engine/lib/cmake/Kanzi")

include(kanzi-common)

# Define the sources of the plugin. Produce a library.
set(sources
    src/my_kanzi_engine_plugin.cpp)

add_library(MyKanziEnginePlugin ${sources})
# Define Kanzi libraries as the dependencies of the plugin.
target_link_libraries(MyKanziEnginePlugin PUBLIC Kanzi::kzcore Kanzi::kzcoreui Kanzi::kzui)

target_include_directories(MyKanziEnginePlugin PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src)

# Define the dll interface macros.
if(BUILD_SHARED_LIBS AND MSVC)
    target_compile_definitions(MyKanziEnginePlugin PRIVATE "MY_KANZI_ENGINE_PLUGIN_API=__declspec(dllexport)")
    target_compile_definitions(MyKanziEnginePlugin PRIVATE "MY_KANZI_ENGINE_PLUGIN_API_EXPORT")
    target_compile_definitions(MyKanziEnginePlugin INTERFACE "MY_KANZI_ENGINE_PLUGIN_API=__declspec(dllimport)")
else()
    target_compile_definitions(MyKanziEnginePlugin PUBLIC "MY_KANZI_ENGINE_PLUGIN_API=")
endif()

# Add a post-build step that copies the plugin dll to a directory where the Kanzi Studio project can find it.
# Set the relative path that points from the plugin directory to the application lib directory.
if(BUILD_SHARED_LIBS AND MSVC)
    set(KANZI_PROJECT_PLUGIN_PATH "${PROJECT_SOURCE_DIR}/../lib/${CMAKE_VS_PLATFORM_NAME}/${MSVC_TAG}_$<CONFIG>_DLL")
    add_custom_command(TARGET MyKanziEnginePlugin POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E make_directory "${KANZI_PROJECT_PLUGIN_PATH}"
        COMMAND ${CMAKE_COMMAND} -E copy_if_different "$<TARGET_FILE:MyKanziEnginePlugin>" "${KANZI_PROJECT_PLUGIN_PATH}")
endif()

install_target_to_output_directory(MyKanziEnginePlugin)

在 <ProjectName>/Application 目录中，编辑 CMakeLists.txt 文件以使主可执行项目包含对 Kanzi Engine 插件的依赖：
```
add_subdirectory(plugin)
target_link_libraries(MyKanziApplication Kanzi::kzui Kanzi::kzcoreui MyKanziEnginePlugin)
```
在 Kanzi Studio 中，选择 File > Open Kanzi Command Prompt。

Kanzi Command Prompt 打开 Windows 命令提示符，并为您打开 Kanzi Command Prompt 的 Kanzi 版本设置 Kanzi 环境变量。

使用 Kanzi Command Prompt 访问 Kanzi 实用工具和构建工具（例如 Gradle 和 CMake），而无需使用绝对路径或设置环境变量。

小技巧

您可以在 Windows 开始菜单的 Rightware 目录中找到 Kanzi Command Prompt。

当您安装了多个版本的 Kanzi 时，确保将您要在该命令提示符下使用的 Kanzi 版本的 Kanzi Command Prompt 启动。
在 <ProjectName>/Application 目录中的 Kanzi Command Prompt 中，运行生成应用程序的 Visual Studio 解决方案的脚本。
```
generate_cmake_vs2022_solution.bat
```
此脚本会在 <ProjectName>/Application/build_vs2022 目录中为应用程序生成 Visual Studio 解决方案。
在 Visual Studio 中打开 <ProjectName>/Application/build_vs<Version>/<ProjectName>.sln Visual Studio 解决方案。该 Visual Studio 解决方案包含：
- 用于 Kanzi Engine 插件的项目名为 MyKanziEnginePlugin。在这里，您创建 Kanzi Engine 插件。
- 用于名为 <ProjectName> 的 C++ 应用程序的项目。在这里，您可以为您的应用程序创建逻辑。
在 Visual Studio 中为您的 Kanzi 应用程序和您的 Kanzi Engine 插件创建逻辑，并在您的 Kanzi Engine 插件中为 Kanzi Studio 配置自定义组件。请参阅应用程序开发、创建 Kanzi Engine 插件、定义数据源和扩展 Kanzi Engine 的功能。

当您添加或删除 Kanzi 应用程序或 Kanzi Engine 插件使用的文件时，请在 CMakeLists.txt 中更新 set 命令中的文件列表，并运行 generate_cmake_vs<Version>_solution.bat 脚本：
- 当您更改在 Kanzi 应用程序中使用的文件时，更新 <ProjectName>/Application/src/executable/CMakeLists.txt。
- 当您更改在 Kanzi Engine 插件中使用的文件时，更新 <ProjectName>/Application/src/plugin/CMakeLists.txt。
例如，要将 tinyxml2.cpp 和 tinyxml2.h 文件添加到您的 Kanzi Engine 插件中，请更新 <ProjectName>/Application/src/plugin/CMakeLists.txt 以包含这些文件。
```
set(sources_plugin
    src/tinyxml2.cpp
    src/tinyxml2.h
    src/mykanziengineplugin.cpp
    src/mykanziengineplugin.hpp
    src/mykanziengineplugin.rc
    src/mykanziengineplugin_module.cpp
    src/mykanziengineplugin_module.hpp)
```
选择您要使用的解决方案配置。

在开发期间，选择 Debug 配置。当您准备好创建生产版本时，选择 Release 配置。
构建您的 Kanzi Engine 插件：
- 要仅构建 Kanzi Engine 插件 DLL，请右键单击 <ProjectName> 项目并选择构建。
- 要构建 Kanzi Engine 插件 DLL 和您的 Kanzi 应用程序，右键单击 <ProjectName>_executable 项目并选择 Build。
Visual Studio 构建：
- 在 <ProjectName>/Application/lib/<PlatformName>/<ConfigurationName> 和 <ProjectName>/Application/build_vs<Version>/runtime/<ConfigurationName> 目录中的插件 DLL
  
  Kanzi Studio 在 <ProjectName>/Application/lib 目录中使用插件 DLL。请参阅将 Kanzi Engine 插件添加到 Kanzi Studio 项目中。。
- 在 <ProjectName>/Application/build_vs<Version>/runtime/<ConfigurationName> 目录中的应用程序可执行文件。

使用模板创建一个 Java Kanzi Engine 插件。¶

您可以使用随 Kanzi 安装的模板创建一个 Java Kanzi Engine 插件。

要在 Kanzi Studio 中使用 Android 功能（例如将工程部署到 Android 设备以及导入 Java Kanzi Engine 插件），您需要 64 位 JDK 17 or 21。请参阅为 Kanzi Studio 设置 Android 环境。

请注意，Java 插件只能用于 Kanzi Android framework (droidfw) 应用程序。

要使用模板创建 Java Kanzi Engine 插件：

在 Kanzi Studio 的 Quick Start 屏幕中点击 New。
在 Quick Start 窗口的 New 选项卡中，选择 Android Application with Java plugin 工程模板，然后点击 Create。

Kanzi 在 <ProjectName>/Tool_project 目录中创建一个 Kanzi Studio 项目，并在 <ProjectName>/Application 目录中创建项目的应用程序代码结构：
- bin 目录包含项目的 kzb 和配置文件。
- configs/platforms/android_gradle 目录包含 Kanzi Android framework (droidfw) 的配置文件。请参阅使用 Kanzi Android framework (droidfw) 进行开发时。
- configs/platforms/android_gradle/app/src/main 包含您应用程序的源代码。
- configs/platforms/android_gradle/<ProjectName>plugin/src/main 包含您的 Java 插件的源代码。
在 Android Studio 中打开 <ProjectName>/Application/configs/platforms/android_gradle Android Studio 项目。

Android Studio 项目包含：
- 用于 Kanzi Engine 插件的项目名为 <ProjectName>plugin。在此项目中定义您的 Kanzi Engine 插件。
- 用于 Java 应用程序的项目名为 app。在此项目中定义您的 Kanzi 应用程序的逻辑。
在 Android Studio 中为您的 Kanzi 应用程序和您的 Kanzi Engine 插件创建逻辑，并在您的 Kanzi Engine 插件中为 Kanzi Studio 配置自定义组件。请参阅扩展 Kanzi Engine 的功能。
构建您的 Kanzi Engine 插件：
- 要仅构建 Kanzi Studio 使用的 Kanzi Engine 插件 JAR，请运行 exportJarDebug 或 exportJarRelease Gradle 目标。
- 要构建 Kanzi Engine 插件和您的 Kanzi 应用程序，请选择 app Java Module，然后选择 Build > Make Project。
更新 Kanzi Studio 项目中的 Kanzi Engine 插件：
1. 在您在第一步中创建的项目中的 Kanzi Studio 中，在 Library > Kanzi Engine Plugins 中右键单击插件并选择 Update Kanzi Engine Plugin。
  
  通过这种方式，您可以更新插件并使用您在 Android Studio 插件项目中所做的更改。
2. 在 Properties 中，确保将 Is Enabled 属性启用。
  
  小技巧
  
  使用 Is Enabled 属性在您的项目中启用或禁用任何 Kanzi Engine 插件。

手动创建一个 Java Kanzi Engine 插件¶

要手动创建 Java Kanzi Engine 插件：

在 Quick Start 窗口的 New 选项卡中，选择 Android Application 工程模板，以新建带有 Java 应用程序的工程。

创建定义 Java Kanzi Engine 插件的目录和文件：

在 Application/configs/platforms/android_gradle 目录中创建目录结构 MyKanziplugin/src/main/java/com/rightware/kanzi/MyKanziplugin。

在 MyKanziplugin/src/main/java/com/rightware/kanzi/MyKanziplugin 目录中创建 MyKanziDataSource.java 文件，并向其中添加一个基本的自定义 DataSource。

package com.rightware.kanzi.mykanziplugin;

import com.rightware.kanzi.DataObject;
import com.rightware.kanzi.DataObjectInt;
import com.rightware.kanzi.DataObjectReal;
import com.rightware.kanzi.DataObjectString;
import com.rightware.kanzi.DataSource;
import com.rightware.kanzi.Domain;
import com.rightware.kanzi.Metaclass;
import com.rightware.kanzi.Metadata;

public class MyKanziDataSource extends DataSource {
    @Metadata
    private static final Metaclass metaclass = new Metaclass("MyKanziDataSource");

    private ObjectRef<DataObject> mRoot;

    public static ObjectRef<MyKanziDataSource> create(Domain domain, String name) {
        return DataSource.createDerived(domain, name, metaclass);
    }

    public static Metaclass getStaticMetaclass() {
        return sStaticMetaclass;
    }

    public DataObject getData() {
        return mRoot.get();
    }

    private MyKanziDataSource(Domain domain, long native Metaclass metaclass) {
        super(domain, native, metaclass);

        // Construct the data object tree of the data source.
        mRoot = DataObject.create(domain, "Root");
        DataObject root = mRoot.get();
        root.addChild(DataObjectInt.create(domain, "Integer value", 1).get());
        root.addChild(DataObjectString.create(domain, "String value", "Placeholder value").get());
        root.addChild(DataObjectReal.create(domain, "Real value", 0.5).get());
    }
}

在 MyKanziplugin/src/main/java/com/rightware/kanzi/MyKanziplugin 目录中创建 MyKanziPlugin.java 文件，并在其中添加插件定义。

package com.rightware.kanzi.mykanziplugin;

import com.rightware.kanzi.MetaclassRegistry;
import com.rightware.kanzi.Plugin;

public class MyKanziPlugin extends Plugin {
    @Override
    public String getName() {
        return "mykanziplugin";
    }

    @Override
    public void registerClasses(MetaclassRegistry metaclassRegistry) {
        metaclassRegistry.registerClass(MyKanziDataSource.class);
    }
}

小技巧

从 Plugin.getName 返回的字符串必须与 Jar 文件的名称匹配。

在 MyKanziplugin/src/main 目录中创建 AndroidManifest.xml 文件，并将插件 Android manifest 添加到其中。

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.rightware.kanzi.mykanziplugin">
</manifest>

在 Application/configs/platforms/android_gradle/MyKanziplugin 目录中创建 build.gradle 文件，并在其中添加 Gradle 构建说明。

apply plugin: 'com.android.library'

android {
    compileSdkVersion 34
    defaultConfig {
        minSdkVersion 26
        targetSdkVersion 28
        versionCode 1
        versionName "1.0"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

android.buildTypes.all { buildType ->
    task "exportJar${buildType.name.capitalize()}"(type: Jar, group: 'Kanzi') {
        archiveBaseName = project.name
        destinationDir = file("${rootDir}/../../../lib/java/${buildType.name.capitalize()}")
        description "Export ${buildType.name} JAR plugin into ${destinationDirectory.get().toString()}."
        manifest {
            attributes 'Plugin-Version': "${android.defaultConfig.versionName}",
                    'Plugin-Class': 'com.rightware.kanzi.mykanziplugin.MyKanziPlugin'
        }
        from("build/intermediates/javac/${buildType.name}/classes/")
        dependsOn("assemble${buildType.name.capitalize()}")
    }
}

java {
    sourceCompatibility = JavaVersion.VERSION_11
    targetCompatibility = JavaVersion.VERSION_11
}

dependencies {
    implementation 'com.rightware.kanzi:kzjava@aar'
}

在 Kanzi Android framework (droidfw) 项目中添加对 Java Kanzi Engine 插件的引用。在 Application/configs/platforms/android_gradle 目录中：
1. 在 settings.gradle 文件中添加对您创建的插件项目的引用。
```
include ':MyKanziplugin'
```
2. 在 app 目录中的 build.gradle 文件中，将插件添加到 dependencies 部分。
```
implementation project(':MyKanziplugin')
```
3. 在 app/src/main/java/com/rightware/kanzi/<ProjectName> 目录中的 <ProjectName>Activity.java 文件中进行以下更改：
  - 在导入中添加：
    import com.rightware.kanzi.mykanziplugin.MyKanziPlugin;
  - 在 onCreate 方法的开头添加：
    mRuntimeRef.get().getDomain().registerPlugin(new MyKanziPlugin());
在 Android Studio 中构建您的 Kanzi Engine 插件：
- 要构建 Kanzi Studio 使用的 Kanzi Engine 插件 JAR，请运行 exportJarDebug 或 exportJarRelease Gradle 目标。
- 要构建 Kanzi Engine 插件和您的 Kanzi 应用程序，请选择 app Java Module，然后选择 Build > Make Project。
Android Studio 在 Application/lib/java/<buildType>/MyKanziplugin.jar 中构建 Kanzi Studio 使用的 JAR 文件。要使用该插件，请将其导入到 Kanzi Studio。请参阅将 Kanzi Engine 插件添加到 Kanzi Studio 项目中。。

将 Kanzi Engine 插件添加到 Kanzi Studio 项目中。¶

要将 Kanzi Engine 插件添加到 Kanzi Studio 项目中：

在 Library 中右键单击 Kanzi Engine Plugins 并选择 Import Kanzi Engine Plugin。

小技巧

您可以使用脚本自动导入 Kanzi Engine 插件。请参阅使用脚本导入 Kanzi Engine 插件。
选择您要导入的插件的 DLL 或 JAR 文件，然后点击 Open。
备注

从 Kanzi Studio 3.9.5 开始，Kanzi Java 插件的路径必须遵循以下模式：
- 对于调试，路径必须是 lib/java/Debug/<PluginName>.jar。
- 对于发布，路径必须是 lib/java/Release/<PluginName>.jar。
请参阅 Kanzi Engine Java 插件的 Debug 和 Release 构建类型支持的更改。。
当您在 Library > Kanzi Engine Plugins 中选择您导入的插件时，您可以在 Properties 中看到该插件为 Kanzi Studio 项目带来的内容列表。例如，在 Properties 中，您可以看到所选插件提供的属性类型、组件、数据源、渲染通道、节点组件和触发器动作类型的列表。
对于 DLL 插件，确保 Kanzi Studio 工程中的设置与您在 Visual Studio 中构建应用程序和插件工程所使用的解决方案配置相匹配。

例如，如果您在 Visual Studio 2022 中使用 Release 解决方案配置，则在 Kanzi Studio 工程的 Project > Properties 中设置：
- Preview Build Configuration 到 Release
- 将 Preview Visual Studio Version 设置为 2022
- Preview Working Directory 到 ..\Application\bin。
通过这些设置，您可以将 Kanzi Studio Preview 设置为与插件一起使用。
在 Library > Kanzi Engine Plugins 中选择插件，并在 Properties 中确保将 Is Enabled 属性启用。

小技巧

使用 Is Enabled 属性在您的项目中启用或禁用任何 Kanzi Engine 插件。
通过按下 Ctrl F8，或选择 Preview > Restart Preview 来重启 Preview。

您现在可以在您的 Kanzi Studio 项目中使用 Kanzi Engine 插件提供的内容。

另请参阅¶

使用 Java 和 Kotlin

调试本机 Kanzi Engine 插件

扩展 Kanzi Engine 的功能

Kanzi Studio 属性编辑器用于在 Kanzi Engine 插件中声明的属性类型。

Kanzi Engine 插件

使用 Package Manager 创建和部署 Engine 插件

将工程从 Kanzi 3.9 迁移到 Kanzi 4