Designing a Universal Event System for Multi-Language Environments in Taro for Harmony

Background

In the Harmony ecosystem, native apps are usually built with ArkTS, but using C++ can significantly improve framework and business performance. As Harmony evolves, collaboration across different language environments has become essential, creating a richer development ecosystem.

Taro integrates the Harmony C‑API, sinking component and layout runtime logic to the C++ layer, greatly enhancing page rendering performance.

Given this context, building an efficient event system that enables communication between C++, ArkTS, and other languages is a valuable and necessary task for Taro.

Multi-Language Event Handling Mechanism

During Harmony adaptation, the event system drives application, page, and component lifecycles and acts as a bridge between ArkTS and JavaScript, allowing JS to invoke native ArkTS capabilities.

Design Considerations for Cross‑Language Event‑Driven Architecture

Designing a cross‑language event architecture must consider the constraints and runtime differences of ArkTS, JavaScript, and C++. Ensuring orderly event transmission across these environments is a key design challenge.

Limitations of the ArkTS Event Architecture

The ArkTS‑based event architecture suffers from performance bottlenecks, especially during event bubbling, which can degrade responsiveness and block the main thread.

To address these issues, Taro pushes event handling logic to the C++ layer and executes it on background threads, improving execution efficiency and preventing main‑thread blocking.

Building the Event System for Multi‑Language Environments

The system must manage various event types, such as common component events and gestures, and dispatch them according to framework and user listeners.

Events are categorized into general events and node events. General events cover system‑level and component lifecycle changes and are handled by the eventCenter . Node events are tightly coupled with the DOM Tree and require fast responses.

Implementation of the Event Center (eventCenter)

The event center, a core module of the Taro runtime, processes system events and lifecycles. It allows developers to register event queues on background threads and dispatch events asynchronously, reducing main‑thread load and providing robust error handling.

Event Listening and Dispatching

Developers can create listeners in C++, ArkTS, and other languages, adding callbacks to the event queue. When an event fires, parameters are converted to the appropriate format for each language, ensuring seamless data transfer.

The event queue dispatches events to listeners in a predefined order, enabling efficient cross‑language handling while maintaining high performance and stability.

Note: In ArkTS, registered events must return to the main thread, and the Harmony platform does not support Symbol‑type events.

Node Event Handling (domEvent)

Node events follow the classic capture‑to‑target‑to‑bubble flow. Taro replicates this propagation model on Harmony, providing a consistent developer experience.

Event Types

Taro handles three main node event types: Harmony events, Harmony gesture events, and custom events. These are listened to and triggered on the TaroElement via a Receiver obtained from the RenderNode .

Event Propagation

When an event on a TaroElement is triggered, it propagates up the node tree. Each node receives the event, executes its callback, and may stop propagation, mirroring standard web behavior.

Harmony’s underlying node events have a different propagation logic compared to the ArkNode tree; to avoid interference, their bubbling must be prevented and the propagation flow manually managed.

Event Callback

Node events are serialized and attached with standard Web properties such as target , stopPropagation , and value , ensuring consistent callback behavior across languages.

Many C++ components rely on this mechanism to update properties and communicate between nodes, guaranteeing timely data reflection and smooth user interaction.

Summary and Outlook

Ensuring consistent event transmission across multiple language environments enhances maintainability and module decoupling. The current solution improves response speed and inter‑module collaboration.

Remaining challenges include early workarounds that bypass ArkTS‑JS call limits, which could be addressed with TurboModule for more direct calls.

Future Taro for Harmony releases will further strengthen cross‑language cooperation, leveraging the event system to achieve flexible module composition.