This article explains how to implement dual‑camera capture on iOS 13+ using AVCaptureMultiCamSession, covering device limits, session configuration, code examples for camera setup, resolution adjustment, audio handling, system‑pressure monitoring, and performance tips for outdoor live streaming.
This article examines why easing curves matter for user experience, derives them from physical formulas, presents common easing functions with full source code, analyses Apple ScrollView dynamics using MATLAB curve fitting, and demonstrates how to recreate app animations through linear interpolation and practical tooling.
This article compares iOS and Android virtual‑goods purchase rules, explains the 30% Apple commission, and outlines two pricing design options—shifting the fee to users or absorbing it yourself—while warning about cross‑platform balance incompatibility.
This article details a step‑by‑step case study of adapting dark mode for the FangDuoDuo iOS app, covering why it matters, common misconceptions, color‑palette redesign, mapping tables, component adjustments, asset handling, and final verification to ensure a seamless user experience.
This article describes how 58.com analyzes the code and resource size of each business component in its iOS app by parsing linkmap files and static libraries, builds version‑wise statistics, and compares component volume changes across releases to support efficient parallel development and app slimming.
This article explains the need for rapid iOS feature updates without re‑submission, defines dynamic feature deployment, compares existing solutions, and details the design, architecture, code examples, and security controls of the NJCS lightweight Objective‑C runtime‑based dynamic deployment framework.
The NetEase Media Advertising SDK was refactored to meet source‑code and static‑library integration needs by splitting into Core and Demo modules, converting Core into a Development Pod, centralizing build settings in xcconfig files, and adding CocoaPods post‑install hooks that automate header copying and configuration, enabling seamless use across the News client and other products.
Flutter‑boot is an open‑source CLI that streamlines hybrid Flutter module development by providing a standardized project layout and automated commands—create, link, remotelink, and update—to integrate Flutter into existing iOS/Android apps, enable local and cloud builds, and cut setup to a single command and two lines of code.
This article analyzes why iOS apps experience long cold‑start times, explains the pre‑main and main launch phases, shows how to measure each stage using DYLD statistics and timestamp code, and provides concrete optimization strategies to reduce startup latency.
This article examines the challenges of iOS centralized building, introduces two build methods—single‑certificate single‑profile and single‑certificate dual‑profile—detailing required commands, certificate management, provisioning profiles, and automation steps to achieve fully automated, reproducible iOS app packaging.
This guide explains how to capture HTTPS traffic from an iOS app with Fiddler, configure the device proxy and certificates, and then recreate the login and query requests in JMeter to build automated API test cases, including token extraction and response validation.
Lens is an integrated iOS debugging toolkit that adds a floating window with plug‑in modules—such as view inspection, real‑time network error alerts, simulated memory warnings, DNS spoofing, FPS monitoring, measurement tools, and configurable switches—to streamline development, testing, design, and product management, boosting team efficiency and reducing production incidents.
This article explains SwiftUI's declarative UI approach by introducing Swift 5.1 language features such as Opaque Result Types, Property Delegates, and Function Builders, illustrating their implementation with code examples, and discussing component composition, data flow, preview capabilities, and future prospects for mobile development.
This article examines the current Flutter build workflow, identifies manual intervention points, and proposes automation strategies—including command‑line parameters, flavor configurations, and IOSDeploy options—to streamline Android and iOS development while weighing effort against maintainability.
This article explores Apple's libMainThreadChecker.dylib implementation, details its environment variables and swizzling logic, demonstrates how to replicate its functionality by enumerating UIKit classes and hooking methods, and discusses pitfalls of full‑method hooking and a bridge‑based solution for reliable runtime monitoring.
To meet strict quality goals for iOS projects, the article describes adopting intermediate‑file code‑coverage instrumentation, generating gcno/gcda files, using lcov for full and incremental analysis, and integrating the process into builds and CI to enforce coverage thresholds and guide test‑case design.
This article explains how to enable Flutter pages to receive touch events and coexist with an iOS full‑screen right‑swipe back gesture by introducing a custom ProxyGestureRecognizer that competes with native recognizers and maps Flutter's internal gesture state to UIKit.
This article explains why modern iOS apps need modular dependency analysis, compares common approaches such as CocoaPods, header scanning, and symbol tools, and then details a source‑level LLVM‑based solution that uses Clang plugins to generate precise method‑level dependency metadata for each bundle.
By generating an order file that places frequently executed code contiguously, the authors reduce iOS app cold‑launch page faults by about 15%, achieving roughly a 10% launch‑time improvement without code changes, using runtime hooking and static analysis to build the symbol ordering.
This article explains how MaFengWo’s iOS app implements a flexible video editing framework that supports custom editing and template‑based creation, detailing the requirement analysis, architecture design, AVFoundation‑based implementation, performance optimizations, and future directions for short‑video content.
This guide walks you through configuring Xcode and writing code so that Swift can call Objective‑C and vice‑versa, covering bridging headers, generated Swift headers, and integrating a Swift framework into an Objective‑C host app.
Meituan’s iOS team introduced the CocoaPods sub‑command zsource, which extracts source‑file paths embedded in binary components’ DWARF data and automatically fetches the corresponding code, letting developers instantly replace a binary with its source for fast, source‑level debugging without rebuilding the whole project.
This article explains how the Matrix team created a low‑overhead iOS/macOS energy‑consumption monitor that captures high‑CPU thread stacks, builds aggregated power‑consume stacks, and helps pinpoint heating scenarios such as image uploads, VoIP calls, and game usage.
The article explains how the Youzan iOS retail client implements a robust offline‑mode switching system that detects network or service faults—via Reachability, RealReachability, and a QoS‑based error pipeline—allows manual or automatic activation, manages state with a finite‑state machine, and prepares for future data‑sync handling.
This article introduces Fastmonkey, an open‑source iOS Monkey testing tool, outlines its key advantages, provides step‑by‑step environment setup, explains bundle‑id and runtime configuration, details optional and custom actions, and describes how to execute tests and view logs.
This guide explains why Google’s 64‑bit requirement forces a React Native upgrade, outlines the benefits of moving to version 0.59.10, and provides step‑by‑step instructions for updating iOS, Android, Babel configuration, native modules, and handling deprecated components and API changes.
The article presents YouZan’s hybrid integration strategy that packages each Flutter feature as an independent artifact—AAR files for Android and frameworks for iOS—allowing native teams to embed Flutter modules via simple scripts and Maven uploads without needing a full Flutter development environment.
This comprehensive guide explains what Flutter plugins are, why they are essential, the MethodChannel communication model, step‑by‑step plugin creation, common pitfalls, testing strategies, publishing to public or private repositories, and a real‑world case study of a routing plugin, providing all the code and configuration details developers need to build and distribute their own Flutter plugins.
This article details the background, challenges, and step‑by‑step solution for standardizing UI across Youzan Retail’s iOS and Android apps, covering designer and developer perspectives, the creation of a shared style library, component architecture, resource management, delivery outcomes, pitfalls, and future automation plans.
Xianyu integrated accessibility directly into its Flutter‑Native hybrid app, establishing a systematic workflow—from design to monitoring—that makes all interactive elements focusable, described, and properly ordered, enabling over 40 000 visually impaired users to navigate the marketplace with an 87.5% issue‑fix rate.
The article details how the Youzan Mobile Assistant adds a local packet‑capture module that leverages Android VpnService/iOS NetworkExtension and tun2socks to route traffic through a SOCKS5 proxy, then uses Socket.IO to push request and response data in real time to the app’s UI while keeping the app alive in the background.
Facing massive codebases, hundreds of developers, and rapid release cycles, Baidu App adopted a multi‑stage componentization strategy—spanning compile isolation, library standardization, runtime distribution, service layers, and degradation control—to improve parallel development, reduce complexity, and boost build speed and quality.
This article introduces 360’s iOS mobile performance monitoring solution, QDAS‑APM, detailing its background, monitored metrics such as page rendering time, main‑thread stalls, network errors, FPS, CPU, memory, crash and startup duration, and explains implementation techniques using KVO, runtime class traversal, and code snippets.
This article explains what CocoaPods is, its evolution, core components, and provides detailed step‑by‑step instructions for installing, uninstalling, and managing multiple versions using tools like Homebrew, RVM with gemsets, and Bundler, helping iOS developers maintain consistent development environments.
This article explains how a simple macOS application was built to generate iOS app icons and launch images of various sizes, describing its UI layout, resource‑plist configuration, and the Objective‑C code that handles path selection, image processing, and export logic.
This article explains how to create a flexible paginated interface in iOS using the custom QiPageMenuView and QiPageContentView components, covering implementation analysis, key properties, code examples, and two usage patterns that enable decoupled menu and content views for seamless scrolling and navigation.
This article examines the motivations, design patterns, and practical implementations of componentized architectures in iOS development, comparing MGJRouter, Protocol‑based routing, and CTMediator solutions, and provides guidelines for integration, memory management, and dynamic configuration in large‑scale mobile applications.
This article provides a comprehensive step‑by‑step guide for integrating Flutter into iOS projects, covering required configuration files, script usage, AppDelegate modifications, MethodChannel communication, common pitfalls, debugging tools, performance monitoring, and routing strategies for both static and dynamic navigation.
This article explains how iOS developers can improve multithreaded performance by understanding the readers‑writers problem, using GCD barrier APIs or pthread_rwlock_t, and applying proper lock granularity and recursive locks to achieve safe and efficient concurrent reads and writes.
This article explains the evolution and advantages of video SDKs, details the core playback pipeline—including decoding, rendering, and audio‑video synchronization—covers cross‑platform implementation on Android, iOS and PC, and shares practical testing experiences and performance‑optimization techniques.
The article details the background, design goals, layered architecture, message flow, UI customization mechanisms, and key class structures of the 58 Group's cross‑platform IM SDK, illustrating how it supports iOS, Android, Web, and H5 with extensible C++ and UIKit components.
This article explains how iOS developers can retrieve crash logs from simulators, test devices, and App Store releases, then use LLDB and custom crashlog scripts to symbolicate, inspect stack traces, and resolve hard‑to‑reproduce crashes caused by memory‑management issues such as over‑release.
Facing iOS App Store review delays, the article explores a lightweight approach that combines native iOS UI with JavaScript via JavaScriptCore, detailing JSContext and JSValue usage, code examples for UI components, and the conversion process that enables dynamic, low‑overhead UI updates without heavy frameworks.
This article explains common H5‑to‑native app interaction patterns, detailing basic interfaces, one‑way and two‑way calls, implementation approaches, and the considerations for whether the H5 or the native side leads the integration, with code examples for Android and iOS.
The iQIYI testing team created a high‑stability, low‑latency iOS remote‑control platform by extending WebDriverAgent with native gesture and screenshot APIs, deploying a Mac‑mini‑based device pool for parallel testing, and adding AI‑driven UI anomaly detection, performance logging, and crash‑monitoring services to enable scalable automated and Monkey testing.
This article explains how the MaFengWo iOS app defined startup, measured key metrics such as launch duration and loss rate, and applied technical and user‑centered optimizations—including pre‑main and post‑main tweaks, fine‑grained interaction strategies, ad caching, and platform mechanisms—to cut launch time by half, lower loss rate by 30% and dramatically increase ad exposure.
This article explains how JD Daojia tackled heavy visual elements in its shopping app by redesigning UI components as asynchronous render nodes, reducing main‑thread work and GPU load, resulting in smoother scrolling up to 60 FPS even on older iPhones.
This article describes the research, design, and implementation of an iOS remote‑control system—including technology selection, architecture with WebSocket and WebDriverAgent, performance optimizations for screenshot and event handling, and future improvement plans—aimed at providing smooth, low‑latency device access through a browser.
This article explains what cookies and sessions are, their types and attributes, demonstrates how they control language preferences on a website, and provides practical iOS examples using NSHTTPCookie, AFNetworking, and NSURLSession to send and manage cookies in network requests.
This article introduces the most commonly used LLDB commands for iOS development, covering command syntax, help utilities, expression evaluation, printing, thread management, breakpoints, and watchpoints, and provides practical code examples to improve debugging efficiency in Xcode.
This article explains how iOS developers can use Xcode's breakpoint features—including basic toggles, conditional breakpoints, ignore counts, actions like LLDB commands and log messages, exception breakpoints, and symbolic breakpoints—to pause execution, inspect state, and streamline debugging workflows.
This article explains how Xcode’s static analysis feature can automatically identify common iOS development problems—including localization warnings, logical errors, memory leaks, dead stores, and syntax mistakes—by analyzing code without execution, and shows how to resolve each type of issue.
DoraemonKit is a comprehensive mobile debugging toolkit for iOS and Android, offering built‑in tools for app information, sandbox browsing, mock GPS, crash viewing, performance monitoring (FPS, CPU, memory, network), visual inspection, and easy integration via CocoaPods or Gradle, plus extensibility for custom modules.
MTHawkeye is Meitu’s iOS debugging and performance‑optimization toolkit that provides a three‑layer architecture—foundation, UI foundation, and plugin layers—to assist developers across development, testing, and production by offering memory leak detection, main‑thread profiling, CPU, network, graphics, storage monitoring, and integrated FLEX utilities.
This article explains how iOS developers can create, configure, and use Xcode breakpoints—including basic, conditional, ignore, action, options, exception, and symbolic breakpoints—to pause execution, inspect state, and streamline debugging with detailed examples and screenshots.
This article introduces the Facebook‑provided WebDriverAgent server for iOS, explains how to install and configure the lightweight python library facebook‑wda, demonstrates core API calls for device control and UI interaction, and shows how to extend the library with custom endpoints for advanced automation tasks.
This article explains how Xcode’s static analysis feature can automatically identify text localization problems, logic errors, memory management concerns, dead‑store data issues, and syntax mistakes in iOS projects, and provides step‑by‑step instructions and code examples for fixing each type of warning.
iOS developers should learn Android to broaden their skill set, grasp the component‑centric design philosophy and core elements like Activities, Services, Intents and Manifest files, and stay competitive in the big‑front‑end era where cross‑platform frameworks demand fluency in both iOS and Android ecosystems.
Matrix for iOS/macOS is an open‑source performance probing tool from the WeChat team that monitors crashes, jank, and memory issues on iOS and macOS, offering plugins for detailed stack capture and out‑of‑memory reporting, with future plans for power‑consumption tracking and cloud integration.
To combat Foreground Out‑Of‑Memory (FOOM) crashes in iOS, we describe the evolution from a simple FBAllocationTracker‑based logger to a high‑performance monitoring system that collects, stores, compresses, reports, and visualizes allocation data using custom hooks, splay trees, hash‑based stack compression, and selective reporting.
This article explains how WeChat’s iOS team built a run‑loop based lag‑monitoring system, describes the causes of main‑thread blockage, the annealing algorithm, time‑consuming stack extraction, crash‑lag detection, and presents performance data showing only a few percent overhead.
This practical guide walks iOS developers through integrating Siri Shortcuts—from understanding the feature and handling bugs like the custom intent UI issue, to implementing Add‑to‑Siri buttons, watch‑face support, forced donations, intent versus NSUserActivity choices, and essential localization, enabling voice‑driven interactions on iOS 12 and later.
This article presents the background, requirements, and technical solution of a mobile log retrieval component that ensures secure, complete, and efficient log collection, storage, and on‑demand retrieval for iOS and Android applications, including design details such as mmap‑based writing, stream compression, multi‑process handling, and a management platform.
This tutorial explains how to install Wireshark, create a virtual network interface for an iPhone, obtain the device UDID, start the virtual interface, and capture TCP/UDP traffic between the iPhone and IoT hardware, including the use of capture and display filters.
This guide explains how to install Charles, configure an iPhone proxy, capture HTTP/HTTPS traffic, set breakpoints, modify requests, repeat calls, and simulate network conditions, providing a comprehensive workflow for iOS network debugging and performance testing.
This article details NetEase News' practical experience of gradually integrating Flutter as a module into an existing Android/iOS codebase, covering architecture, integration methods, build modes, project management, native‑Dart communication, routing strategies, debugging, encountered issues, and stability measures.
This article presents a technical guide for implementing real‑time screen capture and control of iOS devices via a browser, detailing tool introductions, a preliminary solution, an optimized approach, and a comparative analysis of both schemes.
Alibaba’s newly open‑sourced coobjc framework brings coroutine‑based async/await, generators, and actor model support to Objective‑C and Swift on iOS, offering cleaner code, better performance, and reduced threading issues compared to traditional block‑based GCD approaches, with detailed design, implementation, and benchmark insights.
This article explains how to choose, layer, and encapsulate multiple map SDKs for iOS and Android, covering map selection, interface design, singleton vs. multiple instances, provided APIs, advantages, drawbacks, and practical implementation details with illustrative screenshots.
This article explains the principles of caching, compares memory and disk storage, demonstrates several iOS persistence methods, and details how YYCache combines memory and disk layers with LRU optimization and network synchronization to improve performance in a real‑world mobile app.
The Baidu App reduces connection latency by cutting TLS and TCP round‑trips through session resumption, False Start, pre‑connect, backup and composite connections, and automatic rebuilds, achieving 12‑16 % faster text and image loads and modest success‑rate gains across Android and iOS.
This article explains the six SOLID design principles—Single Responsibility, Liskov Substitution, Dependency Inversion, Interface Segregation, Law of Demeter, and Open‑Closed—using iOS‑oriented examples, code snippets, and practical advice to help developers write cleaner, more maintainable software.
This article introduces a novel approach to compute the height of multi‑line UILabels on iOS by pre‑caching character widths per font, demonstrates its implementation in Swift, compares performance against the system boundingRect method through extensive benchmarks, and shows significant speed improvements in real‑world app scenarios.
This article explores the challenges of iOS code coverage, explains the generation of .gcno and .gcda files using LLVM, and presents a transparent, Git‑aware incremental coverage solution that integrates into the development workflow with minimal overhead.
To combat carrier DNS hijacking and latency, Baidu App implements a comprehensive HTTPDNS solution that replaces system DNS with secure, BGP‑routed queries, adds layered strategies for disaster recovery, caching, IP selection, and integrates custom modules into Android’s OkHttp and iOS’s Cronet, dramatically lowering hijack rates while modestly improving response times.
This article explains the concept of tail call optimization in Objective‑C, illustrates correct and incorrect tail‑call examples, describes how the compiler reuses stack frames to achieve O(1) space complexity, and demonstrates the optimization with visual demos and practical code.
The article summarizes the fourth 58 Group technical salon held on November 28, 2018, where experts from the Listening Cloud AI & Cloud Platform and 58 TEG Wireless Architecture shared practical experiences on mobile APM performance monitoring, startup optimization, SDK quality assurance, logging, and related code implementations.
This article details Meituan's systematic approach to reducing iOS app cold‑start time, covering the definition of startup phases, identification of performance bottlenecks, phased launch, self‑registration of startup tasks, code slimming, profiling tools, and continuous monitoring to achieve smoother user experience.
The iQIYI Live Broadcast Assistant adopts Flutter to replace native UI layers on Android and iOS, integrating via Flutter fragments or views and AAR packages on Android and through Podfile, Xcode scripts, and FlutterViewController on iOS, achieving near‑native performance and enabling future migration of more screens to a single codebase.
The article outlines a cross‑platform receipt‑printing solution for retail apps that uses JavaScript‑based parsing, server‑editable templates, and native JS engines on iOS and Android to dynamically manage diverse printer models, reduce maintenance, and enable fast template updates across iOS, Android, and web.
Meituan Waimai improved its iOS client cold‑startup time by fixing existing bottlenecks, introducing a phased‑startup model with self‑registered modules, slimming code and +load methods, parallelizing UI work, and adding detailed runtime metrics, enabling continuous optimization despite rapid feature expansion.
This article investigates a crash caused by calling IMP pointers on ARM64 iOS devices, explains how variadic function argument passing differs from the standard ABI, demonstrates the issue with test code and assembly analysis, and provides a solution by explicitly casting IMP to the correct function type.
This guide introduces the open‑source LLDB debugger and the Facebook‑maintained Chisel plugin for iOS, covering installation via Homebrew, configuration of .lldbinit, and a comprehensive set of custom commands that simplify UI inspection, view hierarchy analysis, and autolayout debugging within Xcode.
Hades is a self‑developed static‑analysis framework for Meituan‑Dianping’s large‑scale iOS codebases that leverages Clang/LLVM to build a high‑level semantic model, enabling global, incremental checks, custom lint tools, CI integration, and efficient code‑quality maintenance across massive projects.
This article describes the challenges of scaling iOS device testing at Autohome, evaluates existing cloud‑device solutions, and presents a self‑built iOS remote‑real‑time testing platform that uses libimobiledevice, iOS‑minicap, WebDriverAgent, iproxy, and a B/S architecture to achieve high‑frame‑rate streaming and low‑latency control.
This guide details how to set up an iOS automation environment using Appium, Java, and related tools on macOS, covering system requirements, installation of Xcode, JDK, Node, Appium, WebDriverAgent, and necessary plugins, along with troubleshooting tips for successful device testing.
This article explains how Swift's Codable protocol simplifies converting between JSON and native data structures, covering basic usage, handling nested objects, optional values, key mapping, date formats, enums, dynamic payloads, and custom types for robust iOS development.
The article explains how Objective‑C Categories can implement a low‑overhead, type‑safe communication layer between iOS components, compares alternative patterns like DI, SPI and NotificationCenter, presents performance data, and proposes two Category‑based schemes with tooling to detect method‑name conflicts and ensure maintainable modular architecture.
This article presents a comprehensive catalog of mobile testing tools and techniques, covering Android and iOS platforms, including UI automation frameworks, unit testing libraries, performance monitoring utilities, network simulation tools, static analysis solutions, code coverage options, cloud testing services, and continuous integration pipelines.
This article presents a comprehensive component‑based architecture for iOS navigation apps, detailing layered design, responsibility division, integration methods, MGJRouter communication, H5‑Native interaction, dynamic configuration, and insights from Taobao's large‑scale componentization practice.
This article explains the evolution, analysis, and improvement of componentized architecture in large‑scale iOS projects, compares MGJRouter, Protocol, and CTMediator routing schemes, discusses integration, resource management, memory considerations, and provides practical code examples for implementing modular components.
This article explains how to solve post‑release user‑side problems by recording UI events and data streams, replaying them through a custom framework that simulates touch events, uses a unified interceptor, and hooks Objective‑C blocks, providing a complete end‑to‑end solution for mobile developers.
The Xianyu team tackled iOS Flutter app bloat by analyzing App.framework, cutting excessive type‑casting, applying dwarf‑stack‑trace and obfuscation flags, stripping dSYM symbols, and removing duplicate assets, which together shrank the generated framework by over 30 % and improved download efficiency.
In large iOS apps like Meituan, navigation‑bar transitions require a systematic approach—using viewWillAppear/WillDisappear to modify styles, employing fake bars during pushes and pops, and following best‑practice rules—to avoid hard‑coded hacks, reduce coupling, and maintain scalable, reliable UI state.
Logan, Meituan‑Dianping’s open‑source mobile logging framework, unifies log collection, secure storage, backend processing, and visual frontend tools to capture all user‑side logs without sampling, enabling fast case‑analysis debugging across Android, iOS, mini‑programs and web, with future ML‑driven insights.
Xianyu’s technical team built an offline replay system that records UI interactions and all relevant runtime data during app use, then replays the exact sequence with injected data, letting developers instantly reproduce user‑reported bugs and facilitating future automated testing with minimal intrusion.
Swift 4.2 has been officially released, bringing faster compilation, enhanced debugging, extensive standard‑library updates, binary‑compatibility progress, numerous language and compiler enhancements, new Swift Package Manager capabilities, and clear migration guidance for developers moving from earlier Swift versions.
This step‑by‑step tutorial shows how to obtain a Mini Program's .wxapkg package from a jail‑broken iPhone or rooted Android device, copy it to a computer, and unpack it with open‑source scripts to reveal the obfuscated JavaScript, configuration and resource files.
This step‑by‑step tutorial explains how to locate the .wxapkg package of a WeChat Mini Program on a jail‑broken iPhone or rooted Android device, copy it to a computer, and unpack it to reveal the obfuscated JavaScript, JSON configuration, WXML, WXSS and resource files.
MMKV is a high‑performance, mmap‑based key‑value library open‑sourced by Tencent, offering cross‑platform support for iOS and Android with features like multi‑process sharing, anonymous memory, AES encryption, and superior read/write speeds compared to SharedPreferences, NSUserDefaults, and SQLite, as demonstrated by benchmark tests.
