Integrating Kanzi Monitor from source code¶

You can integrate Kanzi Monitor from source code into your Kanzi application project. The source code is located in the <KanziWorkspace>/Engine/plugins/monitor/src directory.

Integrating to Windows projects with CMake and Visual Studio¶

To integrate Kanzi Monitor from source to a Windows application project:

In the top-level CMakeLists.txt, add the Kanzi Monitor library root directory location to the CMake configuration.

set(PLUGIN_COMMON_SETUP cmake/common-setup.cmake)

# KANZI_MONITOR_ROOT can be set explicitly: cmake -DKANZI_MONITOR_ROOT=<path>
# If not set, auto-detection from known locations is attempted.
if(NOT KANZI_MONITOR_ROOT)
    if(EXISTS ${PROJECT_SOURCE_DIR}/../../../Engine/plugins/monitor/${PLUGIN_COMMON_SETUP})
        set(KANZI_MONITOR_ROOT ${PROJECT_SOURCE_DIR}/../../../Engine/plugins/monitor)
    elseif(DEFINED ENV{KANZI_HOME} AND
           EXISTS "$ENV{KANZI_HOME}/Engine/plugins/monitor/${PLUGIN_COMMON_SETUP}")
        set(KANZI_MONITOR_ROOT "$ENV{KANZI_HOME}/Engine/plugins/monitor")
    endif()
    if(NOT KANZI_MONITOR_ROOT)
        message(FATAL_ERROR
            "Cannot find Monitor plugin root directory. "
            "Pass -DKANZI_MONITOR_ROOT=<path> to CMake, set the KANZI_HOME "
            "environment variable to your Kanzi workspace root, or install "
            "the plugin under 'WORKSPACE/Engine/plugins'.")
    endif()
endif()

include(${KANZI_MONITOR_ROOT}/${PLUGIN_COMMON_SETUP})
include(${KANZI_MONITOR_ROOT}/cmake/monitor-config.cmake)

Add the Kanzi Monitor library subdirectory to the top-level CMakeLists.txt:
```
add_subdirectory(${KANZI_MONITOR_ROOT} "${CMAKE_BINARY_DIR}/monitor")
```
Note

When Kanzi Monitor is added as a subdirectory, its example application is not built by default. To also build the example, pass -DBUILD_EXAMPLES=ON to CMake.
(Optional) Link the application executable with the Kanzi Monitor library.

This is needed only if the application code uses the Kanzi Monitor API.

Locate the CMakeLists.txt for the application executable:
- If the project uses the Basic Application template, it is the top-level CMakeLists.txt from the previous step.
- If the project uses the Engine Plugin or Datasource plugin template, it is in the <KanziWorkspace>\Projects\<ProjectName>\Application\src\executable directory.
Link the Kanzi Monitor library to the application executable:
```
# Optional for MSVC: Link with the Monitor library.
target_link_libraries(${PROJECT_NAME} KanziPlugin::kzmonitor)
```
Regenerate the project from the updated CMake files.

For example, run the generate_cmake_vs2019_solution.bat script.

Add the kzmonitor module to module names in either application.cfg or under the onConfigure function:

application.cfg: ModuleNames = "kzmonitor"

void onConfigure(ApplicationProperties& configuration) override
{
    configuration.moduleNames = { "kzmonitor" };
}

Make sure that the application has the necessary privileges to write files and open TCP sockets.

Integrating to Android projects with Gradle, CMake, and Android Studio¶

Note

On Android, you must link Kanzi Monitor with target_link_libraries at build time. Dynamic plugin loading via ModuleNames alone does not work on Android because RTTI type information is not shared across .so library boundaries, which prevents the Kanzi Engine from recognizing the plugin module.

To integrate Kanzi Monitor from source to an Android application project:

In the CMakeLists.txt, add the Kanzi Monitor library root directory location to the CMake configuration.

Add these configurations after find_kanzi() and find_package() calls.

set(PLUGIN_COMMON_SETUP cmake/common-setup.cmake)

# KANZI_MONITOR_ROOT can be set explicitly: cmake -DKANZI_MONITOR_ROOT=<path>
# If not set, auto-detection from known locations is attempted.
if(NOT KANZI_MONITOR_ROOT)
    if(EXISTS ${PROJECT_SOURCE_DIR}/../../../Engine/plugins/monitor/${PLUGIN_COMMON_SETUP})
        set(KANZI_MONITOR_ROOT ${PROJECT_SOURCE_DIR}/../../../Engine/plugins/monitor)
    elseif(DEFINED ENV{KANZI_HOME} AND
           EXISTS "$ENV{KANZI_HOME}/Engine/plugins/monitor/${PLUGIN_COMMON_SETUP}")
        set(KANZI_MONITOR_ROOT "$ENV{KANZI_HOME}/Engine/plugins/monitor")
    endif()
    if(NOT KANZI_MONITOR_ROOT)
        message(FATAL_ERROR
            "Cannot find Monitor plugin root directory. "
            "Pass -DKANZI_MONITOR_ROOT=<path> to CMake, set the KANZI_HOME "
            "environment variable to your Kanzi workspace root, or install "
            "the plugin under 'WORKSPACE/Engine/plugins'.")
    endif()
