This article explains how to use ASM to instrument Android bytecode for automatic click event tracking and OkHttp network request monitoring, detailing the Transform API, AOP/ASM techniques, custom ClassVisitor and MethodVisitor implementations, code injection strategies, and provides a complete open‑source example on GitHub.
This article details Ele.me Logistics' mobile‑app monitoring architecture—E‑Monitor, TimeBomb, Dogger, and EDW—explaining how each layer collects, visualizes, and analyzes business‑level availability data, and showcases a real‑world debugging case that leveraged the stack to resolve an HTTP/2 connectivity bug.
This article details the migration of Tencent's Penguin Tutoring app from the Plato framework to React Native, outlines first‑screen performance bottlenecks, presents caching and rendering optimizations, redesigns the carousel component to eliminate flicker, and shares a collection of RN pitfalls and their solutions.
This article describes how the Smart Train Ticket Android team adopted a componentization architecture—splitting base libraries and business modules, configuring independent and integrated builds, handling inter‑module communication, and solving manifest and multi‑flavor packaging challenges—to reduce coupling and dramatically improve build performance.
Youzan refactored its Android Micro Mall and Retail apps from a monolithic codebase into a service‑oriented, componentized architecture where each business module inherits a BaseModule with its own lifecycle, common utilities are extracted into lightweight libraries, and a custom Gradle plugin enables independent building, publishing, and rapid iteration.
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.
This article details Baidu App’s systematic analysis and multi‑layer optimization of its Hybrid landing‑page, covering performance bottlenecks, a CloudHybrid server‑rendered solution, WebView pre‑creation, lazy NA loading, kernel tweaks, intelligent prefetching, and the resulting sub‑second user experience.
The article explains BufferQueue’s internal design and shows how Android developers typically use its wrapper classes—Surface as the producer and SurfaceTexture as the consumer—detailing their constructors, dequeue/queue workflows, lock/unlock mechanisms, and a complete SurfaceView example that illustrates buffer production and consumption by SurfaceFlinger.
This article explains how Android applications can create and use SQLite databases—including custom file paths and no‑Context scenarios such as UIAutomator tests—by detailing standard SQLiteOpenHelper usage, source‑code analysis, and three methods for customizing database locations.
This article explains what Android's Monkey tool is, its testing goals, commonly used command‑line options, how to run a test sending random events to an app, and how to collect and analyze the resulting logs for stability assessment.
Android’s BufferQueue, the core producer‑consumer mechanism behind the display pipeline, manages GraphicBuffer slots through explicit FREE‑DEQUEUED‑QUEUED‑ACQUIRED transitions, using shared memory and Binder to let producers (e.g., Views, MediaCodec) enqueue frames and consumers (e.g., SurfaceFlinger) acquire and release them efficiently.
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.
DroidAssist, an open‑source, configuration‑driven framework from Didi, lets developers replace or augment Android Java bytecode at compile time via simple XML rules—enabling non‑intrusive mocking such as swapping SharedPreferences implementations without source changes or extra dependencies, while supporting incremental builds and rich transformation capabilities.
This article explains practical anti‑debugging methods for Android applications—covering Java tools like Proguard and debugger checks, as well as NDK strategies such as ptrace, file‑node monitoring, Inotify, SO hash verification, and timing analysis—to raise reverse‑engineering difficulty.
The article examines Android crashes caused by the finalize() method exceeding its watchdog timeout, explains the underlying daemon implementation and typical causes such as long‑running finalizers, lock contention and low‑priority threads, and recommends avoiding finalize, reducing finalizable objects, or suppressing the watchdog exception as practical mitigations.
This article examines Android message‑passing mechanisms, comparing traditional EventBus, RxBus, and Otto with the lifecycle‑aware LiveData‑based LiveEventBus, detailing their implementations, advantages, and how LiveData’s observe, observeForever, setValue, and postValue methods enable a memory‑leak‑free event bus for mobile development.
This article provides an in‑depth overview of Android permission architecture, covering permission categories, permission groups, the evolution of permission handling across API levels, special system permissions, custom permissions, common compatibility pitfalls on various OEM ROMs, and a unified design for dynamic permission requests.
This article examines Android’s architecture—covering the Hardware Abstraction Layer, component‑based design, and interface layers—to show how these technical choices enable rapid hardware integration, flexible system evolution, and a robust foundation for modern mobile applications.
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.
Litho, Facebook’s declarative Android UI framework, lets developers define components with immutable props and asynchronous layout, flattening view hierarchies and enabling fine‑grained reuse to boost scroll performance and cut memory usage, though it requires custom component code and lacks a real‑time preview.
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.
The article explains how to use a perceptual hash algorithm to generate image fingerprints, compare them to assess UI screen similarity, and integrate this method with UIAutomator for automated decision‑making in the 360 testing project, reducing computational complexity compared to naive double‑loop approaches.
This article examines the challenges of live‑stream audio noise, compares open‑source denoising solutions such as Speex, WebRTC, and RNNoise, and details the practical integration, performance testing, and final adoption of WebRTC‑based noise reduction within the 58 live‑stream Android SDK.
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 HTTPS handshake, the role of CA and root certificates, how trust chains work, and provides a step‑by‑step guide to using Fiddler for HTTPS decryption on Android, including OpenSSL commands for extracting public keys.
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.
Google has asked the U.S. Supreme Court to review its long‑running copyright fight with Oracle over Java APIs in Android, a case that could dramatically affect developers' ability to reuse software interfaces and shape the future of software innovation.
This article explains why traditional Android photo capture using Intents and onActivityResult is cumbersome, especially in list adapters, and introduces a Fragment‑based PhotoTaker utility that streamlines camera and gallery access, handles dynamic permissions, and works across Android versions.
This article explains how to replace invasive, manually‑invoked SDKs in Android with a unified, non‑intrusive solution using Aspect‑Oriented Programming, Gradle Transform plugins, and ASM bytecode manipulation, improving control, readability, and performance for large‑scale mobile platforms.
This article compares Java and Kotlin for Android development, outlining each language's advantages, drawbacks, market share, and feature differences to help developers decide which technology best fits their projects.
This article explains how Android's fragment system introduced in API Level 11 can be enhanced using the open‑source FragmentOperator library to tag, group, skip, and enforce single‑instance fragments, providing Kotlin code examples and practical scenarios for mobile app navigation.
This article explores the causes of UI stutter in Android apps, explains how frame rate and dropped frames affect perceived smoothness, and details practical profiling solutions—including TraceView, BlockCanary, ArgusAPM, and Matrix‑TraceCanary—along with implementation techniques for accurate lag detection and mitigation.
IOCanary is a non‑intrusive Android tool that hooks file I/O APIs and StrictMode to collect operation details, detect main‑thread blocking, small buffers, duplicate reads, and closeable leaks, then reports them for performance analysis and debugging.
ResourceCanary, a Matrix sub‑module, automatically detects Activity memory leaks and redundant Bitmap objects in large‑scale Android apps by monitoring lifecycle callbacks, leveraging WeakReference queues, parsing Hprof dumps, and providing concise reference chains for fast debugging and performance optimization.
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.
Error Prone is a Google‑released open‑source Java static analysis tool that integrates into build pipelines to catch code defects early, offering non‑intrusive checks, configurable severity levels, and extensibility, making it valuable for Java and Android development.
Matrix is Tencent’s open‑source Android APM that unifies performance monitoring, offering tools like APK Checker, SQLite Lint, Trace Canary, Resource Canary, and IO Canary to detect issues such as leaks, slow methods, and I/O problems, helping developers build higher‑quality apps.
Meituan transformed its monolithic cash‑register apps into a component‑based architecture using WMRouter as the routing foundation and built a strongly‑constrained modular‑event message bus—leveraging annotations, generated interfaces, and LiveData—to ensure type‑safe, module‑scoped communication, improve code reuse, reduce coupling, and simplify maintenance.
QQ Music’s Android team modernized the app for Android 9 Pie by integrating full‑screen displays, native notifications, and enhanced memory profiling, while re‑architecting its dual‑process playback system to cut memory use up to 50%, and adopting Kotlin to shrink code by 25% and halve null‑pointer crashes, delivering a smoother listening experience.
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 explains how to use the MultiItem library to create a multi‑type RecyclerView adapter that supports cross‑RecyclerView item dragging, scaling, and custom control interfaces, providing code examples and a step‑by‑step walkthrough for Android developers.
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.
This article demonstrates how to implement a multi-type RecyclerView adapter on Android that supports cross‑RecyclerView item dragging, scaling, and custom drag controls, providing code examples, interface definitions, and a step‑by‑step explanation of the underlying processes.
This article explains how to use Gradle's productFlavors, flavorDimensions, variant filters, signing configurations, manifest placeholders and source‑set priorities to create flexible multi‑channel Android builds, comparing fast simple packaging with a fully customizable approach and providing command‑line examples.
This article introduces an open‑source Android library that eliminates the need for custom RecyclerView adapters by using a ViewHolderManager system to handle multiple item types, headers, footers, click listeners, load‑more pagination, and animations, with complete code examples and usage guidelines.
This article describes how a large, tightly‑coupled Android detail page was refactored into a clean, modular MVP architecture that splits business logic into reusable Parts, reducing the file size from over 2000 lines to fewer than 200 while improving readability, maintainability, and rendering performance.
This article explains what Android Monkey testing is, walks through the preparation steps, command usage, log redirection, and basic Python-based log filtering, and suggests how to automate the process to improve mobile app stability before release.
Matrix‑ApkChecker, an in‑house APM tool used by WeChat, analyzes Android APKs to identify oversized files, redundant resources, unused assets, and other inefficiencies, providing detailed reports and enabling targeted optimizations such as removing duplicate files, converting PNGs to WebP, and stripping unused libraries, ultimately reducing app size by over 130 KB.
In this interview, MobSDK director Yu Xunjie discusses the platform's comprehensive SDK matrix, automatic integration, 24/7 developer support, product management practices, e‑commerce solutions, short‑video capabilities, and the team's collaborative culture, offering valuable insights for mobile developers.
The article explains that Flutter’s first‑page launch is slower because initialization proceeds through four stages—FlutterMain, FlutterNativeView, FlutterView, and Flutter Bundle—and shows that pre‑initializing the heavy native view, view, and bundle components can cut the initial latency to match later launches.
The article explains what a Dex file is, how it is produced from Java .class files via the dx tool after JVM compilation, and why understanding Dex is crucial for Android tasks such as APK slimming, hot‑fixes, plugin architecture, app hardening, reverse engineering and overcoming the 64K method limit.
The article explains how China's Unified Push Alliance aims to standardize Android push notifications, reduce background wake‑ups and battery drain, and simplify developers' work by enforcing the Android Green App Covenant 2.0 and consolidating push channels into a single process.
This article explains Android's VSync mechanism, defines smoothness metrics such as FPS, skipped frames and smoothness, describes how VSync timing affects rendering, and provides practical testing commands like `adb shell dumpsys gfxinfo` and `adb shell dumpsys SurfaceFlinger` for measuring frame performance.
This article shares WeChat's engineering experience in detecting and preventing various Android memory leaks—including Activity, Bitmap, native, and thread leaks—by building custom tools, refining monitoring pipelines, and applying fallback protection to keep the app stable at scale.
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 uses a cooking metaphor to explore how Kotlin improves Android development by offering safer null handling, concise extension functions, powerful overloads, and expressive lambdas, illustrated with real code examples and practical tips for large‑scale projects.
This article recounts a non‑technical graduate's two‑year self‑learning journey from electronics engineering to Java backend development, detailing the challenges, mindset shifts, and practical steps that ultimately led to landing an offer at Alibaba.
The article explains why using WindowManager for floating buttons on Android is problematic across versions, demonstrates how the JD.com app adds a floating view directly to the Activity's DecorView, and provides a complete lifecycle‑aware implementation for Beike's app using ActivityLifecycleCallbacks and view injection.
This article provides a detailed source‑code analysis of RePlugin's process management, covering process startup, attachBaseContext handling, IPC initialization, PMF setup, plugin installation, synchronization across processes, and the internal mechanisms for loading and updating plugins.
This article dissects RePlugin's process management and plugin loading mechanisms from a source‑code perspective, detailing the startup sequence, framework configuration, IPC initialization, PMF setup, plugin installation flow, and how plugins are registered and synchronized across processes.
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.
This article explains various methods for capturing network packets on Android phones—including internal tcpdump, Fiddler via Wi‑Fi hotspot, and VPNService‑based APKs—describes their drawbacks, and presents a scalable architecture that copies Wi‑Fi traffic to a server for analysis using Go's gopacket library.
This article analyzes iQIYI’s Neptune plugin framework, explaining why pluginization is needed, the core technical principles of class and resource loading, lifecycle management, and how Neptune implements multi‑ClassLoader isolation, resource handling, context wrapping, and incremental updates for large‑scale Android apps.
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 article explains MMKV's design, the challenges of adding multi‑process support on Android, the IPC architecture choices, file‑lock synchronization mechanisms, and performance comparisons with SharedPreferences and SQLite.
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.
This article explains how the highly invasive plugin framework "Dual Master" is adapted to Android P by analyzing the refactored Activity lifecycle handling, the EXECUTE_TRANSACTION message flow, and the necessary code modifications for activity placeholder replacement, restoration, and system provider hooking.
This article explains how Android P refactors the Activity lifecycle handling, details the shift from LAUNCH_ACTIVITY messages to EXECUTE_TRANSACTION processing, and describes the necessary code adaptations for the 分身大师 framework to support dual‑open apps on Android P.
The article analyzes an OOM issue in the Beike Android app caused by large image memory usage, compares Picasso and Glide memory footprints, describes the refactoring effort required to switch libraries, explains Glide's two‑level caching mechanism, and highlights the performance and stability benefits for pre‑Android 8.0 devices.
This article explains how to reduce HTTP requests and page load time for H5 web pages by leveraging Chrome DevTools and its WebSocket‑based protocol to capture network metrics, render trees, and screenshots on both PC and Android, providing step‑by‑step debugging and performance‑testing guidance.
This article provides a comprehensive overview of frequently used Android Debug Bridge (ADB) commands, explains how to troubleshoot common connection and permission issues, and demonstrates how to manage apps, files, system information, and device operations directly from the command line.
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.
Meituan Waimai Android unified the divergent codebases of the standalone Waimai app and the Waimai channel in the Meituan app by introducing a layered architecture—base services, components, business modules, and host—combined with Gradle flavor and a fine‑grained “pins” project, achieving 88 % code reuse, over 70 % productivity improvement, and paving the way for broader platform reuse.
Deep links let users tap a link on their phone and jump directly to a specific page inside an app, bypassing the home screen, and this article explains the underlying URL scheme technology, implementation steps for iOS and Android, standards, ecosystem, and common app schemes.
The article introduces CrossPlatformPoint, a cross‑platform data‑point testing tool for the ZhaiZhai app, outlines the challenges of mobile event‑tracking, presents the tool’s features—including Android and iOS support, server‑side monitoring, keyword search, and offline testing—and provides detailed usage instructions and upgrade tips.
The guide’s first part explains Android P’s major behavior changes—official notch detection, restrictions on hidden APIs, new App Standby Buckets and foreground‑service rules, removal of the legacy Apache HTTP client, privacy updates, HEIF image support, and the ImageDecoder API with practical code examples.
This article introduces Sieve, an internal Android memory‑analysis platform that parses Hprof heap dumps, builds dominator trees, computes retained sizes, and constructs reference paths to help developers locate OOM‑causing leaks and optimize memory usage.
The article describes QACR, Qunar's end‑to‑end mobile crash reporting platform that collects Android, iOS, ANR, and performance anomalies, enriches them with detailed runtime data, performs deep backend analysis, provides real‑time alerts, automatic bug assignment, and multi‑level reporting to improve mobile app stability and user experience.
This article explains how to automatically generate and parse Android Traceview files to track SDK API response times, thread activity, and memory usage, detailing trace file structures, generation methods, and a workflow for collecting and analyzing performance data.
This article introduces Java annotations, explains their three main purposes—documentation, compile‑time checks, and runtime code analysis—demonstrates how to define and use custom annotations, and walks through a handcrafted ButterKnife‑like example that binds UI elements via reflection.
This article explains the shortcomings of hard‑coded exposure tracking in the Beike Zhaofang Android app, benchmarks industry practices, proposes a flexible API‑driven strategy, and provides a complete RecyclerView scroll‑listener implementation with a double‑ended queue to record precise card visibility durations.
WMRouter is an open‑source Android routing framework, originating from Meituan Waimai, that provides flexible URI dispatch and a ServiceLoader inspired by Java SPI, enabling component‑based navigation, dynamic registration, interceptors, singleton management, and decoupled communication for hybrid, multi‑module, and instrumented app architectures.
This article introduces Sieve, an internal Android memory analysis platform that parses Hprof files, builds dominator trees, calculates retained sizes, and visualizes reference chains to help developers identify OOM causes, while discussing the limitations of existing tools and implementation details.
This article explains how to prepare, execute, and analyze power and network traffic consumption tests for push SDKs on mobile devices, covering SDK separation, key power‑draining operations, methods to retrieve traffic data via PID and UID, common issues, and practical solutions.
This article introduces the Sieve Android memory analysis system, explains why existing tools like LeakCanary and MAT fall short, describes how heap dump files are parsed, GC Roots identified, dominator trees generated, retained sizes calculated, and reference chains constructed to help developers locate memory leaks and OOM causes.
The Android app’s HLS video produced an electric‑like noise because FFmpeg’s av_find_best_stream mistakenly selected the second audio track in a dual‑stream file, a track lacking 1‑8 kHz frequencies, whereas iOS and PC used the correct first track; fixing requires publishing videos with a single audio track and adding detection tools.
This article shares a step‑by‑step experience of migrating a Vue‑based project to React Native for an Android delivery‑chain app, covering environment setup, debugging, common pitfalls, routing, state management, storage, hot updates, and practical code snippets to help newcomers get started quickly.
Google’s Android 9 Pie brings AI‑driven enhancements, new developer APIs, adaptive battery and brightness, digital wellbeing tools, and expanded privacy protections, initially rolling out to Pixel devices before reaching a broader range of Android phones.
Andromeda is an open‑source Android framework that unifies local and cross‑process component communication by providing blocking IPC, a global event bus, remote callbacks, and a dispatcher‑based architecture, solving the limitations of existing single‑process routing solutions.
This article introduces Kotlin as a JVM‑based language, explains why it is chosen for Android development, details its main features such as null safety, data classes, and lambda expressions, compares compilation performance with Java, and provides practical JD‑specific integration steps, configuration tips, common pitfalls, and real‑world usage examples.
The team replaced numerous free‑style Jenkins jobs with a single Pipeline‑as‑code project that pulls a shared script from SCM, uses UI parameters and project‑specific configs to run a standardized Android build flow—including React Native bundle download—providing versioned, maintainable, and visualized multi‑project CI.
This article introduces Kotlin as a JVM‑based language, explains why it is chosen for Android development, details its concise syntax, null‑safety, data‑class and lambda features, demonstrates interoperability with Java, analyzes compilation performance, and provides practical JD mobile‑app integration steps and common troubleshooting tips.
This tutorial walks you through the complete process of setting up a local Ethereum node, developing and deploying a Solidity token contract with Truffle, generating Java wrappers using Web3j, and integrating the contract into an Android app to perform transfers and balance queries.
This article provides an in‑depth overview of the ELF file format, describing its headers, section and program tables, symbol structures, and demonstrates how to use this knowledge to locate and hook functions in Android native libraries such as libmedia.so.
After noticing persistent UI stutter on a flagship Android real‑estate app even on 6 GB devices, the author analyzes root causes—CPU overload, GPU overdraw, and memory pressure—then details step‑by‑step fixes using developer options, layout cleanup, and TraceView to achieve sub‑16 ms frame rendering.
The article explains Android’s Nine‑Patch format—a bitmap with a 1‑pixel black border defining stretchable and content areas—covers creation methods (Photoshop, Draw9patch, Android Studio), runtime parsing, practical use in network‑loaded chat bubbles, required conversion workflow, and the underlying PNG “npTc” chunk structure with code examples for manual drawable construction.
This article examines Android’s evolving message‑passing mechanisms, comparing traditional EventBus and RxBus with the newer LiveDataBus, detailing their architectures, code implementations, limitations such as pre‑subscription message delivery, and presents a refined LiveDataBus solution that leverages lifecycle‑aware LiveData to avoid memory leaks.
This article explains iQIYI's Android app launch process, measurement methods, optimization strategies, and monitoring practices that together reduced startup time by up to 40%, offering practical insights for mobile developers seeking faster app launches.
The article explains Android’s process lifecycle and how component states translate into OOM adjustments, LowMemoryKiller levels, scheduling groups, and Linux thread priorities, detailing the mapping of importance levels to oom_score_adj, schedGroup, procState, and cgroup policies, with code examples and a bug case.
