The article analyzes why Flutter crashes on iOS when accessing the GPU in the background, explains the official SyncSwitch fix for ImageDecoder, and details Xianyu’s additional patches for MultipleFrameCodec, EncodeImage, and Rasterizer::DrawToSurface that together, via PR #28383, fully resolve the GPU‑background crash.
This article explains why UIWebView was deprecated, how WKWebView improves performance and memory usage, details its multi‑process architecture, outlines page loading flow, delegate methods, container design, caching strategies, cookie handling across processes, and solutions for white‑screen crashes in iOS apps.
This article explains the fundamentals of iOS Auto Layout, detailing how layouts determine what and where to draw, the role of constraints and linear equations, the layout cycle stages, debugging tips, and performance‑optimizing techniques for high‑frequency updates.
This article explores the underlying physics, mathematical models, and interaction details of iOS's UIScrollView, analyzing its partial‑display principle, deceleration behavior, bounce dynamics, parameter measurement methods, and practical applications in complex scrolling interfaces.
The article explains the iOS code‑signing verification mechanism, why enterprise IPAs built for iOS 15 fail with a signature‑version error, and provides a step‑by‑step guide to re‑sign the package using newer signature formats, along with a deep dive into certificates, provisioning profiles, entitlements and the underlying cryptographic concepts.
Despite the rollout of 5G, mobile developers face hidden challenges: users see a 5G icon that may not reflect actual network mode, Android’s APIs inconsistently expose NR/NSA status, and iOS adds new constants, requiring careful handling to ensure app behavior aligns with true connectivity.
The article compares the view‑and‑layer tree architectures of iOS, Android, Web, and Flutter, explaining iOS’s UIView/CALayer hierarchy, coordinate system, and model‑presentation‑render trees, while detailing Flutter’s widget, element, render‑object, and layer trees, and highlighting their shared parse‑layout‑render pipeline and differing animation approaches.
These articles compare how Web, Android, iOS, and Flutter represent UI structures—detailing the DOM and Virtual DOM creation, diffing, and rendering on the Web, and the XML‑based layout inflation, view hierarchy, styling, and drawing pipeline on Android—to help front‑end developers grasp each platform’s tree‑based architecture.
This guide explains step‑by‑step methods for iPhone and Android users to instantly open their health code using Siri shortcuts, double‑tap back gestures, home‑screen shortcuts, and voice assistants, improving efficiency during pandemic‑related checks.
The article details a systematic investigation of intermittent audio playback stutter on iOS 14.5, tracing the issue from AVPlayer playback through Audio Queue recording, analyzing AudioStreamBasicDescription parameters and buffer size inconsistencies, and presenting a code‑level fix that aligns buffer sizes before invoking AudioConverterFillComplexBuffer.
The DeWu iOS tech salon held on September 25, 2021 brought together internal and external experts from DeWu, Alibaba, and ByteDance to share deep technical insights on video effect rendering, the MBox mobile toolchain, mobile AI with MNN, and the evolution of DeWu's iOS engineering practices, followed by interactive Q&A and community networking.
This comprehensive guide explains what NFC is, compares it with other short‑range wireless technologies, and provides step‑by‑step tutorials for implementing NFC on Android, iOS, and WeChat mini‑programs, covering chip data writing, NDEF formatting, App Clip integration, and universal link handling.
This comprehensive guide explains the inner workings of Apple's ld64 static linker for iOS, covering its historical background, core concepts such as objects, archives, symbols, and fixups, command‑line parameters, execution phases, symbol resolution, dead‑code stripping, optimization passes, output generation, auto‑linking, the -ObjC flag, debugging options, and LTO support.
This comprehensive tutorial explains how to use CocoaPods for iOS and macOS development, covering installation, project initialization, dependency management, podspec creation, private repository setup, version control, caching, and troubleshooting, enabling developers to efficiently manage third‑party libraries and create reusable modules.
This article explains the concepts, benefits, and practical steps for implementing unit tests and generating code‑coverage reports in iOS projects using Xcode, XcodeCoverage, OCMock, and CI tools such as Bamboo and iBiu, while also covering common pitfalls and best practices.
An in‑depth case study of Alibaba.com’s iOS client reveals how architectural decay—manifested as tangled module dependencies, slow builds, and outdated tooling—drains developer productivity, and outlines data‑driven, layered, and automated strategies—including dependency analysis, modular refactoring, and CI safeguards—to restore a healthy, scalable mobile codebase.
This article provides a comprehensive guide to iOS symbolication, explaining what symbolication is, why it is needed, how to analyze crash logs, the required files, and step‑by‑step usage of tools such as symbolicatecrash and atos to turn unreadable crash stacks into readable source code references.
This article explains the Flutter soft‑keyboard invocation flow on Android and iOS, analyzes page‑repaint and animation problems such as stutter on specific devices, and presents practical fixes including performance flags, MediaQuery handling, and native input adjustments.
This article investigates a deadlock between the Main Thread and the JavaScriptCore Heap Collector Thread on iOS 13, explains the underlying mutex and RunLoop interactions, reproduces the issue with CFTimer‑based timers, and proposes an AutoReleasePool‑wrapped solution along with best‑practice recommendations for JavaScriptCore usage.
An in‑depth analysis reveals how a Main Thread and JavaScriptCore Heap Collector Thread can deadlock on iOS 13 due to RunLoop lock contention triggered by timer callbacks and AutoReleasePool memory reclamation, and provides a practical solution using scoped AutoReleasePool blocks to prevent the issue.
This article explains the fundamentals of iOS crashes, describes exception types such as Mach and Signal, details stack memory layout and recovery techniques, and walks through several real‑world crash investigations—including WKWebView, ImageIO, and fishhook issues—culminating in practical mitigation steps that reduced crash rates by over 60%.
This article dives deep into WKWebView on iOS/macOS, explaining its network architecture, cookie handling, multi‑process model, and the four major production issues—request proxy, cookie management, full‑screen adaptation, and WebContent crashes—while offering detailed, source‑level solutions and implementation tips.
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 outlines the various payment channels—In‑App Purchase, third‑party, H5, and mini‑program—across iOS, Android, and WeChat environments, detailing their flow diagrams, required API interactions, code examples, and best‑practice recommendations to help developers implement seamless mobile payments.
This article explains the challenges of iOS crash log symbolication on Linux, evaluates native tools like symbolicatecrash and atos, describes several prototype solutions, and details the final design that pre‑parses DWARF and symbol tables into a distributed cache to achieve massive latency and resource reductions.
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.
An in‑depth analysis of a memory‑growth issue observed in a Kuaishou live‑stream app reveals how ARC, autorelease pools, and NSString’s class‑cluster implementation interact, why @autoreleasepool blocks resolve the leak, and how compiler optimizations and thread‑local pools affect object release in long‑running C++ threads.
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 explains how the iOS singleton pattern works, why dispatch_once executes only once during an app's lifecycle, examines the underlying GCD source code, shows how to manually reset a singleton, and discusses the thread‑safety guarantees of the implementation.
This article describes a complete workflow for iOS UI development that centralizes color definitions in a JSON palette, synchronizes them via a CocoaPods post‑integrate hook, and automatically generates Objective‑C/Swift color constants and Xcode code snippets using Ruby and ERB templates, dramatically improving efficiency and reducing manual errors.
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 explains how IGListKit can replace UICollectionView for building list scenes in iOS apps, detailing its architecture, adapter‑section controller pattern, diff‑based updates, practical issues such as cell‑level diffing, and integration with RxSwift to achieve smooth, performant UI rendering.
Airbnb’s Epoxy iOS framework replaces fragile, indexPath‑driven imperative UI code with a declarative model‑based system that automatically diffs and animates view updates, eliminating crashes, boosting developer satisfaction from –78 to +58, and enabling a unified, open‑source approach to building Swift interfaces.
This article details a UI automation regression framework for mobile event tracking, covering background challenges, Android and iOS log collection methods, H5 integration strategies, performance comparisons, and practical recommendations to improve testing efficiency by about 50%.
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 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 systematically presents the cold‑start performance problems of the Beike iOS app, defines testing standards, explains the essence of optimization, lists common pitfalls, and details a comprehensive set of practical solutions ranging from lifecycle‑aware task scheduling and minimal‑set launchers to dynamic‑library lazy loading, compile‑time I/O elimination, static‑initializer handling, dead‑code removal, and monitoring standards.
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.
This article shares the Kuaishou overseas client team's practical experiences and solutions for improving compilation efficiency through Swift/Objective‑C binary mixed compilation, covering single‑target and multi‑target strategies, moduleization challenges, binary compatibility, and future directions for mobile development.
This article shares the Kuaishou overseas client team's experience of improving Swift/Objective‑C mixed compilation through binary packaging, covering single‑target and multi‑target strategies, moduleization challenges, solutions for C++ and header issues, and future best‑practice recommendations for iOS development.
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.
This article explains Flutter 2's new multi‑engine Add‑to‑App approach, walks through creating an Android project with a Flutter module, shows how to manage engines with FlutterEngineGroup, and compares multi‑engine and single‑engine hybrid solutions in terms of memory and performance.
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.
This article explains the fundamentals of iOS crashes, categorizes common crash types such as wild pointers, deadlocks and watchdogs, presents real-world JD Finance app crash cases with code analysis, and outlines systematic debugging, logging, and preventive practices to keep crash rates well below industry averages.
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.
The NetEase News iOS team adopted a three‑layer componentization strategy—foundation, common, and business—standardizing code conventions, Git workflow, and CI‑driven reviews, encapsulating third‑party libraries, managing dependencies via injection and mediators, and distributing binary pods, which reduced the main project to a single file while expanding reusable components to over 250, achieving low coupling and high cohesion.
This article explores the fundamentals of HTTP cookies within WKWebView, detailing how cookies are stored in memory or disk, the roles of UIProcess, WebContent, and NetworkProcess, and provides code examples for front‑end JavaScript, back‑end headers, and iOS client APIs.
This guide walks you through what Airtest is, how to install it, connect devices, use its visual interface for basic operations, and follow a step‑by‑step example that records actions and generates runnable test scripts for Android and iOS apps.
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.
This article explains how to use the otool command to parse Mach-O sections, extract __objc_classlist and __objc_classrefs, compute their differences, and locate unused Objective‑C classes and methods for iOS app size optimization, providing sample Objective‑C code and detailed implementation steps.
Security researcher Carl Schou has uncovered a new iPhone Wi‑Fi vulnerability where connecting to a network named “%SecretClub%power” crashes the device’s Wi‑Fi, cannot be fixed by resetting network settings, and may require a full data wipe, highlighting iOS’s flawed percent‑sign parsing.
This article dissects the WKWebView loading pipeline on iOS, explaining the three WebKit processes, their communication, the step‑by‑step request flow, and the detailed behavior of each WKNavigationDelegate method, providing practical insights for performance tuning and debugging.
This article investigates the memory‑leak issue in Tencent Penguin Tutor's Cocos Creator implementation on iOS, explains why the engine's node pool and DragonBones animations cause unreleased Texture2D objects, and provides a step‑by‑step solution using explicit pool clearing and proper object disposal.
This guide shows how to set up an iPhone shortcut that instantly displays your health code with a single tap, detailing each step from adding the code to the home screen to configuring a trigger in the Accessibility settings.
This article explains the iOS app launch lifecycle—including cold and hot starts—details launch‑time optimizations before and after the main function, introduces the fundamentals of virtual memory and ASLR, and provides a practical guide to binary reordering using order files and Clang instrumentation.
This article explains what JSBridge is, details its implementation using URL interception and iframe tricks, and walks through the full communication flow between a WebView and native code on iOS, including code examples for registration, message handling, and callbacks.
This article demonstrates how to create recurring iOS calendar reminders for Monday‑to‑Friday workdays, filter out Chinese statutory holidays using an external holiday‑cn JSON source, and handle make‑up workdays, providing complete Swift code and step‑by‑step explanations.
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 tutorial walks iOS developers through downloading the WebKit source, configuring and compiling it, setting up a debugging project or using the MobileMiniBrowser demo, and analyzing WKWebView’s multi‑process architecture—including UI, WebContent, Network, and Storage processes—to troubleshoot and profile rendering behavior.
This article outlines the background, current challenges, and recent enhancements of CI/CD‑integrated business security compliance detection for mobile apps, including incremental source‑code scanning, call‑graph analysis, and performance gains, while also discussing future directions and benefits.
This article explains how to use AOP techniques such as Method Swizzle and NSProxy to hook UICollectionView and UIViewController delegate methods for precise event tracking, analyzes compatibility problems caused by multiple delegate proxies in large apps, and proposes three practical solutions to avoid crashes and maintain extensibility.
This article explains what JSBridge is, details its implementation using URL interception and iframe tricks, and walks through the registration, message handling, and call flow between WebView and native code on iOS, providing full code examples and a step‑by‑step process overview.
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.
After a massive crash caused by a malformed Facebook SDK payload highlighted the lack of fault‑tolerance, this article explains why iOS crash protection is essential, outlines a four‑step handling workflow, and details two main techniques—Aspect‑Oriented Programming hooks and managed zombie objects—along with their pitfalls, performance impact, and memory‑threshold formulas for safe production deployment.
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 article provides a detailed examination of the YYModel framework’s source code, explaining how it leverages Objective‑C runtime to parse JSON into model objects, covering key files, internal classes, mapping mechanisms, and the core conversion methods with illustrative code examples.
An in‑depth guide to designing and implementing a unified popup SDK for a mobile commerce app, covering project background, pain points, architectural modules, data models, template factories, code integration, and measurable benefits such as reduced development effort and cleaner dialog management.
This article explores using AOP techniques such as Method Swizzle and NSProxy‑based delegate proxies to instrument iOS view controllers and collection view delegates, analyzes crashes caused by multiple setDelegate hooks—including interactions with RxCocoa—and proposes several practical solutions to ensure stable hooking in complex app environments.
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.
This article describes how JD Mall’s order system migrated key iOS components to Swift, leveraging static dispatch, value‑type structures, protocol‑oriented design, error handling, guard statements, defer, lazy loading, and functional programming to improve performance, safety, and maintainability across mobile and macOS applications.
This article explains how Swift and Objective‑C can be mixed in iOS projects, covering prerequisite settings, CocoaPods module configuration, name mangling, compilation differences, dynamic features, method replacement techniques, and the underlying Swift runtime metadata that enable seamless inter‑language calls.
This article explains how A‑Station adopted Swift for iOS, details the prerequisites and CocoaPods configuration for mixed Swift‑Objective‑C projects, explores module usage, name mangling, dynamic features, method replacement techniques, and provides practical code examples and tooling references.
This tutorial explains step‑by‑step how to create a custom iOS Flutter plugin for audio playback, covering the MethodChannel architecture, Dart side implementation, Swift native code, and communication of playback controls and status between Flutter and iOS.
This article describes the requirements, architecture, API design, database selection, retention policies, security measures, and performance optimizations of a new iOS log system that records business, network, and player logs, uses WCDB for storage, and employs active pull and encrypted chunked uploads to improve issue diagnosis.
This article explains a novel Swift hooking technique that modifies the virtual function table (VTable) to replace method implementations, detailing Swift's runtime structures such as TypeContext, Metadata, OverrideTable, and providing concrete ARM64 assembly and Swift code examples.
This article introduces SwiftUI, compares it with other declarative UI frameworks, explains its rendering pipeline, lifecycle, data‑binding mechanisms, language features, and discusses how Qunar has adopted SwiftUI and migrated parts of its native iOS codebase from Objective‑C to Swift.
The article examines the missing gesture capabilities in current web standards, compares implementations across Kraken, hammer.js, Flutter, iOS, and Android, and argues for a unified, high‑performance, and easy‑to‑use gesture specification to improve web development.
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 why fixed elements break when the iOS soft keyboard appears in a WebView, compares iOS and Android keyboard behaviors, shows how to listen for keyboard events, and provides practical solutions—including native headers, scrollIntoView tricks and scroll adjustments—to keep sticky UI components correctly positioned.
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 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 article explains the concept of diff algorithms, demonstrates how to perform partial updates in iOS UICollectionView using insert, delete, reload and move APIs, introduces edit paths and the Wagner–Fischer dynamic‑programming algorithm, and provides Swift code examples for calculating optimal edit steps.
This article examines the composition of Flutter iOS and Android build artifacts, then presents detailed strategies—such as removing unused components, relocating assets, and optimizing engine compilation—to significantly reduce package size, with concrete examples, code snippets, and measured results showing up to 50% shrinkage.
This article investigates why the api‑monitor library's for‑in traversal fails to enumerate certain XMLHttpRequest properties on iOS 14.5 beta and PC Chrome, explains the underlying prototype‑property interaction, and provides code examples and cross‑platform comparison results.
This article explains how an iOS/macOS application is launched, detailing the interaction between dyld and the Objective‑C runtime, the initialization steps performed by _objc_init, and the series of functions such as environ_init, static_init, map_images, read_images, and load_images that together realize classes, selectors, protocols and +load methods before main() is called.
Apple’s XNU kernel introduced the “wakeup” metric in iOS 13 to count CPU core activations from low‑power states, and because high wake‑up rates increase dynamic power consumption, developers must identify and consolidate timers, avoid frequent polling, and pause background tasks to lower the metric and extend battery life.
This article introduces JD's code coverage statistics platform, detailing its concepts, significance, implementation approaches for Android and iOS—including Jacoco and Xcode configurations—its SDKs, data collection, reporting mechanisms, and how it enhances testing quality and development efficiency.
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.
By instrumenting the full launch chain, profiling startup tasks, and applying targeted fixes such as staged task scheduling, Lottie and image caching, and reducing heavy +load logic, the Hello Travel iOS app cut its first‑screen rendering time from over one second to under one second for 90 % of users, achieving roughly a 40 % performance gain.
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.
LLDB is a high‑performance debugger integrated with Xcode that supports C, Objective‑C, and C++ development; this article introduces its command‑line syntax, explains key commands such as help, expression, thread, breakpoint, watchpoint, and image, and provides usage examples to improve debugging efficiency.
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.
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.
The article explains how to implement dynamic domain name switching in mobile apps across iOS, Android, Flutter, and H5 by using a configuration center and native network interception techniques such as NSURLProtocol, OkHttp instrumentation, texture bridging, and frontend configuration to resolve regional DNS issues and enable extended features like request statistics and custom responses.
This article details how 58 Tongcheng improved iOS app startup speed by defining launch time, building automated measurement tools, detecting slow methods via hooking, applying binary reordering with Clang sanitizers, and implementing dynamic library lazy loading, achieving significant reductions in launch latency and page faults.
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.