endif()

include(${KANZI_MONITOR_ROOT}/${PLUGIN_COMMON_SETUP})
include(${KANZI_MONITOR_ROOT}/cmake/monitor-config.cmake)

Add the Kanzi Monitor library subdirectory to the top-level CMakeLists.txt:
```
add_subdirectory(${KANZI_MONITOR_ROOT} "${CMAKE_BINARY_DIR}/monitor")
```
Link the application executable with the Kanzi Monitor library.

Locate the CMakeLists.txt for the application executable:
- If the project uses the Basic Application template, it is the top-level CMakeLists.txt from the previous step.
- If the project uses the Engine Plugin or Datasource plugin template, it is in the <KanziWorkspace>\Projects\<ProjectName>\Application\src\executable directory.
Link the Kanzi Monitor library:
```
target_link_libraries(${PROJECT_NAME} KanziPlugin::kzmonitor)
```
If the Kanzi Monitor plugin is not added to the Kanzi Studio project, enable the plugin by adding it to the ModuleNames configuration option in application.cfg:
```
ModuleNames = "kzmonitor"
```
This is the recommended registration method for Android because it works with both Kanzi application frameworks:
- appfw (Basic Application template) – The application has a C++ ExampleApplication subclass, so you can alternatively set configuration.moduleNames = { "kzmonitor" }; in onConfigure().
- droidfw (Android Application template) – The application lifecycle is Java-driven and the C++ source is a stub, so application.cfg is the only viable registration path.
Regenerate the project from the updated CMake files.

For example, update your Android Studio and Gradle environment with the changes that you made to the CMake files.
Make sure that the application has the necessary privileges to write files and open TCP sockets. See Setting permissions on Android.

(Optional) If you need to use the Kanzi Monitor Java API, add AAR modules to the Android Studio project.

In Android Studio, go to the build.gradle file of your application and add Kanzi Monitor modules as dependencies:

def monitorLibDir = getKanzi().toString() + '/Engine/plugins/monitor/lib/android'

dependencies {
    debugImplementation     files("$monitorLibDir/monitor-debug.aar")
    profilingImplementation  files("$monitorLibDir/monitor-profiling.aar")
    releaseImplementation    files("$monitorLibDir/monitor-release.aar")
}

Integrating to QNX and Linux projects with SCons¶

To integrate Kanzi Monitor from source to a QNX or Linux application project:

Locate the Kanzi Monitor plugin root directory.

After installation, it is at <KanziWorkspace>/Engine/plugins/monitor/.

Edit the configs/platforms/common/config.py file of your project to define the kzmonitor module.

Add the following before the application module definition:

# Path to Monitor plugin directory.
monitor_dir = os.path.join(engine_root, "plugins", "monitor")

# Define the kzmonitor module to build from source.
kzmonitor = module("kzmonitor")
kzmonitor.type = "a"
kzmonitor.depends += ["kzcoreui"]
kzmonitor.root = os.path.join(monitor_dir, "src")
kzmonitor.include_paths += [os.path.join(monitor_dir, "include")]
kzmonitor.output_path = os.path.join(
    monitor_dir, "output", platform_name, profile_string, "plugin")
kzmonitor.install_dir = os.path.join(
    monitor_dir, "lib", platform_name, profile_string)
kzmonitor.binary_name = "kzmonitor"

if GetOption("build-dynamic-libs"):
    kzmonitor.type = "so"
    kzmonitor.env["SHLINKFLAGS"] += ["-shared"]
    kzmonitor.env["SHLINKFLAGS"] += ["-Wl,-soname,libkzmonitor.so"]
    kzmonitor.env["CPPDEFINES"] += ["KANZI_MONITOR_PLUGIN_API_EXPORT"]

del kzmonitor

In the same file, add kzmonitor as a dependency of the application module.

If the application code uses the Kanzi Monitor C++ API, also add the Kanzi Monitor include path:

m = module(project_name)
m.depends += ["kzmonitor"]
# Optional: Add Monitor include path if the application uses Monitor API.
m.include_paths += [os.path.join(monitor_dir, "include")]
del m

For QNX targets, add the socket library in the platform-specific config.py.

For example, in configs/platforms/qnx710_screen_aarch64/config.py:
```
m = module(project_name)
m.env["LIBS"] += ["socket"]
del m
```

Add the kzmonitor module to module names in either application.cfg or under the onConfigure function:

application.cfg: ModuleNames = "kzmonitor"

void onConfigure(ApplicationProperties& configuration) override
{
    configuration.moduleNames = { "kzmonitor" };
}

Build the project from the platform-specific SConstruct directory.

For example:
```
scons release ES3
```
Make sure that the application has the necessary privileges to write files and open TCP sockets.

Integrating Kanzi Monitor from source code¶

Integrating to Windows projects with CMake and Visual Studio¶

Integrating to Android projects with Gradle, CMake, and Android Studio¶

Integrating to QNX and Linux projects with SCons¶

See also¶