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.
SwiftUI Hooks is an open‑source library that adapts React Hooks concepts for SwiftUI, providing state‑and‑lifecycle hooks such as useState, useEffect, useMemo, and custom hooks, along with usage rules, testing utilities, context handling, and installation instructions for iOS development.
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.
This article explains the inner workings of #import, precompiled headers (PCH), header maps (hmap), Clang modules, and Swift‑Objective‑C interop, showing how they affect compilation speed, robustness, and scalability in large iOS projects and offering practical optimization techniques.
The article presents Meituan’s cocoapods‑hmap‑prebuilt plugin, which creates per‑pod and shared header‑map files to replace CocoaPods’ default header search paths, eliminates duplicate headers and disables Xcode’s native map, delivering over 45 % faster builds and more than 50 % shorter packaging times in large iOS projects.
After a decade of growth, the iOS app with millions of lines and dozens of third‑party SDKs was re‑architected by converting selected static libraries into dynamic frameworks, employing lazy loading and dependency analysis to reduce download size and improve launch time, while addressing build and compatibility challenges.
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 describes how the iOS team reduced build times by binaryizing nearly 100 CocoaPods components, detailing macro handling, packaging with cocoapods‑packager, storage strategies, dependency switching mechanisms, and CI integration to streamline development and deployment.
This guide walks you through the product design, architecture, and five‑step implementation process for creating a native Clubhouse‑style voice chat app using NetEase G2 audio‑video SDK, covering client components, gateway, server, core workflows, technical challenges, and code examples for iOS and Android.
This article details JD's journey from Objective‑C to Swift, explaining ABI stability, module stability, library evolution, and step‑by‑step configurations for mixed Swift‑Objective‑C compilation at both project and component levels, including build‑setting tweaks and runtime loading solutions.
The article examines why adding Flutter to an iOS app inflates the binary, breaks down the framework’s largest parts—engine, AOT snapshot, assets, and ICU data—and details a three‑pronged strategy of compression, externalization and stripping, using custom build scripts to move or delete files and dynamically load data, achieving roughly a 12 MB size reduction.
This article explains the principles of virtual memory and paging, demonstrates how page faults affect iOS app launch time, and provides a step‑by‑step guide to using clang static instrumentation and Xcode order files to reorder binary symbols, reduce page faults, and achieve measurable startup speed improvements.
This article analyzes a crash caused by NSInvocation argument out‑of‑bounds on iOS 13.3+, explains the underlying runtime changes, demonstrates how to reproduce the issue with a timer‑triggered message forwarding scenario, and provides a fix by correcting the method signature.
This article details JD's transition to Swift mixed compilation, covering ABI stability, module stability, library evolution, the required Xcode configurations, bridging techniques for Swift‑ObjC interaction, component‑level mixing approaches, and solutions to static and dynamic linking issues across iOS versions.
By combining WKURLSchemeHandler with injected JavaScript that captures request bodies, forwards them via WKScriptMessageHandler, and synchronizes cookies and redirects, this approach overcomes iOS WKWebView’s native limitations, offering a stable, per‑webview interception method superior to NSURLProtocol for offline‑package loading.
Brad J. Cox, co‑creator of Objective‑C and a pioneer in software reuse, passed away in 2021, leaving behind a rich personal history, influential publications, and a programming language that shaped Apple's ecosystem before gradually yielding to Swift.
To prevent iOS OOM kills in Gaode Map, developers analyzed Jetsam‑driven physical‑footprint data, identified IOKit, WebKit Malloc, and malloc‑heap as primary consumers, applied graphics texture trimming, shared JavaScriptCore contexts, hooked allocation APIs, and implemented adaptive resource management, achieving roughly 50 % memory reduction and lower crash rates.
This tutorial walks you through using the Charles proxy to intercept and analyze mobile app network traffic, covering installation, SSL configuration, certificate setup on both computer and device, and a practical test with a popular app, ensuring you can reliably capture app data.
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.
To address the growing build times of the Fire Shopkeeper iOS client caused by nearly 100 components, the team implemented component binaryization using custom CocoaPods plugins, static‑framework packaging, binary storage, and CI integration, dramatically cutting compile duration from forty minutes to around twelve minutes.
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 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 explains the design and implementation of a flexible, high‑performance bullet‑comment (danmaku) system for long‑form video on iOS, covering canvas rendering, track management, polling, view reuse, animation control, gradient effects, data handling, and integration with ads and user interactions.
This tutorial walks through using Python's Kivy framework and the Buildozer tool to create, test, and package a cross‑platform mobile app, covering environment setup on macOS, Linux, and CentOS, sample code, build commands, and common troubleshooting tips.
Optimizing app launch on iOS and Android—through deep‑link handling, H5 splash strategies, On‑Demand Resources, custom WKWebView schemes, reduced download size, static and runtime .so loading flags, thread‑pool tuning, method swizzling, actor‑based concurrency, and using Instruments, MetricKit and Android Profiler—prevents user abandonment and boosts conversion.
This article explains the background, advantages, implementation details, and crash analysis of using SwiftMonkey and XCUITest for lightweight, automated iOS Monkey testing, providing code examples and outlining pending improvements for a more robust testing pipeline.
This article introduces a curated list of open‑source iOS and Android projects on GitHub that faithfully clone popular applications such as WeChat, YouTube, NetEase Cloud Music, Bilibili, and Weibo, providing links, screenshots, and brief descriptions for developers seeking practical learning resources.
This article presents a complete, pod‑free solution for improving UITableView performance on iOS by moving heavy text rendering and image loading to background threads, deduplicating tasks, managing concurrent queues, and caching results, ultimately keeping the UI consistently at 60 fps.
The article explains why lowering the frame rate of iOS animations can trade a slight loss in visual smoothness for significant GPU load reduction, describes the Core Animation rendering pipeline, compares different frame‑rate reduction techniques, and presents test results showing the impact on CPU, GPU, and overall app performance.
This article explains how Objective‑C objects are deallocated in both manual reference counting (MRC) and Automatic Reference Counting (ARC), outlines common pitfalls such as using __weak in dealloc, and details the runtime flow from _objc_rootDealloc to the final memory free operation.
This article details Youku's comprehensive accessibility overhaul for its mobile client, describing collaboration with blind‑testing experts, deep technical adaptations across Android, iOS, Weex, Flutter and H5, and specific UI improvements that enable visually‑impaired users to navigate and enjoy video content independently.
This article explains the principles of static and dynamic linking on iOS, details how symbol tables, relocation entries, and GOT/PLT work, and demonstrates a practical static‑library hooking technique using relocation tables and the fishhook library.
This article provides a comprehensive overview of CocoaPods' Podspec file, explaining its purpose, supported formats, core data structures, attribute handling, subspec hierarchy, dependency validation, and practical steps for creating, linting, and publishing pods, with detailed Ruby code examples and best‑practice recommendations for iOS/macOS projects.
This article explains how CocoaPods Core manages Spec repositories, including the structure and initialization of Source, Metadata handling, shard-based indexing, version resolution, CDN migration, and the mechanisms for updating and searching PodSpecs across Git and CDN sources.
This guide explains how to set up and use static analysis tools SwiftLint, Infer, and OCLint for iOS projects, covering installation methods, Xcode integration, custom configuration, report generation, and a comparative overview to help choose the right solution.
The article walks through the complete workflow for building a Flutter plugin—using native_image_view as an example—including platform channel communication, Dart and native (iOS/Android) implementation, testing via an example app, and publishing to public or private Pub repositories.
This article explains how to use LLVM and SanitizerCoverage to insert BasicBlock‑level instrumentation into iOS binaries such as the WeChat SDK, covering the theory of code‑coverage metrics, compilation steps, bitcode extraction, and a practical demo that visualizes runtime execution paths.
This article explains essential iOS layout principles for internationalization, demonstrates Xcode’s preview and debugging tools, shows how to adapt interfaces for right‑to‑left languages, and provides code examples for dynamic type and automatic stack view orientation to ensure a seamless multilingual user experience.
This article explains how iOS obtains the night‑mode launch image by analyzing the naming pattern of cached images, inspecting the SQLite‑based applicationState.db file, extracting the XBApplicationSnapshotManifest entry, and reconstructing the actual image path using system‑level data structures.
This article explains how DevOps principles are adapted for mobile app delivery, detailing the unique challenges of fragmented build environments, device diversity, longer release cycles, and massive scale, and describes Alibaba Cloud’s EMAS Mobile DevOps solution, its architecture, security, scalability, and future roadmap.
This article explains the fundamentals of Aspect‑Oriented Programming on iOS, compares major AOP techniques such as Method Swizzle, Aspects, MPSwizzler, ISA‑swizzle KVO, Fishhook, Thunk and Clang instrumentation, and provides practical code examples and best‑practice guidelines.
This article explores the intricacies of Grand Central Dispatch on iOS, debunking common misconceptions about main thread and main queue execution, analyzing the internal handling of synchronous tasks, and demonstrating how run‑loop activation influences queue‑thread relationships through a series of code experiments.
The session introduces a high‑availability log retrieval platform that tackles mobile debugging challenges—device fragmentation, unstable networks, and delayed logs—by automating command dispatch, client uploads, and notifications, employing a four‑role architecture with real‑time push, fallback mechanisms, and SDKs for logging and retrieval, while planning broader app support, multi‑user tasks, and richer log types.
iQIYI Knowledge implemented a three‑layer componentization architecture—base, functional, and business components—combined with protocol‑based service registration, URL routing, and an automated build pipeline, enabling cross‑platform code reuse, independent testing, and faster integration while reducing coupling and maintenance overhead.
This article introduces JDTuple, an Objective‑C tuple library that uses variadic functions, type encodings, and macro tricks to pack arbitrary values, provide key‑based and sequential unpacking, and simplify multi‑parameter passing and return values in iOS development.
By implementing bundle splitting to shrink the initial JavaScript payload and pre‑heating the React Native container during idle periods, the team cut the mall page bundle from 1.1 MB to 856 KB and reduced iOS launch time from roughly 450 ms to 200 ms and Android from about 4.5 s to 2.5 s, achieving significant cross‑platform speed gains validated through A/B testing.
This article explains how to write and integrate ARM64 inline assembly in iOS applications to implement anti‑debugging checks, discusses the syntax, constraints, calling conventions, common pitfalls, and provides complete assembly‑only solutions for secure runtime detection.
The team accelerated the QMusic live‑streaming SDK by converting large source modules and external pods into pre‑compiled binaries, tuning Xcode build settings, and automating CI caching, slashing full‑build times from roughly 400 seconds to 40 seconds and packaging duration from over 50 minutes to three minutes.
This article details the design and deployment of JD Mall's mobile app stutter monitoring system, introducing the stutter rate metric, describing data collection, analysis, and reporting modules, presenting iOS and Android implementation code, and summarizing the performance improvements achieved across the platform.
This article explains how to use iOS dynamic frameworks to modularize app features, enable on‑demand plugin loading and seamless runtime updates, detailing the design of SVPCore, SVPRuntime, bundle management, and integration steps with code examples.
This article explains how to create an iOS 14 home‑screen Widget for the Hema Town mini‑game, covering design goals, platform restrictions, authentication handling, data timeline updates, SwiftUI UI implementation, bundle splitting, Swift bridging, analytics, review pitfalls, and post‑release considerations.
Meituan Ride‑hailing replaced its slow JavaScript map with a two‑layer Fusion Framework that places a full‑screen native Tencent map beneath a transparent WebView, uses hot‑region data to dispatch touches to the appropriate layer, and synchronizes UI via a Vue directive and JSBridge, dramatically speeding load times and delivering smoother map interactions.
This article provides a comprehensive overview of Apple’s Combine framework—explaining its core concepts such as publishers, subscribers, subjects, operators, and lifecycle management—while demonstrating custom implementations, MVVM integration, and performance comparisons with RxSwift through detailed code examples.
This article provides a comprehensive tutorial on developing iOS 14 WidgetKit widgets, covering widget sizes, Xcode target creation, configuration options, essential SwiftUI components, timeline refresh mechanisms, communication between the main app and widget via App Groups and Keychain, as well as troubleshooting common issues.
The article explains what a SIM card PIN (personal identification number) is, why it is essential for protecting personal data after a phone is stolen, and provides step‑by‑step instructions for enabling and configuring the PIN on both iOS and Android devices.
This article explains the Tagged Pointer mechanism introduced in iOS 64‑bit environments, detailing how it reduces memory usage, speeds up object creation and method dispatch, and describing the underlying tag‑plus‑data representation, class registration, and pointer generation with code examples.
This article explains the purpose, mechanisms, and implementation details of deep linking mobile apps using custom URL schemes and Universal Links, covering success detection, fallback strategies, and practical code examples for both Android and iOS platforms.
This article reviews October's key tech updates, covering NPM v7's new workspace and peer‑dependency features, Chrome's rollout of HTTP/3 over QUIC, Webpack 5's Module Federation for JavaScript architecture, the physics behind iOS UIScrollView animations, Chinese web‑font handling, the lightweight SVGA animation format, and a 1 KB JavaScript 3D game demo.
This article examines the YYCache iOS library, covering its multi‑level architecture, LRU implementation, thread‑safe APIs, eviction policies, lock choices, disk‑storage strategies, Swift integration, performance benchmarks, and practical takeaways for building high‑performance mobile caches.
The article describes how 58.com evolved from a single‑team iOS app to a multi‑team, multi‑app architecture, introduces the App Factory concept with entry projects and pod pools, defines dependency rules, and presents tooling for dependency analysis, pollution detection, and incremental compilation to enable vertical business migration and rapid innovation.
Youku’s iOS app implements a unified responsive‑layout SDK that detects device size, orientation, and split‑screen states, automatically recalculates column counts and component widths, and adapts data, enabling a single codebase to support iPhone, iPad portrait, landscape, floating windows, and split‑screen modes.
This article presents a curated collection of open‑source iOS and Android clones of popular apps—WeChat, YouTube, NetEase Cloud Music, Bilibili, and Weibo—providing GitHub links, screenshots, and brief insights on how replicating these projects can sharpen development skills and reinforce learning.
This article presents a comprehensive method for automating the build and deployment of iOS applications to the Apple App Store, detailing the manual challenges, required certificates and provisioning profiles, and two practical solutions—using ExportOptions.plist and Fastlane—to achieve fully automated push and reduce manual effort.
This article explains how Youku’s iOS app achieves a single‑code responsive layout that adapts to iPhone, iPad portrait, iPad landscape, floating window, and split‑screen modes by using a custom SDK for state management, layout rules, and data processing, dramatically reducing development and maintenance effort.
This guide explains the complete iOS push notification workflow—from creating APNs certificates and enabling Xcode capabilities, to requesting user permission, implementing both local and remote notifications with the UserNotifications framework, debugging tools, and handling received messages across app states.
ZanWeexModuleSDK provides a unified solution for native-Weex interaction across Youzan apps, consolidating common modules like network, routing, config, logging, notifications, tracking, and account, allowing developers to focus on Weex code while handling custom logic via a manager and standardized callbacks.
This article presents a curated collection of open‑source GitHub projects that faithfully replicate major mobile applications—including WeChat, YouTube, NetEase Cloud Music, Bilibili, and Weibo—providing both iOS and Android versions, repository links, and screenshots to help developers practice and learn from real‑world codebases.
This article describes the purpose, design choices, instrumentation technique, data collection, reporting, merging strategies, platform features, and future plans of a custom code‑coverage system built for the Android and iOS versions of the Zhuanzhuan app, highlighting challenges such as accurate instrumentation, performance impact, and multi‑tag data aggregation.
The article explains UIButton’s built‑in UIControlState bitmask, shows how to set titles and colors for normal, highlighted, disabled and selected states, demonstrates combining states, and details creating custom application‑specific states (e.g., follow, mutual, loading) by extending the state enum and overriding state‑related methods.
Alibaba’s Youku team outlines a responsive design framework that uses a single codebase and dedicated SDKs to dynamically adapt Android and iOS app layouts across diverse screen sizes, detailing architecture, data handling, loading processes, and implementation strategies that reduce development effort and maintenance costs for multi‑device deployments.
In SwiftUI, this article explains the @State and @Binding property wrappers, demonstrates their usage with concrete Swift code, explores why @State works only with value types, shows internal implementation details, and clarifies mutable versus immutable behavior within view structs.
This article presents a detailed comparison between Swift and Objective‑C, covering language popularity, community activity, real‑world app adoption, performance benchmarks, Swift's advantages and disadvantages, ABI and module stability, Apple’s strategic support, binary size effects, and deep compiler optimizations such as SIL, inlining, generic specialization, and dispatch mechanisms.
Discover a curated collection of high-fidelity open-source clones of popular apps—including WeChat, YouTube, NetEase Cloud Music, Bilibili, and Weibo—available on GitHub for both iOS and Android, complete with repository links and screenshots to help developers practice and enhance their mobile development skills.
This article explains why iOS launch images often fail to update, reveals that the system caches multiple storyboard‑generated images in the app sandbox, and provides a step‑by‑step method to replace those cached files with custom‑generated ones, including code, orientation handling, and support for older iOS versions.
This article outlines the preparation, framework redesign, and common challenges of integrating Swift into an existing Objective‑C iOS client, covering ABI stability, mixed compilation, module configuration, code standards, and future migration plans.
A humorous Zhihu dialogue illustrates how iOS and Android manage RAM and background processes differently, explaining why iOS often feels smoother despite having less memory, by personifying apps like WeChat, Alipay, and Taobao, the answer highlights iOS's stricter resource control versus Android's more generous allocation.
The Meituan Waimai team tackled Flutter’s excessive binary growth by splitting engine, assets, and data into downloadable modules, implementing custom build flags and runtime loaders for iOS and Android, achieving up to 95 % APK size reduction and over 30 % IPA shrinkage while shifting payload to on‑demand delivery.
To prevent crashes, forced‑out‑of‑memory terminations, and battery drain in image‑heavy iOS apps, developers should avoid retaining unused UIImages, use efficient scaling with UIGraphicsImageRenderer, employ autorelease pools, stream thumbnails via ImageIO, and downsample to view size, cutting peak memory usage from ~600 MB to ~221 MB.
This article explains how iOS keyboards achieve undo and redo functionality by combining the Command and Observer design patterns, illustrates their class structures, and shows how the NSUndoManager leverages these patterns to manage undo and redo stacks in Cocoa Touch applications.
The article details how to collect iOS crash logs, explains their structure, demonstrates symbolication using the atos and symbolicatecrash tools, and describes Youzan’s end‑to‑end solution that manages dSYM files, automates symbolication via a build‑machine workflow, and addresses storage and automation challenges.
This article provides a comprehensive guide to creating iOS 14 App Clips, covering usage scenarios, SwiftUI and UIKit implementation, URL handling, Apple Connect configuration, binary download behavior, data sharing, permission management, code differences, testing, and submission considerations for mobile developers.
This article explains how Baidu App leverages a VDSR‑based deep‑learning model and a series of mobile‑side optimizations to deliver real‑time image and video super‑resolution on iOS and Android devices, detailing the technical challenges, performance gains, and integration steps.
This tutorial explains how to model, generate, and render Bézier curves on iOS using UIBezierPath, CALayer, CAShapeLayer, and CAGradientLayer, compares quadratic and cubic approaches with Catmull‑Rom interpolation, and provides complete code samples for creating dynamic, animated graphics.
Xianyu tackles Flutter’s slow hybrid compilation and native‑module integration pain by introducing a minimal‑shell modular architecture and a two‑phone cross‑process setup that falls back from MethodChannel to socket communication, speeding builds, isolating components, and improving data consistency while adding maintenance and device constraints.
This article describes how Ctrip's iOS team reduced build times from nearly an hour to minutes by modularizing the codebase into bundles, applying incremental compilation with CCache, optimizing header search paths, and introducing a centralized cache for faster bundle retrieval.
This article explains the inner workings of GrowingIO's iOS data‑collection SDK, outlines a focused testing strategy on no‑beacon events, guides the selection of the KIF automation framework, and details step‑by‑step setup, test case implementation, coverage reporting, and CI integration for reliable SDK validation.
