This article introduces Fair 2.0, a Flutter dynamic framework used in the Anjuke Photo App to enable runtime widget updates, explains how to embed dynamic pages, register local widgets and templates, and presents performance data such as package size, memory usage, startup time, and frame rate.
Flutter is chosen for cross‑platform development because its single‑code Dart framework uses a self‑rendering engine and layered architecture—embedder, engine, and framework—to bypass JS bridges, delivering high‑performance, consistent UI via a GPU‑driven pipeline with layout, painting, and compositing optimizations.
This article details how Enterprise WeChat tackled the challenges of five‑platform UI development by adopting Flutter, describing its multi‑module architecture, hybrid stack engine management, communication via pigeon and dart‑ffi, performance optimizations, tooling, and dynamic‑loading strategies that enabled large‑scale cross‑platform deployment.
This article explains Android 64-bit adaptation, covering ABI concepts, SO file management, and automated platform solutions for finding missing SO packages to improve development efficiency.
This article explains the design and implementation of Fair 2.0 hot update for Flutter, compares existing industry solutions, details the overall update workflow, showcases code examples, and introduces the Fair‑API for managing file download and version control.
This guide lists several beginner‑friendly open‑source projects—including a Toutiao clone, a Meituan takeaway clone, and a Spring Boot online exam system—detailing their tech stacks, key features, and implementation highlights to help newcomers gain practical development experience.
This article introduces Fair 2.0, a Flutter dynamic framework that adds logic‑level syntactic sugar to simplify mixed layout‑logic scenarios, explains its dual‑state consistency design, presents three solution options with the chosen implementation, and provides code examples for registration and usage.
This week’s WecTeam Front‑end Weekly spotlights two technical deep‑dives: a Swift‑Objective‑C mixed‑compilation technique that slashes build times by 35%, and ByteDance’s large‑scale data‑tracking governance framework that underpins its trillion‑plus real‑time analytics pipeline.
This tutorial walks through creating nested navigation graphs, extracting them into separate XML files with the include tag, and reorganizing the app into core and feature modules, enabling a modular Android project while preserving existing navigation behavior.
This article explains why setting font‑weight 500 on PingFangSC‑Regular produces the same visual result as 400, why some Android devices only bold numeric/English characters, and provides practical fallback strategies and code examples for reliable mobile font rendering.
This article explains the architecture, communication protocols, JS loading/unloading, data binding, message dispatch, and third‑party extensions of the Fair 2.0 dynamic framework for Flutter, providing detailed code examples and design principles for integrating Dart, JS, and native layers.
This guide explains why raw iOS crash logs are unreadable, introduces dSYM files and DWARF debugging information, shows how to match UUIDs, compute addresses, and use both Xcode and command‑line tools for local symbolication, and describes a scalable online solution for massive crash‑log processing.
This article explains why a specially crafted Unicode string triggers an Android ANR by dissecting the Unicode line‑breaking (UAX #14) and bidirectional (UAX #9) algorithms, showing how runs ending with double zeros lead to an infinite loop in TextLine.getOffsetToLeftRightOf.
This comprehensive guide walks you through installing the Flutter SDK, configuring environment variables, creating projects and modules, understanding declarative versus imperative programming, exploring Flutter's three-layer architecture, rendering pipeline, platform channel integration, and provides a full counter‑app example with recent version highlights.
This article explains how to enable two-way communication between React Native and H5 pages using WebView, covering message handling in both directions, code examples for sending and receiving data, and important migration notes from the built‑in WebView to react‑native‑webview.
Fair 2.0 is an open‑source Flutter dynamic framework that enhances logic dynamicization, offering a compiler to transform Dart files into DSL and JS, with detailed architecture, comparisons to MXFlutter and Kraken, and a series of upcoming technical articles.
This article explains ByteDance’s automated precise testing solution, describing how method call‑chain analysis links code changes to Android Activities, enabling targeted test‑case recommendation, optimizing CI pipelines, and significantly improving test efficiency and coverage for large‑scale mobile projects.
This article describes Trip.com’s experience adapting its Android app to Android 11, covering background, key changes such as scoped storage and package visibility, migration strategies, implementation details, encountered challenges, and lessons learned for mobile developers.
This article explains how to play AAC (ADTS) audio on iOS by demonstrating the complete pipeline—from demuxing the file header and extracting raw data, through decoding with AudioConverterRef, to playback using AudioUnit and AUGraph, and even covering basic transcoding techniques.
This article details concrete techniques for reducing Flutter app memory consumption, focusing on image cache sizing, resource cropping, local caching, asset compression, cache thresholds, and page‑stack management, while providing step‑by‑step experiments, code snippets, and visual illustrations to guide developers.
This article investigates an Android ANR triggered by a while‑true loop in TextView's getOffsetForHorizontal, reproduces the issue on Pixel 2, explains how to extract trace files, compares Android Studio debugging with Frida dynamic hooking, and provides step‑by‑step instructions to reproduce and debug the bug.
The article describes how the MOO app team used Flutter's Dart VM Observatory and Allocation Profile tools to detect and fix an image memory leak caused by a custom painter not deregistering an ImageStreamListener, demonstrating step-by-step snapshot comparison, reference‑chain analysis, and the resulting memory stabilization after code fix.
This article explains why Core Data is needed for iOS data persistence, introduces its concepts such as entities, attributes, relationships, and ORM, walks through creating a data model file, configuring NSPersistentContainer, and demonstrates full CRUD operations with Swift code examples and best‑practice tips.
This article provides a comprehensive, macro-level analysis of Android's four core components—Activity, Service, BroadcastReceiver, and ContentProvider—detailing how each interacts with the ActivityManagerService (AMS) through Binder IPC, including code examples for startActivity, startService, bindService, broadcast, and ContentProvider operations across processes.
The article details MOO Music’s experience with Flutter memory management, explaining the Dart heap, stack, and external memory structures, common leak sources such as missing listener deregistration, unbounded widget lists, retained timers, static references, and third‑party or engine bugs, and offers practical detection and optimization techniques.
This guide provides a comprehensive overview of Android system architecture, explains the ADB communication mechanism, presents a detailed Android app testing checklist covering UI, compatibility, installation, OTA, interaction, concurrency, database, interface, performance, security, and other tests, and lists essential ADB commands and monitoring principles.
Jetpack Compose is a new Android UI framework that replaces traditional View and ViewGroup with a declarative approach, allowing developers to write less code, achieve faster development, and create more maintainable applications.
This article explains how iOS app launch works, presents methods for measuring startup time using system calls and Xcode Instruments, shares a detailed case study of the Maimai app, and offers concrete pre‑main and post‑main optimization techniques—including binary reordering, dynamic‑library reduction, concurrency control, and unconventional tricks—to achieve sub‑second launch performance.
This article explores software architecture concepts by drawing parallels with building design, explains the goals of architectural design such as scalability and maintainability, and demonstrates a practical Android MVVM implementation using WanAndroid with clean‑architecture patterns, Kotlin, and modular project structure.
This article guides developers through compiling, debugging, and analyzing the Flutter 2 Router source code, covering engine setup, architecture layers, key initialization classes, and practical steps to run a custom Flutter engine on Android and iOS.
This article presents a step‑by‑step guide for shrinking iOS app IPA size by leveraging App Thinning, removing unused image assets, compressing media, and eliminating dead code through tools like FengNiao, LSUnusedResources, AppCode, and LinkMap analysis.
JSBridge (JSB) enables bidirectional communication between a WebView’s JavaScript environment and native mobile code, covering WebView basics, platform-specific APIs, interception and injection methods, callback handling, and practical demos for both Android and iOS, helping developers implement robust cross‑platform bridges.
The article details JD.com's Mozi dynamic UI framework, describing its background, problem scope, design choices, version evolution, architecture, SDK, integration workflow, tooling, and future plans for mobile Android and iOS applications.
The article describes how a C++‑based cross‑platform framework and a unified routing mechanism were introduced to solve iOS and Android inconsistencies in WeChat Pay, resulting in fewer bugs, 45% less code, faster feature delivery, and a more reliable data‑flow architecture.
Mobile API gateways act as protocol adapters between networks, centralizing services for mobile apps; the article explains their role at Alibaba, the evolution of R&D efficiency through unified programming models and SDKs, large‑scale platform development, high‑availability strategies, and the EMAS top‑level model for mobile development.
This article explains how Xianyu identifies, monitors, and resolves Android ANR issues by analyzing root causes, implementing SIGQUIT‑based detection, inspecting thread stacks, and applying concrete optimizations such as SharedPreferences replacement, network broadcast caching, and delayed component registration, ultimately cutting ANR rates by more than half.
This article provides an in‑depth analysis of Flutter’s CustomScrollView component, covering its three‑layer architecture, rendering pipeline, scrollable mechanics, pinned header implementation, lazy‑loading strategy, and memory reuse techniques, illustrated with practical examples from Ctrip hotel app development.
This article walks you through using an Android phone to locate Xianyu’s video cache folder, rename the hidden file to MP4, and play or save the downloaded cat video, providing clear screenshots for each step.
This article explains how Aspect‑Oriented Programming is applied in Android development to achieve non‑intrusive privacy compliance checks and thread‑usage optimization, detailing the use of compile‑time ASM bytecode instrumentation and runtime Xposed/epic hooks, along with code examples and measured performance gains.
Chaplin Project replaces costly image‑to‑video synthesis on Xianyu by using centrally managed, OpenGL‑shader templates that combine product images with dynamic effects at playback, supported by a visual editor, resource platform, recommendation engine, and multi‑threaded client architecture, delivering richer browsing while conserving resources.
This article examines how Rust can unify client logic across Android and iOS, compares it with React Native and Flutter, and details a MVVM‑based architecture, binding mechanisms, and debugging optimizations that make Rust a lightweight, high‑performance solution for international mobile teams.
Learn how to manually create an iOS component library using CocoaPods, automate the process with the pod lib create scaffold, customize private templates, and develop a CocoaPods plugin to streamline library generation, complete with code examples and project structure details.
This article explains how to build a custom Android progress view featuring random particle motion, radial gradient backgrounds, sector clipping, pointer color changes, animated color transitions, and a jumping number display, with complete source code and step‑by‑step implementation details.
This article explains why Android developers need Gradle, describes the structure of a default Android project, details Gradle concepts such as projects, tasks, and the wrapper, and walks through dependency configurations, conflict resolution, and the complete build and packaging pipeline for APK generation.
Microsoft’s Windows 11 now runs Android apps natively through an Amazon Appstore integration, while Amazon’s adoption of the newer AAB packaging format offers developers smaller, device‑optimized downloads and distinct differences from Google Play’s requirements.
At Hello Travel, the team detailed how Flutter’s three‑layer architecture and two custom containers—Sparrow Microservice Container and Lumos Cross‑Platform Business Container—enable rapid exposure of native core functions, seamless integration of business logic, and consistent, high‑performance mobile development across more than nine business lines.
The article reports on community efforts to install the Windows 11 ARM64 preview on Android smartphones and Raspberry Pi devices, describing the Renegade Project, successful deployments on OnePlus 6T and Xiaomi 8, remaining limitations, and the required hardware and firmware modifications.
This article provides a step‑by‑step guide on using MotionLayout in Android, covering dependency setup, layout and MotionScene creation, defining start and end states, adding keyframe animations, gesture handling with OnSwipe, and common attributes for building complex UI transitions.
Baidu’s live‑streaming team cut startup latency by dissecting the three‑phase launch process, streamlining business‑logic handling, employing HTTPDNS pre‑resolution, forcing first‑frame rendering, low‑bitrate fallback, pre‑loading kernels, direct H.264 SPS/PPS parsing, and HLS m3u8 pre‑fetching, achieving sub‑3 ms DNS and hundreds‑millisecond overall gains.
The article presents Jiang Hongwei’s GMTC talk on 58RN’s instant‑open strategy, detailing performance metrics, LCP‑based first‑screen measurement, identified bottlenecks, and a series of optimizations—including resource pre‑loading, bundle splitting, native parallel fetching, and dynamic import—that collectively reduce page load time and improve business conversion rates.
Baidu’s live‑streaming startup latency was cut dramatically by streamlining the business‑scene flow, deploying device‑specific playback schemes, using HTTPDNS pre‑fetch, enhancing the kernel and media parsing, and pre‑loading HLS indexes, collectively delivering faster first‑screen times and improved QoE across iOS and Android devices.
This guide shows how to configure permissions, enable cleartext traffic, create a JS page, import the fetch module, and use fetch.fetch in the onInit lifecycle to retrieve JSON data from an external API and display it in a HarmonyOS UI.
By combining telemetry, Xcode Time Profile analysis, and a state‑machine‑driven deferment of playback until UI layout completes, the iQIYI Qixiu iOS team eliminated main‑thread SetFrame blocking and streamlined room‑data handling, boosting instant‑play success from roughly 56% to 78% and markedly improving first‑frame rendering latency.
LOCO Design System, created by 58.com, evolved from a poorly named “Basic Interaction” into a comprehensive, code‑driven UI framework covering graphic, interaction, marketing, and motion guidelines, offering three component modes, multimedia suites, and cross‑platform support to enhance collaboration between designers, engineers, and product teams.
This article breaks down the Android APK installation lifecycle—pre‑install, install, and post‑install—explaining each stage, offering command‑line methods, code examples, performance tweaks, and troubleshooting tips to help developers understand and optimize the whole process.
Starting in August 2021, Google Play will mandate that all newly published Android apps be distributed as Android App Bundles (AAB), a format that reduces app size by about 15% and enables dynamic delivery features, while existing apps remain unaffected.
This guide shows how to import the HarmonyOS storage module, use its get and set methods, and integrate them into a todo‑list app’s lifecycle so that tasks are saved across sessions, with full code examples and screenshots of the result.
This article details a Flutter‑based solution for automatically tracing Chinese characters, covering data preprocessing, SVG‑to‑coordinate conversion, scaling, Y‑axis inversion, translation, centering correction, and smooth stroke animation with frame‑rate optimization.
This article explains how MobX implements data binding and update mechanisms in Flutter, compares it with other state‑management frameworks, walks through the internal Observer‑Atom‑Reaction workflow with code examples, and presents common pitfalls and best‑practice recommendations for mobile developers.
This article explores how the C++‑based Klee framework brings component‑based, data‑driven, and reactive UI development to native mobile and desktop apps, comparing its efficiency and architecture with modern web frameworks and RxSwift, and showcasing practical code examples.
This talk explains how Vue.js can be leveraged to create high‑performance Flutter applications by bridging front‑end ecosystems with W3C‑based rendering, addressing the challenges of Dart‑centric development and showcasing the Kraken engine's role in achieving consistent multi‑device experiences.
This article discusses implementing event tracking in mobile applications using Kotlin, including creating extension methods for cleaner code, handling third-party platform limitations with Selenium, and sharing practical experiences from multiple project versions.
This article explains how DNS resolution overhead impacts mobile network performance, details the structure and types of DNS, examines common DNS problems such as hijacking and caching, and introduces HTTPDNS and GSLB as solutions to improve reliability and speed.
This article explores Android package size reduction by converting built‑in images to network‑loaded resources, detailing resource compression, code obfuscation, AAB splitting, drawable hooking via reflection or bytecode, download strategies with Fresco, caching, and safe removal of unused assets.
This guide explains how to improve iOS app performance by monitoring eight key metrics—battery, launch time, hang rate, memory, disk writes, scrolling, termination, and MXSignposts—using Xcode Organizer, MetricKit, Instruments, XCTest, and the App Store Connect API.
This article analyzes Android's class loading and verification process, identifies optimization opportunities to speed up cold starts, compares industry approaches, and presents a semi‑automated analysis tool along with practical solutions for handling verification failures in mobile apps.
This week’s WecTeam frontend newsletter highlights two practical mobile development articles: a performance‑focused Android native unwind technique that improves backtrace speed with minimal trade‑offs, and a rapid‑adaptation strategy for deploying JD's app on HarmonyOS using a hybrid package approach.
This article provides a comprehensive guide to Android code obfuscation, covering the purpose and benefits of minification, detailed ProGuard/R8 configuration, resource shrinking, desugaring, D8/R8 internals, custom obfuscation dictionaries, and modular ProGuard rules for multi‑module projects.
This article explains the Android Window mechanism in depth, covering the roles of PhoneWindow, WindowManagerImpl, DecorView, ViewRootImpl, and their interactions during Activity startup, view creation, and rendering, with detailed code examples and step‑by‑step analysis.
This article introduces Jetpack Compose, explains why it replaces XML‑based Android UI, walks through environment setup, Gradle configuration, and dependency inclusion, demonstrates the setContent and XML integration methods, explores composable functions, state management, list rendering with LazyColumn, and shares practical tips and reflections on declarative UI development in Android.
This article details how a video editing page built entirely with Flutter and Redux can overcome state, logic, UI, and performance complexities through architectural decisions, time‑range handling, stack‑based rendering, thumbnail caching, and frame‑rate optimizations to achieve native‑level performance on mainstream devices.
This guide details how JD adapted its Android app for HarmonyOS using a hybrid packaging approach, covering HarmonyOS features, Android‑to‑Harmony migration steps, inter‑call mechanisms, Feature Ability development, packaging, and publishing for a cross‑device shopping experience.
This article presents a comprehensive experience of UI componentization in Android projects, covering the background, goals, engineering and component architectures, detailed implementation steps for reusable UI components such as FlatButton, and practical Gradle configurations to achieve modular, decoupled, and scalable UI development.
The article explains how iOS crash interception must comprehensively and stably capture Mach, exception and signal crashes using combined signal‑and‑exception handlers, details stack‑trace symbolication via Mach‑O image lookup, and outlines safe post‑crash processing with a limited run‑loop while avoiding handler conflicts.
This tutorial walks readers through downloading the HarmonyOS 2.0 IDE, configuring the SDK, creating various types of HarmonyOS applications (TV, Wearable, Lite Wearable), installing the emulator, authorizing a Huawei account, and finally running a Hello World app on the emulator.
The Mobile SkyNet platform adds a dedicated mobile monitoring layer to SaaS services, using Zanlogger for error, warning, and info logs, Kafka‑HBase pipelines for high‑throughput storage, WeChat‑based alerting, and an MPaaS console for issue visualization, reducing mobile‑side incidents by about twenty percent.
The article examines why Python struggles on mobile devices and browsers, discusses the BeeWare project's effort to run CPython on Android, highlights technical and resource challenges, funding issues, and Guido van Rossum’s perspective on focusing Python on backend and scientific domains.
This tutorial walks readers through the entire process of setting up the HarmonyOS 2.0 development environment, downloading the IDE and SDK, creating various types of projects, configuring the emulator, and finally running a simple "Hello World" application on a Huawei device.
This tutorial provides a comprehensive step‑by‑step guide to setting up the HarmonyOS 2.0 development environment, downloading the IDE and SDK, creating various app projects, configuring the emulator, and successfully running a Hello World application on a TV device.
This article details the analysis of the iOS app launch process and presents a series of practical optimization techniques—ranging from reducing dynamic libraries and dead code to binary reordering and task concurrency—that together cut Trip.com’s launch time from two seconds to under one second.
This step‑by‑step guide shows beginners how to download and install Huawei DevEco Studio, create a new HarmonyOS project, configure a P40 phone simulator, and run the first HelloWorld app, complete with screenshots and download links.
This article provides an in‑depth overview of Android skinning, covering UI specifications, product‑level thinking, code implementations, dynamic refresh mechanisms, layout inflation interception, skin package loading strategies, performance optimizations, and future directions such as drawable skinning and Material You integration.
The article examines Python's popularity in machine learning, the difficulties of running Python apps on iOS and Android, the BeeWare project's milestones and challenges, funding issues, and Guido van Rossum’s perspective on focusing Python on backend and scientific workloads.
This tutorial explains how to set up Python 3.7, install ADB and UIAutomatorViewer, configure the uiautomator2 library and atx‑agent, and write a Python script that connects to an Android device to launch and interact with the Douyin app using various UI selectors.
This article introduces Kaiyan Kuaichuang's Flutter‑based cross‑platform architecture, covering component layering, state‑management strategies (BLoC, Provider, Redux, Built_redux), data communication via gRPC/ProtoBuf, and a custom URL‑based routing solution, while sharing practical code snippets and lessons learned.
This article systematically explains how to analyze, reduce, and monitor iOS IPA package size by examining Xcode build settings, resource files, and code, providing detailed step‑by‑step configurations, tables of component sizes, practical scripts, and best‑practice recommendations for sustainable bundle‑size management.
This article provides a comprehensive guide to the MVC and MVVM architectural patterns for iOS, explaining their components, interactions, KVO usage, and includes complete Objective‑C code examples that demonstrate how to implement both patterns in a real‑world news‑list app.
The article explains Android’s DEX compilation flow, the transformation of DEX into VDEX and ODEX during ART pre‑optimization, why ODEX lacks the original classes.dex causing ARouter routing failures, and how disabling dex stripping in the build restores the missing classes for stable navigation.
This document presents VM-Mapping, a solution for cross-scene data synchronization in mobile apps, addressing fragmented business scenarios and inconsistent UI states through annotation-based object mapping and data-driven UI updates.
This article introduces an open‑source iOS project that replicates WeChat, detailing its architecture, implemented features such as messaging, contacts, discovery and personal pages, the third‑party libraries used, visual screenshots, current status and how developers can contribute.
This article explains how to define Android UI pages as view trees, convert them to list structures, generate unique page signatures, and filter actionable events such as scrollable and clickable views using Python, enabling more effective model‑based testing of mobile applications.
This article details the design and implementation of a Flutter code coverage tool that instruments Dart's intermediate Dill files using AspectD, covering its background, instrumentation principles, code snippets, data collection, analysis, reporting, and observed improvements in testing efficiency.
The article details how AcFun transitioned its iOS codebase from Objective‑C to Swift, describing Swift's origins, Apple’s strategic push, the company’s architectural evolution, mixed‑language challenges, performance gains, and the adoption of modern frameworks such as SwiftUI, Combine, and RxSwift.
This article details the performance challenges of large‑scale Flutter apps and presents a series of practical optimizations—including module‑level hybrid rendering, native‑side data prefetch with FFI, multi‑level caching, and resource compression—that together reduced home‑page startup time by more than one second.
This article details the background, development steps, and debugging process for enabling dynamic voice playback in iOS push notifications via Notification Service Extension, covering iOS version constraints, integration of system AVSpeechSynthesizer and Baidu offline TTS SDK, code examples, and deployment considerations.
This guide explains the architecture of ADB, how to install it, and provides a comprehensive list of commands for connecting devices, managing apps, transferring files, capturing screenshots, controlling the shell, and performing performance analysis on Android devices.
This article breaks down the full cost of building a modest mobile app in Shenzhen, covering team salaries, social insurance, office rent, equipment, domain and server fees, and outlines the development stages from product planning to launch, arriving at an approximate total of one million yuan for the first version.
The document details DiDi’s driver‑side intelligent voice assistant “XiaoDi,” describing its three‑layer architecture—audio source switching controller, semantic‑parsing core, and business API—along with conflict‑resolution mechanisms, multi‑turn dialogue handling, and a four‑region UI design that together enhance driver safety, convenience, and well‑being.
This article explains the concept of Flutter hot reload, why it is essential for efficient mobile development, answers common questions, demonstrates Dart‑based hot‑reload demos, shows how to enable VM service, automate reloads, and provides an in‑depth source‑code walkthrough of the Flutter toolchain.
The article compares Flutter’s native interaction methods, explaining how Platform Channels use message codecs and thread switching for method calls, while FFI lets Dart directly invoke C functions, offering superior performance but more boilerplate, and discusses trade‑offs, implementation details, and a benchmark showing the speed gap.
