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.
The article explains why an Android app’s main thread can be blocked by detailing Linux process versus thread concepts, the Completely Fair Scheduler’s priority and vruntime calculations, real‑time and nice priorities, and how Android uses cgroups and SchedPolicy enums to allocate CPU shares among foreground, background, and system threads.
The article details iQIYI’s systematic approach to Android app startup optimization—analyzing cold‑start processes, measuring latency with SysTrace and adb, applying process‑aware initialization, async work off the UI thread, layout simplifications, delayed services, and automated tracing—to achieve up to 40 % launch‑time reduction and establish continuous monitoring.
This article provides an extensive overview of Android Debug Bridge (ADB), detailing its architecture, core components, and a wide range of commands—including shell am, pm, appops, wm, settings, input, dumpsys, logcat, push/pull, screencap, and screenrecord—illustrated with examples and code snippets for effective mobile testing and automation.
This article explains the Android Paging Library introduced in Google I/O 2018, covering its background, architecture, core components such as DataSource and PagedList, loading flow, and step‑by‑step usage with Gradle, LiveData, and RecyclerView adapters for efficient pagination in mobile apps.
This article introduces Android Jetpack's Paging Library, explains its architecture—including DataSource, PagedList, and adapters—details the data loading flow, and provides step‑by‑step guidance on integrating the library into a mobile app using Gradle, LiveData, and RecyclerView.
The article explains how iQiyi created the open‑source dexSplitter tool to analyze Android APK composition, generate per‑module sub‑dex files using ProGuard/R8 mappings, and continuously monitor size growth, offering clear module‑level size statistics despite a modest overall dex size increase.
This article explains Android's RenderThread, its role in hardware-accelerated UI rendering, how it enables asynchronous animation via ViewPropertyAnimator, and provides code examples demonstrating RenderThread-driven animation that remains smooth even when the UI thread is blocked.
This article explains the principles and practical methods for caching JavaScript and other resources in Android WebView, covering HTTP cache headers, WebView cache modes, storage locations across Android versions, and the use of HTML5 AppCache to minimize network traffic and improve app performance.
This article introduces a custom MVVM‑DataBinding framework for Android, explains its background, outlines the advantages of combining MVVM with DataBinding, provides detailed usage steps, implementation details, and discusses the framework’s benefits and potential pitfalls for mobile developers.
The Meituan Android team built an automated, non‑intrusive page‑speed plugin that injects SDK calls at compile time via a Gradle Transform, measures cold‑start, first render, network request and second render for Activities and Fragments—including ViewPager lazy loading—fetches real‑time config from a server and reports metrics to their monitoring platform.
This article introduces a lightweight Android MVVM‑DataBinding framework, explains its background and advantages over MVC/MVP, details five design rules, outlines usage steps and internal architecture, discusses benefits and potential pitfalls, and provides a GitHub repository for developers.
The article examines Kotlin’s hidden runtime overheads—such as companion‑object constants, default synchronized lazy delegates, boxing‑prone array types, and temporary progression objects in loops—and describes how the author built a custom Android Lint plugin (KLint) that parses Kotlin files, defines detectors, integrates with Gradle and IDE, and enforces performance‑aware coding standards through CI checks.
This article provides a comprehensive guide to Android's Navigation component, covering its purpose, setup steps, XML graph configuration, fragment navigation, data passing methods, deep link handling, nested navigation, and an analysis of the underlying source code with practical Kotlin examples.
This article provides a comprehensive guide to Android Jetpack's Navigation component, covering its purpose, setup with Gradle, XML graph configuration, fragment navigation code, data passing methods, deep‑link handling, and an analysis of its underlying source classes such as NavHostFragment and NavController.
The article examines Android P’s non‑SDK API restrictions, explains Google’s official dynamic delivery framework Android App Bundles, analyzes the challenges of large‑scale plugin architectures, and outlines JD’s roadmap for migrating from legacy plugin solutions to a component‑centric, AAB‑compatible platform.
This article examines the impact of Android P’s non‑SDK API restrictions on large‑scale Android apps, explains Google’s official dynamic delivery framework Android App Bundles, and outlines JD.com’s evolution from pure pluginization to a hybrid component‑based architecture called AuraPlus, highlighting key technical decisions and migration strategies.
Bandage is an Android library that intercepts exceptions thrown in activity‑lifecycle callbacks and other main‑thread code via a reflective replacement of ActivityThread’s handler, allowing the app to finish the faulty activity or continue running, with configurable black‑/white‑listing, Bugly integration, and developer‑friendly warnings.
The QQ Music K歌 4.6 crash occurs when a hidden RecyclerView, created by fragment recreation after the app is killed, retains a stale cached Footer ViewHolder that mismatches the adapter’s type after an unnotified data change, triggering an IllegalArgumentException during the RecyclerView’s layout step 2.
This article explains how Alibaba's Sophix hot‑fix framework trims Android resource patches by analyzing and reconstructing the resources.arsc string pools, removing unused entries, and re‑indexing references, achieving dramatic size reductions while preserving runtime performance.
This article explains how Android inherits Linux's UID/GID based permission model, details the sandbox isolation for apps, describes how system and app processes obtain their UID/GID, and shows how adb shell and framework permissions grant extensive access to the device.
This article introduces essential Kotlin language features—such as null‑safety, the safe‑call and Elvis operators, triple‑quoted strings, powerful when expressions, object declarations, observable properties, and function types—demonstrating how they enable safer, more concise Android development compared to traditional Java code.
This article presents a comprehensive guide to Android UI and API automation testing, covering framework selection, script development with Robotium and Genymotion, Docker-based Selenium grid deployment, Python RemoteDriver usage, security testing, and best practices for efficient mobile test automation.
This article presents a detailed overview of Android app security threats, the essential components of an Android project, the full APK build and decompilation process, and a range of reverse‑engineering tools and protection strategies—including Smali analysis, SO manipulation, and signing bypass—to help developers safeguard their applications against piracy and data tampering.
This article explains the detailed ELF file format—including ELF header, section and program header tables, various section types, and a practical Android native hook example—helping developers understand and troubleshoot native binary loading and symbol resolution.
This article introduces Google’s Android Architecture Components—Lifecycle, LiveData, ViewModel, and Room—explaining their principles, how they simplify lifecycle management and data handling, and provides practical integration techniques and best‑practice guidelines for mobile developers.
At the iQIYI Technical Salon in Shanghai, senior engineers from iQIYI, Ele.me, Mushroom Street and others shared practical advances in mobile componentization and webization, including Ele.me’s hierarchical Android modularization, the open‑source CC framework, iQIYI’s Qigsaw dynamic delivery and Utopia web‑SPA, LiteApp performance optimizations, and the Lynx cross‑platform framework, while inviting developers to join iQIYI’s R&D team.
This article details the design, technology selection, and implementation of WMDA, a no‑tracking (no‑annotation) user‑behavior analysis SDK for Android, covering bytecode‑instrumentation via a Gradle plugin, event collection for activities, fragments, and clicks, as well as processing, storage, reporting, and current limitations.
The Meituan Waimai Android team cut crash rates from 0.3% to 0.02% by applying systematic crash governance, null‑pointer and OOM safeguards, AOP bytecode rewriting, dependency checks, modular architecture, and robust monitoring, offering a comprehensive blueprint for other Android teams to improve stability.
This article introduces Android WorkManager, explaining its background, architecture, key API features, usage patterns, constraints, cancellation methods, and provides Kotlin code examples for defining workers, creating work requests, and managing tasks across various Android versions.
This article explains how Alibaba's Pandora Lab discovered a kernel space mirroring vulnerability in Android 8 that defeats PAN and KASLR defenses, allowing arbitrary kernel writes and full system compromise through precise page‑table manipulation and a single‑write primitive.
This article explains how RePlugin maps plugin-defined custom‑process activities to host placeholder processes, retrieves component information from the plugin APK, generates static or dynamic process‑mapping tables, adjusts component process names, and orchestrates the launch and lifecycle of these activities on Android.
This article explains why proper architectural design is essential for Android apps, compares the MVC, MVP, and MVVM patterns, analyzes their advantages and disadvantages, and demonstrates the practical benefits of MVVM through a real‑world delivery‑mode switching project.
This article outlines the motivation, tool comparison, and detailed step‑by‑step process for implementing static code scanning across Android and iOS codebases, emphasizing the selection of Infer and the integration of scanning results into CI pipelines and issue‑tracking workflows.
The Roaming Mantis malware exploits compromised routers to perform DNS hijacking, redirecting Android, iOS, and desktop users to malicious sites that install fake updates, steal credentials, and run CoinHive mining scripts, while spreading across more than twenty languages worldwide.
This article explores Android’s sandbox mechanism, detailing how Linux‑based UID/GID permissions, file system rules, and permission groups control app isolation and access, with practical insights into adb shell behavior and permission granting.
This article introduces a lightweight event notification framework for Android, explaining its design, core interfaces, event manager implementation, usage examples with login/logout scenarios, lifecycle considerations, duplicate event checks, and compares it to traditional observer patterns.
The article reviews Google I/O 2018, covering the push for accessible AI with TensorFlow demos, front‑end TensorFlow.js experiments, new Android JetPack and App Bundle features, progressive web app advancements, and impressive WebAssembly applications like a browser‑based AutoCAD viewer.
This article explains how RePlugin enables a host app to recognize, map, and start custom plugin processes—including static and dynamic process mapping, adjusting component process names, launching processes via injected providers, handling process reclamation, and managing activity slot allocation for seamless plugin activity execution.
This article explores mobile application architecture by discussing its conceptual foundations, evolution of industry app architectures, design principles such as separation of concerns and abstraction, practical technical selections, modular design, development implementation, testing, and agile processes, offering a comprehensive guide for developers.
This article explains how to measure and analyze Android SDK startup performance by defining cold, warm, and lukewarm launches, describing a testing methodology that uses specific device, network, and process conditions, and providing ADB commands and shell scripts to capture total launch time.
This article explains how Android's TextView renders text, detailing its coordinate system, layout classes, span types, HTML conversion, and practical implementations such as custom ReplacementSpan and link handling within the Snowball app, providing developers with a comprehensive guide to advanced text styling.
Google announced an early preview of AndroidX, a major refactoring of the Android Support Library that introduces new package namespaces, Maven artifact naming, strict semantic versioning, and migration tools, while advising developers not to use it in production due to known issues.
This article explains how to apply modular refactoring—removing unnecessary files, reorganizing packages, degrading monolithic classes, and decoupling components—using tools such as IronBank, BizLifecycle, and AAR‑based platform support to achieve zero‑coupling, easier version management, and faster builds in Android projects.
This article explains the concepts of cold, warm, and lukewarm Android app launches, outlines a testing methodology for measuring SDK startup times using ADB commands, and discusses practical considerations, test scenarios, and common pitfalls encountered during performance testing.
The article details the design, architecture, and operational workflow of hotel self‑check‑in kiosks, covering traditional and self‑service processes, Windows and Android implementations, card‑issuing hardware, ID scanner protocols, printer integration, hardware monitoring, and network deployment strategies for seamless guest check‑in and check‑out.
The article explains why Android developers split large NDK‑generated .so files from the APK to reduce package size, outlines how to design comprehensive test points for dynamic loading, and provides practical suggestions for handling download, installation, compatibility, and upgrade scenarios.
The article examines Flutter’s memory architecture, compares its Image widget’s graphics‑memory usage to Android ImageView’s Java and native heap behavior across OS versions, and evaluates FlutterView integration strategies—showing reuse saves native memory and offering a pre‑render trick to reduce first‑frame latency.
This article explains several practical methods—including ADB commands, UIAutomatorViewer, source inspection, Appium, and AAPT—to obtain an Android application's package name and launch Activity, which are essential for configuring automation tools such as Appium.
According to StatCounter, Android holds 39.49% of the global personal device market, surpassing Windows, while Chrome OS captures 1.3% of Linux‑based desktops; DistroWatch and Google Trends data show Manjaro currently leading Linux distributions, with Ubuntu topping weekly searches and Linux Mint ranking third overall.
This article explains how the Xposed framework works, why it normally requires root, and presents a technical approach using application sandboxing and dual‑app virtualization to enable Xposed modules on non‑root Android phones, including details of framework porting and hook mechanisms.
This article introduces the Xposed framework, explains its architecture and root‑based installation process, then explores alternative non‑root implementation methods using sandbox virtualization and Java hook techniques, detailing dual‑app virtualization, framework migration, and practical code examples for running Xposed modules on unrooted Android devices.
The article explains how ProGuard’s incremental obfuscation using –applymapping can cause mapping conflicts when previously assigned method names are overwritten, producing warnings and inconsistent names such as ‘c_’, and details the internal workflow, inline handling, and practical steps to diagnose and resolve these issues.
Meitu’s Android DNS SDK combines LocalDNS and HTTP DNS in a hybrid strategy, transparently replaces the system resolver via reflection and native hooks, and dynamically switches to HTTP DNS on anomalies, cutting lookup latency by about 100 ms, boosting cache hit rates and overall request success while preventing DNS hijacking.
This article analyzes the restriction mechanism of hidden APIs in Android P Preview 1 and presents three verified techniques—direct module provisioning, class‑loader manipulation, and access‑flag tampering—that allow developers to invoke system hidden APIs without triggering runtime warnings.
This article reviews the evolution of Suning's e‑commerce Android client from 2012 to the present, detailing the technical challenges of each development stage, the corresponding architectural solutions, and the lessons learned for building high‑performance, modular mobile applications.
This article introduces four essential Android Studio plugins—.ignore, GsonFormat, CodeGlance, and 360 FireLine—that help developers manage .gitignore files, generate Java models from JSON, navigate code faster, and detect security or memory‑leak issues, thereby significantly improving productivity.
The article explains how to create, configure, and integrate custom Android Lint rules—using Issue, Detector, Scope, and IssueRegistry APIs—to catch crashes, bugs, performance and security problems such as missing Toast.show() or unsafe Log usage, supports incremental git‑based scans, and demonstrates deployment in IDE, builds, pre‑commit hooks and CI for improved code quality.
This article analyzes Android P's hidden API restrictions, explains the underlying distinction mechanisms, and presents three practical techniques—direct calls with a provided module, classloader manipulation via reflection, and access flag tampering—to reliably invoke hidden system APIs on Android devices.
Baidu Maps confronts severe performance bottlenecks as its client app scales, analyzing main‑thread overload, third‑party SDK interference, and unstable network latency, and introduces the Nirvana framework to provide internal resource scheduling, monitoring, and isolation, achieving 10‑50% speed gains and noticeable user improvements.
This article explains the differences between stack and heap memory on Android devices, outlines typical memory problems such as high usage, leaks, and overflow, and demonstrates practical testing methods using the dumpsys meminfo command and the LeakCanary library with code examples.
This article introduces a self‑developed Android performance monitoring app, explains how to install, start, and view test results, and details the underlying data‑collection mechanisms for memory, battery, CPU, and FPS metrics, providing practical guidance for developers.
This guide walks through creating a Jenkins job to pull Android source code from Git, configure Gradle invocation, add FIR.IM QR‑code generation, troubleshoot common SDK environment issues, and update Android SDK and build‑tools via command‑line steps.
This article explains how Android P’s DP1 preview restricts non‑SDK API usage by detailing the hidden‑API greylist mechanism, the compilation‑time processing that marks methods and fields in dex files, and the runtime checks performed by the ART virtual machine to enforce these restrictions.
This article introduces the minicap tool—a native NDK‑based screen‑capture solution for Android—explaining its advantages over the built‑in screencap command, how to compile or obtain binaries, install them on a device, and run it to obtain high‑speed, low‑size screenshots for automation testing.
To avoid crashes and missing messages caused by newer Android restrictions on Toast—such as disabled notifications, BadTokenException on pre‑8.0 devices, and token‑null errors on Android 7.1—developers intercept Toast.show with AspectJ, replace it with a custom MToast, handle exceptions, and ultimately migrate to a robust Snackbar‑based notification system.
The article opens with Confucius' teachings on knowledge and inquiry, then presents a developer's issue where MotionPro VPN disconnects on Android, outlines two main causes—lack of app trust and background cleaning by phone managers—and provides clear steps to whitelist the app and reinstall it with trust enabled.
This article examines the Android P DP1 hidden‑API restrictions, detailing the compilation‑time generation of grey‑list files, the transformation of access flags in DEX structures, and the runtime checks performed by the ART virtual machine to enforce non‑SDK call limits.
This article examines the evolution of Android architectural patterns—from MVC, MVP, and MVVM to Flutter‑derived frameworks and Android Architecture Components—explaining their layering, communication mechanisms, and how router‑based decoupling can achieve fully modular mobile applications.
This guide explains how to decode a video, render a watermark with OpenGL, re‑encode the frames, and mux them into a new file on Android, covering texture types, viewport positioning, blending, and the required MediaCodec and MediaMuxer code.
This tutorial explains how to use Android's MediaCodec to encode video frames—either via byte arrays or an input Surface—and then combine the encoded video with audio using MediaMuxer to produce a synchronized MP4 file, complete with code samples and step‑by‑step guidance.
This guide explains how to install and configure Charles to simulate slow or high‑latency mobile networks, including enabling throttling, selecting presets, and restricting throttling to specific hosts for effective app performance testing.
The article explains how Android P disables hidden (non‑official) APIs, describes the reasons behind the restriction, outlines the grey‑list classification, provides verification steps and code examples for testing, and warns developers of the potential consequences for apps that rely on these APIs.
This guide explains how to convert video stream data into individual bitmap images on Android by using SurfaceTexture to receive decoded frames, OpenGL to render them as external textures, and glReadPixels to capture the RGBA data for saving as PNG files.
This article explains how Android P disables the use of hidden (non‑SDK) APIs, describes the official restrictions and grey‑list classifications, provides verification steps and download links, and demonstrates a practical reflection test on the WifiManager hidden field, highlighting the impact on developers.
This article introduces a PickerView library for Android, comparing it with existing libraries and providing examples of its usage in mobile applications.
This guide walks through using Android's MediaCodec with a TextureView to extract, decode, and render video frames, covering setup of TextureView, MediaExtractor, handling input and output buffers, synchronizing playback with PTS/DTS, and adding audio playback via AudioTrack and Sonic library.
Facing duplicated codebases as Meituan Waimai expanded from a single app to multiple channels, the team iteratively tried split libraries, componentization, and MVP layers before settling on a three‑layer platform architecture—platform, business, and host—isolated via Gradle projects, product flavors, and tooling to achieve sustainable, cross‑product code reuse.
