Boosting Harmony OS Apps: Taro’s C++‑Powered Multi‑Language Event System

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 between different language environments (C++, ArkTS, JS) becomes essential.

Taro accesses Harmony's C-API, sinking component and layout runtime logic to the C++ layer, greatly boosting page rendering performance.

Building an efficient event system that communicates across C++, ArkTS, and other languages is a valuable and necessary challenge 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 JS, allowing JS to invoke native ArkTS capabilities.

Design Considerations for Cross‑Language Event Architecture

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

By implementing the low‑level event logic in C++, a performant event management system avoids redundant interfaces and, through the C‑API, distributes events to each language environment efficiently.

Limitations of the ArkTS Event Architecture

Event architectures built purely in ArkTS suffer from poor performance during event bubbling, with heavy syntax and callback logic that can degrade performance and block the main thread, harming user experience.

Moving event handling to the C++ layer and executing it on background threads improves execution efficiency and prevents main‑thread blocking, resulting in smoother applications.

Building the Multi‑Language Event System

The system must manage various event types provided by Harmony, such as generic component events and gestures, and dispatch them orderly based on framework and user listeners.

Events are categorized into normal events (system, application, component lifecycle) handled by an eventCenter, and node events tightly linked to the DOM tree that require rapid response.

Implementation of the Event Center

The event center, a core Taro runtime module, 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 Dispatch

Developers can create listeners in C++, ArkTS, or other languages and add 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 cross‑language handling while maintaining high performance and stability.

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

Node Event Handling (domEvent)

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

Event Types

Taro handles three node event types: Harmony events, Harmony gesture events, and custom events, all listened to and triggered from TaroElement. Events are registered to a Receiver via RenderNode for native events, while custom events are user‑defined.

Event Propagation

When an event on a TaroElement is triggered, it propagates upward through the node tree. Each node can process or stop propagation, allowing flexible business logic adjustments.

Harmony’s underlying node events have a different propagation model; to avoid interference, their bubbling must be prevented and propagation taken over.

Event Callbacks

Callbacks serialize standard Web properties (e.g., target, stopPropagation, value) onto the event object, ensuring consistent behavior across language boundaries.

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

Summary and Outlook

Ensuring consistent event transmission across multiple language environments enhances maintainability and speeds up module collaboration. The current solution improves response time and inter‑module coordination.

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

Future Taro for Harmony developments will further strengthen cross‑language module cooperation, using the event system to decouple logic and enable more flexible composition.