The article explains Swift 5's ABI and module stability, their impact on app size and compatibility, and details a practical approach to building a Swift-based order module within an existing iOS app, including mixed Swift‑Objective‑C integration, CocoaPods configuration, and encountered challenges.
Lokie is a high‑performance iOS AOP framework written in C++14 that replaces the slow Aspect library by using libffi‑based trampolines, offering thread‑safe method interception, detailed API usage, runtime internals, and assembly‑level trampoline implementation with significant speed improvements.
NetEase News adopted Google’s gQUIC via Chromium’s Cronet library together with Nginx + Caddy, making QUIC handle over 75% of traffic and cutting average response time by about 45%, halving error rates and reducing video stutter by more than 25% within three months.
This article explains the background pain points of hard‑coded cross‑stack navigation in a mobile app, describes a dynamic routing component built on URL interception, regex matching and replacement, shows Kotlin and iOS implementations, and demonstrates real‑world cases in an app center and order module.
Explore the lineage from the 1969 birth of UNIX through the creation of Linux, the emergence of Apple's iOS, and the development of Android, highlighting key milestones, contributors, and how these systems interconnect as the foundational kernels of today’s major platforms.
The article details how the Anjuke iOS client was transformed into a platform‑shared architecture through the “Jupiter Plan”, describing background challenges, multi‑endpoint reuse, shell project separation, build‑speed optimizations, and supporting tools that together boosted development efficiency.
Youku’s player was rebuilt with a pipeline‑pattern architecture that unifies playback stages into a modular framework, enabling plug‑in customization, multi‑source support, reduced memory and startup overhead, clearer structure, and improved stability and extensibility for future business innovations.
The article describes how Youzan Mobile replaces its native, labor‑intensive message‑card system with a lightweight Weex container embedded in native MVVM tables, enabling hot‑reloaded, dynamic cards that can be added or updated without app releases, dramatically shortening development cycles and improving performance.
This guide walks through the complete iOS certificate setup, covering Apple developer registration, creation of development and distribution certificates, app ID configuration, adding test devices, and provisioning profile generation, with practical notes and code snippets for each step.
This guide walks through configuring iOS certificates, installing Fastlane, handling common installation issues, and using Fastlane or a build script to package and install an iOS app on a real device, complete with command‑line examples and troubleshooting tips.
This extensive Swift tutorial introduces the language’s fundamentals—including variables, constants, control flow, functions, closures, enums, and memory management—while providing detailed code examples and explanations of advanced concepts such as protocols, generics, and ARC, making it a complete guide for iOS and macOS developers.
This article analyzes the pain points of iOS development at Xianyu—complex environment setup, massive CocoaPods downloads, and slow branch‑switch builds—and details a hybrid Docker‑based solution plus artifact caching that reduces build time from half an hour to under five minutes.
This article explains the background, goals, and step‑by‑step methodology for refactoring a mature mobile platform app into an App Factory that supports rapid, modular development of innovative independent apps through systematic decoupling, middleware management, and automated engineering pipelines.
This tutorial walks through setting up an iOS demo project in Xcode, creating a yellow rectangle view, adding a clickable button and a centered image using Swift code, and then compares the Swift syntax with equivalent Objective‑C snippets, while also covering useful comment tags.
WYBridge provides a unified bridge layer for multiple cross‑platform containers—React Native, Flutter, Weex, and Web—standardizing API definitions, registration, parsing, and invocation across Android and iOS, while offering compatibility solutions for legacy method calls and detailing implementation specifics for each platform.
This article explains the complete live‑streaming workflow—from video/audio capture on the broadcaster side, through encoding, transmission, server processing, and playback—while comparing third‑party services with self‑built solutions and providing concrete iOS code examples using AVFoundation, LFLiveKit and GPUImage.
This article explains how the Haishen platform collects iOS crash logs, uses KSCrash to capture rich crash context, overcomes background‑session upload limitations, extracts system symbol tables from firmware, and implements a fast, JSON‑based crash‑symbolication pipeline using atos while handling symbolicatecrash bugs.
This article provides a detailed tutorial on WKWebView for iOS, covering its creation, configuration, delegate methods, custom UserAgent registration, cookie management, native‑H5 communication, JavaScript bridges, and NSURLRequest caching strategies, offering practical code examples and best‑practice tips.
This article explains the design and implementation of the Haishen crash monitoring platform for iOS, covering its system architecture, data collection, parsing, aggregation, routing, SDK features, exception handling, stack capture, startup crash detection, and upload mechanisms to quickly expose, locate, and fix crashes.
The article thoroughly examines Lottie animation technology, describing how After Effects projects are converted into JSON, parsed into Objective‑C data models such as LOTComposition and LOTLayer, and rendered on iOS/Android via Core Animation, detailing asset handling, layer hierarchy, frame interpolation, and implementation specifics.
This article explains how iOS developers can use the Objective‑C runtime to automatically convert dictionaries to model objects, add properties to existing classes via associated objects, and implement method swizzling for tasks such as analytics injection, illustrating each technique with code flow and diagrams.
This article explains the internal data structures of the Objective‑C runtime, covering objc_object, objc_class, class_data_bits_t, class_rw_t, and class_ro_t, and illustrates how these structures define objects, classes, method caches, and associated metadata in iOS development.
This article explains the design and implementation of a hybrid Flutter container for native Android and iOS apps, covering concept overview, solution comparison, container stack management, navigation handling, iOS gesture support, multi‑container strategies, routing protocols, and practical code examples.
This article explains what Key-Value Observing (KVO) is, how to use it in iOS development, and the runtime mechanisms—such as isa‑swizzling and dynamic subclass creation—that enable automatic property change notifications, while also showing how to build a custom KVO system.
This guide explains how to integrate WeChat OAuth2.0 login into Android and iOS mobile applications, covering preparation, authorization flow, API calls for access tokens and user info, phone‑number binding, re‑login handling, and test case recommendations.
This article details Trip.com’s comprehensive approach to adapting its mobile applications for Arabic users, covering cultural research, RTL design principles, mirroring rules, icon and typography handling, as well as platform‑specific technical solutions for Android, iOS, and React Native.
This article explains the RIB (Router‑Interactor‑Builder) architecture for iOS, detailing its core components, how to generate and connect them with Xcode templates, manage navigation, inject dependencies, write unit tests with mock generation, and integrate the whole structure into a root RIB for a production‑ready app.
This article explains how to embed and retrieve an invisible numeric watermark in iOS screenshots by modifying the least‑significant bit of the RGB pixel data, provides Swift code examples for encoding and decoding, discusses practical usage scenarios, and notes limitations and possible improvements.
This article explains the challenges of iOS network request debugging, reviews existing external and in‑app tools, dives into the URL loading system and URLProtocol mechanics, and presents a delegate‑proxy solution that captures all traffic without altering the original requests, even in production environments.
This article explains why Apple requires apps to use LaunchScreen.storyboard instead of static LaunchImage after June 30 2020, details the preparation steps, presents three implementation approaches, and discusses device‑specific adaptation problems and persistent black‑screen issues with code examples.
This article explains how DinamicX provides cross‑platform accessibility support for mobile apps, detailing the definitions of accessibility, the technical solutions for iOS and Android, SDK attributes, code examples, validation gates, and the broader vision of making Taobao usable for visually impaired users.
This article explains the VIPER architectural pattern for iOS development, detailing each component (View, Interactor, Presenter, Entity, Router), providing Swift protocols and default implementations, and demonstrating a complete movie‑list example with reusable table‑view components and data handling.
This article explains why adding parameter‑reading code to a variadic‑function hook causes a deterministic crash due to stack context pollution, analyzes the calling‑stack layout and register usage with ARM64 assembly, and presents a heap‑based context‑saving solution using TrampolineHook to safely intercept variadic methods on iOS.
This article explains the challenges of mixing React Native and native pages, critiques existing routing solutions, and introduces WYNavigation—a single‑engine, multi‑container framework that aligns RN navigation with native stacks, detailing its concepts, lifecycle handling, routing methods, and implementation code.
The 58 client package size detection live series reviewed two open‑source tools—Zucker for Android modular size analysis and a Mach‑O‑based performance suite for iOS—explaining their principles, implementation, and how they enable non‑intrusive monitoring and optimization of app package sizes.
This article explains how to train and deploy convolutional neural networks directly on iOS and Android devices using Core ML, NNAPI, and TensorFlow Lite, compares performance with desktop TensorFlow, and provides practical code snippets and build‑time tips for mobile AI development.
This article explains the background of on‑device AI, introduces the Mobile Machine Learning (MML) framework and its layered architecture, details the core utilities such as model decryption and task scheduling, and provides a step‑by‑step code guide for initializing, preprocessing, inference, post‑processing, and releasing resources on mobile platforms.
This article explains Apple's requirement to switch to LaunchScreen.storyboard before June 30 2020, compares LaunchImage and LaunchScreen.storyboard, details the preparation steps, presents three implementation approaches, and discusses device‑specific layout problems and cache‑related black‑screen issues with code examples.
This article introduces the Sunglasses crash investigation tool, explains iOS Objective‑C runtime message handling—including method lookup, dynamic resolution, and forwarding—details method swizzling implementation with code examples, and discusses class clusters and future enhancements for mobile development debugging.
This article details Ctrip's experience of adopting Swift for iOS development, covering the language's evolution, statistical adoption, static‑library integration, ObjC‑Swift mixed compilation, module stability with swiftinterface files, CI pipeline adjustments, and strategies for seamless ObjC‑Swift interoperation.
Flutter 1.17, the first stable release of 2020, introduces Metal support that can increase iOS rendering speed by up to 50%, reduces app size and memory usage, adds new Material components such as NavigationRail and an updated DatePicker, improves accessibility, internationalization, and provides enhanced developer tools like network profiling and fast‑start options.
This article explains how to analyze and reduce the size of iOS .ipa packages by classifying resources, using LSUnusedResources to identify unused files, isolating business‑line assets via podspec subspecs, and automating image compression with tools like ImageOptim, TinyPNG and pre‑commit Git hooks.
This article presents a complete iOS app slimming strategy that combines official App Thinning techniques, detailed build‑time optimizations, file‑type specific reductions, and a git‑hook based resource compression workflow, demonstrating a reduction from 154.7 MB to 90 MB in a real project.
With Swift 5’s stable ABI shrinking app bundles, developers can migrate Objective‑C code top‑down—starting at UI layers—to leverage Swift’s safety‑focused optionals, value‑type structs, powerful enums, functional and protocol‑oriented paradigms, while handling interoperability via @objc and dynamic, ultimately future‑proofing apps for SwiftUI, cross‑platform frameworks, and continued iOS/macOS relevance.
The guide explains how iQIYI integrates SiriKit Media Intents and Siri Suggestions on iOS 13, covering extension setup, intent handling (resolve, confirm, handle), playback response codes, shortcut donation via NSUserActivity or Intents, and best practices for media search and background UI.
Woodpecker is an open‑source iOS debugging platform that integrates UI inspection, object viewing, method monitoring, PO commands, and JSON capture into a plugin‑based architecture, enabling developers, testers, designers, and product teams to locate and resolve issues directly on the device without a computer.
This guide walks through preparing an Xcode project with CocoaPods, adding a Flutter module as a dependency, implementing the required platform router in Objective‑C, binding it in AppDelegate, and using Flutter Boost’s open and present APIs to navigate between native and Flutter pages.
iQIYI boosted its mobile app’s network request success rate to 99.7% by implementing detailed monitoring, layered retry strategies, optimized timeouts, reduced concurrency, smarter compression, IPv4 preference, TLS 1.3, and connection‑racing techniques, and now targets 99.9% using multipath, QUIC and intelligent traffic scheduling.
This article introduces the Magpie SDK, a Flutter plugin that enables hybrid page interaction, describes the engineering challenges of integrating Flutter with native Android and iOS, outlines optimization of build processes, toolchain support, communication design, and provides guidance for contribution and future roadmap.
The guide details how Gaode Map’s iOS app cut cold‑start time by over 65% to sub‑400 ms through systematic analysis of launch phases, Mach‑O loading, multi‑dimensional runtime metrics, automated static source parsing, and visual trace tooling, demonstrating a repeatable method for sustained launch‑time optimization.
This article analyses the differences between PC and mobile Internet, evaluates how major Chinese apps adapted their launch, splash and home screens to a gray‑white theme for the Qingming memorial day, and discusses various technical solutions such as theme switching, skin packages, server‑side control and local color manipulation for mobile UI dynamic theming.
DoKit 3.0, the open‑source client development assistant from Didi, introduces a revamped architecture, extensive Android and iOS enhancements, new tools such as interface mock and health testing, a web platform for product management, and detailed integration guides for both platforms.
This article explains the iOS RunLoop mechanism, its role in keeping apps responsive, how it interacts with UIApplicationMain, timers, thread management, and various RunLoop modes, and provides practical examples for using RunLoop to maintain thread life cycles and improve UI performance.
This article details Trip.com’s comprehensive Dark Theme implementation across iOS, Android, and React Native, covering design principles, color mapping, illustration adjustments, platform‑specific adaptation techniques, code examples, and tooling that together reduced development effort while enhancing user experience and brand image.
This article details the motivations, design goals, technical solutions for native iOS, React Native and Web pages, handling of large‑scale parallel development, compatibility strategies, performance measurements and future plans of the dark‑mode adaptation implemented in the 58.com mobile application.
This article explains how to replace image‑based icons in iOS apps with vector icon fonts from Alibaba's iconFont service, covering selection, download, integration of the TTF file, Swift and Objective‑C usage examples, and common pitfalls such as font conflicts and licensing.
FlutterBoost 2.0 redesigns the hybrid architecture by assigning each Flutter page its own controller and view, eliminating screenshot‑based transitions, fixing white/black screen glitches, enhancing iOS surface management and lifecycle callbacks, adding extensive documentation and tests, while acknowledging a ~10 MB per‑page memory cost mitigated through stack limits and reuse.
WBBlades is an open‑source iOS toolset that parses Mach‑O files to provide size analysis, high‑precision unused‑class detection, and crash‑log symbolization without requiring symbol tables, offering both a macOS GUI and command‑line interface for developers to optimize and debug their apps.
This article explains how JD’s dark‑mode foundation component enables iOS 9+ apps to support system and manual dark mode, detailing its architecture, integration steps, custom updaters, window‑level overrides, snapshot handling, and lessons learned for reliable night‑mode implementation.
This guide explains how to integrate WeChat OAuth2.0 login into Android and iOS mobile applications, covering preparation, the authorization code flow, token exchange, user‑info retrieval, phone‑number binding, repeated login handling, and comprehensive test cases.
This article explains what a RunLoop is, why it exists, its internal structure and modes, how it interacts with threads, and common iOS development techniques such as keeping threads alive, image loading, timer handling, and performance monitoring.
This article provides an in-depth overview of NSURLSession on iOS, covering its introduction, configuration options, task types, delegate methods, HTTP/2 support, connection reuse, request redirection, metrics analysis, file upload strategies, background uploads, download handling, breakpoint resumption, and video streaming with m3u8.
This article provides a comprehensive technical walkthrough of AFNetworking, covering its core classes, request and response serialization, task management, network activity indicator handling, reachability monitoring, and SSL pinning security policies, illustrating how the library abstracts NSURLSession for iOS developers.
This article provides a comprehensive overview of AFNetworking 3.x, covering its evolution, core components such as AFURLSessionManager, request and response serialization, task handling, session management, network activity indicator, reachability monitoring, and security policies including SSL pinning and certificate validation, with detailed code examples.
The unified online‑store product SDK consolidates Retail and Micro‑Mall modules into a reusable, Bifrost‑mediated component that accesses host‑app data via a defined interface, adopts standardized UI elements, routes through a mobile‑gateway backend, and thus eliminates duplication, streamlines maintenance, and accelerates feature delivery across Youzan’s SaaS platforms.
This article explains why UI automation testing is essential for complex mobile apps, why Appium is chosen, how to organize test cases with Cucumber, implement custom steps, locate elements using various strategies, handle common exceptions, and outlines the overall workflow and improvement suggestions.
This article explains iOS CPU architecture, why arm64 dominates iPhone hardware, compares CPU and GPU, and provides a step‑by‑step guide with Objective‑C code for implementing the QiCPUMonitor tool that tracks high‑CPU‑usage threads and records their call stacks every three seconds.
This article details the redesign of Ctrip's domestic flight booking module to a dual‑column layout and shares the React Native gesture, animation, and performance optimization techniques that raised frame rates from ~40 fps to ~59 fps while handling double the data volume.
The article clarifies frequent iOS development misconceptions—from unnecessary observer removal and deprecated NSUserDefaults synchronization to block retain‑cycle tricks, responder‑chain versus hit‑testing differences, GCD queue optimizations, safe main‑queue detection, and proper cancellation of dispatch blocks—offering practical code guidance.
The article explains how, with Swift 5.1’s ABI stability, teams can combine Swift and Objective‑C in iOS apps by preferring CocoaPods‑based modular development over bridging headers, detailing the LLVM module system, modulemap setup, namespace and linking issues, and best‑practice steps for a smooth migration.
This guide explains how to adopt Xcode’s UITesting framework for iPad applications—COOHOM, KuJiaLe Cloud Design, and Enterprise Cloud Design—detailing setup, test case creation, execution, code coverage collection, and seamless integration with GitLab CI to automate testing and reporting.
This article explains how to implement method‑execution time monitoring on iOS by hooking objc_msgSend using fishhook and custom assembly, detailing the concepts of hooks, the dyld symbol‑rebinding process, and providing complete code examples for building the QiLagMonitor tool.
This article details the design, algorithm selection, and performance optimizations behind a geospatial photo‑indexing service that aggregates and searches millions of user photos by location and time, enabling faster, more accurate travel content sharing in a mobile app.
This article explains how to monitor iOS main‑thread lag using RunLoop observers and the QiLagMonitor tool, detailing RunLoop modes, observer activities, and providing Objective‑C code for creating semaphores, observers, and a background monitoring loop that captures stack traces when the main thread stalls.
This article presents a comprehensive case study of integrating React Native into the 58 Car Dealer mobile application, covering background, module selection, communication mechanisms, UI development, server design, hot‑update workflow, packaging, debugging, pitfalls, and future optimization directions.
This article explains how to monitor iOS CPU power consumption using the QiCPUMonitor tool, covering CPU architecture basics, the implementation of QiCPUMonitor, relevant data structures, code snippets for thread inspection, and a periodic timer to capture high‑usage threads without impacting app performance.
This article explains how iOS Key-Value Observing works under the hood, enumerates common pitfalls across iOS versions, and shows how the open‑source KVOController library mitigates those issues while providing safer, block‑based observation APIs.
Facing a 24‑million‑line codebase with over 100 third‑party pods, the team tackled slow Xcode compilation, lengthy packaging, and merge‑request bottlenecks by applying build‑setting tweaks, RAM‑disk compilation, CCache, and a custom binary‑pod workflow that automates packaging, publishing, and integration without altering source projects.
This article provides a comprehensive overview of iOS push notification mechanisms, covering remote and local push differences, device token acquisition across iOS versions, silent push constraints, scheduling nuances, and the evolution of notification APIs from iOS 7 to iOS 13, with practical code examples.
This article examines a real iOS project case where a UITableView delegate method does not fire, explores Swift Intermediate Language (SIL) and thunk functions, explains the role of @objc and dynamic dispatch, and demonstrates how generic base classes affect Objective‑C visibility of delegate methods.
This article explains how to enable Xcode Canvas previews for legacy Objective‑C views by leveraging SwiftUI's PreviewProvider, detailing the required project settings, bridging‑header configuration, code examples, and troubleshooting steps for integrating preview support into large iOS codebases.
This article details how the 58 Used‑Car mobile team built, trained, and optimized TensorFlow‑based object‑detection models for on‑device vehicle and VIN code recognition, covering data preparation, model conversion to TF‑Lite, performance improvements, engineering integration on Android/iOS, and real‑world deployment results.
This article explains the various iOS app background execution states, short‑term background tasks, long‑term keep‑alive methods such as silent audio, continuous location, background downloads, and BGTaskScheduler, and provides Objective‑C code examples and configuration steps for developers.
This article explains the three main iOS timer mechanisms—NSTimer, CADisplayLink, and GCD dispatch sources—detailing their creation methods, differences, common pitfalls such as RunLoop mode and thread issues, and practical solutions for accurate scheduling.
The article investigates a sporadic iOS app startup timeout where the process is killed by the system, analyzes crash logs showing a SIGKILL (0x8badf00d) watchdog termination, traces the issue to excessive UIPasteboard calls made by OpenUDID in both main and background threads, validates the hypothesis with multi‑threaded tests, surveys SDK usage of OpenUDID, and proposes moving the identifier storage to the keychain to avoid clipboard‑induced hangs.
This article explains the principles and practical implementations of iOS security hardening techniques—including code obfuscation, anti‑debugging, signature verification, and abnormal data detection—illustrated with real‑world examples from the 58.com iOS client.
The article introduces Tencent’s open‑source Hippy cross‑platform framework, outlines its developer‑friendly features and W3C compliance, and details common debugging techniques—including Chrome DevTools‑based services, jsbundle debugging, and memory monitoring—while presenting practical troubleshooting cases for UI updates, scrolling, performance, and iOS‑specific issues.
The article delivers a detailed 117‑page, eleven‑chapter overview of Youku’s full Dark Mode implementation, explaining the motivation, battery and accessibility benefits, design methodology—including color token systems and contrast hierarchy—and the coordinated technical execution across iOS and Android platforms.
This article explains how to resolve the iPhone X bottom safe‑area blank space that appears when using height: 100% in WKWebView, providing both native iOS adjustments and a temporary front‑end CSS workaround with code examples.
The article details Youzan Retail’s precise iOS testing platform, which instruments Objective‑C code via GCC/LLVM to generate .gcno/.gcda files, processes them with LCOV, and provides both full and git‑diff‑based incremental coverage visualizations across CI, data collection, parsing, and reporting layers to improve manual and automated test quality.
This article details Youku's comprehensive journey to fully support dark mode on both iOS and Android, covering its origins, benefits such as battery savings and accessibility, design methodology, color token system, implementation tactics, and references to official platform guidelines.
This article examines current iOS modularization using CocoaPods, explains binary pod strategies to dramatically reduce build times, compares manual and automated approaches, addresses debugging challenges, and presents a practical solution that toggles between source and binary modes via environment variables and Development Pods for flexible development and fast CI builds.
CocoaPods 1.9 introduces XCFramework support, configuration‑based podspec dependencies, test‑spec code coverage, Swift version variant handling, and a static‑linkage option for use_frameworks!, providing iOS developers with enhanced dependency management and build flexibility.
Discover how a simple Sketch plugin automatically adjusts line height to match iOS defaults, eliminating pixel‑perfect discrepancies and saving designers from tedious manual tweaks.
This guide explains why energy consumption is a critical performance metric for iOS apps, introduces core concepts such as idle, active and overhead states, identifies the main power‑hungry components, and walks through Apple’s profiling tools—Energy Impact, Energy Log, Sysdiagnose and MetricsKit—plus concrete optimization techniques for network, location, CPU, GPU and notifications.
This article introduces NJCS, a lightweight dynamic deployment framework for iOS that enables rapid feature updates without App Store re‑approval, explains its background, integration steps, page creation, navigation APIs, UI component usage, notification handling, and provides practical code examples for developers.
This article details a comprehensive set of practical techniques—ranging from Xcode project configuration tweaks and CocoaPods packaging to CCache, distcc, hardware tricks, PCH usage, and deep Clang/LLVM analysis—that together reduced a massive iOS build from over 27 minutes to under 10 minutes.
This article explains the iOS app signing process, covering symmetric encryption, public‑key cryptography, hybrid cryptosystems, digital signatures, certificates, and how Apple verifies app packages during distribution and on‑device installation, providing both beginner and advanced insights.
This article explores how Objective‑C objects are converted to low‑level C/C++ structures, compares the results of class_getInstanceSize, malloc_size and sizeof, and explains memory‑alignment rules, member ordering, padding, and inheritance effects on the actual memory footprint of iOS objects.
This article explains how to bypass the costly GPU‑CPU‑GPU copy when using Flutter external textures by leveraging CVPixelBuffer's shared memory mechanism, detailing the underlying engine changes, registration and rendering steps, code implementation, and a demo that achieves smooth 60 FPS rendering.
