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.
Google announced the third Android 12 developer preview, detailing new SplashScreen API, call notification template, exact alarm permission, and improved web link handling, with the first stable version slated for August, providing developers with a comprehensive overview of upcoming system changes.
This article details the background, research, identified issues, and step‑by‑step technical solutions—including code examples—for implementing comprehensive accessibility support in the JD Daojia React Native (RN) platform, aiming to enable visually impaired users to complete the full purchase flow.
This article provides a comprehensive Kotlin tutorial for Android developers, covering basic syntax, variable declarations, control statements, functions, classes, objects, delegation, and standard library utilities, illustrated with clear code examples and explanations.
This guide walks you through the prerequisites, configuration steps, and complete payment flow—including unified order, client invocation, asynchronous notification, and status query—required to integrate WeChat Pay into WeChat official accounts and mini‑programs.
This article explains how to analyze and reduce React Native bundle size using tools like react-native-bundle-visualizer and the custom CRN bundle analysis platform, covering library replacements, import optimizations, code splitting, static asset handling, and reporting a typical 50% size reduction.
This article explains how to create a custom ADHoc build configuration in Xcode for a mixed Flutter and iOS project, covering steps such as duplicating Debug/Release configurations, adjusting bundle identifiers, app names, push SDK parameters, certificates, user‑defined settings, and integrating the changes into Flutter’s build scripts and CI pipelines.
Taro 3.2 introduces a revamped compilation pipeline that eliminates intermediate code, adds native source‑map support, supports React Native 0.64 with Hermes, expands APIs and components, enables on‑demand imports, and provides clear migration steps for both new and existing projects, while outlining future roadmap and community resources.
This curated guide presents concise technical deep‑dives into JavaScript protection, pagination techniques, Babel async/await transformation, Web Worker sandboxing, V8 engine tuning, React Native launch optimization, collaborative editing algorithms, Windows defragmentation, CLS metric evolution, accessible UI components, and future‑proof CSS strategies.
This article explains how to represent Android UI view trees as lists, generate unique page signatures, and filter actionable events such as scrolls and touches to improve model‑based testing coverage and traceability, providing Python code examples for each step.
This article analyzes the limitations of classic iOS MVC, explores MVVM's benefits and drawbacks, and proposes a new service‑oriented architecture with a simple DSL to define and compose atomic business functions, aiming for cleaner, more maintainable mobile code.
This article explains why accessibility matters for all users, demonstrates how blind users interact with mobile screens, identifies common focus and labeling issues, and provides practical ARIA and ReactNative code patterns plus Imgcook‑driven automation to generate accessible components efficiently.
NativeScript 8.0 expands the mature cross‑platform framework with Apple Silicon (M1) support, Webpack 5 integration, enhanced accessibility, new ESLint rules, a RootLayout container, updated documentation, and streamlined core features for building iOS and Android apps using JavaScript or TypeScript.
The article introduces Taro 3.2's React Native support, detailing faster compilation via Metro, native source‑map debugging, compatibility with React Native 0.60+ (including 0.64), expanded APIs and components, on‑demand imports to reduce bundle size, and step‑by‑step migration and integration instructions.
Xianyu built an automated mobile performance testing platform that standardizes and integrates testing into the release pipeline, replacing manual steps with three‑stage automated tasks, adding data collection, retry verification, and reporting, cutting manpower from a day to under an hour while boosting data accuracy and stability, with plans to further embed testing into CI.
This article analyzes the theoretical and measured performance differences of inertial scrolling among Web (Chromium), native Android, and Flutter, explains the underlying rendering mechanisms that cause Flutter’s lag, and outlines engine‑level optimizations that bring Flutter’s scroll smoothness close to native levels.
This article explains how iOS generates a touch event, encapsulates it in UITouch and UIEvent objects, propagates it through UIApplication to the view hierarchy using hitTest and pointInside, and finally processes it via UIResponder methods and the responder chain.
This article provides a detailed technical analysis of LeakCanary 2.0, covering its Kotlin‑based integration, the new self‑implemented Hprof parser, detection workflow, core classes such as AppWatcher and ObjectWatcher, graph indexing, and the algorithm used to locate the shortest GC‑root leak path.
Beike adopted Flutter to address rapid growth and staffing shortages, achieving over 80% hybrid development, native‑like performance, one‑second hot‑reload cycles, extensive community package usage, and a systematic Flutter infrastructure across dozens of mobile applications.
This article explains how to create a Flutter-based color‑picker utility that captures the current screen, extracts pixel colors at any touch point, and displays a magnified view with the selected color, providing a practical solution for UI verification and design‑developer communication.
This article details the background, design choices, runtime architecture, code transformation, entry and page support, lifecycle handling, and integration strategy of adapting the Taro 3 framework to run on React Native, providing a comprehensive guide for cross‑platform development.
This article details ByteDance's iOS team approaches to reducing app package size—including resource compression, Assets.car merging, text file zipping, and Mach‑O binary optimizations such as -Oz, LTO, exported symbols, property dynamic handling, __TEXT segment migration, and binary segment compression—resulting in multi‑megabyte savings and improved download performance.
This article explores how UIKit, CoreAnimation, CALayer, and CoreFoundation (including RunLoop) collaborate to perform static drawing and animation on iOS, illustrating the process with a button‑drawing example and detailed code snippets.
This article explains how CADisplayLink registers VSync signals via a mach port, how RunLoop sources and observers process those signals, the impact of adding multiple display links, and the role of CATransaction in committing layer updates and driving iOS UI animation.
The article introduces Appium 2.0, explains its unbundled driver architecture, custom driver templates, special command plugins, and provides installation commands, highlighting how these changes simplify and expand mobile test automation across iOS, Android, and Windows platforms.
This article examines the evolution of Youzan's permission management—from the original SAM system using a 64‑bit RBAC model to the flexible 2.0 architecture with rig, dynamic menu, and widget delegation—highlighting design choices, implementation details, challenges solved, and measurable business impact.
This article describes a method for analyzing Android APK size at the library level by extracting and parsing Gradle intermediate merge files, mapping resources, assets, native libraries and Java resources to their originating libraries, and linking them to maintenance teams for precise package‑size reporting.
The article explains Android virtual memory concepts, address space limits for 32‑ and 64‑bit apps, layout of QQ Music/Karaoke process memory, tools for inspecting /proc/pid/smaps, and shows how memory growth (e.g., loading libYTCommon.so) can cause 32‑bit apps to hit the 4 GB limit and crash.
This article explains the purpose and characteristics of Android Jetpack's ViewModel component, demonstrates how to use it with LiveData in Activities and Fragments, shows code examples for data sharing between fragments, and provides an in‑depth analysis of its internal source code and lifecycle handling.
This article examines Objective‑C method swizzling, compares two common implementation schemes, analyzes 18 inheritance‑hook scenarios for child‑first and parent‑first hook orders, and provides practical recommendations to ensure correct execution order and avoid crashes.
A leaked early draft of Google’s Android 12 documentation shows a flatter UI with more white space and rounded corners, a redesigned notification panel, new privacy indicators for camera and microphone use, and a small “Conversation” widget that may become mandatory on all devices.
This article explains how Youzan extended its APM framework with offline monitoring, built the AWACS visual tool, integrated Appium‑driven regression, instrumented method timing and network traffic via Gradle plugins, captured page rendering time, processed data in the backend, and created an issue‑management platform, outlining future enhancements.
This article provides a step‑by‑step guide on converting static iOS widgets into dynamic, server‑driven configurable widgets using SiriKit Intent files, Intents extensions, SwiftUI views, image loading, user interaction handling, data sharing, and debugging techniques.
This article details Beike's iOS app startup optimization workflow, covering online startup speed measurement, offline performance analysis with a custom profiler, and governance practices such as +load method control, code stripping, and binary reordering to improve launch time and user experience.
This article explains the fundamentals of WebView as a native container for H5, introduces the JSBridge concept for two‑way JavaScript‑Native messaging, and provides detailed implementation patterns and code samples for Android (JavascriptInterface, URL‑Scheme, WebChromeClient) and iOS (WKWebView, user scripts, message handlers).
This article examines typical Android development challenges such as lack of standard architecture, lifecycle management, and testing difficulties, and presents the Snowball onion architecture—an MVVM‑based, RxJava‑powered framework with reusable components, best‑practice guidelines, and a supporting xueqiu‑onion library.
This article introduces Android Jetpack and its Architecture Components, focuses on the Lifecycle library, demonstrates how to integrate it into activities and MVP architectures, explains the underlying source code including ReportFragment and LifecycleRegistry, and provides practical code examples for effective lifecycle management.
The article outlines three developmental stages for engineers—from merely implementing PRD specifications, to understanding business and selecting appropriate technical solutions, and finally proactively contributing business ideas—while describing practical methods for demand exploration, project initiation, management, and data‑driven iteration within a mobile development context.
Learn how to create a low‑cost AI bot for the mobile game Honor of Kings by capturing the phone screen with scrcpy, generating action commands from game images using a Transformer model, and executing those commands via minitouch, complete with setup steps, required tools, and code links.
This article curates a collection of actively maintained high‑fidelity clone projects for popular apps—including WeChat, Zhihu, TikTok, Bilibili, Meituan, and more—showcasing the tech stacks (Flutter, Vue, React, Node.js, etc.), core features, screenshots, and direct GitHub links to help developers learn and build similar applications.
This article details the challenges of JD Pay's Android SDK growth, proposes a refactor using Scene, Interactor, and UserCase concepts to decouple business logic, presents architectural redesign, code examples, and quantitative performance improvements after the overhaul.
Flutter converts native MotionEvent data into a serialized ByteBuffer, passes it through JNI to the engine, creates a Dart PointerDataPacket, hit‑tests the render tree, dispatches the event to each hit object, and resolves competing GestureRecognizers in the arena so the winning recognizer triggers the appropriate callback such as onTap or onDrag.
A recent discovery reveals that Apple’s open‑source file make_tapi_happy.h includes a humorous "only god knows why" comment about WeChat compatibility, highlighting how business negotiations can leave quirky traces in source code.
Xianyu’s streaming page container architecture redesigns the Flutter home page with an MVVM‑based, event‑driven framework, DinamicX DSL templates, and the PowerScrollView list container, eliminating duplicated layout logic, accelerating A/B testing and releases, and enabling dynamic, lightweight pages with partial UI refreshes.
This article presents a comprehensive guide on mobile video editing, covering the historical background of montage, fundamental editing concepts, the component structure of a video editing SDK, detailed performance‑optimisation techniques, compatibility handling, and future directions such as AI‑driven and cloud‑assisted workflows.
This article describes how the JAYE 2.0 project at Beike leverages abstract syntax tree (AST) generation, a custom runtime interpreter, and Dart VM execution to achieve high‑performance, hot‑fixable dynamic updates for Flutter applications, addressing packaging, hot‑reload, and scalability challenges.
Meituan’s MTFlutter team rebuilt Flutter’s embedder layer for HarmonyOS by simulating VSync, creating a SurfaceProvider‑based rendering surface, forwarding touch, key and speech events, and re‑implementing asset loading, message loops and lifecycle callbacks, allowing Flutter apps to run on phones, tablets, TVs and wearables.
The article explains why Android TextView line spacing varies across devices due to mismatched FontMetrics calculations, and presents a low‑intrusion fix that uses a custom LineHeightSpan applied via an ETextView subclass to enforce a visual‑consistent line height equal to the text size on all screen resolutions.
This article guides developers through implementing clipboard detection and paste functionality in WeChat mini programs, covering the use of wx.getClipboardData, regex URL extraction, conditional modal prompts, and provides complete sample code for integration.
This article explains how the exhibition cloud platform leverages Google Flutter for cross‑platform mobile development, detailing its architecture, engine components, integration methods, Platform Channel communication, and the efficiency gains observed in a real‑world trade‑fair app.
This article examines the challenges of loading large third‑party .so libraries in Android apps, analyzes traditional and advanced asynchronous loading methods, discusses dependency and text‑relocation issues, and presents practical solutions and implementation steps to reduce package size while maintaining stability.
This article details the end‑to‑end process of building a Snowball iOS Widget with WidgetKit, covering design principles, lifecycle, data sharing via App Groups, SwiftUI view construction, Intent configuration, and deployment considerations, providing code examples and practical tips for mobile developers.
PowerScrollView is a high‑performance Flutter flow‑layout framework that composes section‑based slivers for lists, grids and waterfalls, adds automatic exposure, scroll‑to‑index, fine‑grained refresh and element‑reuse optimizations, and uses frame‑by‑frame rendering to deliver smooth scrolling across Xianyu’s core pages.
This article explains the fundamentals of hooking on iOS, covering Method Swizzle and Facebook's fishhook, detailing the Mach‑O file structure, PIC technique, and providing complete source code examples that demonstrate how to replace system functions such as NSLog at runtime.
This article presents Sohu Technology's curated list of the most popular 2020 technical articles, covering Android Jetpack Navigation, WorkManager, iOS App Clips, Swift enums, Java low‑latency tuning, Spring Boot auto‑configuration, VIPER architecture, WKWebView, iOS watermarking, RecyclerView exposure, SwiftUI State & Binding, LLVM instrumentation, and Elasticsearch, offering concise overviews and key insights for developers.
This article introduces React Native, covering its core concepts, cross‑platform features, underlying architecture such as JavaScriptCore, Hermes, the Bridge, Virtual DOM, threading model, hot updates, and provides practical examples for building a modal animation on both iOS and Android.
This article examines how UILabel stores its text‑related properties internally, reveals the role of the private _content object, and explains the interactions and pitfalls when using the text and attributedText properties in iOS development.
This article examines the classification of mobile apps, the shortcomings of an H5‑based cash register, the rationale for adopting Kotlin over Java, a detailed overview of Kotlin’s language features and differences, practical implementation details, interoperability, null‑safety techniques, encountered issues, and the performance gains achieved after native migration.
This article outlines Zhenkun's mobile engineering journey from 2020 to 2021, detailing the shift to componentized architecture, the adoption of Flutter hybrid development, CI automation, and real‑time monitoring to boost development efficiency and product quality.
In 2020 Meituan’s tech team highlighted its eight most‑read technical articles—spanning Java thread‑pool design, mobile UI consistency, trillion‑scale KV storage, AI search estimation, Java GC troubleshooting, delivery A/B evaluation, ZGC tuning, and marketing design patterns—while also showcasing the most‑viewed posts, thanking 260,000 readers and inviting new talent for the coming year.
