The Day I Rejected Flutter and Still Couldn't Explain the Android Framework
The Day I Vetoed the Flutter Proposal, I Realized I Couldn't Articulate What the Framework Governs
Author: 疯华整猫
In the week after August 31, 2026, we raised module M's targetSdk from 34 to 36. The new rule from Play took effect that day: new apps and app updates must target Android 16 (API 36) or higher; those needing more time could apply for an extension to November 1. We didn't want to apply, so we started changing two weeks early.
The trouble wasn't compilation; it was the report page. On the second day of gray release, support passed on a piece of feedback: on a large-screen foldable, in expanded mode, switching from the report page to the inspection sheet and back, the follow-up note being filled in on the page had vanished, and the backend received two identical submissions. I couldn't reproduce it no matter how I tried with my own Pixel 6. Later I borrowed a tablet and changed the window size with adb shell wm size to hit it. Android 16, for large-screen devices (minimum width > 600dp), by default causes Activity recreation on orientation and size changes. With target 36 you can still opt out in the manifest, but the version after 2026 (expected API 37) won't allow it. We had written state saving in onSaveInstanceState, but that note was stuffed into the ViewModel in an async callback; when recreation happened, the callback hadn't returned yet.
In the review meeting, someone said: this area will eventually need to be consistent across both platforms; why not rewrite it with Flutter, one codebase, and you won't have to follow Android's version behaviors. I rejected it at the time with a fluent argument: the report page needs to call the system's PdfRenderer to render the inspection sheet, needs hardware Bitmap, and before exporting the PDF, must clear in-memory data per compliance requirements. These pipelines, if changed to a self-drawing engine, would all need to be re-bridged, and the saved manpower wouldn't cover the cost.
After the meeting, I sat at my desk and thought again about the phrase "no need to follow Android's version behaviors," and suddenly felt a bit uneasy. Where does Flutter's Engine run? It runs inside the Android process. Who gives it the canvas? Who manages its lifecycle, permissions, window insets, and how to recover after being reclaimed by the system? I could rattle off "Binder", "WMS", "SurfaceFlinger", but if someone pressed further: "Who exactly triggers Activity recreation, and why can targetSdk change it?" I couldn't answer.
I've been doing Android for six years, using things provided by the Framework every day, but I never seriously read a line of it. That afternoon I listed two questions for myself, and it took nearly half a year to write the answers down clearly: Switching frameworks can replace the API, but not the platform; and, the question "is it still worth learning" puts two completely different types of assets on the same scale.
First, Break Down the Word "Framework"
This term has always been used loosely in Chinese technical discussions, and that looseness creates many false problems.
Some people mean the system source code at frameworks/base: ActivityManagerService, WindowManagerService, PackageManagerService, ViewRootImpl, Binder, Zygote, SurfaceFlinger, ART. Others mean "app architecture" - MVP/MVVM/MVI, modularization, a self-wrapped base layer and routing. Still others use it to mean "a certain company's internal framework."
In interviews, the phrase "do you know Framework" usually refers to the first kind; on resumes, "familiar with Framework" often means the second. The rest of this article only covers the first, i.e., the platform layer. Not because the second is unimportant, but because the one that stumped me this time was the first: why did changing one number, targetSdk, change the life and death of the Activity on screen? That has nothing to do with architecture patterns; the answer lies between ActivityTaskManagerService and ActivityRecord.
Putting the platform layer and app layer side by side, one click passes through these places:
| Layer | Who is responsible | Can this layer be replaced? | Where did I step on the pit this time |
|---|---|---|---|
| Business code | Our Kotlin / Dart | Can be replaced anytime | State saving written in the wrong place |
| UI toolkit | View / Compose / Flutter Widget | Replaced when switching stacks | None |
| App framework | ActivityThread, ViewRootImpl, Choreographer |
Cannot be replaced by switching stacks | Activity recreation, lifecycle callback order |
| System services | ATMS / WMS / PMS / InputManager | Cannot be replaced by switching stacks | Configuration change decision happens here |
| Cross-process & runtime | Binder, ART, Zygote | Cannot be replaced by switching stacks | None |
| Graphics & kernel | SurfaceFlinger, HardwareBuffer, Linux | Cannot be replaced by switching stacks | The chain that PDF rendering walks lives here |
flowchart TB
subgraph APP["App side: area that switching stacks can change"]
A["Business code Kotlin / Dart"] --> B["UI toolkit View / Compose / Widget"]
end
subgraph PLAT["Platform side: area that switching stacks cannot change"]
C["App framework ActivityThread / ViewRootImpl"]
D["System services ATMS / WMS / PMS"]
E["Binder / ART / Zygote"]
F["SurfaceFlinger / HAL / Kernel"]
end
B --> C --> D --> E --> F
A -. "Platform Channel / FFI" .-> C
B -. "Platform View embeds native" .-> D
Flutter replaces part of the top two cells. Its Widget tree, layout algorithm, render instruction generation, and animation driving all happen on the Dart side; the Engine uses C++ to draw the result onto an ANativeWindow. But as long as it runs on Android, the bottom four cells are all still there: the process is still forked by Zygote, Activity is still managed by ATMS, windows are still allocated by WMS, permissions and insets still come from the system, and recovery after being reclaimed still relies on the onSaveInstanceState mechanism.
What I said at that review meeting, "no need to follow Android's version behaviors," only holds in one case: this page doesn't touch any platform capability at all, doesn't need to handle window changes, and won't be reclaimed and restored by the system. The report page in a healthcare app fails all of those conditions.
What a Single Expansion Looks Like at Six Levels
Later, I recorded the whole process on that tablet with Perfetto, and also read through source code and dumpsys. I transcribed the same event into my notes at six levels. This table does more than any sentence like "learn the low-level stuff" to show the problem.
| Observation point | What you see | What it answers | What it can't answer |
|---|---|---|---|
| User's eyes | Expand the foldable, note disappears, two submissions | What the phenomenon is | Who lost the state |
| App logs | onCreate runs again, ViewModel is a new instance |
Component was recreated | Why it was recreated |
dumpsys activity activities |
Original ActivityRecord destroyed, new record has same token sequence |
System indeed killed the old instance | What the decision basis was |
dumpsys window |
smallestScreenWidthDp in Configuration changes from 420 to 720 |
Trigger source is size band crossing 600dp | Why crossing the band requires recreation |
AOSP ActivityTaskManagerService |
Configuration change goes to relaunch branch; with target 36 and large screen, opt-out doesn't take effect |
Platform picks branch by targetSdk | How state should be saved |
| Our own code | Note written into ViewModel in async callback, not into saved state | Where the fix point is | The previous five layers' business |
Of the six rows, the last one is what I can change; the first five are what I need to understand. I used to think "learning Framework" meant to change the first five - modifying system services, doing ROM work, writing black tech. After this, I changed my view: for the vast majority of app developers who will never touch AOSP compilation, the value of reading it is that when someone else changes the first five rows, you can locate the sixth row within an hour, instead of guessing, waiting for gray release, or relying on "upgrade luck."
This judgment will be reused later: whether Flutter is worth learning, whether Framework is worth chewing on, you have to first ask "which row am I usually stuck at."
What Switching Stacks Actually Bypasses, and What It Doesn't
There's plenty of material on Flutter's principles; I only write the part relevant to this decision: where exactly it cuts coupling with the platform.
In the traditional View system, a TextView is ultimately a platform View object. Measurement, layout, and drawing all go through the View tree launched by ViewRootImpl, and drawing commands are then handed to RenderThread and GPU. Compose changed the description method, but the landing point is still the AndroidComposeView in the View tree, and the VSYNC signal from Choreographer is still the same one. Flutter is different: Widgets are just configurations, RenderObject does layout, the generated Layer tree is handed to the Engine, and the Engine draws it itself with Skia or later Impeller. It doesn't ask the system for a View to display text; it asks for a canvas.
This difference brings two real consequences.
One is strong consistency. The same Dart code generates almost identical drawing instructions on Android and iOS, without having to adjust font size, line height, and corner radius on both sides. The other is that platform capabilities must cross a bridge. Camera, Bluetooth, biometrics, system PDF rendering, notifications, background tasks, dark/light mode and font scaling, notches and gesture areas, multi-window - all have to go through a Platform Channel or FFI back to the native side. Flutter later moved Dart execution from a separate UI thread to the platform main thread, so synchronous FFI calls no longer need to cross threads; this is precisely to compress the cost of that bridge - the bridge hasn't disappeared, it's just shorter.
In hybrid stacks it's more obvious. To embed a native map or native WebView inside a Flutter page, you use Platform View; the Hybrid Composition series on the Android side has been revised several times, and essentially still lets native Views and Flutter's canvas compose in SurfaceFlinger. I later measured on a mid-to-low-end device: when embedding a native PdfRenderer output in the report page, the P90 frame time during scrolling was about 6ms worse than the pure native implementation. The sample was only ten rounds, the machine was old, and this number can't support any conclusion, but it's enough to show that "the bridge isn't free."
sequenceDiagram
participant D as Dart Widget tree
participant E as Flutter Engine (C++)
participant A as Android app framework
participant S as System services / SurfaceFlinger
D->>E: Layer tree and drawing instructions
E->>S: Submit to ANativeWindow / GPU
D->>A: Platform Channel request for PDF rendering
A->>S: Apply for HardwareBuffer via system API
S-->>A: Return buffer
A-->>D: Return result (serialized)
Note over A,S: State saving, permissions, insets, lifecycle still determined by platform
So the phrase "switching UI stacks" is accurate; "not having to follow version behaviors" is not. Android 16 making large screens default to recreation on adjustable size and orientation changes doesn't care whether the page draws View or Widget - it cares about the Configuration of the Activity, and the FlutterActivity that hosts Flutter is an Activity too.
Later I wrote this into the selection checklist for my team, in one sentence: Switching stacks saves the repetitive labor of the second layer; it doesn't save a single system behavior change from the third layer downward.
The Shape of a Channel Call at Six Places
The sentence "switching stacks can't replace the platform" sounds like a conclusion, but it stops being abstract when you unpack a single call. I made a table for the most ordinary Channel in the report page: the Dart side calls a method for the native side to decode the inspection sheet PNG into a shareable temp file and return the path.
| Location | Form | Who sets the rules | What problems occurred |
|---|---|---|---|
| Dart business code | await platform.invokeMethod('decodeReport', {'id': ...}) |
Us | Method name changed once, forgot to sync |
| Standard message codec | Args serialized to binary, return value likewise | Flutter's codec | Passed an unsupported type, blew up at runtime |
| Engine / JNI | Switch from Dart side to platform thread, enter Java layer via FlutterJNI |
Engine | Around 3.29 Dart execution threads merged, synchronous FFI overhead changed |
| App framework | MethodChannel handler runs on main thread, decoding goes to BitmapFactory |
Android | Large image decoded on main thread, dropped frames |
| System services / Binder | Getting a temp file requires FileProvider authorization, cross-process to external apps |
Platform | After target upgrade, URI authorization scope tightened, sharing failed |
| Graphics & kernel | Pixel buffer actually lands in native / HardwareBuffer | Platform | Memory peak higher than Java heap curve, invisible in heap dumps |
Of the six rows, the first two come with the cross-end stack, the third from the Engine, the last three are all platform. Switching stacks only rewrites the first two rows; the last four don't change a word, and a cross-language boundary is added. The method-name desync accident happened exactly in the one place that was "new."
This is also my most concrete answer to "is learning Framework useful": in the process hosting the Flutter page, Bitmap pixels are on the native heap, URI authorization is managed by system services, large image decoding shouldn't be on the main thread, and after being reclaimed, state has to be saved yourself - none of this cares whether the page draws Widget or View. If you only know the first two rows, when something goes wrong you won't even know which log to look at.
Later I added a very blunt rule to hybrid-stack code reviews: for every new Channel, the contract file must state clearly "which platform layer this lands on after crossing the boundary." After writing that down, I found that most Channels shouldn't exist at all - what they did could be done purely with data on the Dart side; they crossed the boundary just because it was convenient at the time.
The Android 9 Dividing Line
Learning the Framework had a different meaning around 2018, and that has to be addressed separately, or you'll conflate two completely different paths.
Early on, many "Framework tricks" were actually reflecting into hidden APIs: taking ActivityThread.currentActivityThread(), modifying AssetManager to add plugin resources, hooking Instrumentation for unregistered Activity launching, reflecting PackageManager to install plugins. Back then, the direct payoff of reading source was hard - reading it let you do things others couldn't. An entire generation of pluginization, hot fix, and dual-app solutions in China grew on this ground.
Starting with Android 9 (API 28, August 2018), the platform systematically closed this path. The platform restricted non-SDK interfaces, whether accessed directly, by reflection, or via JNI handles. The list has several categories: blocked (originally blacklist, unusable regardless of target), max-target-x (originally greylist-max-x, tightened by app target API), unsupported (originally greylist, currently available but not promised), sdk (public API), and test-api (absorbed into blocklist from Android 11 / API 30). Each version publishes a hiddenapi-flags.csv; Android 16's even includes a checksum. Runtime enforcement policy goes from kNoChecks, kJustWarn, to kDarkGreyAndBlackList, and debug packages and release packages behave differently.
This means two things happen at once.
On one hand, the monetization path "reading Framework source code = being able to call hidden APIs" is basically closed. Target API is raised once a year. Play requires 36 from 2026-08-31, and API 37 is expected from 2027-08. Each raise tightens the list another round, and features held up by reflection have to be re-bet every year. I saw an old project's plugin framework collapse entirely when raising target 34 to 35; it took three weeks to change to standard dynamic feature modules. Those three weeks bought not new capability, but debt repayment.
On the other hand, the explanatory half of the value actually rose. The more complex the list, the more target branches, the more system behavior forks by version, the harder it is to figure out "why this happened this time" by searching and guessing. In the six-row table earlier, all the first five rows fall into this half.
I drew a very rough but useful line for myself: before 2018, a large chunk of Framework knowledge was "what you can do"; after 2018, what's left is "why it's this way." The former was actively shut off by the platform; the latter the platform can't shut off, and doesn't intend to. Now when someone says "since hidden APIs can't be used, learning Framework is useless," they're using the first half to deny the second half.
The real question is: what do you plan to use it for? If you want to join a phone vendor doing ROM customization, work on AAOS in cars, or do system performance optimization, the first half doesn't even apply - those roles work inside the platform; the list is meant for third-party apps, not for the system itself. If you do application development, the second half is what you use every day.
How the Two Lines Grew to Where They Are Today
Put the two timelines side by side and many debates dissolve on their own. They started from different points, solved different problems, and only happened to collide at the "cross-platform" crossroads in recent years.
| Time | Platform / version | What changed |
|---|---|---|
| 2008-09-23 | Android 1.0 / API 1 | The base of four components, Binder, Dalvik was set |
| 2015 | Dart Developer Summit | Flutter predecessor Sky debuted, running on Android, claimed stable 120fps rendering |
| 2017-05-12 | Flutter alpha 0.0.6 | First publicly downloadable version |
| 2017 | Kotlin 1.2 / KotlinConf | Official Android support for Kotlin; multiplatform project concept proposed, only JVM and JS at the time |
| 2018-08-06 | Android 9 / API 28 | Non-SDK interface restrictions landed, reflection into hidden APIs started tightening by list |
| 2018-12-04 | Flutter 1.0 | Flutter Live London release, first stable version |
| 2019-05 | Google I/O | Android announces Kotlin-first; Jetpack Compose first shown |
| 2021-03-03 | Flutter 2 | Web promoted to stable, desktop early access, Dart 2 introduces null safety (optional) |
| 2021-07 | Compose 1.0 | Production usable, official says Play Store already had 2000+ apps using it |
| 2022-05-12 | Flutter 3 / Dart 2.17 | Six platforms stable; Impeller first appears as experimental preview on iOS, official text says "not production ready" |
| 2023-11 | KMP | JetBrains announces Kotlin Multiplatform stable |
| 2024-04 | — | A Google layoff involving multiple teams affected some Flutter/Dart roles |
| 2024-05 | Google I/O | Official support for sharing Android and iOS business logic with KMP; says 95% of top 1000 Android apps contain Kotlin code |
| 2024-10-22 | HarmonyOS NEXT / HarmonyOS 5 | Official release in mainland China, removed AOSP code, no longer compatible with ordinary APKs |
| 2024-10-27 | Flock | Some community developers start a Flutter fork, questioning upstream investment; mainline remains upstream |
| 2025-01-29 | Dart | Macros canceled entirely after two years of work and nearly 1400 likes on the tracking issue, reason is unacceptable hot-reload performance regression |
| 2025-05 | Compose Multiplatform 1.8.0 | iOS marked stable |
| 2025 | Android 16 / API 36 | Large-screen devices (min width > 600dp) under target 36 default to recreation on orientation/size change, opt-out allowed |
| 2026-03-27 | AOSP | Official recommends switching to android-latest-release instead of aosp-main; source code switches to two releases per year, Q2 and Q4 |
| 2026-08-31 | Google Play | New apps and updates must target 36; extension to 11-01 can be requested. API 37 expected required from 2027-08 |
| 2026 within | Flutter | Keeps quarterly stable releases, Impeller is the only rendering backend on iOS and default on Android API 29+, desktop follows |
The thing most worth watching in the table isn't any version number; it's the direction of the two lines. The platform line has been doing the same thing for years: forking behavior by targetSdk, collecting implicit capabilities into explicit declarations, and tightening background and privacy every year. The tooling line has been doing another thing: extracting UI description from platform APIs, first to declarative, then to self-drawing, then to multi-end sharing.
One is going toward a "finer platform contract," the other toward a "thicker abstraction layer." The thicker the abstraction, the more people need to know what the contract underneath says - because where the abstraction leaks is always where you most need explanation.
My Version-Number Check Failed on Secondhand Sources
Before writing these notes, I wanted to add "as of November 2026, the latest stable Flutter version is X" at the beginning. I checked four sources and got four answers.
A Chinese wiki page, under the same "2026-05-12" entry, had one place saying 3.41.9 was latest and another saying 3.47. An English tech blog listed by release: 3.41 (Feb), 3.44 (May), 3.47 (Aug), 3.47.5 with Dart 3.13 (Sep 18). Another 2026 annual review wrote "the latest in 2026 is 3.44 / Dart 3.12," apparently taking the May release as the annual version. Another mixed "the repo was still active on Nov 30, 2025" with "updated Aug 12, 2026" in one paragraph.
I didn't pick one and write it down. What ended up in my notes was a blunt but unmissable sentence: Stable versions release quarterly, and releases continued through 2026; for the exact version number, refer to the official SDK archive at the time of writing. The vendor's own announcement of 1.5 million monthly active developers in May 2026, up 50% year-over-year, I also marked as "official figure, measurement method not disclosed."
In the same round of checking, I ran into something else. Searching for "domestic big company Flutter adoption," the case sections in the top five Chinese articles were almost verbatim identical: Xianyu's core pages, WeCom, QQ Music, Feishu, Guagualong, and the numbers "cross-platform adaptation costs down 60%" and "iteration cycles down 40%" were identical down to the punctuation. I couldn't find a first-hand technical post-mortem attributed to any team, and ultimately didn't put a single percentage into the main text.
That itself is quite telling: To judge whether a technology is worth investing in, you first have to be able to tell whether what you're reading is a release record, a vendor's self-report, a survey sample, or a press release passed through five hands. This has nothing to do with learning Flutter or chewing Framework; it's a separate capability.
Which Old Tricks Failed, and Which Came Back
| Practice | Why it worked back then | Now |
|---|---|---|
Reflecting @hide APIs for pluginization / hot fix |
The platform didn't guard; read the source and get the handle | Tightened by list from Android 9, target raised yearly, basically debt |
Using Instrumentation hook for unregistered Activity launching |
Same as above | Same as above, and mainstream pluginization has moved to standard dynamic delivery |
| Multi-process "keep alive" | Early background restrictions were loose | Background-launched FGS throws exceptions, FGS types and quotas, store and compliance fail |
| Treating Framework source as interview trivia | Roles were concentrated on the app side, testing rote memory | In automotive/system JD, it becomes practical: modify AMS/WMS, AIDL, HAL |
| Handwriting two sets of UI | Cross-end options weren't mature | Rich-interaction, strong-platform-integration pages are now reconsidered more stable |
| Self-drawing engine | Early shader compilation stutter was a real flaw | Impeller pre-compiles shaders, closing that gap; judgments from around 2018 need rewriting |
| Reading AOSP source | Had to pull 100GB and compile | The bar hasn't dropped, it's risen, but online source search and trace tools are much better |
The last two rows are two sides of the same coin. I tried a preview of Flutter 0.x in 2019; on the mid-range phone of the time, scrolling a complex list stuttered, and I decided it "doesn't suit our business" and didn't look at it for six years. Before that review meeting I reinstalled it, and Impeller had already pre-compiled the first-frame shader batch at build time. The official comparison in the Flutter 3 release post was that the Gallery transition animation's worst frame was about 20x faster. I had read that number back then too, but never connected it to "it will change later."
A judgment based on 2019 performance stayed a long-term conclusion for six years. That is more worth noting than "not learning a new technology."
There's a Third Road, But It's Not on the Same Axis
I have to admit this before writing further, or discussing "cross-platform" in 2026 and only mentioning Flutter would miss half the map. Compose and Kotlin Multiplatform have been walking a different route these years, and their relation to this article's question is quite special.
The difference among the three strategies isn't speed; it's which layer is shared:
| Strategy | What is shared | Where UI lands | New things to accept | For existing native teams |
|---|---|---|---|---|
| Flutter | Logic + UI | Self-drawing engine, same on both ends | Dart, a second UI stack, engine fixed cost | Most thorough replacement |
| KMP | Business logic | Each end native (Compose / SwiftUI) | Multiplatform modules, expect/actual, Kotlin/Native builds |
Least replacement |
| Compose Multiplatform | Logic + UI | Self-drawing, based on Compose | Kotlin multiplatform toolchain | Medium, Android-side mental model carries over |
The KMP timeline is in the earlier table: proposed as multiplatform project concept in 2017, stable in Nov 2023, Google officially supported sharing Android and iOS business logic at I/O in May 2024, Compose Multiplatform's iOS went stable in May 2025. In JetBrains' 2025 developer ecosystem survey, KMP's share among cross-platform users rose from 7% in 2024 to 18%; the same report cites Appfigures data that top 10000 App Store apps using KMP went from under 1% in early 2024 to nearly 3% by mid-2026, and among top apps, KMP apps' total revenue caught up with Flutter apps. These last two figures come from third-party data commissioned by JetBrains and vendor reports, not independent audits; I noted the caveat as usual.
The interesting part is its effect on this question, which is different from what many think.
KMP doesn't require you to replace your UI stack, so its demand on the platform layer isn't reduced at all. The seam that expect/actual draws falls exactly on platform capabilities: networking, storage, permissions, lifecycle, hardware access - every one needs an actual written on the Android side, and that actual is written against platform APIs. The thicker the shared layer, the thinner the platform-side layer, but the thinner it gets, the less room for error - there's no second person to back it up.
Compose Multiplatform is also self-drawing on iOS. That means it faces the same set of bridge, insets, lifecycle, and recovery-after-reclaim problems as Flutter, just with different language and component library. The twelve-item checklist earlier applies equally to it.
So the real change in 2026, I think, is not "Flutter lost to KMP," but that "how much to share" has gone from a binary choice to an adjustable slider: from a shared network module, to half the business logic, to sharing the UI as well, with granularity chosen per project. This makes the question "should we switch stacks" even less precise - now even "how much to switch" can be decided per module.
The platform contract under the slider is always there. That's also why I didn't write a separate chapter comparing Compose/KMP: they change how the second layer is organized, not the ledger of the sixth layer.
And a practical takeaway: this year I didn't adopt KMP, but I walked module M through its approach: which code is truly platform-independent, and which only looks independent. After walking through it, I found that the report page's state layer had a large chunk mixed with lifecycle assumptions; I split it into pure state and platform adaptation. This checklist introduced no new technology, but it made the target 36 fix go from "patch one thing, patch another" to "change one place." Knowing which logic belongs to which layer is exactly what the Framework perspective gives you.
Angle One: These Are Not the Same Kind of Asset
Putting "learning Flutter" and "learning Framework" on the same scale presupposes they're the same kind. Let me unpack what each contains.
Knowledge in a tool stack roughly splits into three tiers. At the top is usage: constructor parameters of a class, arrangement of a Widget, a Gradle config item. In the middle is mechanism: how data flows, who triggers whom, under what conditions something runs again. At the bottom is judgment: at which layer to solve this kind of problem, who bears the cost, and when not to use it.
Flutter gives you: Dart syntax and Widget APIs (usage), the self-drawing render pipeline and declarative rebuild (mechanism), and a set of engineering judgment about "how one piece of logic covers multiple ends." Framework gives you: class names and call order (usage), Binder/process/lifecycle/window/permission models (mechanism), and the ability to locate "why the platform changed behavior this time" (judgment).
What's genuinely interesting is how far their transferability radii diverge:
| What you learn | Does it survive a project change? | Roughly how long does it last | How I estimated |
|---|---|---|---|
| Widget parameters in some Flutter version | Only in Flutter projects | One or two versions | I've personally stepped on changed component attributes in 3.x |
| Dart language and async model | Within the Dart ecosystem | Long | Language layer changes slowly |
| Declarative UI rebuild mindset | Compose, SwiftUI, React all accept it | Very long | After learning recomposition, I looked at Compose's remember and hardly had to relearn |
| Self-drawing engine and GPU pipeline | Graphics, games, automotive HMI | Very long | Decoupled from specific frameworks |
| Two-end consistent collaboration style | Any cross-platform project | Medium to long | Organizational style outlives tools |
A specific ActivityManagerService method signature |
Only in the corresponding AOSP version | One or two years | Every major version changes |
| Specific reflection techniques for hidden APIs | Basically gone | Already expired | Tightened by target since Android 9 |
| Process, Binder, lifecycle, window, permission models | All Android projects, including Flutter's host layer | Ten-plus years | Skeleton hasn't changed since 2008 |
| The act of "locating platform behavior by trace and source" | All ends | Long-term | Tools change, the act doesn't |
There's a point I hadn't figured out before: the most valuable part of Flutter knowledge is precisely not Flutter-exclusive. Declarative rebuild, separation of state and side effects, constraints flowing downward - these hold almost exactly in Compose. When I migrated from View to Compose in 2023, I found recomposition confusing; later I read Flutter's setState and Element reuse to understand "why recomposition skips certain nodes." The reverse is also true: someone fluent in Compose looking at Flutter is usually stuck on Dart and ecosystem, not the rendering mindset.
So the ledger for "learning Flutter" can't be counted as "learning a framework." A large chunk of it deposits into your existing UI account, and even if this project never uses Flutter, you can't withdraw it without a loss. And the ledger for "learning Framework" - its most valuable part isn't class names, but the view that "the platform is a state machine." I solved the target 36 recreation problem not by memorizing the fields of ActivityRecord, but by knowing "to look for the decision at the system service layer."
The overlap between the two is so small that the question "either/or" itself is a bit strange. One spreads horizontally (how multiple ends share one logic), the other digs vertically (why this end doesn't run the way you think). Where you get stuck determines which to fill, and it has little to do with which is more popular.
Angle Two: Account Into Engineering, Not Into Preferences
The few sentences I used to reject the proposal at the review meeting were only valid under one project shape. Later I separated the projects I've handled and seen into three types, and the ledgers are completely different.
| A · Native main app | B · Cross-end new business | C · System customization / automotive | |
|---|---|---|---|
| Typical pages | Report page, inspection sheet, privacy compliance flow | Campaign activity page, internal tool, lightweight form | Desktop, multi-screen, vehicle control, audio strategy |
| Platform capability usage | High (PDF, camera, biometrics, notifications, background) | Low | Extremely high (modifying the platform itself) |
| Value of two-end consistency | Medium, but ends often have their own compliance differences | Very high | N/A |
| Manpower saved by switching stacks | Little, even negative | Obvious | None |
| New costs from switching stacks | Bridging, hybrid stack, two crash stacks | Low | None |
| Need for Framework depth | Medium (must be able to locate platform behavior) | Low | High (must be able to modify platform) |
Our health app belongs to A. The report page calls the system PdfRenderer to render the inspection sheet, needs hardware Bitmap, and before export must clear the in-memory data per compliance requirements. These aren't "just add a plugin." The PDF rendering chain lands at the graphics and kernel layer; the timing of clearing memory lands at the lifecycle layer; the difference in compliance requirements between the two ends lands at the business layer. Switching the UI to self-drawing saves layout code; these three places don't shrink at all, and a cross-language boundary is added.
On my own machine I did a very rough comparison: an almost blank Flutter release project versus an equally minimal native project. The former's APK was about 7MB larger (AGP 8.2.2, minSdk 24, built once, sample size one, so only order-of-magnitude). This 7MB isn't a defect; it's the fixed cost of the engine and Dart runtime. For a health app with modest daily active users distributed via the app store, download conversion genuinely cares about this number. But for an internal enterprise tool, it doesn't even qualify for discussion.
Type B I've done once. Last year a campaign activity page required pixel-perfect two-end styling, a three-week lifespan, and touched no system capability. Using a cross-end solution was correct that time; two days produced both ends, with only an entry point left native. If I had invoked the "report page lesson" to veto it, I'd be running A-class ledgers to manage a B-class project - this kind of mistake I've made before, and at the time I thought I was quite principled.
Type C is a completely different world. I looked at several 2026 automotive job descriptions; requirements were far more concrete than app roles: customization and trimming of AMS/WMS/SurfaceFlinger, Binder IPC, Zygote startup flow, HAL and AIDL, AOSP compilation and trimming, CTS/VTS, functional safety process, and one line: "assist app teams in development, extend non-native system interfaces to support app-call needs." I stared at that last line for a long time - it states the relation between the app layer and platform layer more clearly than any technical article: someone is responsible for modifying the platform to produce an interface, and someone is responsible for writing business on that interface.
If you really want to head into C-class, the bar has to be laid out first. AOSP's official hardware requirement now is 400GB available disk (250GB checkout + 150GB build) and at least 64GB RAM; a 72-core machine takes about 40 minutes for a full build, while a 6-core machine with the same 64GB RAM takes about 6 hours. From 2026 the source moves to two releases per year (Q2 and Q4), and the official recommendation is to use android-latest-release rather than aosp-main. This isn't "buy a book and flip through it"; it's adding memory to the machine at home and scheduling dedicated project time.
I first pulled the source in 2019, configured 16GB RAM and 200GB disk according to a blog post, ran repo sync all night, and OOM'd halfway through the build. The next day I finally read the official requirements page. After that I learned my lesson: to estimate the cost of a technology, read the official hardware requirements and release cadence first, not the tutorial's table of contents.
There's also a ledger that's easiest to miss: a hybrid stack isn't "half Flutter plus half native" summed, it's multiplied. Two build scripts, two dependency upgrade rhythms, two crash stacks and symbol tables, and a Channel contract that both sides must maintain together. In one project I saw a Channel method renamed without sync, the Android side silently taking an empty branch, and the issue went live for three days before being found - unit tests were all green because each side tested itself. These costs don't appear in the benefits column of a selection deck; they slowly surface in scheduling half a year later.
One Cross-End Evaluation, I Only Kept Four Numbers
Earlier I kept saying "measure three numbers." Here's the full record for last year's campaign page. It's a B-class project: three-week lifespan, two-end styling consistency required, no system capabilities. The stack change was right this time, but the basis was not "cross-end is faster"; it's these four rows.
| Number | Definition | Before (native) | After (Add-to-App) |
|---|---|---|---|
| Package size delta | Release APK, single ABI, same build machine, one build each | Baseline | +7.4MB |
| First-entry time | Cold state (after am force-stop), ten rounds, P50 / P90 |
210 / 260ms | 380 / 520ms |
| State loss count | Rotation, background-and-return, after system reclaim, 5 each | 0 | Initial version 3 times, fixed 0 |
| Cross-language boundary count | Channel methods registered in contract file | 0 | Initial version 5, converged to 2 |
Two of the four numbers got worse: package size grew a lot, first-entry time nearly doubled. Those two rows aren't in the table for self-criticism; it's because this project's gains weren't in those two cells - writing two-end styles once, shipping within three weeks, and no follow-up maintenance burden were the reasons to switch stacks. If it were a page with hundreds of thousands of daily active users, distributed through the store, +7.4MB and 170ms would have to be seriously counted into download conversion and first-screen experience, and the conclusion might flip.
The three state losses are the most worth recording. In the initial version I followed my native habit and put state in cross-end memory, without symmetric handling of rotation and reclaim; the first test lost three times. The fix wasn't on the Dart side; it was in the saved state of the hosting Activity. This pit is the same one as the report page incident: who owns the state is decided by lifecycle, not by what UI library draws it.
Reducing Channels from five to two relied on the earlier rule "every new Channel must state which platform layer it lands on." After writing it out, three turned out to be computable on the Dart side with pure data; crossing the boundary was just convenience at the time.
All numbers were marked with limitations in the record: one device, ten rounds, single build, iOS not tested, no long-term aging test. They only support "this campaign page can be done this way," and can't support any conclusion about framework superiority.
{
"case": "Three-week campaign page, Add-to-App",
"date": "2025-11",
"devices": ["Pixel 6 / Android 13"],
"samples": 10,
"abi": "armeabi-v7a",
"metrics": {
"apk_delta_mb": 7.4,
"cold_entry_p50_ms": [210, 380],
"cold_entry_p90_ms": [260, 520],
"state_loss_count": [0, 3, 0],
"channel_methods": [0, 5, 2]
},
"limits": "Single device / ten rounds / single build / iOS not tested / no aging",
"validUntil": "Only valid for this type of project, report page not applicable",
"reviewer": "组里另一位 Android",
"reviewDate": "2026-02"
}
The last three lines were added afterward. I used to record measurement data as just numbers; half a year later, when asked "does this conclusion still hold?", I couldn't answer and had to rerun everything.
Four Combinations, Four Completely Different Ways of Living
Earlier I divided the ledger by project type into A/B/C. When it reaches the engineering directory, the common configurations in domestic teams are actually four combinations. Their build topology, crash attribution path, and team division differ; mixing them when discussing "whether to adopt cross-end" makes for the most unresolved arguments.
| Combination | Directory shape | Crash attribution | Who maintains the boundary | Suitable for |
|---|---|---|---|---|
| Pure native single stack | One Gradle project, one symbol table | One stack | No boundary | Strong platform integration, strong compliance, long-lifecycle main app |
| Add-to-App hybrid | Native project + independent Flutter module, product as aar | Two stacks, aligned by build number | One native-side person + one cross-end person, jointly maintain contract file | Already-mature app, only new pages to cross-end |
| Cross-end main + native capability module | Flutter project as main, native side only writes plugin | Two stacks, main stack in Dart | Cross-end team leads, native side provides plugin | New business, two-end consistency priority, light platform capabilities |
| System customization + upper-layer app | AOSP tree + independent app project, interface agreed by AIDL | System side logcat/tombstone + app side | Platform team provides interface, app team consumes | Automotive, cockpit, dedicated hardware |
Our health app belongs to the first; the report-page proposal was actually trying to move it toward the second. If we really moved, the directory would look like this:
health-android/
├── app/ # Native main project, hosts Activity and compliance chain
│ └── src/main/java/com/example/health/
│ ├── report/ReportActivity.kt # Lifecycle and state saving live here
│ └── bridge/ReportChannel.kt # Channel handler, only thin forwarding
├── flutter_module/ # Independent module, outputs aar
│ ├── lib/report_page.dart
│ └── pubspec.yaml
├── docs/
│ ├── stack-decision.md # Decision record, with conditions and review date
│ ├── channel-contract.json # Cross-language contract, with version
│ └── platform-notes/ # Platform layer notes, seventeen pages
├── tools/
│ ├── note_index.py
│ └── check_channel_contract.py # CI compares contract versions on both sides
└── captures/ # Archive mapping + Dart symbols by build number
What's added isn't a few lines of code; it's four things that didn't exist before: a second build artifact, a second symbol table, a contract file both sides must maintain, and a CI bottleneck comparing contract versions. I didn't mention any of these four at that review meeting; my attention was entirely on "how many days the page rewrite takes."
I later wrote the contract file like this, the shortest usable version:
{
"contractVersion": 3,
"updated": "2026-10-18",
"owner": "原生侧 / 跨端侧 各一人",
"methods": [
{
"name": "decodeReport",
"args": { "id": "String", "maxEdgePx": "int" },
"returns": "String (content Uri)",
"platformLayer": "应用框架 -> FileProvider 跨进程授权",
"runsOn": "主线程收到,大图解码需切到后台线程",
"sinceTargetSdk": 34
},
{
"name": "requestLocationPurpose",
"args": {},
"returns": "bool",
"platformLayer": "权限模型;先弹用途说明再申请",
"runsOn": "ui thread",
"sinceTargetSdk": 33
}
],
"rule": "任何一端改方法名或参数,contractVersion 加一,CI 比对两端声明,不一致直接失败"
}
The platformLayer column is mine, as said earlier; it forces the person writing a Channel to think through "which platform layer this lands on after crossing the boundary." The second requestLocationPurpose now looks redundant - the purpose-explanation dialog should have been done natively per compliance, not initiated from the Dart side. That entry is a leftover from the transition period; I marked it for deletion and plan to remove it in the next version.
For the third and fourth combinations, I haven't worked in them long-term, only walked through reviews on other projects. In the cross-end-main type, what's most easily underestimated is the maintenance cost of "native capability modules": once a plugin must follow a new platform version behavior, the cross-end team has to wait for native-side scheduling, and native side often has only half a person, making the boundary the scheduling bottleneck. The system-customization type is the reverse: the app team waits for the platform team to give AIDL interfaces, and when the interface changes, both sides rework together. The JD line "extend non-native system interfaces to support app-call needs" describes exactly this role.
None of the four combinations is superior, but don't use the directory structure of the first to estimate the cost of the second - that's exactly how I miscalculated in that review.
Angle Three: Those Numbers in the Hiring Market Count Four Different Things
Underneath "is it still worth learning" is often "after learning, is there still a job." To answer that, you have to break apart several heavily cited numbers; they're not on the same metric at all.
| Number | Source type | What it counts | What it can't be used to claim |
|---|---|---|---|
| Flutter 37%, React Native 37%, KMP 18% (2025) | JetBrains developer ecosystem survey | Respondents' self-reported "using" cross-platform framework ratio | Job count, app count, market share |
| KMP from 7% (2024) to 18% (2025) | Same, JetBrains official page also cites | Annual change in same survey | Absolute scale; denominators differ |
| Flutter 9.4%, RN 8.4% (2024) | Stack Overflow developer survey | Usage ratio among all respondents | Trends after 2025 - the 2025 survey changed technology topic categories, no longer lists these two frameworks, no comparable number |
| 1.5M monthly active developers, +50% YoY (2026-05) | Framework official release announcement | Vendor self-reported active developers | Independent third-party verification; measurement method not disclosed |
| KMP in top 10000 App Store apps from <1% (early 2024) to ~3% (mid 2026) | Appfigures data, cited by JetBrains report | Technology share among top apps | All apps, domestic stores, Android side |
| top 1000 Android apps 95% contain Kotlin code (I/O 2024) | Platform official | Code composition of top apps | Binary conclusions like "should I still learn Java" |
I've seen too many articles mash these six rows into one sentence like "Flutter already has 46% market share" and then draw conclusions about pivoting. They count developers, apps, survey answers, downloads, and job postings - completely different things. None of them alone supports a career decision.
What is genuinely useful is the job description itself, because that's concrete work someone is willing to pay for. Roughly categorizing the JDs I can find in 2026, app-side work falls into three piles:
- Business UI and feature delivery: writing pages, wiring APIs, keeping up with versions, fixing bugs. Largest volume, and most compressible by cross-end solutions and generation tools.
- Platform and engineering side: performance, memory, startup, crash attribution, build and CI, multi-module, SDK governance, privacy compliance chain. One notch smaller, but JDs are beginning to explicitly say "able to locate system behavior."
- System and terminal side: ROM customization, AAOS automotive, HAL/AIDL, multi-screen and audio strategy, CTS/VTS, functional safety process. Smallest volume, highest bar, and clearly expanding toward automotive and smart terminals.
In a job-posting sample updated on a recruitment site on 2026-11-04, Framework development engineers had 72.5% falling in the 20-50K/month range, 3-5 years experience required for 45%, and bachelor's degrees for 73.9%. This is the recruitment site's own sample, not an industry-wide statistic; I take it only as a directional reading: this kind of role doesn't hire fresh graduates for practice; it wants people who've already stepped on pits.
There's also a variable in China that can't be avoided. HarmonyOS NEXT was officially released on 2024-10-22, removing AOSP code and no longer compatible with ordinary APKs; from 2025, Huawei's new devices ship with it by default, and leading apps have completed native versions. That's a real diversion for domestic app roles - the same feature might need two versions. In early 2025 public reports, native HarmonyOS had 20,000 apps and services on the shelf and 7.2 million registered developers; these are Huawei-disclosed numbers and need the same caveat.
But there's a counterintuitive corollary: the more fragmented the platforms, the more useful someone who understands "platform contracts" becomes, not less. ArkTS / ArkUI syntax has to be relearned, but the problems the "distributed soft bus" faces in cross-device communication are the same kind as Binder's; multi-end window and lifecycle management is the same state machine under a different name. In a HarmonyOS adaptation tech share, I saw the author compare the soft bus to Binder, and the comments said "now I get it." What transfers is the mechanism-level understanding; what doesn't is API memory. That holds for Flutter, for HarmonyOS, and for any new platform to come.
Job titles are indeed changing in these two years: Android development engineer, smart terminal development, cockpit HMI, on-device AI application. Names will keep changing; the way the three piles are classified hasn't. Knowing which pile you stand in is far more useful than guessing which framework will be popular next year.
Angle Four: What a Hundred Hours Can Buy Back
On time cost, I don't want to write clichés like "learn everything, lifelong learning." A hundred hours is a hundred hours; you have to be clear where you invest it, how long until it pays back, and when it depreciates.
Based on time I actually spent in the last two years, I estimated three investment paths (all for someone of my medium proficiency, app-development-focused; the numbers differ with a different background):
| Path | First 20 hours | By 100 hours | Main payoff | Depreciation risk |
|---|---|---|---|---|
| Systematically learn Flutter and build a hybrid-stack demo | Run Add-to-App, embed a page into an existing app | Independently deliver a medium-complexity cross-end page, handle Channel and Platform View | Directly save manpower when cross-end need arises; declarative mindset feeds back to Compose | Version API changes fast, but mechanism layer doesn't depreciate |
| Systematically chew AOSP full source and compile | Likely stuck on environment (400GB / 64GB threshold) | Just able to compile and run emulator, still haven't read several modules | Only directly pays back for C-class roles | Low, but investment heavy, dropout rate extremely high |
| On-demand Framework reading: every online issue traced to platform layer, write one page | Learn dumpsys trio + online source search + find branches against trace |
Accumulate a dozen-plus pages of "phenomenon → system decision → code fix point" notes | Every version upgrade and stubborn crash saves time | Almost none; records mechanism, not API |
The third row is what I chose, and what I think is the most cost-effective for the vast majority of app developers. It doesn't require compiling AOSP, doesn't require 400GB disk, and doesn't even require reading a whole book. After the target 36 incident, I set myself a blunt rule: every time I hit a problem that "can't be found by search," force myself to trace one level up, write the system decision I find into docs/platform-notes/, one page per subject.
After twelve weeks I had seventeen pages. They include Android 16's configuration-change branch, content-provider installation before Application.onCreate, notification behavior differences after target 33, large-screen insets and gesture area overlap, and a certain SDK blocked by foreground service type under target 35. Not one page was the result of "systematic study"; all were forced out by incidents. But by the ninth week, when raising the target for another module, I could for the first time list which places to verify before changing code - that's what those seventeen pages really bought.
The twenty hours on Flutter I also spent, but with a narrow goal: not learning the whole state-management family, only one thing - embedding an existing pure-display page via Add-to-App, then measuring three things: package size delta, first-entry time, and how state gets lost on exit. I stopped after that. That investment didn't make me a Flutter developer, but the next time someone says at a review meeting "switch and you won't have to follow system versions," I can bring concrete numbers instead of slamming the table.
One judgment I changed: I used to think "if you can't deliver independently, you haven't learned." Now I think what holds for both is: the gain of learning halfway isn't output, it's judgment. A hundred hours won't make a cross-end expert, but it buys an opinion on a stack selection that won't be signed wrong; a hundred hours also won't make a Framework engineer, but it buys a crash located without gray release.
Four Unsynchronized Timelines Are the Real Trouble in Upgrades
When talking about risk, everyone tends to stare at "will the framework be canceled," but what actually makes projects miserable is often a few version lines being out of sync. In our app, five things are evolving on their own rhythm:
| Component | Who sets the pace | Rough frequency | Which layer changes on upgrade | Who it most collides with |
|---|---|---|---|---|
targetSdk / platform behavior |
Google Play and AOSP | Raised once a year, late August deadline | Runtime behavior forks | Permissions, background, window, foreground service |
| AGP / Gradle / JDK | Android toolchain | Multiple times a year | Build artifacts and scripts | Various Gradle plugins, including cross-end side |
| Kotlin / Compose compiler | JetBrains and Google | Multiple times a year, the two are version-bound | Compile time | KMP, coroutines, serialization plugins |
| Flutter SDK / Dart SDK | Flutter team | Quarterly stable release | Engine and UI toolkit | Android-side build scripts, plugin ecosystem |
| Third-party SDKs | Each vendor | Irregular | Runtime + privacy chain | All of the above |
There's a coupling that's especially easy to miss: Compose compiler version is tied to Kotlin version; when Kotlin rises, the compiler must follow; and KMP also uses the same Kotlin. So "just upgrade Kotlin" in a project using both Compose and KMP drags two chains. Flutter seems independent, but its Android artifact is still built by AGP; if AGP rises and Flutter's Gradle plugin hasn't caught up, it errors at configuration stage.
I got burned once. Last year, to save effort, I upgraded AGP and Flutter SDK in the same PR; the build died at configuration, reporting a missing Gradle API. Both sides were changing, and I spent most of the day figuring out it was a removal on the build side, not an engine-side issue. Later I split into two PRs, one moving only build, one only engine, each ran through before merging - done in half a day.
Since then the upgrade order is fixed:
1) targetSdk -- move runtime behavior first, because it changes "what the same code yields"
2) AGP / Gradle / JDK -- move build next, only one major version at a time
3) Kotlin / Compose compiler -- compile time, upgrade in pairs per official correspondence table
4) Flutter SDK / Dart -- engine and toolkit, one separate PR
5) Third-party SDKs -- last, one by one, each running a privacy-chain self-check
The only reason for the order: each step introduces one variable; when something breaks, you know which layer to trace. That's the same thing as "learning Framework" - knowing which layer makes the decision tells you which version line to pull out and verify separately.
I keep a machine-readable snapshot of each combination, so when a problem appears I can see at a glance "which set last worked":
{
"capturedAt": "2026-09-03",
"commit": "9f3c1a7",
"agp": "8.2.2",
"gradle": "8.2",
"jdk": "17",
"kotlin": "1.9.22",
"composeCompiler": "1.5.8",
"compileSdk": 34,
"targetSdk": 36,
"minSdk": 24,
"flutter": "未引入",
"devices": ["Pixel 6 / Android 13", "tablet-like / Android 16"],
"state": "snapshot during upgrade window, update each PR"
}
The flutter field now says "not introduced." I keep it not because it will necessarily be filled, but to remind myself: this table describes the current combination, not a stance.
Angle Five: Technology Can Die, But Don't Tie Your Identity to It
The risk side needs to be written fully, but both sides have to be written, or this becomes either discouragement or advocacy.
Real events on the Flutter side: In April 2024, a Google layoff involving several teams affected some Flutter/Dart roles; per Google at the time, most cut were infrastructure and ops roles, roadmap unchanged. On 2024-10-27, some community developers started the Flock fork, publicly questioning upstream investment. On 2025-01-29, the Dart team announced canceling macros entirely - a feature in development for over two years with nearly 1400 likes on the tracking issue, canceled because compile-time deep semantic analysis degraded hot reload to an unacceptable level; the official wording was "still too far from solving it within a reasonable time." In 2025, Google stopped maintaining flutter_markdown, handing it to the community.
All that is real. The other side is also real: in 2025, the Dart and Flutter teams shipped eight stable releases quarterly (four Flutter, four Dart); Impeller migration completed, removing Skia on iOS and defaulting on Android API 29+; Canonical led desktop multi-window maintenance; official contributor count passed 1700 in the 2026 announcement; and there are production deployments in automotive. Two years after the fork began, mainstream community reaction was muted, and the mainline remains upstream.
My reading: "not dead" and "sustainability was seriously discussed" are two things that can hold at the same time. When choosing, you should know the latter, but you shouldn't use the former to deny the latter. In particular, don't make "will Google kill it" the primary variable in a personal learning decision - Dart officially bet on macros for two years and chopped them, showing the framework itself can't guarantee a roadmap. The platform side is the same: AOSP switched to two source releases per year from 2026, target API raised once a year, hidden-API list tightened each version.
What truly locks people down is never a technology dying; it's outsourcing judgment to a roadmap. I've seen the people in 2015 who bet everything on one pluginization framework; the framework didn't die, but Android 9's list made it unusable. They didn't learn the wrong thing; they defined "what I know" as "which framework I'm familiar with."
The platform-side risks also have to be laid out, lest I seem to be only criticizing cross-end. Domestically: HarmonyOS diversion, target raised yearly, reflection paths closed, generation tools making basic UI coding cheap, and junior resume pass rates dropping. These are real variables. But they compress exactly the "usage" tier - the two shortest rows in the earlier half-life table.
Tying identity to "mechanism + judgment" is more stable than tying it to any one name. That sounds like a slogan, but it translates to something concrete: in my notes now, I haven't memorized a single method name from ActivityTaskManagerService; what I've written are lines like "the decision on configuration changes lives at the system service layer; target determines which branch runs" - sentences that won't change with versions.
Angle Six: Where This Ledger Ultimately Falls
The five angles above have all been technical, but in real teams, these decisions often stall not on technology. They stall on "who is responsible for this end's behavior."
The cross-end solution was originally to solve a manpower problem, not a rendering problem. In the years after 2008, to get a product on two stores, you needed two groups of people writing twice; when requirements changed, both ends scheduled separately, and launch time had to be aligned. When Sky debuted at the Dart Developer Summit in 2015, its pitch was "stable 120fps," which looks like a performance metric, but underneath it was another sentence: if self-drawing can hold that frame rate, one codebase covering two ends is commercially valid. Whether hardware can hold self-drawing decides whether that organizational plan can land.
More than a decade later, the abstraction layer is several times thicker, but the organizational problem has just changed form. After the abstraction layer splits the work into two halves, when something goes wrong, who answers "why is this end behaving this way"?
I laid out the divisions I've seen, with the last column rarely written into proposals:
| Division | Who proposes | Who can veto | Who gets called first when something goes wrong | Where it tends to rot |
|---|---|---|---|---|
| Native team also manages cross-end module | Native side | Native side | Native side | No one really maintains the Dart-side ecosystem; dependencies drag on |
| Independent cross-end team | Cross-end team | Platform / compliance | Cross-end team, then hand to native | Responsibility bounces at the boundary, one incident two handoffs |
| Module-based ownership, boundary in contract file | Module owner | Platform + compliance review | Owner registered in contract | Contract becomes dead letter if not updated |
| System customization + upper-layer app in separate teams | Platform team gives interface | Platform team | Segmented by AIDL interface | Interface changes, both sides rework |
The argument in our group was about the second type. Someone suggested forming a cross-end team and handing all new pages to it, with the reasoning "native side doesn't have to follow two-end styles anymore." It didn't get established. Not because anyone persuaded anyone else, but because someone asked: when the report page gets recreated on Android 16 large-screen and produces duplicate submissions, which work order does it go to?
At that moment everyone realized that a cross-end team can take over page code, but not this end's behavior. Configuration changes are decided by system services; state restoration by Activity lifecycle; permission timing by compliance. When something truly happens, someone still has to be able to open dumpsys, read source branches, and explain to the reviewer. That person isn't in the cross-end team's headcount, and the problem doesn't disappear because of that.
What we landed on was the third type: module-based ownership, the boundary written into channel-contract.json and stack-decision.md, each Channel registering an owner, each decision record writing a reviewer and an expiration date. It didn't solve everything, but at least work orders could be dispatched, and there's no more "I thought you handled it."
This is the other face of the same question as whether to learn these two things. People who learn the Framework, in the organization, play the role of "providing an explanation for platform behavior"; people who learn cross-end play the role of "making one logic cover multiple ends." Both roles need someone, but only one gets called into the room on the day the platform changes behavior. Which is scarcer, you can feel without looking at hiring data - in the three piles earlier, the further down you go, the fewer people can take it.
There's also something very realistic: this role is usually not written into the JD. JDs say "familiar with AMS/WMS" or "has performance optimization experience," not "doesn't guess when an upgrade breaks." But when the release day actually comes, this is the person people look for.
Once I talked with a friend working on automotive; their side is even more direct: the platform team changes a system service, and the app team comes the next day asking "why is my page not showing," with no third party to pass the blame. He said that when they hire, what they value most isn't whether you can write a certain framework, but "whether you can trace the problem to our layer yourself and then ask clearly the right question." I've remembered that sentence for a long time; it's more accurate than phrases like "deep into Framework source."
The Twelve-Item Platform Capability Checklist, One by One
The checklist in the second question of the decision framework - at that review I listed only three items, later expanded to twelve. Since then, whenever someone suggests switching stacks, I print these twelve lines and check "keep / eliminate / add" one by one. It predicts better than any comparison article whether this rewrite will become a pit-filling exercise.
| # | Item | After stack switch | Decision lands at | In our project corresponds to |
|---|---|---|---|---|
| 1 | Permission and purpose-timing | Keep | App framework + system services | Purpose dialog before location, compliance review item |
| 2 | Lifecycle and state restoration | Keep | App framework | Report page note, the main culprit this time |
| 3 | Configuration change and large-screen window | Keep | System services fork by target | sw600dp crossing band triggers recreation |
| 4 | Insets and irregular screens | Keep | App framework | Full-screen report page's notch and gesture area |
| 5 | Notification and background launch restrictions | Keep | System services | Follow-up reminder click chain |
| 6 | Foreground service types and quotas | Keep | System services | Report export service |
| 7 | Exact alarms | Keep | System services | Follow-up reminder scheduling |
| 8 | Graphics and hardware buffers | Keep, plus one more bridge layer | Graphics + kernel | PdfRenderer and hardware Bitmap |
| 9 | File and cross-process URI authorization | Keep | System services | Report sharing to external apps |
| 10 | Privacy chain and memory clearing | Keep | Lifecycle + business | Clearing in-memory data before export |
| 11 | Crash stacks and symbol tables | Add one more | Toolchain | mapping and Dart symbols archived by build number |
| 12 | Build and dependency cadence | Add one more | Toolchain | Two upgrade lines, Gradle and pubspec |
Let me go through a few that are most easily treated as "just add a plugin."
Item 1 is not about whether you can call the API. The purpose explanation must pop before requesting the system permission; this timing is determined jointly by lifecycle and compliance, regardless of what UI draws it. After switching to self-drawing, the dialog can be drawn, but "who comes first" is still decided by the Activity lifecycle; I've seen projects where the explanation was written on the cross-end side, and some native SDK initialized first - essentially the same class of error as this incident.
Items 3 and 4 were both hit this time. Large-screen configuration change is a branch the system services choose by targetSdk; insets are a set of boundary values the window gives the app. After the hosting page becomes FlutterActivity, both still need handling - the official foldable support and multi-window posture adaptation that came later are precisely repackaging these platform items for the upper layer, not eliminating them.
Items 8 and 9 decided whether my rejection's reasoning held. The inspection sheet goes through system PDF rendering, pixel buffer lands natively/hardware-side; sharing out requires FileProvider authorization, a cross-process URI grant. These two things, on the cross-end side, both have to go through Channel back to native and then the platform completes them. So after switching stacks they don't just remain, they each get an extra hop. At the review I said "the manpower saved isn't enough to fill the gap" on intuition; after filling this table, I had a defensible basis.
Item 10 is the least appropriate to hand to a bridge. The timing of clearing the in-memory data before export has to hug the lifecycle and a clear business boundary; one more cross-language call in the middle is one more place to leak. In a healthcare app, this kind of chain has to be explainable line by line to a reviewer; one more layer makes it indefensible.
Items 11 and 12 are pure additions - they didn't exist before. Two crash stacks mean the same build has to archive mapping and Dart symbols simultaneously; two dependency lines mean any upgrade has to check the version matrix table earlier. These don't get discussed at selection meetings, but they'll collect interest every quarter.
After checking, the rule I use myself is crude: if the sum of "keep" and "add" exceeds eight, don't switch stacks for this page; if most are eliminated and the rest can be done with pure data, then it's worth entering a hybrid-stack evaluation. On the report page that day I counted eleven; only one could be eliminated - the small bit of duplicated labor for two-end style consistency.
This table has a side effect: it makes "whether to learn Framework" very concrete. Nine of the twelve rows have decisions landing at the app framework or system service layer. You don't have to be able to modify them, but you should at least know they exist, know which dumpsys to look at when a problem arises, and know that targetSdk will pick branches inside them. Those nine rows are the ledger you can't dodge.
Rather Than Either/Or, Ask Three Questions First
Pulling the five angles together, the criterion I later used at the team is a very crude one. It doesn't answer "is Flutter good"; it answers only "how should this page be written this time, and what should I fill this quarter."
First question: Which layer do I want to replace? Use the six-layer table from the beginning. If the complaint is just that the UI is duplicated between ends, you want to replace layer two; if it's that Android version behavior is hard to follow, that's not in the top two layers, and switching stacks won't solve it.
Second question: Which ledgers remain after switching? List platform capabilities and check each one: permission and purpose-timing, lifecycle and state restoration, window insets and fold/unfold, background tasks and notifications, system capabilities like camera/biometric/PDF, graphics buffer and memory clearing, crash stacks and symbol tables, privacy compliance data chain. The fewer that are checked, the more real the cross-end gain; for a fully checked project, switching stacks just moves the workload onto the bridge.
Third question: In the next three years, what kind of problem am I being evaluated on? Business delivery speed, platform engineering quality, or system-level customization capability. This question decides where learning goes, and it's separate from project selection - you can add cross-end perspective in a pure native project, or deepen platform-layer understanding in a cross-end project.
flowchart TD
Q1{"Which layer to replace"}
Q1 -->|"Layer 2: UI duplicated labor"| Q2{"How many platform capabilities checked"}
Q1 -->|"Layer 3 downward: system behavior"| R1["Switching stacks ineffective, go read platform decisions"]
Q2 -->|"Checked most"| R2["Cross-end suitable, do hybrid-stack evaluation"]
Q2 -->|"Almost none can be checked"| R3["Stay native, don't move workload onto bridge"]
R1 --> Q3{"Next three years evaluated on which kind"}
R2 --> Q3
R3 --> Q3
Q3 -->|"Business delivery"| S1["Add cross-end and multi-end collaboration perspective"]
Q3 -->|"Platform / engineering quality"| S2["Add mechanism layer: process, lifecycle, performance attribution"]
Q3 -->|"System / terminal customization"| S3["Add AOSP practical work, accept 400GB / 64GB threshold"]
To put words on the page at a review meeting, I use this template, one page, filed after writing:
<!-- docs/stack-decision.md -->
# Decision record · Module M report page · 2026-09-03
## One, which layer to replace
Phenomenon: two-end style inconsistency + target 36 large-screen recreation causing state loss
Locate: former at layer 2 (UI description), latter at layers 3~4 (app framework / system services)
Conclusion: these are two problems, don't solve with one rewrite
## Two, ledgers still present after switching (write "keep / eliminate / add" per item)
Permission and purpose-timing keep (compliance requires explanation before request)
Lifecycle and state restoration keep (FlutterActivity is also an Activity)
Window insets and fold keep (large-screen orientation freedom treats both stacks equally)
System PDF rendering keep, and add one Channel bridge layer
Graphics buffer and memory clearing keep (timing before export decided by lifecycle)
Crash stacks and symbol tables add one Dart-side stack
CI and dependency cadence add one
## Three, measurable numbers (write the definition; "should be faster" is not allowed)
Package size delta | first-entry P50 / P90 | scroll frame P90 | cross-language boundary count
## Four, reviewer and expiration date
Review: another Android on team + one iOS, revisit on 2026-12-03
Expiration: this conclusion only holds under target <= 37 and current compliance standards
Those last two lines came from a hard lesson. I used to write technical decisions with only conclusions; half a year later, when platform behavior changed, no one remembered why it was decided that way, and we'd argue again from scratch. Now I write "under what conditions this conclusion holds" and "when to come back and review," making judgment a versioned thing too.
That Review, Rerun With This Criterion
In mid-October I organized that day's meeting words into one page, went through them item by item, and the conclusion was clearer than at the time, while also admitting which sentences I got wrong.
| Criterion | What was said then | After rerun |
|---|---|---|
| Which layer to replace | Vaguely said "replace a codebase" | Style consistency at layer 2, state loss at layers 3~4, two things |
| Platform capability ledger | Listed PDF, hardware Bitmap, memory clearing three items | Expanded to seven; lifecycle and insets are the true culprits this time |
| "No need to follow version behaviors" | I internally counted it as a cross-end advantage, didn't refute | Clearly wrote "not valid": host layer is still Activity |
| Package size | Not mentioned | Added order-of-magnitude comparison, marked single build, sample one |
| Hybrid stack cost | Not mentioned | Added Channel contract, two crash stacks, dependency cadence |
| Review conditions | Not written | Wrote target upper limit and compliance standards, revisit in three months |
The rerun's conclusion has three points, none emotional:
Keep the report page native, move state saving from the async callback to a place saved state can reach, and add a set of UI tests for large-screen orientation changes. This has nothing to do with whether Flutter is good; it's a fix in the sixth row.
The three-week campaign page can go cross-end per B-class; the value of two-end style consistency outweighs everything, and it touches no system capability. I missed this proposal at the meeting because I was entirely on defense for the report page.
What I should fill isn't "learn Flutter or not," but turning "why the platform changed behavior this time" from relying on search into being able to trace to a source branch myself. That has nothing to do with whether I use Dart.
The most biting part is the answer to the third question. I thought I was being evaluated on "delivery speed," but looking back at that year's work orders: target upgrade, privacy compliance inventory, large-screen adaptation, gray-release crash attribution, SDK behavior differences - none was "page writing not fast enough." I had been adjusting my learning direction for a job that didn't exist, and quite earnestly.
Two Learning Paths, Both Starting From a Verification Action
All the judgment above is fine, but when it comes to "how to actually learn," I set myself two routes. They share one feature: neither starts from the first chapter of a book, but from an action that can be verified.
Platform layer: trace one problem, write one page
L1 (about 20 hours, enough for app roles) does only three things. Learn how to read the output of dumpsys activity / dumpsys window / dumpsys meminfo; learn to search the official online source site by class name and follow the call chain three levels; learn to split an online phenomenon into five lines: "what the user sees / app log / system state / source branch / my fix point." The output is a few pages in docs/platform-notes/, no continuity required.
L2 (another 40 hours) starts connecting mechanisms into a picture: the complete order from Zygote fork to Application.onCreate (I only remembered on the third pass that content providers install before Application.onCreate), how a single Binder cross-process call walks, the chain from VSYNC to first frame, and in what form targetSdk forks in source. The output is three hand-drawn Mermaid diagrams; what you can't draw is what you haven't understood.
L3 is when you touch AOSP full source and compilation, accepting the 400GB / 64GB threshold, running one complete build, and changing one system service line to see the effect. This step is only necessary for people aiming at C-class roles; I haven't done it all, only pulled a partial read of frameworks/base.
The template for writing one page per incident is this; you can copy it and use it:
<!-- docs/platform-notes/2026-09-03-config-change.md -->
Phenomenon: notes lost after large-screen expansion, two submissions in backend
Device / system: Pixel Tablet class, Android 16, target 36
Reproduce: wm size changes window size, min width crosses 600dp
App-side evidence: onCreate second time, ViewModel new instance
System-side evidence: dumpsys activity activities shows old record destroyed;
dumpsys window shows smallestScreenWidthDp 420 -> 720
Source branch: config change goes to system service's recreation branch; target 36 large-screen allows opt-out,
API 37 expected non-opt-out
Fix point: write state into saved state, don't use intermediate state from async callback
Still unanswered: why the 600dp threshold for band crossing, chase next time
Review: after fix run ten rounds of config change, two manual, eight scripted
The "still unanswered" line I added later. I used to write only conclusions in notes, which looked complete but quietly covered what I didn't understand.
Cross-end side: embed a page, measure three numbers
L1 (about 20 hours) doesn't touch the whole state-management family; only does Add-to-App: embed a pure-display page in an existing app, walk through entry, exit, rotation, reclaim-then-restore. Measure three numbers - package size delta, first-entry time, state loss count. These three numbers map exactly to three cells in "ledgers still present after switching."
L2 adds the platform bridge: write a Channel to call a system capability, measure the cost of serialization and thread switching; then embed a native Platform View and watch the scroll frame change. By this step, you have a tactile sense of "the bridge isn't free," not just read it from articles.
L3 is independently delivering a complete cross-end module, wiring CI, handling dependency upgrades and crash symbols. Many people start at L3, get stuck on build and ecosystem, then conclude "Flutter doesn't work" - I did exactly that in 2019.
The two L1s together are forty hours, requiring no role change, no new project, and no convincing anyone. They don't buy any skill name you can put on a resume, but the next time a review meeting opens, you'll have a page of numbers you measured yourself instead of a sentence someone else heard.
Command Quick Reference: The Lines I Actually Look at in the Output
The platform-layer commands aren't many; the hard part is knowing which field to look at. Below are ones I ran on that tablet and Pixel 6; the output fragments are copied from real formats with the key lines, and the interpretation is written after.
# Configuration change and Activity life and death
adb shell dumpsys activity activities | grep -E 'mResumedActivity|Hist #|state=|config='
# * Hist #0: ActivityRecord{... u0 com.example.health/.report.ReportActivity t123}
# state=RESUMED ...
# configuration={1.0 ?mcc?mnc ... 720dp sw720dp w720dp h1152dp ...}
adb shell dumpsys window | grep -E 'mCurrentFocus|smallestScreenWidthDp|mRotation'
# mCurrentFocus=Window{... com.example.health/.report.ReportActivity}
# mGlobalConfiguration={ ... smallestScreenWidthDp=720 ... }
sw<N>dp crossing 600 is the signal for the large-screen band change; it's more reliable than screen physical size - it counts the window, not the device. That's also the platform-layer echo of "the adaptation target is the window."
# State and process
adb shell dumpsys activity processes | grep -A6 'com.example.health'
# PSS / USS / oom adj and process priority are all here
dumpsys meminfo com.example.health | head -20
# Cross-process calls
dumpsys binder_calls_stats 2>/dev/null | head -20
# Hidden API hits (some versions show toast or logcat line)
adb logcat -d | grep -iE 'Accessing hidden|hiddenapi|blocked|max-target'
# Accessing hidden method Landroid/app/ActivityThread;... (greylist-max-p, reflection)
That last log saved me once: an old SDK silently failed when raising target 34 to 35; the log clearly printed a max-target hint, but no one looked at the full logcat -d, only our own tag. The platform is always talking; most of the time we weren't listening.
# Minimal Flutter-side verification (combination I used on my machine)
flutter --version
flutter analyze
flutter build apk --release --split-per-abi
# ✓ Built build/app/outputs/flutter-apk/app-armeabi-v7a-release.apk (7.4MB)
adb shell am start -W com.example.health/.FlutterHostActivity | grep -E 'LaunchState|TotalTime'
LaunchState has to be COLD to count as the cold round, same as the earlier startup measurement; if the state isn't set up right, a nice number means nothing.
# Local index of AOSP online source (works without pulling full source)
grep -rn "shouldRelaunch" frameworks/base/services/core/java/com/android/server/wm/ 2>/dev/null | head
# Pull only a single directory for partial reading
git clone --depth=1 --filter=blob:none --sparse \
https://android.googlesource.com/platform/frameworks/base fw-base
cd fw-base && git sparse-checkout set services/core/java/com/android/server/wm
The --filter=blob:none --sparse line was taught to me by a colleague later, far less painful than the whole-night repo sync of 2019. To read mechanisms, you don't need to own all of the source first; that's one of the few genuine threshold-lowering changes in tooling in recent years.
When Using Tools to Read Source, Write the Boundary First
This half-year I have indeed let an agent in the editor search AOSP call chains a few times, but after stepping on one pit I fixed a four-segment prompt. It's not responsible for conclusions, only for laying out evidence; version calibration is always my own.
【Read-only inspection, no code changes】
Project: com.example.health, AGP 8.2.2, compileSdk 34, targetSdk upgrading to 36 in progress.
Please read-only list all code locations that might be affected by "large-screen configuration change triggering Activity recreation",
output by file path + line number, with one sentence "why this is relevant here".
Do not propose changes, don't guess code I haven't pasted, mark "unverified" where unsure.
【Split the version claims, don't choose for me】
I see contradictory statements in four sources:
A official docs say target 36 large-screen allows opt-out, API 37 cannot;
B a Chinese wiki marks two different Flutter versions as latest under 2026-05-12;
C a recruiting-site sample says Framework roles 72.5% fall in 20-50K;
D a vendor announcement says 1.5M monthly active developers, +50% YoY.
Please list each in four columns: "source type / what it counts / whether usable for career decisions / what verification is missing".
Don't merge into one conclusion, don't pick one as fact.
【Read source branch, only draw the chain】
Follow AOSP's configuration-change path, draw the call chain from "system detects Configuration change"
to "Activity is recreated", with each hop labeled class name, method name, and file path.
Mark which branches fork by targetSdk.
No fix suggestions, no summary; mark "I couldn't find this" where you can't jump.
【Change roles, find costs I haven't thought of】
Assume you are the person responsible for compliance review of this health app, and an engineer who has maintained a hybrid stack for two years.
Please each list the three things you'd worry most about after "rewriting this report page as a self-drawing cross-end implementation",
with trigger conditions and observable phenomena for each.
Don't evaluate whether the plan is good; just list risks.
Of the four segments, I use the second most often. Technical judgment errors often aren't about not knowing principles; it's mashing four different definitions into one sentence and feeling smooth about it. These four segments only take up a small part of this learning; the protagonist is never the tool - I didn't lay this out as a twelve-round pipeline because the difficulty is in judgment, not generation.
A Script That Ties the Notes Together
After docs/platform-notes/ accumulated to a dozen-plus pages, searching became a hassle, especially the "still unanswered" lines. I wrote a very short script that does only three things: extract titles, extract unresolved items, group by month, and output an index to paste at the top of the notes.
#!/usr/bin/env python3
"""tools/note_index.py -- scan platform-layer notes, generate index and unresolved list."""
import re
import sys
from pathlib import Path
ROOT = Path(sys.argv[1] if len(sys.argv) > 1 else "docs/platform-notes")
rows, unresolved = [], []
for path in sorted(ROOT.glob("*.md")):
text = path.read_text(encoding="utf-8")
title = next((l[3:].strip() for l in text.splitlines()
if l.startswith("# 现象:")), path.stem)
tags = re.findall(r"^系统侧证据:(.+)$", text, re.M)
rows.append((path.stem, title[:44], "有系统侧证据" if tags else "缺系统侧证据"))
for line in text.splitlines():
if line.startswith("还答不上的:"):
unresolved.append((path.stem, line.split(":", 1)[1].strip()))
print(f"# 平台层笔记索引({len(rows)} 页)\n")
print("| 日期 | 现象 | 证据完整度 |\n| --- | --- | --- |")
for stem, title, flag in rows:
print(f"| {stem} | {title} | {flag} |")
print(f"\n## 还答不上的({len(unresolved)} 条)\n")
for stem, item in unresolved:
print(f"- [{stem}] {item}")
# A snippet from my run (abridged)
# 平台层笔记索引(17 页)
| 2026-09-03 | 大屏展开后备注丢失,后台收到两条提交 | 有系统侧证据 |
| 2026-09-11 | 内容提供者里某 SDK 比 Application.onCreate 更早 | 有系统侧证据 |
| 2026-10-02 | 通知点击后走了中间页,target 33 起不生效 | 缺系统侧证据 |
## 还答不上的(4 条)
- [2026-09-03] 为什么跨档判定用 600dp 这个值,下次追
- [2026-10-02] 系统服务里那条限制是哪个版本引入的,还没定位到分支
The "missing system-side evidence" column is the one I value most. It separates "I think I understand" from "I can get a system-side reading"; the former can pile up fast but doesn't count.
A Complete target Upgrade, Two Weeks in This Order
Earlier I kept saying "must be able to trace to the platform layer." Only by doing one full pass do you know how heavy that phrase is. I saved the schedule and commands from raising 34 to 36; later upgrades (35→36 and another module) followed the same template.
D-14 · List first, don't touch code. Open the official behavior-change list, pick only what's relevant to our project, and write each one "which line of our code might be affected." That time I listed 11 items; only 3 actually caused problems, but from the 7 I hadn't listed, I later added 2. This step is the easiest to skip because "reading it may not be useful," but its value is turning "bet" into "verify."
<!-- docs/target-36-checklist.md (abridged) -->
[ ] Large-screen configuration change defaults to recreation -> ReportActivity / saved state
[ ] Notification trampoline restriction -> push click intermediate page
[ ] PendingIntent must declare mutability -> alarm and sharing two places
[ ] Foreground service must declare type -> report export service
[ ] Exact alarm permission -> follow-up reminder
[ ] Non-SDK interface list tightened one more round -> third-party SDK to scan
[ ] Edge-to-edge and insets -> full-screen report page
[ ] Permission model and purpose timing -> location dialog chain (compliance review item)
D-10 · Create the window, don't change the machine. Borrowed a tablet-like device, and separately on Pixel 6 used wm size / wm density to create several window sizes, especially the band where sw crosses 600dp. This step is the cheapest, but I used to think "without a large-screen device you can't test," which wasted two years.
adb shell wm size 1080x2200
adb shell wm density 420
adb shell dumpsys window | grep -E 'smallestScreenWidthDp|mGlobalConfiguration'
# mGlobalConfiguration={... sw600dp w600dp h1080dp 420dpi ...}
adb shell wm size reset && adb shell wm density reset
D-7 · Scan non-SDK interfaces and third-party SDKs. Compared the official hiddenapi-flags.csv, and ran a full logcat -d on the release package fishing for Accessing hidden. Found an SDK call buried for a long time; the log clearly printed max-target, but we had always filtered only our own tag.
D-5 · Change code. Three real changes: move state saving from async callback into a place saved state can cover, add mutability to PendingIntent, add type to export service. Didn't touch architecture; together under 60 lines.
D-3 · Regression. Ten rounds of configuration change (two manual, eight scripted), two devices, cold/warm/hot three states each. Hit a small pit: I mixed hot-start data into cold-start samples, readings jumped around; only after re-creating the state did it stabilize. On measurement definitions, I'd fallen repeatedly in earlier pieces; this time I aligned them first.
D-1 · Gray release. 5% for one day, watching two numbers: report page recreation count and duplicate-submission rate. Recreation count matched expectations, duplicate submissions hit zero. On day three expanded to 30%, encountered one rollback - a third-party SDK's behavior when reading device info changed under target 36, and compliance review required investigating before scaling out. We rolled just that module back to a 35-compatible branch to observe, waiting for the SDK update; the rest continued normally. Not every problem should be fixed on the spot; some should first be rolled back to see who's responsible.
Of the two weeks, the time actually spent reading source was under four hours, but those four hours determined that the next ten days didn't require trial and error. My old approach was the opposite: change first, run, crash, then search, and search hits a pile of contradictory blogs, ending with gray release as a safety net. The difference isn't skill level; it's knowing which layer to go to for the answer.
That also answers the opening question more concretely: in these two weeks, Flutter never appeared. Not because it's bad; this problem was never in its territory.
Four Numbers I Use to Judge Whether I've Improved
Learning is the easiest thing to self-deceive; "feeling more confident" is saying nothing. I've been recording four numbers since September, definitions fixed first and never changed, kept in docs/learning-metrics.md.
| Number | Definition | Before | After | Sample |
|---|---|---|---|---|
| Median time to locate a platform behavior | From receiving phenomenon to writing "system-side evidence + source branch" | 3h40m | 52m | first 6 pages / next 6 pages |
| Number of acceptance points listed ahead in target upgrade | Items written into checklist before code changes, not post-hoc | 4 (7 added later) | 11 (2 added later) | 34→35 once, 35→36 once |
| Proportion of review comments with evidence | Items pointing to command output, source path, or measured number / total | 1/6 | 5/7 | two cross-end proposal reviews |
| Proportion of difficult tickets located only by gray release | Tickets where root cause required release observation / tough tickets that quarter | 9/14 | 3/12 | two quarters, module M scope |
All four moved in the right direction, but a few need clarifying or it becomes boasting.
The sample is too small: seventeen pages, two reviews, two quarters - can't support any statistical conclusion, only personal trend. The second number's improvement is the most obvious, but it's a bit gimmicky - I turned the act of "listing ahead" into a process, so the number naturally looks good; it doesn't mean my understanding of the platform doubled. The third one's denominator shrank because in the second review I said two fewer sentences.
And one number didn't improve: page delivery speed. From September to November, my weekly average feature points delivered barely moved, even got slightly slower because I wrote an extra note page and ran an extra dumpsys. I hesitated whether to record it, but finally wrote it into the file: this batch of investment buys "fewer incidents that can't be explained" and "upgrades without gambling," not "writing faster." If you evaluate these three months by delivery speed, it's negative return.
I keep it in the table so the next time someone asks "does learning this actually help," I can first say clearly on which dimension it helps and on which it doesn't. If you repeat vague gains often enough, you'll believe them yourself.
The Same Question Looks Different at Three Levels in Interviews
When it comes to "whether to learn," you can't avoid how it's assessed. I regrouped the questions I've both been asked and asked others over these two years into three tiers, and you'll see that "can you recite it" only matters at the shallowest tier.
| Tier | Typical question | What a correct answer looks like | How to prepare |
|---|---|---|---|
| Usage | What flags does PendingIntent have; how does StatefulWidget trigger rebuild in Flutter |
Name and parameters | Docs and having written it |
| Mechanism | Why does changing targetSdk recreate an Activity; which layers does a Channel call go through |
Can draw the chain, point to system-side evidence | Traced source and trace once |
| Judgment | Should this report page switch to cross-end; which version line to move first in this upgrade | Say the cost, conditions, and review time | Have made a decision you had to sign |
For Flutter-facing roles, usage and mechanism are asked a lot, especially state management, render pipeline, Engine and platform thread. For platform and system roles, it's almost all mechanism: when is ActivityRecord destroyed, which objects does a Binder call pass through, how does a window size change reach the View tree. At senior roles and promotion defense, usage largely disappears, leaving all judgment-level questions - and often without technical nouns, just "why did you decide this."
I bombed one myself, memorable. Someone asked the difference between compileSdk and targetSdk; I recited it fluently: one determines which APIs are available at compile time, the other declares which behavior version the app targets. He followed with: "Then why does changing targetSdk from 35 to 36 turn the same Activity on large-screen from reuse into recreation?" I froze for a few seconds, started talking about configuration changes, onConfigurationChanged, configChanges in the manifest, getting more and more roundabout.
The real answer is where the platform reads targetSdk and picks a branch. This question has nothing to do with memorizing definitions; it tests "you know there's a place making the decision, and you know where to find it." Three years later, stumped by myself at that review meeting, it was the same question in a different scenario.
So the way to prepare these two bodies of knowledge is also different. Usage is learned by writing; mechanism is learned by tracing - each trace adds a page to docs/platform-notes/, and what you can't draw is what you haven't understood. Judgment can only be learned by actually making a decision you had to sign, then writing down "why I decided this then, under what conditions it expires," and reviewing half a year later.
One thing I realized later: the hardest to replace among the three tiers is judgment, yet the tier we spend the most time on is usage. Chasing new framework features and memorizing new APIs gives fast feedback and a sense of accomplishment; tracing a branch in a system service may take an entire afternoon to understand why one line of code exists. This time ledger is the same one as in angle four's table.
Three Sayings I've Changed in These Two Years
"Learning Framework is for joining a big company to do ROM." When I entered the industry, a senior in the group said this, and I believed it for many years, so I decided a business app writer like me wouldn't need it, and comfortably never read it. Now I think this sentence conflates "can modify the platform" and "can explain the platform." The former only holds for C-class roles; the latter is a capability used by A-class roles in every version upgrade and every stubborn crash. The blank in the first six years wasn't time saved; it spread every debugging cost into the later years.
"Flutter performance is worse than native." I said this in 2019, based on a mid-range phone's stutter on a complex list, and quite confidently. Later Impeller moved shader compilation to build time, and the official Flutter 3 release post gave the Gallery transition animation's worst frame about 20x faster. After reinstalling, I had to change that sentence into a conditional one: for ordinary lists and animations, it's no longer what it was back then; for embedded native Platform Views, deep hardware capability, and package-size-sensitive scenarios, the bridge and engine fixed cost still need to be counted. What changed isn't right or wrong of the conclusion, but the premise of "how many years one observation can manage" - I took a 2019 hand feel as a long-term physical law.
"Cross-end will replace native roles." This is the most common now, and easiest to use to manufacture anxiety. My current view: it replaces tasks like "turning a design mock into a page," not the role of "being responsible for this end's behavior." Earlier I divided roles into three piles; cross-end compresses the most basic part of the first pile; the second pile's platform and engineering quality, and the third pile's system customization, instead become more dependent on mechanism understanding because the abstraction layer is thicker. The platform also has an extra variable: HarmonyOS makes the same feature possibly require two versions domestically, Flutter makes one logic cover multiple ends; these happen simultaneously, and what's needed isn't fewer people, but people who can more clearly tell which layer is charging.
The common point of the three sayings is that I made a judgment with a smooth sentence when no concrete project was forcing me. What overturned them later was never reading a better opinion article; it was always hitting a concrete incident, a concrete device, a concrete review.
For People in Different Positions
Judgments above change with position. I've collected the situations I discussed with group members and former colleagues into six categories, each with only one thing you can do today, not vague "build a foundation."
One to three years in, mainly writing business pages: Don't touch AOSP full compilation yet, and don't rush to switch cross-end. Read the output of dumpsys activity and dumpsys window until familiar; next time you hit "occasional white screen / state lost / data gone on return," force yourself to trace one layer up to the system side and write a page. The vast majority of problems you hit are at layers 3~4, not layer 6. The twenty-hour Add-to-App can be done, with the goal of understanding "which ledgers remain after switching stacks," not finding a new direction.
Three to seven years, starting to take on performance and architecture work: At this point, the most valuable thing is connecting mechanisms into a picture. Pick three chains and draw them - Zygote to first frame, one Binder call, VSYNC to one frame landing. Where you can't draw, fill it in online source. Treat targetSdk as a version fork line; in each official behavior-change list, pick five relevant items and write one sentence each: "which line of our code will be affected." Doing this once a year is more stable than chasing ten new frameworks.
Seven-plus years, leading people or making technical decisions: Write judgment into versioned documents. In decision records, write "under what conditions it holds," "who reviews," "when to look back," so half-a-year-later you don't re-argue from scratch. Whether to learn some framework isn't a capability question for you anymore; it's a scheduling question - give the twenty-hour L1 to a younger team member and have them bring back three numbers; that's more effective than you learning it and then relaying.
Want to move to automotive / system customization: Accept the threshold, don't bypass it. 400GB disk, 64GB RAM, Ubuntu, repo and android-latest-release, one full build - none can be skipped. Pick one module to dig into (any of AMS/WMS/SurfaceFlinger); the JD says "doesn't require all modules." Also add two things app roles rarely touch: AIDL/HIDL interface design and CTS/VTS validation. For HarmonyOS, treat ArkTS/ArkUI as new syntax; you already have the mechanism foundation.
Small team, one person handling both ends: Cross-end is likely a positive return for you; don't be scared off by the A-class ledger earlier. But write the hybrid stack's costs into the schedule early: who maintains the Channel contract, who upgrades both dependency lines, who looks at Dart-side crash stacks. Doing one L1 and measuring three numbers beats reading ten comparison articles.
Doing healthcare, finance, or other strong-compliance apps: The "keep" items in the platform capability checklist are almost all hard constraints for you. The timing of permission explanation dialogs, in-memory clearing before export, and auditability of background chains don't disappear because you change UI stacks. In selection's second question, walk each item through compliance review's criteria, not just technical. The incident this time looked like configuration change, but the root was writing state in an async callback without considering "after rebuild, is this data still here" - and compliance chains are particularly full of such intermediate states.
A Few Things I Advise My Team Not to Do
First, don't pull AOSP full source just to add a line to your resume. My 2019 pull failed to compile; it never went on the resume, and my notes only have a line about OOM. What persuades people isn't "I've compiled AOSP," it's "you said in half an hour which layer that crash belongs to."
Second, don't make "will this framework be canceled" the primary variable. Dart's two-year macros stopped on a dime; Google itself can't guarantee a roadmap. What you should look at is how much of the hundred hours you invest falls into the long-half-life column.
Third, don't use someone else's article's adoption percentages as your own budget. The numbers "two-end adaptation costs down 60%"... I checked five sources and the wording was nearly identical with no first-hand post-mortem found; even if it's true, it's some team's result in a specific project, unrelated to your compliance chain, hybrid-stack status, or GC density.
Fourth, don't write a selection conclusion as permanently valid. At the bottom of my decision record page is "this conclusion only holds under target 36 and current compliance standards;" after three months, platform behavior changes and you rerun. Writing it as permanent means every future change becomes a slap in the face.
Pits I Stepped On, Ordered by What I Saw at the Time
This half-year I stepped on pits on both sides and mixed them up. I've recorded 24 entries in the order I first saw them. The first six are the six faces of the same incident; at the time it took two days to tell them apart.
| Phenomenon | Root cause | Fix |
|---|---|---|
| Fold expansion loses note, two submissions in backend | target 36 large-screen config change triggers recreation, state only in async callback | Put state into a place saved state can reach |
| Thought self-drawing stack wouldn't need to handle recreation | FlutterActivity is still an Activity; config change decided by system service |
In platform capability checklist, mark lifecycle as "keep" |
| Tablet reproduces, Pixel 6 doesn't no matter how | The criterion is window smallestScreenWidthDp crossing 600dp, not physical size |
wm size creates window, watch dumpsys window sw value |
| Added opt-out and thought long-term worry over | That escape is versioned; API 37 expected non-opt-out | Adapt now, don't rely on the switch |
dumpsys activity activities shows new record, but can't say why |
Only looked at app framework layer, didn't trace to system service's config-change branch | Five-line note method, force filling the "source branch" line |
| Fix only changed the page, next module steps in again | Didn't turn the conclusion into a process | Before target upgrade, list acceptance points first |
| Channel method renamed, Android side silently takes empty branch, live for three days | Cross-language contract unversioned, each side tests itself | Contract file + startup both-side capability self-check |
| Hybrid stack crash only shows Dart stack, native side a mess of addresses | Two symbol tables not archived by build number | Store mapping and Dart symbols in same collection |
| After embedding native Platform View, scroll frame P90 degraded | Composition layer count increased, more visible on mid/low-end | Measure ten rounds before deciding, don't go by impression |
| Old SDK silently fails after target 34→35 | Non-SDK interface tightened by max-target-x |
Move to public API, don't bet the list |
logcat clearly has hidden API hint, no one sees it |
Only filtered our own tag | During upgrade window, always run full logcat -d |
| Debug package runs, release package crashes | Runtime enforcement policy tiers, plus obfuscation | All upgrade verification on release package |
repo sync all night, OOM halfway through compile |
Configured 16GB / 200GB per blog | Official threshold 400GB disk + 64GB RAM |
Pulling aosp-main doesn't get expected latest code |
2026 onwards Q2, Q4 releases, mainline changed to android-latest-release |
Initialize per official list branch |
| Online source search by class name can't find behavior fork point | Fork is three hops down the call chain | --filter=blob:none --sparse pull partial, read along call points |
| Took 2019 stutter as long-term conclusion | Impeller pre-compiles shaders at build time, first-frame jank is no longer the same problem | Re-test old judgments every few years |
| Empty project APK 7MB larger written as fixed conclusion | Single build, sample one | Mark as order-of-magnitude, write AGP and minSdk |
| Learning cross-end started from state-management family, stuck two weeks on ecosystem | Skipped minimal verification loop | Start from Add-to-App and three numbers |
| Learning platform layer from first chapter of first book, gave up in three weeks | No immediate feedback | Change to "trace one online issue, write one page" |
Thought recomposition and setState are two separate systems |
Declarative rebuild mindset largely transfers | Learn them side by side, only fill syntax and ecosystem gaps |
| Took Stack Overflow 2024 proportion as 2025 trend | 2025 survey changed tech topic categories, no longer lists these two frameworks | Use comparable data, note year and definition |
| Mashed 37%, 9.4%, 46% into "market share" one sentence | They count survey self-report, all respondents, another download/app definition | List by source type in four columns, don't merge |
| Citing "two-end adaptation costs down 60%" got asked for source | Five Chinese sources nearly verbatim, no first-hand post-mortem | Delete the number, only write verifiable release records |
| Decision conclusion forgotten half a year later | Didn't write conditions and review date | Write expiration and reviewer at page bottom |
| Evaluated these three months' learning by page delivery speed | Bought locating ability, not faster writing | Change to four-dimension definition, and keep the item that didn't improve |
Where to Dig Next
Sorted by my own investment-return ranking, from most worth doing. The first three need no new project, no convincing anyone, and can be done within a quarter.
| Direction | Solves | Cost |
|---|---|---|
| Read the "config change → recreation" chain fully to the bottom, fill in the still-unanswered 600dp criterion | Next large-screen/multi-window issue no longer has to guess | ~8 hours online source search |
Build a reusable acceptance checklist for target upgrades, listing affected code locations by version fork |
Yearly upgrade turns from gamble to verification | 1 day one-time, half-day update each year |
| Make hybrid-stack Channel contract a versioned machine-readable file, into CI for both-side self-check | Silent empty-branch incidents like that one | Half day, requires both ends to cooperate |
| Measure Platform View's real frame cost on low-end devices | Decide which pages can embed native View | Need one low-end real device + ten-plus rounds sampling |
| Read Binder's complete call chain once, draw a picture yourself | Cross-process issues no longer by rote | ~10 hours |
| Add AIDL/HIDL interface design and CTS/VTS validation | First brick toward system customization | Needs AOSP environment and one full build |
Scan own project and third-party SDKs' non-SDK dependencies with hiddenapi-flags.csv |
Discover where next target upgrade will explode early | Half a day, per target version |
| Do a set of comparison experiments for "declarative rebuild" on Compose and Flutter | Make the transferable part truly your own | One weekend, write one isomorphic page on each side |
| Follow a HarmonyOS native adaptation, take notes with mechanism analogies not API comparisons | Verify the judgment "more fragmented platforms demand more mechanism understanding" | Worth it only with an actual adaptation task |
| Accumulate the four metrics for three more quarters to see if it's just novelty | Judge whether this learning method has long-term return | Time, and possibly a negative answer |
I've kept the last one uncrossed. The four numbers currently head in the right direction, but the sample is only two quarters; it could be the short-term effect of "just started seriously recording." If another year from now the locating time climbs back, it means my on-demand note-taking method can't handle messier problems, and I'll need to change.
Later
In early December, looking back at that decision record, the line "this conclusion only holds under target 36 and current compliance standards" had a pen mark through it, and next to it a date line written as 37. The sentence next to it, "switching stacks can replace the API, but not the platform," I didn't touch.
The borrowed tablet is still in the desk drawer, with a faint scratch on the screen. A colleague passed and asked; I said that was the most expensive test machine of last year, but it didn't cost the department a cent - it just let me say a few fewer words without basis at review meetings.