hmos-appfreeze-analysis

Analyzes HarmonyOS appfreeze faultlogs to locate freeze root causes with evidence chains.

2|Updated Jun 21, 2026
One-click install
npx skills add https://github.com/IsKenKenYa/skills --skill hmos-appfreeze-analysis-iskenkenya
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: hmos-appfreeze-analysis
Source: https://github.com/IsKenKenYa/skills/tree/main/skills/harmonyos/solutions/quality/stability/hmos-appfreeze-analysis
Command: npx skills add https://github.com/IsKenKenYa/skills --skill hmos-appfreeze-analysis-iskenkenya

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve? Diagnosing HarmonyOS/OpenHarmony app freeze (ANR, screen freeze, thread block) failures from raw faultlogs is slow and error-prone, requiring deep knowledge of thread stacks, Binder IPC, EventHandler queues, FFRT, and libuv. This Skill automates the analysis and produces a structured root-cause report with a complete evidence chain. ## Core Features & Use Cases - Sectioned faultlog parsing: Python scripts extract overview, resources, event queue, fault stacks, other threads, Binder propagation chains, and attachments on demand, keeping context small. - Nine-step diagnostic workflow: Rules out system-level causes first (low memory, high CPU load, thermal throttling), then analyzes thread stacks, lock holders, Binder peer chains, FFRT workers, and libuv event loops. - Three-level root cause library: Matches failures against a fault mode library (main thread blocked/busy, input timeout, system overload) and outputs a standardized report with responsibility domain (app/system/mixed) and targeted fix suggestions. - Use Case: A developer receives an APPFREEZE faultlog and sample stack file from a user device; the Skill identifies that the main thread is blocked on a Binder call to a system service whose thread pool is exhausted, and outputs system-side fix recommendations. ## Quick Start Use the hmos-appfreeze-analysis skill to analyze this faultlog file and sample stack file and tell me the root cause of the app freeze.

Frequently Asked Questions about hmos-appfreeze-analysis

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I analyze a HarmonyOS appfreeze faultlog?

Provide the faultlog file and optional sample stack file, then the Skill runs scripts/freeze/main.py with section flags to extract overview, resources, stacks, and Binder data step by step. It concludes with a structured report naming the root cause module and responsibility domain.

What freeze fault types does this analysis support?

It supports APPFREEZE, THREAD_BLOCK_6S, APP_INPUT_BLOCK, LIFECYCLE_TIMEOUT, and BUSSINESS_THREAD_BLOCK_6S/BUSINESS_THREAD_BLOCK_6S business thread events. Business thread events are analyzed against the event-reported TID rather than the main thread.

Does the faultlog analyzer require third-party Python packages?

No, the analysis scripts use only the Python standard library and built-in modules. You only need a working Python 3 interpreter and the correct paths to the faultlog and sample stack files.

How does it distinguish app-side from system-side root causes?

It traces lock holders, Binder peer threads, FFRT workers, and libuv callbacks to the actual implementing module, then assigns responsibility as app, system, mixed, or undetermined. Fix suggestions are restricted to the determined responsibility domain.

Why does the analysis stop early on low memory or high load?

System-level anomalies like low memory, CPU load above 85%, or thermal throttling distort DFX stack captures, making thread stacks unreliable. When NOTE contains system low memory and thermal throttling, the Skill terminates with a system overload conclusion.

Can it analyze FFRT and libuv related freeze issues?

Yes, dedicated reference guides cover FFRT worker exhaustion, task timeout, queue blocking, and primitive deadlocks, plus libuv event loop stalls, thread pool exhaustion, async callback abuse, and synchronous fs calls on the main thread.