openharmonyinsight/openharmony-skills
Overview
This skill defines an iterative multi-agent workflow to migrate Android projects to HarmonyOS. It coordinates Analyzer, Planner, Translator, Validator (using ohos-app-build-debug), Tester, Feature Comparator, and UI Comparator agents to convert, validate, test, and compare modules until parity is achieved. The workflow includes scripts, API mappings, component patterns, and automated verification tools to speed and standardize migration.
How this skill works
The Analyzer agent scans the Android codebase and outputs a structure and dependency report. The Planner creates a modular migration plan and prioritizes modules. The Translator converts Java/Kotlin and Android components to ArkTS and HarmonyOS components. The Validator compiles and packages using the ohos-app-build-debug skill, then the Tester runs functional tests. After all modules complete, Feature Comparator and UI Comparator run global comparisons and feed missing items back to the Planner for another iteration.
When to use it
- Migrating an existing Android app to HarmonyOS with repeatable quality checks
- When you need automated, per-module conversion and validation (Java/Kotlin to ArkTS)
- If you require compiled verification and on-device launch checks using ohos-app-build-debug
- When visual parity between Android and HarmonyOS UI must be measured and corrected
- For iterative migration where missing features are discovered and re-planned
Best practices
- Start with Analyzer to get accurate module sizing and dependencies before planning
- Follow Planner priorities: data layer → business logic → UI layer, ~5000 LOC per module
- Run Validator with ohos-app-build-debug for automated build, install, launch, and screenshot validation
- Keep API_MAPPING and COMPONENT_MAPPING updated to reflect platform differences
- Run global Feature and UI comparisons only after all modules complete, then iterate on missing items
Example use cases
- Migrate a medium Android app by converting Activity→Page and RecyclerView→LazyForEach module-by-module
- Validate converted code by compiling with ohos-app-build-debug, packaging HAPs, and verifying startup screen on device
- Detect business logic gaps with Feature Comparator and create remediation modules in Planner
- Automatically compare screenshots and layout structure between Android and HarmonyOS using Hypium scripts
- Use the workflow for continuous migration cycles until feature and UI parity are achieved
FAQ
It builds the HarmonyOS project, generates HAP packages, installs or simulates install, launches the app, and captures screenshots to confirm the first screen and build integrity.
When are Feature and UI comparisons executed?
Both comparators run after all planned modules are migrated. Their outputs (missing features and UI differences) are returned to Planner to schedule follow-up migration iterations.
23 skills
This skill orchestrates an iterative Android to HarmonyOS migration workflow with agents for analysis, planning, translation, validation, testing, and UI
This skill automates PR work by analyzing changes, generating descriptions, signing off with DCO, and creating linked issues and PRs.
This skill optimizes C++ header file compilation efficiency by systematically reducing dependencies and moving implementations from headers to cpp files.
This skill helps you generate pixel-level OpenHarmony graphic test code with a complete framework, templates, and API references.
This skill performs read-only OpenHarmony dsoftbus code reviews, enforcing safety and logging standards with cross-file and control-flow analysis.
This skill automates OpenHarmony UT and fuzz test workflows, guiding you through configuration, compilation, deployment, and execution for reliable tests.
This skill enforces OpenHarmony C++ conventions, reviewing and refactoring code to ensure naming, formatting, header usage, and secure memory practices.
This skill helps you debug HarmonyOS ArkWeb apps by automating DevTools setup, port forwarding, and webview inspection.
This skill automates OpenHarmony XTS test case generation by parsing API definitions, analyzing coverage, and generating design docs and code that follow XTS
This skill analyzes compilation efficiency for a given source file, reporting compile time, memory usage, and header dependency tree to optimize builds.
This skill helps generate PlantUML sequence and class diagrams for new interfaces by analyzing code patterns and reference interfaces.
This skill reviews C++ code against Core Guidelines using parallel sub-agents, generating per-section findings and a consolidated summary for actionable fixes.
This skill analyzes AI-generated unit tests for coverage, assertions, and determinism, delivering a score, risk level, and must-fix checklist.
This skill builds, installs, launches, and debugs HarmonyOS/OpenHarmony apps by auto-detecting DevEco Studio and configuring tools for you.
This skill performs deep C/C++ thread-safety and lifecycle reviews for OpenHarmony/Chromium code, generating structured JSON and Markdown reports to guide
This skill evaluates AI-generated business code quality, scores 0-10, assesses risk, and generates must-fix items with concrete evidence.
This skill helps integrate a transparent passthrough interface into OpenHarmony graphic_2d by generating IPC plumbing and service-side stubs.
This skill guides designing ArkUI API following OpenHarmony guidelines, synchronizing static and dynamic interfaces, and validating resources and typings.
This skill automates OpenHarmony graphic Gitcode PR creation by guiding status, commits with Signed-off-by, issue and PR template generation.
This skill scans C/C++ codebases for size and circular dependency issues, analyzes maintainability, and reports actionable findings to guide refactoring.
This skill generates architecture and functional design documents from a PRD, analyzing OpenHarmony code to ensure compatibility and structured competitor
This skill orchestrates XTS build and run in one workflow, compiling to HAP and executing tests with optional package and api parameters.
This skill generates OpenHarmony C++ unit tests adhering to HWTEST_F conventions, ensuring 75%+ coverage and consistent mock, NDK/NAPI handling.
