This article explains how Airbnb’s Android team extends its MvRx state‑simulation framework with a custom screenshot library and Happo integration to automatically capture, upload, and compare fragment UI snapshots in CI, detecting visual regressions, layout issues, crashes and memory leaks across commits.
Facing 8‑minute Gradle syncs, frequent GC‑over‑limit errors, and excessive memory usage, the team diagnosed severe memory leaks in Android build configurations, applied variantFilter filtering, tuned JVM arguments, and optimized daemon settings, ultimately reducing sync time to 1.5 minutes and cutting CI build time in half.
This article explains how to create a static analysis tool that scans Android APKs for privacy‑sensitive API calls, covering both compile‑time bytecode instrumentation and runtime stack tracing, with step‑by‑step instructions, code examples, configuration details, and optimization techniques.
This article details the redesign of Snowball's Android network framework using OkHttp and Retrofit, covering motivations, architectural layers, solutions for domain switching, custom annotations, data validation, migration strategy, and the resulting performance and maintainability improvements.
The MemCorruption tool, developed by ByteDance's AppHealth team, provides an online, low‑overhead solution for detecting Use‑After‑Free, Double‑Free, and Heap‑Buffer‑Overflow problems in Android applications by hooking memory allocation functions, sampling allocations, and performing invisible SIGSEGV‑based detection.
This article introduces the fundamentals of Android Runtime (ART) garbage collection, covering its historical background, key milestones, core features such as RegionTLAB, read barriers, pause behavior, generational support, target heap size calculations, multiplier impact, GC trigger thresholds, Systrace analysis, and parameter tuning strategies.
This article explains how to combine Retrofit with Kotlin coroutines on Android, compares the traditional RxJava method with coroutine-based implementations, and presents two encapsulation techniques—using a DSL and leveraging CoroutineExceptionHandler—to simplify asynchronous network calls and centralize error handling.
This article explains two Kotlin‑based network request wrappers for Android that reduce boilerplate by using LiveData, Retrofit, OkHttp and coroutines, compares their design trade‑offs, provides complete Activity, ViewModel, Repository and BaseRepository code samples, and shows how to handle loading, success, error and multiple data sources in a clean MVVM architecture.
This article provides a comprehensive overview of Android app hardening methods, detailing the evolution from first‑generation dex and so protection to advanced code virtualization, and outlines various unpacking (脱壳) techniques—including memory dump, dynamic debugging, hook‑based and custom ROM approaches—used to bypass these protections.
AAPT2, the default Android resource compiler, splits resource processing into compile and link stages, converting XML, PNG, and other files into binary FLAT containers that embed both raw data and metadata, enabling incremental builds, configurable options, and efficient merging into the final APK’s resources.arsc and R.java.
This tutorial explains how to build a custom Gradle Transform plugin, integrate ASM bytecode manipulation, and instrument Android applications to detect and report illegal privacy API calls, covering project setup, plugin implementation, ASM basics, and practical verification steps.
This article investigates the Android dex2oat compilation restrictions introduced for targetSdkVersion ≥ 29, analyzes their impact on app performance, explores SELinux enforcement, and presents a practical solution using system commands and binder calls to trigger dex2oat compilation for both primary and secondary APKs, improving load and runtime speed.
This article explains how to combine an existing Android APK with a HarmonyOS HAP into a single hybrid package for Youku, covering packaging schemes, required configurations, signing procedures, and deployment steps, enabling gradual migration from Android to pure HarmonyOS.
OverlayFS is a stacking file system that merges lower and upper directories into a single view using mount options like lowerdir, upperdir, and workdir, supports copy‑up, whiteouts, opaque directories and configurable rename handling, and is employed in Android, OpenWRT, and container platforms to provide writable overlays on read‑only layers.
This article presents a detailed overview of Alipay's Android wallet system architecture, illustrating its core components such as settlement, customer service, fund processing, and accounting, and further examines the open‑source MetaQ (Metamorphosis) distributed messaging middleware, highlighting its features, advantages over Kafka, and suitable application scenarios.
This article explains how Android 12 introduces reconfigurable widgets, default configuration flags, new size attributes, responsive layouts, compound button interactions, and simplified collection RemoteViews, providing developers with richer, more interactive widget experiences on mobile devices.
This article explains the fundamentals of Android ViewGroup, its coordinate systems, the complete drawing pipeline from Activity creation to SurfaceFlinger, details the Measure‑Layout‑Draw phases, and provides a step‑by‑step guide to building a custom ViewGroup with custom LayoutParams and practical examples.
This Jetpack Compose animation tutorial demonstrates how to create state‑driven, visibility, size, cross‑fade, single‑value, and composite animations using declarative APIs such as remember, mutableStateOf, AnimatedVisibility, animateContentSize, animate*AsState, and updateTransition, showing concise Kotlin code that simplifies UI animation development.
Airbnb’s new Android automation testing framework replaces flaky Espresso tests with deterministic UI rendering by simulating immutable State objects via MvRx, Epoxy, and a custom DSL, enabling fast, reliable tests, easy mock generation, and a launcher for instant screen inspection across multiple state variants.
This article explains how resource overflow such as memory out‑of‑memory (OOM) and file‑descriptor (FD) exhaustion occurs in Android applications, demonstrates how to identify the root causes using MARS‑APM (APMPlus), and provides practical steps to resolve these crashes.
This article explains how Android captures ANR events by intercepting the SIGQUIT signal, covering the relevant signal‑handling functions (kill, signal, sigaction, sigwait, pthread_sigmask), their differences, the SignalCatcher thread implementation, and how developers can create custom SIGQUIT monitors for ANR analysis.
Despite the rollout of 5G, mobile developers face hidden challenges: users see a 5G icon that may not reflect actual network mode, Android’s APIs inconsistently expose NR/NSA status, and iOS adds new constants, requiring careful handling to ensure app behavior aligns with true connectivity.
This article explains why Android memory optimization is needed, introduces background concepts such as garbage collection and memory leaks, reviews common tools like Memory Profiler, MAT and LeakCanary, details image‑related memory reduction techniques, and presents the open‑source KOOM framework for online OOM detection and analysis.
This guide explains how to set up ADB on a Windows PC, capture screenshots from an Android device, analyze the image to locate the game piece and platform in the WeChat Jump mini‑program, and automatically perform jumps using Python code that calculates press duration and simulates swipe input.
These articles compare how Web, Android, iOS, and Flutter represent UI structures—detailing the DOM and Virtual DOM creation, diffing, and rendering on the Web, and the XML‑based layout inflation, view hierarchy, styling, and drawing pipeline on Android—to help front‑end developers grasp each platform’s tree‑based architecture.
This guide explains step‑by‑step methods for iPhone and Android users to instantly open their health code using Siri shortcuts, double‑tap back gestures, home‑screen shortcuts, and voice assistants, improving efficiency during pandemic‑related checks.
The article explains Android R’s ART runtime garbage‑collection configuration and heap layout—including RegionSpace, ImageSpace, ZygoteSpace, non‑moving and LargeObject spaces—details concurrent, native, transition and blocking GC types, illustrates real‑world performance issues, and offers optimization strategies for developers.
This technical article investigates the Android 10+ dex2oat limitation that blocks app‑initiated compilation, analyzes its SELinux enforcement, and presents a practical solution using system commands and binder calls to trigger dex2oat for both primary and secondary APKs, achieving significant load‑time and runtime improvements.
This comprehensive guide explains what NFC is, compares it with other short‑range wireless technologies, and provides step‑by‑step tutorials for implementing NFC on Android, iOS, and WeChat mini‑programs, covering chip data writing, NDEF formatting, App Clip integration, and universal link handling.
This article explains the concept of Time To Interactive (TTI) for the Kuaishou Android app, details how to quantify the metric using FrameTime instead of FPS, describes data collection methods, offline and online tracing, a performance lab, and comprehensive governance and task‑scheduling strategies to reduce startup lag.
This article investigates why text in Flutter buttons often fails to vertically center, analyzes Android font metrics and NotoSansCJK details, explores native Android solutions like includeFontPadding and Paint.getTextBounds, and proposes a Flutter implementation using minikin layout to achieve precise vertical centering.
This article demonstrates how to build a custom stock K-line chart in Android using Jetpack Compose, covering the transition from traditional View drawing to Compose's Canvas API, detailed code for rendering, and implementing drag, long‑press, and pinch‑zoom gestures with state‑driven UI updates.
The article details how refactoring the Haokan Android short‑video client from a single global player to per‑holder multi‑player instances, combined with lifecycle‑lite event handling, pre‑loading, and dedicated thread operations, cut start‑up latency by ~150 ms, reduced frame‑drops dramatically, and boosted overall user experience and business metrics.
This article examines Android 6.0’s storage architecture, detailing the roles and interactions of MountService, Vold, and the kernel, illustrating module and process structures, communication flows via sockets, and highlighting performance considerations such as thread blocking and ANR issues.
This article explains the concept of Time To Interactive (TTI) for Kuaishou's Android client, details how the metric is quantified using FrameTime instead of FPS, describes offline and online data‑collection methods, and outlines the scheduling framework and governance measures designed to reduce post‑cold‑start jank.
The DeWu ANR Monitoring Platform replaces Bugly with a comprehensive internal system that collects ProcessErrorStateInfo, tombstone files, main‑thread stack samples, Looper message histories, and app state, parses and aggregates this data, visualizes trends and root‑cause details, and guides developers in mitigating ANRs.
This article presents a Kotlin‑based technique for removing the repetitive BaseResponse wrapper from Retrofit calls by introducing a custom Converter.Factory and annotation‑driven ConvexTransformer that automatically extracts the data payload.
This article explains the Flutter soft‑keyboard invocation flow on Android and iOS, analyzes page‑repaint and animation problems such as stutter on specific devices, and presents practical fixes including performance flags, MediaQuery handling, and native input adjustments.
This article explains the design and implementation of a pure‑Dart Lottie animation library for Flutter, covering its architecture, data parsing, rendering pipeline, code examples for both Android and Flutter, performance comparisons, and future plans for interactive features.
This guide explains how to set up ADB on a Windows PC, connect an Android device, capture screenshots, and run a Python script that detects the game pieces and board in WeChat's Jump mini‑program to automatically perform jumps based on calculated distances.
dm‑verity is a Linux device‑mapper target that protects a data partition’s integrity by using a compile‑time hash‑tree stored on a separate hash device, with Android employing it for verified boot; user‑space creates the dm device, loads the verity table, activates it, while the kernel’s dev_create, table_load, and suspend handlers set up mapped_device structures and enforce per‑block hash verification during I/O.
This tutorial walks through creating nested navigation graphs, extracting them into separate XML files with the include tag, and reorganizing the app into core and feature modules, enabling a modular Android project while preserving existing navigation behavior.
This article explores obscure Android thread issues—including uncontrolled thread creation, stack memory leaks, and the impact of thread‑priority settings—while presenting monitoring techniques, a pthread hook implementation, and performance considerations to help developers detect and resolve thread‑related crashes.
A Chinese tech blogger retrieved the Android kernel source from UMIDIGI after a GPLv2 violation controversy, documented the process in a YouTube video, and made the code publicly available for developers to review.
This article outlines the various payment channels—In‑App Purchase, third‑party, H5, and mini‑program—across iOS, Android, and WeChat environments, detailing their flow diagrams, required API interactions, code examples, and best‑practice recommendations to help developers implement seamless mobile payments.
Upgrading a project from Android Gradle Plugin 3.5 to 4.1.3 required applying official migration steps, adjusting deprecated fields, resource paths, manifest tasks, ASM version, disabling configure‑on‑demand and the new zipflinger packager, and fixing NDK configuration, which together yielded roughly 36 % faster builds and a 5 MB smaller APK.
This article explains why a specially crafted Unicode string triggers an Android ANR by dissecting the Unicode line‑breaking (UAX #14) and bidirectional (UAX #9) algorithms, showing how runs ending with double zeros lead to an infinite loop in TextLine.getOffsetToLeftRightOf.
This article explains the Android Binder inter‑process communication mechanism, covering its definition, why Android adopts it over traditional Linux IPC methods, and its advantages in performance, stability, and security, while also detailing the underlying Linux concepts and communication steps.
This article introduces several open‑source tools for software architecture—including the Vue‑based mini‑program framework mpvue, the Android channel‑packaging tool Walle, the MySQL index advisor SQLAdvisor, the distributed ID service Leaf, and the hot‑update system Robust—detailing their features, configurations, and GitHub links.
This article explains how to enable two-way communication between React Native and H5 pages using WebView, covering message handling in both directions, code examples for sending and receiving data, and important migration notes from the built‑in WebView to react‑native‑webview.
A Chinese phone maker UMIDIGI faced public pressure after influencer Naomi Wu and a Polish developer demanded the GPL‑v2‑licensed kernel source of the Android 10‑based UMIDIGI F2, highlighting the obligations and controversies surrounding open‑source compliance.
The article explains that Android ANR (Application Not Responding) arises when the UI thread is blocked beyond defined timeouts, classifies the various timeout types, details common root causes such as slow I/O, heavy computation, binder delays, deadlocks, CPU or memory pressure, and outlines a systematic log‑and‑systrace analysis process to pinpoint and resolve these issues.
This article explains ByteDance’s automated precise testing solution, describing how method call‑chain analysis links code changes to Android Activities, enabling targeted test‑case recommendation, optimizing CI pipelines, and significantly improving test efficiency and coverage for large‑scale mobile projects.
The article introduces JavaTweakHook, a lightweight Android hook framework that avoids Xposed by directly manipulating ART structures, compares it with existing solutions, details the hook process—including method creation, ArtMethod copying, assembly trampolines, and native‑Java integration—and provides compilation, usage, and limitation notes.
This article analyzes the latency of video publishing in a mobile app, proposes a parallel video‑track transcoding solution, details implementation steps, performance testing, and optimization techniques to reduce encoding time by up to 30% on Android devices.
This tutorial demonstrates how to capture network packets from the Super Schedule Android app, perform a login request with required headers, and repeatedly fetch and parse topic data using Python urllib2 and JSON handling, enabling infinite scrolling of user‑generated topics.
This article investigates an Android ANR triggered by a while‑true loop in TextView's getOffsetForHorizontal, reproduces the issue on Pixel 2, explains how to extract trace files, compares Android Studio debugging with Frida dynamic hooking, and provides step‑by‑step instructions to reproduce and debug the bug.
This guide walks developers through the complete Android integration of NetEase Cloud's chatroom SDK, covering Gradle setup, required permissions, ProGuard rules, SDK initialization, entering and leaving chatrooms, message handling, and UI component usage with practical code examples.
Android Vold is a standalone daemon that bridges the kernel and framework, handling storage hot‑plug events such as USB, SD card, and internal partitions by receiving kernel uevents via Netlink, processing them in VolumeManager, and communicating with StorageManager through Binder to mount, encrypt, and manage file systems.
This article explains how to keep UIAutomator 1.0 test cases running on Android 11+ by implementing a server‑side ContentProvider, accessing it via reflection from the UIAutomator or shell process, and demonstrates the complete Java code for provider creation and invocation.
The article presents a high‑efficiency Android bitmap‑reuse strategy that combines the inBitmap API with atomic reference counting and a three‑layer LRU cache (active, LruCache, InBitmapPool), dramatically lowering garbage‑collection pauses and achieving over 80 % reuse on pre‑Android 8 devices.
ByteDance has open‑sourced bhook, an Android PLT hook framework supporting API 16‑31 and multiple ABIs, featuring a trampoline‑based hook mechanism, automatic ELF monitoring, and a robust native crash‑catching module for safe runtime function interception.
This tutorial shows how to repurpose a cracked Android phone by rooting it, installing Linux Deploy with Debian, setting up UrBackup server, configuring storage and networking, and connecting clients, providing a low‑cost home backup solution despite Android’s limitations.
This article provides a comprehensive, macro-level analysis of Android's four core components—Activity, Service, BroadcastReceiver, and ContentProvider—detailing how each interacts with the ActivityManagerService (AMS) through Binder IPC, including code examples for startActivity, startService, bindService, broadcast, and ContentProvider operations across processes.
This article continues the investigation of a mysterious string that triggers Android app freezes, explaining Unicode line‑breaking and bidirectional algorithms, how runs end with double zeros, how to craft a reproducing string, and practical ways to avoid the resulting ANR.
This article presents Sliver, an Android‑focused method‑trace framework that combines low‑overhead stack sampling, thread‑suspend techniques, and lock‑information capture to reliably detect and diagnose ANR and jank issues in production environments while maintaining minimal performance impact.
This step‑by‑step guide shows how to root an Android phone, install Linux Deploy with Debian Buster, configure UrBackup server, and connect clients, turning the device into a functional home backup server despite hardware and Android‑specific limitations.
This guide provides a comprehensive overview of Android system architecture, explains the ADB communication mechanism, presents a detailed Android app testing checklist covering UI, compatibility, installation, OTA, interaction, concurrency, database, interface, performance, security, and other tests, and lists essential ADB commands and monitoring principles.
Raphael is a native memory‑leak detection tool developed by Bytedance's video team, open‑sourced to address Android native memory issues through a combination of inline/PLT hooking, efficient stack unwinding, and optimized caching, offering low‑overhead, version‑independent monitoring across diverse native allocation APIs.
This article details a UI automation regression framework for mobile event tracking, covering background challenges, Android and iOS log collection methods, H5 integration strategies, performance comparisons, and practical recommendations to improve testing efficiency by about 50%.
This article explains how to integrate Retrofit with Kotlin coroutines following Google’s Android architecture guidelines, covering coroutine basics, OkHttp and Retrofit setup, generic response handling, repository abstraction, ViewModel usage, and lifecycle‑aware coroutine scopes to achieve clean, asynchronous network calls.
This article explores software architecture concepts by drawing parallels with building design, explains the goals of architectural design such as scalability and maintainability, and demonstrates a practical Android MVVM implementation using WanAndroid with clean‑architecture patterns, Kotlin, and modular project structure.
This article guides developers through compiling, debugging, and analyzing the Flutter 2 Router source code, covering engine setup, architecture layers, key initialization classes, and practical steps to run a custom Flutter engine on Android and iOS.
The Vivo Internet Frontend Team explains why modern products need a unified, cross‑platform rich‑text editor and presents a JSON‑based data model and WebView‑embedded editor architecture that enable consistent rendering, seamless native‑web communication, media handling, keyboard control, and error‑retry mechanisms across web, mobile, and desktop environments.
This article presents a lightweight framework for constructing, collecting, and visualizing Android startup task information, replacing heavy systrace data with concise logs, Kotlin data structures, AspectJ instrumentation, and Python scripts that generate readable timelines and discrete charts to aid performance analysis.
This article explores the underlying font metrics and layout algorithms that cause text vertical misalignment in Flutter, analyzes Android native solutions like includeFontPadding and getTextBounds, and demonstrates how to implement a precise forceVerticalCenter feature by leveraging Minikin and Skia rendering pipelines.
This article explains how Android apps consume power, details the underlying BatteryStatsService, introduces the BatteryCanary tool for monitoring and diagnosing power‑drain issues, and shares practical optimization cases and benchmark results for developers seeking to reduce app energy usage.
JSBridge (JSB) enables bidirectional communication between a WebView’s JavaScript environment and native mobile code, covering WebView basics, platform-specific APIs, interception and injection methods, callback handling, and practical demos for both Android and iOS, helping developers implement robust cross‑platform bridges.
This article explains Flutter 2's new multi‑engine Add‑to‑App approach, walks through creating an Android project with a Flutter module, shows how to manage engines with FlutterEngineGroup, and compares multi‑engine and single‑engine hybrid solutions in terms of memory and performance.
The article reviews current car‑head‑unit integration models, proposes a channel‑agnostic architecture with voice and multi‑resolution support, details performance‑tuning steps such as size reduction and process consolidation, and shares common pitfalls and project‑management insights to help developers successfully port Android apps to automotive platforms.
The article details JD.com's Mozi dynamic UI framework, describing its background, problem scope, design choices, version evolution, architecture, SDK, integration workflow, tooling, and future plans for mobile Android and iOS applications.
The article explains how Meituan’s dynamic layout technology, which complicates automated testing, is tackled by XraySDK’s view‑ability transformation that captures layout data via a local HTTP server and custom listeners, boosting dynamic‑card test coverage from zero to over 80% and streamlining future WebView and compatibility testing.
This article explains how Xianyu identifies, monitors, and resolves Android ANR issues by analyzing root causes, implementing SIGQUIT‑based detection, inspecting thread stacks, and applying concrete optimizations such as SharedPreferences replacement, network broadcast caching, and delayed component registration, ultimately cutting ANR rates by more than half.
This article walks you through using an Android phone to locate Xianyu’s video cache folder, rename the hidden file to MP4, and play or save the downloaded cat video, providing clear screenshots for each step.
This article explains how Aspect‑Oriented Programming is applied in Android development to achieve non‑intrusive privacy compliance checks and thread‑usage optimization, detailing the use of compile‑time ASM bytecode instrumentation and runtime Xposed/epic hooks, along with code examples and measured performance gains.
This article details three memory‑saving techniques—reducing default thread stack size, releasing a 130 MB WebView reservation, and shrinking the ART heap—implemented via system‑API hooking and the Patrons library, and evaluates their performance impact on 32‑bit Android devices.
This article examines how Rust can unify client logic across Android and iOS, compares it with React Native and Flutter, and details a MVVM‑based architecture, binding mechanisms, and debugging optimizations that make Rust a lightweight, high‑performance solution for international mobile teams.
Fastbootd, introduced in Android Q, runs inside recovery to implement the full fastboot flashing protocol—supporting dynamic super‑partition management, USB FunctionFS communication, and OEM commands—by using source files in system/core/fastboot and recovery, triggered via adb or bootloader reboot‑fastboot.
Learn how to set up a complete Android CI/CD pipeline by installing JDK, Android SDK, and Gradle, creating Docker images for builds, configuring Jenkins on Kubernetes, and automating packaging and deployment, with detailed commands and troubleshooting tips for efficient mobile app releases.
To tame the growing complexity of QQ Music’s Android playback page, the team replaced the monolithic MVC/SubController design with a clean, layered architecture that uses lightweight, lifecycle‑aware ViewDelegates and LiveData, enabling on‑demand module loading, clear separation of concerns, reduced memory usage, and reusable UI components.
This article explains how to build a custom Android progress view featuring random particle motion, radial gradient backgrounds, sector clipping, pointer color changes, animated color transitions, and a jumping number display, with complete source code and step‑by‑step implementation details.
The article explains how compile‑time annotation processors in Android replace costly runtime reflection by generating binding classes during build time, showing step‑by‑step code examples, JavaPoet/KotlinPoet usage, and the performance benefits for cleaner, faster, maintainable apps.
Upgrading from AGP 3.5.0 to 4.1.0 dramatically simplifies R class generation, removes redundant R files via R8‑based inlining, reduces APK size by ~7 MB, and speeds up release builds by over ten minutes, as demonstrated through detailed build‑artifact comparisons and Gradle task analysis.
This article explains why Android developers need Gradle, describes the structure of a default Android project, details Gradle concepts such as projects, tasks, and the wrapper, and walks through dependency configurations, conflict resolution, and the complete build and packaging pipeline for APK generation.
This article explains the Android ANR workflow, analyzes the system's appNotResponding logic, and presents a robust monitoring strategy that captures SIGQUIT signals, validates true ANR events, and hooks trace writes to reliably detect and diagnose ANRs in mobile apps.
The article explains how the Windows 11 preview can be installed on Snapdragon‑based Android phones and Raspberry Pi devices via the community‑driven Renegade Project, detailing the required tools, current device support, encountered limitations, and the broader implications for ARM‑based Windows deployments.
The article reports on community efforts to install the Windows 11 ARM64 preview on Android smartphones and Raspberry Pi devices, describing the Renegade Project, successful deployments on OnePlus 6T and Xiaomi 8, remaining limitations, and the required hardware and firmware modifications.
This article provides a step‑by‑step guide on using MotionLayout in Android, covering dependency setup, layout and MotionScene creation, defining start and end states, adding keyframe animations, gesture handling with OnSwipe, and common attributes for building complex UI transitions.
This article details a real‑world Android file‑upload failure caused by the Android Studio Profiler’s OkHttp3Interceptor closing the request’s BufferedSink, explains the debugging steps taken, and provides code modifications to the ProgressRequestBody to prevent the IllegalStateException and ensure correct upload progress tracking.
This article explains the relationship between UI stutter and ANR, critiques common monitoring tools, and presents three robust Android lag‑detection methods—WatchDog polling, Looper Printer replacement, and specialized handlers for IdleHandler, TouchEvent, and SyncBarrier leaks—complete with probability analysis and sample code.
