The article explains how analyzing Java bytecode with tools such as Javassist during the Android Gradle transform phase yields precise, method‑level module dependency data—overcoming the limitations of Gradle trees, import scans, and IDE analysis—and provides a reliable way to map and enforce clean dependency structures in large Android codebases.
Android activity startup latency stems from three phases—Pause, Launch, and Render—so optimizing only onCreate often leaves perceived delays; developers can measure each phase via system logs or AOP hooks (Instrumentation, Looper‑Printer, or ActivityThread handler) to pinpoint and reduce bottlenecks.
Qigsaw, iQIYI’s open‑source framework released in 2019, enables low‑risk dynamic loading of Android App Bundle split APKs across all components and processes, offering Play‑Core‑compatible APIs, single‑hook stability, resource merging, and Tinker‑based hot updates, thereby simplifying plugin integration and reducing app size.
This article describes how Ctrip's hotel query home page evolved through three architectural versions—1.0, 2.0, and 3.0—detailing the motivations, design choices, performance considerations, and the final unified module‑based structure that leverages VLayout for improved scalability and maintainability.
This article recounts the evolution of the Class Optimization Master Android project—from a dual‑end, no‑design prototype to an MVP‑based implementation and finally a modularized architecture—highlighting pain points, solutions, and practical steps for improving code boundaries, build times, and reusable modules.
This guide explains how to locate the Android SDK path in Jenkins, list available SDK components, upgrade a specific version of the tools and build‑tools, and verify the update so that Jenkins can successfully build Android APK packages after a toolchain upgrade.
This article introduces the WAPM performance monitoring SDK for Android, detailing its four‑layer architecture, memory‑leak detection via LeakCanary, UI thread jank analysis using Looper callbacks, network request monitoring through framework hooks, and page load timing via activity and view lifecycle instrumentation.
xCrash is an open‑source Android SDK that reliably captures both Java and native crashes across Android 4.0‑9.0 and multiple CPU architectures by using async‑signal‑safe handlers, a dedicated dumper process, and pre‑allocated resources to generate tombstone‑style dump files without root, offering richer diagnostics than BreakPad and extensible future features.
This article examines the Android shared library (SO) loading mechanism, identifies security vulnerabilities, and presents a method of packing the SO to hinder reverse engineering, detailing each loading step, challenges across Android versions, and before‑after protection results.
This article explains why Retrofit + Gson parsing can fail when server‑sent fields differ from client definitions or when lists contain heterogeneous item types, and demonstrates how to customize TypeAdapters and use @JsonAdapter to gracefully handle these scenarios in Android applications.
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.
By instrumenting every C++ function with GCC’s ‑finstrument‑functions and recording call addresses in per‑thread TLS, the team built a fast, lock‑free stack‑trace mechanism that outperforms libunwind by up to 60×, integrates with Android’s malloc_debug, and powers an automated native‑memory‑leak detection framework with web‑based analysis.
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 describes the limitations of existing Android screen‑casting tools, analyzes the H264 profile issue on devices like Xiaomi 9, and details how the scrcpy source code was altered to output baseline H264 streams, enabling reliable real‑time casting via the Broadway web plugin.
This article provides a comprehensive overview of RxJava2 for Android, covering its observer types, backpressure strategies, thread‑scheduling transformers, the compose() operator, differences between compose and flatMap, and the distinction between hot and cold observables with practical code examples.
Litho is a Facebook‑originated declarative framework for building high‑performance Android UI, replacing XML layouts with component‑based code, leveraging Yoga for async layout, flattening view hierarchies, and offering fine‑grained reuse to dramatically improve RecyclerView scrolling speed and memory consumption.
The article explains how resource obfuscation with andResGuard removes META‑INF service files needed for the Android Main dispatcher, causing coroutines to silently fail after withContext calls, and shows that preserving the META‑INF/services directory restores proper coroutine execution.
This article provides a comprehensive guide to using AspectJ for aspect‑oriented programming in Android, covering core concepts such as aspects, join points, pointcuts and advice, demonstrating matching expressions, custom annotations, and detailing step‑by‑step integration with Gradle plugins and plugin implementation for seamless code weaving.
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 article examines Google's suspension of Huawei support, explains why Android uses the Apache License instead of GPL, outlines common open‑source licenses, discusses licensing implications for Node.js and mobile ecosystems, and highlights recent licensing controversies affecting developers.
Version 1.3.30 of Kotlin introduces Apple support, stable coroutines, KAPT incremental annotation processing, unsigned array extensions, Kotlin/Native platform expansions, and IDE improvements across IntelliJ, CLion, and AppCode, while also detailing configuration steps and performance optimizations for Android developers.
The article introduces Aspect‑Oriented Programming, explains its core concepts and compile‑time versus runtime models, and demonstrates how Android developers can employ compile‑time AOP (using AspectJ) to implement method‑level hot‑fixes, performance monitoring, logging, and other cross‑cutting features while weighing benefits, overhead, and optimization strategies.
This article explains how the Android Monkey tool can be used to perform automated stress testing on fragmented Android devices, covering its purpose, installation locations, key command‑line parameters, a complete example command, and practical steps for integrating Monkey into a mobile testing workflow.
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.
